3 * ported to MPlayer by Arpi <arpi@thot.banki.hu>
4 * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
6 * Copyright (C) 2002 the xine project
7 * Copyright (C) 2002 the ffmpeg project
9 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
11 * This file is part of FFmpeg.
13 * FFmpeg is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
18 * FFmpeg is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with FFmpeg; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 * Sorenson Vector Quantizer #1 (SVQ1) video codec.
31 * For more information of the SVQ1 algorithm, visit:
32 * http://www.pcisys.net/~melanson/codecs/
46 static VLC svq1_block_type;
47 static VLC svq1_motion_component;
48 static VLC svq1_intra_multistage[6];
49 static VLC svq1_inter_multistage[6];
50 static VLC svq1_intra_mean;
51 static VLC svq1_inter_mean;
53 /* motion vector (prediction) */
54 typedef struct svq1_pmv_s {
59 typedef struct SVQ1Context {
65 int pkt_swapped_allocated;
70 int nonref; // 1 if the current frame won't be referenced
73 static const uint8_t string_table[256] = {
74 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
75 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
76 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
77 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
78 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
79 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
80 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
81 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
82 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
83 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
84 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
85 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
86 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
87 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
88 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
89 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
90 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
91 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
92 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
93 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
94 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
95 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
96 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
97 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
98 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
99 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
100 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
101 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
102 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
103 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
104 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
105 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
108 #define SVQ1_PROCESS_VECTOR() \
109 for (; level > 0; i++) { \
110 /* process next depth */ \
116 /* divide block if next bit set */ \
117 if (!get_bits1(bitbuf)) \
119 /* add child nodes */ \
120 list[n++] = list[i]; \
121 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
124 #define SVQ1_ADD_CODEBOOK() \
125 /* add codebook entries to vector */ \
126 for (j = 0; j < stages; j++) { \
127 n3 = codebook[entries[j]] ^ 0x80808080; \
128 n1 += (n3 & 0xFF00FF00) >> 8; \
129 n2 += n3 & 0x00FF00FF; \
132 /* clip to [0..255] */ \
133 if (n1 & 0xFF00FF00) { \
134 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
136 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
137 n1 &= n3 & 0x00FF00FF; \
140 if (n2 & 0xFF00FF00) { \
141 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
143 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
144 n2 &= n3 & 0x00FF00FF; \
147 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
148 codebook = (const uint32_t *)cbook[level]; \
150 bit_cache = get_bits(bitbuf, 4 * stages); \
151 /* calculate codebook entries for this vector */ \
152 for (j = 0; j < stages; j++) { \
153 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
154 16 * j) << (level + 1); \
156 mean -= stages * 128; \
157 n4 = (mean << 16) + mean;
159 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
165 const uint32_t *codebook;
169 unsigned x, y, width, height, level;
170 uint32_t n1, n2, n3, n4;
172 /* initialize list for breadth first processing of vectors */
175 /* recursively process vector */
176 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
177 SVQ1_PROCESS_VECTOR();
179 /* destination address and vector size */
180 dst = (uint32_t *)list[i];
181 width = 1 << ((4 + level) / 2);
182 height = 1 << ((3 + level) / 2);
184 /* get number of stages (-1 skips vector, 0 for mean only) */
185 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
188 for (y = 0; y < height; y++)
189 memset(&dst[y * (pitch / 4)], 0, width);
190 continue; /* skip vector */
193 if (stages > 0 && level >= 4) {
195 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
197 return AVERROR_INVALIDDATA; /* invalid vector */
200 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
203 for (y = 0; y < height; y++)
204 memset(&dst[y * (pitch / 4)], mean, width);
206 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
208 for (y = 0; y < height; y++) {
209 for (x = 0; x < width / 4; x++, codebook++) {
214 dst[x] = n1 << 8 | n2;
224 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
230 const uint32_t *codebook;
234 int x, y, width, height, level;
235 uint32_t n1, n2, n3, n4;
237 /* initialize list for breadth first processing of vectors */
240 /* recursively process vector */
241 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
242 SVQ1_PROCESS_VECTOR();
244 /* destination address and vector size */
245 dst = (uint32_t *)list[i];
246 width = 1 << ((4 + level) / 2);
247 height = 1 << ((3 + level) / 2);
249 /* get number of stages (-1 skips vector, 0 for mean only) */
250 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
253 continue; /* skip vector */
255 if ((stages > 0) && (level >= 4)) {
257 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
259 return AVERROR_INVALIDDATA; /* invalid vector */
262 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
264 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
266 for (y = 0; y < height; y++) {
267 for (x = 0; x < width / 4; x++, codebook++) {
269 /* add mean value to vector */
270 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
271 n2 = n4 + (n3 & 0x00FF00FF);
274 dst[x] = n1 << 8 | n2;
282 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
288 for (i = 0; i < 2; i++) {
289 /* get motion code */
290 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
292 return AVERROR_INVALIDDATA;
294 if (get_bits1(bitbuf))
298 /* add median of motion vector predictors and clip result */
300 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
302 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
308 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
309 int pitch, int x, int y)
315 src = &previous[x + y * pitch];
318 for (i = 0; i < 16; i++) {
319 memcpy(dst, src, 16);
325 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
326 uint8_t *current, uint8_t *previous,
327 int pitch, svq1_pmv *motion, int x, int y,
328 int width, int height)
336 /* predict and decode motion vector */
342 pmv[1] = &motion[x / 8 + 2];
343 pmv[2] = &motion[x / 8 + 4];
346 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
351 motion[x / 8 + 2].x =
352 motion[x / 8 + 3].x = mv.x;
354 motion[x / 8 + 2].y =
355 motion[x / 8 + 3].y = mv.y;
357 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
358 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
360 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
363 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
368 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
369 uint8_t *current, uint8_t *previous,
370 int pitch, svq1_pmv *motion, int x, int y,
371 int width, int height)
379 /* predict and decode motion vector (0) */
385 pmv[1] = &motion[(x / 8) + 2];
386 pmv[2] = &motion[(x / 8) + 4];
389 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
393 /* predict and decode motion vector (1) */
399 pmv[1] = &motion[(x / 8) + 3];
401 result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
405 /* predict and decode motion vector (2) */
407 pmv[2] = &motion[(x / 8) + 1];
409 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
413 /* predict and decode motion vector (3) */
414 pmv[2] = &motion[(x / 8) + 2];
415 pmv[3] = &motion[(x / 8) + 3];
417 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
421 /* form predictions */
422 for (i = 0; i < 4; i++) {
423 int mvx = pmv[i]->x + (i & 1) * 16;
424 int mvy = pmv[i]->y + (i >> 1) * 16;
426 // FIXME: clipping or padding?
427 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
428 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
430 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
433 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
435 /* select next block */
437 current += 8 * (pitch - 1);
445 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
446 GetBitContext *bitbuf,
447 uint8_t *current, uint8_t *previous,
448 int pitch, svq1_pmv *motion, int x, int y,
449 int width, int height)
455 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
457 /* reset motion vectors */
458 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
461 motion[x / 8 + 2].x =
462 motion[x / 8 + 2].y =
463 motion[x / 8 + 3].x =
464 motion[x / 8 + 3].y = 0;
467 switch (block_type) {
468 case SVQ1_BLOCK_SKIP:
469 svq1_skip_block(current, previous, pitch, x, y);
472 case SVQ1_BLOCK_INTER:
473 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
474 pitch, motion, x, y, width, height);
477 av_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
480 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
483 case SVQ1_BLOCK_INTER_4V:
484 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
485 pitch, motion, x, y, width, height);
488 av_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
491 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
494 case SVQ1_BLOCK_INTRA:
495 result = svq1_decode_block_intra(bitbuf, current, pitch);
502 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
507 out[0] = get_bits(bitbuf, 8);
508 seed = string_table[out[0]];
510 for (i = 1; i <= out[0]; i++) {
511 out[i] = get_bits(bitbuf, 8) ^ seed;
512 seed = string_table[out[i] ^ seed];
516 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
518 SVQ1Context *s = avctx->priv_data;
519 GetBitContext *bitbuf = &s->gb;
521 int width = s->width;
522 int height = s->height;
524 skip_bits(bitbuf, 8); /* temporal_reference */
528 switch (get_bits(bitbuf, 2)) {
530 frame->pict_type = AV_PICTURE_TYPE_I;
535 frame->pict_type = AV_PICTURE_TYPE_P;
538 av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
539 return AVERROR_INVALIDDATA;
542 if (frame->pict_type == AV_PICTURE_TYPE_I) {
544 if (s->frame_code == 0x50 || s->frame_code == 0x60) {
545 int csum = get_bits(bitbuf, 16);
547 csum = ff_svq1_packet_checksum(bitbuf->buffer,
548 bitbuf->size_in_bits >> 3,
551 av_dlog(avctx, "%s checksum (%02x) for packet data\n",
552 (csum == 0) ? "correct" : "incorrect", csum);
555 if ((s->frame_code ^ 0x10) >= 0x50) {
558 svq1_parse_string(bitbuf, msg);
560 av_log(avctx, AV_LOG_INFO,
561 "embedded message:\n%s\n", (char *)msg);
564 skip_bits(bitbuf, 2);
565 skip_bits(bitbuf, 2);
568 /* load frame size */
569 frame_size_code = get_bits(bitbuf, 3);
571 if (frame_size_code == 7) {
572 /* load width, height (12 bits each) */
573 width = get_bits(bitbuf, 12);
574 height = get_bits(bitbuf, 12);
576 if (!width || !height)
577 return AVERROR_INVALIDDATA;
579 /* get width, height from table */
580 width = ff_svq1_frame_size_table[frame_size_code][0];
581 height = ff_svq1_frame_size_table[frame_size_code][1];
586 if (get_bits1(bitbuf)) {
587 skip_bits1(bitbuf); /* use packet checksum if (1) */
588 skip_bits1(bitbuf); /* component checksums after image data if (1) */
590 if (get_bits(bitbuf, 2) != 0)
591 return AVERROR_INVALIDDATA;
594 if (get_bits1(bitbuf)) {
596 skip_bits(bitbuf, 4);
598 skip_bits(bitbuf, 2);
600 if (skip_1stop_8data_bits(bitbuf) < 0)
601 return AVERROR_INVALIDDATA;
609 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
610 int *got_frame, AVPacket *avpkt)
612 const uint8_t *buf = avpkt->data;
613 int buf_size = avpkt->size;
614 SVQ1Context *s = avctx->priv_data;
617 int result, i, x, y, width, height;
620 /* initialize bit buffer */
621 init_get_bits8(&s->gb, buf, buf_size);
623 /* decode frame header */
624 s->frame_code = get_bits(&s->gb, 22);
626 if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
627 return AVERROR_INVALIDDATA;
629 /* swap some header bytes (why?) */
630 if (s->frame_code != 0x20) {
633 if (buf_size < 9 * 4) {
634 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
635 return AVERROR_INVALIDDATA;
638 av_fast_padded_malloc(&s->pkt_swapped, &s->pkt_swapped_allocated,
641 return AVERROR(ENOMEM);
643 memcpy(s->pkt_swapped, buf, buf_size);
644 buf = s->pkt_swapped;
645 init_get_bits(&s->gb, buf, buf_size * 8);
646 skip_bits(&s->gb, 22);
648 src = (uint32_t *)(s->pkt_swapped + 4);
651 return AVERROR_INVALIDDATA;
653 for (i = 0; i < 4; i++)
654 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
657 result = svq1_decode_frame_header(avctx, cur);
659 av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
663 result = ff_set_dimensions(avctx, s->width, s->height);
667 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
668 (avctx->skip_frame >= AVDISCARD_NONKEY &&
669 cur->pict_type != AV_PICTURE_TYPE_I) ||
670 avctx->skip_frame >= AVDISCARD_ALL)
673 result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
677 pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
679 return AVERROR(ENOMEM);
681 /* decode y, u and v components */
682 for (i = 0; i < 3; i++) {
683 int linesize = cur->linesize[i];
685 width = FFALIGN(s->width, 16);
686 height = FFALIGN(s->height, 16);
688 if (avctx->flags & CODEC_FLAG_GRAY)
690 width = FFALIGN(s->width / 4, 16);
691 height = FFALIGN(s->height / 4, 16);
694 current = cur->data[i];
696 if (cur->pict_type == AV_PICTURE_TYPE_I) {
698 for (y = 0; y < height; y += 16) {
699 for (x = 0; x < width; x += 16) {
700 result = svq1_decode_block_intra(&s->gb, ¤t[x],
703 av_log(avctx, AV_LOG_ERROR,
704 "Error in svq1_decode_block %i (keyframe)\n",
709 current += 16 * linesize;
713 uint8_t *previous = s->prev->data[i];
715 s->prev->width != s->width || s->prev->height != s->height) {
716 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
717 result = AVERROR_INVALIDDATA;
721 memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
723 for (y = 0; y < height; y += 16) {
724 for (x = 0; x < width; x += 16) {
725 result = svq1_decode_delta_block(avctx, &s->hdsp,
728 pmv, x, y, width, height);
731 "Error in svq1_decode_delta_block %i\n",
740 current += 16 * linesize;
746 av_frame_unref(s->prev);
747 result = av_frame_ref(s->prev, cur);
760 static av_cold int svq1_decode_init(AVCodecContext *avctx)
762 SVQ1Context *s = avctx->priv_data;
766 s->prev = av_frame_alloc();
768 return AVERROR(ENOMEM);
770 s->width = avctx->width + 3 & ~3;
771 s->height = avctx->height + 3 & ~3;
772 avctx->pix_fmt = AV_PIX_FMT_YUV410P;
774 ff_hpeldsp_init(&s->hdsp, avctx->flags);
776 INIT_VLC_STATIC(&svq1_block_type, 2, 4,
777 &ff_svq1_block_type_vlc[0][1], 2, 1,
778 &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
780 INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
781 &ff_mvtab[0][1], 2, 1,
782 &ff_mvtab[0][0], 2, 1, 176);
784 for (i = 0; i < 6; i++) {
785 static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
786 { 10, 10, 14, 14, 14, 16 } };
787 static VLC_TYPE table[168][2];
788 svq1_intra_multistage[i].table = &table[offset];
789 svq1_intra_multistage[i].table_allocated = sizes[0][i];
790 offset += sizes[0][i];
791 init_vlc(&svq1_intra_multistage[i], 3, 8,
792 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
793 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
794 INIT_VLC_USE_NEW_STATIC);
795 svq1_inter_multistage[i].table = &table[offset];
796 svq1_inter_multistage[i].table_allocated = sizes[1][i];
797 offset += sizes[1][i];
798 init_vlc(&svq1_inter_multistage[i], 3, 8,
799 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
800 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
801 INIT_VLC_USE_NEW_STATIC);
804 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
805 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
806 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
808 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
809 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
810 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
815 static av_cold int svq1_decode_end(AVCodecContext *avctx)
817 SVQ1Context *s = avctx->priv_data;
819 av_frame_free(&s->prev);
820 av_freep(&s->pkt_swapped);
821 s->pkt_swapped_allocated = 0;
826 static void svq1_flush(AVCodecContext *avctx)
828 SVQ1Context *s = avctx->priv_data;
830 av_frame_unref(s->prev);
833 AVCodec ff_svq1_decoder = {
835 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
836 .type = AVMEDIA_TYPE_VIDEO,
837 .id = AV_CODEC_ID_SVQ1,
838 .priv_data_size = sizeof(SVQ1Context),
839 .init = svq1_decode_init,
840 .close = svq1_decode_end,
841 .decode = svq1_decode_frame,
842 .capabilities = CODEC_CAP_DR1,
844 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,