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 "get_bits.h"
41 #include "h263data.h"
42 #include "hpeldsp.h"
43 #include "internal.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 } SVQ1Context;
77 
78 static const uint8_t string_table[256] = {
79  0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
80  0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
81  0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
82  0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
83  0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
84  0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
85  0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
86  0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
87  0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
88  0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
89  0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
90  0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
91  0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
92  0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
93  0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
94  0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
95  0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
96  0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
97  0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
98  0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
99  0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
100  0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
101  0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
102  0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
103  0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
104  0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
105  0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
106  0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
107  0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
108  0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
109  0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
110  0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
111 };
112 
113 #define SVQ1_PROCESS_VECTOR() \
114  for (; level > 0; i++) { \
115  /* process next depth */ \
116  if (i == m) { \
117  m = n; \
118  if (--level == 0) \
119  break; \
120  } \
121  /* divide block if next bit set */ \
122  if (!get_bits1(bitbuf)) \
123  break; \
124  /* add child nodes */ \
125  list[n++] = list[i]; \
126  list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
127  }
128 
129 #define SVQ1_ADD_CODEBOOK() \
130  /* add codebook entries to vector */ \
131  for (j = 0; j < stages; j++) { \
132  n3 = codebook[entries[j]] ^ 0x80808080; \
133  n1 += (n3 & 0xFF00FF00) >> 8; \
134  n2 += n3 & 0x00FF00FF; \
135  } \
136  \
137  /* clip to [0..255] */ \
138  if (n1 & 0xFF00FF00) { \
139  n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
140  n1 += 0x7F007F00; \
141  n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
142  n1 &= n3 & 0x00FF00FF; \
143  } \
144  \
145  if (n2 & 0xFF00FF00) { \
146  n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
147  n2 += 0x7F007F00; \
148  n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
149  n2 &= n3 & 0x00FF00FF; \
150  }
151 
152 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
153  codebook = (const uint32_t *)cbook[level]; \
154  if (stages > 0) \
155  bit_cache = get_bits(bitbuf, 4 * stages); \
156  /* calculate codebook entries for this vector */ \
157  for (j = 0; j < stages; j++) { \
158  entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
159  16 * j) << (level + 1); \
160  } \
161  mean -= stages * 128; \
162  n4 = (mean << 16) + mean;
163 
164 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
165  ptrdiff_t pitch)
166 {
167  uint32_t bit_cache;
168  uint8_t *list[63];
169  uint32_t *dst;
170  const uint32_t *codebook;
171  int entries[6];
172  int i, j, m, n;
173  int stages;
174  unsigned mean;
175  unsigned x, y, width, height, level;
176  uint32_t n1, n2, n3, n4;
177 
178  /* initialize list for breadth first processing of vectors */
179  list[0] = pixels;
180 
181  /* recursively process vector */
182  for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
184 
185  /* destination address and vector size */
186  dst = (uint32_t *)list[i];
187  width = 1 << ((4 + level) / 2);
188  height = 1 << ((3 + level) / 2);
189 
190  /* get number of stages (-1 skips vector, 0 for mean only) */
191  stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
192 
193  if (stages == -1) {
194  for (y = 0; y < height; y++)
195  memset(&dst[y * (pitch / 4)], 0, width);
196  continue; /* skip vector */
197  }
198 
199  if ((stages > 0 && level >= 4)) {
200  ff_dlog(NULL,
201  "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
202  stages, level);
203  return AVERROR_INVALIDDATA; /* invalid vector */
204  }
205  av_assert0(stages >= 0);
206 
207  mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
208 
209  if (stages == 0) {
210  for (y = 0; y < height; y++)
211  memset(&dst[y * (pitch / 4)], mean, width);
212  } else {
214 
215  for (y = 0; y < height; y++) {
216  for (x = 0; x < width / 4; x++, codebook++) {
217  n1 = n4;
218  n2 = n4;
220  /* store result */
221  dst[x] = n1 << 8 | n2;
222  }
223  dst += pitch / 4;
224  }
225  }
226  }
227 
228  return 0;
229 }
230 
231 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
232  ptrdiff_t pitch)
233 {
234  uint32_t bit_cache;
235  uint8_t *list[63];
236  uint32_t *dst;
237  const uint32_t *codebook;
238  int entries[6];
239  int i, j, m, n;
240  int stages;
241  unsigned mean;
242  int x, y, width, height, level;
243  uint32_t n1, n2, n3, n4;
244 
245  /* initialize list for breadth first processing of vectors */
246  list[0] = pixels;
247 
248  /* recursively process vector */
249  for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
251 
252  /* destination address and vector size */
253  dst = (uint32_t *)list[i];
254  width = 1 << ((4 + level) / 2);
255  height = 1 << ((3 + level) / 2);
256 
257  /* get number of stages (-1 skips vector, 0 for mean only) */
258  stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
259 
260  if (stages == -1)
261  continue; /* skip vector */
262 
263  if ((stages > 0 && level >= 4)) {
264  ff_dlog(NULL,
265  "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
266  stages, level);
267  return AVERROR_INVALIDDATA; /* invalid vector */
268  }
269  av_assert0(stages >= 0);
270 
271  mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
272 
274 
275  for (y = 0; y < height; y++) {
276  for (x = 0; x < width / 4; x++, codebook++) {
277  n3 = dst[x];
278  /* add mean value to vector */
279  n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
280  n2 = n4 + (n3 & 0x00FF00FF);
282  /* store result */
283  dst[x] = n1 << 8 | n2;
284  }
285  dst += pitch / 4;
286  }
287  }
288  return 0;
289 }
290 
291 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
292  svq1_pmv **pmv)
293 {
294  int diff;
295  int i;
296 
297  for (i = 0; i < 2; i++) {
298  /* get motion code */
299  diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
300  if (diff < 0)
301  return AVERROR_INVALIDDATA;
302  else if (diff) {
303  if (get_bits1(bitbuf))
304  diff = -diff;
305  }
306 
307  /* add median of motion vector predictors and clip result */
308  if (i == 1)
309  mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
310  else
311  mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
312  }
313 
314  return 0;
315 }
316 
317 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
318  ptrdiff_t pitch, int x, int y)
319 {
320  uint8_t *src;
321  uint8_t *dst;
322  int i;
323 
324  src = &previous[x + y * pitch];
325  dst = current;
326 
327  for (i = 0; i < 16; i++) {
328  memcpy(dst, src, 16);
329  src += pitch;
330  dst += pitch;
331  }
332 }
333 
335  uint8_t *current, uint8_t *previous,
336  ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
337  int width, int height)
338 {
339  uint8_t *src;
340  uint8_t *dst;
341  svq1_pmv mv;
342  svq1_pmv *pmv[3];
343  int result;
344 
345  /* predict and decode motion vector */
346  pmv[0] = &motion[0];
347  if (y == 0) {
348  pmv[1] =
349  pmv[2] = pmv[0];
350  } else {
351  pmv[1] = &motion[x / 8 + 2];
352  pmv[2] = &motion[x / 8 + 4];
353  }
354 
355  result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
356  if (result)
357  return result;
358 
359  motion[0].x =
360  motion[x / 8 + 2].x =
361  motion[x / 8 + 3].x = mv.x;
362  motion[0].y =
363  motion[x / 8 + 2].y =
364  motion[x / 8 + 3].y = mv.y;
365 
366  mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
367  mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
368 
369  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
370  dst = current;
371 
372  hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
373 
374  return 0;
375 }
376 
378  uint8_t *current, uint8_t *previous,
379  ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
380  int width, int height)
381 {
382  uint8_t *src;
383  uint8_t *dst;
384  svq1_pmv mv;
385  svq1_pmv *pmv[4];
386  int i, result;
387 
388  /* predict and decode motion vector (0) */
389  pmv[0] = &motion[0];
390  if (y == 0) {
391  pmv[1] =
392  pmv[2] = pmv[0];
393  } else {
394  pmv[1] = &motion[(x / 8) + 2];
395  pmv[2] = &motion[(x / 8) + 4];
396  }
397 
398  result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
399  if (result)
400  return result;
401 
402  /* predict and decode motion vector (1) */
403  pmv[0] = &mv;
404  if (y == 0) {
405  pmv[1] =
406  pmv[2] = pmv[0];
407  } else {
408  pmv[1] = &motion[(x / 8) + 3];
409  }
410  result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
411  if (result)
412  return result;
413 
414  /* predict and decode motion vector (2) */
415  pmv[1] = &motion[0];
416  pmv[2] = &motion[(x / 8) + 1];
417 
418  result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
419  if (result)
420  return result;
421 
422  /* predict and decode motion vector (3) */
423  pmv[2] = &motion[(x / 8) + 2];
424  pmv[3] = &motion[(x / 8) + 3];
425 
426  result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
427  if (result)
428  return result;
429 
430  /* form predictions */
431  for (i = 0; i < 4; i++) {
432  int mvx = pmv[i]->x + (i & 1) * 16;
433  int mvy = pmv[i]->y + (i >> 1) * 16;
434 
435  // FIXME: clipping or padding?
436  mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
437  mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
438 
439  src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
440  dst = current;
441 
442  hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
443 
444  /* select next block */
445  if (i & 1)
446  current += 8 * (pitch - 1);
447  else
448  current += 8;
449  }
450 
451  return 0;
452 }
453 
455  GetBitContext *bitbuf,
456  uint8_t *current, uint8_t *previous,
457  ptrdiff_t pitch, svq1_pmv *motion, int x, int y,
458  int width, int height)
459 {
460  uint32_t block_type;
461  int result = 0;
462 
463  /* get block type */
464  block_type = get_vlc2(bitbuf, svq1_block_type.table,
466 
467  /* reset motion vectors */
468  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
469  motion[0].x =
470  motion[0].y =
471  motion[x / 8 + 2].x =
472  motion[x / 8 + 2].y =
473  motion[x / 8 + 3].x =
474  motion[x / 8 + 3].y = 0;
475  }
476 
477  switch (block_type) {
478  case SVQ1_BLOCK_SKIP:
479  svq1_skip_block(current, previous, pitch, x, y);
480  break;
481 
482  case SVQ1_BLOCK_INTER:
483  result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
484  pitch, motion, x, y, width, height);
485 
486  if (result != 0) {
487  ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
488  break;
489  }
490  result = svq1_decode_block_non_intra(bitbuf, current, pitch);
491  break;
492 
493  case SVQ1_BLOCK_INTER_4V:
494  result = svq1_motion_inter_4v_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_4v_block %i\n", result);
499  break;
500  }
501  result = svq1_decode_block_non_intra(bitbuf, current, pitch);
502  break;
503 
504  case SVQ1_BLOCK_INTRA:
505  result = svq1_decode_block_intra(bitbuf, current, pitch);
506  break;
507  }
508 
509  return result;
510 }
511 
512 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
513 {
514  uint8_t seed;
515  int i;
516 
517  out[0] = get_bits(bitbuf, 8);
518  seed = string_table[out[0]];
519 
520  for (i = 1; i <= out[0]; i++) {
521  out[i] = get_bits(bitbuf, 8) ^ seed;
522  seed = string_table[out[i] ^ seed];
523  }
524  out[i] = 0;
525 }
526 
528 {
529  SVQ1Context *s = avctx->priv_data;
530  GetBitContext *bitbuf = &s->gb;
531  int frame_size_code;
532  int width = s->width;
533  int height = s->height;
534 
535  skip_bits(bitbuf, 8); /* temporal_reference */
536 
537  /* frame type */
538  s->nonref = 0;
539  switch (get_bits(bitbuf, 2)) {
540  case 0:
541  frame->pict_type = AV_PICTURE_TYPE_I;
542  break;
543  case 2:
544  s->nonref = 1;
545  case 1:
546  frame->pict_type = AV_PICTURE_TYPE_P;
547  break;
548  default:
549  av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
550  return AVERROR_INVALIDDATA;
551  }
552 
553  if (frame->pict_type == AV_PICTURE_TYPE_I) {
554  /* unknown fields */
555  if (s->frame_code == 0x50 || s->frame_code == 0x60) {
556  int csum = get_bits(bitbuf, 16);
557 
558  csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));
559 
560  ff_dlog(avctx, "%s checksum (%02x) for packet data\n",
561  (csum == 0) ? "correct" : "incorrect", csum);
562  }
563 
564  if ((s->frame_code ^ 0x10) >= 0x50) {
565  uint8_t msg[257];
566 
567  svq1_parse_string(bitbuf, msg);
568 
569  av_log(avctx, AV_LOG_INFO,
570  "embedded message:\n%s\n", ((char *)msg) + 1);
571  }
572 
573  skip_bits(bitbuf, 2);
574  skip_bits(bitbuf, 2);
575  skip_bits1(bitbuf);
576 
577  /* load frame size */
578  frame_size_code = get_bits(bitbuf, 3);
579 
580  if (frame_size_code == 7) {
581  /* load width, height (12 bits each) */
582  width = get_bits(bitbuf, 12);
583  height = get_bits(bitbuf, 12);
584 
585  if (!width || !height)
586  return AVERROR_INVALIDDATA;
587  } else {
588  /* get width, height from table */
589  width = ff_svq1_frame_size_table[frame_size_code][0];
590  height = ff_svq1_frame_size_table[frame_size_code][1];
591  }
592  }
593 
594  /* unknown fields */
595  if (get_bits1(bitbuf)) {
596  skip_bits1(bitbuf); /* use packet checksum if (1) */
597  skip_bits1(bitbuf); /* component checksums after image data if (1) */
598 
599  if (get_bits(bitbuf, 2) != 0)
600  return AVERROR_INVALIDDATA;
601  }
602 
603  if (get_bits1(bitbuf)) {
604  skip_bits1(bitbuf);
605  skip_bits(bitbuf, 4);
606  skip_bits1(bitbuf);
607  skip_bits(bitbuf, 2);
608 
609  if (skip_1stop_8data_bits(bitbuf) < 0)
610  return AVERROR_INVALIDDATA;
611  }
612  if (get_bits_left(bitbuf) <= 0)
613  return AVERROR_INVALIDDATA;
614 
615  s->width = width;
616  s->height = height;
617  return 0;
618 }
619 
620 static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur,
621  int *got_frame, AVPacket *avpkt)
622 {
623  const uint8_t *buf = avpkt->data;
624  int buf_size = avpkt->size;
625  SVQ1Context *s = avctx->priv_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  .p.name = "svq1",
848  .p.long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
849  .p.type = AVMEDIA_TYPE_VIDEO,
850  .p.id = AV_CODEC_ID_SVQ1,
851  .priv_data_size = sizeof(SVQ1Context),
853  .close = svq1_decode_end,
855  .p.capabilities = AV_CODEC_CAP_DR1,
856  .flush = svq1_flush,
857  .p.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:51
h263data.h
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:206
av_clip
#define av_clip
Definition: common.h:95
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: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: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:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
internal.h
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:38
table
static const uint16_t table[]
Definition: prosumer.c:206
FFCodec
Definition: codec_internal.h:112
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:317
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: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
init
static int init
Definition: av_tx.c:47
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:527
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:164
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
VLC_TYPE
#define VLC_TYPE
Definition: vlc.h:24
SVQ1_CALC_CODEBOOK_ENTRIES
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)
Definition: svq1dec.c:152
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1696
GetBitContext
Definition: get_bits.h:62
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:469
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:57
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:47
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:179
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:62
svq1_decode_frame
static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur, int *got_frame, AVPacket *avpkt)
Definition: svq1dec.c:620
SVQ1Context::gb
GetBitContext gb
Definition: svq1dec.c:63
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:254
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:367
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:334
SVQ1Context::frame_code
int frame_code
Definition: svq1dec.c:74
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:129
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:177
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: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
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:454
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:176
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
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:1403
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:249
AVPacket::size
int size
Definition: packet.h:375
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:116
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:343
codec_internal.h
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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AV_CRC_16_CCITT
@ AV_CRC_16_CCITT
Definition: crc.h:51
string_table
static const uint8_t string_table[256]
Definition: svq1dec.c:78
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:48
SVQ1_PROCESS_VECTOR
#define SVQ1_PROCESS_VECTOR()
Definition: svq1dec.c:113
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: codec_internal.h:31
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:477
SVQ1Context::nonref
int nonref
Definition: svq1dec.c:75
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
svq1_inter_mean
static VLC svq1_inter_mean
Definition: svq1dec.c:53
AVCodecContext::height
int height
Definition: avcodec.h:562
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
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:512
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: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
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:389
svq1_decode_motion_vector
static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv)
Definition: svq1dec.c:291
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:231
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:132
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: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:90
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:416
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:377
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:562
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:50
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:846
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
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