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