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