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