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