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