/** * Complete frame/field rendering by passing any remaining blocks. * Normally ff_draw_horiz_band() is called for each slice, however, * some leftover blocks, for example from error_resilience(), may remain. * It should be safe to call the function a few times for the same field. */ void ff_xvmc_field_end(MpegEncContext *s) { struct xvmc_pix_fmt *render = (struct xvmc_pix_fmt*)s->current_picture.f.data[2]; assert(render); if (render->filled_mv_blocks_num > 0) ff_mpeg_draw_horiz_band(s, 0, 0); }
void ff_vdpau_mpeg_picture_complete(MpegEncContext *s, const uint8_t *buf, int buf_size, int slice_count) { struct vdpau_render_state *render, *last, *next; int i; if (!s->current_picture_ptr) return; render = (struct vdpau_render_state *)s->current_picture_ptr->f.data[0]; assert(render); /* fill VdpPictureInfoMPEG1Or2 struct */ render->info.mpeg.picture_structure = s->picture_structure; render->info.mpeg.picture_coding_type = s->pict_type; render->info.mpeg.intra_dc_precision = s->intra_dc_precision; render->info.mpeg.frame_pred_frame_dct = s->frame_pred_frame_dct; render->info.mpeg.concealment_motion_vectors = s->concealment_motion_vectors; render->info.mpeg.intra_vlc_format = s->intra_vlc_format; render->info.mpeg.alternate_scan = s->alternate_scan; render->info.mpeg.q_scale_type = s->q_scale_type; render->info.mpeg.top_field_first = s->top_field_first; render->info.mpeg.full_pel_forward_vector = s->full_pel[0]; // MPEG-1 only. Set 0 for MPEG-2 render->info.mpeg.full_pel_backward_vector = s->full_pel[1]; // MPEG-1 only. Set 0 for MPEG-2 render->info.mpeg.f_code[0][0] = s->mpeg_f_code[0][0]; // For MPEG-1 fill both horiz. & vert. render->info.mpeg.f_code[0][1] = s->mpeg_f_code[0][1]; render->info.mpeg.f_code[1][0] = s->mpeg_f_code[1][0]; render->info.mpeg.f_code[1][1] = s->mpeg_f_code[1][1]; for (i = 0; i < 64; ++i) { render->info.mpeg.intra_quantizer_matrix[i] = s->intra_matrix[i]; render->info.mpeg.non_intra_quantizer_matrix[i] = s->inter_matrix[i]; } render->info.mpeg.forward_reference = VDP_INVALID_HANDLE; render->info.mpeg.backward_reference = VDP_INVALID_HANDLE; switch(s->pict_type){ case AV_PICTURE_TYPE_B: next = (struct vdpau_render_state *)s->next_picture.f.data[0]; assert(next); render->info.mpeg.backward_reference = next->surface; // no return here, going to set forward prediction case AV_PICTURE_TYPE_P: last = (struct vdpau_render_state *)s->last_picture.f.data[0]; if (!last) // FIXME: Does this test make sense? last = render; // predict second field from the first render->info.mpeg.forward_reference = last->surface; } ff_vdpau_add_data_chunk(s->current_picture_ptr->f.data[0], buf, buf_size); render->info.mpeg.slice_count = slice_count; if (slice_count) ff_mpeg_draw_horiz_band(s, 0, s->avctx->height); render->bitstream_buffers_used = 0; }
/** * Complete frame/field rendering by passing any remaining blocks. * Normally ff_draw_horiz_band() is called for each slice, however, * some leftover blocks, for example from error_resilience(), may remain. * It should be safe to call the function a few times for the same field. */ static int ff_xvmc_field_end(AVCodecContext *avctx) { struct MpegEncContext *s = avctx->priv_data; struct xvmc_pix_fmt *render = (struct xvmc_pix_fmt*)s->current_picture.f->data[2]; assert(render); if (render->filled_mv_blocks_num > 0) ff_mpeg_draw_horiz_band(s, 0, 0); return 0; }
void ff_vdpau_mpeg4_decode_picture(Mpeg4DecContext *ctx, const uint8_t *buf, int buf_size) { MpegEncContext *s = &ctx->m; struct vdpau_render_state *render, *last, *next; int i; if (!s->current_picture_ptr) return; render = (struct vdpau_render_state *)s->current_picture_ptr->f->data[0]; assert(render); /* fill VdpPictureInfoMPEG4Part2 struct */ render->info.mpeg4.trd[0] = s->pp_time; render->info.mpeg4.trb[0] = s->pb_time; render->info.mpeg4.trd[1] = s->pp_field_time >> 1; render->info.mpeg4.trb[1] = s->pb_field_time >> 1; render->info.mpeg4.vop_time_increment_resolution = s->avctx->time_base.den; render->info.mpeg4.vop_coding_type = 0; render->info.mpeg4.vop_fcode_forward = s->f_code; render->info.mpeg4.vop_fcode_backward = s->b_code; render->info.mpeg4.resync_marker_disable = !ctx->resync_marker; render->info.mpeg4.interlaced = !s->progressive_sequence; render->info.mpeg4.quant_type = s->mpeg_quant; render->info.mpeg4.quarter_sample = s->quarter_sample; render->info.mpeg4.short_video_header = s->avctx->codec->id == AV_CODEC_ID_H263; render->info.mpeg4.rounding_control = s->no_rounding; render->info.mpeg4.alternate_vertical_scan_flag = s->alternate_scan; render->info.mpeg4.top_field_first = s->top_field_first; for (i = 0; i < 64; ++i) { render->info.mpeg4.intra_quantizer_matrix[i] = s->intra_matrix[i]; render->info.mpeg4.non_intra_quantizer_matrix[i] = s->inter_matrix[i]; } render->info.mpeg4.forward_reference = VDP_INVALID_HANDLE; render->info.mpeg4.backward_reference = VDP_INVALID_HANDLE; switch (s->pict_type) { case AV_PICTURE_TYPE_B: next = (struct vdpau_render_state *)s->next_picture.f->data[0]; assert(next); render->info.mpeg4.backward_reference = next->surface; render->info.mpeg4.vop_coding_type = 2; // no break here, going to set forward prediction case AV_PICTURE_TYPE_P: last = (struct vdpau_render_state *)s->last_picture.f->data[0]; assert(last); render->info.mpeg4.forward_reference = last->surface; } ff_vdpau_add_data_chunk(s->current_picture_ptr->f->data[0], buf, buf_size); ff_mpeg_draw_horiz_band(s, 0, s->avctx->height); render->bitstream_buffers_used = 0; }
int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx) { MpegEncContext *s = avctx->priv_data; Picture *pic = s->current_picture_ptr; struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private; int val; val = ff_vdpau_common_end_frame(avctx, pic->f, pic_ctx); if (val < 0) return val; ff_mpeg_draw_horiz_band(s, 0, s->avctx->height); return 0; }
int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx) { AVVDPAUContext *hwctx = avctx->hwaccel_context; MpegEncContext *s = avctx->priv_data; VdpVideoSurface surf = ff_vdpau_get_surface_id(s->current_picture_ptr); hwctx->render(hwctx->decoder, surf, (void *)&hwctx->info, hwctx->bitstream_buffers_used, hwctx->bitstream_buffers); ff_mpeg_draw_horiz_band(s, 0, s->avctx->height); hwctx->bitstream_buffers_used = 0; return 0; }
int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx) { AVVDPAUContext *hwctx = avctx->hwaccel_context; MpegEncContext *s = avctx->priv_data; Picture *pic = s->current_picture_ptr; struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private; VdpVideoSurface surf = ff_vdpau_get_surface_id(pic); hwctx->render(hwctx->decoder, surf, (void *)&pic_ctx->info, pic_ctx->bitstream_buffers_used, pic_ctx->bitstream_buffers); ff_mpeg_draw_horiz_band(s, 0, s->avctx->height); av_freep(&pic_ctx->bitstream_buffers); return 0; }
int ff_vaapi_mpeg_end_frame(AVCodecContext *avctx) { struct vaapi_context * const vactx = avctx->hwaccel_context; MpegEncContext *s = avctx->priv_data; int ret; ret = ff_vaapi_commit_slices(vactx); if (ret < 0) goto finish; ret = ff_vaapi_render_picture(vactx, ff_vaapi_get_surface_id(s->current_picture_ptr)); if (ret < 0) goto finish; ff_mpeg_draw_horiz_band(s, 0, s->avctx->height); finish: ff_vaapi_common_end_frame(avctx); return ret; }
int ff_vdpau_mpeg_end_frame(AVCodecContext *avctx) { int res = 0; AVVDPAUContext *hwctx = avctx->hwaccel_context; MpegEncContext *s = avctx->priv_data; Picture *pic = s->current_picture_ptr; struct vdpau_picture_context *pic_ctx = pic->hwaccel_picture_private; VdpVideoSurface surf = ff_vdpau_get_surface_id(pic); #if FF_API_BUFS_VDPAU FF_DISABLE_DEPRECATION_WARNINGS hwctx->info = pic_ctx->info; hwctx->bitstream_buffers = pic_ctx->bitstream_buffers; hwctx->bitstream_buffers_used = pic_ctx->bitstream_buffers_used; hwctx->bitstream_buffers_allocated = pic_ctx->bitstream_buffers_allocated; FF_ENABLE_DEPRECATION_WARNINGS #endif if (!hwctx->render) { res = hwctx->render2(avctx, &pic->f, (void *)&pic_ctx->info, pic_ctx->bitstream_buffers_used, pic_ctx->bitstream_buffers); } else hwctx->render(hwctx->decoder, surf, (void *)&pic_ctx->info, pic_ctx->bitstream_buffers_used, pic_ctx->bitstream_buffers); ff_mpeg_draw_horiz_band(s, 0, s->avctx->height); av_freep(&pic_ctx->bitstream_buffers); #if FF_API_BUFS_VDPAU FF_DISABLE_DEPRECATION_WARNINGS hwctx->bitstream_buffers = NULL; hwctx->bitstream_buffers_used = 0; hwctx->bitstream_buffers_allocated = 0; FF_ENABLE_DEPRECATION_WARNINGS #endif return res; }
static int decode_slice(MpegEncContext *s) { const int part_mask = s->partitioned_frame ? (ER_AC_END | ER_AC_ERROR) : 0x7F; const int mb_size = 16 >> s->avctx->lowres; int ret; s->last_resync_gb = s->gb; s->first_slice_line = 1; s->resync_mb_x = s->mb_x; s->resync_mb_y = s->mb_y; ff_set_qscale(s, s->qscale); if (s->avctx->hwaccel) { const uint8_t *start = s->gb.buffer + get_bits_count(&s->gb) / 8; ret = s->avctx->hwaccel->decode_slice(s->avctx, start, s->gb.buffer_end - start); // ensure we exit decode loop s->mb_y = s->mb_height; return ret; } if (s->partitioned_frame) { const int qscale = s->qscale; if (CONFIG_MPEG4_DECODER && s->codec_id == AV_CODEC_ID_MPEG4) if ((ret = ff_mpeg4_decode_partitions(s->avctx->priv_data)) < 0) return ret; /* restore variables which were modified */ s->first_slice_line = 1; s->mb_x = s->resync_mb_x; s->mb_y = s->resync_mb_y; ff_set_qscale(s, qscale); } for (; s->mb_y < s->mb_height; s->mb_y++) { /* per-row end of slice checks */ if (s->msmpeg4_version) { if (s->resync_mb_y + s->slice_height == s->mb_y) { ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x - 1, s->mb_y, ER_MB_END); return 0; } } if (s->msmpeg4_version == 1) { s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 128; } ff_init_block_index(s); for (; s->mb_x < s->mb_width; s->mb_x++) { int ret; ff_update_block_index(s); if (s->resync_mb_x == s->mb_x && s->resync_mb_y + 1 == s->mb_y) s->first_slice_line = 0; /* DCT & quantize */ s->mv_dir = MV_DIR_FORWARD; s->mv_type = MV_TYPE_16X16; av_dlog(s, "%d %d %06X\n", ret, get_bits_count(&s->gb), show_bits(&s->gb, 24)); tprintf(NULL, "Decoding MB at %dx%d\n", s->mb_x, s->mb_y); ret = s->decode_mb(s, s->block); if (s->pict_type != AV_PICTURE_TYPE_B) ff_h263_update_motion_val(s); if (ret < 0) { const int xy = s->mb_x + s->mb_y * s->mb_stride; if (ret == SLICE_END) { ff_mpv_decode_mb(s, s->block); if (s->loop_filter) ff_h263_loop_filter(s); ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_END & part_mask); s->padding_bug_score--; if (++s->mb_x >= s->mb_width) { s->mb_x = 0; ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size); ff_mpv_report_decode_progress(s); s->mb_y++; } return 0; } else if (ret == SLICE_NOEND) { av_log(s->avctx, AV_LOG_ERROR, "Slice mismatch at MB: %d\n", xy); ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x + 1, s->mb_y, ER_MB_END & part_mask); return AVERROR_INVALIDDATA; } av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", xy); ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR & part_mask); if (s->err_recognition & AV_EF_IGNORE_ERR) continue; return AVERROR_INVALIDDATA; } ff_mpv_decode_mb(s, s->block); if (s->loop_filter) ff_h263_loop_filter(s); } ff_mpeg_draw_horiz_band(s, s->mb_y * mb_size, mb_size); ff_mpv_report_decode_progress(s); s->mb_x = 0; } av_assert1(s->mb_x == 0 && s->mb_y == s->mb_height); if (s->codec_id == AV_CODEC_ID_MPEG4 && (s->workaround_bugs & FF_BUG_AUTODETECT) && get_bits_left(&s->gb) >= 48 && show_bits(&s->gb, 24) == 0x4010 && !s->data_partitioning) s->padding_bug_score += 32; /* try to detect the padding bug */ if (s->codec_id == AV_CODEC_ID_MPEG4 && (s->workaround_bugs & FF_BUG_AUTODETECT) && get_bits_left(&s->gb) >= 0 && get_bits_left(&s->gb) < 137 && !s->data_partitioning) { const int bits_count = get_bits_count(&s->gb); const int bits_left = s->gb.size_in_bits - bits_count; if (bits_left == 0) { s->padding_bug_score += 16; } else if (bits_left != 1) { int v = show_bits(&s->gb, 8); v |= 0x7F >> (7 - (bits_count & 7)); if (v == 0x7F && bits_left <= 8) s->padding_bug_score--; else if (v == 0x7F && ((get_bits_count(&s->gb) + 8) & 8) && bits_left <= 16) s->padding_bug_score += 4; else s->padding_bug_score++; } }
/** * Synthesize the data needed by XvMC to render one macroblock of data. * Fill all relevant fields, if necessary do IDCT. */ void ff_xvmc_decode_mb(MpegEncContext *s) { XvMCMacroBlock *mv_block; struct xvmc_pix_fmt *render; int i, cbp, blocks_per_mb; const int mb_xy = s->mb_y * s->mb_stride + s->mb_x; if (s->encoding) { av_log(s->avctx, AV_LOG_ERROR, "XVMC doesn't support encoding!!!\n"); return; } // from MPV_decode_mb(), update DC predictors for P macroblocks if (!s->mb_intra) { s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 128 << s->intra_dc_precision; } // MC doesn't skip blocks s->mb_skipped = 0; // Do I need to export quant when I could not perform postprocessing? // Anyway, it doesn't hurt. s->current_picture.qscale_table[mb_xy] = s->qscale; // start of XVMC-specific code render = (struct xvmc_pix_fmt*)s->current_picture.f.data[2]; assert(render); assert(render->xvmc_id == AV_XVMC_ID); assert(render->mv_blocks); // take the next free macroblock mv_block = &render->mv_blocks[render->start_mv_blocks_num + render->filled_mv_blocks_num]; mv_block->x = s->mb_x; mv_block->y = s->mb_y; mv_block->dct_type = s->interlaced_dct; // XVMC_DCT_TYPE_FRAME/FIELD; if (s->mb_intra) { mv_block->macroblock_type = XVMC_MB_TYPE_INTRA; // no MC, all done } else { mv_block->macroblock_type = XVMC_MB_TYPE_PATTERN; if (s->mv_dir & MV_DIR_FORWARD) { mv_block->macroblock_type |= XVMC_MB_TYPE_MOTION_FORWARD; // PMV[n][dir][xy] = mv[dir][n][xy] mv_block->PMV[0][0][0] = s->mv[0][0][0]; mv_block->PMV[0][0][1] = s->mv[0][0][1]; mv_block->PMV[1][0][0] = s->mv[0][1][0]; mv_block->PMV[1][0][1] = s->mv[0][1][1]; } if (s->mv_dir & MV_DIR_BACKWARD) { mv_block->macroblock_type |= XVMC_MB_TYPE_MOTION_BACKWARD; mv_block->PMV[0][1][0] = s->mv[1][0][0]; mv_block->PMV[0][1][1] = s->mv[1][0][1]; mv_block->PMV[1][1][0] = s->mv[1][1][0]; mv_block->PMV[1][1][1] = s->mv[1][1][1]; } switch(s->mv_type) { case MV_TYPE_16X16: mv_block->motion_type = XVMC_PREDICTION_FRAME; break; case MV_TYPE_16X8: mv_block->motion_type = XVMC_PREDICTION_16x8; break; case MV_TYPE_FIELD: mv_block->motion_type = XVMC_PREDICTION_FIELD; if (s->picture_structure == PICT_FRAME) { mv_block->PMV[0][0][1] <<= 1; mv_block->PMV[1][0][1] <<= 1; mv_block->PMV[0][1][1] <<= 1; mv_block->PMV[1][1][1] <<= 1; } break; case MV_TYPE_DMV: mv_block->motion_type = XVMC_PREDICTION_DUAL_PRIME; if (s->picture_structure == PICT_FRAME) { mv_block->PMV[0][0][0] = s->mv[0][0][0]; // top from top mv_block->PMV[0][0][1] = s->mv[0][0][1] << 1; mv_block->PMV[0][1][0] = s->mv[0][0][0]; // bottom from bottom mv_block->PMV[0][1][1] = s->mv[0][0][1] << 1; mv_block->PMV[1][0][0] = s->mv[0][2][0]; // dmv00, top from bottom mv_block->PMV[1][0][1] = s->mv[0][2][1] << 1; // dmv01 mv_block->PMV[1][1][0] = s->mv[0][3][0]; // dmv10, bottom from top mv_block->PMV[1][1][1] = s->mv[0][3][1] << 1; // dmv11 } else { mv_block->PMV[0][1][0] = s->mv[0][2][0]; // dmv00 mv_block->PMV[0][1][1] = s->mv[0][2][1]; // dmv01 } break; default: assert(0); } mv_block->motion_vertical_field_select = 0; // set correct field references if (s->mv_type == MV_TYPE_FIELD || s->mv_type == MV_TYPE_16X8) { mv_block->motion_vertical_field_select |= s->field_select[0][0]; mv_block->motion_vertical_field_select |= s->field_select[1][0] << 1; mv_block->motion_vertical_field_select |= s->field_select[0][1] << 2; mv_block->motion_vertical_field_select |= s->field_select[1][1] << 3; } } // !intra // time to handle data blocks mv_block->index = render->next_free_data_block_num; blocks_per_mb = 6; if (s->chroma_format >= 2) { blocks_per_mb = 4 + (1 << s->chroma_format); } // calculate cbp cbp = 0; for (i = 0; i < blocks_per_mb; i++) { cbp += cbp; if (s->block_last_index[i] >= 0) cbp++; } if (s->flags & CODEC_FLAG_GRAY) { if (s->mb_intra) { // intra frames are always full chroma blocks for (i = 4; i < blocks_per_mb; i++) { memset(s->pblocks[i], 0, sizeof(*s->pblocks[i])); // so we need to clear them if (!render->unsigned_intra) *s->pblocks[i][0] = 1 << 10; } } else { cbp &= 0xf << (blocks_per_mb - 4); blocks_per_mb = 4; // luminance blocks only } } mv_block->coded_block_pattern = cbp; if (cbp == 0) mv_block->macroblock_type &= ~XVMC_MB_TYPE_PATTERN; for (i = 0; i < blocks_per_mb; i++) { if (s->block_last_index[i] >= 0) { // I do not have unsigned_intra MOCO to test, hope it is OK. if (s->mb_intra && (render->idct || !render->unsigned_intra)) *s->pblocks[i][0] -= 1 << 10; if (!render->idct) { s->dsp.idct(*s->pblocks[i]); /* It is unclear if MC hardware requires pixel diff values to be * in the range [-255;255]. TODO: Clipping if such hardware is * ever found. As of now it would only be an unnecessary * slowdown. */ } // copy blocks only if the codec doesn't support pblocks reordering if (s->avctx->xvmc_acceleration == 1) { memcpy(&render->data_blocks[render->next_free_data_block_num*64], s->pblocks[i], sizeof(*s->pblocks[i])); } render->next_free_data_block_num++; } } render->filled_mv_blocks_num++; assert(render->filled_mv_blocks_num <= render->allocated_mv_blocks); assert(render->next_free_data_block_num <= render->allocated_data_blocks); /* The above conditions should not be able to fail as long as this function * is used and the following 'if ()' automatically calls a callback to free * blocks. */ if (render->filled_mv_blocks_num == render->allocated_mv_blocks) ff_mpeg_draw_horiz_band(s, 0, 0); }
void ff_vdpau_vc1_decode_picture(MpegEncContext *s, const uint8_t *buf, int buf_size) { VC1Context *v = s->avctx->priv_data; struct vdpau_render_state *render, *last, *next; render = (struct vdpau_render_state *)s->current_picture.f.data[0]; assert(render); /* fill LvPictureInfoVC1 struct */ render->info.vc1.frame_coding_mode = v->fcm ? v->fcm + 1 : 0; render->info.vc1.postprocflag = v->postprocflag; render->info.vc1.pulldown = v->broadcast; render->info.vc1.interlace = v->interlace; render->info.vc1.tfcntrflag = v->tfcntrflag; render->info.vc1.finterpflag = v->finterpflag; render->info.vc1.psf = v->psf; render->info.vc1.dquant = v->dquant; render->info.vc1.panscan_flag = v->panscanflag; render->info.vc1.refdist_flag = v->refdist_flag; render->info.vc1.quantizer = v->quantizer_mode; render->info.vc1.extended_mv = v->extended_mv; render->info.vc1.extended_dmv = v->extended_dmv; render->info.vc1.overlap = v->overlap; render->info.vc1.vstransform = v->vstransform; render->info.vc1.loopfilter = v->s.loop_filter; render->info.vc1.fastuvmc = v->fastuvmc; render->info.vc1.range_mapy_flag = v->range_mapy_flag; render->info.vc1.range_mapy = v->range_mapy; render->info.vc1.range_mapuv_flag = v->range_mapuv_flag; render->info.vc1.range_mapuv = v->range_mapuv; /* Specific to simple/main profile only */ render->info.vc1.multires = v->multires; render->info.vc1.syncmarker = v->s.resync_marker; render->info.vc1.rangered = v->rangered | (v->rangeredfrm << 1); render->info.vc1.maxbframes = v->s.max_b_frames; render->info.vc1.deblockEnable = v->postprocflag & 1; render->info.vc1.pquant = v->pq; render->info.vc1.forward_reference = VDP_INVALID_HANDLE; render->info.vc1.backward_reference = VDP_INVALID_HANDLE; if (v->bi_type) render->info.vc1.picture_type = 4; else render->info.vc1.picture_type = s->pict_type - 1 + s->pict_type / 3; switch(s->pict_type){ case AV_PICTURE_TYPE_B: next = (struct vdpau_render_state *)s->next_picture.f.data[0]; assert(next); render->info.vc1.backward_reference = next->surface; // no break here, going to set forward prediction case AV_PICTURE_TYPE_P: last = (struct vdpau_render_state *)s->last_picture.f.data[0]; if (!last) // FIXME: Does this test make sense? last = render; // predict second field from the first render->info.vc1.forward_reference = last->surface; } ff_vdpau_add_data_chunk(s->current_picture_ptr->f.data[0], buf, buf_size); render->info.vc1.slice_count = 1; ff_mpeg_draw_horiz_band(s, 0, s->avctx->height); render->bitstream_buffers_used = 0; }