3 * Copyright (c) 2000,2001 Fabrice Bellard.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include "mpegvideo.h"
31 #define DC_VLC_BITS 14 //FIXME find a better solution
33 static const uint16_t rv_lum_code[256] =
35 0x3e7f, 0x0f00, 0x0f01, 0x0f02, 0x0f03, 0x0f04, 0x0f05, 0x0f06,
36 0x0f07, 0x0f08, 0x0f09, 0x0f0a, 0x0f0b, 0x0f0c, 0x0f0d, 0x0f0e,
37 0x0f0f, 0x0f10, 0x0f11, 0x0f12, 0x0f13, 0x0f14, 0x0f15, 0x0f16,
38 0x0f17, 0x0f18, 0x0f19, 0x0f1a, 0x0f1b, 0x0f1c, 0x0f1d, 0x0f1e,
39 0x0f1f, 0x0f20, 0x0f21, 0x0f22, 0x0f23, 0x0f24, 0x0f25, 0x0f26,
40 0x0f27, 0x0f28, 0x0f29, 0x0f2a, 0x0f2b, 0x0f2c, 0x0f2d, 0x0f2e,
41 0x0f2f, 0x0f30, 0x0f31, 0x0f32, 0x0f33, 0x0f34, 0x0f35, 0x0f36,
42 0x0f37, 0x0f38, 0x0f39, 0x0f3a, 0x0f3b, 0x0f3c, 0x0f3d, 0x0f3e,
43 0x0f3f, 0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x0386,
44 0x0387, 0x0388, 0x0389, 0x038a, 0x038b, 0x038c, 0x038d, 0x038e,
45 0x038f, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
46 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e,
47 0x039f, 0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6,
48 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce,
49 0x00cf, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056,
50 0x0057, 0x0020, 0x0021, 0x0022, 0x0023, 0x000c, 0x000d, 0x0004,
51 0x0000, 0x0005, 0x000e, 0x000f, 0x0024, 0x0025, 0x0026, 0x0027,
52 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f,
53 0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
54 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
55 0x03a0, 0x03a1, 0x03a2, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
56 0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
57 0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
58 0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
59 0x0f40, 0x0f41, 0x0f42, 0x0f43, 0x0f44, 0x0f45, 0x0f46, 0x0f47,
60 0x0f48, 0x0f49, 0x0f4a, 0x0f4b, 0x0f4c, 0x0f4d, 0x0f4e, 0x0f4f,
61 0x0f50, 0x0f51, 0x0f52, 0x0f53, 0x0f54, 0x0f55, 0x0f56, 0x0f57,
62 0x0f58, 0x0f59, 0x0f5a, 0x0f5b, 0x0f5c, 0x0f5d, 0x0f5e, 0x0f5f,
63 0x0f60, 0x0f61, 0x0f62, 0x0f63, 0x0f64, 0x0f65, 0x0f66, 0x0f67,
64 0x0f68, 0x0f69, 0x0f6a, 0x0f6b, 0x0f6c, 0x0f6d, 0x0f6e, 0x0f6f,
65 0x0f70, 0x0f71, 0x0f72, 0x0f73, 0x0f74, 0x0f75, 0x0f76, 0x0f77,
66 0x0f78, 0x0f79, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f7e, 0x0f7f,
69 static const uint8_t rv_lum_bits[256] =
71 14, 12, 12, 12, 12, 12, 12, 12,
72 12, 12, 12, 12, 12, 12, 12, 12,
73 12, 12, 12, 12, 12, 12, 12, 12,
74 12, 12, 12, 12, 12, 12, 12, 12,
75 12, 12, 12, 12, 12, 12, 12, 12,
76 12, 12, 12, 12, 12, 12, 12, 12,
77 12, 12, 12, 12, 12, 12, 12, 12,
78 12, 12, 12, 12, 12, 12, 12, 12,
79 12, 10, 10, 10, 10, 10, 10, 10,
80 10, 10, 10, 10, 10, 10, 10, 10,
81 10, 10, 10, 10, 10, 10, 10, 10,
82 10, 10, 10, 10, 10, 10, 10, 10,
83 10, 8, 8, 8, 8, 8, 8, 8,
84 8, 8, 8, 8, 8, 8, 8, 8,
85 8, 7, 7, 7, 7, 7, 7, 7,
86 7, 6, 6, 6, 6, 5, 5, 4,
87 2, 4, 5, 5, 6, 6, 6, 6,
88 7, 7, 7, 7, 7, 7, 7, 7,
89 8, 8, 8, 8, 8, 8, 8, 8,
90 8, 8, 8, 8, 8, 8, 8, 8,
91 10, 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 12, 12, 12, 12, 12, 12, 12, 12,
96 12, 12, 12, 12, 12, 12, 12, 12,
97 12, 12, 12, 12, 12, 12, 12, 12,
98 12, 12, 12, 12, 12, 12, 12, 12,
99 12, 12, 12, 12, 12, 12, 12, 12,
100 12, 12, 12, 12, 12, 12, 12, 12,
101 12, 12, 12, 12, 12, 12, 12, 12,
102 12, 12, 12, 12, 12, 12, 12, 12,
105 static const uint16_t rv_chrom_code[256] =
107 0xfe7f, 0x3f00, 0x3f01, 0x3f02, 0x3f03, 0x3f04, 0x3f05, 0x3f06,
108 0x3f07, 0x3f08, 0x3f09, 0x3f0a, 0x3f0b, 0x3f0c, 0x3f0d, 0x3f0e,
109 0x3f0f, 0x3f10, 0x3f11, 0x3f12, 0x3f13, 0x3f14, 0x3f15, 0x3f16,
110 0x3f17, 0x3f18, 0x3f19, 0x3f1a, 0x3f1b, 0x3f1c, 0x3f1d, 0x3f1e,
111 0x3f1f, 0x3f20, 0x3f21, 0x3f22, 0x3f23, 0x3f24, 0x3f25, 0x3f26,
112 0x3f27, 0x3f28, 0x3f29, 0x3f2a, 0x3f2b, 0x3f2c, 0x3f2d, 0x3f2e,
113 0x3f2f, 0x3f30, 0x3f31, 0x3f32, 0x3f33, 0x3f34, 0x3f35, 0x3f36,
114 0x3f37, 0x3f38, 0x3f39, 0x3f3a, 0x3f3b, 0x3f3c, 0x3f3d, 0x3f3e,
115 0x3f3f, 0x0f80, 0x0f81, 0x0f82, 0x0f83, 0x0f84, 0x0f85, 0x0f86,
116 0x0f87, 0x0f88, 0x0f89, 0x0f8a, 0x0f8b, 0x0f8c, 0x0f8d, 0x0f8e,
117 0x0f8f, 0x0f90, 0x0f91, 0x0f92, 0x0f93, 0x0f94, 0x0f95, 0x0f96,
118 0x0f97, 0x0f98, 0x0f99, 0x0f9a, 0x0f9b, 0x0f9c, 0x0f9d, 0x0f9e,
119 0x0f9f, 0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6,
120 0x03c7, 0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce,
121 0x03cf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6,
122 0x00e7, 0x0030, 0x0031, 0x0032, 0x0033, 0x0008, 0x0009, 0x0002,
123 0x0000, 0x0003, 0x000a, 0x000b, 0x0034, 0x0035, 0x0036, 0x0037,
124 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
125 0x03d0, 0x03d1, 0x03d2, 0x03d3, 0x03d4, 0x03d5, 0x03d6, 0x03d7,
126 0x03d8, 0x03d9, 0x03da, 0x03db, 0x03dc, 0x03dd, 0x03de, 0x03df,
127 0x0fa0, 0x0fa1, 0x0fa2, 0x0fa3, 0x0fa4, 0x0fa5, 0x0fa6, 0x0fa7,
128 0x0fa8, 0x0fa9, 0x0faa, 0x0fab, 0x0fac, 0x0fad, 0x0fae, 0x0faf,
129 0x0fb0, 0x0fb1, 0x0fb2, 0x0fb3, 0x0fb4, 0x0fb5, 0x0fb6, 0x0fb7,
130 0x0fb8, 0x0fb9, 0x0fba, 0x0fbb, 0x0fbc, 0x0fbd, 0x0fbe, 0x0fbf,
131 0x3f40, 0x3f41, 0x3f42, 0x3f43, 0x3f44, 0x3f45, 0x3f46, 0x3f47,
132 0x3f48, 0x3f49, 0x3f4a, 0x3f4b, 0x3f4c, 0x3f4d, 0x3f4e, 0x3f4f,
133 0x3f50, 0x3f51, 0x3f52, 0x3f53, 0x3f54, 0x3f55, 0x3f56, 0x3f57,
134 0x3f58, 0x3f59, 0x3f5a, 0x3f5b, 0x3f5c, 0x3f5d, 0x3f5e, 0x3f5f,
135 0x3f60, 0x3f61, 0x3f62, 0x3f63, 0x3f64, 0x3f65, 0x3f66, 0x3f67,
136 0x3f68, 0x3f69, 0x3f6a, 0x3f6b, 0x3f6c, 0x3f6d, 0x3f6e, 0x3f6f,
137 0x3f70, 0x3f71, 0x3f72, 0x3f73, 0x3f74, 0x3f75, 0x3f76, 0x3f77,
138 0x3f78, 0x3f79, 0x3f7a, 0x3f7b, 0x3f7c, 0x3f7d, 0x3f7e, 0x3f7f,
141 static const uint8_t rv_chrom_bits[256] =
143 16, 14, 14, 14, 14, 14, 14, 14,
144 14, 14, 14, 14, 14, 14, 14, 14,
145 14, 14, 14, 14, 14, 14, 14, 14,
146 14, 14, 14, 14, 14, 14, 14, 14,
147 14, 14, 14, 14, 14, 14, 14, 14,
148 14, 14, 14, 14, 14, 14, 14, 14,
149 14, 14, 14, 14, 14, 14, 14, 14,
150 14, 14, 14, 14, 14, 14, 14, 14,
151 14, 12, 12, 12, 12, 12, 12, 12,
152 12, 12, 12, 12, 12, 12, 12, 12,
153 12, 12, 12, 12, 12, 12, 12, 12,
154 12, 12, 12, 12, 12, 12, 12, 12,
155 12, 10, 10, 10, 10, 10, 10, 10,
156 10, 10, 10, 10, 10, 10, 10, 10,
157 10, 8, 8, 8, 8, 8, 8, 8,
158 8, 6, 6, 6, 6, 4, 4, 3,
159 2, 3, 4, 4, 6, 6, 6, 6,
160 8, 8, 8, 8, 8, 8, 8, 8,
161 10, 10, 10, 10, 10, 10, 10, 10,
162 10, 10, 10, 10, 10, 10, 10, 10,
163 12, 12, 12, 12, 12, 12, 12, 12,
164 12, 12, 12, 12, 12, 12, 12, 12,
165 12, 12, 12, 12, 12, 12, 12, 12,
166 12, 12, 12, 12, 12, 12, 12, 12,
167 14, 14, 14, 14, 14, 14, 14, 14,
168 14, 14, 14, 14, 14, 14, 14, 14,
169 14, 14, 14, 14, 14, 14, 14, 14,
170 14, 14, 14, 14, 14, 14, 14, 14,
171 14, 14, 14, 14, 14, 14, 14, 14,
172 14, 14, 14, 14, 14, 14, 14, 14,
173 14, 14, 14, 14, 14, 14, 14, 14,
174 14, 14, 14, 14, 14, 14, 14, 14,
177 static VLC rv_dc_lum, rv_dc_chrom;
179 int rv_decode_dc(MpegEncContext *s, int n)
184 code = get_vlc2(&s->gb, rv_dc_lum.table, DC_VLC_BITS, 2);
186 /* XXX: I don't understand why they use LONGER codes than
187 necessary. The following code would be completely useless
188 if they had thought about it !!! */
189 code = get_bits(&s->gb, 7);
191 code = (int8_t)(get_bits(&s->gb, 7) + 1);
192 } else if (code == 0x7d) {
193 code = -128 + get_bits(&s->gb, 7);
194 } else if (code == 0x7e) {
195 if (get_bits(&s->gb, 1) == 0)
196 code = (int8_t)(get_bits(&s->gb, 8) + 1);
198 code = (int8_t)(get_bits(&s->gb, 8));
199 } else if (code == 0x7f) {
200 get_bits(&s->gb, 11);
207 code = get_vlc2(&s->gb, rv_dc_chrom.table, DC_VLC_BITS, 2);
210 code = get_bits(&s->gb, 9);
212 code = (int8_t)(get_bits(&s->gb, 7) + 1);
213 } else if (code == 0x1fd) {
214 code = -128 + get_bits(&s->gb, 7);
215 } else if (code == 0x1fe) {
219 av_log(s->avctx, AV_LOG_ERROR, "chroma dc error\n");
229 #ifdef CONFIG_ENCODERS
231 /* write RV 1.0 compatible frame header */
232 void rv10_encode_picture_header(MpegEncContext *s, int picture_number)
236 align_put_bits(&s->pb);
238 put_bits(&s->pb, 1, 1); /* marker */
240 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
242 put_bits(&s->pb, 1, 0); /* not PB frame */
244 put_bits(&s->pb, 5, s->qscale);
246 if (s->pict_type == I_TYPE) {
247 /* specific MPEG like DC coding not used */
249 /* if multiple packets per frame are sent, the position at which
250 to display the macro blocks is coded here */
252 put_bits(&s->pb, 6, 0); /* mb_x */
253 put_bits(&s->pb, 6, 0); /* mb_y */
254 put_bits(&s->pb, 12, s->mb_width * s->mb_height);
257 put_bits(&s->pb, 3, 0); /* ignored */
260 static int get_num(GetBitContext *gb)
264 n = get_bits(gb, 16);
268 n1 = get_bits(gb, 16);
269 return (n << 16) | n1;
273 #endif //CONFIG_ENCODERS
275 /* read RV 1.0 compatible frame header */
276 static int rv10_decode_picture_header(MpegEncContext *s)
278 int mb_count, pb_frame, marker, full_frame, unk;
280 full_frame= s->avctx->slice_count==1;
281 //printf("ff:%d\n", full_frame);
282 marker = get_bits(&s->gb, 1);
284 if (get_bits(&s->gb, 1))
285 s->pict_type = P_TYPE;
287 s->pict_type = I_TYPE;
288 //printf("h:%X ver:%d\n",h,s->rv10_version);
289 if(!marker) av_log(s->avctx, AV_LOG_ERROR, "marker missing\n");
290 pb_frame = get_bits(&s->gb, 1);
293 printf("pict_type=%d pb_frame=%d\n", s->pict_type, pb_frame);
297 av_log(s->avctx, AV_LOG_ERROR, "pb frame not supported\n");
301 s->qscale = get_bits(&s->gb, 5);
303 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
307 if (s->pict_type == I_TYPE) {
308 if (s->rv10_version == 3) {
309 /* specific MPEG like DC coding not used */
310 s->last_dc[0] = get_bits(&s->gb, 8);
311 s->last_dc[1] = get_bits(&s->gb, 8);
312 s->last_dc[2] = get_bits(&s->gb, 8);
314 printf("DC:%d %d %d\n",
321 /* if multiple packets per frame are sent, the position at which
322 to display the macro blocks is coded here */
323 if ((!full_frame) || show_bits(&s->gb, 12)==0) {
324 s->mb_x = get_bits(&s->gb, 6); /* mb_x */
325 s->mb_y = get_bits(&s->gb, 6); /* mb_y */
326 mb_count = get_bits(&s->gb, 12);
330 mb_count = s->mb_width * s->mb_height;
332 unk= get_bits(&s->gb, 3); /* ignored */
333 //printf("%d\n", unk);
335 s->unrestricted_mv = 1;
340 static int rv20_decode_picture_header(MpegEncContext *s)
344 if(s->avctx->sub_id == 0x30202002 || s->avctx->sub_id == 0x30203002){
345 if (get_bits(&s->gb, 3)){
346 av_log(s->avctx, AV_LOG_ERROR, "unknown triplet set\n");
351 i= get_bits(&s->gb, 2);
353 case 0: s->pict_type= I_TYPE; break;
354 case 1: s->pict_type= I_TYPE; break; //hmm ...
355 case 2: s->pict_type= P_TYPE; break;
356 case 3: s->pict_type= B_TYPE; break;
358 av_log(s->avctx, AV_LOG_ERROR, "unknown frame type\n");
362 if (get_bits(&s->gb, 1)){
363 av_log(s->avctx, AV_LOG_ERROR, "unknown bit set\n");
367 s->qscale = get_bits(&s->gb, 5);
369 av_log(s->avctx, AV_LOG_ERROR, "error, qscale:0\n");
372 if(s->avctx->sub_id == 0x30203002){
373 if (get_bits(&s->gb, 1)){
374 av_log(s->avctx, AV_LOG_ERROR, "unknown bit2 set\n");
379 if(s->avctx->has_b_frames){
380 if (get_bits(&s->gb, 1)){
381 // av_log(s->avctx, AV_LOG_ERROR, "unknown bit3 set\n");
384 seq= get_bits(&s->gb, 15);
385 mb_pos= get_bits(&s->gb, av_log2(s->mb_num-1)+1);
386 s->mb_x= mb_pos % s->mb_width;
387 s->mb_y= mb_pos / s->mb_width;
389 seq= get_bits(&s->gb, 8)*128;
390 mb_pos= ff_h263_decode_mba(s);
392 //printf("%d\n", seq);
393 seq |= s->time &~0x7FFF;
394 if(seq - s->time > 0x4000) seq -= 0x8000;
395 if(seq - s->time < -0x4000) seq += 0x8000;
397 if(s->pict_type!=B_TYPE){
399 s->pp_time= s->time - s->last_non_b_time;
400 s->last_non_b_time= s->time;
403 s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
404 if(s->pp_time <=s->pb_time || s->pp_time <= s->pp_time - s->pb_time || s->pp_time<=0){
405 printf("messed up order, seeking?, skiping current b frame\n");
410 // printf("%d %d %d %d %d\n", seq, (int)s->time, (int)s->last_non_b_time, s->pp_time, s->pb_time);
412 s->no_rounding= get_bits1(&s->gb);
415 s->unrestricted_mv = 1;
416 s->h263_aic= s->pict_type == I_TYPE;
417 // s->alt_inter_vlc=1;
423 if(s->avctx->debug & FF_DEBUG_PICT_INFO){
424 av_log(s->avctx, AV_LOG_INFO, "num:%5d x:%2d y:%2d type:%d qscale:%2d rnd:%d\n",
425 seq, s->mb_x, s->mb_y, s->pict_type, s->qscale, s->no_rounding);
428 assert(s->pict_type != B_TYPE || !s->low_delay);
430 return s->mb_width*s->mb_height - mb_pos;
433 static int rv10_decode_init(AVCodecContext *avctx)
435 MpegEncContext *s = avctx->priv_data;
439 s->out_format = FMT_H263;
440 s->codec_id= avctx->codec_id;
442 s->width = avctx->width;
443 s->height = avctx->height;
445 switch(avctx->sub_id){
448 s->h263_long_vectors=0;
453 s->h263_long_vectors=1;
458 s->h263_long_vectors=0;
470 s->avctx->has_b_frames=1;
473 av_log(s->avctx, AV_LOG_ERROR, "unknown header %X\n", avctx->sub_id);
475 //printf("ver:%X\n", avctx->sub_id);
476 s->flags= avctx->flags;
478 if (MPV_common_init(s) < 0)
481 h263_decode_init_vlc(s);
483 s->progressive_sequence=1;
487 init_vlc(&rv_dc_lum, DC_VLC_BITS, 256,
490 init_vlc(&rv_dc_chrom, DC_VLC_BITS, 256,
492 rv_chrom_code, 2, 2);
496 avctx->pix_fmt = PIX_FMT_YUV420P;
501 static int rv10_decode_end(AVCodecContext *avctx)
503 MpegEncContext *s = avctx->priv_data;
509 static int rv10_decode_packet(AVCodecContext *avctx,
510 uint8_t *buf, int buf_size)
512 MpegEncContext *s = avctx->priv_data;
513 int i, mb_count, mb_pos, left;
515 init_get_bits(&s->gb, buf, buf_size*8);
517 for(i=0; i<buf_size*8 && i<200; i++)
518 printf("%d", get_bits1(&s->gb));
522 if(s->codec_id ==CODEC_ID_RV10)
523 mb_count = rv10_decode_picture_header(s);
525 mb_count = rv20_decode_picture_header(s);
527 av_log(s->avctx, AV_LOG_ERROR, "HEADER ERROR\n");
531 if (s->mb_x >= s->mb_width ||
532 s->mb_y >= s->mb_height) {
533 av_log(s->avctx, AV_LOG_ERROR, "POS ERROR %d %d\n", s->mb_x, s->mb_y);
536 mb_pos = s->mb_y * s->mb_width + s->mb_x;
537 left = s->mb_width * s->mb_height - mb_pos;
538 if (mb_count > left) {
539 av_log(s->avctx, AV_LOG_ERROR, "COUNT ERROR\n");
542 //if(s->pict_type == P_TYPE) return 0;
544 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) {
545 if(MPV_frame_start(s, avctx) < 0)
550 printf("qscale=%d\n", s->qscale);
553 /* default quantization values */
554 if(s->codec_id== CODEC_ID_RV10){
555 if(s->mb_y==0) s->first_slice_line=1;
557 s->first_slice_line=1;
558 s->resync_mb_x= s->mb_x;
559 s->resync_mb_y= s->mb_y;
563 s->c_dc_scale_table= ff_aic_dc_scale_table;
566 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
569 if(s->modified_quant)
570 s->chroma_qscale_table= ff_h263_chroma_qscale_table;
572 ff_set_qscale(s, s->qscale);
574 s->rv10_first_dc_coded[0] = 0;
575 s->rv10_first_dc_coded[1] = 0;
576 s->rv10_first_dc_coded[2] = 0;
581 s->block_wrap[3]= s->mb_width*2 + 2;
583 s->block_wrap[5]= s->mb_width + 2;
584 ff_init_block_index(s);
585 /* decode each macroblock */
586 for(i=0;i<mb_count;i++) {
588 ff_update_block_index(s);
590 printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
593 s->dsp.clear_blocks(s->block[0]);
594 s->mv_dir = MV_DIR_FORWARD;
595 s->mv_type = MV_TYPE_16X16;
596 ret=ff_h263_decode_mb(s, s->block);
598 if (ret == SLICE_ERROR) {
599 av_log(s->avctx, AV_LOG_ERROR, "ERROR at MB %d %d\n", s->mb_x, s->mb_y);
602 ff_h263_update_motion_val(s);
603 MPV_decode_mb(s, s->block);
605 ff_h263_loop_filter(s);
607 if (++s->mb_x == s->mb_width) {
610 ff_init_block_index(s);
612 if(s->mb_x == s->resync_mb_x)
613 s->first_slice_line=0;
614 if(ret == SLICE_END) break;
620 static int rv10_decode_frame(AVCodecContext *avctx,
621 void *data, int *data_size,
622 uint8_t *buf, int buf_size)
624 MpegEncContext *s = avctx->priv_data;
626 AVFrame *pict = data;
629 printf("*****frame %d size=%d\n", avctx->frame_number, buf_size);
632 /* no supplementary picture */
638 if(avctx->slice_count){
639 for(i=0; i<avctx->slice_count; i++){
640 int offset= avctx->slice_offset[i];
643 if(i+1 == avctx->slice_count)
644 size= buf_size - offset;
646 size= avctx->slice_offset[i+1] - offset;
648 if( rv10_decode_packet(avctx, buf+offset, size) < 0 )
652 if( rv10_decode_packet(avctx, buf, buf_size) < 0 )
656 if(s->pict_type == B_TYPE){ //FIXME remove after cleaning mottion_val indexing
657 memset(s->current_picture.motion_val[0], 0, sizeof(int16_t)*2*(s->mb_width*2+2)*(s->mb_height*2+2));
660 if(s->mb_y>=s->mb_height){
663 if(s->pict_type==B_TYPE || s->low_delay){
664 *pict= *(AVFrame*)&s->current_picture;
665 ff_print_debug_info(s, s->current_picture_ptr);
667 *pict= *(AVFrame*)&s->last_picture;
668 ff_print_debug_info(s, s->last_picture_ptr);
671 *data_size = sizeof(AVFrame);
679 AVCodec rv10_decoder = {
683 sizeof(MpegEncContext),
691 AVCodec rv20_decoder = {
695 sizeof(MpegEncContext),