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/
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 >> 1) + 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 << 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 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) {
557 int temporal_reference;
559 temporal_reference = get_bits (bitbuf, 8);
562 s->pict_type= get_bits (bitbuf, 2)+1;
566 if (s->pict_type == AV_PICTURE_TYPE_I) {
569 if (s->f_code == 0x50 || s->f_code == 0x60) {
570 int csum = get_bits (bitbuf, 16);
572 csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
574 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
575 // (csum == 0) ? "correct" : "incorrect", csum);
578 if ((s->f_code ^ 0x10) >= 0x50) {
581 svq1_parse_string (bitbuf, msg);
583 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
586 skip_bits (bitbuf, 2);
587 skip_bits (bitbuf, 2);
590 /* load frame size */
591 frame_size_code = get_bits (bitbuf, 3);
593 if (frame_size_code == 7) {
594 /* load width, height (12 bits each) */
595 s->width = get_bits (bitbuf, 12);
596 s->height = get_bits (bitbuf, 12);
598 if (!s->width || !s->height)
601 /* get width, height from table */
602 s->width = ff_svq1_frame_size_table[frame_size_code].width;
603 s->height = ff_svq1_frame_size_table[frame_size_code].height;
608 if (get_bits1 (bitbuf) == 1) {
609 skip_bits1 (bitbuf); /* use packet checksum if (1) */
610 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
612 if (get_bits (bitbuf, 2) != 0)
616 if (get_bits1 (bitbuf) == 1) {
618 skip_bits (bitbuf, 4);
620 skip_bits (bitbuf, 2);
622 while (get_bits1 (bitbuf) == 1) {
623 skip_bits (bitbuf, 8);
630 static int svq1_decode_frame(AVCodecContext *avctx,
631 void *data, int *data_size,
634 const uint8_t *buf = avpkt->data;
635 int buf_size = avpkt->size;
636 MpegEncContext *s=avctx->priv_data;
637 uint8_t *current, *previous;
638 int result, i, x, y, width, height;
639 AVFrame *pict = data;
642 /* initialize bit buffer */
643 init_get_bits(&s->gb,buf,buf_size*8);
645 /* decode frame header */
646 s->f_code = get_bits (&s->gb, 22);
648 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
651 /* swap some header bytes (why?) */
652 if (s->f_code != 0x20) {
653 uint32_t *src = (uint32_t *) (buf + 4);
655 for (i=0; i < 4; i++) {
656 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
660 result = svq1_decode_frame_header (&s->gb, s);
665 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
670 //FIXME this avoids some confusion for "B frames" without 2 references
671 //this should be removed after libavcodec can handle more flexible picture types & ordering
672 if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
674 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
675 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
676 || avctx->skip_frame >= AVDISCARD_ALL)
679 if(MPV_frame_start(s, avctx) < 0)
682 pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
686 /* decode y, u and v components */
687 for (i=0; i < 3; i++) {
690 width = FFALIGN(s->width, 16);
691 height = FFALIGN(s->height, 16);
692 linesize= s->linesize;
694 if(s->flags&CODEC_FLAG_GRAY) break;
695 width = FFALIGN(s->width/4, 16);
696 height = FFALIGN(s->height/4, 16);
697 linesize= s->uvlinesize;
700 current = s->current_picture.data[i];
702 if(s->pict_type==AV_PICTURE_TYPE_B){
703 previous = s->next_picture.data[i];
705 previous = s->last_picture.data[i];
708 if (s->pict_type == AV_PICTURE_TYPE_I) {
710 for (y=0; y < height; y+=16) {
711 for (x=0; x < width; x+=16) {
712 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
716 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
721 current += 16*linesize;
725 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
727 for (y=0; y < height; y+=16) {
728 for (x=0; x < width; x+=16) {
729 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
730 linesize, pmv, x, y);
734 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
743 current += 16*linesize;
748 *pict = *(AVFrame*)&s->current_picture;
753 *data_size=sizeof(AVFrame);
760 static av_cold int svq1_decode_init(AVCodecContext *avctx)
762 MpegEncContext *s = avctx->priv_data;
766 MPV_decode_defaults(s);
769 s->width = (avctx->width+3)&~3;
770 s->height = (avctx->height+3)&~3;
771 s->codec_id= avctx->codec->id;
772 avctx->pix_fmt = PIX_FMT_YUV410P;
773 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
774 s->flags= avctx->flags;
775 if (MPV_common_init(s) < 0) return -1;
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,
783 &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}, {10, 10, 14, 14, 14, 16}};
787 static VLC_TYPE table[168][2];
788 svq1_intra_multistage[i].table = &table[offset];
789 svq1_intra_multistage[i].table_allocated = sizes[0][i];
790 offset += sizes[0][i];
791 init_vlc(&svq1_intra_multistage[i], 3, 8,
792 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
793 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
794 svq1_inter_multistage[i].table = &table[offset];
795 svq1_inter_multistage[i].table_allocated = sizes[1][i];
796 offset += sizes[1][i];
797 init_vlc(&svq1_inter_multistage[i], 3, 8,
798 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
799 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
802 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
803 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
804 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
806 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
807 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
808 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
813 static av_cold int svq1_decode_end(AVCodecContext *avctx)
815 MpegEncContext *s = avctx->priv_data;
822 AVCodec ff_svq1_decoder = {
826 sizeof(MpegEncContext),
832 .flush= ff_mpeg_flush,
833 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
834 .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),