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

Merge commit '7d8482640058d66867602a6f58446c9342d9d146'

Browse Source 
* commit '7d8482640058d66867602a6f58446c9342d9d146':
  cavs: deMpegEncContextize

Note, the bugfixes have all been in FFmpeg previously, this just switches away
from MpegEncContext

Conflicts:
	libavcodec/cavs.c
	libavcodec/cavsdec.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/8/head
Michael Niedermayer 12 years ago
parent 6ddda83c3f 7d84826400
commit ca95d1b32d
3 changed files with 190 additions and 167 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. 105
      libavcodec/cavs.c
  2. 25
      libavcodec/cavs.h
  3. 227
      libavcodec/cavsdec.c

105
libavcodec/cavs.c
Unescape View File

@ -375,20 +375,19 @@ void ff_cavs_modify_mb_i(AVSContext *h, int *pred_mode_uv)
*
****************************************************************************/
static inline void mc_dir_part(AVSContext *h,Picture *pic,
static inline void mc_dir_part(AVSContext *h, AVFrame *pic,
int chroma_height,int delta,int list,uint8_t *dest_y,
uint8_t *dest_cb,uint8_t *dest_cr,int src_x_offset,
int src_y_offset,qpel_mc_func *qpix_op,
h264_chroma_mc_func chroma_op,cavs_vector *mv)
{
MpegEncContext * const s = &h->s;
const int mx= mv->x + src_x_offset*8;
const int my= mv->y + src_y_offset*8;
const int luma_xy= (mx&3) + ((my&3)<<2);
uint8_t * src_y = pic->f.data[0] + (mx >> 2) + (my >> 2) * h->l_stride;
uint8_t * src_cb = pic->f.data[1] + (mx >> 3) + (my >> 3) * h->c_stride;
uint8_t * src_cr = pic->f.data[2] + (mx >> 3) + (my >> 3) * h->c_stride;
int extra_width= 0; //(s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;
uint8_t * src_y = pic->data[0] + (mx >> 2) + (my >> 2) * h->l_stride;
uint8_t * src_cb = pic->data[1] + (mx >> 3) + (my >> 3) * h->c_stride;
uint8_t * src_cr = pic->data[2] + (mx >> 3) + (my >> 3) * h->c_stride;
int extra_width = 0;
int extra_height= extra_width;
int emu=0;
const int full_mx= mx>>2;
@ -396,7 +395,7 @@ static inline void mc_dir_part(AVSContext *h,Picture *pic,
const int pic_width = 16*h->mb_width;
const int pic_height = 16*h->mb_height;
if(!pic->f.data[0])
if (!pic->data[0])
return;
if(mx&7) extra_width -= 3;
if(my&7) extra_height -= 3;
@ -405,25 +404,25 @@ static inline void mc_dir_part(AVSContext *h,Picture *pic,
|| full_my < 0-extra_height
|| full_mx + 16/*FIXME*/ > pic_width + extra_width
|| full_my + 16/*FIXME*/ > pic_height + extra_height){
s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*h->l_stride, h->l_stride,
h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_y - 2 - 2*h->l_stride, h->l_stride,
16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
src_y= s->edge_emu_buffer + 2 + 2*h->l_stride;
src_y= h->edge_emu_buffer + 2 + 2*h->l_stride;
emu=1;
}
qpix_op[luma_xy](dest_y, src_y, h->l_stride); //FIXME try variable height perhaps?
if(emu){
s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src_cb, h->c_stride,
h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cb, h->c_stride,
9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
src_cb= s->edge_emu_buffer;
src_cb= h->edge_emu_buffer;
}
chroma_op(dest_cb, src_cb, h->c_stride, chroma_height, mx&7, my&7);
if(emu){
s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src_cr, h->c_stride,
h->vdsp.emulated_edge_mc(h->edge_emu_buffer, src_cr, h->c_stride,
9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
src_cr= s->edge_emu_buffer;
src_cr= h->edge_emu_buffer;
}
chroma_op(dest_cr, src_cr, h->c_stride, chroma_height, mx&7, my&7);
}
@ -444,7 +443,7 @@ static inline void mc_part_std(AVSContext *h,int chroma_height,int delta,
y_offset += 8*h->mby;
if(mv->ref >= 0){
Picture *ref= &h->DPB[mv->ref];
AVFrame *ref = h->DPB[mv->ref].f;
mc_dir_part(h, ref, chroma_height, delta, 0,
dest_y, dest_cb, dest_cr, x_offset, y_offset,
qpix_op, chroma_op, mv);
@ -454,7 +453,7 @@ static inline void mc_part_std(AVSContext *h,int chroma_height,int delta,
}
if((mv+MV_BWD_OFFS)->ref >= 0){
Picture *ref= &h->DPB[0];
AVFrame *ref = h->DPB[0].f;
mc_dir_part(h, ref, chroma_height, delta, 1,
dest_y, dest_cb, dest_cr, x_offset, y_offset,
qpix_op, chroma_op, mv+MV_BWD_OFFS);
@ -465,30 +464,30 @@ void ff_cavs_inter(AVSContext *h, enum cavs_mb mb_type) {
if(ff_cavs_partition_flags[mb_type] == 0){ // 16x16
mc_part_std(h, 8, 0, h->cy, h->cu, h->cv, 0, 0,
h->cdsp.put_cavs_qpel_pixels_tab[0],
h->s.dsp.put_h264_chroma_pixels_tab[0],
h->dsp.put_h264_chroma_pixels_tab[0],
h->cdsp.avg_cavs_qpel_pixels_tab[0],
h->s.dsp.avg_h264_chroma_pixels_tab[0],&h->mv[MV_FWD_X0]);
h->dsp.avg_h264_chroma_pixels_tab[0],&h->mv[MV_FWD_X0]);
}else{
mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 0, 0,
h->cdsp.put_cavs_qpel_pixels_tab[1],
h->s.dsp.put_h264_chroma_pixels_tab[1],
h->dsp.put_h264_chroma_pixels_tab[1],
h->cdsp.avg_cavs_qpel_pixels_tab[1],
h->s.dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X0]);
h->dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X0]);
mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 4, 0,
h->cdsp.put_cavs_qpel_pixels_tab[1],
h->s.dsp.put_h264_chroma_pixels_tab[1],
h->dsp.put_h264_chroma_pixels_tab[1],
h->cdsp.avg_cavs_qpel_pixels_tab[1],
h->s.dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X1]);
h->dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X1]);
mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 0, 4,
h->cdsp.put_cavs_qpel_pixels_tab[1],
h->s.dsp.put_h264_chroma_pixels_tab[1],
h->dsp.put_h264_chroma_pixels_tab[1],
h->cdsp.avg_cavs_qpel_pixels_tab[1],
h->s.dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X2]);
h->dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X2]);
mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 4, 4,
h->cdsp.put_cavs_qpel_pixels_tab[1],
h->s.dsp.put_h264_chroma_pixels_tab[1],
h->dsp.put_h264_chroma_pixels_tab[1],
h->cdsp.avg_cavs_qpel_pixels_tab[1],
h->s.dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X3]);
h->dsp.avg_h264_chroma_pixels_tab[1],&h->mv[MV_FWD_X3]);
}
}
@ -569,8 +568,8 @@ void ff_cavs_mv(AVSContext *h, enum cavs_mv_loc nP, enum cavs_mv_loc nC,
mv_pred_median(h, mvP, mvA, mvB, mvC);
if(mode < MV_PRED_PSKIP) {
mvP->x += get_se_golomb(&h->s.gb);
mvP->y += get_se_golomb(&h->s.gb);
mvP->x += get_se_golomb(&h->gb);
mvP->y += get_se_golomb(&h->gb);
}
set_mvs(mvP,size);
}
@ -652,9 +651,9 @@ int ff_cavs_next_mb(AVSContext *h) {
h->mbx = 0;
h->mby++;
/* re-calculate sample pointers */
h->cy = h->picture.f.data[0] + h->mby * 16 * h->l_stride;
h->cu = h->picture.f.data[1] + h->mby * 8 * h->c_stride;
h->cv = h->picture.f.data[2] + h->mby * 8 * h->c_stride;
h->cy = h->cur.f->data[0] + h->mby * 16 * h->l_stride;
h->cu = h->cur.f->data[1] + h->mby * 8 * h->c_stride;
h->cv = h->cur.f->data[2] + h->mby * 8 * h->c_stride;
if(h->mby == h->mb_height) { //frame end
return 0;
}
@ -669,8 +668,6 @@ int ff_cavs_next_mb(AVSContext *h) {
****************************************************************************/
int ff_cavs_init_pic(AVSContext *h) {
MpegEncContext *s = &h->s;
int ret;
int i;
/* clear some predictors */
@ -681,22 +678,16 @@ int ff_cavs_init_pic(AVSContext *h) {
h->mv[MV_FWD_X0] = ff_cavs_dir_mv;
set_mvs(&h->mv[MV_FWD_X0], BLK_16X16);
h->pred_mode_Y[3] = h->pred_mode_Y[6] = NOT_AVAIL;
h->cy = h->picture.f.data[0];
h->cu = h->picture.f.data[1];
h->cv = h->picture.f.data[2];
h->l_stride = h->picture.f.linesize[0];
h->c_stride = h->picture.f.linesize[1];
h->cy = h->cur.f->data[0];
h->cu = h->cur.f->data[1];
h->cv = h->cur.f->data[2];
h->l_stride = h->cur.f->linesize[0];
h->c_stride = h->cur.f->linesize[1];
h->luma_scan[2] = 8*h->l_stride;
h->luma_scan[3] = 8*h->l_stride+8;
h->mbx = h->mby = h->mbidx = 0;
h->flags = 0;
if (!s->edge_emu_buffer &&
(ret = ff_mpv_frame_size_alloc(s, h->picture.f.linesize[0])) < 0) {
av_log(s->avctx, AV_LOG_ERROR,
"get_buffer() failed to allocate context scratch buffers.\n");
return ret;
}
return 0;
}
@ -729,14 +720,25 @@ void ff_cavs_init_top_lines(AVSContext *h) {
av_cold int ff_cavs_init(AVCodecContext *avctx) {
AVSContext *h = avctx->priv_data;
MpegEncContext * const s = &h->s;
ff_MPV_decode_defaults(s);
ff_dsputil_init(&h->dsp, avctx);
ff_videodsp_init(&h->vdsp, 8);
ff_cavsdsp_init(&h->cdsp, avctx);
s->avctx = avctx;
ff_init_scantable_permutation(h->dsp.idct_permutation,
h->cdsp.idct_perm);
ff_init_scantable(h->dsp.idct_permutation, &h->scantable, ff_zigzag_direct);
h->avctx = avctx;
avctx->pix_fmt= AV_PIX_FMT_YUV420P;
h->cur.f = avcodec_alloc_frame();
h->DPB[0].f = avcodec_alloc_frame();
h->DPB[1].f = avcodec_alloc_frame();
if (!h->cur.f || !h->DPB[0].f || !h->DPB[1].f) {
ff_cavs_end(avctx);
return AVERROR(ENOMEM);
}
h->luma_scan[0] = 0;
h->luma_scan[1] = 8;
h->intra_pred_l[ INTRA_L_VERT] = intra_pred_vert;
@ -762,7 +764,15 @@ av_cold int ff_cavs_init(AVCodecContext *avctx) {
av_cold int ff_cavs_end(AVCodecContext *avctx) {
AVSContext *h = avctx->priv_data;
ff_MPV_common_end(&h->s);
if (h->cur.f->data[0])
avctx->release_buffer(avctx, h->cur.f);
if (h->DPB[0].f->data[0])
avctx->release_buffer(avctx, h->DPB[0].f);
if (h->DPB[1].f->data[0])
avctx->release_buffer(avctx, h->DPB[1].f);
avcodec_free_frame(&h->cur.f);
avcodec_free_frame(&h->DPB[0].f);
avcodec_free_frame(&h->DPB[1].f);
av_free(h->top_qp);
av_free(h->top_mv[0]);
@ -774,5 +784,6 @@ av_cold int ff_cavs_end(AVCodecContext *avctx) {
av_free(h->col_mv);
av_free(h->col_type_base);
av_free(h->block);
av_freep(&h->edge_emu_buffer);
return 0;
}

25
libavcodec/cavs.h
Unescape View File

@ -22,9 +22,10 @@
#ifndef AVCODEC_CAVS_H
#define AVCODEC_CAVS_H
#include "dsputil.h"
#include "mpegvideo.h"
#include "cavsdsp.h"
#include "dsputil.h"
#include "get_bits.h"
#include "videodsp.h"
#define SLICE_MAX_START_CODE 0x000001af
#define EXT_START_CODE 0x000001b5
@ -152,15 +153,25 @@ struct dec_2dvlc {
int8_t max_run;
};
typedef struct AVSFrame {
AVFrame *f;
int poc;
} AVSFrame;
typedef struct AVSContext {
MpegEncContext s;
CAVSDSPContext cdsp;
Picture picture; ///< currently decoded frame
Picture DPB[2]; ///< reference frames
AVCodecContext *avctx;
DSPContext dsp;
VideoDSPContext vdsp;
CAVSDSPContext cdsp;
GetBitContext gb;
AVSFrame cur; ///< currently decoded frame
AVSFrame DPB[2]; ///< reference frames
int dist[2]; ///< temporal distances from current frame to ref frames
int low_delay;
int profile, level;
int aspect_ratio;
int mb_width, mb_height;
int width, height;
int pic_type;
int stream_revision; ///<0 for samples from 2006, 1 for rm52j encoder
int progressive;
@ -221,6 +232,8 @@ typedef struct AVSContext {
int direct_den[2]; ///< for scaling in direct B block
int scale_den[2]; ///< for scaling neighbouring MVs
uint8_t *edge_emu_buffer;
int got_keyframe;
DCTELEM *block;
} AVSContext;

227
libavcodec/cavsdec.c
Unescape View File

@ -31,6 +31,8 @@
#include "golomb.h"
#include "cavs.h"
#include "internal.h"
#include "mpeg12data.h"
#include "mpegvideo.h"
static const uint8_t mv_scan[4] = {
MV_FWD_X0, MV_FWD_X1,
@ -526,9 +528,9 @@ static inline int dequant(AVSContext *h, DCTELEM *level_buf, uint8_t *run_buf,
while (--coeff_num >= 0) {
pos += run_buf[coeff_num];
if (pos > 63) {
av_log(h->s.avctx, AV_LOG_ERROR,
av_log(h->avctx, AV_LOG_ERROR,
"position out of block bounds at pic %d MB(%d,%d)\n",
h->picture.poc, h->mbx, h->mby);
h->cur.poc, h->mbx, h->mby);
return -1;
}
dst[scantab[pos]] = (level_buf[coeff_num] * mul + round) >> shift;
@ -581,7 +583,7 @@ static int decode_residual_block(AVSContext *h, GetBitContext *gb,
dequant_shift[qp], i))
return -1;
h->cdsp.cavs_idct8_add(dst, block, stride);
h->s.dsp.clear_block(block);
h->dsp.clear_block(block);
return 0;
}
@ -589,10 +591,10 @@ static int decode_residual_block(AVSContext *h, GetBitContext *gb,
static inline void decode_residual_chroma(AVSContext *h)
{
if (h->cbp & (1 << 4))
decode_residual_block(h, &h->s.gb, chroma_dec, 0,
decode_residual_block(h, &h->gb, chroma_dec, 0,
cavs_chroma_qp[h->qp], h->cu, h->c_stride);
if (h->cbp & (1 << 5))
decode_residual_block(h, &h->s.gb, chroma_dec, 0,
decode_residual_block(h, &h->gb, chroma_dec, 0,
cavs_chroma_qp[h->qp], h->cv, h->c_stride);
}
@ -601,19 +603,19 @@ static inline int decode_residual_inter(AVSContext *h)
int block;
/* get coded block pattern */
int cbp = get_ue_golomb(&h->s.gb);
int cbp = get_ue_golomb(&h->gb);
if (cbp > 63U) {
av_log(h->s.avctx, AV_LOG_ERROR, "illegal inter cbp\n");
av_log(h->avctx, AV_LOG_ERROR, "illegal inter cbp\n");
return -1;
}
h->cbp = cbp_tab[cbp][1];
/* get quantizer */
if (h->cbp && !h->qp_fixed)
h->qp = (h->qp + get_se_golomb(&h->s.gb)) & 63;
h->qp = (h->qp + get_se_golomb(&h->gb)) & 63;
for (block = 0; block < 4; block++)
if (h->cbp & (1 << block))
decode_residual_block(h, &h->s.gb, inter_dec, 0, h->qp,
decode_residual_block(h, &h->gb, inter_dec, 0, h->qp,
h->cy + h->luma_scan[block], h->l_stride);
decode_residual_chroma(h);
@ -638,7 +640,7 @@ static inline void set_mv_intra(AVSContext *h)
static int decode_mb_i(AVSContext *h, int cbp_code)
{
GetBitContext *gb = &h->s.gb;
GetBitContext *gb = &h->gb;
unsigned pred_mode_uv;
int block;
uint8_t top[18];
@ -665,7 +667,7 @@ static int decode_mb_i(AVSContext *h, int cbp_code)
}
pred_mode_uv = get_ue_golomb(gb);
if (pred_mode_uv > 6) {
av_log(h->s.avctx, AV_LOG_ERROR, "illegal intra chroma pred mode\n");
av_log(h->avctx, AV_LOG_ERROR, "illegal intra chroma pred mode\n");
return -1;
}
ff_cavs_modify_mb_i(h, &pred_mode_uv);
@ -674,7 +676,7 @@ static int decode_mb_i(AVSContext *h, int cbp_code)
if (h->pic_type == AV_PICTURE_TYPE_I)
cbp_code = get_ue_golomb(gb);
if (cbp_code > 63U) {
av_log(h->s.avctx, AV_LOG_ERROR, "illegal intra cbp\n");
av_log(h->avctx, AV_LOG_ERROR, "illegal intra cbp\n");
return -1;
}
h->cbp = cbp_tab[cbp_code][0];
@ -717,7 +719,7 @@ static inline void set_intra_mode_default(AVSContext *h)
static void decode_mb_p(AVSContext *h, enum cavs_mb mb_type)
{
GetBitContext *gb = &h->s.gb;
GetBitContext *gb = &h->gb;
int ref[4];
ff_cavs_init_mb(h);
@ -798,7 +800,7 @@ static int decode_mb_b(AVSContext *h, enum cavs_mb mb_type)
break;
case B_8X8:
for (block = 0; block < 4; block++)
sub_type[block] = get_bits(&h->s.gb, 2);
sub_type[block] = get_bits(&h->gb, 2);
for (block = 0; block < 4; block++) {
switch (sub_type[block]) {
case B_SUB_DIRECT:
@ -833,7 +835,7 @@ static int decode_mb_b(AVSContext *h, enum cavs_mb mb_type)
break;
default:
if (mb_type <= B_SYM_16X16) {
av_log(h->s.avctx, AV_LOG_ERROR, "Invalid mb_type %d in B frame\n", mb_type);
av_log(h->avctx, AV_LOG_ERROR, "Invalid mb_type %d in B frame\n", mb_type);
return AVERROR_INVALIDDATA;
}
av_assert2(mb_type < B_8X8);
@ -884,7 +886,7 @@ static int decode_mb_b(AVSContext *h, enum cavs_mb mb_type)
static inline int decode_slice_header(AVSContext *h, GetBitContext *gb)
{
if (h->stc > 0xAF)
av_log(h->s.avctx, AV_LOG_ERROR, "unexpected start code 0x%02x\n", h->stc);
av_log(h->avctx, AV_LOG_ERROR, "unexpected start code 0x%02x\n", h->stc);
if (h->stc >= h->mb_height)
return -1;
@ -902,7 +904,7 @@ static inline int decode_slice_header(AVSContext *h, GetBitContext *gb)
if ((h->pic_type != AV_PICTURE_TYPE_I) ||
(!h->pic_structure && h->mby >= h->mb_width / 2))
if (get_bits1(gb)) { //slice_weighting_flag
av_log(h->s.avctx, AV_LOG_ERROR,
av_log(h->avctx, AV_LOG_ERROR,
"weighted prediction not yet supported\n");
}
return 0;
@ -910,7 +912,7 @@ static inline int decode_slice_header(AVSContext *h, GetBitContext *gb)
static inline int check_for_slice(AVSContext *h)
{
GetBitContext *gb = &h->s.gb;
GetBitContext *gb = &h->gb;
int align;
if (h->mbx)
@ -938,60 +940,60 @@ static inline int check_for_slice(AVSContext *h)
static int decode_pic(AVSContext *h)
{
MpegEncContext *s = &h->s;
int skip_count = -1;
int ret;
enum cavs_mb mb_type;
if (!s->context_initialized) {
if (ff_MPV_common_init(s) < 0)
return -1;
ff_init_scantable_permutation(s->dsp.idct_permutation,
h->cdsp.idct_perm);
ff_init_scantable(s->dsp.idct_permutation, &h->scantable, ff_zigzag_direct);
}
skip_bits(&s->gb, 16);//bbv_dwlay
skip_bits(&h->gb, 16);//bbv_dwlay
if (h->stc == PIC_PB_START_CODE) {
h->pic_type = get_bits(&s->gb, 2) + AV_PICTURE_TYPE_I;
h->pic_type = get_bits(&h->gb, 2) + AV_PICTURE_TYPE_I;
if (h->pic_type > AV_PICTURE_TYPE_B) {
av_log(s->avctx, AV_LOG_ERROR, "illegal picture type\n");
av_log(h->avctx, AV_LOG_ERROR, "illegal picture type\n");
return -1;
}
/* make sure we have the reference frames we need */
if (!h->DPB[0].f.data[0] ||
(!h->DPB[1].f.data[0] && h->pic_type == AV_PICTURE_TYPE_B))
if (!h->DPB[0].f->data[0] ||
(!h->DPB[1].f->data[0] && h->pic_type == AV_PICTURE_TYPE_B))
return -1;
} else {
h->pic_type = AV_PICTURE_TYPE_I;
if (get_bits1(&s->gb))
skip_bits(&s->gb, 24);//time_code
if (get_bits1(&h->gb))
skip_bits(&h->gb, 24);//time_code
/* old sample clips were all progressive and no low_delay,
bump stream revision if detected otherwise */
if (s->low_delay || !(show_bits(&s->gb, 9) & 1))
if (h->low_delay || !(show_bits(&h->gb, 9) & 1))
h->stream_revision = 1;
/* similarly test top_field_first and repeat_first_field */
else if (show_bits(&s->gb, 11) & 3)
else if (show_bits(&h->gb, 11) & 3)
h->stream_revision = 1;
if (h->stream_revision > 0)
skip_bits(&s->gb, 1); //marker_bit
skip_bits(&h->gb, 1); //marker_bit
}
/* release last B frame */
if (h->picture.f.data[0])
s->avctx->release_buffer(s->avctx, &h->picture.f);
if (h->cur.f->data[0])
h->avctx->release_buffer(h->avctx, h->cur.f);
if ((ret = ff_get_buffer(s->avctx, &h->picture.f)) < 0)
if ((ret = ff_get_buffer(h->avctx, h->cur.f)) < 0)
return ret;
if (!h->edge_emu_buffer) {
int alloc_size = FFALIGN(FFABS(h->cur.f->linesize[0]) + 32, 32);
h->edge_emu_buffer = av_mallocz(alloc_size * 2 * 24);
if (!h->edge_emu_buffer)
return AVERROR(ENOMEM);
}
if ((ret = ff_cavs_init_pic(h)) < 0)
return ret;
h->picture.poc = get_bits(&s->gb, 8) * 2;
h->cur.poc = get_bits(&h->gb, 8) * 2;
/* get temporal distances and MV scaling factors */
if (h->pic_type != AV_PICTURE_TYPE_B) {
h->dist[0] = (h->picture.poc - h->DPB[0].poc + 512) % 512;
h->dist[0] = (h->cur.poc - h->DPB[0].poc + 512) % 512;
} else {
h->dist[0] = (h->DPB[0].poc - h->picture.poc + 512) % 512;
h->dist[0] = (h->DPB[0].poc - h->cur.poc + 512) % 512;
}
h->dist[1] = (h->picture.poc - h->DPB[1].poc + 512) % 512;
h->dist[1] = (h->cur.poc - h->DPB[1].poc + 512) % 512;
h->scale_den[0] = h->dist[0] ? 512/h->dist[0] : 0;
h->scale_den[1] = h->dist[1] ? 512/h->dist[1] : 0;
if (h->pic_type == AV_PICTURE_TYPE_B) {
@ -1001,32 +1003,32 @@ static int decode_pic(AVSContext *h)
h->direct_den[1] = h->dist[1] ? 16384 / h->dist[1] : 0;
}
if (s->low_delay)
get_ue_golomb(&s->gb); //bbv_check_times
h->progressive = get_bits1(&s->gb);
if (h->low_delay)
get_ue_golomb(&h->gb); //bbv_check_times
h->progressive = get_bits1(&h->gb);
h->pic_structure = 1;
if (!h->progressive)
h->pic_structure = get_bits1(&s->gb);
h->pic_structure = get_bits1(&h->gb);
if (!h->pic_structure && h->stc == PIC_PB_START_CODE)
skip_bits1(&s->gb); //advanced_pred_mode_disable
skip_bits1(&s->gb); //top_field_first
skip_bits1(&s->gb); //repeat_first_field
h->qp_fixed = get_bits1(&s->gb);
h->qp = get_bits(&s->gb, 6);
skip_bits1(&h->gb); //advanced_pred_mode_disable
skip_bits1(&h->gb); //top_field_first
skip_bits1(&h->gb); //repeat_first_field
h->qp_fixed = get_bits1(&h->gb);
h->qp = get_bits(&h->gb, 6);
if (h->pic_type == AV_PICTURE_TYPE_I) {
if (!h->progressive && !h->pic_structure)
skip_bits1(&s->gb);//what is this?
skip_bits(&s->gb, 4); //reserved bits
skip_bits1(&h->gb);//what is this?
skip_bits(&h->gb, 4); //reserved bits
} else {
if (!(h->pic_type == AV_PICTURE_TYPE_B && h->pic_structure == 1))
h->ref_flag = get_bits1(&s->gb);
skip_bits(&s->gb, 4); //reserved bits
h->skip_mode_flag = get_bits1(&s->gb);
h->ref_flag = get_bits1(&h->gb);
skip_bits(&h->gb, 4); //reserved bits
h->skip_mode_flag = get_bits1(&h->gb);
}
h->loop_filter_disable = get_bits1(&s->gb);
if (!h->loop_filter_disable && get_bits1(&s->gb)) {
h->alpha_offset = get_se_golomb(&s->gb);
h->beta_offset = get_se_golomb(&s->gb);
h->loop_filter_disable = get_bits1(&h->gb);
if (!h->loop_filter_disable && get_bits1(&h->gb)) {
h->alpha_offset = get_se_golomb(&h->gb);
h->beta_offset = get_se_golomb(&h->gb);
} else {
h->alpha_offset = h->beta_offset = 0;
}
@ -1040,11 +1042,11 @@ static int decode_pic(AVSContext *h)
if (check_for_slice(h))
skip_count = -1;
if (h->skip_mode_flag && (skip_count < 0))
skip_count = get_ue_golomb(&s->gb);
skip_count = get_ue_golomb(&h->gb);
if (h->skip_mode_flag && skip_count--) {
decode_mb_p(h, P_SKIP);
} else {
mb_type = get_ue_golomb(&s->gb) + P_SKIP + h->skip_mode_flag;
mb_type = get_ue_golomb(&h->gb) + P_SKIP + h->skip_mode_flag;
if (mb_type > P_8X8)
decode_mb_i(h, mb_type - P_8X8 - 1);
else
@ -1056,11 +1058,11 @@ static int decode_pic(AVSContext *h)
if (check_for_slice(h))
skip_count = -1;
if (h->skip_mode_flag && (skip_count < 0))
skip_count = get_ue_golomb(&s->gb);
skip_count = get_ue_golomb(&h->gb);
if (h->skip_mode_flag && skip_count--) {
decode_mb_b(h, B_SKIP);
} else {
mb_type = get_ue_golomb(&s->gb) + B_SKIP + h->skip_mode_flag;
mb_type = get_ue_golomb(&h->gb) + B_SKIP + h->skip_mode_flag;
if (mb_type > B_8X8)
decode_mb_i(h, mb_type - B_8X8 - 1);
else
@ -1069,11 +1071,10 @@ static int decode_pic(AVSContext *h)
} while (ff_cavs_next_mb(h));
}
if (h->pic_type != AV_PICTURE_TYPE_B) {
if (h->DPB[1].f.data[0])
s->avctx->release_buffer(s->avctx, &h->DPB[1].f);
h->DPB[1] = h->DPB[0];
h->DPB[0] = h->picture;
memset(&h->picture, 0, sizeof(Picture));
if (h->DPB[1].f->data[0])
h->avctx->release_buffer(h->avctx, h->DPB[1].f);
FFSWAP(AVSFrame, h->cur, h->DPB[1]);
FFSWAP(AVSFrame, h->DPB[0], h->DPB[1]);
}
return 0;
}
@ -1086,41 +1087,40 @@ static int decode_pic(AVSContext *h)
static int decode_seq_header(AVSContext *h)
{
MpegEncContext *s = &h->s;
int frame_rate_code;
int width, height;
h->profile = get_bits(&s->gb, 8);
h->level = get_bits(&s->gb, 8);
skip_bits1(&s->gb); //progressive sequence
h->profile = get_bits(&h->gb, 8);
h->level = get_bits(&h->gb, 8);
skip_bits1(&h->gb); //progressive sequence
width = get_bits(&s->gb, 14);
height = get_bits(&s->gb, 14);
if ((s->width || s->height) && (s->width != width || s->height != height)) {
av_log_missing_feature(s, "Width/height changing in CAVS", 0);
width = get_bits(&h->gb, 14);
height = get_bits(&h->gb, 14);
if ((h->width || h->height) && (h->width != width || h->height != height)) {
av_log_missing_feature(h->avctx, "Width/height changing in CAVS", 0);
return AVERROR_PATCHWELCOME;
}
if (width <= 0 || height <= 0) {
av_log(s, AV_LOG_ERROR, "Dimensions invalid\n");
av_log(h->avctx, AV_LOG_ERROR, "Dimensions invalid\n");
return AVERROR_INVALIDDATA;
}
s->width = width;
s->height = height;
skip_bits(&s->gb, 2); //chroma format
skip_bits(&s->gb, 3); //sample_precision
h->aspect_ratio = get_bits(&s->gb, 4);
frame_rate_code = get_bits(&s->gb, 4);
skip_bits(&s->gb, 18); //bit_rate_lower
skip_bits1(&s->gb); //marker_bit
skip_bits(&s->gb, 12); //bit_rate_upper
s->low_delay = get_bits1(&s->gb);
h->mb_width = (s->width + 15) >> 4;
h->mb_height = (s->height + 15) >> 4;
h->s.avctx->time_base.den = ff_mpeg12_frame_rate_tab[frame_rate_code].num;
h->s.avctx->time_base.num = ff_mpeg12_frame_rate_tab[frame_rate_code].den;
h->s.avctx->width = s->width;
h->s.avctx->height = s->height;
h->width = width;
h->height = height;
skip_bits(&h->gb, 2); //chroma format
skip_bits(&h->gb, 3); //sample_precision
h->aspect_ratio = get_bits(&h->gb, 4);
frame_rate_code = get_bits(&h->gb, 4);
skip_bits(&h->gb, 18); //bit_rate_lower
skip_bits1(&h->gb); //marker_bit
skip_bits(&h->gb, 12); //bit_rate_upper
h->low_delay = get_bits1(&h->gb);
h->mb_width = (h->width + 15) >> 4;
h->mb_height = (h->height + 15) >> 4;
h->avctx->time_base.den = ff_mpeg12_frame_rate_tab[frame_rate_code].num;
h->avctx->time_base.num = ff_mpeg12_frame_rate_tab[frame_rate_code].den;
h->avctx->width = h->width;
h->avctx->height = h->height;
if (!h->top_qp)
ff_cavs_init_top_lines(h);
return 0;
@ -1136,7 +1136,6 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
AVPacket *avpkt)
{
AVSContext *h = avctx->priv_data;
MpegEncContext *s = &h->s;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
AVFrame *picture = data;
@ -1145,13 +1144,13 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
const uint8_t *buf_end;
const uint8_t *buf_ptr;
s->avctx = avctx;
if (buf_size == 0) {
if (!s->low_delay && h->DPB[0].f.data[0]) {
if (!h->low_delay && h->DPB[0].f->data[0]) {
*got_frame = 1;
*picture = h->DPB[0].f;
memset(&h->DPB[0], 0, sizeof(h->DPB[0]));
*picture = *h->DPB[0].f;
if (h->cur.f->data[0])
avctx->release_buffer(avctx, h->cur.f);
FFSWAP(AVSFrame, h->cur, h->DPB[0]);
}
return 0;
}
@ -1161,19 +1160,19 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
for(;;) {
buf_ptr = avpriv_mpv_find_start_code(buf_ptr, buf_end, &stc);
if ((stc & 0xFFFFFE00) || buf_ptr == buf_end)
return FFMAX(0, buf_ptr - buf - s->parse_context.last_index);
return FFMAX(0, buf_ptr - buf);
input_size = (buf_end - buf_ptr) * 8;
switch (stc) {
case CAVS_START_CODE:
init_get_bits(&s->gb, buf_ptr, input_size);
init_get_bits(&h->gb, buf_ptr, input_size);
decode_seq_header(h);
break;
case PIC_I_START_CODE:
if (!h->got_keyframe) {
if(h->DPB[0].f.data[0])
avctx->release_buffer(avctx, &h->DPB[0].f);
if(h->DPB[1].f.data[0])
avctx->release_buffer(avctx, &h->DPB[1].f);
if(h->DPB[0].f->data[0])
avctx->release_buffer(avctx, h->DPB[0].f);
if(h->DPB[1].f->data[0])
avctx->release_buffer(avctx, h->DPB[1].f);
h->got_keyframe = 1;
}
case PIC_PB_START_CODE:
@ -1182,19 +1181,19 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
break;
if(!h->top_qp)
break;
init_get_bits(&s->gb, buf_ptr, input_size);
init_get_bits(&h->gb, buf_ptr, input_size);
h->stc = stc;
if (decode_pic(h))
break;
*got_frame = 1;
if (h->pic_type != AV_PICTURE_TYPE_B) {
if (h->DPB[1].f.data[0]) {
*picture = h->DPB[1].f;
if (h->DPB[1].f->data[0]) {
*picture = *h->DPB[1].f;
} else {
*got_frame = 0;
}
} else
*picture = h->picture.f;
*picture = *h->cur.f;
break;
case EXT_START_CODE:
//mpeg_decode_extension(avctx, buf_ptr, input_size);
@ -1204,8 +1203,8 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
break;
default:
if (stc <= SLICE_MAX_START_CODE) {
init_get_bits(&s->gb, buf_ptr, input_size);
decode_slice_header(h, &s->gb);
init_get_bits(&h->gb, buf_ptr, input_size);
decode_slice_header(h, &h->gb);
}
break;
}

Write Preview
Loading…
Cancel
Save