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