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