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