ffv1dec.c 40.8 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
 *
 * 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 {
48 49
        int i, e;
        unsigned a;
50
        e = 0;
51
        while (get_rac(c, state + 1 + FFMIN(e, 9))) { // 1..10
52
            e++;
53 54 55
            if (e > 31)
                return AVERROR_INVALIDDATA;
        }
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 83

        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);
84
    ff_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
85 86 87 88 89 90 91 92 93 94 95
            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;
}

96 97 98 99 100 101 102 103 104 105 106 107 108
static int is_input_end(FFV1Context *s)
{
    if (s->ac != AC_GOLOMB_RICE) {
        RangeCoder *const c = &s->c;
        if (c->overread > MAX_OVERREAD)
            return AVERROR_INVALIDDATA;
    } else {
        if (get_bits_left(&s->gb) < 1)
            return AVERROR_INVALIDDATA;
    }
    return 0;
}

109 110 111 112 113
#define TYPE int16_t
#define RENAME(name) name
#include "ffv1dec_template.c"
#undef TYPE
#undef RENAME
114

115 116 117
#define TYPE int32_t
#define RENAME(name) name ## 32
#include "ffv1dec_template.c"
118

119
static int decode_plane(FFV1Context *s, uint8_t *src,
120 121
                         int w, int h, int stride, int plane_index,
                         int pixel_stride)
122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
{
    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) {
143 144 145
            int ret = decode_line(s, w, sample, plane_index, 8);
            if (ret < 0)
                return ret;
146
            for (x = 0; x < w; x++)
147
                src[x*pixel_stride + stride * y] = sample[1][x];
148
        } else {
149 150 151
            int ret = decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
            if (ret < 0)
                return ret;
152 153
            if (s->packed_at_lsb) {
                for (x = 0; x < w; x++) {
154
                    ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x];
155 156 157
                }
            } else {
                for (x = 0; x < w; x++) {
158
                    ((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);
159 160 161 162 163
                }
            }
        }
// STOP_TIMER("decode-line") }
    }
164
    return 0;
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
}

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);
194
        if (idx >= (unsigned)f->quant_table_count) {
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
            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) {
211 212
        f->cur->interlaced_frame = 1;
        f->cur->top_field_first  = 1;
213
    } else if (ps == 2) {
214 215
        f->cur->interlaced_frame = 1;
        f->cur->top_field_first  = 0;
216
    } else if (ps == 3) {
217
        f->cur->interlaced_frame = 0;
218
    }
219 220
    f->cur->sample_aspect_ratio.num = get_symbol(c, state, 0);
    f->cur->sample_aspect_ratio.den = get_symbol(c, state, 0);
221

222 223 224 225 226 227 228 229
    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 };
    }

230 231 232
    if (fs->version > 3) {
        fs->slice_reset_contexts = get_rac(c, state);
        fs->slice_coding_mode = get_symbol(c, state, 0);
233
        if (fs->slice_coding_mode != 1) {
234 235 236
            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) {
237 238 239 240
                av_log(f->avctx, AV_LOG_ERROR, "slice_rct_y_coef out of range\n");
                return AVERROR_INVALIDDATA;
            }
        }
241
    }
242

243 244 245 246 247
    return 0;
}

static int decode_slice(AVCodecContext *c, void *arg)
{
248 249
    FFV1Context *fs   = *(void **)arg;
    FFV1Context *f    = fs->avctx->priv_data;
250
    int width, height, x, y, ret;
251
    const int ps      = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
252
    AVFrame * const p = f->cur;
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
    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) {
281
                pdst->state = av_malloc_array(CONTEXT_SIZE,  psrc->context_count);
282 283
                memcpy(pdst->state, psrc->state, CONTEXT_SIZE * psrc->context_count);
            } else {
284
                pdst->vlc_state = av_malloc_array(sizeof(*pdst->vlc_state), psrc->context_count);
285 286 287 288
                memcpy(pdst->vlc_state, psrc->vlc_state, sizeof(*pdst->vlc_state) * psrc->context_count);
            }
        }
    }
289

290 291
    fs->slice_rct_by_coef = 1;
    fs->slice_rct_ry_coef = 1;
292

293
    if (f->version > 2) {
294
        if (ff_ffv1_init_slice_state(f, fs) < 0)
295 296
            return AVERROR(ENOMEM);
        if (decode_slice_header(f, fs) < 0) {
297
            fs->slice_x = fs->slice_y = fs->slice_height = fs->slice_width = 0;
298 299 300 301
            fs->slice_damaged = 1;
            return AVERROR_INVALIDDATA;
        }
    }
302
    if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0)
303
        return ret;
304
    if (f->cur->key_frame || fs->slice_reset_contexts)
305
        ff_ffv1_clear_slice_state(f, fs);
306

307 308 309 310
    width  = fs->slice_width;
    height = fs->slice_height;
    x      = fs->slice_x;
    y      = fs->slice_y;
311

312
    if (fs->ac == AC_GOLOMB_RICE) {
313
        if (f->version == 3 && f->micro_version > 1 || f->version > 3)
314 315
            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;
316 317 318 319 320 321
        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);
322
    if (f->colorspace == 0 && (f->chroma_planes || !fs->transparency)) {
323 324
        const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
        const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
325 326
        const int cx            = x >> f->chroma_h_shift;
        const int cy            = y >> f->chroma_v_shift;
327
        decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
328 329

        if (f->chroma_planes) {
330 331
            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);
332 333
        }
        if (fs->transparency)
334 335 336 337
            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);
338
    } else if (f->use32bit) {
339
        uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
340
                               p->data[1] + ps * x + y * p->linesize[1],
341 342
                               p->data[2] + ps * x + y * p->linesize[2],
                               p->data[3] + ps * x + y * p->linesize[3] };
343
        decode_rgb_frame32(fs, planes, width, height, p->linesize);
344
    } else {
345
        uint8_t *planes[4] = { p->data[0] + ps * x + y * p->linesize[0],
346
                               p->data[1] + ps * x + y * p->linesize[1],
347 348
                               p->data[2] + ps * x + y * p->linesize[2],
                               p->data[3] + ps * x + y * p->linesize[3] };
349 350
        decode_rgb_frame(fs, planes, width, height, p->linesize);
    }
351
    if (fs->ac != AC_GOLOMB_RICE && f->version > 2) {
352
        int v;
353
        get_rac(&fs->c, (uint8_t[]) { 129 });
354 355 356 357 358 359 360 361 362
        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();

363 364
    ff_thread_report_progress(&f->picture, si, 0);

365 366 367 368 369 370 371 372 373 374 375 376
    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++) {
377
        unsigned len = get_symbol(c, state, 0) + 1U;
378

379
        if (len > 128 - i || !len)
Luca Barbato's avatar
Luca Barbato committed
380
            return AVERROR_INVALIDDATA;
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401

        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++) {
402 403 404 405
        int ret = read_quant_table(c, quant_table[i], context_count);
        if (ret < 0)
            return ret;
        context_count *= ret;
406
        if (context_count > 32768U) {
Luca Barbato's avatar
Luca Barbato committed
407
            return AVERROR_INVALIDDATA;
408 409 410 411 412 413 414 415 416
        }
    }
    return (context_count + 1) / 2;
}

static int read_extra_header(FFV1Context *f)
{
    RangeCoder *const c = &f->c;
    uint8_t state[CONTEXT_SIZE];
417
    int i, j, k, ret;
418
    uint8_t state2[32][CONTEXT_SIZE];
419
    unsigned crc = 0;
420 421 422 423 424 425 426 427

    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);
428 429 430 431
    if (f->version < 2) {
        av_log(f->avctx, AV_LOG_ERROR, "Invalid version in global header\n");
        return AVERROR_INVALIDDATA;
    }
432 433
    if (f->version > 2) {
        c->bytestream_end -= 4;
434
        f->micro_version = get_symbol(c, state, 0);
435 436
        if (f->micro_version < 0)
            return AVERROR_INVALIDDATA;
437
    }
438
    f->ac = get_symbol(c, state, 0);
439

440
    if (f->ac == AC_RANGE_CUSTOM_TAB) {
441 442
        for (i = 1; i < 256; i++)
            f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
443
    }
444

445
    f->colorspace                 = get_symbol(c, state, 0); //YUV cs type
446
    f->avctx->bits_per_raw_sample = get_symbol(c, state, 0);
447 448 449 450
    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);
451
    f->plane_count                = 1 + (f->chroma_planes || f->version<4) + f->transparency;
452 453
    f->num_h_slices               = 1 + get_symbol(c, state, 0);
    f->num_v_slices               = 1 + get_symbol(c, state, 0);
454

455 456 457 458 459 460
    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;
    }

461 462 463 464
    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
465
        return AVERROR_INVALIDDATA;
466 467 468
    }

    f->quant_table_count = get_symbol(c, state, 0);
469 470
    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);
471
        f->quant_table_count = 0;
Luca Barbato's avatar
Luca Barbato committed
472
        return AVERROR_INVALIDDATA;
473
    }
474 475 476 477 478

    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");
479
            return AVERROR_INVALIDDATA;
480 481
        }
    }
482
    if ((ret = ff_ffv1_allocate_initial_states(f)) < 0)
483
        return ret;
484 485

    for (i = 0; i < f->quant_table_count; i++)
486
        if (get_rac(c, state)) {
487 488 489 490 491 492
            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;
                }
493
        }
494 495 496

    if (f->version > 2) {
        f->ec = get_symbol(c, state, 0);
497
        if (f->micro_version > 2)
498
            f->intra = get_symbol(c, state, 0);
499 500 501 502
    }

    if (f->version > 2) {
        unsigned v;
503 504
        v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0,
                   f->avctx->extradata, f->avctx->extradata_size);
505
        if (v || f->avctx->extradata_size < 4) {
506 507 508
            av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
            return AVERROR_INVALIDDATA;
        }
509
        crc = AV_RB32(f->avctx->extradata + f->avctx->extradata_size - 4);
510 511
    }

512 513
    if (f->avctx->debug & FF_DEBUG_PICT_INFO)
        av_log(f->avctx, AV_LOG_DEBUG,
514
               "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",
515
               f->version, f->micro_version,
516 517 518 519 520 521 522 523
               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,
524 525
               f->intra,
               crc
526
              );
527 528 529 530 531 532 533 534 535 536 537 538
    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) {
539
        int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample;
540 541 542 543 544 545
        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;
546
        f->ac = get_symbol(c, state, 0);
547

548
        if (f->ac == AC_RANGE_CUSTOM_TAB) {
549 550 551 552 553 554 555 556
            for (i = 1; i < 256; i++) {
                int st = get_symbol(c, state, 1) + c->one_state[i];
                if (st < 1 || st > 255) {
                    av_log(f->avctx, AV_LOG_ERROR, "invalid state transition %d\n", st);
                    return AVERROR_INVALIDDATA;
                }
                f->state_transition[i] = st;
            }
557 558
        }

559
        colorspace          = get_symbol(c, state, 0); //YUV cs type
560
        bits_per_raw_sample = f->version > 0 ? get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
561 562 563 564
        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);
565 566
        if (colorspace == 0 && f->avctx->skip_alpha)
            transparency = 0;
567 568

        if (f->plane_count) {
569 570 571 572 573 574
            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) {
575 576 577 578 579
                av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
                return AVERROR_INVALIDDATA;
            }
        }

580 581 582 583 584 585
        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;
        }

586
        f->colorspace                 = colorspace;
587
        f->avctx->bits_per_raw_sample = bits_per_raw_sample;
588 589 590 591
        f->chroma_planes              = chroma_planes;
        f->chroma_h_shift             = chroma_h_shift;
        f->chroma_v_shift             = chroma_v_shift;
        f->transparency               = transparency;
592

593 594 595 596 597 598 599
        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;
600 601 602 603
            else if (f->avctx->bits_per_raw_sample == 9) {
                f->packed_at_lsb = 1;
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY9;
            } else if (f->avctx->bits_per_raw_sample == 10) {
604 605 606 607 608 609 610 611 612
                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) {
613
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
614 615
            } else
                return AVERROR(ENOSYS);
616 617 618 619 620
        } 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);
621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
        } 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;
            }
636
        } else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) {
637 638 639 640 641 642
            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;
            }
643 644 645 646 647 648 649
        } 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;
            }
650
        } else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) {
651 652 653
            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;
654
            case 0x01: f->avctx->pix_fmt = AV_PIX_FMT_YUV440P10; break;
655 656 657
            case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P10; break;
            case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P10; break;
            }
658 659 660 661 662 663 664
        } 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;
            }
665 666 667 668
        } 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;
669
            case 0x01: f->avctx->pix_fmt = AV_PIX_FMT_YUV440P12; break;
670 671 672
            case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P12; break;
            case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P12; break;
            }
673 674 675 676 677 678 679
        } else if (f->avctx->bits_per_raw_sample == 14 && !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_YUV444P14; break;
            case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P14; break;
            case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P14; break;
            }
680
        } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){
681
            f->packed_at_lsb = 1;
682 683 684 685 686
            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;
            }
687
        } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){
688
            f->packed_at_lsb = 1;
689 690 691 692 693
            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;
            }
694 695 696 697 698
        }
    } 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
699
            return AVERROR(ENOSYS);
700
        }
701 702 703 704 705
        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)
706
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP9;
707
        else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency)
708
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP10;
709 710
        else if (f->avctx->bits_per_raw_sample == 10 && f->transparency)
            f->avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
711
        else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency)
712
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP12;
713 714
        else if (f->avctx->bits_per_raw_sample == 12 && f->transparency)
            f->avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
715
        else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency)
716
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP14;
717 718 719 720
        else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency) {
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP16;
            f->use32bit = 1;
        }
721 722 723 724
        else if (f->avctx->bits_per_raw_sample == 16 && f->transparency) {
            f->avctx->pix_fmt = AV_PIX_FMT_GBRAP16;
            f->use32bit = 1;
        }
725 726
    } else {
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
Luca Barbato's avatar
Luca Barbato committed
727
        return AVERROR(ENOSYS);
728
    }
729 730 731 732
    if (f->avctx->pix_fmt == AV_PIX_FMT_NONE) {
        av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
        return AVERROR(ENOSYS);
    }
733

734
    ff_dlog(f->avctx, "%d %d %d\n",
735 736 737 738 739
            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");
740
            return AVERROR_INVALIDDATA;
741
        }
742
        f->slice_count = f->max_slice_count;
743 744 745 746
    } else if (f->version < 3) {
        f->slice_count = get_symbol(c, state, 0);
    } else {
        const uint8_t *p = c->bytestream_end;
747
        for (f->slice_count = 0;
748
             f->slice_count < MAX_SLICES && 3 + 5*!!f->ec < p - c->bytestream_start;
749
             f->slice_count++) {
750 751 752 753 754 755 756
            int trailer = 3 + 5*!!f->ec;
            int size = AV_RB24(p-trailer);
            if (size + trailer > p - c->bytestream_start)
                break;
            p -= size + trailer;
        }
    }
757 758
    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);
759
        return AVERROR_INVALIDDATA;
760 761 762 763
    }

    for (j = 0; j < f->slice_count; j++) {
        FFV1Context *fs = f->slice_context[j];
764
        fs->ac            = f->ac;
765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
        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
781
                return AVERROR_INVALIDDATA;
782 783
            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
784
                return AVERROR_INVALIDDATA;
785 786 787 788 789 790 791 792 793 794
        }

        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
795
                    return AVERROR_INVALIDDATA;
796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
                }
                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
821
    int ret;
822

823
    if ((ret = ff_ffv1_common_init(avctx)) < 0)
824
        return ret;
825

826
    if (avctx->extradata_size > 0 && (ret = read_extra_header(f)) < 0)
Luca Barbato's avatar
Luca Barbato committed
827
        return ret;
828

829
    if ((ret = ff_ffv1_init_slice_contexts(f)) < 0)
Luca Barbato's avatar
Luca Barbato committed
830
        return ret;
831

832 833
    avctx->internal->allocate_progress = 1;

834 835 836
    return 0;
}

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

848 849 850 851 852
    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;
853

854 855 856 857 858 859 860
    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;
    }

861
    f->avctx = avctx;
862 863 864
    ff_init_range_decoder(c, buf, buf_size);
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);

865
    p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P
866
    if (get_rac(c, &keystate)) {
867
        p->key_frame    = 1;
868
        f->key_frame_ok = 0;
Luca Barbato's avatar
Luca Barbato committed
869 870
        if ((ret = read_header(f)) < 0)
            return ret;
871 872 873
        f->key_frame_ok = 1;
    } else {
        if (!f->key_frame_ok) {
874
            av_log(avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
875
                   "Cannot decode non-keyframe without valid keyframe\n");
876 877
            return AVERROR_INVALIDDATA;
        }
878
        p->key_frame = 0;
879 880
    }

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

884
    if (avctx->debug & FF_DEBUG_PICT_INFO)
885 886 887
        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);

888 889
    ff_thread_finish_setup(avctx);

890 891 892 893 894 895
    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;

896 897
        if (i || f->version > 2) v = AV_RB24(buf_p-trailer) + trailer;
        else                     v = buf_p - c->bytestream_start;
898 899
        if (buf_p - c->bytestream_start < v) {
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
900
            ff_thread_report_progress(&f->picture, INT_MAX, 0);
Luca Barbato's avatar
Luca Barbato committed
901
            return AVERROR_INVALIDDATA;
902 903 904 905 906 907 908
        }
        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;
909
                av_log(f->avctx, AV_LOG_ERROR, "slice CRC mismatch %X!", crc);
910 911 912 913 914 915 916 917 918
                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;
            }
919
            if (avctx->debug & FF_DEBUG_PICT_INFO) {
920
                av_log(avctx, AV_LOG_DEBUG, "slice %d, CRC: 0x%08"PRIX32"\n", i, AV_RB32(buf_p + v - 4));
921
            }
922 923 924 925 926
        }

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

929
        fs->avctx = avctx;
930
        fs->cur = p;
931 932
    }

933 934 935 936
    avctx->execute(avctx,
                   decode_slice,
                   &f->slice_context[0],
                   NULL,
937
                   f->slice_count,
938
                   sizeof(void*));
939

940 941
    for (i = f->slice_count - 1; i >= 0; i--) {
        FFV1Context *fs = f->slice_context[i];
942
        int j;
943
        if (fs->slice_damaged && f->last_picture.f->data[0]) {
944
            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
945 946
            const uint8_t *src[4];
            uint8_t *dst[4];
947
            ff_thread_await_progress(&f->last_picture, INT_MAX, 0);
948
            for (j = 0; j < desc->nb_components; j++) {
949
                int pixshift = desc->comp[j].depth > 8;
950 951
                int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
                int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
952
                dst[j] = p->data[j] + p->linesize[j] *
953
                         (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
954
                src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
955
                         (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
956 957 958

            }
            if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
959
                desc->flags & FF_PSEUDOPAL) {
960 961
                dst[1] = p->data[1];
                src[1] = f->last_picture.f->data[1];
962
            }
963
            av_image_copy(dst, p->linesize, src,
964
                          f->last_picture.f->linesize,
965 966
                          avctx->pix_fmt,
                          fs->slice_width,
967
                          fs->slice_height);
968 969
        }
    }
970
    ff_thread_report_progress(&f->picture, INT_MAX, 0);
971 972 973

    f->picture_number++;

974 975
    if (f->last_picture.f)
        ff_thread_release_buffer(avctx, &f->last_picture);
976
    f->cur = NULL;
977 978
    if ((ret = av_frame_ref(data, f->picture.f)) < 0)
        return ret;
979

980
    *got_frame = 1;
981 982 983 984

    return buf_size;
}

985
#if HAVE_THREADS
986 987 988
static int init_thread_copy(AVCodecContext *avctx)
{
    FFV1Context *f = avctx->priv_data;
989
    int i, ret;
990

991 992 993
    f->picture.f      = NULL;
    f->last_picture.f = NULL;
    f->sample_buffer  = NULL;
994
    f->max_slice_count = 0;
995 996
    f->slice_count = 0;

997 998 999 1000 1001 1002
    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]));
    }

1003 1004 1005
    f->picture.f      = av_frame_alloc();
    f->last_picture.f = av_frame_alloc();

1006
    if ((ret = ff_ffv1_init_slice_contexts(f)) < 0)
1007 1008
        return ret;

1009 1010
    return 0;
}
1011
#endif
1012

1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
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;
    }
}

1041
#if HAVE_THREADS
1042 1043 1044 1045 1046 1047 1048 1049 1050
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;

1051
    {
1052 1053 1054 1055 1056 1057
        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));

1058
        memcpy(fdst, fsrc, sizeof(*fdst));
1059 1060 1061 1062
        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;
1063 1064 1065 1066 1067 1068 1069
        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);
1070 1071
    }

1072
    av_assert1(fdst->max_slice_count == fsrc->max_slice_count);
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082


    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;

1083 1084
    return 0;
}
1085
#endif
1086

1087 1088
AVCodec ff_ffv1_decoder = {
    .name           = "ffv1",
1089
    .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1090 1091 1092 1093
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_FFV1,
    .priv_data_size = sizeof(FFV1Context),
    .init           = decode_init,
1094
    .close          = ff_ffv1_close,
1095
    .decode         = decode_frame,
1096 1097
    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
    .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
1098
    .capabilities   = AV_CODEC_CAP_DR1 /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/ |
1099
                      AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
1100
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP
1101
};