rv10.c
Go to the documentation of this file.
1 /*
2  * RV10/RV20 decoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer
5  *
6  * This file is part of Libav.
7  *
8  * Libav is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * Libav is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
28 #include "libavutil/imgutils.h"
29 #include "avcodec.h"
30 #include "dsputil.h"
31 #include "mpegvideo.h"
32 #include "mpeg4video.h"
33 #include "h263.h"
34 
35 //#define DEBUG
36 
37 #define RV_GET_MAJOR_VER(x) ((x) >> 28)
38 #define RV_GET_MINOR_VER(x) (((x) >> 20) & 0xFF)
39 #define RV_GET_MICRO_VER(x) (((x) >> 12) & 0xFF)
40 
41 #define DC_VLC_BITS 14 //FIXME find a better solution
42 
43 static const uint16_t rv_lum_code[256] =
44 {
45  0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
46  0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
47  0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
48  0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
49  0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
50  0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
51  0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
52  0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
53  0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
54  0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
55  0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
56  0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
57  0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
58  0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
59  0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
60  0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
61  0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
62  0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
63  0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
64  0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
65  0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
66  0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
67  0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
68  0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
69  0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
70  0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
71  0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
72  0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
73  0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
74  0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
75  0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
76  0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
77 };
78 
79 static const uint8_t rv_lum_bits[256] =
80 {
81  14, 12, 12, 12, 12, 12, 12, 12,
82  12, 12, 12, 12, 12, 12, 12, 12,
83  12, 12, 12, 12, 12, 12, 12, 12,
84  12, 12, 12, 12, 12, 12, 12, 12,
85  12, 12, 12, 12, 12, 12, 12, 12,
86  12, 12, 12, 12, 12, 12, 12, 12,
87  12, 12, 12, 12, 12, 12, 12, 12,
88  12, 12, 12, 12, 12, 12, 12, 12,
89  12, 10, 10, 10, 10, 10, 10, 10,
90  10, 10, 10, 10, 10, 10, 10, 10,
91  10, 10, 10, 10, 10, 10, 10, 10,
92  10, 10, 10, 10, 10, 10, 10, 10,
93  10, 8, 8, 8, 8, 8, 8, 8,
94  8, 8, 8, 8, 8, 8, 8, 8,
95  8, 7, 7, 7, 7, 7, 7, 7,
96  7, 6, 6, 6, 6, 5, 5, 4,
97  2, 4, 5, 5, 6, 6, 6, 6,
98  7, 7, 7, 7, 7, 7, 7, 7,
99  8, 8, 8, 8, 8, 8, 8, 8,
100  8, 8, 8, 8, 8, 8, 8, 8,
101  10, 10, 10, 10, 10, 10, 10, 10,
102  10, 10, 10, 10, 10, 10, 10, 10,
103  10, 10, 10, 10, 10, 10, 10, 10,
104  10, 10, 10, 10, 10, 10, 10, 10,
105  12, 12, 12, 12, 12, 12, 12, 12,
106  12, 12, 12, 12, 12, 12, 12, 12,
107  12, 12, 12, 12, 12, 12, 12, 12,
108  12, 12, 12, 12, 12, 12, 12, 12,
109  12, 12, 12, 12, 12, 12, 12, 12,
110  12, 12, 12, 12, 12, 12, 12, 12,
111  12, 12, 12, 12, 12, 12, 12, 12,
112  12, 12, 12, 12, 12, 12, 12, 12,
113 };
114 
115 static const uint16_t rv_chrom_code[256] =
116 {
117  0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
118  0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
119  0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
120  0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
121  0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
122  0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
123  0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
124  0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
125  0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
126  0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
127  0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
128  0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
129  0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
130  0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
131  0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
132  0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
133  0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
134  0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
135  0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
136  0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
137  0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
138  0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
139  0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
140  0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
141  0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
142  0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
143  0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
144  0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
145  0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
146  0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
147  0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
148  0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
149 };
150 
151 static const uint8_t rv_chrom_bits[256] =
152 {
153  16, 14, 14, 14, 14, 14, 14, 14,
154  14, 14, 14, 14, 14, 14, 14, 14,
155  14, 14, 14, 14, 14, 14, 14, 14,
156  14, 14, 14, 14, 14, 14, 14, 14,
157  14, 14, 14, 14, 14, 14, 14, 14,
158  14, 14, 14, 14, 14, 14, 14, 14,
159  14, 14, 14, 14, 14, 14, 14, 14,
160  14, 14, 14, 14, 14, 14, 14, 14,
161  14, 12, 12, 12, 12, 12, 12, 12,
162  12, 12, 12, 12, 12, 12, 12, 12,
163  12, 12, 12, 12, 12, 12, 12, 12,
164  12, 12, 12, 12, 12, 12, 12, 12,
165  12, 10, 10, 10, 10, 10, 10, 10,
166  10, 10, 10, 10, 10, 10, 10, 10,
167  10, 8, 8, 8, 8, 8, 8, 8,
168  8, 6, 6, 6, 6, 4, 4, 3,
169  2, 3, 4, 4, 6, 6, 6, 6,
170  8, 8, 8, 8, 8, 8, 8, 8,
171  10, 10, 10, 10, 10, 10, 10, 10,
172  10, 10, 10, 10, 10, 10, 10, 10,
173  12, 12, 12, 12, 12, 12, 12, 12,
174  12, 12, 12, 12, 12, 12, 12, 12,
175  12, 12, 12, 12, 12, 12, 12, 12,
176  12, 12, 12, 12, 12, 12, 12, 12,
177  14, 14, 14, 14, 14, 14, 14, 14,
178  14, 14, 14, 14, 14, 14, 14, 14,
179  14, 14, 14, 14, 14, 14, 14, 14,
180  14, 14, 14, 14, 14, 14, 14, 14,
181  14, 14, 14, 14, 14, 14, 14, 14,
182  14, 14, 14, 14, 14, 14, 14, 14,
183  14, 14, 14, 14, 14, 14, 14, 14,
184  14, 14, 14, 14, 14, 14, 14, 14,
185 };
186 
188 
190 {
191  int code;
192 
193  if (n < 4) {
194  code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
195  if (code < 0) {
196  /* XXX: I don't understand why they use LONGER codes than
197  necessary. The following code would be completely useless
198  if they had thought about it !!! */
199  code = get_bits(&s->gb, 7);
200  if (code == 0x7c) {
201  code = (int8_t)(get_bits(&s->gb, 7) + 1);
202  } else if (code == 0x7d) {
203  code = -128 + get_bits(&s->gb, 7);
204  } else if (code == 0x7e) {
205  if (get_bits1(&s->gb) == 0)
206  code = (int8_t)(get_bits(&s->gb, 8) + 1);
207  else
208  code = (int8_t)(get_bits(&s->gb, 8));
209  } else if (code == 0x7f) {
210  skip_bits(&s->gb, 11);
211  code = 1;
212  }
213  } else {
214  code -= 128;
215  }
216  } else {
217  code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
218  /* same remark */
219  if (code < 0) {
220  code = get_bits(&s->gb, 9);
221  if (code == 0x1fc) {
222  code = (int8_t)(get_bits(&s->gb, 7) + 1);
223  } else if (code == 0x1fd) {
224  code = -128 + get_bits(&s->gb, 7);
225  } else if (code == 0x1fe) {
226  skip_bits(&s->gb, 9);
227  code = 1;
228  } else {
229  av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
230  return 0xffff;
231  }
232  } else {
233  code -= 128;
234  }
235  }
236  return -code;
237 }
238 
239 /* read RV 1.0 compatible frame header */
241 {
242  int mb_count, pb_frame, marker, mb_xy;
243 
244  marker = get_bits1(&s->gb);
245 
246  if (get_bits1(&s->gb))
248  else
250  if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
251  pb_frame = get_bits1(&s->gb);
252 
253  av_dlog(s->avctx, "pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
254 
255  if (pb_frame){
256  av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
257  return -1;
258  }
259 
260  s->qscale = get_bits(&s->gb, 5);
261  if(s->qscale==0){
262  av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
263  return -1;
264  }
265 
266  if (s->pict_type == AV_PICTURE_TYPE_I) {
267  if (s->rv10_version == 3) {
268  /* specific MPEG like DC coding not used */
269  s->last_dc[0] = get_bits(&s->gb, 8);
270  s->last_dc[1] = get_bits(&s->gb, 8);
271  s->last_dc[2] = get_bits(&s->gb, 8);
272  av_dlog(s->avctx, "DC:%d %d %d\n", s->last_dc[0],
273  s->last_dc[1], s->last_dc[2]);
274  }
275  }
276  /* if multiple packets per frame are sent, the position at which
277  to display the macroblocks is coded here */
278 
279  mb_xy= s->mb_x + s->mb_y*s->mb_width;
280  if(show_bits(&s->gb, 12)==0 || (mb_xy && mb_xy < s->mb_num)){
281  s->mb_x = get_bits(&s->gb, 6); /* mb_x */
282  s->mb_y = get_bits(&s->gb, 6); /* mb_y */
283  mb_count = get_bits(&s->gb, 12);
284  } else {
285  s->mb_x = 0;
286  s->mb_y = 0;
287  mb_count = s->mb_width * s->mb_height;
288  }
289  skip_bits(&s->gb, 3); /* ignored */
290  s->f_code = 1;
291  s->unrestricted_mv = 1;
292 
293  return mb_count;
294 }
295 
297 {
298  int seq, mb_pos, i;
299  int rpr_bits;
300 
301  i= get_bits(&s->gb, 2);
302  switch(i){
303  case 0: s->pict_type= AV_PICTURE_TYPE_I; break;
304  case 1: s->pict_type= AV_PICTURE_TYPE_I; break; //hmm ...
305  case 2: s->pict_type= AV_PICTURE_TYPE_P; break;
306  case 3: s->pict_type= AV_PICTURE_TYPE_B; break;
307  default:
308  av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
309  return -1;
310  }
311 
313  av_log(s->avctx, AV_LOG_ERROR, "early B pix\n");
314  return -1;
315  }
316 
317  if (get_bits1(&s->gb)){
318  av_log(s->avctx, AV_LOG_ERROR, "reserved bit set\n");
319  return -1;
320  }
321 
322  s->qscale = get_bits(&s->gb, 5);
323  if(s->qscale==0){
324  av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
325  return -1;
326  }
327 
328  if(RV_GET_MINOR_VER(s->avctx->sub_id) >= 2)
329  s->loop_filter = get_bits1(&s->gb);
330 
331  if(RV_GET_MINOR_VER(s->avctx->sub_id) <= 1)
332  seq = get_bits(&s->gb, 8) << 7;
333  else
334  seq = get_bits(&s->gb, 13) << 2;
335 
336  rpr_bits = s->avctx->extradata[1] & 7;
337  if(rpr_bits){
338  int f, new_w, new_h;
339  rpr_bits = FFMIN((rpr_bits >> 1) + 1, 3);
340 
341  f = get_bits(&s->gb, rpr_bits);
342 
343  if(f){
344  new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
345  new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
346  }else{
347  new_w= s->orig_width ;
348  new_h= s->orig_height;
349  }
350  if(new_w != s->width || new_h != s->height){
351  av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
352  if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
353  return -1;
354  MPV_common_end(s);
355  avcodec_set_dimensions(s->avctx, new_w, new_h);
356  s->width = new_w;
357  s->height = new_h;
358  if (MPV_common_init(s) < 0)
359  return -1;
360  }
361 
362  if(s->avctx->debug & FF_DEBUG_PICT_INFO){
363  av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
364  }
365  } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
366  return AVERROR_INVALIDDATA;
367 
368  mb_pos = ff_h263_decode_mba(s);
369 
370 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
371  seq |= s->time &~0x7FFF;
372  if(seq - s->time > 0x4000) seq -= 0x8000;
373  if(seq - s->time < -0x4000) seq += 0x8000;
374  if(seq != s->time){
376  s->time= seq;
377  s->pp_time= s->time - s->last_non_b_time;
378  s->last_non_b_time= s->time;
379  }else{
380  s->time= seq;
381  s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
382  if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
383  av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
384  return FRAME_SKIPPED;
385  }
387  }
388  }
389 // printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
390 /*for(i=0; i<32; i++){
391  av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
392 }
393 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
394  s->no_rounding= get_bits1(&s->gb);
395 
397  skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
398 
399  s->f_code = 1;
400  s->unrestricted_mv = 1;
402 // s->alt_inter_vlc=1;
403 // s->obmc=1;
404 // s->umvplus=1;
405  s->modified_quant=1;
406  if(!s->avctx->lowres)
407  s->loop_filter=1;
408 
409  if(s->avctx->debug & FF_DEBUG_PICT_INFO){
410  av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
411  seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
412  }
413 
414  assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
415 
416  return s->mb_width*s->mb_height - mb_pos;
417 }
418 
420 {
421  MpegEncContext *s = avctx->priv_data;
422  static int done=0;
423  int major_ver, minor_ver, micro_ver;
424 
425  if (avctx->extradata_size < 8) {
426  av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
427  return -1;
428  }
429 
431 
432  s->avctx= avctx;
433  s->out_format = FMT_H263;
434  s->codec_id= avctx->codec_id;
435  avctx->flags |= CODEC_FLAG_EMU_EDGE;
436 
437  s->orig_width = s->width = avctx->coded_width;
438  s->orig_height= s->height = avctx->coded_height;
439 
440  s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
441  avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
442 
443  major_ver = RV_GET_MAJOR_VER(avctx->sub_id);
444  minor_ver = RV_GET_MINOR_VER(avctx->sub_id);
445  micro_ver = RV_GET_MICRO_VER(avctx->sub_id);
446 
447  s->low_delay = 1;
448  switch (major_ver) {
449  case 1:
450  s->rv10_version = micro_ver ? 3 : 1;
451  s->obmc = micro_ver == 2;
452  break;
453  case 2:
454  if (minor_ver >= 2) {
455  s->low_delay = 0;
456  s->avctx->has_b_frames = 1;
457  }
458  break;
459  default:
460  av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
461  av_log_missing_feature(avctx, "RV1/2 version", 1);
462  return AVERROR_PATCHWELCOME;
463  }
464 
465  if(avctx->debug & FF_DEBUG_PICT_INFO){
466  av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
467  }
468 
469  avctx->pix_fmt = PIX_FMT_YUV420P;
470 
471  if (MPV_common_init(s) < 0)
472  return -1;
473 
475 
476  /* init rv vlc */
477  if (!done) {
478  INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
479  rv_lum_bits, 1, 1,
480  rv_lum_code, 2, 2, 16384);
481  INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
482  rv_chrom_bits, 1, 1,
483  rv_chrom_code, 2, 2, 16388);
484  done = 1;
485  }
486 
487  return 0;
488 }
489 
491 {
492  MpegEncContext *s = avctx->priv_data;
493 
494  MPV_common_end(s);
495  return 0;
496 }
497 
499  const uint8_t *buf, int buf_size, int buf_size2)
500 {
501  MpegEncContext *s = avctx->priv_data;
502  int mb_count, mb_pos, left, start_mb_x, active_bits_size;
503 
504  active_bits_size = buf_size * 8;
505  init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
506  if(s->codec_id ==CODEC_ID_RV10)
507  mb_count = rv10_decode_picture_header(s);
508  else
509  mb_count = rv20_decode_picture_header(s);
510  if (mb_count < 0) {
511  av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
512  return -1;
513  }
514 
515  if (s->mb_x >= s->mb_width ||
516  s->mb_y >= s->mb_height) {
517  av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
518  return -1;
519  }
520  mb_pos = s->mb_y * s->mb_width + s->mb_x;
521  left = s->mb_width * s->mb_height - mb_pos;
522  if (mb_count > left) {
523  av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
524  return -1;
525  }
526 
527  if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
528  if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
529  ff_er_frame_end(s);
530  MPV_frame_end(s);
531  s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
532  }
533  if(MPV_frame_start(s, avctx) < 0)
534  return -1;
536  } else {
537  if (s->current_picture_ptr->f.pict_type != s->pict_type) {
538  av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
539  return -1;
540  }
541  }
542 
543  av_dlog(avctx, "qscale=%d\n", s->qscale);
544 
545  /* default quantization values */
546  if(s->codec_id== CODEC_ID_RV10){
547  if(s->mb_y==0) s->first_slice_line=1;
548  }else{
549  s->first_slice_line=1;
550  s->resync_mb_x= s->mb_x;
551  }
552  start_mb_x= s->mb_x;
553  s->resync_mb_y= s->mb_y;
554  if(s->h263_aic){
555  s->y_dc_scale_table=
557  }else{
558  s->y_dc_scale_table=
560  }
561 
562  if(s->modified_quant)
564 
565  ff_set_qscale(s, s->qscale);
566 
567  s->rv10_first_dc_coded[0] = 0;
568  s->rv10_first_dc_coded[1] = 0;
569  s->rv10_first_dc_coded[2] = 0;
570  s->block_wrap[0]=
571  s->block_wrap[1]=
572  s->block_wrap[2]=
573  s->block_wrap[3]= s->b8_stride;
574  s->block_wrap[4]=
575  s->block_wrap[5]= s->mb_stride;
577  /* decode each macroblock */
578 
579  for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
580  int ret;
582  av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
583 
584  s->mv_dir = MV_DIR_FORWARD;
585  s->mv_type = MV_TYPE_16X16;
586  ret=ff_h263_decode_mb(s, s->block);
587 
588  // Repeat the slice end check from ff_h263_decode_mb with our active
589  // bitstream size
590  if (ret != SLICE_ERROR) {
591  int v = show_bits(&s->gb, 16);
592 
593  if (get_bits_count(&s->gb) + 16 > active_bits_size)
594  v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
595 
596  if (!v)
597  ret = SLICE_END;
598  }
599  if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
600  8 * buf_size2 >= get_bits_count(&s->gb)) {
601  active_bits_size = buf_size2 * 8;
602  av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
603  8 * buf_size, active_bits_size);
604  ret= SLICE_OK;
605  }
606 
607  if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
608  av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
609  return -1;
610  }
611  if(s->pict_type != AV_PICTURE_TYPE_B)
613  MPV_decode_mb(s, s->block);
614  if(s->loop_filter)
616 
617  if (++s->mb_x == s->mb_width) {
618  s->mb_x = 0;
619  s->mb_y++;
621  }
622  if(s->mb_x == s->resync_mb_x)
623  s->first_slice_line=0;
624  if(ret == SLICE_END) break;
625  }
626 
627  ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
628 
629  return active_bits_size;
630 }
631 
632 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
633 {
634  if(avctx->slice_count) return avctx->slice_offset[n];
635  else return AV_RL32(buf + n*8);
636 }
637 
639  void *data, int *data_size,
640  AVPacket *avpkt)
641 {
642  const uint8_t *buf = avpkt->data;
643  int buf_size = avpkt->size;
644  MpegEncContext *s = avctx->priv_data;
645  int i;
646  AVFrame *pict = data;
647  int slice_count;
648  const uint8_t *slices_hdr = NULL;
649 
650  av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
651 
652  /* no supplementary picture */
653  if (buf_size == 0) {
654  return 0;
655  }
656 
657  if(!avctx->slice_count){
658  slice_count = (*buf++) + 1;
659  buf_size--;
660  slices_hdr = buf + 4;
661  buf += 8 * slice_count;
662  buf_size -= 8 * slice_count;
663  if (buf_size <= 0)
664  return AVERROR_INVALIDDATA;
665  }else
666  slice_count = avctx->slice_count;
667 
668  for(i=0; i<slice_count; i++){
669  int offset= get_slice_offset(avctx, slices_hdr, i);
670  int size, size2;
671 
672  if(i+1 == slice_count)
673  size= buf_size - offset;
674  else
675  size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
676 
677  if(i+2 >= slice_count)
678  size2= buf_size - offset;
679  else
680  size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
681 
682  if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
683  i++;
684  }
685 
686  if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
687  ff_er_frame_end(s);
688  MPV_frame_end(s);
689 
690  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
691  *pict= *(AVFrame*)s->current_picture_ptr;
692  } else if (s->last_picture_ptr != NULL) {
693  *pict= *(AVFrame*)s->last_picture_ptr;
694  }
695 
696  if(s->last_picture_ptr || s->low_delay){
697  *data_size = sizeof(AVFrame);
698  ff_print_debug_info(s, pict);
699  }
700  s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
701  }
702 
703  return avpkt->size;
704 }
705 
707  .name = "rv10",
708  .type = AVMEDIA_TYPE_VIDEO,
709  .id = CODEC_ID_RV10,
710  .priv_data_size = sizeof(MpegEncContext),
714  .capabilities = CODEC_CAP_DR1,
715  .max_lowres = 3,
716  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
717  .pix_fmts= ff_pixfmt_list_420,
718 };
719 
721  .name = "rv20",
722  .type = AVMEDIA_TYPE_VIDEO,
723  .id = CODEC_ID_RV20,
724  .priv_data_size = sizeof(MpegEncContext),
728  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
730  .max_lowres = 3,
731  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
732  .pix_fmts= ff_pixfmt_list_420,
733 };