3 * Copyright (C) 2002 the xine project
4 * Copyright (C) 2002 the ffmpeg project
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * Ported to mplayer by Arpi <arpi@thot.banki.hu>
21 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
27 * Sorenson Vector Quantizer #1 (SVQ1) video decoder.
40 #include "mpegvideo.h"
43 static VLC svq1_block_type;
44 static VLC svq1_motion_component;
45 static VLC svq1_intra_multistage[6];
46 static VLC svq1_inter_multistage[6];
47 static VLC svq1_intra_mean;
48 static VLC svq1_inter_mean;
50 #define MEDIAN(a,b,c) (((a < b) != (b >= c)) ? b : (((a < c) != (c > b)) ? c : a))
52 #define SVQ1_BLOCK_SKIP 0
53 #define SVQ1_BLOCK_INTER 1
54 #define SVQ1_BLOCK_INTER_4V 2
55 #define SVQ1_BLOCK_INTRA 3
57 /* motion vector (prediction) */
58 typedef struct svq1_pmv_s {
66 static const uint16_t checksum_table[256] = {
67 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
68 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
69 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
70 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
71 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
72 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
73 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
74 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
75 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
76 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
77 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
78 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
79 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
80 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
81 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
82 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
83 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
84 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
85 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
86 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
87 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
88 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
89 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
90 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
91 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
92 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
93 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
94 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
95 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
96 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
97 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
98 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
101 static const uint8_t string_table[256] = {
102 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
103 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
104 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
105 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
106 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
107 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
108 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
109 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
110 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
111 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
112 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
113 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
114 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
115 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
116 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
117 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
118 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
119 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
120 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
121 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
122 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
123 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
124 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
125 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
126 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
127 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
128 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
129 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
130 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
131 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
132 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
133 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
136 #define SVQ1_PROCESS_VECTOR()\
137 for (; level > 0; i++) {\
138 /* process next depth */\
144 /* divide block if next bit set */\
145 if (get_bits (bitbuf, 1) == 0)\
147 /* add child nodes */\
148 list[n++] = list[i];\
149 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
152 #define SVQ1_ADD_CODEBOOK()\
153 /* add codebook entries to vector */\
154 for (j=0; j < stages; j++) {\
155 n3 = codebook[entries[j]] ^ 0x80808080;\
156 n1 += ((n3 & 0xFF00FF00) >> 8);\
157 n2 += (n3 & 0x00FF00FF);\
160 /* clip to [0..255] */\
161 if (n1 & 0xFF00FF00) {\
162 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
164 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
165 n1 &= (n3 & 0x00FF00FF);\
168 if (n2 & 0xFF00FF00) {\
169 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
171 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
172 n2 &= (n3 & 0x00FF00FF);\
175 #define SVQ1_DO_CODEBOOK_INTRA()\
176 for (y=0; y < height; y++) {\
177 for (x=0; x < (width / 4); x++, codebook++) {\
182 dst[x] = (n1 << 8) | n2;\
187 #define SVQ1_DO_CODEBOOK_NONINTRA()\
188 for (y=0; y < height; y++) {\
189 for (x=0; x < (width / 4); x++, codebook++) {\
191 /* add mean value to vector */\
192 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
193 n2 = (n3 & 0x00FF00FF) + n4;\
196 dst[x] = (n1 << 8) | n2;\
201 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
202 codebook = (const uint32_t *) cbook[level];\
203 bit_cache = get_bits (bitbuf, 4*stages);\
204 /* calculate codebook entries for this vector */\
205 for (j=0; j < stages; j++) {\
206 entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
208 mean -= (stages * 128);\
209 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
211 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
215 const uint32_t *codebook;
219 unsigned x, y, width, height, level;
220 uint32_t n1, n2, n3, n4;
222 /* initialize list for breadth first processing of vectors */
225 /* recursively process vector */
226 for (i=0, m=1, n=1, level=5; i < n; i++) {
227 SVQ1_PROCESS_VECTOR();
229 /* destination address and vector size */
230 dst = (uint32_t *) list[i];
231 width = 1 << ((4 + level) /2);
232 height = 1 << ((3 + level) /2);
234 /* get number of stages (-1 skips vector, 0 for mean only) */
235 stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
238 for (y=0; y < height; y++) {
239 memset (&dst[y*(pitch / 4)], 0, width);
241 continue; /* skip vector */
244 if ((stages > 0) && (level >= 4)) {
246 printf("Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
248 return -1; /* invalid vector */
251 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
254 for (y=0; y < height; y++) {
255 memset (&dst[y*(pitch / 4)], mean, width);
258 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
259 SVQ1_DO_CODEBOOK_INTRA()
266 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
270 const uint32_t *codebook;
274 int x, y, width, height, level;
275 uint32_t n1, n2, n3, n4;
277 /* initialize list for breadth first processing of vectors */
280 /* recursively process vector */
281 for (i=0, m=1, n=1, level=5; i < n; i++) {
282 SVQ1_PROCESS_VECTOR();
284 /* destination address and vector size */
285 dst = (uint32_t *) list[i];
286 width = 1 << ((4 + level) /2);
287 height = 1 << ((3 + level) /2);
289 /* get number of stages (-1 skips vector, 0 for mean only) */
290 stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
292 if (stages == -1) continue; /* skip vector */
294 if ((stages > 0) && (level >= 4)) {
296 printf("Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
298 return -1; /* invalid vector */
301 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
303 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
304 SVQ1_DO_CODEBOOK_NONINTRA()
309 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
313 for (i=0; i < 2; i++) {
315 /* get motion code */
316 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2) - 32;
318 /* add median of motion vector predictors and clip result */
320 mv->y = ((diff + MEDIAN(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
322 mv->x = ((diff + MEDIAN(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_t *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)
381 int w= (s->width+15)&~15;
382 int h= (s->height+15)&~15;
383 if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
384 printf("%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
387 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
390 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
395 static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
396 uint8_t *current, uint8_t *previous, int pitch,
397 svq1_pmv_t *motion,int x, int y) {
404 /* predict and decode motion vector (0) */
411 pmv[1] = &motion[(x / 8) + 2];
412 pmv[2] = &motion[(x / 8) + 4];
415 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
420 /* predict and decode motion vector (1) */
427 pmv[1] = &motion[(x / 8) + 3];
429 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
434 /* predict and decode motion vector (2) */
436 pmv[2] = &motion[(x / 8) + 1];
438 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
443 /* predict and decode motion vector (3) */
444 pmv[2] = &motion[(x / 8) + 2];
445 pmv[3] = &motion[(x / 8) + 3];
447 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
452 /* form predictions */
453 for (i=0; i < 4; i++) {
454 int mvx= pmv[i]->x + (i&1)*16;
455 int mvy= pmv[i]->y + (i>>1)*16;
457 ///XXX /FIXME cliping or padding?
464 int w= (s->width+15)&~15;
465 int h= (s->height+15)&~15;
466 if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
467 printf("%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
469 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
472 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
474 /* select next block */
476 current += 8*(pitch - 1);
485 static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
486 uint8_t *current, uint8_t *previous, int pitch,
487 svq1_pmv_t *motion, int x, int y) {
492 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
494 /* reset motion vectors */
495 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
498 motion[(x / 8) + 2].x =
499 motion[(x / 8) + 2].y =
500 motion[(x / 8) + 3].x =
501 motion[(x / 8) + 3].y = 0;
504 switch (block_type) {
505 case SVQ1_BLOCK_SKIP:
506 svq1_skip_block (current, previous, pitch, x, y);
509 case SVQ1_BLOCK_INTER:
510 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
515 printf("Error in svq1_motion_inter_block %i\n",result);
519 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
522 case SVQ1_BLOCK_INTER_4V:
523 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
528 printf("Error in svq1_motion_inter_4v_block %i\n",result);
532 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
535 case SVQ1_BLOCK_INTRA:
536 result = svq1_decode_block_intra (bitbuf, current, pitch);
543 /* standard video sizes */
544 static struct { int width; int height; } svq1_frame_size_table[8] = {
545 { 160, 120 }, { 128, 96 }, { 176, 144 }, { 352, 288 },
546 { 704, 576 }, { 240, 180 }, { 320, 240 }, { -1, -1 }
549 static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
552 for (i=0; i < length; i++) {
553 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
559 static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
560 int width, int height, int value) {
563 for (y=0; y < height; y++) {
564 for (x=0; x < width; x++) {
565 value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
574 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
578 out[0] = get_bits (bitbuf, 8);
580 seed = string_table[out[0]];
582 for (i=1; i < out[0]; i++) {
583 out[i] = get_bits (bitbuf, 8) ^ seed;
584 seed = string_table[out[i] ^ seed];
588 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
590 int temporal_reference;
592 temporal_reference = get_bits (bitbuf, 8);
595 s->pict_type= get_bits (bitbuf, 2)+1;
599 if (s->pict_type == I_TYPE) {
602 if (s->f_code == 0x50 || s->f_code == 0x60) {
603 int csum = get_bits (bitbuf, 16);
605 csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
607 // printf ("%s checksum (%02x) for packet data\n",
608 // (csum == 0) ? "correct" : "incorrect", csum);
611 if ((s->f_code ^ 0x10) >= 0x50) {
614 svq1_parse_string (bitbuf, (char *) msg);
616 printf ("embedded message: \"%s\"\n", (char *) msg);
619 get_bits (bitbuf, 2);
620 get_bits (bitbuf, 2);
621 get_bits (bitbuf, 1);
623 /* load frame size */
624 frame_size_code = get_bits (bitbuf, 3);
626 if (frame_size_code == 7) {
627 /* load width, height (12 bits each) */
628 s->width = get_bits (bitbuf, 12);
629 s->height = get_bits (bitbuf, 12);
631 if (!s->width || !s->height)
634 /* get width, height from table */
635 s->width = svq1_frame_size_table[frame_size_code].width;
636 s->height = svq1_frame_size_table[frame_size_code].height;
641 if (get_bits (bitbuf, 1) == 1) {
642 get_bits (bitbuf, 1); /* use packet checksum if (1) */
643 get_bits (bitbuf, 1); /* component checksums after image data if (1) */
645 if (get_bits (bitbuf, 2) != 0)
649 if (get_bits (bitbuf, 1) == 1) {
650 get_bits (bitbuf, 1);
651 get_bits (bitbuf, 4);
652 get_bits (bitbuf, 1);
653 get_bits (bitbuf, 2);
655 while (get_bits (bitbuf, 1) == 1) {
656 get_bits (bitbuf, 8);
663 static int svq1_decode_frame(AVCodecContext *avctx,
664 void *data, int *data_size,
665 uint8_t *buf, int buf_size)
667 MpegEncContext *s=avctx->priv_data;
668 uint8_t *current, *previous;
669 int result, i, x, y, width, height;
670 AVFrame *pict = data;
672 /* initialize bit buffer */
673 init_get_bits(&s->gb,buf,buf_size*8);
675 /* decode frame header */
676 s->f_code = get_bits (&s->gb, 22);
678 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
681 /* swap some header bytes (why?) */
682 if (s->f_code != 0x20) {
683 uint32_t *src = (uint32_t *) (buf + 4);
685 for (i=0; i < 4; i++) {
686 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
690 result = svq1_decode_frame_header (&s->gb, s);
695 printf("Error in svq1_decode_frame_header %i\n",result);
700 //FIXME this avoids some confusion for "B frames" without 2 references
701 //this should be removed after libavcodec can handle more flaxible picture types & ordering
702 if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
704 if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
706 if(MPV_frame_start(s, avctx) < 0)
709 /* decode y, u and v components */
710 for (i=0; i < 3; i++) {
713 width = (s->width+15)&~15;
714 height = (s->height+15)&~15;
715 linesize= s->linesize;
717 if(s->flags&CODEC_FLAG_GRAY) break;
718 width = (s->width/4+15)&~15;
719 height = (s->height/4+15)&~15;
720 linesize= s->uvlinesize;
723 current = s->current_picture.data[i];
725 if(s->pict_type==B_TYPE){
726 previous = s->next_picture.data[i];
728 previous = s->last_picture.data[i];
731 if (s->pict_type == I_TYPE) {
733 for (y=0; y < height; y+=16) {
734 for (x=0; x < width; x+=16) {
735 result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
739 printf("Error in svq1_decode_block %i (keyframe)\n",result);
744 current += 16*linesize;
747 svq1_pmv_t pmv[width/8+3];
749 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
751 for (y=0; y < height; y+=16) {
752 for (x=0; x < width; x+=16) {
753 result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
754 linesize, pmv, x, y);
758 printf("Error in svq1_decode_delta_block %i\n",result);
767 current += 16*linesize;
772 *pict = *(AVFrame*)&s->current_picture;
777 *data_size=sizeof(AVFrame);
781 static int svq1_decode_init(AVCodecContext *avctx)
783 MpegEncContext *s = avctx->priv_data;
787 s->width = (avctx->width+3)&~3;
788 s->height = (avctx->height+3)&~3;
789 s->codec_id= avctx->codec->id;
790 avctx->pix_fmt = PIX_FMT_YUV410P;
791 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
792 s->flags= avctx->flags;
793 if (MPV_common_init(s) < 0) return -1;
795 init_vlc(&svq1_block_type, 2, 4,
796 &svq1_block_type_vlc[0][1], 2, 1,
797 &svq1_block_type_vlc[0][0], 2, 1);
799 init_vlc(&svq1_motion_component, 7, 65,
800 &svq1_motion_component_vlc[0][1], 4, 2,
801 &svq1_motion_component_vlc[0][0], 4, 2);
803 for (i = 0; i < 6; i++) {
804 init_vlc(&svq1_intra_multistage[i], 3, 8,
805 &svq1_intra_multistage_vlc[i][0][1], 2, 1,
806 &svq1_intra_multistage_vlc[i][0][0], 2, 1);
807 init_vlc(&svq1_inter_multistage[i], 3, 8,
808 &svq1_inter_multistage_vlc[i][0][1], 2, 1,
809 &svq1_inter_multistage_vlc[i][0][0], 2, 1);
812 init_vlc(&svq1_intra_mean, 8, 256,
813 &svq1_intra_mean_vlc[0][1], 4, 2,
814 &svq1_intra_mean_vlc[0][0], 4, 2);
816 init_vlc(&svq1_inter_mean, 9, 512,
817 &svq1_inter_mean_vlc[0][1], 4, 2,
818 &svq1_inter_mean_vlc[0][0], 4, 2);
823 static int svq1_decode_end(AVCodecContext *avctx)
825 MpegEncContext *s = avctx->priv_data;
831 AVCodec svq1_decoder = {
835 sizeof(MpegEncContext),