Work around gcc stupidity: With -MM gcc outputs just the basename of files as
[libav.git] / libavcodec / svq3.c
CommitLineData
8b82a956
MN
1/*
2 * Copyright (c) 2003 The FFmpeg Project.
3 *
b78e7197
DB
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
8b82a956
MN
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
b78e7197 9 * version 2.1 of the License, or (at your option) any later version.
8b82a956 10 *
b78e7197 11 * FFmpeg is distributed in the hope that it will be useful,
8b82a956
MN
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
b78e7197 17 * License along with FFmpeg; if not, write to the Free Software
5509bffa 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
e5a389a1
DB
19 */
20
21/*
8b82a956
MN
22 * How to use this decoder:
23 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
89a79364
MM
24 * have stsd atoms to describe media trak properties. A stsd atom for a
25 * video trak contains 1 or more ImageDescription atoms. These atoms begin
26 * with the 4-byte length of the atom followed by the codec fourcc. Some
27 * decoders need information in this atom to operate correctly. Such
28 * is the case with SVQ3. In order to get the best use out of this decoder,
29 * the calling app must make the SVQ3 ImageDescription atom available
8b82a956
MN
30 * via the AVCodecContext's extradata[_size] field:
31 *
115329f1 32 * AVCodecContext.extradata = pointer to ImageDescription, first characters
89a79364 33 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
115329f1
DB
34 * AVCodecContext.extradata_size = size of ImageDescription atom memory
35 * buffer (which will be the same as the ImageDescription atom size field
89a79364
MM
36 * from the QT file, minus 4 bytes since the length is missing)
37 *
38 * You will know you have these parameters passed correctly when the decoder
39 * correctly decodes this file:
40 * ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
8b82a956 41 */
115329f1 42
8b82a956
MN
43/**
44 * @file svq3.c
45 * svq3 decoder.
46 */
47
115329f1
DB
48#define FULLPEL_MODE 1
49#define HALFPEL_MODE 2
94d44f45 50#define THIRDPEL_MODE 3
2e26c8d2 51#define PREDICT_MODE 4
115329f1 52
f7a8c179
MN
53/* dual scan (from some older h264 draft)
54 o-->o-->o o
55 | /|
56 o o o / o
57 | / | |/ |
58 o o o o
115329f1 59 /
f7a8c179
MN
60 o-->o-->o-->o
61*/
8b82a956
MN
62static const uint8_t svq3_scan[16]={
63 0+0*4, 1+0*4, 2+0*4, 2+1*4,
64 2+2*4, 3+0*4, 3+1*4, 3+2*4,
65 0+1*4, 0+2*4, 1+1*4, 1+2*4,
66 0+3*4, 1+3*4, 2+3*4, 3+3*4,
67};
68
69static const uint8_t svq3_pred_0[25][2] = {
70 { 0, 0 },
71 { 1, 0 }, { 0, 1 },
72 { 0, 2 }, { 1, 1 }, { 2, 0 },
73 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
74 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
75 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
76 { 2, 4 }, { 3, 3 }, { 4, 2 },
77 { 4, 3 }, { 3, 4 },
78 { 4, 4 }
79};
80
81static const int8_t svq3_pred_1[6][6][5] = {
82 { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
83 { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
84 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
85 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
86 { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
87 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
88 { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
89 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
90 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
91 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
92 { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
93 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
94};
95
96static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
97 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
98 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
99 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
100 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
101};
102
103static const uint32_t svq3_dequant_coeff[32] = {
104 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
105 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
106 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
107 61694, 68745, 77615, 89113,100253,109366,126635,141533
108};
109
110
111static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp){
112 const int qmul= svq3_dequant_coeff[qp];
113#define stride 16
114 int i;
115 int temp[16];
116 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride};
117 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
118
119 for(i=0; i<4; i++){
120 const int offset= y_offset[i];
121 const int z0= 13*(block[offset+stride*0] + block[offset+stride*4]);
122 const int z1= 13*(block[offset+stride*0] - block[offset+stride*4]);
123 const int z2= 7* block[offset+stride*1] - 17*block[offset+stride*5];
124 const int z3= 17* block[offset+stride*1] + 7*block[offset+stride*5];
125
126 temp[4*i+0]= z0+z3;
127 temp[4*i+1]= z1+z2;
128 temp[4*i+2]= z1-z2;
129 temp[4*i+3]= z0-z3;
130 }
131
132 for(i=0; i<4; i++){
133 const int offset= x_offset[i];
134 const int z0= 13*(temp[4*0+i] + temp[4*2+i]);
135 const int z1= 13*(temp[4*0+i] - temp[4*2+i]);
136 const int z2= 7* temp[4*1+i] - 17*temp[4*3+i];
137 const int z3= 17* temp[4*1+i] + 7*temp[4*3+i];
138
139 block[stride*0 +offset]= ((z0 + z3)*qmul + 0x80000)>>20;
140 block[stride*2 +offset]= ((z1 + z2)*qmul + 0x80000)>>20;
141 block[stride*8 +offset]= ((z1 - z2)*qmul + 0x80000)>>20;
142 block[stride*10+offset]= ((z0 - z3)*qmul + 0x80000)>>20;
143 }
144}
145#undef stride
146
147static void svq3_add_idct_c (uint8_t *dst, DCTELEM *block, int stride, int qp, int dc){
148 const int qmul= svq3_dequant_coeff[qp];
149 int i;
55fde95e 150 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
8b82a956
MN
151
152 if (dc) {
153 dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
154 block[0] = 0;
155 }
156
157 for (i=0; i < 4; i++) {
158 const int z0= 13*(block[0 + 4*i] + block[2 + 4*i]);
159 const int z1= 13*(block[0 + 4*i] - block[2 + 4*i]);
160 const int z2= 7* block[1 + 4*i] - 17*block[3 + 4*i];
161 const int z3= 17* block[1 + 4*i] + 7*block[3 + 4*i];
162
163 block[0 + 4*i]= z0 + z3;
164 block[1 + 4*i]= z1 + z2;
165 block[2 + 4*i]= z1 - z2;
166 block[3 + 4*i]= z0 - z3;
167 }
168
169 for (i=0; i < 4; i++) {
170 const int z0= 13*(block[i + 4*0] + block[i + 4*2]);
171 const int z1= 13*(block[i + 4*0] - block[i + 4*2]);
172 const int z2= 7* block[i + 4*1] - 17*block[i + 4*3];
173 const int z3= 17* block[i + 4*1] + 7*block[i + 4*3];
174 const int rr= (dc + 0x80000);
175
176 dst[i + stride*0]= cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
177 dst[i + stride*1]= cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
178 dst[i + stride*2]= cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
179 dst[i + stride*3]= cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
180 }
181}
182
8b82a956 183static inline int svq3_decode_block (GetBitContext *gb, DCTELEM *block,
bb270c08 184 int index, const int type) {
8b82a956
MN
185
186 static const uint8_t *const scan_patterns[4] =
187 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
188
189 int run, level, sign, vlc, limit;
190 const int intra = (3 * type) >> 2;
191 const uint8_t *const scan = scan_patterns[type];
192
193 for (limit=(16 >> intra); index < 16; index=limit, limit+=8) {
194 for (; (vlc = svq3_get_ue_golomb (gb)) != 0; index++) {
195
196 if (vlc == INVALID_VLC)
bb270c08 197 return -1;
8b82a956
MN
198
199 sign = (vlc & 0x1) - 1;
200 vlc = (vlc + 1) >> 1;
201
202 if (type == 3) {
bb270c08
DB
203 if (vlc < 3) {
204 run = 0;
205 level = vlc;
206 } else if (vlc < 4) {
207 run = 1;
208 level = 1;
209 } else {
210 run = (vlc & 0x3);
211 level = ((vlc + 9) >> 2) - run;
212 }
8b82a956 213 } else {
bb270c08
DB
214 if (vlc < 16) {
215 run = svq3_dct_tables[intra][vlc].run;
216 level = svq3_dct_tables[intra][vlc].level;
217 } else if (intra) {
218 run = (vlc & 0x7);
219 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
220 } else {
221 run = (vlc & 0xF);
222 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
223 }
8b82a956
MN
224 }
225
226 if ((index += run) >= limit)
bb270c08 227 return -1;
8b82a956
MN
228
229 block[scan[index]] = (level ^ sign) - sign;
230 }
231
232 if (type != 2) {
233 break;
234 }
235 }
236
237 return 0;
238}
239
da3b9756 240static inline void svq3_mc_dir_part (MpegEncContext *s,
bb270c08
DB
241 int x, int y, int width, int height,
242 int mx, int my, int dxy,
243 int thirdpel, int dir, int avg) {
da3b9756
MM
244
245 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
8b82a956
MN
246 uint8_t *src, *dest;
247 int i, emu = 0;
669ac79c 248 int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2
8b82a956 249
94d44f45
MN
250 mx += x;
251 my += y;
115329f1 252
4c701ac8
MN
253 if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
254 my < 0 || my >= (s->v_edge_pos - height - 1)) {
8b82a956
MN
255
256 if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
257 emu = 1;
258 }
259
f66e4f5f
RD
260 mx = av_clip (mx, -16, (s->h_edge_pos - width + 15));
261 my = av_clip (my, -16, (s->v_edge_pos - height + 15));
8b82a956
MN
262 }
263
264 /* form component predictions */
265 dest = s->current_picture.data[0] + x + y*s->linesize;
da3b9756 266 src = pic->data[0] + mx + my*s->linesize;
8b82a956
MN
267
268 if (emu) {
a7d3e772 269 ff_emulated_edge_mc (s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
bb270c08 270 mx, my, s->h_edge_pos, s->v_edge_pos);
8b82a956
MN
271 src = s->edge_emu_buffer;
272 }
669ac79c 273 if(thirdpel)
da3b9756 274 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
669ac79c 275 else
da3b9756 276 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
8b82a956
MN
277
278 if (!(s->flags & CODEC_FLAG_GRAY)) {
bb270c08
DB
279 mx = (mx + (mx < (int) x)) >> 1;
280 my = (my + (my < (int) y)) >> 1;
8b82a956
MN
281 width = (width >> 1);
282 height = (height >> 1);
669ac79c 283 blocksize++;
8b82a956
MN
284
285 for (i=1; i < 3; i++) {
286 dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
da3b9756 287 src = pic->data[i] + mx + my*s->uvlinesize;
8b82a956
MN
288
289 if (emu) {
a7d3e772 290 ff_emulated_edge_mc (s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
bb270c08 291 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
a7d3e772 292 src = s->edge_emu_buffer;
8b82a956 293 }
669ac79c 294 if(thirdpel)
da3b9756 295 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
669ac79c 296 else
da3b9756 297 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
8b82a956
MN
298 }
299 }
300}
301
2e26c8d2
MM
302static inline int svq3_mc_dir (H264Context *h, int size, int mode, int dir, int avg) {
303
304 int i, j, k, mx, my, dx, dy, x, y;
305 MpegEncContext *const s = (MpegEncContext *) h;
306 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
307 const int part_height = 16 >> ((unsigned) (size + 1) / 3);
308 const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
309 const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width;
310 const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width;
311
312 for (i=0; i < 16; i+=part_height) {
313 for (j=0; j < 16; j+=part_width) {
314 const int b_xy = (4*s->mb_x+(j>>2)) + (4*s->mb_y+(i>>2))*h->b_stride;
315 int dxy;
316 x = 16*s->mb_x + j;
317 y = 16*s->mb_y + i;
318 k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8);
319
320 if (mode != PREDICT_MODE) {
bb270c08 321 pred_motion (h, k, (part_width >> 2), dir, 1, &mx, &my);
2e26c8d2 322 } else {
bb270c08
DB
323 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
324 my = s->next_picture.motion_val[0][b_xy][1]<<1;
325
326 if (dir == 0) {
327 mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
328 my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1)>>1;
329 } else {
330 mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
331 my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1)>>1;
332 }
2e26c8d2
MM
333 }
334
335 /* clip motion vector prediction to frame border */
f66e4f5f
RD
336 mx = av_clip (mx, extra_width - 6*x, h_edge_pos - 6*x);
337 my = av_clip (my, extra_width - 6*y, v_edge_pos - 6*y);
2e26c8d2
MM
338
339 /* get (optional) motion vector differential */
340 if (mode == PREDICT_MODE) {
bb270c08 341 dx = dy = 0;
2e26c8d2 342 } else {
bb270c08
DB
343 dy = svq3_get_se_golomb (&s->gb);
344 dx = svq3_get_se_golomb (&s->gb);
2e26c8d2 345
bb270c08 346 if (dx == INVALID_VLC || dy == INVALID_VLC) {
884182b3 347 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
bb270c08
DB
348 return -1;
349 }
2e26c8d2
MM
350 }
351
352 /* compute motion vector */
353 if (mode == THIRDPEL_MODE) {
bb270c08
DB
354 int fx, fy;
355 mx = ((mx + 1)>>1) + dx;
356 my = ((my + 1)>>1) + dy;
357 fx= ((unsigned)(mx + 0x3000))/3 - 0x1000;
358 fy= ((unsigned)(my + 0x3000))/3 - 0x1000;
359 dxy= (mx - 3*fx) + 4*(my - 3*fy);
360
361 svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
362 mx += mx;
363 my += my;
2e26c8d2 364 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
bb270c08
DB
365 mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
366 my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
367 dxy= (mx&1) + 2*(my&1);
2e26c8d2 368
bb270c08
DB
369 svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
370 mx *= 3;
371 my *= 3;
2e26c8d2 372 } else {
bb270c08
DB
373 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
374 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
2e26c8d2 375
bb270c08
DB
376 svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
377 mx *= 6;
378 my *= 6;
2e26c8d2
MM
379 }
380
381 /* update mv_cache */
382 if (mode != PREDICT_MODE) {
bb270c08
DB
383 int32_t mv = pack16to32(mx,my);
384
385 if (part_height == 8 && i < 8) {
386 *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
387
388 if (part_width == 8 && j < 8) {
389 *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
390 }
391 }
392 if (part_width == 8 && j < 8) {
393 *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
394 }
395 if (part_width == 4 || part_height == 4) {
396 *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
397 }
2e26c8d2
MM
398 }
399
400 /* write back motion vectors */
401 fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
402 }
403 }
404
405 return 0;
406}
407
8b82a956 408static int svq3_decode_mb (H264Context *h, unsigned int mb_type) {
2e26c8d2
MM
409 int i, j, k, m, dir, mode;
410 int cbp = 0;
8b82a956
MN
411 uint32_t vlc;
412 int8_t *top, *left;
413 MpegEncContext *const s = (MpegEncContext *) h;
414 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
415 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
416
bb270c08
DB
417 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
418 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
419 h->topright_samples_available = 0xFFFF;
8b82a956 420
bb270c08 421 if (mb_type == 0) { /* SKIP */
2e26c8d2 422 if (s->pict_type == P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
da3b9756
MM
423 svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
424
2e26c8d2 425 if (s->pict_type == B_TYPE) {
bb270c08 426 svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
da3b9756 427 }
8b82a956 428
2e26c8d2
MM
429 mb_type = MB_TYPE_SKIP;
430 } else {
cbf5374f
MN
431 mb_type= FFMIN(s->next_picture.mb_type[mb_xy], 6);
432 if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 0, 0) < 0)
433 return -1;
434 if(svq3_mc_dir (h, mb_type, PREDICT_MODE, 1, 1) < 0)
435 return -1;
da3b9756 436
da3b9756
MM
437 mb_type = MB_TYPE_16x16;
438 }
bb270c08 439 } else if (mb_type < 8) { /* INTER */
5fc32c27 440 if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
94d44f45 441 mode = THIRDPEL_MODE;
5fc32c27 442 } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
94d44f45 443 mode = HALFPEL_MODE;
8b82a956 444 } else {
94d44f45 445 mode = FULLPEL_MODE;
8b82a956
MN
446 }
447
448 /* fill caches */
da3b9756 449 /* note ref_cache should contain here:
f7a8c179
MN
450 ????????
451 ???11111
452 N??11111
453 N??11111
454 N??11111
f7a8c179 455 */
115329f1 456
da3b9756
MM
457 for (m=0; m < 2; m++) {
458 if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
bb270c08
DB
459 for (i=0; i < 4; i++) {
460 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - 1 + i*h->b_stride];
461 }
da3b9756 462 } else {
bb270c08
DB
463 for (i=0; i < 4; i++) {
464 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
465 }
8b82a956 466 }
da3b9756 467 if (s->mb_y > 0) {
bb270c08
DB
468 memcpy (h->mv_cache[m][scan8[0] - 1*8], s->current_picture.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
469 memset (&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1, 4);
470
471 if (s->mb_x < (s->mb_width - 1)) {
472 *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride + 4];
473 h->ref_cache[m][scan8[0] + 4 - 1*8] =
474 (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
475 h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1;
476 }else
477 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
478 if (s->mb_x > 0) {
479 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride - 1];
480 h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] == -1) ? PART_NOT_AVAILABLE : 1;
481 }else
482 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
f7a8c179 483 }else
bb270c08 484 memset (&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
da3b9756
MM
485
486 if (s->pict_type != B_TYPE)
bb270c08 487 break;
da3b9756 488 }
8b82a956
MN
489
490 /* decode motion vector(s) and form prediction(s) */
da3b9756 491 if (s->pict_type == P_TYPE) {
cbf5374f
MN
492 if(svq3_mc_dir (h, (mb_type - 1), mode, 0, 0) < 0)
493 return -1;
bb270c08 494 } else { /* B_TYPE */
2e26c8d2 495 if (mb_type != 2) {
bb270c08 496 if(svq3_mc_dir (h, 0, mode, 0, 0) < 0)
cbf5374f 497 return -1;
2e26c8d2 498 } else {
bb270c08
DB
499 for (i=0; i < 4; i++) {
500 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
501 }
da3b9756 502 }
da3b9756 503 if (mb_type != 1) {
bb270c08 504 if(svq3_mc_dir (h, 0, mode, 1, (mb_type == 3)) < 0)
cbf5374f 505 return -1;
da3b9756 506 } else {
bb270c08
DB
507 for (i=0; i < 4; i++) {
508 memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
509 }
da3b9756 510 }
8b82a956
MN
511 }
512
8b82a956 513 mb_type = MB_TYPE_16x16;
bb270c08 514 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
8b82a956
MN
515 memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
516
da3b9756
MM
517 if (mb_type == 8) {
518 if (s->mb_x > 0) {
bb270c08
DB
519 for (i=0; i < 4; i++) {
520 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
521 }
522 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
523 h->left_samples_available = 0x5F5F;
524 }
da3b9756
MM
525 }
526 if (s->mb_y > 0) {
bb270c08
DB
527 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
528 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
529 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
530 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
531
532 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
533 h->top_samples_available = 0x33FF;
534 }
8b82a956 535 }
8b82a956 536
da3b9756
MM
537 /* decode prediction codes for luma blocks */
538 for (i=0; i < 16; i+=2) {
bb270c08 539 vlc = svq3_get_ue_golomb (&s->gb);
8b82a956 540
bb270c08 541 if (vlc >= 25){
884182b3 542 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
bb270c08 543 return -1;
884182b3 544 }
8b82a956 545
bb270c08
DB
546 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
547 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
8b82a956 548
bb270c08
DB
549 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
550 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
8b82a956 551
bb270c08 552 if (left[1] == -1 || left[2] == -1){
884182b3 553 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
bb270c08 554 return -1;
884182b3 555 }
da3b9756 556 }
bb270c08 557 } else { /* mb_type == 33, DC_128_PRED block type */
da3b9756 558 for (i=0; i < 4; i++) {
bb270c08 559 memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
da3b9756 560 }
8b82a956
MN
561 }
562
563 write_back_intra_pred_mode (h);
da3b9756
MM
564
565 if (mb_type == 8) {
566 check_intra4x4_pred_mode (h);
567
568 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
569 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
570 } else {
571 for (i=0; i < 4; i++) {
572 memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
573 }
574
575 h->top_samples_available = 0x33FF;
576 h->left_samples_available = 0x5F5F;
577 }
8b82a956 578
8b82a956 579 mb_type = MB_TYPE_INTRA4x4;
bb270c08 580 } else { /* INTRA16x16 */
8b82a956
MN
581 dir = i_mb_type_info[mb_type - 8].pred_mode;
582 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
583
884182b3
MN
584 if ((h->intra16x16_pred_mode = check_intra_pred_mode (h, dir)) == -1){
585 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
8b82a956 586 return -1;
884182b3 587 }
8b82a956
MN
588
589 cbp = i_mb_type_info[mb_type - 8].cbp;
590 mb_type = MB_TYPE_INTRA16x16;
591 }
592
593 if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) {
594 for (i=0; i < 4; i++) {
595 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
596 }
da3b9756
MM
597 if (s->pict_type == B_TYPE) {
598 for (i=0; i < 4; i++) {
bb270c08 599 memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
da3b9756
MM
600 }
601 }
8b82a956
MN
602 }
603 if (!IS_INTRA4x4(mb_type)) {
604 memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
605 }
2e26c8d2 606 if (!IS_SKIP(mb_type) || s->pict_type == B_TYPE) {
f7a8c179
MN
607 memset (h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
608 s->dsp.clear_blocks(h->mb);
8b82a956
MN
609 }
610
2e26c8d2 611 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == B_TYPE)) {
884182b3
MN
612 if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48){
613 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
2e26c8d2 614 return -1;
884182b3 615 }
2e26c8d2
MM
616
617 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
618 }
8b82a956
MN
619 if (IS_INTRA16x16(mb_type) || (s->pict_type != I_TYPE && s->adaptive_quant && cbp)) {
620 s->qscale += svq3_get_se_golomb (&s->gb);
621
884182b3
MN
622 if (s->qscale > 31){
623 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
8b82a956 624 return -1;
884182b3 625 }
8b82a956
MN
626 }
627 if (IS_INTRA16x16(mb_type)) {
884182b3
MN
628 if (svq3_decode_block (&s->gb, h->mb, 0, 0)){
629 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
8b82a956 630 return -1;
884182b3 631 }
8b82a956
MN
632 }
633
2e26c8d2
MM
634 if (cbp) {
635 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
636 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
8b82a956
MN
637
638 for (i=0; i < 4; i++) {
639 if ((cbp & (1 << i))) {
bb270c08
DB
640 for (j=0; j < 4; j++) {
641 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
642 h->non_zero_count_cache[ scan8[k] ] = 1;
8b82a956 643
bb270c08 644 if (svq3_decode_block (&s->gb, &h->mb[16*k], index, type)){
884182b3 645 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
bb270c08 646 return -1;
884182b3 647 }
bb270c08 648 }
8b82a956
MN
649 }
650 }
651
652 if ((cbp & 0x30)) {
653 for (i=0; i < 2; ++i) {
bb270c08 654 if (svq3_decode_block (&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
884182b3 655 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
bb270c08 656 return -1;
884182b3 657 }
8b82a956
MN
658 }
659
660 if ((cbp & 0x20)) {
bb270c08
DB
661 for (i=0; i < 8; i++) {
662 h->non_zero_count_cache[ scan8[16+i] ] = 1;
8b82a956 663
bb270c08 664 if (svq3_decode_block (&s->gb, &h->mb[16*(16 + i)], 1, 1)){
884182b3 665 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
bb270c08 666 return -1;
884182b3 667 }
bb270c08 668 }
8b82a956
MN
669 }
670 }
671 }
672
673 s->current_picture.mb_type[mb_xy] = mb_type;
674
675 if (IS_INTRA(mb_type)) {
676 h->chroma_pred_mode = check_intra_pred_mode (h, DC_PRED8x8);
677 }
678
679 return 0;
680}
681
da3b9756
MM
682static int svq3_decode_slice_header (H264Context *h) {
683 MpegEncContext *const s = (MpegEncContext *) h;
684 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
685 int i, header;
686
687 header = get_bits (&s->gb, 8);
688
689 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
690 /* TODO: what? */
9b879566 691 av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
da3b9756
MM
692 return -1;
693 } else {
694 int length = (header >> 5) & 3;
695
5bb8a0da 696 h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits (&s->gb, 8*length) + 8*length;
da3b9756 697
303e50e6
MN
698 if (h->next_slice_index > s->gb.size_in_bits){
699 av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
da3b9756 700 return -1;
303e50e6 701 }
da3b9756
MM
702
703 s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
5bb8a0da 704 skip_bits(&s->gb, 8);
da3b9756
MM
705
706 if (length > 0) {
5bb8a0da 707 memcpy ((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
da3b9756
MM
708 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
709 }
710 }
711
303e50e6
MN
712 if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3){
713 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
da3b9756 714 return -1;
303e50e6 715 }
da3b9756
MM
716
717 h->slice_type = golomb_to_pict_type[i];
718
719 if ((header & 0x9F) == 2) {
720 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
721 s->mb_skip_run = get_bits (&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
722 } else {
3a5729ea 723 skip_bits1 (&s->gb);
da3b9756
MM
724 s->mb_skip_run = 0;
725 }
726
727 h->slice_num = get_bits (&s->gb, 8);
728 s->qscale = get_bits (&s->gb, 5);
729 s->adaptive_quant = get_bits1 (&s->gb);
730
731 /* unknown fields */
3a5729ea 732 skip_bits1 (&s->gb);
da3b9756
MM
733
734 if (h->unknown_svq3_flag) {
3a5729ea 735 skip_bits1 (&s->gb);
da3b9756
MM
736 }
737
3a5729ea
AB
738 skip_bits1 (&s->gb);
739 skip_bits (&s->gb, 2);
da3b9756
MM
740
741 while (get_bits1 (&s->gb)) {
3a5729ea 742 skip_bits (&s->gb, 8);
da3b9756
MM
743 }
744
745 /* reset intra predictors and invalidate motion vector references */
746 if (s->mb_x > 0) {
747 memset (h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
748 memset (h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
749 }
750 if (s->mb_y > 0) {
751 memset (h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
752
753 if (s->mb_x > 0) {
754 h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
755 }
756 }
757
758 return 0;
759}
760
8b82a956 761static int svq3_decode_frame (AVCodecContext *avctx,
bb270c08 762 void *data, int *data_size,
30317501 763 const uint8_t *buf, int buf_size) {
8b82a956
MN
764 MpegEncContext *const s = avctx->priv_data;
765 H264Context *const h = avctx->priv_data;
da3b9756 766 int m, mb_type;
14284f78 767 unsigned char *extradata;
ebcd2f96 768 unsigned int size;
da3b9756 769
8b82a956 770 s->flags = avctx->flags;
303e50e6 771 s->flags2 = avctx->flags2;
4ff7c576
MM
772 s->unrestricted_mv = 1;
773
8b82a956 774 if (!s->context_initialized) {
4c701ac8
MN
775 s->width = avctx->width;
776 s->height = avctx->height;
8b82a956
MN
777 h->halfpel_flag = 1;
778 h->thirdpel_flag = 1;
da3b9756 779 h->unknown_svq3_flag = 0;
4691a77d 780 h->chroma_qp[0] = h->chroma_qp[1] = 4;
8b82a956
MN
781
782 if (MPV_common_init (s) < 0)
783 return -1;
784
4c701ac8
MN
785 h->b_stride = 4*s->mb_width;
786
8b82a956 787 alloc_tables (h);
8b82a956 788
14284f78
MM
789 /* prowl for the "SEQH" marker in the extradata */
790 extradata = (unsigned char *)avctx->extradata;
791 for (m = 0; m < avctx->extradata_size; m++) {
792 if (!memcmp (extradata, "SEQH", 4))
793 break;
794 extradata++;
795 }
ebcd2f96 796
14284f78 797 /* if a match was found, parse the extra data */
2c160320 798 if (extradata && !memcmp (extradata, "SEQH", 4)) {
da3b9756
MM
799
800 GetBitContext gb;
8b82a956 801
fead30d4 802 size = AV_RB32(&extradata[4]);
63d33cf4 803 init_get_bits (&gb, extradata + 8, size*8);
8b82a956 804
da3b9756
MM
805 /* 'frame size code' and optional 'width, height' */
806 if (get_bits (&gb, 3) == 7) {
3a5729ea
AB
807 skip_bits (&gb, 12);
808 skip_bits (&gb, 12);
8b82a956
MN
809 }
810
da3b9756
MM
811 h->halfpel_flag = get_bits1 (&gb);
812 h->thirdpel_flag = get_bits1 (&gb);
8b82a956 813
da3b9756 814 /* unknown fields */
3a5729ea
AB
815 skip_bits1 (&gb);
816 skip_bits1 (&gb);
817 skip_bits1 (&gb);
818 skip_bits1 (&gb);
8b82a956 819
da3b9756 820 s->low_delay = get_bits1 (&gb);
8b82a956 821
da3b9756 822 /* unknown field */
3a5729ea 823 skip_bits1 (&gb);
8b82a956 824
da3b9756 825 while (get_bits1 (&gb)) {
3a5729ea 826 skip_bits (&gb, 8);
da3b9756 827 }
8b82a956 828
da3b9756
MM
829 h->unknown_svq3_flag = get_bits1 (&gb);
830 avctx->has_b_frames = !s->low_delay;
831 }
832 }
8b82a956 833
da3b9756
MM
834 /* special case for last picture */
835 if (buf_size == 0) {
836 if (s->next_picture_ptr && !s->low_delay) {
837 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
838 *data_size = sizeof(AVFrame);
839 }
840 return 0;
841 }
8b82a956 842
da3b9756 843 init_get_bits (&s->gb, buf, 8*buf_size);
8b82a956 844
da3b9756 845 s->mb_x = s->mb_y = 0;
8b82a956 846
da3b9756
MM
847 if (svq3_decode_slice_header (h))
848 return -1;
8b82a956 849
da3b9756
MM
850 s->pict_type = h->slice_type;
851 s->picture_number = h->slice_num;
8b82a956 852
4704097a 853 if(avctx->debug&FF_DEBUG_PICT_INFO){
115329f1 854 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d\n",
d8085ea7 855 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
4704097a
MN
856 s->adaptive_quant, s->qscale
857 );
858 }
8b82a956 859
da3b9756
MM
860 /* for hurry_up==5 */
861 s->current_picture.pict_type = s->pict_type;
862 s->current_picture.key_frame = (s->pict_type == I_TYPE);
863
755bfeab 864 /* Skip B-frames if we do not have reference frames. */
da3b9756 865 if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0;
755bfeab 866 /* Skip B-frames if we are in a hurry. */
da3b9756 867 if (avctx->hurry_up && s->pict_type == B_TYPE) return 0;
755bfeab 868 /* Skip everything if we are in a hurry >= 5. */
da3b9756 869 if (avctx->hurry_up >= 5) return 0;
8c3eba7c
MN
870 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
871 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
872 || avctx->skip_frame >= AVDISCARD_ALL)
873 return 0;
da3b9756
MM
874
875 if (s->next_p_frame_damaged) {
876 if (s->pict_type == B_TYPE)
877 return 0;
878 else
879 s->next_p_frame_damaged = 0;
880 }
8b82a956 881
0c74098b
MN
882 if (frame_start (h) < 0)
883 return -1;
8b82a956 884
da3b9756
MM
885 if (s->pict_type == B_TYPE) {
886 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
887
888 if (h->frame_num_offset < 0) {
889 h->frame_num_offset += 256;
890 }
891 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
9b879566 892 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
da3b9756
MM
893 return -1;
894 }
895 } else {
896 h->prev_frame_num = h->frame_num;
897 h->frame_num = h->slice_num;
898 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
899
900 if (h->prev_frame_num_offset < 0) {
901 h->prev_frame_num_offset += 256;
902 }
903 }
904
905 for(m=0; m<2; m++){
906 int i;
907 for(i=0; i<4; i++){
908 int j;
909 for(j=-1; j<4; j++)
bb270c08 910 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
a1f6643d
MN
911 if(i<3)
912 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
da3b9756 913 }
f7a8c179 914 }
115329f1 915
8b82a956
MN
916 for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) {
917 for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
da3b9756 918
5bb8a0da 919 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
bb270c08 920 ((get_bits_count(&s->gb) & 7) == 0 || show_bits (&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
da3b9756 921
bb270c08
DB
922 skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
923 s->gb.size_in_bits = 8*buf_size;
da3b9756 924
bb270c08
DB
925 if (svq3_decode_slice_header (h))
926 return -1;
da3b9756 927
bb270c08 928 /* TODO: support s->mb_skip_run */
da3b9756
MM
929 }
930
931 mb_type = svq3_get_ue_golomb (&s->gb);
8b82a956
MN
932
933 if (s->pict_type == I_TYPE) {
bb270c08 934 mb_type += 8;
da3b9756 935 } else if (s->pict_type == B_TYPE && mb_type >= 4) {
bb270c08 936 mb_type += 4;
8b82a956 937 }
da3b9756 938 if (mb_type > 33 || svq3_decode_mb (h, mb_type)) {
bb270c08
DB
939 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
940 return -1;
8b82a956
MN
941 }
942
943 if (mb_type != 0) {
bb270c08 944 hl_decode_mb (h);
8b82a956 945 }
2e26c8d2
MM
946
947 if (s->pict_type != B_TYPE && !s->low_delay) {
bb270c08
DB
948 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
949 (s->pict_type == P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
2e26c8d2 950 }
8b82a956 951 }
4c701ac8
MN
952
953 ff_draw_horiz_band(s, 16*s->mb_y, 16);
8b82a956
MN
954 }
955
8b82a956 956 MPV_frame_end(s);
da3b9756
MM
957
958 if (s->pict_type == B_TYPE || s->low_delay) {
959 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
960 } else {
961 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
962 }
963
964 avctx->frame_number = s->picture_number - 1;
965
755bfeab 966 /* Do not output the last pic after seeking. */
da3b9756
MM
967 if (s->last_picture_ptr || s->low_delay) {
968 *data_size = sizeof(AVFrame);
969 }
970
8b82a956
MN
971 return buf_size;
972}
973
974
975AVCodec svq3_decoder = {
976 "svq3",
977 CODEC_TYPE_VIDEO,
978 CODEC_ID_SVQ3,
979 sizeof(H264Context),
980 decode_init,
981 NULL,
982 decode_end,
983 svq3_decode_frame,
934982c4 984 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
8b82a956 985};