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  int render_x, render_y;
52 
53  vp56_rac_gets(c, 8);
54  if(vp56_rac_gets(c, 5) > 5)
55  return AVERROR_INVALIDDATA;
56  vp56_rac_gets(c, 2);
57  if (vp56_rac_get(c)) {
58  avpriv_report_missing_feature(s->avctx, "Interlacing");
59  return AVERROR_PATCHWELCOME;
60  }
61  rows = vp56_rac_gets(c, 8); /* number of stored macroblock rows */
62  cols = vp56_rac_gets(c, 8); /* number of stored macroblock cols */
63  if (!rows || !cols) {
64  av_log(s->avctx, AV_LOG_ERROR, "Invalid size %dx%d\n",
65  cols << 4, rows << 4);
66  return AVERROR_INVALIDDATA;
67  }
68  render_y = vp56_rac_gets(c, 8); /* number of displayed macroblock rows */
69  render_x = vp56_rac_gets(c, 8); /* number of displayed macroblock cols */
70  if (render_x == 0 || render_x > cols ||
71  render_y == 0 || render_y > rows)
72  return AVERROR_INVALIDDATA;
73  vp56_rac_gets(c, 2);
74  if (!s->macroblocks || /* first frame */
75  16*cols != s->avctx->coded_width ||
76  16*rows != s->avctx->coded_height) {
77  int ret = ff_set_dimensions(s->avctx, 16 * cols, 16 * rows);
78  if (ret < 0)
79  return ret;
80  return VP56_SIZE_CHANGE;
81  }
82  } else if (!s->macroblocks)
83  return AVERROR_INVALIDDATA;
84  return 0;
85 }
86 
87 static void vp5_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
88 {
89  VP56RangeCoder *c = &s->c;
90  VP56Model *model = s->modelp;
91  int comp, di;
92 
93  for (comp=0; comp<2; comp++) {
94  int delta = 0;
96  int sign = vp56_rac_get_prob(c, model->vector_sig[comp]);
97  di = vp56_rac_get_prob(c, model->vector_pdi[comp][0]);
98  di |= vp56_rac_get_prob(c, model->vector_pdi[comp][1]) << 1;
100  model->vector_pdv[comp]);
101  delta = di | (delta << 2);
102  delta = (delta ^ -sign) + sign;
103  }
104  if (!comp)
105  vect->x = delta;
106  else
107  vect->y = delta;
108  }
109 }
110 
111 static void vp5_parse_vector_models(VP56Context *s)
112 {
113  VP56RangeCoder *c = &s->c;
114  VP56Model *model = s->modelp;
115  int comp, node;
116 
117  for (comp=0; comp<2; comp++) {
119  model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
121  model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
123  model->vector_pdi[comp][0] = vp56_rac_gets_nn(c, 7);
125  model->vector_pdi[comp][1] = vp56_rac_gets_nn(c, 7);
126  }
127 
128  for (comp=0; comp<2; comp++)
129  for (node=0; node<7; node++)
130  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][4 + node]))
131  model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
132 }
133 
134 static int vp5_parse_coeff_models(VP56Context *s)
135 {
136  VP56RangeCoder *c = &s->c;
137  VP56Model *model = s->modelp;
138  uint8_t def_prob[11];
139  int node, cg, ctx;
140  int ct; /* code type */
141  int pt; /* plane type (0 for Y, 1 for U or V) */
142 
143  memset(def_prob, 0x80, sizeof(def_prob));
144 
145  for (pt=0; pt<2; pt++)
146  for (node=0; node<11; node++)
148  def_prob[node] = vp56_rac_gets_nn(c, 7);
149  model->coeff_dccv[pt][node] = def_prob[node];
150  } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
151  model->coeff_dccv[pt][node] = def_prob[node];
152  }
153 
154  for (ct=0; ct<3; ct++)
155  for (pt=0; pt<2; pt++)
156  for (cg=0; cg<6; cg++)
157  for (node=0; node<11; node++)
158  if (vp56_rac_get_prob_branchy(c, vp5_ract_pct[ct][pt][cg][node])) {
159  def_prob[node] = vp56_rac_gets_nn(c, 7);
160  model->coeff_ract[pt][ct][cg][node] = def_prob[node];
161  } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
162  model->coeff_ract[pt][ct][cg][node] = def_prob[node];
163  }
164 
165  /* coeff_dcct is a linear combination of coeff_dccv */
166  for (pt=0; pt<2; pt++)
167  for (ctx=0; ctx<36; ctx++)
168  for (node=0; node<5; node++)
169  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);
170 
171  /* coeff_acct is a linear combination of coeff_ract */
172  for (ct=0; ct<3; ct++)
173  for (pt=0; pt<2; pt++)
174  for (cg=0; cg<3; cg++)
175  for (ctx=0; ctx<6; ctx++)
176  for (node=0; node<5; node++)
177  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);
178  return 0;
179 }
180 
181 static int vp5_parse_coeff(VP56Context *s)
182 {
183  VP56RangeCoder *c = &s->c;
184  VP56Model *model = s->modelp;
185  uint8_t *permute = s->idct_scantable;
186  uint8_t *model1, *model2;
187  int coeff, sign, coeff_idx;
188  int b, i, cg, idx, ctx, ctx_last;
189  int pt = 0; /* plane type (0 for Y, 1 for U or V) */
190 
191  if (vpX_rac_is_end(c)) {
192  av_log(s->avctx, AV_LOG_ERROR, "End of AC stream reached in vp5_parse_coeff\n");
193  return AVERROR_INVALIDDATA;
194  }
195 
196  for (b=0; b<6; b++) {
197  int ct = 1; /* code type */
198 
199  if (b > 3) pt = 1;
200 
201  ctx = 6*s->coeff_ctx[ff_vp56_b6to4[b]][0]
202  + s->above_blocks[s->above_block_idx[b]].not_null_dc;
203  model1 = model->coeff_dccv[pt];
204  model2 = model->coeff_dcct[pt][ctx];
205 
206  coeff_idx = 0;
207  for (;;) {
208  if (vp56_rac_get_prob_branchy(c, model2[0])) {
209  if (vp56_rac_get_prob_branchy(c, model2[2])) {
210  if (vp56_rac_get_prob_branchy(c, model2[3])) {
211  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 4;
212  idx = vp56_rac_get_tree(c, ff_vp56_pc_tree, model1);
213  sign = vp56_rac_get(c);
214  coeff = ff_vp56_coeff_bias[idx+5];
215  for (i=ff_vp56_coeff_bit_length[idx]; i>=0; i--)
217  } else {
218  if (vp56_rac_get_prob_branchy(c, model2[4])) {
219  coeff = 3 + vp56_rac_get_prob(c, model1[5]);
220  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 3;
221  } else {
222  coeff = 2;
223  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 2;
224  }
225  sign = vp56_rac_get(c);
226  }
227  ct = 2;
228  } else {
229  ct = 1;
230  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 1;
231  sign = vp56_rac_get(c);
232  coeff = 1;
233  }
234  coeff = (coeff ^ -sign) + sign;
235  if (coeff_idx)
236  coeff *= s->dequant_ac;
237  s->block_coeff[b][permute[coeff_idx]] = coeff;
238  } else {
239  if (ct && !vp56_rac_get_prob_branchy(c, model2[1]))
240  break;
241  ct = 0;
242  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 0;
243  }
244  coeff_idx++;
245  if (coeff_idx >= 64)
246  break;
247 
248  cg = vp5_coeff_groups[coeff_idx];
249  ctx = s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx];
250  model1 = model->coeff_ract[pt][ct][cg];
251  model2 = cg > 2 ? model1 : model->coeff_acct[pt][ct][cg][ctx];
252  }
253 
254  ctx_last = FFMIN(s->coeff_ctx_last[ff_vp56_b6to4[b]], 24);
255  s->coeff_ctx_last[ff_vp56_b6to4[b]] = coeff_idx;
256  if (coeff_idx < ctx_last)
257  for (i=coeff_idx; i<=ctx_last; i++)
258  s->coeff_ctx[ff_vp56_b6to4[b]][i] = 5;
259  s->above_blocks[s->above_block_idx[b]].not_null_dc = s->coeff_ctx[ff_vp56_b6to4[b]][0];
260  s->idct_selector[b] = 63;
261  }
262  return 0;
263 }
264 
265 static void vp5_default_models_init(VP56Context *s)
266 {
267  VP56Model *model = s->modelp;
268  int i;
269 
270  for (i=0; i<2; i++) {
271  model->vector_sig[i] = 0x80;
272  model->vector_dct[i] = 0x80;
273  model->vector_pdi[i][0] = 0x55;
274  model->vector_pdi[i][1] = 0x80;
275  }
276  memcpy(model->mb_types_stats, ff_vp56_def_mb_types_stats, sizeof(model->mb_types_stats));
277  memset(model->vector_pdv, 0x80, sizeof(model->vector_pdv));
278 }
279 
281 {
282  VP56Context *s = avctx->priv_data;
283  int ret;
284 
285  if ((ret = ff_vp56_init(avctx, 1, 0)) < 0)
286  return ret;
287  ff_vp5dsp_init(&s->vp56dsp);
288  s->vp56_coord_div = vp5_coord_div;
289  s->parse_vector_adjustment = vp5_parse_vector_adjustment;
290  s->parse_coeff = vp5_parse_coeff;
291  s->default_models_init = vp5_default_models_init;
292  s->parse_vector_models = vp5_parse_vector_models;
293  s->parse_coeff_models = vp5_parse_coeff_models;
294  s->parse_header = vp5_parse_header;
295 
296  return 0;
297 }
298 
300  .name = "vp5",
301  .long_name = NULL_IF_CONFIG_SMALL("On2 VP5"),
302  .type = AVMEDIA_TYPE_VIDEO,
303  .id = AV_CODEC_ID_VP5,
304  .priv_data_size = sizeof(VP56Context),
306  .close = ff_vp56_free,
308  .capabilities = AV_CODEC_CAP_DR1,
309 };
vp5_decode_init
static av_cold int vp5_decode_init(AVCodecContext *avctx)
Definition: vp5.c:280
AVCodec
AVCodec.
Definition: codec.h:202
vp56_rac_get
static av_always_inline int vp56_rac_get(VP56RangeCoder *c)
Definition: vp56.h:305
ff_vp56_init
av_cold int ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
Definition: vp56.c:776
vp5_parse_coeff
static int vp5_parse_coeff(VP56Context *s)
Definition: vp5.c:181
av_clip
#define av_clip
Definition: common.h:96
VP56mv::x
int16_t x
Definition: vp56.h:69
vp56data.h
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
ff_vp5dsp_init
void ff_vp5dsp_init(VP56DSPContext *s)
vp5_default_models_init
static void vp5_default_models_init(VP56Context *s)
Definition: vp5.c:265
vpX_rac_is_end
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:239
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
VP56Model::mb_types_stats
uint8_t mb_types_stats[3][10][2]
Definition: vp56.h:123
VP56Model::coeff_acct
uint8_t coeff_acct[2][3][3][6][5]
Definition: vp56.h:119
ff_vp56_coeff_bit_length
const uint8_t ff_vp56_coeff_bit_length[]
Definition: vp56data.c:68
internal.h
b
#define b
Definition: input.c:40
vp5_coord_div
static const uint8_t vp5_coord_div[]
Definition: vp5data.h:175
VP56Model::coeff_ract
uint8_t coeff_ract[2][3][6][11]
Definition: vp56.h:118
vp56_rac_gets_nn
static av_unused int vp56_rac_gets_nn(VP56RangeCoder *c, int bits)
Definition: vp56.h:368
vp56_rac_get_prob_branchy
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob)
Definition: vp56.h:287
ff_vp56_b6to4
const uint8_t ff_vp56_b6to4[]
Definition: vp56data.c:29
VP56_SIZE_CHANGE
#define VP56_SIZE_CHANGE
Definition: vp56.h:73
vp5_parse_vector_adjustment
static void vp5_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
Definition: vp5.c:87
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ff_vp5_decoder
const AVCodec ff_vp5_decoder
Definition: vp5.c:299
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
s
#define s(width, name)
Definition: cbs_vp9.c:257
permute
static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
Definition: proresdec2.c:44
vp56_rac_gets
static int vp56_rac_gets(VP56RangeCoder *c, int bits)
Definition: vp56.h:329
ctx
AVFormatContext * ctx
Definition: movenc.c:48
VP56mv::y
int16_t y
Definition: vp56.h:70
vp5_ract_pct
static const uint8_t vp5_ract_pct[3][2][6][11]
Definition: vp5data.h:52
VP56mv
Definition: vp56.h:68
VP56Model::coeff_dccv
uint8_t coeff_dccv[2][11]
Definition: vp56.h:117
VP56Model::coeff_dcct
uint8_t coeff_dcct[2][36][5]
Definition: vp56.h:120
vp56.h
vp5_parse_header
static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
Definition: vp5.c:37
VP56Model::vector_sig
uint8_t vector_sig[2]
Definition: vp56.h:112
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
vp5_ract_lc
static const int16_t vp5_ract_lc[3][3][5][6][2]
Definition: vp5data.h:124
ff_vp56_def_mb_types_stats
const uint8_t ff_vp56_def_mb_types_stats[3][10][2]
Definition: vp56data.c:40
vp5_dccv_pct
static const uint8_t vp5_dccv_pct[2][11]
Definition: vp5data.h:47
c
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
vp5_dccv_lc
static const int16_t vp5_dccv_lc[5][36][2]
Definition: vp5data.h:91
vp5data.h
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
ff_vp56_coeff_parse_table
const uint8_t ff_vp56_coeff_parse_table[6][11]
Definition: vp56data.c:31
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
vp5_parse_vector_models
static void vp5_parse_vector_models(VP56Context *s)
Definition: vp5.c:111
vp56_rac_get_tree
static av_always_inline int vp56_rac_get_tree(VP56RangeCoder *c, const VP56Tree *tree, const uint8_t *probs)
Definition: vp56.h:381
pt
int pt
Definition: rtp.c:35
ff_vp56_pva_tree
const VP56Tree ff_vp56_pva_tree[]
Definition: vp56data.c:49
ff_vp56_init_range_decoder
int ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size)
Definition: vp56rac.c:40
VP56Model::vector_pdi
uint8_t vector_pdi[2][2]
Definition: vp56.h:114
AV_CODEC_ID_VP5
@ AV_CODEC_ID_VP5
Definition: codec_id.h:140
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
delta
float delta
Definition: vorbis_enc_data.h:430
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_vp56_pc_tree
const VP56Tree ff_vp56_pc_tree[]
Definition: vp56data.c:59
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
avcodec.h
ret
ret
Definition: filter_design.txt:187
ff_vp56_coeff_bias
const uint8_t ff_vp56_coeff_bias[]
Definition: vp56data.c:67
VP56_FRAME_CURRENT
@ VP56_FRAME_CURRENT
Definition: vp56.h:44
VP56RangeCoder
Definition: vp56.h:87
AVCodecContext
main external API structure.
Definition: avcodec.h:383
VP56Model
Definition: vp56.h:108
ff_vp56_init_dequant
void ff_vp56_init_dequant(VP56Context *s, int quantizer)
Definition: vp56.c:34
ff_vp56_decode_frame
int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: vp56.c:568
ff_vp56_free
av_cold int ff_vp56_free(AVCodecContext *avctx)
Definition: vp56.c:835
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_set_dimensions
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:86
vp56_rac_get_prob
#define vp56_rac_get_prob
Definition: vp56.h:270
vp5_coeff_groups
static const uint8_t vp5_coeff_groups[]
Definition: vp5data.h:31
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
vp5_parse_coeff_models
static int vp5_parse_coeff_models(VP56Context *s)
Definition: vp5.c:134
VP56Model::vector_dct
uint8_t vector_dct[2]
Definition: vp56.h:113
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:73
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
vp5_vmc_pct
static const uint8_t vp5_vmc_pct[2][11]
Definition: vp5data.h:42
VP56Model::vector_pdv
uint8_t vector_pdv[2][7]
Definition: vp56.h:115