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