← Back to branch summary

~siretart/libav/trusty-security

« back to all changes in this revision

Viewing changes to libavcodec/ffv1dec.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2013-10-22 23:24:08 UTC
  • mfrom: (1.3.36 sid)
  • Revision ID: package-import@ubuntu.com-20131022232408-b8tvvn4pyzri9mi3
Tags: 6:9.10-1ubuntu1
https://launchpad.net/bugs/1243235
https://launchpad.net/bugs/1180288
https://launchpad.net/bugs/1242802
* Build all -extra flavors from this source package, as libav got demoted
  from main to universe, cf LP: #1243235
* Simplify debian/rules to follow exactly the code that debian executes
* New upstream (LP: #1180288) fixes lots of security issues (LP: #1242802)
* Merge from unstable, remaining changes:
  - build-depend on libtiff5-dev rather than libtiff4-dev,
    avoids FTBFS caused by imlib
  - follow the regular debian codepaths

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/ffv1dec.c
 
1
/*
 
2
 * FFV1 decoder
 
3
 *
 
4
 * Copyright (c) 2003-2012 Michael Niedermayer <michaelni@gmx.at>
 
5
 *
 
6
 * This file is part of Libav.
 
7
 *
 
8
 * Libav is free software; you can redistribute it and/or
 
9
 * modify it under the terms of the GNU Lesser General Public
 
10
 * License as published by the Free Software Foundation; either
 
11
 * version 2.1 of the License, or (at your option) any later version.
 
12
 *
 
13
 * Libav is distributed in the hope that it will be useful,
 
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
16
 * Lesser General Public License for more details.
 
17
 *
 
18
 * You should have received a copy of the GNU Lesser General Public
 
19
 * License along with Libav; if not, write to the Free Software
 
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
21
 */
 
22
 
 
23
/**
 
24
 * @file
 
25
 * FF Video Codec 1 (a lossless codec) decoder
 
26
 */
 
27
 
 
28
#include "libavutil/avassert.h"
 
29
#include "libavutil/pixdesc.h"
 
30
#include "libavutil/crc.h"
 
31
#include "libavutil/opt.h"
 
32
#include "libavutil/imgutils.h"
 
33
#include "avcodec.h"
 
34
#include "internal.h"
 
35
#include "get_bits.h"
 
36
#include "put_bits.h"
 
37
#include "dsputil.h"
 
38
#include "rangecoder.h"
 
39
#include "golomb.h"
 
40
#include "mathops.h"
 
41
#include "ffv1.h"
 
42
 
 
43
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state,
 
44
                                               int is_signed)
 
45
{
 
46
    if (get_rac(c, state + 0))
 
47
        return 0;
 
48
    else {
 
49
        int i, e, a;
 
50
        e = 0;
 
51
        while (get_rac(c, state + 1 + FFMIN(e, 9))) // 1..10
 
52
            e++;
 
53
 
 
54
        a = 1;
 
55
        for (i = e - 1; i >= 0; i--)
 
56
            a += a + get_rac(c, state + 22 + FFMIN(i, 9));  // 22..31
 
57
 
 
58
        e = -(is_signed && get_rac(c, state + 11 + FFMIN(e, 10))); // 11..21
 
59
        return (a ^ e) - e;
 
60
    }
 
61
}
 
62
 
 
63
static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed)
 
64
{
 
65
    return get_symbol_inline(c, state, is_signed);
 
66
}
 
67
 
 
68
static inline int get_vlc_symbol(GetBitContext *gb, VlcState *const state,
 
69
                                 int bits)
 
70
{
 
71
    int k, i, v, ret;
 
72
 
 
73
    i = state->count;
 
74
    k = 0;
 
75
    while (i < state->error_sum) { // FIXME: optimize
 
76
        k++;
 
77
        i += i;
 
78
    }
 
79
 
 
80
    assert(k <= 8);
 
81
 
 
82
    v = get_sr_golomb(gb, k, 12, bits);
 
83
    av_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
 
84
            v, state->bias, state->error_sum, state->drift, state->count, k);
 
85
 
 
86
#if 0 // JPEG LS
 
87
    if (k == 0 && 2 * state->drift <= -state->count)
 
88
        v ^= (-1);
 
89
#else
 
90
    v ^= ((2 * state->drift + state->count) >> 31);
 
91
#endif
 
92
 
 
93
    ret = fold(v + state->bias, bits);
 
94
 
 
95
    update_vlc_state(state, v);
 
96
 
 
97
    return ret;
 
98
}
 
99
 
 
100
static av_always_inline void decode_line(FFV1Context *s, int w,
 
101
                                         int16_t *sample[2],
 
102
                                         int plane_index, int bits)
 
103
{
 
104
    PlaneContext *const p = &s->plane[plane_index];
 
105
    RangeCoder *const c   = &s->c;
 
106
    int x;
 
107
    int run_count = 0;
 
108
    int run_mode  = 0;
 
109
    int run_index = s->run_index;
 
110
 
 
111
    for (x = 0; x < w; x++) {
 
112
        int diff, context, sign;
 
113
 
 
114
        context = get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
 
115
        if (context < 0) {
 
116
            context = -context;
 
117
            sign    = 1;
 
118
        } else
 
119
            sign = 0;
 
120
 
 
121
        av_assert2(context < p->context_count);
 
122
 
 
123
        if (s->ac) {
 
124
            diff = get_symbol_inline(c, p->state[context], 1);
 
125
        } else {
 
126
            if (context == 0 && run_mode == 0)
 
127
                run_mode = 1;
 
128
 
 
129
            if (run_mode) {
 
130
                if (run_count == 0 && run_mode == 1) {
 
131
                    if (get_bits1(&s->gb)) {
 
132
                        run_count = 1 << ff_log2_run[run_index];
 
133
                        if (x + run_count <= w)
 
134
                            run_index++;
 
135
                    } else {
 
136
                        if (ff_log2_run[run_index])
 
137
                            run_count = get_bits(&s->gb, ff_log2_run[run_index]);
 
138
                        else
 
139
                            run_count = 0;
 
140
                        if (run_index)
 
141
                            run_index--;
 
142
                        run_mode = 2;
 
143
                    }
 
144
                }
 
145
                run_count--;
 
146
                if (run_count < 0) {
 
147
                    run_mode  = 0;
 
148
                    run_count = 0;
 
149
                    diff      = get_vlc_symbol(&s->gb, &p->vlc_state[context],
 
150
                                               bits);
 
151
                    if (diff >= 0)
 
152
                        diff++;
 
153
                } else
 
154
                    diff = 0;
 
155
            } else
 
156
                diff = get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 
157
 
 
158
            av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
 
159
                    run_count, run_index, run_mode, x, get_bits_count(&s->gb));
 
160
        }
 
161
 
 
162
        if (sign)
 
163
            diff = -diff;
 
164
 
 
165
        sample[1][x] = (predict(sample[1] + x, sample[0] + x) + diff) &
 
166
                       ((1 << bits) - 1);
 
167
    }
 
168
    s->run_index = run_index;
 
169
}
 
170
 
 
171
static void decode_plane(FFV1Context *s, uint8_t *src,
 
172
                         int w, int h, int stride, int plane_index)
 
173
{
 
174
    int x, y;
 
175
    int16_t *sample[2];
 
176
    sample[0] = s->sample_buffer + 3;
 
177
    sample[1] = s->sample_buffer + w + 6 + 3;
 
178
 
 
179
    s->run_index = 0;
 
180
 
 
181
    memset(s->sample_buffer, 0, 2 * (w + 6) * sizeof(*s->sample_buffer));
 
182
 
 
183
    for (y = 0; y < h; y++) {
 
184
        int16_t *temp = sample[0]; // FIXME: try a normal buffer
 
185
 
 
186
        sample[0] = sample[1];
 
187
        sample[1] = temp;
 
188
 
 
189
        sample[1][-1] = sample[0][0];
 
190
        sample[0][w]  = sample[0][w - 1];
 
191
 
 
192
// { START_TIMER
 
193
        if (s->avctx->bits_per_raw_sample <= 8) {
 
194
            decode_line(s, w, sample, plane_index, 8);
 
195
            for (x = 0; x < w; x++)
 
196
                src[x + stride * y] = sample[1][x];
 
197
        } else {
 
198
            decode_line(s, w, sample, plane_index,
 
199
                        s->avctx->bits_per_raw_sample);
 
200
            if (s->packed_at_lsb) {
 
201
                for (x = 0; x < w; x++)
 
202
                    ((uint16_t *)(src + stride * y))[x] = sample[1][x];
 
203
            } else {
 
204
                for (x = 0; x < w; x++)
 
205
                    ((uint16_t *)(src + stride * y))[x] = sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
 
206
            }
 
207
        }
 
208
// STOP_TIMER("decode-line") }
 
209
    }
 
210
}
 
211
 
 
212
static void decode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h,
 
213
                             int stride[3])
 
214
{
 
215
    int x, y, p;
 
216
    int16_t *sample[4][2];
 
217
    int lbd  = s->avctx->bits_per_raw_sample <= 8;
 
218
    int bits = s->avctx->bits_per_raw_sample > 0
 
219
               ? s->avctx->bits_per_raw_sample
 
220
               : 8;
 
221
    int offset = 1 << bits;
 
222
 
 
223
    for (x = 0; x < 4; x++) {
 
224
        sample[x][0] = s->sample_buffer +  x * 2      * (w + 6) + 3;
 
225
        sample[x][1] = s->sample_buffer + (x * 2 + 1) * (w + 6) + 3;
 
226
    }
 
227
 
 
228
    s->run_index = 0;
 
229
 
 
230
    memset(s->sample_buffer, 0, 8 * (w + 6) * sizeof(*s->sample_buffer));
 
231
 
 
232
    for (y = 0; y < h; y++) {
 
233
        for (p = 0; p < 3 + s->transparency; p++) {
 
234
            int16_t *temp = sample[p][0]; //FIXME try a normal buffer
 
235
 
 
236
            sample[p][0] = sample[p][1];
 
237
            sample[p][1] = temp;
 
238
 
 
239
            sample[p][1][-1] = sample[p][0][0];
 
240
            sample[p][0][w]  = sample[p][0][w - 1];
 
241
            if (lbd)
 
242
                decode_line(s, w, sample[p], (p + 1) / 2, 9);
 
243
            else
 
244
                decode_line(s, w, sample[p], (p + 1) / 2, bits + 1);
 
245
        }
 
246
        for (x = 0; x < w; x++) {
 
247
            int g = sample[0][1][x];
 
248
            int b = sample[1][1][x];
 
249
            int r = sample[2][1][x];
 
250
            int a = sample[3][1][x];
 
251
 
 
252
            b -= offset;
 
253
            r -= offset;
 
254
            g -= (b + r) >> 2;
 
255
            b += g;
 
256
            r += g;
 
257
 
 
258
            if (lbd)
 
259
                *((uint32_t *)(src[0] + x * 4 + stride[0] * y)) = b +
 
260
                    (g << 8) + (r << 16) + (a << 24);
 
261
            else {
 
262
                *((uint16_t *)(src[0] + x * 2 + stride[0] * y)) = b;
 
263
                *((uint16_t *)(src[1] + x * 2 + stride[1] * y)) = g;
 
264
                *((uint16_t *)(src[2] + x * 2 + stride[2] * y)) = r;
 
265
            }
 
266
        }
 
267
    }
 
268
}
 
269
 
 
270
static int decode_slice_header(FFV1Context *f, FFV1Context *fs)
 
271
{
 
272
    RangeCoder *c = &fs->c;
 
273
    uint8_t state[CONTEXT_SIZE];
 
274
    unsigned ps, i, context_count;
 
275
    memset(state, 128, sizeof(state));
 
276
 
 
277
    if (fs->ac > 1) {
 
278
        for (i = 1; i < 256; i++) {
 
279
            fs->c.one_state[i]        = f->state_transition[i];
 
280
            fs->c.zero_state[256 - i] = 256 - fs->c.one_state[i];
 
281
        }
 
282
    }
 
283
 
 
284
    fs->slice_x      = get_symbol(c, state, 0) * f->width;
 
285
    fs->slice_y      = get_symbol(c, state, 0) * f->height;
 
286
    fs->slice_width  = (get_symbol(c, state, 0) + 1) * f->width + fs->slice_x;
 
287
    fs->slice_height = (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y;
 
288
 
 
289
    fs->slice_x     /= f->num_h_slices;
 
290
    fs->slice_y     /= f->num_v_slices;
 
291
    fs->slice_width  = fs->slice_width / f->num_h_slices - fs->slice_x;
 
292
    fs->slice_height = fs->slice_height / f->num_v_slices - fs->slice_y;
 
293
    if ((unsigned)fs->slice_width  > f->width ||
 
294
        (unsigned)fs->slice_height > f->height)
 
295
        return AVERROR_INVALIDDATA;
 
296
    if ((unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width ||
 
297
        (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
 
298
        return AVERROR_INVALIDDATA;
 
299
 
 
300
    for (i = 0; i < f->plane_count; i++) {
 
301
        PlaneContext *const p = &fs->plane[i];
 
302
        int idx               = get_symbol(c, state, 0);
 
303
        if (idx > (unsigned)f->quant_table_count) {
 
304
            av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
 
305
            return AVERROR_INVALIDDATA;
 
306
        }
 
307
        p->quant_table_index = idx;
 
308
        memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
 
309
        context_count = f->context_count[idx];
 
310
 
 
311
        if (p->context_count < context_count) {
 
312
            av_freep(&p->state);
 
313
            av_freep(&p->vlc_state);
 
314
        }
 
315
        p->context_count = context_count;
 
316
    }
 
317
 
 
318
    ps = get_symbol(c, state, 0);
 
319
    if (ps == 1) {
 
320
        f->picture.interlaced_frame = 1;
 
321
        f->picture.top_field_first  = 1;
 
322
    } else if (ps == 2) {
 
323
        f->picture.interlaced_frame = 1;
 
324
        f->picture.top_field_first  = 0;
 
325
    } else if (ps == 3) {
 
326
        f->picture.interlaced_frame = 0;
 
327
    }
 
328
    f->picture.sample_aspect_ratio.num = get_symbol(c, state, 0);
 
329
    f->picture.sample_aspect_ratio.den = get_symbol(c, state, 0);
 
330
 
 
331
    return 0;
 
332
}
 
333
 
 
334
static int decode_slice(AVCodecContext *c, void *arg)
 
335
{
 
336
    FFV1Context *fs = *(void **)arg;
 
337
    FFV1Context *f  = fs->avctx->priv_data;
 
338
    int width, height, x, y, ret;
 
339
    const int ps = (av_pix_fmt_desc_get(c->pix_fmt)->flags & PIX_FMT_PLANAR)
 
340
                   ? (c->bits_per_raw_sample > 8) + 1
 
341
                   : 4;
 
342
    AVFrame *const p = &f->picture;
 
343
 
 
344
    if (f->version > 2) {
 
345
        if (decode_slice_header(f, fs) < 0) {
 
346
            fs->slice_damaged = 1;
 
347
            return AVERROR_INVALIDDATA;
 
348
        }
 
349
    }
 
350
    if ((ret = ffv1_init_slice_state(f, fs)) < 0)
 
351
        return ret;
 
352
    if (f->picture.key_frame)
 
353
        ffv1_clear_slice_state(f, fs);
 
354
    width  = fs->slice_width;
 
355
    height = fs->slice_height;
 
356
    x      = fs->slice_x;
 
357
    y      = fs->slice_y;
 
358
 
 
359
    if (!fs->ac) {
 
360
        if (f->version == 3 && f->minor_version > 1 || f->version > 3)
 
361
            get_rac(&fs->c, (uint8_t[]) { 129 });
 
362
        fs->ac_byte_count = f->version > 2 || (!x && !y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0;
 
363
        init_get_bits(&fs->gb, fs->c.bytestream_start + fs->ac_byte_count,
 
364
                      (fs->c.bytestream_end - fs->c.bytestream_start -
 
365
                       fs->ac_byte_count) * 8);
 
366
    }
 
367
 
 
368
    av_assert1(width && height);
 
369
    if (f->colorspace == 0) {
 
370
        const int chroma_width  = -((-width) >> f->chroma_h_shift);
 
371
        const int chroma_height = -((-height) >> f->chroma_v_shift);
 
372
        const int cx            = x >> f->chroma_h_shift;
 
373
        const int cy            = y >> f->chroma_v_shift;
 
374
        decode_plane(fs, p->data[0] + ps * x + y * p->linesize[0], width,
 
375
                     height, p->linesize[0],
 
376
                     0);
 
377
 
 
378
        if (f->chroma_planes) {
 
379
            decode_plane(fs, p->data[1] + ps * cx + cy * p->linesize[1],
 
380
                         chroma_width, chroma_height, p->linesize[1],
 
381
                         1);
 
382
            decode_plane(fs, p->data[2] + ps * cx + cy * p->linesize[2],
 
383
                         chroma_width, chroma_height, p->linesize[2],
 
384
                         1);
 
385
        }
 
386
        if (fs->transparency)
 
387
            decode_plane(fs, p->data[3] + ps * x + y * p->linesize[3], width,
 
388
                         height, p->linesize[3],
 
389
                         2);
 
390
    } else {
 
391
        uint8_t *planes[3] = { p->data[0] + ps * x + y * p->linesize[0],
 
392
                               p->data[1] + ps * x + y * p->linesize[1],
 
393
                               p->data[2] + ps * x + y * p->linesize[2] };
 
394
        decode_rgb_frame(fs, planes, width, height, p->linesize);
 
395
    }
 
396
    if (fs->ac && f->version > 2) {
 
397
        int v;
 
398
        get_rac(&fs->c, (uint8_t[]) { 129 });
 
399
        v = fs->c.bytestream_end - fs->c.bytestream - 2 - 5 * f->ec;
 
400
        if (v) {
 
401
            av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n",
 
402
                   v);
 
403
            fs->slice_damaged = 1;
 
404
        }
 
405
    }
 
406
 
 
407
    emms_c();
 
408
 
 
409
    return 0;
 
410
}
 
411
 
 
412
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale)
 
413
{
 
414
    int v;
 
415
    int i = 0;
 
416
    uint8_t state[CONTEXT_SIZE];
 
417
 
 
418
    memset(state, 128, sizeof(state));
 
419
 
 
420
    for (v = 0; i < 128; v++) {
 
421
        unsigned len = get_symbol(c, state, 0) + 1;
 
422
 
 
423
        if (len > 128 - i)
 
424
            return -1;
 
425
 
 
426
        while (len--) {
 
427
            quant_table[i] = scale * v;
 
428
            i++;
 
429
        }
 
430
    }
 
431
 
 
432
    for (i = 1; i < 128; i++)
 
433
        quant_table[256 - i] = -quant_table[i];
 
434
    quant_table[128] = -quant_table[127];
 
435
 
 
436
    return 2 * v - 1;
 
437
}
 
438
 
 
439
static int read_quant_tables(RangeCoder *c,
 
440
                             int16_t quant_table[MAX_CONTEXT_INPUTS][256])
 
441
{
 
442
    int i;
 
443
    int context_count = 1;
 
444
 
 
445
    for (i = 0; i < 5; i++) {
 
446
        context_count *= read_quant_table(c, quant_table[i], context_count);
 
447
        if (context_count > 32768U) {
 
448
            return -1;
 
449
        }
 
450
    }
 
451
    return (context_count + 1) / 2;
 
452
}
 
453
 
 
454
static int read_extra_header(FFV1Context *f)
 
455
{
 
456
    RangeCoder *const c = &f->c;
 
457
    uint8_t state[CONTEXT_SIZE];
 
458
    int i, j, k, ret;
 
459
    uint8_t state2[32][CONTEXT_SIZE];
 
460
 
 
461
    memset(state2, 128, sizeof(state2));
 
462
    memset(state, 128, sizeof(state));
 
463
 
 
464
    ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
 
465
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
 
466
 
 
467
    f->version = get_symbol(c, state, 0);
 
468
    if (f->version > 2) {
 
469
        c->bytestream_end -= 4;
 
470
        f->minor_version   = get_symbol(c, state, 0);
 
471
    }
 
472
    f->ac = f->avctx->coder_type = get_symbol(c, state, 0);
 
473
 
 
474
    if (f->ac > 1) {
 
475
        for (i = 1; i < 256; i++)
 
476
            f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i];
 
477
    }
 
478
 
 
479
    f->colorspace                 = get_symbol(c, state, 0); //YUV cs type
 
480
    f->avctx->bits_per_raw_sample = get_symbol(c, state, 0);
 
481
    f->chroma_planes              = get_rac(c, state);
 
482
    f->chroma_h_shift             = get_symbol(c, state, 0);
 
483
    f->chroma_v_shift             = get_symbol(c, state, 0);
 
484
    f->transparency               = get_rac(c, state);
 
485
    f->plane_count                = 2 + f->transparency;
 
486
    f->num_h_slices               = 1 + get_symbol(c, state, 0);
 
487
    f->num_v_slices               = 1 + get_symbol(c, state, 0);
 
488
 
 
489
    if (f->num_h_slices > (unsigned)f->width ||
 
490
        f->num_v_slices > (unsigned)f->height) {
 
491
        av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
 
492
        return AVERROR_INVALIDDATA;
 
493
    }
 
494
 
 
495
    f->quant_table_count = get_symbol(c, state, 0);
 
496
    if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
 
497
        return AVERROR_INVALIDDATA;
 
498
    for (i = 0; i < f->quant_table_count; i++) {
 
499
        f->context_count[i] = read_quant_tables(c, f->quant_tables[i]);
 
500
        if (f->context_count[i] < 0) {
 
501
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
 
502
            return AVERROR_INVALIDDATA;
 
503
        }
 
504
    }
 
505
    if ((ret = ffv1_allocate_initial_states(f)) < 0)
 
506
        return ret;
 
507
 
 
508
    for (i = 0; i < f->quant_table_count; i++)
 
509
        if (get_rac(c, state)) {
 
510
            for (j = 0; j < f->context_count[i]; j++)
 
511
                for (k = 0; k < CONTEXT_SIZE; k++) {
 
512
                    int pred = j ? f->initial_states[i][j - 1][k] : 128;
 
513
                    f->initial_states[i][j][k] =
 
514
                        (pred + get_symbol(c, state2[k], 1)) & 0xFF;
 
515
                }
 
516
        }
 
517
 
 
518
    if (f->version > 2) {
 
519
        f->ec = get_symbol(c, state, 0);
 
520
    }
 
521
 
 
522
    if (f->version > 2) {
 
523
        unsigned v;
 
524
        v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0,
 
525
                   f->avctx->extradata, f->avctx->extradata_size);
 
526
        if (v) {
 
527
            av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v);
 
528
            return AVERROR_INVALIDDATA;
 
529
        }
 
530
    }
 
531
 
 
532
    return 0;
 
533
}
 
534
 
 
535
 
 
536
static int read_header(FFV1Context *f)
 
537
{
 
538
    uint8_t state[CONTEXT_SIZE];
 
539
    int i, j, context_count = -1;
 
540
    RangeCoder *const c = &f->slice_context[0]->c;
 
541
 
 
542
    memset(state, 128, sizeof(state));
 
543
 
 
544
    if (f->version < 2) {
 
545
        unsigned v = get_symbol(c, state, 0);
 
546
        if (v > 1) {
 
547
            av_log(f->avctx, AV_LOG_ERROR,
 
548
                   "invalid version %d in version 1 header\n", v);
 
549
            return AVERROR_INVALIDDATA;
 
550
        }
 
551
        f->version = v;
 
552
 
 
553
        f->ac = f->avctx->coder_type = get_symbol(c, state, 0);
 
554
 
 
555
        if (f->ac > 1) {
 
556
            for (i = 1; i < 256; i++)
 
557
                f->state_transition[i] =
 
558
                    get_symbol(c, state, 1) + c->one_state[i];
 
559
        }
 
560
 
 
561
        f->colorspace = get_symbol(c, state, 0); //YUV cs type
 
562
 
 
563
        if (f->version > 0)
 
564
            f->avctx->bits_per_raw_sample = get_symbol(c, state, 0);
 
565
 
 
566
        f->chroma_planes  = get_rac(c, state);
 
567
        f->chroma_h_shift = get_symbol(c, state, 0);
 
568
        f->chroma_v_shift = get_symbol(c, state, 0);
 
569
        f->transparency   = get_rac(c, state);
 
570
        f->plane_count    = 2 + f->transparency;
 
571
    }
 
572
 
 
573
    if (f->colorspace == 0) {
 
574
        if (!f->transparency && !f->chroma_planes) {
 
575
            if (f->avctx->bits_per_raw_sample <= 8)
 
576
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 
577
            else
 
578
                f->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
 
579
        } else if (f->avctx->bits_per_raw_sample <= 8 && !f->transparency) {
 
580
            switch (16 * f->chroma_h_shift + f->chroma_v_shift) {
 
581
            case 0x00:
 
582
                f->avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 
583
                break;
 
584
            case 0x01:
 
585
                f->avctx->pix_fmt = AV_PIX_FMT_YUV440P;
 
586
                break;
 
587
            case 0x10:
 
588
                f->avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 
589
                break;
 
590
            case 0x11:
 
591
                f->avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 
592
                break;
 
593
            case 0x20:
 
594
                f->avctx->pix_fmt = AV_PIX_FMT_YUV411P;
 
595
                break;
 
596
            case 0x22:
 
597
                f->avctx->pix_fmt = AV_PIX_FMT_YUV410P;
 
598
                break;
 
599
            default:
 
600
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 
601
                return AVERROR(ENOSYS);
 
602
            }
 
603
        } else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency) {
 
604
            switch (16 * f->chroma_h_shift + f->chroma_v_shift) {
 
605
            case 0x00:
 
606
                f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
 
607
                break;
 
608
            case 0x10:
 
609
                f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
 
610
                break;
 
611
            case 0x11:
 
612
                f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
 
613
                break;
 
614
            default:
 
615
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 
616
                return AVERROR(ENOSYS);
 
617
            }
 
618
        } else if (f->avctx->bits_per_raw_sample == 9) {
 
619
            f->packed_at_lsb = 1;
 
620
            switch (16 * f->chroma_h_shift + f->chroma_v_shift) {
 
621
            case 0x00:
 
622
                f->avctx->pix_fmt = AV_PIX_FMT_YUV444P9;
 
623
                break;
 
624
            case 0x10:
 
625
                f->avctx->pix_fmt = AV_PIX_FMT_YUV422P9;
 
626
                break;
 
627
            case 0x11:
 
628
                f->avctx->pix_fmt = AV_PIX_FMT_YUV420P9;
 
629
                break;
 
630
            default:
 
631
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 
632
                return AVERROR(ENOSYS);
 
633
            }
 
634
        } else if (f->avctx->bits_per_raw_sample == 10) {
 
635
            f->packed_at_lsb = 1;
 
636
            switch (16 * f->chroma_h_shift + f->chroma_v_shift) {
 
637
            case 0x00:
 
638
                f->avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
 
639
                break;
 
640
            case 0x10:
 
641
                f->avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
 
642
                break;
 
643
            case 0x11:
 
644
                f->avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
 
645
                break;
 
646
            default:
 
647
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 
648
                return AVERROR(ENOSYS);
 
649
            }
 
650
        } else {
 
651
            switch (16 * f->chroma_h_shift + f->chroma_v_shift) {
 
652
            case 0x00:
 
653
                f->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
 
654
                break;
 
655
            case 0x10:
 
656
                f->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
 
657
                break;
 
658
            case 0x11:
 
659
                f->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
 
660
                break;
 
661
            default:
 
662
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 
663
                return AVERROR(ENOSYS);
 
664
            }
 
665
        }
 
666
    } else if (f->colorspace == 1) {
 
667
        if (f->chroma_h_shift || f->chroma_v_shift) {
 
668
            av_log(f->avctx, AV_LOG_ERROR,
 
669
                   "chroma subsampling not supported in this colorspace\n");
 
670
            return AVERROR(ENOSYS);
 
671
        }
 
672
        switch (f->avctx->bits_per_raw_sample) {
 
673
        case 8:
 
674
            f->avctx->pix_fmt = AV_PIX_FMT_RGB32;
 
675
            break;
 
676
        case 9:
 
677
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP9;
 
678
            break;
 
679
        case 10:
 
680
            f->avctx->pix_fmt = AV_PIX_FMT_GBRP10;
 
681
            break;
 
682
        default:
 
683
            av_log(f->avctx, AV_LOG_ERROR,
 
684
                   "bit depth %d not supported\n",
 
685
                   f->avctx->bits_per_raw_sample);
 
686
            return AVERROR(ENOSYS);
 
687
        }
 
688
    } else {
 
689
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
 
690
        return AVERROR(ENOSYS);
 
691
    }
 
692
 
 
693
    av_dlog(f->avctx, "%d %d %d\n",
 
694
            f->chroma_h_shift, f->chroma_v_shift, f->avctx->pix_fmt);
 
695
    if (f->version < 2) {
 
696
        context_count = read_quant_tables(c, f->quant_table);
 
697
        if (context_count < 0) {
 
698
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
 
699
            return AVERROR_INVALIDDATA;
 
700
        }
 
701
    } else if (f->version < 3) {
 
702
        f->slice_count = get_symbol(c, state, 0);
 
703
    } else {
 
704
        const uint8_t *p = c->bytestream_end;
 
705
        for (f->slice_count = 0;
 
706
             f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start;
 
707
             f->slice_count++) {
 
708
            int trailer = 3 + 5 * !!f->ec;
 
709
            int size    = AV_RB24(p - trailer);
 
710
            if (size + trailer > p - c->bytestream_start)
 
711
                break;
 
712
            p -= size + trailer;
 
713
        }
 
714
    }
 
715
    if (f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0) {
 
716
        av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid\n",
 
717
               f->slice_count);
 
718
        return AVERROR_INVALIDDATA;
 
719
    }
 
720
 
 
721
    for (j = 0; j < f->slice_count; j++) {
 
722
        FFV1Context *fs = f->slice_context[j];
 
723
        fs->ac            = f->ac;
 
724
        fs->packed_at_lsb = f->packed_at_lsb;
 
725
 
 
726
        fs->slice_damaged = 0;
 
727
 
 
728
        if (f->version == 2) {
 
729
            fs->slice_x     = get_symbol(c, state, 0) * f->width;
 
730
            fs->slice_y     = get_symbol(c, state, 0) * f->height;
 
731
            fs->slice_width =
 
732
                (get_symbol(c, state, 0) + 1) * f->width + fs->slice_x;
 
733
            fs->slice_height =
 
734
                (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y;
 
735
 
 
736
            fs->slice_x      /= f->num_h_slices;
 
737
            fs->slice_y      /= f->num_v_slices;
 
738
            fs->slice_width  = fs->slice_width  / f->num_h_slices - fs->slice_x;
 
739
            fs->slice_height = fs->slice_height / f->num_v_slices - fs->slice_y;
 
740
            if ((unsigned)fs->slice_width > f->width ||
 
741
                (unsigned)fs->slice_height > f->height)
 
742
                return AVERROR_INVALIDDATA;
 
743
            if ((unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
 
744
                || (unsigned)fs->slice_y + (uint64_t)fs->slice_height >
 
745
                f->height)
 
746
                return AVERROR_INVALIDDATA;
 
747
        }
 
748
 
 
749
        for (i = 0; i < f->plane_count; i++) {
 
750
            PlaneContext *const p = &fs->plane[i];
 
751
 
 
752
            if (f->version == 2) {
 
753
                int idx = get_symbol(c, state, 0);
 
754
                if (idx > (unsigned)f->quant_table_count) {
 
755
                    av_log(f->avctx, AV_LOG_ERROR,
 
756
                           "quant_table_index out of range\n");
 
757
                    return AVERROR_INVALIDDATA;
 
758
                }
 
759
                p->quant_table_index = idx;
 
760
                memcpy(p->quant_table, f->quant_tables[idx],
 
761
                       sizeof(p->quant_table));
 
762
                context_count = f->context_count[idx];
 
763
            } else {
 
764
                memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
 
765
            }
 
766
 
 
767
            if (f->version <= 2) {
 
768
                av_assert0(context_count >= 0);
 
769
                if (p->context_count < context_count) {
 
770
                    av_freep(&p->state);
 
771
                    av_freep(&p->vlc_state);
 
772
                }
 
773
                p->context_count = context_count;
 
774
            }
 
775
        }
 
776
    }
 
777
    return 0;
 
778
}
 
779
 
 
780
static av_cold int ffv1_decode_init(AVCodecContext *avctx)
 
781
{
 
782
    FFV1Context *f = avctx->priv_data;
 
783
    int ret;
 
784
 
 
785
    ffv1_common_init(avctx);
 
786
 
 
787
    if (avctx->extradata && (ret = read_extra_header(f)) < 0)
 
788
        return ret;
 
789
 
 
790
    if ((ret = ffv1_init_slice_contexts(f)) < 0)
 
791
        return ret;
 
792
 
 
793
    return 0;
 
794
}
 
795
 
 
796
static int ffv1_decode_frame(AVCodecContext *avctx, void *data,
 
797
                             int *got_frame, AVPacket *avpkt)
 
798
{
 
799
    const uint8_t *buf  = avpkt->data;
 
800
    int buf_size        = avpkt->size;
 
801
    FFV1Context *f      = avctx->priv_data;
 
802
    RangeCoder *const c = &f->slice_context[0]->c;
 
803
    AVFrame *const p    = &f->picture;
 
804
    int i, ret;
 
805
    uint8_t keystate = 128;
 
806
    const uint8_t *buf_p;
 
807
 
 
808
    AVFrame *picture = data;
 
809
 
 
810
    /* release previously stored data */
 
811
    if (p->data[0])
 
812
        avctx->release_buffer(avctx, p);
 
813
 
 
814
    ff_init_range_decoder(c, buf, buf_size);
 
815
    ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);
 
816
 
 
817
    p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P
 
818
    if (get_rac(c, &keystate)) {
 
819
        p->key_frame    = 1;
 
820
        f->key_frame_ok = 0;
 
821
        if ((ret = read_header(f)) < 0)
 
822
            return ret;
 
823
        f->key_frame_ok = 1;
 
824
    } else {
 
825
        if (!f->key_frame_ok) {
 
826
            av_log(avctx, AV_LOG_ERROR,
 
827
                   "Cannot decode non-keyframe without valid keyframe\n");
 
828
            return AVERROR_INVALIDDATA;
 
829
        }
 
830
        p->key_frame = 0;
 
831
    }
 
832
 
 
833
    p->reference = 3; //for error concealment
 
834
    if ((ret = ff_get_buffer(avctx, p)) < 0) {
 
835
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 
836
        return ret;
 
837
    }
 
838
 
 
839
    if (avctx->debug & FF_DEBUG_PICT_INFO)
 
840
        av_log(avctx, AV_LOG_DEBUG,
 
841
               "ver:%d keyframe:%d coder:%d ec:%d slices:%d bps:%d\n",
 
842
               f->version, p->key_frame, f->ac, f->ec, f->slice_count,
 
843
               f->avctx->bits_per_raw_sample);
 
844
 
 
845
    buf_p = buf + buf_size;
 
846
    for (i = f->slice_count - 1; i >= 0; i--) {
 
847
        FFV1Context *fs = f->slice_context[i];
 
848
        int trailer     = 3 + 5 * !!f->ec;
 
849
        int v;
 
850
 
 
851
        if (i || f->version > 2)
 
852
            v = AV_RB24(buf_p - trailer) + trailer;
 
853
        else
 
854
            v = buf_p - c->bytestream_start;
 
855
        if (buf_p - c->bytestream_start < v) {
 
856
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
 
857
            return AVERROR_INVALIDDATA;
 
858
        }
 
859
        buf_p -= v;
 
860
 
 
861
        if (f->ec) {
 
862
            unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v);
 
863
            if (crc) {
 
864
                av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", crc);
 
865
                fs->slice_damaged = 1;
 
866
            }
 
867
        }
 
868
 
 
869
        if (i) {
 
870
            ff_init_range_decoder(&fs->c, buf_p, v);
 
871
        } else
 
872
            fs->c.bytestream_end = (uint8_t *)(buf_p + v);
 
873
    }
 
874
 
 
875
    avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL,
 
876
                   f->slice_count,
 
877
                   sizeof(void *));
 
878
 
 
879
    for (i = f->slice_count - 1; i >= 0; i--) {
 
880
        FFV1Context *fs = f->slice_context[i];
 
881
        int j;
 
882
        if (fs->slice_damaged && f->last_picture.data[0]) {
 
883
            const uint8_t *src[4];
 
884
            uint8_t *dst[4];
 
885
            for (j = 0; j < 4; j++) {
 
886
                int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0;
 
887
                int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0;
 
888
                dst[j] = f->picture.data[j] + f->picture.linesize[j] *
 
889
                         (fs->slice_y >> sv) + (fs->slice_x >> sh);
 
890
                src[j] = f->last_picture.data[j] +
 
891
                         f->last_picture.linesize[j] *
 
892
                         (fs->slice_y >> sv) + (fs->slice_x >> sh);
 
893
            }
 
894
            av_image_copy(dst, f->picture.linesize, (const uint8_t **)src,
 
895
                          f->last_picture.linesize,
 
896
                          avctx->pix_fmt, fs->slice_width,
 
897
                          fs->slice_height);
 
898
        }
 
899
    }
 
900
 
 
901
    f->picture_number++;
 
902
 
 
903
    *picture   = *p;
 
904
    *got_frame = 1;
 
905
 
 
906
    FFSWAP(AVFrame, f->picture, f->last_picture);
 
907
 
 
908
    return buf_size;
 
909
}
 
910
 
 
911
AVCodec ff_ffv1_decoder = {
 
912
    .name           = "ffv1",
 
913
    .type           = AVMEDIA_TYPE_VIDEO,
 
914
    .id             = AV_CODEC_ID_FFV1,
 
915
    .priv_data_size = sizeof(FFV1Context),
 
916
    .init           = ffv1_decode_init,
 
917
    .close          = ffv1_close,
 
918
    .decode         = ffv1_decode_frame,
 
919
    .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ |
 
920
                      CODEC_CAP_SLICE_THREADS,
 
921
    .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
 
922
};