git.sesse.net Git - ffmpeg/blob - libavcodec/svq1dec.c

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