libmpcodecs/vd.c

   1 /*
   2  * This file is part of MPlayer.
   3  *
   4  * MPlayer is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * MPlayer is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include "config.h"
  24 #include "mp_msg.h"
  25 #include "help_mp.h"
  26
  27 #include "codec-cfg.h"
  28 //#include "mp_image.h"
  29
  30 #include "img_format.h"
  31
  32 #include "stream/stream.h"
  33 #include "libmpdemux/demuxer.h"
  34 #include "libmpdemux/stheader.h"
  35 #include "dec_video.h"
  36
  37 #include "vd.h"
  38 #include "vf.h"
  39
  40 //#include "vd_internal.h"
  41
  42 extern const vd_functions_t mpcodecs_vd_null;
  43 extern const vd_functions_t mpcodecs_vd_ffmpeg;
  44 extern const vd_functions_t mpcodecs_vd_theora;
  45 extern const vd_functions_t mpcodecs_vd_dshow;
  46 extern const vd_functions_t mpcodecs_vd_dmo;
  47 extern const vd_functions_t mpcodecs_vd_vfw;
  48 extern const vd_functions_t mpcodecs_vd_vfwex;
  49 extern const vd_functions_t mpcodecs_vd_raw;
  50 extern const vd_functions_t mpcodecs_vd_hmblck;
  51 extern const vd_functions_t mpcodecs_vd_xanim;
  52 extern const vd_functions_t mpcodecs_vd_mpng;
  53 extern const vd_functions_t mpcodecs_vd_ijpg;
  54 extern const vd_functions_t mpcodecs_vd_mtga;
  55 extern const vd_functions_t mpcodecs_vd_sgi;
  56 extern const vd_functions_t mpcodecs_vd_libmpeg2;
  57 extern const vd_functions_t mpcodecs_vd_mpegpes;
  58 extern const vd_functions_t mpcodecs_vd_zrmjpeg;
  59 extern const vd_functions_t mpcodecs_vd_realvid;
  60 extern const vd_functions_t mpcodecs_vd_xvid;
  61 extern const vd_functions_t mpcodecs_vd_libdv;
  62 extern const vd_functions_t mpcodecs_vd_lzo;
  63 extern const vd_functions_t mpcodecs_vd_qtvideo;
  64
  65 /* Please do not add any new decoders here. If you want to implement a new
  66  * decoder, add it to libavcodec, except for wrappers around external
  67  * libraries and decoders requiring binary support. */
  68
  69 const vd_functions_t * const mpcodecs_vd_drivers[] = {
  70         &mpcodecs_vd_null,
  71 #ifdef CONFIG_LIBAVCODEC
  72         &mpcodecs_vd_ffmpeg,
  73 #endif
  74 #ifdef CONFIG_OGGTHEORA
  75         &mpcodecs_vd_theora,
  76 #endif
  77 #ifdef CONFIG_WIN32DLL
  78         &mpcodecs_vd_dshow,
  79         &mpcodecs_vd_dmo,
  80         &mpcodecs_vd_vfw,
  81         &mpcodecs_vd_vfwex,
  82 #endif
  83         &mpcodecs_vd_lzo,
  84         &mpcodecs_vd_raw,
  85         &mpcodecs_vd_hmblck,
  86 #ifdef CONFIG_XANIM
  87         &mpcodecs_vd_xanim,
  88 #endif
  89 #ifdef CONFIG_PNG
  90         &mpcodecs_vd_mpng,
  91 #endif
  92 #ifdef CONFIG_JPEG
  93         &mpcodecs_vd_ijpg,
  94 #endif
  95         &mpcodecs_vd_mtga,
  96         &mpcodecs_vd_sgi,
  97 #ifdef CONFIG_LIBMPEG2
  98         &mpcodecs_vd_libmpeg2,
  99 #endif
 100         &mpcodecs_vd_mpegpes,
 101 #ifdef CONFIG_ZR
 102         &mpcodecs_vd_zrmjpeg,
 103 #endif
 104 #ifdef CONFIG_REALCODECS
 105         &mpcodecs_vd_realvid,
 106 #endif
 107 #ifdef CONFIG_XVID4
 108         &mpcodecs_vd_xvid,
 109 #endif
 110 #ifdef CONFIG_LIBDV095
 111         &mpcodecs_vd_libdv,
 112 #endif
 113 #ifdef CONFIG_QTX_CODECS
 114         &mpcodecs_vd_qtvideo,
 115 #endif
 116     /* Please do not add any new decoders here. If you want to implement a new
 117      * decoder, add it to libavcodec, except for wrappers around external
 118      * libraries and decoders requiring binary support. */
 119         NULL
 120 };
 121
 122 #include "libvo/video_out.h"
 123
 124 // libvo opts:
 125 int fullscreen=0;
 126 int vidmode=0;
 127 int softzoom=0;
 128 int flip=-1;
 129 int opt_screen_size_x=0;
 130 int opt_screen_size_y=0;
 131 float screen_size_xy=0;
 132 float movie_aspect=-1.0;
 133 int vo_flags=0;
 134 int vd_use_slices=1;
 135
 136 /** global variables for gamma, brightness, contrast, saturation and hue
 137     modified by mplayer.c and gui/mplayer/gtk/eq.c:
 138     ranges -100 - 100
 139     1000 if the vo default should be used
 140 */
 141 int vo_gamma_gamma = 1000;
 142 int vo_gamma_brightness = 1000;
 143 int vo_gamma_contrast = 1000;
 144 int vo_gamma_saturation = 1000;
 145 int vo_gamma_hue = 1000;
 146
 147 extern vd_functions_t* mpvdec; // FIXME!
 148
 149 #define SCREEN_SIZE_X 1
 150 #define SCREEN_SIZE_Y 1
 151
 152 int mpcodecs_config_vo(sh_video_t *sh, int w, int h, unsigned int preferred_outfmt){
 153     int i,j;
 154     unsigned int out_fmt=0;
 155     int screen_size_x=0;//SCREEN_SIZE_X;
 156     int screen_size_y=0;//SCREEN_SIZE_Y;
 157     vf_instance_t* vf=sh->vfilter,*sc=NULL;
 158     int palette=0;
 159     int vocfg_flags=0;
 160
 161     if(w)
 162         sh->disp_w=w;
 163     if(h)
 164         sh->disp_h=h;
 165
 166     if(!sh->disp_w || !sh->disp_h)
 167         return 0;
 168
 169     mp_msg(MSGT_DECVIDEO, MSGL_V,
 170            "VDec: vo config request - %d x %d (preferred colorspace: %s)\n",
 171            w, h, vo_format_name(preferred_outfmt));
 172
 173 //    if(!vf) return 1; // temp hack
 174
 175     if(get_video_quality_max(sh)<=0 && divx_quality){
 176         // user wants postprocess but no pp filter yet:
 177         sh->vfilter=vf=vf_open_filter(vf,"pp",NULL);
 178     }
 179
 180     // check if libvo and codec has common outfmt (no conversion):
 181 csp_again:
 182
 183     if( mp_msg_test(MSGT_DECVIDEO,MSGL_V) ){
 184         vf_instance_t* f=vf;
 185         mp_msg(MSGT_DECVIDEO,MSGL_V,"Trying filter chain:");
 186         for(f = vf ; f ; f = f->next)
 187             mp_msg(MSGT_DECVIDEO,MSGL_V," %s",f->info->name);
 188         mp_msg(MSGT_DECVIDEO,MSGL_V,"\n");
 189     }
 190
 191     j=-1;
 192     for(i=0;i<CODECS_MAX_OUTFMT;i++){
 193         int flags;
 194         out_fmt=sh->codec->outfmt[i];
 195         if(out_fmt==(unsigned int)0xFFFFFFFF) continue;
 196         flags=vf->query_format(vf,out_fmt);
 197         mp_msg(MSGT_CPLAYER,MSGL_DBG2,"vo_debug: query(%s) returned 0x%X (i=%d) \n",vo_format_name(out_fmt),flags,i);
 198         if((flags&VFCAP_CSP_SUPPORTED_BY_HW) || (flags&VFCAP_CSP_SUPPORTED && j<0)){
 199             // check (query) if codec really support this outfmt...
 200             sh->outfmtidx=j; // pass index to the control() function this way
 201             if(mpvdec->control(sh,VDCTRL_QUERY_FORMAT,&out_fmt)==CONTROL_FALSE){
 202                 mp_msg(MSGT_CPLAYER,MSGL_DBG2,"vo_debug: codec query_format(%s) returned FALSE\n",vo_format_name(out_fmt));
 203                 continue;
 204             }
 205             j=i; vo_flags=flags; if(flags&VFCAP_CSP_SUPPORTED_BY_HW) break;
 206         } else
 207             if(!palette && !(flags&(VFCAP_CSP_SUPPORTED_BY_HW|VFCAP_CSP_SUPPORTED)) && (out_fmt==IMGFMT_RGB8||out_fmt==IMGFMT_BGR8)){
 208             sh->outfmtidx=j; // pass index to the control() function this way
 209             if(mpvdec->control(sh,VDCTRL_QUERY_FORMAT,&out_fmt)!=CONTROL_FALSE)
 210                 palette=1;
 211         }
 212     }
 213     if(j<0){
 214         // TODO: no match - we should use conversion...
 215         if(strcmp(vf->info->name,"scale") && palette!=-1){
 216             mp_msg(MSGT_DECVIDEO,MSGL_INFO,MSGTR_CouldNotFindColorspace);
 217             sc=vf=vf_open_filter(vf,"scale",NULL);
 218             goto csp_again;
 219         } else
 220         if(palette==1){
 221             mp_msg(MSGT_DECVIDEO,MSGL_V,"vd: Trying -vf palette...\n");
 222             palette=-1;
 223             vf=vf_open_filter(vf,"palette",NULL);
 224             goto csp_again;
 225         } else
 226         { // sws failed, if the last filter (vf_vo) support MPEGPES try to append vf_lavc
 227              vf_instance_t* vo, *vp = NULL, *ve, *vpp = NULL;
 228              // Remove the scale filter if we added it ourself
 229              if(vf == sc) {
 230                ve = vf;
 231                vf = vf->next;
 232                vf_uninit_filter(ve);
 233              }
 234              // Find the last filter (vf_vo)
 235              for(vo = vf ; vo->next ; vo = vo->next) {
 236                vpp = vp;
 237                vp = vo;
 238              }
 239              if(vo->query_format(vo,IMGFMT_MPEGPES) && (!vp || (vp && strcmp(vp->info->name,"lavc")))) {
 240                ve = vf_open_filter(vo,"lavc",NULL);
 241                if(vp) vp->next = ve;
 242                  else vf = ve;
 243                goto csp_again;
 244              }
 245              if (vp && !strcmp(vp->info->name,"lavc")) {
 246                 if (vpp) vpp->next = vo;
 247                 else vf = vo;
 248                 vf_uninit_filter(vp);
 249              }
 250         }
 251         mp_msg(MSGT_CPLAYER,MSGL_WARN,MSGTR_VOincompCodec);
 252         sh->vf_initialized=-1;
 253         return 0;       // failed
 254     }
 255     out_fmt=sh->codec->outfmt[j];
 256     mp_msg(MSGT_CPLAYER, MSGL_V, "VDec: using %s as output csp (no %d)\n",
 257            vo_format_name(out_fmt), j);
 258     sh->outfmtidx=j;
 259     sh->vfilter=vf;
 260
 261     // autodetect flipping
 262     if(flip==-1){
 263         flip=0;
 264         if(sh->codec->outflags[j]&CODECS_FLAG_FLIP)
 265             if(!(sh->codec->outflags[j]&CODECS_FLAG_NOFLIP))
 266                 flip=1;
 267     }
 268     if(vo_flags&VFCAP_FLIPPED) flip^=1;
 269     if(flip && !(vo_flags&VFCAP_FLIP)){
 270         // we need to flip, but no flipping filter avail.
 271         vf_add_before_vo(&vf, "flip", NULL);
 272         sh->vfilter = vf;
 273     }
 274
 275     // time to do aspect ratio corrections...
 276
 277   if(movie_aspect>-1.0) sh->aspect = movie_aspect; // cmdline overrides autodetect
 278   else if(sh->stream_aspect!=0.0) sh->aspect = sh->stream_aspect;
 279 //  if(!sh->aspect) sh->aspect=1.0;
 280
 281   if(opt_screen_size_x||opt_screen_size_y){
 282     screen_size_x = opt_screen_size_x;
 283     screen_size_y = opt_screen_size_y;
 284     if(!vidmode){
 285      if(!screen_size_x) screen_size_x=SCREEN_SIZE_X;
 286      if(!screen_size_y) screen_size_y=SCREEN_SIZE_Y;
 287      if(screen_size_x<=8) screen_size_x*=sh->disp_w;
 288      if(screen_size_y<=8) screen_size_y*=sh->disp_h;
 289     }
 290   } else {
 291     // check source format aspect, calculate prescale ::atmos
 292     screen_size_x=sh->disp_w;
 293     screen_size_y=sh->disp_h;
 294     if(screen_size_xy>=0.001){
 295      if(screen_size_xy<=8){
 296        // -xy means x+y scale
 297        screen_size_x*=screen_size_xy;
 298        screen_size_y*=screen_size_xy;
 299      } else {
 300        // -xy means forced width while keeping correct aspect
 301        screen_size_x=screen_size_xy;
 302        screen_size_y=screen_size_xy*sh->disp_h/sh->disp_w;
 303      }
 304     }
 305     if(sh->aspect>0.01){
 306       int w;
 307       mp_msg(MSGT_CPLAYER,MSGL_INFO,MSGTR_MovieAspectIsSet,sh->aspect);
 308       mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_ASPECT=%1.4f\n", sh->aspect);
 309       w=(int)((float)screen_size_y*sh->aspect); w+=w%2; // round
 310       // we don't like horizontal downscale || user forced width:
 311       if(w<screen_size_x || screen_size_xy>8){
 312         screen_size_y=(int)((float)screen_size_x*(1.0/sh->aspect));
 313         screen_size_y+=screen_size_y%2; // round
 314       } else screen_size_x=w; // keep new width
 315     } else {
 316       mp_msg(MSGT_CPLAYER,MSGL_INFO,MSGTR_MovieAspectUndefined);
 317     }
 318   }
 319
 320   vocfg_flags = (fullscreen ? VOFLAG_FULLSCREEN:0)
 321       | (vidmode ? VOFLAG_MODESWITCHING:0)
 322       | (softzoom ? VOFLAG_SWSCALE:0)
 323       | (flip ? VOFLAG_FLIPPING:0);
 324
 325     // Time to config libvo!
 326     mp_msg(MSGT_CPLAYER,MSGL_V,"VO Config (%dx%d->%dx%d,flags=%d,'%s',0x%X)\n",
 327                       sh->disp_w,sh->disp_h,
 328                       screen_size_x,screen_size_y,
 329                       vocfg_flags,
 330                       "MPlayer",out_fmt);
 331
 332     vf->w = sh->disp_w;
 333     vf->h = sh->disp_h;
 334     if(vf_config_wrapper(vf,sh->disp_w,sh->disp_h,
 335                          screen_size_x,screen_size_y,
 336                          vocfg_flags,
 337                          out_fmt)==0){
 338 //                      "MPlayer",out_fmt)){
 339         mp_msg(MSGT_CPLAYER,MSGL_WARN,MSGTR_CannotInitVO);
 340         sh->vf_initialized=-1;
 341         return 0;
 342     }
 343
 344     sh->vf_initialized=1;
 345
 346     if (vo_gamma_gamma != 1000)
 347         set_video_colors(sh, "gamma", vo_gamma_gamma);
 348     if (vo_gamma_brightness != 1000)
 349         set_video_colors(sh, "brightness", vo_gamma_brightness);
 350     if (vo_gamma_contrast != 1000)
 351         set_video_colors(sh, "contrast", vo_gamma_contrast);
 352     if (vo_gamma_saturation != 1000)
 353         set_video_colors(sh, "saturation", vo_gamma_saturation);
 354     if (vo_gamma_hue != 1000)
 355         set_video_colors(sh, "hue", vo_gamma_hue);
 356
 357     return 1;
 358 }
 359
 360 // mp_imgtype: buffering type, see mp_image.h
 361 // mp_imgflag: buffer requirements (read/write, preserve, stride limits), see mp_image.h
 362 // returns NULL or allocated mp_image_t*
 363 // Note: buffer allocation may be moved to mpcodecs_config_vo() later...
 364 mp_image_t* mpcodecs_get_image(sh_video_t *sh, int mp_imgtype, int mp_imgflag, int w, int h){
 365   mp_image_t* mpi=vf_get_image(sh->vfilter,sh->codec->outfmt[sh->outfmtidx],mp_imgtype,mp_imgflag,w,h);
 366   if (mpi) mpi->x=mpi->y=0;
 367   return mpi;
 368 }
 369
 370 void mpcodecs_draw_slice(sh_video_t *sh, unsigned char** src, int* stride, int w,int h, int x, int y) {
 371   struct vf_instance_s* vf = sh->vfilter;
 372
 373   if(vf->draw_slice)
 374     vf->draw_slice(vf,src,stride,w,h,x,y);
 375 }