Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vp56.h @ 9106a698

History | View | Annotate | Download (7.5 KB)

1
/**
2
 * @file libavcodec/vp56.h
3
 * VP5 and VP6 compatible video decoder (common features)
4
 *
5
 * Copyright (C) 2006  Aurelien Jacobs <aurel@gnuage.org>
6
 *
7
 * This file is part of FFmpeg.
8
 *
9
 * FFmpeg is free software; you can redistribute it and/or
10
 * modify it under the terms of the GNU Lesser General Public
11
 * License as published by the Free Software Foundation; either
12
 * version 2.1 of the License, or (at your option) any later version.
13
 *
14
 * FFmpeg is distributed in the hope that it will be useful,
15
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17
 * Lesser General Public License for more details.
18
 *
19
 * You should have received a copy of the GNU Lesser General Public
20
 * License along with FFmpeg; if not, write to the Free Software
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
 */
23

    
24
#ifndef AVCODEC_VP56_H
25
#define AVCODEC_VP56_H
26

    
27
#include "vp56data.h"
28
#include "dsputil.h"
29
#include "get_bits.h"
30
#include "bytestream.h"
31

    
32

    
33
typedef struct vp56_context VP56Context;
34
typedef struct vp56_mv VP56mv;
35

    
36
typedef void (*VP56ParseVectorAdjustment)(VP56Context *s,
37
                                          VP56mv *vect);
38
typedef int  (*VP56Adjust)(int v, int t);
39
typedef void (*VP56Filter)(VP56Context *s, uint8_t *dst, uint8_t *src,
40
                           int offset1, int offset2, int stride,
41
                           VP56mv mv, int mask, int select, int luma);
42
typedef void (*VP56ParseCoeff)(VP56Context *s);
43
typedef void (*VP56DefaultModelsInit)(VP56Context *s);
44
typedef void (*VP56ParseVectorModels)(VP56Context *s);
45
typedef void (*VP56ParseCoeffModels)(VP56Context *s);
46
typedef int  (*VP56ParseHeader)(VP56Context *s, const uint8_t *buf,
47
                                int buf_size, int *golden_frame);
48

    
49
typedef struct {
50
    int high;
51
    int bits;
52
    const uint8_t *buffer;
53
    unsigned long code_word;
54
} VP56RangeCoder;
55

    
56
typedef struct {
57
    uint8_t not_null_dc;
58
    VP56Frame ref_frame;
59
    DCTELEM dc_coeff;
60
} VP56RefDc;
61

    
62
struct vp56_mv {
63
    int x;
64
    int y;
65
};
66

    
67
typedef struct {
68
    uint8_t type;
69
    VP56mv mv;
70
} VP56Macroblock;
71

    
72
typedef struct {
73
    uint8_t coeff_reorder[64];       /* used in vp6 only */
74
    uint8_t coeff_index_to_pos[64];  /* used in vp6 only */
75
    uint8_t vector_sig[2];           /* delta sign */
76
    uint8_t vector_dct[2];           /* delta coding types */
77
    uint8_t vector_pdi[2][2];        /* predefined delta init */
78
    uint8_t vector_pdv[2][7];        /* predefined delta values */
79
    uint8_t vector_fdv[2][8];        /* 8 bit delta value definition */
80
    uint8_t coeff_dccv[2][11];       /* DC coeff value */
81
    uint8_t coeff_ract[2][3][6][11]; /* Run/AC coding type and AC coeff value */
82
    uint8_t coeff_acct[2][3][3][6][5];/* vp5 only AC coding type for coding group < 3 */
83
    uint8_t coeff_dcct[2][36][5];    /* DC coeff coding type */
84
    uint8_t coeff_runv[2][14];       /* run value (vp6 only) */
85
    uint8_t mb_type[3][10][10];      /* model for decoding MB type */
86
    uint8_t mb_types_stats[3][10][2];/* contextual, next MB type stats */
87
} VP56Model;
88

    
89
struct vp56_context {
90
    AVCodecContext *avctx;
91
    DSPContext dsp;
92
    ScanTable scantable;
93
    AVFrame frames[4];
94
    AVFrame *framep[6];
95
    uint8_t *edge_emu_buffer_alloc;
96
    uint8_t *edge_emu_buffer;
97
    VP56RangeCoder c;
98
    VP56RangeCoder cc;
99
    VP56RangeCoder *ccp;
100
    int sub_version;
101

    
102
    /* frame info */
103
    int plane_width[4];
104
    int plane_height[4];
105
    int mb_width;   /* number of horizontal MB */
106
    int mb_height;  /* number of vertical MB */
107
    int block_offset[6];
108

    
109
    int quantizer;
110
    uint16_t dequant_dc;
111
    uint16_t dequant_ac;
112

    
113
    /* DC predictors management */
114
    VP56RefDc *above_blocks;
115
    VP56RefDc left_block[4];
116
    int above_block_idx[6];
117
    DCTELEM prev_dc[3][3];    /* [plan][ref_frame] */
118

    
119
    /* blocks / macroblock */
120
    VP56mb mb_type;
121
    VP56Macroblock *macroblocks;
122
    DECLARE_ALIGNED_16(DCTELEM, block_coeff[6][64]);
123

    
124
    /* motion vectors */
125
    VP56mv mv[6];  /* vectors for each block in MB */
126
    VP56mv vector_candidate[2];
127
    int vector_candidate_pos;
128

    
129
    /* filtering hints */
130
    int filter_header;               /* used in vp6 only */
131
    int deblock_filtering;
132
    int filter_selection;
133
    int filter_mode;
134
    int max_vector_length;
135
    int sample_variance_threshold;
136

    
137
    uint8_t coeff_ctx[4][64];              /* used in vp5 only */
138
    uint8_t coeff_ctx_last[4];             /* used in vp5 only */
139

    
140
    int has_alpha;
141

    
142
    /* upside-down flipping hints */
143
    int flip;  /* are we flipping ? */
144
    int frbi;  /* first row block index in MB */
145
    int srbi;  /* second row block index in MB */
146
    int stride[4];  /* stride for each plan */
147

    
148
    const uint8_t *vp56_coord_div;
149
    VP56ParseVectorAdjustment parse_vector_adjustment;
150
    VP56Adjust adjust;
151
    VP56Filter filter;
152
    VP56ParseCoeff parse_coeff;
153
    VP56DefaultModelsInit default_models_init;
154
    VP56ParseVectorModels parse_vector_models;
155
    VP56ParseCoeffModels parse_coeff_models;
156
    VP56ParseHeader parse_header;
157

    
158
    VP56Model *modelp;
159
    VP56Model models[2];
160

    
161
    /* huffman decoding */
162
    int use_huffman;
163
    GetBitContext gb;
164
    VLC dccv_vlc[2];
165
    VLC runv_vlc[2];
166
    VLC ract_vlc[2][3][6];
167
    unsigned int nb_null[2][2];       /* number of consecutive NULL DC/AC */
168
};
169

    
170

    
171
void vp56_init(AVCodecContext *avctx, int flip, int has_alpha);
172
int vp56_free(AVCodecContext *avctx);
173
void vp56_init_dequant(VP56Context *s, int quantizer);
174
int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
175
                      AVPacket *avpkt);
176

    
177

    
178
/**
179
 * vp56 specific range coder implementation
180
 */
181

    
182
static inline void vp56_init_range_decoder(VP56RangeCoder *c,
183
                                           const uint8_t *buf, int buf_size)
184
{
185
    c->high = 255;
186
    c->bits = 8;
187
    c->buffer = buf;
188
    c->code_word = bytestream_get_be16(&c->buffer);
189
}
190

    
191
static inline int vp56_rac_get_prob(VP56RangeCoder *c, uint8_t prob)
192
{
193
    unsigned int low = 1 + (((c->high - 1) * prob) / 256);
194
    unsigned int low_shift = low << 8;
195
    int bit = c->code_word >= low_shift;
196

    
197
    if (bit) {
198
        c->high -= low;
199
        c->code_word -= low_shift;
200
    } else {
201
        c->high = low;
202
    }
203

    
204
    /* normalize */
205
    while (c->high < 128) {
206
        c->high <<= 1;
207
        c->code_word <<= 1;
208
        if (--c->bits == 0) {
209
            c->bits = 8;
210
            c->code_word |= *c->buffer++;
211
        }
212
    }
213
    return bit;
214
}
215

    
216
static inline int vp56_rac_get(VP56RangeCoder *c)
217
{
218
    /* equiprobable */
219
    int low = (c->high + 1) >> 1;
220
    unsigned int low_shift = low << 8;
221
    int bit = c->code_word >= low_shift;
222
    if (bit) {
223
        c->high = (c->high - low) << 1;
224
        c->code_word -= low_shift;
225
    } else {
226
        c->high = low << 1;
227
    }
228

    
229
    /* normalize */
230
    c->code_word <<= 1;
231
    if (--c->bits == 0) {
232
        c->bits = 8;
233
        c->code_word |= *c->buffer++;
234
    }
235
    return bit;
236
}
237

    
238
static inline int vp56_rac_gets(VP56RangeCoder *c, int bits)
239
{
240
    int value = 0;
241

    
242
    while (bits--) {
243
        value = (value << 1) | vp56_rac_get(c);
244
    }
245

    
246
    return value;
247
}
248

    
249
static inline int vp56_rac_gets_nn(VP56RangeCoder *c, int bits)
250
{
251
    int v = vp56_rac_gets(c, 7) << 1;
252
    return v + !v;
253
}
254

    
255
static inline int vp56_rac_get_tree(VP56RangeCoder *c,
256
                                    const VP56Tree *tree,
257
                                    const uint8_t *probs)
258
{
259
    while (tree->val > 0) {
260
        if (vp56_rac_get_prob(c, probs[tree->prob_idx]))
261
            tree += tree->val;
262
        else
263
            tree++;
264
    }
265
    return -tree->val;
266
}
267

    
268
#endif /* AVCODEC_VP56_H */