Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

VP5 and VP6 video decoder

Browse Source 
Originally committed as revision 6213 to svn://svn.ffmpeg.org/ffmpeg/trunk
pull/126/head
Aurelien Jacobs 19 years ago
parent 34a8dcd031
commit 5ce117c37c
18 changed files with 2544 additions and 15 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      Changelog
  2. 2
      MAINTAINERS
  3. 2
      doc/ffmpeg-doc.texi
  4. 2
      libavcodec/Makefile
  5. 9
      libavcodec/allcodecs.c
  6. 10
      libavcodec/avcodec.h
  7. 289
      libavcodec/vp5.c
  8. 662
      libavcodec/vp56.c
  9. 248
      libavcodec/vp56.h
  10. 65
      libavcodec/vp56data.c
  11. 246
      libavcodec/vp56data.h
  12. 173
      libavcodec/vp5data.h
  13. 512
      libavcodec/vp6.c
  14. 291
      libavcodec/vp6data.h
  15. 5
      libavformat/flvdec.c
  16. 6
      libavformat/nsvdec.c
  17. 2
      libavformat/riff.c
  18. 33
      libavformat/swf.c

2
Changelog
Unescape View File

@ -56,6 +56,8 @@ version <next>
- MacIntel support
- AVISynth support
- VMware video decoder
- VP5 video decoder
- VP6 video decoder
version 0.4.9-pre1:

2
MAINTAINERS
Unescape View File

@ -164,6 +164,8 @@ Codecs:
vcr1.c Michael Niedermayer
vmnc.c Kostya Shishkov
vp3* Mike Melanson
vp5 Aurelien Jacobs
vp6 Aurelien Jacobs
vqavideo.c Mike Melanson
wmv2.c Michael Niedermayer
wnv1.c Kostya Shishkov

2
doc/ffmpeg-doc.texi
Unescape View File

@ -778,6 +778,8 @@ following image formats are supported:
@item Sorenson Video 1 @tab X @tab X @tab fourcc: SVQ1
@item Sorenson Video 3 @tab @tab X @tab fourcc: SVQ3
@item On2 VP3 @tab @tab X @tab still experimental
@item On2 VP5 @tab @tab X @tab fourcc: VP50
@item On2 VP6 @tab @tab X @tab fourcc: VP62
@item Theora @tab @tab X @tab still experimental
@item Intel Indeo 3 @tab @tab X
@item FLV @tab X @tab X @tab Sorenson H.263 used in Flash

2
libavcodec/Makefile
Unescape View File

@ -123,6 +123,8 @@ OBJS-$(CONFIG_VMDVIDEO_DECODER) += vmdav.o
OBJS-$(CONFIG_VMNC_DECODER) += vmnc.o
OBJS-$(CONFIG_VORBIS_DECODER) += vorbis.o
OBJS-$(CONFIG_VP3_DECODER) += vp3.o
OBJS-$(CONFIG_VP5_DECODER) += vp5.o vp56.o vp56data.o
OBJS-$(CONFIG_VP6_DECODER) += vp6.o vp56.o vp56data.o
OBJS-$(CONFIG_VQA_DECODER) += vqavideo.o
OBJS-$(CONFIG_WMAV1_DECODER) += wmadec.o
OBJS-$(CONFIG_WMAV2_DECODER) += wmadec.o

9
libavcodec/allcodecs.c
Unescape View File

@ -371,6 +371,15 @@ void avcodec_register_all(void)
#ifdef CONFIG_THEORA_DECODER
register_avcodec(&theora_decoder);
#endif //CONFIG_THEORA_DECODER
#ifdef CONFIG_VP5_DECODER
register_avcodec(&vp5_decoder);
#endif //CONFIG_VP5_DECODER
#ifdef CONFIG_VP6_DECODER
register_avcodec(&vp6_decoder);
#endif //CONFIG_VP6_DECODER
#ifdef CONFIG_VP6F_DECODER
register_avcodec(&vp6f_decoder);
#endif //CONFIG_VP6F_DECODER
#ifdef CONFIG_ASV1_DECODER
register_avcodec(&asv1_decoder);
#endif //CONFIG_ASV1_DECODER

10
libavcodec/avcodec.h
Unescape View File

@ -17,8 +17,8 @@ extern "C" {
#define AV_STRINGIFY(s) AV_TOSTRING(s)
#define AV_TOSTRING(s) #s
#define LIBAVCODEC_VERSION_INT ((51<<16)+(13<<8)+0)
#define LIBAVCODEC_VERSION 51.13.0
#define LIBAVCODEC_VERSION_INT ((51<<16)+(14<<8)+0)
#define LIBAVCODEC_VERSION 51.14.0
#define LIBAVCODEC_BUILD LIBAVCODEC_VERSION_INT
#define LIBAVCODEC_IDENT "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
@ -121,6 +121,9 @@ enum CodecID {
CODEC_ID_CAVS,
CODEC_ID_JPEG2000,
CODEC_ID_VMNC,
CODEC_ID_VP5,
CODEC_ID_VP6,
CODEC_ID_VP6F,
/* various pcm "codecs" */
CODEC_ID_PCM_S16LE= 0x10000,
@ -2192,6 +2195,9 @@ extern AVCodec h264_decoder;
extern AVCodec indeo3_decoder;
extern AVCodec vp3_decoder;
extern AVCodec theora_decoder;
extern AVCodec vp5_decoder;
extern AVCodec vp6_decoder;
extern AVCodec vp6f_decoder;
extern AVCodec amr_nb_decoder;
extern AVCodec amr_nb_encoder;
extern AVCodec amr_wb_encoder;

289
libavcodec/vp5.c
Unescape View File

@ -0,0 +1,289 @@
/**
* @file vp5.c
* VP5 compatible video decoder
*
* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include "avcodec.h"
#include "dsputil.h"
#include "bitstream.h"
#include "mpegvideo.h"
#include "vp56.h"
#include "vp56data.h"
#include "vp5data.h"
static int vp5_parse_header(vp56_context_t *s, uint8_t *buf, int buf_size,
int *golden_frame)
{
vp56_range_coder_t *c = &s->c;
int rows, cols;
vp56_init_range_decoder(&s->c, buf, buf_size);
s->frames[VP56_FRAME_CURRENT].key_frame = !vp56_rac_get(c);
vp56_rac_get(c);
vp56_init_dequant(s, vp56_rac_gets(c, 6));
if (s->frames[VP56_FRAME_CURRENT].key_frame)
{
vp56_rac_gets(c, 8);
if(vp56_rac_gets(c, 5) > 5)
return 0;
vp56_rac_gets(c, 2);
if (vp56_rac_get(c)) {
av_log(s->avctx, AV_LOG_ERROR, "interlacing not supported\n");
return 0;
}
rows = vp56_rac_gets(c, 8); /* number of stored macroblock rows */
cols = vp56_rac_gets(c, 8); /* number of stored macroblock cols */
vp56_rac_gets(c, 8); /* number of displayed macroblock rows */
vp56_rac_gets(c, 8); /* number of displayed macroblock cols */
vp56_rac_gets(c, 2);
if (16*cols != s->avctx->coded_width ||
16*rows != s->avctx->coded_height) {
avcodec_set_dimensions(s->avctx, 16*cols, 16*rows);
return 2;
}
}
return 1;
}
/* Gives very similar result than the vp6 version except in a few cases */
static int vp5_adjust(int v, int t)
{
int s2, s1 = v >> 31;
v ^= s1;
v -= s1;
v *= v < 2*t;
v -= t;
s2 = v >> 31;
v ^= s2;
v -= s2;
v = t - v;
v += s1;
v ^= s1;
return v;
}
static void vp5_parse_vector_adjustment(vp56_context_t *s, vp56_mv_t *vector)
{
vp56_range_coder_t *c = &s->c;
int comp, di;
for (comp=0; comp<2; comp++) {
int delta = 0;
if (vp56_rac_get_prob(c, s->vector_model_dct[comp])) {
int sign = vp56_rac_get_prob(c, s->vector_model_sig[comp]);
di = vp56_rac_get_prob(c, s->vector_model_pdi[comp][0]);
di |= vp56_rac_get_prob(c, s->vector_model_pdi[comp][1]) << 1;
delta = vp56_rac_get_tree(c, vp56_pva_tree,
s->vector_model_pdv[comp]);
delta = di | (delta << 2);
delta = (delta ^ -sign) + sign;
}
if (!comp)
vector->x = delta;
else
vector->y = delta;
}
}
static void vp5_parse_vector_models(vp56_context_t *s)
{
vp56_range_coder_t *c = &s->c;
int comp, node;
for (comp=0; comp<2; comp++) {
if (vp56_rac_get_prob(c, vp5_vmc_pct[comp][0]))
s->vector_model_dct[comp] = vp56_rac_gets_nn(c, 7);
if (vp56_rac_get_prob(c, vp5_vmc_pct[comp][1]))
s->vector_model_sig[comp] = vp56_rac_gets_nn(c, 7);
if (vp56_rac_get_prob(c, vp5_vmc_pct[comp][2]))
s->vector_model_pdi[comp][0] = vp56_rac_gets_nn(c, 7);
if (vp56_rac_get_prob(c, vp5_vmc_pct[comp][3]))
s->vector_model_pdi[comp][1] = vp56_rac_gets_nn(c, 7);
}
for (comp=0; comp<2; comp++)
for (node=0; node<7; node++)
if (vp56_rac_get_prob(c, vp5_vmc_pct[comp][4 + node]))
s->vector_model_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
}
static void vp5_parse_coeff_models(vp56_context_t *s)
{
vp56_range_coder_t *c = &s->c;
uint8_t def_prob[11];
int node, cg, ctx;
int ct; /* code type */
int pt; /* plane type (0 for Y, 1 for U or V) */
memset(def_prob, 0x80, sizeof(def_prob));
for (pt=0; pt<2; pt++)
for (node=0; node<11; node++)
if (vp56_rac_get_prob(c, vp5_dccv_pct[pt][node])) {
def_prob[node] = vp56_rac_gets_nn(c, 7);
s->coeff_model_dccv[pt][node] = def_prob[node];
} else if (s->frames[VP56_FRAME_CURRENT].key_frame) {
s->coeff_model_dccv[pt][node] = def_prob[node];
}
for (ct=0; ct<3; ct++)
for (pt=0; pt<2; pt++)
for (cg=0; cg<6; cg++)
for (node=0; node<11; node++)
if (vp56_rac_get_prob(c, vp5_ract_pct[ct][pt][cg][node])) {
def_prob[node] = vp56_rac_gets_nn(c, 7);
s->coeff_model_ract[pt][ct][cg][node] = def_prob[node];
} else if (s->frames[VP56_FRAME_CURRENT].key_frame) {
s->coeff_model_ract[pt][ct][cg][node] = def_prob[node];
}
/* coeff_model_dcct is a linear combination of coeff_model_dccv */
for (pt=0; pt<2; pt++)
for (ctx=0; ctx<36; ctx++)
for (node=0; node<5; node++)
s->coeff_model_dcct[pt][ctx][node] = clip(((s->coeff_model_dccv[pt][node] * vp5_dccv_lc[node][ctx][0] + 128) >> 8) + vp5_dccv_lc[node][ctx][1], 1, 254);
/* coeff_model_acct is a linear combination of coeff_model_ract */
for (ct=0; ct<3; ct++)
for (pt=0; pt<2; pt++)
for (cg=0; cg<3; cg++)
for (ctx=0; ctx<6; ctx++)
for (node=0; node<5; node++)
s->coeff_model_acct[pt][ct][cg][ctx][node] = clip(((s->coeff_model_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);
}
static void vp5_parse_coeff(vp56_context_t *s)
{
vp56_range_coder_t *c = &s->c;
uint8_t *permute = s->scantable.permutated;
uint8_t *model, *model2;
int coeff, sign, coeff_idx;
int b, i, cg, idx, ctx, ctx_last;
int pt = 0; /* plane type (0 for Y, 1 for U or V) */
for (b=0; b<6; b++) {
int ct = 1; /* code type */
if (b > 3) pt = 1;
ctx = 6*s->coeff_ctx[vp56_b6to4[b]][0]
+ s->above_blocks[s->above_block_idx[b]].not_null_dc;
model = s->coeff_model_dccv[pt];
model2 = s->coeff_model_dcct[pt][ctx];
for (coeff_idx=0; coeff_idx<64; ) {
if (vp56_rac_get_prob(c, model2[0])) {
if (vp56_rac_get_prob(c, model2[2])) {
if (vp56_rac_get_prob(c, model2[3])) {
s->coeff_ctx[vp56_b6to4[b]][coeff_idx] = 4;
idx = vp56_rac_get_tree(c, vp56_pc_tree, model);
sign = vp56_rac_get(c);
coeff = vp56_coeff_bias[idx];
for (i=vp56_coeff_bit_length[idx]; i>=0; i--)
coeff += vp56_rac_get_prob(c, vp56_coeff_parse_table[idx][i]) << i;
} else {
if (vp56_rac_get_prob(c, model2[4])) {
coeff = 3 + vp56_rac_get_prob(c, model[5]);
s->coeff_ctx[vp56_b6to4[b]][coeff_idx] = 3;
} else {
coeff = 2;
s->coeff_ctx[vp56_b6to4[b]][coeff_idx] = 2;
}
sign = vp56_rac_get(c);
}
ct = 2;
} else {
ct = 1;
s->coeff_ctx[vp56_b6to4[b]][coeff_idx] = 1;
sign = vp56_rac_get(c);
coeff = 1;
}
coeff = (coeff ^ -sign) + sign;
if (coeff_idx)
coeff *= s->dequant_ac;
s->block_coeff[b][permute[coeff_idx]] = coeff;
} else {
if (ct && !vp56_rac_get_prob(c, model2[1]))
break;
ct = 0;
s->coeff_ctx[vp56_b6to4[b]][coeff_idx] = 0;
}
cg = vp5_coeff_groups[++coeff_idx];
ctx = s->coeff_ctx[vp56_b6to4[b]][coeff_idx];
model = s->coeff_model_ract[pt][ct][cg];
model2 = cg > 2 ? model : s->coeff_model_acct[pt][ct][cg][ctx];
}
ctx_last = FFMIN(s->coeff_ctx_last[vp56_b6to4[b]], 24);
s->coeff_ctx_last[vp56_b6to4[b]] = coeff_idx;
if (coeff_idx < ctx_last)
for (i=coeff_idx; i<=ctx_last; i++)
s->coeff_ctx[vp56_b6to4[b]][i] = 5;
s->above_blocks[s->above_block_idx[b]].not_null_dc = s->coeff_ctx[vp56_b6to4[b]][0];
}
}
static void vp5_default_models_init(vp56_context_t *s)
{
int i;
for (i=0; i<2; i++) {
s->vector_model_sig[i] = 0x80;
s->vector_model_dct[i] = 0x80;
s->vector_model_pdi[i][0] = 0x55;
s->vector_model_pdi[i][1] = 0x80;
}
memcpy(s->mb_types_stats, vp56_def_mb_types_stats, sizeof(s->mb_types_stats));
memset(s->vector_model_pdv, 0x80, sizeof(s->vector_model_pdv));
}
static int vp5_decode_init(AVCodecContext *avctx)
{
vp56_context_t *s = avctx->priv_data;
vp56_init(s, avctx, 1);
s->vp56_coord_div = vp5_coord_div;
s->parse_vector_adjustment = vp5_parse_vector_adjustment;
s->adjust = vp5_adjust;
s->parse_coeff = vp5_parse_coeff;
s->default_models_init = vp5_default_models_init;
s->parse_vector_models = vp5_parse_vector_models;
s->parse_coeff_models = vp5_parse_coeff_models;
s->parse_header = vp5_parse_header;
return 0;
}
AVCodec vp5_decoder = {
"vp5",
CODEC_TYPE_VIDEO,
CODEC_ID_VP5,
sizeof(vp56_context_t),
vp5_decode_init,
NULL,
vp56_free,
vp56_decode_frame,
};

662
libavcodec/vp56.c
Unescape View File

@ -0,0 +1,662 @@
/**
* @file vp56.c
* VP5 and VP6 compatible video decoder (common features)
*
* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avcodec.h"
#include "vp56.h"
#include "vp56data.h"
void vp56_init_dequant(vp56_context_t *s, int quantizer)
{
s->quantizer = quantizer;
s->dequant_dc = vp56_dc_dequant[quantizer] << 2;
s->dequant_ac = vp56_ac_dequant[quantizer] << 2;
}
static int vp56_get_vectors_predictors(vp56_context_t *s, int row, int col,
vp56_frame_t ref_frame)
{
int nb_pred = 0;
vp56_mv_t vector[2] = {{0,0}, {0,0}};
int pos, offset;
vp56_mv_t mvp;
for (pos=0; pos<12; pos++) {
mvp.x = col + vp56_candidate_predictor_pos[pos][0];
mvp.y = row + vp56_candidate_predictor_pos[pos][1];
if (mvp.x < 0 || mvp.x >= s->mb_width ||
mvp.y < 0 || mvp.y >= s->mb_height)
continue;
offset = mvp.x + s->mb_width*mvp.y;
if (vp56_reference_frame[s->macroblocks[offset].type] != ref_frame)
continue;
if ((s->macroblocks[offset].mv.x == vector[0].x &&
s->macroblocks[offset].mv.y == vector[0].y) ||
(s->macroblocks[offset].mv.x == 0 &&
s->macroblocks[offset].mv.y == 0))
continue;
vector[nb_pred++] = s->macroblocks[offset].mv;
if (nb_pred > 1) {
nb_pred = -1;
break;
}
s->vector_candidate_pos = pos;
}
s->vector_candidate[0] = vector[0];
s->vector_candidate[1] = vector[1];
return nb_pred+1;
}
static void vp56_parse_mb_type_models(vp56_context_t *s)
{
vp56_range_coder_t *c = &s->c;
int i, ctx, type;
for (ctx=0; ctx<3; ctx++) {
if (vp56_rac_get_prob(c, 174)) {
int idx = vp56_rac_gets(c, 4);
memcpy(s->mb_types_stats[ctx],vp56_pre_def_mb_type_stats[idx][ctx],
sizeof(s->mb_types_stats[ctx]));
}
if (vp56_rac_get_prob(c, 254)) {
for (type=0; type<10; type++) {
for(i=0; i<2; i++) {
if (vp56_rac_get_prob(c, 205)) {
int delta, sign = vp56_rac_get(c);
delta = vp56_rac_get_tree(c, vp56_pmbtm_tree,
vp56_mb_type_model_model);
if (!delta)
delta = 4 * vp56_rac_gets(c, 7);
s->mb_types_stats[ctx][type][i] += (delta ^ -sign) + sign;
}
}
}
}
}
/* compute MB type probability tables based on previous MB type */
for (ctx=0; ctx<3; ctx++) {
int p[10];
for (type=0; type<10; type++)
p[type] = 100 * s->mb_types_stats[ctx][type][1];
for (type=0; type<10; type++) {
int p02, p34, p0234, p17, p56, p89, p5689, p156789;
/* conservative MB type probability */
s->mb_type_model[ctx][type][0] = 255 - (255 * s->mb_types_stats[ctx][type][0]) / (1 + s->mb_types_stats[ctx][type][0] + s->mb_types_stats[ctx][type][1]);
p[type] = 0; /* same MB type => weight is null */
/* binary tree parsing probabilities */
p02 = p[0] + p[2];
p34 = p[3] + p[4];
p0234 = p02 + p34;
p17 = p[1] + p[7];
p56 = p[5] + p[6];
p89 = p[8] + p[9];
p5689 = p56 + p89;
p156789 = p17 + p5689;
s->mb_type_model[ctx][type][1] = 1 + 255 * p0234/(1+p0234+p156789);
s->mb_type_model[ctx][type][2] = 1 + 255 * p02 / (1+p0234);
s->mb_type_model[ctx][type][3] = 1 + 255 * p17 / (1+p156789);
s->mb_type_model[ctx][type][4] = 1 + 255 * p[0] / (1+p02);
s->mb_type_model[ctx][type][5] = 1 + 255 * p[3] / (1+p34);
s->mb_type_model[ctx][type][6] = 1 + 255 * p[1] / (1+p17);
s->mb_type_model[ctx][type][7] = 1 + 255 * p56 / (1+p5689);
s->mb_type_model[ctx][type][8] = 1 + 255 * p[5] / (1+p56);
s->mb_type_model[ctx][type][9] = 1 + 255 * p[8] / (1+p89);
/* restore initial value */
p[type] = 100 * s->mb_types_stats[ctx][type][1];
}
}
}
static vp56_mb_t vp56_parse_mb_type(vp56_context_t *s,
vp56_mb_t prev_type, int ctx)
{
uint8_t *mb_type_model = s->mb_type_model[ctx][prev_type];
vp56_range_coder_t *c = &s->c;
if (vp56_rac_get_prob(c, mb_type_model[0]))
return prev_type;
else
return vp56_rac_get_tree(c, vp56_pmbt_tree, mb_type_model);
}
static void vp56_decode_4mv(vp56_context_t *s, int row, int col)
{
vp56_mv_t mv = {0,0};
int type[4];
int b;
/* parse each block type */
for (b=0; b<4; b++) {
type[b] = vp56_rac_gets(&s->c, 2);
if (type[b])
type[b]++; /* only returns 0, 2, 3 or 4 (all INTER_PF) */
}
/* get vectors */
for (b=0; b<4; b++) {
switch (type[b]) {
case VP56_MB_INTER_NOVEC_PF:
s->mv[b] = (vp56_mv_t) {0,0};
break;
case VP56_MB_INTER_DELTA_PF:
s->parse_vector_adjustment(s, &s->mv[b]);
break;
case VP56_MB_INTER_V1_PF:
s->mv[b] = s->vector_candidate[0];
break;
case VP56_MB_INTER_V2_PF:
s->mv[b] = s->vector_candidate[1];
break;
}
mv.x += s->mv[b].x;
mv.y += s->mv[b].y;
}
/* this is the one selected for the whole MB for prediction */
s->macroblocks[row * s->mb_width + col].mv = s->mv[3];
/* chroma vectors are average luma vectors */
if (s->avctx->codec->id == CODEC_ID_VP5) {
s->mv[4].x = s->mv[5].x = RSHIFT(mv.x,2);
s->mv[4].y = s->mv[5].y = RSHIFT(mv.y,2);
} else {
s->mv[4] = s->mv[5] = (vp56_mv_t) {mv.x/4, mv.y/4};
}
}
static vp56_mb_t vp56_decode_mv(vp56_context_t *s, int row, int col)
{
vp56_mv_t *mv, vector = {0,0};
int ctx, b;
ctx = vp56_get_vectors_predictors(s, row, col, VP56_FRAME_PREVIOUS);
s->mb_type = vp56_parse_mb_type(s, s->mb_type, ctx);
s->macroblocks[row * s->mb_width + col].type = s->mb_type;
switch (s->mb_type) {
case VP56_MB_INTER_V1_PF:
mv = &s->vector_candidate[0];
break;
case VP56_MB_INTER_V2_PF:
mv = &s->vector_candidate[1];
break;
case VP56_MB_INTER_V1_GF:
vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN);
mv = &s->vector_candidate[0];
break;
case VP56_MB_INTER_V2_GF:
vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN);
mv = &s->vector_candidate[1];
break;
case VP56_MB_INTER_DELTA_PF:
s->parse_vector_adjustment(s, &vector);
mv = &vector;
break;
case VP56_MB_INTER_DELTA_GF:
vp56_get_vectors_predictors(s, row, col, VP56_FRAME_GOLDEN);
s->parse_vector_adjustment(s, &vector);
mv = &vector;
break;
case VP56_MB_INTER_4V:
vp56_decode_4mv(s, row, col);
return s->mb_type;
default:
mv = &vector;
break;
}
s->macroblocks[row*s->mb_width + col].mv = *mv;
/* same vector for all blocks */
for (b=0; b<6; b++)
s->mv[b] = *mv;
return s->mb_type;
}
static void vp56_add_predictors_dc(vp56_context_t *s, vp56_frame_t ref_frame)
{
int idx = s->scantable.permutated[0];
int i;
for (i=0; i<6; i++) {
vp56_ref_dc_t *ab = &s->above_blocks[s->above_block_idx[i]];
vp56_ref_dc_t *lb = &s->left_block[vp56_b6to4[i]];
int count = 0;
int dc = 0;
if (ref_frame == lb->ref_frame) {
dc += lb->dc_coeff;
count++;
}
if (ref_frame == ab->ref_frame) {
dc += ab->dc_coeff;
count++;
}
if (s->avctx->codec->id == CODEC_ID_VP5) {
if (count < 2 && ref_frame == ab[-1].ref_frame) {
dc += ab[-1].dc_coeff;
count++;
}
if (count < 2 && ref_frame == ab[1].ref_frame) {
dc += ab[1].dc_coeff;
count++;
}
}
if (count == 0)
dc = s->prev_dc[vp56_b6to3[i]][ref_frame];
else if (count == 2)
dc /= 2;
s->block_coeff[i][idx] += dc;
s->prev_dc[vp56_b6to3[i]][ref_frame] = s->block_coeff[i][idx];
ab->dc_coeff = s->block_coeff[i][idx];
ab->ref_frame = ref_frame;
lb->dc_coeff = s->block_coeff[i][idx];
lb->ref_frame = ref_frame;
s->block_coeff[i][idx] *= s->dequant_dc;
}
}
static void vp56_edge_filter(vp56_context_t *s, uint8_t *yuv,
int pix_inc, int line_inc, int t)
{
int pix2_inc = 2 * pix_inc;
int i, v;
for (i=0; i<12; i++) {
v = (yuv[-pix2_inc] + 3*(yuv[0]-yuv[-pix_inc]) - yuv[pix_inc] + 4) >>3;
v = s->adjust(v, t);
yuv[-pix_inc] = clip_uint8(yuv[-pix_inc] + v);
yuv[0] = clip_uint8(yuv[0] - v);
yuv += line_inc;
}
}
static void vp56_deblock_filter(vp56_context_t *s, uint8_t *yuv,
int stride, int dx, int dy)
{
int t = vp56_filter_threshold[s->quantizer];
if (dx) vp56_edge_filter(s, yuv + 10-dx , 1, stride, t);
if (dy) vp56_edge_filter(s, yuv + stride*(10-dy), stride, 1, t);
}
static void vp56_mc(vp56_context_t *s, int b, uint8_t *src,
int stride, int x, int y)
{
int plane = vp56_b6to3[b];
uint8_t *dst= s->frames[VP56_FRAME_CURRENT].data[plane]+s->block_offset[b];
uint8_t *src_block;
int src_offset;
int overlap_offset = 0;
int mask = s->vp56_coord_div[b] - 1;
int deblock_filtering = s->deblock_filtering;
int dx;
int dy;
if (s->avctx->skip_loop_filter >= AVDISCARD_ALL ||
(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY
&& !s->frames[VP56_FRAME_CURRENT].key_frame))
deblock_filtering = 0;
dx = s->mv[b].x / s->vp56_coord_div[b];
dy = s->mv[b].y / s->vp56_coord_div[b];
if (b >= 4) {
x /= 2;
y /= 2;
}
x += dx - 2;
y += dy - 2;
if (x<0 || x+12>=s->plane_width[plane] ||
y<0 || y+12>=s->plane_height[plane]) {
ff_emulated_edge_mc(s->edge_emu_buffer,
src + s->block_offset[b] + (dy-2)*stride + (dx-2),
stride, 12, 12, x, y,
s->plane_width[plane],
s->plane_height[plane]);
src_block = s->edge_emu_buffer;
src_offset = 2 + 2*stride;
} else if (deblock_filtering) {
/* only need a 12x12 block, but there is no such dsp function, */
/* so copy a 16x12 block */
s->dsp.put_pixels_tab[0][0](s->edge_emu_buffer,
src + s->block_offset[b] + (dy-2)*stride + (dx-2),
stride, 12);
src_block = s->edge_emu_buffer;
src_offset = 2 + 2*stride;
} else {
src_block = src;
src_offset = s->block_offset[b] + dy*stride + dx;
}
if (deblock_filtering)
vp56_deblock_filter(s, src_block, stride, dx&7, dy&7);
if (s->mv[b].x & mask)
overlap_offset += (s->mv[b].x > 0) ? 1 : -1;
if (s->mv[b].y & mask)
overlap_offset += (s->mv[b].y > 0) ? stride : -stride;
if (overlap_offset) {
if (s->filter)
s->filter(s, dst, src_block, src_offset, src_offset+overlap_offset,
stride, s->mv[b], mask, s->filter_selection, b<4);
else
s->dsp.put_no_rnd_pixels_l2[1](dst, src_block+src_offset,
src_block+src_offset+overlap_offset,
stride, 8);
} else {
s->dsp.put_pixels_tab[1][0](dst, src_block+src_offset, stride, 8);
}
}
static void vp56_decode_mb(vp56_context_t *s, int row, int col)
{
AVFrame *frame_current, *frame_ref;
vp56_mb_t mb_type;
vp56_frame_t ref_frame;
int b, plan, off;
if (s->frames[VP56_FRAME_CURRENT].key_frame)
mb_type = VP56_MB_INTRA;
else
mb_type = vp56_decode_mv(s, row, col);
ref_frame = vp56_reference_frame[mb_type];
memset(s->block_coeff, 0, sizeof(s->block_coeff));
s->parse_coeff(s);
vp56_add_predictors_dc(s, ref_frame);
frame_current = &s->frames[VP56_FRAME_CURRENT];
frame_ref = &s->frames[ref_frame];
switch (mb_type) {
case VP56_MB_INTRA:
for (b=0; b<6; b++) {
plan = vp56_b6to3[b];
s->dsp.idct_put(frame_current->data[plan] + s->block_offset[b],
s->stride[plan], s->block_coeff[b]);
}
break;
case VP56_MB_INTER_NOVEC_PF:
case VP56_MB_INTER_NOVEC_GF:
for (b=0; b<6; b++) {
plan = vp56_b6to3[b];
off = s->block_offset[b];
s->dsp.put_pixels_tab[1][0](frame_current->data[plan] + off,
frame_ref->data[plan] + off,
s->stride[plan], 8);
s->dsp.idct_add(frame_current->data[plan] + off,
s->stride[plan], s->block_coeff[b]);
}
break;
case VP56_MB_INTER_DELTA_PF:
case VP56_MB_INTER_V1_PF:
case VP56_MB_INTER_V2_PF:
case VP56_MB_INTER_DELTA_GF:
case VP56_MB_INTER_4V:
case VP56_MB_INTER_V1_GF:
case VP56_MB_INTER_V2_GF:
for (b=0; b<6; b++) {
int x_off = b==1 || b==3 ? 8 : 0;
int y_off = b==2 || b==3 ? 8 : 0;
plan = vp56_b6to3[b];
vp56_mc(s, b, frame_ref->data[plan], s->stride[plan],
16*col+x_off, 16*row+y_off);
s->dsp.idct_add(frame_current->data[plan] + s->block_offset[b],
s->stride[plan], s->block_coeff[b]);
}
break;
}
}
static int vp56_size_changed(AVCodecContext *avctx, vp56_context_t *s)
{
int stride = s->frames[VP56_FRAME_CURRENT].linesize[0];
int i;
s->plane_width[0] = s->avctx->width;
s->plane_width[1] = s->plane_width[2] = s->avctx->width/2;
s->plane_height[0] = s->avctx->height;
s->plane_height[1] = s->plane_height[2] = s->avctx->height/2;
for (i=0; i<3; i++)
s->stride[i] = s->flip * s->frames[VP56_FRAME_CURRENT].linesize[i];
s->mb_width = (s->avctx->width+15) / 16;
s->mb_height = (s->avctx->height+15) / 16;
if (s->mb_width > 1000 || s->mb_height > 1000) {
av_log(avctx, AV_LOG_ERROR, "picture too big\n");
return -1;
}
s->above_blocks = av_realloc(s->above_blocks,
(4*s->mb_width+6) * sizeof(*s->above_blocks));
s->macroblocks = av_realloc(s->macroblocks,
s->mb_width*s->mb_height*sizeof(*s->macroblocks));
s->edge_emu_buffer_alloc = av_realloc(s->edge_emu_buffer_alloc, 16*stride);
s->edge_emu_buffer = s->edge_emu_buffer_alloc;
if (s->flip < 0)
s->edge_emu_buffer += 15 * stride;
return 0;
}
int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
uint8_t *buf, int buf_size)
{
vp56_context_t *s = avctx->priv_data;
AVFrame *const p = &s->frames[VP56_FRAME_CURRENT];
AVFrame *picture = data;
int mb_row, mb_col, mb_row_flip, mb_offset = 0;
int block, y, uv, stride_y, stride_uv;
int golden_frame = 0;
int res;
res = s->parse_header(s, buf, buf_size, &golden_frame);
if (!res)
return -1;
p->reference = 1;
if (avctx->get_buffer(avctx, p) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
if (res == 2)
if (vp56_size_changed(avctx, s)) {
avctx->release_buffer(avctx, p);
return -1;
}
if (p->key_frame) {
p->pict_type = FF_I_TYPE;
s->default_models_init(s);
for (block=0; block<s->mb_height*s->mb_width; block++)
s->macroblocks[block].type = VP56_MB_INTRA;
} else {
p->pict_type = FF_P_TYPE;
vp56_parse_mb_type_models(s);
s->parse_vector_models(s);
s->mb_type = VP56_MB_INTER_NOVEC_PF;
}
s->parse_coeff_models(s);
memset(s->prev_dc, 0, sizeof(s->prev_dc));
s->prev_dc[1][VP56_FRAME_CURRENT] = 128;
s->prev_dc[2][VP56_FRAME_CURRENT] = 128;
for (block=0; block < 4*s->mb_width+6; block++) {
s->above_blocks[block].ref_frame = -1;
s->above_blocks[block].dc_coeff = 0;
s->above_blocks[block].not_null_dc = 0;
}
s->above_blocks[2*s->mb_width + 2].ref_frame = 0;
s->above_blocks[3*s->mb_width + 4].ref_frame = 0;
stride_y = p->linesize[0];
stride_uv = p->linesize[1];
if (s->flip < 0)
mb_offset = 7;
/* main macroblocks loop */
for (mb_row=0; mb_row<s->mb_height; mb_row++) {
if (s->flip < 0)
mb_row_flip = s->mb_height - mb_row - 1;
else
mb_row_flip = mb_row;
for (block=0; block<4; block++) {
s->left_block[block].ref_frame = -1;
s->left_block[block].dc_coeff = 0;
s->left_block[block].not_null_dc = 0;
memset(s->coeff_ctx[block], 0, 64*sizeof(s->coeff_ctx[block][0]));
}
memset(s->coeff_ctx_last, 24, sizeof(s->coeff_ctx_last));
s->above_block_idx[0] = 1;
s->above_block_idx[1] = 2;
s->above_block_idx[2] = 1;
s->above_block_idx[3] = 2;
s->above_block_idx[4] = 2*s->mb_width + 2 + 1;
s->above_block_idx[5] = 3*s->mb_width + 4 + 1;
s->block_offset[s->frbi] = (mb_row_flip*16 + mb_offset) * stride_y;
s->block_offset[s->srbi] = s->block_offset[s->frbi] + 8*stride_y;
s->block_offset[1] = s->block_offset[0] + 8;
s->block_offset[3] = s->block_offset[2] + 8;
s->block_offset[4] = (mb_row_flip*8 + mb_offset) * stride_uv;
s->block_offset[5] = s->block_offset[4];
for (mb_col=0; mb_col<s->mb_width; mb_col++) {
vp56_decode_mb(s, mb_row, mb_col);
for (y=0; y<4; y++) {
s->above_block_idx[y] += 2;
s->block_offset[y] += 16;
}
for (uv=4; uv<6; uv++) {
s->above_block_idx[uv] += 1;
s->block_offset[uv] += 8;
}
}
}
if (s->frames[VP56_FRAME_PREVIOUS].data[0]
&& (s->frames[VP56_FRAME_PREVIOUS].data[0]
!= s->frames[VP56_FRAME_GOLDEN].data[0])) {
avctx->release_buffer(avctx, &s->frames[VP56_FRAME_PREVIOUS]);
}
if (p->key_frame || golden_frame) {
if (s->frames[VP56_FRAME_GOLDEN].data[0])
avctx->release_buffer(avctx, &s->frames[VP56_FRAME_GOLDEN]);
s->frames[VP56_FRAME_GOLDEN] = *p;
}
s->frames[VP56_FRAME_PREVIOUS] = *p;
*picture = *p;
*data_size = sizeof(AVPicture);
return buf_size;
}
void vp56_init(vp56_context_t *s, AVCodecContext *avctx, int flip)
{
int i;
s->avctx = avctx;
avctx->pix_fmt = PIX_FMT_YUV420P;
if (s->avctx->idct_algo == FF_IDCT_AUTO)
s->avctx->idct_algo = FF_IDCT_VP3;
dsputil_init(&s->dsp, s->avctx);
ff_init_scantable(s->dsp.idct_permutation, &s->scantable,ff_zigzag_direct);
avcodec_set_dimensions(s->avctx, 0, 0);
for (i=0; i<3; i++)
s->frames[i].data[0] = NULL;
s->edge_emu_buffer_alloc = NULL;
s->above_blocks = NULL;
s->macroblocks = NULL;
s->quantizer = -1;
s->deblock_filtering = 1;
s->filter = NULL;
if (flip) {
s->flip = -1;
s->frbi = 2;
s->srbi = 0;
} else {
s->flip = 1;
s->frbi = 0;
s->srbi = 2;
}
}
int vp56_free(AVCodecContext *avctx)
{
vp56_context_t *s = avctx->priv_data;
av_free(s->above_blocks);
av_free(s->macroblocks);
av_free(s->edge_emu_buffer_alloc);
if (s->frames[VP56_FRAME_GOLDEN].data[0]
&& (s->frames[VP56_FRAME_PREVIOUS].data[0]
!= s->frames[VP56_FRAME_GOLDEN].data[0]))
avctx->release_buffer(avctx, &s->frames[VP56_FRAME_GOLDEN]);
if (s->frames[VP56_FRAME_PREVIOUS].data[0])
avctx->release_buffer(avctx, &s->frames[VP56_FRAME_PREVIOUS]);
return 0;
}

248
libavcodec/vp56.h
Unescape View File

@ -0,0 +1,248 @@
/**
* @file vp56.h
* VP5 and VP6 compatible video decoder (common features)
*
* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef VP56_H
#define VP56_H
#include <stdint.h>
#include "vp56data.h"
#include "dsputil.h"
#include "mpegvideo.h"
typedef struct vp56_context vp56_context_t;
typedef struct vp56_mv vp56_mv_t;
typedef void (*vp56_parse_vector_adjustment_t)(vp56_context_t *s,
vp56_mv_t *vector);
typedef int (*vp56_adjust_t)(int v, int t);
typedef void (*vp56_filter_t)(vp56_context_t *s, uint8_t *dst, uint8_t *src,
int offset1, int offset2, int stride,
vp56_mv_t mv, int mask, int select, int luma);
typedef void (*vp56_parse_coeff_t)(vp56_context_t *s);
typedef void (*vp56_default_models_init_t)(vp56_context_t *s);
typedef void (*vp56_parse_vector_models_t)(vp56_context_t *s);
typedef void (*vp56_parse_coeff_models_t)(vp56_context_t *s);
typedef int (*vp56_parse_header_t)(vp56_context_t *s, uint8_t *buf,
int buf_size, int *golden_frame);
typedef struct {
int high;
int bits;
const uint8_t *buffer;
unsigned long code_word;
} vp56_range_coder_t;
typedef struct {
uint8_t not_null_dc;
vp56_frame_t ref_frame;
DCTELEM dc_coeff;
} vp56_ref_dc_t;
struct vp56_mv {
int x;
int y;
};
typedef struct {
uint8_t type;
vp56_mv_t mv;
} vp56_macroblock_t;
struct vp56_context {
AVCodecContext *avctx;
DSPContext dsp;
ScanTable scantable;
AVFrame frames[3];
uint8_t *edge_emu_buffer_alloc;
uint8_t *edge_emu_buffer;
vp56_range_coder_t c;
/* frame info */
int plane_width[3];
int plane_height[3];
int mb_width; /* number of horizontal MB */
int mb_height; /* number of vertical MB */
int block_offset[6];
int quantizer;
uint16_t dequant_dc;
uint16_t dequant_ac;
/* DC predictors management */
vp56_ref_dc_t *above_blocks;
vp56_ref_dc_t left_block[4];
int above_block_idx[6];
DCTELEM prev_dc[3][3]; /* [plan][ref_frame] */
/* blocks / macroblock */
vp56_mb_t mb_type;
vp56_macroblock_t *macroblocks;
DECLARE_ALIGNED_16(DCTELEM, block_coeff[6][64]);
uint8_t coeff_reorder[64]; /* used in vp6 only */
uint8_t coeff_index_to_pos[64]; /* used in vp6 only */
/* motion vectors */
vp56_mv_t mv[6]; /* vectors for each block in MB */
vp56_mv_t vector_candidate[2];
int vector_candidate_pos;
/* filtering hints */
int deblock_filtering;
int filter_selection;
int filter_mode;
int max_vector_length;
int sample_variance_threshold;
/* AC models */
uint8_t vector_model_sig[2]; /* delta sign */
uint8_t vector_model_dct[2]; /* delta coding types */
uint8_t vector_model_pdi[2][2]; /* predefined delta init */
uint8_t vector_model_pdv[2][7]; /* predefined delta values */
uint8_t vector_model_fdv[2][8]; /* 8 bit delta value definition */
uint8_t mb_type_model[3][10][10]; /* model for decoding MB type */
uint8_t coeff_model_dccv[2][11]; /* DC coeff value */
uint8_t coeff_model_ract[2][3][6][11]; /* Run/AC coding type and AC coeff value */
uint8_t coeff_model_acct[2][3][3][6][5];/* vp5 only AC coding type for coding group < 3 */
uint8_t coeff_model_dcct[2][36][5]; /* DC coeff coding type */
uint8_t coeff_model_runv[2][14]; /* run value (vp6 only) */
uint8_t mb_types_stats[3][10][2]; /* contextual, next MB type stats */
uint8_t coeff_ctx[4][64]; /* used in vp5 only */
uint8_t coeff_ctx_last[4]; /* used in vp5 only */
/* upside-down flipping hints */
int flip; /* are we flipping ? */
int frbi; /* first row block index in MB */
int srbi; /* second row block index in MB */
int stride[3]; /* stride for each plan */
const uint8_t *vp56_coord_div;
vp56_parse_vector_adjustment_t parse_vector_adjustment;
vp56_adjust_t adjust;
vp56_filter_t filter;
vp56_parse_coeff_t parse_coeff;
vp56_default_models_init_t default_models_init;
vp56_parse_vector_models_t parse_vector_models;
vp56_parse_coeff_models_t parse_coeff_models;
vp56_parse_header_t parse_header;
};
void vp56_init(vp56_context_t *s, AVCodecContext *avctx, int flip);
int vp56_free(AVCodecContext *avctx);
void vp56_init_dequant(vp56_context_t *s, int quantizer);
int vp56_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
uint8_t *buf, int buf_size);
/**
* vp56 specific range coder implementation
*/
static inline void vp56_init_range_decoder(vp56_range_coder_t *c,
const uint8_t *buf, int buf_size)
{
c->high = 255;
c->bits = 8;
c->buffer = buf;
c->code_word = *c->buffer++ << 8;
c->code_word |= *c->buffer++;
}
static inline int vp56_rac_get_prob(vp56_range_coder_t *c, uint8_t prob)
{
unsigned int low = 1 + (((c->high - 1) * prob) / 256);
unsigned int low_shift = low << 8;
int bit = c->code_word >= low_shift;
if (bit) {
c->high -= low;
c->code_word -= low_shift;
} else {
c->high = low;
}
/* normalize */
while (c->high < 128) {
c->high <<= 1;
c->code_word <<= 1;
if (--c->bits == 0) {
c->bits = 8;
c->code_word |= *c->buffer++;
}
}
return bit;
}
static inline int vp56_rac_get(vp56_range_coder_t *c)
{
/* equiprobable */
int low = (c->high + 1) >> 1;
unsigned int low_shift = low << 8;
int bit = c->code_word >= low_shift;
if (bit) {
c->high = (c->high - low) << 1;
c->code_word -= low_shift;
} else {
c->high = low << 1;
}
/* normalize */
c->code_word <<= 1;
if (--c->bits == 0) {
c->bits = 8;
c->code_word |= *c->buffer++;
}
return bit;
}
static inline int vp56_rac_gets(vp56_range_coder_t *c, int bits)
{
int value = 0;
while (bits--) {
value = (value << 1) | vp56_rac_get(c);
}
return value;
}
static inline int vp56_rac_gets_nn(vp56_range_coder_t *c, int bits)
{
int v = vp56_rac_gets(c, 7) << 1;
return v + !v;
}
static inline int vp56_rac_get_tree(vp56_range_coder_t *c,
const vp56_tree_t *tree,
const uint8_t *probs)
{
while (tree->val > 0) {
if (vp56_rac_get_prob(c, probs[tree->prob_idx]))
tree += tree->val;
else
tree++;
}
return -tree->val;
}
#endif /* VP56_H */

65
libavcodec/vp56data.c
Unescape View File

@ -0,0 +1,65 @@
/**
* @file vp56data.c
* VP5 and VP6 compatible video decoder (common data)
*
* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <inttypes.h>
#include "vp56data.h"
const uint8_t vp56_b6to3[] = { 0, 0, 0, 0, 1, 2 };
const uint8_t vp56_b6to4[] = { 0, 0, 1, 1, 2, 3 };
const uint8_t vp56_coeff_parse_table[6][11] = {
{ 159, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 145, 165, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 140, 148, 173, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 135, 140, 155, 176, 0, 0, 0, 0, 0, 0, 0 },
{ 130, 134, 141, 157, 180, 0, 0, 0, 0, 0, 0 },
{ 129, 130, 133, 140, 153, 177, 196, 230, 243, 254, 254 },
};
const uint8_t vp56_def_mb_types_stats[3][10][2] = {
{ { 69, 42 }, { 1, 2 }, { 1, 7 }, { 44, 42 }, { 6, 22 },
{ 1, 3 }, { 0, 2 }, { 1, 5 }, { 0, 1 }, { 0, 0 }, },
{ { 229, 8 }, { 1, 1 }, { 0, 8 }, { 0, 0 }, { 0, 0 },
{ 1, 2 }, { 0, 1 }, { 0, 0 }, { 1, 1 }, { 0, 0 }, },
{ { 122, 35 }, { 1, 1 }, { 1, 6 }, { 46, 34 }, { 0, 0 },
{ 1, 2 }, { 0, 1 }, { 0, 1 }, { 1, 1 }, { 0, 0 }, },
};
const vp56_tree_t vp56_pva_tree[] = {
{ 8, 0},
{ 4, 1},
{ 2, 2}, {-0}, {-1},
{ 2, 3}, {-2}, {-3},
{ 4, 4},
{ 2, 5}, {-4}, {-5},
{ 2, 6}, {-6}, {-7},
};
const vp56_tree_t vp56_pc_tree[] = {
{ 4, 6},
{ 2, 7}, {-0}, {-1},
{ 4, 8},
{ 2, 9}, {-2}, {-3},
{ 2,10}, {-4}, {-5},
};
const uint8_t vp56_coeff_bias[] = { 5, 7, 11, 19, 35, 67 };
const uint8_t vp56_coeff_bit_length[] = { 0, 1, 2, 3, 4, 10 };

246
libavcodec/vp56data.h
Unescape View File

@ -0,0 +1,246 @@
/**
* @file vp56data.h
* VP5 and VP6 compatible video decoder (common data)
*
* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef VP56DATA_H
#define VP56DATA_H
#include <inttypes.h>
typedef enum {
VP56_FRAME_CURRENT = 0,
VP56_FRAME_PREVIOUS = 1,
VP56_FRAME_GOLDEN = 2,
} vp56_frame_t;
typedef enum {
VP56_MB_INTER_NOVEC_PF = 0, /**< Inter MB, no vector, from previous frame */
VP56_MB_INTRA = 1, /**< Intra MB */
VP56_MB_INTER_DELTA_PF = 2, /**< Inter MB, above/left vector + delta, from previous frame */
VP56_MB_INTER_V1_PF = 3, /**< Inter MB, first vector, from previous frame */
VP56_MB_INTER_V2_PF = 4, /**< Inter MB, second vector, from previous frame */
VP56_MB_INTER_NOVEC_GF = 5, /**< Inter MB, no vector, from golden frame */
VP56_MB_INTER_DELTA_GF = 6, /**< Inter MB, above/left vector + delta, from golden frame */
VP56_MB_INTER_4V = 7, /**< Inter MB, 4 vectors, from previous frame */
VP56_MB_INTER_V1_GF = 8, /**< Inter MB, first vector, from golden frame */
VP56_MB_INTER_V2_GF = 9, /**< Inter MB, second vector, from golden frame */
} vp56_mb_t;
typedef struct {
int8_t val;
int8_t prob_idx;
} vp56_tree_t;
extern const uint8_t vp56_b6to3[];
extern const uint8_t vp56_b6to4[];
extern const uint8_t vp56_coeff_parse_table[6][11];
extern const uint8_t vp56_def_mb_types_stats[3][10][2];
extern const vp56_tree_t vp56_pva_tree[];
extern const vp56_tree_t vp56_pc_tree[];
extern const uint8_t vp56_coeff_bias[];
extern const uint8_t vp56_coeff_bit_length[];
static const vp56_frame_t vp56_reference_frame[] = {
VP56_FRAME_PREVIOUS, /* VP56_MB_INTER_NOVEC_PF */
VP56_FRAME_CURRENT, /* VP56_MB_INTRA */
VP56_FRAME_PREVIOUS, /* VP56_MB_INTER_DELTA_PF */
VP56_FRAME_PREVIOUS, /* VP56_MB_INTER_V1_PF */
VP56_FRAME_PREVIOUS, /* VP56_MB_INTER_V2_PF */
VP56_FRAME_GOLDEN, /* VP56_MB_INTER_NOVEC_GF */
VP56_FRAME_GOLDEN, /* VP56_MB_INTER_DELTA_GF */
VP56_FRAME_PREVIOUS, /* VP56_MB_INTER_4V */
VP56_FRAME_GOLDEN, /* VP56_MB_INTER_V1_GF */
VP56_FRAME_GOLDEN, /* VP56_MB_INTER_V2_GF */
};
static const uint8_t vp56_ac_dequant[64] = {
94, 92, 90, 88, 86, 82, 78, 74,
70, 66, 62, 58, 54, 53, 52, 51,
50, 49, 48, 47, 46, 45, 44, 43,
42, 40, 39, 37, 36, 35, 34, 33,
32, 31, 30, 29, 28, 27, 26, 25,
24, 23, 22, 21, 20, 19, 18, 17,
16, 15, 14, 13, 12, 11, 10, 9,
8, 7, 6, 5, 4, 3, 2, 1,
};
static const uint8_t vp56_dc_dequant[64] = {
47, 47, 47, 47, 45, 43, 43, 43,
43, 43, 42, 41, 41, 40, 40, 40,
40, 35, 35, 35, 35, 33, 33, 33,
33, 32, 32, 32, 27, 27, 26, 26,
25, 25, 24, 24, 23, 23, 19, 19,
19, 19, 18, 18, 17, 16, 16, 16,
16, 16, 15, 11, 11, 11, 10, 10,
9, 8, 7, 5, 3, 3, 2, 2,
};
static const uint8_t vp56_pre_def_mb_type_stats[16][3][10][2] = {
{ { { 9, 15 }, { 32, 25 }, { 7, 19 }, { 9, 21 }, { 1, 12 },
{ 14, 12 }, { 3, 18 }, { 14, 23 }, { 3, 10 }, { 0, 4 }, },
{ { 41, 22 }, { 1, 0 }, { 1, 31 }, { 0, 0 }, { 0, 0 },
{ 0, 1 }, { 1, 7 }, { 0, 1 }, { 98, 25 }, { 4, 10 }, },
{ { 2, 3 }, { 2, 3 }, { 0, 2 }, { 0, 2 }, { 0, 0 },
{ 11, 4 }, { 1, 4 }, { 0, 2 }, { 3, 2 }, { 0, 4 }, }, },
{ { { 48, 39 }, { 1, 2 }, { 11, 27 }, { 29, 44 }, { 7, 27 },
{ 1, 4 }, { 0, 3 }, { 1, 6 }, { 1, 2 }, { 0, 0 }, },
{ { 123, 37 }, { 6, 4 }, { 1, 27 }, { 0, 0 }, { 0, 0 },
{ 5, 8 }, { 1, 7 }, { 0, 1 }, { 12, 10 }, { 0, 2 }, },
{ { 49, 46 }, { 3, 4 }, { 7, 31 }, { 42, 41 }, { 0, 0 },
{ 2, 6 }, { 1, 7 }, { 1, 4 }, { 2, 4 }, { 0, 1 }, }, },
{ { { 21, 32 }, { 1, 2 }, { 4, 10 }, { 32, 43 }, { 6, 23 },
{ 2, 3 }, { 1, 19 }, { 1, 6 }, { 12, 21 }, { 0, 7 }, },
{ { 26, 14 }, { 14, 12 }, { 0, 24 }, { 0, 0 }, { 0, 0 },
{ 55, 17 }, { 1, 9 }, { 0, 36 }, { 5, 7 }, { 1, 3 }, },
{ { 26, 25 }, { 1, 1 }, { 2, 10 }, { 67, 39 }, { 0, 0 },
{ 1, 1 }, { 0, 14 }, { 0, 2 }, { 31, 26 }, { 1, 6 }, }, },
{ { { 69, 83 }, { 0, 0 }, { 0, 2 }, { 10, 29 }, { 3, 12 },
{ 0, 1 }, { 0, 3 }, { 0, 3 }, { 2, 2 }, { 0, 0 }, },
{ { 209, 5 }, { 0, 0 }, { 0, 27 }, { 0, 0 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, },
{ { 103, 46 }, { 1, 2 }, { 2, 10 }, { 33, 42 }, { 0, 0 },
{ 1, 4 }, { 0, 3 }, { 0, 1 }, { 1, 3 }, { 0, 0 }, }, },
{ { { 11, 20 }, { 1, 4 }, { 18, 36 }, { 43, 48 }, { 13, 35 },
{ 0, 2 }, { 0, 5 }, { 3, 12 }, { 1, 2 }, { 0, 0 }, },
{ { 2, 5 }, { 4, 5 }, { 0, 121 }, { 0, 0 }, { 0, 0 },
{ 0, 3 }, { 2, 4 }, { 1, 4 }, { 2, 2 }, { 0, 1 }, },
{ { 14, 31 }, { 9, 13 }, { 14, 54 }, { 22, 29 }, { 0, 0 },
{ 2, 6 }, { 4, 18 }, { 6, 13 }, { 1, 5 }, { 0, 1 }, }, },
{ { { 70, 44 }, { 0, 1 }, { 2, 10 }, { 37, 46 }, { 8, 26 },
{ 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 1 }, { 0, 0 }, },
{ { 175, 5 }, { 0, 1 }, { 0, 48 }, { 0, 0 }, { 0, 0 },
{ 0, 2 }, { 0, 1 }, { 0, 2 }, { 0, 1 }, { 0, 0 }, },
{ { 85, 39 }, { 0, 0 }, { 1, 9 }, { 69, 40 }, { 0, 0 },
{ 0, 1 }, { 0, 3 }, { 0, 1 }, { 2, 3 }, { 0, 0 }, }, },
{ { { 8, 15 }, { 0, 1 }, { 8, 21 }, { 74, 53 }, { 22, 42 },
{ 0, 1 }, { 0, 2 }, { 0, 3 }, { 1, 2 }, { 0, 0 }, },
{ { 83, 5 }, { 2, 3 }, { 0, 102 }, { 0, 0 }, { 0, 0 },
{ 1, 3 }, { 0, 2 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, },
{ { 31, 28 }, { 0, 0 }, { 3, 14 }, { 130, 34 }, { 0, 0 },
{ 0, 1 }, { 0, 3 }, { 0, 1 }, { 3, 3 }, { 0, 1 }, }, },
{ { { 141, 42 }, { 0, 0 }, { 1, 4 }, { 11, 24 }, { 1, 11 },
{ 0, 1 }, { 0, 1 }, { 0, 2 }, { 0, 0 }, { 0, 0 }, },
{ { 233, 6 }, { 0, 0 }, { 0, 8 }, { 0, 0 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 1 }, { 0, 0 }, },
{ { 171, 25 }, { 0, 0 }, { 1, 5 }, { 25, 21 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, }, },
{ { { 8, 19 }, { 4, 10 }, { 24, 45 }, { 21, 37 }, { 9, 29 },
{ 0, 3 }, { 1, 7 }, { 11, 25 }, { 0, 2 }, { 0, 1 }, },
{ { 34, 16 }, { 112, 21 }, { 1, 28 }, { 0, 0 }, { 0, 0 },
{ 6, 8 }, { 1, 7 }, { 0, 3 }, { 2, 5 }, { 0, 2 }, },
{ { 17, 21 }, { 68, 29 }, { 6, 15 }, { 13, 22 }, { 0, 0 },
{ 6, 12 }, { 3, 14 }, { 4, 10 }, { 1, 7 }, { 0, 3 }, }, },
{ { { 46, 42 }, { 0, 1 }, { 2, 10 }, { 54, 51 }, { 10, 30 },
{ 0, 2 }, { 0, 2 }, { 0, 1 }, { 0, 1 }, { 0, 0 }, },
{ { 159, 35 }, { 2, 2 }, { 0, 25 }, { 0, 0 }, { 0, 0 },
{ 3, 6 }, { 0, 5 }, { 0, 1 }, { 4, 4 }, { 0, 1 }, },
{ { 51, 39 }, { 0, 1 }, { 2, 12 }, { 91, 44 }, { 0, 0 },
{ 0, 2 }, { 0, 3 }, { 0, 1 }, { 2, 3 }, { 0, 1 }, }, },
{ { { 28, 32 }, { 0, 0 }, { 3, 10 }, { 75, 51 }, { 14, 33 },
{ 0, 1 }, { 0, 2 }, { 0, 1 }, { 1, 2 }, { 0, 0 }, },
{ { 75, 39 }, { 5, 7 }, { 2, 48 }, { 0, 0 }, { 0, 0 },
{ 3, 11 }, { 2, 16 }, { 1, 4 }, { 7, 10 }, { 0, 2 }, },
{ { 81, 25 }, { 0, 0 }, { 2, 9 }, { 106, 26 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 1, 1 }, { 0, 0 }, }, },
{ { { 100, 46 }, { 0, 1 }, { 3, 9 }, { 21, 37 }, { 5, 20 },
{ 0, 1 }, { 0, 2 }, { 1, 2 }, { 0, 1 }, { 0, 0 }, },
{ { 212, 21 }, { 0, 1 }, { 0, 9 }, { 0, 0 }, { 0, 0 },
{ 1, 2 }, { 0, 2 }, { 0, 0 }, { 2, 2 }, { 0, 0 }, },
{ { 140, 37 }, { 0, 1 }, { 1, 8 }, { 24, 33 }, { 0, 0 },
{ 1, 2 }, { 0, 2 }, { 0, 1 }, { 1, 2 }, { 0, 0 }, }, },
{ { { 27, 29 }, { 0, 1 }, { 9, 25 }, { 53, 51 }, { 12, 34 },
{ 0, 1 }, { 0, 3 }, { 1, 5 }, { 0, 2 }, { 0, 0 }, },
{ { 4, 2 }, { 0, 0 }, { 0, 172 }, { 0, 0 }, { 0, 0 },
{ 0, 1 }, { 0, 2 }, { 0, 0 }, { 2, 0 }, { 0, 0 }, },
{ { 14, 23 }, { 1, 3 }, { 11, 53 }, { 90, 31 }, { 0, 0 },
{ 0, 3 }, { 1, 5 }, { 2, 6 }, { 1, 2 }, { 0, 0 }, }, },
{ { { 80, 38 }, { 0, 0 }, { 1, 4 }, { 69, 33 }, { 5, 16 },
{ 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 1 }, { 0, 0 }, },
{ { 187, 22 }, { 1, 1 }, { 0, 17 }, { 0, 0 }, { 0, 0 },
{ 3, 6 }, { 0, 4 }, { 0, 1 }, { 4, 4 }, { 0, 1 }, },
{ { 123, 29 }, { 0, 0 }, { 1, 7 }, { 57, 30 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 0 }, }, },
{ { { 16, 20 }, { 0, 0 }, { 2, 8 }, { 104, 49 }, { 15, 33 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 1, 1 }, { 0, 0 }, },
{ { 133, 6 }, { 1, 2 }, { 1, 70 }, { 0, 0 }, { 0, 0 },
{ 0, 2 }, { 0, 4 }, { 0, 3 }, { 1, 1 }, { 0, 0 }, },
{ { 13, 14 }, { 0, 0 }, { 4, 20 }, { 175, 20 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 1, 1 }, { 0, 0 }, }, },
{ { { 194, 16 }, { 0, 0 }, { 1, 1 }, { 1, 9 }, { 1, 3 },
{ 0, 0 }, { 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, },
{ { 251, 1 }, { 0, 0 }, { 0, 2 }, { 0, 0 }, { 0, 0 },
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, },
{ { 202, 23 }, { 0, 0 }, { 1, 3 }, { 2, 9 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, }, },
};
static const uint8_t vp56_filter_threshold[] = {
14, 14, 13, 13, 12, 12, 10, 10,
10, 10, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 8, 8, 8, 8,
8, 8, 8, 8, 7, 7, 7, 7,
7, 7, 6, 6, 6, 6, 6, 6,
5, 5, 5, 5, 4, 4, 4, 4,
4, 4, 4, 3, 3, 3, 3, 2,
};
static const uint8_t vp56_mb_type_model_model[] = {
171, 83, 199, 140, 125, 104,
};
static const vp56_tree_t vp56_pmbtm_tree[] = {
{ 4, 0},
{ 2, 1}, {-8}, {-4},
{ 8, 2},
{ 6, 3},
{ 4, 4},
{ 2, 5}, {-24}, {-20}, {-16}, {-12}, {-0},
};
static const vp56_tree_t vp56_pmbt_tree[] = {
{ 8, 1},
{ 4, 2},
{ 2, 4}, {-VP56_MB_INTER_NOVEC_PF}, {-VP56_MB_INTER_DELTA_PF},
{ 2, 5}, {-VP56_MB_INTER_V1_PF}, {-VP56_MB_INTER_V2_PF},
{ 4, 3},
{ 2, 6}, {-VP56_MB_INTRA}, {-VP56_MB_INTER_4V},
{ 4, 7},
{ 2, 8}, {-VP56_MB_INTER_NOVEC_GF}, {-VP56_MB_INTER_DELTA_GF},
{ 2, 9}, {-VP56_MB_INTER_V1_GF}, {-VP56_MB_INTER_V2_GF},
};
/* relative pos of surrounding blocks, from closest to farthest */
static const int8_t vp56_candidate_predictor_pos[12][2] = {
{ 0, -1 },
{ -1, 0 },
{ -1, -1 },
{ 1, -1 },
{ 0, -2 },
{ -2, 0 },
{ -2, -1 },
{ -1, -2 },
{ 1, -2 },
{ 2, -1 },
{ -2, -2 },
{ 2, -2 },
};
#endif /* VP56DATA */

173
libavcodec/vp5data.h
Unescape View File

@ -0,0 +1,173 @@
/**
* @file vp5data.h
* VP5 compatible video decoder
*
* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef VP5DATA_H
#define VP5DATA_H
#include <inttypes.h>
static const uint8_t vp5_coeff_groups[] = {
-1, 0, 1, 1, 2, 1, 1, 2,
2, 1, 1, 2, 2, 2, 1, 2,
2, 2, 2, 2, 1, 1, 2, 2,
3, 3, 4, 3, 4, 4, 4, 3,
3, 3, 3, 3, 4, 3, 3, 3,
4, 4, 4, 4, 4, 3, 3, 4,
4, 4, 3, 4, 4, 4, 4, 4,
4, 4, 5, 5, 5, 5, 5, 5,
};
static const uint8_t vp5_vmc_pct[2][11] = {
{ 243, 220, 251, 253, 237, 232, 241, 245, 247, 251, 253 },
{ 235, 211, 246, 249, 234, 231, 248, 249, 252, 252, 254 },
};
static const uint8_t vp5_dccv_pct[2][11] = {
{ 146, 197, 181, 207, 232, 243, 238, 251, 244, 250, 249 },
{ 179, 219, 214, 240, 250, 254, 244, 254, 254, 254, 254 },
};
static const uint8_t vp5_ract_pct[3][2][6][11] = {
{ { { 227, 246, 230, 247, 244, 254, 254, 254, 254, 254, 254 },
{ 202, 254, 209, 231, 231, 249, 249, 253, 254, 254, 254 },
{ 206, 254, 225, 242, 241, 251, 253, 254, 254, 254, 254 },
{ 235, 254, 241, 253, 252, 254, 254, 254, 254, 254, 254 },
{ 234, 254, 248, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 } },
{ { 240, 254, 248, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 238, 254, 240, 253, 254, 254, 254, 254, 254, 254, 254 },
{ 244, 254, 251, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 } } },
{ { { 206, 203, 227, 239, 247, 254, 253, 254, 254, 254, 254 },
{ 207, 199, 220, 236, 243, 252, 252, 254, 254, 254, 254 },
{ 212, 219, 230, 243, 244, 253, 252, 254, 254, 254, 254 },
{ 236, 237, 247, 252, 253, 254, 254, 254, 254, 254, 254 },
{ 240, 240, 248, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 } },
{ { 230, 233, 249, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 238, 238, 250, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 248, 251, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 } } },
{ { { 225, 239, 227, 231, 244, 253, 243, 254, 254, 253, 254 },
{ 232, 234, 224, 228, 242, 249, 242, 252, 251, 251, 254 },
{ 235, 249, 238, 240, 251, 254, 249, 254, 253, 253, 254 },
{ 249, 253, 251, 250, 254, 254, 254, 254, 254, 254, 254 },
{ 251, 250, 249, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 } },
{ { 243, 244, 250, 250, 254, 254, 254, 254, 254, 254, 254 },
{ 249, 248, 250, 253, 254, 254, 254, 254, 254, 254, 254 },
{ 253, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 } } },
};
static const int16_t vp5_dccv_lc[5][36][2] = {
{ {154, 61}, {141, 54}, { 90, 45}, { 54, 34}, { 54, 13}, {128, 109},
{136, 54}, {148, 45}, { 92, 41}, { 54, 33}, { 51, 15}, { 87, 113},
{ 87, 44}, { 97, 40}, { 67, 36}, { 46, 29}, { 41, 15}, { 64, 80},
{ 59, 33}, { 61, 31}, { 51, 28}, { 44, 22}, { 33, 12}, { 49, 63},
{ 69, 12}, { 59, 16}, { 46, 14}, { 31, 13}, { 26, 6}, { 92, 26},
{128, 108}, { 77, 119}, { 54, 84}, { 26, 71}, { 87, 19}, { 95, 155} },
{ {154, 4}, {182, 0}, {159, -8}, {128, -5}, {143, -5}, {187, 55},
{182, 0}, {228, -3}, {187, -7}, {174, -9}, {189, -11}, {169, 79},
{161, -9}, {192, -8}, {187, -9}, {169, -10}, {136, -9}, {184, 40},
{164, -11}, {179, -10}, {174, -10}, {161, -10}, {115, -7}, {197, 20},
{195, -11}, {195, -11}, {146, -10}, {110, -6}, { 95, -4}, {195, 39},
{182, 55}, {172, 77}, {177, 37}, {169, 29}, {172, 52}, { 92, 162} },
{ {174, 80}, {164, 80}, { 95, 80}, { 46, 66}, { 56, 24}, { 36, 193},
{164, 80}, {166, 77}, {105, 76}, { 49, 68}, { 46, 31}, { 49, 186},
{ 97, 78}, {110, 74}, { 72, 72}, { 44, 60}, { 33, 30}, { 69, 131},
{ 61, 61}, { 69, 63}, { 51, 57}, { 31, 48}, { 26, 27}, { 64, 89},
{ 67, 23}, { 51, 32}, { 36, 33}, { 26, 28}, { 20, 12}, { 44, 68},
{ 26, 197}, { 41, 189}, { 61, 129}, { 28, 103}, { 49, 52}, {-12, 245} },
{ {102, 141}, { 79, 166}, { 72, 162}, { 97, 125}, {179, 4}, {307, 0},
{ 72, 168}, { 69, 175}, { 84, 160}, {105, 127}, {148, 34}, {310, 0},
{ 84, 151}, { 82, 161}, { 87, 153}, { 87, 135}, {115, 51}, {317, 0},
{ 97, 125}, {102, 131}, {105, 125}, { 87, 122}, { 84, 64}, { 54, 184},
{166, 18}, {146, 43}, {125, 51}, { 90, 64}, { 95, 7}, { 38, 154},
{294, 0}, { 13, 225}, { 10, 225}, { 67, 168}, { 0, 167}, {161, 94} },
{ {172, 76}, {172, 75}, {136, 80}, { 64, 98}, { 74, 67}, {315, 0},
{169, 76}, {207, 56}, {164, 66}, { 97, 80}, { 67, 72}, {328, 0},
{136, 80}, {187, 53}, {154, 62}, { 72, 85}, { -2, 105}, {305, 0},
{ 74, 91}, {128, 64}, {113, 64}, { 61, 77}, { 41, 75}, {259, 0},
{ 46, 84}, { 51, 81}, { 28, 89}, { 31, 78}, { 23, 77}, {202, 0},
{323, 0}, {323, 0}, {300, 0}, {236, 0}, {195, 0}, {328, 0} },
};
static const int16_t vp5_ract_lc[3][3][5][6][2] = {
{ { { {276, 0}, {238, 0}, {195, 0}, {156, 0}, {113, 0}, {274, 0} },
{ { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1} },
{ {192, 59}, {182, 50}, {141, 48}, {110, 40}, { 92, 19}, {125,128} },
{ {169, 87}, {169, 83}, {184, 62}, {220, 16}, {184, 0}, {264, 0} },
{ {212, 40}, {212, 36}, {169, 49}, {174, 27}, { 8,120}, {182, 71} } },
{ { {259, 10}, {197, 19}, {143, 22}, {123, 16}, {110, 8}, {133, 88} },
{ { 0, 1}, {256, 0}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1} },
{ {207, 46}, {187, 50}, { 97, 83}, { 23,100}, { 41, 56}, { 56,188} },
{ {166, 90}, {146,108}, {161, 88}, {136, 95}, {174, 0}, {266, 0} },
{ {264, 7}, {243, 18}, {184, 43}, {-14,154}, { 20,112}, { 20,199} } },
{ { {230, 26}, {197, 22}, {159, 20}, {146, 12}, {136, 4}, { 54,162} },
{ { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1} },
{ {192, 59}, {156, 72}, { 84,101}, { 49,101}, { 79, 47}, { 79,167} },
{ {138,115}, {136,116}, {166, 80}, {238, 0}, {195, 0}, {261, 0} },
{ {225, 33}, {205, 42}, {159, 61}, { 79, 96}, { 92, 66}, { 28,195} } },
}, {
{ { {200, 37}, {197, 18}, {159, 13}, {143, 7}, {102, 5}, {123,126} },
{ {197, 3}, {220, -9}, {210,-12}, {187, -6}, {151, -2}, {174, 80} },
{ {200, 53}, {187, 47}, {159, 40}, {118, 38}, {100, 18}, {141,111} },
{ {179, 78}, {166, 86}, {197, 50}, {207, 27}, {187, 0}, {115,139} },
{ {218, 34}, {220, 29}, {174, 46}, {128, 61}, { 54, 89}, {187, 65} } },
{ { {238, 14}, {197, 18}, {125, 26}, { 90, 25}, { 82, 13}, {161, 86} },
{ {189, 1}, {205, -2}, {156, -4}, {143, -4}, {146, -4}, {172, 72} },
{ {230, 31}, {192, 45}, {102, 76}, { 38, 85}, { 56, 41}, { 64,173} },
{ {166, 91}, {141,111}, {128,116}, {118,109}, {177, 0}, { 23,222} },
{ {253, 14}, {236, 21}, {174, 49}, { 33,118}, { 44, 93}, { 23,187} } },
{ { {218, 28}, {179, 28}, {118, 35}, { 95, 30}, { 72, 24}, {128,108} },
{ {187, 1}, {174, -1}, {125, -1}, {110, -1}, {108, -1}, {202, 52} },
{ {197, 53}, {146, 75}, { 46,118}, { 33,103}, { 64, 50}, {118,126} },
{ {138,114}, {128,122}, {161, 86}, {243, -6}, {195, 0}, { 38,210} },
{ {215, 39}, {179, 58}, { 97,101}, { 95, 85}, { 87, 70}, { 69,152} } },
}, {
{ { {236, 24}, {205, 18}, {172, 12}, {154, 6}, {125, 1}, {169, 75} },
{ {187, 4}, {230, -2}, {228, -4}, {236, -4}, {241, -2}, {192, 66} },
{ {200, 46}, {187, 42}, {159, 34}, {136, 25}, {105, 10}, {179, 62} },
{ {207, 55}, {192, 63}, {192, 54}, {195, 36}, {177, 1}, {143, 98} },
{ {225, 27}, {207, 34}, {200, 30}, {131, 57}, { 97, 60}, {197, 45} } },
{ { {271, 8}, {218, 13}, {133, 19}, { 90, 19}, { 72, 7}, {182, 51} },
{ {179, 1}, {225, -1}, {154, -2}, {110, -1}, { 92, 0}, {195, 41} },
{ {241, 26}, {189, 40}, { 82, 64}, { 33, 60}, { 67, 17}, {120, 94} },
{ {192, 68}, {151, 94}, {146, 90}, {143, 72}, {161, 0}, {113,128} },
{ {256, 12}, {218, 29}, {166, 48}, { 44, 99}, { 31, 87}, {148, 78} } },
{ { {238, 20}, {184, 22}, {113, 27}, { 90, 22}, { 74, 9}, {192, 37} },
{ {184, 0}, {215, -1}, {141, -1}, { 97, 0}, { 49, 0}, {264, 13} },
{ {182, 51}, {138, 61}, { 95, 63}, { 54, 59}, { 64, 25}, {200, 45} },
{ {179, 75}, {156, 87}, {174, 65}, {177, 44}, {174, 0}, {164, 85} },
{ {195, 45}, {148, 65}, {105, 79}, { 95, 72}, { 87, 60}, {169, 63} } },
}
};
static const uint8_t vp5_coord_div[] = { 2, 2, 2, 2, 4, 4 };
#endif /* VP5DATA_H */

512
libavcodec/vp6.c
Unescape View File

@ -0,0 +1,512 @@
/**
* @file vp6.c
* VP6 compatible video decoder
*
* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <inttypes.h>
#include "avcodec.h"
#include "dsputil.h"
#include "bitstream.h"
#include "mpegvideo.h"
#include "vp56.h"
#include "vp56data.h"
#include "vp6data.h"
static int vp6_parse_header(vp56_context_t *s, uint8_t *buf, int buf_size,
int *golden_frame)
{
vp56_range_coder_t *c = &s->c;
int parse_filter_info;
int rows, cols;
int res = 1;
if (buf[0] & 1)
return 0;
s->frames[VP56_FRAME_CURRENT].key_frame = !(buf[0] & 0x80);
vp56_init_dequant(s, (buf[0] >> 1) & 0x3F);
if (s->frames[VP56_FRAME_CURRENT].key_frame) {
if ((buf[1] & 0xFE) != 0x46) /* would be 0x36 for VP61 */
return 0;
if (buf[1] & 1) {
av_log(s->avctx, AV_LOG_ERROR, "interlacing not supported\n");
return 0;
}
rows = buf[2]; /* number of stored macroblock rows */
cols = buf[3]; /* number of stored macroblock cols */
/* buf[4] is number of displayed macroblock rows */
/* buf[5] is number of displayed macroblock cols */
if (16*cols != s->avctx->coded_width ||
16*rows != s->avctx->coded_height) {
avcodec_set_dimensions(s->avctx, 16*cols, 16*rows);
res = 2;
}
vp56_init_range_decoder(c, buf+6, buf_size-6);
vp56_rac_gets(c, 2);
parse_filter_info = 1;
} else {
vp56_init_range_decoder(c, buf+1, buf_size-1);
*golden_frame = vp56_rac_get(c);
s->deblock_filtering = vp56_rac_get(c);
if (s->deblock_filtering)
vp56_rac_get(c);
parse_filter_info = vp56_rac_get(c);
}
if (parse_filter_info) {
if (vp56_rac_get(c)) {
s->filter_mode = 2;
s->sample_variance_threshold = vp56_rac_gets(c, 5);
s->max_vector_length = 2 << vp56_rac_gets(c, 3);
} else if (vp56_rac_get(c)) {
s->filter_mode = 1;
} else {
s->filter_mode = 0;
}
s->filter_selection = vp56_rac_gets(c, 4);
}
vp56_rac_get(c);
return res;
}
static void vp6_coeff_order_table_init(vp56_context_t *s)
{
int i, pos, idx = 1;
s->coeff_index_to_pos[0] = 0;
for (i=0; i<16; i++)
for (pos=1; pos<64; pos++)
if (s->coeff_reorder[pos] == i)
s->coeff_index_to_pos[idx++] = pos;
}
static void vp6_default_models_init(vp56_context_t *s)
{
s->vector_model_dct[0] = 0xA2;
s->vector_model_dct[1] = 0xA4;
s->vector_model_sig[0] = 0x80;
s->vector_model_sig[1] = 0x80;
memcpy(s->mb_types_stats, vp56_def_mb_types_stats, sizeof(s->mb_types_stats));
memcpy(s->vector_model_fdv, vp6_def_fdv_vector_model, sizeof(s->vector_model_fdv));
memcpy(s->vector_model_pdv, vp6_def_pdv_vector_model, sizeof(s->vector_model_pdv));
memcpy(s->coeff_model_runv, vp6_def_runv_coeff_model, sizeof(s->coeff_model_runv));
memcpy(s->coeff_reorder, vp6_def_coeff_reorder, sizeof(s->coeff_reorder));
vp6_coeff_order_table_init(s);
}
static void vp6_parse_vector_models(vp56_context_t *s)
{
vp56_range_coder_t *c = &s->c;
int comp, node;
for (comp=0; comp<2; comp++) {
if (vp56_rac_get_prob(c, vp6_sig_dct_pct[comp][0]))
s->vector_model_dct[comp] = vp56_rac_gets_nn(c, 7);
if (vp56_rac_get_prob(c, vp6_sig_dct_pct[comp][1]))
s->vector_model_sig[comp] = vp56_rac_gets_nn(c, 7);
}
for (comp=0; comp<2; comp++)
for (node=0; node<7; node++)
if (vp56_rac_get_prob(c, vp6_pdv_pct[comp][node]))
s->vector_model_pdv[comp][node] = vp56_rac_gets_nn(c, 7);
for (comp=0; comp<2; comp++)
for (node=0; node<8; node++)
if (vp56_rac_get_prob(c, vp6_fdv_pct[comp][node]))
s->vector_model_fdv[comp][node] = vp56_rac_gets_nn(c, 7);
}
static void vp6_parse_coeff_models(vp56_context_t *s)
{
vp56_range_coder_t *c = &s->c;
int def_prob[11];
int node, cg, ctx, pos;
int ct; /* code type */
int pt; /* plane type (0 for Y, 1 for U or V) */
memset(def_prob, 0x80, sizeof(def_prob));
for (pt=0; pt<2; pt++)
for (node=0; node<11; node++)
if (vp56_rac_get_prob(c, vp6_dccv_pct[pt][node])) {
def_prob[node] = vp56_rac_gets_nn(c, 7);
s->coeff_model_dccv[pt][node] = def_prob[node];
} else if (s->frames[VP56_FRAME_CURRENT].key_frame) {
s->coeff_model_dccv[pt][node] = def_prob[node];
}
if (vp56_rac_get(c)) {
for (pos=1; pos<64; pos++)
if (vp56_rac_get_prob(c, vp6_coeff_reorder_pct[pos]))
s->coeff_reorder[pos] = vp56_rac_gets(c, 4);
vp6_coeff_order_table_init(s);
}
for (cg=0; cg<2; cg++)
for (node=0; node<14; node++)
if (vp56_rac_get_prob(c, vp6_runv_pct[cg][node]))
s->coeff_model_runv[cg][node] = vp56_rac_gets_nn(c, 7);
for (ct=0; ct<3; ct++)
for (pt=0; pt<2; pt++)
for (cg=0; cg<6; cg++)
for (node=0; node<11; node++)
if (vp56_rac_get_prob(c, vp6_ract_pct[ct][pt][cg][node])) {
def_prob[node] = vp56_rac_gets_nn(c, 7);
s->coeff_model_ract[pt][ct][cg][node] = def_prob[node];
} else if (s->frames[VP56_FRAME_CURRENT].key_frame) {
s->coeff_model_ract[pt][ct][cg][node] = def_prob[node];
}
/* coeff_model_dcct is a linear combination of coeff_model_dccv */
for (pt=0; pt<2; pt++)
for (ctx=0; ctx<3; ctx++)
for (node=0; node<5; node++)
s->coeff_model_dcct[pt][ctx][node] = clip(((s->coeff_model_dccv[pt][node] * vp6_dccv_lc[ctx][node][0] + 128) >> 8) + vp6_dccv_lc[ctx][node][1], 1, 255);
}
static void vp6_parse_vector_adjustment(vp56_context_t *s, vp56_mv_t *vector)
{
vp56_range_coder_t *c = &s->c;
int comp;
*vector = (vp56_mv_t) {0,0};
if (s->vector_candidate_pos < 2)
*vector = s->vector_candidate[0];
for (comp=0; comp<2; comp++) {
int i, delta = 0;
if (vp56_rac_get_prob(c, s->vector_model_dct[comp])) {
static const uint8_t prob_order[] = {0, 1, 2, 7, 6, 5, 4};
for (i=0; i<sizeof(prob_order); i++) {
int j = prob_order[i];
delta |= vp56_rac_get_prob(c, s->vector_model_fdv[comp][j])<<j;
}
if (delta & 0xF0)
delta |= vp56_rac_get_prob(c, s->vector_model_fdv[comp][3])<<3;
else
delta |= 8;
} else {
delta = vp56_rac_get_tree(c, vp56_pva_tree,
s->vector_model_pdv[comp]);
}
if (delta && vp56_rac_get_prob(c, s->vector_model_sig[comp]))
delta = -delta;
if (!comp)
vector->x += delta;
else
vector->y += delta;
}
}
static void vp6_parse_coeff(vp56_context_t *s)
{
vp56_range_coder_t *c = &s->c;
uint8_t *permute = s->scantable.permutated;
uint8_t *model, *model2, *model3;
int coeff, sign, coeff_idx;
int b, i, cg, idx, ctx;
int pt = 0; /* plane type (0 for Y, 1 for U or V) */
for (b=0; b<6; b++) {
int ct = 1; /* code type */
int run = 1;
if (b > 3) pt = 1;
ctx = s->left_block[vp56_b6to4[b]].not_null_dc
+ s->above_blocks[s->above_block_idx[b]].not_null_dc;
model = s->coeff_model_dccv[pt];
model2 = s->coeff_model_dcct[pt][ctx];
for (coeff_idx=0; coeff_idx<64; ) {
if ((coeff_idx>1 && ct==0) || vp56_rac_get_prob(c, model2[0])) {
/* parse a coeff */
if (coeff_idx == 0) {
s->left_block[vp56_b6to4[b]].not_null_dc = 1;
s->above_blocks[s->above_block_idx[b]].not_null_dc = 1;
}
if (vp56_rac_get_prob(c, model2[2])) {
if (vp56_rac_get_prob(c, model2[3])) {
idx = vp56_rac_get_tree(c, vp56_pc_tree, model);
coeff = vp56_coeff_bias[idx];
for (i=vp56_coeff_bit_length[idx]; i>=0; i--)
coeff += vp56_rac_get_prob(c, vp56_coeff_parse_table[idx][i]) << i;
} else {
if (vp56_rac_get_prob(c, model2[4]))
coeff = 3 + vp56_rac_get_prob(c, model[5]);
else
coeff = 2;
}
ct = 2;
} else {
ct = 1;
coeff = 1;
}
sign = vp56_rac_get(c);
coeff = (coeff ^ -sign) + sign;
if (coeff_idx)
coeff *= s->dequant_ac;
idx = s->coeff_index_to_pos[coeff_idx];
s->block_coeff[b][permute[idx]] = coeff;
run = 1;
} else {
/* parse a run */
ct = 0;
if (coeff_idx == 0) {
s->left_block[vp56_b6to4[b]].not_null_dc = 0;
s->above_blocks[s->above_block_idx[b]].not_null_dc = 0;
} else {
if (!vp56_rac_get_prob(c, model2[1]))
break;
model3 = s->coeff_model_runv[coeff_idx >= 6];
run = vp56_rac_get_tree(c, vp6_pcr_tree, model3);
if (!run)
for (run=9, i=0; i<6; i++)
run += vp56_rac_get_prob(c, model3[i+8]) << i;
}
}
cg = vp6_coeff_groups[coeff_idx+=run];
model = model2 = s->coeff_model_ract[pt][ct][cg];
}
}
}
static int vp6_adjust(int v, int t)
{
int V = v, s = v >> 31;
V ^= s;
V -= s;
if (V-t-1 >= (unsigned)(t-1))
return v;
V = 2*t - V;
V += s;
V ^= s;
return V;
}
static int vp6_block_variance(uint8_t *src, int stride)
{
int sum = 0, square_sum = 0;
int y, x;
for (y=0; y<8; y+=2) {
for (x=0; x<8; x+=2) {
sum += src[x];
square_sum += src[x]*src[x];
}
src += 2*stride;
}
return (16*square_sum - sum*sum) / (16*16);
}
static void vp6_filter_hv2(vp56_context_t *s, uint8_t *dst, uint8_t *src,
int stride, int delta, int16_t weight)
{
s->dsp.put_pixels_tab[1][0](dst, src, stride, 8);
s->dsp.biweight_h264_pixels_tab[3](dst, src+delta, stride, 2,
8-weight, weight, 0);
}
static void vp6_filter_hv4(uint8_t *dst, uint8_t *src, int stride,
int delta, const int16_t *weights)
{
int x, y;
for (y=0; y<8; y++) {
for (x=0; x<8; x++) {
dst[x] = clip_uint8(( src[x-delta ] * weights[0]
+ src[x ] * weights[1]
+ src[x+delta ] * weights[2]
+ src[x+2*delta] * weights[3] + 64) >> 7);
}
src += stride;
dst += stride;
}
}
static void vp6_filter_diag2(vp56_context_t *s, uint8_t *dst, uint8_t *src,
int stride, int h_weight, int v_weight)
{
uint8_t *tmp = s->edge_emu_buffer+16;
int x, xmax;
s->dsp.put_pixels_tab[1][0](tmp, src, stride, 8);
s->dsp.biweight_h264_pixels_tab[3](tmp, src+1, stride, 2,
8-h_weight, h_weight, 0);
/* we need a 8x9 block to do vertical filter, so compute one more line */
for (x=8*stride, xmax=x+8; x<xmax; x++)
tmp[x] = (src[x]*(8-h_weight) + src[x+1]*h_weight + 4) >> 3;
s->dsp.put_pixels_tab[1][0](dst, tmp, stride, 8);
s->dsp.biweight_h264_pixels_tab[3](dst, tmp+stride, stride, 2,
8-v_weight, v_weight, 0);
}
static void vp6_filter_diag4(uint8_t *dst, uint8_t *src, int stride,
const int16_t *h_weights,const int16_t *v_weights)
{
int x, y;
int tmp[8*11];
int *t = tmp;
src -= stride;
for (y=0; y<11; y++) {
for (x=0; x<8; x++) {
t[x] = clip_uint8(( src[x-1] * h_weights[0]
+ src[x ] * h_weights[1]
+ src[x+1] * h_weights[2]
+ src[x+2] * h_weights[3] + 64) >> 7);
}
src += stride;
t += 8;
}
t = tmp + 8;
for (y=0; y<8; y++) {
for (x=0; x<8; x++) {
dst[x] = clip_uint8(( t[x-8 ] * v_weights[0]
+ t[x ] * v_weights[1]
+ t[x+8 ] * v_weights[2]
+ t[x+16] * v_weights[3] + 64) >> 7);
}
dst += stride;
t += 8;
}
}
static void vp6_filter(vp56_context_t *s, uint8_t *dst, uint8_t *src,
int offset1, int offset2, int stride,
vp56_mv_t mv, int mask, int select, int luma)
{
int filter4 = 0;
int x8 = mv.x & mask;
int y8 = mv.y & mask;
if (luma) {
x8 *= 2;
y8 *= 2;
filter4 = s->filter_mode;
if (filter4 == 2) {
if (s->max_vector_length &&
(ABS(mv.x) > s->max_vector_length ||
ABS(mv.y) > s->max_vector_length)) {
filter4 = 0;
} else if (!s->sample_variance_threshold
|| (vp6_block_variance(src+offset1, stride)
< s->sample_variance_threshold)) {
filter4 = 0;
}
}
}
if ((y8 && (offset2-offset1)*s->flip<0) || (!y8 && offset1 > offset2)) {
offset1 = offset2;
}
if (filter4) {
if (!y8) { /* left or right combine */
vp6_filter_hv4(dst, src+offset1, stride, 1,
vp6_block_copy_filter[select][x8]);
} else if (!x8) { /* above or below combine */
vp6_filter_hv4(dst, src+offset1, stride, stride,
vp6_block_copy_filter[select][y8]);
} else if ((mv.x^mv.y) >> 31) { /* lower-left or upper-right combine */
vp6_filter_diag4(dst, src+offset1-1, stride,
vp6_block_copy_filter[select][x8],
vp6_block_copy_filter[select][y8]);
} else { /* lower-right or upper-left combine */
vp6_filter_diag4(dst, src+offset1, stride,
vp6_block_copy_filter[select][x8],
vp6_block_copy_filter[select][y8]);
}
} else {
if (!y8) { /* left or right combine */
vp6_filter_hv2(s, dst, src+offset1, stride, 1, x8);
} else if (!x8) { /* above or below combine */
vp6_filter_hv2(s, dst, src+offset1, stride, stride, y8);
} else if ((mv.x^mv.y) >> 31) { /* lower-left or upper-right combine */
vp6_filter_diag2(s, dst, src+offset1-1, stride, x8, y8);
} else { /* lower-right or upper-left combine */
vp6_filter_diag2(s, dst, src+offset1, stride, x8, y8);
}
}
}
static int vp6_decode_init(AVCodecContext *avctx)
{
vp56_context_t *s = avctx->priv_data;
vp56_init(s, avctx, avctx->codec->id == CODEC_ID_VP6);
s->vp56_coord_div = vp6_coord_div;
s->parse_vector_adjustment = vp6_parse_vector_adjustment;
s->adjust = vp6_adjust;
s->filter = vp6_filter;
s->parse_coeff = vp6_parse_coeff;
s->default_models_init = vp6_default_models_init;
s->parse_vector_models = vp6_parse_vector_models;
s->parse_coeff_models = vp6_parse_coeff_models;
s->parse_header = vp6_parse_header;
return 0;
}
AVCodec vp6_decoder = {
"vp6",
CODEC_TYPE_VIDEO,
CODEC_ID_VP6,
sizeof(vp56_context_t),
vp6_decode_init,
NULL,
vp56_free,
vp56_decode_frame,
};
/* flash version, not flipped upside-down */
AVCodec vp6f_decoder = {
"vp6f",
CODEC_TYPE_VIDEO,
CODEC_ID_VP6F,
sizeof(vp56_context_t),
vp6_decode_init,
NULL,
vp56_free,
vp56_decode_frame,
};

291
libavcodec/vp6data.h
Unescape View File

@ -0,0 +1,291 @@
/**
* @file vp6data.h
* VP6 compatible video decoder
*
* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef VP6DATA_H
#define VP6DATA_H
#include <inttypes.h>
#include "vp56data.h"
static const uint8_t vp6_def_fdv_vector_model[2][8] = {
{ 247, 210, 135, 68, 138, 220, 239, 246 },
{ 244, 184, 201, 44, 173, 221, 239, 253 },
};
static const uint8_t vp6_def_pdv_vector_model[2][7] = {
{ 225, 146, 172, 147, 214, 39, 156 },
{ 204, 170, 119, 235, 140, 230, 228 },
};
static const uint8_t vp6_def_coeff_reorder[] = {
0, 0, 1, 1, 1, 2, 2, 2,
2, 2, 2, 3, 3, 4, 4, 4,
5, 5, 5, 5, 6, 6, 7, 7,
7, 7, 7, 8, 8, 9, 9, 9,
9, 9, 9, 10, 10, 11, 11, 11,
11, 11, 11, 12, 12, 12, 12, 12,
12, 13, 13, 13, 13, 13, 14, 14,
14, 14, 15, 15, 15, 15, 15, 15,
};
static const uint8_t vp6_def_runv_coeff_model[2][14] = {
{ 198, 197, 196, 146, 198, 204, 169, 142, 130, 136, 149, 149, 191, 249 },
{ 135, 201, 181, 154, 98, 117, 132, 126, 146, 169, 184, 240, 246, 254 },
};
static const uint8_t vp6_sig_dct_pct[2][2] = {
{ 237, 246 },
{ 231, 243 },
};
static const uint8_t vp6_pdv_pct[2][7] = {
{ 253, 253, 254, 254, 254, 254, 254 },
{ 245, 253, 254, 254, 254, 254, 254 },
};
static const uint8_t vp6_fdv_pct[2][8] = {
{ 254, 254, 254, 254, 254, 250, 250, 252 },
{ 254, 254, 254, 254, 254, 251, 251, 254 },
};
static const uint8_t vp6_dccv_pct[2][11] = {
{ 146, 255, 181, 207, 232, 243, 238, 251, 244, 250, 249 },
{ 179, 255, 214, 240, 250, 255, 244, 255, 255, 255, 255 },
};
static const uint8_t vp6_coeff_reorder_pct[] = {
255, 132, 132, 159, 153, 151, 161, 170,
164, 162, 136, 110, 103, 114, 129, 118,
124, 125, 132, 136, 114, 110, 142, 135,
134, 123, 143, 126, 153, 183, 166, 161,
171, 180, 179, 164, 203, 218, 225, 217,
215, 206, 203, 217, 229, 241, 248, 243,
253, 255, 253, 255, 255, 255, 255, 255,
255, 255, 255, 255, 255, 255, 255, 255,
};
static const uint8_t vp6_runv_pct[2][14] = {
{ 219, 246, 238, 249, 232, 239, 249, 255, 248, 253, 239, 244, 241, 248 },
{ 198, 232, 251, 253, 219, 241, 253, 255, 248, 249, 244, 238, 251, 255 },
};
static const uint8_t vp6_ract_pct[3][2][6][11] = {
{ { { 227, 246, 230, 247, 244, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 209, 231, 231, 249, 249, 253, 255, 255, 255 },
{ 255, 255, 225, 242, 241, 251, 253, 255, 255, 255, 255 },
{ 255, 255, 241, 253, 252, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 248, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } },
{ { 240, 255, 248, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 240, 253, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } } },
{ { { 206, 203, 227, 239, 247, 255, 253, 255, 255, 255, 255 },
{ 207, 199, 220, 236, 243, 252, 252, 255, 255, 255, 255 },
{ 212, 219, 230, 243, 244, 253, 252, 255, 255, 255, 255 },
{ 236, 237, 247, 252, 253, 255, 255, 255, 255, 255, 255 },
{ 240, 240, 248, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } },
{ { 230, 233, 249, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 238, 238, 250, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 248, 251, 255, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } } },
{ { { 225, 239, 227, 231, 244, 253, 243, 255, 255, 253, 255 },
{ 232, 234, 224, 228, 242, 249, 242, 252, 251, 251, 255 },
{ 235, 249, 238, 240, 251, 255, 249, 255, 253, 253, 255 },
{ 249, 253, 251, 250, 255, 255, 255, 255, 255, 255, 255 },
{ 251, 250, 249, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } },
{ { 243, 244, 250, 250, 255, 255, 255, 255, 255, 255, 255 },
{ 249, 248, 250, 253, 255, 255, 255, 255, 255, 255, 255 },
{ 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 },
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 } } }
};
static const int vp6_dccv_lc[3][5][2] = {
{ { 122, 133 }, { 0, 1 }, { 78, 171 }, { 139, 117 }, { 168, 79 } },
{ { 133, 51 }, { 0, 1 }, { 169, 71 }, { 214, 44 }, { 210, 38 } },
{ { 142, -16 }, { 0, 1 }, { 221, -30 }, { 246, -3 }, { 203, 17 } },
};
static const uint8_t vp6_coeff_groups[] = {
0, 0, 1, 1, 1, 2, 2, 2,
2, 2, 2, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5,
};
static const int16_t vp6_block_copy_filter[16][8][4] = {
{ { 0, 128, 0, 0 }, /* 0 */
{ -3, 122, 9, 0 },
{ -4, 109, 24, -1 },
{ -5, 91, 45, -3 },
{ -4, 68, 68, -4 },
{ -3, 45, 91, -5 },
{ -1, 24, 109, -4 },
{ 0, 9, 122, -3 } },
{ { 0, 128, 0, 0 }, /* 1 */
{ -4, 124, 9, -1 },
{ -5, 110, 25, -2 },
{ -6, 91, 46, -3 },
{ -5, 69, 69, -5 },
{ -3, 46, 91, -6 },
{ -2, 25, 110, -5 },
{ -1, 9, 124, -4 } },
{ { 0, 128, 0, 0 }, /* 2 */
{ -4, 123, 10, -1 },
{ -6, 110, 26, -2 },
{ -7, 92, 47, -4 },
{ -6, 70, 70, -6 },
{ -4, 47, 92, -7 },
{ -2, 26, 110, -6 },
{ -1, 10, 123, -4 } },
{ { 0, 128, 0, 0 }, /* 3 */
{ -5, 124, 10, -1 },
{ -7, 110, 27, -2 },
{ -7, 91, 48, -4 },
{ -6, 70, 70, -6 },
{ -4, 48, 92, -8 },
{ -2, 27, 110, -7 },
{ -1, 10, 124, -5 } },
{ { 0, 128, 0, 0 }, /* 4 */
{ -6, 124, 11, -1 },
{ -8, 111, 28, -3 },
{ -8, 92, 49, -5 },
{ -7, 71, 71, -7 },
{ -5, 49, 92, -8 },
{ -3, 28, 111, -8 },
{ -1, 11, 124, -6 } },
{ { 0, 128, 0, 0 }, /* 5 */
{ -6, 123, 12, -1 },
{ -9, 111, 29, -3 },
{ -9, 93, 50, -6 },
{ -8, 72, 72, -8 },
{ -6, 50, 93, -9 },
{ -3, 29, 111, -9 },
{ -1, 12, 123, -6 } },
{ { 0, 128, 0, 0 }, /* 6 */
{ -7, 124, 12, -1 },
{ -10, 111, 30, -3 },
{ -10, 93, 51, -6 },
{ -9, 73, 73, -9 },
{ -6, 51, 93, -10 },
{ -3, 30, 111, -10 },
{ -1, 12, 124, -7 } },
{ { 0, 128, 0, 0 }, /* 7 */
{ -7, 123, 13, -1 },
{ -11, 112, 31, -4 },
{ -11, 94, 52, -7 },
{ -10, 74, 74, -10 },
{ -7, 52, 94, -11 },
{ -4, 31, 112, -11 },
{ -1, 13, 123, -7 } },
{ { 0, 128, 0, 0 }, /* 8 */
{ -8, 124, 13, -1 },
{ -12, 112, 32, -4 },
{ -12, 94, 53, -7 },
{ -10, 74, 74, -10 },
{ -7, 53, 94, -12 },
{ -4, 32, 112, -12 },
{ -1, 13, 124, -8 } },
{ { 0, 128, 0, 0 }, /* 9 */
{ -9, 124, 14, -1 },
{ -13, 112, 33, -4 },
{ -13, 95, 54, -8 },
{ -11, 75, 75, -11 },
{ -8, 54, 95, -13 },
{ -4, 33, 112, -13 },
{ -1, 14, 124, -9 } },
{ { 0, 128, 0, 0 }, /* 10 */
{ -9, 123, 15, -1 },
{ -14, 113, 34, -5 },
{ -14, 95, 55, -8 },
{ -12, 76, 76, -12 },
{ -8, 55, 95, -14 },
{ -5, 34, 112, -13 },
{ -1, 15, 123, -9 } },
{ { 0, 128, 0, 0 }, /* 11 */
{ -10, 124, 15, -1 },
{ -14, 113, 34, -5 },
{ -15, 96, 56, -9 },
{ -13, 77, 77, -13 },
{ -9, 56, 96, -15 },
{ -5, 34, 113, -14 },
{ -1, 15, 124, -10 } },
{ { 0, 128, 0, 0 }, /* 12 */
{ -10, 123, 16, -1 },
{ -15, 113, 35, -5 },
{ -16, 98, 56, -10 },
{ -14, 78, 78, -14 },
{ -10, 56, 98, -16 },
{ -5, 35, 113, -15 },
{ -1, 16, 123, -10 } },
{ { 0, 128, 0, 0 }, /* 13 */
{ -11, 124, 17, -2 },
{ -16, 113, 36, -5 },
{ -17, 98, 57, -10 },
{ -14, 78, 78, -14 },
{ -10, 57, 98, -17 },
{ -5, 36, 113, -16 },
{ -2, 17, 124, -11 } },
{ { 0, 128, 0, 0 }, /* 14 */
{ -12, 125, 17, -2 },
{ -17, 114, 37, -6 },
{ -18, 99, 58, -11 },
{ -15, 79, 79, -15 },
{ -11, 58, 99, -18 },
{ -6, 37, 114, -17 },
{ -2, 17, 125, -12 } },
{ { 0, 128, 0, 0 }, /* 15 */
{ -12, 124, 18, -2 },
{ -18, 114, 38, -6 },
{ -19, 99, 59, -11 },
{ -16, 80, 80, -16 },
{ -11, 59, 99, -19 },
{ -6, 38, 114, -18 },
{ -2, 18, 124, -12 } },
};
const vp56_tree_t vp6_pcr_tree[] = {
{ 8, 0},
{ 4, 1},
{ 2, 2}, {-1}, {-2},
{ 2, 3}, {-3}, {-4},
{ 8, 4},
{ 4, 5},
{ 2, 6}, {-5}, {-6},
{ 2, 7}, {-7}, {-8},
{-0},
};
static const uint8_t vp6_coord_div[] = { 4, 4, 4, 4, 8, 8 };
#endif /* VP6DATA_H */

5
libavformat/flvdec.c
Unescape View File

@ -184,6 +184,11 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
switch(flags & 0xF){
case 2: st->codec->codec_id = CODEC_ID_FLV1; break;
case 3: st->codec->codec_id = CODEC_ID_FLASHSV; break;
case 4:
st->codec->codec_id = CODEC_ID_VP6F;
get_byte(&s->pb); /* width and height adjustment */
size--;
break;
default:
av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flags & 0xf);
st->codec->codec_tag= flags & 0xF;

6
libavformat/nsvdec.c
Unescape View File

@ -182,15 +182,15 @@ static const CodecTag nsv_codec_video_tags[] = {
{ CODEC_ID_VP3, MKTAG('V', 'P', '3', ' ') },
{ CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },
{ CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },
{ CODEC_ID_VP5, MKTAG('V', 'P', '5', ' ') },
{ CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },
{ CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
/*
{ CODEC_ID_VP4, MKTAG('V', 'P', '4', ' ') },
{ CODEC_ID_VP4, MKTAG('V', 'P', '4', '0') },
{ CODEC_ID_VP5, MKTAG('V', 'P', '5', ' ') },
{ CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },
{ CODEC_ID_VP6, MKTAG('V', 'P', '6', ' ') },
{ CODEC_ID_VP6, MKTAG('V', 'P', '6', '0') },
{ CODEC_ID_VP6, MKTAG('V', 'P', '6', '1') },
{ CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
*/
{ CODEC_ID_XVID, MKTAG('X', 'V', 'I', 'D') }, /* cf sample xvid decoder from nsv_codec_sdk.zip */
{ CODEC_ID_RAWVIDEO, MKTAG('R', 'G', 'B', '3') },

2
libavformat/riff.c
Unescape View File

@ -114,6 +114,8 @@ const CodecTag codec_bmp_tags[] = {
{ CODEC_ID_INDEO3, MKTAG('I', 'V', '3', '2') },
{ CODEC_ID_VP3, MKTAG('V', 'P', '3', '1') },
{ CODEC_ID_VP3, MKTAG('V', 'P', '3', '0') },
{ CODEC_ID_VP5, MKTAG('V', 'P', '5', '0') },
{ CODEC_ID_VP6, MKTAG('V', 'P', '6', '2') },
{ CODEC_ID_ASV1, MKTAG('A', 'S', 'V', '1') },
{ CODEC_ID_ASV2, MKTAG('A', 'S', 'V', '2') },
{ CODEC_ID_VCR1, MKTAG('V', 'C', 'R', '1') },

33
libavformat/swf.c
Unescape View File

@ -19,6 +19,7 @@
*/
#include "avformat.h"
#include "bitstream.h"
#include "riff.h" /* for CodecTag */
/* should have a generic way to indicate probable size */
#define DUMMY_FILE_SIZE (100 * 1024 * 1024)
@ -45,8 +46,6 @@
#define FLAG_SETFILL0 0x02
#define FLAG_SETFILL1 0x04
#define SWF_VIDEO_CODEC_FLV1 0x02
#define AUDIO_FIFO_SIZE 65536
/* character id used */
@ -80,6 +79,12 @@ typedef struct {
int audio_type;
} SWFContext;
static const CodecTag swf_codec_tags[] = {
{CODEC_ID_FLV1, 0x02},
{CODEC_ID_VP6F, 0x04},
{0, 0},
};
static const int sSampleRates[3][4] = {
{44100, 48000, 32000, 0},
{22050, 24000, 16000, 0},
@ -328,10 +333,12 @@ static int swf_write_header(AVFormatContext *s)
if (enc->codec_type == CODEC_TYPE_AUDIO)
audio_enc = enc;
else {
if ( enc->codec_id == CODEC_ID_FLV1 || enc->codec_id == CODEC_ID_MJPEG ) {
if ( enc->codec_id == CODEC_ID_VP6F ||
enc->codec_id == CODEC_ID_FLV1 ||
enc->codec_id == CODEC_ID_MJPEG ) {
video_enc = enc;
} else {
av_log(enc, AV_LOG_ERROR, "SWF only supports FLV1 and MJPEG\n");
av_log(enc, AV_LOG_ERROR, "SWF only supports VP6, FLV1 and MJPEG\n");
return -1;
}
}
@ -361,7 +368,9 @@ static int swf_write_header(AVFormatContext *s)
}
put_tag(pb, "FWS");
if ( video_enc && video_enc->codec_id == CODEC_ID_FLV1 ) {
if ( video_enc && video_enc->codec_id == CODEC_ID_VP6F ) {
put_byte(pb, 8); /* version (version 8 and above support VP6 codec) */
} else if ( video_enc && video_enc->codec_id == CODEC_ID_FLV1 ) {
put_byte(pb, 6); /* version (version 6 and above support FLV1 codec) */
} else {
put_byte(pb, 4); /* version (should use 4 for mpeg audio support) */
@ -375,7 +384,8 @@ static int swf_write_header(AVFormatContext *s)
put_le16(pb, (uint16_t)(DUMMY_DURATION * (int64_t)rate / rate_base)); /* frame count */
/* define a shape with the jpeg inside */
if ( video_enc && video_enc->codec_id == CODEC_ID_FLV1 ) {
if ( video_enc && (video_enc->codec_id == CODEC_ID_VP6F ||
video_enc->codec_id == CODEC_ID_FLV1 )) {
} else if ( video_enc && video_enc->codec_id == CODEC_ID_MJPEG ) {
put_swf_tag(s, TAG_DEFINESHAPE);
@ -512,7 +522,8 @@ retry_swf_audio_packet:
}
}
if ( swf->video_type == CODEC_ID_FLV1 ) {
if ( swf->video_type == CODEC_ID_VP6F ||
swf->video_type == CODEC_ID_FLV1 ) {
if ( swf->video_frame_number == 0 ) {
/* create a new video object */
put_swf_tag(s, TAG_VIDEOSTREAM);
@ -521,7 +532,7 @@ retry_swf_audio_packet:
put_le16(pb, enc->width);
put_le16(pb, enc->height);
put_byte(pb, 0);
put_byte(pb, SWF_VIDEO_CODEC_FLV1);
put_byte(pb,codec_get_tag(swf_codec_tags,swf->video_type));
put_swf_end_tag(s);
/* place the video object for the first time */
@ -784,18 +795,20 @@ static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap)
return AVERROR_IO;
}
if ( tag == TAG_VIDEOSTREAM && !vst) {
int codec_id;
swf->ch_id = get_le16(pb);
get_le16(pb);
get_le16(pb);
get_le16(pb);
get_byte(pb);
/* Check for FLV1 */
if ( get_byte(pb) == SWF_VIDEO_CODEC_FLV1 ) {
codec_id = codec_get_id(swf_codec_tags, get_byte(pb));
if ( codec_id ) {
vst = av_new_stream(s, 0);
av_set_pts_info(vst, 24, 1, 1000); /* 24 bit pts in ms */
vst->codec->codec_type = CODEC_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_FLV1;
vst->codec->codec_id = codec_id;
if ( swf->samples_per_frame ) {
vst->codec->time_base.den = 1000. / swf->ms_per_frame;
vst->codec->time_base.num = 1;

Write Preview
Loading…
Cancel
Save