Replace all CODEC_ID_* with AV_CODEC_ID_*
[libav.git] / libavcodec / svq3.c
1 /*
2 * Copyright (c) 2003 The Libav Project
3 *
4 * This file is part of Libav.
5 *
6 * Libav is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * Libav is distributed in the hope that it will be useful,
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
17 * License along with Libav; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /*
22 * How to use this decoder:
23 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
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
30 * via the AVCodecContext's extradata[_size] field:
31 *
32 * AVCodecContext.extradata = pointer to ImageDescription, first characters
33 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
34 * AVCodecContext.extradata_size = size of ImageDescription atom memory
35 * buffer (which will be the same as the ImageDescription atom size field
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 * http://samples.libav.org/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41 */
42 #include "internal.h"
43 #include "dsputil.h"
44 #include "avcodec.h"
45 #include "mpegvideo.h"
46 #include "h264.h"
47
48 #include "h264data.h" //FIXME FIXME FIXME
49
50 #include "h264_mvpred.h"
51 #include "golomb.h"
52 #include "rectangle.h"
53 #include "vdpau_internal.h"
54
55 #if CONFIG_ZLIB
56 #include <zlib.h>
57 #endif
58
59 #include "svq1.h"
60
61 /**
62 * @file
63 * svq3 decoder.
64 */
65
66 typedef struct {
67 H264Context h;
68 int halfpel_flag;
69 int thirdpel_flag;
70 int unknown_flag;
71 int next_slice_index;
72 uint32_t watermark_key;
73 } SVQ3Context;
74
75 #define FULLPEL_MODE 1
76 #define HALFPEL_MODE 2
77 #define THIRDPEL_MODE 3
78 #define PREDICT_MODE 4
79
80 /* dual scan (from some older h264 draft)
81 o-->o-->o o
82 | /|
83 o o o / o
84 | / | |/ |
85 o o o o
86 /
87 o-->o-->o-->o
88 */
89 static const uint8_t svq3_scan[16] = {
90 0+0*4, 1+0*4, 2+0*4, 2+1*4,
91 2+2*4, 3+0*4, 3+1*4, 3+2*4,
92 0+1*4, 0+2*4, 1+1*4, 1+2*4,
93 0+3*4, 1+3*4, 2+3*4, 3+3*4,
94 };
95
96 static const uint8_t svq3_pred_0[25][2] = {
97 { 0, 0 },
98 { 1, 0 }, { 0, 1 },
99 { 0, 2 }, { 1, 1 }, { 2, 0 },
100 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
101 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
102 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
103 { 2, 4 }, { 3, 3 }, { 4, 2 },
104 { 4, 3 }, { 3, 4 },
105 { 4, 4 }
106 };
107
108 static const int8_t svq3_pred_1[6][6][5] = {
109 { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
110 { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
111 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
112 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
113 { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
114 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
115 { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
116 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
117 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
118 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
119 { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
120 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
121 };
122
123 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
124 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
125 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
126 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
127 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
128 };
129
130 static const uint32_t svq3_dequant_coeff[32] = {
131 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
132 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
133 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
134 61694, 68745, 77615, 89113,100253,109366,126635,141533
135 };
136
137 void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp){
138 const int qmul = svq3_dequant_coeff[qp];
139 #define stride 16
140 int i;
141 int temp[16];
142 static const uint8_t x_offset[4]={0, 1*stride, 4*stride, 5*stride};
143
144 for(i=0; i<4; i++){
145 const int z0 = 13*(input[4*i+0] + input[4*i+2]);
146 const int z1 = 13*(input[4*i+0] - input[4*i+2]);
147 const int z2 = 7* input[4*i+1] - 17*input[4*i+3];
148 const int z3 = 17* input[4*i+1] + 7*input[4*i+3];
149
150 temp[4*i+0] = z0+z3;
151 temp[4*i+1] = z1+z2;
152 temp[4*i+2] = z1-z2;
153 temp[4*i+3] = z0-z3;
154 }
155
156 for(i=0; i<4; i++){
157 const int offset= x_offset[i];
158 const int z0= 13*(temp[4*0+i] + temp[4*2+i]);
159 const int z1= 13*(temp[4*0+i] - temp[4*2+i]);
160 const int z2= 7* temp[4*1+i] - 17*temp[4*3+i];
161 const int z3= 17* temp[4*1+i] + 7*temp[4*3+i];
162
163 output[stride* 0+offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
164 output[stride* 2+offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
165 output[stride* 8+offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
166 output[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
167 }
168 }
169 #undef stride
170
171 void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
172 int dc)
173 {
174 const int qmul = svq3_dequant_coeff[qp];
175 int i;
176
177 if (dc) {
178 dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
179 block[0] = 0;
180 }
181
182 for (i = 0; i < 4; i++) {
183 const int z0 = 13*(block[0 + 4*i] + block[2 + 4*i]);
184 const int z1 = 13*(block[0 + 4*i] - block[2 + 4*i]);
185 const int z2 = 7* block[1 + 4*i] - 17*block[3 + 4*i];
186 const int z3 = 17* block[1 + 4*i] + 7*block[3 + 4*i];
187
188 block[0 + 4*i] = z0 + z3;
189 block[1 + 4*i] = z1 + z2;
190 block[2 + 4*i] = z1 - z2;
191 block[3 + 4*i] = z0 - z3;
192 }
193
194 for (i = 0; i < 4; i++) {
195 const int z0 = 13*(block[i + 4*0] + block[i + 4*2]);
196 const int z1 = 13*(block[i + 4*0] - block[i + 4*2]);
197 const int z2 = 7* block[i + 4*1] - 17*block[i + 4*3];
198 const int z3 = 17* block[i + 4*1] + 7*block[i + 4*3];
199 const int rr = (dc + 0x80000);
200
201 dst[i + stride*0] = av_clip_uint8( dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) );
202 dst[i + stride*1] = av_clip_uint8( dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) );
203 dst[i + stride*2] = av_clip_uint8( dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) );
204 dst[i + stride*3] = av_clip_uint8( dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) );
205 }
206 }
207
208 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
209 int index, const int type)
210 {
211 static const uint8_t *const scan_patterns[4] =
212 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
213
214 int run, level, sign, vlc, limit;
215 const int intra = (3 * type) >> 2;
216 const uint8_t *const scan = scan_patterns[type];
217
218 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
219 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
220
221 if (vlc == INVALID_VLC)
222 return -1;
223
224 sign = (vlc & 0x1) - 1;
225 vlc = (vlc + 1) >> 1;
226
227 if (type == 3) {
228 if (vlc < 3) {
229 run = 0;
230 level = vlc;
231 } else if (vlc < 4) {
232 run = 1;
233 level = 1;
234 } else {
235 run = (vlc & 0x3);
236 level = ((vlc + 9) >> 2) - run;
237 }
238 } else {
239 if (vlc < 16) {
240 run = svq3_dct_tables[intra][vlc].run;
241 level = svq3_dct_tables[intra][vlc].level;
242 } else if (intra) {
243 run = (vlc & 0x7);
244 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
245 } else {
246 run = (vlc & 0xF);
247 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
248 }
249 }
250
251 if ((index += run) >= limit)
252 return -1;
253
254 block[scan[index]] = (level ^ sign) - sign;
255 }
256
257 if (type != 2) {
258 break;
259 }
260 }
261
262 return 0;
263 }
264
265 static inline void svq3_mc_dir_part(MpegEncContext *s,
266 int x, int y, int width, int height,
267 int mx, int my, int dxy,
268 int thirdpel, int dir, int avg)
269 {
270 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
271 uint8_t *src, *dest;
272 int i, emu = 0;
273 int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
274
275 mx += x;
276 my += y;
277
278 if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
279 my < 0 || my >= (s->v_edge_pos - height - 1)) {
280
281 if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
282 emu = 1;
283 }
284
285 mx = av_clip (mx, -16, (s->h_edge_pos - width + 15));
286 my = av_clip (my, -16, (s->v_edge_pos - height + 15));
287 }
288
289 /* form component predictions */
290 dest = s->current_picture.f.data[0] + x + y*s->linesize;
291 src = pic->f.data[0] + mx + my*s->linesize;
292
293 if (emu) {
294 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
295 mx, my, s->h_edge_pos, s->v_edge_pos);
296 src = s->edge_emu_buffer;
297 }
298 if (thirdpel)
299 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
300 else
301 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
302
303 if (!(s->flags & CODEC_FLAG_GRAY)) {
304 mx = (mx + (mx < (int) x)) >> 1;
305 my = (my + (my < (int) y)) >> 1;
306 width = (width >> 1);
307 height = (height >> 1);
308 blocksize++;
309
310 for (i = 1; i < 3; i++) {
311 dest = s->current_picture.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
312 src = pic->f.data[i] + mx + my * s->uvlinesize;
313
314 if (emu) {
315 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
316 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
317 src = s->edge_emu_buffer;
318 }
319 if (thirdpel)
320 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
321 else
322 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
323 }
324 }
325 }
326
327 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
328 int avg)
329 {
330 int i, j, k, mx, my, dx, dy, x, y;
331 MpegEncContext *const s = (MpegEncContext *) h;
332 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
333 const int part_height = 16 >> ((unsigned) (size + 1) / 3);
334 const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
335 const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width;
336 const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width;
337
338 for (i = 0; i < 16; i += part_height) {
339 for (j = 0; j < 16; j += part_width) {
340 const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
341 int dxy;
342 x = 16*s->mb_x + j;
343 y = 16*s->mb_y + i;
344 k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
345
346 if (mode != PREDICT_MODE) {
347 pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
348 } else {
349 mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
350 my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
351
352 if (dir == 0) {
353 mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
354 my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
355 } else {
356 mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
357 my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
358 }
359 }
360
361 /* clip motion vector prediction to frame border */
362 mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
363 my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
364
365 /* get (optional) motion vector differential */
366 if (mode == PREDICT_MODE) {
367 dx = dy = 0;
368 } else {
369 dy = svq3_get_se_golomb(&s->gb);
370 dx = svq3_get_se_golomb(&s->gb);
371
372 if (dx == INVALID_VLC || dy == INVALID_VLC) {
373 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
374 return -1;
375 }
376 }
377
378 /* compute motion vector */
379 if (mode == THIRDPEL_MODE) {
380 int fx, fy;
381 mx = ((mx + 1)>>1) + dx;
382 my = ((my + 1)>>1) + dy;
383 fx = ((unsigned)(mx + 0x3000))/3 - 0x1000;
384 fy = ((unsigned)(my + 0x3000))/3 - 0x1000;
385 dxy = (mx - 3*fx) + 4*(my - 3*fy);
386
387 svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
388 mx += mx;
389 my += my;
390 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
391 mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
392 my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
393 dxy = (mx&1) + 2*(my&1);
394
395 svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
396 mx *= 3;
397 my *= 3;
398 } else {
399 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
400 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
401
402 svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
403 mx *= 6;
404 my *= 6;
405 }
406
407 /* update mv_cache */
408 if (mode != PREDICT_MODE) {
409 int32_t mv = pack16to32(mx,my);
410
411 if (part_height == 8 && i < 8) {
412 *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
413
414 if (part_width == 8 && j < 8) {
415 *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
416 }
417 }
418 if (part_width == 8 && j < 8) {
419 *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
420 }
421 if (part_width == 4 || part_height == 4) {
422 *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
423 }
424 }
425
426 /* write back motion vectors */
427 fill_rectangle(s->current_picture.f.motion_val[dir][b_xy],
428 part_width >> 2, part_height >> 2, h->b_stride,
429 pack16to32(mx, my), 4);
430 }
431 }
432
433 return 0;
434 }
435
436 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
437 {
438 H264Context *h = &svq3->h;
439 int i, j, k, m, dir, mode;
440 int cbp = 0;
441 uint32_t vlc;
442 int8_t *top, *left;
443 MpegEncContext *const s = (MpegEncContext *) h;
444 const int mb_xy = h->mb_xy;
445 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
446
447 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
448 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
449 h->topright_samples_available = 0xFFFF;
450
451 if (mb_type == 0) { /* SKIP */
452 if (s->pict_type == AV_PICTURE_TYPE_P || s->next_picture.f.mb_type[mb_xy] == -1) {
453 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
454
455 if (s->pict_type == AV_PICTURE_TYPE_B) {
456 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
457 }
458
459 mb_type = MB_TYPE_SKIP;
460 } else {
461 mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
462 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
463 return -1;
464 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
465 return -1;
466
467 mb_type = MB_TYPE_16x16;
468 }
469 } else if (mb_type < 8) { /* INTER */
470 if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1 (&s->gb)) {
471 mode = THIRDPEL_MODE;
472 } else if (svq3->halfpel_flag && svq3->thirdpel_flag == !get_bits1 (&s->gb)) {
473 mode = HALFPEL_MODE;
474 } else {
475 mode = FULLPEL_MODE;
476 }
477
478 /* fill caches */
479 /* note ref_cache should contain here:
480 ????????
481 ???11111
482 N??11111
483 N??11111
484 N??11111
485 */
486
487 for (m = 0; m < 2; m++) {
488 if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
489 for (i = 0; i < 4; i++) {
490 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.f.motion_val[m][b_xy - 1 + i*h->b_stride];
491 }
492 } else {
493 for (i = 0; i < 4; i++) {
494 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
495 }
496 }
497 if (s->mb_y > 0) {
498 memcpy(h->mv_cache[m][scan8[0] - 1*8], s->current_picture.f.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
499 memset(&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
500
501 if (s->mb_x < (s->mb_width - 1)) {
502 *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4];
503 h->ref_cache[m][scan8[0] + 4 - 1*8] =
504 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
505 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride ] ] == -1) ? PART_NOT_AVAILABLE : 1;
506 }else
507 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
508 if (s->mb_x > 0) {
509 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1];
510 h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] == -1) ? PART_NOT_AVAILABLE : 1;
511 }else
512 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
513 }else
514 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
515
516 if (s->pict_type != AV_PICTURE_TYPE_B)
517 break;
518 }
519
520 /* decode motion vector(s) and form prediction(s) */
521 if (s->pict_type == AV_PICTURE_TYPE_P) {
522 if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
523 return -1;
524 } else { /* AV_PICTURE_TYPE_B */
525 if (mb_type != 2) {
526 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
527 return -1;
528 } else {
529 for (i = 0; i < 4; i++) {
530 memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
531 }
532 }
533 if (mb_type != 1) {
534 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
535 return -1;
536 } else {
537 for (i = 0; i < 4; i++) {
538 memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
539 }
540 }
541 }
542
543 mb_type = MB_TYPE_16x16;
544 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
545 memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
546
547 if (mb_type == 8) {
548 if (s->mb_x > 0) {
549 for (i = 0; i < 4; i++) {
550 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
551 }
552 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
553 h->left_samples_available = 0x5F5F;
554 }
555 }
556 if (s->mb_y > 0) {
557 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
558 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
559 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
560 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
561
562 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
563 h->top_samples_available = 0x33FF;
564 }
565 }
566
567 /* decode prediction codes for luma blocks */
568 for (i = 0; i < 16; i+=2) {
569 vlc = svq3_get_ue_golomb(&s->gb);
570
571 if (vlc >= 25){
572 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
573 return -1;
574 }
575
576 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
577 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
578
579 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
580 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
581
582 if (left[1] == -1 || left[2] == -1){
583 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
584 return -1;
585 }
586 }
587 } else { /* mb_type == 33, DC_128_PRED block type */
588 for (i = 0; i < 4; i++) {
589 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
590 }
591 }
592
593 write_back_intra_pred_mode(h);
594
595 if (mb_type == 8) {
596 ff_h264_check_intra4x4_pred_mode(h);
597
598 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
599 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
600 } else {
601 for (i = 0; i < 4; i++) {
602 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
603 }
604
605 h->top_samples_available = 0x33FF;
606 h->left_samples_available = 0x5F5F;
607 }
608
609 mb_type = MB_TYPE_INTRA4x4;
610 } else { /* INTRA16x16 */
611 dir = i_mb_type_info[mb_type - 8].pred_mode;
612 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
613
614 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1){
615 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
616 return -1;
617 }
618
619 cbp = i_mb_type_info[mb_type - 8].cbp;
620 mb_type = MB_TYPE_INTRA16x16;
621 }
622
623 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
624 for (i = 0; i < 4; i++) {
625 memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
626 }
627 if (s->pict_type == AV_PICTURE_TYPE_B) {
628 for (i = 0; i < 4; i++) {
629 memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
630 }
631 }
632 }
633 if (!IS_INTRA4x4(mb_type)) {
634 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
635 }
636 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
637 memset(h->non_zero_count_cache + 8, 0, 14*8*sizeof(uint8_t));
638 s->dsp.clear_blocks(h->mb+ 0);
639 s->dsp.clear_blocks(h->mb+384);
640 }
641
642 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
643 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
644 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
645 return -1;
646 }
647
648 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
649 }
650 if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
651 s->qscale += svq3_get_se_golomb(&s->gb);
652
653 if (s->qscale > 31u){
654 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
655 return -1;
656 }
657 }
658 if (IS_INTRA16x16(mb_type)) {
659 AV_ZERO128(h->mb_luma_dc[0]+0);
660 AV_ZERO128(h->mb_luma_dc[0]+8);
661 if (svq3_decode_block(&s->gb, h->mb_luma_dc, 0, 1)){
662 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
663 return -1;
664 }
665 }
666
667 if (cbp) {
668 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
669 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
670
671 for (i = 0; i < 4; i++) {
672 if ((cbp & (1 << i))) {
673 for (j = 0; j < 4; j++) {
674 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
675 h->non_zero_count_cache[ scan8[k] ] = 1;
676
677 if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
678 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
679 return -1;
680 }
681 }
682 }
683 }
684
685 if ((cbp & 0x30)) {
686 for (i = 1; i < 3; ++i) {
687 if (svq3_decode_block(&s->gb, &h->mb[16*16*i], 0, 3)){
688 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
689 return -1;
690 }
691 }
692
693 if ((cbp & 0x20)) {
694 for (i = 1; i < 3; i++) {
695 for (j = 0; j < 4; j++) {
696 k = 16*i + j;
697 h->non_zero_count_cache[ scan8[k] ] = 1;
698
699 if (svq3_decode_block(&s->gb, &h->mb[16*k], 1, 1)){
700 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
701 return -1;
702 }
703 }
704 }
705 }
706 }
707 }
708
709 h->cbp= cbp;
710 s->current_picture.f.mb_type[mb_xy] = mb_type;
711
712 if (IS_INTRA(mb_type)) {
713 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
714 }
715
716 return 0;
717 }
718
719 static int svq3_decode_slice_header(AVCodecContext *avctx)
720 {
721 SVQ3Context *svq3 = avctx->priv_data;
722 H264Context *h = &svq3->h;
723 MpegEncContext *s = &h->s;
724 const int mb_xy = h->mb_xy;
725 int i, header;
726
727 header = get_bits(&s->gb, 8);
728
729 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
730 /* TODO: what? */
731 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
732 return -1;
733 } else {
734 int length = (header >> 5) & 3;
735
736 svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
737
738 if (svq3->next_slice_index > s->gb.size_in_bits) {
739 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
740 return -1;
741 }
742
743 s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1);
744 skip_bits(&s->gb, 8);
745
746 if (svq3->watermark_key) {
747 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
748 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key);
749 }
750 if (length > 0) {
751 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
752 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
753 }
754 skip_bits_long(&s->gb, 0);
755 }
756
757 if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
758 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
759 return -1;
760 }
761
762 h->slice_type = golomb_to_pict_type[i];
763
764 if ((header & 0x9F) == 2) {
765 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
766 s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
767 } else {
768 skip_bits1(&s->gb);
769 s->mb_skip_run = 0;
770 }
771
772 h->slice_num = get_bits(&s->gb, 8);
773 s->qscale = get_bits(&s->gb, 5);
774 s->adaptive_quant = get_bits1(&s->gb);
775
776 /* unknown fields */
777 skip_bits1(&s->gb);
778
779 if (svq3->unknown_flag) {
780 skip_bits1(&s->gb);
781 }
782
783 skip_bits1(&s->gb);
784 skip_bits(&s->gb, 2);
785
786 while (get_bits1(&s->gb)) {
787 skip_bits(&s->gb, 8);
788 }
789
790 /* reset intra predictors and invalidate motion vector references */
791 if (s->mb_x > 0) {
792 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1 ]+3, -1, 4*sizeof(int8_t));
793 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x] , -1, 8*sizeof(int8_t)*s->mb_x);
794 }
795 if (s->mb_y > 0) {
796 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
797
798 if (s->mb_x > 0) {
799 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
800 }
801 }
802
803 return 0;
804 }
805
806 static av_cold int svq3_decode_init(AVCodecContext *avctx)
807 {
808 SVQ3Context *svq3 = avctx->priv_data;
809 H264Context *h = &svq3->h;
810 MpegEncContext *s = &h->s;
811 int m;
812 unsigned char *extradata;
813 unsigned char *extradata_end;
814 unsigned int size;
815 int marker_found = 0;
816
817 if (ff_h264_decode_init(avctx) < 0)
818 return -1;
819
820 s->flags = avctx->flags;
821 s->flags2 = avctx->flags2;
822 s->unrestricted_mv = 1;
823 h->is_complex=1;
824 avctx->pix_fmt = avctx->codec->pix_fmts[0];
825
826 if (!s->context_initialized) {
827 h->chroma_qp[0] = h->chroma_qp[1] = 4;
828
829 svq3->halfpel_flag = 1;
830 svq3->thirdpel_flag = 1;
831 svq3->unknown_flag = 0;
832
833 /* prowl for the "SEQH" marker in the extradata */
834 extradata = (unsigned char *)avctx->extradata;
835 extradata_end = avctx->extradata + avctx->extradata_size;
836 if (extradata) {
837 for (m = 0; m + 8 < avctx->extradata_size; m++) {
838 if (!memcmp(extradata, "SEQH", 4)) {
839 marker_found = 1;
840 break;
841 }
842 extradata++;
843 }
844 }
845
846 /* if a match was found, parse the extra data */
847 if (marker_found) {
848
849 GetBitContext gb;
850 int frame_size_code;
851
852 size = AV_RB32(&extradata[4]);
853 if (size > extradata_end - extradata - 8)
854 return AVERROR_INVALIDDATA;
855 init_get_bits(&gb, extradata + 8, size*8);
856
857 /* 'frame size code' and optional 'width, height' */
858 frame_size_code = get_bits(&gb, 3);
859 switch (frame_size_code) {
860 case 0: avctx->width = 160; avctx->height = 120; break;
861 case 1: avctx->width = 128; avctx->height = 96; break;
862 case 2: avctx->width = 176; avctx->height = 144; break;
863 case 3: avctx->width = 352; avctx->height = 288; break;
864 case 4: avctx->width = 704; avctx->height = 576; break;
865 case 5: avctx->width = 240; avctx->height = 180; break;
866 case 6: avctx->width = 320; avctx->height = 240; break;
867 case 7:
868 avctx->width = get_bits(&gb, 12);
869 avctx->height = get_bits(&gb, 12);
870 break;
871 }
872
873 svq3->halfpel_flag = get_bits1(&gb);
874 svq3->thirdpel_flag = get_bits1(&gb);
875
876 /* unknown fields */
877 skip_bits1(&gb);
878 skip_bits1(&gb);
879 skip_bits1(&gb);
880 skip_bits1(&gb);
881
882 s->low_delay = get_bits1(&gb);
883
884 /* unknown field */
885 skip_bits1(&gb);
886
887 while (get_bits1(&gb)) {
888 skip_bits(&gb, 8);
889 }
890
891 svq3->unknown_flag = get_bits1(&gb);
892 avctx->has_b_frames = !s->low_delay;
893 if (svq3->unknown_flag) {
894 #if CONFIG_ZLIB
895 unsigned watermark_width = svq3_get_ue_golomb(&gb);
896 unsigned watermark_height = svq3_get_ue_golomb(&gb);
897 int u1 = svq3_get_ue_golomb(&gb);
898 int u2 = get_bits(&gb, 8);
899 int u3 = get_bits(&gb, 2);
900 int u4 = svq3_get_ue_golomb(&gb);
901 unsigned long buf_len = watermark_width*watermark_height*4;
902 int offset = (get_bits_count(&gb)+7)>>3;
903 uint8_t *buf;
904
905 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
906 return -1;
907
908 buf = av_malloc(buf_len);
909 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
910 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
911 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
912 av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
913 av_free(buf);
914 return -1;
915 }
916 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
917 svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
918 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
919 av_free(buf);
920 #else
921 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
922 return -1;
923 #endif
924 }
925 }
926
927 s->width = avctx->width;
928 s->height = avctx->height;
929
930 if (ff_MPV_common_init(s) < 0)
931 return -1;
932
933 h->b_stride = 4*s->mb_width;
934
935 if (ff_h264_alloc_tables(h) < 0) {
936 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
937 return AVERROR(ENOMEM);
938 }
939 }
940
941 return 0;
942 }
943
944 static int svq3_decode_frame(AVCodecContext *avctx,
945 void *data, int *data_size,
946 AVPacket *avpkt)
947 {
948 const uint8_t *buf = avpkt->data;
949 SVQ3Context *svq3 = avctx->priv_data;
950 H264Context *h = &svq3->h;
951 MpegEncContext *s = &h->s;
952 int buf_size = avpkt->size;
953 int m, mb_type;
954
955 /* special case for last picture */
956 if (buf_size == 0) {
957 if (s->next_picture_ptr && !s->low_delay) {
958 *(AVFrame *) data = s->next_picture.f;
959 s->next_picture_ptr = NULL;
960 *data_size = sizeof(AVFrame);
961 }
962 return 0;
963 }
964
965 init_get_bits (&s->gb, buf, 8*buf_size);
966
967 s->mb_x = s->mb_y = h->mb_xy = 0;
968
969 if (svq3_decode_slice_header(avctx))
970 return -1;
971
972 s->pict_type = h->slice_type;
973 s->picture_number = h->slice_num;
974
975 if (avctx->debug&FF_DEBUG_PICT_INFO){
976 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
977 av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
978 s->adaptive_quant, s->qscale, h->slice_num);
979 }
980
981 /* for skipping the frame */
982 s->current_picture.f.pict_type = s->pict_type;
983 s->current_picture.f.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
984
985 /* Skip B-frames if we do not have reference frames. */
986 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
987 return 0;
988 if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
989 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
990 || avctx->skip_frame >= AVDISCARD_ALL)
991 return 0;
992
993 if (s->next_p_frame_damaged) {
994 if (s->pict_type == AV_PICTURE_TYPE_B)
995 return 0;
996 else
997 s->next_p_frame_damaged = 0;
998 }
999
1000 if (ff_h264_frame_start(h) < 0)
1001 return -1;
1002
1003 if (s->pict_type == AV_PICTURE_TYPE_B) {
1004 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
1005
1006 if (h->frame_num_offset < 0) {
1007 h->frame_num_offset += 256;
1008 }
1009 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
1010 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1011 return -1;
1012 }
1013 } else {
1014 h->prev_frame_num = h->frame_num;
1015 h->frame_num = h->slice_num;
1016 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
1017
1018 if (h->prev_frame_num_offset < 0) {
1019 h->prev_frame_num_offset += 256;
1020 }
1021 }
1022
1023 for (m = 0; m < 2; m++){
1024 int i;
1025 for (i = 0; i < 4; i++){
1026 int j;
1027 for (j = -1; j < 4; j++)
1028 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1029 if (i < 3)
1030 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1031 }
1032 }
1033
1034 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1035 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1036 h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1037
1038 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1039 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1040
1041 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1042 s->gb.size_in_bits = 8*buf_size;
1043
1044 if (svq3_decode_slice_header(avctx))
1045 return -1;
1046
1047 /* TODO: support s->mb_skip_run */
1048 }
1049
1050 mb_type = svq3_get_ue_golomb(&s->gb);
1051
1052 if (s->pict_type == AV_PICTURE_TYPE_I) {
1053 mb_type += 8;
1054 } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
1055 mb_type += 4;
1056 }
1057 if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1058 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1059 return -1;
1060 }
1061
1062 if (mb_type != 0) {
1063 ff_h264_hl_decode_mb (h);
1064 }
1065
1066 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
1067 s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1068 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1069 }
1070 }
1071
1072 ff_draw_horiz_band(s, 16*s->mb_y, 16);
1073 }
1074
1075 ff_MPV_frame_end(s);
1076
1077 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1078 *(AVFrame *) data = s->current_picture.f;
1079 } else {
1080 *(AVFrame *) data = s->last_picture.f;
1081 }
1082
1083 /* Do not output the last pic after seeking. */
1084 if (s->last_picture_ptr || s->low_delay) {
1085 *data_size = sizeof(AVFrame);
1086 }
1087
1088 return buf_size;
1089 }
1090
1091 static int svq3_decode_end(AVCodecContext *avctx)
1092 {
1093 SVQ3Context *svq3 = avctx->priv_data;
1094 H264Context *h = &svq3->h;
1095 MpegEncContext *s = &h->s;
1096
1097 ff_h264_free_context(h);
1098
1099 ff_MPV_common_end(s);
1100
1101 return 0;
1102 }
1103
1104 AVCodec ff_svq3_decoder = {
1105 .name = "svq3",
1106 .type = AVMEDIA_TYPE_VIDEO,
1107 .id = AV_CODEC_ID_SVQ3,
1108 .priv_data_size = sizeof(SVQ3Context),
1109 .init = svq3_decode_init,
1110 .close = svq3_decode_end,
1111 .decode = svq3_decode_frame,
1112 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
1113 CODEC_CAP_DELAY,
1114 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1115 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUVJ420P, PIX_FMT_NONE },
1116 };