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[257])
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  out[i] = 0;
515 }
516 
517 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
518 {
519  SVQ1Context *s = avctx->priv_data;
520  GetBitContext *bitbuf = &s->gb;
521  int frame_size_code;
522  int width = s->width;
523  int height = s->height;
524 
525  skip_bits(bitbuf, 8); /* temporal_reference */
526 
527  /* frame type */
528  s->nonref = 0;
529  switch (get_bits(bitbuf, 2)) {
530  case 0:
531  frame->pict_type = AV_PICTURE_TYPE_I;
532  break;
533  case 2:
534  s->nonref = 1;
535  case 1:
536  frame->pict_type = AV_PICTURE_TYPE_P;
537  break;
538  default:
539  av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
540  return AVERROR_INVALIDDATA;
541  }
542 
543  if (frame->pict_type == AV_PICTURE_TYPE_I) {
544  /* unknown fields */
545  if (s->frame_code == 0x50 || s->frame_code == 0x60) {
546  int csum = get_bits(bitbuf, 16);
547 
548  csum = ff_svq1_packet_checksum(bitbuf->buffer,
549  bitbuf->size_in_bits >> 3,
550  csum);
551 
552  av_dlog(avctx, "%s checksum (%02x) for packet data\n",
553  (csum == 0) ? "correct" : "incorrect", csum);
554  }
555 
556  if ((s->frame_code ^ 0x10) >= 0x50) {
557  uint8_t msg[257];
558 
559  svq1_parse_string(bitbuf, msg);
560 
561  av_log(avctx, AV_LOG_INFO,
562  "embedded message:\n%s\n", ((char *)msg) + 1);
563  }
564 
565  skip_bits(bitbuf, 2);
566  skip_bits(bitbuf, 2);
567  skip_bits1(bitbuf);
568 
569  /* load frame size */
570  frame_size_code = get_bits(bitbuf, 3);
571 
572  if (frame_size_code == 7) {
573  /* load width, height (12 bits each) */
574  width = get_bits(bitbuf, 12);
575  height = get_bits(bitbuf, 12);
576 
577  if (!width || !height)
578  return AVERROR_INVALIDDATA;
579  } else {
580  /* get width, height from table */
581  width = ff_svq1_frame_size_table[frame_size_code][0];
582  height = ff_svq1_frame_size_table[frame_size_code][1];
583  }
584  }
585 
586  /* unknown fields */
587  if (get_bits1(bitbuf)) {
588  skip_bits1(bitbuf); /* use packet checksum if (1) */
589  skip_bits1(bitbuf); /* component checksums after image data if (1) */
590 
591  if (get_bits(bitbuf, 2) != 0)
592  return AVERROR_INVALIDDATA;
593  }
594 
595  if (get_bits1(bitbuf)) {
596  skip_bits1(bitbuf);
597  skip_bits(bitbuf, 4);
598  skip_bits1(bitbuf);
599  skip_bits(bitbuf, 2);
600 
601  if (skip_1stop_8data_bits(bitbuf) < 0)
602  return AVERROR_INVALIDDATA;
603  }
604 
605  s->width = width;
606  s->height = height;
607  return 0;
608 }
609 
610 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
611  int *got_frame, AVPacket *avpkt)
612 {
613  const uint8_t *buf = avpkt->data;
614  int buf_size = avpkt->size;
615  SVQ1Context *s = avctx->priv_data;
616  AVFrame *cur = data;
617  uint8_t *current;
618  int result, i, x, y, width, height;
619  svq1_pmv *pmv;
620 
621  /* initialize bit buffer */
622  init_get_bits8(&s->gb, buf, buf_size);
623 
624  /* decode frame header */
625  s->frame_code = get_bits(&s->gb, 22);
626 
627  if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
628  return AVERROR_INVALIDDATA;
629 
630  /* swap some header bytes (why?) */
631  if (s->frame_code != 0x20) {
632  uint32_t *src;
633 
634  if (buf_size < 9 * 4) {
635  av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
636  return AVERROR_INVALIDDATA;
637  }
638 
639  av_fast_padded_malloc(&s->pkt_swapped, &s->pkt_swapped_allocated,
640  buf_size);
641  if (!s->pkt_swapped)
642  return AVERROR(ENOMEM);
643 
644  memcpy(s->pkt_swapped, buf, buf_size);
645  buf = s->pkt_swapped;
646  init_get_bits(&s->gb, buf, buf_size * 8);
647  skip_bits(&s->gb, 22);
648 
649  src = (uint32_t *)(s->pkt_swapped + 4);
650 
651  if (buf_size < 36)
652  return AVERROR_INVALIDDATA;
653 
654  for (i = 0; i < 4; i++)
655  src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
656  }
657 
658  result = svq1_decode_frame_header(avctx, cur);
659  if (result != 0) {
660  av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
661  return result;
662  }
663 
664  result = ff_set_dimensions(avctx, s->width, s->height);
665  if (result < 0)
666  return result;
667 
668  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
669  (avctx->skip_frame >= AVDISCARD_NONKEY &&
670  cur->pict_type != AV_PICTURE_TYPE_I) ||
671  avctx->skip_frame >= AVDISCARD_ALL)
672  return buf_size;
673 
674  result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
675  if (result < 0)
676  return result;
677 
678  pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
679  if (!pmv)
680  return AVERROR(ENOMEM);
681 
682  /* decode y, u and v components */
683  for (i = 0; i < 3; i++) {
684  int linesize = cur->linesize[i];
685  if (i == 0) {
686  width = FFALIGN(s->width, 16);
687  height = FFALIGN(s->height, 16);
688  } else {
689  if (avctx->flags & CODEC_FLAG_GRAY)
690  break;
691  width = FFALIGN(s->width / 4, 16);
692  height = FFALIGN(s->height / 4, 16);
693  }
694 
695  current = cur->data[i];
696 
697  if (cur->pict_type == AV_PICTURE_TYPE_I) {
698  /* keyframe */
699  for (y = 0; y < height; y += 16) {
700  for (x = 0; x < width; x += 16) {
701  result = svq1_decode_block_intra(&s->gb, &current[x],
702  linesize);
703  if (result) {
704  av_log(avctx, AV_LOG_ERROR,
705  "Error in svq1_decode_block %i (keyframe)\n",
706  result);
707  goto err;
708  }
709  }
710  current += 16 * linesize;
711  }
712  } else {
713  /* delta frame */
714  uint8_t *previous = s->prev->data[i];
715  if (!previous ||
716  s->prev->width != s->width || s->prev->height != s->height) {
717  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
718  result = AVERROR_INVALIDDATA;
719  goto err;
720  }
721 
722  memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
723 
724  for (y = 0; y < height; y += 16) {
725  for (x = 0; x < width; x += 16) {
726  result = svq1_decode_delta_block(avctx, &s->hdsp,
727  &s->gb, &current[x],
728  previous, linesize,
729  pmv, x, y, width, height);
730  if (result != 0) {
731  av_dlog(avctx,
732  "Error in svq1_decode_delta_block %i\n",
733  result);
734  goto err;
735  }
736  }
737 
738  pmv[0].x =
739  pmv[0].y = 0;
740 
741  current += 16 * linesize;
742  }
743  }
744  }
745 
746  if (!s->nonref) {
747  av_frame_unref(s->prev);
748  result = av_frame_ref(s->prev, cur);
749  if (result < 0)
750  goto err;
751  }
752 
753  *got_frame = 1;
754  result = buf_size;
755 
756 err:
757  av_free(pmv);
758  return result;
759 }
760 
761 static av_cold int svq1_decode_init(AVCodecContext *avctx)
762 {
763  SVQ1Context *s = avctx->priv_data;
764  int i;
765  int offset = 0;
766 
767  s->prev = av_frame_alloc();
768  if (!s->prev)
769  return AVERROR(ENOMEM);
770 
771  s->width = avctx->width + 3 & ~3;
772  s->height = avctx->height + 3 & ~3;
773  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
774 
775  ff_hpeldsp_init(&s->hdsp, avctx->flags);
776 
777  INIT_VLC_STATIC(&svq1_block_type, 2, 4,
778  &ff_svq1_block_type_vlc[0][1], 2, 1,
779  &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
780 
781  INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
782  &ff_mvtab[0][1], 2, 1,
783  &ff_mvtab[0][0], 2, 1, 176);
784 
785  for (i = 0; i < 6; i++) {
786  static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
787  { 10, 10, 14, 14, 14, 16 } };
788  static VLC_TYPE table[168][2];
789  svq1_intra_multistage[i].table = &table[offset];
790  svq1_intra_multistage[i].table_allocated = sizes[0][i];
791  offset += sizes[0][i];
792  init_vlc(&svq1_intra_multistage[i], 3, 8,
793  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
794  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
795  INIT_VLC_USE_NEW_STATIC);
796  svq1_inter_multistage[i].table = &table[offset];
797  svq1_inter_multistage[i].table_allocated = sizes[1][i];
798  offset += sizes[1][i];
799  init_vlc(&svq1_inter_multistage[i], 3, 8,
800  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
801  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
802  INIT_VLC_USE_NEW_STATIC);
803  }
804 
805  INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
806  &ff_svq1_intra_mean_vlc[0][1], 4, 2,
807  &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
808 
809  INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
810  &ff_svq1_inter_mean_vlc[0][1], 4, 2,
811  &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
812 
813  return 0;
814 }
815 
816 static av_cold int svq1_decode_end(AVCodecContext *avctx)
817 {
818  SVQ1Context *s = avctx->priv_data;
819 
820  av_frame_free(&s->prev);
821  av_freep(&s->pkt_swapped);
822  s->pkt_swapped_allocated = 0;
823 
824  return 0;
825 }
826 
827 static void svq1_flush(AVCodecContext *avctx)
828 {
829  SVQ1Context *s = avctx->priv_data;
830 
831  av_frame_unref(s->prev);
832 }
833 
834 AVCodec ff_svq1_decoder = {
835  .name = "svq1",
836  .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
837  .type = AVMEDIA_TYPE_VIDEO,
838  .id = AV_CODEC_ID_SVQ1,
839  .priv_data_size = sizeof(SVQ1Context),
840  .init = svq1_decode_init,
841  .close = svq1_decode_end,
842  .decode = svq1_decode_frame,
843  .capabilities = CODEC_CAP_DR1,
844  .flush = svq1_flush,
845  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
846  AV_PIX_FMT_NONE },
847 };
Generated on Fri Dec 5 2014 04:42:02 for FFmpeg by   doxygen 1.8.2