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