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