2 * Copyright (c) 2003 The FFmpeg Project
4 * This file is part of FFmpeg.
6 * FFmpeg 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.
11 * FFmpeg 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.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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:
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)
38 * You will know you have these parameters passed correctly when the decoder
39 * correctly decodes this file:
40 * http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
45 #include "mpegvideo.h"
48 #include "h264data.h" // FIXME FIXME FIXME
50 #include "h264_mvpred.h"
52 #include "rectangle.h"
53 #include "vdpau_internal.h"
76 uint32_t watermark_key;
80 int next_p_frame_damaged;
83 int last_frame_output;
86 #define FULLPEL_MODE 1
87 #define HALFPEL_MODE 2
88 #define THIRDPEL_MODE 3
89 #define PREDICT_MODE 4
91 /* dual scan (from some older h264 draft)
100 static const uint8_t svq3_scan[16] = {
101 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
102 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
103 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
104 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
107 static const uint8_t svq3_pred_0[25][2] = {
110 { 0, 2 }, { 1, 1 }, { 2, 0 },
111 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
112 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
113 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
114 { 2, 4 }, { 3, 3 }, { 4, 2 },
119 static const int8_t svq3_pred_1[6][6][5] = {
120 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
121 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
122 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
123 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
124 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
125 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
126 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
127 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
128 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
129 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
130 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
131 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
134 static const struct {
137 } svq3_dct_tables[2][16] = {
138 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
139 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
140 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
141 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
144 static const uint32_t svq3_dequant_coeff[32] = {
145 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
146 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
147 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
148 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
151 void ff_svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
153 const int qmul = svq3_dequant_coeff[qp];
157 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
159 for (i = 0; i < 4; i++) {
160 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
161 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
162 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
163 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
165 temp[4 * i + 0] = z0 + z3;
166 temp[4 * i + 1] = z1 + z2;
167 temp[4 * i + 2] = z1 - z2;
168 temp[4 * i + 3] = z0 - z3;
171 for (i = 0; i < 4; i++) {
172 const int offset = x_offset[i];
173 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
174 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
175 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
176 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
178 output[stride * 0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
179 output[stride * 2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
180 output[stride * 8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
181 output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
186 void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block,
187 int stride, int qp, int dc)
189 const int qmul = svq3_dequant_coeff[qp];
193 dc = 13 * 13 * (dc == 1 ? 1538 * block[0]
194 : qmul * (block[0] >> 3) / 2);
198 for (i = 0; i < 4; i++) {
199 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
200 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
201 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
202 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
204 block[0 + 4 * i] = z0 + z3;
205 block[1 + 4 * i] = z1 + z2;
206 block[2 + 4 * i] = z1 - z2;
207 block[3 + 4 * i] = z0 - z3;
210 for (i = 0; i < 4; i++) {
211 const int z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
212 const int z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
213 const int z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
214 const int z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
215 const int rr = (dc + 0x80000);
217 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
218 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
219 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
220 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
224 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
225 int index, const int type)
227 static const uint8_t *const scan_patterns[4] =
228 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
230 int run, level, sign, limit;
232 const int intra = 3 * type >> 2;
233 const uint8_t *const scan = scan_patterns[type];
235 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
236 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
237 if ((int32_t)vlc < 0)
240 sign = (vlc & 1) ? 0 : -1;
247 } else if (vlc < 4) {
252 level = (vlc + 9 >> 2) - run;
256 run = svq3_dct_tables[intra][vlc].run;
257 level = svq3_dct_tables[intra][vlc].level;
260 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
263 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
268 if ((index += run) >= limit)
271 block[scan[index]] = (level ^ sign) - sign;
282 static inline void svq3_mc_dir_part(SVQ3Context *s,
283 int x, int y, int width, int height,
284 int mx, int my, int dxy,
285 int thirdpel, int dir, int avg)
287 H264Context *h = &s->h;
288 const Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
291 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
296 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
297 my < 0 || my >= s->v_edge_pos - height - 1) {
298 if ((h->flags & CODEC_FLAG_EMU_EDGE))
301 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
302 my = av_clip(my, -16, s->v_edge_pos - height + 15);
305 /* form component predictions */
306 dest = h->cur_pic.f.data[0] + x + y * h->linesize;
307 src = pic->f.data[0] + mx + my * h->linesize;
310 h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src, h->linesize,
311 width + 1, height + 1,
312 mx, my, s->h_edge_pos, s->v_edge_pos);
313 src = h->edge_emu_buffer;
316 (avg ? h->dsp.avg_tpel_pixels_tab
317 : h->dsp.put_tpel_pixels_tab)[dxy](dest, src, h->linesize,
320 (avg ? h->dsp.avg_pixels_tab
321 : h->dsp.put_pixels_tab)[blocksize][dxy](dest, src, h->linesize,
324 if (!(h->flags & CODEC_FLAG_GRAY)) {
325 mx = mx + (mx < (int) x) >> 1;
326 my = my + (my < (int) y) >> 1;
328 height = height >> 1;
331 for (i = 1; i < 3; i++) {
332 dest = h->cur_pic.f.data[i] + (x >> 1) + (y >> 1) * h->uvlinesize;
333 src = pic->f.data[i] + mx + my * h->uvlinesize;
336 h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src, h->uvlinesize,
337 width + 1, height + 1,
338 mx, my, (s->h_edge_pos >> 1),
340 src = h->edge_emu_buffer;
343 (avg ? h->dsp.avg_tpel_pixels_tab
344 : h->dsp.put_tpel_pixels_tab)[dxy](dest, src,
348 (avg ? h->dsp.avg_pixels_tab
349 : h->dsp.put_pixels_tab)[blocksize][dxy](dest, src,
356 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
359 int i, j, k, mx, my, dx, dy, x, y;
360 H264Context *h = &s->h;
361 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
362 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
363 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
364 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
365 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
367 for (i = 0; i < 16; i += part_height)
368 for (j = 0; j < 16; j += part_width) {
369 const int b_xy = (4 * h->mb_x + (j >> 2)) +
370 (4 * h->mb_y + (i >> 2)) * h->b_stride;
372 x = 16 * h->mb_x + j;
373 y = 16 * h->mb_y + i;
374 k = (j >> 2 & 1) + (i >> 1 & 2) +
375 (j >> 1 & 4) + (i & 8);
377 if (mode != PREDICT_MODE) {
378 pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
380 mx = s->next_pic->f.motion_val[0][b_xy][0] << 1;
381 my = s->next_pic->f.motion_val[0][b_xy][1] << 1;
384 mx = mx * h->frame_num_offset /
385 h->prev_frame_num_offset + 1 >> 1;
386 my = my * h->frame_num_offset /
387 h->prev_frame_num_offset + 1 >> 1;
389 mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
390 h->prev_frame_num_offset + 1 >> 1;
391 my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
392 h->prev_frame_num_offset + 1 >> 1;
396 /* clip motion vector prediction to frame border */
397 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
398 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
400 /* get (optional) motion vector differential */
401 if (mode == PREDICT_MODE) {
404 dy = svq3_get_se_golomb(&h->gb);
405 dx = svq3_get_se_golomb(&h->gb);
407 if (dx == INVALID_VLC || dy == INVALID_VLC) {
408 av_log(h->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
413 /* compute motion vector */
414 if (mode == THIRDPEL_MODE) {
416 mx = (mx + 1 >> 1) + dx;
417 my = (my + 1 >> 1) + dy;
418 fx = (unsigned)(mx + 0x3000) / 3 - 0x1000;
419 fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
420 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
422 svq3_mc_dir_part(s, x, y, part_width, part_height,
423 fx, fy, dxy, 1, dir, avg);
426 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
427 mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
428 my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
429 dxy = (mx & 1) + 2 * (my & 1);
431 svq3_mc_dir_part(s, x, y, part_width, part_height,
432 mx >> 1, my >> 1, dxy, 0, dir, avg);
436 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
437 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
439 svq3_mc_dir_part(s, x, y, part_width, part_height,
440 mx, my, 0, 0, dir, avg);
445 /* update mv_cache */
446 if (mode != PREDICT_MODE) {
447 int32_t mv = pack16to32(mx, my);
449 if (part_height == 8 && i < 8) {
450 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
452 if (part_width == 8 && j < 8)
453 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
455 if (part_width == 8 && j < 8)
456 AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
457 if (part_width == 4 || part_height == 4)
458 AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
461 /* write back motion vectors */
462 fill_rectangle(h->cur_pic.f.motion_val[dir][b_xy],
463 part_width >> 2, part_height >> 2, h->b_stride,
464 pack16to32(mx, my), 4);
470 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
472 H264Context *h = &s->h;
473 int i, j, k, m, dir, mode;
477 const int mb_xy = h->mb_xy;
478 const int b_xy = 4 * h->mb_x + 4 * h->mb_y * h->b_stride;
480 h->top_samples_available = (h->mb_y == 0) ? 0x33FF : 0xFFFF;
481 h->left_samples_available = (h->mb_x == 0) ? 0x5F5F : 0xFFFF;
482 h->topright_samples_available = 0xFFFF;
484 if (mb_type == 0) { /* SKIP */
485 if (h->pict_type == AV_PICTURE_TYPE_P ||
486 s->next_pic->f.mb_type[mb_xy] == -1) {
487 svq3_mc_dir_part(s, 16 * h->mb_x, 16 * h->mb_y, 16, 16,
490 if (h->pict_type == AV_PICTURE_TYPE_B)
491 svq3_mc_dir_part(s, 16 * h->mb_x, 16 * h->mb_y, 16, 16,
494 mb_type = MB_TYPE_SKIP;
496 mb_type = FFMIN(s->next_pic->f.mb_type[mb_xy], 6);
497 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
499 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
502 mb_type = MB_TYPE_16x16;
504 } else if (mb_type < 8) { /* INTER */
505 if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&h->gb))
506 mode = THIRDPEL_MODE;
507 else if (s->halfpel_flag &&
508 s->thirdpel_flag == !get_bits1(&h->gb))
514 /* note ref_cache should contain here:
522 for (m = 0; m < 2; m++) {
523 if (h->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
524 for (i = 0; i < 4; i++)
525 AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
526 h->cur_pic.f.motion_val[m][b_xy - 1 + i * h->b_stride]);
528 for (i = 0; i < 4; i++)
529 AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
532 memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
533 h->cur_pic.f.motion_val[m][b_xy - h->b_stride],
534 4 * 2 * sizeof(int16_t));
535 memset(&h->ref_cache[m][scan8[0] - 1 * 8],
536 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
538 if (h->mb_x < h->mb_width - 1) {
539 AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
540 h->cur_pic.f.motion_val[m][b_xy - h->b_stride + 4]);
541 h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
542 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride + 1] + 6] == -1 ||
543 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
545 h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
547 AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
548 h->cur_pic.f.motion_val[m][b_xy - h->b_stride - 1]);
549 h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
550 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
552 h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
554 memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
555 PART_NOT_AVAILABLE, 8);
557 if (h->pict_type != AV_PICTURE_TYPE_B)
561 /* decode motion vector(s) and form prediction(s) */
562 if (h->pict_type == AV_PICTURE_TYPE_P) {
563 if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
565 } else { /* AV_PICTURE_TYPE_B */
567 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
570 for (i = 0; i < 4; i++)
571 memset(h->cur_pic.f.motion_val[0][b_xy + i * h->b_stride],
572 0, 4 * 2 * sizeof(int16_t));
575 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
578 for (i = 0; i < 4; i++)
579 memset(h->cur_pic.f.motion_val[1][b_xy + i * h->b_stride],
580 0, 4 * 2 * sizeof(int16_t));
584 mb_type = MB_TYPE_16x16;
585 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
586 memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
590 for (i = 0; i < 4; i++)
591 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
592 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
593 h->left_samples_available = 0x5F5F;
596 h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 0];
597 h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 1];
598 h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 2];
599 h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride] + 3];
601 if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
602 h->top_samples_available = 0x33FF;
605 /* decode prediction codes for luma blocks */
606 for (i = 0; i < 16; i += 2) {
607 vlc = svq3_get_ue_golomb(&h->gb);
610 av_log(h->avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
614 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
615 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
617 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
618 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
620 if (left[1] == -1 || left[2] == -1) {
621 av_log(h->avctx, AV_LOG_ERROR, "weird prediction\n");
625 } else { /* mb_type == 33, DC_128_PRED block type */
626 for (i = 0; i < 4; i++)
627 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
630 write_back_intra_pred_mode(h);
633 ff_h264_check_intra4x4_pred_mode(h);
635 h->top_samples_available = (h->mb_y == 0) ? 0x33FF : 0xFFFF;
636 h->left_samples_available = (h->mb_x == 0) ? 0x5F5F : 0xFFFF;
638 for (i = 0; i < 4; i++)
639 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
641 h->top_samples_available = 0x33FF;
642 h->left_samples_available = 0x5F5F;
645 mb_type = MB_TYPE_INTRA4x4;
646 } else { /* INTRA16x16 */
647 dir = i_mb_type_info[mb_type - 8].pred_mode;
648 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
650 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1) {
651 av_log(h->avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
655 cbp = i_mb_type_info[mb_type - 8].cbp;
656 mb_type = MB_TYPE_INTRA16x16;
659 if (!IS_INTER(mb_type) && h->pict_type != AV_PICTURE_TYPE_I) {
660 for (i = 0; i < 4; i++)
661 memset(h->cur_pic.f.motion_val[0][b_xy + i * h->b_stride],
662 0, 4 * 2 * sizeof(int16_t));
663 if (h->pict_type == AV_PICTURE_TYPE_B) {
664 for (i = 0; i < 4; i++)
665 memset(h->cur_pic.f.motion_val[1][b_xy + i * h->b_stride],
666 0, 4 * 2 * sizeof(int16_t));
669 if (!IS_INTRA4x4(mb_type)) {
670 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
672 if (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B) {
673 memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
674 h->dsp.clear_blocks(h->mb + 0);
675 h->dsp.clear_blocks(h->mb + 384);
678 if (!IS_INTRA16x16(mb_type) &&
679 (!IS_SKIP(mb_type) || h->pict_type == AV_PICTURE_TYPE_B)) {
680 if ((vlc = svq3_get_ue_golomb(&h->gb)) >= 48U){
681 av_log(h->avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
685 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
686 : golomb_to_inter_cbp[vlc];
688 if (IS_INTRA16x16(mb_type) ||
689 (h->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
690 h->qscale += svq3_get_se_golomb(&h->gb);
692 if (h->qscale > 31u) {
693 av_log(h->avctx, AV_LOG_ERROR, "qscale:%d\n", h->qscale);
697 if (IS_INTRA16x16(mb_type)) {
698 AV_ZERO128(h->mb_luma_dc[0] + 0);
699 AV_ZERO128(h->mb_luma_dc[0] + 8);
700 if (svq3_decode_block(&h->gb, h->mb_luma_dc[0], 0, 1)) {
701 av_log(h->avctx, AV_LOG_ERROR,
702 "error while decoding intra luma dc\n");
708 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
709 const int type = ((h->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
711 for (i = 0; i < 4; i++)
712 if ((cbp & (1 << i))) {
713 for (j = 0; j < 4; j++) {
714 k = index ? (1 * (j & 1) + 2 * (i & 1) +
715 2 * (j & 2) + 4 * (i & 2))
717 h->non_zero_count_cache[scan8[k]] = 1;
719 if (svq3_decode_block(&h->gb, &h->mb[16 * k], index, type)) {
720 av_log(h->avctx, AV_LOG_ERROR,
721 "error while decoding block\n");
728 for (i = 1; i < 3; ++i)
729 if (svq3_decode_block(&h->gb, &h->mb[16 * 16 * i], 0, 3)) {
730 av_log(h->avctx, AV_LOG_ERROR,
731 "error while decoding chroma dc block\n");
736 for (i = 1; i < 3; i++) {
737 for (j = 0; j < 4; j++) {
739 h->non_zero_count_cache[scan8[k]] = 1;
741 if (svq3_decode_block(&h->gb, &h->mb[16 * k], 1, 1)) {
742 av_log(h->avctx, AV_LOG_ERROR,
743 "error while decoding chroma ac block\n");
753 h->cur_pic.f.mb_type[mb_xy] = mb_type;
755 if (IS_INTRA(mb_type))
756 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
761 static int svq3_decode_slice_header(AVCodecContext *avctx)
763 SVQ3Context *s = avctx->priv_data;
764 H264Context *h = &s->h;
765 const int mb_xy = h->mb_xy;
769 header = get_bits(&h->gb, 8);
771 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
773 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
776 int length = header >> 5 & 3;
778 s->next_slice_index = get_bits_count(&h->gb) +
779 8 * show_bits(&h->gb, 8 * length) +
782 if (s->next_slice_index > h->gb.size_in_bits) {
783 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
787 h->gb.size_in_bits = s->next_slice_index - 8 * (length - 1);
788 skip_bits(&h->gb, 8);
790 if (s->watermark_key) {
791 uint32_t header = AV_RL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1]);
792 AV_WL32(&h->gb.buffer[(get_bits_count(&h->gb) >> 3) + 1],
793 header ^ s->watermark_key);
796 memcpy((uint8_t *) &h->gb.buffer[get_bits_count(&h->gb) >> 3],
797 &h->gb.buffer[h->gb.size_in_bits >> 3], length - 1);
799 skip_bits_long(&h->gb, 0);
802 if ((slice_id = svq3_get_ue_golomb(&h->gb)) >= 3) {
803 av_log(h->avctx, AV_LOG_ERROR, "illegal slice type %d \n", slice_id);
807 h->slice_type = golomb_to_pict_type[slice_id];
809 if ((header & 0x9F) == 2) {
810 i = (h->mb_num < 64) ? 6 : (1 + av_log2(h->mb_num - 1));
811 h->mb_skip_run = get_bits(&h->gb, i) -
812 (h->mb_y * h->mb_width + h->mb_x);
818 h->slice_num = get_bits(&h->gb, 8);
819 h->qscale = get_bits(&h->gb, 5);
820 s->adaptive_quant = get_bits1(&h->gb);
829 skip_bits(&h->gb, 2);
831 while (get_bits1(&h->gb))
832 skip_bits(&h->gb, 8);
834 /* reset intra predictors and invalidate motion vector references */
836 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
837 -1, 4 * sizeof(int8_t));
838 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_x],
839 -1, 8 * sizeof(int8_t) * h->mb_x);
842 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - h->mb_stride],
843 -1, 8 * sizeof(int8_t) * (h->mb_width - h->mb_x));
846 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - h->mb_stride - 1] + 3] = -1;
852 static av_cold int svq3_decode_init(AVCodecContext *avctx)
854 SVQ3Context *s = avctx->priv_data;
855 H264Context *h = &s->h;
857 unsigned char *extradata;
858 unsigned char *extradata_end;
860 int marker_found = 0;
862 s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
863 s->last_pic = av_mallocz(sizeof(*s->last_pic));
864 s->next_pic = av_mallocz(sizeof(*s->next_pic));
865 if (!s->next_pic || !s->last_pic || !s->cur_pic) {
866 av_freep(&s->cur_pic);
867 av_freep(&s->last_pic);
868 av_freep(&s->next_pic);
869 return AVERROR(ENOMEM);
872 if (ff_h264_decode_init(avctx) < 0)
875 h->flags = avctx->flags;
877 h->sps.chroma_format_idc = 1;
878 h->picture_structure = PICT_FRAME;
879 avctx->pix_fmt = avctx->codec->pix_fmts[0];
881 h->chroma_qp[0] = h->chroma_qp[1] = 4;
882 h->chroma_x_shift = h->chroma_y_shift = 1;
885 s->thirdpel_flag = 1;
888 /* prowl for the "SEQH" marker in the extradata */
889 extradata = (unsigned char *)avctx->extradata;
890 extradata_end = avctx->extradata + avctx->extradata_size;
892 for (m = 0; m + 8 < avctx->extradata_size; m++) {
893 if (!memcmp(extradata, "SEQH", 4)) {
901 /* if a match was found, parse the extra data */
906 size = AV_RB32(&extradata[4]);
907 if (size > extradata_end - extradata - 8)
908 return AVERROR_INVALIDDATA;
909 init_get_bits(&gb, extradata + 8, size * 8);
911 /* 'frame size code' and optional 'width, height' */
912 frame_size_code = get_bits(&gb, 3);
913 switch (frame_size_code) {
943 avctx->width = get_bits(&gb, 12);
944 avctx->height = get_bits(&gb, 12);
948 s->halfpel_flag = get_bits1(&gb);
949 s->thirdpel_flag = get_bits1(&gb);
957 h->low_delay = get_bits1(&gb);
962 while (get_bits1(&gb))
965 s->unknown_flag = get_bits1(&gb);
966 avctx->has_b_frames = !h->low_delay;
967 if (s->unknown_flag) {
969 unsigned watermark_width = svq3_get_ue_golomb(&gb);
970 unsigned watermark_height = svq3_get_ue_golomb(&gb);
971 int u1 = svq3_get_ue_golomb(&gb);
972 int u2 = get_bits(&gb, 8);
973 int u3 = get_bits(&gb, 2);
974 int u4 = svq3_get_ue_golomb(&gb);
975 unsigned long buf_len = watermark_width *
976 watermark_height * 4;
977 int offset = get_bits_count(&gb) + 7 >> 3;
980 if (watermark_height <= 0 || (uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
983 buf = av_malloc(buf_len);
984 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n",
985 watermark_width, watermark_height);
986 av_log(avctx, AV_LOG_DEBUG,
987 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
988 u1, u2, u3, u4, offset);
989 if (uncompress(buf, &buf_len, extradata + 8 + offset,
990 size - offset) != Z_OK) {
991 av_log(avctx, AV_LOG_ERROR,
992 "could not uncompress watermark logo\n");
996 s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
997 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
998 av_log(avctx, AV_LOG_DEBUG,
999 "watermark key %#x\n", s->watermark_key);
1002 av_log(avctx, AV_LOG_ERROR,
1003 "this svq3 file contains watermark which need zlib support compiled in\n");
1009 h->width = avctx->width;
1010 h->height = avctx->height;
1011 h->mb_width = (h->width + 15) / 16;
1012 h->mb_height = (h->height + 15) / 16;
1013 h->mb_stride = h->mb_width + 1;
1014 h->mb_num = h->mb_width * h->mb_height;
1015 h->b_stride = 4 * h->mb_width;
1016 s->h_edge_pos = h->mb_width * 16;
1017 s->v_edge_pos = h->mb_height * 16;
1019 if (ff_h264_alloc_tables(h) < 0) {
1020 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1021 return AVERROR(ENOMEM);
1027 static int get_buffer(AVCodecContext *avctx, Picture *pic)
1029 SVQ3Context *s = avctx->priv_data;
1030 H264Context *h = &s->h;
1031 const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
1032 const int mb_array_size = h->mb_stride * h->mb_height;
1033 const int b4_stride = h->mb_width * 4 + 1;
1034 const int b4_array_size = b4_stride * h->mb_height * 4;
1037 if (!pic->motion_val_base[0]) {
1040 pic->mb_type_base = av_mallocz((big_mb_num + h->mb_stride) * sizeof(uint32_t));
1041 if (!pic->mb_type_base)
1042 return AVERROR(ENOMEM);
1043 pic->f.mb_type = pic->mb_type_base + 2 * h->mb_stride + 1;
1045 for (i = 0; i < 2; i++) {
1046 pic->motion_val_base[i] = av_mallocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1047 pic->f.ref_index[i] = av_mallocz(4 * mb_array_size);
1048 if (!pic->motion_val_base[i] || !pic->f.ref_index[i])
1049 return AVERROR(ENOMEM);
1051 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
1054 pic->f.motion_subsample_log2 = 2;
1055 pic->f.reference = !(h->pict_type == AV_PICTURE_TYPE_B);
1057 ret = ff_get_buffer(avctx, &pic->f);
1059 h->linesize = pic->f.linesize[0];
1060 h->uvlinesize = pic->f.linesize[1];
1065 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1066 int *got_frame, AVPacket *avpkt)
1068 SVQ3Context *s = avctx->priv_data;
1069 H264Context *h = &s->h;
1070 int buf_size = avpkt->size;
1075 /* special case for last picture */
1076 if (buf_size == 0) {
1077 if (s->next_pic->f.data[0] && !h->low_delay && !s->last_frame_output) {
1078 *(AVFrame *) data = s->next_pic->f;
1079 s->last_frame_output = 1;
1085 h->mb_x = h->mb_y = h->mb_xy = 0;
1087 if (s->watermark_key) {
1088 av_fast_malloc(&s->buf, &s->buf_size,
1089 buf_size+FF_INPUT_BUFFER_PADDING_SIZE);
1091 return AVERROR(ENOMEM);
1092 memcpy(s->buf, avpkt->data, buf_size);
1098 init_get_bits(&h->gb, buf, 8 * buf_size);
1100 if (svq3_decode_slice_header(avctx))
1103 h->pict_type = h->slice_type;
1105 if (h->pict_type != AV_PICTURE_TYPE_B)
1106 FFSWAP(Picture*, s->next_pic, s->last_pic);
1108 if (s->cur_pic->f.data[0])
1109 avctx->release_buffer(avctx, &s->cur_pic->f);
1111 /* for skipping the frame */
1112 s->cur_pic->f.pict_type = h->pict_type;
1113 s->cur_pic->f.key_frame = (h->pict_type == AV_PICTURE_TYPE_I);
1115 ret = get_buffer(avctx, s->cur_pic);
1119 h->cur_pic_ptr = s->cur_pic;
1120 h->cur_pic = *s->cur_pic;
1122 for (i = 0; i < 16; i++) {
1123 h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1124 h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->linesize * ((scan8[i] - scan8[0]) >> 3);
1126 for (i = 0; i < 16; i++) {
1127 h->block_offset[16 + i] =
1128 h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1129 h->block_offset[48 + 16 + i] =
1130 h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
1133 if (h->pict_type != AV_PICTURE_TYPE_I) {
1134 if (!s->last_pic->f.data[0]) {
1135 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1136 ret = get_buffer(avctx, s->last_pic);
1139 memset(s->last_pic->f.data[0], 0, avctx->height * s->last_pic->f.linesize[0]);
1140 memset(s->last_pic->f.data[1], 0x80, (avctx->height / 2) *
1141 s->last_pic->f.linesize[1]);
1142 memset(s->last_pic->f.data[2], 0x80, (avctx->height / 2) *
1143 s->last_pic->f.linesize[2]);
1146 if (h->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f.data[0]) {
1147 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1148 ret = get_buffer(avctx, s->next_pic);
1151 memset(s->next_pic->f.data[0], 0, avctx->height * s->next_pic->f.linesize[0]);
1152 memset(s->next_pic->f.data[1], 0x80, (avctx->height / 2) *
1153 s->next_pic->f.linesize[1]);
1154 memset(s->next_pic->f.data[2], 0x80, (avctx->height / 2) *
1155 s->next_pic->f.linesize[2]);
1159 if (avctx->debug & FF_DEBUG_PICT_INFO)
1160 av_log(h->avctx, AV_LOG_DEBUG,
1161 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1162 av_get_picture_type_char(h->pict_type),
1163 s->halfpel_flag, s->thirdpel_flag,
1164 s->adaptive_quant, h->qscale, h->slice_num);
1166 if (avctx->skip_frame >= AVDISCARD_NONREF && h->pict_type == AV_PICTURE_TYPE_B ||
1167 avctx->skip_frame >= AVDISCARD_NONKEY && h->pict_type != AV_PICTURE_TYPE_I ||
1168 avctx->skip_frame >= AVDISCARD_ALL)
1171 if (s->next_p_frame_damaged) {
1172 if (h->pict_type == AV_PICTURE_TYPE_B)
1175 s->next_p_frame_damaged = 0;
1178 if (h->pict_type == AV_PICTURE_TYPE_B) {
1179 h->frame_num_offset = h->slice_num - h->prev_frame_num;
1181 if (h->frame_num_offset < 0)
1182 h->frame_num_offset += 256;
1183 if (h->frame_num_offset == 0 ||
1184 h->frame_num_offset >= h->prev_frame_num_offset) {
1185 av_log(h->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1189 h->prev_frame_num = h->frame_num;
1190 h->frame_num = h->slice_num;
1191 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1193 if (h->prev_frame_num_offset < 0)
1194 h->prev_frame_num_offset += 256;
1197 for (m = 0; m < 2; m++) {
1199 for (i = 0; i < 4; i++) {
1201 for (j = -1; j < 4; j++)
1202 h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1204 h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1208 for (h->mb_y = 0; h->mb_y < h->mb_height; h->mb_y++) {
1209 for (h->mb_x = 0; h->mb_x < h->mb_width; h->mb_x++) {
1211 h->mb_xy = h->mb_x + h->mb_y * h->mb_stride;
1213 if ((get_bits_count(&h->gb) + 7) >= h->gb.size_in_bits &&
1214 ((get_bits_count(&h->gb) & 7) == 0 ||
1215 show_bits(&h->gb, -get_bits_count(&h->gb) & 7) == 0)) {
1216 skip_bits(&h->gb, s->next_slice_index - get_bits_count(&h->gb));
1217 h->gb.size_in_bits = 8 * buf_size;
1219 if (svq3_decode_slice_header(avctx))
1222 /* TODO: support s->mb_skip_run */
1225 mb_type = svq3_get_ue_golomb(&h->gb);
1227 if (h->pict_type == AV_PICTURE_TYPE_I)
1229 else if (h->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1231 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1232 av_log(h->avctx, AV_LOG_ERROR,
1233 "error while decoding MB %d %d\n", h->mb_x, h->mb_y);
1238 ff_h264_hl_decode_mb(h);
1240 if (h->pict_type != AV_PICTURE_TYPE_B && !h->low_delay)
1241 h->cur_pic.f.mb_type[h->mb_x + h->mb_y * h->mb_stride] =
1242 (h->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1245 ff_draw_horiz_band(avctx, &h->dsp, s->cur_pic, s->last_pic->f.data[0] ? s->last_pic : NULL,
1246 16 * h->mb_y, 16, h->picture_structure, 0, 1,
1247 h->low_delay, h->mb_height * 16, h->mb_width * 16);
1250 left = buf_size*8 - get_bits_count(&h->gb);
1252 if (h->mb_y != h->mb_height || h->mb_x != h->mb_width) {
1253 av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, h->mb_y, h->mb_x, left);
1254 //av_hex_dump(stderr, buf+buf_size-8, 8);
1258 av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1262 if (h->pict_type == AV_PICTURE_TYPE_B || h->low_delay)
1263 *(AVFrame *)data = s->cur_pic->f;
1265 *(AVFrame *)data = s->last_pic->f;
1267 /* Do not output the last pic after seeking. */
1268 if (s->last_pic->f.data[0] || h->low_delay)
1271 if (h->pict_type != AV_PICTURE_TYPE_B) {
1272 FFSWAP(Picture*, s->cur_pic, s->next_pic);
1278 static void free_picture(AVCodecContext *avctx, Picture *pic)
1281 for (i = 0; i < 2; i++) {
1282 av_freep(&pic->motion_val_base[i]);
1283 av_freep(&pic->f.ref_index[i]);
1285 av_freep(&pic->mb_type_base);
1288 avctx->release_buffer(avctx, &pic->f);
1292 static int svq3_decode_end(AVCodecContext *avctx)
1294 SVQ3Context *s = avctx->priv_data;
1295 H264Context *h = &s->h;
1297 free_picture(avctx, s->cur_pic);
1298 free_picture(avctx, s->next_pic);
1299 free_picture(avctx, s->last_pic);
1301 ff_h264_free_context(h);
1309 AVCodec ff_svq3_decoder = {
1311 .type = AVMEDIA_TYPE_VIDEO,
1312 .id = AV_CODEC_ID_SVQ3,
1313 .priv_data_size = sizeof(SVQ3Context),
1314 .init = svq3_decode_init,
1315 .close = svq3_decode_end,
1316 .decode = svq3_decode_frame,
1317 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND |
1320 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1321 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,