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/
35 #include "libavutil/crc.h"
45 static VLC svq1_block_type;
46 static VLC svq1_motion_component;
47 static VLC svq1_intra_multistage[6];
48 static VLC svq1_inter_multistage[6];
49 static VLC svq1_intra_mean;
50 static VLC svq1_inter_mean;
52 /* motion vector (prediction) */
53 typedef struct svq1_pmv_s {
58 typedef struct SVQ1Context {
64 int pkt_swapped_allocated;
69 int nonref; // 1 if the current frame won't be referenced
72 static const uint8_t string_table[256] = {
73 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
74 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
75 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
76 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
77 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
78 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
79 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
80 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
81 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
82 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
83 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
84 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
85 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
86 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
87 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
88 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
89 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
90 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
91 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
92 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
93 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
94 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
95 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
96 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
97 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
98 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
99 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
100 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
101 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
102 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
103 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
104 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
107 #define SVQ1_PROCESS_VECTOR() \
108 for (; level > 0; i++) { \
109 /* process next depth */ \
115 /* divide block if next bit set */ \
116 if (!get_bits1(bitbuf)) \
118 /* add child nodes */ \
119 list[n++] = list[i]; \
120 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
123 #define SVQ1_ADD_CODEBOOK() \
124 /* add codebook entries to vector */ \
125 for (j = 0; j < stages; j++) { \
126 n3 = codebook[entries[j]] ^ 0x80808080; \
127 n1 += (n3 & 0xFF00FF00) >> 8; \
128 n2 += n3 & 0x00FF00FF; \
131 /* clip to [0..255] */ \
132 if (n1 & 0xFF00FF00) { \
133 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
135 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
136 n1 &= n3 & 0x00FF00FF; \
139 if (n2 & 0xFF00FF00) { \
140 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
142 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
143 n2 &= n3 & 0x00FF00FF; \
146 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
147 codebook = (const uint32_t *)cbook[level]; \
149 bit_cache = get_bits(bitbuf, 4 * stages); \
150 /* calculate codebook entries for this vector */ \
151 for (j = 0; j < stages; j++) { \
152 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
153 16 * j) << (level + 1); \
155 mean -= stages * 128; \
156 n4 = (mean << 16) + mean;
158 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
164 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 */
199 av_assert0(stages >= 0);
201 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
204 for (y = 0; y < height; y++)
205 memset(&dst[y * (pitch / 4)], mean, width);
207 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
209 for (y = 0; y < height; y++) {
210 for (x = 0; x < width / 4; x++, codebook++) {
215 dst[x] = n1 << 8 | n2;
225 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
231 const uint32_t *codebook;
236 int x, y, width, height, level;
237 uint32_t n1, n2, n3, n4;
239 /* initialize list for breadth first processing of vectors */
242 /* recursively process vector */
243 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
244 SVQ1_PROCESS_VECTOR();
246 /* destination address and vector size */
247 dst = (uint32_t *)list[i];
248 width = 1 << ((4 + level) / 2);
249 height = 1 << ((3 + level) / 2);
251 /* get number of stages (-1 skips vector, 0 for mean only) */
252 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
255 continue; /* skip vector */
257 if ((stages > 0 && level >= 4)) {
259 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
261 return AVERROR_INVALIDDATA; /* invalid vector */
263 av_assert0(stages >= 0);
265 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
267 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
269 for (y = 0; y < height; y++) {
270 for (x = 0; x < width / 4; x++, codebook++) {
272 /* add mean value to vector */
273 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
274 n2 = n4 + (n3 & 0x00FF00FF);
277 dst[x] = n1 << 8 | n2;
285 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
291 for (i = 0; i < 2; i++) {
292 /* get motion code */
293 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
295 return AVERROR_INVALIDDATA;
297 if (get_bits1(bitbuf))
301 /* add median of motion vector predictors and clip result */
303 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
305 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
311 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
312 ptrdiff_t pitch, int x, int y)
318 src = &previous[x + y * pitch];
321 for (i = 0; i < 16; i++) {
322 memcpy(dst, src, 16);
328 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
329 uint8_t *current, uint8_t *previous,
330 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
331 int width, int height)
339 /* predict and decode motion vector */
345 pmv[1] = &motion[x / 8 + 2];
346 pmv[2] = &motion[x / 8 + 4];
349 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
354 motion[x / 8 + 2].x =
355 motion[x / 8 + 3].x = mv.x;
357 motion[x / 8 + 2].y =
358 motion[x / 8 + 3].y = mv.y;
360 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
361 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
363 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
366 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
371 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
372 uint8_t *current, uint8_t *previous,
373 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
374 int width, int height)
382 /* predict and decode motion vector (0) */
388 pmv[1] = &motion[(x / 8) + 2];
389 pmv[2] = &motion[(x / 8) + 4];
392 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
396 /* predict and decode motion vector (1) */
402 pmv[1] = &motion[(x / 8) + 3];
404 result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
408 /* predict and decode motion vector (2) */
410 pmv[2] = &motion[(x / 8) + 1];
412 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
416 /* predict and decode motion vector (3) */
417 pmv[2] = &motion[(x / 8) + 2];
418 pmv[3] = &motion[(x / 8) + 3];
420 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
424 /* form predictions */
425 for (i = 0; i < 4; i++) {
426 int mvx = pmv[i]->x + (i & 1) * 16;
427 int mvy = pmv[i]->y + (i >> 1) * 16;
429 // FIXME: clipping or padding?
430 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
431 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
433 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
436 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
438 /* select next block */
440 current += 8 * (pitch - 1);
448 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
449 GetBitContext *bitbuf,
450 uint8_t *current, uint8_t *previous,
451 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
452 int width, int height)
458 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
460 /* reset motion vectors */
461 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
464 motion[x / 8 + 2].x =
465 motion[x / 8 + 2].y =
466 motion[x / 8 + 3].x =
467 motion[x / 8 + 3].y = 0;
470 switch (block_type) {
471 case SVQ1_BLOCK_SKIP:
472 svq1_skip_block(current, previous, pitch, x, y);
475 case SVQ1_BLOCK_INTER:
476 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
477 pitch, motion, x, y, width, height);
480 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
483 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
486 case SVQ1_BLOCK_INTER_4V:
487 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
488 pitch, motion, x, y, width, height);
491 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
494 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
497 case SVQ1_BLOCK_INTRA:
498 result = svq1_decode_block_intra(bitbuf, current, pitch);
505 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
510 out[0] = get_bits(bitbuf, 8);
511 seed = string_table[out[0]];
513 for (i = 1; i <= out[0]; i++) {
514 out[i] = get_bits(bitbuf, 8) ^ seed;
515 seed = string_table[out[i] ^ seed];
520 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
522 SVQ1Context *s = avctx->priv_data;
523 GetBitContext *bitbuf = &s->gb;
525 int width = s->width;
526 int height = s->height;
528 skip_bits(bitbuf, 8); /* temporal_reference */
532 switch (get_bits(bitbuf, 2)) {
534 frame->pict_type = AV_PICTURE_TYPE_I;
539 frame->pict_type = AV_PICTURE_TYPE_P;
542 av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
543 return AVERROR_INVALIDDATA;
546 if (frame->pict_type == AV_PICTURE_TYPE_I) {
548 if (s->frame_code == 0x50 || s->frame_code == 0x60) {
549 int csum = get_bits(bitbuf, 16);
551 csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));
553 ff_dlog(avctx, "%s checksum (%02x) for packet data\n",
554 (csum == 0) ? "correct" : "incorrect", csum);
557 if ((s->frame_code ^ 0x10) >= 0x50) {
560 svq1_parse_string(bitbuf, msg);
562 av_log(avctx, AV_LOG_INFO,
563 "embedded message:\n%s\n", ((char *)msg) + 1);
566 skip_bits(bitbuf, 2);
567 skip_bits(bitbuf, 2);
570 /* load frame size */
571 frame_size_code = get_bits(bitbuf, 3);
573 if (frame_size_code == 7) {
574 /* load width, height (12 bits each) */
575 width = get_bits(bitbuf, 12);
576 height = get_bits(bitbuf, 12);
578 if (!width || !height)
579 return AVERROR_INVALIDDATA;
581 /* get width, height from table */
582 width = ff_svq1_frame_size_table[frame_size_code][0];
583 height = ff_svq1_frame_size_table[frame_size_code][1];
588 if (get_bits1(bitbuf)) {
589 skip_bits1(bitbuf); /* use packet checksum if (1) */
590 skip_bits1(bitbuf); /* component checksums after image data if (1) */
592 if (get_bits(bitbuf, 2) != 0)
593 return AVERROR_INVALIDDATA;
596 if (get_bits1(bitbuf)) {
598 skip_bits(bitbuf, 4);
600 skip_bits(bitbuf, 2);
602 if (skip_1stop_8data_bits(bitbuf) < 0)
603 return AVERROR_INVALIDDATA;
605 if (get_bits_left(bitbuf) <= 0)
606 return AVERROR_INVALIDDATA;
613 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
614 int *got_frame, AVPacket *avpkt)
616 const uint8_t *buf = avpkt->data;
617 int buf_size = avpkt->size;
618 SVQ1Context *s = avctx->priv_data;
621 int result, i, x, y, width, height;
625 /* initialize bit buffer */
626 ret = init_get_bits8(&s->gb, buf, buf_size);
630 /* decode frame header */
631 s->frame_code = get_bits(&s->gb, 22);
633 if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
634 return AVERROR_INVALIDDATA;
636 /* swap some header bytes (why?) */
637 if (s->frame_code != 0x20) {
640 if (buf_size < 9 * 4) {
641 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
642 return AVERROR_INVALIDDATA;
645 av_fast_padded_malloc(&s->pkt_swapped,
646 &s->pkt_swapped_allocated,
649 return AVERROR(ENOMEM);
651 memcpy(s->pkt_swapped, buf, buf_size);
652 buf = s->pkt_swapped;
653 init_get_bits(&s->gb, buf, buf_size * 8);
654 skip_bits(&s->gb, 22);
656 src = (uint32_t *)(s->pkt_swapped + 4);
658 for (i = 0; i < 4; i++)
659 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
662 result = svq1_decode_frame_header(avctx, cur);
664 ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
668 result = ff_set_dimensions(avctx, s->width, s->height);
672 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
673 (avctx->skip_frame >= AVDISCARD_NONKEY &&
674 cur->pict_type != AV_PICTURE_TYPE_I) ||
675 avctx->skip_frame >= AVDISCARD_ALL)
678 result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
682 pmv = av_malloc_array(FFALIGN(s->width, 16) / 8 + 3, sizeof(*pmv));
684 return AVERROR(ENOMEM);
686 /* decode y, u and v components */
687 for (i = 0; i < 3; i++) {
688 int linesize = cur->linesize[i];
690 width = FFALIGN(s->width, 16);
691 height = FFALIGN(s->height, 16);
693 if (avctx->flags & AV_CODEC_FLAG_GRAY)
695 width = FFALIGN(s->width / 4, 16);
696 height = FFALIGN(s->height / 4, 16);
699 current = cur->data[i];
701 if (cur->pict_type == AV_PICTURE_TYPE_I) {
703 for (y = 0; y < height; y += 16) {
704 for (x = 0; x < width; x += 16) {
705 result = svq1_decode_block_intra(&s->gb, ¤t[x],
708 av_log(avctx, AV_LOG_ERROR,
709 "Error in svq1_decode_block %i (keyframe)\n",
714 current += 16 * linesize;
718 uint8_t *previous = s->prev->data[i];
720 s->prev->width != s->width || s->prev->height != s->height) {
721 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
722 result = AVERROR_INVALIDDATA;
726 memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
728 for (y = 0; y < height; y += 16) {
729 for (x = 0; x < width; x += 16) {
730 result = svq1_decode_delta_block(avctx, &s->hdsp,
733 pmv, x, y, width, height);
736 "Error in svq1_decode_delta_block %i\n",
745 current += 16 * linesize;
751 av_frame_unref(s->prev);
752 result = av_frame_ref(s->prev, cur);
765 static av_cold int svq1_decode_init(AVCodecContext *avctx)
767 SVQ1Context *s = avctx->priv_data;
771 s->prev = av_frame_alloc();
773 return AVERROR(ENOMEM);
775 s->width = avctx->width + 3 & ~3;
776 s->height = avctx->height + 3 & ~3;
777 avctx->pix_fmt = AV_PIX_FMT_YUV410P;
779 ff_hpeldsp_init(&s->hdsp, avctx->flags);
781 INIT_VLC_STATIC(&svq1_block_type, 2, 4,
782 &ff_svq1_block_type_vlc[0][1], 2, 1,
783 &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
785 INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
786 &ff_mvtab[0][1], 2, 1,
787 &ff_mvtab[0][0], 2, 1, 176);
789 for (i = 0; i < 6; i++) {
790 static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
791 { 10, 10, 14, 14, 14, 16 } };
792 static VLC_TYPE table[168][2];
793 svq1_intra_multistage[i].table = &table[offset];
794 svq1_intra_multistage[i].table_allocated = sizes[0][i];
795 offset += sizes[0][i];
796 init_vlc(&svq1_intra_multistage[i], 3, 8,
797 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
798 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
799 INIT_VLC_USE_NEW_STATIC);
800 svq1_inter_multistage[i].table = &table[offset];
801 svq1_inter_multistage[i].table_allocated = sizes[1][i];
802 offset += sizes[1][i];
803 init_vlc(&svq1_inter_multistage[i], 3, 8,
804 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
805 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
806 INIT_VLC_USE_NEW_STATIC);
809 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
810 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
811 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
813 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
814 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
815 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
820 static av_cold int svq1_decode_end(AVCodecContext *avctx)
822 SVQ1Context *s = avctx->priv_data;
824 av_frame_free(&s->prev);
825 av_freep(&s->pkt_swapped);
826 s->pkt_swapped_allocated = 0;
831 static void svq1_flush(AVCodecContext *avctx)
833 SVQ1Context *s = avctx->priv_data;
835 av_frame_unref(s->prev);
838 AVCodec ff_svq1_decoder = {
840 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
841 .type = AVMEDIA_TYPE_VIDEO,
842 .id = AV_CODEC_ID_SVQ1,
843 .priv_data_size = sizeof(SVQ1Context),
844 .init = svq1_decode_init,
845 .close = svq1_decode_end,
846 .decode = svq1_decode_frame,
847 .capabilities = AV_CODEC_CAP_DR1,
849 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,