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