ffv1dec.c 32.5 KB
Newer Older
1 2 3
/*
 * FFV1 decoder
 *
4
 * Copyright (c) 2003-2012 Michael Niedermayer <michaelni@gmx.at>
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 *
 * This file is part of Libav.
 *
 * Libav 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.
 *
 * Libav 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 Libav; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * FF Video Codec 1 (a lossless codec) decoder
 */

#include "libavutil/avassert.h"
29 30 31 32
#include "libavutil/pixdesc.h"
#include "libavutil/crc.h"
#include "libavutil/opt.h"
#include "libavutil/imgutils.h"
33
#include "libavutil/timer.h"
34
#include "avcodec.h"
35
#include "internal.h"
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
#include "get_bits.h"
#include "put_bits.h"
#include "rangecoder.h"
#include "golomb.h"
#include "mathops.h"
#include "ffv1.h"

static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state,
                                               int is_signed)
{
    if (get_rac(c, state + 0))
        return 0;
    else {
        int i, e, a;
        e = 0;
        while (get_rac(c, state + 1 + FFMIN(e, 9))) // 1..10
            e++;

        a = 1;
        for (i = e - 1; i >= 0; i--)
            a += a + get_rac(c, state + 22 + FFMIN(i, 9));  // 22..31

        e = -(is_signed && get_rac(c, state + 11 + FFMIN(e, 10))); // 11..21
        return (a ^ e) - e;
    }
}

static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
{
    return get_symbol_inline(c, state, is_signed);
}

static inline int get_vlc_symbol(GetBitContext *gb, VlcState *const state,
                                 int bits)
{
    int k, i, v, ret;

    i = state->count;
    k = 0;
    while (i < state->error_sum) { // FIXME: optimize
        k++;
        i += i;
    }

    assert(k <= 8);

    v = get_sr_golomb(gb, k, 12, bits);
83
    ff_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
            v, state->bias, state->error_sum, state->drift, state->count, k);

    v ^= ((2 * state->drift + state->count) >> 31);

    ret = fold(v + state->bias, bits);

    update_vlc_state(state, v);

    return ret;
}

static av_always_inline void decode_line(FFV1Context *s, int w,
                                         int16_t *sample[2],
                                         int plane_index, int bits)
{
    PlaneContext *const p = &s->plane[plane_index];
    RangeCoder *const c   = &s->c;
    int x;
    int run_count = 0;
    int run_mode  = 0;
    int run_index = s->run_index;

    for (x = 0; x < w; x++) {
        int diff, context, sign;

        context = get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
        if (context < 0) {
            context = -context;
            sign    = 1;
        } else
            sign = 0;

        av_assert2(context < p->context_count);

118
        if (s->ac != AC_GOLOMB_RICE) {
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
            diff = get_symbol_inline(c, p->state[context], 1);
        } else {
            if (context == 0 && run_mode == 0)
                run_mode = 1;

            if (run_mode) {
                if (run_count == 0 && run_mode == 1) {
                    if (get_bits1(&s->gb)) {
                        run_count = 1 << ff_log2_run[run_index];
                        if (x + run_count <= w)
                            run_index++;
                    } else {
                        if (ff_log2_run[run_index])
                            run_count = get_bits(&s->gb, ff_log2_run[run_index]);
                        else
                            run_count = 0;
                        if (run_index)
                            run_index--;
                        run_mode = 2;
                    }
                }
                run_count--;
                if (run_count < 0) {
                    run_mode  = 0;
                    run_count = 0;
                    diff      = get_vlc_symbol(&s->gb, &p->vlc_state[context],
                                               bits);
                    if (diff >= 0)
                        diff++;
                } else
                    diff = 0;
            } else
                diff = get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);

153
            ff_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
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 189 190 191 192 193 194
                    run_count, run_index, run_mode, x, get_bits_count(&s->gb));
        }

        if (sign)
            diff = -diff;

        sample[1][x] = (predict(sample[1] + x, sample[0] + x) + diff) &
                       ((1 << bits) - 1);
    }
    s->run_index = run_index;
}

static void decode_plane(FFV1Context *s, uint8_t *src,
                         int w, int h, int stride, int plane_index)
{
    int x, y;
    int16_t *sample[2];
    sample[0] = s->sample_buffer + 3;
    sample[1] = s->sample_buffer + w + 6 + 3;

    s->run_index = 0;

    memset(s->sample_buffer, 0, 2 * (w + 6) * sizeof(*s->sample_buffer));

    for (y = 0; y < h; y++) {
        int16_t *temp = sample[0]; // FIXME: try a normal buffer

        sample[0] = sample[1];
        sample[1] = temp;

        sample[1][-1] = sample[0][0];
        sample[0][w]  = sample[0][w - 1];

// { START_TIMER
        if (s->avctx->bits_per_raw_sample <= 8) {
            decode_line(s, w, sample, plane_index, 8);
            for (x = 0; x < w; x++)
                src[x + stride * y] = sample[1][x];
        } else {
            decode_line(s, w, sample, plane_index,
                        s->avctx->bits_per_raw_sample);
195 196 197 198 199 200 201
            if (s->packed_at_lsb) {
                for (x = 0; x < w; x++)
                    ((uint16_t *)(src + stride * y))[x] = sample[1][x];
            } else {
                for (x = 0; x < w; x++)
                    ((uint16_t *)(src + stride * y))[x] = sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
            }
202 203 204 205 206
        }
// STOP_TIMER("decode-line") }
    }
}

207 208
static void decode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h,
                             int stride[3])
209 210
{
    int x, y, p;
211 212 213 214 215 216 217 218
    int16_t *sample[4][2];
    int lbd  = s->avctx->bits_per_raw_sample <= 8;
    int bits = s->avctx->bits_per_raw_sample > 0
               ? s->avctx->bits_per_raw_sample
               : 8;
    int offset = 1 << bits;

    for (x = 0; x < 4; x++) {
219 220 221 222 223 224
        sample[x][0] = s->sample_buffer +  x * 2      * (w + 6) + 3;
        sample[x][1] = s->sample_buffer + (x * 2 + 1) * (w + 6) + 3;
    }

    s->run_index = 0;

225
    memset(s->sample_buffer, 0, 8 * (w + 6) * sizeof(*s->sample_buffer));
226 227

    for (y = 0; y < h; y++) {
228 229
        for (p = 0; p < 3 + s->transparency; p++) {
            int16_t *temp = sample[p][0]; //FIXME try a normal buffer
230 231 232 233 234 235

            sample[p][0] = sample[p][1];
            sample[p][1] = temp;

            sample[p][1][-1] = sample[p][0][0];
            sample[p][0][w]  = sample[p][0][w - 1];
236 237 238 239
            if (lbd)
                decode_line(s, w, sample[p], (p + 1) / 2, 9);
            else
                decode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
240 241 242 243 244
        }
        for (x = 0; x < w; x++) {
            int g = sample[0][1][x];
            int b = sample[1][1][x];
            int r = sample[2][1][x];
245
            int a = sample[3][1][x];
246

247 248
            b -= offset;
            r -= offset;
249 250 251 252
            g -= (b + r) >> 2;
            b += g;
            r += g;

253 254 255 256 257 258 259 260
            if (lbd)
                *((uint32_t *)(src[0] + x * 4 + stride[0] * y)) = b +
                    (g << 8) + (r << 16) + (a << 24);
            else {
                *((uint16_t *)(src[0] + x * 2 + stride[0] * y)) = b;
                *((uint16_t *)(src[1] + x * 2 + stride[1] * y)) = g;
                *((uint16_t *)(src[2] + x * 2 + stride[2] * y)) = r;
            }
261 262 263 264
        }
    }
}

265 266 267 268 269 270 271
static int decode_slice_header(FFV1Context *f, FFV1Context *fs)
{
    RangeCoder *c = &fs->c;
    uint8_t state[CONTEXT_SIZE];
    unsigned ps, i, context_count;
    memset(state, 128, sizeof(state));

272
    if (fs->ac == AC_RANGE_CUSTOM_TAB) {
273 274 275 276 277
        for (i = 1; i < 256; i++) {
            fs->c.one_state[i]        = f->state_transition[i];
            fs->c.zero_state[256 - i] = 256 - fs->c.one_state[i];
        }
    }
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314

    fs->slice_x      = get_symbol(c, state, 0) * f->width;
    fs->slice_y      = get_symbol(c, state, 0) * f->height;
    fs->slice_width  = (get_symbol(c, state, 0) + 1) * f->width + fs->slice_x;
    fs->slice_height = (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y;

    fs->slice_x     /= f->num_h_slices;
    fs->slice_y     /= f->num_v_slices;
    fs->slice_width  = fs->slice_width / f->num_h_slices - fs->slice_x;
    fs->slice_height = fs->slice_height / f->num_v_slices - fs->slice_y;
    if ((unsigned)fs->slice_width  > f->width ||
        (unsigned)fs->slice_height > f->height)
        return AVERROR_INVALIDDATA;
    if ((unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width ||
        (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
        return AVERROR_INVALIDDATA;

    for (i = 0; i < f->plane_count; i++) {
        PlaneContext *const p = &fs->plane[i];
        int idx               = get_symbol(c, state, 0);
        if (idx > (unsigned)f->quant_table_count) {
            av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
            return AVERROR_INVALIDDATA;
        }
        p->quant_table_index = idx;
        memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
        context_count = f->context_count[idx];

        if (p->context_count < context_count) {
            av_freep(&p->state);
            av_freep(&p->vlc_state);
        }
        p->context_count = context_count;
    }

    ps = get_symbol(c, state, 0);
    if (ps == 1) {
315 316
        f->cur->interlaced_frame = 1;
        f->cur->top_field_first  = 1;
317
    } else if (ps == 2) {
318 319
        f->cur->interlaced_frame = 1;
        f->cur->top_field_first  = 0;
320
    } else if (ps == 3) {
321
        f->cur->interlaced_frame = 0;
322
    }
323 324
    f->cur->sample_aspect_ratio.num = get_symbol(c, state, 0);
    f->cur->sample_aspect_ratio.den = get_symbol(c, state, 0);
325

326 327 328 329 330 331 332 333
    if (av_image_check_sar(f->width, f->height,
                           f->cur->sample_aspect_ratio) < 0) {
        av_log(f->avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
               f->cur->sample_aspect_ratio.num,
               f->cur->sample_aspect_ratio.den);
        f->cur->sample_aspect_ratio = (AVRational){ 0, 1 };
    }

334 335 336
    return 0;
}

337 338
static int decode_slice(AVCodecContext *c, void *arg)
{
339 340 341
    FFV1Context *fs = *(void **)arg;
    FFV1Context *f  = fs->avctx->priv_data;
    int width, height, x, y, ret;
342
    const int ps = (av_pix_fmt_desc_get(c->pix_fmt)->flags & AV_PIX_FMT_FLAG_PLANAR)
343 344
                   ? (c->bits_per_raw_sample > 8) + 1
                   : 4;
345
    AVFrame *const p = f->cur;
346

347 348 349 350 351 352 353 354
    if (f->version > 2) {
        if (decode_slice_header(f, fs) < 0) {
            fs->slice_damaged = 1;
            return AVERROR_INVALIDDATA;
        }
    }
    if ((ret = ffv1_init_slice_state(f, fs)) < 0)
        return ret;
355
    if (f->cur->key_frame)
356 357 358 359 360 361
        ffv1_clear_slice_state(f, fs);
    width  = fs->slice_width;
    height = fs->slice_height;
    x      = fs->slice_x;
    y      = fs->slice_y;

362
    if (fs->ac == AC_GOLOMB_RICE) {
363 364 365 366 367 368 369 370
        if (f->version == 3 && f->minor_version > 1 || f->version > 3)
            get_rac(&fs->c, (uint8_t[]) { 129 });
        fs->ac_byte_count = f->version > 2 || (!x && !y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
        init_get_bits(&fs->gb, fs->c.bytestream_start + fs->ac_byte_count,
                      (fs->c.bytestream_end - fs->c.bytestream_start -
                       fs->ac_byte_count) * 8);
    }

371 372
    av_assert1(width && height);
    if (f->colorspace == 0) {
373 374
        const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
        const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
375 376
        const int cx            = x >> f->chroma_h_shift;
        const int cy            = y >> f->chroma_v_shift;
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
        decode_plane(fs, p->data[0] + ps * x + y * p->linesize[0], width,
                     height, p->linesize[0],
                     0);

        if (f->chroma_planes) {
            decode_plane(fs, p->data[1] + ps * cx + cy * p->linesize[1],
                         chroma_width, chroma_height, p->linesize[1],
                         1);
            decode_plane(fs, p->data[2] + ps * cx + cy * p->linesize[2],
                         chroma_width, chroma_height, p->linesize[2],
                         1);
        }
        if (fs->transparency)
            decode_plane(fs, p->data[3] + ps * x + y * p->linesize[3], width,
                         height, p->linesize[3],
                         2);
393
    } else {
394 395 396 397 398
        uint8_t *planes[3] = { p->data[0] + ps * x + y * p->linesize[0],
                               p->data[1] + ps * x + y * p->linesize[1],
                               p->data[2] + ps * x + y * p->linesize[2] };
        decode_rgb_frame(fs, planes, width, height, p->linesize);
    }
399
    if (fs->ac != AC_GOLOMB_RICE && f->version > 2) {
400 401 402 403 404 405 406 407
        int v;
        get_rac(&fs->c, (uint8_t[]) { 129 });
        v = fs->c.bytestream_end - fs->c.bytestream - 2 - 5 * f->ec;
        if (v) {
            av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n",
                   v);
            fs->slice_damaged = 1;
        }
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
    }

    emms_c();

    return 0;
}

static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
{
    int v;
    int i = 0;
    uint8_t state[CONTEXT_SIZE];

    memset(state, 128, sizeof(state));

    for (v = 0; i < 128; v++) {
424
        unsigned len = get_symbol(c, state, 0) + 1;
425

426 427
        if (len > 128 - i)
            return -1;
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450

        while (len--) {
            quant_table[i] = scale * v;
            i++;
        }
    }

    for (i = 1; i < 128; i++)
        quant_table[256 - i] = -quant_table[i];
    quant_table[128] = -quant_table[127];

    return 2 * v - 1;
}

static int read_quant_tables(RangeCoder *c,
                             int16_t quant_table[MAX_CONTEXT_INPUTS][256])
{
    int i;
    int context_count = 1;

    for (i = 0; i < 5; i++) {
        context_count *= read_quant_table(c, quant_table[i], context_count);
        if (context_count > 32768U) {
451
            return -1;
452 453 454 455 456 457 458 459 460
        }
    }
    return (context_count + 1) / 2;
}

static int read_extra_header(FFV1Context *f)
{
    RangeCoder *const c = &f->c;
    uint8_t state[CONTEXT_SIZE];
461
    int i, j, k, ret;
462 463 464 465 466 467 468 469 470
    uint8_t state2[32][CONTEXT_SIZE];

    memset(state2, 128, sizeof(state2));
    memset(state, 128, sizeof(state));

    ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);

    f->version = get_symbol(c, state, 0);
471 472 473 474
    if (f->version > 2) {
        c->bytestream_end -= 4;
        f->minor_version   = get_symbol(c, state, 0);
    }
475
    f->ac = get_symbol(c, state, 0);
476

477
    if (f->ac == AC_RANGE_CUSTOM_TAB) {
478 479
        for (i = 1; i < 256; i++)
            f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
480 481 482
    }

    f->colorspace                 = get_symbol(c, state, 0); //YUV cs type
483
    f->avctx->bits_per_raw_sample = get_symbol(c, state, 0);
484 485 486 487 488 489 490
    f->chroma_planes              = get_rac(c, state);
    f->chroma_h_shift             = get_symbol(c, state, 0);
    f->chroma_v_shift             = get_symbol(c, state, 0);
    f->transparency               = get_rac(c, state);
    f->plane_count                = 2 + f->transparency;
    f->num_h_slices               = 1 + get_symbol(c, state, 0);
    f->num_v_slices               = 1 + get_symbol(c, state, 0);
491 492 493 494

    if (f->num_h_slices > (unsigned)f->width ||
        f->num_v_slices > (unsigned)f->height) {
        av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
Luca Barbato's avatar
Luca Barbato committed
495
        return AVERROR_INVALIDDATA;
496 497 498 499
    }

    f->quant_table_count = get_symbol(c, state, 0);
    if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
Luca Barbato's avatar
Luca Barbato committed
500
        return AVERROR_INVALIDDATA;
501 502 503 504
    for (i = 0; i < f->quant_table_count; i++) {
        f->context_count[i] = read_quant_tables(c, f->quant_tables[i]);
        if (f->context_count[i] < 0) {
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
505
            return AVERROR_INVALIDDATA;
506 507
        }
    }
508 509
    if ((ret = ffv1_allocate_initial_states(f)) < 0)
        return ret;
510 511

    for (i = 0; i < f->quant_table_count; i++)
512
        if (get_rac(c, state)) {
513 514 515 516 517 518
            for (j = 0; j < f->context_count[i]; j++)
                for (k = 0; k < CONTEXT_SIZE; k++) {
                    int pred = j ? f->initial_states[i][j - 1][k] : 128;
                    f->initial_states[i][j][k] =
                        (pred + get_symbol(c, state2[k], 1)) & 0xFF;
                }
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
        }

    if (f->version > 2) {
        f->ec = get_symbol(c, state, 0);
    }

    if (f->version > 2) {
        unsigned v;
        v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0,
                   f->avctx->extradata, f->avctx->extradata_size);
        if (v) {
            av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
            return AVERROR_INVALIDDATA;
        }
    }

535 536 537 538 539 540 541
    av_log(f->avctx, AV_LOG_VERBOSE,
           "FFV1 version %d.%d colorspace %d - %d bits - %d/%d planes, %s transparent - tile geometry %dx%d - %s\n",
           f->version, f->minor_version, f->colorspace, f->avctx->bits_per_raw_sample,
           f->plane_count, f->chroma_planes, f->transparency ? "" : "not",
           f->num_h_slices, f->num_v_slices,
           f->ec ? "per-slice crc" : "no crc");

542 543 544
    return 0;
}

545

546 547 548
static int read_header(FFV1Context *f)
{
    uint8_t state[CONTEXT_SIZE];
549
    int i, j, context_count = -1;
550 551 552 553 554
    RangeCoder *const c = &f->slice_context[0]->c;

    memset(state, 128, sizeof(state));

    if (f->version < 2) {
555
        int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample;
556 557 558 559 560 561 562 563
        unsigned v = get_symbol(c, state, 0);
        if (v > 1) {
            av_log(f->avctx, AV_LOG_ERROR,
                   "invalid version %d in version 1 header\n", v);
            return AVERROR_INVALIDDATA;
        }
        f->version = v;

564
        f->ac = get_symbol(c, state, 0);
565

566
        if (f->ac == AC_RANGE_CUSTOM_TAB) {
567
            for (i = 1; i < 256; i++)
568 569 570 571
                f->state_transition[i] =
                    get_symbol(c, state, 1) + c->one_state[i];
        }

572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
        colorspace          = get_symbol(c, state, 0); //YUV cs type
        bits_per_raw_sample = f->version > 0 ? get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
        chroma_planes       = get_rac(c, state);
        chroma_h_shift      = get_symbol(c, state, 0);
        chroma_v_shift      = get_symbol(c, state, 0);
        transparency        = get_rac(c, state);

        if (f->plane_count) {
            if (colorspace          != f->colorspace                 ||
                bits_per_raw_sample != f->avctx->bits_per_raw_sample ||
                chroma_planes       != f->chroma_planes              ||
                chroma_h_shift      != f->chroma_h_shift             ||
                chroma_v_shift      != f->chroma_v_shift             ||
                transparency        != f->transparency) {
                av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
                return AVERROR_INVALIDDATA;
            }
        }
590

591 592 593 594 595 596
        f->colorspace                 = colorspace;
        f->avctx->bits_per_raw_sample = bits_per_raw_sample;
        f->chroma_planes              = chroma_planes;
        f->chroma_h_shift             = chroma_h_shift;
        f->chroma_v_shift             = chroma_v_shift;
        f->transparency               = transparency;
597 598

        f->plane_count    = 2 + f->transparency;
599 600 601
    }

    if (f->colorspace == 0) {
602 603 604 605 606 607
        if (f->transparency && f->avctx->bits_per_raw_sample > 8) {
            av_log(f->avctx, AV_LOG_ERROR,
                   "Transparency not supported for bit depth %d\n",
                   f->avctx->bits_per_raw_sample);
            return AVERROR(ENOSYS);
        }
608 609 610 611 612 613
        if (!f->transparency && !f->chroma_planes) {
            if (f->avctx->bits_per_raw_sample <= 8)
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
            else
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
        } else if (f->avctx->bits_per_raw_sample <= 8 && !f->transparency) {
614 615 616 617
            switch (16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV444P;
                break;
618 619 620
            case 0x01:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV440P;
                break;
621 622 623 624 625 626 627 628 629 630 631 632 633 634
            case 0x10:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV422P;
                break;
            case 0x11:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV420P;
                break;
            case 0x20:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV411P;
                break;
            case 0x22:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV410P;
                break;
            default:
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
Luca Barbato's avatar
Luca Barbato committed
635
                return AVERROR(ENOSYS);
636
            }
637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683
        } else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency) {
            switch (16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00:
                f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
                break;
            case 0x10:
                f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
                break;
            case 0x11:
                f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
                break;
            default:
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
                return AVERROR(ENOSYS);
            }
        } else if (f->avctx->bits_per_raw_sample == 9) {
            f->packed_at_lsb = 1;
            switch (16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV444P9;
                break;
            case 0x10:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV422P9;
                break;
            case 0x11:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV420P9;
                break;
            default:
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
                return AVERROR(ENOSYS);
            }
        } else if (f->avctx->bits_per_raw_sample == 10) {
            f->packed_at_lsb = 1;
            switch (16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
                break;
            case 0x10:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
                break;
            case 0x11:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
                break;
            default:
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
                return AVERROR(ENOSYS);
            }
684 685 686 687 688 689 690 691 692 693 694 695 696
        } else {
            switch (16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
                break;
            case 0x10:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
                break;
            case 0x11:
                f->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
                break;
            default:
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
Luca Barbato's avatar
Luca Barbato committed
697
                return AVERROR(ENOSYS);
698 699 700 701 702 703
            }
        }
    } else if (f->colorspace == 1) {
        if (f->chroma_h_shift || f->chroma_v_shift) {
            av_log(f->avctx, AV_LOG_ERROR,
                   "chroma subsampling not supported in this colorspace\n");
Luca Barbato's avatar
Luca Barbato committed
704
            return AVERROR(ENOSYS);
705
        }
706 707 708 709 710
        if (f->transparency) {
            av_log(f->avctx, AV_LOG_ERROR,
                   "Transparency not supported in this colorspace\n");
                   return AVERROR(ENOSYS);
        }
711
        switch (f->avctx->bits_per_raw_sample) {
712
        case 0:
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
        case 8:
            f->avctx->pix_fmt = AV_PIX_FMT_RGB32;
            break;
        case 9:
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP9;
            break;
        case 10:
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP10;
            break;
        default:
            av_log(f->avctx, AV_LOG_ERROR,
                   "bit depth %d not supported\n",
                   f->avctx->bits_per_raw_sample);
            return AVERROR(ENOSYS);
        }
728 729
    } else {
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
Luca Barbato's avatar
Luca Barbato committed
730
        return AVERROR(ENOSYS);
731 732
    }

733
    ff_dlog(f->avctx, "%d %d %d\n",
734 735 736 737 738
            f->chroma_h_shift, f->chroma_v_shift, f->avctx->pix_fmt);
    if (f->version < 2) {
        context_count = read_quant_tables(c, f->quant_table);
        if (context_count < 0) {
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
739
            return AVERROR_INVALIDDATA;
740
        }
741
    } else if (f->version < 3) {
742
        f->slice_count = get_symbol(c, state, 0);
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
    } else {
        const uint8_t *p = c->bytestream_end;
        for (f->slice_count = 0;
             f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start;
             f->slice_count++) {
            int trailer = 3 + 5 * !!f->ec;
            int size    = AV_RB24(p - trailer);
            if (size + trailer > p - c->bytestream_start)
                break;
            p -= size + trailer;
        }
    }
    if (f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0) {
        av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid\n",
               f->slice_count);
        return AVERROR_INVALIDDATA;
759 760 761 762
    }

    for (j = 0; j < f->slice_count; j++) {
        FFV1Context *fs = f->slice_context[j];
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777
        fs->ac            = f->ac;
        fs->packed_at_lsb = f->packed_at_lsb;

        fs->slice_damaged = 0;

        if (f->version == 2) {
            fs->slice_x     = get_symbol(c, state, 0) * f->width;
            fs->slice_y     = get_symbol(c, state, 0) * f->height;
            fs->slice_width =
                (get_symbol(c, state, 0) + 1) * f->width + fs->slice_x;
            fs->slice_height =
                (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y;

            fs->slice_x      /= f->num_h_slices;
            fs->slice_y      /= f->num_v_slices;
778 779
            fs->slice_width  = fs->slice_width  / f->num_h_slices - fs->slice_x;
            fs->slice_height = fs->slice_height / f->num_v_slices - fs->slice_y;
780
            if ((unsigned)fs->slice_width > f->width ||
781
                (unsigned)fs->slice_height > f->height)
Luca Barbato's avatar
Luca Barbato committed
782
                return AVERROR_INVALIDDATA;
783 784 785
            if ((unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
                || (unsigned)fs->slice_y + (uint64_t)fs->slice_height >
                f->height)
Luca Barbato's avatar
Luca Barbato committed
786
                return AVERROR_INVALIDDATA;
787 788 789 790 791
        }

        for (i = 0; i < f->plane_count; i++) {
            PlaneContext *const p = &fs->plane[i];

792
            if (f->version == 2) {
793 794 795 796
                int idx = get_symbol(c, state, 0);
                if (idx > (unsigned)f->quant_table_count) {
                    av_log(f->avctx, AV_LOG_ERROR,
                           "quant_table_index out of range\n");
Luca Barbato's avatar
Luca Barbato committed
797
                    return AVERROR_INVALIDDATA;
798 799 800 801 802 803 804 805 806
                }
                p->quant_table_index = idx;
                memcpy(p->quant_table, f->quant_tables[idx],
                       sizeof(p->quant_table));
                context_count = f->context_count[idx];
            } else {
                memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
            }

807 808 809 810 811 812 813
            if (f->version <= 2) {
                av_assert0(context_count >= 0);
                if (p->context_count < context_count) {
                    av_freep(&p->state);
                    av_freep(&p->vlc_state);
                }
                p->context_count = context_count;
814 815 816 817 818 819 820 821 822
            }
        }
    }
    return 0;
}

static av_cold int ffv1_decode_init(AVCodecContext *avctx)
{
    FFV1Context *f = avctx->priv_data;
Luca Barbato's avatar
Luca Barbato committed
823
    int ret;
824 825 826

    ffv1_common_init(avctx);

827 828 829 830
    f->last_picture = av_frame_alloc();
    if (!f->last_picture)
        return AVERROR(ENOMEM);

Luca Barbato's avatar
Luca Barbato committed
831 832
    if (avctx->extradata && (ret = read_extra_header(f)) < 0)
        return ret;
833

Luca Barbato's avatar
Luca Barbato committed
834 835
    if ((ret = ffv1_init_slice_contexts(f)) < 0)
        return ret;
836 837 838 839 840

    return 0;
}

static int ffv1_decode_frame(AVCodecContext *avctx, void *data,
841
                             int *got_frame, AVPacket *avpkt)
842
{
843
    uint8_t *buf        = avpkt->data;
844 845 846
    int buf_size        = avpkt->size;
    FFV1Context *f      = avctx->priv_data;
    RangeCoder *const c = &f->slice_context[0]->c;
847
    int i, ret;
848
    uint8_t keystate = 128;
849
    uint8_t *buf_p;
850
    AVFrame *const p    = data;
851

852
    f->cur = p;
853 854 855 856

    ff_init_range_decoder(c, buf, buf_size);
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);

857
    p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P
858
    if (get_rac(c, &keystate)) {
859 860
        p->key_frame    = 1;
        f->key_frame_ok = 0;
Luca Barbato's avatar
Luca Barbato committed
861 862
        if ((ret = read_header(f)) < 0)
            return ret;
863
        f->key_frame_ok = 1;
864
    } else {
865 866
        if (!f->key_frame_ok) {
            av_log(avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
867
                   "Cannot decode non-keyframe without valid keyframe\n");
868
            return AVERROR_INVALIDDATA;
869
        }
870
        p->key_frame = 0;
871 872
    }

873
    if ((ret = ff_get_buffer(avctx, p, AV_GET_BUFFER_FLAG_REF)) < 0) {
874
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
Luca Barbato's avatar
Luca Barbato committed
875
        return ret;
876 877 878
    }

    if (avctx->debug & FF_DEBUG_PICT_INFO)
879 880 881 882
        av_log(avctx, AV_LOG_DEBUG,
               "ver:%d keyframe:%d coder:%d ec:%d slices:%d bps:%d\n",
               f->version, p->key_frame, f->ac, f->ec, f->slice_count,
               f->avctx->bits_per_raw_sample);
883 884

    buf_p = buf + buf_size;
885
    for (i = f->slice_count - 1; i >= 0; i--) {
886
        FFV1Context *fs = f->slice_context[i];
887 888 889 890 891 892 893 894
        int trailer     = 3 + 5 * !!f->ec;
        int v;

        if (i || f->version > 2)
            v = AV_RB24(buf_p - trailer) + trailer;
        else
            v = buf_p - c->bytestream_start;
        if (buf_p - c->bytestream_start < v) {
895
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
Luca Barbato's avatar
Luca Barbato committed
896
            return AVERROR_INVALIDDATA;
897 898
        }
        buf_p -= v;
899 900 901 902 903 904 905 906 907 908

        if (f->ec) {
            unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v);
            if (crc) {
                av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", crc);
                fs->slice_damaged = 1;
            }
        }

        if (i) {
909
            ff_init_range_decoder(&fs->c, buf_p, v);
910
        } else
911
            fs->c.bytestream_end = buf_p + v;
912 913

        fs->cur = p;
914 915 916 917 918 919 920 921 922
    }

    avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL,
                   f->slice_count,
                   sizeof(void *));

    for (i = f->slice_count - 1; i >= 0; i--) {
        FFV1Context *fs = f->slice_context[i];
        int j;
923
        if (fs->slice_damaged && f->last_picture->data[0]) {
924 925 926 927 928
            const uint8_t *src[4];
            uint8_t *dst[4];
            for (j = 0; j < 4; j++) {
                int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
                int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
929
                dst[j] = p->data[j] + p->linesize[j] *
930
                         (fs->slice_y >> sv) + (fs->slice_x >> sh);
931 932
                src[j] = f->last_picture->data[j] +
                         f->last_picture->linesize[j] *
933 934
                         (fs->slice_y >> sv) + (fs->slice_x >> sh);
            }
935
            av_image_copy(dst, p->linesize, src,
936
                          f->last_picture->linesize,
937 938 939
                          avctx->pix_fmt, fs->slice_width,
                          fs->slice_height);
        }
940 941 942 943
    }

    f->picture_number++;

944 945
    av_frame_unref(f->last_picture);
    if ((ret = av_frame_ref(f->last_picture, p)) < 0)
946 947
        return ret;
    f->cur = NULL;
948

949
    *got_frame = 1;
950

951 952 953
    return buf_size;
}

954 955 956 957 958 959 960 961 962 963 964
static av_cold int ffv1_decode_close(AVCodecContext *avctx)
{
    FFV1Context *s = avctx->priv_data;;

    av_frame_free(&s->last_picture);

    ffv1_close(avctx);

    return 0;
}

965 966
AVCodec ff_ffv1_decoder = {
    .name           = "ffv1",
967
    .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
968 969 970 971
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_FFV1,
    .priv_data_size = sizeof(FFV1Context),
    .init           = ffv1_decode_init,
972
    .close          = ffv1_decode_close,
973
    .decode         = ffv1_decode_frame,
974 975
    .capabilities   = AV_CODEC_CAP_DR1 /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/ |
                      AV_CODEC_CAP_SLICE_THREADS,
976
};