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