Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vp56.h @ 800274f8

History | View | Annotate | Download (7.62 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
    const uint8_t *end;
54
    unsigned long code_word;
55
} VP56RangeCoder;
56

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

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

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

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

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

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

    
110
    int quantizer;
111
    uint16_t dequant_dc;
112
    uint16_t dequant_ac;
113
    int8_t *qscale_table;
114

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

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

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

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

    
139
    uint8_t coeff_ctx[4][64];              /* used in vp5 only */
140
    uint8_t coeff_ctx_last[4];             /* used in vp5 only */
141

    
142
    int has_alpha;
143

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

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

    
160
    VP56Model *modelp;
161
    VP56Model models[2];
162

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

    
172

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

    
179

    
180
/**
181
 * vp56 specific range coder implementation
182
 */
183

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

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

    
200
    if (bit) {
201
        c->high -= low;
202
        c->code_word -= low_shift;
203
    } else {
204
        c->high = low;
205
    }
206

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

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

    
232
    /* normalize */
233
    c->code_word <<= 1;
234
    if (--c->bits == 0 && c->buffer < c->end) {
235
        c->bits = 8;
236
        c->code_word |= *c->buffer++;
237
    }
238
    return bit;
239
}
240

    
241
static inline int vp56_rac_gets(VP56RangeCoder *c, int bits)
242
{
243
    int value = 0;
244

    
245
    while (bits--) {
246
        value = (value << 1) | vp56_rac_get(c);
247
    }
248

    
249
    return value;
250
}
251

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

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

    
271
#endif /* AVCODEC_VP56_H */