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
[257])
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
];
517 static int svq1_decode_frame_header(AVCodecContext
*avctx
, AVFrame
*frame
)
519 SVQ1Context
*s
= avctx
->priv_data
;
520 GetBitContext
*bitbuf
= &s
->gb
;
522 int width
= s
->width
;
523 int height
= s
->height
;
525 skip_bits(bitbuf
, 8); /* temporal_reference */
529 switch (get_bits(bitbuf
, 2)) {
531 frame
->pict_type
= AV_PICTURE_TYPE_I
;
536 frame
->pict_type
= AV_PICTURE_TYPE_P
;
539 av_log(avctx
, AV_LOG_ERROR
, "Invalid frame type.\n");
540 return AVERROR_INVALIDDATA
;
543 if (frame
->pict_type
== AV_PICTURE_TYPE_I
) {
545 if (s
->frame_code
== 0x50 || s
->frame_code
== 0x60) {
546 int csum
= get_bits(bitbuf
, 16);
548 csum
= ff_svq1_packet_checksum(bitbuf
->buffer
,
549 bitbuf
->size_in_bits
>> 3,
552 av_dlog(avctx
, "%s checksum (%02x) for packet data\n",
553 (csum
== 0) ? "correct" : "incorrect", csum
);
556 if ((s
->frame_code
^ 0x10) >= 0x50) {
559 svq1_parse_string(bitbuf
, msg
);
561 av_log(avctx
, AV_LOG_INFO
,
562 "embedded message:\n%s\n", ((char *)msg
) + 1);
565 skip_bits(bitbuf
, 2);
566 skip_bits(bitbuf
, 2);
569 /* load frame size */
570 frame_size_code
= get_bits(bitbuf
, 3);
572 if (frame_size_code
== 7) {
573 /* load width, height (12 bits each) */
574 width
= get_bits(bitbuf
, 12);
575 height
= get_bits(bitbuf
, 12);
577 if (!width
|| !height
)
578 return AVERROR_INVALIDDATA
;
580 /* get width, height from table */
581 width
= ff_svq1_frame_size_table
[frame_size_code
][0];
582 height
= ff_svq1_frame_size_table
[frame_size_code
][1];
587 if (get_bits1(bitbuf
)) {
588 skip_bits1(bitbuf
); /* use packet checksum if (1) */
589 skip_bits1(bitbuf
); /* component checksums after image data if (1) */
591 if (get_bits(bitbuf
, 2) != 0)
592 return AVERROR_INVALIDDATA
;
595 if (get_bits1(bitbuf
)) {
597 skip_bits(bitbuf
, 4);
599 skip_bits(bitbuf
, 2);
601 if (skip_1stop_8data_bits(bitbuf
) < 0)
602 return AVERROR_INVALIDDATA
;
610 static int svq1_decode_frame(AVCodecContext
*avctx
, void *data
,
611 int *got_frame
, AVPacket
*avpkt
)
613 const uint8_t *buf
= avpkt
->data
;
614 int buf_size
= avpkt
->size
;
615 SVQ1Context
*s
= avctx
->priv_data
;
618 int result
, i
, x
, y
, width
, height
;
621 /* initialize bit buffer */
622 init_get_bits8(&s
->gb
, buf
, buf_size
);
624 /* decode frame header */
625 s
->frame_code
= get_bits(&s
->gb
, 22);
627 if ((s
->frame_code
& ~0x70) || !(s
->frame_code
& 0x60))
628 return AVERROR_INVALIDDATA
;
630 /* swap some header bytes (why?) */
631 if (s
->frame_code
!= 0x20) {
634 if (buf_size
< 9 * 4) {
635 av_log(avctx
, AV_LOG_ERROR
, "Input packet too small\n");
636 return AVERROR_INVALIDDATA
;
639 av_fast_padded_malloc(&s
->pkt_swapped
, &s
->pkt_swapped_allocated
,
642 return AVERROR(ENOMEM
);
644 memcpy(s
->pkt_swapped
, buf
, buf_size
);
645 buf
= s
->pkt_swapped
;
646 init_get_bits(&s
->gb
, buf
, buf_size
* 8);
647 skip_bits(&s
->gb
, 22);
649 src
= (uint32_t *)(s
->pkt_swapped
+ 4);
652 return AVERROR_INVALIDDATA
;
654 for (i
= 0; i
< 4; i
++)
655 src
[i
] = ((src
[i
] << 16) | (src
[i
] >> 16)) ^ src
[7 - i
];
658 result
= svq1_decode_frame_header(avctx
, cur
);
660 av_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
& 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_ERROR
,
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
);
822 s
->pkt_swapped_allocated
= 0;
827 static void svq1_flush(AVCodecContext
*avctx
)
829 SVQ1Context
*s
= avctx
->priv_data
;
831 av_frame_unref(s
->prev
);
834 AVCodec ff_svq1_decoder
= {
836 .long_name
= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
837 .type
= AVMEDIA_TYPE_VIDEO
,
838 .id
= AV_CODEC_ID_SVQ1
,
839 .priv_data_size
= sizeof(SVQ1Context
),
840 .init
= svq1_decode_init
,
841 .close
= svq1_decode_end
,
842 .decode
= svq1_decode_frame
,
843 .capabilities
= CODEC_CAP_DR1
,
845 .pix_fmts
= (const enum AVPixelFormat
[]) { AV_PIX_FMT_YUV410P
,