off-by-1 error in the never-before-tested embedded string code
[libav.git] / libavcodec / svq1.c
1 /*
2 *
3 * Copyright (C) 2002 the xine project
4 * Copyright (C) 2002 the ffmpeg project
5 *
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.
10 *
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.
15 *
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
19 *
20 * Ported to mplayer by Arpi <arpi@thot.banki.hu>
21 * Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
22 *
23 */
24
25 /**
26 * @file svq1.c
27 * Sorenson Vector Quantizer #1 (SVQ1) video decoder.
28 */
29
30
31 //#define DEBUG_SVQ1
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <unistd.h>
36
37 #include "common.h"
38 #include "avcodec.h"
39 #include "dsputil.h"
40 #include "mpegvideo.h"
41 #include "bswap.h"
42
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;
49
50 #define MEDIAN(a,b,c) (((a < b) != (b >= c)) ? b : (((a < c) != (c > b)) ? c : a))
51
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
56
57 /* motion vector (prediction) */
58 typedef struct svq1_pmv_s {
59 int x;
60 int y;
61 } svq1_pmv_t;
62
63 #include "svq1_cb.h"
64 #include "svq1_vlc.h"
65
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
99 };
100
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
134 };
135
136 #define SVQ1_PROCESS_VECTOR()\
137 for (; level > 0; i++) {\
138 /* process next depth */\
139 if (i == m) {\
140 m = n;\
141 if (--level == 0)\
142 break;\
143 }\
144 /* divide block if next bit set */\
145 if (get_bits (bitbuf, 1) == 0)\
146 break;\
147 /* add child nodes */\
148 list[n++] = list[i];\
149 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
150 }
151
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);\
158 }\
159 \
160 /* clip to [0..255] */\
161 if (n1 & 0xFF00FF00) {\
162 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
163 n1 += 0x7F007F00;\
164 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
165 n1 &= (n3 & 0x00FF00FF);\
166 }\
167 \
168 if (n2 & 0xFF00FF00) {\
169 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
170 n2 += 0x7F007F00;\
171 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
172 n2 &= (n3 & 0x00FF00FF);\
173 }
174
175 #define SVQ1_DO_CODEBOOK_INTRA()\
176 for (y=0; y < height; y++) {\
177 for (x=0; x < (width / 4); x++, codebook++) {\
178 n1 = n4;\
179 n2 = n4;\
180 SVQ1_ADD_CODEBOOK()\
181 /* store result */\
182 dst[x] = (n1 << 8) | n2;\
183 }\
184 dst += (pitch / 4);\
185 }
186
187 #define SVQ1_DO_CODEBOOK_NONINTRA()\
188 for (y=0; y < height; y++) {\
189 for (x=0; x < (width / 4); x++, codebook++) {\
190 n3 = dst[x];\
191 /* add mean value to vector */\
192 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
193 n2 = (n3 & 0x00FF00FF) + n4;\
194 SVQ1_ADD_CODEBOOK()\
195 /* store result */\
196 dst[x] = (n1 << 8) | n2;\
197 }\
198 dst += (pitch / 4);\
199 }
200
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);\
207 }\
208 mean -= (stages * 128);\
209 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
210
211 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
212 uint32_t bit_cache;
213 uint8_t *list[63];
214 uint32_t *dst;
215 const uint32_t *codebook;
216 int entries[6];
217 int i, j, m, n;
218 int mean, stages;
219 unsigned x, y, width, height, level;
220 uint32_t n1, n2, n3, n4;
221
222 /* initialize list for breadth first processing of vectors */
223 list[0] = pixels;
224
225 /* recursively process vector */
226 for (i=0, m=1, n=1, level=5; i < n; i++) {
227 SVQ1_PROCESS_VECTOR();
228
229 /* destination address and vector size */
230 dst = (uint32_t *) list[i];
231 width = 1 << ((4 + level) /2);
232 height = 1 << ((3 + level) /2);
233
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;
236
237 if (stages == -1) {
238 for (y=0; y < height; y++) {
239 memset (&dst[y*(pitch / 4)], 0, width);
240 }
241 continue; /* skip vector */
242 }
243
244 if ((stages > 0) && (level >= 4)) {
245 #ifdef DEBUG_SVQ1
246 printf("Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
247 #endif
248 return -1; /* invalid vector */
249 }
250
251 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
252
253 if (stages == 0) {
254 for (y=0; y < height; y++) {
255 memset (&dst[y*(pitch / 4)], mean, width);
256 }
257 } else {
258 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
259 SVQ1_DO_CODEBOOK_INTRA()
260 }
261 }
262
263 return 0;
264 }
265
266 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
267 uint32_t bit_cache;
268 uint8_t *list[63];
269 uint32_t *dst;
270 const uint32_t *codebook;
271 int entries[6];
272 int i, j, m, n;
273 int mean, stages;
274 int x, y, width, height, level;
275 uint32_t n1, n2, n3, n4;
276
277 /* initialize list for breadth first processing of vectors */
278 list[0] = pixels;
279
280 /* recursively process vector */
281 for (i=0, m=1, n=1, level=5; i < n; i++) {
282 SVQ1_PROCESS_VECTOR();
283
284 /* destination address and vector size */
285 dst = (uint32_t *) list[i];
286 width = 1 << ((4 + level) /2);
287 height = 1 << ((3 + level) /2);
288
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;
291
292 if (stages == -1) continue; /* skip vector */
293
294 if ((stages > 0) && (level >= 4)) {
295 #ifdef DEBUG_SVQ1
296 printf("Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
297 #endif
298 return -1; /* invalid vector */
299 }
300
301 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
302
303 SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
304 SVQ1_DO_CODEBOOK_NONINTRA()
305 }
306 return 0;
307 }
308
309 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
310 int diff;
311 int i;
312
313 for (i=0; i < 2; i++) {
314
315 /* get motion code */
316 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2) - 32;
317
318 /* add median of motion vector predictors and clip result */
319 if (i == 1)
320 mv->y = ((diff + MEDIAN(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
321 else
322 mv->x = ((diff + MEDIAN(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
323 }
324
325 return 0;
326 }
327
328 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
329 uint8_t *src;
330 uint8_t *dst;
331 int i;
332
333 src = &previous[x + y*pitch];
334 dst = current;
335
336 for (i=0; i < 16; i++) {
337 memcpy (dst, src, 16);
338 src += pitch;
339 dst += pitch;
340 }
341 }
342
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) {
346 uint8_t *src;
347 uint8_t *dst;
348 svq1_pmv_t mv;
349 svq1_pmv_t *pmv[3];
350 int result;
351
352 /* predict and decode motion vector */
353 pmv[0] = &motion[0];
354 if (y == 0) {
355 pmv[1] =
356 pmv[2] = pmv[0];
357 }
358 else {
359 pmv[1] = &motion[(x / 8) + 2];
360 pmv[2] = &motion[(x / 8) + 4];
361 }
362
363 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
364
365 if (result != 0)
366 return result;
367
368 motion[0].x =
369 motion[(x / 8) + 2].x =
370 motion[(x / 8) + 3].x = mv.x;
371 motion[0].y =
372 motion[(x / 8) + 2].y =
373 motion[(x / 8) + 3].y = mv.y;
374
375 if(y + (mv.y >> 1)<0)
376 mv.y= 0;
377 if(x + (mv.x >> 1)<0)
378 mv.x= 0;
379
380 #if 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));
385 #endif
386
387 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
388 dst = current;
389
390 s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
391
392 return 0;
393 }
394
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) {
398 uint8_t *src;
399 uint8_t *dst;
400 svq1_pmv_t mv;
401 svq1_pmv_t *pmv[4];
402 int i, result;
403
404 /* predict and decode motion vector (0) */
405 pmv[0] = &motion[0];
406 if (y == 0) {
407 pmv[1] =
408 pmv[2] = pmv[0];
409 }
410 else {
411 pmv[1] = &motion[(x / 8) + 2];
412 pmv[2] = &motion[(x / 8) + 4];
413 }
414
415 result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
416
417 if (result != 0)
418 return result;
419
420 /* predict and decode motion vector (1) */
421 pmv[0] = &mv;
422 if (y == 0) {
423 pmv[1] =
424 pmv[2] = pmv[0];
425 }
426 else {
427 pmv[1] = &motion[(x / 8) + 3];
428 }
429 result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
430
431 if (result != 0)
432 return result;
433
434 /* predict and decode motion vector (2) */
435 pmv[1] = &motion[0];
436 pmv[2] = &motion[(x / 8) + 1];
437
438 result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
439
440 if (result != 0)
441 return result;
442
443 /* predict and decode motion vector (3) */
444 pmv[2] = &motion[(x / 8) + 2];
445 pmv[3] = &motion[(x / 8) + 3];
446
447 result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
448
449 if (result != 0)
450 return result;
451
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;
456
457 ///XXX /FIXME cliping or padding?
458 if(y + (mvy >> 1)<0)
459 mvy= 0;
460 if(x + (mvx >> 1)<0)
461 mvx= 0;
462
463 #if 0
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));
468 #endif
469 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
470 dst = current;
471
472 s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
473
474 /* select next block */
475 if (i & 1) {
476 current += 8*(pitch - 1);
477 } else {
478 current += 8;
479 }
480 }
481
482 return 0;
483 }
484
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) {
488 uint32_t block_type;
489 int result = 0;
490
491 /* get block type */
492 block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
493
494 /* reset motion vectors */
495 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
496 motion[0].x =
497 motion[0].y =
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;
502 }
503
504 switch (block_type) {
505 case SVQ1_BLOCK_SKIP:
506 svq1_skip_block (current, previous, pitch, x, y);
507 break;
508
509 case SVQ1_BLOCK_INTER:
510 result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
511
512 if (result != 0)
513 {
514 #ifdef DEBUG_SVQ1
515 printf("Error in svq1_motion_inter_block %i\n",result);
516 #endif
517 break;
518 }
519 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
520 break;
521
522 case SVQ1_BLOCK_INTER_4V:
523 result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
524
525 if (result != 0)
526 {
527 #ifdef DEBUG_SVQ1
528 printf("Error in svq1_motion_inter_4v_block %i\n",result);
529 #endif
530 break;
531 }
532 result = svq1_decode_block_non_intra (bitbuf, current, pitch);
533 break;
534
535 case SVQ1_BLOCK_INTRA:
536 result = svq1_decode_block_intra (bitbuf, current, pitch);
537 break;
538 }
539
540 return result;
541 }
542
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 }
547 };
548
549 static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
550 int i;
551
552 for (i=0; i < length; i++) {
553 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
554 }
555
556 return value;
557 }
558
559 static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
560 int width, int height, int value) {
561 int x, y;
562
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);
566 }
567
568 pixels += pitch;
569 }
570
571 return value;
572 }
573
574 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
575 uint8_t seed;
576 int i;
577
578 out[0] = get_bits (bitbuf, 8);
579
580 seed = string_table[out[0]];
581
582 for (i=1; i <= out[0]; i++) {
583 out[i] = get_bits (bitbuf, 8) ^ seed;
584 seed = string_table[out[i] ^ seed];
585 }
586 }
587
588 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
589 int frame_size_code;
590 int temporal_reference;
591
592 temporal_reference = get_bits (bitbuf, 8);
593
594 /* frame type */
595 s->pict_type= get_bits (bitbuf, 2)+1;
596 if(s->pict_type==4)
597 return -1;
598
599 if (s->pict_type == I_TYPE) {
600
601 /* unknown fields */
602 if (s->f_code == 0x50 || s->f_code == 0x60) {
603 int csum = get_bits (bitbuf, 16);
604
605 csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
606
607 // printf ("%s checksum (%02x) for packet data\n",
608 // (csum == 0) ? "correct" : "incorrect", csum);
609 }
610
611 if ((s->f_code ^ 0x10) >= 0x50) {
612 char msg[256];
613
614 svq1_parse_string (bitbuf, (char *) msg);
615
616 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
617 }
618
619 skip_bits (bitbuf, 2);
620 skip_bits (bitbuf, 2);
621 skip_bits1 (bitbuf);
622
623 /* load frame size */
624 frame_size_code = get_bits (bitbuf, 3);
625
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);
630
631 if (!s->width || !s->height)
632 return -1;
633 } else {
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;
637 }
638 }
639
640 /* unknown fields */
641 if (get_bits (bitbuf, 1) == 1) {
642 skip_bits1 (bitbuf); /* use packet checksum if (1) */
643 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
644
645 if (get_bits (bitbuf, 2) != 0)
646 return -1;
647 }
648
649 if (get_bits (bitbuf, 1) == 1) {
650 skip_bits1 (bitbuf);
651 skip_bits (bitbuf, 4);
652 skip_bits1 (bitbuf);
653 skip_bits (bitbuf, 2);
654
655 while (get_bits (bitbuf, 1) == 1) {
656 skip_bits (bitbuf, 8);
657 }
658 }
659
660 return 0;
661 }
662
663 static int svq1_decode_frame(AVCodecContext *avctx,
664 void *data, int *data_size,
665 uint8_t *buf, int buf_size)
666 {
667 MpegEncContext *s=avctx->priv_data;
668 uint8_t *current, *previous;
669 int result, i, x, y, width, height;
670 AVFrame *pict = data;
671
672 /* initialize bit buffer */
673 init_get_bits(&s->gb,buf,buf_size*8);
674
675 /* decode frame header */
676 s->f_code = get_bits (&s->gb, 22);
677
678 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
679 return -1;
680
681 /* swap some header bytes (why?) */
682 if (s->f_code != 0x20) {
683 uint32_t *src = (uint32_t *) (buf + 4);
684
685 for (i=0; i < 4; i++) {
686 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
687 }
688 }
689
690 result = svq1_decode_frame_header (&s->gb, s);
691
692 if (result != 0)
693 {
694 #ifdef DEBUG_SVQ1
695 printf("Error in svq1_decode_frame_header %i\n",result);
696 #endif
697 return result;
698 }
699
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;
703
704 if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
705
706 if(MPV_frame_start(s, avctx) < 0)
707 return -1;
708
709 /* decode y, u and v components */
710 for (i=0; i < 3; i++) {
711 int linesize;
712 if (i == 0) {
713 width = (s->width+15)&~15;
714 height = (s->height+15)&~15;
715 linesize= s->linesize;
716 } else {
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;
721 }
722
723 current = s->current_picture.data[i];
724
725 if(s->pict_type==B_TYPE){
726 previous = s->next_picture.data[i];
727 }else{
728 previous = s->last_picture.data[i];
729 }
730
731 if (s->pict_type == I_TYPE) {
732 /* keyframe */
733 for (y=0; y < height; y+=16) {
734 for (x=0; x < width; x+=16) {
735 result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
736 if (result != 0)
737 {
738 #ifdef DEBUG_SVQ1
739 printf("Error in svq1_decode_block %i (keyframe)\n",result);
740 #endif
741 return result;
742 }
743 }
744 current += 16*linesize;
745 }
746 } else {
747 svq1_pmv_t pmv[width/8+3];
748 /* delta frame */
749 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
750
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, &current[x], previous,
754 linesize, pmv, x, y);
755 if (result != 0)
756 {
757 #ifdef DEBUG_SVQ1
758 printf("Error in svq1_decode_delta_block %i\n",result);
759 #endif
760 return result;
761 }
762 }
763
764 pmv[0].x =
765 pmv[0].y = 0;
766
767 current += 16*linesize;
768 }
769 }
770 }
771
772 *pict = *(AVFrame*)&s->current_picture;
773
774
775 MPV_frame_end(s);
776
777 *data_size=sizeof(AVFrame);
778 return buf_size;
779 }
780
781 static int svq1_decode_init(AVCodecContext *avctx)
782 {
783 MpegEncContext *s = avctx->priv_data;
784 int i;
785
786 s->avctx = avctx;
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;
794
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);
798
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);
802
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);
810 }
811
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);
815
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);
819
820 return 0;
821 }
822
823 static int svq1_decode_end(AVCodecContext *avctx)
824 {
825 MpegEncContext *s = avctx->priv_data;
826
827 MPV_common_end(s);
828 return 0;
829 }
830
831 AVCodec svq1_decoder = {
832 "svq1",
833 CODEC_TYPE_VIDEO,
834 CODEC_ID_SVQ1,
835 sizeof(MpegEncContext),
836 svq1_decode_init,
837 NULL,
838 svq1_decode_end,
839 svq1_decode_frame,
840 CODEC_CAP_DR1,
841 .flush= ff_mpeg_flush,
842 };