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 {
44  MpegEncContext m;
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 
192 static VLC rv_dc_lum, rv_dc_chrom;
193 
194 int ff_rv_decode_dc(MpegEncContext *s, int n)
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 */
245 static int rv10_decode_picture_header(MpegEncContext *s)
246 {
247  int mb_count, pb_frame, marker, mb_xy;
248 
249  marker = get_bits1(&s->gb);
250 
251  if (get_bits1(&s->gb))
252  s->pict_type = AV_PICTURE_TYPE_P;
253  else
254  s->pict_type = AV_PICTURE_TYPE_I;
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 
301 static int rv20_decode_picture_header(RVDecContext *rv)
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 
318  if(s->last_picture_ptr==NULL && s->pict_type==AV_PICTURE_TYPE_B){
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;
365  ff_MPV_common_end(s);
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){
385  if(s->pict_type!=AV_PICTURE_TYPE_B){
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  }
396  ff_mpeg4_init_direct_mv(s);
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;
407  s->h263_aic= s->pict_type == AV_PICTURE_TYPE_I;
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 
424 static av_cold int rv10_decode_init(AVCodecContext *avctx)
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;
430 
431  if (avctx->extradata_size < 8) {
432  av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n");
433  return -1;
434  }
435 
436  ff_MPV_decode_defaults(s);
437 
438  s->avctx= avctx;
439  s->out_format = FMT_H263;
440  s->codec_id= avctx->codec_id;
441  avctx->flags |= CODEC_FLAG_EMU_EDGE;
442 
443  s->orig_width = s->width = avctx->coded_width;
444  s->orig_height= s->height = avctx->coded_height;
445 
446  s->h263_long_vectors= ((uint8_t*)avctx->extradata)[3] & 1;
447  rv->sub_id = AV_RB32((uint8_t*)avctx->extradata + 4);
448 
449  major_ver = RV_GET_MAJOR_VER(rv->sub_id);
450  minor_ver = RV_GET_MINOR_VER(rv->sub_id);
451  micro_ver = RV_GET_MICRO_VER(rv->sub_id);
452 
453  s->low_delay = 1;
454  switch (major_ver) {
455  case 1:
456  s->rv10_version = micro_ver ? 3 : 1;
457  s->obmc = micro_ver == 2;
458  break;
459  case 2:
460  if (minor_ver >= 2) {
461  s->low_delay = 0;
462  s->avctx->has_b_frames = 1;
463  }
464  break;
465  default:
466  av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", rv->sub_id);
467  av_log_missing_feature(avctx, "RV1/2 version", 1);
468  return AVERROR_PATCHWELCOME;
469  }
470 
471  if(avctx->debug & FF_DEBUG_PICT_INFO){
472  av_log(avctx, AV_LOG_DEBUG, "ver:%X ver0:%X\n", rv->sub_id, avctx->extradata_size >= 4 ? ((uint32_t*)avctx->extradata)[0] : -1);
473  }
474 
475  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
476 
477  if (ff_MPV_common_init(s) < 0)
478  return -1;
479 
480  ff_h263_decode_init_vlc(s);
481 
482  /* init rv vlc */
483  if (!done) {
484  INIT_VLC_STATIC(&rv_dc_lum, DC_VLC_BITS, 256,
485  rv_lum_bits, 1, 1,
486  rv_lum_code, 2, 2, 16384);
487  INIT_VLC_STATIC(&rv_dc_chrom, DC_VLC_BITS, 256,
488  rv_chrom_bits, 1, 1,
489  rv_chrom_code, 2, 2, 16388);
490  done = 1;
491  }
492 
493  return 0;
494 }
495 
496 static av_cold int rv10_decode_end(AVCodecContext *avctx)
497 {
498  MpegEncContext *s = avctx->priv_data;
499 
500  ff_MPV_common_end(s);
501  return 0;
502 }
503 
504 static int rv10_decode_packet(AVCodecContext *avctx,
505  const uint8_t *buf, int buf_size, int buf_size2)
506 {
507  RVDecContext *rv = avctx->priv_data;
508  MpegEncContext *s = &rv->m;
509  int mb_count, mb_pos, left, start_mb_x, active_bits_size;
510 
511  active_bits_size = buf_size * 8;
512  init_get_bits(&s->gb, buf, FFMAX(buf_size, buf_size2) * 8);
513  if(s->codec_id ==AV_CODEC_ID_RV10)
514  mb_count = rv10_decode_picture_header(s);
515  else
516  mb_count = rv20_decode_picture_header(rv);
517  if (mb_count < 0) {
518  av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
519  return -1;
520  }
521 
522  if (s->mb_x >= s->mb_width ||
523  s->mb_y >= s->mb_height) {
524  av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
525  return -1;
526  }
527  mb_pos = s->mb_y * s->mb_width + s->mb_x;
528  left = s->mb_width * s->mb_height - mb_pos;
529  if (mb_count > left) {
530  av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
531  return -1;
532  }
533 
534  if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
535  if(s->current_picture_ptr){ //FIXME write parser so we always have complete frames?
536  ff_er_frame_end(s);
537  ff_MPV_frame_end(s);
538  s->mb_x= s->mb_y = s->resync_mb_x = s->resync_mb_y= 0;
539  }
540  if(ff_MPV_frame_start(s, avctx) < 0)
541  return -1;
542  ff_er_frame_start(s);
543  } else {
544  if (s->current_picture_ptr->f.pict_type != s->pict_type) {
545  av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
546  return -1;
547  }
548  }
549 
550  av_dlog(avctx, "qscale=%d\n", s->qscale);
551 
552  /* default quantization values */
553  if(s->codec_id== AV_CODEC_ID_RV10){
554  if(s->mb_y==0) s->first_slice_line=1;
555  }else{
556  s->first_slice_line=1;
557  s->resync_mb_x= s->mb_x;
558  }
559  start_mb_x= s->mb_x;
560  s->resync_mb_y= s->mb_y;
561  if(s->h263_aic){
562  s->y_dc_scale_table=
563  s->c_dc_scale_table= ff_aic_dc_scale_table;
564  }else{
565  s->y_dc_scale_table=
566  s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
567  }
568 
569  if(s->modified_quant)
570  s->chroma_qscale_table= ff_h263_chroma_qscale_table;
571 
572  ff_set_qscale(s, s->qscale);
573 
574  s->rv10_first_dc_coded[0] = 0;
575  s->rv10_first_dc_coded[1] = 0;
576  s->rv10_first_dc_coded[2] = 0;
577  s->block_wrap[0]=
578  s->block_wrap[1]=
579  s->block_wrap[2]=
580  s->block_wrap[3]= s->b8_stride;
581  s->block_wrap[4]=
582  s->block_wrap[5]= s->mb_stride;
583  ff_init_block_index(s);
584  /* decode each macroblock */
585 
586  for(s->mb_num_left= mb_count; s->mb_num_left>0; s->mb_num_left--) {
587  int ret;
588  ff_update_block_index(s);
589  av_dlog(avctx, "**mb x=%d y=%d\n", s->mb_x, s->mb_y);
590 
591  s->mv_dir = MV_DIR_FORWARD;
592  s->mv_type = MV_TYPE_16X16;
593  ret=ff_h263_decode_mb(s, s->block);
594 
595  // Repeat the slice end check from ff_h263_decode_mb with our active
596  // bitstream size
597  if (ret != SLICE_ERROR) {
598  int v = show_bits(&s->gb, 16);
599 
600  if (get_bits_count(&s->gb) + 16 > active_bits_size)
601  v >>= get_bits_count(&s->gb) + 16 - active_bits_size;
602 
603  if (!v)
604  ret = SLICE_END;
605  }
606  if (ret != SLICE_ERROR && active_bits_size < get_bits_count(&s->gb) &&
607  8 * buf_size2 >= get_bits_count(&s->gb)) {
608  active_bits_size = buf_size2 * 8;
609  av_log(avctx, AV_LOG_DEBUG, "update size from %d to %d\n",
610  8 * buf_size, active_bits_size);
611  ret= SLICE_OK;
612  }
613 
614  if (ret == SLICE_ERROR || active_bits_size < get_bits_count(&s->gb)) {
615  av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
616  return -1;
617  }
618  if(s->pict_type != AV_PICTURE_TYPE_B)
619  ff_h263_update_motion_val(s);
620  ff_MPV_decode_mb(s, s->block);
621  if(s->loop_filter)
622  ff_h263_loop_filter(s);
623 
624  if (++s->mb_x == s->mb_width) {
625  s->mb_x = 0;
626  s->mb_y++;
627  ff_init_block_index(s);
628  }
629  if(s->mb_x == s->resync_mb_x)
630  s->first_slice_line=0;
631  if(ret == SLICE_END) break;
632  }
633 
634  ff_er_add_slice(s, start_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
635 
636  return active_bits_size;
637 }
638 
639 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
640 {
641  if(avctx->slice_count) return avctx->slice_offset[n];
642  else return AV_RL32(buf + n*8);
643 }
644 
645 static int rv10_decode_frame(AVCodecContext *avctx,
646  void *data, int *got_frame,
647  AVPacket *avpkt)
648 {
649  const uint8_t *buf = avpkt->data;
650  int buf_size = avpkt->size;
651  MpegEncContext *s = avctx->priv_data;
652  int i;
653  AVFrame *pict = data;
654  int slice_count;
655  const uint8_t *slices_hdr = NULL;
656 
657  av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
658 
659  /* no supplementary picture */
660  if (buf_size == 0) {
661  return 0;
662  }
663 
664  if(!avctx->slice_count){
665  slice_count = (*buf++) + 1;
666  buf_size--;
667  slices_hdr = buf + 4;
668  buf += 8 * slice_count;
669  buf_size -= 8 * slice_count;
670  if (buf_size <= 0)
671  return AVERROR_INVALIDDATA;
672  }else
673  slice_count = avctx->slice_count;
674 
675  for(i=0; i<slice_count; i++){
676  unsigned offset = get_slice_offset(avctx, slices_hdr, i);
677  int size, size2;
678 
679  if (offset >= buf_size)
680  return AVERROR_INVALIDDATA;
681 
682  if(i+1 == slice_count)
683  size= buf_size - offset;
684  else
685  size= get_slice_offset(avctx, slices_hdr, i+1) - offset;
686 
687  if(i+2 >= slice_count)
688  size2= buf_size - offset;
689  else
690  size2= get_slice_offset(avctx, slices_hdr, i+2) - offset;
691 
692  if (size <= 0 || size2 <= 0 ||
693  offset + FFMAX(size, size2) > buf_size)
694  return AVERROR_INVALIDDATA;
695 
696  if(rv10_decode_packet(avctx, buf+offset, size, size2) > 8*size)
697  i++;
698  }
699 
700  if(s->current_picture_ptr != NULL && s->mb_y>=s->mb_height){
701  ff_er_frame_end(s);
702  ff_MPV_frame_end(s);
703 
704  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
705  *pict = s->current_picture_ptr->f;
706  } else if (s->last_picture_ptr != NULL) {
707  *pict = s->last_picture_ptr->f;
708  }
709 
710  if(s->last_picture_ptr || s->low_delay){
711  *got_frame = 1;
712  ff_print_debug_info(s, pict);
713  }
714  s->current_picture_ptr= NULL; // so we can detect if frame_end was not called (find some nicer solution...)
715  }
716 
717  return avpkt->size;
718 }
719 
720 AVCodec ff_rv10_decoder = {
721  .name = "rv10",
722  .type = AVMEDIA_TYPE_VIDEO,
723  .id = AV_CODEC_ID_RV10,
724  .priv_data_size = sizeof(RVDecContext),
725  .init = rv10_decode_init,
726  .close = rv10_decode_end,
727  .decode = rv10_decode_frame,
728  .capabilities = CODEC_CAP_DR1,
729  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
730  .pix_fmts = ff_pixfmt_list_420,
731 };
732 
733 AVCodec ff_rv20_decoder = {
734  .name = "rv20",
735  .type = AVMEDIA_TYPE_VIDEO,
736  .id = AV_CODEC_ID_RV20,
737  .priv_data_size = sizeof(RVDecContext),
738  .init = rv10_decode_init,
739  .close = rv10_decode_end,
740  .decode = rv10_decode_frame,
741  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
742  .flush = ff_mpeg_flush,
743  .long_name = NULL_IF_CONFIG_SMALL("RealVideo 2.0"),
744  .pix_fmts = ff_pixfmt_list_420,
745 };