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 };
int rv10_first_dc_coded[3]
Definition: mpegvideo.h:576
#define SLICE_ERROR
Definition: mpegvideo.h:655
enum PixelFormat pix_fmt
Pixel format, see PIX_FMT_xxx.
Definition: avcodec.h:1426
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2608
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
int size
Audio Video Frame.
Definition: avcodec.h:985
struct MpegEncContext MpegEncContext
MpegEncContext.
AV_WL32 AV_WL24 AV_WL16 AV_RB32
Definition: bytestream.h:89
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
Definition: rv10.c:640
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:306
int coded_width
Bitstream width / height, may be different from width/height if lowres enabled.
Definition: avcodec.h:2543
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
static const uint16_t rv_chrom_code[256]
Definition: rv10.c:115
int size
Definition: avcodec.h:909
AVCodec ff_rv20_decoder
Definition: rv10.c:728
int obmc
overlapped block motion compensation
Definition: mpegvideo.h:497
mpegvideo header.
void ff_h263_decode_init_vlc(MpegEncContext *s)
Definition: ituh263dec.c:104
#define SLICE_OK
Definition: mpegvideo.h:654
static int rv10_decode_picture_header(MpegEncContext *s)
Definition: rv10.c:240
AVCodec.
Definition: avcodec.h:3189
int qscale
QP.
Definition: mpegvideo.h:324
int h263_aic
Advanded INTRA Coding (AIC)
Definition: mpegvideo.h:252
#define v(n)
Definition: regs.h:34
int block_wrap[6]
Definition: mpegvideo.h:415
static int rv20_decode_picture_header(MpegEncContext *s)
Definition: rv10.c:296
int modified_quant
Definition: mpegvideo.h:505
int mb_num_left
number of MBs left in this video packet (for partitioned Slices only)
Definition: mpegvideo.h:489
int64_t time
time of current frame
Definition: mpegvideo.h:513
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:64
#define av_cold
Definition: attributes.h:71
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: get_bits.h:402
enum OutputFormat out_format
output format
Definition: mpegvideo.h:209
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2008
#define RV_GET_MICRO_VER(x)
Definition: rv10.c:39
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1387
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Definition: mpegvideo.h:388
const char data[16]
Definition: mxf.c:60
uint8_t * data
Definition: avcodec.h:908
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
int ff_h263_decode_mba(MpegEncContext *s)
Definition: ituh263dec.c:136
uint16_t pp_time
time distance between the last 2 p,s,i frames
Definition: mpegvideo.h:515
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:237
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2536
enum PixelFormat ff_pixfmt_list_420[]
Definition: mpegvideo.c:130
void MPV_common_end(MpegEncContext *s)
Definition: mpegvideo.c:923
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
Definition: utils.c:133
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:743
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:336
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2888
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:719
int slice_count
slice count
Definition: avcodec.h:1942
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1745
int last_dc[3]
last DC values for MPEG1
Definition: mpegvideo.h:303
int sub_id
Some codecs need additional format info.
Definition: avcodec.h:1365
AVCodec ff_rv10_decoder
Definition: rv10.c:714
int unrestricted_mv
mv can point outside of the coded picture
Definition: mpegvideo.h:340
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:191
AV_RL32
Definition: bytestream.h:89
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1355
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:140
#define RV_GET_MINOR_VER(x)
Definition: rv10.c:38
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
Definition: mpeg4video.c:78
int rv_decode_dc(MpegEncContext *s, int n)
Definition: rv10.c:189
const char * name
Name of the codec implementation.
Definition: avcodec.h:3196
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:547
GetBitContext gb
Definition: mpegvideo.h:603
#define FFMAX(a, b)
Definition: common.h:53
void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64])
Definition: mpegvideo.c:2528
Definition: get_bits.h:63
enum CodecID codec_id
Definition: mpegvideo.h:217
#define CODEC_FLAG_EMU_EDGE
Don't draw edges.
Definition: avcodec.h:641
void MPV_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1357
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2640
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:486
void ff_er_add_slice(MpegEncContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:213
void ff_h263_loop_filter(MpegEncContext *s)
Definition: h263.c:142
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
Definition: avcodec.h:1029
int ff_h263_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
Definition: ituh263dec.c:601
#define FFMIN(a, b)
Definition: common.h:55
#define f(n)
Definition: regs.h:33
void MPV_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
Definition: mpegvideo.c:649
#define RV_GET_MAJOR_VER(x)
Definition: rv10.c:37
struct AVFrame AVFrame
Audio Video Frame.
#define DC_VLC_BITS
Definition: rv10.c:41
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:299
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:251
void ff_er_frame_end(MpegEncContext *s)
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:481
static const uint8_t rv_chrom_bits[256]
Definition: rv10.c:151
const uint8_t ff_aic_dc_scale_table[32]
Definition: h263data.h:248
static av_cold int rv10_decode_end(AVCodecContext *avctx)
Definition: rv10.c:498
#define av_dlog(pctx,...)
av_dlog macros Useful to print debug messages that shouldn't get compiled in normally.
Definition: log.h:158
av_cold int MPV_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:658
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:370
int first_slice_line
used in mpeg4 too to handle resync markers
Definition: mpegvideo.h:591
NULL
Definition: eval.c:50
static av_cold int rv10_decode_init(AVCodecContext *avctx)
Definition: rv10.c:424
int64_t last_non_b_time
Definition: mpegvideo.h:514
static const uint16_t rv_lum_code[256]
Definition: rv10.c:43
external API header
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:49
int debug
debug
Definition: avcodec.h:2007
main external API structure.
Definition: avcodec.h:1329
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:327
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:111
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideo.c:75
#define SLICE_END
end marker found
Definition: mpegvideo.h:656
int extradata_size
Definition: avcodec.h:1388
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
int coded_height
Definition: avcodec.h:2543
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
#define ER_MB_END
Definition: mpegvideo.h:484
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:354
void ff_er_frame_start(MpegEncContext *s)
int f_code
forward MV resolution
Definition: mpegvideo.h:344
#define MV_DIR_FORWARD
Definition: mpegvideo.h:366
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:331
DCTELEM(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:651
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:307
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:239
MpegEncContext.
Definition: mpegvideo.h:201
struct AVCodecContext * avctx
Definition: mpegvideo.h:203
static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
Definition: rv10.c:646
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:238
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:125
const uint8_t ff_h263_chroma_qscale_table[32]
Definition: h263data.h:262
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
Definition: alsdec.c:1779
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:297
Bi-dir predicted.
Definition: avutil.h:298
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (h263)
Definition: mpegvideo.h:308
DSP utils.
void * priv_data
Definition: avcodec.h:1531
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
Print debugging info for the given picture.
Definition: mpegvideo.c:1518
static const uint8_t rv_lum_bits[256]
Definition: rv10.c:79
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:487
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
struct AVFrame f
Definition: mpegvideo.h:86
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:1948
int frame_number
audio or video frame number
Definition: avcodec.h:1471
#define AV_LOG_INFO
Definition: log.h:119
int rv10_version
RV10 version: 0 or 3.
Definition: mpegvideo.h:575
#define FRAME_SKIPPED
return value for header parsers if frame is not coded
Definition: mpegvideo.h:40
int h263_long_vectors
use horrible h263v1 long vector mode
Definition: mpegvideo.h:341
static VLC rv_dc_lum
Definition: rv10.c:187
#define CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:750
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
Definition: utils.c:1714
int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function for encode/decode called after coding/decoding the header and before a frame is code...
Definition: mpegvideo.c:1163
Predicted.
Definition: avutil.h:297
uint16_t pb_time
time distance between the last b and p,s,i frame
Definition: mpegvideo.h:516
static VLC rv_dc_chrom
Definition: rv10.c:187
enum CodecID codec_id
Definition: avcodec.h:1575
static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int buf_size2)
Definition: rv10.c:506