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->er);
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->er, 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->er);
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 };
int rv10_first_dc_coded[3]
Definition: mpegvideo.h:587
#define SLICE_ERROR
Definition: mpegvideo.h:666
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2543
int size
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
Definition: rv10.c:642
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:325
int coded_width
Bitstream width / height, may be different from width/height.
Definition: avcodec.h:1515
av_cold int ff_MPV_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:941
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:237
#define ER_MB_END
static const uint16_t rv_chrom_code[256]
Definition: rv10.c:120
void ff_er_frame_end(ERContext *s)
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
Definition: utils.c:149
int size
Definition: avcodec.h:916
enum AVCodecID codec_id
Definition: mpegvideo.h:228
AVCodec ff_rv20_decoder
Definition: rv10.c:736
int sub_id
Definition: rv10.c:45
int obmc
overlapped block motion compensation
Definition: mpegvideo.h:504
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1533
mpegvideo header.
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
void ff_h263_decode_init_vlc(MpegEncContext *s)
Definition: ituh263dec.c:104
#define SLICE_OK
Definition: mpegvideo.h:665
static int rv10_decode_picture_header(MpegEncContext *s)
Definition: rv10.c:245
AVCodec.
Definition: avcodec.h:2960
int qscale
QP.
Definition: mpegvideo.h:343
int h263_aic
Advanded INTRA Coding (AIC)
Definition: mpegvideo.h:263
int block_wrap[6]
Definition: mpegvideo.h:435
int modified_quant
Definition: mpegvideo.h:516
int mb_num_left
number of MBs left in this video packet (for partitioned Slices only)
Definition: mpegvideo.h:496
int64_t time
time of current frame
Definition: mpegvideo.h:524
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
uint8_t
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: get_bits.h:436
enum OutputFormat out_format
output format
Definition: mpegvideo.h:220
struct RVDecContext RVDecContext
#define AV_RB32
Definition: intreadwrite.h:130
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpegvideo.c:2843
#define RV_GET_MICRO_VER(x)
Definition: rv10.c:39
int ff_rv_decode_dc(MpegEncContext *s, int n)
Definition: rv10.c:194
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1454
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Definition: mpegvideo.h:408
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:915
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:192
MpegEncContext m
Definition: rv10.c:44
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:526
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:248
enum AVPixelFormat ff_pixfmt_list_420[]
Definition: mpegvideo.c:128
void ff_MPV_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1640
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:812
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2823
int slice_count
slice count
Definition: avcodec.h:1699
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1634
int last_dc[3]
last DC values for MPEG1
Definition: mpegvideo.h:322
AVCodec ff_rv10_decoder
Definition: rv10.c:723
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
int unrestricted_mv
mv can point outside of the coded picture
Definition: mpegvideo.h:359
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
ERContext er
Definition: mpegvideo.h:704
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1434
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
#define RV_GET_MINOR_VER(x)
Definition: rv10.c:38
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
Definition: mpeg4video.c:78
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:558
GetBitContext gb
Definition: mpegvideo.h:614
Definition: get_bits.h:63
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2575
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:493
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:220
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:1065
int ff_h263_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
Definition: ituh263dec.c:601
#define RV_GET_MAJOR_VER(x)
Definition: rv10.c:37
#define DC_VLC_BITS
Definition: rv10.c:41
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:318
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:251
static int rv10_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: rv10.c:648
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:515
#define AV_RL32
Definition: intreadwrite.h:146
static const uint8_t rv_chrom_bits[256]
Definition: rv10.c:156
const uint8_t ff_aic_dc_scale_table[32]
Definition: h263data.h:248
int ff_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:1429
static av_cold int rv10_decode_end(AVCodecContext *avctx)
Definition: rv10.c:499
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:390
int first_slice_line
used in mpeg4 too to handle resync markers
Definition: mpegvideo.h:602
NULL
Definition: eval.c:52
static av_cold int rv10_decode_init(AVCodecContext *avctx)
Definition: rv10.c:424
int64_t last_non_b_time
Definition: mpegvideo.h:525
static const uint16_t rv_lum_code[256]
Definition: rv10.c:48
external API header
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:49
enum AVCodecID codec_id
Definition: avcodec.h:1350
int debug
debug
Definition: avcodec.h:2568
main external API structure.
Definition: avcodec.h:1339
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:216
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideo.c:73
#define SLICE_END
end marker found
Definition: mpegvideo.h:667
int extradata_size
Definition: avcodec.h:1455
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
int coded_height
Definition: avcodec.h:1515
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:260
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:2007
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:372
int f_code
forward MV resolution
Definition: mpegvideo.h:364
#define MV_DIR_FORWARD
Definition: mpegvideo.h:386
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:350
DCTELEM(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:662
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:326
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:250
MpegEncContext.
Definition: mpegvideo.h:212
struct AVCodecContext * avctx
Definition: mpegvideo.h:214
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:249
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:1772
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:316
Bi-dir predicted.
Definition: avutil.h:247
const uint8_t * chroma_qscale_table
qscale -> chroma_qscale (h263)
Definition: mpegvideo.h:327
DSP utils.
void * priv_data
Definition: avcodec.h:1382
static int rv20_decode_picture_header(RVDecContext *rv)
Definition: rv10.c:301
void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64])
Definition: mpegvideo.c:2446
void ff_MPV_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1200
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
Print debugging info for the given picture.
Definition: mpegvideo.c:1802
static const uint8_t rv_lum_bits[256]
Definition: rv10.c:84
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:494
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
struct AVFrame f
Definition: mpegvideo.h:96
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:1715
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2135
int rv10_version
RV10 version: 0 or 3.
Definition: mpegvideo.h:586
#define FRAME_SKIPPED
return value for header parsers if frame is not coded
Definition: mpegvideo.h:44
int h263_long_vectors
use horrible h263v1 long vector mode
Definition: mpegvideo.h:360
static VLC rv_dc_lum
Definition: rv10.c:192
This structure stores compressed data.
Definition: avcodec.h:898
Predicted.
Definition: avutil.h:246
void ff_MPV_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
Definition: mpegvideo.c:745
uint16_t pb_time
time distance between the last b and p,s,i frame
Definition: mpegvideo.h:527
static VLC rv_dc_chrom
Definition: rv10.c:192
static int rv10_decode_packet(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int buf_size2)
Definition: rv10.c:507