git.sesse.net Git - ffmpeg/blob - libavfilter/vf_mp.c

   1 /*
   2  * Copyright (c) 2011 Michael Niedermayer
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  *
  20  * Parts of this file have been stolen from mplayer
  21  */
  22
  23 /**
  24  * @file
  25  */
  26
  27 #include "avfilter.h"
  28 #include "video.h"
  29 #include "formats.h"
  30 #include "internal.h"
  31 #include "libavutil/avassert.h"
  32 #include "libavutil/pixdesc.h"
  33 #include "libavutil/intreadwrite.h"
  34 #include "libavutil/imgutils.h"
  35
  36 #include "libmpcodecs/vf.h"
  37 #include "libmpcodecs/img_format.h"
  38 #include "libmpcodecs/cpudetect.h"
  39 #include "libmpcodecs/vd_ffmpeg.h"
  40 #include "libmpcodecs/vf_scale.h"
  41 #include "libmpcodecs/libvo/fastmemcpy.h"
  42
  43 #include "libswscale/swscale.h"
  44
  45
  46 //FIXME maybe link the orig in
  47 //XXX: identical pix_fmt must be following with each others
  48 static const struct {
  49     int fmt;
  50     enum AVPixelFormat pix_fmt;
  51 } conversion_map[] = {
  52     {IMGFMT_ARGB, AV_PIX_FMT_ARGB},
  53     {IMGFMT_BGRA, AV_PIX_FMT_BGRA},
  54     {IMGFMT_BGR24, AV_PIX_FMT_BGR24},
  55     {IMGFMT_BGR16BE, AV_PIX_FMT_RGB565BE},
  56     {IMGFMT_BGR16LE, AV_PIX_FMT_RGB565LE},
  57     {IMGFMT_BGR15BE, AV_PIX_FMT_RGB555BE},
  58     {IMGFMT_BGR15LE, AV_PIX_FMT_RGB555LE},
  59     {IMGFMT_BGR12BE, AV_PIX_FMT_RGB444BE},
  60     {IMGFMT_BGR12LE, AV_PIX_FMT_RGB444LE},
  61     {IMGFMT_BGR8,  AV_PIX_FMT_RGB8},
  62     {IMGFMT_BGR4,  AV_PIX_FMT_RGB4},
  63     {IMGFMT_BGR1,  AV_PIX_FMT_MONOBLACK},
  64     {IMGFMT_RGB1,  AV_PIX_FMT_MONOBLACK},
  65     {IMGFMT_RG4B,  AV_PIX_FMT_BGR4_BYTE},
  66     {IMGFMT_BG4B,  AV_PIX_FMT_RGB4_BYTE},
  67     {IMGFMT_RGB48LE, AV_PIX_FMT_RGB48LE},
  68     {IMGFMT_RGB48BE, AV_PIX_FMT_RGB48BE},
  69     {IMGFMT_ABGR, AV_PIX_FMT_ABGR},
  70     {IMGFMT_RGBA, AV_PIX_FMT_RGBA},
  71     {IMGFMT_RGB24, AV_PIX_FMT_RGB24},
  72     {IMGFMT_RGB16BE, AV_PIX_FMT_BGR565BE},
  73     {IMGFMT_RGB16LE, AV_PIX_FMT_BGR565LE},
  74     {IMGFMT_RGB15BE, AV_PIX_FMT_BGR555BE},
  75     {IMGFMT_RGB15LE, AV_PIX_FMT_BGR555LE},
  76     {IMGFMT_RGB12BE, AV_PIX_FMT_BGR444BE},
  77     {IMGFMT_RGB12LE, AV_PIX_FMT_BGR444LE},
  78     {IMGFMT_RGB8,  AV_PIX_FMT_BGR8},
  79     {IMGFMT_RGB4,  AV_PIX_FMT_BGR4},
  80     {IMGFMT_BGR8,  AV_PIX_FMT_PAL8},
  81     {IMGFMT_YUY2,  AV_PIX_FMT_YUYV422},
  82     {IMGFMT_UYVY,  AV_PIX_FMT_UYVY422},
  83     {IMGFMT_NV12,  AV_PIX_FMT_NV12},
  84     {IMGFMT_NV21,  AV_PIX_FMT_NV21},
  85     {IMGFMT_Y800,  AV_PIX_FMT_GRAY8},
  86     {IMGFMT_Y8,    AV_PIX_FMT_GRAY8},
  87     {IMGFMT_YVU9,  AV_PIX_FMT_YUV410P},
  88     {IMGFMT_IF09,  AV_PIX_FMT_YUV410P},
  89     {IMGFMT_YV12,  AV_PIX_FMT_YUV420P},
  90     {IMGFMT_I420,  AV_PIX_FMT_YUV420P},
  91     {IMGFMT_IYUV,  AV_PIX_FMT_YUV420P},
  92     {IMGFMT_411P,  AV_PIX_FMT_YUV411P},
  93     {IMGFMT_422P,  AV_PIX_FMT_YUV422P},
  94     {IMGFMT_444P,  AV_PIX_FMT_YUV444P},
  95     {IMGFMT_440P,  AV_PIX_FMT_YUV440P},
  96
  97     {IMGFMT_420A,  AV_PIX_FMT_YUVA420P},
  98
  99     {IMGFMT_420P16_LE,  AV_PIX_FMT_YUV420P16LE},
 100     {IMGFMT_420P16_BE,  AV_PIX_FMT_YUV420P16BE},
 101     {IMGFMT_422P16_LE,  AV_PIX_FMT_YUV422P16LE},
 102     {IMGFMT_422P16_BE,  AV_PIX_FMT_YUV422P16BE},
 103     {IMGFMT_444P16_LE,  AV_PIX_FMT_YUV444P16LE},
 104     {IMGFMT_444P16_BE,  AV_PIX_FMT_YUV444P16BE},
 105
 106     // YUVJ are YUV formats that use the full Y range and not just
 107     // 16 - 235 (see colorspaces.txt).
 108     // Currently they are all treated the same way.
 109     {IMGFMT_YV12,  AV_PIX_FMT_YUVJ420P},
 110     {IMGFMT_422P,  AV_PIX_FMT_YUVJ422P},
 111     {IMGFMT_444P,  AV_PIX_FMT_YUVJ444P},
 112     {IMGFMT_440P,  AV_PIX_FMT_YUVJ440P},
 113
 114     {IMGFMT_XVMC_MOCO_MPEG2, AV_PIX_FMT_XVMC_MPEG2_MC},
 115     {IMGFMT_XVMC_IDCT_MPEG2, AV_PIX_FMT_XVMC_MPEG2_IDCT},
 116     {IMGFMT_VDPAU_MPEG1,     AV_PIX_FMT_VDPAU_MPEG1},
 117     {IMGFMT_VDPAU_MPEG2,     AV_PIX_FMT_VDPAU_MPEG2},
 118     {IMGFMT_VDPAU_H264,      AV_PIX_FMT_VDPAU_H264},
 119     {IMGFMT_VDPAU_WMV3,      AV_PIX_FMT_VDPAU_WMV3},
 120     {IMGFMT_VDPAU_VC1,       AV_PIX_FMT_VDPAU_VC1},
 121     {IMGFMT_VDPAU_MPEG4,     AV_PIX_FMT_VDPAU_MPEG4},
 122     {0, AV_PIX_FMT_NONE}
 123 };
 124
 125 extern const vf_info_t ff_vf_info_detc;
 126 extern const vf_info_t ff_vf_info_dint;
 127 extern const vf_info_t ff_vf_info_divtc;
 128 extern const vf_info_t ff_vf_info_down3dright;
 129 extern const vf_info_t ff_vf_info_dsize;
 130 extern const vf_info_t ff_vf_info_eq2;
 131 extern const vf_info_t ff_vf_info_eq;
 132 extern const vf_info_t ff_vf_info_fil;
 133 //extern const vf_info_t ff_vf_info_filmdint;
 134 extern const vf_info_t ff_vf_info_fspp;
 135 extern const vf_info_t ff_vf_info_harddup;
 136 extern const vf_info_t ff_vf_info_il;
 137 extern const vf_info_t ff_vf_info_ilpack;
 138 extern const vf_info_t ff_vf_info_ivtc;
 139 extern const vf_info_t ff_vf_info_kerndeint;
 140 extern const vf_info_t ff_vf_info_mcdeint;
 141 extern const vf_info_t ff_vf_info_noise;
 142 extern const vf_info_t ff_vf_info_ow;
 143 extern const vf_info_t ff_vf_info_perspective;
 144 extern const vf_info_t ff_vf_info_phase;
 145 extern const vf_info_t ff_vf_info_pp7;
 146 extern const vf_info_t ff_vf_info_pullup;
 147 extern const vf_info_t ff_vf_info_qp;
 148 extern const vf_info_t ff_vf_info_sab;
 149 extern const vf_info_t ff_vf_info_softpulldown;
 150 extern const vf_info_t ff_vf_info_softskip;
 151 extern const vf_info_t ff_vf_info_spp;
 152 extern const vf_info_t ff_vf_info_stereo3d;
 153 extern const vf_info_t ff_vf_info_telecine;
 154 extern const vf_info_t ff_vf_info_tinterlace;
 155 extern const vf_info_t ff_vf_info_unsharp;
 156 extern const vf_info_t ff_vf_info_uspp;
 157
 158
 159 static const vf_info_t* const filters[]={
 160     &ff_vf_info_detc,
 161     &ff_vf_info_dint,
 162     &ff_vf_info_divtc,
 163     &ff_vf_info_down3dright,
 164     &ff_vf_info_dsize,
 165     &ff_vf_info_eq2,
 166     &ff_vf_info_eq,
 167     &ff_vf_info_fil,
 168 //    &ff_vf_info_filmdint, cmmx.h vd.h ‘opt_screen_size_x’
 169     &ff_vf_info_fspp,
 170     &ff_vf_info_harddup,
 171     &ff_vf_info_il,
 172     &ff_vf_info_ilpack,
 173     &ff_vf_info_ivtc,
 174     &ff_vf_info_kerndeint,
 175     &ff_vf_info_mcdeint,
 176     &ff_vf_info_noise,
 177     &ff_vf_info_ow,
 178     &ff_vf_info_perspective,
 179     &ff_vf_info_phase,
 180     &ff_vf_info_pp7,
 181     &ff_vf_info_pullup,
 182     &ff_vf_info_qp,
 183     &ff_vf_info_sab,
 184     &ff_vf_info_softpulldown,
 185     &ff_vf_info_softskip,
 186     &ff_vf_info_spp,
 187     &ff_vf_info_stereo3d,
 188     &ff_vf_info_telecine,
 189     &ff_vf_info_tinterlace,
 190     &ff_vf_info_unsharp,
 191     &ff_vf_info_uspp,
 192
 193     NULL
 194 };
 195
 196 /*
 197 Unsupported filters
 198 1bpp
 199 ass
 200 bmovl
 201 crop
 202 dvbscale
 203 flip
 204 expand
 205 format
 206 halfpack
 207 lavc
 208 lavcdeint
 209 noformat
 210 pp
 211 scale
 212 tfields
 213 vo
 214 yadif
 215 zrmjpeg
 216 */
 217
 218 CpuCaps ff_gCpuCaps; //FIXME initialize this so optims work
 219
 220
 221 static void ff_sws_getFlagsAndFilterFromCmdLine(int *flags, SwsFilter **srcFilterParam, SwsFilter **dstFilterParam)
 222 {
 223         static int firstTime=1;
 224         *flags=0;
 225
 226 #if ARCH_X86
 227         if(ff_gCpuCaps.hasMMX)
 228                 __asm__ volatile("emms\n\t"::: "memory"); //FIXME this should not be required but it IS (even for non-MMX versions)
 229 #endif
 230         if(firstTime)
 231         {
 232                 firstTime=0;
 233                 *flags= SWS_PRINT_INFO;
 234         }
 235         else if( ff_mp_msg_test(MSGT_VFILTER,MSGL_DBG2) ) *flags= SWS_PRINT_INFO;
 236
 237         switch(SWS_BILINEAR)
 238         {
 239                 case 0: *flags|= SWS_FAST_BILINEAR; break;
 240                 case 1: *flags|= SWS_BILINEAR; break;
 241                 case 2: *flags|= SWS_BICUBIC; break;
 242                 case 3: *flags|= SWS_X; break;
 243                 case 4: *flags|= SWS_POINT; break;
 244                 case 5: *flags|= SWS_AREA; break;
 245                 case 6: *flags|= SWS_BICUBLIN; break;
 246                 case 7: *flags|= SWS_GAUSS; break;
 247                 case 8: *flags|= SWS_SINC; break;
 248                 case 9: *flags|= SWS_LANCZOS; break;
 249                 case 10:*flags|= SWS_SPLINE; break;
 250                 default:*flags|= SWS_BILINEAR; break;
 251         }
 252
 253         *srcFilterParam= NULL;
 254         *dstFilterParam= NULL;
 255 }
 256
 257 //exact copy from vf_scale.c
 258 // will use sws_flags & src_filter (from cmd line)
 259 struct SwsContext *ff_sws_getContextFromCmdLine(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat)
 260 {
 261         int flags, i;
 262         SwsFilter *dstFilterParam, *srcFilterParam;
 263         enum AVPixelFormat dfmt, sfmt;
 264
 265         for(i=0; conversion_map[i].fmt && dstFormat != conversion_map[i].fmt; i++);
 266         dfmt= conversion_map[i].pix_fmt;
 267         for(i=0; conversion_map[i].fmt && srcFormat != conversion_map[i].fmt; i++);
 268         sfmt= conversion_map[i].pix_fmt;
 269
 270         if (srcFormat == IMGFMT_RGB8 || srcFormat == IMGFMT_BGR8) sfmt = AV_PIX_FMT_PAL8;
 271         ff_sws_getFlagsAndFilterFromCmdLine(&flags, &srcFilterParam, &dstFilterParam);
 272
 273         return sws_getContext(srcW, srcH, sfmt, dstW, dstH, dfmt, flags , srcFilterParam, dstFilterParam, NULL);
 274 }
 275
 276 typedef struct {
 277     vf_instance_t vf;
 278     vf_instance_t next_vf;
 279     AVFilterContext *avfctx;
 280     int frame_returned;
 281 } MPContext;
 282
 283 void ff_mp_msg(int mod, int lev, const char *format, ... ){
 284     va_list va;
 285     va_start(va, format);
 286     //FIXME convert lev/mod
 287     av_vlog(NULL, AV_LOG_DEBUG, format, va);
 288     va_end(va);
 289 }
 290
 291 int ff_mp_msg_test(int mod, int lev){
 292     return 123;
 293 }
 294
 295 void ff_init_avcodec(void)
 296 {
 297     //we maybe should init but its kinda 1. unneeded 2. a bit inpolite from here
 298 }
 299
 300 //Exact copy of vf.c
 301 void ff_vf_clone_mpi_attributes(mp_image_t* dst, mp_image_t* src){
 302     dst->pict_type= src->pict_type;
 303     dst->fields = src->fields;
 304     dst->qscale_type= src->qscale_type;
 305     if(dst->width == src->width && dst->height == src->height){
 306         dst->qstride= src->qstride;
 307         dst->qscale= src->qscale;
 308     }
 309 }
 310
 311 //Exact copy of vf.c
 312 void ff_vf_next_draw_slice(struct vf_instance *vf,unsigned char** src, int * stride,int w, int h, int x, int y){
 313     if (vf->next->draw_slice) {
 314         vf->next->draw_slice(vf->next,src,stride,w,h,x,y);
 315         return;
 316     }
 317     if (!vf->dmpi) {
 318         ff_mp_msg(MSGT_VFILTER,MSGL_ERR,"draw_slice: dmpi not stored by vf_%s\n", vf->info->name);
 319         return;
 320     }
 321     if (!(vf->dmpi->flags & MP_IMGFLAG_PLANAR)) {
 322         memcpy_pic(vf->dmpi->planes[0]+y*vf->dmpi->stride[0]+vf->dmpi->bpp/8*x,
 323             src[0], vf->dmpi->bpp/8*w, h, vf->dmpi->stride[0], stride[0]);
 324         return;
 325     }
 326     memcpy_pic(vf->dmpi->planes[0]+y*vf->dmpi->stride[0]+x, src[0],
 327         w, h, vf->dmpi->stride[0], stride[0]);
 328     memcpy_pic(vf->dmpi->planes[1]+(y>>vf->dmpi->chroma_y_shift)*vf->dmpi->stride[1]+(x>>vf->dmpi->chroma_x_shift),
 329         src[1], w>>vf->dmpi->chroma_x_shift, h>>vf->dmpi->chroma_y_shift, vf->dmpi->stride[1], stride[1]);
 330     memcpy_pic(vf->dmpi->planes[2]+(y>>vf->dmpi->chroma_y_shift)*vf->dmpi->stride[2]+(x>>vf->dmpi->chroma_x_shift),
 331         src[2], w>>vf->dmpi->chroma_x_shift, h>>vf->dmpi->chroma_y_shift, vf->dmpi->stride[2], stride[2]);
 332 }
 333
 334 //Exact copy of vf.c
 335 void ff_vf_mpi_clear(mp_image_t* mpi,int x0,int y0,int w,int h){
 336     int y;
 337     if(mpi->flags&MP_IMGFLAG_PLANAR){
 338         y0&=~1;h+=h&1;
 339         if(x0==0 && w==mpi->width){
 340             // full width clear:
 341             memset(mpi->planes[0]+mpi->stride[0]*y0,0,mpi->stride[0]*h);
 342             memset(mpi->planes[1]+mpi->stride[1]*(y0>>mpi->chroma_y_shift),128,mpi->stride[1]*(h>>mpi->chroma_y_shift));
 343             memset(mpi->planes[2]+mpi->stride[2]*(y0>>mpi->chroma_y_shift),128,mpi->stride[2]*(h>>mpi->chroma_y_shift));
 344         } else
 345         for(y=y0;y<y0+h;y+=2){
 346             memset(mpi->planes[0]+x0+mpi->stride[0]*y,0,w);
 347             memset(mpi->planes[0]+x0+mpi->stride[0]*(y+1),0,w);
 348             memset(mpi->planes[1]+(x0>>mpi->chroma_x_shift)+mpi->stride[1]*(y>>mpi->chroma_y_shift),128,(w>>mpi->chroma_x_shift));
 349             memset(mpi->planes[2]+(x0>>mpi->chroma_x_shift)+mpi->stride[2]*(y>>mpi->chroma_y_shift),128,(w>>mpi->chroma_x_shift));
 350         }
 351         return;
 352     }
 353     // packed:
 354     for(y=y0;y<y0+h;y++){
 355         unsigned char* dst=mpi->planes[0]+mpi->stride[0]*y+(mpi->bpp>>3)*x0;
 356         if(mpi->flags&MP_IMGFLAG_YUV){
 357             unsigned int* p=(unsigned int*) dst;
 358             int size=(mpi->bpp>>3)*w/4;
 359             int i;
 360 #if HAVE_BIGENDIAN
 361 #define CLEAR_PACKEDYUV_PATTERN 0x00800080
 362 #define CLEAR_PACKEDYUV_PATTERN_SWAPPED 0x80008000
 363 #else
 364 #define CLEAR_PACKEDYUV_PATTERN 0x80008000
 365 #define CLEAR_PACKEDYUV_PATTERN_SWAPPED 0x00800080
 366 #endif
 367             if(mpi->flags&MP_IMGFLAG_SWAPPED){
 368                 for(i=0;i<size-3;i+=4) p[i]=p[i+1]=p[i+2]=p[i+3]=CLEAR_PACKEDYUV_PATTERN_SWAPPED;
 369                 for(;i<size;i++) p[i]=CLEAR_PACKEDYUV_PATTERN_SWAPPED;
 370             } else {
 371                 for(i=0;i<size-3;i+=4) p[i]=p[i+1]=p[i+2]=p[i+3]=CLEAR_PACKEDYUV_PATTERN;
 372                 for(;i<size;i++) p[i]=CLEAR_PACKEDYUV_PATTERN;
 373             }
 374         } else
 375             memset(dst,0,(mpi->bpp>>3)*w);
 376     }
 377 }
 378
 379 int ff_vf_next_query_format(struct vf_instance *vf, unsigned int fmt){
 380     return 1;
 381 }
 382
 383 //used by delogo
 384 unsigned int ff_vf_match_csp(vf_instance_t** vfp,const unsigned int* list,unsigned int preferred){
 385     return preferred;
 386 }
 387
 388 mp_image_t* ff_vf_get_image(vf_instance_t* vf, unsigned int outfmt, int mp_imgtype, int mp_imgflag, int w, int h){
 389     MPContext *m= (MPContext*)(((uint8_t*)vf) - offsetof(MPContext, next_vf));
 390   mp_image_t* mpi=NULL;
 391   int w2;
 392   int number = mp_imgtype >> 16;
 393
 394   av_assert0(vf->next == NULL); // all existing filters call this just on next
 395
 396   //vf_dint needs these as it calls ff_vf_get_image() before configuring the output
 397   if(vf->w==0 && w>0) vf->w=w;
 398   if(vf->h==0 && h>0) vf->h=h;
 399
 400   av_assert0(w == -1 || w >= vf->w);
 401   av_assert0(h == -1 || h >= vf->h);
 402   av_assert0(vf->w > 0);
 403   av_assert0(vf->h > 0);
 404
 405   av_log(m->avfctx, AV_LOG_DEBUG, "get_image: %d:%d, vf: %d:%d\n", w,h,vf->w,vf->h);
 406
 407   if (w == -1) w = vf->w;
 408   if (h == -1) h = vf->h;
 409
 410   w2=(mp_imgflag&MP_IMGFLAG_ACCEPT_ALIGNED_STRIDE)?((w+15)&(~15)):w;
 411
 412   // Note: we should call libvo first to check if it supports direct rendering
 413   // and if not, then fallback to software buffers:
 414   switch(mp_imgtype & 0xff){
 415   case MP_IMGTYPE_EXPORT:
 416     if(!vf->imgctx.export_images[0]) vf->imgctx.export_images[0]=ff_new_mp_image(w2,h);
 417     mpi=vf->imgctx.export_images[0];
 418     break;
 419   case MP_IMGTYPE_STATIC:
 420     if(!vf->imgctx.static_images[0]) vf->imgctx.static_images[0]=ff_new_mp_image(w2,h);
 421     mpi=vf->imgctx.static_images[0];
 422     break;
 423   case MP_IMGTYPE_TEMP:
 424     if(!vf->imgctx.temp_images[0]) vf->imgctx.temp_images[0]=ff_new_mp_image(w2,h);
 425     mpi=vf->imgctx.temp_images[0];
 426     break;
 427   case MP_IMGTYPE_IPB:
 428     if(!(mp_imgflag&MP_IMGFLAG_READABLE)){ // B frame:
 429       if(!vf->imgctx.temp_images[0]) vf->imgctx.temp_images[0]=ff_new_mp_image(w2,h);
 430       mpi=vf->imgctx.temp_images[0];
 431       break;
 432     }
 433   case MP_IMGTYPE_IP:
 434     if(!vf->imgctx.static_images[vf->imgctx.static_idx]) vf->imgctx.static_images[vf->imgctx.static_idx]=ff_new_mp_image(w2,h);
 435     mpi=vf->imgctx.static_images[vf->imgctx.static_idx];
 436     vf->imgctx.static_idx^=1;
 437     break;
 438   case MP_IMGTYPE_NUMBERED:
 439     if (number == -1) {
 440       int i;
 441       for (i = 0; i < NUM_NUMBERED_MPI; i++)
 442         if (!vf->imgctx.numbered_images[i] || !vf->imgctx.numbered_images[i]->usage_count)
 443           break;
 444       number = i;
 445     }
 446     if (number < 0 || number >= NUM_NUMBERED_MPI) return NULL;
 447     if (!vf->imgctx.numbered_images[number]) vf->imgctx.numbered_images[number] = ff_new_mp_image(w2,h);
 448     mpi = vf->imgctx.numbered_images[number];
 449     mpi->number = number;
 450     break;
 451   }
 452   if(mpi){
 453     mpi->type=mp_imgtype;
 454     mpi->w=vf->w; mpi->h=vf->h;
 455     // keep buffer allocation status & color flags only:
 456 //    mpi->flags&=~(MP_IMGFLAG_PRESERVE|MP_IMGFLAG_READABLE|MP_IMGFLAG_DIRECT);
 457     mpi->flags&=MP_IMGFLAG_ALLOCATED|MP_IMGFLAG_TYPE_DISPLAYED|MP_IMGFLAGMASK_COLORS;
 458     // accept restrictions, draw_slice and palette flags only:
 459     mpi->flags|=mp_imgflag&(MP_IMGFLAGMASK_RESTRICTIONS|MP_IMGFLAG_DRAW_CALLBACK|MP_IMGFLAG_RGB_PALETTE);
 460     if(!vf->draw_slice) mpi->flags&=~MP_IMGFLAG_DRAW_CALLBACK;
 461     if(mpi->width!=w2 || mpi->height!=h){
 462 //      printf("vf.c: MPI parameters changed!  %dx%d -> %dx%d   \n", mpi->width,mpi->height,w2,h);
 463         if(mpi->flags&MP_IMGFLAG_ALLOCATED){
 464             if(mpi->width<w2 || mpi->height<h){
 465                 // need to re-allocate buffer memory:
 466                 av_free(mpi->planes[0]);
 467                 mpi->flags&=~MP_IMGFLAG_ALLOCATED;
 468                 ff_mp_msg(MSGT_VFILTER,MSGL_V,"vf.c: have to REALLOCATE buffer memory :(\n");
 469             }
 470 //      } else {
 471         } {
 472             mpi->width=w2; mpi->chroma_width=(w2 + (1<<mpi->chroma_x_shift) - 1)>>mpi->chroma_x_shift;
 473             mpi->height=h; mpi->chroma_height=(h + (1<<mpi->chroma_y_shift) - 1)>>mpi->chroma_y_shift;
 474         }
 475     }
 476     if(!mpi->bpp) ff_mp_image_setfmt(mpi,outfmt);
 477     if(!(mpi->flags&MP_IMGFLAG_ALLOCATED) && mpi->type>MP_IMGTYPE_EXPORT){
 478
 479         av_assert0(!vf->get_image);
 480         // check libvo first!
 481         if(vf->get_image) vf->get_image(vf,mpi);
 482
 483         if(!(mpi->flags&MP_IMGFLAG_DIRECT)){
 484           // non-direct and not yet allocated image. allocate it!
 485           if (!mpi->bpp) { // no way we can allocate this
 486               ff_mp_msg(MSGT_DECVIDEO, MSGL_FATAL,
 487                      "ff_vf_get_image: Tried to allocate a format that can not be allocated!\n");
 488               return NULL;
 489           }
 490
 491           // check if codec prefer aligned stride:
 492           if(mp_imgflag&MP_IMGFLAG_PREFER_ALIGNED_STRIDE){
 493               int align=(mpi->flags&MP_IMGFLAG_PLANAR &&
 494                          mpi->flags&MP_IMGFLAG_YUV) ?
 495                          (8<<mpi->chroma_x_shift)-1 : 15; // -- maybe FIXME
 496               w2=((w+align)&(~align));
 497               if(mpi->width!=w2){
 498 #if 0
 499                   // we have to change width... check if we CAN co it:
 500                   int flags=vf->query_format(vf,outfmt); // should not fail
 501                   if(!(flags&3)) ff_mp_msg(MSGT_DECVIDEO,MSGL_WARN,"??? ff_vf_get_image{vf->query_format(outfmt)} failed!\n");
 502 //                printf("query -> 0x%X    \n",flags);
 503                   if(flags&VFCAP_ACCEPT_STRIDE){
 504 #endif
 505                       mpi->width=w2;
 506                       mpi->chroma_width=(w2 + (1<<mpi->chroma_x_shift) - 1)>>mpi->chroma_x_shift;
 507 //                  }
 508               }
 509           }
 510
 511           ff_mp_image_alloc_planes(mpi);
 512 //        printf("clearing img!\n");
 513           ff_vf_mpi_clear(mpi,0,0,mpi->width,mpi->height);
 514         }
 515     }
 516     av_assert0(!vf->start_slice);
 517     if(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)
 518         if(vf->start_slice) vf->start_slice(vf,mpi);
 519     if(!(mpi->flags&MP_IMGFLAG_TYPE_DISPLAYED)){
 520             ff_mp_msg(MSGT_DECVIDEO,MSGL_V,"*** [%s] %s%s mp_image_t, %dx%dx%dbpp %s %s, %d bytes\n",
 521                   "NULL"/*vf->info->name*/,
 522                   (mpi->type==MP_IMGTYPE_EXPORT)?"Exporting":
 523                   ((mpi->flags&MP_IMGFLAG_DIRECT)?"Direct Rendering":"Allocating"),
 524                   (mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)?" (slices)":"",
 525                   mpi->width,mpi->height,mpi->bpp,
 526                   (mpi->flags&MP_IMGFLAG_YUV)?"YUV":((mpi->flags&MP_IMGFLAG_SWAPPED)?"BGR":"RGB"),
 527                   (mpi->flags&MP_IMGFLAG_PLANAR)?"planar":"packed",
 528                   mpi->bpp*mpi->width*mpi->height/8);
 529             ff_mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"(imgfmt: %x, planes: %p,%p,%p strides: %d,%d,%d, chroma: %dx%d, shift: h:%d,v:%d)\n",
 530                 mpi->imgfmt, mpi->planes[0], mpi->planes[1], mpi->planes[2],
 531                 mpi->stride[0], mpi->stride[1], mpi->stride[2],
 532                 mpi->chroma_width, mpi->chroma_height, mpi->chroma_x_shift, mpi->chroma_y_shift);
 533             mpi->flags|=MP_IMGFLAG_TYPE_DISPLAYED;
 534     }
 535
 536   mpi->qscale = NULL;
 537   mpi->usage_count++;
 538   }
 539 //    printf("\rVF_MPI: %p %p %p %d %d %d    \n",
 540 //      mpi->planes[0],mpi->planes[1],mpi->planes[2],
 541 //      mpi->stride[0],mpi->stride[1],mpi->stride[2]);
 542   return mpi;
 543 }
 544
 545
 546 int ff_vf_next_put_image(struct vf_instance *vf,mp_image_t *mpi, double pts){
 547     MPContext *m= (void*)vf;
 548     AVFilterLink *outlink     = m->avfctx->outputs[0];
 549     AVFilterBuffer    *pic    = av_mallocz(sizeof(AVFilterBuffer));
 550     AVFilterBufferRef *picref = av_mallocz(sizeof(AVFilterBufferRef));
 551     int i;
 552
 553     av_assert0(vf->next);
 554
 555     av_log(m->avfctx, AV_LOG_DEBUG, "ff_vf_next_put_image\n");
 556
 557     if (!pic || !picref)
 558         goto fail;
 559
 560     picref->buf = pic;
 561     picref->buf->free= (void*)av_free;
 562     if (!(picref->video = av_mallocz(sizeof(AVFilterBufferRefVideoProps))))
 563         goto fail;
 564
 565     pic->w = picref->video->w = mpi->w;
 566     pic->h = picref->video->h = mpi->h;
 567
 568     /* make sure the buffer gets read permission or it's useless for output */
 569     picref->perms = AV_PERM_READ | AV_PERM_REUSE2;
 570 //    av_assert0(mpi->flags&MP_IMGFLAG_READABLE);
 571     if(!(mpi->flags&MP_IMGFLAG_PRESERVE))
 572         picref->perms |= AV_PERM_WRITE;
 573
 574     pic->refcount = 1;
 575     picref->type = AVMEDIA_TYPE_VIDEO;
 576
 577     for(i=0; conversion_map[i].fmt && mpi->imgfmt != conversion_map[i].fmt; i++);
 578     pic->format = picref->format = conversion_map[i].pix_fmt;
 579
 580     memcpy(pic->data,        mpi->planes,   FFMIN(sizeof(pic->data)    , sizeof(mpi->planes)));
 581     memcpy(pic->linesize,    mpi->stride,   FFMIN(sizeof(pic->linesize), sizeof(mpi->stride)));
 582     memcpy(picref->data,     pic->data,     sizeof(picref->data));
 583     memcpy(picref->linesize, pic->linesize, sizeof(picref->linesize));
 584
 585     if(pts != MP_NOPTS_VALUE)
 586         picref->pts= pts * av_q2d(outlink->time_base);
 587
 588     ff_filter_frame(outlink, picref);
 589     m->frame_returned++;
 590
 591     return 1;
 592 fail:
 593     if (picref && picref->video)
 594         av_free(picref->video);
 595     av_free(picref);
 596     av_free(pic);
 597     return 0;
 598 }
 599
 600 int ff_vf_next_config(struct vf_instance *vf,
 601         int width, int height, int d_width, int d_height,
 602         unsigned int voflags, unsigned int outfmt){
 603
 604     av_assert0(width>0 && height>0);
 605     vf->next->w = width; vf->next->h = height;
 606
 607     return 1;
 608 #if 0
 609     int flags=vf->next->query_format(vf->next,outfmt);
 610     if(!flags){
 611         // hmm. colorspace mismatch!!!
 612         //this is fatal for us ATM
 613         return 0;
 614     }
 615     ff_mp_msg(MSGT_VFILTER,MSGL_V,"REQ: flags=0x%X  req=0x%X  \n",flags,vf->default_reqs);
 616     miss=vf->default_reqs - (flags&vf->default_reqs);
 617     if(miss&VFCAP_ACCEPT_STRIDE){
 618         // vf requires stride support but vf->next doesn't support it!
 619         // let's insert the 'expand' filter, it does the job for us:
 620         vf_instance_t* vf2=vf_open_filter(vf->next,"expand",NULL);
 621         if(!vf2) return 0; // shouldn't happen!
 622         vf->next=vf2;
 623     }
 624     vf->next->w = width; vf->next->h = height;
 625     return 1;
 626 #endif
 627 }
 628
 629 int ff_vf_next_control(struct vf_instance *vf, int request, void* data){
 630     MPContext *m= (void*)vf;
 631     av_log(m->avfctx, AV_LOG_DEBUG, "Received control %d\n", request);
 632     return 0;
 633 }
 634
 635 static int vf_default_query_format(struct vf_instance *vf, unsigned int fmt){
 636     MPContext *m= (void*)vf;
 637     int i;
 638     av_log(m->avfctx, AV_LOG_DEBUG, "query %X\n", fmt);
 639
 640     for(i=0; conversion_map[i].fmt; i++){
 641         if(fmt==conversion_map[i].fmt)
 642             return 1; //we suport all
 643     }
 644     return 0;
 645 }
 646
 647
 648 static av_cold int init(AVFilterContext *ctx, const char *args)
 649 {
 650     MPContext *m = ctx->priv;
 651     char name[256];
 652     int i;
 653
 654     m->avfctx= ctx;
 655
 656     if(!args || 1!=sscanf(args, "%255[^:=]", name)){
 657         av_log(ctx, AV_LOG_ERROR, "Invalid parameter.\n");
 658         return AVERROR(EINVAL);
 659     }
 660     args += strlen(name);
 661     if (args[0] == '=')
 662         args++;
 663
 664     for(i=0; ;i++){
 665         if(!filters[i] || !strcmp(name, filters[i]->name))
 666             break;
 667     }
 668
 669     if(!filters[i]){
 670         av_log(ctx, AV_LOG_ERROR, "Unknown filter %s\n", name);
 671         return AVERROR(EINVAL);
 672     }
 673
 674     av_log(ctx, AV_LOG_WARNING,
 675            "'%s' is a wrapped MPlayer filter (libmpcodecs). This filter may be removed\n"
 676            "once it has been ported to a native libavfilter.\n", name);
 677
 678     memset(&m->vf,0,sizeof(m->vf));
 679     m->vf.info= filters[i];
 680
 681     m->vf.next        = &m->next_vf;
 682     m->vf.put_image   = ff_vf_next_put_image;
 683     m->vf.config      = ff_vf_next_config;
 684     m->vf.query_format= vf_default_query_format;
 685     m->vf.control     = ff_vf_next_control;
 686     m->vf.default_caps=VFCAP_ACCEPT_STRIDE;
 687     m->vf.default_reqs=0;
 688     if(m->vf.info->opts)
 689         av_log(ctx, AV_LOG_ERROR, "opts / m_struct_set is unsupported\n");
 690 #if 0
 691     if(vf->info->opts) { // vf_vo get some special argument
 692       const m_struct_t* st = vf->info->opts;
 693       void* vf_priv = m_struct_alloc(st);
 694       int n;
 695       for(n = 0 ; args && args[2*n] ; n++)
 696         m_struct_set(st,vf_priv,args[2*n],args[2*n+1]);
 697       vf->priv = vf_priv;
 698       args = NULL;
 699     } else // Otherwise we should have the '_oldargs_'
 700       if(args && !strcmp(args[0],"_oldargs_"))
 701         args = (char**)args[1];
 702       else
 703         args = NULL;
 704 #endif
 705     if(m->vf.info->vf_open(&m->vf, (char*)args)<=0){
 706         av_log(ctx, AV_LOG_ERROR, "vf_open() of %s with arg=%s failed\n", name, args);
 707         return -1;
 708     }
 709
 710     return 0;
 711 }
 712
 713 static av_cold void uninit(AVFilterContext *ctx)
 714 {
 715     MPContext *m = ctx->priv;
 716     vf_instance_t *vf = &m->vf;
 717
 718     while(vf){
 719         vf_instance_t *next = vf->next;
 720         if(vf->uninit)
 721             vf->uninit(vf);
 722         ff_free_mp_image(vf->imgctx.static_images[0]);
 723         ff_free_mp_image(vf->imgctx.static_images[1]);
 724         ff_free_mp_image(vf->imgctx.temp_images[0]);
 725         ff_free_mp_image(vf->imgctx.export_images[0]);
 726         vf = next;
 727     }
 728 }
 729
 730 static int query_formats(AVFilterContext *ctx)
 731 {
 732     AVFilterFormats *avfmts=NULL;
 733     MPContext *m = ctx->priv;
 734     enum AVPixelFormat lastpixfmt = AV_PIX_FMT_NONE;
 735     int i;
 736
 737     for(i=0; conversion_map[i].fmt; i++){
 738         av_log(ctx, AV_LOG_DEBUG, "query: %X\n", conversion_map[i].fmt);
 739         if(m->vf.query_format(&m->vf, conversion_map[i].fmt)){
 740             av_log(ctx, AV_LOG_DEBUG, "supported,adding\n");
 741             if (conversion_map[i].pix_fmt != lastpixfmt) {
 742                 ff_add_format(&avfmts, conversion_map[i].pix_fmt);
 743                 lastpixfmt = conversion_map[i].pix_fmt;
 744             }
 745         }
 746     }
 747
 748     if (!avfmts)
 749         return -1;
 750
 751     //We assume all allowed input formats are also allowed output formats
 752     ff_set_common_formats(ctx, avfmts);
 753     return 0;
 754 }
 755
 756 static int config_inprops(AVFilterLink *inlink)
 757 {
 758     MPContext *m = inlink->dst->priv;
 759     int i;
 760     for(i=0; conversion_map[i].fmt && conversion_map[i].pix_fmt != inlink->format; i++);
 761
 762     av_assert0(conversion_map[i].fmt && inlink->w && inlink->h);
 763
 764     m->vf.fmt.have_configured = 1;
 765     m->vf.fmt.orig_height     = inlink->h;
 766     m->vf.fmt.orig_width      = inlink->w;
 767     m->vf.fmt.orig_fmt        = conversion_map[i].fmt;
 768
 769     if(m->vf.config(&m->vf, inlink->w, inlink->h, inlink->w, inlink->h, 0, conversion_map[i].fmt)<=0)
 770         return -1;
 771
 772     return 0;
 773 }
 774
 775 static int config_outprops(AVFilterLink *outlink)
 776 {
 777     MPContext *m = outlink->src->priv;
 778
 779     outlink->w = m->next_vf.w;
 780     outlink->h = m->next_vf.h;
 781
 782     return 0;
 783 }
 784
 785 static int request_frame(AVFilterLink *outlink)
 786 {
 787     MPContext *m = outlink->src->priv;
 788     int ret;
 789
 790     av_log(m->avfctx, AV_LOG_DEBUG, "mp request_frame\n");
 791
 792     for(m->frame_returned=0; !m->frame_returned;){
 793         ret=ff_request_frame(outlink->src->inputs[0]);
 794         if(ret<0)
 795             break;
 796     }
 797
 798     av_log(m->avfctx, AV_LOG_DEBUG, "mp request_frame ret=%d\n", ret);
 799     return ret;
 800 }
 801
 802 static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *inpic)
 803 {
 804     MPContext *m = inlink->dst->priv;
 805     int i;
 806     double pts= MP_NOPTS_VALUE;
 807     mp_image_t* mpi = ff_new_mp_image(inpic->video->w, inpic->video->h);
 808
 809     if(inpic->pts != AV_NOPTS_VALUE)
 810         pts= inpic->pts / av_q2d(inlink->time_base);
 811
 812     for(i=0; conversion_map[i].fmt && conversion_map[i].pix_fmt != inlink->format; i++);
 813     ff_mp_image_setfmt(mpi,conversion_map[i].fmt);
 814
 815     memcpy(mpi->planes, inpic->data,     FFMIN(sizeof(inpic->data)    , sizeof(mpi->planes)));
 816     memcpy(mpi->stride, inpic->linesize, FFMIN(sizeof(inpic->linesize), sizeof(mpi->stride)));
 817
 818     //FIXME pass interleced & tff flags around
 819
 820     // mpi->flags|=MP_IMGFLAG_ALLOCATED; ?
 821     mpi->flags |= MP_IMGFLAG_READABLE;
 822     if(!(inpic->perms & AV_PERM_WRITE))
 823         mpi->flags |= MP_IMGFLAG_PRESERVE;
 824     if(m->vf.put_image(&m->vf, mpi, pts) == 0){
 825         av_log(m->avfctx, AV_LOG_DEBUG, "put_image() says skip\n");
 826     }else{
 827         avfilter_unref_buffer(inpic);
 828     }
 829     ff_free_mp_image(mpi);
 830     return 0;
 831 }
 832
 833 static const AVFilterPad mp_inputs[] = {
 834     {
 835         .name         = "default",
 836         .type         = AVMEDIA_TYPE_VIDEO,
 837         .filter_frame = filter_frame,
 838         .config_props = config_inprops,
 839         .min_perms    = AV_PERM_READ,
 840     },
 841     { NULL }
 842 };
 843
 844 static const AVFilterPad mp_outputs[] = {
 845     {
 846         .name          = "default",
 847         .type          = AVMEDIA_TYPE_VIDEO,
 848         .request_frame = request_frame,
 849         .config_props  = config_outprops,
 850     },
 851     { NULL }
 852 };
 853
 854 AVFilter avfilter_vf_mp = {
 855     .name      = "mp",
 856     .description = NULL_IF_CONFIG_SMALL("Apply a libmpcodecs filter to the input video."),
 857     .init = init,
 858     .uninit = uninit,
 859     .priv_size = sizeof(MPContext),
 860     .query_formats = query_formats,
 861     .inputs        = mp_inputs,
 862     .outputs       = mp_outputs,
 863 };