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) {
 195             av_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)) {
 257             av_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             av_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             av_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             av_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_malloc(s->pkt_swapped, &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         for (i = 0; i < 4; i++)
 653             src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
 654     }
 655
 656     result = svq1_decode_frame_header(avctx, cur);
 657
 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 != 0) {
 703                         av_log(avctx, AV_LOG_INFO,
 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
 822     return 0;
 823 }
 824
 825 static void svq1_flush(AVCodecContext *avctx)
 826 {
 827     SVQ1Context *s = avctx->priv_data;
 828
 829     av_frame_unref(s->prev);
 830 }
 831
 832 AVCodec ff_svq1_decoder = {
 833     .name           = "svq1",
 834     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
 835     .type           = AVMEDIA_TYPE_VIDEO,
 836     .id             = AV_CODEC_ID_SVQ1,
 837     .priv_data_size = sizeof(SVQ1Context),
 838     .init           = svq1_decode_init,
 839     .close          = svq1_decode_end,
 840     .decode         = svq1_decode_frame,
 841     .capabilities   = CODEC_CAP_DR1,
 842     .flush          = svq1_flush,
 843     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
 844                                                      AV_PIX_FMT_NONE },
 845 };