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 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];\
198 bit_cache = get_bits (bitbuf, 4*stages);\
199 /* calculate codebook entries for this vector */\
200 for (j=0; j < stages; j++) {\
201 entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
203 mean -= (stages * 128);\
204 n4 = (mean << 16) + mean;
206 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
210 const uint32_t *codebook;
214 unsigned x, y, width, height, level;
215 uint32_t n1, n2, n3, n4;
217 /* initialize list for breadth first processing of vectors */
220 /* recursively process vector */
221 for (i=0, m=1, n=1, level=5; i < n; i++) {
222 SVQ1_PROCESS_VECTOR();
224 /* destination address and vector size */
225 dst = (uint32_t *) list[i];
226 width = 1 << ((4 + level) /2);
227 height = 1 << ((3 + level) /2);
229 /* get number of stages (-1 skips vector, 0 for mean only) */
230 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
233 for (y=0; y < height; y++) {
234 memset (&dst[y*(pitch / 4)], 0, width);
236 continue; /* skip vector */
239 if ((stages > 0) && (level >= 4)) {
241 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
243 return -1; /* invalid vector */
246 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
249 for (y=0; y < height; y++) {
250 memset (&dst[y*(pitch / 4)], mean, width);
253 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
254 SVQ1_DO_CODEBOOK_INTRA()
261 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
265 const uint32_t *codebook;
269 int x, y, width, height, level;
270 uint32_t n1, n2, n3, n4;
272 /* initialize list for breadth first processing of vectors */
275 /* recursively process vector */
276 for (i=0, m=1, n=1, level=5; i < n; i++) {
277 SVQ1_PROCESS_VECTOR();
279 /* destination address and vector size */
280 dst = (uint32_t *) list[i];
281 width = 1 << ((4 + level) /2);
282 height = 1 << ((3 + level) /2);
284 /* get number of stages (-1 skips vector, 0 for mean only) */
285 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
287 if (stages == -1) continue; /* skip vector */
289 if ((stages > 0) && (level >= 4)) {
291 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
293 return -1; /* invalid vector */
296 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
298 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
299 SVQ1_DO_CODEBOOK_NONINTRA()
304 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv) {
308 for (i=0; i < 2; i++) {
310 /* get motion code */
311 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
315 if(get_bits1(bitbuf)) diff= -diff;
318 /* add median of motion vector predictors and clip result */
320 mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
322 mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
328 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
333 src = &previous[x + y*pitch];
336 for (i=0; i < 16; i++) {
337 memcpy (dst, src, 16);
343 static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
344 uint8_t *current, uint8_t *previous, int pitch,
345 svq1_pmv *motion, int x, int y) {
352 /* predict and decode motion vector */
359 pmv[1] = &motion[(x / 8) + 2];
360 pmv[2] = &motion[(x / 8) + 4];
363 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
369 motion[(x / 8) + 2].x =
370 motion[(x / 8) + 3].x = mv.x;
372 motion[(x / 8) + 2].y =
373 motion[(x / 8) + 3].y = mv.y;
375 if(y + (mv.y >> 1)<0)
377 if(x + (mv.x >> 1)<0)
380 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
383 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
388 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
389 uint8_t *current, uint8_t *previous, int pitch,
390 svq1_pmv *motion,int x, int y) {
397 /* predict and decode motion vector (0) */
404 pmv[1] = &motion[(x / 8) + 2];
405 pmv[2] = &motion[(x / 8) + 4];
408 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
413 /* predict and decode motion vector (1) */
420 pmv[1] = &motion[(x / 8) + 3];
422 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
427 /* predict and decode motion vector (2) */
429 pmv[2] = &motion[(x / 8) + 1];
431 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
436 /* predict and decode motion vector (3) */
437 pmv[2] = &motion[(x / 8) + 2];
438 pmv[3] = &motion[(x / 8) + 3];
440 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
445 /* form predictions */
446 for (i=0; i < 4; i++) {
447 int mvx= pmv[i]->x + (i&1)*16;
448 int mvy= pmv[i]->y + (i>>1)*16;
450 ///XXX /FIXME clipping or padding?
456 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
459 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
461 /* select next block */
463 current += 8*(pitch - 1);
472 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
473 uint8_t *current, uint8_t *previous, int pitch,
474 svq1_pmv *motion, int x, int y) {
479 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
481 /* reset motion vectors */
482 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
485 motion[(x / 8) + 2].x =
486 motion[(x / 8) + 2].y =
487 motion[(x / 8) + 3].x =
488 motion[(x / 8) + 3].y = 0;
491 switch (block_type) {
492 case SVQ1_BLOCK_SKIP:
493 svq1_skip_block (current, previous, pitch, x, y);
496 case SVQ1_BLOCK_INTER:
497 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
501 av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
504 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
507 case SVQ1_BLOCK_INTER_4V:
508 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
512 av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
515 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
518 case SVQ1_BLOCK_INTRA:
519 result = svq1_decode_block_intra (bitbuf, current, pitch);
526 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
529 for (i=0; i < length; i++) {
530 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
536 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
540 out[0] = get_bits (bitbuf, 8);
542 seed = string_table[out[0]];
544 for (i=1; i <= out[0]; i++) {
545 out[i] = get_bits (bitbuf, 8) ^ seed;
546 seed = string_table[out[i] ^ seed];
550 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
553 skip_bits(bitbuf, 8); /* temporal_reference */
556 s->pict_type= get_bits (bitbuf, 2)+1;
560 if (s->pict_type == AV_PICTURE_TYPE_I) {
563 if (s->f_code == 0x50 || s->f_code == 0x60) {
564 int csum = get_bits (bitbuf, 16);
566 csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
568 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
569 // (csum == 0) ? "correct" : "incorrect", csum);
572 if ((s->f_code ^ 0x10) >= 0x50) {
575 svq1_parse_string (bitbuf, msg);
577 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
580 skip_bits (bitbuf, 2);
581 skip_bits (bitbuf, 2);
584 /* load frame size */
585 frame_size_code = get_bits (bitbuf, 3);
587 if (frame_size_code == 7) {
588 /* load width, height (12 bits each) */
589 s->width = get_bits (bitbuf, 12);
590 s->height = get_bits (bitbuf, 12);
592 if (!s->width || !s->height)
595 /* get width, height from table */
596 s->width = ff_svq1_frame_size_table[frame_size_code].width;
597 s->height = ff_svq1_frame_size_table[frame_size_code].height;
602 if (get_bits1 (bitbuf) == 1) {
603 skip_bits1 (bitbuf); /* use packet checksum if (1) */
604 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
606 if (get_bits (bitbuf, 2) != 0)
610 if (get_bits1 (bitbuf) == 1) {
612 skip_bits (bitbuf, 4);
614 skip_bits (bitbuf, 2);
616 while (get_bits1 (bitbuf) == 1) {
617 skip_bits (bitbuf, 8);
624 static int svq1_decode_frame(AVCodecContext *avctx,
625 void *data, int *data_size,
628 const uint8_t *buf = avpkt->data;
629 int buf_size = avpkt->size;
630 MpegEncContext *s=avctx->priv_data;
631 uint8_t *current, *previous;
632 int result, i, x, y, width, height;
633 AVFrame *pict = data;
636 /* initialize bit buffer */
637 init_get_bits(&s->gb,buf,buf_size*8);
639 /* decode frame header */
640 s->f_code = get_bits (&s->gb, 22);
642 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
645 /* swap some header bytes (why?) */
646 if (s->f_code != 0x20) {
647 uint32_t *src = (uint32_t *) (buf + 4);
649 for (i=0; i < 4; i++) {
650 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
654 result = svq1_decode_frame_header (&s->gb, s);
658 av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
662 //FIXME this avoids some confusion for "B frames" without 2 references
663 //this should be removed after libavcodec can handle more flexible picture types & ordering
664 if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
666 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
667 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
668 || avctx->skip_frame >= AVDISCARD_ALL)
671 if(MPV_frame_start(s, avctx) < 0)
674 pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
678 /* decode y, u and v components */
679 for (i=0; i < 3; i++) {
682 width = FFALIGN(s->width, 16);
683 height = FFALIGN(s->height, 16);
684 linesize= s->linesize;
686 if(s->flags&CODEC_FLAG_GRAY) break;
687 width = FFALIGN(s->width/4, 16);
688 height = FFALIGN(s->height/4, 16);
689 linesize= s->uvlinesize;
692 current = s->current_picture.f.data[i];
694 if(s->pict_type==AV_PICTURE_TYPE_B){
695 previous = s->next_picture.f.data[i];
697 previous = s->last_picture.f.data[i];
700 if (s->pict_type == AV_PICTURE_TYPE_I) {
702 for (y=0; y < height; y+=16) {
703 for (x=0; x < width; x+=16) {
704 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
707 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
711 current += 16*linesize;
715 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
717 for (y=0; y < height; y+=16) {
718 for (x=0; x < width; x+=16) {
719 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
720 linesize, pmv, x, y);
723 av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
731 current += 16*linesize;
736 *pict = *(AVFrame*)&s->current_picture;
741 *data_size=sizeof(AVFrame);
748 static av_cold int svq1_decode_init(AVCodecContext *avctx)
750 MpegEncContext *s = avctx->priv_data;
754 MPV_decode_defaults(s);
757 s->width = (avctx->width+3)&~3;
758 s->height = (avctx->height+3)&~3;
759 s->codec_id= avctx->codec->id;
760 avctx->pix_fmt = PIX_FMT_YUV410P;
761 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
762 s->flags= avctx->flags;
763 if (MPV_common_init(s) < 0) return -1;
765 INIT_VLC_STATIC(&svq1_block_type, 2, 4,
766 &ff_svq1_block_type_vlc[0][1], 2, 1,
767 &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
769 INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
771 &mvtab[0][0], 2, 1, 176);
773 for (i = 0; i < 6; i++) {
774 static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
775 static VLC_TYPE table[168][2];
776 svq1_intra_multistage[i].table = &table[offset];
777 svq1_intra_multistage[i].table_allocated = sizes[0][i];
778 offset += sizes[0][i];
779 init_vlc(&svq1_intra_multistage[i], 3, 8,
780 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
781 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
782 svq1_inter_multistage[i].table = &table[offset];
783 svq1_inter_multistage[i].table_allocated = sizes[1][i];
784 offset += sizes[1][i];
785 init_vlc(&svq1_inter_multistage[i], 3, 8,
786 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
787 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC);
790 INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
791 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
792 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
794 INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
795 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
796 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
801 static av_cold int svq1_decode_end(AVCodecContext *avctx)
803 MpegEncContext *s = avctx->priv_data;
810 AVCodec ff_svq1_decoder = {
812 .type = AVMEDIA_TYPE_VIDEO,
814 .priv_data_size = sizeof(MpegEncContext),
815 .init = svq1_decode_init,
816 .close = svq1_decode_end,
817 .decode = svq1_decode_frame,
818 .capabilities = CODEC_CAP_DR1,
819 .flush= ff_mpeg_flush,
820 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
821 .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),