FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 "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)) \
118  break; \
119  /* add child nodes */ \
120  list[n++] = list[i]; \
121  list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
122  }
123 
124 #define SVQ1_ADD_CODEBOOK() \
125  /* add codebook entries to vector */ \
126  for (j = 0; j < stages; j++) { \
127  n3 = codebook[entries[j]] ^ 0x80808080; \
128  n1 += (n3 & 0xFF00FF00) >> 8; \
129  n2 += n3 & 0x00FF00FF; \
130  } \
131  \
132  /* clip to [0..255] */ \
133  if (n1 & 0xFF00FF00) { \
134  n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
135  n1 += 0x7F007F00; \
136  n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
137  n1 &= n3 & 0x00FF00FF; \
138  } \
139  \
140  if (n2 & 0xFF00FF00) { \
141  n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
142  n2 += 0x7F007F00; \
143  n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \
144  n2 &= n3 & 0x00FF00FF; \
145  }
146 
147 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
148  codebook = (const uint32_t *)cbook[level]; \
149  if (stages > 0) \
150  bit_cache = get_bits(bitbuf, 4 * stages); \
151  /* calculate codebook entries for this vector */ \
152  for (j = 0; j < stages; j++) { \
153  entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
154  16 * j) << (level + 1); \
155  } \
156  mean -= stages * 128; \
157  n4 = (mean << 16) + mean;
158 
159 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
160  int pitch)
161 {
162  uint32_t bit_cache;
163  uint8_t *list[63];
164  uint32_t *dst;
165  const uint32_t *codebook;
166  int entries[6];
167  int i, j, m, n;
168  int mean, stages;
169  unsigned x, y, width, height, level;
170  uint32_t n1, n2, n3, n4;
171 
172  /* initialize list for breadth first processing of vectors */
173  list[0] = pixels;
174 
175  /* recursively process vector */
176  for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
178 
179  /* destination address and vector size */
180  dst = (uint32_t *)list[i];
181  width = 1 << ((4 + level) / 2);
182  height = 1 << ((3 + level) / 2);
183 
184  /* get number of stages (-1 skips vector, 0 for mean only) */
185  stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
186 
187  if (stages == -1) {
188  for (y = 0; y < height; y++)
189  memset(&dst[y * (pitch / 4)], 0, width);
190  continue; /* skip vector */
191  }
192 
193  if (stages > 0 && level >= 4) {
194  av_dlog(NULL,
195  "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
196  stages, level);
197  return AVERROR_INVALIDDATA; /* invalid vector */
198  }
199 
200  mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
201 
202  if (stages == 0) {
203  for (y = 0; y < height; y++)
204  memset(&dst[y * (pitch / 4)], mean, width);
205  } else {
207 
208  for (y = 0; y < height; y++) {
209  for (x = 0; x < width / 4; x++, codebook++) {
210  n1 = n4;
211  n2 = n4;
213  /* store result */
214  dst[x] = n1 << 8 | n2;
215  }
216  dst += pitch / 4;
217  }
218  }
219  }
220 
221  return 0;
222 }
223 
225  int pitch)
226 {
227  uint32_t bit_cache;
228  uint8_t *list[63];
229  uint32_t *dst;
230  const uint32_t *codebook;
231  int entries[6];
232  int i, j, m, n;
233  int mean, stages;
234  int x, y, width, height, level;
235  uint32_t n1, n2, n3, n4;
236 
237  /* initialize list for breadth first processing of vectors */
238  list[0] = pixels;
239 
240  /* recursively process vector */
241  for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
243 
244  /* destination address and vector size */
245  dst = (uint32_t *)list[i];
246  width = 1 << ((4 + level) / 2);
247  height = 1 << ((3 + level) / 2);
248 
249  /* get number of stages (-1 skips vector, 0 for mean only) */
250  stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
251 
252  if (stages == -1)
253  continue; /* skip vector */
254 
255  if ((stages > 0) && (level >= 4)) {
256  av_dlog(NULL,
257  "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
258  stages, level);
259  return AVERROR_INVALIDDATA; /* invalid vector */
260  }
261 
262  mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
263 
265 
266  for (y = 0; y < height; y++) {
267  for (x = 0; x < width / 4; x++, codebook++) {
268  n3 = dst[x];
269  /* add mean value to vector */
270  n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
271  n2 = n4 + (n3 & 0x00FF00FF);
273  /* store result */
274  dst[x] = n1 << 8 | n2;
275  }
276  dst += pitch / 4;
277  }
278  }
279  return 0;
280 }
281 
283  svq1_pmv **pmv)
284 {
285  int diff;
286  int i;
287 
288  for (i = 0; i < 2; i++) {
289  /* get motion code */
290  diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
291  if (diff < 0)
292  return AVERROR_INVALIDDATA;
293  else if (diff) {
294  if (get_bits1(bitbuf))
295  diff = -diff;
296  }
297 
298  /* add median of motion vector predictors and clip result */
299  if (i == 1)
300  mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
301  else
302  mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
303  }
304 
305  return 0;
306 }
307 
308 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
309  int pitch, int x, int y)
310 {
311  uint8_t *src;
312  uint8_t *dst;
313  int i;
314 
315  src = &previous[x + y * pitch];
316  dst = current;
317 
318  for (i = 0; i < 16; i++) {
319  memcpy(dst, src, 16);
320  src += pitch;
321  dst += pitch;
322  }
323 }
324 
326  uint8_t *current, uint8_t *previous,
327  int pitch, svq1_pmv *motion, int x, int y,
328  int width, int height)
329 {
330  uint8_t *src;
331  uint8_t *dst;
332  svq1_pmv mv;
333  svq1_pmv *pmv[3];
334  int result;
335 
336  /* predict and decode motion vector */
337  pmv[0] = &motion[0];
338  if (y == 0) {
339  pmv[1] =
340  pmv[2] = pmv[0];
341  } else {
342  pmv[1] = &motion[x / 8 + 2];
343  pmv[2] = &motion[x / 8 + 4];
344  }
345 
346  result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
347  if (result)
348  return result;
349 
350  motion[0].x =
351  motion[x / 8 + 2].x =
352  motion[x / 8 + 3].x = mv.x;
353  motion[0].y =
354  motion[x / 8 + 2].y =
355  motion[x / 8 + 3].y = mv.y;
356 
357  mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));
358  mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
359 
360  src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
361  dst = current;
362 
363  hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
364 
365  return 0;
366 }
367 
369  uint8_t *current, uint8_t *previous,
370  int pitch, svq1_pmv *motion, int x, int y,
371  int width, int height)
372 {
373  uint8_t *src;
374  uint8_t *dst;
375  svq1_pmv mv;
376  svq1_pmv *pmv[4];
377  int i, result;
378 
379  /* predict and decode motion vector (0) */
380  pmv[0] = &motion[0];
381  if (y == 0) {
382  pmv[1] =
383  pmv[2] = pmv[0];
384  } else {
385  pmv[1] = &motion[(x / 8) + 2];
386  pmv[2] = &motion[(x / 8) + 4];
387  }
388 
389  result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
390  if (result)
391  return result;
392 
393  /* predict and decode motion vector (1) */
394  pmv[0] = &mv;
395  if (y == 0) {
396  pmv[1] =
397  pmv[2] = pmv[0];
398  } else {
399  pmv[1] = &motion[(x / 8) + 3];
400  }
401  result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
402  if (result)
403  return result;
404 
405  /* predict and decode motion vector (2) */
406  pmv[1] = &motion[0];
407  pmv[2] = &motion[(x / 8) + 1];
408 
409  result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
410  if (result)
411  return result;
412 
413  /* predict and decode motion vector (3) */
414  pmv[2] = &motion[(x / 8) + 2];
415  pmv[3] = &motion[(x / 8) + 3];
416 
417  result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
418  if (result)
419  return result;
420 
421  /* form predictions */
422  for (i = 0; i < 4; i++) {
423  int mvx = pmv[i]->x + (i & 1) * 16;
424  int mvy = pmv[i]->y + (i >> 1) * 16;
425 
426  // FIXME: clipping or padding?
427  mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));
428  mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
429 
430  src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
431  dst = current;
432 
433  hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
434 
435  /* select next block */
436  if (i & 1)
437  current += 8 * (pitch - 1);
438  else
439  current += 8;
440  }
441 
442  return 0;
443 }
444 
446  GetBitContext *bitbuf,
447  uint8_t *current, uint8_t *previous,
448  int pitch, svq1_pmv *motion, int x, int y,
449  int width, int height)
450 {
451  uint32_t block_type;
452  int result = 0;
453 
454  /* get block type */
455  block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
456 
457  /* reset motion vectors */
458  if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
459  motion[0].x =
460  motion[0].y =
461  motion[x / 8 + 2].x =
462  motion[x / 8 + 2].y =
463  motion[x / 8 + 3].x =
464  motion[x / 8 + 3].y = 0;
465  }
466 
467  switch (block_type) {
468  case SVQ1_BLOCK_SKIP:
469  svq1_skip_block(current, previous, pitch, x, y);
470  break;
471 
472  case SVQ1_BLOCK_INTER:
473  result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
474  pitch, motion, x, y, width, height);
475 
476  if (result != 0) {
477  av_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
478  break;
479  }
480  result = svq1_decode_block_non_intra(bitbuf, current, pitch);
481  break;
482 
483  case SVQ1_BLOCK_INTER_4V:
484  result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
485  pitch, motion, x, y, width, height);
486 
487  if (result != 0) {
488  av_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
489  break;
490  }
491  result = svq1_decode_block_non_intra(bitbuf, current, pitch);
492  break;
493 
494  case SVQ1_BLOCK_INTRA:
495  result = svq1_decode_block_intra(bitbuf, current, pitch);
496  break;
497  }
498 
499  return result;
500 }
501 
502 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])
503 {
504  uint8_t seed;
505  int i;
506 
507  out[0] = get_bits(bitbuf, 8);
508  seed = string_table[out[0]];
509 
510  for (i = 1; i <= out[0]; i++) {
511  out[i] = get_bits(bitbuf, 8) ^ seed;
512  seed = string_table[out[i] ^ seed];
513  }
514  out[i] = 0;
515 }
516 
518 {
519  SVQ1Context *s = avctx->priv_data;
520  GetBitContext *bitbuf = &s->gb;
521  int frame_size_code;
522  int width = s->width;
523  int height = s->height;
524 
525  skip_bits(bitbuf, 8); /* temporal_reference */
526 
527  /* frame type */
528  s->nonref = 0;
529  switch (get_bits(bitbuf, 2)) {
530  case 0:
531  frame->pict_type = AV_PICTURE_TYPE_I;
532  break;
533  case 2:
534  s->nonref = 1;
535  case 1:
536  frame->pict_type = AV_PICTURE_TYPE_P;
537  break;
538  default:
539  av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
540  return AVERROR_INVALIDDATA;
541  }
542 
543  if (frame->pict_type == AV_PICTURE_TYPE_I) {
544  /* unknown fields */
545  if (s->frame_code == 0x50 || s->frame_code == 0x60) {
546  int csum = get_bits(bitbuf, 16);
547 
548  csum = ff_svq1_packet_checksum(bitbuf->buffer,
549  bitbuf->size_in_bits >> 3,
550  csum);
551 
552  av_dlog(avctx, "%s checksum (%02x) for packet data\n",
553  (csum == 0) ? "correct" : "incorrect", csum);
554  }
555 
556  if ((s->frame_code ^ 0x10) >= 0x50) {
557  uint8_t msg[257];
558 
559  svq1_parse_string(bitbuf, msg);
560 
561  av_log(avctx, AV_LOG_INFO,
562  "embedded message:\n%s\n", ((char *)msg) + 1);
563  }
564 
565  skip_bits(bitbuf, 2);
566  skip_bits(bitbuf, 2);
567  skip_bits1(bitbuf);
568 
569  /* load frame size */
570  frame_size_code = get_bits(bitbuf, 3);
571 
572  if (frame_size_code == 7) {
573  /* load width, height (12 bits each) */
574  width = get_bits(bitbuf, 12);
575  height = get_bits(bitbuf, 12);
576 
577  if (!width || !height)
578  return AVERROR_INVALIDDATA;
579  } else {
580  /* get width, height from table */
581  width = ff_svq1_frame_size_table[frame_size_code][0];
582  height = ff_svq1_frame_size_table[frame_size_code][1];
583  }
584  }
585 
586  /* unknown fields */
587  if (get_bits1(bitbuf)) {
588  skip_bits1(bitbuf); /* use packet checksum if (1) */
589  skip_bits1(bitbuf); /* component checksums after image data if (1) */
590 
591  if (get_bits(bitbuf, 2) != 0)
592  return AVERROR_INVALIDDATA;
593  }
594 
595  if (get_bits1(bitbuf)) {
596  skip_bits1(bitbuf);
597  skip_bits(bitbuf, 4);
598  skip_bits1(bitbuf);
599  skip_bits(bitbuf, 2);
600 
601  if (skip_1stop_8data_bits(bitbuf) < 0)
602  return AVERROR_INVALIDDATA;
603  }
604 
605  s->width = width;
606  s->height = height;
607  return 0;
608 }
609 
610 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
611  int *got_frame, AVPacket *avpkt)
612 {
613  const uint8_t *buf = avpkt->data;
614  int buf_size = avpkt->size;
615  SVQ1Context *s = avctx->priv_data;
616  AVFrame *cur = data;
617  uint8_t *current;
618  int result, i, x, y, width, height;
619  svq1_pmv *pmv;
620 
621  /* initialize bit buffer */
622  init_get_bits8(&s->gb, buf, buf_size);
623 
624  /* decode frame header */
625  s->frame_code = get_bits(&s->gb, 22);
626 
627  if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
628  return AVERROR_INVALIDDATA;
629 
630  /* swap some header bytes (why?) */
631  if (s->frame_code != 0x20) {
632  uint32_t *src;
633 
634  if (buf_size < 9 * 4) {
635  av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
636  return AVERROR_INVALIDDATA;
637  }
638 
641  buf_size);
642  if (!s->pkt_swapped)
643  return AVERROR(ENOMEM);
644 
645  memcpy(s->pkt_swapped, buf, buf_size);
646  buf = s->pkt_swapped;
647  init_get_bits(&s->gb, buf, buf_size * 8);
648  skip_bits(&s->gb, 22);
649 
650  src = (uint32_t *)(s->pkt_swapped + 4);
651 
652  if (buf_size < 36)
653  return AVERROR_INVALIDDATA;
654 
655  for (i = 0; i < 4; i++)
656  src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
657  }
658 
659  result = svq1_decode_frame_header(avctx, cur);
660  if (result != 0) {
661  av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
662  return result;
663  }
664 
665  result = ff_set_dimensions(avctx, s->width, s->height);
666  if (result < 0)
667  return result;
668 
669  if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
670  (avctx->skip_frame >= AVDISCARD_NONKEY &&
671  cur->pict_type != AV_PICTURE_TYPE_I) ||
672  avctx->skip_frame >= AVDISCARD_ALL)
673  return buf_size;
674 
675  result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
676  if (result < 0)
677  return result;
678 
679  pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
680  if (!pmv)
681  return AVERROR(ENOMEM);
682 
683  /* decode y, u and v components */
684  for (i = 0; i < 3; i++) {
685  int linesize = cur->linesize[i];
686  if (i == 0) {
687  width = FFALIGN(s->width, 16);
688  height = FFALIGN(s->height, 16);
689  } else {
690  if (avctx->flags & CODEC_FLAG_GRAY)
691  break;
692  width = FFALIGN(s->width / 4, 16);
693  height = FFALIGN(s->height / 4, 16);
694  }
695 
696  current = cur->data[i];
697 
698  if (cur->pict_type == AV_PICTURE_TYPE_I) {
699  /* keyframe */
700  for (y = 0; y < height; y += 16) {
701  for (x = 0; x < width; x += 16) {
702  result = svq1_decode_block_intra(&s->gb, &current[x],
703  linesize);
704  if (result) {
705  av_log(avctx, AV_LOG_ERROR,
706  "Error in svq1_decode_block %i (keyframe)\n",
707  result);
708  goto err;
709  }
710  }
711  current += 16 * linesize;
712  }
713  } else {
714  /* delta frame */
715  uint8_t *previous = s->prev->data[i];
716  if (!previous ||
717  s->prev->width != s->width || s->prev->height != s->height) {
718  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
719  result = AVERROR_INVALIDDATA;
720  goto err;
721  }
722 
723  memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
724 
725  for (y = 0; y < height; y += 16) {
726  for (x = 0; x < width; x += 16) {
727  result = svq1_decode_delta_block(avctx, &s->hdsp,
728  &s->gb, &current[x],
729  previous, linesize,
730  pmv, x, y, width, height);
731  if (result != 0) {
732  av_dlog(avctx,
733  "Error in svq1_decode_delta_block %i\n",
734  result);
735  goto err;
736  }
737  }
738 
739  pmv[0].x =
740  pmv[0].y = 0;
741 
742  current += 16 * linesize;
743  }
744  }
745  }
746 
747  if (!s->nonref) {
748  av_frame_unref(s->prev);
749  result = av_frame_ref(s->prev, cur);
750  if (result < 0)
751  goto err;
752  }
753 
754  *got_frame = 1;
755  result = buf_size;
756 
757 err:
758  av_free(pmv);
759  return result;
760 }
761 
763 {
764  SVQ1Context *s = avctx->priv_data;
765  int i;
766  int offset = 0;
767 
768  s->prev = av_frame_alloc();
769  if (!s->prev)
770  return AVERROR(ENOMEM);
771 
772  s->width = avctx->width + 3 & ~3;
773  s->height = avctx->height + 3 & ~3;
774  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
775 
776  ff_hpeldsp_init(&s->hdsp, avctx->flags);
777 
778  INIT_VLC_STATIC(&svq1_block_type, 2, 4,
779  &ff_svq1_block_type_vlc[0][1], 2, 1,
780  &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
781 
782  INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
783  &ff_mvtab[0][1], 2, 1,
784  &ff_mvtab[0][0], 2, 1, 176);
785 
786  for (i = 0; i < 6; i++) {
787  static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
788  { 10, 10, 14, 14, 14, 16 } };
789  static VLC_TYPE table[168][2];
790  svq1_intra_multistage[i].table = &table[offset];
791  svq1_intra_multistage[i].table_allocated = sizes[0][i];
792  offset += sizes[0][i];
793  init_vlc(&svq1_intra_multistage[i], 3, 8,
794  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
795  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
797  svq1_inter_multistage[i].table = &table[offset];
798  svq1_inter_multistage[i].table_allocated = sizes[1][i];
799  offset += sizes[1][i];
800  init_vlc(&svq1_inter_multistage[i], 3, 8,
801  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
802  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
804  }
805 
806  INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
807  &ff_svq1_intra_mean_vlc[0][1], 4, 2,
808  &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
809 
810  INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
811  &ff_svq1_inter_mean_vlc[0][1], 4, 2,
812  &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
813 
814  return 0;
815 }
816 
818 {
819  SVQ1Context *s = avctx->priv_data;
820 
821  av_frame_free(&s->prev);
822  av_freep(&s->pkt_swapped);
823  s->pkt_swapped_allocated = 0;
824 
825  return 0;
826 }
827 
828 static void svq1_flush(AVCodecContext *avctx)
829 {
830  SVQ1Context *s = avctx->priv_data;
831 
832  av_frame_unref(s->prev);
833 }
834 
836  .name = "svq1",
837  .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
838  .type = AVMEDIA_TYPE_VIDEO,
839  .id = AV_CODEC_ID_SVQ1,
840  .priv_data_size = sizeof(SVQ1Context),
844  .capabilities = CODEC_CAP_DR1,
845  .flush = svq1_flush,
846  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
847  AV_PIX_FMT_NONE },
848 };