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  if (s->avctx->extradata_size < 8 + 2 * f) {
345  av_log(s->avctx, AV_LOG_ERROR, "Extradata too small.\n");
346  return AVERROR_INVALIDDATA;
347  }
348 
349  new_w= 4*((uint8_t*)s->avctx->extradata)[6+2*f];
350  new_h= 4*((uint8_t*)s->avctx->extradata)[7+2*f];
351  }else{
352  new_w= s->orig_width ;
353  new_h= s->orig_height;
354  }
355  if(new_w != s->width || new_h != s->height){
356  av_log(s->avctx, AV_LOG_DEBUG, "attempting to change resolution to %dx%d\n", new_w, new_h);
357  if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
358  return -1;
359  MPV_common_end(s);
360  avcodec_set_dimensions(s->avctx, new_w, new_h);
361  s->width = new_w;
362  s->height = new_h;
363  if (MPV_common_init(s) < 0)
364  return -1;
365  }
366 
367  if(s->avctx->debug & FF_DEBUG_PICT_INFO){
368  av_log(s->avctx, AV_LOG_DEBUG, "F %d/%d\n", f, rpr_bits);
369  }
370  } else if (av_image_check_size(s->width, s->height, 0, s->avctx) < 0)
371  return AVERROR_INVALIDDATA;
372 
373  mb_pos = ff_h263_decode_mba(s);
374 
375 //av_log(s->avctx, AV_LOG_DEBUG, "%d\n", seq);
376  seq |= s->time &~0x7FFF;
377  if(seq - s->time > 0x4000) seq -= 0x8000;
378  if(seq - s->time < -0x4000) seq += 0x8000;
379  if(seq != s->time){
381  s->time= seq;
382  s->pp_time= s->time - s->last_non_b_time;
383  s->last_non_b_time= s->time;
384  }else{
385  s->time= seq;
386  s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
387  if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
388  av_log(s->avctx, AV_LOG_DEBUG, "messed up order, possible from seeking? skipping current b frame\n");
389  return FRAME_SKIPPED;
390  }
392  }
393  }
394 // printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
395 /*for(i=0; i<32; i++){
396  av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
397 }
398 av_log(s->avctx, AV_LOG_DEBUG, "\n");*/
399  s->no_rounding= get_bits1(&s->gb);
400 
402  skip_bits(&s->gb, 5); // binary decoder reads 3+2 bits here but they don't seem to be used
403 
404  s->f_code = 1;
405  s->unrestricted_mv = 1;
407 // s->alt_inter_vlc=1;
408 // s->obmc=1;
409 // s->umvplus=1;
410  s->modified_quant=1;
411  if(!s->avctx->lowres)
412  s->loop_filter=1;
413 
414  if(s->avctx->debug & FF_DEBUG_PICT_INFO){
415  av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
416  seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
417  }
418 
419  assert(s->pict_type != AV_PICTURE_TYPE_B || !s->low_delay);
420 
421  return s->mb_width*s->mb_height - mb_pos;
422 }
423 
425 {
426  MpegEncContext *s = avctx->priv_data;
427  static int done=0;
428  int major_ver, minor_ver, micro_ver;
429 
430  if (avctx->extradata_size < 8) {
431  av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
432  return -1;
433  }
434 
436 
437  s->avctx= avctx;
438  s->out_format = FMT_H263;
439  s->codec_id= avctx->codec_id;
440  avctx->flags |= CODEC_FLAG_EMU_EDGE;
441 
442  s->orig_width = s->width = avctx->coded_width;
443  s->orig_height= s->height = avctx->coded_height;
444 
445  s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
446  avctx->sub_id= AV_RB32((uint8_t*)avctx->extradata + 4);
447 
448  major_ver = RV_GET_MAJOR_VER(avctx->sub_id);
449  minor_ver = RV_GET_MINOR_VER(avctx->sub_id);
450  micro_ver = RV_GET_MICRO_VER(avctx->sub_id);
451 
452  s->low_delay = 1;
453  switch (major_ver) {
454  case 1:
455  s->rv10_version = micro_ver ? 3 : 1;
456  s->obmc = micro_ver == 2;
457  break;
458  case 2:
459  if (minor_ver >= 2) {
460  s->low_delay = 0;
461  s->avctx->has_b_frames = 1;
462  }
463  break;
464  default:
465  av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
466  av_log_missing_feature(avctx, "RV1/2 version", 1);
467  return AVERROR_PATCHWELCOME;
468  }
469 
470  if(avctx->debug & FF_DEBUG_PICT_INFO){
471  av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", avctx->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
472  }
473 
474  avctx->pix_fmt = PIX_FMT_YUV420P;
475 
476  if (MPV_common_init(s) < 0)
477  return -1;
478 
480 
481  /* init rv vlc */
482  if (!done) {
483  INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
484  rv_lum_bits, 1, 1,
485  rv_lum_code, 2, 2, 16384);
486  INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
487  rv_chrom_bits, 1, 1,
488  rv_chrom_code, 2, 2, 16388);
489  done = 1;
490  }
491 
492  return 0;
493 }
494 
496 {
497  MpegEncContext *s = avctx->priv_data;
498 
499  MPV_common_end(s);
500  return 0;
501 }
502 
504  const uint8_t *buf, int buf_size, int buf_size2)
505 {
506  MpegEncContext *s = avctx->priv_data;
507  int mb_count, mb_pos, left, start_mb_x, active_bits_size;
508 
509  active_bits_size = buf_size * 8;
510  init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
511  if(s->codec_id ==CODEC_ID_RV10)
512  mb_count = rv10_decode_picture_header(s);
513  else
514  mb_count = rv20_decode_picture_header(s);
515  if (mb_count < 0) {
516  av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
517  return -1;
518  }
519 
520  if (s->mb_x >= s->mb_width ||
521  s->mb_y >= s->mb_height) {
522  av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
523  return -1;
524  }
525  mb_pos = s->mb_y * s->mb_width + s->mb_x;
526  left = s->mb_width * s->mb_height - mb_pos;
527  if (mb_count > left) {
528  av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
529  return -1;
530  }
531 
532  if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
533  if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
534  ff_er_frame_end(s);
535  MPV_frame_end(s);
536  s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
537  }
538  if(MPV_frame_start(s, avctx) < 0)
539  return -1;
541  } else {
542  if (s->current_picture_ptr->f.pict_type != s->pict_type) {
543  av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
544  return -1;
545  }
546  }
547 
548  av_dlog(avctx, "qscale=%d\n", s->qscale);
549 
550  /* default quantization values */
551  if(s->codec_id== CODEC_ID_RV10){
552  if(s->mb_y==0) s->first_slice_line=1;
553  }else{
554  s->first_slice_line=1;
555  s->resync_mb_x= s->mb_x;
556  }
557  start_mb_x= s->mb_x;
558  s->resync_mb_y= s->mb_y;
559  if(s->h263_aic){
560  s->y_dc_scale_table=
562  }else{
563  s->y_dc_scale_table=
565  }
566 
567  if(s->modified_quant)
569 
570  ff_set_qscale(s, s->qscale);
571 
572  s->rv10_first_dc_coded[0] = 0;
573  s->rv10_first_dc_coded[1] = 0;
574  s->rv10_first_dc_coded[2] = 0;
575  s->block_wrap[0]=
576  s->block_wrap[1]=
577  s->block_wrap[2]=
578  s->block_wrap[3]= s->b8_stride;
579  s->block_wrap[4]=
580  s->block_wrap[5]= s->mb_stride;
582  /* decode each macroblock */
583 
584  for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
585  int ret;
587  av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
588 
589  s->mv_dir = MV_DIR_FORWARD;
590  s->mv_type = MV_TYPE_16X16;
591  ret=ff_h263_decode_mb(s, s->block);
592 
593  // Repeat the slice end check from ff_h263_decode_mb with our active
594  // bitstream size
595  if (ret != SLICE_ERROR) {
596  int v = show_bits(&s->gb, 16);
597 
598  if (get_bits_count(&s->gb) + 16 > active_bits_size)
599  v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
600 
601  if (!v)
602  ret = SLICE_END;
603  }
604  if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
605  8 * buf_size2 >= get_bits_count(&s->gb)) {
606  active_bits_size = buf_size2 * 8;
607  av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
608  8 * buf_size, active_bits_size);
609  ret= SLICE_OK;
610  }
611 
612  if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
613  av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
614  return -1;
615  }
616  if(s->pict_type != AV_PICTURE_TYPE_B)
618  MPV_decode_mb(s, s->block);
619  if(s->loop_filter)
621 
622  if (++s->mb_x == s->mb_width) {
623  s->mb_x = 0;
624  s->mb_y++;
626  }
627  if(s->mb_x == s->resync_mb_x)
628  s->first_slice_line=0;
629  if(ret == SLICE_END) break;
630  }
631 
632  ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
633 
634  return active_bits_size;
635 }
636 
637 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
638 {
639  if(avctx->slice_count) return avctx->slice_offset[n];
640  else return AV_RL32(buf + n*8);
641 }
642 
644  void *data, int *data_size,
645  AVPacket *avpkt)
646 {
647  const uint8_t *buf = avpkt->data;
648  int buf_size = avpkt->size;
649  MpegEncContext *s = avctx->priv_data;
650  int i;
651  AVFrame *pict = data;
652  int slice_count;
653  const uint8_t *slices_hdr = NULL;
654 
655  av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
656 
657  /* no supplementary picture */
658  if (buf_size == 0) {
659  return 0;
660  }
661 
662  if(!avctx->slice_count){
663  slice_count = (*buf++) + 1;
664  buf_size--;
665  slices_hdr = buf + 4;
666  buf += 8 * slice_count;
667  buf_size -= 8 * slice_count;
668  if (buf_size <= 0)
669  return AVERROR_INVALIDDATA;
670  }else
671  slice_count = avctx->slice_count;
672 
673  for(i=0; i<slice_count; i++){
674  int offset= get_slice_offset(avctx, slices_hdr, i);
675  int size, size2;
676 
677  if(i+1 == slice_count)
678  size= buf_size - offset;
679  else
680  size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
681 
682  if(i+2 >= slice_count)
683  size2= buf_size - offset;
684  else
685  size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
686 
687  if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
688  i++;
689  }
690 
691  if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
692  ff_er_frame_end(s);
693  MPV_frame_end(s);
694 
695  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
696  *pict= *(AVFrame*)s->current_picture_ptr;
697  } else if (s->last_picture_ptr != NULL) {
698  *pict= *(AVFrame*)s->last_picture_ptr;
699  }
700 
701  if(s->last_picture_ptr || s->low_delay){
702  *data_size = sizeof(AVFrame);
703  ff_print_debug_info(s, pict);
704  }
705  s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...)
706  }
707 
708  return avpkt->size;
709 }
710 
712  .name = "rv10",
713  .type = AVMEDIA_TYPE_VIDEO,
714  .id = CODEC_ID_RV10,
715  .priv_data_size = sizeof(MpegEncContext),
719  .capabilities = CODEC_CAP_DR1,
720  .max_lowres = 3,
721  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
722  .pix_fmts= ff_pixfmt_list_420,
723 };
724 
726  .name = "rv20",
727  .type = AVMEDIA_TYPE_VIDEO,
728  .id = CODEC_ID_RV20,
729  .priv_data_size = sizeof(MpegEncContext),
733  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
735  .max_lowres = 3,
736  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
737  .pix_fmts= ff_pixfmt_list_420,
738 };