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/
39 #include "mpegvideo.h"
47 extern const uint8_t mvtab[33][2];
49 static VLC svq1_block_type;
50 static VLC svq1_motion_component;
51 static VLC svq1_intra_multistage[6];
52 static VLC svq1_inter_multistage[6];
53 static VLC svq1_intra_mean;
54 static VLC svq1_inter_mean;
56 /* motion vector (prediction) */
57 typedef struct svq1_pmv_s {
62 static const uint16_t checksum_table[256] = {
63 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
64 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
65 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
66 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
67 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
68 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
69 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
70 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
71 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
72 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
73 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
74 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
75 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
76 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
77 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
78 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
79 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
80 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
81 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
82 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
83 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
84 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
85 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
86 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
87 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
88 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
89 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
90 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
91 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
92 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
93 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
94 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
97 static const uint8_t string_table[256] = {
98 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
99 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
100 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
101 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
102 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
103 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
104 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
105 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
106 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
107 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
108 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
109 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
110 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
111 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
112 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
113 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
114 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
115 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
116 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
117 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
118 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
119 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
120 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
121 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
122 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
123 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
124 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
125 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
126 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
127 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
128 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
129 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
132 #define SVQ1_PROCESS_VECTOR()\
133 for (; level > 0; i++) {\
134 /* process next depth */\
140 /* divide block if next bit set */\
141 if (get_bits1 (bitbuf) == 0)\
143 /* add child nodes */\
144 list[n++] = list[i];\
145 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
148 #define SVQ1_ADD_CODEBOOK()\
149 /* add codebook entries to vector */\
150 for (j=0; j < stages; j++) {\
151 n3 = codebook[entries[j]] ^ 0x80808080;\
152 n1 += ((n3 & 0xFF00FF00) >> 8);\
153 n2 += (n3 & 0x00FF00FF);\
156 /* clip to [0..255] */\
157 if (n1 & 0xFF00FF00) {\
158 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
160 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
161 n1 &= (n3 & 0x00FF00FF);\
164 if (n2 & 0xFF00FF00) {\
165 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
167 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
168 n2 &= (n3 & 0x00FF00FF);\
171 #define SVQ1_DO_CODEBOOK_INTRA()\
172 for (y=0; y < height; y++) {\
173 for (x=0; x < (width / 4); x++, codebook++) {\
178 dst[x] = (n1 << 8) | n2;\
183 #define SVQ1_DO_CODEBOOK_NONINTRA()\
184 for (y=0; y < height; y++) {\
185 for (x=0; x < (width / 4); x++, codebook++) {\
187 /* add mean value to vector */\
188 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
189 n2 = (n3 & 0x00FF00FF) + n4;\
192 dst[x] = (n1 << 8) | n2;\
197 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
198 codebook = (const uint32_t *) cbook[level];\
199 bit_cache = get_bits (bitbuf, 4*stages);\
200 /* calculate codebook entries for this vector */\
201 for (j=0; j < stages; j++) {\
202 entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
204 mean -= (stages * 128);\
205 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
207 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
211 const uint32_t *codebook;
215 unsigned x, y, width, height, level;
216 uint32_t n1, n2, n3, n4;
218 /* initialize list for breadth first processing of vectors */
221 /* recursively process vector */
222 for (i=0, m=1, n=1, level=5; i < n; i++) {
223 SVQ1_PROCESS_VECTOR();
225 /* destination address and vector size */
226 dst = (uint32_t *) list[i];
227 width = 1 << ((4 + level) /2);
228 height = 1 << ((3 + level) /2);
230 /* get number of stages (-1 skips vector, 0 for mean only) */
231 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
234 for (y=0; y < height; y++) {
235 memset (&dst[y*(pitch / 4)], 0, width);
237 continue; /* skip vector */
240 if ((stages > 0) && (level >= 4)) {
242 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
244 return -1; /* invalid vector */
247 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
250 for (y=0; y < height; y++) {
251 memset (&dst[y*(pitch / 4)], mean, width);
254 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
255 SVQ1_DO_CODEBOOK_INTRA()
262 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
266 const uint32_t *codebook;
270 int x, y, width, height, level;
271 uint32_t n1, n2, n3, n4;
273 /* initialize list for breadth first processing of vectors */
276 /* recursively process vector */
277 for (i=0, m=1, n=1, level=5; i < n; i++) {
278 SVQ1_PROCESS_VECTOR();
280 /* destination address and vector size */
281 dst = (uint32_t *) list[i];
282 width = 1 << ((4 + level) /2);
283 height = 1 << ((3 + level) /2);
285 /* get number of stages (-1 skips vector, 0 for mean only) */
286 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
288 if (stages == -1) continue; /* skip vector */
290 if ((stages > 0) && (level >= 4)) {
292 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
294 return -1; /* invalid vector */
297 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
299 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
300 SVQ1_DO_CODEBOOK_NONINTRA()
305 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv) {
309 for (i=0; i < 2; i++) {
311 /* get motion code */
312 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
316 if(get_bits1(bitbuf)) diff= -diff;
319 /* add median of motion vector predictors and clip result */
321 mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
323 mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
329 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
334 src = &previous[x + y*pitch];
337 for (i=0; i < 16; i++) {
338 memcpy (dst, src, 16);
344 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
345 uint8_t *current, uint8_t *previous, int pitch,
346 svq1_pmv *motion, int x, int y) {
353 /* predict and decode motion vector */
360 pmv[1] = &motion[(x / 8) + 2];
361 pmv[2] = &motion[(x / 8) + 4];
364 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
370 motion[(x / 8) + 2].x =
371 motion[(x / 8) + 3].x = mv.x;
373 motion[(x / 8) + 2].y =
374 motion[(x / 8) + 3].y = mv.y;
376 if(y + (mv.y >> 1)<0)
378 if(x + (mv.x >> 1)<0)
381 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
384 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
389 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
390 uint8_t *current, uint8_t *previous, int pitch,
391 svq1_pmv *motion,int x, int y) {
398 /* predict and decode motion vector (0) */
405 pmv[1] = &motion[(x / 8) + 2];
406 pmv[2] = &motion[(x / 8) + 4];
409 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
414 /* predict and decode motion vector (1) */
421 pmv[1] = &motion[(x / 8) + 3];
423 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
428 /* predict and decode motion vector (2) */
430 pmv[2] = &motion[(x / 8) + 1];
432 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
437 /* predict and decode motion vector (3) */
438 pmv[2] = &motion[(x / 8) + 2];
439 pmv[3] = &motion[(x / 8) + 3];
441 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
446 /* form predictions */
447 for (i=0; i < 4; i++) {
448 int mvx= pmv[i]->x + (i&1)*16;
449 int mvy= pmv[i]->y + (i>>1)*16;
451 ///XXX /FIXME clipping or padding?
457 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
460 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
462 /* select next block */
464 current += 8*(pitch - 1);
473 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
474 uint8_t *current, uint8_t *previous, int pitch,
475 svq1_pmv *motion, int x, int y) {
480 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
482 /* reset motion vectors */
483 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
486 motion[(x / 8) + 2].x =
487 motion[(x / 8) + 2].y =
488 motion[(x / 8) + 3].x =
489 motion[(x / 8) + 3].y = 0;
492 switch (block_type) {
493 case SVQ1_BLOCK_SKIP:
494 svq1_skip_block (current, previous, pitch, x, y);
497 case SVQ1_BLOCK_INTER:
498 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
503 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
507 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
510 case SVQ1_BLOCK_INTER_4V:
511 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
516 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
520 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
523 case SVQ1_BLOCK_INTRA:
524 result = svq1_decode_block_intra (bitbuf, current, pitch);
531 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
534 for (i=0; i < length; i++) {
535 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
541 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
545 out[0] = get_bits (bitbuf, 8);
547 seed = string_table[out[0]];
549 for (i=1; i <= out[0]; i++) {
550 out[i] = get_bits (bitbuf, 8) ^ seed;
551 seed = string_table[out[i] ^ seed];
555 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
558 skip_bits(bitbuf, 8); /* temporal_reference */
561 s->pict_type= get_bits (bitbuf, 2)+1;
565 if (s->pict_type == AV_PICTURE_TYPE_I) {
568 if (s->f_code == 0x50 || s->f_code == 0x60) {
569 int csum = get_bits (bitbuf, 16);
571 csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
573 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
574 // (csum == 0) ? "correct" : "incorrect", csum);
577 if ((s->f_code ^ 0x10) >= 0x50) {
580 svq1_parse_string (bitbuf, msg);
582 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
585 skip_bits (bitbuf, 2);
586 skip_bits (bitbuf, 2);
589 /* load frame size */
590 frame_size_code = get_bits (bitbuf, 3);
592 if (frame_size_code == 7) {
593 /* load width, height (12 bits each) */
594 s->width = get_bits (bitbuf, 12);
595 s->height = get_bits (bitbuf, 12);
597 if (!s->width || !s->height)
600 /* get width, height from table */
601 s->width = ff_svq1_frame_size_table[frame_size_code].width;
602 s->height = ff_svq1_frame_size_table[frame_size_code].height;
607 if (get_bits1 (bitbuf) == 1) {
608 skip_bits1 (bitbuf); /* use packet checksum if (1) */
609 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
611 if (get_bits (bitbuf, 2) != 0)
615 if (get_bits1 (bitbuf) == 1) {
617 skip_bits (bitbuf, 4);
619 skip_bits (bitbuf, 2);
621 while (get_bits1 (bitbuf) == 1) {
622 skip_bits (bitbuf, 8);
629 static int svq1_decode_frame(AVCodecContext *avctx,
630 void *data, int *data_size,
633 const uint8_t *buf = avpkt->data;
634 int buf_size = avpkt->size;
635 MpegEncContext *s=avctx->priv_data;
636 uint8_t *current, *previous;
637 int result, i, x, y, width, height;
638 AVFrame *pict = data;
641 /* initialize bit buffer */
642 init_get_bits(&s->gb,buf,buf_size*8);
644 /* decode frame header */
645 s->f_code = get_bits (&s->gb, 22);
647 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
650 /* swap some header bytes (why?) */
651 if (s->f_code != 0x20) {
652 uint32_t *src = (uint32_t *) (buf + 4);
654 for (i=0; i < 4; i++) {
655 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
659 result = svq1_decode_frame_header (&s->gb, s);
664 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
669 //FIXME this avoids some confusion for "B frames" without 2 references
670 //this should be removed after libavcodec can handle more flexible picture types & ordering
671 if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
673 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
674 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
675 || avctx->skip_frame >= AVDISCARD_ALL)
678 if(MPV_frame_start(s, avctx) < 0)
681 pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
685 /* decode y, u and v components */
686 for (i=0; i < 3; i++) {
689 width = FFALIGN(s->width, 16);
690 height = FFALIGN(s->height, 16);
691 linesize= s->linesize;
693 if(s->flags&CODEC_FLAG_GRAY) break;
694 width = FFALIGN(s->width/4, 16);
695 height = FFALIGN(s->height/4, 16);
696 linesize= s->uvlinesize;
699 current = s->current_picture.data[i];
701 if(s->pict_type==AV_PICTURE_TYPE_B){
702 previous = s->next_picture.data[i];
704 previous = s->last_picture.data[i];
707 if (s->pict_type == AV_PICTURE_TYPE_I) {
709 for (y=0; y < height; y+=16) {
710 for (x=0; x < width; x+=16) {
711 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
715 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
720 current += 16*linesize;
724 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
726 for (y=0; y < height; y+=16) {
727 for (x=0; x < width; x+=16) {
728 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
729 linesize, pmv, x, y);
733 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
742 current += 16*linesize;
747 *pict = *(AVFrame*)&s->current_picture;
752 *data_size=sizeof(AVFrame);
759 static av_cold int svq1_decode_init(AVCodecContext *avctx)
761 MpegEncContext *s = avctx->priv_data;
765 MPV_decode_defaults(s);
768 s->width = (avctx->width+3)&~3;
769 s->height = (avctx->height+3)&~3;
770 s->codec_id= avctx->codec->id;
771 avctx->pix_fmt = PIX_FMT_YUV410P;
772 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
773 s->flags= avctx->flags;
774 if (MPV_common_init(s) < 0) return -1;
776 INIT_VLC_STATIC(&svq1_block_type, 2, 4,
777 &ff_svq1_block_type_vlc[0][1], 2, 1,
778 &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
780 INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
782 &mvtab[0][0], 2, 1, 176);
784 for (i = 0; i < 6; i++) {
785 static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
786 static VLC_TYPE table[168][2];
787 svq1_intra_multistage[i].table = &table[offset];
788 svq1_intra_multistage[i].table_allocated = sizes[0][i];
789 offset += sizes[0][i];
790 init_vlc(&svq1_intra_multistage[i], 3, 8,
791 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
792 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
793 svq1_inter_multistage[i].table = &table[offset];
794 svq1_inter_multistage[i].table_allocated = sizes[1][i];
795 offset += sizes[1][i];
796 init_vlc(&svq1_inter_multistage[i], 3, 8,
797 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
798 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
801 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
802 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
803 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
805 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
806 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
807 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
812 static av_cold int svq1_decode_end(AVCodecContext *avctx)
814 MpegEncContext *s = avctx->priv_data;
821 AVCodec ff_svq1_decoder = {
825 sizeof(MpegEncContext),
831 .flush= ff_mpeg_flush,
832 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
833 .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),