mplayer.hg: libmpcodecs/vd_ffmpeg.c comparison

comparison libmpcodecs/vd_ffmpeg.c @ 28525:1e671b7bf2e0

Consistently place whitespace around * ( ) and ,

author	reimar
date	Sat, 14 Feb 2009 17:43:06 +0000
parents	3e0ccf5f272e
children	90da3cbfbdd9

comparison

equal deleted inserted replaced

-:3e0ccf5f272e
+:1e671b7bf2e0
 static int get_buffer(AVCodecContext *avctx, AVFrame *pic);
 static void release_buffer(AVCodecContext *avctx, AVFrame *pic);
 #if CONFIG_XVMC
-static enum PixelFormat get_format(struct AVCodecContext * avctx,
+static enum PixelFormat get_format(struct AVCodecContext *avctx,
-const enum PixelFormat * pix_fmt);
+const enum PixelFormat *pix_fmt);
 static int mc_get_buffer(AVCodecContext *avctx, AVFrame *pic);
 static void mc_release_buffer(AVCodecContext *avctx, AVFrame *pic);
 static void mc_render_slice(struct AVCodecContext *s,
 AVFrame *src, int offset[4],
 int y, int type, int height);
 mp_msg(MSGT_DECVIDEO, MSGL_ERR, "Unknown discard value %s\n", str);
 return AVDISCARD_DEFAULT;
 }
 // to set/get/query special features/parameters
-static int control(sh_video_t *sh,int cmd,void* arg,...){
+static int control(sh_video_t *sh, int cmd, void *arg, ...){
 vd_ffmpeg_ctx *ctx = sh->context;
 AVCodecContext *avctx = ctx->avctx;
 switch(cmd){
 case VDCTRL_QUERY_FORMAT:
 {
-int format =(*((int*)arg));
+int format =(*((int *)arg));
-if( format == ctx->best_csp ) return CONTROL_TRUE;//supported
+if(format == ctx->best_csp) return CONTROL_TRUE;//supported
 // possible conversions:
-switch( format ){
+switch(format){
 case IMGFMT_YV12:
 case IMGFMT_IYUV:
 case IMGFMT_I420:
 // "converted" using pointer/stride modification
 if(avctx->pix_fmt==PIX_FMT_YUV420P) return CONTROL_TRUE;// u/v swap
 return avctx->has_b_frames + 10;
 }
 return CONTROL_UNKNOWN;
 }
-void mp_msp_av_log_callback(void* ptr, int level, const char* fmt, va_list vl)
+void mp_msp_av_log_callback(void *ptr, int level, const char *fmt, va_list vl)
 {
 static int print_prefix=1;
-AVClass* avc= ptr ? *(AVClass**)ptr : NULL;
+AVClass *avc= ptr ? *(AVClass **)ptr : NULL;
 int type= MSGT_FIXME;
 int mp_level;
 char buf[256];
 switch(level){
 if (!mp_msg_test(type, mp_level)) return;
 if(ptr){
 if(!strcmp(avc->class_name, "AVCodecContext")){
-AVCodecContext * s= ptr;
+AVCodecContext *s= ptr;
 if(s->codec){
 if(s->codec->type == CODEC_TYPE_AUDIO){
 if(s->codec->decode)
 type= MSGT_DECAUDIO;
 }else if(s->codec->type == CODEC_TYPE_VIDEO){
 type= MSGT_DECVIDEO;
 }
 //FIXME subtitles, encoders (what msgt for them? there is no appropriate ...)
 }
 }else if(!strcmp(avc->class_name, "AVFormatContext")){
-#if 0 //needs libavformat include FIXME iam too lazy to do this cleanly,probably the whole should be moved out of this file ...
+#if 0 //needs libavformat include FIXME iam too lazy to do this cleanly, probably the whole should be moved out of this file ...
-AVFormatContext * s= ptr;
+AVFormatContext *s= ptr;
 if(s->iformat)
 type= MSGT_DEMUXER;
 else if(s->oformat)
 type= MSGT_MUXER;
 #endif
 return 0;
 memset(ctx, 0, sizeof(vd_ffmpeg_ctx));
 lavc_codec = (AVCodec *)avcodec_find_decoder_by_name(sh->codec->dll);
 if(!lavc_codec){
-mp_msg(MSGT_DECVIDEO,MSGL_ERR,MSGTR_MissingLAVCcodec,sh->codec->dll);
+mp_msg(MSGT_DECVIDEO, MSGL_ERR, MSGTR_MissingLAVCcodec, sh->codec->dll);
 uninit(sh);
 return 0;
 }
 if(vd_use_slices && (lavc_codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND) && !do_vis_debug)
 avctx->skip_idct = str2AVDiscard(lavc_param_skip_idct_str);
 avctx->skip_frame = str2AVDiscard(lavc_param_skip_frame_str);
 if(lavc_avopt){
 if(parse_avopts(avctx, lavc_avopt) < 0){
-mp_msg(MSGT_DECVIDEO,MSGL_ERR, "Your options /%s/ look like gibberish to me pal\n", lavc_avopt);
+mp_msg(MSGT_DECVIDEO, MSGL_ERR, "Your options /%s/ look like gibberish to me pal\n", lavc_avopt);
 uninit(sh);
 return 0;
 }
 }
-mp_dbg(MSGT_DECVIDEO,MSGL_DBG2,"libavcodec.size: %d x %d\n",avctx->width,avctx->height);
+mp_dbg(MSGT_DECVIDEO, MSGL_DBG2, "libavcodec.size: %d x %d\n", avctx->width, avctx->height);
 switch (sh->format) {
 case mmioFOURCC('S','V','Q','3'):
 /* SVQ3 extradata can show up as sh->ImageDesc if demux_mov is used, or
 in the phony AVI header if demux_lavf is used. The first case is
 handled here; the second case falls through to the next section. */
 if (sh->ImageDesc) {
-avctx->extradata_size = (*(int*)sh->ImageDesc) - sizeof(int);
+avctx->extradata_size = (*(int *)sh->ImageDesc) - sizeof(int);
 avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
-memcpy(avctx->extradata, ((int*)sh->ImageDesc)+1, avctx->extradata_size);
+memcpy(avctx->extradata, ((int *)sh->ImageDesc)+1, avctx->extradata_size);
 break;
 }
 /* fallthrough */
 case mmioFOURCC('A','V','R','n'):
 {
 int x;
 uint8_t *p = avctx->extradata;
 for (x=0; x<avctx->extradata_size; x++)
-mp_msg(MSGT_DECVIDEO, MSGL_INFO,"[%x] ", p[x]);
+mp_msg(MSGT_DECVIDEO, MSGL_INFO, "[%x] ", p[x]);
-mp_msg(MSGT_DECVIDEO, MSGL_INFO,"\n");
+mp_msg(MSGT_DECVIDEO, MSGL_INFO, "\n");
 }
 #endif
 break;
 case mmioFOURCC('R', 'V', '1', '0'):
 case mmioFOURCC('R', 'V', '4', '0'):
 if(sh->bih->biSize<sizeof(*sh->bih)+8){
 /* only 1 packet per frame & sub_id from fourcc */
 avctx->extradata_size= 8;
 avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
-((uint32_t*)avctx->extradata)[0] = 0;
+((uint32_t *)avctx->extradata)[0] = 0;
-((uint32_t*)avctx->extradata)[1] =
+((uint32_t *)avctx->extradata)[1] =
 (sh->format == mmioFOURCC('R', 'V', '1', '3')) ? 0x10003001 : 0x10000000;
 } else {
 /* has extra slice header (demux_rm or rm->avi streamcopy) */
 avctx->extradata_size = sh->bih->biSize-sizeof(BITMAPINFOHEADER);
 avctx->extradata = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 memcpy(avctx->extradata, sh->bih+1, avctx->extradata_size);
 break;
 }
 /* Pass palette to codec */
 if (sh->bih && (sh->bih->biBitCount <= 8)) {
-avctx->palctrl = calloc(1,sizeof(AVPaletteControl));
+avctx->palctrl = calloc(1, sizeof(AVPaletteControl));
 avctx->palctrl->palette_changed = 1;
 if (sh->bih->biSize-sizeof(BITMAPINFOHEADER))
 /* Palette size in biSize */
 memcpy(avctx->palctrl->palette, sh->bih+1,
 FFMIN(sh->bih->biSize-sizeof(BITMAPINFOHEADER), AVPALETTE_SIZE));
 if(lavc_param_threads > 1)
 avcodec_thread_init(avctx, lavc_param_threads);
 /* open it */
 if (avcodec_open(avctx, lavc_codec) < 0) {
-mp_msg(MSGT_DECVIDEO,MSGL_ERR, MSGTR_CantOpenCodec);
+mp_msg(MSGT_DECVIDEO, MSGL_ERR, MSGTR_CantOpenCodec);
 uninit(sh);
 return 0;
 }
-mp_msg(MSGT_DECVIDEO,MSGL_V,"INFO: libavcodec init OK!\n");
+mp_msg(MSGT_DECVIDEO, MSGL_V, "INFO: libavcodec init OK!\n");
-return 1; //mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h,IMGFMT_YV12);
+return 1; //mpcodecs_config_vo(sh, sh->disp_w, sh->disp_h, IMGFMT_YV12);
 }
 // uninit driver
 static void uninit(sh_video_t *sh){
 vd_ffmpeg_ctx *ctx = sh->context;
 AVCodecContext *avctx = ctx->avctx;
 if(lavc_param_vstats){
 int i;
 for(i=1; i<32; i++){
-mp_msg(MSGT_DECVIDEO, MSGL_INFO,"QP: %d, count: %d\n", i, ctx->qp_stat[i]);
+mp_msg(MSGT_DECVIDEO, MSGL_INFO, "QP: %d, count: %d\n", i, ctx->qp_stat[i]);
 }
-mp_msg(MSGT_DECVIDEO, MSGL_INFO,MSGTR_MPCODECS_ArithmeticMeanOfQP,
+mp_msg(MSGT_DECVIDEO, MSGL_INFO, MSGTR_MPCODECS_ArithmeticMeanOfQP,
 ctx->qp_sum / avctx->coded_frame->coded_picture_number,
 1.0/(ctx->inv_qp_sum / avctx->coded_frame->coded_picture_number)
 );
 }
 if (avctx) {
 if (avctx->codec && avcodec_close(avctx) < 0)
-mp_msg(MSGT_DECVIDEO,MSGL_ERR, MSGTR_CantCloseCodec);
+mp_msg(MSGT_DECVIDEO, MSGL_ERR, MSGTR_CantCloseCodec);
 av_freep(&avctx->extradata);
 av_freep(&avctx->palctrl);
 av_freep(&avctx->slice_offset);
 }
 }
 static void draw_slice(struct AVCodecContext *s,
 AVFrame *src, int offset[4],
 int y, int type, int height){
-sh_video_t * sh = s->opaque;
+sh_video_t *sh = s->opaque;
 uint8_t *source[3]= {src->data[0] + offset[0], src->data[1] + offset[1], src->data[2] + offset[2]};
 #if 0
 int start=0, i;
 int width= s->width;
 int skip_stride= ((width<<lavc_param_lowres)+15)>>4;
 else{
 uint8_t *src2[3]= {src[0] + start*16,
 src[1] + start*8,
 src[2] + start*8};
 //printf("%2d-%2d x %d\n", start, i, y);
-mpcodecs_draw_slice (sh,src2, stride, (i-start)*16, height, start*16, y);
+mpcodecs_draw_slice (sh, src2, stride, (i-start)*16, height, start*16, y);
 start= i+1;
 }
 }
 }
 }else
 case PIX_FMT_XVMC_MPEG2_IDCT:ctx->best_csp=IMGFMT_XVMC_IDCT_MPEG2;break;
 #endif
 default:
 ctx->best_csp=0;
 }
-if (!mpcodecs_config_vo(sh,sh->disp_w,sh->disp_h, ctx->best_csp))
+if (!mpcodecs_config_vo(sh, sh->disp_w, sh->disp_h, ctx->best_csp))
 return -1;
 ctx->vo_initialized = 1;
 }
 return 0;
 }
 static int get_buffer(AVCodecContext *avctx, AVFrame *pic){
-sh_video_t * sh = avctx->opaque;
+sh_video_t *sh = avctx->opaque;
 vd_ffmpeg_ctx *ctx = sh->context;
-mp_image_t* mpi=NULL;
+mp_image_t *mpi=NULL;
 int flags= MP_IMGFLAG_ACCEPT_STRIDE | MP_IMGFLAG_PREFER_ALIGNED_STRIDE;
 int type= MP_IMGTYPE_IPB;
 int width= avctx->width;
 int height= avctx->height;
 int align=15;
 //printf("get_buffer %d %d %d\n", pic->reference, ctx->ip_count, ctx->b_count);
 if(avctx->pix_fmt == PIX_FMT_YUV410P)
 align=63; //yes seriously, its really needed (16x16 chroma blocks in SVQ1 -> 64x64)
 if (pic->buffer_hints) {
-mp_msg(MSGT_DECVIDEO,MSGL_DBG2, "Buffer hints: %u\n", pic->buffer_hints);
+mp_msg(MSGT_DECVIDEO, MSGL_DBG2, "Buffer hints: %u\n", pic->buffer_hints);
 type = MP_IMGTYPE_TEMP;
 if (pic->buffer_hints & FF_BUFFER_HINTS_READABLE)
 flags |= MP_IMGFLAG_READABLE;
 if (pic->buffer_hints & FF_BUFFER_HINTS_PRESERVE) {
 type = MP_IMGTYPE_STATIC;
 type = MP_IMGTYPE_STATIC;
 flags |= MP_IMGFLAG_PRESERVE;
 }
 flags|=(!avctx->hurry_up && ctx->do_slices) ?
 MP_IMGFLAG_DRAW_CALLBACK:0;
-mp_msg(MSGT_DECVIDEO,MSGL_DBG2, type == MP_IMGTYPE_STATIC ? "using STATIC\n" : "using TEMP\n");
+mp_msg(MSGT_DECVIDEO, MSGL_DBG2, type == MP_IMGTYPE_STATIC ? "using STATIC\n" : "using TEMP\n");
 } else {
 if(!pic->reference){
 ctx->b_count++;
 flags|=(!avctx->hurry_up && ctx->do_slices) ?
 MP_IMGFLAG_DRAW_CALLBACK:0;
 flags|= MP_IMGFLAG_PRESERVE|MP_IMGFLAG_READABLE
 | (ctx->do_slices ? MP_IMGFLAG_DRAW_CALLBACK : 0);
 }
 }
-if(init_vo(sh,avctx->pix_fmt) < 0){
+if(init_vo(sh, avctx->pix_fmt) < 0){
 avctx->release_buffer= avcodec_default_release_buffer;
 avctx->get_buffer= avcodec_default_get_buffer;
 return avctx->get_buffer(avctx, pic);
 }
 if(avctx->has_b_frames){
 type= MP_IMGTYPE_IPB;
 }else{
 type= MP_IMGTYPE_IP;
 }
-mp_msg(MSGT_DECVIDEO,MSGL_DBG2, type== MP_IMGTYPE_IPB ? "using IPB\n" : "using IP\n");
+mp_msg(MSGT_DECVIDEO, MSGL_DBG2, type== MP_IMGTYPE_IPB ? "using IPB\n" : "using IP\n");
 }
-mpi= mpcodecs_get_image(sh,type, flags,
+mpi= mpcodecs_get_image(sh, type, flags,
 (width+align)&(~align), (height+align)&(~align));
 // ok, let's see what did we get:
-if(  mpi->flags&MP_IMGFLAG_DRAW_CALLBACK &&
+if(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK &&
 !(mpi->flags&MP_IMGFLAG_DIRECT)){
 // nice, filter/vo likes draw_callback :)
 avctx->draw_horiz_band= draw_slice;
 } else
 avctx->draw_horiz_band= NULL;
 pic->type= FF_BUFFER_TYPE_USER;
 return 0;
 }
 static void release_buffer(struct AVCodecContext *avctx, AVFrame *pic){
-mp_image_t* mpi= pic->opaque;
+mp_image_t *mpi= pic->opaque;
-sh_video_t * sh = avctx->opaque;
+sh_video_t *sh = avctx->opaque;
 vd_ffmpeg_ctx *ctx = sh->context;
 int i;
 //printf("release buffer %d %d %d\n", mpi ? mpi->flags&MP_IMGFLAG_PRESERVE : -99, ctx->ip_count, ctx->b_count);
 for (i = 0; i < AVPALETTE_COUNT; i++)
 p[i] = le2me_32(p[i]);
 }
 // decode a frame
-static mp_image_t* decode(sh_video_t *sh,void* data,int len,int flags){
+static mp_image_t *decode(sh_video_t *sh, void *data, int len, int flags){
 int got_picture=0;
 int ret;
 vd_ffmpeg_ctx *ctx = sh->context;
 AVFrame *pic= ctx->pic;
 AVCodecContext *avctx = ctx->avctx;
-mp_image_t* mpi=NULL;
+mp_image_t *mpi=NULL;
 int dr1= ctx->do_dr1;
 if(len<=0) return NULL; // skipped frame
 //ffmpeg interlace (mpeg2) bug have been fixed. no need of -noslices
 ((int *)data)[0], ((int *)data)[1], ((int *)data)[2], ((int *)data)[3]);
 ret = avcodec_decode_video(avctx, pic,
 &got_picture, data, len);
 dr1= ctx->do_dr1;
-if(ret<0) mp_msg(MSGT_DECVIDEO,MSGL_WARN, "Error while decoding frame!\n");
+if(ret<0) mp_msg(MSGT_DECVIDEO, MSGL_WARN, "Error while decoding frame!\n");
 //printf("repeat: %d\n", pic->repeat_pict);
 //-- vstats generation
 while(lavc_param_vstats){ // always one time loop
 static FILE *fvstats=NULL;
 char filename[20];
 struct tm *today;
 today2 = time(NULL);
 today = localtime(&today2);
 sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
 today->tm_min, today->tm_sec);
-fvstats = fopen(filename,"w");
+fvstats = fopen(filename, "w");
 if(!fvstats) {
 perror("fopen");
 lavc_param_vstats=0; // disable block
 break;
 /*exit(1);*/
 {
 int x, y;
 int w = ((avctx->width  << lavc_param_lowres)+15) >> 4;
 int h = ((avctx->height << lavc_param_lowres)+15) >> 4;
 int8_t *q = pic->qscale_table;
-for( y = 0; y < h; y++ ) {
+for(y = 0; y < h; y++) {
-for( x = 0; x < w; x++ )
+for(x = 0; x < w; x++)
 quality += (double)*(q+x);
 q += pic->qstride;
 }
 quality /= w * h;
 }
 }
 //--
 if(!got_picture) return NULL;        // skipped image
-if(init_vo(sh,avctx->pix_fmt) < 0) return NULL;
+if(init_vo(sh, avctx->pix_fmt) < 0) return NULL;
 if(dr1 && pic->opaque){
-mpi= (mp_image_t*)pic->opaque;
+mpi= (mp_image_t *)pic->opaque;
 }
 if(!mpi)
 mpi=mpcodecs_get_image(sh, MP_IMGTYPE_EXPORT, MP_IMGFLAG_PRESERVE,
 avctx->width, avctx->height);
 return mpi;
 }
 #if CONFIG_XVMC
-static enum PixelFormat get_format(struct AVCodecContext * avctx,
+static enum PixelFormat get_format(struct AVCodecContext *avctx,
-const enum PixelFormat * fmt){
+const enum PixelFormat *fmt){
-sh_video_t * sh = avctx->opaque;
+sh_video_t *sh = avctx->opaque;
 int i;
 if(avctx->xvmc_acceleration){
 vd_ffmpeg_ctx *ctx = sh->context;
 avctx->get_buffer= mc_get_buffer;
 assert(ctx->do_slices); //it is (vo_)ffmpeg bug if this fails
 avctx->flags|= CODEC_FLAG_EMU_EDGE;//do i need that??!!
 avctx->slice_flags=SLICE_FLAG_CODED_ORDER|SLICE_FLAG_ALLOW_FIELD;
 }
 for(i=0;fmt[i]!=-1;i++){
-mp_msg(MSGT_DECVIDEO, MSGL_INFO, MSGTR_MPCODECS_TryingPixfmt,i);
+mp_msg(MSGT_DECVIDEO, MSGL_INFO, MSGTR_MPCODECS_TryingPixfmt, i);
-if( init_vo(sh,fmt[i]) >= 0)
+if(init_vo(sh, fmt[i]) >= 0)
 return fmt[i];
 }
 return fmt[0];
 }
 static int mc_get_buffer(AVCodecContext *avctx, AVFrame *pic){
-sh_video_t * sh = avctx->opaque;
+sh_video_t *sh = avctx->opaque;
 vd_ffmpeg_ctx *ctx = sh->context;
-mp_image_t* mpi=NULL;
+mp_image_t *mpi=NULL;
-struct xvmc_render_state * render;
+struct xvmc_render_state *render;
 int flags= MP_IMGFLAG_ACCEPT_STRIDE | MP_IMGFLAG_PREFER_ALIGNED_STRIDE|
 MP_IMGFLAG_DRAW_CALLBACK;
 //  printf("vd_ffmpeg::mc_get_buffer (xvmc) %d %d %d\n", pic->reference, ctx->ip_count, ctx->b_count);
 if(!avctx->xvmc_acceleration){
 exit(1);
 //        return -1;//!!fixme check error conditions
 }
 assert(avctx->draw_horiz_band == mc_render_slice);
 assert(avctx->release_buffer == mc_release_buffer);
-if( mp_msg_test(MSGT_DECVIDEO,MSGL_DBG5) )
+if(mp_msg_test(MSGT_DECVIDEO, MSGL_DBG5))
 mp_msg(MSGT_DECVIDEO, MSGL_DBG5, "vd_ffmpeg::mc_get_buffer\n");
-if(init_vo(sh,avctx->pix_fmt) < 0){
+if(init_vo(sh, avctx->pix_fmt) < 0){
 mp_msg(MSGT_DECVIDEO, MSGL_WARN, MSGTR_MPCODECS_UnexpectedInitVoError);
 exit(1);
 //        return -1;//!!fixme check error conditions
 }
 }else{
 ctx->ip_count++;
 flags|= MP_IMGFLAG_PRESERVE|MP_IMGFLAG_READABLE;
 }
-mpi= mpcodecs_get_image(sh, MP_IMGTYPE_IPB,flags ,
+mpi= mpcodecs_get_image(sh, MP_IMGTYPE_IPB, flags,
 avctx->width, avctx->height);
 if(mpi==NULL){
 mp_msg(MSGT_DECVIDEO, MSGL_ERR, MSGTR_MPCODECS_UnrecoverableErrorRenderBuffersNotTaken);
 assert(0);
 exit(1);
 //        return -1;//!!fixme check error conditions in ffmpeg
 };
-if( (mpi->flags & MP_IMGFLAG_DIRECT) == 0){
+if((mpi->flags & MP_IMGFLAG_DIRECT) == 0){
 mp_msg(MSGT_DECVIDEO, MSGL_ERR, MSGTR_MPCODECS_OnlyBuffersAllocatedByVoXvmcAllowed);
 assert(0);
 exit(1);
 //        return -1;//!!fixme check error conditions in ffmpeg
 }
 ctx->b_age=1;
 }
 pic->type= FF_BUFFER_TYPE_USER;
-render=(struct xvmc_render_state*)mpi->priv;//same as data[2]
+render=(struct xvmc_render_state *)mpi->priv;//same as data[2]
-if( mp_msg_test(MSGT_DECVIDEO,MSGL_DBG5) )
+if(mp_msg_test(MSGT_DECVIDEO, MSGL_DBG5))
-mp_msg(MSGT_DECVIDEO, MSGL_DBG5, "vd_ffmpeg::mc_get_buffer (render=%p)\n",render);
+mp_msg(MSGT_DECVIDEO, MSGL_DBG5, "vd_ffmpeg::mc_get_buffer (render=%p)\n", render);
 assert(render != 0);
 assert(render->magic == AV_XVMC_RENDER_MAGIC);
 render->state |= AV_XVMC_STATE_PREDICTION;
 return 0;
 }
 static void mc_release_buffer(AVCodecContext *avctx, AVFrame *pic){
-mp_image_t* mpi= pic->opaque;
+mp_image_t *mpi= pic->opaque;
-sh_video_t * sh = avctx->opaque;
+sh_video_t *sh = avctx->opaque;
 vd_ffmpeg_ctx *ctx = sh->context;
-struct xvmc_render_state * render;
+struct xvmc_render_state *render;
 int i;
 if(ctx->ip_count <= 2 && ctx->b_count<=1){
 if(mpi->flags&MP_IMGFLAG_PRESERVE)
 ctx->b_count--;
 }
 //printf("R%X %X\n", pic->linesize[0], pic->data[0]);
 //mark the surface as not requared for prediction
-render=(struct xvmc_render_state*)pic->data[2];//same as mpi->priv
+render=(struct xvmc_render_state *)pic->data[2];//same as mpi->priv
-if( mp_msg_test(MSGT_DECVIDEO,MSGL_DBG5) )
+if(mp_msg_test(MSGT_DECVIDEO, MSGL_DBG5))
-mp_msg(MSGT_DECVIDEO, MSGL_DBG5, "vd_ffmpeg::mc_release_buffer (render=%p)\n",render);
+mp_msg(MSGT_DECVIDEO, MSGL_DBG5, "vd_ffmpeg::mc_release_buffer (render=%p)\n", render);
 assert(render!=NULL);
 assert(render->magic==AV_XVMC_RENDER_MAGIC);
 render->state&=~AV_XVMC_STATE_PREDICTION;
 for(i=0; i<4; i++){
 pic->data[i]= NULL;
 static void mc_render_slice(struct AVCodecContext *s,
 AVFrame *src, int offset[4],
 int y, int type, int height){
 int width= s->width;
-sh_video_t * sh = s->opaque;
+sh_video_t *sh = s->opaque;
 uint8_t *source[3]= {src->data[0], src->data[1], src->data[2]};
 assert(src->linesize[0]==0 && src->linesize[1]==0 && src->linesize[2]==0);
 assert(offset[0]==0 && offset[1]==0 && offset[2]==0);

Mercurial > mplayer.hg

comparison libmpcodecs/vd_ffmpeg.c @ 28525:1e671b7bf2e0