ffv1dec.c 37.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 95 96 97 98 99
            v, state->bias, state->error_sum, state->drift, state->count, k);

#if 0 // JPEG LS
    if (k == 0 && 2 * state->drift <= -state->count)
        v ^= (-1);
#else
    v ^= ((2 * state->drift + state->count) >> 31);
#endif

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

    update_vlc_state(state, v);

    return ret;
}

100 101 102 103 104
#define TYPE int16_t
#define RENAME(name) name
#include "ffv1dec_template.c"
#undef TYPE
#undef RENAME
105

106 107 108
#define TYPE int32_t
#define RENAME(name) name ## 32
#include "ffv1dec_template.c"
109 110

static void decode_plane(FFV1Context *s, uint8_t *src,
111 112
                         int w, int h, int stride, int plane_index,
                         int pixel_stride)
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
{
    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++)
136
                src[x*pixel_stride + stride * y] = sample[1][x];
137 138 139 140
        } 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++) {
141
                    ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x];
142 143 144
                }
            } else {
                for (x = 0; x < w; x++) {
145
                    ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
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 175 176 177 178 179
                }
            }
        }
// 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);
180
        if (idx >= (unsigned)f->quant_table_count) {
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
            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) {
197 198
        f->cur->interlaced_frame = 1;
        f->cur->top_field_first  = 1;
199
    } else if (ps == 2) {
200 201
        f->cur->interlaced_frame = 1;
        f->cur->top_field_first  = 0;
202
    } else if (ps == 3) {
203
        f->cur->interlaced_frame = 0;
204
    }
205 206
    f->cur->sample_aspect_ratio.num = get_symbol(c, state, 0);
    f->cur->sample_aspect_ratio.den = get_symbol(c, state, 0);
207

208 209 210 211 212 213 214 215
    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 };
    }

216 217 218
    if (fs->version > 3) {
        fs->slice_reset_contexts = get_rac(c, state);
        fs->slice_coding_mode = get_symbol(c, state, 0);
219
        if (fs->slice_coding_mode != 1) {
220 221 222
            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) {
223 224 225 226
                av_log(f->avctx, AV_LOG_ERROR, "slice_rct_y_coef out of range\n");
                return AVERROR_INVALIDDATA;
            }
        }
227
    }
228

229 230 231 232 233
    return 0;
}

static int decode_slice(AVCodecContext *c, void *arg)
{
234 235
    FFV1Context *fs   = *(void **)arg;
    FFV1Context *f    = fs->avctx->priv_data;
236
    int width, height, x, y, ret;
237
    const int ps      = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step;
238
    AVFrame * const p = f->cur;
239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
    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) {
267
                pdst->state = av_malloc_array(CONTEXT_SIZE,  psrc->context_count);
268 269
                memcpy(pdst->state, psrc->state, CONTEXT_SIZE * psrc->context_count);
            } else {
270
                pdst->vlc_state = av_malloc_array(sizeof(*pdst->vlc_state), psrc->context_count);
271 272 273 274
                memcpy(pdst->vlc_state, psrc->vlc_state, sizeof(*pdst->vlc_state) * psrc->context_count);
            }
        }
    }
275

276 277
    fs->slice_rct_by_coef = 1;
    fs->slice_rct_ry_coef = 1;
278

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

293 294 295 296
    width  = fs->slice_width;
    height = fs->slice_height;
    x      = fs->slice_x;
    y      = fs->slice_y;
297

298
    if (fs->ac == AC_GOLOMB_RICE) {
299
        if (f->version == 3 && f->micro_version > 1 || f->version > 3)
300 301
            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;
302 303 304 305 306 307
        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);
308
    if (f->colorspace == 0 && (f->chroma_planes || !fs->transparency)) {
309 310
        const int chroma_width  = AV_CEIL_RSHIFT(width,  f->chroma_h_shift);
        const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift);
311 312
        const int cx            = x >> f->chroma_h_shift;
        const int cy            = y >> f->chroma_v_shift;
313
        decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1);
314 315

        if (f->chroma_planes) {
316 317
            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);
318 319
        }
        if (fs->transparency)
320 321 322 323
            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);
324 325 326 327 328
    } 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);
329
    } else {
330 331 332
        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] };
333 334
        decode_rgb_frame(fs, planes, width, height, p->linesize);
    }
335
    if (fs->ac != AC_GOLOMB_RICE && f->version > 2) {
336
        int v;
337
        get_rac(&fs->c, (uint8_t[]) { 129 });
338 339 340 341 342 343 344 345 346
        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();

347 348
    ff_thread_report_progress(&f->picture, si, 0);

349 350 351 352 353 354 355 356 357 358 359 360 361 362
    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;

363
        if (len > 128 - i || !len)
Luca Barbato's avatar
Luca Barbato committed
364
            return AVERROR_INVALIDDATA;
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385

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

static int read_extra_header(FFV1Context *f)
{
    RangeCoder *const c = &f->c;
    uint8_t state[CONTEXT_SIZE];
401
    int i, j, k, ret;
402
    uint8_t state2[32][CONTEXT_SIZE];
403
    unsigned crc = 0;
404 405 406 407 408 409 410 411

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

424
    if (f->ac == AC_RANGE_CUSTOM_TAB) {
425 426
        for (i = 1; i < 256; i++)
            f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
427
    }
428

429
    f->colorspace                 = get_symbol(c, state, 0); //YUV cs type
430
    f->avctx->bits_per_raw_sample = get_symbol(c, state, 0);
431 432 433 434
    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);
435
    f->plane_count                = 1 + (f->chroma_planes || f->version<4) + f->transparency;
436 437
    f->num_h_slices               = 1 + get_symbol(c, state, 0);
    f->num_v_slices               = 1 + get_symbol(c, state, 0);
438

439 440 441 442 443 444
    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;
    }

445 446 447 448
    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
449
        return AVERROR_INVALIDDATA;
450 451 452
    }

    f->quant_table_count = get_symbol(c, state, 0);
453 454
    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);
455
        f->quant_table_count = 0;
Luca Barbato's avatar
Luca Barbato committed
456
        return AVERROR_INVALIDDATA;
457
    }
458 459 460 461 462

    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");
463
            return AVERROR_INVALIDDATA;
464 465
        }
    }
466
    if ((ret = ff_ffv1_allocate_initial_states(f)) < 0)
467
        return ret;
468 469

    for (i = 0; i < f->quant_table_count; i++)
470
        if (get_rac(c, state)) {
471 472 473 474 475 476
            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;
                }
477
        }
478 479 480

    if (f->version > 2) {
        f->ec = get_symbol(c, state, 0);
481
        if (f->micro_version > 2)
482
            f->intra = get_symbol(c, state, 0);
483 484 485 486
    }

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

496 497
    if (f->avctx->debug & FF_DEBUG_PICT_INFO)
        av_log(f->avctx, AV_LOG_DEBUG,
498
               "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",
499
               f->version, f->micro_version,
500 501 502 503 504 505 506 507
               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,
508 509
               f->intra,
               crc
510
              );
511 512 513 514 515 516 517 518 519 520 521 522
    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) {
523
        int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample;
524 525 526 527 528 529
        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;
530
        f->ac = get_symbol(c, state, 0);
531

532
        if (f->ac == AC_RANGE_CUSTOM_TAB) {
533 534
            for (i = 1; i < 256; i++)
                f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
535 536
        }

537
        colorspace          = get_symbol(c, state, 0); //YUV cs type
538
        bits_per_raw_sample = f->version > 0 ? get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample;
539 540 541 542
        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);
543 544
        if (colorspace == 0 && f->avctx->skip_alpha)
            transparency = 0;
545 546

        if (f->plane_count) {
547 548 549 550 551 552
            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) {
553 554 555 556 557
                av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n");
                return AVERROR_INVALIDDATA;
            }
        }

558 559 560 561 562 563
        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;
        }

564
        f->colorspace                 = colorspace;
565
        f->avctx->bits_per_raw_sample = bits_per_raw_sample;
566 567 568 569
        f->chroma_planes              = chroma_planes;
        f->chroma_h_shift             = chroma_h_shift;
        f->chroma_v_shift             = chroma_v_shift;
        f->transparency               = transparency;
570

571 572 573 574 575 576 577 578 579
        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;
            else
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
580 581 582 583 584
        } 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);
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
        } 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;
            }
600
        } else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) {
601 602 603 604 605 606
            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;
            }
607 608 609 610 611 612 613
        } 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;
            }
614
        } else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) {
615 616 617 618 619 620
            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;
            }
621 622 623 624 625 626 627
        } 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;
            }
628
        } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){
629 630 631 632 633
            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;
            }
634 635 636 637 638 639
        } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){
            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;
            }
640 641 642 643 644
        }
    } 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
645
            return AVERROR(ENOSYS);
646
        }
647 648 649 650 651
        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)
652
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP9;
653
        else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency)
654
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP10;
655
        else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency)
656
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP12;
657
        else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency)
658
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP14;
659 660 661 662
        else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency) {
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP16;
            f->use32bit = 1;
        }
663 664
    } else {
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
Luca Barbato's avatar
Luca Barbato committed
665
        return AVERROR(ENOSYS);
666
    }
667 668 669 670
    if (f->avctx->pix_fmt == AV_PIX_FMT_NONE) {
        av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
        return AVERROR(ENOSYS);
    }
671

672
    ff_dlog(f->avctx, "%d %d %d\n",
673 674 675 676 677
            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");
678
            return AVERROR_INVALIDDATA;
679
        }
680
        f->slice_count = f->max_slice_count;
681 682 683 684
    } else if (f->version < 3) {
        f->slice_count = get_symbol(c, state, 0);
    } else {
        const uint8_t *p = c->bytestream_end;
685 686 687
        for (f->slice_count = 0;
             f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start;
             f->slice_count++) {
688 689 690 691 692 693 694
            int trailer = 3 + 5*!!f->ec;
            int size = AV_RB24(p-trailer);
            if (size + trailer > p - c->bytestream_start)
                break;
            p -= size + trailer;
        }
    }
695 696
    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);
697
        return AVERROR_INVALIDDATA;
698 699 700 701
    }

    for (j = 0; j < f->slice_count; j++) {
        FFV1Context *fs = f->slice_context[j];
702
        fs->ac            = f->ac;
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
        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
719
                return AVERROR_INVALIDDATA;
720 721
            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
722
                return AVERROR_INVALIDDATA;
723 724 725 726 727 728 729 730 731 732
        }

        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
733
                    return AVERROR_INVALIDDATA;
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
                }
                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
759
    int ret;
760

761
    if ((ret = ff_ffv1_common_init(avctx)) < 0)
762
        return ret;
763

764
    if (avctx->extradata_size > 0 && (ret = read_extra_header(f)) < 0)
Luca Barbato's avatar
Luca Barbato committed
765
        return ret;
766

767
    if ((ret = ff_ffv1_init_slice_contexts(f)) < 0)
Luca Barbato's avatar
Luca Barbato committed
768
        return ret;
769

770 771
    avctx->internal->allocate_progress = 1;

772 773 774
    return 0;
}

775
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
776
{
777
    uint8_t *buf        = avpkt->data;
778 779 780
    int buf_size        = avpkt->size;
    FFV1Context *f      = avctx->priv_data;
    RangeCoder *const c = &f->slice_context[0]->c;
781
    int i, ret;
782
    uint8_t keystate = 128;
783
    uint8_t *buf_p;
784
    AVFrame *p;
785

786 787 788 789 790
    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;
791

792 793 794 795 796 797 798
    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;
    }

799
    f->avctx = avctx;
800 801 802
    ff_init_range_decoder(c, buf, buf_size);
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);

803
    p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P
804
    if (get_rac(c, &keystate)) {
805
        p->key_frame    = 1;
806
        f->key_frame_ok = 0;
Luca Barbato's avatar
Luca Barbato committed
807 808
        if ((ret = read_header(f)) < 0)
            return ret;
809 810 811
        f->key_frame_ok = 1;
    } else {
        if (!f->key_frame_ok) {
812
            av_log(avctx, AV_LOG_ERROR,
Diego Biurrun's avatar
Diego Biurrun committed
813
                   "Cannot decode non-keyframe without valid keyframe\n");
814 815
            return AVERROR_INVALIDDATA;
        }
816
        p->key_frame = 0;
817 818
    }

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

822
    if (avctx->debug & FF_DEBUG_PICT_INFO)
823 824 825
        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);

826 827
    ff_thread_finish_setup(avctx);

828 829 830 831 832 833
    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;

834 835
        if (i || f->version > 2) v = AV_RB24(buf_p-trailer) + trailer;
        else                     v = buf_p - c->bytestream_start;
836 837
        if (buf_p - c->bytestream_start < v) {
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
838
            ff_thread_report_progress(&f->picture, INT_MAX, 0);
Luca Barbato's avatar
Luca Barbato committed
839
            return AVERROR_INVALIDDATA;
840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
        }
        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;
            }
857 858 859
            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));
            }
860 861 862 863 864
        }

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

867
        fs->avctx = avctx;
868
        fs->cur = p;
869 870
    }

871 872 873 874
    avctx->execute(avctx,
                   decode_slice,
                   &f->slice_context[0],
                   NULL,
875
                   f->slice_count,
876
                   sizeof(void*));
877

878 879
    for (i = f->slice_count - 1; i >= 0; i--) {
        FFV1Context *fs = f->slice_context[i];
880
        int j;
881
        if (fs->slice_damaged && f->last_picture.f->data[0]) {
882
            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
883 884
            const uint8_t *src[4];
            uint8_t *dst[4];
885
            ff_thread_await_progress(&f->last_picture, INT_MAX, 0);
886
            for (j = 0; j < 4; j++) {
887
                int pixshift = desc->comp[j].depth > 8;
888 889
                int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
                int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
890
                dst[j] = p->data[j] + p->linesize[j] *
891
                         (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
892
                src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] *
893
                         (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift);
894
            }
895
            av_image_copy(dst, p->linesize, src,
896
                          f->last_picture.f->linesize,
897 898
                          avctx->pix_fmt,
                          fs->slice_width,
899
                          fs->slice_height);
900 901
        }
    }
902
    ff_thread_report_progress(&f->picture, INT_MAX, 0);
903 904 905

    f->picture_number++;

906 907
    if (f->last_picture.f)
        ff_thread_release_buffer(avctx, &f->last_picture);
908
    f->cur = NULL;
909 910
    if ((ret = av_frame_ref(data, f->picture.f)) < 0)
        return ret;
911

912
    *got_frame = 1;
913 914 915 916

    return buf_size;
}

917
#if HAVE_THREADS
918 919 920
static int init_thread_copy(AVCodecContext *avctx)
{
    FFV1Context *f = avctx->priv_data;
921
    int i, ret;
922

923 924 925
    f->picture.f      = NULL;
    f->last_picture.f = NULL;
    f->sample_buffer  = NULL;
926
    f->max_slice_count = 0;
927 928
    f->slice_count = 0;

929 930 931 932 933 934
    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]));
    }

935 936 937
    f->picture.f      = av_frame_alloc();
    f->last_picture.f = av_frame_alloc();

938
    if ((ret = ff_ffv1_init_slice_contexts(f)) < 0)
939 940
        return ret;

941 942
    return 0;
}
943
#endif
944

945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972
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;
    }
}

973
#if HAVE_THREADS
974 975 976 977 978 979 980 981 982
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;

983
    {
984 985 986 987 988 989
        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));

990
        memcpy(fdst, fsrc, sizeof(*fdst));
991 992 993 994
        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;
995 996 997 998 999 1000 1001
        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);
1002 1003
    }

1004
    av_assert1(fdst->max_slice_count == fsrc->max_slice_count);
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014


    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;

1015 1016
    return 0;
}
1017
#endif
1018

1019 1020
AVCodec ff_ffv1_decoder = {
    .name           = "ffv1",
1021
    .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1022 1023 1024 1025
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_FFV1,
    .priv_data_size = sizeof(FFV1Context),
    .init           = decode_init,
1026
    .close          = ff_ffv1_close,
1027
    .decode         = decode_frame,
1028 1029
    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
    .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
1030
    .capabilities   = AV_CODEC_CAP_DR1 /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/ |
1031
                      AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
1032
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP
1033
};