Index: debian/changelog =================================================================== --- debian/changelog (revision 21040) +++ debian/changelog (working copy) @@ -1,3 +1,13 @@ +mplayer (3:1.0svn+r21040) unstable; urgency=low + + * Non-maintainer upload. + * Unichrome XvMC Patch from Mailing List. + * Removed Bob deinterlacer. + + -- Ailin Nemui Sat, 18 Nov 2006 01:30:45 +0100 + mplayer (1.0svn) unstable; urgency=low * change version naming from cvs to svn. Index: libmpcodecs/vd_ffmpeg.c =================================================================== --- libmpcodecs/vd_ffmpeg.c (revision 21040) +++ libmpcodecs/vd_ffmpeg.c (working copy) @@ -10,6 +10,7 @@ #include "bswap.h" #include "vd_internal.h" +#include "libvo/video_out.h" static vd_info_t info = { "FFmpeg's libavcodec codec family", @@ -153,6 +154,8 @@ case IMGFMT_XVMC_IDCT_MPEG2: case IMGFMT_XVMC_MOCO_MPEG2: if(avctx->pix_fmt==PIX_FMT_XVMC_MPEG2_IDCT) return CONTROL_TRUE; + case IMGFMT_XVMC_VLD_MPEG2: + if(avctx->pix_fmt==PIX_FMT_XVMC_MPEG2_VLD) return CONTROL_TRUE; #endif } return CONTROL_FALSE; @@ -221,6 +224,9 @@ vd_ffmpeg_ctx *ctx; AVCodec *lavc_codec; int lowres_w=0; +#ifdef HAVE_XVMC + char *voname = 0; +#endif int do_vis_debug= lavc_param_vismv || (lavc_param_debug&(FF_DEBUG_VIS_MB_TYPE|FF_DEBUG_VIS_QP)); if(!avcodec_inited){ @@ -255,11 +261,23 @@ #ifdef HAVE_XVMC + // Try and get the name of the selected vo system + // so that if its _not_ xvmc we can fail gracefully + // and mplayer can fall back to a sw decoder + if (sh->video_out) { + vo_info_t *voinfo; + vo_functions_t * shvoc=sh->video_out; + if (shvoc) { + voinfo = shvoc->info; + if (voinfo) voname=voinfo->short_name; + } + } #ifdef CODEC_CAP_HWACCEL - if(lavc_codec->capabilities & CODEC_CAP_HWACCEL){ + if((lavc_codec->capabilities & CODEC_CAP_HWACCEL) && #else - if(lavc_codec->id == CODEC_ID_MPEG2VIDEO_XVMC){ + if((lavc_codec->id == CODEC_ID_MPEG2VIDEO_XVMC) && #endif + voname && !strcmp(voname,"xvmc") ) { mp_msg(MSGT_DECVIDEO, MSGL_INFO, MSGTR_MPCODECS_XVMCAcceleratedCodec); assert(ctx->do_dr1);//these are must to! assert(ctx->do_slices); //it is (vo_)ffmpeg bug if this fails @@ -527,6 +545,7 @@ #ifdef HAVE_XVMC case PIX_FMT_XVMC_MPEG2_MC:ctx->best_csp=IMGFMT_XVMC_MOCO_MPEG2;break; case PIX_FMT_XVMC_MPEG2_IDCT:ctx->best_csp=IMGFMT_XVMC_IDCT_MPEG2;break; + case PIX_FMT_XVMC_MPEG2_VLD:ctx->best_csp=IMGFMT_XVMC_VLD_MPEG2;break; #endif default: ctx->best_csp=0; @@ -902,7 +921,11 @@ avctx->get_buffer= mc_get_buffer; avctx->release_buffer= mc_release_buffer; avctx->draw_horiz_band = mc_render_slice; + if (avctx->xvmc_acceleration != 4) mp_msg(MSGT_DECVIDEO, MSGL_INFO, MSGTR_MPCODECS_XVMCAcceleratedMPEG2); + else + mp_msg(MSGT_DECVIDEO, MSGL_INFO, MSGTR_MPCODECS_XVMCVLDAcceleratedMPEG2); + assert(ctx->do_dr1);//these are must to! assert(ctx->do_slices); //it is (vo_)ffmpeg bug if this fails avctx->flags|= CODEC_FLAG_EMU_EDGE;//do i need that??!! Index: libmpcodecs/img_format.c =================================================================== --- libmpcodecs/img_format.c (revision 21040) +++ libmpcodecs/img_format.c (working copy) @@ -65,6 +65,7 @@ case IMGFMT_ZRMJPEGIB: return("Zoran MJPEG bottom field first"); case IMGFMT_XVMC_MOCO_MPEG2: return("MPEG1/2 Motion Compensation"); case IMGFMT_XVMC_IDCT_MPEG2: return("MPEG1/2 Motion Compensation and IDCT"); + case IMGFMT_XVMC_VLD_MPEG2: return("MPEG1/2 Motion Compensation and VLD"); } return("Unknown"); } Index: libmpcodecs/img_format.h =================================================================== --- libmpcodecs/img_format.h (revision 21040) +++ libmpcodecs/img_format.h (working copy) @@ -106,6 +106,7 @@ //these are chroma420 #define IMGFMT_XVMC_MOCO_MPEG2 (IMGFMT_XVMC|0x02) #define IMGFMT_XVMC_IDCT_MPEG2 (IMGFMT_XVMC|0x82) +#define IMGFMT_XVMC_VLD_MPEG2 (IMGFMT_XVMC|0x42) typedef struct { void* data; Index: codec-cfg.c =================================================================== --- codec-cfg.c (revision 21040) +++ codec-cfg.c (working copy) @@ -178,6 +178,7 @@ {"ZRMJPEGIT", IMGFMT_ZRMJPEGIT}, {"ZRMJPEGIB", IMGFMT_ZRMJPEGIB}, + {"VLD_MPEG2",IMGFMT_XVMC_VLD_MPEG2}, {"IDCT_MPEG2",IMGFMT_XVMC_IDCT_MPEG2}, {"MOCO_MPEG2",IMGFMT_XVMC_MOCO_MPEG2}, Index: Makefile =================================================================== --- Makefile (revision 21040) +++ Makefile (working copy) @@ -127,6 +127,9 @@ ifeq ($(TREMOR_INTERNAL),yes) PARTS += tremor endif +ifeq ($(HAVE_XVMC_ACCEL),yes) +CODEC_LIBS += $(X_LIB) +endif ALL_PRG = mplayer$(EXESUF) ifeq ($(MENCODER),yes) Index: vidix/drivers/radeon_vid.c =================================================================== --- vidix/drivers/radeon_vid.c (revision 21040) +++ vidix/drivers/radeon_vid.c (working copy) @@ -905,7 +905,7 @@ DEVICE_ATI_RADEON_R300_AF, DEVICE_ATI_RADEON_RV350_AP, DEVICE_ATI_RADEON_RV350_AR, - DEVICE_ATI_RADEON_RV350_BK, +// DEVICE_ATI_RADEON_RV350_BK, DEVICE_ATI_RADEON_R350_AH, DEVICE_ATI_RADEON_R350_AI, DEVICE_ATI_RADEON_R350_NH, Index: libvo/vo_xvmc.c =================================================================== --- libvo/vo_xvmc.c (revision 21040) +++ libvo/vo_xvmc.c (working copy) @@ -24,6 +24,10 @@ #include #include +#ifdef HAVE_XVMC_VLD +#include +#endif + #include "x11_common.h" #include "xvmc_render.h" @@ -44,15 +48,16 @@ #define UNUSED(x) ((void)(x)) +extern unsigned int video_format; - static int benchmark; static int use_sleep; static int first_frame;//draw colorkey on first frame static int use_queue; static int xv_port_request = 0; -static int bob_deinterlace; -static int top_field_first; +static int use_deint_bob; /* non-zero if we're doing bob de-interlacing */ +static int use_deint_one; /* non-zero if we're doing one field de-interlacing */ +static int use_tv_clip; /* non-zero if we're clipping the top couple of lines */ static int image_width,image_height; static uint32_t drwX,drwY; @@ -115,7 +120,7 @@ "XVideo Motion Compensation", "xvmc", "Ivan Kalvachev ", - "" + "Ivor Hewitt - VIA VLD support" }; LIBVO_EXTERN(xvmc); @@ -188,7 +193,23 @@ } //end of vo_xv shm/xvimage code +int hasVLDAcceleration() +{ +#ifdef HAVE_XVMC_VLD + return XVMC_VLD == (surface_info.mc_type & XVMC_VLD); +#else + return 0; +#endif +} + static int xvmc_check_surface_format(uint32_t format, XvMCSurfaceInfo * surf_info){ +#ifdef HAVE_XVMC_VLD + if (format == IMGFMT_XVMC_VLD_MPEG2 ){ + if( surf_info->mc_type != (XVMC_VLD|XVMC_MPEG_2) ) return -1; + if( surf_info->chroma_format != XVMC_CHROMA_FORMAT_420 ) return -1; + return 0; + } +#endif if ( format == IMGFMT_XVMC_IDCT_MPEG2 ){ if( surf_info->mc_type != (XVMC_IDCT|XVMC_MPEG_2) ) return -1; if( surf_info->chroma_format != XVMC_CHROMA_FORMAT_420 ) return -1; @@ -347,7 +368,6 @@ // the surface have passed vf system without been skiped, it will be displayed rndr->state |= MP_XVMC_STATE_DISPLAY_PENDING; p_render_surface_to_show = rndr; - top_field_first = mpi->fields & MP_IMGFIELD_TOP_FIRST; return VO_TRUE; } @@ -366,10 +386,17 @@ { "benchmark", OPT_ARG_BOOL, &benchmark, NULL }, { "sleep", OPT_ARG_BOOL, &use_sleep, NULL }, { "queue", OPT_ARG_BOOL, &use_queue, NULL }, - { "bobdeint", OPT_ARG_BOOL, &bob_deinterlace, NULL }, + { "deint-bob", OPT_ARG_BOOL, &use_deint_bob, NULL }, + { "deint-one", OPT_ARG_BOOL, &use_deint_one, NULL }, + { "tv-clip", OPT_ARG_BOOL, &use_tv_clip, NULL }, { NULL } }; + // If the video is not MPEG1 or MPEG2, we can't decode it, so + // fail cleanly to allow mplayer to fallback to another vo system + if (video_format != 0x10000001 && video_format != 0x10000002) return -1; + + //Obtain display handler if (!vo_init()) return -1;//vo_xv @@ -404,7 +431,9 @@ benchmark = 0; //disable PutImageto allow faster display than screen refresh use_sleep = 0; use_queue = 0; - bob_deinterlace = 0; + use_deint_bob = 0; + use_deint_one = 0; + use_tv_clip = 0; /* parse suboptions */ if ( subopt_parse( arg, subopts ) != 0 ) @@ -476,6 +505,8 @@ if(surface_info.chroma_format == XVMC_CHROMA_FORMAT_444) blocks_per_macroblock = 12; +if (!hasVLDAcceleration()) +{ rez = XvMCCreateBlocks(mDisplay,&ctx,numblocks*blocks_per_macroblock,&data_blocks); if( rez != Success ){ XvMCDestroyContext(mDisplay,&ctx); @@ -491,6 +522,8 @@ } printf("vo_xvmc: mv_blocks allocated\n"); +} + if(surface_render==NULL) surface_render=malloc(MAX_SURFACES*sizeof(xvmc_render_state_t));//easy mem debug memset(surface_render,0,MAX_SURFACES*sizeof(xvmc_render_state_t)); @@ -509,6 +542,11 @@ surface_render[i].chroma_format = surface_info.chroma_format; surface_render[i].unsigned_intra = (surface_info.flags & XVMC_INTRA_UNSIGNED) == XVMC_INTRA_UNSIGNED; surface_render[i].p_surface = &surface_array[i]; + + surface_render[i].state = 0; + surface_render[i].disp = mDisplay; + surface_render[i].ctx = &ctx; + if( mp_msg_test(MSGT_VO,MSGL_DBG4) ) printf("vo_xvmc: surface[%d] = %p .rndr=%p\n",i,&surface_array[i], &surface_render[i]); } @@ -585,8 +623,10 @@ printf("vo_xvmc: OSD support by additional frontend rendering\n"); break; case BACKEND_SUBPICTURE: - printf("vo_xvmc: OSD support by beckend rendering (fast)\n"); - printf("vo_xvmc: Pleace send feedback to configrm that it work,otherwise send bugreport!\n"); + printf("vo_xvmc: OSD support by backend rendering " + "(fast, but untested with mplayer.)\n"); + printf("vo_xvmc: Please send feedback to confirm that OSD works.\n" + "vo_xvmc: Otherwise, please send a bugreport!\n"); break; } @@ -1017,9 +1057,9 @@ } static void put_xvmc_image(xvmc_render_state_t * p_render_surface, int draw_ck){ -int rez; +int rez,field; int clipX,clipY,clipW,clipH; -int i; +int srcY=0,srcH=image_height; if(p_render_surface == NULL) return; @@ -1035,19 +1075,55 @@ if(benchmark) return; - for (i = 1; i <= bob_deinterlace + 1; i++) { - int field = top_field_first ? i : i ^ 3; + if (use_tv_clip) { + /* + Clip top few lines off to get rid of annoying flicker + when using bob de-interlacing on TV sourced video. + */ + srcY+=4; + srcH-=4; + } + + if (use_deint_bob || use_deint_one) { + /* + Passing XVMC_TOP_FIELD then XVMC_BOTTOM_FIELD turns on + bob de-interlacing in the unichrome driver. Just passing + XVMC_TOP_FIELD through just does 1 field de-interlacing. + */ + field=p_render_surface->flags ? XVMC_TOP_FIELD : XVMC_BOTTOM_FIELD; + } + else field=XVMC_FRAME_PICTURE; /* no de-interlacing */ + rez = XvMCPutSurface(mDisplay, p_render_surface->p_surface, vo_window, - 0, 0, image_width, image_height, + 0, srcY, image_width, srcH, clipX, clipY, clipW, clipH, - bob_deinterlace ? field : 3); - //p_render_surface_to_show->display_flags); + field); + + if (use_deint_bob && rez == Success) { + /* + Pause before we do the next putsurface - I guess this is to + allow the hardware to complete whatever it needs to do before + we hit it with more data, and cause something to spin on a lock + Adding this reduces CPU usage from about 20% to 10% on a 1GHz CPU. + Xine actually does this: + unsigned ms_per_field = 500 * frame->vo_frame.duration / 90000 - 2; + I can't see how to get frame duration in mplayer, so we use an + abitrary pause of 10ms - seems to work ok. + */ + usleep(10*1000); + rez = XvMCPutSurface(mDisplay, p_render_surface->p_surface, + vo_window, + 0,srcY,image_width,srcH, + clipX, clipY, clipW, clipH, + (field & XVMC_TOP_FIELD) ? XVMC_BOTTOM_FIELD : XVMC_TOP_FIELD); + } + + if(rez != Success){ printf("vo_xvmc: PutSurface failer, critical error %d!\n",rez); assert(0); } - } XFlush(mDisplay); } @@ -1147,9 +1223,11 @@ if( number_of_surfaces ){ + if (!hasVLDAcceleration()) + { XvMCDestroyMacroBlocks(mDisplay,&mv_blocks); XvMCDestroyBlocks(mDisplay,&data_blocks); - + } for(i=0; imagic == MP_XVMC_RENDER_MAGIC ); + if (hasVLDAcceleration()) + { + rez = XvMCPutSlice2(mDisplay,&ctx,(char*)rndr->slice_data, + rndr->slice_datalen, + rndr->slice_code); + if (rez) + printf("vo_xxmc::slice Error %d\n",rez); + + } + else + { rez = XvMCRenderSurface(mDisplay,&ctx,rndr->picture_structure, rndr->p_surface, rndr->p_past_surface, @@ -1238,7 +1333,7 @@ if(rez != Success) { int i; - printf("vo_xvmc::slice: RenderSirface returned %d\n",rez); + printf("vo_xvmc::slice: RenderSurface returned %d\n",rez); printf("vo_xvmc::slice: pict=%d,flags=%x,start_blocks=%d,num_blocks=%d\n", rndr->picture_structure,rndr->flags,rndr->start_mv_blocks_num, @@ -1266,6 +1361,7 @@ rez = XvMCFlushSurface(mDisplay, rndr->p_surface); assert(rez==Success); +} // rndr->start_mv_blocks_num += rndr->filled_mv_blocks_num; rndr->start_mv_blocks_num = 0; rndr->filled_mv_blocks_num = 0; @@ -1358,8 +1454,16 @@ // these are shared!! so watch out // do call RenderSurface before overwriting +if (!hasVLDAcceleration()) +{ mpi->planes[0] = (char*)data_blocks.blocks; mpi->planes[1] = (char*)mv_blocks.macro_blocks; +} +else +{ + mpi->planes[0] = 1; + mpi->planes[1] = 0; +} mpi->priv = mpi->planes[2] = (char*)rndr; @@ -1379,12 +1483,6 @@ static int control(uint32_t request, void *data, ... ) { switch (request){ - case VOCTRL_GET_DEINTERLACE: - *(int*)data = bob_deinterlace; - return VO_TRUE; - case VOCTRL_SET_DEINTERLACE: - bob_deinterlace = *(int*)data; - return VO_TRUE; case VOCTRL_QUERY_FORMAT: return query_format(*((uint32_t*)data)); case VOCTRL_DRAW_IMAGE: Index: configure =================================================================== --- configure (revision 21040) +++ configure (working copy) @@ -430,7 +430,8 @@ --with-xmmsplugindir=DIR XMMS plugins in DIR --with-xmmslibdir=DIR libxmms.so.1 in DIR --with-cdparanoialibdir=DIR cdparanoia libraries (libcdda_*) in DIR (*) - --with-xvmclib=NAME adapter-specific library name (e.g. XvMCNVIDIA) + --with-xvmclib=NAME name of adapter-specific library + (e.g. XvMCNVIDIA/I810XvMC/viaXvMC/viaXvMCPro) --with-freetype-config=PATH path to freetype-config --with-fribidi-config=PATH path to fribidi-config @@ -1544,6 +1545,7 @@ fi _prefix="/usr/local" +_xvmclib="" # GOTCHA: the variables below defines the default behavior for autodetection # and have - unless stated otherwise - at least 2 states : yes no @@ -3909,35 +3911,89 @@ echores "$_xv" -echocheck "XvMC" -if test "$_xv" = yes && test "$_xvmc" != no ; then - _xvmc=no - cat > $TMPC < +xvmc_check() +{ + if test "$_xvmcvld" = yes; then + _xvmcinc="vldXvMC.h" + else + _xvmcinc="XvMClib.h" + fi + + echo "#include #include -#include +#include int main(void) { (void) XvMCQueryExtension(0,0,0); (void) XvMCCreateContext(0,0,0,0,0,0,0); - return 0; } -EOF - for _ld_tmp in $_xvmclib XvMCNVIDIA XvMCW I810XvMC ; do - cc_check -lXvMC -l$_ld_tmp $_ld_xv $_ld_x11 && _xvmc=yes && _xvmclib="$_ld_tmp" && break - done -fi -if test "$_xvmc" = yes ; then + return 0; }" > $TMPC + + _success=0 + cc_check $_inc_x11 -lXvMC -l$_xvmclib $_ld_xv $_ld_x11 && _success=1 + return $_ok +} + +# Note: here we try to determine what xvmc capability is available +# if the xvmc wrapper is available then we link to that, also we +# check whether we can include the vld (slice) level xvmc include file +if test "$_x11" = yes && test "$_xv" = yes && test "$_xvmc" != no ; then + _xvmc=no + +# No explicit xvmc lib specified so try and find one + if test "$_xvmclib" = ""; then +# Try with the xvmc wrapper+vld first + echocheck "XvMC (Wrapper+vld)" + _xvmclib="XvMCW" + _xvmcvld=yes + xvmc_check && _xvmc=yes + echores $_xvmc + +# Try with the xvmc wrapper + if test "$_xvmc" = no ; then + echocheck "XvMC (Wrapper)" + _xvmcvld=no + xvmc_check && _xvmc=yes + echores $_xvmc + fi + +# Try with the nvidia lib + if test "$_xvmc" = no ; then + echocheck "XvMC (NVIDIA)" + _xvmclib="XvMCNVIDIA" + xvmc_check && _xvmc=yes + echores $_xvmc + fi + else +# check for specified xvmc lib + echocheck "XvMC vld+("$_xvmclib")" + _xvmcvld=yes + xvmc_check && _xvmc=yes + echores $_xvmc + + if test "$_xvmc" = no ; then + echocheck "XvMC ("$_xvmclib")" + _xvmcvld=no + xvmc_check && _xvmc=yes + echores $_xvmc + fi + fi + + if test "$_xvmc" = yes ; then _def_xvmc='#define HAVE_XVMC 1' _ld_xvmc="-lXvMC -l$_xvmclib" _vosrc="$_vosrc vo_xvmc.c" _vomodules="xvmc $_vomodules" - _res_comment="using $_xvmclib" -else - _def_xvmc='#undef HAVE_XVMC' + else _novomodules="xvmc $_novomodules" + _def_xvmc='#undef HAVE_XVMC' + fi + + if test "$_xvmcvld" = yes; then + _def_xvmc_vld='#define HAVE_XVMC_VLD 1' + else + _def_xvmc_vld='#undef HAVE_XVMC_VLD' + fi fi -echores "$_xvmc" - echocheck "Xinerama" if test "$_xinerama" = auto ; then cat > $TMPC <id=-2 when we fail? vo_config_count=0; //if((video_out->preinit(vo_subdevice))!=0){ + + // let the video driver know what format the video is in so it can + // reject it if it wants - lets vo_xvmc fail if ffmpeg12mc codec not used + video_format=sh_video->format; + if(!(video_out=init_best_video_out(video_driver_list))){ mp_msg(MSGT_CPLAYER,MSGL_FATAL,MSGTR_ErrorInitializingVODevice); return 0; Index: help/help_mp-en.h =================================================================== --- help/help_mp-en.h (revision 21040) +++ help/help_mp-en.h (working copy) @@ -1612,6 +1612,7 @@ #define MSGTR_MPCODECS_DRIFailure "[VD_FFMPEG] DRI failure.\n" #define MSGTR_MPCODECS_CouldntAllocateImageForCodec "[VD_FFMPEG] Couldn't allocate image for codec.\n" #define MSGTR_MPCODECS_XVMCAcceleratedMPEG2 "[VD_FFMPEG] XVMC-accelerated MPEG-2.\n" +#define MSGTR_MPCODECS_XVMCVLDAcceleratedMPEG2 "[VD_FFMPEG] XVMC-VLD-accelerated MPEG-2.\n" #define MSGTR_MPCODECS_TryingPixfmt "[VD_FFMPEG] Trying pixfmt=%d.\n" #define MSGTR_MPCODECS_McGetBufferShouldWorkOnlyWithXVMC "[VD_FFMPEG] The mc_get_buffer should work only with XVMC acceleration!!" #define MSGTR_MPCODECS_UnexpectedInitVoError "[VD_FFMPEG] Unexpected init_vo error.\n" Index: xvmc_render.h =================================================================== --- xvmc_render.h (revision 21040) +++ xvmc_render.h (working copy) @@ -5,6 +5,9 @@ #include #include +#ifdef HAVE_XVMC_VLD +#include +#endif //the surface should be shown, video driver manipulate this #define MP_XVMC_STATE_DISPLAY_PENDING 1 @@ -27,7 +30,20 @@ int idct;//does we use IDCT acceleration? int chroma_format;//420,422,444 int unsigned_intra;//+-128 for intra pictures after clip + +#ifdef HAVE_XVMC_VLD + int reserved1[3]; + // These are for the XVMC VLD slice interface + int pict_type; //this is for skipping frames + int slice_code; + int slice_datalen; + unsigned char *slice_data; + Display *disp; + XvMCContext *ctx; +#else int reserved1[12];//future extenstions (e.g. gmc,qpel) +#endif + void * p_osd_target_surface_render;//pointer to the surface where subpicture is rendered XvMCSurface* p_surface;//pointer to rendered surface, never changed @@ -47,4 +63,6 @@ int next_free_data_block_num;//used in add_mv_block, pointer to next free block + + } xvmc_render_state_t; Index: etc/codecs.conf =================================================================== --- etc/codecs.conf (revision 21040) +++ etc/codecs.conf (working copy) @@ -124,6 +124,7 @@ fourcc mx5p ; MPEG IMX 625/50 (50 Mb/s) driver ffmpeg dll "mpegvideo_xvmc" + out VLD_MPEG2 out IDCT_MPEG2 out MOCO_MPEG2 Index: libavutil/avutil.h =================================================================== --- libavutil/avutil.h (revision 7120) +++ libavutil/avutil.h (working copy) @@ -88,6 +88,7 @@ PIX_FMT_YUVJ444P, ///< Planar YUV 4:4:4, 24bpp, full scale (jpeg) PIX_FMT_XVMC_MPEG2_MC,///< XVideo Motion Acceleration via common packet passing(xvmc_render.h) PIX_FMT_XVMC_MPEG2_IDCT, + PIX_FMT_XVMC_MPEG2_VLD, PIX_FMT_UYVY422, ///< Packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1 PIX_FMT_UYYVYY411, ///< Packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3 PIX_FMT_BGR32, ///< Packed RGB 8:8:8, 32bpp, (msb)8A 8B 8G 8R(lsb), in cpu endianness Index: libavcodec/mpeg12.c =================================================================== --- libavcodec/mpeg12.c (revision 7120) +++ libavcodec/mpeg12.c (working copy) @@ -85,10 +85,17 @@ extern void XVMC_init_block(MpegEncContext *s);//set s->block #endif + +#ifdef HAVE_XVMC_VLD +extern int XVMC_decode_slice(MpegEncContext *s, int start_code, + uint8_t *buffer, int buf_size); +#endif + static const enum PixelFormat pixfmt_yuv_420[]= {PIX_FMT_YUV420P,-1}; static const enum PixelFormat pixfmt_yuv_422[]= {PIX_FMT_YUV422P,-1}; static const enum PixelFormat pixfmt_yuv_444[]= {PIX_FMT_YUV444P,-1}; static const enum PixelFormat pixfmt_xvmc_mpg2_420[] = { + PIX_FMT_XVMC_MPEG2_VLD, PIX_FMT_XVMC_MPEG2_IDCT, PIX_FMT_XVMC_MPEG2_MC, -1}; @@ -2541,6 +2548,16 @@ return -1; } +#ifdef HAVE_XVMC_VLD + if (s->avctx->xvmc_acceleration == 4){ + int used = XVMC_decode_slice(s, mb_y, *buf, buf_size); + if (used < 0) + return DECODE_SLICE_ERROR; + *buf += used - 1; + return DECODE_SLICE_OK; + } +#endif + init_get_bits(&s->gb, *buf, buf_size*8); ff_mpeg1_clean_buffers(s); @@ -3487,6 +3504,41 @@ }; #endif /* !CONFIG_MPEGVIDEO_PARSER */ +#ifdef HAVE_XVMC_VLD +static int mpeg_xxmc_decode_init(AVCodecContext *avctx){ + Mpeg1Context *s; + if( avctx->thread_count > 1) + return -1; + if( !(avctx->slice_flags & SLICE_FLAG_CODED_ORDER) ) + return -1; + if( !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD) ) + dprintf("mpeg12.c: XVMC_VLD decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n"); + + mpeg_decode_init(avctx); + s = avctx->priv_data; + + avctx->pix_fmt = PIX_FMT_XVMC_MPEG2_VLD; + avctx->xvmc_acceleration = 4; + + return 0; +} + +AVCodec mpeg_xxmc_decoder = { + "mpegvideo_xvmc", + CODEC_TYPE_VIDEO, + CODEC_ID_MPEG2VIDEO_XVMC, + sizeof(Mpeg1Context), + mpeg_xxmc_decode_init, + NULL, + mpeg_decode_end, + mpeg_decode_frame, + CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED| CODEC_CAP_HWACCEL, + .flush= ff_mpeg_flush, +}; + +#endif + + /* this is ugly i know, but the alternative is too make hundreds of vars global and prefix them with ff_mpeg1_ which is far uglier. */ Index: libavcodec/xvmcvideo.c =================================================================== --- libavcodec/xvmcvideo.c (revision 7120) +++ libavcodec/xvmcvideo.c (working copy) @@ -72,11 +72,68 @@ } } +#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; + 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]; @@ -87,14 +144,55 @@ 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 case B_TYPE: next = (xvmc_render_state_t*)s->next_picture.data[2]; @@ -113,19 +211,119 @@ render->p_past_surface = last->p_surface; return 0; } +} -return -1; +#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; +} + void XVMC_field_end(MpegEncContext *s){ xvmc_render_state_t * render; 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){ @@ -315,4 +513,50 @@ } +#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 + Index: libavcodec/allcodecs.c =================================================================== --- libavcodec/allcodecs.c (revision 7120) +++ libavcodec/allcodecs.c (working copy) @@ -312,6 +312,11 @@ #ifdef CONFIG_MPEGVIDEO_DECODER register_avcodec(&mpegvideo_decoder); #endif //CONFIG_MPEGVIDEO_DECODER +#ifdef HAVE_XVMC_VLD +#ifdef CONFIG_MPEG_XVMC_DECODER + register_avcodec(&mpeg_xxmc_decoder); +#endif //CONFIG_MPEG_XVMC_DECODER +#endif #ifdef HAVE_XVMC #ifdef CONFIG_MPEG_XVMC_DECODER register_avcodec(&mpeg_xvmc_decoder); Index: libavcodec/avcodec.h =================================================================== --- libavcodec/avcodec.h (revision 7120) +++ libavcodec/avcodec.h (working copy) @@ -2205,6 +2205,7 @@ extern AVCodec mpeg2video_decoder; extern AVCodec mpegvideo_decoder; extern AVCodec mpeg_xvmc_decoder; +extern AVCodec mpeg_xxmc_decoder; extern AVCodec h263i_decoder; extern AVCodec flv_decoder; extern AVCodec rv10_decoder;