svq1dec.c
Go to the documentation of this file.
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 Libav.
12  *
13  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26  */
27 
36 #include "avcodec.h"
37 #include "dsputil.h"
38 #include "mpegvideo.h"
39 #include "mathops.h"
40 
41 #include "svq1.h"
42 
43 #undef NDEBUG
44 #include <assert.h>
45 
46 extern const uint8_t ff_mvtab[33][2];
47 
54 
55 /* motion vector (prediction) */
56 typedef struct svq1_pmv_s {
57  int x;
58  int y;
59 } svq1_pmv;
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  if (stages > 0)\
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);\
203  }\
204  mean -= (stages * 128);\
205  n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
206 
207 static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
208  uint32_t bit_cache;
209  uint8_t *list[63];
210  uint32_t *dst;
211  const uint32_t *codebook;
212  int entries[6];
213  int i, j, m, n;
214  int mean, stages;
215  unsigned x, y, width, height, level;
216  uint32_t n1, n2, n3, n4;
217 
218  /* initialize list for breadth first processing of vectors */
219  list[0] = pixels;
220 
221  /* recursively process vector */
222  for (i=0, m=1, n=1, level=5; i < n; i++) {
224 
225  /* destination address and vector size */
226  dst = (uint32_t *) list[i];
227  width = 1 << ((4 + level) /2);
228  height = 1 << ((3 + level) /2);
229 
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;
232 
233  if (stages == -1) {
234  for (y=0; y < height; y++) {
235  memset (&dst[y*(pitch / 4)], 0, width);
236  }
237  continue; /* skip vector */
238  }
239 
240  if ((stages > 0) && (level >= 4)) {
241  av_dlog(NULL,
242  "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
243  stages, level);
244  return -1; /* invalid vector */
245  }
246 
247  mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
248 
249  if (stages == 0) {
250  for (y=0; y < height; y++) {
251  memset (&dst[y*(pitch / 4)], mean, width);
252  }
253  } else {
256  }
257  }
258 
259  return 0;
260 }
261 
262 static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
263  uint32_t bit_cache;
264  uint8_t *list[63];
265  uint32_t *dst;
266  const uint32_t *codebook;
267  int entries[6];
268  int i, j, m, n;
269  int mean, stages;
270  int x, y, width, height, level;
271  uint32_t n1, n2, n3, n4;
272 
273  /* initialize list for breadth first processing of vectors */
274  list[0] = pixels;
275 
276  /* recursively process vector */
277  for (i=0, m=1, n=1, level=5; i < n; i++) {
279 
280  /* destination address and vector size */
281  dst = (uint32_t *) list[i];
282  width = 1 << ((4 + level) /2);
283  height = 1 << ((3 + level) /2);
284 
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;
287 
288  if (stages == -1) continue; /* skip vector */
289 
290  if ((stages > 0) && (level >= 4)) {
291  av_dlog(NULL,
292  "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
293  stages, level);
294  return -1; /* invalid vector */
295  }
296 
297  mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
298 
301  }
302  return 0;
303 }
304 
306  int diff;
307  int i;
308 
309  for (i=0; i < 2; i++) {
310 
311  /* get motion code */
312  diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
313  if(diff<0)
314  return -1;
315  else if(diff){
316  if(get_bits1(bitbuf)) diff= -diff;
317  }
318 
319  /* add median of motion vector predictors and clip result */
320  if (i == 1)
321  mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
322  else
323  mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
324  }
325 
326  return 0;
327 }
328 
329 static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
330  uint8_t *src;
331  uint8_t *dst;
332  int i;
333 
334  src = &previous[x + y*pitch];
335  dst = current;
336 
337  for (i=0; i < 16; i++) {
338  memcpy (dst, src, 16);
339  src += pitch;
340  dst += pitch;
341  }
342 }
343 
345  uint8_t *current, uint8_t *previous, int pitch,
346  svq1_pmv *motion, int x, int y) {
347  uint8_t *src;
348  uint8_t *dst;
349  svq1_pmv mv;
350  svq1_pmv *pmv[3];
351  int result;
352 
353  /* predict and decode motion vector */
354  pmv[0] = &motion[0];
355  if (y == 0) {
356  pmv[1] =
357  pmv[2] = pmv[0];
358  }
359  else {
360  pmv[1] = &motion[(x / 8) + 2];
361  pmv[2] = &motion[(x / 8) + 4];
362  }
363 
364  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
365 
366  if (result != 0)
367  return result;
368 
369  motion[0].x =
370  motion[(x / 8) + 2].x =
371  motion[(x / 8) + 3].x = mv.x;
372  motion[0].y =
373  motion[(x / 8) + 2].y =
374  motion[(x / 8) + 3].y = mv.y;
375 
376  if(y + (mv.y >> 1)<0)
377  mv.y= 0;
378  if(x + (mv.x >> 1)<0)
379  mv.x= 0;
380 
381  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
382  dst = current;
383 
384  s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
385 
386  return 0;
387 }
388 
390  uint8_t *current, uint8_t *previous, int pitch,
391  svq1_pmv *motion,int x, int y) {
392  uint8_t *src;
393  uint8_t *dst;
394  svq1_pmv mv;
395  svq1_pmv *pmv[4];
396  int i, result;
397 
398  /* predict and decode motion vector (0) */
399  pmv[0] = &motion[0];
400  if (y == 0) {
401  pmv[1] =
402  pmv[2] = pmv[0];
403  }
404  else {
405  pmv[1] = &motion[(x / 8) + 2];
406  pmv[2] = &motion[(x / 8) + 4];
407  }
408 
409  result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
410 
411  if (result != 0)
412  return result;
413 
414  /* predict and decode motion vector (1) */
415  pmv[0] = &mv;
416  if (y == 0) {
417  pmv[1] =
418  pmv[2] = pmv[0];
419  }
420  else {
421  pmv[1] = &motion[(x / 8) + 3];
422  }
423  result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
424 
425  if (result != 0)
426  return result;
427 
428  /* predict and decode motion vector (2) */
429  pmv[1] = &motion[0];
430  pmv[2] = &motion[(x / 8) + 1];
431 
432  result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
433 
434  if (result != 0)
435  return result;
436 
437  /* predict and decode motion vector (3) */
438  pmv[2] = &motion[(x / 8) + 2];
439  pmv[3] = &motion[(x / 8) + 3];
440 
441  result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
442 
443  if (result != 0)
444  return result;
445 
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;
450 
452  if(y + (mvy >> 1)<0)
453  mvy= 0;
454  if(x + (mvx >> 1)<0)
455  mvx= 0;
456 
457  src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
458  dst = current;
459 
460  s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
461 
462  /* select next block */
463  if (i & 1) {
464  current += 8*(pitch - 1);
465  } else {
466  current += 8;
467  }
468  }
469 
470  return 0;
471 }
472 
474  uint8_t *current, uint8_t *previous, int pitch,
475  svq1_pmv *motion, int x, int y) {
476  uint32_t block_type;
477  int result = 0;
478 
479  /* get block type */
480  block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
481 
482  /* reset motion vectors */
483  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
484  motion[0].x =
485  motion[0].y =
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;
490  }
491 
492  switch (block_type) {
493  case SVQ1_BLOCK_SKIP:
494  svq1_skip_block (current, previous, pitch, x, y);
495  break;
496 
497  case SVQ1_BLOCK_INTER:
498  result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
499 
500  if (result != 0)
501  {
502  av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
503  break;
504  }
505  result = svq1_decode_block_non_intra (bitbuf, current, pitch);
506  break;
507 
508  case SVQ1_BLOCK_INTER_4V:
509  result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
510 
511  if (result != 0)
512  {
513  av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
514  break;
515  }
516  result = svq1_decode_block_non_intra (bitbuf, current, pitch);
517  break;
518 
519  case SVQ1_BLOCK_INTRA:
520  result = svq1_decode_block_intra (bitbuf, current, pitch);
521  break;
522  }
523 
524  return result;
525 }
526 
527 uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
528  int i;
529 
530  for (i=0; i < length; i++) {
531  value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
532  }
533 
534  return value;
535 }
536 
537 static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
538  uint8_t seed;
539  int i;
540 
541  out[0] = get_bits (bitbuf, 8);
542 
543  seed = string_table[out[0]];
544 
545  for (i=1; i <= out[0]; i++) {
546  out[i] = get_bits (bitbuf, 8) ^ seed;
547  seed = string_table[out[i] ^ seed];
548  }
549 }
550 
552  int frame_size_code;
553 
554  skip_bits(bitbuf, 8); /* temporal_reference */
555 
556  /* frame type */
557  s->pict_type= get_bits (bitbuf, 2)+1;
558  if(s->pict_type==4)
559  return -1;
560 
561  if (s->pict_type == AV_PICTURE_TYPE_I) {
562 
563  /* unknown fields */
564  if (s->f_code == 0x50 || s->f_code == 0x60) {
565  int csum = get_bits (bitbuf, 16);
566 
567  csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
568 
569 // av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
570 // (csum == 0) ? "correct" : "incorrect", csum);
571  }
572 
573  if ((s->f_code ^ 0x10) >= 0x50) {
574  uint8_t msg[256];
575 
576  svq1_parse_string (bitbuf, msg);
577 
578  av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
579  }
580 
581  skip_bits (bitbuf, 2);
582  skip_bits (bitbuf, 2);
583  skip_bits1 (bitbuf);
584 
585  /* load frame size */
586  frame_size_code = get_bits (bitbuf, 3);
587 
588  if (frame_size_code == 7) {
589  /* load width, height (12 bits each) */
590  s->width = get_bits (bitbuf, 12);
591  s->height = get_bits (bitbuf, 12);
592 
593  if (!s->width || !s->height)
594  return -1;
595  } else {
596  /* get width, height from table */
597  s->width = ff_svq1_frame_size_table[frame_size_code].width;
598  s->height = ff_svq1_frame_size_table[frame_size_code].height;
599  }
600  }
601 
602  /* unknown fields */
603  if (get_bits1 (bitbuf) == 1) {
604  skip_bits1 (bitbuf); /* use packet checksum if (1) */
605  skip_bits1 (bitbuf); /* component checksums after image data if (1) */
606 
607  if (get_bits (bitbuf, 2) != 0)
608  return -1;
609  }
610 
611  if (get_bits1 (bitbuf) == 1) {
612  skip_bits1 (bitbuf);
613  skip_bits (bitbuf, 4);
614  skip_bits1 (bitbuf);
615  skip_bits (bitbuf, 2);
616 
617  while (get_bits1 (bitbuf) == 1) {
618  skip_bits (bitbuf, 8);
619  }
620  }
621 
622  return 0;
623 }
624 
626  void *data, int *data_size,
627  AVPacket *avpkt)
628 {
629  const uint8_t *buf = avpkt->data;
630  int buf_size = avpkt->size;
631  MpegEncContext *s=avctx->priv_data;
632  uint8_t *current, *previous;
633  int result, i, x, y, width, height;
634  AVFrame *pict = data;
635  svq1_pmv *pmv;
636 
637  /* initialize bit buffer */
638  init_get_bits(&s->gb,buf,buf_size*8);
639 
640  /* decode frame header */
641  s->f_code = get_bits (&s->gb, 22);
642 
643  if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
644  return -1;
645 
646  /* swap some header bytes (why?) */
647  if (s->f_code != 0x20) {
648  uint32_t *src;
649 
650  if (buf_size < 9 * 4) {
651  av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
652  return AVERROR_INVALIDDATA;
653  }
654 
656  buf_size);
657  if (!s->pkt_swapped)
658  return AVERROR(ENOMEM);
659 
660  memcpy(s->pkt_swapped, buf, buf_size);
661  buf = s->pkt_swapped;
662  init_get_bits(&s->gb, buf, buf_size * 8);
663  skip_bits(&s->gb, 22);
664 
665  src = (uint32_t *)(s->pkt_swapped + 4);
666 
667  for (i = 0; i < 4; i++)
668  src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
669  }
670 
671  result = svq1_decode_frame_header (&s->gb, s);
672 
673  if (result != 0)
674  {
675  av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
676  return result;
677  }
678  avcodec_set_dimensions(avctx, s->width, s->height);
679 
680  //FIXME this avoids some confusion for "B frames" without 2 references
681  //this should be removed after libavcodec can handle more flexible picture types & ordering
682  if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size;
683 
686  || avctx->skip_frame >= AVDISCARD_ALL)
687  return buf_size;
688 
689  if(MPV_frame_start(s, avctx) < 0)
690  return -1;
691 
692  pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv));
693  if (!pmv)
694  return -1;
695 
696  /* decode y, u and v components */
697  for (i=0; i < 3; i++) {
698  int linesize;
699  if (i == 0) {
700  width = FFALIGN(s->width, 16);
701  height = FFALIGN(s->height, 16);
702  linesize= s->linesize;
703  } else {
704  if(s->flags&CODEC_FLAG_GRAY) break;
705  width = FFALIGN(s->width/4, 16);
706  height = FFALIGN(s->height/4, 16);
707  linesize= s->uvlinesize;
708  }
709 
710  current = s->current_picture.f.data[i];
711 
713  previous = s->next_picture.f.data[i];
714  }else{
715  previous = s->last_picture.f.data[i];
716  }
717 
718  if (s->pict_type == AV_PICTURE_TYPE_I) {
719  /* keyframe */
720  for (y=0; y < height; y+=16) {
721  for (x=0; x < width; x+=16) {
722  result = svq1_decode_block_intra (&s->gb, &current[x], linesize);
723  if (result != 0)
724  {
725  av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
726  goto err;
727  }
728  }
729  current += 16*linesize;
730  }
731  } else {
732  /* delta frame */
733  memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
734 
735  for (y=0; y < height; y+=16) {
736  for (x=0; x < width; x+=16) {
737  result = svq1_decode_delta_block (s, &s->gb, &current[x], previous,
738  linesize, pmv, x, y);
739  if (result != 0)
740  {
741  av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result);
742  goto err;
743  }
744  }
745 
746  pmv[0].x =
747  pmv[0].y = 0;
748 
749  current += 16*linesize;
750  }
751  }
752  }
753 
754  *pict = *(AVFrame*)&s->current_picture;
755 
756 
757  MPV_frame_end(s);
758 
759  *data_size=sizeof(AVFrame);
760  result = buf_size;
761 err:
762  av_free(pmv);
763  return result;
764 }
765 
767 {
768  MpegEncContext *s = avctx->priv_data;
769  int i;
770  int offset = 0;
771 
773 
774  s->avctx = avctx;
775  s->width = (avctx->width+3)&~3;
776  s->height = (avctx->height+3)&~3;
777  s->codec_id= avctx->codec->id;
778  avctx->pix_fmt = PIX_FMT_YUV410P;
779  avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
780  s->flags= avctx->flags;
781  if (MPV_common_init(s) < 0) return -1;
782 
783  INIT_VLC_STATIC(&svq1_block_type, 2, 4,
784  &ff_svq1_block_type_vlc[0][1], 2, 1,
785  &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
786 
787  INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
788  &ff_mvtab[0][1], 2, 1,
789  &ff_mvtab[0][0], 2, 1, 176);
790 
791  for (i = 0; i < 6; i++) {
792  static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}};
793  static VLC_TYPE table[168][2];
794  svq1_intra_multistage[i].table = &table[offset];
795  svq1_intra_multistage[i].table_allocated = sizes[0][i];
796  offset += sizes[0][i];
797  init_vlc(&svq1_intra_multistage[i], 3, 8,
798  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
800  svq1_inter_multistage[i].table = &table[offset];
801  svq1_inter_multistage[i].table_allocated = sizes[1][i];
802  offset += sizes[1][i];
803  init_vlc(&svq1_inter_multistage[i], 3, 8,
804  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
806  }
807 
808  INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
809  &ff_svq1_intra_mean_vlc[0][1], 4, 2,
810  &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
811 
812  INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
813  &ff_svq1_inter_mean_vlc[0][1], 4, 2,
814  &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
815 
816  return 0;
817 }
818 
820 {
821  MpegEncContext *s = avctx->priv_data;
822 
823  av_freep(&s->pkt_swapped);
824 
825  MPV_common_end(s);
826  return 0;
827 }
828 
829 
831  .name = "svq1",
832  .type = AVMEDIA_TYPE_VIDEO,
833  .id = CODEC_ID_SVQ1,
834  .priv_data_size = sizeof(MpegEncContext),
838  .capabilities = CODEC_CAP_DR1,
840  .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV410P, PIX_FMT_NONE},
841  .long_name= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
842 };