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 Libav.
13 * Libav 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 * Libav 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 Libav; 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) == 0) \
119 /* add child nodes */ \
120 list[n++] = list[i]; \
121 list[n++] = list[i] + \
122 (((level & 1) ? pitch : 1) << (level / 2 + 1)); \
125 #define SVQ1_ADD_CODEBOOK() \
126 /* add codebook entries to vector */ \
127 for (j = 0; j < stages; j++) { \
128 n3 = codebook[entries[j]] ^ 0x80808080; \
129 n1 += (n3 & 0xFF00FF00) >> 8; \
130 n2 += n3 & 0x00FF00FF; \
133 /* clip to [0..255] */ \
134 if (n1 & 0xFF00FF00) { \
135 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
137 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
138 n1 &= n3 & 0x00FF00FF; \
141 if (n2 & 0xFF00FF00) { \
142 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
144 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
145 n2 &= n3 & 0x00FF00FF; \
148 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
149 codebook = (const uint32_t *)cbook[level]; \
151 bit_cache = get_bits(bitbuf, 4 * stages); \
152 /* calculate codebook entries for this vector */ \
153 for (j = 0; j < stages; j++) { \
154 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
155 16 * j) << (level + 1); \
157 mean -= stages * 128; \
158 n4 = mean + (mean >> 31) << 16 | (mean & 0xFFFF);
160 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
166 const uint32_t *codebook;
170 unsigned x, y, width, height, level;
171 uint32_t n1, n2, n3, n4;
173 /* initialize list for breadth first processing of vectors */
176 /* recursively process vector */
177 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
178 SVQ1_PROCESS_VECTOR();
180 /* destination address and vector size */
181 dst = (uint32_t *)list[i];
182 width = 1 << ((4 + level) / 2);
183 height = 1 << ((3 + level) / 2);
185 /* get number of stages (-1 skips vector, 0 for mean only) */
186 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
189 for (y = 0; y < height; y++)
190 memset(&dst[y * (pitch / 4)], 0, width);
191 continue; /* skip vector */
194 if ((stages > 0 && level >= 4) || stages < 0) {
196 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
198 return AVERROR_INVALIDDATA; /* invalid vector */
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;
235 int x, y, width, height, level;
236 uint32_t n1, n2, n3, n4;
238 /* initialize list for breadth first processing of vectors */
241 /* recursively process vector */
242 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
243 SVQ1_PROCESS_VECTOR();
245 /* destination address and vector size */
246 dst = (uint32_t *)list[i];
247 width = 1 << ((4 + level) / 2);
248 height = 1 << ((3 + level) / 2);
250 /* get number of stages (-1 skips vector, 0 for mean only) */
251 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
254 continue; /* skip vector */
256 if ((stages > 0 && level >= 4) || stages < 0) {
258 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
260 return AVERROR_INVALIDDATA; /* invalid vector */
263 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
265 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
267 for (y = 0; y < height; y++) {
268 for (x = 0; x < width / 4; x++, codebook++) {
270 /* add mean value to vector */
271 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
272 n2 = n4 + (n3 & 0x00FF00FF);
275 dst[x] = n1 << 8 | n2;
283 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
289 for (i = 0; i < 2; i++) {
290 /* get motion code */
291 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
293 return AVERROR_INVALIDDATA;
295 if (get_bits1(bitbuf))
299 /* add median of motion vector predictors and clip result */
301 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
303 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
309 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
310 int pitch, int x, int y)
316 src = &previous[x + y * pitch];
319 for (i = 0; i < 16; i++) {
320 memcpy(dst, src, 16);
326 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
327 uint8_t *current, uint8_t *previous,
328 int pitch, svq1_pmv *motion, int x, int y,
329 int width, int height)
337 /* predict and decode motion vector */
343 pmv[1] = &motion[x / 8 + 2];
344 pmv[2] = &motion[x / 8 + 4];
347 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
353 motion[x / 8 + 2].x =
354 motion[x / 8 + 3].x = mv.x;
356 motion[x / 8 + 2].y =
357 motion[x / 8 + 3].y = mv.y;
359 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
360 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
362 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
365 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
370 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
371 uint8_t *current, uint8_t *previous,
372 int pitch, svq1_pmv *motion, int x, int y,
373 int width, int height)
381 /* predict and decode motion vector (0) */
387 pmv[1] = &motion[(x / 8) + 2];
388 pmv[2] = &motion[(x / 8) + 4];
391 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);
409 /* predict and decode motion vector (2) */
411 pmv[2] = &motion[(x / 8) + 1];
413 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
418 /* predict and decode motion vector (3) */
419 pmv[2] = &motion[(x / 8) + 2];
420 pmv[3] = &motion[(x / 8) + 3];
422 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
427 /* form predictions */
428 for (i = 0; i < 4; i++) {
429 int mvx = pmv[i]->x + (i & 1) * 16;
430 int mvy = pmv[i]->y + (i >> 1) * 16;
432 // FIXME: clipping or padding?
433 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
434 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
436 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
439 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
441 /* select next block */
443 current += 8 * (pitch - 1);
451 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
452 GetBitContext *bitbuf,
453 uint8_t *current, uint8_t *previous,
454 int pitch, svq1_pmv *motion, int x, int y,
455 int width, int height)
461 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
463 /* reset motion vectors */
464 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
467 motion[x / 8 + 2].x =
468 motion[x / 8 + 2].y =
469 motion[x / 8 + 3].x =
470 motion[x / 8 + 3].y = 0;
473 switch (block_type) {
474 case SVQ1_BLOCK_SKIP:
475 svq1_skip_block(current, previous, pitch, x, y);
478 case SVQ1_BLOCK_INTER:
479 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
480 pitch, motion, x, y, width, height);
483 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
486 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
489 case SVQ1_BLOCK_INTER_4V:
490 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
491 pitch, motion, x, y, width, height);
494 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
497 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
500 case SVQ1_BLOCK_INTRA:
501 result = svq1_decode_block_intra(bitbuf, current, pitch);
508 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
513 out[0] = get_bits(bitbuf, 8);
514 seed = string_table[out[0]];
516 for (i = 1; i <= out[0]; i++) {
517 out[i] = get_bits(bitbuf, 8) ^ seed;
518 seed = string_table[out[i] ^ seed];
522 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
524 SVQ1Context *s = avctx->priv_data;
525 GetBitContext *bitbuf = &s->gb;
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 = ff_svq1_packet_checksum(bitbuf->buffer,
552 bitbuf->size_in_bits >> 3,
555 ff_dlog(avctx, "%s checksum (%02x) for packet data\n",
556 (csum == 0) ? "correct" : "incorrect", csum);
559 if ((s->frame_code ^ 0x10) >= 0x50) {
562 svq1_parse_string(bitbuf, msg);
564 av_log(avctx, AV_LOG_INFO,
565 "embedded message: \"%s\"\n", (char *)msg);
568 skip_bits(bitbuf, 2);
569 skip_bits(bitbuf, 2);
572 /* load frame size */
573 frame_size_code = get_bits(bitbuf, 3);
575 if (frame_size_code == 7) {
576 /* load width, height (12 bits each) */
577 s->width = get_bits(bitbuf, 12);
578 s->height = get_bits(bitbuf, 12);
580 if (!s->width || !s->height)
581 return AVERROR_INVALIDDATA;
583 /* get width, height from table */
584 s->width = ff_svq1_frame_size_table[frame_size_code][0];
585 s->height = ff_svq1_frame_size_table[frame_size_code][1];
590 if (get_bits1(bitbuf) == 1) {
591 skip_bits1(bitbuf); /* use packet checksum if (1) */
592 skip_bits1(bitbuf); /* component checksums after image data if (1) */
594 if (get_bits(bitbuf, 2) != 0)
595 return AVERROR_INVALIDDATA;
598 if (get_bits1(bitbuf) == 1) {
600 skip_bits(bitbuf, 4);
602 skip_bits(bitbuf, 2);
604 while (get_bits1(bitbuf) == 1)
605 skip_bits(bitbuf, 8);
611 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
612 int *got_frame, AVPacket *avpkt)
614 const uint8_t *buf = avpkt->data;
615 int buf_size = avpkt->size;
616 SVQ1Context *s = avctx->priv_data;
619 int result, i, x, y, width, height;
622 /* initialize bit buffer */
623 init_get_bits(&s->gb, buf, buf_size * 8);
625 /* decode frame header */
626 s->frame_code = get_bits(&s->gb, 22);
628 if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
629 return AVERROR_INVALIDDATA;
631 /* swap some header bytes (why?) */
632 if (s->frame_code != 0x20) {
635 if (buf_size < 9 * 4) {
636 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
637 return AVERROR_INVALIDDATA;
640 av_fast_padded_malloc(&s->pkt_swapped,
641 &s->pkt_swapped_allocated,
644 return AVERROR(ENOMEM);
646 memcpy(s->pkt_swapped, buf, buf_size);
647 buf = s->pkt_swapped;
648 init_get_bits(&s->gb, buf, buf_size * 8);
649 skip_bits(&s->gb, 22);
651 src = (uint32_t *)(s->pkt_swapped + 4);
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);
660 ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
664 result = ff_set_dimensions(avctx, s->width, s->height);
668 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
669 (avctx->skip_frame >= AVDISCARD_NONKEY &&
670 cur->pict_type != AV_PICTURE_TYPE_I) ||
671 avctx->skip_frame >= AVDISCARD_ALL)
674 result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
678 pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
680 return AVERROR(ENOMEM);
682 /* decode y, u and v components */
683 for (i = 0; i < 3; i++) {
684 int linesize = cur->linesize[i];
686 width = FFALIGN(s->width, 16);
687 height = FFALIGN(s->height, 16);
689 if (avctx->flags & AV_CODEC_FLAG_GRAY)
691 width = FFALIGN(s->width / 4, 16);
692 height = FFALIGN(s->height / 4, 16);
695 current = cur->data[i];
697 if (cur->pict_type == AV_PICTURE_TYPE_I) {
699 for (y = 0; y < height; y += 16) {
700 for (x = 0; x < width; x += 16) {
701 result = svq1_decode_block_intra(&s->gb, ¤t[x],
704 av_log(avctx, AV_LOG_INFO,
705 "Error in svq1_decode_block %i (keyframe)\n",
710 current += 16 * linesize;
714 uint8_t *previous = s->prev->data[i];
716 s->prev->width != s->width || s->prev->height != s->height) {
717 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
718 result = AVERROR_INVALIDDATA;
722 memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
724 for (y = 0; y < height; y += 16) {
725 for (x = 0; x < width; x += 16) {
726 result = svq1_decode_delta_block(avctx, &s->hdsp,
729 pmv, x, y, width, height);
732 "Error in svq1_decode_delta_block %i\n",
741 current += 16 * linesize;
747 av_frame_unref(s->prev);
748 result = av_frame_ref(s->prev, cur);
761 static av_cold int svq1_decode_init(AVCodecContext *avctx)
763 SVQ1Context *s = avctx->priv_data;
767 s->prev = av_frame_alloc();
769 return AVERROR(ENOMEM);
771 s->width = avctx->width + 3 & ~3;
772 s->height = avctx->height + 3 & ~3;
773 avctx->pix_fmt = AV_PIX_FMT_YUV410P;
775 ff_hpeldsp_init(&s->hdsp, avctx->flags);
777 INIT_VLC_STATIC(&svq1_block_type, 2, 4,
778 &ff_svq1_block_type_vlc[0][1], 2, 1,
779 &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
781 INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
782 &ff_mvtab[0][1], 2, 1,
783 &ff_mvtab[0][0], 2, 1, 176);
785 for (i = 0; i < 6; i++) {
786 static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
787 { 10, 10, 14, 14, 14, 16 } };
788 static VLC_TYPE table[168][2];
789 svq1_intra_multistage[i].table = &table[offset];
790 svq1_intra_multistage[i].table_allocated = sizes[0][i];
791 offset += sizes[0][i];
792 init_vlc(&svq1_intra_multistage[i], 3, 8,
793 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
794 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
795 INIT_VLC_USE_NEW_STATIC);
796 svq1_inter_multistage[i].table = &table[offset];
797 svq1_inter_multistage[i].table_allocated = sizes[1][i];
798 offset += sizes[1][i];
799 init_vlc(&svq1_inter_multistage[i], 3, 8,
800 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
801 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
802 INIT_VLC_USE_NEW_STATIC);
805 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
806 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
807 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
809 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
810 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
811 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
816 static av_cold int svq1_decode_end(AVCodecContext *avctx)
818 SVQ1Context *s = avctx->priv_data;
820 av_frame_free(&s->prev);
821 av_freep(&s->pkt_swapped);
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 = AV_CODEC_CAP_DR1,
844 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,