svq1dec.c 26.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
 * SVQ1 decoder
 * ported to MPlayer by Arpi <arpi@thot.banki.hu>
 * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
 *
 * Copyright (C) 2002 the xine project
 * Copyright (C) 2002 the ffmpeg project
 *
 * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
29
 * @file
30 31 32 33 34 35
 * Sorenson Vector Quantizer #1 (SVQ1) video codec.
 * For more information of the SVQ1 algorithm, visit:
 *   http://www.pcisys.net/~melanson/codecs/
 */

#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 42 43 44 45 46 47 48 49 50 51 52 53 54
#include "svq1.h"

#undef NDEBUG
#include <assert.h>

static VLC svq1_block_type;
static VLC svq1_motion_component;
static VLC svq1_intra_multistage[6];
static VLC svq1_inter_multistage[6];
static VLC svq1_intra_mean;
static VLC svq1_inter_mean;

/* motion vector (prediction) */
typedef struct svq1_pmv_s {
55 56
    int x;
    int y;
57
} svq1_pmv;
58

59
typedef struct SVQ1Context {
60
    HpelDSPContext hdsp;
61
    GetBitContext gb;
62
    AVFrame *prev;
63 64 65 66 67 68
    int width;
    int height;
    int frame_code;
    int nonref;         // 1 if the current frame won't be referenced
} SVQ1Context;

69
static const uint8_t string_table[256] = {
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
    0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
    0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
    0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
    0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
    0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
    0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
    0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
    0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
    0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
    0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
    0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
    0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
    0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
    0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
    0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
    0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
    0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
    0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
    0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
    0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
    0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
    0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
    0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
    0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
    0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
    0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
    0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
    0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
    0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
    0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
    0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
    0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
102 103
};

104 105 106 107 108 109 110 111 112
#define SVQ1_PROCESS_VECTOR()                                           \
    for (; level > 0; i++) {                                            \
        /* process next depth */                                        \
        if (i == m) {                                                   \
            m = n;                                                      \
            if (--level == 0)                                           \
                break;                                                  \
        }                                                               \
        /* divide block if next bit set */                              \
113
        if (!get_bits1(bitbuf))                                         \
114 115 116
            break;                                                      \
        /* add child nodes */                                           \
        list[n++] = list[i];                                            \
117
        list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
118 119
    }

120 121 122 123
#define SVQ1_ADD_CODEBOOK()                                             \
    /* add codebook entries to vector */                                \
    for (j = 0; j < stages; j++) {                                      \
        n3  = codebook[entries[j]] ^ 0x80808080;                        \
124 125
        n1 += (n3 & 0xFF00FF00) >> 8;                                   \
        n2 +=  n3 & 0x00FF00FF;                                         \
126 127 128 129
    }                                                                   \
                                                                        \
    /* clip to [0..255] */                                              \
    if (n1 & 0xFF00FF00) {                                              \
130
        n3  = (n1 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
131
        n1 += 0x7F007F00;                                               \
132 133
        n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
        n1 &= n3 & 0x00FF00FF;                                          \
134 135 136
    }                                                                   \
                                                                        \
    if (n2 & 0xFF00FF00) {                                              \
137
        n3  = (n2 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
138
        n2 += 0x7F007F00;                                               \
139 140
        n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
        n2 &= n3 & 0x00FF00FF;                                          \
141 142
    }

143 144 145 146 147 148 149 150 151
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)                               \
    codebook = (const uint32_t *)cbook[level];                          \
    if (stages > 0)                                                     \
        bit_cache = get_bits(bitbuf, 4 * stages);                       \
    /* calculate codebook entries for this vector */                    \
    for (j = 0; j < stages; j++) {                                      \
        entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) +   \
                      16 * j) << (level + 1);                           \
    }                                                                   \
152
    mean -= stages * 128;                                               \
153
    n4    = (mean << 16) + mean;
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188

static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
                                   int pitch)
{
    uint32_t bit_cache;
    uint8_t *list[63];
    uint32_t *dst;
    const uint32_t *codebook;
    int entries[6];
    int i, j, m, n;
    int mean, stages;
    unsigned x, y, width, height, level;
    uint32_t n1, n2, n3, n4;

    /* initialize list for breadth first processing of vectors */
    list[0] = pixels;

    /* recursively process vector */
    for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
        SVQ1_PROCESS_VECTOR();

        /* destination address and vector size */
        dst    = (uint32_t *)list[i];
        width  = 1 << ((4 + level) / 2);
        height = 1 << ((3 + level) / 2);

        /* get number of stages (-1 skips vector, 0 for mean only) */
        stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;

        if (stages == -1) {
            for (y = 0; y < height; y++)
                memset(&dst[y * (pitch / 4)], 0, width);
            continue;   /* skip vector */
        }

189
        if (stages > 0 && level >= 4) {
190 191 192
            av_dlog(NULL,
                    "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
                    stages, level);
193
            return AVERROR_INVALIDDATA;  /* invalid vector */
194 195 196 197 198 199 200 201 202
        }

        mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);

        if (stages == 0) {
            for (y = 0; y < height; y++)
                memset(&dst[y * (pitch / 4)], mean, width);
        } else {
            SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
203 204 205 206 207 208 209 210 211 212 213

            for (y = 0; y < height; y++) {
                for (x = 0; x < width / 4; x++, codebook++) {
                    n1 = n4;
                    n2 = n4;
                    SVQ1_ADD_CODEBOOK()
                    /* store result */
                    dst[x] = n1 << 8 | n2;
                }
                dst += pitch / 4;
            }
214
        }
215 216
    }

217
    return 0;
218 219
}

220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
                                       int pitch)
{
    uint32_t bit_cache;
    uint8_t *list[63];
    uint32_t *dst;
    const uint32_t *codebook;
    int entries[6];
    int i, j, m, n;
    int mean, stages;
    int x, y, width, height, level;
    uint32_t n1, n2, n3, n4;

    /* initialize list for breadth first processing of vectors */
    list[0] = pixels;

    /* recursively process vector */
    for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
        SVQ1_PROCESS_VECTOR();

        /* destination address and vector size */
        dst    = (uint32_t *)list[i];
        width  = 1 << ((4 + level) / 2);
        height = 1 << ((3 + level) / 2);

        /* get number of stages (-1 skips vector, 0 for mean only) */
        stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;

        if (stages == -1)
            continue;           /* skip vector */

        if ((stages > 0) && (level >= 4)) {
            av_dlog(NULL,
                    "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
                    stages, level);
255
            return AVERROR_INVALIDDATA;  /* invalid vector */
256
        }
257

258
        mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
259

260
        SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
261 262 263 264 265 266 267 268 269 270 271 272 273

        for (y = 0; y < height; y++) {
            for (x = 0; x < width / 4; x++, codebook++) {
                n3 = dst[x];
                /* add mean value to vector */
                n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
                n2 = n4 +  (n3 & 0x00FF00FF);
                SVQ1_ADD_CODEBOOK()
                /* store result */
                dst[x] = n1 << 8 | n2;
            }
            dst += pitch / 4;
        }
274 275
    }
    return 0;
276 277
}

278 279 280 281 282
static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
                                     svq1_pmv **pmv)
{
    int diff;
    int i;
283

284 285 286 287
    for (i = 0; i < 2; i++) {
        /* get motion code */
        diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
        if (diff < 0)
288
            return AVERROR_INVALIDDATA;
289 290 291 292
        else if (diff) {
            if (get_bits1(bitbuf))
                diff = -diff;
        }
293

294 295 296 297 298
        /* add median of motion vector predictors and clip result */
        if (i == 1)
            mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
        else
            mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
299 300
    }

301
    return 0;
302 303
}

304 305 306 307 308 309
static void svq1_skip_block(uint8_t *current, uint8_t *previous,
                            int pitch, int x, int y)
{
    uint8_t *src;
    uint8_t *dst;
    int i;
310

311 312
    src = &previous[x + y * pitch];
    dst = current;
313

314 315 316 317 318
    for (i = 0; i < 16; i++) {
        memcpy(dst, src, 16);
        src += pitch;
        dst += pitch;
    }
319 320
}

321
static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
322
                                   uint8_t *current, uint8_t *previous,
323 324
                                   int pitch, svq1_pmv *motion, int x, int y,
                                   int width, int height)
325 326 327 328 329 330 331 332 333 334 335 336 337
{
    uint8_t *src;
    uint8_t *dst;
    svq1_pmv mv;
    svq1_pmv *pmv[3];
    int result;

    /* predict and decode motion vector */
    pmv[0] = &motion[0];
    if (y == 0) {
        pmv[1] =
        pmv[2] = pmv[0];
    } else {
338 339
        pmv[1] = &motion[x / 8 + 2];
        pmv[2] = &motion[x / 8 + 4];
340
    }
341

342
    result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
343
    if (result)
344
        return result;
345

346 347 348 349 350 351
    motion[0].x         =
    motion[x / 8 + 2].x =
    motion[x / 8 + 3].x = mv.x;
    motion[0].y         =
    motion[x / 8 + 2].y =
    motion[x / 8 + 3].y = mv.y;
352

353 354
    mv.x = av_clip(mv.x, -2 * x, 2 * (width  - x - 16));
    mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
355

356 357
    src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
    dst = current;
358

359
    hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
360

361
    return 0;
362 363
}

364
static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
365
                                      uint8_t *current, uint8_t *previous,
366 367
                                      int pitch, svq1_pmv *motion, int x, int y,
                                      int width, int height)
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
{
    uint8_t *src;
    uint8_t *dst;
    svq1_pmv mv;
    svq1_pmv *pmv[4];
    int i, result;

    /* predict and decode motion vector (0) */
    pmv[0] = &motion[0];
    if (y == 0) {
        pmv[1] =
        pmv[2] = pmv[0];
    } else {
        pmv[1] = &motion[(x / 8) + 2];
        pmv[2] = &motion[(x / 8) + 4];
    }
384

385
    result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
386
    if (result)
387
        return result;
388

389 390 391 392 393 394 395 396 397
    /* predict and decode motion vector (1) */
    pmv[0] = &mv;
    if (y == 0) {
        pmv[1] =
        pmv[2] = pmv[0];
    } else {
        pmv[1] = &motion[(x / 8) + 3];
    }
    result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
398
    if (result)
399
        return result;
400

401 402 403
    /* predict and decode motion vector (2) */
    pmv[1] = &motion[0];
    pmv[2] = &motion[(x / 8) + 1];
404

405
    result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
406
    if (result)
407
        return result;
408

409 410 411
    /* predict and decode motion vector (3) */
    pmv[2] = &motion[(x / 8) + 2];
    pmv[3] = &motion[(x / 8) + 3];
412

413
    result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
414
    if (result)
415
        return result;
416

417 418 419 420
    /* form predictions */
    for (i = 0; i < 4; i++) {
        int mvx = pmv[i]->x + (i  & 1) * 16;
        int mvy = pmv[i]->y + (i >> 1) * 16;
421

422
        // FIXME: clipping or padding?
423 424
        mvx = av_clip(mvx, -2 * x, 2 * (width  - x - 8));
        mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
425

426 427
        src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
        dst = current;
428

429
        hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
430

431 432 433 434 435
        /* select next block */
        if (i & 1)
            current += 8 * (pitch - 1);
        else
            current += 8;
436 437
    }

438
    return 0;
439 440
}

441
static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
442
                                   GetBitContext *bitbuf,
443
                                   uint8_t *current, uint8_t *previous,
444 445
                                   int pitch, svq1_pmv *motion, int x, int y,
                                   int width, int height)
446 447 448 449 450 451 452 453 454
{
    uint32_t block_type;
    int result = 0;

    /* get block type */
    block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);

    /* reset motion vectors */
    if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
455 456 457 458 459 460
        motion[0].x         =
        motion[0].y         =
        motion[x / 8 + 2].x =
        motion[x / 8 + 2].y =
        motion[x / 8 + 3].x =
        motion[x / 8 + 3].y = 0;
461 462
    }

463 464 465 466
    switch (block_type) {
    case SVQ1_BLOCK_SKIP:
        svq1_skip_block(current, previous, pitch, x, y);
        break;
467

468
    case SVQ1_BLOCK_INTER:
469
        result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
470
                                         pitch, motion, x, y, width, height);
471

472
        if (result != 0) {
473
            av_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
474 475 476 477
            break;
        }
        result = svq1_decode_block_non_intra(bitbuf, current, pitch);
        break;
478

479
    case SVQ1_BLOCK_INTER_4V:
480
        result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
481
                                            pitch, motion, x, y, width, height);
482

483
        if (result != 0) {
484
            av_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
485 486 487 488
            break;
        }
        result = svq1_decode_block_non_intra(bitbuf, current, pitch);
        break;
489

490 491 492
    case SVQ1_BLOCK_INTRA:
        result = svq1_decode_block_intra(bitbuf, current, pitch);
        break;
493 494
    }

495
    return result;
496 497
}

498 499 500 501
static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
{
    uint8_t seed;
    int i;
502

503 504
    out[0] = get_bits(bitbuf, 8);
    seed   = string_table[out[0]];
505

506 507 508 509
    for (i = 1; i <= out[0]; i++) {
        out[i] = get_bits(bitbuf, 8) ^ seed;
        seed   = string_table[out[i] ^ seed];
    }
510 511
}

512
static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
513
{
514 515
    SVQ1Context *s = avctx->priv_data;
    GetBitContext *bitbuf = &s->gb;
516
    int frame_size_code;
517 518
    int width  = s->width;
    int height = s->height;
519

520
    skip_bits(bitbuf, 8); /* temporal_reference */
521

522
    /* frame type */
523 524 525 526 527 528 529 530 531 532 533 534
    s->nonref = 0;
    switch (get_bits(bitbuf, 2)) {
    case 0:
        frame->pict_type = AV_PICTURE_TYPE_I;
        break;
    case 2:
        s->nonref = 1;
    case 1:
        frame->pict_type = AV_PICTURE_TYPE_P;
        break;
    default:
        av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
535
        return AVERROR_INVALIDDATA;
536
    }
537

538
    if (frame->pict_type == AV_PICTURE_TYPE_I) {
539
        /* unknown fields */
540
        if (s->frame_code == 0x50 || s->frame_code == 0x60) {
541
            int csum = get_bits(bitbuf, 16);
542

543 544 545
            csum = ff_svq1_packet_checksum(bitbuf->buffer,
                                           bitbuf->size_in_bits >> 3,
                                           csum);
546

547
            av_dlog(avctx, "%s checksum (%02x) for packet data\n",
548 549
                    (csum == 0) ? "correct" : "incorrect", csum);
        }
550

551
        if ((s->frame_code ^ 0x10) >= 0x50) {
552
            uint8_t msg[256];
553

554
            svq1_parse_string(bitbuf, msg);
555

556
            av_log(avctx, AV_LOG_INFO,
557
                   "embedded message:\n%s\n", (char *)msg);
558
        }
559

560 561 562
        skip_bits(bitbuf, 2);
        skip_bits(bitbuf, 2);
        skip_bits1(bitbuf);
563

564 565
        /* load frame size */
        frame_size_code = get_bits(bitbuf, 3);
566

567 568
        if (frame_size_code == 7) {
            /* load width, height (12 bits each) */
569 570
            width  = get_bits(bitbuf, 12);
            height = get_bits(bitbuf, 12);
571

572
            if (!width || !height)
573
                return AVERROR_INVALIDDATA;
574 575
        } else {
            /* get width, height from table */
576 577
            width  = ff_svq1_frame_size_table[frame_size_code][0];
            height = ff_svq1_frame_size_table[frame_size_code][1];
578
        }
579 580
    }

581
    /* unknown fields */
582
    if (get_bits1(bitbuf)) {
583 584
        skip_bits1(bitbuf);    /* use packet checksum if (1) */
        skip_bits1(bitbuf);    /* component checksums after image data if (1) */
585

586
        if (get_bits(bitbuf, 2) != 0)
587
            return AVERROR_INVALIDDATA;
588
    }
589

590
    if (get_bits1(bitbuf)) {
591 592 593 594
        skip_bits1(bitbuf);
        skip_bits(bitbuf, 4);
        skip_bits1(bitbuf);
        skip_bits(bitbuf, 2);
595

596 597
        if (skip_1stop_8data_bits(bitbuf) < 0)
            return AVERROR_INVALIDDATA;
598 599
    }

600 601
    s->width  = width;
    s->height = height;
602
    return 0;
603 604
}

605
static int svq1_decode_frame(AVCodecContext *avctx, void *data,
606
                             int *got_frame, AVPacket *avpkt)
607
{
608 609
    const uint8_t *buf = avpkt->data;
    int buf_size       = avpkt->size;
610
    SVQ1Context     *s = avctx->priv_data;
611
    AVFrame       *cur = data;
612
    uint8_t *current;
613 614
    int result, i, x, y, width, height;
    svq1_pmv *pmv;
615

616
    /* initialize bit buffer */
617
    init_get_bits8(&s->gb, buf, buf_size);
618

619
    /* decode frame header */
620
    s->frame_code = get_bits(&s->gb, 22);
621

622
    if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
623
        return AVERROR_INVALIDDATA;
624

625
    /* swap some header bytes (why?) */
626
    if (s->frame_code != 0x20) {
627
        uint32_t *src = (uint32_t *)(buf + 4);
628

629 630
        if (buf_size < 36)
            return AVERROR_INVALIDDATA;
631

632 633
        for (i = 0; i < 4; i++)
            src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
634 635
    }

636
    result = svq1_decode_frame_header(avctx, cur);
637
    if (result != 0) {
638
        av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
639
        return result;
640
    }
641 642 643 644

    result = ff_set_dimensions(avctx, s->width, s->height);
    if (result < 0)
        return result;
645

646
    if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
647
        (avctx->skip_frame >= AVDISCARD_NONKEY &&
648
         cur->pict_type != AV_PICTURE_TYPE_I) ||
649 650 651
        avctx->skip_frame >= AVDISCARD_ALL)
        return buf_size;

652
    result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
653
    if (result < 0)
654
        return result;
655

656 657
    pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
    if (!pmv)
658
        return AVERROR(ENOMEM);
659

660 661
    /* decode y, u and v components */
    for (i = 0; i < 3; i++) {
662
        int linesize = cur->linesize[i];
663 664 665 666
        if (i == 0) {
            width    = FFALIGN(s->width,  16);
            height   = FFALIGN(s->height, 16);
        } else {
667
            if (avctx->flags & CODEC_FLAG_GRAY)
668 669 670
                break;
            width    = FFALIGN(s->width  / 4, 16);
            height   = FFALIGN(s->height / 4, 16);
671 672
        }

673
        current = cur->data[i];
674

675
        if (cur->pict_type == AV_PICTURE_TYPE_I) {
676 677 678 679 680
            /* keyframe */
            for (y = 0; y < height; y += 16) {
                for (x = 0; x < width; x += 16) {
                    result = svq1_decode_block_intra(&s->gb, &current[x],
                                                     linesize);
681
                    if (result) {
682
                        av_log(avctx, AV_LOG_ERROR,
683 684 685 686 687 688 689 690 691
                               "Error in svq1_decode_block %i (keyframe)\n",
                               result);
                        goto err;
                    }
                }
                current += 16 * linesize;
            }
        } else {
            /* delta frame */
692
            uint8_t *previous = s->prev->data[i];
693 694
            if (!previous ||
                s->prev->width != s->width || s->prev->height != s->height) {
695 696 697 698 699
                av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
                result = AVERROR_INVALIDDATA;
                goto err;
            }

700 701 702 703
            memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));

            for (y = 0; y < height; y += 16) {
                for (x = 0; x < width; x += 16) {
704
                    result = svq1_decode_delta_block(avctx, &s->hdsp,
705
                                                     &s->gb, &current[x],
706
                                                     previous, linesize,
707
                                                     pmv, x, y, width, height);
708
                    if (result != 0) {
709
                        av_dlog(avctx,
710 711 712 713 714 715 716 717 718 719 720 721
                                "Error in svq1_decode_delta_block %i\n",
                                result);
                        goto err;
                    }
                }

                pmv[0].x     =
                    pmv[0].y = 0;

                current += 16 * linesize;
            }
        }
722 723
    }

724 725 726 727 728 729
    if (!s->nonref) {
        av_frame_unref(s->prev);
        result = av_frame_ref(s->prev, cur);
        if (result < 0)
            goto err;
    }
730

731
    *got_frame = 1;
732
    result     = buf_size;
733

734
err:
735 736
    av_free(pmv);
    return result;
737 738
}

739
static av_cold int svq1_decode_init(AVCodecContext *avctx)
740
{
741
    SVQ1Context *s = avctx->priv_data;
742
    int i;
743
    int offset = 0;
744

745
    s->prev = av_frame_alloc();
746
    if (!s->prev)
747
        return AVERROR(ENOMEM);
748

749 750
    s->width            = avctx->width  + 3 & ~3;
    s->height           = avctx->height + 3 & ~3;
751
    avctx->pix_fmt      = AV_PIX_FMT_YUV410P;
752

753
    ff_hpeldsp_init(&s->hdsp, avctx->flags);
754

755
    INIT_VLC_STATIC(&svq1_block_type, 2, 4,
756 757
                    &ff_svq1_block_type_vlc[0][1], 2, 1,
                    &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
758

759
    INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
760 761
                    &ff_mvtab[0][1], 2, 1,
                    &ff_mvtab[0][0], 2, 1, 176);
762 763

    for (i = 0; i < 6; i++) {
764 765
        static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
                                             { 10, 10, 14, 14, 14, 16 } };
766
        static VLC_TYPE table[168][2];
767
        svq1_intra_multistage[i].table           = &table[offset];
768
        svq1_intra_multistage[i].table_allocated = sizes[0][i];
769
        offset                                  += sizes[0][i];
770
        init_vlc(&svq1_intra_multistage[i], 3, 8,
771 772 773 774
                 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
                 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
                 INIT_VLC_USE_NEW_STATIC);
        svq1_inter_multistage[i].table           = &table[offset];
775
        svq1_inter_multistage[i].table_allocated = sizes[1][i];
776
        offset                                  += sizes[1][i];
777
        init_vlc(&svq1_inter_multistage[i], 3, 8,
778 779 780
                 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
                 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
                 INIT_VLC_USE_NEW_STATIC);
781 782
    }

783
    INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
784 785
                    &ff_svq1_intra_mean_vlc[0][1], 4, 2,
                    &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
786

787
    INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
788 789
                    &ff_svq1_inter_mean_vlc[0][1], 4, 2,
                    &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
790 791 792 793

    return 0;
}

794
static av_cold int svq1_decode_end(AVCodecContext *avctx)
795
{
796 797
    SVQ1Context *s = avctx->priv_data;

798
    av_frame_free(&s->prev);
799 800 801 802

    return 0;
}

803 804 805 806
static void svq1_flush(AVCodecContext *avctx)
{
    SVQ1Context *s = avctx->priv_data;

807
    av_frame_unref(s->prev);
808 809
}

810
AVCodec ff_svq1_decoder = {
811
    .name           = "svq1",
812
    .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
813
    .type           = AVMEDIA_TYPE_VIDEO,
814
    .id             = AV_CODEC_ID_SVQ1,
815
    .priv_data_size = sizeof(SVQ1Context),
816 817 818 819
    .init           = svq1_decode_init,
    .close          = svq1_decode_end,
    .decode         = svq1_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
820
    .flush          = svq1_flush,
821 822
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
                                                     AV_PIX_FMT_NONE },
823
};