ffv1dec.c 38.7 KB
Newer Older
1 2 3
/*
 * FFV1 decoder
 *
4
 * Copyright (c) 2003-2013 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 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
 *
 * 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
 */

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

#include "libavutil/avassert.h"
#include "libavutil/crc.h"
#include "libavutil/opt.h"
#include "libavutil/imgutils.h"
#include "libavutil/pixdesc.h"
#include "libavutil/timer.h"
#include "avcodec.h"
#include "internal.h"
#include "get_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;
50
        while (get_rac(c, state + 1 + FFMIN(e, 9))) { // 1..10
51
            e++;
52 53 54
            if (e > 31)
                return AVERROR_INVALIDDATA;
        }
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

        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;
    }

    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
            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;
}

95 96 97 98 99
#define TYPE int16_t
#define RENAME(name) name
#include "ffv1dec_template.c"
#undef TYPE
#undef RENAME
100

101 102 103
#define TYPE int32_t
#define RENAME(name) name ## 32
#include "ffv1dec_template.c"
104 105

static void decode_plane(FFV1Context *s, uint8_t *src,
106 107
                         int w, int h, int stride, int plane_index,
                         int pixel_stride)
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
{
    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++)
131
                src[x*pixel_stride + stride * y] = sample[1][x];
132 133 134 135
        } else {
            decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
            if (s->packed_at_lsb) {
                for (x = 0; x < w; x++) {
136
                    ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x];
137 138 139
                }
            } else {
                for (x = 0; x < w; x++) {
140
                    ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x] << (16 - s->avctx->bits_per_raw_sample) | ((uint16_t **)sample)[1][x] >> (2 * s->avctx->bits_per_raw_sample - 16);
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
                }
            }
        }
// STOP_TIMER("decode-line") }
    }
}

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));

    av_assert0(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;
    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 -1;
    if (    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
         || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
        return -1;

    for (i = 0; i < f->plane_count; i++) {
        PlaneContext * const p = &fs->plane[i];
        int idx = get_symbol(c, state, 0);
175
        if (idx >= (unsigned)f->quant_table_count) {
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
            av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
            return -1;
        }
        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) {
192 193
        f->cur->interlaced_frame = 1;
        f->cur->top_field_first  = 1;
194
    } else if (ps == 2) {
195 196
        f->cur->interlaced_frame = 1;
        f->cur->top_field_first  = 0;
197
    } else if (ps == 3) {
198
        f->cur->interlaced_frame = 0;
199
    }
200 201
    f->cur->sample_aspect_ratio.num = get_symbol(c, state, 0);
    f->cur->sample_aspect_ratio.den = get_symbol(c, state, 0);
202

203 204 205 206 207 208 209 210
    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 };
    }

211 212 213
    if (fs->version > 3) {
        fs->slice_reset_contexts = get_rac(c, state);
        fs->slice_coding_mode = get_symbol(c, state, 0);
214
        if (fs->slice_coding_mode != 1) {
215 216 217
            fs->slice_rct_by_coef = get_symbol(c, state, 0);
            fs->slice_rct_ry_coef = get_symbol(c, state, 0);
            if ((uint64_t)fs->slice_rct_by_coef + (uint64_t)fs->slice_rct_ry_coef > 4) {
218 219 220 221
                av_log(f->avctx, AV_LOG_ERROR, "slice_rct_y_coef out of range\n");
                return AVERROR_INVALIDDATA;
            }
        }
222
    }
223

224 225 226 227 228
    return 0;
}

static int decode_slice(AVCodecContext *c, void *arg)
{
229 230
    FFV1Context *fs   = *(void **)arg;
    FFV1Context *f    = fs->avctx->priv_data;
231
    int width, height, x, y, ret;
232
    const int ps      = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
233
    AVFrame * const p = f->cur;
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
    int i, si;

    for( si=0; fs != f->slice_context[si]; si ++)
        ;

    if(f->fsrc && !p->key_frame)
        ff_thread_await_progress(&f->last_picture, si, 0);

    if(f->fsrc && !p->key_frame) {
        FFV1Context *fssrc = f->fsrc->slice_context[si];
        FFV1Context *fsdst = f->slice_context[si];
        av_assert1(fsdst->plane_count == fssrc->plane_count);
        av_assert1(fsdst == fs);

        if (!p->key_frame)
            fsdst->slice_damaged |= fssrc->slice_damaged;

        for (i = 0; i < f->plane_count; i++) {
            PlaneContext *psrc = &fssrc->plane[i];
            PlaneContext *pdst = &fsdst->plane[i];

            av_free(pdst->state);
            av_free(pdst->vlc_state);
            memcpy(pdst, psrc, sizeof(*pdst));
            pdst->state = NULL;
            pdst->vlc_state = NULL;

            if (fssrc->ac) {
262
                pdst->state = av_malloc_array(CONTEXT_SIZE,  psrc->context_count);
263 264
                memcpy(pdst->state, psrc->state, CONTEXT_SIZE * psrc->context_count);
            } else {
265
                pdst->vlc_state = av_malloc_array(sizeof(*pdst->vlc_state), psrc->context_count);
266 267 268 269
                memcpy(pdst->vlc_state, psrc->vlc_state, sizeof(*pdst->vlc_state) * psrc->context_count);
            }
        }
    }
270

271 272
    fs->slice_rct_by_coef = 1;
    fs->slice_rct_ry_coef = 1;
273

274
    if (f->version > 2) {
275
        if (ff_ffv1_init_slice_state(f, fs) < 0)
276 277
            return AVERROR(ENOMEM);
        if (decode_slice_header(f, fs) < 0) {
278
            fs->slice_x = fs->slice_y = fs->slice_height = fs->slice_width = 0;
279 280 281 282
            fs->slice_damaged = 1;
            return AVERROR_INVALIDDATA;
        }
    }
283
    if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
284
        return ret;
285
    if (f->cur->key_frame || fs->slice_reset_contexts)
286
        ff_ffv1_clear_slice_state(f, fs);
287

288 289 290 291
    width  = fs->slice_width;
    height = fs->slice_height;
    x      = fs->slice_x;
    y      = fs->slice_y;
292

293
    if (fs->ac == AC_GOLOMB_RICE) {
294
        if (f->version == 3 && f->micro_version > 1 || f->version > 3)
295 296
            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;
297 298 299 300 301 302
        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);
    }

    av_assert1(width && height);
303
    if (f->colorspace == 0 && (f->chroma_planes || !fs->transparency)) {
304 305
        const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
        const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
306 307
        const int cx            = x >> f->chroma_h_shift;
        const int cy            = y >> f->chroma_v_shift;
308
        decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
309 310

        if (f->chroma_planes) {
311 312
            decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1);
            decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1);
313 314
        }
        if (fs->transparency)
315 316 317 318
            decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], (f->version >= 4 && !f->chroma_planes) ? 1 : 2, 1);
    } else if (f->colorspace == 0) {
         decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0]    , width, height, p->linesize[0], 0, 2);
         decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0] + 1, width, height, p->linesize[0], 1, 2);
319 320 321 322 323
    } else if (f->use32bit) {
        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_frame32(fs, planes, width, height, p->linesize);
324
    } else {
325 326 327
        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] };
328 329
        decode_rgb_frame(fs, planes, width, height, p->linesize);
    }
330
    if (fs->ac != AC_GOLOMB_RICE && f->version > 2) {
331
        int v;
332
        get_rac(&fs->c, (uint8_t[]) { 129 });
333 334 335 336 337 338 339 340 341
        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;
        }
    }

    emms_c();

342 343
    ff_thread_report_progress(&f->picture, si, 0);

344 345 346 347 348 349 350 351 352 353 354 355 356 357
    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++) {
        unsigned len = get_symbol(c, state, 0) + 1;

358
        if (len > 128 - i || !len)
Luca Barbato's avatar
Luca Barbato committed
359
            return AVERROR_INVALIDDATA;
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380

        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++) {
381 382 383 384
        int ret = read_quant_table(c, quant_table[i], context_count);
        if (ret < 0)
            return ret;
        context_count *= ret;
385
        if (context_count > 32768U) {
Luca Barbato's avatar
Luca Barbato committed
386
            return AVERROR_INVALIDDATA;
387 388 389 390 391 392 393 394 395
        }
    }
    return (context_count + 1) / 2;
}

static int read_extra_header(FFV1Context *f)
{
    RangeCoder *const c = &f->c;
    uint8_t state[CONTEXT_SIZE];
396
    int i, j, k, ret;
397
    uint8_t state2[32][CONTEXT_SIZE];
398
    unsigned crc = 0;
399 400 401 402 403 404 405 406

    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);
407 408 409 410
    if (f->version < 2) {
        av_log(f->avctx, AV_LOG_ERROR, "Invalid version in global header\n");
        return AVERROR_INVALIDDATA;
    }
411 412
    if (f->version > 2) {
        c->bytestream_end -= 4;
413
        f->micro_version = get_symbol(c, state, 0);
414 415
        if (f->micro_version < 0)
            return AVERROR_INVALIDDATA;
416
    }
417
    f->ac = get_symbol(c, state, 0);
418

419
    if (f->ac == AC_RANGE_CUSTOM_TAB) {
420 421
        for (i = 1; i < 256; i++)
            f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
422
    }
423

424
    f->colorspace                 = get_symbol(c, state, 0); //YUV cs type
425
    f->avctx->bits_per_raw_sample = get_symbol(c, state, 0);
426 427 428 429
    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);
430
    f->plane_count                = 1 + (f->chroma_planes || f->version<4) + f->transparency;
431 432
    f->num_h_slices               = 1 + get_symbol(c, state, 0);
    f->num_v_slices               = 1 + get_symbol(c, state, 0);
433

434 435 436 437 438 439
    if (f->chroma_h_shift > 4U || f->chroma_v_shift > 4U) {
        av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
               f->chroma_h_shift, f->chroma_v_shift);
        return AVERROR_INVALIDDATA;
    }

440 441 442 443
    if (f->num_h_slices > (unsigned)f->width  || !f->num_h_slices ||
        f->num_v_slices > (unsigned)f->height || !f->num_v_slices
       ) {
        av_log(f->avctx, AV_LOG_ERROR, "slice count invalid\n");
Luca Barbato's avatar
Luca Barbato committed
444
        return AVERROR_INVALIDDATA;
445 446 447
    }

    f->quant_table_count = get_symbol(c, state, 0);
448 449
    if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) {
        av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count);
450
        f->quant_table_count = 0;
Luca Barbato's avatar
Luca Barbato committed
451
        return AVERROR_INVALIDDATA;
452
    }
453 454 455 456 457

    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");
458
            return AVERROR_INVALIDDATA;
459 460
        }
    }
461
    if ((ret = ff_ffv1_allocate_initial_states(f)) < 0)
462
        return ret;
463 464

    for (i = 0; i < f->quant_table_count; i++)
465
        if (get_rac(c, state)) {
466 467 468 469 470 471
            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;
                }
472
        }
473 474 475

    if (f->version > 2) {
        f->ec = get_symbol(c, state, 0);
476
        if (f->micro_version > 2)
477
            f->intra = get_symbol(c, state, 0);
478 479 480 481
    }

    if (f->version > 2) {
        unsigned v;
482 483
        v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0,
                   f->avctx->extradata, f->avctx->extradata_size);
484
        if (v || f->avctx->extradata_size < 4) {
485 486 487
            av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
            return AVERROR_INVALIDDATA;
        }
488
        crc = AV_RB32(f->avctx->extradata + f->avctx->extradata_size - 4);
489 490
    }

491 492
    if (f->avctx->debug & FF_DEBUG_PICT_INFO)
        av_log(f->avctx, AV_LOG_DEBUG,
493
               "global: ver:%d.%d, coder:%d, colorspace: %d bpr:%d chroma:%d(%d:%d), alpha:%d slices:%dx%d qtabs:%d ec:%d intra:%d CRC:0x%08X\n",
494
               f->version, f->micro_version,
495 496 497 498 499 500 501 502
               f->ac,
               f->colorspace,
               f->avctx->bits_per_raw_sample,
               f->chroma_planes, f->chroma_h_shift, f->chroma_v_shift,
               f->transparency,
               f->num_h_slices, f->num_v_slices,
               f->quant_table_count,
               f->ec,
503 504
               f->intra,
               crc
505
              );
506 507 508 509 510 511 512 513 514 515 516 517
    return 0;
}

static int read_header(FFV1Context *f)
{
    uint8_t state[CONTEXT_SIZE];
    int i, j, context_count = -1; //-1 to avoid warning
    RangeCoder *const c = &f->slice_context[0]->c;

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

    if (f->version < 2) {
518
        int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample;
519 520 521 522 523 524
        unsigned v= get_symbol(c, state, 0);
        if (v >= 2) {
            av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v);
            return AVERROR_INVALIDDATA;
        }
        f->version = v;
525
        f->ac = get_symbol(c, state, 0);
526

527
        if (f->ac == AC_RANGE_CUSTOM_TAB) {
528 529
            for (i = 1; i < 256; i++)
                f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
530 531
        }

532
        colorspace          = get_symbol(c, state, 0); //YUV cs type
533
        bits_per_raw_sample = f->version > 0 ? get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
534 535 536 537
        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);
538 539
        if (colorspace == 0 && f->avctx->skip_alpha)
            transparency = 0;
540 541

        if (f->plane_count) {
542 543 544 545 546 547
            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) {
548 549 550 551 552
                av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
                return AVERROR_INVALIDDATA;
            }
        }

553 554 555 556 557 558
        if (chroma_h_shift > 4U || chroma_v_shift > 4U) {
            av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n",
                   chroma_h_shift, chroma_v_shift);
            return AVERROR_INVALIDDATA;
        }

559
        f->colorspace                 = colorspace;
560
        f->avctx->bits_per_raw_sample = bits_per_raw_sample;
561 562 563 564
        f->chroma_planes              = chroma_planes;
        f->chroma_h_shift             = chroma_h_shift;
        f->chroma_v_shift             = chroma_v_shift;
        f->transparency               = transparency;
565

566 567 568 569 570 571 572
        f->plane_count    = 2 + f->transparency;
    }

    if (f->colorspace == 0) {
        if (!f->transparency && !f->chroma_planes) {
            if (f->avctx->bits_per_raw_sample <= 8)
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
573 574 575 576 577 578 579 580 581 582
            else if (f->avctx->bits_per_raw_sample == 10) {
                f->packed_at_lsb = 1;
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY10;
            } else if (f->avctx->bits_per_raw_sample == 12) {
                f->packed_at_lsb = 1;
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY12;
            } else if (f->avctx->bits_per_raw_sample == 16) {
                f->packed_at_lsb = 1;
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
            } else if (f->avctx->bits_per_raw_sample < 16) {
583
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
584 585
            } else
                return AVERROR(ENOSYS);
586 587 588 589 590
        } else if (f->transparency && !f->chroma_planes) {
            if (f->avctx->bits_per_raw_sample <= 8)
                f->avctx->pix_fmt = AV_PIX_FMT_YA8;
            else
                return AVERROR(ENOSYS);
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
        } 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_YUV444P; break;
            case 0x01: f->avctx->pix_fmt = AV_PIX_FMT_YUV440P; break;
            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;
            }
        } 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;
            }
606
        } else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) {
607 608 609 610 611 612
            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;
            }
613 614 615 616 617 618 619
        } else if (f->avctx->bits_per_raw_sample == 9 && f->transparency) {
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P9; break;
            case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P9; break;
            case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P9; break;
            }
620
        } else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) {
621 622 623 624 625 626
            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;
            }
627 628 629 630 631 632 633
        } else if (f->avctx->bits_per_raw_sample == 10 && f->transparency) {
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P10; break;
            case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P10; break;
            case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P10; break;
            }
634 635 636 637 638 639 640
        } else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency) {
            f->packed_at_lsb = 1;
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P12; break;
            case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P12; break;
            case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P12; break;
            }
641
        } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){
642
            f->packed_at_lsb = 1;
643 644 645 646 647
            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;
            }
648
        } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){
649
            f->packed_at_lsb = 1;
650 651 652 653 654
            switch(16 * f->chroma_h_shift + f->chroma_v_shift) {
            case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P16; break;
            case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P16; break;
            case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16; break;
            }
655 656 657 658 659
        }
    } 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
660
            return AVERROR(ENOSYS);
661
        }
662 663 664 665 666
        if (     f->avctx->bits_per_raw_sample <=  8 && !f->transparency)
            f->avctx->pix_fmt = AV_PIX_FMT_0RGB32;
        else if (f->avctx->bits_per_raw_sample <=  8 && f->transparency)
            f->avctx->pix_fmt = AV_PIX_FMT_RGB32;
        else if (f->avctx->bits_per_raw_sample ==  9 && !f->transparency)
667
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP9;
668
        else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency)
669
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP10;
670
        else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency)
671
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP12;
672
        else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency)
673
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP14;
674 675 676 677
        else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency) {
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP16;
            f->use32bit = 1;
        }
678 679
    } else {
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
Luca Barbato's avatar
Luca Barbato committed
680
        return AVERROR(ENOSYS);
681
    }
682 683 684 685
    if (f->avctx->pix_fmt == AV_PIX_FMT_NONE) {
        av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
        return AVERROR(ENOSYS);
    }
686

687
    ff_dlog(f->avctx, "%d %d %d\n",
688 689 690 691 692
            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");
693
            return AVERROR_INVALIDDATA;
694
        }
695
        f->slice_count = f->max_slice_count;
696 697 698 699
    } else if (f->version < 3) {
        f->slice_count = get_symbol(c, state, 0);
    } else {
        const uint8_t *p = c->bytestream_end;
700 701 702
        for (f->slice_count = 0;
             f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start;
             f->slice_count++) {
703 704 705 706 707 708 709
            int trailer = 3 + 5*!!f->ec;
            int size = AV_RB24(p-trailer);
            if (size + trailer > p - c->bytestream_start)
                break;
            p -= size + trailer;
        }
    }
710 711
    if (f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0 || f->slice_count > f->max_slice_count) {
        av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid (max=%d)\n", f->slice_count, f->max_slice_count);
712
        return AVERROR_INVALIDDATA;
713 714 715 716
    }

    for (j = 0; j < f->slice_count; j++) {
        FFV1Context *fs = f->slice_context[j];
717
        fs->ac            = f->ac;
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
        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;
            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)
Luca Barbato's avatar
Luca Barbato committed
734
                return AVERROR_INVALIDDATA;
735 736
            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
737
                return AVERROR_INVALIDDATA;
738 739 740 741 742 743 744 745 746 747
        }

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

            if (f->version == 2) {
                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
748
                    return AVERROR_INVALIDDATA;
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773
                }
                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));
            }

            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;
            }
        }
    }
    return 0;
}

static av_cold int decode_init(AVCodecContext *avctx)
{
    FFV1Context *f = avctx->priv_data;
Luca Barbato's avatar
Luca Barbato committed
774
    int ret;
775

776
    if ((ret = ff_ffv1_common_init(avctx)) < 0)
777
        return ret;
778

779
    if (avctx->extradata_size > 0 && (ret = read_extra_header(f)) < 0)
Luca Barbato's avatar
Luca Barbato committed
780
        return ret;
781

782
    if ((ret = ff_ffv1_init_slice_contexts(f)) < 0)
Luca Barbato's avatar
Luca Barbato committed
783
        return ret;
784

785 786
    avctx->internal->allocate_progress = 1;

787 788 789
    return 0;
}

790
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
791
{
792
    uint8_t *buf        = avpkt->data;
793 794 795
    int buf_size        = avpkt->size;
    FFV1Context *f      = avctx->priv_data;
    RangeCoder *const c = &f->slice_context[0]->c;
796
    int i, ret;
797
    uint8_t keystate = 128;
798
    uint8_t *buf_p;
799
    AVFrame *p;
800

801 802 803 804 805
    if (f->last_picture.f)
        ff_thread_release_buffer(avctx, &f->last_picture);
    FFSWAP(ThreadFrame, f->picture, f->last_picture);

    f->cur = p = f->picture.f;
806

807 808 809 810 811 812 813
    if (f->version < 3 && avctx->field_order > AV_FIELD_PROGRESSIVE) {
        /* we have interlaced material flagged in container */
        p->interlaced_frame = 1;
        if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
            p->top_field_first = 1;
    }

814
    f->avctx = avctx;
815 816 817
    ff_init_range_decoder(c, buf, buf_size);
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);

818
    p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P
819
    if (get_rac(c, &keystate)) {
820
        p->key_frame    = 1;
821
        f->key_frame_ok = 0;
Luca Barbato's avatar
Luca Barbato committed
822 823
        if ((ret = read_header(f)) < 0)
            return ret;
824 825 826
        f->key_frame_ok = 1;
    } else {
        if (!f->key_frame_ok) {
827
            av_log(avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
828
                   "Cannot decode non-keyframe without valid keyframe\n");
829 830
            return AVERROR_INVALIDDATA;
        }
831
        p->key_frame = 0;
832 833
    }

834
    if ((ret = ff_thread_get_buffer(avctx, &f->picture, AV_GET_BUFFER_FLAG_REF)) < 0)
Luca Barbato's avatar
Luca Barbato committed
835
        return ret;
836

837
    if (avctx->debug & FF_DEBUG_PICT_INFO)
838 839 840
        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);

841 842
    ff_thread_finish_setup(avctx);

843 844 845 846 847 848
    buf_p = buf + buf_size;
    for (i = f->slice_count - 1; i >= 0; i--) {
        FFV1Context *fs = f->slice_context[i];
        int trailer = 3 + 5*!!f->ec;
        int v;

849 850
        if (i || f->version > 2) v = AV_RB24(buf_p-trailer) + trailer;
        else                     v = buf_p - c->bytestream_start;
851 852
        if (buf_p - c->bytestream_start < v) {
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
853
            ff_thread_report_progress(&f->picture, INT_MAX, 0);
Luca Barbato's avatar
Luca Barbato committed
854
            return AVERROR_INVALIDDATA;
855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
        }
        buf_p -= v;

        if (f->ec) {
            unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v);
            if (crc) {
                int64_t ts = avpkt->pts != AV_NOPTS_VALUE ? avpkt->pts : avpkt->dts;
                av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!", crc);
                if (ts != AV_NOPTS_VALUE && avctx->pkt_timebase.num) {
                    av_log(f->avctx, AV_LOG_ERROR, "at %f seconds\n", ts*av_q2d(avctx->pkt_timebase));
                } else if (ts != AV_NOPTS_VALUE) {
                    av_log(f->avctx, AV_LOG_ERROR, "at %"PRId64"\n", ts);
                } else {
                    av_log(f->avctx, AV_LOG_ERROR, "\n");
                }
                fs->slice_damaged = 1;
            }
872 873 874
            if (avctx->debug & FF_DEBUG_PICT_INFO) {
                av_log(avctx, AV_LOG_DEBUG, "slice %d, CRC: 0x%08X\n", i, AV_RB32(buf_p + v - 4));
            }
875 876 877 878 879
        }

        if (i) {
            ff_init_range_decoder(&fs->c, buf_p, v);
        } else
880
            fs->c.bytestream_end = buf_p + v;
881

882
        fs->avctx = avctx;
883
        fs->cur = p;
884 885
    }

886 887 888 889
    avctx->execute(avctx,
                   decode_slice,
                   &f->slice_context[0],
                   NULL,
890
                   f->slice_count,
891
                   sizeof(void*));
892

893 894
    for (i = f->slice_count - 1; i >= 0; i--) {
        FFV1Context *fs = f->slice_context[i];
895
        int j;
896
        if (fs->slice_damaged && f->last_picture.f->data[0]) {
897
            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
898 899
            const uint8_t *src[4];
            uint8_t *dst[4];
900
            ff_thread_await_progress(&f->last_picture, INT_MAX, 0);
901
            for (j = 0; j < 4; j++) {
902
                int pixshift = desc->comp[j].depth > 8;
903 904
                int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
                int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
905
                dst[j] = p->data[j] + p->linesize[j] *
906
                         (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
907
                src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
908
                         (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
909
            }
910
            av_image_copy(dst, p->linesize, src,
911
                          f->last_picture.f->linesize,
912 913
                          avctx->pix_fmt,
                          fs->slice_width,
914
                          fs->slice_height);
915 916
        }
    }
917
    ff_thread_report_progress(&f->picture, INT_MAX, 0);
918 919 920

    f->picture_number++;

921 922
    if (f->last_picture.f)
        ff_thread_release_buffer(avctx, &f->last_picture);
923
    f->cur = NULL;
924 925
    if ((ret = av_frame_ref(data, f->picture.f)) < 0)
        return ret;
926

927
    *got_frame = 1;
928 929 930 931

    return buf_size;
}

932
#if HAVE_THREADS
933 934 935
static int init_thread_copy(AVCodecContext *avctx)
{
    FFV1Context *f = avctx->priv_data;
936
    int i, ret;
937

938 939 940
    f->picture.f      = NULL;
    f->last_picture.f = NULL;
    f->sample_buffer  = NULL;
941
    f->max_slice_count = 0;
942 943
    f->slice_count = 0;

944 945 946 947 948 949
    for (i = 0; i < f->quant_table_count; i++) {
        av_assert0(f->version > 1);
        f->initial_states[i] = av_memdup(f->initial_states[i],
                                         f->context_count[i] * sizeof(*f->initial_states[i]));
    }

950 951 952
    f->picture.f      = av_frame_alloc();
    f->last_picture.f = av_frame_alloc();

953
    if ((ret = ff_ffv1_init_slice_contexts(f)) < 0)
954 955
        return ret;

956 957
    return 0;
}
958
#endif
959

960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987
static void copy_fields(FFV1Context *fsdst, FFV1Context *fssrc, FFV1Context *fsrc)
{
    fsdst->version             = fsrc->version;
    fsdst->micro_version       = fsrc->micro_version;
    fsdst->chroma_planes       = fsrc->chroma_planes;
    fsdst->chroma_h_shift      = fsrc->chroma_h_shift;
    fsdst->chroma_v_shift      = fsrc->chroma_v_shift;
    fsdst->transparency        = fsrc->transparency;
    fsdst->plane_count         = fsrc->plane_count;
    fsdst->ac                  = fsrc->ac;
    fsdst->colorspace          = fsrc->colorspace;

    fsdst->ec                  = fsrc->ec;
    fsdst->intra               = fsrc->intra;
    fsdst->slice_damaged       = fssrc->slice_damaged;
    fsdst->key_frame_ok        = fsrc->key_frame_ok;

    fsdst->bits_per_raw_sample = fsrc->bits_per_raw_sample;
    fsdst->packed_at_lsb       = fsrc->packed_at_lsb;
    fsdst->slice_count         = fsrc->slice_count;
    if (fsrc->version<3){
        fsdst->slice_x             = fssrc->slice_x;
        fsdst->slice_y             = fssrc->slice_y;
        fsdst->slice_width         = fssrc->slice_width;
        fsdst->slice_height        = fssrc->slice_height;
    }
}

988
#if HAVE_THREADS
989 990 991 992 993 994 995 996 997
static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
{
    FFV1Context *fsrc = src->priv_data;
    FFV1Context *fdst = dst->priv_data;
    int i, ret;

    if (dst == src)
        return 0;

998
    {
999 1000 1001 1002 1003 1004
        ThreadFrame picture = fdst->picture, last_picture = fdst->last_picture;
        uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
        struct FFV1Context *slice_context[MAX_SLICES];
        memcpy(initial_states, fdst->initial_states, sizeof(fdst->initial_states));
        memcpy(slice_context,  fdst->slice_context , sizeof(fdst->slice_context));

1005
        memcpy(fdst, fsrc, sizeof(*fdst));
1006 1007 1008 1009
        memcpy(fdst->initial_states, initial_states, sizeof(fdst->initial_states));
        memcpy(fdst->slice_context,  slice_context , sizeof(fdst->slice_context));
        fdst->picture      = picture;
        fdst->last_picture = last_picture;
1010 1011 1012 1013 1014 1015 1016
        for (i = 0; i<fdst->num_h_slices * fdst->num_v_slices; i++) {
            FFV1Context *fssrc = fsrc->slice_context[i];
            FFV1Context *fsdst = fdst->slice_context[i];
            copy_fields(fsdst, fssrc, fsrc);
        }
        av_assert0(!fdst->plane[0].state);
        av_assert0(!fdst->sample_buffer);
1017 1018
    }

1019
    av_assert1(fdst->max_slice_count == fsrc->max_slice_count);
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029


    ff_thread_release_buffer(dst, &fdst->picture);
    if (fsrc->picture.f->data[0]) {
        if ((ret = ff_thread_ref_frame(&fdst->picture, &fsrc->picture)) < 0)
            return ret;
    }

    fdst->fsrc = fsrc;

1030 1031
    return 0;
}
1032
#endif
1033

1034 1035
AVCodec ff_ffv1_decoder = {
    .name           = "ffv1",
1036
    .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1037 1038 1039 1040
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_FFV1,
    .priv_data_size = sizeof(FFV1Context),
    .init           = decode_init,
1041
    .close          = ff_ffv1_close,
1042
    .decode         = decode_frame,
1043 1044
    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
    .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
1045
    .capabilities   = AV_CODEC_CAP_DR1 /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/ |
1046
                      AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
1047
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP
1048
};