Export svq1_packet_checksum() that is needed for svq3 watermarks,
[libav.git] / libavcodec / svq1dec.c
1 /*
2 * SVQ1 decoder
3 * ported to MPlayer by Arpi <arpi@thot.banki.hu>
4 * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
5 *
6 * Copyright (C) 2002 the xine project
7 * Copyright (C) 2002 the ffmpeg project
8 *
9 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
10 *
11 * This file is part of FFmpeg.
12 *
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.
17 *
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.
22 *
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
26 */
27
28 /**
29 * @file svq1.c
30 * Sorenson Vector Quantizer #1 (SVQ1) video codec.
31 * For more information of the SVQ1 algorithm, visit:
32 * http://www.pcisys.net/~melanson/codecs/
33 */
34
35
36 //#define DEBUG_SVQ1
37 #include "avcodec.h"
38 #include "dsputil.h"
39 #include "mpegvideo.h"
40
41 #include "svq1.h"
42
43 #undef NDEBUG
44 #include <assert.h>
45
46 extern const uint8_t mvtab[33][2];
47
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;
54
55 /* motion vector (prediction) */
56 typedef struct svq1_pmv_s {
57 int x;
58 int y;
59 } svq1_pmv_t;
60
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
94 };
95
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
129 };
130
131 #define SVQ1_PROCESS_VECTOR()\
132 for (; level > 0; i++) {\
133 /* process next depth */\
134 if (i == m) {\
135 m = n;\
136 if (--level == 0)\
137 break;\
138 }\
139 /* divide block if next bit set */\
140 if (get_bits1 (bitbuf) == 0)\
141 break;\
142 /* add child nodes */\
143 list[n++] = list[i];\
144 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
145 }
146
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);\
153 }\
154 \
155 /* clip to [0..255] */\
156 if (n1 & 0xFF00FF00) {\
157 n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
158 n1 += 0x7F007F00;\
159 n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
160 n1 &= (n3 & 0x00FF00FF);\
161 }\
162 \
163 if (n2 & 0xFF00FF00) {\
164 n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
165 n2 += 0x7F007F00;\
166 n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
167 n2 &= (n3 & 0x00FF00FF);\
168 }
169
170 #define SVQ1_DO_CODEBOOK_INTRA()\
171 for (y=0; y < height; y++) {\
172 for (x=0; x < (width / 4); x++, codebook++) {\
173 n1 = n4;\
174 n2 = n4;\
175 SVQ1_ADD_CODEBOOK()\
176 /* store result */\
177 dst[x] = (n1 << 8) | n2;\
178 }\
179 dst += (pitch / 4);\
180 }
181
182 #define SVQ1_DO_CODEBOOK_NONINTRA()\
183 for (y=0; y < height; y++) {\
184 for (x=0; x < (width / 4); x++, codebook++) {\
185 n3 = dst[x];\
186 /* add mean value to vector */\
187 n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
188 n2 = (n3 & 0x00FF00FF) + n4;\
189 SVQ1_ADD_CODEBOOK()\
190 /* store result */\
191 dst[x] = (n1 << 8) | n2;\
192 }\
193 dst += (pitch / 4);\
194 }
195
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);\
202 }\
203 mean -= (stages * 128);\
204 n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
205
206 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
207 uint32_t bit_cache;
208 uint8_t *list[63];
209 uint32_t *dst;
210 const uint32_t *codebook;
211 int entries[6];
212 int i, j, m, n;
213 int mean, stages;
214 unsigned x, y, width, height, level;
215 uint32_t n1, n2, n3, n4;
216
217 /* initialize list for breadth first processing of vectors */
218 list[0] = pixels;
219
220 /* recursively process vector */
221 for (i=0, m=1, n=1, level=5; i < n; i++) {
222 SVQ1_PROCESS_VECTOR();
223
224 /* destination address and vector size */
225 dst = (uint32_t *) list[i];
226 width = 1 << ((4 + level) /2);
227 height = 1 << ((3 + level) /2);
228
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;
231
232 if (stages == -1) {
233 for (y=0; y < height; y++) {
234 memset (&dst[y*(pitch / 4)], 0, width);
235 }
236 continue; /* skip vector */
237 }
238
239 if ((stages > 0) && (level >= 4)) {
240 #ifdef DEBUG_SVQ1
241 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
242 #endif
243 return -1; /* invalid vector */
244 }
245
246 mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
247
248 if (stages == 0) {
249 for (y=0; y < height; y++) {
250 memset (&dst[y*(pitch / 4)], mean, width);
251 }
252 } else {
253 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
254 SVQ1_DO_CODEBOOK_INTRA()
255 }
256 }
257
258 return 0;
259 }
260
261 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
262 uint32_t bit_cache;
263 uint8_t *list[63];
264 uint32_t *dst;
265 const uint32_t *codebook;
266 int entries[6];
267 int i, j, m, n;
268 int mean, stages;
269 int x, y, width, height, level;
270 uint32_t n1, n2, n3, n4;
271
272 /* initialize list for breadth first processing of vectors */
273 list[0] = pixels;
274
275 /* recursively process vector */
276 for (i=0, m=1, n=1, level=5; i < n; i++) {
277 SVQ1_PROCESS_VECTOR();
278
279 /* destination address and vector size */
280 dst = (uint32_t *) list[i];
281 width = 1 << ((4 + level) /2);
282 height = 1 << ((3 + level) /2);
283
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;
286
287 if (stages == -1) continue; /* skip vector */
288
289 if ((stages > 0) && (level >= 4)) {
290 #ifdef DEBUG_SVQ1
291 av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
292 #endif
293 return -1; /* invalid vector */
294 }
295
296 mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
297
298 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
299 SVQ1_DO_CODEBOOK_NONINTRA()
300 }
301 return 0;
302 }
303
304 static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
305 int diff;
306 int i;
307
308 for (i=0; i < 2; i++) {
309
310 /* get motion code */
311 diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
312 if(diff<0)
313 return -1;
314 else if(diff){
315 if(get_bits1(bitbuf)) diff= -diff;
316 }
317
318 /* add median of motion vector predictors and clip result */
319 if (i == 1)
320 mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
321 else
322 mv->x = ((diff + mid_pred(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 av_log(s->avctx, AV_LOG_INFO, "%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 clipping 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 av_log(s->avctx, AV_LOG_INFO, "%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 av_log(s->avctx, AV_LOG_INFO, "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 av_log(s->avctx, AV_LOG_INFO, "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 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
544 int i;
545
546 for (i=0; i < length; i++) {
547 value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
548 }
549
550 return value;
551 }
552
553 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
554 uint8_t seed;
555 int i;
556
557 out[0] = get_bits (bitbuf, 8);
558
559 seed = string_table[out[0]];
560
561 for (i=1; i <= out[0]; i++) {
562 out[i] = get_bits (bitbuf, 8) ^ seed;
563 seed = string_table[out[i] ^ seed];
564 }
565 }
566
567 static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
568 int frame_size_code;
569 int temporal_reference;
570
571 temporal_reference = get_bits (bitbuf, 8);
572
573 /* frame type */
574 s->pict_type= get_bits (bitbuf, 2)+1;
575 if(s->pict_type==4)
576 return -1;
577
578 if (s->pict_type == FF_I_TYPE) {
579
580 /* unknown fields */
581 if (s->f_code == 0x50 || s->f_code == 0x60) {
582 int csum = get_bits (bitbuf, 16);
583
584 csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
585
586 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
587 // (csum == 0) ? "correct" : "incorrect", csum);
588 }
589
590 if ((s->f_code ^ 0x10) >= 0x50) {
591 uint8_t msg[256];
592
593 svq1_parse_string (bitbuf, msg);
594
595 av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
596 }
597
598 skip_bits (bitbuf, 2);
599 skip_bits (bitbuf, 2);
600 skip_bits1 (bitbuf);
601
602 /* load frame size */
603 frame_size_code = get_bits (bitbuf, 3);
604
605 if (frame_size_code == 7) {
606 /* load width, height (12 bits each) */
607 s->width = get_bits (bitbuf, 12);
608 s->height = get_bits (bitbuf, 12);
609
610 if (!s->width || !s->height)
611 return -1;
612 } else {
613 /* get width, height from table */
614 s->width = ff_svq1_frame_size_table[frame_size_code].width;
615 s->height = ff_svq1_frame_size_table[frame_size_code].height;
616 }
617 }
618
619 /* unknown fields */
620 if (get_bits1 (bitbuf) == 1) {
621 skip_bits1 (bitbuf); /* use packet checksum if (1) */
622 skip_bits1 (bitbuf); /* component checksums after image data if (1) */
623
624 if (get_bits (bitbuf, 2) != 0)
625 return -1;
626 }
627
628 if (get_bits1 (bitbuf) == 1) {
629 skip_bits1 (bitbuf);
630 skip_bits (bitbuf, 4);
631 skip_bits1 (bitbuf);
632 skip_bits (bitbuf, 2);
633
634 while (get_bits1 (bitbuf) == 1) {
635 skip_bits (bitbuf, 8);
636 }
637 }
638
639 return 0;
640 }
641
642 static int svq1_decode_frame(AVCodecContext *avctx,
643 void *data, int *data_size,
644 const uint8_t *buf, int buf_size)
645 {
646 MpegEncContext *s=avctx->priv_data;
647 uint8_t *current, *previous;
648 int result, i, x, y, width, height;
649 AVFrame *pict = data;
650
651 /* initialize bit buffer */
652 init_get_bits(&s->gb,buf,buf_size*8);
653
654 /* decode frame header */
655 s->f_code = get_bits (&s->gb, 22);
656
657 if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
658 return -1;
659
660 /* swap some header bytes (why?) */
661 if (s->f_code != 0x20) {
662 uint32_t *src = (uint32_t *) (buf + 4);
663
664 for (i=0; i < 4; i++) {
665 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
666 }
667 }
668
669 result = svq1_decode_frame_header (&s->gb, s);
670
671 if (result != 0)
672 {
673 #ifdef DEBUG_SVQ1
674 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
675 #endif
676 return result;
677 }
678
679 //FIXME this avoids some confusion for "B frames" without 2 references
680 //this should be removed after libavcodec can handle more flexible picture types & ordering
681 if(s->pict_type==FF_B_TYPE && s->last_picture_ptr==NULL) return buf_size;
682
683 if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return buf_size;
684 if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
685 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
686 || avctx->skip_frame >= AVDISCARD_ALL)
687 return buf_size;
688
689 if(MPV_frame_start(s, avctx) < 0)
690 return -1;
691
692 /* decode y, u and v components */
693 for (i=0; i < 3; i++) {
694 int linesize;
695 if (i == 0) {
696 width = (s->width+15)&~15;
697 height = (s->height+15)&~15;
698 linesize= s->linesize;
699 } else {
700 if(s->flags&CODEC_FLAG_GRAY) break;
701 width = (s->width/4+15)&~15;
702 height = (s->height/4+15)&~15;
703 linesize= s->uvlinesize;
704 }
705
706 current = s->current_picture.data[i];
707
708 if(s->pict_type==FF_B_TYPE){
709 previous = s->next_picture.data[i];
710 }else{
711 previous = s->last_picture.data[i];
712 }
713
714 if (s->pict_type == FF_I_TYPE) {
715 /* keyframe */
716 for (y=0; y < height; y+=16) {
717 for (x=0; x < width; x+=16) {
718 result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
719 if (result != 0)
720 {
721 //#ifdef DEBUG_SVQ1
722 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
723 //#endif
724 return result;
725 }
726 }
727 current += 16*linesize;
728 }
729 } else {
730 svq1_pmv_t pmv[width/8+3];
731 /* delta frame */
732 memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
733
734 for (y=0; y < height; y+=16) {
735 for (x=0; x < width; x+=16) {
736 result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
737 linesize, pmv, x, y);
738 if (result != 0)
739 {
740 #ifdef DEBUG_SVQ1
741 av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
742 #endif
743 return result;
744 }
745 }
746
747 pmv[0].x =
748 pmv[0].y = 0;
749
750 current += 16*linesize;
751 }
752 }
753 }
754
755 *pict = *(AVFrame*)&s->current_picture;
756
757
758 MPV_frame_end(s);
759
760 *data_size=sizeof(AVFrame);
761 return buf_size;
762 }
763
764 static av_cold int svq1_decode_init(AVCodecContext *avctx)
765 {
766 MpegEncContext *s = avctx->priv_data;
767 int i;
768
769 MPV_decode_defaults(s);
770
771 s->avctx = avctx;
772 s->width = (avctx->width+3)&~3;
773 s->height = (avctx->height+3)&~3;
774 s->codec_id= avctx->codec->id;
775 avctx->pix_fmt = PIX_FMT_YUV410P;
776 avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
777 s->flags= avctx->flags;
778 if (MPV_common_init(s) < 0) return -1;
779
780 init_vlc(&svq1_block_type, 2, 4,
781 &ff_svq1_block_type_vlc[0][1], 2, 1,
782 &ff_svq1_block_type_vlc[0][0], 2, 1, 1);
783
784 init_vlc(&svq1_motion_component, 7, 33,
785 &mvtab[0][1], 2, 1,
786 &mvtab[0][0], 2, 1, 1);
787
788 for (i = 0; i < 6; i++) {
789 init_vlc(&svq1_intra_multistage[i], 3, 8,
790 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
791 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
792 init_vlc(&svq1_inter_multistage[i], 3, 8,
793 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
794 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
795 }
796
797 init_vlc(&svq1_intra_mean, 8, 256,
798 &ff_svq1_intra_mean_vlc[0][1], 4, 2,
799 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 1);
800
801 init_vlc(&svq1_inter_mean, 9, 512,
802 &ff_svq1_inter_mean_vlc[0][1], 4, 2,
803 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1);
804
805 return 0;
806 }
807
808 static av_cold int svq1_decode_end(AVCodecContext *avctx)
809 {
810 MpegEncContext *s = avctx->priv_data;
811
812 MPV_common_end(s);
813 return 0;
814 }
815
816
817 AVCodec svq1_decoder = {
818 "svq1",
819 CODEC_TYPE_VIDEO,
820 CODEC_ID_SVQ1,
821 sizeof(MpegEncContext),
822 svq1_decode_init,
823 NULL,
824 svq1_decode_end,
825 svq1_decode_frame,
826 CODEC_CAP_DR1,
827 .flush= ff_mpeg_flush,
828 .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
829 .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1"),
830 };