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