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[257])
 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     out[i] = 0;
 515 }
 516
 517 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
 518 {
 519     SVQ1Context *s = avctx->priv_data;
 520     GetBitContext *bitbuf = &s->gb;
 521     int frame_size_code;
 522     int width  = s->width;
 523     int height = s->height;
 524
 525     skip_bits(bitbuf, 8); /* temporal_reference */
 526
 527     /* frame type */
 528     s->nonref = 0;
 529     switch (get_bits(bitbuf, 2)) {
 530     case 0:
 531         frame->pict_type = AV_PICTURE_TYPE_I;
 532         break;
 533     case 2:
 534         s->nonref = 1;
 535     case 1:
 536         frame->pict_type = AV_PICTURE_TYPE_P;
 537         break;
 538     default:
 539         av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
 540         return AVERROR_INVALIDDATA;
 541     }
 542
 543     if (frame->pict_type == AV_PICTURE_TYPE_I) {
 544         /* unknown fields */
 545         if (s->frame_code == 0x50 || s->frame_code == 0x60) {
 546             int csum = get_bits(bitbuf, 16);
 547
 548             csum = ff_svq1_packet_checksum(bitbuf->buffer,
 549                                            bitbuf->size_in_bits >> 3,
 550                                            csum);
 551
 552             av_dlog(avctx, "%s checksum (%02x) for packet data\n",
 553                     (csum == 0) ? "correct" : "incorrect", csum);
 554         }
 555
 556         if ((s->frame_code ^ 0x10) >= 0x50) {
 557             uint8_t msg[257];
 558
 559             svq1_parse_string(bitbuf, msg);
 560
 561             av_log(avctx, AV_LOG_INFO,
 562                    "embedded message:\n%s\n", ((char *)msg) + 1);
 563         }
 564
 565         skip_bits(bitbuf, 2);
 566         skip_bits(bitbuf, 2);
 567         skip_bits1(bitbuf);
 568
 569         /* load frame size */
 570         frame_size_code = get_bits(bitbuf, 3);
 571
 572         if (frame_size_code == 7) {
 573             /* load width, height (12 bits each) */
 574             width  = get_bits(bitbuf, 12);
 575             height = get_bits(bitbuf, 12);
 576
 577             if (!width || !height)
 578                 return AVERROR_INVALIDDATA;
 579         } else {
 580             /* get width, height from table */
 581             width  = ff_svq1_frame_size_table[frame_size_code][0];
 582             height = ff_svq1_frame_size_table[frame_size_code][1];
 583         }
 584     }
 585
 586     /* unknown fields */
 587     if (get_bits1(bitbuf)) {
 588         skip_bits1(bitbuf);    /* use packet checksum if (1) */
 589         skip_bits1(bitbuf);    /* component checksums after image data if (1) */
 590
 591         if (get_bits(bitbuf, 2) != 0)
 592             return AVERROR_INVALIDDATA;
 593     }
 594
 595     if (get_bits1(bitbuf)) {
 596         skip_bits1(bitbuf);
 597         skip_bits(bitbuf, 4);
 598         skip_bits1(bitbuf);
 599         skip_bits(bitbuf, 2);
 600
 601         if (skip_1stop_8data_bits(bitbuf) < 0)
 602             return AVERROR_INVALIDDATA;
 603     }
 604
 605     s->width  = width;
 606     s->height = height;
 607     return 0;
 608 }
 609
 610 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
 611                              int *got_frame, AVPacket *avpkt)
 612 {
 613     const uint8_t *buf = avpkt->data;
 614     int buf_size       = avpkt->size;
 615     SVQ1Context     *s = avctx->priv_data;
 616     AVFrame       *cur = data;
 617     uint8_t *current;
 618     int result, i, x, y, width, height;
 619     svq1_pmv *pmv;
 620
 621     /* initialize bit buffer */
 622     init_get_bits8(&s->gb, buf, buf_size);
 623
 624     /* decode frame header */
 625     s->frame_code = get_bits(&s->gb, 22);
 626
 627     if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
 628         return AVERROR_INVALIDDATA;
 629
 630     /* swap some header bytes (why?) */
 631     if (s->frame_code != 0x20) {
 632         uint32_t *src;
 633
 634         if (buf_size < 9 * 4) {
 635             av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
 636             return AVERROR_INVALIDDATA;
 637         }
 638
 639         av_fast_padded_malloc(&s->pkt_swapped,
 640                               &s->pkt_swapped_allocated,
 641                               buf_size);
 642         if (!s->pkt_swapped)
 643             return AVERROR(ENOMEM);
 644
 645         memcpy(s->pkt_swapped, buf, buf_size);
 646         buf = s->pkt_swapped;
 647         init_get_bits(&s->gb, buf, buf_size * 8);
 648         skip_bits(&s->gb, 22);
 649
 650         src = (uint32_t *)(s->pkt_swapped + 4);
 651
 652         if (buf_size < 36)
 653             return AVERROR_INVALIDDATA;
 654
 655         for (i = 0; i < 4; i++)
 656             src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
 657     }
 658
 659     result = svq1_decode_frame_header(avctx, cur);
 660     if (result != 0) {
 661         av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
 662         return result;
 663     }
 664
 665     result = ff_set_dimensions(avctx, s->width, s->height);
 666     if (result < 0)
 667         return result;
 668
 669     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
 670         (avctx->skip_frame >= AVDISCARD_NONKEY &&
 671          cur->pict_type != AV_PICTURE_TYPE_I) ||
 672         avctx->skip_frame >= AVDISCARD_ALL)
 673         return buf_size;
 674
 675     result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
 676     if (result < 0)
 677         return result;
 678
 679     pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
 680     if (!pmv)
 681         return AVERROR(ENOMEM);
 682
 683     /* decode y, u and v components */
 684     for (i = 0; i < 3; i++) {
 685         int linesize = cur->linesize[i];
 686         if (i == 0) {
 687             width    = FFALIGN(s->width,  16);
 688             height   = FFALIGN(s->height, 16);
 689         } else {
 690             if (avctx->flags & CODEC_FLAG_GRAY)
 691                 break;
 692             width    = FFALIGN(s->width  / 4, 16);
 693             height   = FFALIGN(s->height / 4, 16);
 694         }
 695
 696         current = cur->data[i];
 697
 698         if (cur->pict_type == AV_PICTURE_TYPE_I) {
 699             /* keyframe */
 700             for (y = 0; y < height; y += 16) {
 701                 for (x = 0; x < width; x += 16) {
 702                     result = svq1_decode_block_intra(&s->gb, &current[x],
 703                                                      linesize);
 704                     if (result) {
 705                         av_log(avctx, AV_LOG_ERROR,
 706                                "Error in svq1_decode_block %i (keyframe)\n",
 707                                result);
 708                         goto err;
 709                     }
 710                 }
 711                 current += 16 * linesize;
 712             }
 713         } else {
 714             /* delta frame */
 715             uint8_t *previous = s->prev->data[i];
 716             if (!previous ||
 717                 s->prev->width != s->width || s->prev->height != s->height) {
 718                 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
 719                 result = AVERROR_INVALIDDATA;
 720                 goto err;
 721             }
 722
 723             memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
 724
 725             for (y = 0; y < height; y += 16) {
 726                 for (x = 0; x < width; x += 16) {
 727                     result = svq1_decode_delta_block(avctx, &s->hdsp,
 728                                                      &s->gb, &current[x],
 729                                                      previous, linesize,
 730                                                      pmv, x, y, width, height);
 731                     if (result != 0) {
 732                         av_dlog(avctx,
 733                                 "Error in svq1_decode_delta_block %i\n",
 734                                 result);
 735                         goto err;
 736                     }
 737                 }
 738
 739                 pmv[0].x     =
 740                     pmv[0].y = 0;
 741
 742                 current += 16 * linesize;
 743             }
 744         }
 745     }
 746
 747     if (!s->nonref) {
 748         av_frame_unref(s->prev);
 749         result = av_frame_ref(s->prev, cur);
 750         if (result < 0)
 751             goto err;
 752     }
 753
 754     *got_frame = 1;
 755     result     = buf_size;
 756
 757 err:
 758     av_free(pmv);
 759     return result;
 760 }
 761
 762 static av_cold int svq1_decode_init(AVCodecContext *avctx)
 763 {
 764     SVQ1Context *s = avctx->priv_data;
 765     int i;
 766     int offset = 0;
 767
 768     s->prev = av_frame_alloc();
 769     if (!s->prev)
 770         return AVERROR(ENOMEM);
 771
 772     s->width            = avctx->width  + 3 & ~3;
 773     s->height           = avctx->height + 3 & ~3;
 774     avctx->pix_fmt      = AV_PIX_FMT_YUV410P;
 775
 776     ff_hpeldsp_init(&s->hdsp, avctx->flags);
 777
 778     INIT_VLC_STATIC(&svq1_block_type, 2, 4,
 779                     &ff_svq1_block_type_vlc[0][1], 2, 1,
 780                     &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
 781
 782     INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
 783                     &ff_mvtab[0][1], 2, 1,
 784                     &ff_mvtab[0][0], 2, 1, 176);
 785
 786     for (i = 0; i < 6; i++) {
 787         static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
 788                                              { 10, 10, 14, 14, 14, 16 } };
 789         static VLC_TYPE table[168][2];
 790         svq1_intra_multistage[i].table           = &table[offset];
 791         svq1_intra_multistage[i].table_allocated = sizes[0][i];
 792         offset                                  += sizes[0][i];
 793         init_vlc(&svq1_intra_multistage[i], 3, 8,
 794                  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
 795                  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
 796                  INIT_VLC_USE_NEW_STATIC);
 797         svq1_inter_multistage[i].table           = &table[offset];
 798         svq1_inter_multistage[i].table_allocated = sizes[1][i];
 799         offset                                  += sizes[1][i];
 800         init_vlc(&svq1_inter_multistage[i], 3, 8,
 801                  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
 802                  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
 803                  INIT_VLC_USE_NEW_STATIC);
 804     }
 805
 806     INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
 807                     &ff_svq1_intra_mean_vlc[0][1], 4, 2,
 808                     &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
 809
 810     INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
 811                     &ff_svq1_inter_mean_vlc[0][1], 4, 2,
 812                     &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
 813
 814     return 0;
 815 }
 816
 817 static av_cold int svq1_decode_end(AVCodecContext *avctx)
 818 {
 819     SVQ1Context *s = avctx->priv_data;
 820
 821     av_frame_free(&s->prev);
 822     av_freep(&s->pkt_swapped);
 823     s->pkt_swapped_allocated = 0;
 824
 825     return 0;
 826 }
 827
 828 static void svq1_flush(AVCodecContext *avctx)
 829 {
 830     SVQ1Context *s = avctx->priv_data;
 831
 832     av_frame_unref(s->prev);
 833 }
 834
 835 AVCodec ff_svq1_decoder = {
 836     .name           = "svq1",
 837     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
 838     .type           = AVMEDIA_TYPE_VIDEO,
 839     .id             = AV_CODEC_ID_SVQ1,
 840     .priv_data_size = sizeof(SVQ1Context),
 841     .init           = svq1_decode_init,
 842     .close          = svq1_decode_end,
 843     .decode         = svq1_decode_frame,
 844     .capabilities   = CODEC_CAP_DR1,
 845     .flush          = svq1_flush,
 846     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
 847                                                      AV_PIX_FMT_NONE },
 848 };