FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 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
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 #include "avcodec.h"
36 #include "get_bits.h"
37 #include "h263.h"
38 #include "hpeldsp.h"
39 #include "internal.h"
40 #include "mathops.h"
41 #include "svq1.h"
42 
43 #undef NDEBUG
44 #include <assert.h>
45 
46 static VLC svq1_block_type;
47 static VLC svq1_motion_component;
48 static VLC svq1_intra_multistage[6];
49 static VLC svq1_inter_multistage[6];
50 static VLC svq1_intra_mean;
51 static VLC svq1_inter_mean;
52 
53 /* motion vector (prediction) */
54 typedef struct svq1_pmv_s {
55  int x;
56  int y;
57 } svq1_pmv;
58 
59 typedef struct SVQ1Context {
60  HpelDSPContext hdsp;
61  GetBitContext gb;
62  AVFrame *prev;
63 
64  uint8_t *pkt_swapped;
65  int pkt_swapped_allocated;
66 
67  int width;
68  int height;
69  int frame_code;
70  int nonref; // 1 if the current frame won't be referenced
71 } SVQ1Context;
72 
73 static const uint8_t string_table[256] = {
74  0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
75  0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
76  0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
77  0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
78  0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
79  0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
80  0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
81  0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
82  0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
83  0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
84  0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
85  0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
86  0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
87  0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
88  0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
89  0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
90  0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
91  0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
92  0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
93  0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
94  0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
95  0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
96  0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
97  0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
98  0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
99  0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
100  0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
101  0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
102  0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
103  0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
104  0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
105  0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
106 };
107 
108 #define SVQ1_PROCESS_VECTOR() \
109  for (; level > 0; i++) { \
110  /* process next depth */ \
111  if (i == m) { \
112  m = n; \
113  if (--level == 0) \
114  break; \
115  } \
116  /* divide block if next bit set */ \
117  if (!get_bits1(bitbuf)) \
118  break; \
119  /* add child nodes */ \
120  list[n++] = list[i]; \
121  list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
122  }
123 
124 #define SVQ1_ADD_CODEBOOK() \
125  /* add codebook entries to vector */ \
126  for (j = 0; j < stages; j++) { \
127  n3 = codebook[entries[j]] ^ 0x80808080; \
128  n1 += (n3 & 0xFF00FF00) >> 8; \
129  n2 += n3 & 0x00FF00FF; \
130  } \
131  \
132  /* clip to [0..255] */ \
133  if (n1 & 0xFF00FF00) { \
134  n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
135  n1 += 0x7F007F00; \
136  n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
137  n1 &= n3 & 0x00FF00FF; \
138  } \
139  \
140  if (n2 & 0xFF00FF00) { \
141  n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
142  n2 += 0x7F007F00; \
143  n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
144  n2 &= n3 & 0x00FF00FF; \
145  }
146 
147 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
148  codebook = (const uint32_t *)cbook[level]; \
149  if (stages > 0) \
150  bit_cache = get_bits(bitbuf, 4 * stages); \
151  /* calculate codebook entries for this vector */ \
152  for (j = 0; j < stages; j++) { \
153  entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
154  16 * j) << (level + 1); \
155  } \
156  mean -= stages * 128; \
157  n4 = (mean << 16) + mean;
158 
159 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
160  int pitch)
161 {
162  uint32_t bit_cache;
163  uint8_t *list[63];
164  uint32_t *dst;
165  const uint32_t *codebook;
166  int entries[6];
167  int i, j, m, n;
168  int mean, stages;
169  unsigned x, y, width, height, level;
170  uint32_t n1, n2, n3, n4;
171 
172  /* initialize list for breadth first processing of vectors */
173  list[0] = pixels;
174 
175  /* recursively process vector */
176  for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
177  SVQ1_PROCESS_VECTOR();
178 
179  /* destination address and vector size */
180  dst = (uint32_t *)list[i];
181  width = 1 << ((4 + level) / 2);
182  height = 1 << ((3 + level) / 2);
183 
184  /* get number of stages (-1 skips vector, 0 for mean only) */
185  stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
186 
187  if (stages == -1) {
188  for (y = 0; y < height; y++)
189  memset(&dst[y * (pitch / 4)], 0, width);
190  continue; /* skip vector */
191  }
192 
193  if (stages > 0 && level >= 4) {
194  av_dlog(NULL,
195  "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
196  stages, level);
197  return AVERROR_INVALIDDATA; /* invalid vector */
198  }
199 
200  mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
201 
202  if (stages == 0) {
203  for (y = 0; y < height; y++)
204  memset(&dst[y * (pitch / 4)], mean, width);
205  } else {
206  SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
207 
208  for (y = 0; y < height; y++) {
209  for (x = 0; x < width / 4; x++, codebook++) {
210  n1 = n4;
211  n2 = n4;
212  SVQ1_ADD_CODEBOOK()
213  /* store result */
214  dst[x] = n1 << 8 | n2;
215  }
216  dst += pitch / 4;
217  }
218  }
219  }
220 
221  return 0;
222 }
223 
224 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
225  int pitch)
226 {
227  uint32_t bit_cache;
228  uint8_t *list[63];
229  uint32_t *dst;
230  const uint32_t *codebook;
231  int entries[6];
232  int i, j, m, n;
233  int mean, stages;
234  int x, y, width, height, level;
235  uint32_t n1, n2, n3, n4;
236 
237  /* initialize list for breadth first processing of vectors */
238  list[0] = pixels;
239 
240  /* recursively process vector */
241  for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
242  SVQ1_PROCESS_VECTOR();
243 
244  /* destination address and vector size */
245  dst = (uint32_t *)list[i];
246  width = 1 << ((4 + level) / 2);
247  height = 1 << ((3 + level) / 2);
248 
249  /* get number of stages (-1 skips vector, 0 for mean only) */
250  stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
251 
252  if (stages == -1)
253  continue; /* skip vector */
254 
255  if ((stages > 0) && (level >= 4)) {
256  av_dlog(NULL,
257  "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
258  stages, level);
259  return AVERROR_INVALIDDATA; /* invalid vector */
260  }
261 
262  mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
263 
264  SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
265 
266  for (y = 0; y < height; y++) {
267  for (x = 0; x < width / 4; x++, codebook++) {
268  n3 = dst[x];
269  /* add mean value to vector */
270  n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
271  n2 = n4 + (n3 & 0x00FF00FF);
272  SVQ1_ADD_CODEBOOK()
273  /* store result */
274  dst[x] = n1 << 8 | n2;
275  }
276  dst += pitch / 4;
277  }
278  }
279  return 0;
280 }
281 
282 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
283  svq1_pmv **pmv)
284 {
285  int diff;
286  int i;
287 
288  for (i = 0; i < 2; i++) {
289  /* get motion code */
290  diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
291  if (diff < 0)
292  return AVERROR_INVALIDDATA;
293  else if (diff) {
294  if (get_bits1(bitbuf))
295  diff = -diff;
296  }
297 
298  /* add median of motion vector predictors and clip result */
299  if (i == 1)
300  mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
301  else
302  mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
303  }
304 
305  return 0;
306 }
307 
308 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
309  int pitch, int x, int y)
310 {
311  uint8_t *src;
312  uint8_t *dst;
313  int i;
314 
315  src = &previous[x + y * pitch];
316  dst = current;
317 
318  for (i = 0; i < 16; i++) {
319  memcpy(dst, src, 16);
320  src += pitch;
321  dst += pitch;
322  }
323 }
324 
325 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
326  uint8_t *current, uint8_t *previous,
327  int pitch, svq1_pmv *motion, int x, int y,
328  int width, int height)
329 {
330  uint8_t *src;
331  uint8_t *dst;
332  svq1_pmv mv;
333  svq1_pmv *pmv[3];
334  int result;
335 
336  /* predict and decode motion vector */
337  pmv[0] = &motion[0];
338  if (y == 0) {
339  pmv[1] =
340  pmv[2] = pmv[0];
341  } else {
342  pmv[1] = &motion[x / 8 + 2];
343  pmv[2] = &motion[x / 8 + 4];
344  }
345 
346  result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
347  if (result)
348  return result;
349 
350  motion[0].x =
351  motion[x / 8 + 2].x =
352  motion[x / 8 + 3].x = mv.x;
353  motion[0].y =
354  motion[x / 8 + 2].y =
355  motion[x / 8 + 3].y = mv.y;
356 
357  mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
358  mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
359 
360  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
361  dst = current;
362 
363  hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
364 
365  return 0;
366 }
367 
368 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
369  uint8_t *current, uint8_t *previous,
370  int pitch, svq1_pmv *motion, int x, int y,
371  int width, int height)
372 {
373  uint8_t *src;
374  uint8_t *dst;
375  svq1_pmv mv;
376  svq1_pmv *pmv[4];
377  int i, result;
378 
379  /* predict and decode motion vector (0) */
380  pmv[0] = &motion[0];
381  if (y == 0) {
382  pmv[1] =
383  pmv[2] = pmv[0];
384  } else {
385  pmv[1] = &motion[(x / 8) + 2];
386  pmv[2] = &motion[(x / 8) + 4];
387  }
388 
389  result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
390  if (result)
391  return result;
392 
393  /* predict and decode motion vector (1) */
394  pmv[0] = &mv;
395  if (y == 0) {
396  pmv[1] =
397  pmv[2] = pmv[0];
398  } else {
399  pmv[1] = &motion[(x / 8) + 3];
400  }
401  result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
402  if (result)
403  return result;
404 
405  /* predict and decode motion vector (2) */
406  pmv[1] = &motion[0];
407  pmv[2] = &motion[(x / 8) + 1];
408 
409  result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
410  if (result)
411  return result;
412 
413  /* predict and decode motion vector (3) */
414  pmv[2] = &motion[(x / 8) + 2];
415  pmv[3] = &motion[(x / 8) + 3];
416 
417  result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
418  if (result)
419  return result;
420 
421  /* form predictions */
422  for (i = 0; i < 4; i++) {
423  int mvx = pmv[i]->x + (i & 1) * 16;
424  int mvy = pmv[i]->y + (i >> 1) * 16;
425 
426  // FIXME: clipping or padding?
427  mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
428  mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
429 
430  src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
431  dst = current;
432 
433  hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
434 
435  /* select next block */
436  if (i & 1)
437  current += 8 * (pitch - 1);
438  else
439  current += 8;
440  }
441 
442  return 0;
443 }
444 
445 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
446  GetBitContext *bitbuf,
447  uint8_t *current, uint8_t *previous,
448  int pitch, svq1_pmv *motion, int x, int y,
449  int width, int height)
450 {
451  uint32_t block_type;
452  int result = 0;
453 
454  /* get block type */
455  block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
456 
457  /* reset motion vectors */
458  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
459  motion[0].x =
460  motion[0].y =
461  motion[x / 8 + 2].x =
462  motion[x / 8 + 2].y =
463  motion[x / 8 + 3].x =
464  motion[x / 8 + 3].y = 0;
465  }
466 
467  switch (block_type) {
468  case SVQ1_BLOCK_SKIP:
469  svq1_skip_block(current, previous, pitch, x, y);
470  break;
471 
472  case SVQ1_BLOCK_INTER:
473  result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
474  pitch, motion, x, y, width, height);
475 
476  if (result != 0) {
477  av_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
478  break;
479  }
480  result = svq1_decode_block_non_intra(bitbuf, current, pitch);
481  break;
482 
483  case SVQ1_BLOCK_INTER_4V:
484  result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
485  pitch, motion, x, y, width, height);
486 
487  if (result != 0) {
488  av_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
489  break;
490  }
491  result = svq1_decode_block_non_intra(bitbuf, current, pitch);
492  break;
493 
494  case SVQ1_BLOCK_INTRA:
495  result = svq1_decode_block_intra(bitbuf, current, pitch);
496  break;
497  }
498 
499  return result;
500 }
501 
502 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
503 {
504  uint8_t seed;
505  int i;
506 
507  out[0] = get_bits(bitbuf, 8);
508  seed = string_table[out[0]];
509 
510  for (i = 1; i <= out[0]; i++) {
511  out[i] = get_bits(bitbuf, 8) ^ seed;
512  seed = string_table[out[i] ^ seed];
513  }
514 }
515 
516 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
517 {
518  SVQ1Context *s = avctx->priv_data;
519  GetBitContext *bitbuf = &s->gb;
520  int frame_size_code;
521  int width = s->width;
522  int height = s->height;
523 
524  skip_bits(bitbuf, 8); /* temporal_reference */
525 
526  /* frame type */
527  s->nonref = 0;
528  switch (get_bits(bitbuf, 2)) {
529  case 0:
530  frame->pict_type = AV_PICTURE_TYPE_I;
531  break;
532  case 2:
533  s->nonref = 1;
534  case 1:
535  frame->pict_type = AV_PICTURE_TYPE_P;
536  break;
537  default:
538  av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
539  return AVERROR_INVALIDDATA;
540  }
541 
542  if (frame->pict_type == AV_PICTURE_TYPE_I) {
543  /* unknown fields */
544  if (s->frame_code == 0x50 || s->frame_code == 0x60) {
545  int csum = get_bits(bitbuf, 16);
546 
547  csum = ff_svq1_packet_checksum(bitbuf->buffer,
548  bitbuf->size_in_bits >> 3,
549  csum);
550 
551  av_dlog(avctx, "%s checksum (%02x) for packet data\n",
552  (csum == 0) ? "correct" : "incorrect", csum);
553  }
554 
555  if ((s->frame_code ^ 0x10) >= 0x50) {
556  uint8_t msg[256];
557 
558  svq1_parse_string(bitbuf, msg);
559 
560  av_log(avctx, AV_LOG_INFO,
561  "embedded message:\n%s\n", (char *)msg);
562  }
563 
564  skip_bits(bitbuf, 2);
565  skip_bits(bitbuf, 2);
566  skip_bits1(bitbuf);
567 
568  /* load frame size */
569  frame_size_code = get_bits(bitbuf, 3);
570 
571  if (frame_size_code == 7) {
572  /* load width, height (12 bits each) */
573  width = get_bits(bitbuf, 12);
574  height = get_bits(bitbuf, 12);
575 
576  if (!width || !height)
577  return AVERROR_INVALIDDATA;
578  } else {
579  /* get width, height from table */
580  width = ff_svq1_frame_size_table[frame_size_code][0];
581  height = ff_svq1_frame_size_table[frame_size_code][1];
582  }
583  }
584 
585  /* unknown fields */
586  if (get_bits1(bitbuf)) {
587  skip_bits1(bitbuf); /* use packet checksum if (1) */
588  skip_bits1(bitbuf); /* component checksums after image data if (1) */
589 
590  if (get_bits(bitbuf, 2) != 0)
591  return AVERROR_INVALIDDATA;
592  }
593 
594  if (get_bits1(bitbuf)) {
595  skip_bits1(bitbuf);
596  skip_bits(bitbuf, 4);
597  skip_bits1(bitbuf);
598  skip_bits(bitbuf, 2);
599 
600  if (skip_1stop_8data_bits(bitbuf) < 0)
601  return AVERROR_INVALIDDATA;
602  }
603 
604  s->width = width;
605  s->height = height;
606  return 0;
607 }
608 
609 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
610  int *got_frame, AVPacket *avpkt)
611 {
612  const uint8_t *buf = avpkt->data;
613  int buf_size = avpkt->size;
614  SVQ1Context *s = avctx->priv_data;
615  AVFrame *cur = data;
616  uint8_t *current;
617  int result, i, x, y, width, height;
618  svq1_pmv *pmv;
619 
620  /* initialize bit buffer */
621  init_get_bits8(&s->gb, buf, buf_size);
622 
623  /* decode frame header */
624  s->frame_code = get_bits(&s->gb, 22);
625 
626  if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
627  return AVERROR_INVALIDDATA;
628 
629  /* swap some header bytes (why?) */
630  if (s->frame_code != 0x20) {
631  uint32_t *src;
632 
633  if (buf_size < 9 * 4) {
634  av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
635  return AVERROR_INVALIDDATA;
636  }
637 
638  av_fast_padded_malloc(&s->pkt_swapped, &s->pkt_swapped_allocated,
639  buf_size);
640  if (!s->pkt_swapped)
641  return AVERROR(ENOMEM);
642 
643  memcpy(s->pkt_swapped, buf, buf_size);
644  buf = s->pkt_swapped;
645  init_get_bits(&s->gb, buf, buf_size * 8);
646  skip_bits(&s->gb, 22);
647 
648  src = (uint32_t *)(s->pkt_swapped + 4);
649 
650  if (buf_size < 36)
651  return AVERROR_INVALIDDATA;
652 
653  for (i = 0; i < 4; i++)
654  src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
655  }
656 
657  result = svq1_decode_frame_header(avctx, cur);
658  if (result != 0) {
659  av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
660  return result;
661  }
662 
663  result = ff_set_dimensions(avctx, s->width, s->height);
664  if (result < 0)
665  return result;
666 
667  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
668  (avctx->skip_frame >= AVDISCARD_NONKEY &&
669  cur->pict_type != AV_PICTURE_TYPE_I) ||
670  avctx->skip_frame >= AVDISCARD_ALL)
671  return buf_size;
672 
673  result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
674  if (result < 0)
675  return result;
676 
677  pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
678  if (!pmv)
679  return AVERROR(ENOMEM);
680 
681  /* decode y, u and v components */
682  for (i = 0; i < 3; i++) {
683  int linesize = cur->linesize[i];
684  if (i == 0) {
685  width = FFALIGN(s->width, 16);
686  height = FFALIGN(s->height, 16);
687  } else {
688  if (avctx->flags & CODEC_FLAG_GRAY)
689  break;
690  width = FFALIGN(s->width / 4, 16);
691  height = FFALIGN(s->height / 4, 16);
692  }
693 
694  current = cur->data[i];
695 
696  if (cur->pict_type == AV_PICTURE_TYPE_I) {
697  /* keyframe */
698  for (y = 0; y < height; y += 16) {
699  for (x = 0; x < width; x += 16) {
700  result = svq1_decode_block_intra(&s->gb, &current[x],
701  linesize);
702  if (result) {
703  av_log(avctx, AV_LOG_ERROR,
704  "Error in svq1_decode_block %i (keyframe)\n",
705  result);
706  goto err;
707  }
708  }
709  current += 16 * linesize;
710  }
711  } else {
712  /* delta frame */
713  uint8_t *previous = s->prev->data[i];
714  if (!previous ||
715  s->prev->width != s->width || s->prev->height != s->height) {
716  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
717  result = AVERROR_INVALIDDATA;
718  goto err;
719  }
720 
721  memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
722 
723  for (y = 0; y < height; y += 16) {
724  for (x = 0; x < width; x += 16) {
725  result = svq1_decode_delta_block(avctx, &s->hdsp,
726  &s->gb, &current[x],
727  previous, linesize,
728  pmv, x, y, width, height);
729  if (result != 0) {
730  av_dlog(avctx,
731  "Error in svq1_decode_delta_block %i\n",
732  result);
733  goto err;
734  }
735  }
736 
737  pmv[0].x =
738  pmv[0].y = 0;
739 
740  current += 16 * linesize;
741  }
742  }
743  }
744 
745  if (!s->nonref) {
746  av_frame_unref(s->prev);
747  result = av_frame_ref(s->prev, cur);
748  if (result < 0)
749  goto err;
750  }
751 
752  *got_frame = 1;
753  result = buf_size;
754 
755 err:
756  av_free(pmv);
757  return result;
758 }
759 
760 static av_cold int svq1_decode_init(AVCodecContext *avctx)
761 {
762  SVQ1Context *s = avctx->priv_data;
763  int i;
764  int offset = 0;
765 
766  s->prev = av_frame_alloc();
767  if (!s->prev)
768  return AVERROR(ENOMEM);
769 
770  s->width = avctx->width + 3 & ~3;
771  s->height = avctx->height + 3 & ~3;
772  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
773 
774  ff_hpeldsp_init(&s->hdsp, avctx->flags);
775 
776  INIT_VLC_STATIC(&svq1_block_type, 2, 4,
777  &ff_svq1_block_type_vlc[0][1], 2, 1,
778  &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
779 
780  INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
781  &ff_mvtab[0][1], 2, 1,
782  &ff_mvtab[0][0], 2, 1, 176);
783 
784  for (i = 0; i < 6; i++) {
785  static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
786  { 10, 10, 14, 14, 14, 16 } };
787  static VLC_TYPE table[168][2];
788  svq1_intra_multistage[i].table = &table[offset];
789  svq1_intra_multistage[i].table_allocated = sizes[0][i];
790  offset += sizes[0][i];
791  init_vlc(&svq1_intra_multistage[i], 3, 8,
792  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
793  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
794  INIT_VLC_USE_NEW_STATIC);
795  svq1_inter_multistage[i].table = &table[offset];
796  svq1_inter_multistage[i].table_allocated = sizes[1][i];
797  offset += sizes[1][i];
798  init_vlc(&svq1_inter_multistage[i], 3, 8,
799  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
800  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
801  INIT_VLC_USE_NEW_STATIC);
802  }
803 
804  INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
805  &ff_svq1_intra_mean_vlc[0][1], 4, 2,
806  &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
807 
808  INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
809  &ff_svq1_inter_mean_vlc[0][1], 4, 2,
810  &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
811 
812  return 0;
813 }
814 
815 static av_cold int svq1_decode_end(AVCodecContext *avctx)
816 {
817  SVQ1Context *s = avctx->priv_data;
818 
819  av_frame_free(&s->prev);
820  av_freep(&s->pkt_swapped);
821  s->pkt_swapped_allocated = 0;
822 
823  return 0;
824 }
825 
826 static void svq1_flush(AVCodecContext *avctx)
827 {
828  SVQ1Context *s = avctx->priv_data;
829 
830  av_frame_unref(s->prev);
831 }
832 
833 AVCodec ff_svq1_decoder = {
834  .name = "svq1",
835  .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
836  .type = AVMEDIA_TYPE_VIDEO,
837  .id = AV_CODEC_ID_SVQ1,
838  .priv_data_size = sizeof(SVQ1Context),
839  .init = svq1_decode_init,
840  .close = svq1_decode_end,
841  .decode = svq1_decode_frame,
842  .capabilities = CODEC_CAP_DR1,
843  .flush = svq1_flush,
844  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
845  AV_PIX_FMT_NONE },
846 };
Generated on Sun Sep 14 2014 18:56:04 for FFmpeg by   doxygen 1.8.2