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