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/
38 #include "mpegvideo.h"
46 extern const uint8_t ff_mvtab[33][2];
48 static VLC svq1_block_type;
49 static VLC svq1_motion_component;
50 static VLC svq1_intra_multistage[6];
51 static VLC svq1_inter_multistage[6];
52 static VLC svq1_intra_mean;
53 static VLC svq1_inter_mean;
55 /* motion vector (prediction) */
56 typedef struct svq1_pmv_s {
61 static const uint16_t checksum_table[256] = {
62 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
63 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
64 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
65 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
66 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
67 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
68 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
69 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
70 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
71 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
72 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
73 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
74 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
75 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
76 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
77 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
78 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
79 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
80 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
81 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
82 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
83 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
84 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
85 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
86 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
87 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
88 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
89 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
90 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
91 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
92 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
93 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
96 static const uint8_t string_table[256] = {
97 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
98 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
99 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
100 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
101 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
102 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
103 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
104 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
105 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
106 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
107 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
108 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
109 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
110 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
111 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
112 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
113 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
114 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
115 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
116 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
117 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
118 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
119 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
120 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
121 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
122 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
123 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
124 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
125 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
126 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
127 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
128 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
131 #define SVQ1_PROCESS_VECTOR()\
132 for (; level > 0; i++) {\
133 /* process next depth */\
139 /* divide block if next bit set */\
140 if (get_bits1 (bitbuf) == 0)\
142 /* add child nodes */\
143 list[n++] = list[i];\
144 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
147 #define SVQ1_ADD_CODEBOOK()\
148 /* add codebook entries to vector */\
149 for (j=0; j < stages; j++) {\
150 n3 = codebook[entries[j]] ^ 0x80808080;\
151 n1 += ((n3 & 0xFF00FF00) >> 8);\
152 n2 += (n3 & 0x00FF00FF);\
155 /* clip to [0..255] */\
156 if (n1 & 0xFF00FF00) {\
157 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
159 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
160 n1 &= (n3 & 0x00FF00FF);\
163 if (n2 & 0xFF00FF00) {\
164 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
166 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
167 n2 &= (n3 & 0x00FF00FF);\
170 #define SVQ1_DO_CODEBOOK_INTRA()\
171 for (y=0; y < height; y++) {\
172 for (x=0; x < (width / 4); x++, codebook++) {\
177 dst[x] = (n1 << 8) | n2;\
182 #define SVQ1_DO_CODEBOOK_NONINTRA()\
183 for (y=0; y < height; y++) {\
184 for (x=0; x < (width / 4); x++, codebook++) {\
186 /* add mean value to vector */\
187 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
188 n2 = (n3 & 0x00FF00FF) + n4;\
191 dst[x] = (n1 << 8) | n2;\
196 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
197 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 << 16) + mean;
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 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
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 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
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 = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
323 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
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);
502 av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
505 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
508 case SVQ1_BLOCK_INTER_4V:
509 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
513 av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
516 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
519 case SVQ1_BLOCK_INTRA:
520 result = svq1_decode_block_intra (bitbuf, current, pitch);
527 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
530 for (i=0; i < length; i++) {
531 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
537 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
541 out[0] = get_bits (bitbuf, 8);
543 seed = string_table[out[0]];
545 for (i=1; i <= out[0]; i++) {
546 out[i] = get_bits (bitbuf, 8) ^ seed;
547 seed = string_table[out[i] ^ seed];
551 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
554 skip_bits(bitbuf, 8); /* temporal_reference */
557 s->pict_type= get_bits (bitbuf, 2)+1;
561 if (s->pict_type == AV_PICTURE_TYPE_I) {
564 if (s->f_code == 0x50 || s->f_code == 0x60) {
565 int csum = get_bits (bitbuf, 16);
567 csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
569 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
570 // (csum == 0) ? "correct" : "incorrect", csum);
573 if ((s->f_code ^ 0x10) >= 0x50) {
576 svq1_parse_string (bitbuf, msg);
578 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
581 skip_bits (bitbuf, 2);
582 skip_bits (bitbuf, 2);
585 /* load frame size */
586 frame_size_code = get_bits (bitbuf, 3);
588 if (frame_size_code == 7) {
589 /* load width, height (12 bits each) */
590 s->width = get_bits (bitbuf, 12);
591 s->height = get_bits (bitbuf, 12);
593 if (!s->width || !s->height)
596 /* get width, height from table */
597 s->width = ff_svq1_frame_size_table[frame_size_code].width;
598 s->height = ff_svq1_frame_size_table[frame_size_code].height;
603 if (get_bits1 (bitbuf) == 1) {
604 skip_bits1 (bitbuf); /* use packet checksum if (1) */
605 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
607 if (get_bits (bitbuf, 2) != 0)
611 if (get_bits1 (bitbuf) == 1) {
613 skip_bits (bitbuf, 4);
615 skip_bits (bitbuf, 2);
617 while (get_bits1 (bitbuf) == 1) {
618 skip_bits (bitbuf, 8);
625 static int svq1_decode_frame(AVCodecContext *avctx,
626 void *data, int *data_size,
629 const uint8_t *buf = avpkt->data;
630 int buf_size = avpkt->size;
631 MpegEncContext *s=avctx->priv_data;
632 uint8_t *current, *previous;
633 int result, i, x, y, width, height;
634 AVFrame *pict = data;
637 /* initialize bit buffer */
638 init_get_bits(&s->gb,buf,buf_size*8);
640 /* decode frame header */
641 s->f_code = get_bits (&s->gb, 22);
643 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
646 /* swap some header bytes (why?) */
647 if (s->f_code != 0x20) {
648 uint32_t *src = (uint32_t *) (buf + 4);
650 for (i=0; i < 4; i++) {
651 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
655 result = svq1_decode_frame_header (&s->gb, s);
659 av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
662 avcodec_set_dimensions(avctx, s->width, s->height);
664 //FIXME this avoids some confusion for "B frames" without 2 references
665 //this should be removed after libavcodec can handle more flexible picture types & ordering
666 if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
668 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
669 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
670 || avctx->skip_frame >= AVDISCARD_ALL)
673 if(ff_MPV_frame_start(s, avctx) < 0)
676 pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
680 /* decode y, u and v components */
681 for (i=0; i < 3; i++) {
684 width = FFALIGN(s->width, 16);
685 height = FFALIGN(s->height, 16);
686 linesize= s->linesize;
688 if(s->flags&CODEC_FLAG_GRAY) break;
689 width = FFALIGN(s->width/4, 16);
690 height = FFALIGN(s->height/4, 16);
691 linesize= s->uvlinesize;
694 current = s->current_picture.f.data[i];
696 if(s->pict_type==AV_PICTURE_TYPE_B){
697 previous = s->next_picture.f.data[i];
699 previous = s->last_picture.f.data[i];
702 if (s->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], linesize);
709 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
713 current += 16*linesize;
717 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
719 for (y=0; y < height; y+=16) {
720 for (x=0; x < width; x+=16) {
721 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
722 linesize, pmv, x, y);
725 av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
733 current += 16*linesize;
738 *pict = *(AVFrame*)&s->current_picture;
743 *data_size=sizeof(AVFrame);
750 static av_cold int svq1_decode_init(AVCodecContext *avctx)
752 MpegEncContext *s = avctx->priv_data;
756 ff_MPV_decode_defaults(s);
759 s->width = (avctx->width+3)&~3;
760 s->height = (avctx->height+3)&~3;
761 s->codec_id= avctx->codec->id;
762 avctx->pix_fmt = PIX_FMT_YUV410P;
763 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
764 s->flags= avctx->flags;
765 if (ff_MPV_common_init(s) < 0) return -1;
767 INIT_VLC_STATIC(&svq1_block_type, 2, 4,
768 &ff_svq1_block_type_vlc[0][1], 2, 1,
769 &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
771 INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
772 &ff_mvtab[0][1], 2, 1,
773 &ff_mvtab[0][0], 2, 1, 176);
775 for (i = 0; i < 6; i++) {
776 static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
777 static VLC_TYPE table[168][2];
778 svq1_intra_multistage[i].table = &table[offset];
779 svq1_intra_multistage[i].table_allocated = sizes[0][i];
780 offset += sizes[0][i];
781 init_vlc(&svq1_intra_multistage[i], 3, 8,
782 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
783 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
784 svq1_inter_multistage[i].table = &table[offset];
785 svq1_inter_multistage[i].table_allocated = sizes[1][i];
786 offset += sizes[1][i];
787 init_vlc(&svq1_inter_multistage[i], 3, 8,
788 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
789 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
792 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
793 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
794 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
796 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
797 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
798 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
803 static av_cold int svq1_decode_end(AVCodecContext *avctx)
805 MpegEncContext *s = avctx->priv_data;
807 ff_MPV_common_end(s);
812 AVCodec ff_svq1_decoder = {
814 .type = AVMEDIA_TYPE_VIDEO,
816 .priv_data_size = sizeof(MpegEncContext),
817 .init = svq1_decode_init,
818 .close = svq1_decode_end,
819 .decode = svq1_decode_frame,
820 .capabilities = CODEC_CAP_DR1,
821 .flush= ff_mpeg_flush,
822 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
823 .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),