FFmpeg
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 "libavutil/crc.h"
36 #include "libavutil/thread.h"
37 
38 #include "avcodec.h"
39 #include "codec_internal.h"
40 #include "decode.h"
41 #include "get_bits.h"
42 #include "h263data.h"
43 #include "hpeldsp.h"
44 #include "mathops.h"
45 #include "svq1.h"
46 
47 #define SVQ1_BLOCK_TYPE_VLC_BITS 3
50 static const VLCElem *svq1_intra_multistage[6];
51 static const VLCElem *svq1_inter_multistage[6];
53 static VLCElem svq1_inter_mean[1434];
54 
55 /* motion vector (prediction) */
56 typedef struct svq1_pmv_s {
57  int x;
58  int y;
59 } svq1_pmv;
60 
61 typedef struct SVQ1Context {
65 
66  uint8_t *pkt_swapped;
68 
69  svq1_pmv *pmv;
71 
72  int width;
73  int height;
75  int nonref; // 1 if the current frame won't be referenced
76 
78 } SVQ1Context;
79 
80 static const uint8_t string_table[256] = {
81  0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
82  0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
83  0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
84  0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
85  0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
86  0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
87  0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
88  0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
89  0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
90  0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
91  0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
92  0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
93  0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
94  0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
95  0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
96  0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
97  0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
98  0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
99  0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
100  0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
101  0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
102  0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
103  0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
104  0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
105  0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
106  0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
107  0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
108  0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
109  0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
110  0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
111  0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
112  0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
113 };
114 
115 #define SVQ1_PROCESS_VECTOR() \
116  for (; level > 0; i++) { \
117  /* process next depth */ \
118  if (i == m) { \
119  m = n; \
120  if (--level == 0) \
121  break; \
122  } \
123  /* divide block if next bit set */ \
124  if (!get_bits1(bitbuf)) \
125  break; \
126  /* add child nodes */ \
127  list[n++] = list[i]; \
128  list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
129  }
130 
131 #define SVQ1_ADD_CODEBOOK() \
132  /* add codebook entries to vector */ \
133  for (j = 0; j < stages; j++) { \
134  n3 = codebook[entries[j]] ^ 0x80808080; \
135  n1 += (n3 & 0xFF00FF00) >> 8; \
136  n2 += n3 & 0x00FF00FF; \
137  } \
138  \
139  /* clip to [0..255] */ \
140  if (n1 & 0xFF00FF00) { \
141  n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
142  n1 += 0x7F007F00; \
143  n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
144  n1 &= n3 & 0x00FF00FF; \
145  } \
146  \
147  if (n2 & 0xFF00FF00) { \
148  n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
149  n2 += 0x7F007F00; \
150  n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
151  n2 &= n3 & 0x00FF00FF; \
152  }
153 
154 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
155  codebook = (const uint32_t *)cbook[level]; \
156  if (stages > 0) \
157  bit_cache = get_bits(bitbuf, 4 * stages); \
158  /* calculate codebook entries for this vector */ \
159  for (j = 0; j < stages; j++) { \
160  entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
161  16 * j) << (level + 1); \
162  } \
163  mean -= stages * 128; \
164  n4 = (mean << 16) + mean;
165 
166 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
167  ptrdiff_t pitch)
168 {
169  uint32_t bit_cache;
170  uint8_t *list[63];
171  uint32_t *dst;
172  const uint32_t *codebook;
173  int entries[6];
174  int i, j, m, n;
175  int stages;
176  unsigned mean;
177  unsigned x, y, width, height, level;
178  uint32_t n1, n2, n3, n4;
179 
180  /* initialize list for breadth first processing of vectors */
181  list[0] = pixels;
182 
183  /* recursively process vector */
184  for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
186 
187  /* destination address and vector size */
188  dst = (uint32_t *)list[i];
189  width = 1 << ((4 + level) / 2);
190  height = 1 << ((3 + level) / 2);
191 
192  /* get number of stages (-1 skips vector, 0 for mean only) */
193  stages = get_vlc2(bitbuf, svq1_intra_multistage[level], 4, 2) - 1;
194 
195  if (stages == -1) {
196  for (y = 0; y < height; y++)
197  memset(&dst[y * (pitch / 4)], 0, width);
198  continue; /* skip vector */
199  }
200 
201  if ((stages > 0 && level >= 4)) {
202  ff_dlog(NULL,
203  "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
204  stages, level);
205  return AVERROR_INVALIDDATA; /* invalid vector */
206  }
207  av_assert0(stages >= 0);
208 
209  mean = get_vlc2(bitbuf, svq1_intra_mean, 8, 3);
210 
211  if (stages == 0) {
212  for (y = 0; y < height; y++)
213  memset(&dst[y * (pitch / 4)], mean, width);
214  } else {
216 
217  for (y = 0; y < height; y++) {
218  for (x = 0; x < width / 4; x++, codebook++) {
219  n1 = n4;
220  n2 = n4;
222  /* store result */
223  dst[x] = n1 << 8 | n2;
224  }
225  dst += pitch / 4;
226  }
227  }
228  }
229 
230  return 0;
231 }
232 
233 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
234  ptrdiff_t pitch, int buggy)
235 {
236  uint32_t bit_cache;
237  uint8_t *list[63];
238  uint32_t *dst;
239  const uint32_t *codebook;
240  int entries[6];
241  int i, j, m, n;
242  int stages;
243  unsigned mean;
244  int x, y, width, height, level;
245  uint32_t n1, n2, n3, n4;
246 
247  /* initialize list for breadth first processing of vectors */
248  list[0] = pixels;
249 
250  /* recursively process vector */
251  for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
253 
254  /* destination address and vector size */
255  dst = (uint32_t *)list[i];
256  width = 1 << ((4 + level) / 2);
257  height = 1 << ((3 + level) / 2);
258 
259  /* get number of stages (-1 skips vector, 0 for mean only) */
260  stages = get_vlc2(bitbuf, svq1_inter_multistage[level], 3, 2) - 1;
261 
262  if (stages == -1)
263  continue; /* skip vector */
264 
265  if ((stages > 0 && level >= 4)) {
266  ff_dlog(NULL,
267  "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
268  stages, level);
269  return AVERROR_INVALIDDATA; /* invalid vector */
270  }
271  av_assert0(stages >= 0);
272 
273  mean = get_vlc2(bitbuf, svq1_inter_mean, 9, 3) - 256;
274 
275  if (buggy) {
276  if (mean == -128)
277  mean = 128;
278  else if (mean == 128)
279  mean = -128;
280  }
281 
283 
284  for (y = 0; y < height; y++) {
285  for (x = 0; x < width / 4; x++) {
286  n3 = dst[x];
287  /* add mean value to vector */
288  n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
289  n2 = n4 + (n3 & 0x00FF00FF);
291  /* store result */
292  dst[x] = n1 << 8 | n2;
293  if (codebook != NULL)
294  codebook++;
295  }
296  dst += pitch / 4;
297  }
298  }
299  return 0;
300 }
301 
302 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
303  svq1_pmv **pmv)
304 {
305  int diff;
306  int i;
307 
308  for (i = 0; i < 2; i++) {
309  /* get motion code */
310  diff = get_vlc2(bitbuf, svq1_motion_component, 7, 2);
311  if (diff < 0)
312  return AVERROR_INVALIDDATA;
313  else if (diff) {
314  if (get_bits1(bitbuf))
315  diff = -diff;
316  }
317 
318  /* add median of motion vector predictors and clip result */
319  if (i == 1)
320  mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
321  else
322  mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
323  }
324 
325  return 0;
326 }
327 
328 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
329  ptrdiff_t pitch, int x, int y)
330 {
331  uint8_t *src;
332  uint8_t *dst;
333  int i;
334 
335  src = &previous[x + y * pitch];
336  dst = current;
337 
338  for (i = 0; i < 16; i++) {
339  memcpy(dst, src, 16);
340  src += pitch;
341  dst += pitch;
342  }
343 }
344 
346  uint8_t *current, uint8_t *previous,
347  ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
348  int width, int height)
349 {
350  uint8_t *src;
351  uint8_t *dst;
352  svq1_pmv mv;
353  svq1_pmv *pmv[3];
354  int result;
355 
356  /* predict and decode motion vector */
357  pmv[0] = &motion[0];
358  if (y == 0) {
359  pmv[1] =
360  pmv[2] = pmv[0];
361  } else {
362  pmv[1] = &motion[x / 8 + 2];
363  pmv[2] = &motion[x / 8 + 4];
364  }
365 
366  result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
367  if (result)
368  return result;
369 
370  motion[0].x =
371  motion[x / 8 + 2].x =
372  motion[x / 8 + 3].x = mv.x;
373  motion[0].y =
374  motion[x / 8 + 2].y =
375  motion[x / 8 + 3].y = mv.y;
376 
377  mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
378  mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
379 
380  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
381  dst = current;
382 
383  hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
384 
385  return 0;
386 }
387 
389  uint8_t *current, uint8_t *previous,
390  ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
391  int width, int height)
392 {
393  uint8_t *src;
394  uint8_t *dst;
395  svq1_pmv mv;
396  svq1_pmv *pmv[4];
397  int i, result;
398 
399  /* predict and decode motion vector (0) */
400  pmv[0] = &motion[0];
401  if (y == 0) {
402  pmv[1] =
403  pmv[2] = pmv[0];
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  if (result)
411  return result;
412 
413  /* predict and decode motion vector (1) */
414  pmv[0] = &mv;
415  if (y == 0) {
416  pmv[1] =
417  pmv[2] = pmv[0];
418  } else {
419  pmv[1] = &motion[(x / 8) + 3];
420  }
421  result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
422  if (result)
423  return result;
424 
425  /* predict and decode motion vector (2) */
426  pmv[1] = &motion[0];
427  pmv[2] = &motion[(x / 8) + 1];
428 
429  result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
430  if (result)
431  return result;
432 
433  /* predict and decode motion vector (3) */
434  pmv[2] = &motion[(x / 8) + 2];
435  pmv[3] = &motion[(x / 8) + 3];
436 
437  result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
438  if (result)
439  return result;
440 
441  /* form predictions */
442  for (i = 0; i < 4; i++) {
443  int mvx = pmv[i]->x + (i & 1) * 16;
444  int mvy = pmv[i]->y + (i >> 1) * 16;
445 
446  // FIXME: clipping or padding?
447  mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
448  mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
449 
450  src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
451  dst = current;
452 
453  hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
454 
455  /* select next block */
456  if (i & 1)
457  current += 8 * (pitch - 1);
458  else
459  current += 8;
460  }
461 
462  return 0;
463 }
464 
466  GetBitContext *bitbuf,
467  uint8_t *current, uint8_t *previous,
468  ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
469  int width, int height, int buggy)
470 {
471  uint32_t block_type;
472  int result = 0;
473 
474  /* get block type */
475  block_type = get_vlc2(bitbuf, svq1_block_type,
477 
478  /* reset motion vectors */
479  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
480  motion[0].x =
481  motion[0].y =
482  motion[x / 8 + 2].x =
483  motion[x / 8 + 2].y =
484  motion[x / 8 + 3].x =
485  motion[x / 8 + 3].y = 0;
486  }
487 
488  switch (block_type) {
489  case SVQ1_BLOCK_SKIP:
490  svq1_skip_block(current, previous, pitch, x, y);
491  break;
492 
493  case SVQ1_BLOCK_INTER:
494  result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
495  pitch, motion, x, y, width, height);
496 
497  if (result != 0) {
498  ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
499  break;
500  }
501  result = svq1_decode_block_non_intra(bitbuf, current, pitch, buggy);
502  break;
503 
504  case SVQ1_BLOCK_INTER_4V:
505  result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
506  pitch, motion, x, y, width, height);
507 
508  if (result != 0) {
509  ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
510  break;
511  }
512  result = svq1_decode_block_non_intra(bitbuf, current, pitch, buggy);
513  break;
514 
515  case SVQ1_BLOCK_INTRA:
516  result = svq1_decode_block_intra(bitbuf, current, pitch);
517  break;
518  }
519 
520  return result;
521 }
522 
523 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
524 {
525  uint8_t seed;
526  int i;
527 
528  out[0] = get_bits(bitbuf, 8);
529  seed = string_table[out[0]];
530 
531  for (i = 1; i <= out[0]; i++) {
532  out[i] = get_bits(bitbuf, 8) ^ seed;
533  seed = string_table[out[i] ^ seed];
534  }
535  out[i] = 0;
536 }
537 
538 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame, int * buggy)
539 {
540  SVQ1Context *s = avctx->priv_data;
541  GetBitContext *bitbuf = &s->gb;
542  int frame_size_code;
543  int width = s->width;
544  int height = s->height;
545  int tempref;
546 
547  tempref = get_bits(bitbuf, 8); /* temporal_reference */
548  *buggy = tempref == 0 && s->last_tempref == 0 && avctx->extradata_size == 0;
549  s->last_tempref = tempref;
550 
551  /* frame type */
552  s->nonref = 0;
553  switch (get_bits(bitbuf, 2)) {
554  case 0:
556  break;
557  case 2:
558  s->nonref = 1;
559  case 1:
561  break;
562  default:
563  av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
564  return AVERROR_INVALIDDATA;
565  }
566 
568  /* unknown fields */
569  if (s->frame_code == 0x50 || s->frame_code == 0x60) {
570  int csum = get_bits(bitbuf, 16);
571 
572  csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));
573 
574  ff_dlog(avctx, "%s checksum (%02x) for packet data\n",
575  (csum == 0) ? "correct" : "incorrect", csum);
576  }
577 
578  if ((s->frame_code ^ 0x10) >= 0x50) {
579  uint8_t msg[257];
580 
581  svq1_parse_string(bitbuf, msg);
582 
583  av_log(avctx, AV_LOG_INFO,
584  "embedded message:\n%s\n", ((char *)msg) + 1);
585  }
586 
587  skip_bits(bitbuf, 2);
588  skip_bits(bitbuf, 2);
589  skip_bits1(bitbuf);
590 
591  /* load frame size */
592  frame_size_code = get_bits(bitbuf, 3);
593 
594  if (frame_size_code == 7) {
595  /* load width, height (12 bits each) */
596  width = get_bits(bitbuf, 12);
597  height = get_bits(bitbuf, 12);
598 
599  if (!width || !height)
600  return AVERROR_INVALIDDATA;
601  } else {
602  /* get width, height from table */
603  width = ff_svq1_frame_size_table[frame_size_code][0];
604  height = ff_svq1_frame_size_table[frame_size_code][1];
605  }
606  }
607 
608  /* unknown fields */
609  if (get_bits1(bitbuf)) {
610  skip_bits1(bitbuf); /* use packet checksum if (1) */
611  skip_bits1(bitbuf); /* component checksums after image data if (1) */
612 
613  if (get_bits(bitbuf, 2) != 0)
614  return AVERROR_INVALIDDATA;
615  }
616 
617  if (get_bits1(bitbuf)) {
618  skip_bits1(bitbuf);
619  skip_bits(bitbuf, 4);
620  skip_bits1(bitbuf);
621  skip_bits(bitbuf, 2);
622 
623  if (skip_1stop_8data_bits(bitbuf) < 0)
624  return AVERROR_INVALIDDATA;
625  }
626  if (get_bits_left(bitbuf) <= 0)
627  return AVERROR_INVALIDDATA;
628 
629  s->width = width;
630  s->height = height;
631  return 0;
632 }
633 
634 static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur,
635  int *got_frame, AVPacket *avpkt)
636 {
637  const uint8_t *buf = avpkt->data;
638  int buf_size = avpkt->size;
639  SVQ1Context *s = avctx->priv_data;
640  uint8_t *current;
641  int result, i, x, y, width, height, buggy;
642  int ret;
643 
644  /* initialize bit buffer */
645  ret = init_get_bits8(&s->gb, buf, buf_size);
646  if (ret < 0)
647  return ret;
648 
649  /* decode frame header */
650  s->frame_code = get_bits(&s->gb, 22);
651 
652  if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
653  return AVERROR_INVALIDDATA;
654 
655  /* swap some header bytes (why?) */
656  if (s->frame_code != 0x20) {
657  uint32_t *src;
658 
659  if (buf_size < 9 * 4) {
660  av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
661  return AVERROR_INVALIDDATA;
662  }
663 
664  av_fast_padded_malloc(&s->pkt_swapped,
665  &s->pkt_swapped_allocated,
666  buf_size);
667  if (!s->pkt_swapped)
668  return AVERROR(ENOMEM);
669 
670  memcpy(s->pkt_swapped, buf, buf_size);
671  buf = s->pkt_swapped;
672  init_get_bits(&s->gb, buf, buf_size * 8);
673  skip_bits(&s->gb, 22);
674 
675  src = (uint32_t *)(s->pkt_swapped + 4);
676 
677  for (i = 0; i < 4; i++)
678  src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
679  }
680 
681  result = svq1_decode_frame_header(avctx, cur, &buggy);
682  if (result != 0) {
683  ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
684  return result;
685  }
686 
687  result = ff_set_dimensions(avctx, s->width, s->height);
688  if (result < 0)
689  return result;
690 
691  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
692  (avctx->skip_frame >= AVDISCARD_NONKEY &&
693  cur->pict_type != AV_PICTURE_TYPE_I) ||
694  avctx->skip_frame >= AVDISCARD_ALL)
695  return buf_size;
696 
697  result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
698  if (result < 0)
699  return result;
700 
701  av_fast_padded_malloc(&s->pmv, &s->pmv_allocated, (FFALIGN(s->width, 16) / 8 + 3) * sizeof(*s->pmv));
702  if (!s->pmv)
703  return AVERROR(ENOMEM);
704 
705  /* decode y, u and v components */
706  for (i = 0; i < 3; i++) {
707  int linesize = cur->linesize[i];
708  if (i == 0) {
709  width = FFALIGN(s->width, 16);
710  height = FFALIGN(s->height, 16);
711  } else {
712  if (avctx->flags & AV_CODEC_FLAG_GRAY)
713  break;
714  width = FFALIGN(s->width / 4, 16);
715  height = FFALIGN(s->height / 4, 16);
716  }
717 
718  current = cur->data[i];
719 
720  if (cur->pict_type == AV_PICTURE_TYPE_I) {
721  /* keyframe */
722  for (y = 0; y < height; y += 16) {
723  for (x = 0; x < width; x += 16) {
724  result = svq1_decode_block_intra(&s->gb, &current[x],
725  linesize);
726  if (result) {
727  av_log(avctx, AV_LOG_ERROR,
728  "Error in svq1_decode_block %i (keyframe)\n",
729  result);
730  return result;
731  }
732  }
733  current += 16 * linesize;
734  }
735  } else {
736  /* delta frame */
737  uint8_t *previous = s->prev->data[i];
738  if (!previous ||
739  s->prev->width != s->width || s->prev->height != s->height) {
740  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
741  return AVERROR_INVALIDDATA;
742  }
743 
744  memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
745 
746  for (y = 0; y < height; y += 16) {
747  for (x = 0; x < width; x += 16) {
748  result = svq1_decode_delta_block(avctx, &s->hdsp,
749  &s->gb, &current[x],
750  previous, linesize,
751  s->pmv, x, y, width, height, buggy);
752  if (result != 0) {
753  ff_dlog(avctx,
754  "Error in svq1_decode_delta_block %i\n",
755  result);
756  return result;
757  }
758  }
759 
760  s->pmv[0].x =
761  s->pmv[0].y = 0;
762 
763  current += 16 * linesize;
764  }
765  }
766  }
767 
768  if (!s->nonref) {
769  result = av_frame_replace(s->prev, cur);
770  if (result < 0)
771  return result;
772  }
773 
774  *got_frame = 1;
775  result = buf_size;
776 
777  return result;
778 }
779 
780 static av_cold void svq1_static_init(void)
781 {
782  static VLCElem table[196];
784 
786  &ff_svq1_block_type_vlc[0][1], 2, 1,
787  &ff_svq1_block_type_vlc[0][0], 2, 1, 0);
788 
790  &ff_mvtab[0][1], 2, 1,
791  &ff_mvtab[0][0], 2, 1, 0);
792 
793  for (int i = 0; i < 6; i++) {
795  ff_vlc_init_tables(&state, 4, 8,
796  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
797  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, 0);
799  ff_vlc_init_tables(&state, 3, 8,
800  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
801  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, 0);
802  }
803 
805  &ff_svq1_intra_mean_vlc[0][1], 4, 2,
806  &ff_svq1_intra_mean_vlc[0][0], 4, 2, 0);
807 
809  &ff_svq1_inter_mean_vlc[0][1], 4, 2,
810  &ff_svq1_inter_mean_vlc[0][0], 4, 2, 0);
811 }
812 
814 {
815  static AVOnce init_static_once = AV_ONCE_INIT;
816  SVQ1Context *s = avctx->priv_data;
817 
818  s->prev = av_frame_alloc();
819  if (!s->prev)
820  return AVERROR(ENOMEM);
821 
822  s->width = avctx->width + 3 & ~3;
823  s->height = avctx->height + 3 & ~3;
824  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
825 
826  ff_hpeldsp_init(&s->hdsp, avctx->flags);
827 
828  ff_thread_once(&init_static_once, svq1_static_init);
829 
830  s->last_tempref = 0xFF;
831 
832  return 0;
833 }
834 
836 {
837  SVQ1Context *s = avctx->priv_data;
838 
839  av_frame_free(&s->prev);
840  av_freep(&s->pkt_swapped);
841  s->pkt_swapped_allocated = 0;
842  av_freep(&s->pmv);
843  s->pmv_allocated = 0;
844 
845  return 0;
846 }
847 
848 static void svq1_flush(AVCodecContext *avctx)
849 {
850  SVQ1Context *s = avctx->priv_data;
851 
852  av_frame_unref(s->prev);
853 }
854 
856  .p.name = "svq1",
857  CODEC_LONG_NAME("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
858  .p.type = AVMEDIA_TYPE_VIDEO,
859  .p.id = AV_CODEC_ID_SVQ1,
860  .priv_data_size = sizeof(SVQ1Context),
862  .close = svq1_decode_end,
864  .p.capabilities = AV_CODEC_CAP_DR1,
865  .flush = svq1_flush,
866 };
h263data.h
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:98
svq1_static_init
static av_cold void svq1_static_init(void)
Definition: svq1dec.c:780
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
out
FILE * out
Definition: movenc.c:54
svq1_block_type
static VLCElem svq1_block_type[8]
Definition: svq1dec.c:48
svq1_decode_block_non_intra
static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch, int buggy)
Definition: svq1dec.c:233
thread.h
ff_svq1_inter_codebooks
const FF_VISIBILITY_PUSH_HIDDEN int8_t *const ff_svq1_inter_codebooks[6]
Definition: svq1_cb.h:776
SVQ1Context::last_tempref
int last_tempref
Definition: svq1dec.c:77
SVQ1Context::height
int height
Definition: svq1dec.c:73
mv
static const int8_t mv[256][2]
Definition: 4xm.c:80
ff_svq1_intra_codebooks
const int8_t *const ff_svq1_intra_codebooks[6]
Definition: svq1_cb.h:1519
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:111
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
svq1_inter_multistage
static const VLCElem * svq1_inter_multistage[6]
Definition: svq1dec.c:51
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVPacket::data
uint8_t * data
Definition: packet.h:522
table
static const uint16_t table[]
Definition: prosumer.c:205
FFCodec
Definition: codec_internal.h:127
svq1_skip_block
static void svq1_skip_block(uint8_t *current, uint8_t *previous, ptrdiff_t pitch, int x, int y)
Definition: svq1dec.c:328
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:94
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
ff_svq1_intra_multistage_vlc
const uint8_t ff_svq1_intra_multistage_vlc[6][8][2]
Definition: svq1_vlc.h:33
crc.h
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
ff_svq1_inter_mean_vlc
const uint16_t ff_svq1_inter_mean_vlc[512][2]
Definition: svq1_vlc.h:136
svq1_decode_block_intra
static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch)
Definition: svq1dec.c:166
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
SVQ1_CALC_CODEBOOK_ENTRIES
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)
Definition: svq1dec.c:154
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1770
state
static struct @377 state
GetBitContext
Definition: get_bits.h:108
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:525
svq1_decode_end
static av_cold int svq1_decode_end(AVCodecContext *avctx)
Definition: svq1dec.c:835
svq1_pmv_s::x
int x
Definition: svq1dec.c:57
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:88
SVQ1_BLOCK_TYPE_VLC_BITS
#define SVQ1_BLOCK_TYPE_VLC_BITS
Definition: svq1dec.c:47
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
SVQ1Context::hdsp
HpelDSPContext hdsp
Definition: svq1dec.c:62
VLCInitState
For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.
Definition: vlc.h:209
svq1_decode_frame
static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur, int *got_frame, AVPacket *avpkt)
Definition: svq1dec.c:634
SVQ1Context::gb
GetBitContext gb
Definition: svq1dec.c:63
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:547
svq1_inter_mean
static VLCElem svq1_inter_mean[1434]
Definition: svq1dec.c:53
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:425
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
decode.h
get_bits.h
SVQ1Context
Definition: svq1dec.c:61
SVQ1Context::pmv
svq1_pmv * pmv
Definition: svq1dec.c:69
svq1_motion_inter_block
static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)
Definition: svq1dec.c:345
SVQ1Context::frame_code
int frame_code
Definition: svq1dec.c:74
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
SVQ1_ADD_CODEBOOK
#define SVQ1_ADD_CODEBOOK()
Definition: svq1dec.c:131
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:109
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
SVQ1_BLOCK_INTRA
#define SVQ1_BLOCK_INTRA
Definition: svq1.h:45
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
mathops.h
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
SVQ1_BLOCK_SKIP
#define SVQ1_BLOCK_SKIP
Definition: svq1.h:42
seed
static unsigned int seed
Definition: videogen.c:78
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
AVOnce
#define AVOnce
Definition: thread.h:202
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:218
HpelDSPContext::put_pixels_tab
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1618
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:322
AVPacket::size
int size
Definition: packet.h:523
codec_internal.h
VLCElem
Definition: vlc.h:32
SVQ1_BLOCK_INTER_4V
#define SVQ1_BLOCK_INTER_4V
Definition: svq1.h:44
svq1_flush
static void svq1_flush(AVCodecContext *avctx)
Definition: svq1dec.c:848
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
height
#define height
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
AV_CODEC_ID_SVQ1
@ AV_CODEC_ID_SVQ1
Definition: codec_id.h:74
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AV_CRC_16_CCITT
@ AV_CRC_16_CCITT
Definition: crc.h:51
string_table
static const uint8_t string_table[256]
Definition: svq1dec.c:80
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:52
svq1_decode_frame_header
static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame, int *buggy)
Definition: svq1dec.c:538
SVQ1_PROCESS_VECTOR
#define SVQ1_PROCESS_VECTOR()
Definition: svq1dec.c:115
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
SVQ1Context::nonref
int nonref
Definition: svq1dec.c:75
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
SVQ1_BLOCK_INTER
#define SVQ1_BLOCK_INTER
Definition: svq1.h:43
avcodec.h
svq1_parse_string
static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
Definition: svq1dec.c:523
svq1_intra_mean
static VLCElem svq1_intra_mean[632]
Definition: svq1dec.c:52
ff_svq1_inter_multistage_vlc
const uint8_t ff_svq1_inter_multistage_vlc[6][8][2]
Definition: svq1_vlc.h:50
mid_pred
#define mid_pred
Definition: mathops.h:98
SVQ1Context::prev
AVFrame * prev
Definition: svq1dec.c:64
ret
ret
Definition: filter_design.txt:187
svq1_decode_delta_block
static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height, int buggy)
Definition: svq1dec.c:465
ff_mvtab
const uint8_t ff_mvtab[33][2]
Definition: h263data.c:88
av_frame_replace
int av_frame_replace(AVFrame *dst, const AVFrame *src)
Ensure the destination frame refers to the same data described by the source frame,...
Definition: frame.c:482
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:699
AVCodecContext
main external API structure.
Definition: avcodec.h:445
svq1_decode_motion_vector
static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv)
Definition: svq1dec.c:302
ff_svq1_block_type_vlc
const uint8_t ff_svq1_block_type_vlc[4][2]
Definition: svq1_vlc.h:27
ff_svq1_intra_mean_vlc
const uint16_t ff_svq1_intra_mean_vlc[256][2]
Definition: svq1_vlc.h:67
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
VLC_INIT_STATIC_TABLE
#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:267
SVQ1Context::width
int width
Definition: svq1dec.c:72
SVQ1Context::pkt_swapped_allocated
int pkt_swapped_allocated
Definition: svq1dec.c:67
svq1.h
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:133
mean
static float mean(const float *input, int size)
Definition: vf_nnedi.c:862
svq1_decode_init
static av_cold int svq1_decode_init(AVCodecContext *avctx)
Definition: svq1dec.c:813
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_vlc_init_tables
static const VLCElem * ff_vlc_init_tables(VLCInitState *state, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, int flags)
Definition: vlc.h:243
SVQ1Context::pmv_allocated
int pmv_allocated
Definition: svq1dec.c:70
svq1_motion_component
static VLCElem svq1_motion_component[176]
Definition: svq1dec.c:49
SVQ1Context::pkt_swapped
uint8_t * pkt_swapped
Definition: svq1dec.c:66
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
VLC_INIT_STATE
#define VLC_INIT_STATE(_table)
Definition: vlc.h:214
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
svq1_motion_inter_4v_block
static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)
Definition: svq1dec.c:388
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
hpeldsp.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:215
svq1_pmv_s::y
int y
Definition: svq1dec.c:58
av_bswap16
#define av_bswap16
Definition: bswap.h:27
ff_svq1_frame_size_table
const uint16_t ff_svq1_frame_size_table[7][2]
Definition: svq1.c:40
ff_svq1_decoder
const FFCodec ff_svq1_decoder
Definition: svq1dec.c:855
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
svq1_intra_multistage
static const VLCElem * svq1_intra_multistage[6]
Definition: svq1dec.c:50
svq1_pmv_s
Definition: svq1dec.c:56