svq1dec.c 26.5 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 "hpeldsp.h"
38
#include "internal.h"
39
#include "mathops.h"
40 41 42 43 44
#include "svq1.h"

#undef NDEBUG
#include <assert.h>

45
extern const uint8_t ff_mvtab[33][2];
46 47 48 49 50 51 52 53 54 55

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 {
56 57
    int x;
    int y;
58
} svq1_pmv;
59

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

70
static const uint8_t string_table[256] = {
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 102
    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
103 104
};

105 106 107 108 109 110 111 112 113
#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 */                              \
114
        if (!get_bits1(bitbuf))                                         \
115 116 117
            break;                                                      \
        /* add child nodes */                                           \
        list[n++] = list[i];                                            \
118
        list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
119 120
    }

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

144 145 146 147 148 149 150 151 152
#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);                           \
    }                                                                   \
153
    mean -= stages * 128;                                               \
154
    n4    = (mean << 16) + mean;
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 189

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 */
        }

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

        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);
204 205 206 207 208 209 210 211 212 213 214

            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;
            }
215
        }
216 217
    }

218
    return 0;
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 255
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);
256
            return AVERROR_INVALIDDATA;  /* invalid vector */
257
        }
258

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

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

        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;
        }
275 276
    }
    return 0;
277 278
}

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

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

295 296 297 298 299
        /* 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);
300 301
    }

302
    return 0;
303 304
}

305 306 307 308 309 310
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;
311

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

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

322
static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
323
                                   uint8_t *current, uint8_t *previous,
324 325
                                   int pitch, svq1_pmv *motion, int x, int y,
                                   int width, int height)
326 327 328 329 330 331 332 333 334 335 336 337 338
{
    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 {
339 340
        pmv[1] = &motion[x / 8 + 2];
        pmv[2] = &motion[x / 8 + 4];
341
    }
342

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

347 348 349 350 351 352
    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;
353

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

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

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

362
    return 0;
363 364
}

365
static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
366
                                      uint8_t *current, uint8_t *previous,
367 368
                                      int pitch, svq1_pmv *motion, int x, int y,
                                      int width, int height)
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
{
    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];
    }
385

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

390 391 392 393 394 395 396 397 398
    /* 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);
399
    if (result)
400
        return result;
401

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

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

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

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

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

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

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

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

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

439
    return 0;
440 441
}

442
static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
443
                                   GetBitContext *bitbuf,
444
                                   uint8_t *current, uint8_t *previous,
445 446
                                   int pitch, svq1_pmv *motion, int x, int y,
                                   int width, int height)
447 448 449 450 451 452 453 454 455
{
    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) {
456 457 458 459 460 461
        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;
462 463
    }

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

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

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

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

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

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

496
    return result;
497 498
}

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

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

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

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

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

523
    /* frame type */
524 525 526 527 528 529 530 531 532 533 534 535
    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");
536
        return AVERROR_INVALIDDATA;
537
    }
538

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

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

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

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

555
            svq1_parse_string(bitbuf, msg);
556

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

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

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

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

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

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

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

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

597
        while (get_bits1(bitbuf))
598
            skip_bits(bitbuf, 8);
599 600
    }

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

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

617 618
    /* initialize bit buffer */
    init_get_bits(&s->gb, buf, buf_size * 8);
619

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

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

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

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

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

637
    result = svq1_decode_frame_header(avctx, cur);
638
    if (result != 0) {
639
        av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
640
        return result;
641
    }
642 643
    avcodec_set_dimensions(avctx, s->width, s->height);

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

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

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

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

671
        current = cur->data[i];
672

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

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

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

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

                current += 16 * linesize;
            }
        }
720 721
    }

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

729
    *got_frame = 1;
730
    result     = buf_size;
731

732
err:
733 734
    av_free(pmv);
    return result;
735 736
}

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

743
    s->prev = avcodec_alloc_frame();
744
    if (!s->prev)
745
        return AVERROR(ENOMEM);
746

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

751
    ff_hpeldsp_init(&s->hdsp, avctx->flags);
752

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

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

    for (i = 0; i < 6; i++) {
762 763
        static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
                                             { 10, 10, 14, 14, 14, 16 } };
764
        static VLC_TYPE table[168][2];
765
        svq1_intra_multistage[i].table           = &table[offset];
766
        svq1_intra_multistage[i].table_allocated = sizes[0][i];
767
        offset                                  += sizes[0][i];
768
        init_vlc(&svq1_intra_multistage[i], 3, 8,
769 770 771 772
                 &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];
773
        svq1_inter_multistage[i].table_allocated = sizes[1][i];
774
        offset                                  += sizes[1][i];
775
        init_vlc(&svq1_inter_multistage[i], 3, 8,
776 777 778
                 &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);
779 780
    }

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

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

    return 0;
}

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

796
    av_frame_free(&s->prev);
797 798 799 800

    return 0;
}

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

805
    av_frame_unref(s->prev);
806 807
}

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