Attachment #2278 for bug #13452

View | Details | Raw Unified | Return to bug 13452
Collapse All | Expand All

Lines 104-109 Link Here

(-)ffmpeg-10924-alt1.rvrt/libavcodec/allcodecs.c (+1 lines)
104	REGISTER_ENCDEC (MJPEG, mjpeg);	104	REGISTER_ENCDEC (MJPEG, mjpeg);
105	REGISTER_DECODER (MJPEGB, mjpegb);	105	REGISTER_DECODER (MJPEGB, mjpegb);
106	REGISTER_DECODER (MMVIDEO, mmvideo);	106	REGISTER_DECODER (MMVIDEO, mmvideo);
		107	REGISTER_DECODER (MPEG_XVMC_VLD, mpeg_xvmc_vld);
107	REGISTER_DECODER (MPEG_XVMC, mpeg_xvmc);	108	REGISTER_DECODER (MPEG_XVMC, mpeg_xvmc);
108	REGISTER_ENCDEC (MPEG1VIDEO, mpeg1video);	109	REGISTER_ENCDEC (MPEG1VIDEO, mpeg1video);
109	REGISTER_ENCDEC (MPEG2VIDEO, mpeg2video);	110	REGISTER_ENCDEC (MPEG2VIDEO, mpeg2video);

Lines 70-75 Link Here

(-)ffmpeg-10924-alt1.rvrt/libavcodec/mpeg12.c (+65 lines)
70	extern void XVMC_pack_pblocks(MpegEncContext *s,int cbp);	70	extern void XVMC_pack_pblocks(MpegEncContext *s,int cbp);
71	extern void XVMC_init_block(MpegEncContext *s);//set s->block	71	extern void XVMC_init_block(MpegEncContext *s);//set s->block
72		72
		73
		74	#ifdef HAVE_XVMC_VLD
		75	extern int XVMC_decode_slice(MpegEncContext *s, int start_code,
		76	uint8_t *buffer, int buf_size);
		77	int has_xvmc_vld = 0;
		78	#endif
		79
73	static const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,-1};	80	static const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,-1};
74	static const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,-1};	81	static const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,-1};
75	static const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,-1};	82	static const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,-1};
Lines 77-82 Link Here
77	PIX_FMT_XVMC_MPEG2_IDCT,	84	PIX_FMT_XVMC_MPEG2_IDCT,
78	PIX_FMT_XVMC_MPEG2_MC,	85	PIX_FMT_XVMC_MPEG2_MC,
79	-1};	86	-1};
		87	static const enum PixelFormat pixfmt_xvmc_vld_mpg2_420[] = {
		88	PIX_FMT_XVMC_MPEG2_VLD,
		89	PIX_FMT_XVMC_MPEG2_IDCT,
		90	PIX_FMT_XVMC_MPEG2_MC,
		91	-1};
80		92
81	uint8_t ff_mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];	93	uint8_t ff_mpeg12_static_rl_table_store[2][2][2*MAX_RUN + MAX_LEVEL + 3];
82		94
Lines 1313-1318 Link Here
1313	}//mpeg2	1325	}//mpeg2
1314		1326
1315	if(avctx->xvmc_acceleration){	1327	if(avctx->xvmc_acceleration){
		1328	if (has_xvmc_vld)
		1329	avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_vld_mpg2_420);
		1330	else
1316	avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);	1331	avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
1317	}else{	1332	}else{
1318	if(s->chroma_format < 2){	1333	if(s->chroma_format < 2){
Lines 1682-1687 Link Here
1682	return -1;	1697	return -1;
1683	}	1698	}
1684		1699
		1700	#ifdef HAVE_XVMC_VLD
		1701	if (s->avctx->xvmc_acceleration == 4){
		1702	int used = XVMC_decode_slice(s, mb_y, *buf, buf_size);
		1703	if (used < 0)
		1704	return DECODE_SLICE_ERROR;
		1705	*buf += used - 1;
		1706	return DECODE_SLICE_OK;
		1707	}
		1708	#endif
		1709
1685	init_get_bits(&s->gb, buf, buf_size8);	1710	init_get_bits(&s->gb, buf, buf_size8);
1686		1711
1687	ff_mpeg1_clean_buffers(s);	1712	ff_mpeg1_clean_buffers(s);
Lines 2077-2082 Link Here
2077	s->low_delay= 1;	2102	s->low_delay= 1;
2078		2103
2079	if(avctx->xvmc_acceleration){	2104	if(avctx->xvmc_acceleration){
		2105	if (has_xvmc_vld)
		2106	avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_vld_mpg2_420);
		2107	else
2080	avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);	2108	avctx->pix_fmt = avctx->get_format(avctx,pixfmt_xvmc_mpg2_420);
2081	}else{	2109	}else{
2082	avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);	2110	avctx->pix_fmt = avctx->get_format(avctx,pixfmt_yuv_420);
Lines 2474-2479 Link Here
2474		2502
2475	#endif	2503	#endif
2476		2504
		2505	#ifdef HAVE_XVMC_VLD
		2506	static int mpeg_xxmc_decode_init(AVCodecContext *avctx){
		2507	Mpeg1Context *s;
		2508	if (!has_xvmc_vld)
		2509	return mpeg_mc_decode_init(avctx);
		2510	if( avctx->thread_count > 1)
		2511	return -1;
		2512	if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) )
		2513	return -1;
		2514	if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) )
		2515	dprintf("mpeg12.c: XVMC_VLD decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
		2516
		2517	mpeg_decode_init(avctx);
		2518	s = avctx->priv_data;
		2519
		2520	avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_VLD;
		2521	avctx->xvmc_acceleration = 4;
		2522
		2523	return 0;
		2524	}
		2525
		2526	AVCodec mpeg_xvmc_vld_decoder = {
		2527	"mpegvideo_xvmc",
		2528	CODEC_TYPE_VIDEO,
		2529	CODEC_ID_MPEG2VIDEO_XVMC,
		2530	sizeof(Mpeg1Context),
		2531	mpeg_xxmc_decode_init,
		2532	NULL,
		2533	mpeg_decode_end,
		2534	mpeg_decode_frame,
		2535	CODEC_CAP_DRAW_HORIZ_BAND \| CODEC_CAP_DR1 \| CODEC_CAP_TRUNCATED\| CODEC_CAP_HWACCEL,
		2536	.flush= ff_mpeg_flush,
		2537	};
		2538
		2539	#endif
		2540
		2541
2477	/* this is ugly i know, but the alternative is too make	2542	/* this is ugly i know, but the alternative is too make
2478	hundreds of vars global and prefix them with ff_mpeg1_	2543	hundreds of vars global and prefix them with ff_mpeg1_
2479	which is far uglier. */	2544	which is far uglier. */

Lines 28-33 Link Here

(-)ffmpeg-10924-alt1.rvrt/libavcodec/xvmc_render.h (+12 lines)
28	#include <X11/extensions/Xvlib.h>	28	#include <X11/extensions/Xvlib.h>
29	#include <X11/extensions/XvMClib.h>	29	#include <X11/extensions/XvMClib.h>
30		30
		31	#ifdef HAVE_XVMC_VLD
		32	#include <X11/extensions/vldXvMC.h>
		33	#endif
31		34
32	//the surface should be shown, video driver manipulates this	35	//the surface should be shown, video driver manipulates this
33	#define MP_XVMC_STATE_DISPLAY_PENDING 1	36	#define MP_XVMC_STATE_DISPLAY_PENDING 1
Lines 50-55 Link Here
50	int idct;//Do we use IDCT acceleration?	53	int idct;//Do we use IDCT acceleration?
51	int chroma_format;//420,422,444	54	int chroma_format;//420,422,444
52	int unsigned_intra;//+-128 for intra pictures after clip	55	int unsigned_intra;//+-128 for intra pictures after clip
		56	#ifdef HAVE_XVMC_VLD
		57	// These are for the XVMC VLD slice interface
		58	int pict_type; //this is for skipping frames
		59	int slice_code;
		60	int slice_datalen;
		61	unsigned char *slice_data;
		62	Display *disp;
		63	XvMCContext *ctx;
		64	#endif
53	XvMCSurface* p_surface;//pointer to rendered surface, never changed	65	XvMCSurface* p_surface;//pointer to rendered surface, never changed
54		66
55	//these are changed by decoder	67	//these are changed by decoder




    }
}

#ifdef HAVE_XVMC_VLD
static XvMCSurface* findPastSurface(MpegEncContext *s,
                                    xvmc_render_state_t *render)
{
    Picture *lastp = s->last_picture_ptr;
    xvmc_render_state_t *last = NULL;

    if (NULL!=lastp) {
        last = (xvmc_render_state_t*)(lastp->data[2]);
        if (B_TYPE==last->pict_type)
            av_log(s->avctx,AV_LOG_DEBUG, "Past frame is a B frame in findPastSurface, this is bad.\n");
        //assert(B_TYPE!=last->pict_type);
    }

    if (NULL==last)
        if (!s->first_field)
            last = render; // predict second field from the first
        else
            return 0;

    if (last->magic != MP_XVMC_RENDER_MAGIC)
        return 0;

    return (last->state & MP_XVMC_STATE_PREDICTION) ? last->p_surface : 0;
}

static XvMCSurface* findFutureSurface(MpegEncContext *s)
{
    Picture *nextp = s->next_picture_ptr;
    xvmc_render_state_t *next = NULL;

    if (NULL!=nextp) {
        next = (xvmc_render_state_t*)(nextp->data[2]);
        if (B_TYPE==next->pict_type)
            av_log(s->avctx,AV_LOG_DEBUG, "Next frame is a B frame in findFutureSurface, thisis bad.\n");
        //assert(B_TYPE!=next->pict_type);
    }

    assert(NULL!=next);

    if (next->magic != MP_XVMC_RENDER_MAGIC)
        return 0;

    return (next->state & MP_XVMC_STATE_PREDICTION) ? next->p_surface : 0;
}
#endif //HAVE_XVMC_VLD

//these functions should be called on every new field or/and frame
//They should be safe if they are called few times for same field!
int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx){
xvmc_render_state_t * render,* last, * next;

#ifdef HAVE_XVMC_VLD
    XvMCMpegControl     binfo;
    XvMCQMatrix         qmatrix;
    int                 i;
    Status              status;

    memset(&binfo, 0, sizeof(binfo));
    memset(&qmatrix, 0, sizeof(qmatrix));
#endif

    assert(avctx != NULL);

    render = (xvmc_render_state_t*)s->current_picture.data[2];

    render->picture_structure = s->picture_structure;
    render->flags = (s->first_field)? 0: XVMC_SECOND_FIELD;

#ifdef HAVE_XVMC_VLD
    if (s->avctx->xvmc_acceleration == 4)
    {
        if (render->picture_structure == PICT_FRAME)
            render->flags |= XVMC_FRAME_PICTURE;
        else if (render->picture_structure == PICT_TOP_FIELD)
            render->flags |= XVMC_TOP_FIELD;
        else if (render->picture_structure == PICT_BOTTOM_FIELD)
            render->flags |= XVMC_BOTTOM_FIELD;
    }
    else
#endif
    {
//make sure that all data is drawn by XVMC_end_frame
    assert(render->filled_mv_blocks_num==0);
    }

    render->p_future_surface = NULL;
    render->p_past_surface = NULL;

    render->pict_type = s->pict_type; // for later frame dropping use

#ifdef HAVE_XVMC_VLD
    if (s->avctx->xvmc_acceleration == 4)
{
    switch(s->pict_type){
        case  I_TYPE:
            break;
        case  B_TYPE:
            render->p_past_surface = findPastSurface(s, render);
            render->p_future_surface = findFutureSurface(s);
            if (!render->p_past_surface)
                av_log(avctx, AV_LOG_ERROR, "error: decoding B frame and past frame is null!");
            else if (!render->p_future_surface)
                av_log(avctx, AV_LOG_ERROR, "error: decoding B frame and future frame is null!");
            break;
            
        case  P_TYPE:
            render->p_past_surface = findPastSurface(s, render);
            render->p_future_surface = render->p_surface;
            if (!render->p_past_surface)
                av_log(avctx, AV_LOG_ERROR, "error: decoding P frame and past frame is null!");
            break;
    }
} else
#endif
{
    switch(s->pict_type){
        case  I_TYPE:
            return 0;// no prediction from other frames

            render->p_past_surface = last->p_surface;
            return 0;
    }
}

#ifdef HAVE_XVMC_VLD
    if (s->avctx->xvmc_acceleration == 4)
    {
        for (i = 0; i < 64; i++){
        qmatrix.intra_quantiser_matrix[i] = s->intra_matrix[s->dsp.idct_permutation[i]];
        qmatrix.non_intra_quantiser_matrix[i] = s->inter_matrix[s->dsp.idct_permutation[i]];
        qmatrix.chroma_intra_quantiser_matrix[i] = s->chroma_intra_matrix[s->dsp.idct_permutation[i]];
        qmatrix.chroma_non_intra_quantiser_matrix[i] = s->chroma_inter_matrix[s->dsp.idct_permutation[i]];
        }

    qmatrix.load_intra_quantiser_matrix = 1;
    qmatrix.load_non_intra_quantiser_matrix = 1;
    qmatrix.load_chroma_intra_quantiser_matrix = 1;
    qmatrix.load_chroma_non_intra_quantiser_matrix = 1;


    binfo.flags = 0;
    if (s->alternate_scan)
        binfo.flags |= XVMC_ALTERNATE_SCAN;
    if (s->top_field_first)
        binfo.flags |= XVMC_TOP_FIELD_FIRST;
    if (s->frame_pred_frame_dct)
        binfo.flags |= XVMC_PRED_DCT_FRAME;
    else
        binfo.flags |= XVMC_PRED_DCT_FIELD;

    if (s->intra_vlc_format)
        binfo.flags |= XVMC_INTRA_VLC_FORMAT;
    if (!s->first_field && !s->progressive_sequence)
        binfo.flags |= XVMC_SECOND_FIELD;
    if (s->q_scale_type)
        binfo.flags |= XVMC_Q_SCALE_TYPE;
    if (s->concealment_motion_vectors)
        binfo.flags |= XVMC_CONCEALMENT_MOTION_VECTORS;
    if (s->progressive_sequence)
        binfo.flags |= XVMC_PROGRESSIVE_SEQUENCE;

    binfo.picture_structure = s->picture_structure;
    switch (s->pict_type)
    {
    case I_TYPE:    binfo.picture_coding_type = XVMC_I_PICTURE;     break;
    case P_TYPE:    binfo.picture_coding_type = XVMC_P_PICTURE;     break;
    case B_TYPE:    binfo.picture_coding_type = XVMC_B_PICTURE;     break;
    default:    av_log(avctx, AV_LOG_ERROR, "%s: Unknown picture coding type: %d\n", __FUNCTION__, s->pict_type);
    }

    binfo.intra_dc_precision = s->intra_dc_precision;;

    if (s->codec_id == CODEC_ID_MPEG2VIDEO)
        binfo.mpeg_coding = 2;
    else
        binfo.mpeg_coding = 1;

    s->mb_width = (s->width + 15) / 16;
    s->mb_height = (s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence) ?
        2 * ((s->height + 31) / 32) : (s->height + 15) / 16;

    if (s->codec_id == CODEC_ID_MPEG2VIDEO)
{
    binfo.FVMV_range = (s->mpeg_f_code[0][1] - 1);
    binfo.FHMV_range = (s->mpeg_f_code[0][0] - 1);
    binfo.BVMV_range = (s->mpeg_f_code[1][1] - 1);
    binfo.BHMV_range = (s->mpeg_f_code[1][0] - 1);
}
else
{
    binfo.FVMV_range = (s->mpeg_f_code[0][0] - 1);
    binfo.FHMV_range = (s->mpeg_f_code[0][0] - 1);
    binfo.BVMV_range = (s->mpeg_f_code[1][1] - 1);
    binfo.BHMV_range = (s->mpeg_f_code[1][1] - 1);
}

    status = XvMCLoadQMatrix(render->disp, render->ctx, &qmatrix);
    if (status)
        av_log(avctx,AV_LOG_ERROR, "XvMCLoadQMatrix: Error: %d\n", status);

    status = XvMCBeginSurface(render->disp, render->ctx, render->p_surface,
                              render->p_past_surface, render->p_future_surface,
                              &binfo);
    if (status)
        av_log(avctx,AV_LOG_ERROR, "XvMCBeginSurface: Error: %d\n", status);

    if (!status)
        return 0;
    }
#endif

return -1;
}

    render = (xvmc_render_state_t*)s->current_picture.data[2];
    assert(render != NULL);

#ifdef HAVE_XVMC_VLD
    if (s->avctx->xvmc_acceleration == 4)
    {
        XvMCFlushSurface(render->disp, render->p_surface);
        XvMCSyncSurface(render->disp, render->p_surface);

    	s->error_count = 0;
    }
    else
#endif
    {
    if(render->filled_mv_blocks_num > 0){
//        printf("xvmcvideo.c: rendering %d left blocks after last slice!!!\n",render->filled_mv_blocks_num );
        ff_draw_horiz_band(s,0,0);
    }
}
}

void XVMC_decode_mb(MpegEncContext *s){
XvMCMacroBlock * mv_block;


}

#ifdef HAVE_XVMC_VLD
static int length_to_next_start(uint8_t* pbuf_ptr, int buf_size)
{
    uint8_t*    buf_ptr;
    unsigned int    state = 0xFFFFFFFF, v;

    buf_ptr = pbuf_ptr;
    while (buf_ptr < pbuf_ptr + buf_size)
    {
        v = *buf_ptr++;
        if (state == 0x000001) {
            return buf_ptr - pbuf_ptr - 4;
        }
        state = ((state << 8) | v) & 0xffffff;
    }
    return -1;
}

#define SLICE_MIN_START_CODE   0x00000101
#define SLICE_MAX_START_CODE   0x000001af

void XVMC_decode_slice(MpegEncContext *s, int mb_y, uint8_t* buffer, int buf_size)
{
    int slicelen = length_to_next_start(buffer, buf_size);
    xvmc_render_state_t*    render;

    if (slicelen < 0)
    {
        if ((mb_y == s->mb_height - 1) || 
            (!s->progressive_sequence && mb_y == (s->mb_height >> 1) -1) ||
	    (s->codec_id != CODEC_ID_MPEG2VIDEO))
            slicelen = buf_size;
        else
            return;
    }

    render = (xvmc_render_state_t*)s->current_picture.data[2];
    render->slice_code = SLICE_MIN_START_CODE + mb_y;
    render->slice_data = buffer;
    render->slice_datalen = slicelen;

    ff_draw_horiz_band(s, 0, 0);
}
#endif

#endif


Lines 88-93 Link Here

(-)ffmpeg-10924-alt1.rvrt/libavutil/avutil.h (+1 lines)
88	PIX_FMT_YUVJ444P, ///< Planar YUV 4:4:4, 24bpp, full scale (jpeg)	88	PIX_FMT_YUVJ444P, ///< Planar YUV 4:4:4, 24bpp, full scale (jpeg)
89	PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing(xvmc_render.h)	89	PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing(xvmc_render.h)
90	PIX_FMT_XVMC_MPEG2_IDCT,	90	PIX_FMT_XVMC_MPEG2_IDCT,
		91	PIX_FMT_XVMC_MPEG2_VLD,
91	PIX_FMT_UYVY422, ///< Packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1	92	PIX_FMT_UYVY422, ///< Packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
92	PIX_FMT_UYYVYY411, ///< Packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3	93	PIX_FMT_UYYVYY411, ///< Packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
93	PIX_FMT_BGR32, ///< Packed RGB 8:8:8, 32bpp, (msb)8A 8B 8G 8R(lsb), in cpu endianness	94	PIX_FMT_BGR32, ///< Packed RGB 8:8:8, 32bpp, (msb)8A 8B 8G 8R(lsb), in cpu endianness

Return to bug 13452

Lines 68-78 Link Here

(-)ffmpeg-10924-alt1.rvrt/libavcodec/xvmcvideo.c (+244 lines)
68	}	68	}
69	}	69	}
70		70
		71	#ifdef HAVE_XVMC_VLD
		72	static XvMCSurface* findPastSurface(MpegEncContext *s,
		73	xvmc_render_state_t *render)
		74	{
		75	Picture *lastp = s->last_picture_ptr;
		76	xvmc_render_state_t *last = NULL;
		77
		78	if (NULL!=lastp) {
		79	last = (xvmc_render_state_t*)(lastp->data[2]);
		80	if (B_TYPE==last->pict_type)
		81	av_log(s->avctx,AV_LOG_DEBUG, "Past frame is a B frame in findPastSurface, this is bad.\n");
		82	//assert(B_TYPE!=last->pict_type);
		83	}
		84
		85	if (NULL==last)
		86	if (!s->first_field)
		87	last = render; // predict second field from the first
		88	else
		89	return 0;
		90
		91	if (last->magic != MP_XVMC_RENDER_MAGIC)
		92	return 0;
		93
		94	return (last->state & MP_XVMC_STATE_PREDICTION) ? last->p_surface : 0;
		95	}
		96
		97	static XvMCSurface* findFutureSurface(MpegEncContext *s)
		98	{
		99	Picture *nextp = s->next_picture_ptr;
		100	xvmc_render_state_t *next = NULL;
		101
		102	if (NULL!=nextp) {
		103	next = (xvmc_render_state_t*)(nextp->data[2]);
		104	if (B_TYPE==next->pict_type)
		105	av_log(s->avctx,AV_LOG_DEBUG, "Next frame is a B frame in findFutureSurface, thisis bad.\n");
		106	//assert(B_TYPE!=next->pict_type);
		107	}
		108
		109	assert(NULL!=next);
		110
		111	if (next->magic != MP_XVMC_RENDER_MAGIC)
		112	return 0;
		113
		114	return (next->state & MP_XVMC_STATE_PREDICTION) ? next->p_surface : 0;
		115	}
		116	#endif //HAVE_XVMC_VLD
		117
71	//these functions should be called on every new field or/and frame	118	//these functions should be called on every new field or/and frame
72	//They should be safe if they are called few times for same field!	119	//They should be safe if they are called few times for same field!
73	int XVMC_field_start(MpegEncContexts, AVCodecContext avctx){	120	int XVMC_field_start(MpegEncContexts, AVCodecContext avctx){
74	xvmc_render_state_t * render,* last, * next;	121	xvmc_render_state_t * render,* last, * next;
75		122
		123	#ifdef HAVE_XVMC_VLD
		124	XvMCMpegControl binfo;
		125	XvMCQMatrix qmatrix;
		126	int i;
		127	Status status;
		128
		129	memset(&binfo, 0, sizeof(binfo));
		130	memset(&qmatrix, 0, sizeof(qmatrix));
		131	#endif
		132
76	assert(avctx != NULL);	133	assert(avctx != NULL);
77		134
78	render = (xvmc_render_state_t*)s->current_picture.data[2];	135	render = (xvmc_render_state_t*)s->current_picture.data[2];
Lines 83-94 Link Here
83	render->picture_structure = s->picture_structure;	140	render->picture_structure = s->picture_structure;
84	render->flags = (s->first_field)? 0: XVMC_SECOND_FIELD;	141	render->flags = (s->first_field)? 0: XVMC_SECOND_FIELD;
85		142
		143	#ifdef HAVE_XVMC_VLD
		144	if (s->avctx->xvmc_acceleration == 4)
		145	{
		146	if (render->picture_structure == PICT_FRAME)
		147	render->flags \|= XVMC_FRAME_PICTURE;
		148	else if (render->picture_structure == PICT_TOP_FIELD)
		149	render->flags \|= XVMC_TOP_FIELD;
		150	else if (render->picture_structure == PICT_BOTTOM_FIELD)
		151	render->flags \|= XVMC_BOTTOM_FIELD;
		152	}
		153	else
		154	#endif
		155	{
86	//make sure that all data is drawn by XVMC_end_frame	156	//make sure that all data is drawn by XVMC_end_frame
87	assert(render->filled_mv_blocks_num==0);	157	assert(render->filled_mv_blocks_num==0);
		158	}
88		159
89	render->p_future_surface = NULL;	160	render->p_future_surface = NULL;
90	render->p_past_surface = NULL;	161	render->p_past_surface = NULL;
91		162
		163	render->pict_type = s->pict_type; // for later frame dropping use
		164
		165	#ifdef HAVE_XVMC_VLD
		166	if (s->avctx->xvmc_acceleration == 4)
		167	{
		168	switch(s->pict_type){
		169	case I_TYPE:
		170	break;
		171	case B_TYPE:
		172	render->p_past_surface = findPastSurface(s, render);
		173	render->p_future_surface = findFutureSurface(s);
		174	if (!render->p_past_surface)
		175	av_log(avctx, AV_LOG_ERROR, "error: decoding B frame and past frame is null!");
		176	else if (!render->p_future_surface)
		177	av_log(avctx, AV_LOG_ERROR, "error: decoding B frame and future frame is null!");
		178	break;
		179
		180	case P_TYPE:
		181	render->p_past_surface = findPastSurface(s, render);
		182	render->p_future_surface = render->p_surface;
		183	if (!render->p_past_surface)
		184	av_log(avctx, AV_LOG_ERROR, "error: decoding P frame and past frame is null!");
		185	break;
		186	}
		187	} else
		188	#endif
		189	{
92	switch(s->pict_type){	190	switch(s->pict_type){
93	case I_TYPE:	191	case I_TYPE:
94	return 0;// no prediction from other frames	192	return 0;// no prediction from other frames
Lines 109-114 Link Here
109	render->p_past_surface = last->p_surface;	207	render->p_past_surface = last->p_surface;
110	return 0;	208	return 0;
111	}	209	}
		210	}
		211
		212	#ifdef HAVE_XVMC_VLD
		213	if (s->avctx->xvmc_acceleration == 4)
		214	{
		215	for (i = 0; i < 64; i++){
		216	qmatrix.intra_quantiser_matrix[i] = s->intra_matrix[s->dsp.idct_permutation[i]];
		217	qmatrix.non_intra_quantiser_matrix[i] = s->inter_matrix[s->dsp.idct_permutation[i]];
		218	qmatrix.chroma_intra_quantiser_matrix[i] = s->chroma_intra_matrix[s->dsp.idct_permutation[i]];
		219	qmatrix.chroma_non_intra_quantiser_matrix[i] = s->chroma_inter_matrix[s->dsp.idct_permutation[i]];
		220	}
		221
		222	qmatrix.load_intra_quantiser_matrix = 1;
		223	qmatrix.load_non_intra_quantiser_matrix = 1;
		224	qmatrix.load_chroma_intra_quantiser_matrix = 1;
		225	qmatrix.load_chroma_non_intra_quantiser_matrix = 1;
		226
		227
		228	binfo.flags = 0;
		229	if (s->alternate_scan)
		230	binfo.flags \|= XVMC_ALTERNATE_SCAN;
		231	if (s->top_field_first)
		232	binfo.flags \|= XVMC_TOP_FIELD_FIRST;
		233	if (s->frame_pred_frame_dct)
		234	binfo.flags \|= XVMC_PRED_DCT_FRAME;
		235	else
		236	binfo.flags \|= XVMC_PRED_DCT_FIELD;
		237
		238	if (s->intra_vlc_format)
		239	binfo.flags \|= XVMC_INTRA_VLC_FORMAT;
		240	if (!s->first_field && !s->progressive_sequence)
		241	binfo.flags \|= XVMC_SECOND_FIELD;
		242	if (s->q_scale_type)
		243	binfo.flags \|= XVMC_Q_SCALE_TYPE;
		244	if (s->concealment_motion_vectors)
		245	binfo.flags \|= XVMC_CONCEALMENT_MOTION_VECTORS;
		246	if (s->progressive_sequence)
		247	binfo.flags \|= XVMC_PROGRESSIVE_SEQUENCE;
		248
		249	binfo.picture_structure = s->picture_structure;
		250	switch (s->pict_type)
		251	{
		252	case I_TYPE: binfo.picture_coding_type = XVMC_I_PICTURE; break;
		253	case P_TYPE: binfo.picture_coding_type = XVMC_P_PICTURE; break;
		254	case B_TYPE: binfo.picture_coding_type = XVMC_B_PICTURE; break;
		255	default: av_log(avctx, AV_LOG_ERROR, "%s: Unknown picture coding type: %d\n", __FUNCTION__, s->pict_type);
		256	}
		257
		258	binfo.intra_dc_precision = s->intra_dc_precision;;
		259
		260	if (s->codec_id == CODEC_ID_MPEG2VIDEO)
		261	binfo.mpeg_coding = 2;
		262	else
		263	binfo.mpeg_coding = 1;
		264
		265	s->mb_width = (s->width + 15) / 16;
		266	s->mb_height = (s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence) ?
		267	2 * ((s->height + 31) / 32) : (s->height + 15) / 16;
		268
		269	if (s->codec_id == CODEC_ID_MPEG2VIDEO)
		270	{
		271	binfo.FVMV_range = (s->mpeg_f_code[0][1] - 1);
		272	binfo.FHMV_range = (s->mpeg_f_code[0][0] - 1);
		273	binfo.BVMV_range = (s->mpeg_f_code[1][1] - 1);
274	binfo.BHMV_range = (s->mpeg_f_code[1][0] - 1);
275	}
276	else
277	{
278	binfo.FVMV_range = (s->mpeg_f_code[0][0] - 1);
279	binfo.FHMV_range = (s->mpeg_f_code[0][0] - 1);
280	binfo.BVMV_range = (s->mpeg_f_code[1][1] - 1);
281	binfo.BHMV_range = (s->mpeg_f_code[1][1] - 1);
282	}
283
284	status = XvMCLoadQMatrix(render->disp, render->ctx, &qmatrix);
285	if (status)
286	av_log(avctx,AV_LOG_ERROR, "XvMCLoadQMatrix: Error: %d\n", status);
287
288	status = XvMCBeginSurface(render->disp, render->ctx, render->p_surface,
289	render->p_past_surface, render->p_future_surface,
290	&binfo);
291	if (status)
292	av_log(avctx,AV_LOG_ERROR, "XvMCBeginSurface: Error: %d\n", status);
293
294	if (!status)
295	return 0;
296	}
297	#endif
112		298
113	return -1;	299	return -1;
114	}	300	}
Lines 118-128 Link Here
118	render = (xvmc_render_state_t*)s->current_picture.data[2];	304	render = (xvmc_render_state_t*)s->current_picture.data[2];
119	assert(render != NULL);	305	assert(render != NULL);
120		306
		307	#ifdef HAVE_XVMC_VLD
		308	if (s->avctx->xvmc_acceleration == 4)
		309	{
		310	XvMCFlushSurface(render->disp, render->p_surface);
		311	XvMCSyncSurface(render->disp, render->p_surface);
		312
		313	s->error_count = 0;
		314	}
		315	else
		316	#endif
		317	{
121	if(render->filled_mv_blocks_num > 0){	318	if(render->filled_mv_blocks_num > 0){
122	// printf("xvmcvideo.c: rendering %d left blocks after last slice!!!\n",render->filled_mv_blocks_num );	319	// printf("xvmcvideo.c: rendering %d left blocks after last slice!!!\n",render->filled_mv_blocks_num );
123	ff_draw_horiz_band(s,0,0);	320	ff_draw_horiz_band(s,0,0);
124	}	321	}
125	}	322	}
		323	}
126		324
127	void XVMC_decode_mb(MpegEncContext *s){	325	void XVMC_decode_mb(MpegEncContext *s){
128	XvMCMacroBlock * mv_block;	326	XvMCMacroBlock * mv_block;
Lines 311-314 Link Here
311		509
312	}	510	}
313		511
		512	#ifdef HAVE_XVMC_VLD
		513	static int length_to_next_start(uint8_t* pbuf_ptr, int buf_size)
		514	{
		515	uint8_t* buf_ptr;
		516	unsigned int state = 0xFFFFFFFF, v;
		517
		518	buf_ptr = pbuf_ptr;
		519	while (buf_ptr < pbuf_ptr + buf_size)
		520	{
		521	v = *buf_ptr++;
		522	if (state == 0x000001) {
		523	return buf_ptr - pbuf_ptr - 4;
		524	}
		525	state = ((state << 8) \| v) & 0xffffff;
		526	}
		527	return -1;
		528	}
		529
		530	#define SLICE_MIN_START_CODE 0x00000101
		531	#define SLICE_MAX_START_CODE 0x000001af
		532
		533	void XVMC_decode_slice(MpegEncContext s, int mb_y, uint8_t buffer, int buf_size)
		534	{
		535	int slicelen = length_to_next_start(buffer, buf_size);
		536	xvmc_render_state_t* render;
		537
		538	if (slicelen < 0)
		539	{
		540	if ((mb_y == s->mb_height - 1) \|\|
		541	(!s->progressive_sequence && mb_y == (s->mb_height >> 1) -1) \|\|
		542	(s->codec_id != CODEC_ID_MPEG2VIDEO))
		543	slicelen = buf_size;
		544	else
		545	return;
		546	}
		547
		548	render = (xvmc_render_state_t*)s->current_picture.data[2];
		549	render->slice_code = SLICE_MIN_START_CODE + mb_y;
		550	render->slice_data = buffer;
		551	render->slice_datalen = slicelen;
		552
		553	ff_draw_horiz_band(s, 0, 0);
		554	}
		555	#endif
		556
314	#endif	557	#endif
		558