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