FFmpeg  4.4.4
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:
541  break;
542  case 2:
543  s->nonref = 1;
544  case 1:
546  break;
547  default:
548  av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
549  return AVERROR_INVALIDDATA;
550  }
551 
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 
650  av_fast_padded_malloc(&s->pkt_swapped,
651  &s->pkt_swapped_allocated,
652  buf_size);
653  if (!s->pkt_swapped)
654  return AVERROR(ENOMEM);
655 
656  memcpy(s->pkt_swapped, buf, buf_size);
657  buf = s->pkt_swapped;
658  init_get_bits(&s->gb, buf, buf_size * 8);
659  skip_bits(&s->gb, 22);
660 
661  src = (uint32_t *)(s->pkt_swapped + 4);
662 
663  for (i = 0; i < 4; i++)
664  src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
665  }
666 
667  result = svq1_decode_frame_header(avctx, cur);
668  if (result != 0) {
669  ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
670  return result;
671  }
672 
673  result = ff_set_dimensions(avctx, s->width, s->height);
674  if (result < 0)
675  return result;
676 
677  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
678  (avctx->skip_frame >= AVDISCARD_NONKEY &&
679  cur->pict_type != AV_PICTURE_TYPE_I) ||
680  avctx->skip_frame >= AVDISCARD_ALL)
681  return buf_size;
682 
683  result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
684  if (result < 0)
685  return result;
686 
687  av_fast_padded_malloc(&s->pmv, &s->pmv_allocated, (FFALIGN(s->width, 16) / 8 + 3) * sizeof(*s->pmv));
688  if (!s->pmv)
689  return AVERROR(ENOMEM);
690 
691  /* decode y, u and v components */
692  for (i = 0; i < 3; i++) {
693  int linesize = cur->linesize[i];
694  if (i == 0) {
695  width = FFALIGN(s->width, 16);
696  height = FFALIGN(s->height, 16);
697  } else {
698  if (avctx->flags & AV_CODEC_FLAG_GRAY)
699  break;
700  width = FFALIGN(s->width / 4, 16);
701  height = FFALIGN(s->height / 4, 16);
702  }
703 
704  current = cur->data[i];
705 
706  if (cur->pict_type == AV_PICTURE_TYPE_I) {
707  /* keyframe */
708  for (y = 0; y < height; y += 16) {
709  for (x = 0; x < width; x += 16) {
710  result = svq1_decode_block_intra(&s->gb, &current[x],
711  linesize);
712  if (result) {
713  av_log(avctx, AV_LOG_ERROR,
714  "Error in svq1_decode_block %i (keyframe)\n",
715  result);
716  return result;
717  }
718  }
719  current += 16 * linesize;
720  }
721  } else {
722  /* delta frame */
723  uint8_t *previous = s->prev->data[i];
724  if (!previous ||
725  s->prev->width != s->width || s->prev->height != s->height) {
726  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
727  return AVERROR_INVALIDDATA;
728  }
729 
730  memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
731 
732  for (y = 0; y < height; y += 16) {
733  for (x = 0; x < width; x += 16) {
734  result = svq1_decode_delta_block(avctx, &s->hdsp,
735  &s->gb, &current[x],
736  previous, linesize,
737  s->pmv, x, y, width, height);
738  if (result != 0) {
739  ff_dlog(avctx,
740  "Error in svq1_decode_delta_block %i\n",
741  result);
742  return result;
743  }
744  }
745 
746  s->pmv[0].x =
747  s->pmv[0].y = 0;
748 
749  current += 16 * linesize;
750  }
751  }
752  }
753 
754  if (!s->nonref) {
755  av_frame_unref(s->prev);
756  result = av_frame_ref(s->prev, cur);
757  if (result < 0)
758  return result;
759  }
760 
761  *got_frame = 1;
762  result = buf_size;
763 
764  return result;
765 }
766 
767 static av_cold void svq1_static_init(void)
768 {
770  &ff_svq1_block_type_vlc[0][1], 2, 1,
771  &ff_svq1_block_type_vlc[0][0], 2, 1, 8);
772 
774  &ff_mvtab[0][1], 2, 1,
775  &ff_mvtab[0][0], 2, 1, 176);
776 
777  for (int i = 0, offset = 0; i < 6; i++) {
778  static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
779  { 10, 10, 14, 14, 14, 16 } };
780  static VLC_TYPE table[168][2];
783  offset += sizes[0][i];
785  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
786  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
790  offset += sizes[1][i];
792  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
793  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
795  }
796 
798  &ff_svq1_intra_mean_vlc[0][1], 4, 2,
799  &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
800 
802  &ff_svq1_inter_mean_vlc[0][1], 4, 2,
803  &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
804 }
805 
807 {
808  static AVOnce init_static_once = AV_ONCE_INIT;
809  SVQ1Context *s = avctx->priv_data;
810 
811  s->prev = av_frame_alloc();
812  if (!s->prev)
813  return AVERROR(ENOMEM);
814 
815  s->width = avctx->width + 3 & ~3;
816  s->height = avctx->height + 3 & ~3;
817  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
818 
819  ff_hpeldsp_init(&s->hdsp, avctx->flags);
820 
821  ff_thread_once(&init_static_once, svq1_static_init);
822 
823  return 0;
824 }
825 
827 {
828  SVQ1Context *s = avctx->priv_data;
829 
830  av_frame_free(&s->prev);
831  av_freep(&s->pkt_swapped);
832  s->pkt_swapped_allocated = 0;
833  av_freep(&s->pmv);
834  s->pmv_allocated = 0;
835 
836  return 0;
837 }
838 
839 static void svq1_flush(AVCodecContext *avctx)
840 {
841  SVQ1Context *s = avctx->priv_data;
842 
843  av_frame_unref(s->prev);
844 }
845 
847  .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 };
static void flush(AVCodecContext *avctx)
#define av_cold
Definition: attributes.h:88
uint8_t
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define s(width, name)
Definition: cbs_vp9.c:257
static const unsigned codebook[256][2]
Definition: cfhdenc.c:42
#define av_clip
Definition: common.h:122
#define NULL
Definition: coverity.c:32
Public header for CRC hash function implementation.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static AVFrame * frame
bitstream reader API header.
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 int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:854
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#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_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
@ AV_CODEC_ID_SVQ1
Definition: codec_id.h:71
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:236
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: avcodec.h:235
@ AVDISCARD_NONREF
discard all non reference
Definition: avcodec.h:232
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:50
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
@ AV_CRC_16_CCITT
Definition: crc.h:52
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
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
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
const uint8_t ff_mvtab[33][2]
Definition: h263data.c:88
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
static const int sizes[][2]
Definition: img2dec.c:53
int i
Definition: input.c:407
static const int8_t mv[256][2]
Definition: 4xm.c:78
#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
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:84
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define AVOnce
Definition: thread.h:172
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
#define AV_ONCE_INIT
Definition: thread.h:173
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:309
#define FFALIGN(x, a)
Definition: macros.h:48
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
#define mid_pred
Definition: mathops.h:97
const char data[16]
Definition: mxf.c:142
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
static const uint16_t table[]
Definition: prosumer.c:206
#define av_bswap16
Definition: bswap.h:31
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
void * priv_data
Definition: avcodec.h:563
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2006
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
const uint8_t * buffer
Definition: get_bits.h:62
int size_in_bits
Definition: get_bits.h:68
Half-pel DSP context.
Definition: hpeldsp.h:45
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
HpelDSPContext hdsp
Definition: svq1dec.c:61
int pmv_allocated
Definition: svq1dec.c:69
uint8_t * pkt_swapped
Definition: svq1dec.c:65
int width
Definition: svq1dec.c:71
int pkt_swapped_allocated
Definition: svq1dec.c:66
int height
Definition: svq1dec.c:72
GetBitContext gb
Definition: svq1dec.c:62
int frame_code
Definition: svq1dec.c:73
AVFrame * prev
Definition: svq1dec.c:63
svq1_pmv * pmv
Definition: svq1dec.c:68
int nonref
Definition: svq1dec.c:74
Definition: vlc.h:26
int table_allocated
Definition: vlc.h:29
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int y
Definition: svq1dec.c:57
int x
Definition: svq1dec.c:56
const uint16_t ff_svq1_frame_size_table[7][2]
Definition: svq1.c:40
Sorenson Vector Quantizer #1 (SVQ1) video codec.
#define SVQ1_BLOCK_INTER_4V
Definition: svq1.h:42
#define SVQ1_BLOCK_INTER
Definition: svq1.h:41
const uint8_t ff_svq1_intra_multistage_vlc[6][8][2]
Definition: svq1_vlc.h:33
const uint8_t ff_svq1_inter_multistage_vlc[6][8][2]
Definition: svq1_vlc.h:50
const int8_t *const ff_svq1_intra_codebooks[6]
Definition: svq1_cb.h:1519
const int8_t *const ff_svq1_inter_codebooks[6]
Definition: svq1_cb.h:776
#define SVQ1_BLOCK_INTRA
Definition: svq1.h:43
#define SVQ1_BLOCK_SKIP
Definition: svq1.h:40
const uint16_t ff_svq1_inter_mean_vlc[512][2]
Definition: svq1_vlc.h:136
const uint16_t ff_svq1_intra_mean_vlc[256][2]
Definition: svq1_vlc.h:67
const uint8_t ff_svq1_block_type_vlc[4][2]
Definition: svq1_vlc.h:27
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
static av_cold int svq1_decode_end(AVCodecContext *avctx)
Definition: svq1dec.c:826
static VLC svq1_inter_multistage[6]
Definition: svq1dec.c:50
static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
Definition: svq1dec.c:526
static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv)
Definition: svq1dec.c:290
static VLC svq1_inter_mean
Definition: svq1dec.c:52
static av_cold int svq1_decode_init(AVCodecContext *avctx)
Definition: svq1dec.c:806
static const uint8_t string_table[256]
Definition: svq1dec.c:77
AVCodec ff_svq1_decoder
Definition: svq1dec.c:846
static int svq1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: svq1dec.c:619
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)
Definition: svq1dec.c:151
#define SVQ1_BLOCK_TYPE_VLC_BITS
Definition: svq1dec.c:46
static void svq1_flush(AVCodecContext *avctx)
Definition: svq1dec.c:839
static VLC svq1_motion_component
Definition: svq1dec.c:48
static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch)
Definition: svq1dec.c:230
static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
Definition: svq1dec.c:511
#define SVQ1_ADD_CODEBOOK()
Definition: svq1dec.c:128
static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch)
Definition: svq1dec.c:163
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 void svq1_static_init(void)
Definition: svq1dec.c:767
static VLC svq1_intra_multistage[6]
Definition: svq1dec.c:49
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
#define SVQ1_PROCESS_VECTOR()
Definition: svq1dec.c:112
static VLC svq1_intra_mean
Definition: svq1dec.c:51
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
static VLC svq1_block_type
Definition: svq1dec.c:47
uint8_t level
Definition: svq3.c:206
#define ff_dlog(a,...)
#define av_freep(p)
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
FILE * out
Definition: movenc.c:54
#define height
#define width
static float mean(const float *input, int size)
Definition: vf_nnedi.c:864
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
static unsigned int seed
Definition: videogen.c:78
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:120
#define INIT_VLC_USE_NEW_STATIC
Definition: vlc.h:95
#define VLC_TYPE
Definition: vlc.h:24