*/
/**
- * @file vc1.c
+ * @file libavcodec/vc1.c
* VC-1 and WMV3 decoder
*
*/
+#include "internal.h"
#include "dsputil.h"
#include "avcodec.h"
#include "mpegvideo.h"
#include "vc1acdata.h"
#include "msmpeg4data.h"
#include "unary.h"
+#include "simple_idct.h"
+#include "mathops.h"
+#include "vdpau_internal.h"
#undef NDEBUG
#include <assert.h>
static const uint16_t table_mb_intra[64][2];
-static inline int decode210(GetBitContext *gb){
- if (get_bits1(gb))
- return 0;
- else
- return 2 - get_bits1(gb);
-}
-
/**
* Init VC-1 specific tables and VC1Context members
* @param v The VC1Context to initialize
/***********************************************************************/
/**
- * @defgroup bitplane VC9 Bitplane decoding
+ * @defgroup vc1bitplane VC-1 Bitplane decoding
* @see 8.7, p56
* @{
*/
-/** @addtogroup bitplane
+/**
* Imode types
* @{
*/
}
/** Decode a bitplane's bits
- * @param bp Bitplane where to store the decode bits
+ * @param data bitplane where to store the decode bits
+ * @param[out] raw_flag pointer to the flag indicating that this bitplane is not coded explicitly
* @param v VC-1 context for bit reading and logging
* @return Status
* @todo FIXME: Optimize
/** @} */ //Bitplane group
+#define FILTSIGN(a) ((a) >= 0 ? 1 : -1)
+/**
+ * VC-1 in-loop deblocking filter for one line
+ * @param src source block type
+ * @param stride block stride
+ * @param pq block quantizer
+ * @return whether other 3 pairs should be filtered or not
+ * @see 8.6
+ */
+static av_always_inline int vc1_filter_line(uint8_t* src, int stride, int pq){
+ uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
+
+ int a0 = (2*(src[-2*stride] - src[ 1*stride]) - 5*(src[-1*stride] - src[ 0*stride]) + 4) >> 3;
+ int a0_sign = a0 >> 31; /* Store sign */
+ a0 = (a0 ^ a0_sign) - a0_sign; /* a0 = FFABS(a0); */
+ if(a0 < pq){
+ int a1 = FFABS((2*(src[-4*stride] - src[-1*stride]) - 5*(src[-3*stride] - src[-2*stride]) + 4) >> 3);
+ int a2 = FFABS((2*(src[ 0*stride] - src[ 3*stride]) - 5*(src[ 1*stride] - src[ 2*stride]) + 4) >> 3);
+ if(a1 < a0 || a2 < a0){
+ int clip = src[-1*stride] - src[ 0*stride];
+ int clip_sign = clip >> 31;
+ clip = ((clip ^ clip_sign) - clip_sign)>>1;
+ if(clip){
+ int a3 = FFMIN(a1, a2);
+ int d = 5 * (a3 - a0);
+ int d_sign = (d >> 31);
+ d = ((d ^ d_sign) - d_sign) >> 3;
+ d_sign ^= a0_sign;
+
+ if( d_sign ^ clip_sign )
+ d = 0;
+ else{
+ d = FFMIN(d, clip);
+ d = (d ^ d_sign) - d_sign; /* Restore sign */
+ src[-1*stride] = cm[src[-1*stride] - d];
+ src[ 0*stride] = cm[src[ 0*stride] + d];
+ }
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+/**
+ * VC-1 in-loop deblocking filter
+ * @param src source block type
+ * @param step distance between horizontally adjacent elements
+ * @param stride distance between vertically adjacent elements
+ * @param len edge length to filter (4 or 8 pixels)
+ * @param pq block quantizer
+ * @see 8.6
+ */
+static void vc1_loop_filter(uint8_t* src, int step, int stride, int len, int pq)
+{
+ int i;
+ int filt3;
+
+ for(i = 0; i < len; i += 4){
+ filt3 = vc1_filter_line(src + 2*step, stride, pq);
+ if(filt3){
+ vc1_filter_line(src + 0*step, stride, pq);
+ vc1_filter_line(src + 1*step, stride, pq);
+ vc1_filter_line(src + 3*step, stride, pq);
+ }
+ src += step * 4;
+ }
+}
+
+static void vc1_loop_filter_iblk(MpegEncContext *s, int pq)
+{
+ int i, j;
+ if(!s->first_slice_line)
+ vc1_loop_filter(s->dest[0], 1, s->linesize, 16, pq);
+ vc1_loop_filter(s->dest[0] + 8*s->linesize, 1, s->linesize, 16, pq);
+ for(i = !s->mb_x*8; i < 16; i += 8)
+ vc1_loop_filter(s->dest[0] + i, s->linesize, 1, 16, pq);
+ for(j = 0; j < 2; j++){
+ if(!s->first_slice_line)
+ vc1_loop_filter(s->dest[j+1], 1, s->uvlinesize, 8, pq);
+ if(s->mb_x)
+ vc1_loop_filter(s->dest[j+1], s->uvlinesize, 1, 8, pq);
+ }
+}
+
/***********************************************************************/
/** VOP Dquant decoding
* @param v VC-1 Context
my = s->mv[dir][0][1];
// store motion vectors for further use in B frames
- if(s->pict_type == P_TYPE) {
+ if(s->pict_type == FF_P_TYPE) {
s->current_picture.motion_val[1][s->block_index[0]][0] = mx;
s->current_picture.motion_val[1][s->block_index[0]][1] = my;
}
if (v->profile == PROFILE_ADVANCED)
{
+ v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;
+ v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;
return decode_sequence_header_adv(v, gb);
}
else
{
+ v->zz_8x4 = wmv2_scantableA;
+ v->zz_4x8 = wmv2_scantableB;
v->res_sm = get_bits(gb, 2); //reserved
if (v->res_sm)
{
av_log(avctx, AV_LOG_ERROR,
"LOOPFILTER shell not be enabled in simple profile\n");
}
+ if(v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)
+ v->s.loop_filter = 0;
v->res_x8 = get_bits1(gb); //reserved
- if (v->res_x8)
- {
- av_log(avctx, AV_LOG_ERROR,
- "1 for reserved RES_X8 is forbidden\n");
- //return -1;
- }
v->multires = get_bits1(gb);
v->res_fasttx = get_bits1(gb);
if (!v->res_fasttx)
{
- av_log(avctx, AV_LOG_ERROR,
- "0 for reserved RES_FASTTX is forbidden\n");
- //return -1;
+ v->s.dsp.vc1_inv_trans_8x8 = ff_simple_idct;
+ v->s.dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;
+ v->s.dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;
+ v->s.dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;
}
v->fastuvmc = get_bits1(gb); //common
if(get_bits1(gb)) { //Display Info - decoding is not affected by it
int w, h, ar = 0;
av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
- v->s.avctx->width = v->s.width = w = get_bits(gb, 14) + 1;
- v->s.avctx->height = v->s.height = h = get_bits(gb, 14) + 1;
+ v->s.avctx->coded_width = w = get_bits(gb, 14) + 1;
+ v->s.avctx->coded_height = h = get_bits(gb, 14) + 1;
av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
if(get_bits1(gb))
ar = get_bits(gb, 4);
h = get_bits(gb, 8);
v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
}
+ av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n", v->s.avctx->sample_aspect_ratio.num, v->s.avctx->sample_aspect_ratio.den);
if(get_bits1(gb)){ //framerate stuff
if(get_bits1(gb)) {
static int decode_entry_point(AVCodecContext *avctx, GetBitContext *gb)
{
VC1Context *v = avctx->priv_data;
- int i, blink, clentry, refdist;
+ int i;
av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
- blink = get_bits1(gb); // broken link
- clentry = get_bits1(gb); // closed entry
+ v->broken_link = get_bits1(gb);
+ v->closed_entry = get_bits1(gb);
v->panscanflag = get_bits1(gb);
- refdist = get_bits1(gb); // refdist flag
+ v->refdist_flag = get_bits1(gb);
v->s.loop_filter = get_bits1(gb);
v->fastuvmc = get_bits1(gb);
v->extended_mv = get_bits1(gb);
}
if(v->extended_mv)
v->extended_dmv = get_bits1(gb);
- if(get_bits1(gb)) {
+ if((v->range_mapy_flag = get_bits1(gb))) {
av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
- skip_bits(gb, 3); // Y range, ignored for now
+ v->range_mapy = get_bits(gb, 3);
}
- if(get_bits1(gb)) {
+ if((v->range_mapuv_flag = get_bits1(gb))) {
av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
- skip_bits(gb, 3); // UV range, ignored for now
+ v->range_mapuv = get_bits(gb, 3);
}
av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
"BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
"RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
"DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
- blink, clentry, v->panscanflag, refdist, v->s.loop_filter,
+ v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,
v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
return 0;
v->s.pict_type = get_bits1(gb);
if (v->s.avctx->max_b_frames) {
if (!v->s.pict_type) {
- if (get_bits1(gb)) v->s.pict_type = I_TYPE;
- else v->s.pict_type = B_TYPE;
- } else v->s.pict_type = P_TYPE;
- } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
+ if (get_bits1(gb)) v->s.pict_type = FF_I_TYPE;
+ else v->s.pict_type = FF_B_TYPE;
+ } else v->s.pict_type = FF_P_TYPE;
+ } else v->s.pict_type = v->s.pict_type ? FF_P_TYPE : FF_I_TYPE;
v->bi_type = 0;
- if(v->s.pict_type == B_TYPE) {
- v->bfraction = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
- v->bfraction = ff_vc1_bfraction_lut[v->bfraction];
+ if(v->s.pict_type == FF_B_TYPE) {
+ v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
+ v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
if(v->bfraction == 0) {
- v->s.pict_type = BI_TYPE;
+ v->s.pict_type = FF_BI_TYPE;
}
}
- if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
+ if(v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE)
skip_bits(gb, 7); // skip buffer fullness
/* calculate RND */
- if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
+ if(v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE)
v->rnd = 1;
- if(v->s.pict_type == P_TYPE)
+ if(v->s.pict_type == FF_P_TYPE)
v->rnd ^= 1;
/* Quantizer stuff */
pqindex = get_bits(gb, 5);
+ if(!pqindex) return -1;
if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
v->pq = ff_vc1_pquant_table[0][pqindex];
else
v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
v->range_x = 1 << (v->k_x - 1);
v->range_y = 1 << (v->k_y - 1);
- if (v->profile == PROFILE_ADVANCED)
- {
- if (v->postprocflag) v->postproc = get_bits1(gb);
- }
- else
- if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
+ if (v->multires && v->s.pict_type != FF_B_TYPE) v->respic = get_bits(gb, 2);
- if(v->res_x8 && (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)){
- if(get_bits1(gb))return -1;
- }
+ if(v->res_x8 && (v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE)){
+ v->x8_type = get_bits1(gb);
+ }else v->x8_type = 0;
//av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
-// (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
+// (v->s.pict_type == FF_P_TYPE) ? 'P' : ((v->s.pict_type == FF_I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
- if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
+ if(v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_P_TYPE) v->use_ic = 0;
switch(v->s.pict_type) {
- case P_TYPE:
+ case FF_P_TYPE:
if (v->pq < 5) v->tt_index = 0;
else if(v->pq < 13) v->tt_index = 1;
else v->tt_index = 2;
v->ttfrm = TT_8X8;
}
break;
- case B_TYPE:
+ case FF_B_TYPE:
if (v->pq < 5) v->tt_index = 0;
else if(v->pq < 13) v->tt_index = 1;
else v->tt_index = 2;
break;
}
- /* AC Syntax */
- v->c_ac_table_index = decode012(gb);
- if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
+ if(!v->x8_type)
{
- v->y_ac_table_index = decode012(gb);
+ /* AC Syntax */
+ v->c_ac_table_index = decode012(gb);
+ if (v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE)
+ {
+ v->y_ac_table_index = decode012(gb);
+ }
+ /* DC Syntax */
+ v->s.dc_table_index = get_bits1(gb);
}
- /* DC Syntax */
- v->s.dc_table_index = get_bits1(gb);
- if(v->s.pict_type == BI_TYPE) {
- v->s.pict_type = B_TYPE;
+ if(v->s.pict_type == FF_BI_TYPE) {
+ v->s.pict_type = FF_B_TYPE;
v->bi_type = 1;
}
return 0;
}
switch(get_unary(gb, 0, 4)) {
case 0:
- v->s.pict_type = P_TYPE;
+ v->s.pict_type = FF_P_TYPE;
break;
case 1:
- v->s.pict_type = B_TYPE;
+ v->s.pict_type = FF_B_TYPE;
break;
case 2:
- v->s.pict_type = I_TYPE;
+ v->s.pict_type = FF_I_TYPE;
break;
case 3:
- v->s.pict_type = BI_TYPE;
+ v->s.pict_type = FF_BI_TYPE;
break;
case 4:
- v->s.pict_type = P_TYPE; // skipped pic
+ v->s.pict_type = FF_P_TYPE; // skipped pic
v->p_frame_skipped = 1;
return 0;
}
if(v->interlace)
v->uvsamp = get_bits1(gb);
if(v->finterpflag) v->interpfrm = get_bits1(gb);
- if(v->s.pict_type == B_TYPE) {
- v->bfraction = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
- v->bfraction = ff_vc1_bfraction_lut[v->bfraction];
+ if(v->s.pict_type == FF_B_TYPE) {
+ v->bfraction_lut_index = get_vlc2(gb, ff_vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
+ v->bfraction = ff_vc1_bfraction_lut[v->bfraction_lut_index];
if(v->bfraction == 0) {
- v->s.pict_type = BI_TYPE; /* XXX: should not happen here */
+ v->s.pict_type = FF_BI_TYPE; /* XXX: should not happen here */
}
}
pqindex = get_bits(gb, 5);
+ if(!pqindex) return -1;
v->pqindex = pqindex;
if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
v->pq = ff_vc1_pquant_table[0][pqindex];
else v->halfpq = 0;
if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
v->pquantizer = get_bits1(gb);
+ if(v->postprocflag)
+ v->postproc = get_bits(gb, 2);
- if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
+ if(v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_P_TYPE) v->use_ic = 0;
switch(v->s.pict_type) {
- case I_TYPE:
- case BI_TYPE:
+ case FF_I_TYPE:
+ case FF_BI_TYPE:
status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
if (status < 0) return -1;
av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
}
}
break;
- case P_TYPE:
- if(v->postprocflag)
- v->postproc = get_bits1(gb);
+ case FF_P_TYPE:
if (v->extended_mv) v->mvrange = get_unary(gb, 0, 3);
else v->mvrange = 0;
v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
v->ttfrm = TT_8X8;
}
break;
- case B_TYPE:
- if(v->postprocflag)
- v->postproc = get_bits1(gb);
+ case FF_B_TYPE:
if (v->extended_mv) v->mvrange = get_unary(gb, 0, 3);
else v->mvrange = 0;
v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
/* AC Syntax */
v->c_ac_table_index = decode012(gb);
- if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
+ if (v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE)
{
v->y_ac_table_index = decode012(gb);
}
/* DC Syntax */
v->s.dc_table_index = get_bits1(gb);
- if ((v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE) && v->dquant) {
+ if ((v->s.pict_type == FF_I_TYPE || v->s.pict_type == FF_BI_TYPE) && v->dquant) {
av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
vop_dquant_decoding(v);
}
v->bi_type = 0;
- if(v->s.pict_type == BI_TYPE) {
- v->s.pict_type = B_TYPE;
+ if(v->s.pict_type == FF_BI_TYPE) {
+ v->s.pict_type = FF_B_TYPE;
v->bi_type = 1;
}
return 0;
/***********************************************************************/
/**
- * @defgroup block VC-1 Block-level functions
+ * @defgroup vc1block VC-1 Block-level functions
* @see 7.1.4, p91 and 8.1.1.7, p(1)04
* @{
*/
/** Get predicted DC value for I-frames only
* prediction dir: left=0, top=1
* @param s MpegEncContext
+ * @param overlap flag indicating that overlap filtering is used
+ * @param pq integer part of picture quantizer
* @param[in] n block index in the current MB
* @param dc_val_ptr Pointer to DC predictor
* @param dir_ptr Prediction direction for use in AC prediction
/** Get predicted DC value
* prediction dir: left=0, top=1
* @param s MpegEncContext
+ * @param overlap flag indicating that overlap filtering is used
+ * @param pq integer part of picture quantizer
* @param[in] n block index in the current MB
+ * @param a_avail flag indicating top block availability
+ * @param c_avail flag indicating left block availability
* @param dc_val_ptr Pointer to DC predictor
* @param dir_ptr Prediction direction for use in AC prediction
*/
return pred;
}
+/** @} */ // Block group
/**
- * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
+ * @defgroup vc1_std_mb VC1 Macroblock-level functions in Simple/Main Profiles
* @see 7.1.4, p91 and 8.1.1.7, p(1)04
* @{
*/
* @param last Last coefficient
* @param skip How much zero coefficients to skip
* @param value Decoded AC coefficient value
+ * @param codingset set of VLC to decode data
* @see 8.1.3.4
*/
static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
/** Decode intra block in intra frames - should be faster than decode_intra_block
* @param v VC1Context
* @param block block to decode
+ * @param[in] n subblock index
* @param coded are AC coeffs present or not
* @param codingset set of VLC to decode data
*/
if(v->s.ac_pred) {
if(!dc_pred_dir)
- zz_table = ff_vc1_horizontal_zz;
+ zz_table = wmv1_scantable[2];
else
- zz_table = ff_vc1_vertical_zz;
+ zz_table = wmv1_scantable[3];
} else
- zz_table = ff_vc1_normal_zz;
+ zz_table = wmv1_scantable[1];
ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
ac_val2 = ac_val;
/** Decode intra block in intra frames - should be faster than decode_intra_block
* @param v VC1Context
* @param block block to decode
+ * @param[in] n subblock number
* @param coded are AC coeffs present or not
* @param codingset set of VLC to decode data
+ * @param mquant quantizer value for this macroblock
*/
static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
{
if(v->s.ac_pred) {
if(!dc_pred_dir)
- zz_table = ff_vc1_horizontal_zz;
+ zz_table = wmv1_scantable[2];
else
- zz_table = ff_vc1_vertical_zz;
+ zz_table = wmv1_scantable[3];
} else
- zz_table = ff_vc1_normal_zz;
+ zz_table = wmv1_scantable[1];
while (!last) {
vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
/** Decode intra block in inter frames - more generic version than vc1_decode_i_block
* @param v VC1Context
* @param block block to decode
+ * @param[in] n subblock index
* @param coded are AC coeffs present or not
* @param mquant block quantizer
* @param codingset set of VLC to decode data
const int8_t *zz_table;
int k;
- zz_table = ff_vc1_simple_progressive_8x8_zz;
+ zz_table = wmv1_scantable[0];
while (!last) {
vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
/** Decode P block
*/
-static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
+static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block,
+ uint8_t *dst, int linesize, int skip_block, int apply_filter, int cbp_top, int cbp_left)
{
MpegEncContext *s = &v->s;
GetBitContext *gb = &s->gb;
int subblkpat = 0;
int scale, off, idx, last, skip, value;
int ttblk = ttmb & 7;
+ int pat = 0;
if(ttmb == -1) {
ttblk = ff_vc1_ttblk_to_tt[v->tt_index][get_vlc2(gb, ff_vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
}
switch(ttblk) {
case TT_8X8:
+ pat = 0xF;
i = 0;
last = 0;
while (!last) {
i += skip;
if(i > 63)
break;
- idx = ff_vc1_simple_progressive_8x8_zz[i++];
+ idx = wmv1_scantable[0][i++];
block[idx] = value * scale;
if(!v->pquantizer)
block[idx] += (block[idx] < 0) ? -mquant : mquant;
}
- s->dsp.vc1_inv_trans_8x8(block);
+ if(!skip_block){
+ s->dsp.vc1_inv_trans_8x8(block);
+ s->dsp.add_pixels_clamped(block, dst, linesize);
+ if(apply_filter && cbp_top & 0xC)
+ vc1_loop_filter(dst, 1, linesize, 8, mquant);
+ if(apply_filter && cbp_left & 0xA)
+ vc1_loop_filter(dst, linesize, 1, 8, mquant);
+ }
break;
case TT_4X4:
+ pat = ~subblkpat & 0xF;
for(j = 0; j < 4; j++) {
last = subblkpat & (1 << (3 - j));
i = 0;
if(!v->pquantizer)
block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
}
- if(!(subblkpat & (1 << (3 - j))))
- s->dsp.vc1_inv_trans_4x4(block, j);
+ if(!(subblkpat & (1 << (3 - j))) && !skip_block){
+ s->dsp.vc1_inv_trans_4x4(dst + (j&1)*4 + (j&2)*2*linesize, linesize, block + off);
+ if(apply_filter && (j&2 ? pat & (1<<(j-2)) : (cbp_top & (1 << (j + 2)))))
+ vc1_loop_filter(dst + (j&1)*4 + (j&2)*2*linesize, 1, linesize, 4, mquant);
+ if(apply_filter && (j&1 ? pat & (1<<(j-1)) : (cbp_left & (1 << (j + 1)))))
+ vc1_loop_filter(dst + (j&1)*4 + (j&2)*2*linesize, linesize, 1, 4, mquant);
+ }
}
break;
case TT_8X4:
+ pat = ~((subblkpat & 2)*6 + (subblkpat & 1)*3) & 0xF;
for(j = 0; j < 2; j++) {
last = subblkpat & (1 << (1 - j));
i = 0;
i += skip;
if(i > 31)
break;
- if(v->profile < PROFILE_ADVANCED)
- idx = ff_vc1_simple_progressive_8x4_zz[i++];
- else
- idx = ff_vc1_adv_progressive_8x4_zz[i++];
- block[idx + off] = value * scale;
+ idx = v->zz_8x4[i++]+off;
+ block[idx] = value * scale;
if(!v->pquantizer)
- block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
+ block[idx] += (block[idx] < 0) ? -mquant : mquant;
+ }
+ if(!(subblkpat & (1 << (1 - j))) && !skip_block){
+ s->dsp.vc1_inv_trans_8x4(dst + j*4*linesize, linesize, block + off);
+ if(apply_filter && j ? pat & 0x3 : (cbp_top & 0xC))
+ vc1_loop_filter(dst + j*4*linesize, 1, linesize, 8, mquant);
+ if(apply_filter && cbp_left & (2 << j))
+ vc1_loop_filter(dst + j*4*linesize, linesize, 1, 4, mquant);
}
- if(!(subblkpat & (1 << (1 - j))))
- s->dsp.vc1_inv_trans_8x4(block, j);
}
break;
case TT_4X8:
+ pat = ~(subblkpat*5) & 0xF;
for(j = 0; j < 2; j++) {
last = subblkpat & (1 << (1 - j));
i = 0;
i += skip;
if(i > 31)
break;
- if(v->profile < PROFILE_ADVANCED)
- idx = ff_vc1_simple_progressive_4x8_zz[i++];
- else
- idx = ff_vc1_adv_progressive_4x8_zz[i++];
- block[idx + off] = value * scale;
+ idx = v->zz_4x8[i++]+off;
+ block[idx] = value * scale;
if(!v->pquantizer)
- block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
+ block[idx] += (block[idx] < 0) ? -mquant : mquant;
+ }
+ if(!(subblkpat & (1 << (1 - j))) && !skip_block){
+ s->dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off);
+ if(apply_filter && cbp_top & (2 << j))
+ vc1_loop_filter(dst + j*4, 1, linesize, 4, mquant);
+ if(apply_filter && j ? pat & 0x5 : (cbp_left & 0xA))
+ vc1_loop_filter(dst + j*4, linesize, 1, 8, mquant);
}
- if(!(subblkpat & (1 << (1 - j))))
- s->dsp.vc1_inv_trans_4x8(block, j);
}
break;
}
- return 0;
+ return pat;
}
+/** @} */ // Macroblock group
+
+static const int size_table [6] = { 0, 2, 3, 4, 5, 8 };
+static const int offset_table[6] = { 0, 1, 3, 7, 15, 31 };
/** Decode one P-frame MB (in Simple/Main profile)
*/
int cbp; /* cbp decoding stuff */
int mqdiff, mquant; /* MB quantization */
int ttmb = v->ttfrm; /* MB Transform type */
- int status;
- static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
- offset_table[6] = { 0, 1, 3, 7, 15, 31 };
int mb_has_coeffs = 1; /* last_flag */
int dmv_x, dmv_y; /* Differential MV components */
- int index, index1; /* LUT indices */
+ int index, index1; /* LUT indexes */
int val, sign; /* temp values */
int first_block = 1;
int dst_idx, off;
int skipped, fourmv;
+ int block_cbp = 0, pat;
+ int apply_loop_filter;
mquant = v->pq; /* Loosy initialization */
s->dsp.clear_blocks(s->block[0]);
+ apply_loop_filter = s->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY);
if (!fourmv) /* 1MV mode */
{
if (!skipped)
if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
s->dsp.vc1_inv_trans_8x8(s->block[i]);
if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
- for(j = 0; j < 64; j++) s->block[i][j] += 128;
- if(!v->res_fasttx && v->res_x8) for(j = 0; j < 64; j++) s->block[i][j] += 16;
- s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
+ s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
if(v->pq >= 9 && v->overlap) {
if(v->c_avail)
s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
if(v->a_avail)
s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
}
+ if(apply_loop_filter && s->mb_x && s->mb_x != (s->mb_width - 1) && s->mb_y && s->mb_y != (s->mb_height - 1)){
+ int left_cbp, top_cbp;
+ if(i & 4){
+ left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
+ top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
+ }else{
+ left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
+ top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
+ }
+ if(left_cbp & 0xC)
+ vc1_loop_filter(s->dest[dst_idx] + off, 1, i & 4 ? s->uvlinesize : s->linesize, 8, mquant);
+ if(top_cbp & 0xA)
+ vc1_loop_filter(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, 1, 8, mquant);
+ }
+ block_cbp |= 0xF << (i << 2);
} else if(val) {
- vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
+ int left_cbp = 0, top_cbp = 0, filter = 0;
+ if(apply_loop_filter && s->mb_x && s->mb_x != (s->mb_width - 1) && s->mb_y && s->mb_y != (s->mb_height - 1)){
+ filter = 1;
+ if(i & 4){
+ left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
+ top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
+ }else{
+ left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
+ top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
+ }
+ if(left_cbp & 0xC)
+ vc1_loop_filter(s->dest[dst_idx] + off, 1, i & 4 ? s->uvlinesize : s->linesize, 8, mquant);
+ if(top_cbp & 0xA)
+ vc1_loop_filter(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, 1, 8, mquant);
+ }
+ pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), filter, left_cbp, top_cbp);
+ block_cbp |= pat << (i << 2);
if(!v->ttmbf && ttmb < 8) ttmb = -1;
first_block = 0;
- if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
- s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
}
}
}
if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
s->dsp.vc1_inv_trans_8x8(s->block[i]);
if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
- for(j = 0; j < 64; j++) s->block[i][j] += 128;
- if(!v->res_fasttx && v->res_x8) for(j = 0; j < 64; j++) s->block[i][j] += 16;
- s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
+ s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
if(v->pq >= 9 && v->overlap) {
if(v->c_avail)
s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
if(v->a_avail)
s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
}
+ if(v->s.loop_filter && s->mb_x && s->mb_x != (s->mb_width - 1) && s->mb_y && s->mb_y != (s->mb_height - 1)){
+ int left_cbp, top_cbp;
+ if(i & 4){
+ left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
+ top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
+ }else{
+ left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
+ top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
+ }
+ if(left_cbp & 0xC)
+ vc1_loop_filter(s->dest[dst_idx] + off, 1, i & 4 ? s->uvlinesize : s->linesize, 8, mquant);
+ if(top_cbp & 0xA)
+ vc1_loop_filter(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, 1, 8, mquant);
+ }
+ block_cbp |= 0xF << (i << 2);
} else if(is_coded[i]) {
- status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
+ int left_cbp = 0, top_cbp = 0, filter = 0;
+ if(v->s.loop_filter && s->mb_x && s->mb_x != (s->mb_width - 1) && s->mb_y && s->mb_y != (s->mb_height - 1)){
+ filter = 1;
+ if(i & 4){
+ left_cbp = v->cbp[s->mb_x - 1] >> (i * 4);
+ top_cbp = v->cbp[s->mb_x - s->mb_stride] >> (i * 4);
+ }else{
+ left_cbp = (i & 1) ? (cbp >> ((i-1)*4)) : (v->cbp[s->mb_x - 1] >> ((i+1)*4));
+ top_cbp = (i & 2) ? (cbp >> ((i-2)*4)) : (v->cbp[s->mb_x - s->mb_stride] >> ((i+2)*4));
+ }
+ if(left_cbp & 0xC)
+ vc1_loop_filter(s->dest[dst_idx] + off, 1, i & 4 ? s->uvlinesize : s->linesize, 8, mquant);
+ if(top_cbp & 0xA)
+ vc1_loop_filter(s->dest[dst_idx] + off, i & 4 ? s->uvlinesize : s->linesize, 1, 8, mquant);
+ }
+ pat = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), filter, left_cbp, top_cbp);
+ block_cbp |= pat << (i << 2);
if(!v->ttmbf && ttmb < 8) ttmb = -1;
first_block = 0;
- if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
- s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
}
}
- return status;
+ return 0;
}
else //Skipped MB
{
return 0;
}
}
+ v->cbp[s->mb_x] = block_cbp;
/* Should never happen */
return -1;
int cbp = 0; /* cbp decoding stuff */
int mqdiff, mquant; /* MB quantization */
int ttmb = v->ttfrm; /* MB Transform type */
-
- static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
- offset_table[6] = { 0, 1, 3, 7, 15, 31 };
int mb_has_coeffs = 0; /* last_flag */
- int index, index1; /* LUT indices */
+ int index, index1; /* LUT indexes */
int val, sign; /* temp values */
int first_block = 1;
int dst_idx, off;
if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
s->dsp.vc1_inv_trans_8x8(s->block[i]);
if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
- for(j = 0; j < 64; j++) s->block[i][j] += 128;
- s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
+ s->dsp.put_signed_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
} else if(val) {
- vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
+ vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block, s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize, (i&4) && (s->flags & CODEC_FLAG_GRAY), 0, 0, 0);
if(!v->ttmbf && ttmb < 8) ttmb = -1;
first_block = 0;
- if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
- s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
}
}
}
vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
s->dsp.vc1_inv_trans_8x8(s->block[k]);
- if(!v->res_fasttx && !v->res_x8) for(j = 0; j < 64; j++) s->block[k][j] -= 16;
if(v->pq >= 9 && v->overlap) {
for(j = 0; j < 64; j++) s->block[k][j] += 128;
}
s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
}
+ if(v->s.loop_filter) vc1_loop_filter_iblk(s, s->current_picture.qscale_table[mb_pos]);
if(get_bits_count(&s->gb) > v->bits) {
ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
}
+ if(v->s.loop_filter) vc1_loop_filter_iblk(s, s->current_picture.qscale_table[mb_pos]);
if(get_bits_count(&s->gb) > v->bits) {
ff_er_add_slice(s, 0, 0, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END));
}
s->first_slice_line = 1;
+ memset(v->cbp_base, 0, sizeof(v->cbp_base[0])*2*s->mb_stride);
for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
ff_init_block_index(s);
return;
}
}
+ memmove(v->cbp_base, v->cbp, sizeof(v->cbp_base[0])*s->mb_stride);
ff_draw_horiz_band(s, s->mb_y * 16, 16);
s->first_slice_line = 0;
}
av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
return;
}
+ if(v->s.loop_filter) vc1_loop_filter_iblk(s, s->current_picture.qscale_table[s->mb_x + s->mb_y *s->mb_stride]);
}
ff_draw_horiz_band(s, s->mb_y * 16, 16);
s->first_slice_line = 0;
ff_draw_horiz_band(s, s->mb_y * 16, 16);
s->first_slice_line = 0;
}
- s->pict_type = P_TYPE;
+ s->pict_type = FF_P_TYPE;
}
static void vc1_decode_blocks(VC1Context *v)
{
v->s.esc3_level_length = 0;
+ if(v->x8_type){
+ ff_intrax8_decode_picture(&v->x8, 2*v->pq+v->halfpq, v->pq*(!v->pquantizer) );
+ }else{
- switch(v->s.pict_type) {
- case I_TYPE:
- if(v->profile == PROFILE_ADVANCED)
- vc1_decode_i_blocks_adv(v);
- else
- vc1_decode_i_blocks(v);
- break;
- case P_TYPE:
- if(v->p_frame_skipped)
- vc1_decode_skip_blocks(v);
- else
- vc1_decode_p_blocks(v);
- break;
- case B_TYPE:
- if(v->bi_type){
+ switch(v->s.pict_type) {
+ case FF_I_TYPE:
if(v->profile == PROFILE_ADVANCED)
vc1_decode_i_blocks_adv(v);
else
vc1_decode_i_blocks(v);
- }else
- vc1_decode_b_blocks(v);
- break;
+ break;
+ case FF_P_TYPE:
+ if(v->p_frame_skipped)
+ vc1_decode_skip_blocks(v);
+ else
+ vc1_decode_p_blocks(v);
+ break;
+ case FF_B_TYPE:
+ if(v->bi_type){
+ if(v->profile == PROFILE_ADVANCED)
+ vc1_decode_i_blocks_adv(v);
+ else
+ vc1_decode_i_blocks(v);
+ }else
+ vc1_decode_b_blocks(v);
+ break;
+ }
}
}
/** Find VC-1 marker in buffer
* @return position where next marker starts or end of buffer if no marker found
*/
-static av_always_inline uint8_t* find_next_marker(uint8_t *src, uint8_t *end)
+static av_always_inline const uint8_t* find_next_marker(const uint8_t *src, const uint8_t *end)
{
uint32_t mrk = 0xFFFFFFFF;
return end;
}
-static av_always_inline int vc1_unescape_buffer(uint8_t *src, int size, uint8_t *dst)
+static av_always_inline int vc1_unescape_buffer(const uint8_t *src, int size, uint8_t *dst)
{
int dsize = 0, i;
* @todo TODO: Handle VC-1 IDUs (Transport level?)
* @todo TODO: Decypher remaining bits in extra_data
*/
-static int vc1_decode_init(AVCodecContext *avctx)
+static av_cold int vc1_decode_init(AVCodecContext *avctx)
{
VC1Context *v = avctx->priv_data;
MpegEncContext *s = &v->s;
if (!avctx->extradata_size || !avctx->extradata) return -1;
if (!(avctx->flags & CODEC_FLAG_GRAY))
- avctx->pix_fmt = PIX_FMT_YUV420P;
+ avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
else
avctx->pix_fmt = PIX_FMT_GRAY8;
+ avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
v->s.avctx = avctx;
avctx->flags |= CODEC_FLAG_EMU_EDGE;
v->s.flags |= CODEC_FLAG_EMU_EDGE;
+ if(avctx->idct_algo==FF_IDCT_AUTO){
+ avctx->idct_algo=FF_IDCT_WMV2;
+ }
+
if(ff_h263_decode_init(avctx) < 0)
return -1;
if (vc1_init_common(v) < 0) return -1;
av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
}
} else { // VC1/WVC1
- uint8_t *start = avctx->extradata, *end = avctx->extradata + avctx->extradata_size;
- uint8_t *next; int size, buf2_size;
+ const uint8_t *start = avctx->extradata;
+ uint8_t *end = avctx->extradata + avctx->extradata_size;
+ const uint8_t *next;
+ int size, buf2_size;
uint8_t *buf2 = NULL;
- int seq_inited = 0, ep_inited = 0;
+ int seq_initialized = 0, ep_initialized = 0;
if(avctx->extradata_size < 16) {
av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
av_free(buf2);
return -1;
}
- seq_inited = 1;
+ seq_initialized = 1;
break;
case VC1_CODE_ENTRYPOINT:
if(decode_entry_point(avctx, &gb) < 0){
av_free(buf2);
return -1;
}
- ep_inited = 1;
+ ep_initialized = 1;
break;
}
}
av_free(buf2);
- if(!seq_inited || !ep_inited){
+ if(!seq_initialized || !ep_initialized){
av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
return -1;
}
v->acpred_plane = av_malloc(s->mb_stride * s->mb_height);
v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height);
+ v->cbp_base = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
+ v->cbp = v->cbp_base + s->mb_stride;
+
/* allocate block type info in that way so it could be used with s->block_index[] */
v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
// return -1;
}
+ ff_intrax8_common_init(&v->x8,s);
return 0;
}
*/
static int vc1_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
- uint8_t *buf, int buf_size)
+ const uint8_t *buf, int buf_size)
{
VC1Context *v = avctx->priv_data;
MpegEncContext *s = &v->s;
AVFrame *pict = data;
uint8_t *buf2 = NULL;
+ const uint8_t *buf_start = buf;
/* no supplementary picture */
if (buf_size == 0) {
s->current_picture_ptr= &s->picture[i];
}
+ if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){
+ if (v->profile < PROFILE_ADVANCED)
+ avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
+ else
+ avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
+ }
+
//for advanced profile we may need to parse and unescape data
if (avctx->codec_id == CODEC_ID_VC1) {
int buf_size2 = 0;
buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
if(IS_MARKER(AV_RB32(buf))){ /* frame starts with marker and needs to be parsed */
- uint8_t *start, *end, *next;
+ const uint8_t *start, *end, *next;
int size;
next = buf;
if(size <= 0) continue;
switch(AV_RB32(start)){
case VC1_CODE_FRAME:
+ if (avctx->hwaccel ||
+ s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
+ buf_start = start;
buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
break;
case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
}
}
}else if(v->interlace && ((buf[0] & 0xC0) == 0xC0)){ /* WVC1 interlaced stores both fields divided by marker */
- uint8_t *divider;
+ const uint8_t *divider;
divider = find_next_marker(buf, buf + buf_size);
if((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD){
av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
+ av_free(buf2);
return -1;
}
}
}
- if(s->pict_type != I_TYPE && !v->res_rtm_flag){
+ if(s->pict_type != FF_I_TYPE && !v->res_rtm_flag){
av_free(buf2);
return -1;
}
// for hurry_up==5
s->current_picture.pict_type= s->pict_type;
- s->current_picture.key_frame= s->pict_type == I_TYPE;
+ s->current_picture.key_frame= s->pict_type == FF_I_TYPE;
/* skip B-frames if we don't have reference frames */
- if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)){
+ if(s->last_picture_ptr==NULL && (s->pict_type==FF_B_TYPE || s->dropable)){
av_free(buf2);
return -1;//buf_size;
}
/* skip b frames if we are in a hurry */
- if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
- if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
- || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
+ if(avctx->hurry_up && s->pict_type==FF_B_TYPE) return -1;//buf_size;
+ if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==FF_B_TYPE)
+ || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=FF_I_TYPE)
|| avctx->skip_frame >= AVDISCARD_ALL) {
av_free(buf2);
return buf_size;
}
if(s->next_p_frame_damaged){
- if(s->pict_type==B_TYPE)
+ if(s->pict_type==FF_B_TYPE)
return buf_size;
else
s->next_p_frame_damaged=0;
s->me.qpel_put= s->dsp.put_qpel_pixels_tab;
s->me.qpel_avg= s->dsp.avg_qpel_pixels_tab;
- ff_er_frame_start(s);
+ if ((CONFIG_VC1_VDPAU_DECODER || CONFIG_WMV3_VDPAU_DECODER)
+ &&s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
+ ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
+ else if (avctx->hwaccel) {
+ if (avctx->hwaccel->start_frame(avctx, buf, buf_size) < 0)
+ return -1;
+ if (avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start) < 0)
+ return -1;
+ if (avctx->hwaccel->end_frame(avctx) < 0)
+ return -1;
+ } else {
+ ff_er_frame_start(s);
- v->bits = buf_size * 8;
- vc1_decode_blocks(v);
+ v->bits = buf_size * 8;
+ vc1_decode_blocks(v);
//av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
// if(get_bits_count(&s->gb) > buf_size * 8)
// return -1;
- ff_er_frame_end(s);
+ ff_er_frame_end(s);
+ }
MPV_frame_end(s);
assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
assert(s->current_picture.pict_type == s->pict_type);
- if (s->pict_type == B_TYPE || s->low_delay) {
+ if (s->pict_type == FF_B_TYPE || s->low_delay) {
*pict= *(AVFrame*)s->current_picture_ptr;
} else if (s->last_picture_ptr != NULL) {
*pict= *(AVFrame*)s->last_picture_ptr;
}
/* Return the Picture timestamp as the frame number */
- /* we substract 1 because it is added on utils.c */
+ /* we subtract 1 because it is added on utils.c */
avctx->frame_number = s->picture_number - 1;
av_free(buf2);
/** Close a VC1/WMV3 decoder
* @warning Initial try at using MpegEncContext stuff
*/
-static int vc1_decode_end(AVCodecContext *avctx)
+static av_cold int vc1_decode_end(AVCodecContext *avctx)
{
VC1Context *v = avctx->priv_data;
av_freep(&v->acpred_plane);
av_freep(&v->over_flags_plane);
av_freep(&v->mb_type_base);
+ av_freep(&v->cbp_base);
+ ff_intrax8_common_end(&v->x8);
return 0;
}
vc1_decode_end,
vc1_decode_frame,
CODEC_CAP_DELAY,
- NULL
+ NULL,
+ .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
+ .pix_fmts = ff_hwaccel_pixfmt_list_420
};
AVCodec wmv3_decoder = {
vc1_decode_end,
vc1_decode_frame,
CODEC_CAP_DELAY,
- NULL
+ NULL,
+ .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
+ .pix_fmts = ff_hwaccel_pixfmt_list_420
};
+
+#if CONFIG_WMV3_VDPAU_DECODER
+AVCodec wmv3_vdpau_decoder = {
+ "wmv3_vdpau",
+ CODEC_TYPE_VIDEO,
+ CODEC_ID_WMV3,
+ sizeof(VC1Context),
+ vc1_decode_init,
+ NULL,
+ vc1_decode_end,
+ vc1_decode_frame,
+ CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
+ NULL,
+ .long_name = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
+ .pix_fmts = (enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE}
+};
+#endif
+
+#if CONFIG_VC1_VDPAU_DECODER
+AVCodec vc1_vdpau_decoder = {
+ "vc1_vdpau",
+ CODEC_TYPE_VIDEO,
+ CODEC_ID_VC1,
+ sizeof(VC1Context),
+ vc1_decode_init,
+ NULL,
+ vc1_decode_end,
+ vc1_decode_frame,
+ CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
+ NULL,
+ .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
+ .pix_fmts = (enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE}
+};
+#endif
projects / ffmpeg / blobdiff