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
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].table, 3, 3) - 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.table, 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].table, 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.table, 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++, codebook++) {
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  }
294  dst += pitch / 4;
295  }
296  }
297  return 0;
298 }
299 
300 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
301  svq1_pmv **pmv)
302 {
303  int diff;
304  int i;
305 
306  for (i = 0; i < 2; i++) {
307  /* get motion code */
308  diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
309  if (diff < 0)
310  return AVERROR_INVALIDDATA;
311  else if (diff) {
312  if (get_bits1(bitbuf))
313  diff = -diff;
314  }
315 
316  /* add median of motion vector predictors and clip result */
317  if (i == 1)
318  mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
319  else
320  mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
321  }
322 
323  return 0;
324 }
325 
326 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
327  ptrdiff_t pitch, int x, int y)
328 {
329  uint8_t *src;
330  uint8_t *dst;
331  int i;
332 
333  src = &previous[x + y * pitch];
334  dst = current;
335 
336  for (i = 0; i < 16; i++) {
337  memcpy(dst, src, 16);
338  src += pitch;
339  dst += pitch;
340  }
341 }
342 
344  uint8_t *current, uint8_t *previous,
345  ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
346  int width, int height)
347 {
348  uint8_t *src;
349  uint8_t *dst;
350  svq1_pmv mv;
351  svq1_pmv *pmv[3];
352  int result;
353 
354  /* predict and decode motion vector */
355  pmv[0] = &motion[0];
356  if (y == 0) {
357  pmv[1] =
358  pmv[2] = pmv[0];
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  if (result)
366  return result;
367 
368  motion[0].x =
369  motion[x / 8 + 2].x =
370  motion[x / 8 + 3].x = mv.x;
371  motion[0].y =
372  motion[x / 8 + 2].y =
373  motion[x / 8 + 3].y = mv.y;
374 
375  mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
376  mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
377 
378  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
379  dst = current;
380 
381  hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
382 
383  return 0;
384 }
385 
387  uint8_t *current, uint8_t *previous,
388  ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
389  int width, int height)
390 {
391  uint8_t *src;
392  uint8_t *dst;
393  svq1_pmv mv;
394  svq1_pmv *pmv[4];
395  int i, result;
396 
397  /* predict and decode motion vector (0) */
398  pmv[0] = &motion[0];
399  if (y == 0) {
400  pmv[1] =
401  pmv[2] = pmv[0];
402  } else {
403  pmv[1] = &motion[(x / 8) + 2];
404  pmv[2] = &motion[(x / 8) + 4];
405  }
406 
407  result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
408  if (result)
409  return result;
410 
411  /* predict and decode motion vector (1) */
412  pmv[0] = &mv;
413  if (y == 0) {
414  pmv[1] =
415  pmv[2] = pmv[0];
416  } else {
417  pmv[1] = &motion[(x / 8) + 3];
418  }
419  result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
420  if (result)
421  return result;
422 
423  /* predict and decode motion vector (2) */
424  pmv[1] = &motion[0];
425  pmv[2] = &motion[(x / 8) + 1];
426 
427  result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
428  if (result)
429  return result;
430 
431  /* predict and decode motion vector (3) */
432  pmv[2] = &motion[(x / 8) + 2];
433  pmv[3] = &motion[(x / 8) + 3];
434 
435  result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
436  if (result)
437  return result;
438 
439  /* form predictions */
440  for (i = 0; i < 4; i++) {
441  int mvx = pmv[i]->x + (i & 1) * 16;
442  int mvy = pmv[i]->y + (i >> 1) * 16;
443 
444  // FIXME: clipping or padding?
445  mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
446  mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
447 
448  src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
449  dst = current;
450 
451  hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
452 
453  /* select next block */
454  if (i & 1)
455  current += 8 * (pitch - 1);
456  else
457  current += 8;
458  }
459 
460  return 0;
461 }
462 
464  GetBitContext *bitbuf,
465  uint8_t *current, uint8_t *previous,
466  ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
467  int width, int height, int buggy)
468 {
469  uint32_t block_type;
470  int result = 0;
471 
472  /* get block type */
473  block_type = get_vlc2(bitbuf, svq1_block_type.table,
475 
476  /* reset motion vectors */
477  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
478  motion[0].x =
479  motion[0].y =
480  motion[x / 8 + 2].x =
481  motion[x / 8 + 2].y =
482  motion[x / 8 + 3].x =
483  motion[x / 8 + 3].y = 0;
484  }
485 
486  switch (block_type) {
487  case SVQ1_BLOCK_SKIP:
488  svq1_skip_block(current, previous, pitch, x, y);
489  break;
490 
491  case SVQ1_BLOCK_INTER:
492  result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
493  pitch, motion, x, y, width, height);
494 
495  if (result != 0) {
496  ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
497  break;
498  }
499  result = svq1_decode_block_non_intra(bitbuf, current, pitch, buggy);
500  break;
501 
502  case SVQ1_BLOCK_INTER_4V:
503  result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
504  pitch, motion, x, y, width, height);
505 
506  if (result != 0) {
507  ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
508  break;
509  }
510  result = svq1_decode_block_non_intra(bitbuf, current, pitch, buggy);
511  break;
512 
513  case SVQ1_BLOCK_INTRA:
514  result = svq1_decode_block_intra(bitbuf, current, pitch);
515  break;
516  }
517 
518  return result;
519 }
520 
521 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
522 {
523  uint8_t seed;
524  int i;
525 
526  out[0] = get_bits(bitbuf, 8);
527  seed = string_table[out[0]];
528 
529  for (i = 1; i <= out[0]; i++) {
530  out[i] = get_bits(bitbuf, 8) ^ seed;
531  seed = string_table[out[i] ^ seed];
532  }
533  out[i] = 0;
534 }
535 
536 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame, int * buggy)
537 {
538  SVQ1Context *s = avctx->priv_data;
539  GetBitContext *bitbuf = &s->gb;
540  int frame_size_code;
541  int width = s->width;
542  int height = s->height;
543  int tempref;
544 
545  tempref = get_bits(bitbuf, 8); /* temporal_reference */
546  *buggy = tempref == 0 && s->last_tempref == 0 && avctx->extradata_size == 0;
547  s->last_tempref = tempref;
548 
549  /* frame type */
550  s->nonref = 0;
551  switch (get_bits(bitbuf, 2)) {
552  case 0:
553  frame->pict_type = AV_PICTURE_TYPE_I;
554  break;
555  case 2:
556  s->nonref = 1;
557  case 1:
558  frame->pict_type = AV_PICTURE_TYPE_P;
559  break;
560  default:
561  av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
562  return AVERROR_INVALIDDATA;
563  }
564 
565  if (frame->pict_type == AV_PICTURE_TYPE_I) {
566  /* unknown fields */
567  if (s->frame_code == 0x50 || s->frame_code == 0x60) {
568  int csum = get_bits(bitbuf, 16);
569 
570  csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));
571 
572  ff_dlog(avctx, "%s checksum (%02x) for packet data\n",
573  (csum == 0) ? "correct" : "incorrect", csum);
574  }
575 
576  if ((s->frame_code ^ 0x10) >= 0x50) {
577  uint8_t msg[257];
578 
579  svq1_parse_string(bitbuf, msg);
580 
581  av_log(avctx, AV_LOG_INFO,
582  "embedded message:\n%s\n", ((char *)msg) + 1);
583  }
584 
585  skip_bits(bitbuf, 2);
586  skip_bits(bitbuf, 2);
587  skip_bits1(bitbuf);
588 
589  /* load frame size */
590  frame_size_code = get_bits(bitbuf, 3);
591 
592  if (frame_size_code == 7) {
593  /* load width, height (12 bits each) */
594  width = get_bits(bitbuf, 12);
595  height = get_bits(bitbuf, 12);
596 
597  if (!width || !height)
598  return AVERROR_INVALIDDATA;
599  } else {
600  /* get width, height from table */
601  width = ff_svq1_frame_size_table[frame_size_code][0];
602  height = ff_svq1_frame_size_table[frame_size_code][1];
603  }
604  }
605 
606  /* unknown fields */
607  if (get_bits1(bitbuf)) {
608  skip_bits1(bitbuf); /* use packet checksum if (1) */
609  skip_bits1(bitbuf); /* component checksums after image data if (1) */
610 
611  if (get_bits(bitbuf, 2) != 0)
612  return AVERROR_INVALIDDATA;
613  }
614 
615  if (get_bits1(bitbuf)) {
616  skip_bits1(bitbuf);
617  skip_bits(bitbuf, 4);
618  skip_bits1(bitbuf);
619  skip_bits(bitbuf, 2);
620 
621  if (skip_1stop_8data_bits(bitbuf) < 0)
622  return AVERROR_INVALIDDATA;
623  }
624  if (get_bits_left(bitbuf) <= 0)
625  return AVERROR_INVALIDDATA;
626 
627  s->width = width;
628  s->height = height;
629  return 0;
630 }
631 
632 static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur,
633  int *got_frame, AVPacket *avpkt)
634 {
635  const uint8_t *buf = avpkt->data;
636  int buf_size = avpkt->size;
637  SVQ1Context *s = avctx->priv_data;
638  uint8_t *current;
639  int result, i, x, y, width, height, buggy;
640  int ret;
641 
642  /* initialize bit buffer */
643  ret = init_get_bits8(&s->gb, buf, buf_size);
644  if (ret < 0)
645  return ret;
646 
647  /* decode frame header */
648  s->frame_code = get_bits(&s->gb, 22);
649 
650  if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
651  return AVERROR_INVALIDDATA;
652 
653  /* swap some header bytes (why?) */
654  if (s->frame_code != 0x20) {
655  uint32_t *src;
656 
657  if (buf_size < 9 * 4) {
658  av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
659  return AVERROR_INVALIDDATA;
660  }
661 
662  av_fast_padded_malloc(&s->pkt_swapped,
663  &s->pkt_swapped_allocated,
664  buf_size);
665  if (!s->pkt_swapped)
666  return AVERROR(ENOMEM);
667 
668  memcpy(s->pkt_swapped, buf, buf_size);
669  buf = s->pkt_swapped;
670  init_get_bits(&s->gb, buf, buf_size * 8);
671  skip_bits(&s->gb, 22);
672 
673  src = (uint32_t *)(s->pkt_swapped + 4);
674 
675  for (i = 0; i < 4; i++)
676  src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
677  }
678 
679  result = svq1_decode_frame_header(avctx, cur, &buggy);
680  if (result != 0) {
681  ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
682  return result;
683  }
684 
685  result = ff_set_dimensions(avctx, s->width, s->height);
686  if (result < 0)
687  return result;
688 
689  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
690  (avctx->skip_frame >= AVDISCARD_NONKEY &&
691  cur->pict_type != AV_PICTURE_TYPE_I) ||
692  avctx->skip_frame >= AVDISCARD_ALL)
693  return buf_size;
694 
695  result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
696  if (result < 0)
697  return result;
698 
699  av_fast_padded_malloc(&s->pmv, &s->pmv_allocated, (FFALIGN(s->width, 16) / 8 + 3) * sizeof(*s->pmv));
700  if (!s->pmv)
701  return AVERROR(ENOMEM);
702 
703  /* decode y, u and v components */
704  for (i = 0; i < 3; i++) {
705  int linesize = cur->linesize[i];
706  if (i == 0) {
707  width = FFALIGN(s->width, 16);
708  height = FFALIGN(s->height, 16);
709  } else {
710  if (avctx->flags & AV_CODEC_FLAG_GRAY)
711  break;
712  width = FFALIGN(s->width / 4, 16);
713  height = FFALIGN(s->height / 4, 16);
714  }
715 
716  current = cur->data[i];
717 
718  if (cur->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],
723  linesize);
724  if (result) {
725  av_log(avctx, AV_LOG_ERROR,
726  "Error in svq1_decode_block %i (keyframe)\n",
727  result);
728  return result;
729  }
730  }
731  current += 16 * linesize;
732  }
733  } else {
734  /* delta frame */
735  uint8_t *previous = s->prev->data[i];
736  if (!previous ||
737  s->prev->width != s->width || s->prev->height != s->height) {
738  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
739  return AVERROR_INVALIDDATA;
740  }
741 
742  memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
743 
744  for (y = 0; y < height; y += 16) {
745  for (x = 0; x < width; x += 16) {
746  result = svq1_decode_delta_block(avctx, &s->hdsp,
747  &s->gb, &current[x],
748  previous, linesize,
749  s->pmv, x, y, width, height, buggy);
750  if (result != 0) {
751  ff_dlog(avctx,
752  "Error in svq1_decode_delta_block %i\n",
753  result);
754  return result;
755  }
756  }
757 
758  s->pmv[0].x =
759  s->pmv[0].y = 0;
760 
761  current += 16 * linesize;
762  }
763  }
764  }
765 
766  if (!s->nonref) {
767  av_frame_unref(s->prev);
768  result = av_frame_ref(s->prev, cur);
769  if (result < 0)
770  return result;
771  }
772 
773  *got_frame = 1;
774  result = buf_size;
775 
776  return result;
777 }
778 
779 static av_cold void svq1_static_init(void)
780 {
782  &ff_svq1_block_type_vlc[0][1], 2, 1,
783  &ff_svq1_block_type_vlc[0][0], 2, 1, 8);
784 
786  &ff_mvtab[0][1], 2, 1,
787  &ff_mvtab[0][0], 2, 1, 176);
788 
789  for (int i = 0, offset = 0; i < 6; i++) {
790  static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
791  { 10, 10, 14, 14, 14, 16 } };
792  static VLCElem table[168];
795  offset += sizes[0][i];
797  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
798  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
802  offset += sizes[1][i];
804  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
805  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
807  }
808 
810  &ff_svq1_intra_mean_vlc[0][1], 4, 2,
811  &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
812 
814  &ff_svq1_inter_mean_vlc[0][1], 4, 2,
815  &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
816 }
817 
819 {
820  static AVOnce init_static_once = AV_ONCE_INIT;
821  SVQ1Context *s = avctx->priv_data;
822 
823  s->prev = av_frame_alloc();
824  if (!s->prev)
825  return AVERROR(ENOMEM);
826 
827  s->width = avctx->width + 3 & ~3;
828  s->height = avctx->height + 3 & ~3;
829  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
830 
831  ff_hpeldsp_init(&s->hdsp, avctx->flags);
832 
833  ff_thread_once(&init_static_once, svq1_static_init);
834 
835  s->last_tempref = 0xFF;
836 
837  return 0;
838 }
839 
841 {
842  SVQ1Context *s = avctx->priv_data;
843 
844  av_frame_free(&s->prev);
845  av_freep(&s->pkt_swapped);
846  s->pkt_swapped_allocated = 0;
847  av_freep(&s->pmv);
848  s->pmv_allocated = 0;
849 
850  return 0;
851 }
852 
853 static void svq1_flush(AVCodecContext *avctx)
854 {
855  SVQ1Context *s = avctx->priv_data;
856 
857  av_frame_unref(s->prev);
858 }
859 
861  .p.name = "svq1",
862  CODEC_LONG_NAME("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
863  .p.type = AVMEDIA_TYPE_VIDEO,
864  .p.id = AV_CODEC_ID_SVQ1,
865  .priv_data_size = sizeof(SVQ1Context),
867  .close = svq1_decode_end,
869  .p.capabilities = AV_CODEC_CAP_DR1,
870  .flush = svq1_flush,
871  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
872  AV_PIX_FMT_NONE },
873 };
svq1_inter_multistage
static VLC svq1_inter_multistage[6]
Definition: svq1dec.c:51
h263data.h
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:95
svq1_static_init
static av_cold void svq1_static_init(void)
Definition: svq1dec.c:779
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
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_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
INIT_VLC_STATIC
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:125
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
svq1_intra_multistage
static VLC svq1_intra_multistage[6]
Definition: svq1dec.c:50
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:68
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVPacket::data
uint8_t * data
Definition: packet.h:374
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:43
table
static const uint16_t table[]
Definition: prosumer.c:205
FFCodec
Definition: codec_internal.h:119
svq1_skip_block
static void svq1_skip_block(uint8_t *current, uint8_t *previous, ptrdiff_t pitch, int x, int y)
Definition: svq1dec.c:326
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:91
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
svq1_intra_mean
static VLC svq1_intra_mean
Definition: svq1dec.c:52
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
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:467
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
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:123
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:1698
GetBitContext
Definition: get_bits.h:61
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
svq1_decode_end
static av_cold int svq1_decode_end(AVCodecContext *avctx)
Definition: svq1dec.c:840
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:104
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:184
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:667
SVQ1Context::hdsp
HpelDSPContext hdsp
Definition: svq1dec.c:62
svq1_decode_frame
static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur, int *got_frame, AVPacket *avpkt)
Definition: svq1dec.c:632
SVQ1Context::gb
GetBitContext gb
Definition: svq1dec.c:63
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
s
#define s(width, name)
Definition: cbs_vp9.c:256
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:376
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:343
SVQ1Context::frame_code
int frame_code
Definition: svq1dec.c:74
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
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:76
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:62
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:182
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:57
SVQ1_BLOCK_INTRA
#define SVQ1_BLOCK_INTRA
Definition: svq1.h:45
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
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
INIT_VLC_USE_NEW_STATIC
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:100
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:787
AVOnce
#define AVOnce
Definition: thread.h:181
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
VLC::table_allocated
int table_allocated
Definition: vlc.h:34
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:75
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:1450
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:422
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:259
AVPacket::size
int size
Definition: packet.h:375
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:353
codec_internal.h
VLCElem
Definition: vlc.h:27
SVQ1_BLOCK_INTER_4V
#define SVQ1_BLOCK_INTER_4V
Definition: svq1.h:44
svq1_flush
static void svq1_flush(AVCodecContext *avctx)
Definition: svq1dec.c:853
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
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_bswap16
#define av_bswap16
Definition: bswap.h:31
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
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:269
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:49
svq1_decode_frame_header
static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame, int *buggy)
Definition: svq1dec.c:536
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:487
SVQ1Context::nonref
int nonref
Definition: svq1dec.c:75
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
svq1_inter_mean
static VLC svq1_inter_mean
Definition: svq1dec.c:53
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
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:521
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
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
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:463
ff_mvtab
const uint8_t ff_mvtab[33][2]
Definition: h263data.c:88
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:844
AVCodecContext
main external API structure.
Definition: avcodec.h:398
svq1_decode_motion_vector
static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv)
Definition: svq1dec.c:300
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
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
VLC
Definition: vlc.h:31
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
VLC::table
VLCElem * table
Definition: vlc.h:33
mean
static float mean(const float *input, int size)
Definition: vf_nnedi.c:857
svq1_decode_init
static av_cold int svq1_decode_init(AVCodecContext *avctx)
Definition: svq1dec.c:818
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
SVQ1Context::pmv_allocated
int pmv_allocated
Definition: svq1dec.c:70
svq1_block_type
static VLC svq1_block_type
Definition: svq1dec.c:48
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
SVQ1Context::pkt_swapped
uint8_t * pkt_swapped
Definition: svq1dec.c:66
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
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:386
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
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:370
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:72
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:72
svq1_pmv_s::y
int y
Definition: svq1dec.c:58
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:860
codebook
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
svq1_motion_component
static VLC svq1_motion_component
Definition: svq1dec.c:49
svq1_pmv_s
Definition: svq1dec.c:56