FFmpeg
vp5.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * VP5 compatible video decoder
24  */
25 
26 #include <stdlib.h>
27 #include <string.h>
28 
29 #include "avcodec.h"
30 #include "internal.h"
31 
32 #include "vp56.h"
33 #include "vp56data.h"
34 #include "vp5data.h"
35 
36 
37 static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
38 {
39  VP56RangeCoder *c = &s->c;
40  int rows, cols;
41  int ret;
42 
43  ret = ff_vp56_init_range_decoder(&s->c, buf, buf_size);
44  if (ret < 0)
45  return ret;
46  s->frames[VP56_FRAME_CURRENT]->key_frame = !vp56_rac_get(c);
47  vp56_rac_get(c);
49  if (s->frames[VP56_FRAME_CURRENT]->key_frame)
50  {
51  vp56_rac_gets(c, 8);
52  if(vp56_rac_gets(c, 5) > 5)
53  return AVERROR_INVALIDDATA;
54  vp56_rac_gets(c, 2);
55  if (vp56_rac_get(c)) {
56  avpriv_report_missing_feature(s->avctx, "Interlacing");
57  return AVERROR_PATCHWELCOME;
58  }
59  rows = vp56_rac_gets(c, 8); /* number of stored macroblock rows */
60  cols = vp56_rac_gets(c, 8); /* number of stored macroblock cols */
61  if (!rows || !cols) {
62  av_log(s->avctx, AV_LOG_ERROR, "Invalid size %dx%d\n",
63  cols << 4, rows << 4);
64  return AVERROR_INVALIDDATA;
65  }
66  vp56_rac_gets(c, 8); /* number of displayed macroblock rows */
67  vp56_rac_gets(c, 8); /* number of displayed macroblock cols */
68  vp56_rac_gets(c, 2);
69  if (!s->macroblocks || /* first frame */
70  16*cols != s->avctx->coded_width ||
71  16*rows != s->avctx->coded_height) {
72  int ret = ff_set_dimensions(s->avctx, 16 * cols, 16 * rows);
73  if (ret < 0)
74  return ret;
75  return VP56_SIZE_CHANGE;
76  }
77  } else if (!s->macroblocks)
78  return AVERROR_INVALIDDATA;
79  return 0;
80 }
81 
82 static void vp5_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
83 {
84  VP56RangeCoder *c = &s->c;
85  VP56Model *model = s->modelp;
86  int comp, di;
87 
88  for (comp=0; comp<2; comp++) {
89  int delta = 0;
90  if (vp56_rac_get_prob_branchy(c, model->vector_dct[comp])) {
91  int sign = vp56_rac_get_prob(c, model->vector_sig[comp]);
92  di = vp56_rac_get_prob(c, model->vector_pdi[comp][0]);
93  di |= vp56_rac_get_prob(c, model->vector_pdi[comp][1]) << 1;
95  model->vector_pdv[comp]);
96  delta = di | (delta << 2);
97  delta = (delta ^ -sign) + sign;
98  }
99  if (!comp)
100  vect->x = delta;
101  else
102  vect->y = delta;
103  }
104 }
105 
106 static void vp5_parse_vector_models(VP56Context *s)
107 {
108  VP56RangeCoder *c = &s->c;
109  VP56Model *model = s->modelp;
110  int comp, node;
111 
112  for (comp=0; comp<2; comp++) {
113  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][0]))
114  model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
115  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][1]))
116  model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
117  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][2]))
118  model->vector_pdi[comp][0] = vp56_rac_gets_nn(c, 7);
119  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][3]))
120  model->vector_pdi[comp][1] = vp56_rac_gets_nn(c, 7);
121  }
122 
123  for (comp=0; comp<2; comp++)
124  for (node=0; node<7; node++)
125  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][4 + node]))
126  model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
127 }
128 
129 static int vp5_parse_coeff_models(VP56Context *s)
130 {
131  VP56RangeCoder *c = &s->c;
132  VP56Model *model = s->modelp;
133  uint8_t def_prob[11];
134  int node, cg, ctx;
135  int ct; /* code type */
136  int pt; /* plane type (0 for Y, 1 for U or V) */
137 
138  memset(def_prob, 0x80, sizeof(def_prob));
139 
140  for (pt=0; pt<2; pt++)
141  for (node=0; node<11; node++)
142  if (vp56_rac_get_prob_branchy(c, vp5_dccv_pct[pt][node])) {
143  def_prob[node] = vp56_rac_gets_nn(c, 7);
144  model->coeff_dccv[pt][node] = def_prob[node];
145  } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
146  model->coeff_dccv[pt][node] = def_prob[node];
147  }
148 
149  for (ct=0; ct<3; ct++)
150  for (pt=0; pt<2; pt++)
151  for (cg=0; cg<6; cg++)
152  for (node=0; node<11; node++)
153  if (vp56_rac_get_prob_branchy(c, vp5_ract_pct[ct][pt][cg][node])) {
154  def_prob[node] = vp56_rac_gets_nn(c, 7);
155  model->coeff_ract[pt][ct][cg][node] = def_prob[node];
156  } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
157  model->coeff_ract[pt][ct][cg][node] = def_prob[node];
158  }
159 
160  /* coeff_dcct is a linear combination of coeff_dccv */
161  for (pt=0; pt<2; pt++)
162  for (ctx=0; ctx<36; ctx++)
163  for (node=0; node<5; node++)
164  model->coeff_dcct[pt][ctx][node] = av_clip(((model->coeff_dccv[pt][node] * vp5_dccv_lc[node][ctx][0] + 128) >> 8) + vp5_dccv_lc[node][ctx][1], 1, 254);
165 
166  /* coeff_acct is a linear combination of coeff_ract */
167  for (ct=0; ct<3; ct++)
168  for (pt=0; pt<2; pt++)
169  for (cg=0; cg<3; cg++)
170  for (ctx=0; ctx<6; ctx++)
171  for (node=0; node<5; node++)
172  model->coeff_acct[pt][ct][cg][ctx][node] = av_clip(((model->coeff_ract[pt][ct][cg][node] * vp5_ract_lc[ct][cg][node][ctx][0] + 128) >> 8) + vp5_ract_lc[ct][cg][node][ctx][1], 1, 254);
173  return 0;
174 }
175 
176 static int vp5_parse_coeff(VP56Context *s)
177 {
178  VP56RangeCoder *c = &s->c;
179  VP56Model *model = s->modelp;
180  uint8_t *permute = s->idct_scantable;
181  uint8_t *model1, *model2;
182  int coeff, sign, coeff_idx;
183  int b, i, cg, idx, ctx, ctx_last;
184  int pt = 0; /* plane type (0 for Y, 1 for U or V) */
185 
186  if (vpX_rac_is_end(c)) {
187  av_log(s->avctx, AV_LOG_ERROR, "End of AC stream reached in vp5_parse_coeff\n");
188  return AVERROR_INVALIDDATA;
189  }
190 
191  for (b=0; b<6; b++) {
192  int ct = 1; /* code type */
193 
194  if (b > 3) pt = 1;
195 
196  ctx = 6*s->coeff_ctx[ff_vp56_b6to4[b]][0]
197  + s->above_blocks[s->above_block_idx[b]].not_null_dc;
198  model1 = model->coeff_dccv[pt];
199  model2 = model->coeff_dcct[pt][ctx];
200 
201  coeff_idx = 0;
202  for (;;) {
203  if (vp56_rac_get_prob_branchy(c, model2[0])) {
204  if (vp56_rac_get_prob_branchy(c, model2[2])) {
205  if (vp56_rac_get_prob_branchy(c, model2[3])) {
206  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 4;
207  idx = vp56_rac_get_tree(c, ff_vp56_pc_tree, model1);
208  sign = vp56_rac_get(c);
209  coeff = ff_vp56_coeff_bias[idx+5];
210  for (i=ff_vp56_coeff_bit_length[idx]; i>=0; i--)
211  coeff += vp56_rac_get_prob(c, ff_vp56_coeff_parse_table[idx][i]) << i;
212  } else {
213  if (vp56_rac_get_prob_branchy(c, model2[4])) {
214  coeff = 3 + vp56_rac_get_prob(c, model1[5]);
215  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 3;
216  } else {
217  coeff = 2;
218  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 2;
219  }
220  sign = vp56_rac_get(c);
221  }
222  ct = 2;
223  } else {
224  ct = 1;
225  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 1;
226  sign = vp56_rac_get(c);
227  coeff = 1;
228  }
229  coeff = (coeff ^ -sign) + sign;
230  if (coeff_idx)
231  coeff *= s->dequant_ac;
232  s->block_coeff[b][permute[coeff_idx]] = coeff;
233  } else {
234  if (ct && !vp56_rac_get_prob_branchy(c, model2[1]))
235  break;
236  ct = 0;
237  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 0;
238  }
239  coeff_idx++;
240  if (coeff_idx >= 64)
241  break;
242 
243  cg = vp5_coeff_groups[coeff_idx];
244  ctx = s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx];
245  model1 = model->coeff_ract[pt][ct][cg];
246  model2 = cg > 2 ? model1 : model->coeff_acct[pt][ct][cg][ctx];
247  }
248 
249  ctx_last = FFMIN(s->coeff_ctx_last[ff_vp56_b6to4[b]], 24);
250  s->coeff_ctx_last[ff_vp56_b6to4[b]] = coeff_idx;
251  if (coeff_idx < ctx_last)
252  for (i=coeff_idx; i<=ctx_last; i++)
253  s->coeff_ctx[ff_vp56_b6to4[b]][i] = 5;
254  s->above_blocks[s->above_block_idx[b]].not_null_dc = s->coeff_ctx[ff_vp56_b6to4[b]][0];
255  s->idct_selector[b] = 63;
256  }
257  return 0;
258 }
259 
260 static void vp5_default_models_init(VP56Context *s)
261 {
262  VP56Model *model = s->modelp;
263  int i;
264 
265  for (i=0; i<2; i++) {
266  model->vector_sig[i] = 0x80;
267  model->vector_dct[i] = 0x80;
268  model->vector_pdi[i][0] = 0x55;
269  model->vector_pdi[i][1] = 0x80;
270  }
271  memcpy(model->mb_types_stats, ff_vp56_def_mb_types_stats, sizeof(model->mb_types_stats));
272  memset(model->vector_pdv, 0x80, sizeof(model->vector_pdv));
273 }
274 
276 {
277  VP56Context *s = avctx->priv_data;
278  int ret;
279 
280  if ((ret = ff_vp56_init(avctx, 1, 0)) < 0)
281  return ret;
282  ff_vp5dsp_init(&s->vp56dsp);
283  s->vp56_coord_div = vp5_coord_div;
284  s->parse_vector_adjustment = vp5_parse_vector_adjustment;
285  s->parse_coeff = vp5_parse_coeff;
286  s->default_models_init = vp5_default_models_init;
287  s->parse_vector_models = vp5_parse_vector_models;
288  s->parse_coeff_models = vp5_parse_coeff_models;
289  s->parse_header = vp5_parse_header;
290 
291  return 0;
292 }
293 
295  .name = "vp5",
296  .long_name = NULL_IF_CONFIG_SMALL("On2 VP5"),
297  .type = AVMEDIA_TYPE_VIDEO,
298  .id = AV_CODEC_ID_VP5,
299  .priv_data_size = sizeof(VP56Context),
301  .close = ff_vp56_free,
303  .capabilities = AV_CODEC_CAP_DR1,
304 };
av_cold int ff_vp56_free(AVCodecContext *avctx)
Definition: vp56.c:835
uint8_t coeff_ract[2][3][6][11]
Definition: vp56.h:116
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
VP5 and VP6 compatible video decoder (common features)
static av_cold int vp5_decode_init(AVCodecContext *avctx)
Definition: vp5.c:275
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:104
const uint8_t ff_vp56_coeff_bias[]
Definition: vp56data.c:67
uint8_t coeff_dccv[2][11]
Definition: vp56.h:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint8_t mb_types_stats[3][10][2]
Definition: vp56.h:121
static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
Definition: vp5.c:37
uint8_t vector_sig[2]
Definition: vp56.h:110
static const uint8_t vp5_coord_div[]
Definition: vp5data.h:175
static int vp5_parse_coeff_models(VP56Context *s)
Definition: vp5.c:129
#define VP56_SIZE_CHANGE
Definition: vp56.h:71
VP5 compatible video decoder.
static void vp5_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
Definition: vp5.c:82
av_cold int ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
Definition: vp56.c:776
AVCodec.
Definition: avcodec.h:3484
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static const uint8_t vp5_ract_pct[3][2][6][11]
Definition: vp5data.h:52
int16_t y
Definition: vp56.h:68
uint8_t
#define av_cold
Definition: attributes.h:82
float delta
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
static int vp5_parse_coeff(VP56Context *s)
Definition: vp5.c:176
int pt
Definition: rtp.c:35
static av_always_inline int vpX_rac_is_end(VP56RangeCoder *c)
vp5689 returns 1 if the end of the stream has been reached, 0 otherwise.
Definition: vp56.h:237
static av_always_inline int vp56_rac_get_tree(VP56RangeCoder *c, const VP56Tree *tree, const uint8_t *probs)
Definition: vp56.h:379
#define av_log(a,...)
static const uint8_t vp5_dccv_pct[2][11]
Definition: vp5data.h:47
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static void vp5_parse_vector_models(VP56Context *s)
Definition: vp5.c:106
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
static av_always_inline int vp56_rac_get(VP56RangeCoder *c)
Definition: vp56.h:303
const char * name
Name of the codec implementation.
Definition: avcodec.h:3491
void ff_vp56_init_dequant(VP56Context *s, int quantizer)
Definition: vp56.c:34
const uint8_t ff_vp56_b6to4[]
Definition: vp56data.c:29
AVCodec ff_vp5_decoder
Definition: vp5.c:294
int ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
Definition: vp56rac.c:40
VP5 and VP6 compatible video decoder (common data)
static av_unused int vp56_rac_gets_nn(VP56RangeCoder *c, int bits)
Definition: vp56.h:366
#define b
Definition: input.c:41
#define FFMIN(a, b)
Definition: common.h:96
uint8_t vector_pdi[2][2]
Definition: vp56.h:112
static const int16_t vp5_ract_lc[3][3][5][6][2]
Definition: vp5data.h:124
AVFormatContext * ctx
Definition: movenc.c:48
int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: vp56.c:568
const uint8_t ff_vp56_coeff_bit_length[]
Definition: vp56data.c:68
#define s(width, name)
Definition: cbs_vp9.c:257
#define vp56_rac_get_prob
Definition: vp56.h:268
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static const int16_t vp5_dccv_lc[5][36][2]
Definition: vp5data.h:91
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob)
Definition: vp56.h:285
Libavcodec external API header.
const VP56Tree ff_vp56_pc_tree[]
Definition: vp56data.c:59
main external API structure.
Definition: avcodec.h:1568
static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
Definition: proresdec2.c:42
void * buf
Definition: avisynth_c.h:766
const uint8_t ff_vp56_coeff_parse_table[6][11]
Definition: vp56data.c:31
uint8_t coeff_dcct[2][36][5]
Definition: vp56.h:118
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t coeff_acct[2][3][3][6][5]
Definition: vp56.h:117
Definition: vp56.h:66
static const uint8_t vp5_vmc_pct[2][11]
Definition: vp5data.h:42
const VP56Tree ff_vp56_pva_tree[]
Definition: vp56data.c:49
int16_t x
Definition: vp56.h:67
common internal api header.
static void vp5_default_models_init(VP56Context *s)
Definition: vp5.c:260
void * priv_data
Definition: avcodec.h:1595
void ff_vp5dsp_init(VP56DSPContext *s)
uint8_t vector_pdv[2][7]
Definition: vp56.h:113
static const double coeff[2][5]
Definition: vf_owdenoise.c:72
static const uint8_t vp5_coeff_groups[]
Definition: vp5data.h:31
const uint8_t ff_vp56_def_mb_types_stats[3][10][2]
Definition: vp56data.c:40
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
uint8_t vector_dct[2]
Definition: vp56.h:111
static int vp56_rac_gets(VP56RangeCoder *c, int bits)
Definition: vp56.h:327