Chiebot-Mirror
/
FFmpeg
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

lavc/vp9: rename ctx to avctx

Browse Source 
This reduces diff with Libav. It also prevents a potential confusion
between the private context and the AVCodecContext.
pull/131/merge
Clément Bœsch 8 years ago
parent 1c9f4b5078
commit 12c44d6373
3 changed files with 176 additions and 176 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. 282
      libavcodec/vp9.c
  2. 4
      libavcodec/vp9_mc_template.c
  3. 66
      libavcodec/vp9block.c

282
libavcodec/vp9.c
Unescape View File

@ -36,21 +36,21 @@
#define VP9_SYNCCODE 0x498342
static void vp9_unref_frame(AVCodecContext *ctx, VP9Frame *f)
static void vp9_unref_frame(AVCodecContext *avctx, VP9Frame *f)
{
ff_thread_release_buffer(ctx, &f->tf);
ff_thread_release_buffer(avctx, &f->tf);
av_buffer_unref(&f->extradata);
av_buffer_unref(&f->hwaccel_priv_buf);
f->segmentation_map = NULL;
f->hwaccel_picture_private = NULL;
}
static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
static int vp9_alloc_frame(AVCodecContext *avctx, VP9Frame *f)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
int ret, sz;
if ((ret = ff_thread_get_buffer(ctx, &f->tf, AV_GET_BUFFER_FLAG_REF)) < 0)
if ((ret = ff_thread_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF)) < 0)
return ret;
sz = 64 * s->sb_cols * s->sb_rows;
if (!(f->extradata = av_buffer_allocz(sz * (1 + sizeof(struct VP9mvrefPair))))) {
@ -60,8 +60,8 @@ static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
f->segmentation_map = f->extradata->data;
f->mv = (struct VP9mvrefPair *) (f->extradata->data + sz);
if (ctx->hwaccel) {
const AVHWAccel *hwaccel = ctx->hwaccel;
if (avctx->hwaccel) {
const AVHWAccel *hwaccel = avctx->hwaccel;
av_assert0(!f->hwaccel_picture_private);
if (hwaccel->frame_priv_data_size) {
f->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
@ -74,11 +74,11 @@ static int vp9_alloc_frame(AVCodecContext *ctx, VP9Frame *f)
return 0;
fail:
vp9_unref_frame(ctx, f);
vp9_unref_frame(avctx, f);
return AVERROR(ENOMEM);
}
static int vp9_ref_frame(AVCodecContext *ctx, VP9Frame *dst, VP9Frame *src)
static int vp9_ref_frame(AVCodecContext *avctx, VP9Frame *dst, VP9Frame *src)
{
int res;
@ -102,22 +102,22 @@ static int vp9_ref_frame(AVCodecContext *ctx, VP9Frame *dst, VP9Frame *src)
return 0;
fail:
vp9_unref_frame(ctx, dst);
vp9_unref_frame(avctx, dst);
return AVERROR(ENOMEM);
}
static int update_size(AVCodecContext *ctx, int w, int h)
static int update_size(AVCodecContext *avctx, int w, int h)
{
#define HWACCEL_MAX (CONFIG_VP9_DXVA2_HWACCEL + CONFIG_VP9_D3D11VA_HWACCEL + CONFIG_VP9_VAAPI_HWACCEL)
enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
uint8_t *p;
int bytesperpixel = s->bytesperpixel, res, cols, rows;
av_assert0(w > 0 && h > 0);
if (!(s->pix_fmt == s->gf_fmt && w == s->w && h == s->h)) {
if ((res = ff_set_dimensions(ctx, w, h)) < 0)
if ((res = ff_set_dimensions(avctx, w, h)) < 0)
return res;
switch (s->pix_fmt) {
@ -143,11 +143,11 @@ static int update_size(AVCodecContext *ctx, int w, int h)
*fmtp++ = s->pix_fmt;
*fmtp = AV_PIX_FMT_NONE;
res = ff_thread_get_format(ctx, pix_fmts);
res = ff_thread_get_format(avctx, pix_fmts);
if (res < 0)
return res;
ctx->pix_fmt = res;
avctx->pix_fmt = res;
s->gf_fmt = s->pix_fmt;
s->w = w;
s->h = h;
@ -197,7 +197,7 @@ static int update_size(AVCodecContext *ctx, int w, int h)
av_freep(&s->block_base);
if (s->s.h.bpp != s->last_bpp) {
ff_vp9dsp_init(&s->dsp, s->s.h.bpp, ctx->flags & AV_CODEC_FLAG_BITEXACT);
ff_vp9dsp_init(&s->dsp, s->s.h.bpp, avctx->flags & AV_CODEC_FLAG_BITEXACT);
ff_videodsp_init(&s->vdsp, s->s.h.bpp);
s->last_bpp = s->s.h.bpp;
}
@ -205,9 +205,9 @@ static int update_size(AVCodecContext *ctx, int w, int h)
return 0;
}
static int update_block_buffers(AVCodecContext *ctx)
static int update_block_buffers(AVCodecContext *avctx)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
int chroma_blocks, chroma_eobs, bytesperpixel = s->bytesperpixel;
if (s->b_base && s->block_base && s->block_alloc_using_2pass == s->s.frames[CUR_FRAME].uses_2pass)
@ -318,34 +318,34 @@ static int update_prob(VP56RangeCoder *c, int p)
255 - inv_recenter_nonneg(inv_map_table[d], 255 - p);
}
static int read_colorspace_details(AVCodecContext *ctx)
static int read_colorspace_details(AVCodecContext *avctx)
{
static const enum AVColorSpace colorspaces[8] = {
AVCOL_SPC_UNSPECIFIED, AVCOL_SPC_BT470BG, AVCOL_SPC_BT709, AVCOL_SPC_SMPTE170M,
AVCOL_SPC_SMPTE240M, AVCOL_SPC_BT2020_NCL, AVCOL_SPC_RESERVED, AVCOL_SPC_RGB,
};
VP9Context *s = ctx->priv_data;
int bits = ctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
VP9Context *s = avctx->priv_data;
int bits = avctx->profile <= 1 ? 0 : 1 + get_bits1(&s->gb); // 0:8, 1:10, 2:12
s->bpp_index = bits;
s->s.h.bpp = 8 + bits * 2;
s->bytesperpixel = (7 + s->s.h.bpp) >> 3;
ctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
if (ctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
avctx->colorspace = colorspaces[get_bits(&s->gb, 3)];
if (avctx->colorspace == AVCOL_SPC_RGB) { // RGB = profile 1
static const enum AVPixelFormat pix_fmt_rgb[3] = {
AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12
};
s->ss_h = s->ss_v = 0;
ctx->color_range = AVCOL_RANGE_JPEG;
avctx->color_range = AVCOL_RANGE_JPEG;
s->pix_fmt = pix_fmt_rgb[bits];
if (ctx->profile & 1) {
if (avctx->profile & 1) {
if (get_bits1(&s->gb)) {
av_log(ctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
av_log(avctx, AV_LOG_ERROR, "Reserved bit set in RGB\n");
return AVERROR_INVALIDDATA;
}
} else {
av_log(ctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
ctx->profile);
av_log(avctx, AV_LOG_ERROR, "RGB not supported in profile %d\n",
avctx->profile);
return AVERROR_INVALIDDATA;
}
} else {
@ -357,18 +357,18 @@ static int read_colorspace_details(AVCodecContext *ctx)
{ { AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12 },
{ AV_PIX_FMT_YUV440P12, AV_PIX_FMT_YUV420P12 } }
};
ctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
if (ctx->profile & 1) {
avctx->color_range = get_bits1(&s->gb) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
if (avctx->profile & 1) {
s->ss_h = get_bits1(&s->gb);
s->ss_v = get_bits1(&s->gb);
s->pix_fmt = pix_fmt_for_ss[bits][s->ss_v][s->ss_h];
if (s->pix_fmt == AV_PIX_FMT_YUV420P) {
av_log(ctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
ctx->profile);
av_log(avctx, AV_LOG_ERROR, "YUV 4:2:0 not supported in profile %d\n",
avctx->profile);
return AVERROR_INVALIDDATA;
} else if (get_bits1(&s->gb)) {
av_log(ctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
ctx->profile);
av_log(avctx, AV_LOG_ERROR, "Profile %d color details reserved bit set\n",
avctx->profile);
return AVERROR_INVALIDDATA;
}
} else {
@ -380,31 +380,31 @@ static int read_colorspace_details(AVCodecContext *ctx)
return 0;
}
static int decode_frame_header(AVCodecContext *ctx,
static int decode_frame_header(AVCodecContext *avctx,
const uint8_t *data, int size, int *ref)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
int c, i, j, k, l, m, n, w, h, max, size2, res, sharp;
int last_invisible;
const uint8_t *data2;
/* general header */
if ((res = init_get_bits8(&s->gb, data, size)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
av_log(avctx, AV_LOG_ERROR, "Failed to initialize bitstream reader\n");
return res;
}
if (get_bits(&s->gb, 2) != 0x2) { // frame marker
av_log(ctx, AV_LOG_ERROR, "Invalid frame marker\n");
av_log(avctx, AV_LOG_ERROR, "Invalid frame marker\n");
return AVERROR_INVALIDDATA;
}
ctx->profile = get_bits1(&s->gb);
ctx->profile |= get_bits1(&s->gb) << 1;
if (ctx->profile == 3) ctx->profile += get_bits1(&s->gb);
if (ctx->profile > 3) {
av_log(ctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", ctx->profile);
avctx->profile = get_bits1(&s->gb);
avctx->profile |= get_bits1(&s->gb) << 1;
if (avctx->profile == 3) avctx->profile += get_bits1(&s->gb);
if (avctx->profile > 3) {
av_log(avctx, AV_LOG_ERROR, "Profile %d is not yet supported\n", avctx->profile);
return AVERROR_INVALIDDATA;
}
s->s.h.profile = ctx->profile;
s->s.h.profile = avctx->profile;
if (get_bits1(&s->gb)) {
*ref = get_bits(&s->gb, 3);
return 0;
@ -417,10 +417,10 @@ static int decode_frame_header(AVCodecContext *ctx,
s->s.h.use_last_frame_mvs = !s->s.h.errorres && !last_invisible;
if (s->s.h.keyframe) {
if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");
av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
return AVERROR_INVALIDDATA;
}
if ((res = read_colorspace_details(ctx)) < 0)
if ((res = read_colorspace_details(avctx)) < 0)
return res;
// for profile 1, here follows the subsampling bits
s->s.h.refreshrefmask = 0xff;
@ -433,11 +433,11 @@ static int decode_frame_header(AVCodecContext *ctx,
s->s.h.resetctx = s->s.h.errorres ? 0 : get_bits(&s->gb, 2);
if (s->s.h.intraonly) {
if (get_bits_long(&s->gb, 24) != VP9_SYNCCODE) { // synccode
av_log(ctx, AV_LOG_ERROR, "Invalid sync code\n");
av_log(avctx, AV_LOG_ERROR, "Invalid sync code\n");
return AVERROR_INVALIDDATA;
}
if (ctx->profile >= 1) {
if ((res = read_colorspace_details(ctx)) < 0)
if (avctx->profile >= 1) {
if ((res = read_colorspace_details(avctx)) < 0)
return res;
} else {
s->ss_h = s->ss_v = 1;
@ -445,8 +445,8 @@ static int decode_frame_header(AVCodecContext *ctx,
s->bpp_index = 0;
s->bytesperpixel = 1;
s->pix_fmt = AV_PIX_FMT_YUV420P;
ctx->colorspace = AVCOL_SPC_BT470BG;
ctx->color_range = AVCOL_RANGE_JPEG;
avctx->colorspace = AVCOL_SPC_BT470BG;
avctx->color_range = AVCOL_RANGE_JPEG;
}
s->s.h.refreshrefmask = get_bits(&s->gb, 8);
w = get_bits(&s->gb, 16) + 1;
@ -464,7 +464,7 @@ static int decode_frame_header(AVCodecContext *ctx,
if (!s->s.refs[s->s.h.refidx[0]].f->buf[0] ||
!s->s.refs[s->s.h.refidx[1]].f->buf[0] ||
!s->s.refs[s->s.h.refidx[2]].f->buf[0]) {
av_log(ctx, AV_LOG_ERROR, "Not all references are available\n");
av_log(avctx, AV_LOG_ERROR, "Not all references are available\n");
return AVERROR_INVALIDDATA;
}
if (get_bits1(&s->gb)) {
@ -552,7 +552,7 @@ static int decode_frame_header(AVCodecContext *ctx,
s->s.h.lossless = s->s.h.yac_qi == 0 && s->s.h.ydc_qdelta == 0 &&
s->s.h.uvdc_qdelta == 0 && s->s.h.uvac_qdelta == 0;
if (s->s.h.lossless)
ctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
/* segmentation header info */
if ((s->s.h.segmentation.enabled = get_bits1(&s->gb))) {
@ -631,8 +631,8 @@ static int decode_frame_header(AVCodecContext *ctx,
}
/* tiling info */
if ((res = update_size(ctx, w, h)) < 0) {
av_log(ctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
if ((res = update_size(avctx, w, h)) < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to initialize decoder for %dx%d @ %d\n",
w, h, s->pix_fmt);
return res;
}
@ -654,7 +654,7 @@ static int decode_frame_header(AVCodecContext *ctx,
s->c_b = av_fast_realloc(s->c_b, &s->c_b_size,
sizeof(VP56RangeCoder) * s->s.h.tiling.tile_cols);
if (!s->c_b) {
av_log(ctx, AV_LOG_ERROR, "Ran out of memory during range coder init\n");
av_log(avctx, AV_LOG_ERROR, "Ran out of memory during range coder init\n");
return AVERROR(ENOMEM);
}
}
@ -665,17 +665,17 @@ static int decode_frame_header(AVCodecContext *ctx,
AVFrame *ref = s->s.refs[s->s.h.refidx[i]].f;
int refw = ref->width, refh = ref->height;
if (ref->format != ctx->pix_fmt) {
av_log(ctx, AV_LOG_ERROR,
if (ref->format != avctx->pix_fmt) {
av_log(avctx, AV_LOG_ERROR,
"Ref pixfmt (%s) did not match current frame (%s)",
av_get_pix_fmt_name(ref->format),
av_get_pix_fmt_name(ctx->pix_fmt));
av_get_pix_fmt_name(avctx->pix_fmt));
return AVERROR_INVALIDDATA;
} else if (refw == w && refh == h) {
s->mvscale[i][0] = s->mvscale[i][1] = 0;
} else {
if (w * 2 < refw || h * 2 < refh || w > 16 * refw || h > 16 * refh) {
av_log(ctx, AV_LOG_ERROR,
av_log(avctx, AV_LOG_ERROR,
"Invalid ref frame dimensions %dx%d for frame size %dx%d\n",
refw, refh, w, h);
return AVERROR_INVALIDDATA;
@ -711,7 +711,7 @@ static int decode_frame_header(AVCodecContext *ctx,
data2 = align_get_bits(&s->gb);
if (size2 > size - (data2 - data)) {
av_log(ctx, AV_LOG_ERROR, "Invalid compressed header size\n");
av_log(avctx, AV_LOG_ERROR, "Invalid compressed header size\n");
return AVERROR_INVALIDDATA;
}
res = ff_vp56_init_range_decoder(&s->c, data2, size2);
@ -719,7 +719,7 @@ static int decode_frame_header(AVCodecContext *ctx,
return res;
if (vp56_rac_get_prob_branchy(&s->c, 128)) { // marker bit
av_log(ctx, AV_LOG_ERROR, "Marker bit was set\n");
av_log(avctx, AV_LOG_ERROR, "Marker bit was set\n");
return AVERROR_INVALIDDATA;
}
@ -915,10 +915,10 @@ static int decode_frame_header(AVCodecContext *ctx,
return (data2 - data) + size2;
}
static void decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
static void decode_sb(AVCodecContext *avctx, int row, int col, struct VP9Filter *lflvl,
ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
int c = ((s->above_partition_ctx[col] >> (3 - bl)) & 1) |
(((s->left_partition_ctx[row & 0x7] >> (3 - bl)) & 1) << 1);
const uint8_t *p = s->s.h.keyframe || s->s.h.intraonly ? ff_vp9_default_kf_partition_probs[bl][c] :
@ -931,35 +931,35 @@ static void decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *l
if (bl == BL_8X8) {
bp = vp8_rac_get_tree(&s->c, ff_vp9_partition_tree, p);
ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
} else if (col + hbs < s->cols) { // FIXME why not <=?
if (row + hbs < s->rows) { // FIXME why not <=?
bp = vp8_rac_get_tree(&s->c, ff_vp9_partition_tree, p);
switch (bp) {
case PARTITION_NONE:
ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
break;
case PARTITION_H:
ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
yoff += hbs * 8 * y_stride;
uvoff += hbs * 8 * uv_stride >> s->ss_v;
ff_vp9_decode_block(ctx, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
ff_vp9_decode_block(avctx, row + hbs, col, lflvl, yoff, uvoff, bl, bp);
break;
case PARTITION_V:
ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
yoff += hbs * 8 * bytesperpixel;
uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
ff_vp9_decode_block(ctx, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
ff_vp9_decode_block(avctx, row, col + hbs, lflvl, yoff, uvoff, bl, bp);
break;
case PARTITION_SPLIT:
decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
decode_sb(ctx, row, col + hbs, lflvl,
decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
decode_sb(avctx, row, col + hbs, lflvl,
yoff + 8 * hbs * bytesperpixel,
uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
yoff += hbs * 8 * y_stride;
uvoff += hbs * 8 * uv_stride >> s->ss_v;
decode_sb(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
decode_sb(ctx, row + hbs, col + hbs, lflvl,
decode_sb(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
decode_sb(avctx, row + hbs, col + hbs, lflvl,
yoff + 8 * hbs * bytesperpixel,
uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
break;
@ -968,36 +968,36 @@ static void decode_sb(AVCodecContext *ctx, int row, int col, struct VP9Filter *l
}
} else if (vp56_rac_get_prob_branchy(&s->c, p[1])) {
bp = PARTITION_SPLIT;
decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
decode_sb(ctx, row, col + hbs, lflvl,
decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
decode_sb(avctx, row, col + hbs, lflvl,
yoff + 8 * hbs * bytesperpixel,
uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
} else {
bp = PARTITION_H;
ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
}
} else if (row + hbs < s->rows) { // FIXME why not <=?
if (vp56_rac_get_prob_branchy(&s->c, p[2])) {
bp = PARTITION_SPLIT;
decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
yoff += hbs * 8 * y_stride;
uvoff += hbs * 8 * uv_stride >> s->ss_v;
decode_sb(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
decode_sb(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
} else {
bp = PARTITION_V;
ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, bl, bp);
ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, bl, bp);
}
} else {
bp = PARTITION_SPLIT;
decode_sb(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
decode_sb(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
}
s->counts.partition[bl][c][bp]++;
}
static void decode_sb_mem(AVCodecContext *ctx, int row, int col, struct VP9Filter *lflvl,
static void decode_sb_mem(AVCodecContext *avctx, int row, int col, struct VP9Filter *lflvl,
ptrdiff_t yoff, ptrdiff_t uvoff, enum BlockLevel bl)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
VP9Block *b = s->b;
ptrdiff_t hbs = 4 >> bl;
AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
@ -1006,39 +1006,39 @@ static void decode_sb_mem(AVCodecContext *ctx, int row, int col, struct VP9Filte
if (bl == BL_8X8) {
av_assert2(b->bl == BL_8X8);
ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
} else if (s->b->bl == bl) {
ff_vp9_decode_block(ctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
ff_vp9_decode_block(avctx, row, col, lflvl, yoff, uvoff, b->bl, b->bp);
if (b->bp == PARTITION_H && row + hbs < s->rows) {
yoff += hbs * 8 * y_stride;
uvoff += hbs * 8 * uv_stride >> s->ss_v;
ff_vp9_decode_block(ctx, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
ff_vp9_decode_block(avctx, row + hbs, col, lflvl, yoff, uvoff, b->bl, b->bp);
} else if (b->bp == PARTITION_V && col + hbs < s->cols) {
yoff += hbs * 8 * bytesperpixel;
uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
ff_vp9_decode_block(ctx, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
ff_vp9_decode_block(avctx, row, col + hbs, lflvl, yoff, uvoff, b->bl, b->bp);
}
} else {
decode_sb_mem(ctx, row, col, lflvl, yoff, uvoff, bl + 1);
decode_sb_mem(avctx, row, col, lflvl, yoff, uvoff, bl + 1);
if (col + hbs < s->cols) { // FIXME why not <=?
if (row + hbs < s->rows) {
decode_sb_mem(ctx, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
decode_sb_mem(avctx, row, col + hbs, lflvl, yoff + 8 * hbs * bytesperpixel,
uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
yoff += hbs * 8 * y_stride;
uvoff += hbs * 8 * uv_stride >> s->ss_v;
decode_sb_mem(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
decode_sb_mem(ctx, row + hbs, col + hbs, lflvl,
decode_sb_mem(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
decode_sb_mem(avctx, row + hbs, col + hbs, lflvl,
yoff + 8 * hbs * bytesperpixel,
uvoff + (8 * hbs * bytesperpixel >> s->ss_h), bl + 1);
} else {
yoff += hbs * 8 * bytesperpixel;
uvoff += hbs * 8 * bytesperpixel >> s->ss_h;
decode_sb_mem(ctx, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
decode_sb_mem(avctx, row, col + hbs, lflvl, yoff, uvoff, bl + 1);
}
} else if (row + hbs < s->rows) {
yoff += hbs * 8 * y_stride;
uvoff += hbs * 8 * uv_stride >> s->ss_v;
decode_sb_mem(ctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
decode_sb_mem(avctx, row + hbs, col, lflvl, yoff, uvoff, bl + 1);
}
}
}
@ -1195,10 +1195,10 @@ static av_always_inline void filter_plane_rows(VP9Context *s, int row, int ss_h,
}
}
static void loopfilter_sb(AVCodecContext *ctx, struct VP9Filter *lflvl,
static void loopfilter_sb(AVCodecContext *avctx, struct VP9Filter *lflvl,
int row, int col, ptrdiff_t yoff, ptrdiff_t uvoff)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
AVFrame *f = s->s.frames[CUR_FRAME].tf.f;
uint8_t *dst = f->data[0] + yoff;
ptrdiff_t ls_y = f->linesize[0], ls_uv = f->linesize[1];
@ -1236,22 +1236,22 @@ static void free_buffers(VP9Context *s)
av_freep(&s->block_base);
}
static av_cold int vp9_decode_free(AVCodecContext *ctx)
static av_cold int vp9_decode_free(AVCodecContext *avctx)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
int i;
for (i = 0; i < 3; i++) {
if (s->s.frames[i].tf.f->buf[0])
vp9_unref_frame(ctx, &s->s.frames[i]);
vp9_unref_frame(avctx, &s->s.frames[i]);
av_frame_free(&s->s.frames[i].tf.f);
}
for (i = 0; i < 8; i++) {
if (s->s.refs[i].f->buf[0])
ff_thread_release_buffer(ctx, &s->s.refs[i]);
ff_thread_release_buffer(avctx, &s->s.refs[i]);
av_frame_free(&s->s.refs[i].f);
if (s->next_refs[i].f->buf[0])
ff_thread_release_buffer(ctx, &s->next_refs[i]);
ff_thread_release_buffer(avctx, &s->next_refs[i]);
av_frame_free(&s->next_refs[i].f);
}
free_buffers(s);
@ -1262,12 +1262,12 @@ static av_cold int vp9_decode_free(AVCodecContext *ctx)
}
static int vp9_decode_frame(AVCodecContext *ctx, void *frame,
static int vp9_decode_frame(AVCodecContext *avctx, void *frame,
int *got_frame, AVPacket *pkt)
{
const uint8_t *data = pkt->data;
int size = pkt->size;
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
int res, tile_row, tile_col, i, ref, row, col;
int retain_segmap_ref = s->s.frames[REF_FRAME_SEGMAP].segmentation_map &&
(!s->s.h.segmentation.enabled || !s->s.h.segmentation.update_map);
@ -1275,11 +1275,11 @@ static int vp9_decode_frame(AVCodecContext *ctx, void *frame,
AVFrame *f;
int bytesperpixel;
if ((res = decode_frame_header(ctx, data, size, &ref)) < 0) {
if ((res = decode_frame_header(avctx, data, size, &ref)) < 0) {
return res;
} else if (res == 0) {
if (!s->s.refs[ref].f->buf[0]) {
av_log(ctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
av_log(avctx, AV_LOG_ERROR, "Requested reference %d not available\n", ref);
return AVERROR_INVALIDDATA;
}
if ((res = av_frame_ref(frame, s->s.refs[ref].f)) < 0)
@ -1293,7 +1293,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
((AVFrame *)frame)->pkt_dts = pkt->dts;
for (i = 0; i < 8; i++) {
if (s->next_refs[i].f->buf[0])
ff_thread_release_buffer(ctx, &s->next_refs[i]);
ff_thread_release_buffer(avctx, &s->next_refs[i]);
if (s->s.refs[i].f->buf[0] &&
(res = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0)
return res;
@ -1306,19 +1306,19 @@ FF_ENABLE_DEPRECATION_WARNINGS
if (!retain_segmap_ref || s->s.h.keyframe || s->s.h.intraonly) {
if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0])
vp9_unref_frame(ctx, &s->s.frames[REF_FRAME_SEGMAP]);
vp9_unref_frame(avctx, &s->s.frames[REF_FRAME_SEGMAP]);
if (!s->s.h.keyframe && !s->s.h.intraonly && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
(res = vp9_ref_frame(ctx, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)
(res = vp9_ref_frame(avctx, &s->s.frames[REF_FRAME_SEGMAP], &s->s.frames[CUR_FRAME])) < 0)
return res;
}
if (s->s.frames[REF_FRAME_MVPAIR].tf.f->buf[0])
vp9_unref_frame(ctx, &s->s.frames[REF_FRAME_MVPAIR]);
vp9_unref_frame(avctx, &s->s.frames[REF_FRAME_MVPAIR]);
if (!s->s.h.intraonly && !s->s.h.keyframe && !s->s.h.errorres && s->s.frames[CUR_FRAME].tf.f->buf[0] &&
(res = vp9_ref_frame(ctx, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)
(res = vp9_ref_frame(avctx, &s->s.frames[REF_FRAME_MVPAIR], &s->s.frames[CUR_FRAME])) < 0)
return res;
if (s->s.frames[CUR_FRAME].tf.f->buf[0])
vp9_unref_frame(ctx, &s->s.frames[CUR_FRAME]);
if ((res = vp9_alloc_frame(ctx, &s->s.frames[CUR_FRAME])) < 0)
vp9_unref_frame(avctx, &s->s.frames[CUR_FRAME]);
if ((res = vp9_alloc_frame(avctx, &s->s.frames[CUR_FRAME])) < 0)
return res;
f = s->s.frames[CUR_FRAME].tf.f;
f->key_frame = s->s.h.keyframe;
@ -1329,13 +1329,13 @@ FF_ENABLE_DEPRECATION_WARNINGS
if (s->s.frames[REF_FRAME_SEGMAP].tf.f->buf[0] &&
(s->s.frames[REF_FRAME_MVPAIR].tf.f->width != s->s.frames[CUR_FRAME].tf.f->width ||
s->s.frames[REF_FRAME_MVPAIR].tf.f->height != s->s.frames[CUR_FRAME].tf.f->height)) {
vp9_unref_frame(ctx, &s->s.frames[REF_FRAME_SEGMAP]);
vp9_unref_frame(avctx, &s->s.frames[REF_FRAME_SEGMAP]);
}
// ref frame setup
for (i = 0; i < 8; i++) {
if (s->next_refs[i].f->buf[0])
ff_thread_release_buffer(ctx, &s->next_refs[i]);
ff_thread_release_buffer(avctx, &s->next_refs[i]);
if (s->s.h.refreshrefmask & (1 << i)) {
res = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf);
} else if (s->s.refs[i].f->buf[0]) {
@ -1345,14 +1345,14 @@ FF_ENABLE_DEPRECATION_WARNINGS
return res;
}
if (ctx->hwaccel) {
res = ctx->hwaccel->start_frame(ctx, NULL, 0);
if (avctx->hwaccel) {
res = avctx->hwaccel->start_frame(avctx, NULL, 0);
if (res < 0)
return res;
res = ctx->hwaccel->decode_slice(ctx, pkt->data, pkt->size);
res = avctx->hwaccel->decode_slice(avctx, pkt->data, pkt->size);
if (res < 0)
return res;
res = ctx->hwaccel->end_frame(ctx);
res = avctx->hwaccel->end_frame(avctx);
if (res < 0)
return res;
goto finish;
@ -1372,9 +1372,9 @@ FF_ENABLE_DEPRECATION_WARNINGS
memset(s->above_uv_nnz_ctx[1], 0, s->sb_cols * 16 >> s->ss_h);
memset(s->above_segpred_ctx, 0, s->cols);
s->pass = s->s.frames[CUR_FRAME].uses_2pass =
ctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;
if ((res = update_block_buffers(ctx)) < 0) {
av_log(ctx, AV_LOG_ERROR,
avctx->active_thread_type == FF_THREAD_FRAME && s->s.h.refreshctx && !s->s.h.parallelmode;
if ((res = update_block_buffers(avctx)) < 0) {
av_log(avctx, AV_LOG_ERROR,
"Failed to allocate block buffers\n");
return res;
}
@ -1392,9 +1392,9 @@ FF_ENABLE_DEPRECATION_WARNINGS
break;
}
s->prob_ctx[s->s.h.framectxid].p = s->prob.p;
ff_thread_finish_setup(ctx);
ff_thread_finish_setup(avctx);
} else if (!s->s.h.refreshctx) {
ff_thread_finish_setup(ctx);
ff_thread_finish_setup(avctx);
}
do {
@ -1473,10 +1473,10 @@ FF_ENABLE_DEPRECATION_WARNINGS
}
if (s->pass == 2) {
decode_sb_mem(ctx, row, col, lflvl_ptr,
decode_sb_mem(avctx, row, col, lflvl_ptr,
yoff2, uvoff2, BL_64X64);
} else {
decode_sb(ctx, row, col, lflvl_ptr,
decode_sb(avctx, row, col, lflvl_ptr,
yoff2, uvoff2, BL_64X64);
}
}
@ -1511,7 +1511,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
for (col = 0; col < s->cols;
col += 8, yoff2 += 64 * bytesperpixel,
uvoff2 += 64 * bytesperpixel >> s->ss_h, lflvl_ptr++) {
loopfilter_sb(ctx, lflvl_ptr, row, col, yoff2, uvoff2);
loopfilter_sb(avctx, lflvl_ptr, row, col, yoff2, uvoff2);
}
}
@ -1524,7 +1524,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
if (s->pass < 2 && s->s.h.refreshctx && !s->s.h.parallelmode) {
ff_vp9_adapt_probs(s);
ff_thread_finish_setup(ctx);
ff_thread_finish_setup(avctx);
}
} while (s->pass++ == 1);
ff_thread_report_progress(&s->s.frames[CUR_FRAME].tf, INT_MAX, 0);
@ -1533,7 +1533,7 @@ finish:
// ref frame setup
for (i = 0; i < 8; i++) {
if (s->s.refs[i].f->buf[0])
ff_thread_release_buffer(ctx, &s->s.refs[i]);
ff_thread_release_buffer(avctx, &s->s.refs[i]);
if (s->next_refs[i].f->buf[0] &&
(res = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0)
return res;
@ -1548,27 +1548,27 @@ finish:
return pkt->size;
}
static void vp9_decode_flush(AVCodecContext *ctx)
static void vp9_decode_flush(AVCodecContext *avctx)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
int i;
for (i = 0; i < 3; i++)
vp9_unref_frame(ctx, &s->s.frames[i]);
vp9_unref_frame(avctx, &s->s.frames[i]);
for (i = 0; i < 8; i++)
ff_thread_release_buffer(ctx, &s->s.refs[i]);
ff_thread_release_buffer(avctx, &s->s.refs[i]);
}
static int init_frames(AVCodecContext *ctx)
static int init_frames(AVCodecContext *avctx)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
int i;
for (i = 0; i < 3; i++) {
s->s.frames[i].tf.f = av_frame_alloc();
if (!s->s.frames[i].tf.f) {
vp9_decode_free(ctx);
av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
vp9_decode_free(avctx);
av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
return AVERROR(ENOMEM);
}
}
@ -1576,8 +1576,8 @@ static int init_frames(AVCodecContext *ctx)
s->s.refs[i].f = av_frame_alloc();
s->next_refs[i].f = av_frame_alloc();
if (!s->s.refs[i].f || !s->next_refs[i].f) {
vp9_decode_free(ctx);
av_log(ctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
vp9_decode_free(avctx);
av_log(avctx, AV_LOG_ERROR, "Failed to allocate frame buffer %d\n", i);
return AVERROR(ENOMEM);
}
}
@ -1585,15 +1585,15 @@ static int init_frames(AVCodecContext *ctx)
return 0;
}
static av_cold int vp9_decode_init(AVCodecContext *ctx)
static av_cold int vp9_decode_init(AVCodecContext *avctx)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
ctx->internal->allocate_progress = 1;
avctx->internal->allocate_progress = 1;
s->last_bpp = 0;
s->s.h.filter.sharpness = -1;
return init_frames(ctx);
return init_frames(avctx);
}
#if HAVE_THREADS

4
libavcodec/vp9_mc_template.c
Unescape View File

@ -27,13 +27,13 @@
(VP56mv) { .x = ROUNDED_DIV(a.x + b.x + c.x + d.x, 4), \
.y = ROUNDED_DIV(a.y + b.y + c.y + d.y, 4) }
static void FN(inter_pred)(AVCodecContext *ctx)
static void FN(inter_pred)(AVCodecContext *avctx)
{
static const uint8_t bwlog_tab[2][N_BS_SIZES] = {
{ 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 },
{ 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4 },
};
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
VP9Block *b = s->b;
int row = s->row, col = s->col;
ThreadFrame *tref1 = &s->s.refs[s->s.h.refidx[b->ref[0]]], *tref2;

66
libavcodec/vp9block.c
Unescape View File

@ -86,7 +86,7 @@ static av_always_inline void setctx_2d(uint8_t *ptr, int w, int h,
}
}
static void decode_mode(AVCodecContext *ctx)
static void decode_mode(AVCodecContext *avctx)
{
static const uint8_t left_ctx[N_BS_SIZES] = {
0x0, 0x8, 0x0, 0x8, 0xc, 0x8, 0xc, 0xe, 0xc, 0xe, 0xf, 0xe, 0xf
@ -98,7 +98,7 @@ static void decode_mode(AVCodecContext *ctx)
TX_32X32, TX_32X32, TX_32X32, TX_32X32, TX_16X16, TX_16X16,
TX_16X16, TX_8X8, TX_8X8, TX_8X8, TX_4X4, TX_4X4, TX_4X4
};
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
VP9Block *b = s->b;
int row = s->row, col = s->col, row7 = s->row7;
enum TxfmMode max_tx = max_tx_for_bl_bp[b->bs];
@ -955,9 +955,9 @@ static int decode_coeffs_b32_16bpp(VP9Context *s, int16_t *coef, int n_coeffs,
nnz, scan, nb, band_counts, qmul);
}
static av_always_inline int decode_coeffs(AVCodecContext *ctx, int is8bitsperpixel)
static av_always_inline int decode_coeffs(AVCodecContext *avctx, int is8bitsperpixel)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
VP9Block *b = s->b;
int row = s->row, col = s->col;
uint8_t (*p)[6][11] = s->prob.coef[b->tx][0 /* y */][!b->intra];
@ -1122,14 +1122,14 @@ static av_always_inline int decode_coeffs(AVCodecContext *ctx, int is8bitsperpix
return total_coeff;
}
static int decode_coeffs_8bpp(AVCodecContext *ctx)
static int decode_coeffs_8bpp(AVCodecContext *avctx)
{
return decode_coeffs(ctx, 1);
return decode_coeffs(avctx, 1);
}
static int decode_coeffs_16bpp(AVCodecContext *ctx)
static int decode_coeffs_16bpp(AVCodecContext *avctx)
{
return decode_coeffs(ctx, 0);
return decode_coeffs(avctx, 0);
}
static av_always_inline int check_intra_mode(VP9Context *s, int mode, uint8_t **a,
@ -1313,10 +1313,10 @@ static av_always_inline int check_intra_mode(VP9Context *s, int mode, uint8_t **
return mode;
}
static av_always_inline void intra_recon(AVCodecContext *ctx, ptrdiff_t y_off,
static av_always_inline void intra_recon(AVCodecContext *avctx, ptrdiff_t y_off,
ptrdiff_t uv_off, int bytesperpixel)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
VP9Block *b = s->b;
int row = s->row, col = s->col;
int w4 = bwh_tab[1][b->bs][0] << 1, step1d = 1 << b->tx, n;
@ -1383,14 +1383,14 @@ static av_always_inline void intra_recon(AVCodecContext *ctx, ptrdiff_t y_off,
}
}
static void intra_recon_8bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
static void intra_recon_8bpp(AVCodecContext *avctx, ptrdiff_t y_off, ptrdiff_t uv_off)
{
intra_recon(ctx, y_off, uv_off, 1);
intra_recon(avctx, y_off, uv_off, 1);
}
static void intra_recon_16bpp(AVCodecContext *ctx, ptrdiff_t y_off, ptrdiff_t uv_off)
static void intra_recon_16bpp(AVCodecContext *avctx, ptrdiff_t y_off, ptrdiff_t uv_off)
{
intra_recon(ctx, y_off, uv_off, 2);
intra_recon(avctx, y_off, uv_off, 2);
}
static av_always_inline void mc_luma_unscaled(VP9Context *s, vp9_mc_func (*mc)[2],
@ -1660,23 +1660,23 @@ static av_always_inline void mc_chroma_scaled(VP9Context *s, vp9_scaled_mc_func
#undef BYTES_PER_PIXEL
#undef SCALED
static av_always_inline void inter_recon(AVCodecContext *ctx, int bytesperpixel)
static av_always_inline void inter_recon(AVCodecContext *avctx, int bytesperpixel)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
VP9Block *b = s->b;
int row = s->row, col = s->col;
if (s->mvscale[b->ref[0]][0] || (b->comp && s->mvscale[b->ref[1]][0])) {
if (bytesperpixel == 1) {
inter_pred_scaled_8bpp(ctx);
inter_pred_scaled_8bpp(avctx);
} else {
inter_pred_scaled_16bpp(ctx);
inter_pred_scaled_16bpp(avctx);
}
} else {
if (bytesperpixel == 1) {
inter_pred_8bpp(ctx);
inter_pred_8bpp(avctx);
} else {
inter_pred_16bpp(ctx);
inter_pred_16bpp(avctx);
}
}
if (!b->skip) {
@ -1726,14 +1726,14 @@ static av_always_inline void inter_recon(AVCodecContext *ctx, int bytesperpixel)
}
}
static void inter_recon_8bpp(AVCodecContext *ctx)
static void inter_recon_8bpp(AVCodecContext *avctx)
{
inter_recon(ctx, 1);
inter_recon(avctx, 1);
}
static void inter_recon_16bpp(AVCodecContext *ctx)
static void inter_recon_16bpp(AVCodecContext *avctx)
{
inter_recon(ctx, 2);
inter_recon(avctx, 2);
}
static av_always_inline void mask_edges(uint8_t (*mask)[8][4], int ss_h, int ss_v,
@ -1858,11 +1858,11 @@ static av_always_inline void mask_edges(uint8_t (*mask)[8][4], int ss_h, int ss_
}
}
void ff_vp9_decode_block(AVCodecContext *ctx, int row, int col,
void ff_vp9_decode_block(AVCodecContext *avctx, int row, int col,
struct VP9Filter *lflvl, ptrdiff_t yoff, ptrdiff_t uvoff,
enum BlockLevel bl, enum BlockPartition bp)
{
VP9Context *s = ctx->priv_data;
VP9Context *s = avctx->priv_data;
VP9Block *b = s->b;
enum BlockSize bs = bl * 3 + bp;
int bytesperpixel = s->bytesperpixel;
@ -1882,7 +1882,7 @@ void ff_vp9_decode_block(AVCodecContext *ctx, int row, int col,
b->bs = bs;
b->bl = bl;
b->bp = bp;
decode_mode(ctx);
decode_mode(avctx);
b->uvtx = b->tx - ((s->ss_h && w4 * 2 == (1 << b->tx)) ||
(s->ss_v && h4 * 2 == (1 << b->tx)));
@ -1890,9 +1890,9 @@ void ff_vp9_decode_block(AVCodecContext *ctx, int row, int col,
int has_coeffs;
if (bytesperpixel == 1) {
has_coeffs = decode_coeffs_8bpp(ctx);
has_coeffs = decode_coeffs_8bpp(avctx);
} else {
has_coeffs = decode_coeffs_16bpp(ctx);
has_coeffs = decode_coeffs_16bpp(avctx);
}
if (!has_coeffs && b->bs <= BS_8x8 && !b->intra) {
b->skip = 1;
@ -1974,15 +1974,15 @@ void ff_vp9_decode_block(AVCodecContext *ctx, int row, int col,
}
if (b->intra) {
if (s->s.h.bpp > 8) {
intra_recon_16bpp(ctx, yoff, uvoff);
intra_recon_16bpp(avctx, yoff, uvoff);
} else {
intra_recon_8bpp(ctx, yoff, uvoff);
intra_recon_8bpp(avctx, yoff, uvoff);
}
} else {
if (s->s.h.bpp > 8) {
inter_recon_16bpp(ctx);
inter_recon_16bpp(avctx);
} else {
inter_recon_8bpp(ctx);
inter_recon_8bpp(avctx);
}
}
if (emu[0]) {

Write Preview
Loading…
Cancel
Save