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 #define SVQ1_BLOCK_TYPE_VLC_BITS 3
47 static VLC svq1_block_type;
48 static VLC svq1_motion_component;
49 static VLC svq1_intra_multistage[6];
50 static VLC svq1_inter_multistage[6];
51 static VLC svq1_intra_mean;
52 static VLC svq1_inter_mean;
54 /* motion vector (prediction) */
55 typedef struct svq1_pmv_s {
60 typedef struct SVQ1Context {
66 int pkt_swapped_allocated;
74 int nonref; // 1 if the current frame won't be referenced
77 static const uint8_t string_table[256] = {
78 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
79 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
80 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
81 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
82 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
83 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
84 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
85 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
86 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
87 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
88 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
89 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
90 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
91 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
92 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
93 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
94 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
95 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
96 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
97 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
98 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
99 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
100 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
101 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
102 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
103 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
104 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
105 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
106 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
107 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
108 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
109 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
112 #define SVQ1_PROCESS_VECTOR() \
113 for (; level > 0; i++) { \
114 /* process next depth */ \
120 /* divide block if next bit set */ \
121 if (!get_bits1(bitbuf)) \
123 /* add child nodes */ \
124 list[n++] = list[i]; \
125 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
128 #define SVQ1_ADD_CODEBOOK() \
129 /* add codebook entries to vector */ \
130 for (j = 0; j < stages; j++) { \
131 n3 = codebook[entries[j]] ^ 0x80808080; \
132 n1 += (n3 & 0xFF00FF00) >> 8; \
133 n2 += n3 & 0x00FF00FF; \
136 /* clip to [0..255] */ \
137 if (n1 & 0xFF00FF00) { \
138 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
140 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
141 n1 &= n3 & 0x00FF00FF; \
144 if (n2 & 0xFF00FF00) { \
145 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
147 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
148 n2 &= n3 & 0x00FF00FF; \
151 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
152 codebook = (const uint32_t *)cbook[level]; \
154 bit_cache = get_bits(bitbuf, 4 * stages); \
155 /* calculate codebook entries for this vector */ \
156 for (j = 0; j < stages; j++) { \
157 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
158 16 * j) << (level + 1); \
160 mean -= stages * 128; \
161 n4 = (mean << 16) + mean;
163 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
169 const uint32_t *codebook;
174 unsigned x, y, width, height, level;
175 uint32_t n1, n2, n3, n4;
177 /* initialize list for breadth first processing of vectors */
180 /* recursively process vector */
181 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
182 SVQ1_PROCESS_VECTOR();
184 /* destination address and vector size */
185 dst = (uint32_t *)list[i];
186 width = 1 << ((4 + level) / 2);
187 height = 1 << ((3 + level) / 2);
189 /* get number of stages (-1 skips vector, 0 for mean only) */
190 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
193 for (y = 0; y < height; y++)
194 memset(&dst[y * (pitch / 4)], 0, width);
195 continue; /* skip vector */
198 if ((stages > 0 && level >= 4)) {
200 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
202 return AVERROR_INVALIDDATA; /* invalid vector */
204 av_assert0(stages >= 0);
206 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
209 for (y = 0; y < height; y++)
210 memset(&dst[y * (pitch / 4)], mean, width);
212 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
214 for (y = 0; y < height; y++) {
215 for (x = 0; x < width / 4; x++, codebook++) {
220 dst[x] = n1 << 8 | n2;
230 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
236 const uint32_t *codebook;
241 int x, y, width, height, level;
242 uint32_t n1, n2, n3, n4;
244 /* initialize list for breadth first processing of vectors */
247 /* recursively process vector */
248 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
249 SVQ1_PROCESS_VECTOR();
251 /* destination address and vector size */
252 dst = (uint32_t *)list[i];
253 width = 1 << ((4 + level) / 2);
254 height = 1 << ((3 + level) / 2);
256 /* get number of stages (-1 skips vector, 0 for mean only) */
257 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
260 continue; /* skip vector */
262 if ((stages > 0 && level >= 4)) {
264 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
266 return AVERROR_INVALIDDATA; /* invalid vector */
268 av_assert0(stages >= 0);
270 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
272 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
274 for (y = 0; y < height; y++) {
275 for (x = 0; x < width / 4; x++, codebook++) {
277 /* add mean value to vector */
278 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
279 n2 = n4 + (n3 & 0x00FF00FF);
282 dst[x] = n1 << 8 | n2;
290 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
296 for (i = 0; i < 2; i++) {
297 /* get motion code */
298 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
300 return AVERROR_INVALIDDATA;
302 if (get_bits1(bitbuf))
306 /* add median of motion vector predictors and clip result */
308 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
310 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
316 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
317 ptrdiff_t pitch, int x, int y)
323 src = &previous[x + y * pitch];
326 for (i = 0; i < 16; i++) {
327 memcpy(dst, src, 16);
333 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
334 uint8_t *current, uint8_t *previous,
335 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
336 int width, int height)
344 /* predict and decode motion vector */
350 pmv[1] = &motion[x / 8 + 2];
351 pmv[2] = &motion[x / 8 + 4];
354 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
359 motion[x / 8 + 2].x =
360 motion[x / 8 + 3].x = mv.x;
362 motion[x / 8 + 2].y =
363 motion[x / 8 + 3].y = mv.y;
365 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
366 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
368 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
371 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
376 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
377 uint8_t *current, uint8_t *previous,
378 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
379 int width, int height)
387 /* predict and decode motion vector (0) */
393 pmv[1] = &motion[(x / 8) + 2];
394 pmv[2] = &motion[(x / 8) + 4];
397 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
401 /* predict and decode motion vector (1) */
407 pmv[1] = &motion[(x / 8) + 3];
409 result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
413 /* predict and decode motion vector (2) */
415 pmv[2] = &motion[(x / 8) + 1];
417 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
421 /* predict and decode motion vector (3) */
422 pmv[2] = &motion[(x / 8) + 2];
423 pmv[3] = &motion[(x / 8) + 3];
425 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
429 /* form predictions */
430 for (i = 0; i < 4; i++) {
431 int mvx = pmv[i]->x + (i & 1) * 16;
432 int mvy = pmv[i]->y + (i >> 1) * 16;
434 // FIXME: clipping or padding?
435 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
436 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
438 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
441 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
443 /* select next block */
445 current += 8 * (pitch - 1);
453 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
454 GetBitContext *bitbuf,
455 uint8_t *current, uint8_t *previous,
456 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
457 int width, int height)
463 block_type = get_vlc2(bitbuf, svq1_block_type.table,
464 SVQ1_BLOCK_TYPE_VLC_BITS, 1);
466 /* reset motion vectors */
467 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
470 motion[x / 8 + 2].x =
471 motion[x / 8 + 2].y =
472 motion[x / 8 + 3].x =
473 motion[x / 8 + 3].y = 0;
476 switch (block_type) {
477 case SVQ1_BLOCK_SKIP:
478 svq1_skip_block(current, previous, pitch, x, y);
481 case SVQ1_BLOCK_INTER:
482 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
483 pitch, motion, x, y, width, height);
486 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
489 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
492 case SVQ1_BLOCK_INTER_4V:
493 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
494 pitch, motion, x, y, width, height);
497 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
500 result = svq1_decode_block_non_intra(bitbuf, current, pitch);
503 case SVQ1_BLOCK_INTRA:
504 result = svq1_decode_block_intra(bitbuf, current, pitch);
511 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
516 out[0] = get_bits(bitbuf, 8);
517 seed = string_table[out[0]];
519 for (i = 1; i <= out[0]; i++) {
520 out[i] = get_bits(bitbuf, 8) ^ seed;
521 seed = string_table[out[i] ^ seed];
526 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
528 SVQ1Context *s = avctx->priv_data;
529 GetBitContext *bitbuf = &s->gb;
531 int width = s->width;
532 int height = s->height;
534 skip_bits(bitbuf, 8); /* temporal_reference */
538 switch (get_bits(bitbuf, 2)) {
540 frame->pict_type = AV_PICTURE_TYPE_I;
545 frame->pict_type = AV_PICTURE_TYPE_P;
548 av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
549 return AVERROR_INVALIDDATA;
552 if (frame->pict_type == AV_PICTURE_TYPE_I) {
554 if (s->frame_code == 0x50 || s->frame_code == 0x60) {
555 int csum = get_bits(bitbuf, 16);
557 csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));
559 ff_dlog(avctx, "%s checksum (%02x) for packet data\n",
560 (csum == 0) ? "correct" : "incorrect", csum);
563 if ((s->frame_code ^ 0x10) >= 0x50) {
566 svq1_parse_string(bitbuf, msg);
568 av_log(avctx, AV_LOG_INFO,
569 "embedded message:\n%s\n", ((char *)msg) + 1);
572 skip_bits(bitbuf, 2);
573 skip_bits(bitbuf, 2);
576 /* load frame size */
577 frame_size_code = get_bits(bitbuf, 3);
579 if (frame_size_code == 7) {
580 /* load width, height (12 bits each) */
581 width = get_bits(bitbuf, 12);
582 height = get_bits(bitbuf, 12);
584 if (!width || !height)
585 return AVERROR_INVALIDDATA;
587 /* get width, height from table */
588 width = ff_svq1_frame_size_table[frame_size_code][0];
589 height = ff_svq1_frame_size_table[frame_size_code][1];
594 if (get_bits1(bitbuf)) {
595 skip_bits1(bitbuf); /* use packet checksum if (1) */
596 skip_bits1(bitbuf); /* component checksums after image data if (1) */
598 if (get_bits(bitbuf, 2) != 0)
599 return AVERROR_INVALIDDATA;
602 if (get_bits1(bitbuf)) {
604 skip_bits(bitbuf, 4);
606 skip_bits(bitbuf, 2);
608 if (skip_1stop_8data_bits(bitbuf) < 0)
609 return AVERROR_INVALIDDATA;
611 if (get_bits_left(bitbuf) <= 0)
612 return AVERROR_INVALIDDATA;
619 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
620 int *got_frame, AVPacket *avpkt)
622 const uint8_t *buf = avpkt->data;
623 int buf_size = avpkt->size;
624 SVQ1Context *s = avctx->priv_data;
627 int result, i, x, y, width, height;
630 /* initialize bit buffer */
631 ret = init_get_bits8(&s->gb, buf, buf_size);
635 /* decode frame header */
636 s->frame_code = get_bits(&s->gb, 22);
638 if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
639 return AVERROR_INVALIDDATA;
641 /* swap some header bytes (why?) */
642 if (s->frame_code != 0x20) {
645 if (buf_size < 9 * 4) {
646 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
647 return AVERROR_INVALIDDATA;
650 av_fast_padded_malloc(&s->pkt_swapped,
651 &s->pkt_swapped_allocated,
654 return AVERROR(ENOMEM);
656 memcpy(s->pkt_swapped, buf, buf_size);
657 buf = s->pkt_swapped;
658 init_get_bits(&s->gb, buf, buf_size * 8);
659 skip_bits(&s->gb, 22);
661 src = (uint32_t *)(s->pkt_swapped + 4);
663 for (i = 0; i < 4; i++)
664 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
667 result = svq1_decode_frame_header(avctx, cur);
669 ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
673 result = ff_set_dimensions(avctx, s->width, s->height);
677 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
678 (avctx->skip_frame >= AVDISCARD_NONKEY &&
679 cur->pict_type != AV_PICTURE_TYPE_I) ||
680 avctx->skip_frame >= AVDISCARD_ALL)
683 result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
687 av_fast_padded_malloc(&s->pmv, &s->pmv_allocated, (FFALIGN(s->width, 16) / 8 + 3) * sizeof(*s->pmv));
689 return AVERROR(ENOMEM);
691 /* decode y, u and v components */
692 for (i = 0; i < 3; i++) {
693 int linesize = cur->linesize[i];
695 width = FFALIGN(s->width, 16);
696 height = FFALIGN(s->height, 16);
698 if (avctx->flags & AV_CODEC_FLAG_GRAY)
700 width = FFALIGN(s->width / 4, 16);
701 height = FFALIGN(s->height / 4, 16);
704 current = cur->data[i];
706 if (cur->pict_type == AV_PICTURE_TYPE_I) {
708 for (y = 0; y < height; y += 16) {
709 for (x = 0; x < width; x += 16) {
710 result = svq1_decode_block_intra(&s->gb, ¤t[x],
713 av_log(avctx, AV_LOG_ERROR,
714 "Error in svq1_decode_block %i (keyframe)\n",
719 current += 16 * linesize;
723 uint8_t *previous = s->prev->data[i];
725 s->prev->width != s->width || s->prev->height != s->height) {
726 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
727 return AVERROR_INVALIDDATA;
730 memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
732 for (y = 0; y < height; y += 16) {
733 for (x = 0; x < width; x += 16) {
734 result = svq1_decode_delta_block(avctx, &s->hdsp,
737 s->pmv, x, y, width, height);
740 "Error in svq1_decode_delta_block %i\n",
749 current += 16 * linesize;
755 av_frame_unref(s->prev);
756 result = av_frame_ref(s->prev, cur);
767 static av_cold void svq1_static_init(void)
769 INIT_VLC_STATIC(&svq1_block_type, SVQ1_BLOCK_TYPE_VLC_BITS, 4,
770 &ff_svq1_block_type_vlc[0][1], 2, 1,
771 &ff_svq1_block_type_vlc[0][0], 2, 1, 8);
773 INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
774 &ff_mvtab[0][1], 2, 1,
775 &ff_mvtab[0][0], 2, 1, 176);
777 for (int i = 0, offset = 0; i < 6; i++) {
778 static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
779 { 10, 10, 14, 14, 14, 16 } };
780 static VLC_TYPE table[168][2];
781 svq1_intra_multistage[i].table = &table[offset];
782 svq1_intra_multistage[i].table_allocated = sizes[0][i];
783 offset += sizes[0][i];
784 init_vlc(&svq1_intra_multistage[i], 3, 8,
785 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
786 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
787 INIT_VLC_USE_NEW_STATIC);
788 svq1_inter_multistage[i].table = &table[offset];
789 svq1_inter_multistage[i].table_allocated = sizes[1][i];
790 offset += sizes[1][i];
791 init_vlc(&svq1_inter_multistage[i], 3, 8,
792 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
793 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
794 INIT_VLC_USE_NEW_STATIC);
797 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
798 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
799 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
801 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
802 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
803 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
806 static av_cold int svq1_decode_init(AVCodecContext *avctx)
808 static AVOnce init_static_once = AV_ONCE_INIT;
809 SVQ1Context *s = avctx->priv_data;
811 s->prev = av_frame_alloc();
813 return AVERROR(ENOMEM);
815 s->width = avctx->width + 3 & ~3;
816 s->height = avctx->height + 3 & ~3;
817 avctx->pix_fmt = AV_PIX_FMT_YUV410P;
819 ff_hpeldsp_init(&s->hdsp, avctx->flags);
821 ff_thread_once(&init_static_once, svq1_static_init);
826 static av_cold int svq1_decode_end(AVCodecContext *avctx)
828 SVQ1Context *s = avctx->priv_data;
830 av_frame_free(&s->prev);
831 av_freep(&s->pkt_swapped);
832 s->pkt_swapped_allocated = 0;
834 s->pmv_allocated = 0;
839 static void svq1_flush(AVCodecContext *avctx)
841 SVQ1Context *s = avctx->priv_data;
843 av_frame_unref(s->prev);
846 AVCodec ff_svq1_decoder = {
848 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
849 .type = AVMEDIA_TYPE_VIDEO,
850 .id = AV_CODEC_ID_SVQ1,
851 .priv_data_size = sizeof(SVQ1Context),
852 .init = svq1_decode_init,
853 .close = svq1_decode_end,
854 .decode = svq1_decode_frame,
855 .capabilities = AV_CODEC_CAP_DR1,
857 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
859 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,