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