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