FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 "get_bits.h"
31 #include "internal.h"
32 
33 #include "vp56.h"
34 #include "vp56data.h"
35 #include "vp5data.h"
36 
37 
38 static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
39 {
40  VP56RangeCoder *c = &s->c;
41  int rows, cols;
42  int ret;
43 
44  ret = ff_vp56_init_range_decoder(&s->c, buf, buf_size);
45  if (ret < 0)
46  return ret;
47  s->frames[VP56_FRAME_CURRENT]->key_frame = !vp56_rac_get(c);
48  vp56_rac_get(c);
50  if (s->frames[VP56_FRAME_CURRENT]->key_frame)
51  {
52  int render_x, render_y;
53 
54  vp56_rac_gets(c, 8);
55  if(vp56_rac_gets(c, 5) > 5)
56  return AVERROR_INVALIDDATA;
57  vp56_rac_gets(c, 2);
58  if (vp56_rac_get(c)) {
59  av_log(s->avctx, AV_LOG_ERROR, "interlacing not supported\n");
60  return AVERROR_PATCHWELCOME;
61  }
62  rows = vp56_rac_gets(c, 8); /* number of stored macroblock rows */
63  cols = vp56_rac_gets(c, 8); /* number of stored macroblock cols */
64  if (!rows || !cols) {
65  av_log(s->avctx, AV_LOG_ERROR, "Invalid size %dx%d\n",
66  cols << 4, rows << 4);
67  return AVERROR_INVALIDDATA;
68  }
69  render_y = vp56_rac_gets(c, 8); /* number of displayed macroblock rows */
70  render_x = vp56_rac_gets(c, 8); /* number of displayed macroblock cols */
71  if (render_x == 0 || render_x > cols ||
72  render_y == 0 || render_y > rows)
73  return AVERROR_INVALIDDATA;
74  vp56_rac_gets(c, 2);
75  if (!s->macroblocks || /* first frame */
76  16*cols != s->avctx->coded_width ||
77  16*rows != s->avctx->coded_height) {
78  int ret = ff_set_dimensions(s->avctx, 16 * cols, 16 * rows);
79  if (ret < 0)
80  return ret;
81  return VP56_SIZE_CHANGE;
82  }
83  } else if (!s->macroblocks)
84  return AVERROR_INVALIDDATA;
85  return 0;
86 }
87 
88 static void vp5_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
89 {
90  VP56RangeCoder *c = &s->c;
91  VP56Model *model = s->modelp;
92  int comp, di;
93 
94  for (comp=0; comp<2; comp++) {
95  int delta = 0;
96  if (vp56_rac_get_prob_branchy(c, model->vector_dct[comp])) {
97  int sign = vp56_rac_get_prob(c, model->vector_sig[comp]);
98  di = vp56_rac_get_prob(c, model->vector_pdi[comp][0]);
99  di |= vp56_rac_get_prob(c, model->vector_pdi[comp][1]) << 1;
101  model->vector_pdv[comp]);
102  delta = di | (delta << 2);
103  delta = (delta ^ -sign) + sign;
104  }
105  if (!comp)
106  vect->x = delta;
107  else
108  vect->y = delta;
109  }
110 }
111 
112 static void vp5_parse_vector_models(VP56Context *s)
113 {
114  VP56RangeCoder *c = &s->c;
115  VP56Model *model = s->modelp;
116  int comp, node;
117 
118  for (comp=0; comp<2; comp++) {
119  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][0]))
120  model->vector_dct[comp] = vp56_rac_gets_nn(c, 7);
121  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][1]))
122  model->vector_sig[comp] = vp56_rac_gets_nn(c, 7);
123  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][2]))
124  model->vector_pdi[comp][0] = vp56_rac_gets_nn(c, 7);
125  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][3]))
126  model->vector_pdi[comp][1] = vp56_rac_gets_nn(c, 7);
127  }
128 
129  for (comp=0; comp<2; comp++)
130  for (node=0; node<7; node++)
131  if (vp56_rac_get_prob_branchy(c, vp5_vmc_pct[comp][4 + node]))
132  model->vector_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
133 }
134 
135 static int vp5_parse_coeff_models(VP56Context *s)
136 {
137  VP56RangeCoder *c = &s->c;
138  VP56Model *model = s->modelp;
139  uint8_t def_prob[11];
140  int node, cg, ctx;
141  int ct; /* code type */
142  int pt; /* plane type (0 for Y, 1 for U or V) */
143 
144  memset(def_prob, 0x80, sizeof(def_prob));
145 
146  for (pt=0; pt<2; pt++)
147  for (node=0; node<11; node++)
148  if (vp56_rac_get_prob_branchy(c, vp5_dccv_pct[pt][node])) {
149  def_prob[node] = vp56_rac_gets_nn(c, 7);
150  model->coeff_dccv[pt][node] = def_prob[node];
151  } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
152  model->coeff_dccv[pt][node] = def_prob[node];
153  }
154 
155  for (ct=0; ct<3; ct++)
156  for (pt=0; pt<2; pt++)
157  for (cg=0; cg<6; cg++)
158  for (node=0; node<11; node++)
159  if (vp56_rac_get_prob_branchy(c, vp5_ract_pct[ct][pt][cg][node])) {
160  def_prob[node] = vp56_rac_gets_nn(c, 7);
161  model->coeff_ract[pt][ct][cg][node] = def_prob[node];
162  } else if (s->frames[VP56_FRAME_CURRENT]->key_frame) {
163  model->coeff_ract[pt][ct][cg][node] = def_prob[node];
164  }
165 
166  /* coeff_dcct is a linear combination of coeff_dccv */
167  for (pt=0; pt<2; pt++)
168  for (ctx=0; ctx<36; ctx++)
169  for (node=0; node<5; node++)
170  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);
171 
172  /* coeff_acct is a linear combination of coeff_ract */
173  for (ct=0; ct<3; ct++)
174  for (pt=0; pt<2; pt++)
175  for (cg=0; cg<3; cg++)
176  for (ctx=0; ctx<6; ctx++)
177  for (node=0; node<5; node++)
178  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);
179  return 0;
180 }
181 
182 static int vp5_parse_coeff(VP56Context *s)
183 {
184  VP56RangeCoder *c = &s->c;
185  VP56Model *model = s->modelp;
186  uint8_t *permute = s->idct_scantable;
187  uint8_t *model1, *model2;
188  int coeff, sign, coeff_idx;
189  int b, i, cg, idx, ctx, ctx_last;
190  int pt = 0; /* plane type (0 for Y, 1 for U or V) */
191 
192  if (vpX_rac_is_end(c)) {
193  av_log(s->avctx, AV_LOG_ERROR, "End of AC stream reached in vp5_parse_coeff\n");
194  return AVERROR_INVALIDDATA;
195  }
196 
197  for (b=0; b<6; b++) {
198  int ct = 1; /* code type */
199 
200  if (b > 3) pt = 1;
201 
202  ctx = 6*s->coeff_ctx[ff_vp56_b6to4[b]][0]
203  + s->above_blocks[s->above_block_idx[b]].not_null_dc;
204  model1 = model->coeff_dccv[pt];
205  model2 = model->coeff_dcct[pt][ctx];
206 
207  coeff_idx = 0;
208  for (;;) {
209  if (vp56_rac_get_prob_branchy(c, model2[0])) {
210  if (vp56_rac_get_prob_branchy(c, model2[2])) {
211  if (vp56_rac_get_prob_branchy(c, model2[3])) {
212  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 4;
213  idx = vp56_rac_get_tree(c, ff_vp56_pc_tree, model1);
214  sign = vp56_rac_get(c);
215  coeff = ff_vp56_coeff_bias[idx+5];
216  for (i=ff_vp56_coeff_bit_length[idx]; i>=0; i--)
217  coeff += vp56_rac_get_prob(c, ff_vp56_coeff_parse_table[idx][i]) << i;
218  } else {
219  if (vp56_rac_get_prob_branchy(c, model2[4])) {
220  coeff = 3 + vp56_rac_get_prob(c, model1[5]);
221  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 3;
222  } else {
223  coeff = 2;
224  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 2;
225  }
226  sign = vp56_rac_get(c);
227  }
228  ct = 2;
229  } else {
230  ct = 1;
231  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 1;
232  sign = vp56_rac_get(c);
233  coeff = 1;
234  }
235  coeff = (coeff ^ -sign) + sign;
236  if (coeff_idx)
237  coeff *= s->dequant_ac;
238  s->block_coeff[b][permute[coeff_idx]] = coeff;
239  } else {
240  if (ct && !vp56_rac_get_prob_branchy(c, model2[1]))
241  break;
242  ct = 0;
243  s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx] = 0;
244  }
245  coeff_idx++;
246  if (coeff_idx >= 64)
247  break;
248 
249  cg = vp5_coeff_groups[coeff_idx];
250  ctx = s->coeff_ctx[ff_vp56_b6to4[b]][coeff_idx];
251  model1 = model->coeff_ract[pt][ct][cg];
252  model2 = cg > 2 ? model1 : model->coeff_acct[pt][ct][cg][ctx];
253  }
254 
255  ctx_last = FFMIN(s->coeff_ctx_last[ff_vp56_b6to4[b]], 24);
256  s->coeff_ctx_last[ff_vp56_b6to4[b]] = coeff_idx;
257  if (coeff_idx < ctx_last)
258  for (i=coeff_idx; i<=ctx_last; i++)
259  s->coeff_ctx[ff_vp56_b6to4[b]][i] = 5;
260  s->above_blocks[s->above_block_idx[b]].not_null_dc = s->coeff_ctx[ff_vp56_b6to4[b]][0];
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  s->vp56_coord_div = vp5_coord_div;
288  s->parse_vector_adjustment = vp5_parse_vector_adjustment;
289  s->parse_coeff = vp5_parse_coeff;
290  s->default_models_init = vp5_default_models_init;
291  s->parse_vector_models = vp5_parse_vector_models;
292  s->parse_coeff_models = vp5_parse_coeff_models;
293  s->parse_header = vp5_parse_header;
294 
295  return 0;
296 }
297 
299  .name = "vp5",
300  .long_name = NULL_IF_CONFIG_SMALL("On2 VP5"),
301  .type = AVMEDIA_TYPE_VIDEO,
302  .id = AV_CODEC_ID_VP5,
303  .priv_data_size = sizeof(VP56Context),
305  .close = ff_vp56_free,
307  .capabilities = AV_CODEC_CAP_DR1,
308 };
av_cold int ff_vp56_free(AVCodecContext *avctx)
Definition: vp56.c:812
uint8_t coeff_ract[2][3][6][11]
Definition: vp56.h:114
const char * s
Definition: avisynth_c.h:631
#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:280
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:216
const uint8_t ff_vp56_coeff_bias[]
Definition: vp56data.c:67
uint8_t coeff_dccv[2][11]
Definition: vp56.h:113
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint8_t mb_types_stats[3][10][2]
Definition: vp56.h:119
static int vp5_parse_header(VP56Context *s, const uint8_t *buf, int buf_size)
Definition: vp5.c:38
uint8_t vector_sig[2]
Definition: vp56.h:108
const char * b
Definition: vf_curves.c:109
static const uint8_t vp5_coord_div[]
Definition: vp5data.h:175
static int vp5_parse_coeff_models(VP56Context *s)
Definition: vp5.c:135
#define VP56_SIZE_CHANGE
Definition: vp56.h:70
VP5 compatible video decoder.
static void vp5_parse_vector_adjustment(VP56Context *s, VP56mv *vect)
Definition: vp5.c:88
av_cold int ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha)
Definition: vp56.c:752
AVCodec.
Definition: avcodec.h:3482
static const uint8_t vp5_ract_pct[3][2][6][11]
Definition: vp5data.h:52
int16_t y
Definition: vp56.h:67
uint8_t
#define av_cold
Definition: attributes.h:74
float delta
static int vp5_parse_coeff(VP56Context *s)
Definition: vp5.c:182
int pt
Definition: rtp.c:35
static void permute(int16_t dst[64], const int16_t src[64], enum idct_permutation_type perm_type)
Definition: dct-test.c:143
bitstream reader API header.
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:233
static av_always_inline int vp56_rac_get_tree(VP56RangeCoder *c, const VP56Tree *tree, const uint8_t *probs)
Definition: vp56.h:375
#define av_log(a,...)
static const uint8_t vp5_dccv_pct[2][11]
Definition: vp5data.h:47
#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:112
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:178
static av_always_inline int vp56_rac_get(VP56RangeCoder *c)
Definition: vp56.h:299
const char * name
Name of the codec implementation.
Definition: avcodec.h:3489
void ff_vp56_init_dequant(VP56Context *s, int quantizer)
Definition: vp56.c:34
const uint8_t ff_vp56_b6to4[]
Definition: vp56data.c:29
Libavcodec external API header.
AVCodec ff_vp5_decoder
Definition: vp5.c:298
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:362
#define FFMIN(a, b)
Definition: common.h:92
uint8_t vector_pdi[2][2]
Definition: vp56.h:110
static const int16_t vp5_ract_lc[3][3][5][6][2]
Definition: vp5data.h:124
int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: vp56.c:544
const uint8_t ff_vp56_coeff_bit_length[]
Definition: vp56data.c:68
#define vp56_rac_get_prob
Definition: vp56.h:264
#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:281
const VP56Tree ff_vp56_pc_tree[]
Definition: vp56data.c:59
main external API structure.
Definition: avcodec.h:1512
void * buf
Definition: avisynth_c.h:553
const uint8_t ff_vp56_coeff_parse_table[6][11]
Definition: vp56data.c:31
uint8_t coeff_dcct[2][36][5]
Definition: vp56.h:116
uint8_t coeff_acct[2][3][3][6][5]
Definition: vp56.h:115
Definition: vp56.h:65
static const uint8_t vp5_vmc_pct[2][11]
Definition: vp5data.h:42
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:521
const VP56Tree ff_vp56_pva_tree[]
Definition: vp56data.c:49
int16_t x
Definition: vp56.h:66
common internal api header.
static void vp5_default_models_init(VP56Context *s)
Definition: vp5.c:265
static double c[64]
void * priv_data
Definition: avcodec.h:1554
uint8_t vector_pdv[2][7]
Definition: vp56.h:111
static const double coeff[2][5]
Definition: vf_owdenoise.c:71
static void comp(unsigned char *dst, int dst_stride, unsigned char *src, int src_stride, int add)
Definition: eamad.c:83
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:857
uint8_t vector_dct[2]
Definition: vp56.h:109
static int vp56_rac_gets(VP56RangeCoder *c, int bits)
Definition: vp56.h:323