Libav
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 Libav.
12  *
13  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26  */
27 
35 #include "avcodec.h"
36 #include "get_bits.h"
37 #include "h263.h"
38 #include "hpeldsp.h"
39 #include "internal.h"
40 #include "mathops.h"
41 #include "svq1.h"
42 
43 #undef NDEBUG
44 #include <assert.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) == 0) \
118  break; \
119  /* add child nodes */ \
120  list[n++] = list[i]; \
121  list[n++] = list[i] + \
122  (((level & 1) ? pitch : 1) << (level / 2 + 1)); \
123  }
124 
125 #define SVQ1_ADD_CODEBOOK() \
126  /* add codebook entries to vector */ \
127  for (j = 0; j < stages; j++) { \
128  n3 = codebook[entries[j]] ^ 0x80808080; \
129  n1 += (n3 & 0xFF00FF00) >> 8; \
130  n2 += n3 & 0x00FF00FF; \
131  } \
132  \
133  /* clip to [0..255] */ \
134  if (n1 & 0xFF00FF00) { \
135  n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
136  n1 += 0x7F007F00; \
137  n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
138  n1 &= n3 & 0x00FF00FF; \
139  } \
140  \
141  if (n2 & 0xFF00FF00) { \
142  n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
143  n2 += 0x7F007F00; \
144  n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
145  n2 &= n3 & 0x00FF00FF; \
146  }
147 
148 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
149  codebook = (const uint32_t *)cbook[level]; \
150  if (stages > 0) \
151  bit_cache = get_bits(bitbuf, 4 * stages); \
152  /* calculate codebook entries for this vector */ \
153  for (j = 0; j < stages; j++) { \
154  entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
155  16 * j) << (level + 1); \
156  } \
157  mean -= stages * 128; \
158  n4 = mean + (mean >> 31) << 16 | (mean & 0xFFFF);
159 
160 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
161  int pitch)
162 {
163  uint32_t bit_cache;
164  uint8_t *list[63];
165  uint32_t *dst;
166  const uint32_t *codebook;
167  int entries[6];
168  int i, j, m, n;
169  int mean, stages;
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  av_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 
201  mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
202 
203  if (stages == 0) {
204  for (y = 0; y < height; y++)
205  memset(&dst[y * (pitch / 4)], mean, width);
206  } else {
208 
209  for (y = 0; y < height; y++) {
210  for (x = 0; x < width / 4; x++, codebook++) {
211  n1 = n4;
212  n2 = n4;
214  /* store result */
215  dst[x] = n1 << 8 | n2;
216  }
217  dst += pitch / 4;
218  }
219  }
220  }
221 
222  return 0;
223 }
224 
226  int pitch)
227 {
228  uint32_t bit_cache;
229  uint8_t *list[63];
230  uint32_t *dst;
231  const uint32_t *codebook;
232  int entries[6];
233  int i, j, m, n;
234  int mean, stages;
235  int x, y, width, height, level;
236  uint32_t n1, n2, n3, n4;
237 
238  /* initialize list for breadth first processing of vectors */
239  list[0] = pixels;
240 
241  /* recursively process vector */
242  for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
244 
245  /* destination address and vector size */
246  dst = (uint32_t *)list[i];
247  width = 1 << ((4 + level) / 2);
248  height = 1 << ((3 + level) / 2);
249 
250  /* get number of stages (-1 skips vector, 0 for mean only) */
251  stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
252 
253  if (stages == -1)
254  continue; /* skip vector */
255 
256  if ((stages > 0) && (level >= 4)) {
257  av_dlog(NULL,
258  "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
259  stages, level);
260  return AVERROR_INVALIDDATA; /* invalid vector */
261  }
262 
263  mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
264 
266 
267  for (y = 0; y < height; y++) {
268  for (x = 0; x < width / 4; x++, codebook++) {
269  n3 = dst[x];
270  /* add mean value to vector */
271  n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
272  n2 = n4 + (n3 & 0x00FF00FF);
274  /* store result */
275  dst[x] = n1 << 8 | n2;
276  }
277  dst += pitch / 4;
278  }
279  }
280  return 0;
281 }
282 
284  svq1_pmv **pmv)
285 {
286  int diff;
287  int i;
288 
289  for (i = 0; i < 2; i++) {
290  /* get motion code */
291  diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
292  if (diff < 0)
293  return AVERROR_INVALIDDATA;
294  else if (diff) {
295  if (get_bits1(bitbuf))
296  diff = -diff;
297  }
298 
299  /* add median of motion vector predictors and clip result */
300  if (i == 1)
301  mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
302  else
303  mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
304  }
305 
306  return 0;
307 }
308 
309 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
310  int pitch, int x, int y)
311 {
312  uint8_t *src;
313  uint8_t *dst;
314  int i;
315 
316  src = &previous[x + y * pitch];
317  dst = current;
318 
319  for (i = 0; i < 16; i++) {
320  memcpy(dst, src, 16);
321  src += pitch;
322  dst += pitch;
323  }
324 }
325 
327  uint8_t *current, uint8_t *previous,
328  int pitch, svq1_pmv *motion, int x, int y,
329  int width, int height)
330 {
331  uint8_t *src;
332  uint8_t *dst;
333  svq1_pmv mv;
334  svq1_pmv *pmv[3];
335  int result;
336 
337  /* predict and decode motion vector */
338  pmv[0] = &motion[0];
339  if (y == 0) {
340  pmv[1] =
341  pmv[2] = pmv[0];
342  } else {
343  pmv[1] = &motion[x / 8 + 2];
344  pmv[2] = &motion[x / 8 + 4];
345  }
346 
347  result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
348 
349  if (result != 0)
350  return result;
351 
352  motion[0].x =
353  motion[x / 8 + 2].x =
354  motion[x / 8 + 3].x = mv.x;
355  motion[0].y =
356  motion[x / 8 + 2].y =
357  motion[x / 8 + 3].y = mv.y;
358 
359  mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
360  mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
361 
362  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
363  dst = current;
364 
365  hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
366 
367  return 0;
368 }
369 
371  uint8_t *current, uint8_t *previous,
372  int pitch, svq1_pmv *motion, int x, int y,
373  int width, int height)
374 {
375  uint8_t *src;
376  uint8_t *dst;
377  svq1_pmv mv;
378  svq1_pmv *pmv[4];
379  int i, result;
380 
381  /* predict and decode motion vector (0) */
382  pmv[0] = &motion[0];
383  if (y == 0) {
384  pmv[1] =
385  pmv[2] = pmv[0];
386  } else {
387  pmv[1] = &motion[(x / 8) + 2];
388  pmv[2] = &motion[(x / 8) + 4];
389  }
390 
391  result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
392 
393  if (result != 0)
394  return result;
395 
396  /* predict and decode motion vector (1) */
397  pmv[0] = &mv;
398  if (y == 0) {
399  pmv[1] =
400  pmv[2] = pmv[0];
401  } else {
402  pmv[1] = &motion[(x / 8) + 3];
403  }
404  result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
405 
406  if (result != 0)
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 
415  if (result != 0)
416  return result;
417 
418  /* predict and decode motion vector (3) */
419  pmv[2] = &motion[(x / 8) + 2];
420  pmv[3] = &motion[(x / 8) + 3];
421 
422  result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
423 
424  if (result != 0)
425  return result;
426 
427  /* form predictions */
428  for (i = 0; i < 4; i++) {
429  int mvx = pmv[i]->x + (i & 1) * 16;
430  int mvy = pmv[i]->y + (i >> 1) * 16;
431 
432  // FIXME: clipping or padding?
433  mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
434  mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
435 
436  src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
437  dst = current;
438 
439  hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
440 
441  /* select next block */
442  if (i & 1)
443  current += 8 * (pitch - 1);
444  else
445  current += 8;
446  }
447 
448  return 0;
449 }
450 
452  GetBitContext *bitbuf,
453  uint8_t *current, uint8_t *previous,
454  int pitch, svq1_pmv *motion, int x, int y,
455  int width, int height)
456 {
457  uint32_t block_type;
458  int result = 0;
459 
460  /* get block type */
461  block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
462 
463  /* reset motion vectors */
464  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
465  motion[0].x =
466  motion[0].y =
467  motion[x / 8 + 2].x =
468  motion[x / 8 + 2].y =
469  motion[x / 8 + 3].x =
470  motion[x / 8 + 3].y = 0;
471  }
472 
473  switch (block_type) {
474  case SVQ1_BLOCK_SKIP:
475  svq1_skip_block(current, previous, pitch, x, y);
476  break;
477 
478  case SVQ1_BLOCK_INTER:
479  result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
480  pitch, motion, x, y, width, height);
481 
482  if (result != 0) {
483  av_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
484  break;
485  }
486  result = svq1_decode_block_non_intra(bitbuf, current, pitch);
487  break;
488 
489  case SVQ1_BLOCK_INTER_4V:
490  result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
491  pitch, motion, x, y, width, height);
492 
493  if (result != 0) {
494  av_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
495  break;
496  }
497  result = svq1_decode_block_non_intra(bitbuf, current, pitch);
498  break;
499 
500  case SVQ1_BLOCK_INTRA:
501  result = svq1_decode_block_intra(bitbuf, current, pitch);
502  break;
503  }
504 
505  return result;
506 }
507 
509 {
510  uint8_t seed;
511  int i;
512 
513  out[0] = get_bits(bitbuf, 8);
514  seed = string_table[out[0]];
515 
516  for (i = 1; i <= out[0]; i++) {
517  out[i] = get_bits(bitbuf, 8) ^ seed;
518  seed = string_table[out[i] ^ seed];
519  }
520 }
521 
523 {
524  SVQ1Context *s = avctx->priv_data;
525  GetBitContext *bitbuf = &s->gb;
526  int frame_size_code;
527 
528  skip_bits(bitbuf, 8); /* temporal_reference */
529 
530  /* frame type */
531  s->nonref = 0;
532  switch (get_bits(bitbuf, 2)) {
533  case 0:
534  frame->pict_type = AV_PICTURE_TYPE_I;
535  break;
536  case 2:
537  s->nonref = 1;
538  case 1:
539  frame->pict_type = AV_PICTURE_TYPE_P;
540  break;
541  default:
542  av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
543  return AVERROR_INVALIDDATA;
544  }
545 
546  if (frame->pict_type == AV_PICTURE_TYPE_I) {
547  /* unknown fields */
548  if (s->frame_code == 0x50 || s->frame_code == 0x60) {
549  int csum = get_bits(bitbuf, 16);
550 
551  csum = ff_svq1_packet_checksum(bitbuf->buffer,
552  bitbuf->size_in_bits >> 3,
553  csum);
554 
555  av_dlog(avctx, "%s checksum (%02x) for packet data\n",
556  (csum == 0) ? "correct" : "incorrect", csum);
557  }
558 
559  if ((s->frame_code ^ 0x10) >= 0x50) {
560  uint8_t msg[256];
561 
562  svq1_parse_string(bitbuf, msg);
563 
564  av_log(avctx, AV_LOG_INFO,
565  "embedded message: \"%s\"\n", (char *)msg);
566  }
567 
568  skip_bits(bitbuf, 2);
569  skip_bits(bitbuf, 2);
570  skip_bits1(bitbuf);
571 
572  /* load frame size */
573  frame_size_code = get_bits(bitbuf, 3);
574 
575  if (frame_size_code == 7) {
576  /* load width, height (12 bits each) */
577  s->width = get_bits(bitbuf, 12);
578  s->height = get_bits(bitbuf, 12);
579 
580  if (!s->width || !s->height)
581  return AVERROR_INVALIDDATA;
582  } else {
583  /* get width, height from table */
584  s->width = ff_svq1_frame_size_table[frame_size_code][0];
585  s->height = ff_svq1_frame_size_table[frame_size_code][1];
586  }
587  }
588 
589  /* unknown fields */
590  if (get_bits1(bitbuf) == 1) {
591  skip_bits1(bitbuf); /* use packet checksum if (1) */
592  skip_bits1(bitbuf); /* component checksums after image data if (1) */
593 
594  if (get_bits(bitbuf, 2) != 0)
595  return AVERROR_INVALIDDATA;
596  }
597 
598  if (get_bits1(bitbuf) == 1) {
599  skip_bits1(bitbuf);
600  skip_bits(bitbuf, 4);
601  skip_bits1(bitbuf);
602  skip_bits(bitbuf, 2);
603 
604  while (get_bits1(bitbuf) == 1)
605  skip_bits(bitbuf, 8);
606  }
607 
608  return 0;
609 }
610 
611 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
612  int *got_frame, AVPacket *avpkt)
613 {
614  const uint8_t *buf = avpkt->data;
615  int buf_size = avpkt->size;
616  SVQ1Context *s = avctx->priv_data;
617  AVFrame *cur = data;
618  uint8_t *current;
619  int result, i, x, y, width, height;
620  svq1_pmv *pmv;
621 
622  /* initialize bit buffer */
623  init_get_bits(&s->gb, buf, buf_size * 8);
624 
625  /* decode frame header */
626  s->frame_code = get_bits(&s->gb, 22);
627 
628  if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
629  return AVERROR_INVALIDDATA;
630 
631  /* swap some header bytes (why?) */
632  if (s->frame_code != 0x20) {
633  uint32_t *src;
634 
635  if (buf_size < 9 * 4) {
636  av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
637  return AVERROR_INVALIDDATA;
638  }
639 
642  buf_size);
643  if (!s->pkt_swapped)
644  return AVERROR(ENOMEM);
645 
646  memcpy(s->pkt_swapped, buf, buf_size);
647  buf = s->pkt_swapped;
648  init_get_bits(&s->gb, buf, buf_size * 8);
649  skip_bits(&s->gb, 22);
650 
651  src = (uint32_t *)(s->pkt_swapped + 4);
652 
653  for (i = 0; i < 4; i++)
654  src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
655  }
656 
657  result = svq1_decode_frame_header(avctx, cur);
658 
659  if (result != 0) {
660  av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
661  return result;
662  }
663 
664  result = ff_set_dimensions(avctx, s->width, s->height);
665  if (result < 0)
666  return result;
667 
668  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
669  (avctx->skip_frame >= AVDISCARD_NONKEY &&
670  cur->pict_type != AV_PICTURE_TYPE_I) ||
671  avctx->skip_frame >= AVDISCARD_ALL)
672  return buf_size;
673 
674  result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
675  if (result < 0)
676  return result;
677 
678  pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
679  if (!pmv)
680  return AVERROR(ENOMEM);
681 
682  /* decode y, u and v components */
683  for (i = 0; i < 3; i++) {
684  int linesize = cur->linesize[i];
685  if (i == 0) {
686  width = FFALIGN(s->width, 16);
687  height = FFALIGN(s->height, 16);
688  } else {
689  if (avctx->flags & CODEC_FLAG_GRAY)
690  break;
691  width = FFALIGN(s->width / 4, 16);
692  height = FFALIGN(s->height / 4, 16);
693  }
694 
695  current = cur->data[i];
696 
697  if (cur->pict_type == AV_PICTURE_TYPE_I) {
698  /* keyframe */
699  for (y = 0; y < height; y += 16) {
700  for (x = 0; x < width; x += 16) {
701  result = svq1_decode_block_intra(&s->gb, &current[x],
702  linesize);
703  if (result != 0) {
704  av_log(avctx, AV_LOG_INFO,
705  "Error in svq1_decode_block %i (keyframe)\n",
706  result);
707  goto err;
708  }
709  }
710  current += 16 * linesize;
711  }
712  } else {
713  /* delta frame */
714  uint8_t *previous = s->prev->data[i];
715  if (!previous ||
716  s->prev->width != s->width || s->prev->height != s->height) {
717  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
718  result = AVERROR_INVALIDDATA;
719  goto err;
720  }
721 
722  memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
723 
724  for (y = 0; y < height; y += 16) {
725  for (x = 0; x < width; x += 16) {
726  result = svq1_decode_delta_block(avctx, &s->hdsp,
727  &s->gb, &current[x],
728  previous, linesize,
729  pmv, x, y, width, height);
730  if (result != 0) {
731  av_dlog(avctx,
732  "Error in svq1_decode_delta_block %i\n",
733  result);
734  goto err;
735  }
736  }
737 
738  pmv[0].x =
739  pmv[0].y = 0;
740 
741  current += 16 * linesize;
742  }
743  }
744  }
745 
746  if (!s->nonref) {
747  av_frame_unref(s->prev);
748  result = av_frame_ref(s->prev, cur);
749  if (result < 0)
750  goto err;
751  }
752 
753  *got_frame = 1;
754  result = buf_size;
755 
756 err:
757  av_free(pmv);
758  return result;
759 }
760 
762 {
763  SVQ1Context *s = avctx->priv_data;
764  int i;
765  int offset = 0;
766 
767  s->prev = av_frame_alloc();
768  if (!s->prev)
769  return AVERROR(ENOMEM);
770 
771  s->width = avctx->width + 3 & ~3;
772  s->height = avctx->height + 3 & ~3;
773  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
774 
775  ff_hpeldsp_init(&s->hdsp, avctx->flags);
776 
777  INIT_VLC_STATIC(&svq1_block_type, 2, 4,
778  &ff_svq1_block_type_vlc[0][1], 2, 1,
779  &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
780 
781  INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
782  &ff_mvtab[0][1], 2, 1,
783  &ff_mvtab[0][0], 2, 1, 176);
784 
785  for (i = 0; i < 6; i++) {
786  static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
787  { 10, 10, 14, 14, 14, 16 } };
788  static VLC_TYPE table[168][2];
789  svq1_intra_multistage[i].table = &table[offset];
790  svq1_intra_multistage[i].table_allocated = sizes[0][i];
791  offset += sizes[0][i];
792  init_vlc(&svq1_intra_multistage[i], 3, 8,
793  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
794  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
796  svq1_inter_multistage[i].table = &table[offset];
797  svq1_inter_multistage[i].table_allocated = sizes[1][i];
798  offset += sizes[1][i];
799  init_vlc(&svq1_inter_multistage[i], 3, 8,
800  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
801  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
803  }
804 
805  INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
806  &ff_svq1_intra_mean_vlc[0][1], 4, 2,
807  &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
808 
809  INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
810  &ff_svq1_inter_mean_vlc[0][1], 4, 2,
811  &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
812 
813  return 0;
814 }
815 
817 {
818  SVQ1Context *s = avctx->priv_data;
819 
820  av_frame_free(&s->prev);
821  av_freep(&s->pkt_swapped);
822 
823  return 0;
824 }
825 
826 static void svq1_flush(AVCodecContext *avctx)
827 {
828  SVQ1Context *s = avctx->priv_data;
829 
830  av_frame_unref(s->prev);
831 }
832 
834  .name = "svq1",
835  .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
836  .type = AVMEDIA_TYPE_VIDEO,
837  .id = AV_CODEC_ID_SVQ1,
838  .priv_data_size = sizeof(SVQ1Context),
842  .capabilities = CODEC_CAP_DR1,
843  .flush = svq1_flush,
844  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
845  AV_PIX_FMT_NONE },
846 };
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
discard all frames except keyframes
Definition: avcodec.h:567
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
static VLC svq1_inter_multistage[6]
Definition: svq1dec.c:49
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, int pitch, svq1_pmv *motion, int x, int y, int width, int height)
Definition: svq1dec.c:370
static VLC svq1_motion_component
Definition: svq1dec.c:47
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
uint16_t ff_svq1_packet_checksum(const uint8_t *data, const int length, int value)
Definition: svq13.c:60
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:133
int size
Definition: avcodec.h:974
const uint8_t * buffer
Definition: get_bits.h:54
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1254
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer with padding, reusing the given one if large enough.
Definition: utils.c:59
#define VLC_TYPE
Definition: get_bits.h:62
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
discard all
Definition: avcodec.h:568
#define SVQ1_BLOCK_INTRA
Definition: svq1.h:43
AVCodec.
Definition: avcodec.h:2796
#define FFALIGN(x, a)
Definition: common.h:62
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
enum AVDiscard skip_frame
Definition: avcodec.h:2727
const uint16_t ff_svq1_frame_size_table[7][2]
Definition: svq1.c:40
#define SVQ1_BLOCK_SKIP
Definition: svq1.h:40
static av_cold int svq1_decode_end(AVCodecContext *avctx)
Definition: svq1dec.c:816
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:275
uint8_t
#define av_cold
Definition: attributes.h:66
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:57
static VLC svq1_intra_mean
Definition: svq1dec.c:50
const int8_t *const ff_svq1_inter_codebooks[6]
Definition: svq1_cb.h:776
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: get_bits.h:443
static VLC svq1_intra_multistage[6]
Definition: svq1dec.c:48
const uint8_t ff_mvtab[33][2]
Definition: h263data.h:91
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:188
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:684
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:973
bitstream reader API header.
#define SVQ1_ADD_CODEBOOK()
Definition: svq1dec.c:125
static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
Definition: svq1dec.c:522
int width
width and height of the video frame
Definition: frame.h:174
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:186
static const int sizes[][2]
Definition: img2dec.c:46
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:69
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:150
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)
Definition: svq1dec.c:148
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1144
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:168
const char * name
Name of the codec implementation.
Definition: avcodec.h:2803
#define SVQ1_BLOCK_INTER
Definition: svq1.h:41
static void svq1_skip_block(uint8_t *current, uint8_t *previous, int pitch, int x, int y)
Definition: svq1dec.c:309
Sorenson Vector Quantizer #1 (SVQ1) video codec.
Definition: get_bits.h:64
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:196
static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels, int pitch)
Definition: svq1dec.c:160
static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
Definition: svq1dec.c:508
int width
Definition: svq1dec.c:67
const uint8_t ff_svq1_block_type_vlc[4][2]
Definition: svq1_vlc.h:27
int width
picture width / height.
Definition: avcodec.h:1224
HpelDSPContext hdsp
Definition: svq1dec.c:60
int size_in_bits
Definition: get_bits.h:56
uint8_t * pkt_swapped
Definition: svq1dec.c:64
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:522
static void svq1_flush(AVCodecContext *avctx)
Definition: svq1dec.c:826
int pkt_swapped_allocated
Definition: svq1dec.c:65
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:441
const uint8_t ff_svq1_inter_multistage_vlc[6][8][2]
Definition: svq1_vlc.h:50
static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, int pitch, svq1_pmv *motion, int x, int y, int width, int height)
Definition: svq1dec.c:451
int table_allocated
Definition: get_bits.h:67
static const int8_t mv[256][2]
Definition: 4xm.c:75
NULL
Definition: eval.c:55
Half-pel DSP functions.
static int width
Definition: utils.c:156
#define AV_LOG_INFO
Standard information.
Definition: log.h:134
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:153
main external API structure.
Definition: avcodec.h:1050
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:490
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: utils.c:612
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:424
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:271
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:296
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:71
static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, int pitch, svq1_pmv *motion, int x, int y, int width, int height)
Definition: svq1dec.c:326
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:263
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:375
GetBitContext gb
Definition: svq1dec.c:61
#define mid_pred
Definition: mathops.h:98
static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, int pitch)
Definition: svq1dec.c:225
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:127
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:283
#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:141
uint8_t level
Definition: svq3.c:147
int height
Definition: gxfenc.c:72
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
discard all non reference
Definition: avcodec.h:565
static int svq1_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: svq1dec.c:611
const int8_t *const ff_svq1_intra_codebooks[6]
Definition: svq1_cb.h:1519
common internal api header.
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:637
const uint8_t ff_svq1_intra_multistage_vlc[6][8][2]
Definition: svq1_vlc.h:33
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
Definition: alsdec.c:1771
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:283
const uint16_t ff_svq1_inter_mean_vlc[512][2]
Definition: svq1_vlc.h:136
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:499
int y
Definition: svq1dec.c:56
void * priv_data
Definition: avcodec.h:1092
#define SVQ1_PROCESS_VECTOR()
Definition: svq1dec.c:108
int nonref
Definition: svq1dec.c:70
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:66
static av_cold int svq1_decode_init(AVCodecContext *avctx)
Definition: svq1dec.c:761
int height
Definition: frame.h:174
static VLC svq1_block_type
Definition: svq1dec.c:46
AVCodec ff_svq1_decoder
Definition: svq1dec.c:833
AVPixelFormat
Pixel format.
Definition: pixfmt.h:63
This structure stores compressed data.
Definition: avcodec.h:950
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:850
Predicted.
Definition: avutil.h:254
int x
Definition: svq1dec.c:55