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"
36 #include "libavutil/thread.h"
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;
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)) {
196 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
198 return AVERROR_INVALIDDATA; /* invalid vector */
200 av_assert0(stages >= 0);
202 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
205 for (y = 0; y < height; y++)
206 memset(&dst[y * (pitch / 4)], mean, width);
208 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
210 for (y = 0; y < height; y++) {
211 for (x = 0; x < width / 4; x++, codebook++) {
216 dst[x] = n1 << 8 | n2;
226 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
232 const uint32_t *codebook;
237 int x, y, width, height, level;
238 uint32_t n1, n2, n3, n4;
240 /* initialize list for breadth first processing of vectors */
243 /* recursively process vector */
244 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
245 SVQ1_PROCESS_VECTOR();
247 /* destination address and vector size */
248 dst = (uint32_t *)list[i];
249 width = 1 << ((4 + level) / 2);
250 height = 1 << ((3 + level) / 2);
252 /* get number of stages (-1 skips vector, 0 for mean only) */
253 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
256 continue; /* skip vector */
258 if ((stages > 0 && level >= 4)) {
260 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
262 return AVERROR_INVALIDDATA; /* invalid vector */
264 av_assert0(stages >= 0);
266 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
268 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
270 for (y = 0; y < height; y++) {
271 for (x = 0; x < width / 4; x++, codebook++) {
273 /* add mean value to vector */
274 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
275 n2 = n4 + (n3 & 0x00FF00FF);
278 dst[x] = n1 << 8 | n2;
286 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
292 for (i = 0; i < 2; i++) {
293 /* get motion code */
294 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
296 return AVERROR_INVALIDDATA;
298 if (get_bits1(bitbuf))
302 /* add median of motion vector predictors and clip result */
304 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
306 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
312 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
313 ptrdiff_t pitch, int x, int y)
319 src = &previous[x + y * pitch];
322 for (i = 0; i < 16; i++) {
323 memcpy(dst, src, 16);
329 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
330 uint8_t *current, uint8_t *previous,
331 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
332 int width, int height)
340 /* predict and decode motion vector */
346 pmv[1] = &motion[x / 8 + 2];
347 pmv[2] = &motion[x / 8 + 4];
350 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
355 motion[x / 8 + 2].x =
356 motion[x / 8 + 3].x = mv.x;
358 motion[x / 8 + 2].y =
359 motion[x / 8 + 3].y = mv.y;
361 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
362 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
364 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
367 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
372 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
373 uint8_t *current, uint8_t *previous,
374 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
375 int width, int height)
383 /* predict and decode motion vector (0) */
389 pmv[1] = &motion[(x / 8) + 2];
390 pmv[2] = &motion[(x / 8) + 4];
393 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
397 /* predict and decode motion vector (1) */
403 pmv[1] = &motion[(x / 8) + 3];
405 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);
417 /* predict and decode motion vector (3) */
418 pmv[2] = &motion[(x / 8) + 2];
419 pmv[3] = &motion[(x / 8) + 3];
421 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
425 /* form predictions */
426 for (i = 0; i < 4; i++) {
427 int mvx = pmv[i]->x + (i & 1) * 16;
428 int mvy = pmv[i]->y + (i >> 1) * 16;
430 // FIXME: clipping or padding?
431 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
432 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
434 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
437 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
439 /* select next block */
441 current += 8 * (pitch - 1);
449 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
450 GetBitContext *bitbuf,
451 uint8_t *current, uint8_t *previous,
452 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
453 int width, int height)
459 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
461 /* reset motion vectors */
462 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
465 motion[x / 8 + 2].x =
466 motion[x / 8 + 2].y =
467 motion[x / 8 + 3].x =
468 motion[x / 8 + 3].y = 0;
471 switch (block_type) {
472 case SVQ1_BLOCK_SKIP:
473 svq1_skip_block(current, previous, pitch, x, y);
476 case SVQ1_BLOCK_INTER:
477 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
478 pitch, motion, x, y, width, height);
481 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
484 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
487 case SVQ1_BLOCK_INTER_4V:
488 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
489 pitch, motion, x, y, width, height);
492 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
495 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
498 case SVQ1_BLOCK_INTRA:
499 result = svq1_decode_block_intra(bitbuf, current, pitch);
506 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
511 out[0] = get_bits(bitbuf, 8);
512 seed = string_table[out[0]];
514 for (i = 1; i <= out[0]; i++) {
515 out[i] = get_bits(bitbuf, 8) ^ seed;
516 seed = string_table[out[i] ^ seed];
521 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
523 SVQ1Context *s = avctx->priv_data;
524 GetBitContext *bitbuf = &s->gb;
526 int width = s->width;
527 int height = s->height;
529 skip_bits(bitbuf, 8); /* temporal_reference */
533 switch (get_bits(bitbuf, 2)) {
535 frame->pict_type = AV_PICTURE_TYPE_I;
540 frame->pict_type = AV_PICTURE_TYPE_P;
543 av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
544 return AVERROR_INVALIDDATA;
547 if (frame->pict_type == AV_PICTURE_TYPE_I) {
549 if (s->frame_code == 0x50 || s->frame_code == 0x60) {
550 int csum = get_bits(bitbuf, 16);
552 csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));
554 ff_dlog(avctx, "%s checksum (%02x) for packet data\n",
555 (csum == 0) ? "correct" : "incorrect", csum);
558 if ((s->frame_code ^ 0x10) >= 0x50) {
561 svq1_parse_string(bitbuf, msg);
563 av_log(avctx, AV_LOG_INFO,
564 "embedded message:\n%s\n", ((char *)msg) + 1);
567 skip_bits(bitbuf, 2);
568 skip_bits(bitbuf, 2);
571 /* load frame size */
572 frame_size_code = get_bits(bitbuf, 3);
574 if (frame_size_code == 7) {
575 /* load width, height (12 bits each) */
576 width = get_bits(bitbuf, 12);
577 height = get_bits(bitbuf, 12);
579 if (!width || !height)
580 return AVERROR_INVALIDDATA;
582 /* get width, height from table */
583 width = ff_svq1_frame_size_table[frame_size_code][0];
584 height = ff_svq1_frame_size_table[frame_size_code][1];
589 if (get_bits1(bitbuf)) {
590 skip_bits1(bitbuf); /* use packet checksum if (1) */
591 skip_bits1(bitbuf); /* component checksums after image data if (1) */
593 if (get_bits(bitbuf, 2) != 0)
594 return AVERROR_INVALIDDATA;
597 if (get_bits1(bitbuf)) {
599 skip_bits(bitbuf, 4);
601 skip_bits(bitbuf, 2);
603 if (skip_1stop_8data_bits(bitbuf) < 0)
604 return AVERROR_INVALIDDATA;
606 if (get_bits_left(bitbuf) <= 0)
607 return AVERROR_INVALIDDATA;
614 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
615 int *got_frame, AVPacket *avpkt)
617 const uint8_t *buf = avpkt->data;
618 int buf_size = avpkt->size;
619 SVQ1Context *s = avctx->priv_data;
622 int result, i, x, y, width, height;
626 /* initialize bit buffer */
627 ret = init_get_bits8(&s->gb, buf, buf_size);
631 /* decode frame header */
632 s->frame_code = get_bits(&s->gb, 22);
634 if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
635 return AVERROR_INVALIDDATA;
637 /* swap some header bytes (why?) */
638 if (s->frame_code != 0x20) {
641 if (buf_size < 9 * 4) {
642 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
643 return AVERROR_INVALIDDATA;
646 av_fast_padded_malloc(&s->pkt_swapped,
647 &s->pkt_swapped_allocated,
650 return AVERROR(ENOMEM);
652 memcpy(s->pkt_swapped, buf, buf_size);
653 buf = s->pkt_swapped;
654 init_get_bits(&s->gb, buf, buf_size * 8);
655 skip_bits(&s->gb, 22);
657 src = (uint32_t *)(s->pkt_swapped + 4);
659 for (i = 0; i < 4; i++)
660 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
663 result = svq1_decode_frame_header(avctx, cur);
665 ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
669 result = ff_set_dimensions(avctx, s->width, s->height);
673 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
674 (avctx->skip_frame >= AVDISCARD_NONKEY &&
675 cur->pict_type != AV_PICTURE_TYPE_I) ||
676 avctx->skip_frame >= AVDISCARD_ALL)
679 result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
683 pmv = av_malloc_array(FFALIGN(s->width, 16) / 8 + 3, sizeof(*pmv));
685 return AVERROR(ENOMEM);
687 /* decode y, u and v components */
688 for (i = 0; i < 3; i++) {
689 int linesize = cur->linesize[i];
691 width = FFALIGN(s->width, 16);
692 height = FFALIGN(s->height, 16);
694 if (avctx->flags & AV_CODEC_FLAG_GRAY)
696 width = FFALIGN(s->width / 4, 16);
697 height = FFALIGN(s->height / 4, 16);
700 current = cur->data[i];
702 if (cur->pict_type == AV_PICTURE_TYPE_I) {
704 for (y = 0; y < height; y += 16) {
705 for (x = 0; x < width; x += 16) {
706 result = svq1_decode_block_intra(&s->gb, ¤t[x],
709 av_log(avctx, AV_LOG_ERROR,
710 "Error in svq1_decode_block %i (keyframe)\n",
715 current += 16 * linesize;
719 uint8_t *previous = s->prev->data[i];
721 s->prev->width != s->width || s->prev->height != s->height) {
722 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
723 result = AVERROR_INVALIDDATA;
727 memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
729 for (y = 0; y < height; y += 16) {
730 for (x = 0; x < width; x += 16) {
731 result = svq1_decode_delta_block(avctx, &s->hdsp,
734 pmv, x, y, width, height);
737 "Error in svq1_decode_delta_block %i\n",
746 current += 16 * linesize;
752 av_frame_unref(s->prev);
753 result = av_frame_ref(s->prev, cur);
766 static av_cold void svq1_static_init(void)
768 INIT_VLC_STATIC(&svq1_block_type, 2, 4,
769 &ff_svq1_block_type_vlc[0][1], 2, 1,
770 &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
772 INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
773 &ff_mvtab[0][1], 2, 1,
774 &ff_mvtab[0][0], 2, 1, 176);
776 for (int i = 0, offset = 0; i < 6; i++) {
777 static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
778 { 10, 10, 14, 14, 14, 16 } };
779 static VLC_TYPE table[168][2];
780 svq1_intra_multistage[i].table = &table[offset];
781 svq1_intra_multistage[i].table_allocated = sizes[0][i];
782 offset += sizes[0][i];
783 init_vlc(&svq1_intra_multistage[i], 3, 8,
784 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
785 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
786 INIT_VLC_USE_NEW_STATIC);
787 svq1_inter_multistage[i].table = &table[offset];
788 svq1_inter_multistage[i].table_allocated = sizes[1][i];
789 offset += sizes[1][i];
790 init_vlc(&svq1_inter_multistage[i], 3, 8,
791 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
792 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
793 INIT_VLC_USE_NEW_STATIC);
796 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
797 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
798 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
800 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
801 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
802 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
805 static av_cold int svq1_decode_init(AVCodecContext *avctx)
807 static AVOnce init_static_once = AV_ONCE_INIT;
808 SVQ1Context *s = avctx->priv_data;
810 s->prev = av_frame_alloc();
812 return AVERROR(ENOMEM);
814 s->width = avctx->width + 3 & ~3;
815 s->height = avctx->height + 3 & ~3;
816 avctx->pix_fmt = AV_PIX_FMT_YUV410P;
818 ff_hpeldsp_init(&s->hdsp, avctx->flags);
820 ff_thread_once(&init_static_once, svq1_static_init);
825 static av_cold int svq1_decode_end(AVCodecContext *avctx)
827 SVQ1Context *s = avctx->priv_data;
829 av_frame_free(&s->prev);
830 av_freep(&s->pkt_swapped);
831 s->pkt_swapped_allocated = 0;
836 static void svq1_flush(AVCodecContext *avctx)
838 SVQ1Context *s = avctx->priv_data;
840 av_frame_unref(s->prev);
843 AVCodec ff_svq1_decoder = {
845 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
846 .type = AVMEDIA_TYPE_VIDEO,
847 .id = AV_CODEC_ID_SVQ1,
848 .priv_data_size = sizeof(SVQ1Context),
849 .init = svq1_decode_init,
850 .close = svq1_decode_end,
851 .decode = svq1_decode_frame,
852 .capabilities = AV_CODEC_CAP_DR1,
854 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
856 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,