falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

Merge commit '7d8482640058d66867602a6f58446c9342d9d146' 

* 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>
tags/n1.1
Michael Niedermayer 12 years ago
parent
6ddda83c3f 7d84826400
commit
ca95d1b32d
3 changed files with 190 additions and 167 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +58
    -47
      libavcodec/cavs.c
  2. +19
    -6
      libavcodec/cavs.h
  3. +113
    -114
      libavcodec/cavsdec.c

+ 58
- 47
libavcodec/cavs.c 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, int chroma_height,int delta,int list,uint8_t *dest_y,
uint8_t *dest_cb,uint8_t *dest_cr,int src_x_offset, uint8_t *dest_cb,uint8_t *dest_cr,int src_x_offset,
int src_y_offset,qpel_mc_func *qpix_op, int src_y_offset,qpel_mc_func *qpix_op,
h264_chroma_mc_func chroma_op,cavs_vector *mv) 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 mx= mv->x + src_x_offset*8;
const int my= mv->y + src_y_offset*8; const int my= mv->y + src_y_offset*8;
const int luma_xy= (mx&3) + ((my&3)<<2); 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 extra_height= extra_width;
int emu=0; int emu=0;
const int full_mx= mx>>2; 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_width = 16*h->mb_width;
const int pic_height = 16*h->mb_height; const int pic_height = 16*h->mb_height;


if(!pic->f.data[0])
if (!pic->data[0])
return; return;
if(mx&7) extra_width -= 3; if(mx&7) extra_width -= 3;
if(my&7) extra_height -= 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_my < 0-extra_height
|| full_mx + 16/*FIXME*/ > pic_width + extra_width || full_mx + 16/*FIXME*/ > pic_width + extra_width
|| full_my + 16/*FIXME*/ > pic_height + extra_height){ || 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); 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; emu=1;
} }


qpix_op[luma_xy](dest_y, src_y, h->l_stride); //FIXME try variable height perhaps? qpix_op[luma_xy](dest_y, src_y, h->l_stride); //FIXME try variable height perhaps?


if(emu){ 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); 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); chroma_op(dest_cb, src_cb, h->c_stride, chroma_height, mx&7, my&7);


if(emu){ 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); 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); 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; y_offset += 8*h->mby;


if(mv->ref >= 0){ 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, mc_dir_part(h, ref, chroma_height, delta, 0,
dest_y, dest_cb, dest_cr, x_offset, y_offset, dest_y, dest_cb, dest_cr, x_offset, y_offset,
qpix_op, chroma_op, mv); 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){ 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, mc_dir_part(h, ref, chroma_height, delta, 1,
dest_y, dest_cb, dest_cr, x_offset, y_offset, dest_y, dest_cb, dest_cr, x_offset, y_offset,
qpix_op, chroma_op, mv+MV_BWD_OFFS); 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 if(ff_cavs_partition_flags[mb_type] == 0){ // 16x16
mc_part_std(h, 8, 0, h->cy, h->cu, h->cv, 0, 0, mc_part_std(h, 8, 0, h->cy, h->cu, h->cv, 0, 0,
h->cdsp.put_cavs_qpel_pixels_tab[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->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{ }else{
mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 0, 0, mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 0, 0,
h->cdsp.put_cavs_qpel_pixels_tab[1], 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->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, mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 4, 0,
h->cdsp.put_cavs_qpel_pixels_tab[1], 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->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, mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 0, 4,
h->cdsp.put_cavs_qpel_pixels_tab[1], 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->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, mc_part_std(h, 4, 0, h->cy, h->cu, h->cv, 4, 4,
h->cdsp.put_cavs_qpel_pixels_tab[1], 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->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); mv_pred_median(h, mvP, mvA, mvB, mvC);


if(mode < MV_PRED_PSKIP) { 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); set_mvs(mvP,size);
} }
@@ -652,9 +651,9 @@ int ff_cavs_next_mb(AVSContext *h) {
h->mbx = 0; h->mbx = 0;
h->mby++; h->mby++;
/* re-calculate sample pointers */ /* 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 if(h->mby == h->mb_height) { //frame end
return 0; return 0;
} }
@@ -669,8 +668,6 @@ int ff_cavs_next_mb(AVSContext *h) {
****************************************************************************/ ****************************************************************************/


int ff_cavs_init_pic(AVSContext *h) { int ff_cavs_init_pic(AVSContext *h) {
MpegEncContext *s = &h->s;
int ret;
int i; int i;


/* clear some predictors */ /* clear some predictors */
@@ -681,22 +678,16 @@ int ff_cavs_init_pic(AVSContext *h) {
h->mv[MV_FWD_X0] = ff_cavs_dir_mv; h->mv[MV_FWD_X0] = ff_cavs_dir_mv;
set_mvs(&h->mv[MV_FWD_X0], BLK_16X16); set_mvs(&h->mv[MV_FWD_X0], BLK_16X16);
h->pred_mode_Y[3] = h->pred_mode_Y[6] = NOT_AVAIL; 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[2] = 8*h->l_stride;
h->luma_scan[3] = 8*h->l_stride+8; h->luma_scan[3] = 8*h->l_stride+8;
h->mbx = h->mby = h->mbidx = 0; h->mbx = h->mby = h->mbidx = 0;
h->flags = 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; return 0;
} }


@@ -729,14 +720,25 @@ void ff_cavs_init_top_lines(AVSContext *h) {


av_cold int ff_cavs_init(AVCodecContext *avctx) { av_cold int ff_cavs_init(AVCodecContext *avctx) {
AVSContext *h = avctx->priv_data; 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); 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; 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[0] = 0;
h->luma_scan[1] = 8; h->luma_scan[1] = 8;
h->intra_pred_l[ INTRA_L_VERT] = intra_pred_vert; 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) { av_cold int ff_cavs_end(AVCodecContext *avctx) {
AVSContext *h = avctx->priv_data; 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_qp);
av_free(h->top_mv[0]); 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_mv);
av_free(h->col_type_base); av_free(h->col_type_base);
av_free(h->block); av_free(h->block);
av_freep(&h->edge_emu_buffer);
return 0; return 0;
} }

+ 19
- 6
libavcodec/cavs.h View File

@@ -22,9 +22,10 @@
#ifndef AVCODEC_CAVS_H #ifndef AVCODEC_CAVS_H
#define AVCODEC_CAVS_H #define AVCODEC_CAVS_H


#include "dsputil.h"
#include "mpegvideo.h"
#include "cavsdsp.h" #include "cavsdsp.h"
#include "dsputil.h"
#include "get_bits.h"
#include "videodsp.h"


#define SLICE_MAX_START_CODE 0x000001af #define SLICE_MAX_START_CODE 0x000001af
#define EXT_START_CODE 0x000001b5 #define EXT_START_CODE 0x000001b5
@@ -152,15 +153,25 @@ struct dec_2dvlc {
int8_t max_run; int8_t max_run;
}; };


typedef struct AVSFrame {
AVFrame *f;
int poc;
} AVSFrame;

typedef struct AVSContext { 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 dist[2]; ///< temporal distances from current frame to ref frames
int low_delay;
int profile, level; int profile, level;
int aspect_ratio; int aspect_ratio;
int mb_width, mb_height; int mb_width, mb_height;
int width, height;
int pic_type; int pic_type;
int stream_revision; ///<0 for samples from 2006, 1 for rm52j encoder int stream_revision; ///<0 for samples from 2006, 1 for rm52j encoder
int progressive; int progressive;
@@ -221,6 +232,8 @@ typedef struct AVSContext {
int direct_den[2]; ///< for scaling in direct B block int direct_den[2]; ///< for scaling in direct B block
int scale_den[2]; ///< for scaling neighbouring MVs int scale_den[2]; ///< for scaling neighbouring MVs


uint8_t *edge_emu_buffer;

int got_keyframe; int got_keyframe;
DCTELEM *block; DCTELEM *block;
} AVSContext; } AVSContext;


+ 113
- 114
libavcodec/cavsdec.c View File

@@ -31,6 +31,8 @@
#include "golomb.h" #include "golomb.h"
#include "cavs.h" #include "cavs.h"
#include "internal.h" #include "internal.h"
#include "mpeg12data.h"
#include "mpegvideo.h"


static const uint8_t mv_scan[4] = { static const uint8_t mv_scan[4] = {
MV_FWD_X0, MV_FWD_X1, 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) { while (--coeff_num >= 0) {
pos += run_buf[coeff_num]; pos += run_buf[coeff_num];
if (pos > 63) { 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", "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; return -1;
} }
dst[scantab[pos]] = (level_buf[coeff_num] * mul + round) >> shift; 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)) dequant_shift[qp], i))
return -1; return -1;
h->cdsp.cavs_idct8_add(dst, block, stride); h->cdsp.cavs_idct8_add(dst, block, stride);
h->s.dsp.clear_block(block);
h->dsp.clear_block(block);
return 0; return 0;
} }


@@ -589,10 +591,10 @@ static int decode_residual_block(AVSContext *h, GetBitContext *gb,
static inline void decode_residual_chroma(AVSContext *h) static inline void decode_residual_chroma(AVSContext *h)
{ {
if (h->cbp & (1 << 4)) 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); cavs_chroma_qp[h->qp], h->cu, h->c_stride);
if (h->cbp & (1 << 5)) 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); cavs_chroma_qp[h->qp], h->cv, h->c_stride);
} }


@@ -601,19 +603,19 @@ static inline int decode_residual_inter(AVSContext *h)
int block; int block;


/* get coded block pattern */ /* get coded block pattern */
int cbp = get_ue_golomb(&h->s.gb);
int cbp = get_ue_golomb(&h->gb);
if (cbp > 63U) { 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; return -1;
} }
h->cbp = cbp_tab[cbp][1]; h->cbp = cbp_tab[cbp][1];


/* get quantizer */ /* get quantizer */
if (h->cbp && !h->qp_fixed) 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++) for (block = 0; block < 4; block++)
if (h->cbp & (1 << 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); h->cy + h->luma_scan[block], h->l_stride);
decode_residual_chroma(h); 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) static int decode_mb_i(AVSContext *h, int cbp_code)
{ {
GetBitContext *gb = &h->s.gb;
GetBitContext *gb = &h->gb;
unsigned pred_mode_uv; unsigned pred_mode_uv;
int block; int block;
uint8_t top[18]; 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); pred_mode_uv = get_ue_golomb(gb);
if (pred_mode_uv > 6) { 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; return -1;
} }
ff_cavs_modify_mb_i(h, &pred_mode_uv); 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) if (h->pic_type == AV_PICTURE_TYPE_I)
cbp_code = get_ue_golomb(gb); cbp_code = get_ue_golomb(gb);
if (cbp_code > 63U) { 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; return -1;
} }
h->cbp = cbp_tab[cbp_code][0]; 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) static void decode_mb_p(AVSContext *h, enum cavs_mb mb_type)
{ {
GetBitContext *gb = &h->s.gb;
GetBitContext *gb = &h->gb;
int ref[4]; int ref[4];


ff_cavs_init_mb(h); ff_cavs_init_mb(h);
@@ -798,7 +800,7 @@ static int decode_mb_b(AVSContext *h, enum cavs_mb mb_type)
break; break;
case B_8X8: case B_8X8:
for (block = 0; block < 4; block++) 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++) { for (block = 0; block < 4; block++) {
switch (sub_type[block]) { switch (sub_type[block]) {
case B_SUB_DIRECT: case B_SUB_DIRECT:
@@ -833,7 +835,7 @@ static int decode_mb_b(AVSContext *h, enum cavs_mb mb_type)
break; break;
default: default:
if (mb_type <= B_SYM_16X16) { 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; return AVERROR_INVALIDDATA;
} }
av_assert2(mb_type < B_8X8); 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) static inline int decode_slice_header(AVSContext *h, GetBitContext *gb)
{ {
if (h->stc > 0xAF) 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) if (h->stc >= h->mb_height)
return -1; return -1;
@@ -902,7 +904,7 @@ static inline int decode_slice_header(AVSContext *h, GetBitContext *gb)
if ((h->pic_type != AV_PICTURE_TYPE_I) || if ((h->pic_type != AV_PICTURE_TYPE_I) ||
(!h->pic_structure && h->mby >= h->mb_width / 2)) (!h->pic_structure && h->mby >= h->mb_width / 2))
if (get_bits1(gb)) { //slice_weighting_flag 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"); "weighted prediction not yet supported\n");
} }
return 0; return 0;
@@ -910,7 +912,7 @@ static inline int decode_slice_header(AVSContext *h, GetBitContext *gb)


static inline int check_for_slice(AVSContext *h) static inline int check_for_slice(AVSContext *h)
{ {
GetBitContext *gb = &h->s.gb;
GetBitContext *gb = &h->gb;
int align; int align;


if (h->mbx) if (h->mbx)
@@ -938,60 +940,60 @@ static inline int check_for_slice(AVSContext *h)


static int decode_pic(AVSContext *h) static int decode_pic(AVSContext *h)
{ {
MpegEncContext *s = &h->s;
int skip_count = -1; int skip_count = -1;
int ret; int ret;
enum cavs_mb mb_type; 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) { 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) { 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; return -1;
} }
/* make sure we have the reference frames we need */ /* 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; return -1;
} else { } else {
h->pic_type = AV_PICTURE_TYPE_I; 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, /* old sample clips were all progressive and no low_delay,
bump stream revision if detected otherwise */ 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; h->stream_revision = 1;
/* similarly test top_field_first and repeat_first_field */ /* 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; h->stream_revision = 1;
if (h->stream_revision > 0) if (h->stream_revision > 0)
skip_bits(&s->gb, 1); //marker_bit
skip_bits(&h->gb, 1); //marker_bit
} }
/* release last B frame */ /* 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; 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) if ((ret = ff_cavs_init_pic(h)) < 0)
return ret; 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 */ /* get temporal distances and MV scaling factors */
if (h->pic_type != AV_PICTURE_TYPE_B) { 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 { } 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[0] = h->dist[0] ? 512/h->dist[0] : 0;
h->scale_den[1] = h->dist[1] ? 512/h->dist[1] : 0; h->scale_den[1] = h->dist[1] ? 512/h->dist[1] : 0;
if (h->pic_type == AV_PICTURE_TYPE_B) { 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; 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; h->pic_structure = 1;
if (!h->progressive) 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) 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->pic_type == AV_PICTURE_TYPE_I) {
if (!h->progressive && !h->pic_structure) 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 { } else {
if (!(h->pic_type == AV_PICTURE_TYPE_B && h->pic_structure == 1)) 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 { } else {
h->alpha_offset = h->beta_offset = 0; h->alpha_offset = h->beta_offset = 0;
} }
@@ -1040,11 +1042,11 @@ static int decode_pic(AVSContext *h)
if (check_for_slice(h)) if (check_for_slice(h))
skip_count = -1; skip_count = -1;
if (h->skip_mode_flag && (skip_count < 0)) 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--) { if (h->skip_mode_flag && skip_count--) {
decode_mb_p(h, P_SKIP); decode_mb_p(h, P_SKIP);
} else { } 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) if (mb_type > P_8X8)
decode_mb_i(h, mb_type - P_8X8 - 1); decode_mb_i(h, mb_type - P_8X8 - 1);
else else
@@ -1056,11 +1058,11 @@ static int decode_pic(AVSContext *h)
if (check_for_slice(h)) if (check_for_slice(h))
skip_count = -1; skip_count = -1;
if (h->skip_mode_flag && (skip_count < 0)) 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--) { if (h->skip_mode_flag && skip_count--) {
decode_mb_b(h, B_SKIP); decode_mb_b(h, B_SKIP);
} else { } 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) if (mb_type > B_8X8)
decode_mb_i(h, mb_type - B_8X8 - 1); decode_mb_i(h, mb_type - B_8X8 - 1);
else else
@@ -1069,11 +1071,10 @@ static int decode_pic(AVSContext *h)
} while (ff_cavs_next_mb(h)); } while (ff_cavs_next_mb(h));
} }
if (h->pic_type != AV_PICTURE_TYPE_B) { 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; return 0;
} }
@@ -1086,41 +1087,40 @@ static int decode_pic(AVSContext *h)


static int decode_seq_header(AVSContext *h) static int decode_seq_header(AVSContext *h)
{ {
MpegEncContext *s = &h->s;
int frame_rate_code; int frame_rate_code;
int width, height; 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; return AVERROR_PATCHWELCOME;
} }
if (width <= 0 || height <= 0) { 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; 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) if (!h->top_qp)
ff_cavs_init_top_lines(h); ff_cavs_init_top_lines(h);
return 0; return 0;
@@ -1136,7 +1136,6 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
AVPacket *avpkt) AVPacket *avpkt)
{ {
AVSContext *h = avctx->priv_data; AVSContext *h = avctx->priv_data;
MpegEncContext *s = &h->s;
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
AVFrame *picture = data; 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_end;
const uint8_t *buf_ptr; const uint8_t *buf_ptr;


s->avctx = avctx;

if (buf_size == 0) { 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; *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; return 0;
} }
@@ -1161,19 +1160,19 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
for(;;) { for(;;) {
buf_ptr = avpriv_mpv_find_start_code(buf_ptr, buf_end, &stc); buf_ptr = avpriv_mpv_find_start_code(buf_ptr, buf_end, &stc);
if ((stc & 0xFFFFFE00) || buf_ptr == buf_end) 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; input_size = (buf_end - buf_ptr) * 8;
switch (stc) { switch (stc) {
case CAVS_START_CODE: 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); decode_seq_header(h);
break; break;
case PIC_I_START_CODE: case PIC_I_START_CODE:
if (!h->got_keyframe) { 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; h->got_keyframe = 1;
} }
case PIC_PB_START_CODE: case PIC_PB_START_CODE:
@@ -1182,19 +1181,19 @@ static int cavs_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
break; break;
if(!h->top_qp) if(!h->top_qp)
break; break;
init_get_bits(&s->gb, buf_ptr, input_size);
init_get_bits(&h->gb, buf_ptr, input_size);
h->stc = stc; h->stc = stc;
if (decode_pic(h)) if (decode_pic(h))
break; break;
*got_frame = 1; *got_frame = 1;
if (h->pic_type != AV_PICTURE_TYPE_B) { 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 { } else {
*got_frame = 0; *got_frame = 0;
} }
} else } else
*picture = h->picture.f;
*picture = *h->cur.f;
break; break;
case EXT_START_CODE: case EXT_START_CODE:
//mpeg_decode_extension(avctx, buf_ptr, input_size); //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; break;
default: default:
if (stc <= SLICE_MAX_START_CODE) { 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; break;
} }


Write Preview
Loading…
Cancel
Save