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