← Back to branch summary

~siretart/libav/trusty-security

« back to all changes in this revision

Viewing changes to libavcodec/ffv1.h

  • 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/ffv1.h
 
1
/*
 
2
 * FFV1 codec for libavcodec
 
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
#ifndef AVCODEC_FFV1_H
 
24
#define AVCODEC_FFV1_H
 
25
 
 
26
#include <stdint.h>
 
27
 
 
28
#include "avcodec.h"
 
29
#include "dsputil.h"
 
30
#include "get_bits.h"
 
31
#include "put_bits.h"
 
32
#include "rangecoder.h"
 
33
 
 
34
#define MAX_PLANES 4
 
35
#define CONTEXT_SIZE 32
 
36
 
 
37
#define MAX_QUANT_TABLES 8
 
38
#define MAX_CONTEXT_INPUTS 5
 
39
 
 
40
extern const uint8_t ff_log2_run[41];
 
41
 
 
42
extern const int8_t ffv1_quant5_10bit[256];
 
43
extern const int8_t ffv1_quant5[256];
 
44
extern const int8_t ffv1_quant9_10bit[256];
 
45
extern const int8_t ffv1_quant11[256];
 
46
extern const uint8_t ffv1_ver2_state[256];
 
47
 
 
48
typedef struct VlcState {
 
49
    int16_t drift;
 
50
    uint16_t error_sum;
 
51
    int8_t bias;
 
52
    uint8_t count;
 
53
} VlcState;
 
54
 
 
55
typedef struct PlaneContext {
 
56
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
 
57
    int quant_table_index;
 
58
    int context_count;
 
59
    uint8_t (*state)[CONTEXT_SIZE];
 
60
    VlcState *vlc_state;
 
61
    uint8_t interlace_bit_state[2];
 
62
} PlaneContext;
 
63
 
 
64
#define MAX_SLICES 256
 
65
 
 
66
typedef struct FFV1Context {
 
67
    AVClass *class;
 
68
    AVCodecContext *avctx;
 
69
    RangeCoder c;
 
70
    GetBitContext gb;
 
71
    PutBitContext pb;
 
72
    uint64_t rc_stat[256][2];
 
73
    uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
 
74
    int version;
 
75
    int minor_version;
 
76
    int width, height;
 
77
    int chroma_planes;
 
78
    int chroma_h_shift, chroma_v_shift;
 
79
    int transparency;
 
80
    int flags;
 
81
    int picture_number;
 
82
    AVFrame picture, last_picture;
 
83
    int plane_count;
 
84
    int ac;     // 1 = range coder <-> 0 = golomb rice
 
85
    int ac_byte_count;      // number of bytes used for AC coding
 
86
    PlaneContext plane[MAX_PLANES];
 
87
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
 
88
    int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
 
89
    int context_count[MAX_QUANT_TABLES];
 
90
    uint8_t state_transition[256];
 
91
    uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
 
92
    int run_index;
 
93
    int colorspace;
 
94
    int16_t *sample_buffer;
 
95
 
 
96
    int ec;
 
97
    int slice_damaged;
 
98
    int key_frame_ok;
 
99
 
 
100
    int bits_per_raw_sample;
 
101
    int packed_at_lsb;
 
102
 
 
103
    int gob_count;
 
104
    int quant_table_count;
 
105
 
 
106
    DSPContext dsp;
 
107
 
 
108
    struct FFV1Context *slice_context[MAX_SLICES];
 
109
    int slice_count;
 
110
    int num_v_slices;
 
111
    int num_h_slices;
 
112
    int slice_width;
 
113
    int slice_height;
 
114
    int slice_x;
 
115
    int slice_y;
 
116
} FFV1Context;
 
117
 
 
118
static av_always_inline int fold(int diff, int bits)
 
119
{
 
120
    if (bits == 8)
 
121
        diff = (int8_t)diff;
 
122
    else {
 
123
        diff +=  1 << (bits  - 1);
 
124
        diff &= (1 <<  bits) - 1;
 
125
        diff -=  1 << (bits  - 1);
 
126
    }
 
127
 
 
128
    return diff;
 
129
}
 
130
 
 
131
static inline int predict(int16_t *src, int16_t *last)
 
132
{
 
133
    const int LT = last[-1];
 
134
    const int T  = last[0];
 
135
    const int L  = src[-1];
 
136
 
 
137
    return mid_pred(L, L + T - LT, T);
 
138
}
 
139
 
 
140
static inline int get_context(PlaneContext *p, int16_t *src,
 
141
                              int16_t *last, int16_t *last2)
 
142
{
 
143
    const int LT = last[-1];
 
144
    const int T  = last[0];
 
145
    const int RT = last[1];
 
146
    const int L  = src[-1];
 
147
 
 
148
    if (p->quant_table[3][127]) {
 
149
        const int TT = last2[0];
 
150
        const int LL = src[-2];
 
151
        return p->quant_table[0][(L - LT) & 0xFF] +
 
152
               p->quant_table[1][(LT - T) & 0xFF] +
 
153
               p->quant_table[2][(T - RT) & 0xFF] +
 
154
               p->quant_table[3][(LL - L) & 0xFF] +
 
155
               p->quant_table[4][(TT - T) & 0xFF];
 
156
    } else
 
157
        return p->quant_table[0][(L - LT) & 0xFF] +
 
158
               p->quant_table[1][(LT - T) & 0xFF] +
 
159
               p->quant_table[2][(T - RT) & 0xFF];
 
160
}
 
161
 
 
162
static inline void update_vlc_state(VlcState *const state, const int v)
 
163
{
 
164
    int drift = state->drift;
 
165
    int count = state->count;
 
166
    state->error_sum += FFABS(v);
 
167
    drift            += v;
 
168
 
 
169
    if (count == 128) { // FIXME: variable
 
170
        count            >>= 1;
 
171
        drift            >>= 1;
 
172
        state->error_sum >>= 1;
 
173
    }
 
174
    count++;
 
175
 
 
176
    if (drift <= -count) {
 
177
        if (state->bias > -128)
 
178
            state->bias--;
 
179
 
 
180
        drift += count;
 
181
        if (drift <= -count)
 
182
            drift = -count + 1;
 
183
    } else if (drift > 0) {
 
184
        if (state->bias < 127)
 
185
            state->bias++;
 
186
 
 
187
        drift -= count;
 
188
        if (drift > 0)
 
189
            drift = 0;
 
190
    }
 
191
 
 
192
    state->drift = drift;
 
193
    state->count = count;
 
194
}
 
195
 
 
196
int ffv1_common_init(AVCodecContext *avctx);
 
197
int ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs);
 
198
int ffv1_init_slice_contexts(FFV1Context *f);
 
199
int ffv1_allocate_initial_states(FFV1Context *f);
 
200
void ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs);
 
201
int ffv1_close(AVCodecContext *avctx);
 
202
 
 
203
#endif /* AVCODEC_FFV1_H */