src/third_party/ffmpeg/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 #include "libavutil/opt.h"
  36
  37 #include "libmpcodecs/vf.h"
  38 #include "libmpcodecs/img_format.h"
  39 #include "libmpcodecs/cpudetect.h"
  40 #include "libmpcodecs/av_helpers.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 #if FF_API_XVMC
 115     {IMGFMT_XVMC_MOCO_MPEG2, AV_PIX_FMT_XVMC_MPEG2_MC},
 116     {IMGFMT_XVMC_IDCT_MPEG2, AV_PIX_FMT_XVMC_MPEG2_IDCT},
 117 #endif /* FF_API_XVMC */
 118
 119     {IMGFMT_VDPAU_MPEG1,     AV_PIX_FMT_VDPAU_MPEG1},
 120     {IMGFMT_VDPAU_MPEG2,     AV_PIX_FMT_VDPAU_MPEG2},
 121     {IMGFMT_VDPAU_H264,      AV_PIX_FMT_VDPAU_H264},
 122     {IMGFMT_VDPAU_WMV3,      AV_PIX_FMT_VDPAU_WMV3},
 123     {IMGFMT_VDPAU_VC1,       AV_PIX_FMT_VDPAU_VC1},
 124     {IMGFMT_VDPAU_MPEG4,     AV_PIX_FMT_VDPAU_MPEG4},
 125     {0, AV_PIX_FMT_NONE}
 126 };
 127
 128 extern const vf_info_t ff_vf_info_eq2;
 129 extern const vf_info_t ff_vf_info_eq;
 130 extern const vf_info_t ff_vf_info_fspp;
 131 extern const vf_info_t ff_vf_info_ilpack;
 132 extern const vf_info_t ff_vf_info_pp7;
 133 extern const vf_info_t ff_vf_info_softpulldown;
 134 extern const vf_info_t ff_vf_info_uspp;
 135
 136
 137 static const vf_info_t* const filters[]={
 138     &ff_vf_info_eq2,
 139     &ff_vf_info_eq,
 140     &ff_vf_info_fspp,
 141     &ff_vf_info_ilpack,
 142     &ff_vf_info_pp7,
 143     &ff_vf_info_softpulldown,
 144     &ff_vf_info_uspp,
 145
 146     NULL
 147 };
 148
 149 /*
 150 Unsupported filters
 151 1bpp
 152 ass
 153 bmovl
 154 crop
 155 dvbscale
 156 flip
 157 expand
 158 format
 159 halfpack
 160 lavc
 161 lavcdeint
 162 noformat
 163 pp
 164 scale
 165 tfields
 166 vo
 167 yadif
 168 zrmjpeg
 169 */
 170
 171 CpuCaps ff_gCpuCaps; //FIXME initialize this so optims work
 172
 173 enum AVPixelFormat ff_mp2ff_pix_fmt(int mp){
 174     int i;
 175     for(i=0; conversion_map[i].fmt && mp != conversion_map[i].fmt; i++)
 176         ;
 177     return mp == conversion_map[i].fmt ? conversion_map[i].pix_fmt : AV_PIX_FMT_NONE;
 178 }
 179
 180 typedef struct {
 181     const AVClass *class;
 182     vf_instance_t vf;
 183     vf_instance_t next_vf;
 184     AVFilterContext *avfctx;
 185     int frame_returned;
 186     char *filter;
 187     enum AVPixelFormat in_pix_fmt;
 188 } MPContext;
 189
 190 #define OFFSET(x) offsetof(MPContext, x)
 191 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
 192 static const AVOption mp_options[] = {
 193     { "filter", "set MPlayer filter name and parameters", OFFSET(filter), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
 194     { NULL }
 195 };
 196
 197 AVFILTER_DEFINE_CLASS(mp);
 198
 199 void ff_mp_msg(int mod, int lev, const char *format, ... ){
 200     va_list va;
 201     va_start(va, format);
 202     //FIXME convert lev/mod
 203     av_vlog(NULL, AV_LOG_DEBUG, format, va);
 204     va_end(va);
 205 }
 206
 207 int ff_mp_msg_test(int mod, int lev){
 208     return 123;
 209 }
 210
 211 void ff_init_avcodec(void)
 212 {
 213     //we maybe should init but its kinda 1. unneeded 2. a bit impolite from here
 214 }
 215
 216 //Exact copy of vf.c
 217 void ff_vf_clone_mpi_attributes(mp_image_t* dst, mp_image_t* src){
 218     dst->pict_type= src->pict_type;
 219     dst->fields = src->fields;
 220     dst->qscale_type= src->qscale_type;
 221     if(dst->width == src->width && dst->height == src->height){
 222         dst->qstride= src->qstride;
 223         dst->qscale= src->qscale;
 224     }
 225 }
 226
 227 //Exact copy of vf.c
 228 void ff_vf_next_draw_slice(struct vf_instance *vf,unsigned char** src, int * stride,int w, int h, int x, int y){
 229     if (vf->next->draw_slice) {
 230         vf->next->draw_slice(vf->next,src,stride,w,h,x,y);
 231         return;
 232     }
 233     if (!vf->dmpi) {
 234         ff_mp_msg(MSGT_VFILTER,MSGL_ERR,"draw_slice: dmpi not stored by vf_%s\n", vf->info->name);
 235         return;
 236     }
 237     if (!(vf->dmpi->flags & MP_IMGFLAG_PLANAR)) {
 238         memcpy_pic(vf->dmpi->planes[0]+y*vf->dmpi->stride[0]+vf->dmpi->bpp/8*x,
 239             src[0], vf->dmpi->bpp/8*w, h, vf->dmpi->stride[0], stride[0]);
 240         return;
 241     }
 242     memcpy_pic(vf->dmpi->planes[0]+y*vf->dmpi->stride[0]+x, src[0],
 243         w, h, vf->dmpi->stride[0], stride[0]);
 244     memcpy_pic(vf->dmpi->planes[1]+(y>>vf->dmpi->chroma_y_shift)*vf->dmpi->stride[1]+(x>>vf->dmpi->chroma_x_shift),
 245         src[1], w>>vf->dmpi->chroma_x_shift, h>>vf->dmpi->chroma_y_shift, vf->dmpi->stride[1], stride[1]);
 246     memcpy_pic(vf->dmpi->planes[2]+(y>>vf->dmpi->chroma_y_shift)*vf->dmpi->stride[2]+(x>>vf->dmpi->chroma_x_shift),
 247         src[2], w>>vf->dmpi->chroma_x_shift, h>>vf->dmpi->chroma_y_shift, vf->dmpi->stride[2], stride[2]);
 248 }
 249
 250 //Exact copy of vf.c
 251 void ff_vf_mpi_clear(mp_image_t* mpi,int x0,int y0,int w,int h){
 252     int y;
 253     if(mpi->flags&MP_IMGFLAG_PLANAR){
 254         y0&=~1;h+=h&1;
 255         if(x0==0 && w==mpi->width){
 256             // full width clear:
 257             memset(mpi->planes[0]+mpi->stride[0]*y0,0,mpi->stride[0]*h);
 258             memset(mpi->planes[1]+mpi->stride[1]*(y0>>mpi->chroma_y_shift),128,mpi->stride[1]*(h>>mpi->chroma_y_shift));
 259             memset(mpi->planes[2]+mpi->stride[2]*(y0>>mpi->chroma_y_shift),128,mpi->stride[2]*(h>>mpi->chroma_y_shift));
 260         } else
 261         for(y=y0;y<y0+h;y+=2){
 262             memset(mpi->planes[0]+x0+mpi->stride[0]*y,0,w);
 263             memset(mpi->planes[0]+x0+mpi->stride[0]*(y+1),0,w);
 264             memset(mpi->planes[1]+(x0>>mpi->chroma_x_shift)+mpi->stride[1]*(y>>mpi->chroma_y_shift),128,(w>>mpi->chroma_x_shift));
 265             memset(mpi->planes[2]+(x0>>mpi->chroma_x_shift)+mpi->stride[2]*(y>>mpi->chroma_y_shift),128,(w>>mpi->chroma_x_shift));
 266         }
 267         return;
 268     }
 269     // packed:
 270     for(y=y0;y<y0+h;y++){
 271         unsigned char* dst=mpi->planes[0]+mpi->stride[0]*y+(mpi->bpp>>3)*x0;
 272         if(mpi->flags&MP_IMGFLAG_YUV){
 273             unsigned int* p=(unsigned int*) dst;
 274             int size=(mpi->bpp>>3)*w/4;
 275             int i;
 276 #if HAVE_BIGENDIAN
 277 #define CLEAR_PACKEDYUV_PATTERN 0x00800080
 278 #define CLEAR_PACKEDYUV_PATTERN_SWAPPED 0x80008000
 279 #else
 280 #define CLEAR_PACKEDYUV_PATTERN 0x80008000
 281 #define CLEAR_PACKEDYUV_PATTERN_SWAPPED 0x00800080
 282 #endif
 283             if(mpi->flags&MP_IMGFLAG_SWAPPED){
 284                 for(i=0;i<size-3;i+=4) p[i]=p[i+1]=p[i+2]=p[i+3]=CLEAR_PACKEDYUV_PATTERN_SWAPPED;
 285                 for(;i<size;i++) p[i]=CLEAR_PACKEDYUV_PATTERN_SWAPPED;
 286             } else {
 287                 for(i=0;i<size-3;i+=4) p[i]=p[i+1]=p[i+2]=p[i+3]=CLEAR_PACKEDYUV_PATTERN;
 288                 for(;i<size;i++) p[i]=CLEAR_PACKEDYUV_PATTERN;
 289             }
 290         } else
 291             memset(dst,0,(mpi->bpp>>3)*w);
 292     }
 293 }
 294
 295 int ff_vf_next_query_format(struct vf_instance *vf, unsigned int fmt){
 296     return 1;
 297 }
 298
 299 //used by delogo
 300 unsigned int ff_vf_match_csp(vf_instance_t** vfp,const unsigned int* list,unsigned int preferred){
 301     return preferred;
 302 }
 303
 304 mp_image_t* ff_vf_get_image(vf_instance_t* vf, unsigned int outfmt, int mp_imgtype, int mp_imgflag, int w, int h){
 305     MPContext *m= (MPContext*)(((uint8_t*)vf) - offsetof(MPContext, next_vf));
 306   mp_image_t* mpi=NULL;
 307   int w2;
 308   int number = mp_imgtype >> 16;
 309
 310   av_assert0(vf->next == NULL); // all existing filters call this just on next
 311
 312   //vf_dint needs these as it calls ff_vf_get_image() before configuring the output
 313   if(vf->w==0 && w>0) vf->w=w;
 314   if(vf->h==0 && h>0) vf->h=h;
 315
 316   av_assert0(w == -1 || w >= vf->w);
 317   av_assert0(h == -1 || h >= vf->h);
 318   av_assert0(vf->w > 0);
 319   av_assert0(vf->h > 0);
 320
 321   av_log(m->avfctx, AV_LOG_DEBUG, "get_image: %d:%d, vf: %d:%d\n", w,h,vf->w,vf->h);
 322
 323   if (w == -1) w = vf->w;
 324   if (h == -1) h = vf->h;
 325
 326   w2=(mp_imgflag&MP_IMGFLAG_ACCEPT_ALIGNED_STRIDE)?((w+15)&(~15)):w;
 327
 328   // Note: we should call libvo first to check if it supports direct rendering
 329   // and if not, then fallback to software buffers:
 330   switch(mp_imgtype & 0xff){
 331   case MP_IMGTYPE_EXPORT:
 332     if(!vf->imgctx.export_images[0]) vf->imgctx.export_images[0]=ff_new_mp_image(w2,h);
 333     mpi=vf->imgctx.export_images[0];
 334     break;
 335   case MP_IMGTYPE_STATIC:
 336     if(!vf->imgctx.static_images[0]) vf->imgctx.static_images[0]=ff_new_mp_image(w2,h);
 337     mpi=vf->imgctx.static_images[0];
 338     break;
 339   case MP_IMGTYPE_TEMP:
 340     if(!vf->imgctx.temp_images[0]) vf->imgctx.temp_images[0]=ff_new_mp_image(w2,h);
 341     mpi=vf->imgctx.temp_images[0];
 342     break;
 343   case MP_IMGTYPE_IPB:
 344     if(!(mp_imgflag&MP_IMGFLAG_READABLE)){ // B frame:
 345       if(!vf->imgctx.temp_images[0]) vf->imgctx.temp_images[0]=ff_new_mp_image(w2,h);
 346       mpi=vf->imgctx.temp_images[0];
 347       break;
 348     }
 349   case MP_IMGTYPE_IP:
 350     if(!vf->imgctx.static_images[vf->imgctx.static_idx]) vf->imgctx.static_images[vf->imgctx.static_idx]=ff_new_mp_image(w2,h);
 351     mpi=vf->imgctx.static_images[vf->imgctx.static_idx];
 352     vf->imgctx.static_idx^=1;
 353     break;
 354   case MP_IMGTYPE_NUMBERED:
 355     if (number == -1) {
 356       int i;
 357       for (i = 0; i < NUM_NUMBERED_MPI; i++)
 358         if (!vf->imgctx.numbered_images[i] || !vf->imgctx.numbered_images[i]->usage_count)
 359           break;
 360       number = i;
 361     }
 362     if (number < 0 || number >= NUM_NUMBERED_MPI) return NULL;
 363     if (!vf->imgctx.numbered_images[number]) vf->imgctx.numbered_images[number] = ff_new_mp_image(w2,h);
 364     mpi = vf->imgctx.numbered_images[number];
 365     mpi->number = number;
 366     break;
 367   }
 368   if(mpi){
 369     mpi->type=mp_imgtype;
 370     mpi->w=vf->w; mpi->h=vf->h;
 371     // keep buffer allocation status & color flags only:
 372 //    mpi->flags&=~(MP_IMGFLAG_PRESERVE|MP_IMGFLAG_READABLE|MP_IMGFLAG_DIRECT);
 373     mpi->flags&=MP_IMGFLAG_ALLOCATED|MP_IMGFLAG_TYPE_DISPLAYED|MP_IMGFLAGMASK_COLORS;
 374     // accept restrictions, draw_slice and palette flags only:
 375     mpi->flags|=mp_imgflag&(MP_IMGFLAGMASK_RESTRICTIONS|MP_IMGFLAG_DRAW_CALLBACK|MP_IMGFLAG_RGB_PALETTE);
 376     if(!vf->draw_slice) mpi->flags&=~MP_IMGFLAG_DRAW_CALLBACK;
 377     if(mpi->width!=w2 || mpi->height!=h){
 378 //      printf("vf.c: MPI parameters changed!  %dx%d -> %dx%d   \n", mpi->width,mpi->height,w2,h);
 379         if(mpi->flags&MP_IMGFLAG_ALLOCATED){
 380             if(mpi->width<w2 || mpi->height<h){
 381                 // need to re-allocate buffer memory:
 382                 av_free(mpi->planes[0]);
 383                 mpi->flags&=~MP_IMGFLAG_ALLOCATED;
 384                 ff_mp_msg(MSGT_VFILTER,MSGL_V,"vf.c: have to REALLOCATE buffer memory :(\n");
 385             }
 386 //      } else {
 387         } {
 388             mpi->width=w2; mpi->chroma_width=(w2 + (1<<mpi->chroma_x_shift) - 1)>>mpi->chroma_x_shift;
 389             mpi->height=h; mpi->chroma_height=(h + (1<<mpi->chroma_y_shift) - 1)>>mpi->chroma_y_shift;
 390         }
 391     }
 392     if(!mpi->bpp) ff_mp_image_setfmt(mpi,outfmt);
 393     if(!(mpi->flags&MP_IMGFLAG_ALLOCATED) && mpi->type>MP_IMGTYPE_EXPORT){
 394
 395         av_assert0(!vf->get_image);
 396         // check libvo first!
 397         if(vf->get_image) vf->get_image(vf,mpi);
 398
 399         if(!(mpi->flags&MP_IMGFLAG_DIRECT)){
 400           // non-direct and not yet allocated image. allocate it!
 401           if (!mpi->bpp) { // no way we can allocate this
 402               ff_mp_msg(MSGT_DECVIDEO, MSGL_FATAL,
 403                      "ff_vf_get_image: Tried to allocate a format that can not be allocated!\n");
 404               return NULL;
 405           }
 406
 407           // check if codec prefer aligned stride:
 408           if(mp_imgflag&MP_IMGFLAG_PREFER_ALIGNED_STRIDE){
 409               int align=(mpi->flags&MP_IMGFLAG_PLANAR &&
 410                          mpi->flags&MP_IMGFLAG_YUV) ?
 411                          (8<<mpi->chroma_x_shift)-1 : 15; // -- maybe FIXME
 412               w2=((w+align)&(~align));
 413               if(mpi->width!=w2){
 414 #if 0
 415                   // we have to change width... check if we CAN co it:
 416                   int flags=vf->query_format(vf,outfmt); // should not fail
 417                   if(!(flags&3)) ff_mp_msg(MSGT_DECVIDEO,MSGL_WARN,"??? ff_vf_get_image{vf->query_format(outfmt)} failed!\n");
 418 //                printf("query -> 0x%X    \n",flags);
 419                   if(flags&VFCAP_ACCEPT_STRIDE){
 420 #endif
 421                       mpi->width=w2;
 422                       mpi->chroma_width=(w2 + (1<<mpi->chroma_x_shift) - 1)>>mpi->chroma_x_shift;
 423 //                  }
 424               }
 425           }
 426
 427           ff_mp_image_alloc_planes(mpi);
 428 //        printf("clearing img!\n");
 429           ff_vf_mpi_clear(mpi,0,0,mpi->width,mpi->height);
 430         }
 431     }
 432     av_assert0(!vf->start_slice);
 433     if(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)
 434         if(vf->start_slice) vf->start_slice(vf,mpi);
 435     if(!(mpi->flags&MP_IMGFLAG_TYPE_DISPLAYED)){
 436             ff_mp_msg(MSGT_DECVIDEO,MSGL_V,"*** [%s] %s%s mp_image_t, %dx%dx%dbpp %s %s, %d bytes\n",
 437                   "NULL"/*vf->info->name*/,
 438                   (mpi->type==MP_IMGTYPE_EXPORT)?"Exporting":
 439                   ((mpi->flags&MP_IMGFLAG_DIRECT)?"Direct Rendering":"Allocating"),
 440                   (mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)?" (slices)":"",
 441                   mpi->width,mpi->height,mpi->bpp,
 442                   (mpi->flags&MP_IMGFLAG_YUV)?"YUV":((mpi->flags&MP_IMGFLAG_SWAPPED)?"BGR":"RGB"),
 443                   (mpi->flags&MP_IMGFLAG_PLANAR)?"planar":"packed",
 444                   mpi->bpp*mpi->width*mpi->height/8);
 445             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",
 446                 mpi->imgfmt, mpi->planes[0], mpi->planes[1], mpi->planes[2],
 447                 mpi->stride[0], mpi->stride[1], mpi->stride[2],
 448                 mpi->chroma_width, mpi->chroma_height, mpi->chroma_x_shift, mpi->chroma_y_shift);
 449             mpi->flags|=MP_IMGFLAG_TYPE_DISPLAYED;
 450     }
 451
 452   mpi->qscale = NULL;
 453   mpi->usage_count++;
 454   }
 455 //    printf("\rVF_MPI: %p %p %p %d %d %d    \n",
 456 //      mpi->planes[0],mpi->planes[1],mpi->planes[2],
 457 //      mpi->stride[0],mpi->stride[1],mpi->stride[2]);
 458   return mpi;
 459 }
 460
 461 int ff_vf_next_put_image(struct vf_instance *vf,mp_image_t *mpi, double pts){
 462     MPContext *m= (MPContext*)(((uint8_t*)vf) - offsetof(MPContext, vf));
 463     AVFilterLink *outlink     = m->avfctx->outputs[0];
 464     AVFrame *picref = av_frame_alloc();
 465     int i;
 466
 467     av_assert0(vf->next);
 468
 469     av_log(m->avfctx, AV_LOG_DEBUG, "ff_vf_next_put_image\n");
 470
 471     if (!picref)
 472         goto fail;
 473
 474     picref->width  = mpi->w;
 475     picref->height = mpi->h;
 476
 477     picref->type = AVMEDIA_TYPE_VIDEO;
 478
 479     for(i=0; conversion_map[i].fmt && mpi->imgfmt != conversion_map[i].fmt; i++);
 480     picref->format = conversion_map[i].pix_fmt;
 481
 482     for(i=0; conversion_map[i].fmt && m->in_pix_fmt != conversion_map[i].pix_fmt; i++);
 483     if (mpi->imgfmt == conversion_map[i].fmt)
 484         picref->format = conversion_map[i].pix_fmt;
 485
 486     memcpy(picref->linesize, mpi->stride, FFMIN(sizeof(picref->linesize), sizeof(mpi->stride)));
 487
 488     for(i=0; i<4 && mpi->stride[i]; i++){
 489         picref->data[i] = mpi->planes[i];
 490     }
 491
 492     if(pts != MP_NOPTS_VALUE)
 493         picref->pts= pts * av_q2d(outlink->time_base);
 494
 495     if(1) { // mp buffers are currently unsupported in libavfilter, we thus must copy
 496         AVFrame *tofree = picref;
 497         picref = av_frame_clone(picref);
 498         av_frame_free(&tofree);
 499     }
 500
 501     ff_filter_frame(outlink, picref);
 502     m->frame_returned++;
 503
 504     return 1;
 505 fail:
 506     av_frame_free(&picref);
 507     return 0;
 508 }
 509
 510 int ff_vf_next_config(struct vf_instance *vf,
 511         int width, int height, int d_width, int d_height,
 512         unsigned int voflags, unsigned int outfmt){
 513
 514     av_assert0(width>0 && height>0);
 515     vf->next->w = width; vf->next->h = height;
 516
 517     return 1;
 518 #if 0
 519     int flags=vf->next->query_format(vf->next,outfmt);
 520     if(!flags){
 521         // hmm. colorspace mismatch!!!
 522         //this is fatal for us ATM
 523         return 0;
 524     }
 525     ff_mp_msg(MSGT_VFILTER,MSGL_V,"REQ: flags=0x%X  req=0x%X  \n",flags,vf->default_reqs);
 526     miss=vf->default_reqs - (flags&vf->default_reqs);
 527     if(miss&VFCAP_ACCEPT_STRIDE){
 528         // vf requires stride support but vf->next doesn't support it!
 529         // let's insert the 'expand' filter, it does the job for us:
 530         vf_instance_t* vf2=vf_open_filter(vf->next,"expand",NULL);
 531         if(!vf2) return 0; // shouldn't happen!
 532         vf->next=vf2;
 533     }
 534     vf->next->w = width; vf->next->h = height;
 535     return 1;
 536 #endif
 537 }
 538
 539 int ff_vf_next_control(struct vf_instance *vf, int request, void* data){
 540     MPContext *m= (MPContext*)(((uint8_t*)vf) - offsetof(MPContext, vf));
 541     av_log(m->avfctx, AV_LOG_DEBUG, "Received control %d\n", request);
 542     return 0;
 543 }
 544
 545 static int vf_default_query_format(struct vf_instance *vf, unsigned int fmt){
 546     MPContext *m= (MPContext*)(((uint8_t*)vf) - offsetof(MPContext, vf));
 547     int i;
 548     av_log(m->avfctx, AV_LOG_DEBUG, "query %X\n", fmt);
 549
 550     for(i=0; conversion_map[i].fmt; i++){
 551         if(fmt==conversion_map[i].fmt)
 552             return 1; //we suport all
 553     }
 554     return 0;
 555 }
 556
 557
 558 static av_cold int init(AVFilterContext *ctx)
 559 {
 560     MPContext *m = ctx->priv;
 561     int cpu_flags = av_get_cpu_flags();
 562     char name[256];
 563     const char *args;
 564     int i;
 565
 566     ff_gCpuCaps.hasMMX      = cpu_flags & AV_CPU_FLAG_MMX;
 567     ff_gCpuCaps.hasMMX2     = cpu_flags & AV_CPU_FLAG_MMX2;
 568     ff_gCpuCaps.hasSSE      = cpu_flags & AV_CPU_FLAG_SSE;
 569     ff_gCpuCaps.hasSSE2     = cpu_flags & AV_CPU_FLAG_SSE2;
 570     ff_gCpuCaps.hasSSE3     = cpu_flags & AV_CPU_FLAG_SSE3;
 571     ff_gCpuCaps.hasSSSE3    = cpu_flags & AV_CPU_FLAG_SSSE3;
 572     ff_gCpuCaps.hasSSE4     = cpu_flags & AV_CPU_FLAG_SSE4;
 573     ff_gCpuCaps.hasSSE42    = cpu_flags & AV_CPU_FLAG_SSE42;
 574     ff_gCpuCaps.hasAVX      = cpu_flags & AV_CPU_FLAG_AVX;
 575     ff_gCpuCaps.has3DNow    = cpu_flags & AV_CPU_FLAG_3DNOW;
 576     ff_gCpuCaps.has3DNowExt = cpu_flags & AV_CPU_FLAG_3DNOWEXT;
 577
 578     m->avfctx= ctx;
 579
 580     args = m->filter;
 581     if(!args || 1!=sscanf(args, "%255[^:=]", name)){
 582         av_log(ctx, AV_LOG_ERROR, "Invalid parameter.\n");
 583         return AVERROR(EINVAL);
 584     }
 585     args += strlen(name);
 586     if (args[0] == '=')
 587         args++;
 588
 589     for(i=0; ;i++){
 590         if(!filters[i] || !strcmp(name, filters[i]->name))
 591             break;
 592     }
 593
 594     if(!filters[i]){
 595         av_log(ctx, AV_LOG_ERROR, "Unknown filter %s\n", name);
 596         return AVERROR(EINVAL);
 597     }
 598
 599     av_log(ctx, AV_LOG_WARNING,
 600            "'%s' is a wrapped MPlayer filter (libmpcodecs). This filter may be removed\n"
 601            "once it has been ported to a native libavfilter.\n", name);
 602
 603     memset(&m->vf,0,sizeof(m->vf));
 604     m->vf.info= filters[i];
 605
 606     m->vf.next        = &m->next_vf;
 607     m->vf.put_image   = ff_vf_next_put_image;
 608     m->vf.config      = ff_vf_next_config;
 609     m->vf.query_format= vf_default_query_format;
 610     m->vf.control     = ff_vf_next_control;
 611     m->vf.default_caps=VFCAP_ACCEPT_STRIDE;
 612     m->vf.default_reqs=0;
 613     if(m->vf.info->opts)
 614         av_log(ctx, AV_LOG_ERROR, "opts / m_struct_set is unsupported\n");
 615 #if 0
 616     if(vf->info->opts) { // vf_vo get some special argument
 617       const m_struct_t* st = vf->info->opts;
 618       void* vf_priv = m_struct_alloc(st);
 619       int n;
 620       for(n = 0 ; args && args[2*n] ; n++)
 621         m_struct_set(st,vf_priv,args[2*n],args[2*n+1]);
 622       vf->priv = vf_priv;
 623       args = NULL;
 624     } else // Otherwise we should have the '_oldargs_'
 625       if(args && !strcmp(args[0],"_oldargs_"))
 626         args = (char**)args[1];
 627       else
 628         args = NULL;
 629 #endif
 630     if(m->vf.info->vf_open(&m->vf, (char*)args)<=0){
 631         av_log(ctx, AV_LOG_ERROR, "vf_open() of %s with arg=%s failed\n", name, args);
 632         return -1;
 633     }
 634
 635     return 0;
 636 }
 637
 638 static av_cold void uninit(AVFilterContext *ctx)
 639 {
 640     MPContext *m = ctx->priv;
 641     vf_instance_t *vf = &m->vf;
 642
 643     while(vf){
 644         vf_instance_t *next = vf->next;
 645         if(vf->uninit)
 646             vf->uninit(vf);
 647         ff_free_mp_image(vf->imgctx.static_images[0]);
 648         ff_free_mp_image(vf->imgctx.static_images[1]);
 649         ff_free_mp_image(vf->imgctx.temp_images[0]);
 650         ff_free_mp_image(vf->imgctx.export_images[0]);
 651         vf = next;
 652     }
 653 }
 654
 655 static int query_formats(AVFilterContext *ctx)
 656 {
 657     AVFilterFormats *avfmts=NULL;
 658     MPContext *m = ctx->priv;
 659     enum AVPixelFormat lastpixfmt = AV_PIX_FMT_NONE;
 660     int i;
 661
 662     for(i=0; conversion_map[i].fmt; i++){
 663         av_log(ctx, AV_LOG_DEBUG, "query: %X\n", conversion_map[i].fmt);
 664         if(m->vf.query_format(&m->vf, conversion_map[i].fmt)){
 665             av_log(ctx, AV_LOG_DEBUG, "supported,adding\n");
 666             if (conversion_map[i].pix_fmt != lastpixfmt) {
 667                 ff_add_format(&avfmts, conversion_map[i].pix_fmt);
 668                 lastpixfmt = conversion_map[i].pix_fmt;
 669             }
 670         }
 671     }
 672
 673     if (!avfmts)
 674         return -1;
 675
 676     //We assume all allowed input formats are also allowed output formats
 677     ff_set_common_formats(ctx, avfmts);
 678     return 0;
 679 }
 680
 681 static int config_inprops(AVFilterLink *inlink)
 682 {
 683     MPContext *m = inlink->dst->priv;
 684     int i;
 685     for(i=0; conversion_map[i].fmt && conversion_map[i].pix_fmt != inlink->format; i++);
 686
 687     av_assert0(conversion_map[i].fmt && inlink->w && inlink->h);
 688
 689     m->vf.fmt.have_configured = 1;
 690     m->vf.fmt.orig_height     = inlink->h;
 691     m->vf.fmt.orig_width      = inlink->w;
 692     m->vf.fmt.orig_fmt        = conversion_map[i].fmt;
 693
 694     if(m->vf.config(&m->vf, inlink->w, inlink->h, inlink->w, inlink->h, 0, conversion_map[i].fmt)<=0)
 695         return -1;
 696
 697     return 0;
 698 }
 699
 700 static int config_outprops(AVFilterLink *outlink)
 701 {
 702     MPContext *m = outlink->src->priv;
 703
 704     outlink->w = m->next_vf.w;
 705     outlink->h = m->next_vf.h;
 706
 707     return 0;
 708 }
 709
 710 static int request_frame(AVFilterLink *outlink)
 711 {
 712     MPContext *m = outlink->src->priv;
 713     int ret;
 714
 715     av_log(m->avfctx, AV_LOG_DEBUG, "mp request_frame\n");
 716
 717     for(m->frame_returned=0; !m->frame_returned;){
 718         ret=ff_request_frame(outlink->src->inputs[0]);
 719         if(ret<0)
 720             break;
 721     }
 722
 723     av_log(m->avfctx, AV_LOG_DEBUG, "mp request_frame ret=%d\n", ret);
 724     return ret;
 725 }
 726
 727 static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
 728 {
 729     MPContext *m = inlink->dst->priv;
 730     int i;
 731     double pts= MP_NOPTS_VALUE;
 732     mp_image_t* mpi = ff_new_mp_image(inpic->width, inpic->height);
 733
 734     if(inpic->pts != AV_NOPTS_VALUE)
 735         pts= inpic->pts / av_q2d(inlink->time_base);
 736
 737     for(i=0; conversion_map[i].fmt && conversion_map[i].pix_fmt != inlink->format; i++);
 738     ff_mp_image_setfmt(mpi,conversion_map[i].fmt);
 739     m->in_pix_fmt = inlink->format;
 740
 741     memcpy(mpi->planes, inpic->data,     FFMIN(sizeof(inpic->data)    , sizeof(mpi->planes)));
 742     memcpy(mpi->stride, inpic->linesize, FFMIN(sizeof(inpic->linesize), sizeof(mpi->stride)));
 743
 744     if (inpic->interlaced_frame)
 745         mpi->fields |= MP_IMGFIELD_INTERLACED;
 746     if (inpic->top_field_first)
 747         mpi->fields |= MP_IMGFIELD_TOP_FIRST;
 748     if (inpic->repeat_pict)
 749         mpi->fields |= MP_IMGFIELD_REPEAT_FIRST;
 750
 751     // mpi->flags|=MP_IMGFLAG_ALLOCATED; ?
 752     mpi->flags |= MP_IMGFLAG_READABLE;
 753     if(!av_frame_is_writable(inpic))
 754         mpi->flags |= MP_IMGFLAG_PRESERVE;
 755     if(m->vf.put_image(&m->vf, mpi, pts) == 0){
 756         av_log(m->avfctx, AV_LOG_DEBUG, "put_image() says skip\n");
 757     }else{
 758         av_frame_free(&inpic);
 759     }
 760     ff_free_mp_image(mpi);
 761     return 0;
 762 }
 763
 764 static const AVFilterPad mp_inputs[] = {
 765     {
 766         .name         = "default",
 767         .type         = AVMEDIA_TYPE_VIDEO,
 768         .filter_frame = filter_frame,
 769         .config_props = config_inprops,
 770     },
 771     { NULL }
 772 };
 773
 774 static const AVFilterPad mp_outputs[] = {
 775     {
 776         .name          = "default",
 777         .type          = AVMEDIA_TYPE_VIDEO,
 778         .request_frame = request_frame,
 779         .config_props  = config_outprops,
 780     },
 781     { NULL }
 782 };
 783
 784 AVFilter ff_vf_mp = {
 785     .name          = "mp",
 786     .description   = NULL_IF_CONFIG_SMALL("Apply a libmpcodecs filter to the input video."),
 787     .init          = init,
 788     .uninit        = uninit,
 789     .priv_size     = sizeof(MPContext),
 790     .query_formats = query_formats,
 791     .inputs        = mp_inputs,
 792     .outputs       = mp_outputs,
 793     .priv_class    = &mp_class,
 794 };