libavfilter/libmpcodecs: add vf_stereo3d support
[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 "libavutil/avassert.h"
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/imgutils.h"
32
33 #include "libmpcodecs/vf.h"
34 #include "libmpcodecs/img_format.h"
35 #include "libmpcodecs/cpudetect.h"
36 #include "libmpcodecs/vd_ffmpeg.h"
37 #include "libmpcodecs/vf_scale.h"
38 #include "libmpcodecs/libvo/fastmemcpy.h"
39
40 #include "libswscale/swscale.h"
41
42
43 //FIXME maybe link the orig in
44 //XXX: identical pix_fmt must be following with each others
45 static const struct {
46     int fmt;
47     enum PixelFormat pix_fmt;
48 } conversion_map[] = {
49     {IMGFMT_ARGB, PIX_FMT_ARGB},
50     {IMGFMT_BGRA, PIX_FMT_BGRA},
51     {IMGFMT_BGR24, PIX_FMT_BGR24},
52     {IMGFMT_BGR16BE, PIX_FMT_RGB565BE},
53     {IMGFMT_BGR16LE, PIX_FMT_RGB565LE},
54     {IMGFMT_BGR15BE, PIX_FMT_RGB555BE},
55     {IMGFMT_BGR15LE, PIX_FMT_RGB555LE},
56     {IMGFMT_BGR12BE, PIX_FMT_RGB444BE},
57     {IMGFMT_BGR12LE, PIX_FMT_RGB444LE},
58     {IMGFMT_BGR8,  PIX_FMT_RGB8},
59     {IMGFMT_BGR4,  PIX_FMT_RGB4},
60     {IMGFMT_BGR1,  PIX_FMT_MONOBLACK},
61     {IMGFMT_RGB1,  PIX_FMT_MONOBLACK},
62     {IMGFMT_RG4B,  PIX_FMT_BGR4_BYTE},
63     {IMGFMT_BG4B,  PIX_FMT_RGB4_BYTE},
64     {IMGFMT_RGB48LE, PIX_FMT_RGB48LE},
65     {IMGFMT_RGB48BE, PIX_FMT_RGB48BE},
66     {IMGFMT_ABGR, PIX_FMT_ABGR},
67     {IMGFMT_RGBA, PIX_FMT_RGBA},
68     {IMGFMT_RGB24, PIX_FMT_RGB24},
69     {IMGFMT_RGB16BE, PIX_FMT_BGR565BE},
70     {IMGFMT_RGB16LE, PIX_FMT_BGR565LE},
71     {IMGFMT_RGB15BE, PIX_FMT_BGR555BE},
72     {IMGFMT_RGB15LE, PIX_FMT_BGR555LE},
73     {IMGFMT_RGB12BE, PIX_FMT_BGR444BE},
74     {IMGFMT_RGB12LE, PIX_FMT_BGR444LE},
75     {IMGFMT_RGB8,  PIX_FMT_BGR8},
76     {IMGFMT_RGB4,  PIX_FMT_BGR4},
77     {IMGFMT_BGR8,  PIX_FMT_PAL8},
78     {IMGFMT_YUY2,  PIX_FMT_YUYV422},
79     {IMGFMT_UYVY,  PIX_FMT_UYVY422},
80     {IMGFMT_NV12,  PIX_FMT_NV12},
81     {IMGFMT_NV21,  PIX_FMT_NV21},
82     {IMGFMT_Y800,  PIX_FMT_GRAY8},
83     {IMGFMT_Y8,    PIX_FMT_GRAY8},
84     {IMGFMT_YVU9,  PIX_FMT_YUV410P},
85     {IMGFMT_IF09,  PIX_FMT_YUV410P},
86     {IMGFMT_YV12,  PIX_FMT_YUV420P},
87     {IMGFMT_I420,  PIX_FMT_YUV420P},
88     {IMGFMT_IYUV,  PIX_FMT_YUV420P},
89     {IMGFMT_411P,  PIX_FMT_YUV411P},
90     {IMGFMT_422P,  PIX_FMT_YUV422P},
91     {IMGFMT_444P,  PIX_FMT_YUV444P},
92     {IMGFMT_440P,  PIX_FMT_YUV440P},
93
94     {IMGFMT_420A,  PIX_FMT_YUVA420P},
95
96     {IMGFMT_420P16_LE,  PIX_FMT_YUV420P16LE},
97     {IMGFMT_420P16_BE,  PIX_FMT_YUV420P16BE},
98     {IMGFMT_422P16_LE,  PIX_FMT_YUV422P16LE},
99     {IMGFMT_422P16_BE,  PIX_FMT_YUV422P16BE},
100     {IMGFMT_444P16_LE,  PIX_FMT_YUV444P16LE},
101     {IMGFMT_444P16_BE,  PIX_FMT_YUV444P16BE},
102
103     // YUVJ are YUV formats that use the full Y range and not just
104     // 16 - 235 (see colorspaces.txt).
105     // Currently they are all treated the same way.
106     {IMGFMT_YV12,  PIX_FMT_YUVJ420P},
107     {IMGFMT_422P,  PIX_FMT_YUVJ422P},
108     {IMGFMT_444P,  PIX_FMT_YUVJ444P},
109     {IMGFMT_440P,  PIX_FMT_YUVJ440P},
110
111     {IMGFMT_XVMC_MOCO_MPEG2, PIX_FMT_XVMC_MPEG2_MC},
112     {IMGFMT_XVMC_IDCT_MPEG2, PIX_FMT_XVMC_MPEG2_IDCT},
113     {IMGFMT_VDPAU_MPEG1,     PIX_FMT_VDPAU_MPEG1},
114     {IMGFMT_VDPAU_MPEG2,     PIX_FMT_VDPAU_MPEG2},
115     {IMGFMT_VDPAU_H264,      PIX_FMT_VDPAU_H264},
116     {IMGFMT_VDPAU_WMV3,      PIX_FMT_VDPAU_WMV3},
117     {IMGFMT_VDPAU_VC1,       PIX_FMT_VDPAU_VC1},
118     {IMGFMT_VDPAU_MPEG4,     PIX_FMT_VDPAU_MPEG4},
119     {0, PIX_FMT_NONE}
120 };
121
122 //copied from vf.c
123 extern const vf_info_t vf_info_1bpp;
124 extern const vf_info_t vf_info_2xsai;
125 extern const vf_info_t vf_info_ass;
126 extern const vf_info_t vf_info_bmovl;
127 extern const vf_info_t vf_info_crop;
128 extern const vf_info_t vf_info_decimate;
129 extern const vf_info_t vf_info_denoise3d;
130 extern const vf_info_t vf_info_detc;
131 extern const vf_info_t vf_info_dint;
132 extern const vf_info_t vf_info_divtc;
133 extern const vf_info_t vf_info_down3dright;
134 extern const vf_info_t vf_info_dsize;
135 extern const vf_info_t vf_info_dvbscale;
136 extern const vf_info_t vf_info_eq2;
137 extern const vf_info_t vf_info_eq;
138 extern const vf_info_t vf_info_expand;
139 extern const vf_info_t vf_info_field;
140 extern const vf_info_t vf_info_fil;
141 extern const vf_info_t vf_info_filmdint;
142 extern const vf_info_t vf_info_fixpts;
143 extern const vf_info_t vf_info_flip;
144 extern const vf_info_t vf_info_format;
145 extern const vf_info_t vf_info_framestep;
146 extern const vf_info_t vf_info_fspp;
147 extern const vf_info_t vf_info_geq;
148 extern const vf_info_t vf_info_halfpack;
149 extern const vf_info_t vf_info_harddup;
150 extern const vf_info_t vf_info_hqdn3d;
151 extern const vf_info_t vf_info_hue;
152 extern const vf_info_t vf_info_il;
153 extern const vf_info_t vf_info_ilpack;
154 extern const vf_info_t vf_info_ivtc;
155 extern const vf_info_t vf_info_kerndeint;
156 extern const vf_info_t vf_info_lavc;
157 extern const vf_info_t vf_info_lavcdeint;
158 extern const vf_info_t vf_info_mcdeint;
159 extern const vf_info_t vf_info_mirror;
160 extern const vf_info_t vf_info_noformat;
161 extern const vf_info_t vf_info_noise;
162 extern const vf_info_t vf_info_ow;
163 extern const vf_info_t vf_info_palette;
164 extern const vf_info_t vf_info_perspective;
165 extern const vf_info_t vf_info_phase;
166 extern const vf_info_t vf_info_pp7;
167 extern const vf_info_t vf_info_pp;
168 extern const vf_info_t vf_info_pullup;
169 extern const vf_info_t vf_info_qp;
170 extern const vf_info_t vf_info_rectangle;
171 extern const vf_info_t vf_info_remove_logo;
172 extern const vf_info_t vf_info_rotate;
173 extern const vf_info_t vf_info_sab;
174 extern const vf_info_t vf_info_scale;
175 extern const vf_info_t vf_info_screenshot;
176 extern const vf_info_t vf_info_smartblur;
177 extern const vf_info_t vf_info_softpulldown;
178 extern const vf_info_t vf_info_softskip;
179 extern const vf_info_t vf_info_spp;
180 extern const vf_info_t vf_info_stereo3d;
181 extern const vf_info_t vf_info_swapuv;
182 extern const vf_info_t vf_info_telecine;
183 extern const vf_info_t vf_info_test;
184 extern const vf_info_t vf_info_tfields;
185 extern const vf_info_t vf_info_tile;
186 extern const vf_info_t vf_info_tinterlace;
187 extern const vf_info_t vf_info_unsharp;
188 extern const vf_info_t vf_info_uspp;
189 extern const vf_info_t vf_info_vo;
190 extern const vf_info_t vf_info_yadif;
191 extern const vf_info_t vf_info_yuvcsp;
192 extern const vf_info_t vf_info_yvu9;
193 extern const vf_info_t vf_info_zrmjpeg;
194
195
196 static const vf_info_t* const filters[]={
197     &vf_info_2xsai,
198     &vf_info_decimate,
199     &vf_info_denoise3d,
200     &vf_info_detc,
201     &vf_info_dint,
202     &vf_info_divtc,
203     &vf_info_down3dright,
204     &vf_info_dsize,
205     &vf_info_eq2,
206     &vf_info_eq,
207     &vf_info_field,
208     &vf_info_fil,
209 //    &vf_info_filmdint, cmmx.h vd.h ‘opt_screen_size_x’
210     &vf_info_fixpts,
211     &vf_info_framestep,
212     &vf_info_fspp,
213     &vf_info_geq,
214     &vf_info_harddup,
215     &vf_info_hqdn3d,
216     &vf_info_hue,
217     &vf_info_il,
218     &vf_info_ilpack,
219     &vf_info_ivtc,
220     &vf_info_kerndeint,
221     &vf_info_mcdeint,
222     &vf_info_mirror,
223     &vf_info_noise,
224     &vf_info_ow,
225     &vf_info_palette,
226     &vf_info_perspective,
227     &vf_info_phase,
228     &vf_info_pp7,
229     &vf_info_pullup,
230     &vf_info_qp,
231     &vf_info_rectangle,
232     &vf_info_remove_logo,
233     &vf_info_rotate,
234     &vf_info_sab,
235     &vf_info_screenshot,
236     &vf_info_smartblur,
237     &vf_info_softpulldown,
238     &vf_info_softskip,
239     &vf_info_spp,
240     &vf_info_stereo3d,
241     &vf_info_swapuv,
242     &vf_info_telecine,
243     &vf_info_tile,
244     &vf_info_tinterlace,
245     &vf_info_unsharp,
246     &vf_info_uspp,
247     &vf_info_yuvcsp,
248     &vf_info_yvu9,
249
250     NULL
251 };
252
253 /*
254 Unsupported filters
255 1bpp
256 ass
257 bmovl
258 crop
259 dvbscale
260 flip
261 expand
262 format
263 halfpack
264 lavc
265 lavcdeint
266 noformat
267 pp
268 scale
269 tfields
270 vo
271 yadif
272 zrmjpeg
273 */
274
275 CpuCaps gCpuCaps; //FIXME initialize this so optims work
276
277
278 static void sws_getFlagsAndFilterFromCmdLine(int *flags, SwsFilter **srcFilterParam, SwsFilter **dstFilterParam)
279 {
280         static int firstTime=1;
281         *flags=0;
282
283 #if ARCH_X86
284         if(gCpuCaps.hasMMX)
285                 __asm__ volatile("emms\n\t"::: "memory"); //FIXME this should not be required but it IS (even for non-MMX versions)
286 #endif
287         if(firstTime)
288         {
289                 firstTime=0;
290                 *flags= SWS_PRINT_INFO;
291         }
292         else if( mp_msg_test(MSGT_VFILTER,MSGL_DBG2) ) *flags= SWS_PRINT_INFO;
293
294         switch(SWS_BILINEAR)
295         {
296                 case 0: *flags|= SWS_FAST_BILINEAR; break;
297                 case 1: *flags|= SWS_BILINEAR; break;
298                 case 2: *flags|= SWS_BICUBIC; break;
299                 case 3: *flags|= SWS_X; break;
300                 case 4: *flags|= SWS_POINT; break;
301                 case 5: *flags|= SWS_AREA; break;
302                 case 6: *flags|= SWS_BICUBLIN; break;
303                 case 7: *flags|= SWS_GAUSS; break;
304                 case 8: *flags|= SWS_SINC; break;
305                 case 9: *flags|= SWS_LANCZOS; break;
306                 case 10:*flags|= SWS_SPLINE; break;
307                 default:*flags|= SWS_BILINEAR; break;
308         }
309
310         *srcFilterParam= NULL;
311         *dstFilterParam= NULL;
312 }
313
314 //exact copy from vf_scale.c
315 // will use sws_flags & src_filter (from cmd line)
316 struct SwsContext *sws_getContextFromCmdLine(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat)
317 {
318         int flags, i;
319         SwsFilter *dstFilterParam, *srcFilterParam;
320         enum PixelFormat dfmt, sfmt;
321
322         for(i=0; conversion_map[i].fmt && dstFormat != conversion_map[i].fmt; i++);
323         dfmt= conversion_map[i].pix_fmt;
324         for(i=0; conversion_map[i].fmt && srcFormat != conversion_map[i].fmt; i++);
325         sfmt= conversion_map[i].pix_fmt;
326
327         if (srcFormat == IMGFMT_RGB8 || srcFormat == IMGFMT_BGR8) sfmt = PIX_FMT_PAL8;
328         sws_getFlagsAndFilterFromCmdLine(&flags, &srcFilterParam, &dstFilterParam);
329
330         return sws_getContext(srcW, srcH, sfmt, dstW, dstH, dfmt, flags , srcFilterParam, dstFilterParam, NULL);
331 }
332
333 typedef struct {
334     vf_instance_t vf;
335     vf_instance_t next_vf;
336     AVFilterContext *avfctx;
337     int frame_returned;
338 } MPContext;
339
340 void mp_msg(int mod, int lev, const char *format, ... ){
341     va_list va;
342     va_start(va, format);
343     //FIXME convert lev/mod
344     av_vlog(NULL, AV_LOG_DEBUG, format, va);
345     va_end(va);
346 }
347
348 int mp_msg_test(int mod, int lev){
349     return 123;
350 }
351
352 void init_avcodec(void)
353 {
354     //we maybe should init but its kinda 1. unneeded 2. a bit inpolite from here
355 }
356
357 //Exact copy of vf.c
358 void vf_clone_mpi_attributes(mp_image_t* dst, mp_image_t* src){
359     dst->pict_type= src->pict_type;
360     dst->fields = src->fields;
361     dst->qscale_type= src->qscale_type;
362     if(dst->width == src->width && dst->height == src->height){
363         dst->qstride= src->qstride;
364         dst->qscale= src->qscale;
365     }
366 }
367
368 //Exact copy of vf.c
369 void vf_next_draw_slice(struct vf_instance *vf,unsigned char** src, int * stride,int w, int h, int x, int y){
370     if (vf->next->draw_slice) {
371         vf->next->draw_slice(vf->next,src,stride,w,h,x,y);
372         return;
373     }
374     if (!vf->dmpi) {
375         mp_msg(MSGT_VFILTER,MSGL_ERR,"draw_slice: dmpi not stored by vf_%s\n", vf->info->name);
376         return;
377     }
378     if (!(vf->dmpi->flags & MP_IMGFLAG_PLANAR)) {
379         memcpy_pic(vf->dmpi->planes[0]+y*vf->dmpi->stride[0]+vf->dmpi->bpp/8*x,
380             src[0], vf->dmpi->bpp/8*w, h, vf->dmpi->stride[0], stride[0]);
381         return;
382     }
383     memcpy_pic(vf->dmpi->planes[0]+y*vf->dmpi->stride[0]+x, src[0],
384         w, h, vf->dmpi->stride[0], stride[0]);
385     memcpy_pic(vf->dmpi->planes[1]+(y>>vf->dmpi->chroma_y_shift)*vf->dmpi->stride[1]+(x>>vf->dmpi->chroma_x_shift),
386         src[1], w>>vf->dmpi->chroma_x_shift, h>>vf->dmpi->chroma_y_shift, vf->dmpi->stride[1], stride[1]);
387     memcpy_pic(vf->dmpi->planes[2]+(y>>vf->dmpi->chroma_y_shift)*vf->dmpi->stride[2]+(x>>vf->dmpi->chroma_x_shift),
388         src[2], w>>vf->dmpi->chroma_x_shift, h>>vf->dmpi->chroma_y_shift, vf->dmpi->stride[2], stride[2]);
389 }
390
391 //Exact copy of vf.c
392 void vf_mpi_clear(mp_image_t* mpi,int x0,int y0,int w,int h){
393     int y;
394     if(mpi->flags&MP_IMGFLAG_PLANAR){
395         y0&=~1;h+=h&1;
396         if(x0==0 && w==mpi->width){
397             // full width clear:
398             memset(mpi->planes[0]+mpi->stride[0]*y0,0,mpi->stride[0]*h);
399             memset(mpi->planes[1]+mpi->stride[1]*(y0>>mpi->chroma_y_shift),128,mpi->stride[1]*(h>>mpi->chroma_y_shift));
400             memset(mpi->planes[2]+mpi->stride[2]*(y0>>mpi->chroma_y_shift),128,mpi->stride[2]*(h>>mpi->chroma_y_shift));
401         } else
402         for(y=y0;y<y0+h;y+=2){
403             memset(mpi->planes[0]+x0+mpi->stride[0]*y,0,w);
404             memset(mpi->planes[0]+x0+mpi->stride[0]*(y+1),0,w);
405             memset(mpi->planes[1]+(x0>>mpi->chroma_x_shift)+mpi->stride[1]*(y>>mpi->chroma_y_shift),128,(w>>mpi->chroma_x_shift));
406             memset(mpi->planes[2]+(x0>>mpi->chroma_x_shift)+mpi->stride[2]*(y>>mpi->chroma_y_shift),128,(w>>mpi->chroma_x_shift));
407         }
408         return;
409     }
410     // packed:
411     for(y=y0;y<y0+h;y++){
412         unsigned char* dst=mpi->planes[0]+mpi->stride[0]*y+(mpi->bpp>>3)*x0;
413         if(mpi->flags&MP_IMGFLAG_YUV){
414             unsigned int* p=(unsigned int*) dst;
415             int size=(mpi->bpp>>3)*w/4;
416             int i;
417 #if HAVE_BIGENDIAN
418 #define CLEAR_PACKEDYUV_PATTERN 0x00800080
419 #define CLEAR_PACKEDYUV_PATTERN_SWAPPED 0x80008000
420 #else
421 #define CLEAR_PACKEDYUV_PATTERN 0x80008000
422 #define CLEAR_PACKEDYUV_PATTERN_SWAPPED 0x00800080
423 #endif
424             if(mpi->flags&MP_IMGFLAG_SWAPPED){
425                 for(i=0;i<size-3;i+=4) p[i]=p[i+1]=p[i+2]=p[i+3]=CLEAR_PACKEDYUV_PATTERN_SWAPPED;
426                 for(;i<size;i++) p[i]=CLEAR_PACKEDYUV_PATTERN_SWAPPED;
427             } else {
428                 for(i=0;i<size-3;i+=4) p[i]=p[i+1]=p[i+2]=p[i+3]=CLEAR_PACKEDYUV_PATTERN;
429                 for(;i<size;i++) p[i]=CLEAR_PACKEDYUV_PATTERN;
430             }
431         } else
432             memset(dst,0,(mpi->bpp>>3)*w);
433     }
434 }
435
436 int vf_next_query_format(struct vf_instance *vf, unsigned int fmt){
437     return 1;
438 }
439
440 //used by delogo
441 unsigned int vf_match_csp(vf_instance_t** vfp,const unsigned int* list,unsigned int preferred){
442     return preferred;
443 }
444
445 mp_image_t* vf_get_image(vf_instance_t* vf, unsigned int outfmt, int mp_imgtype, int mp_imgflag, int w, int h){
446     MPContext *m= ((uint8_t*)vf) - offsetof(MPContext, next_vf);
447   mp_image_t* mpi=NULL;
448   int w2;
449   int number = mp_imgtype >> 16;
450
451   av_assert0(vf->next == NULL); // all existing filters call this just on next
452
453   //vf_dint needs these as it calls vf_get_image() before configuring the output
454   if(vf->w==0 && w>0) vf->w=w;
455   if(vf->h==0 && h>0) vf->h=h;
456
457   av_assert0(w == -1 || w >= vf->w);
458   av_assert0(h == -1 || h >= vf->h);
459   av_assert0(vf->w > 0);
460   av_assert0(vf->h > 0);
461
462   av_log(m->avfctx, AV_LOG_DEBUG, "get_image: %d:%d, vf: %d:%d\n", w,h,vf->w,vf->h);
463
464   if (w == -1) w = vf->w;
465   if (h == -1) h = vf->h;
466
467   w2=(mp_imgflag&MP_IMGFLAG_ACCEPT_ALIGNED_STRIDE)?((w+15)&(~15)):w;
468
469   // Note: we should call libvo first to check if it supports direct rendering
470   // and if not, then fallback to software buffers:
471   switch(mp_imgtype & 0xff){
472   case MP_IMGTYPE_EXPORT:
473     if(!vf->imgctx.export_images[0]) vf->imgctx.export_images[0]=new_mp_image(w2,h);
474     mpi=vf->imgctx.export_images[0];
475     break;
476   case MP_IMGTYPE_STATIC:
477     if(!vf->imgctx.static_images[0]) vf->imgctx.static_images[0]=new_mp_image(w2,h);
478     mpi=vf->imgctx.static_images[0];
479     break;
480   case MP_IMGTYPE_TEMP:
481     if(!vf->imgctx.temp_images[0]) vf->imgctx.temp_images[0]=new_mp_image(w2,h);
482     mpi=vf->imgctx.temp_images[0];
483     break;
484   case MP_IMGTYPE_IPB:
485     if(!(mp_imgflag&MP_IMGFLAG_READABLE)){ // B frame:
486       if(!vf->imgctx.temp_images[0]) vf->imgctx.temp_images[0]=new_mp_image(w2,h);
487       mpi=vf->imgctx.temp_images[0];
488       break;
489     }
490   case MP_IMGTYPE_IP:
491     if(!vf->imgctx.static_images[vf->imgctx.static_idx]) vf->imgctx.static_images[vf->imgctx.static_idx]=new_mp_image(w2,h);
492     mpi=vf->imgctx.static_images[vf->imgctx.static_idx];
493     vf->imgctx.static_idx^=1;
494     break;
495   case MP_IMGTYPE_NUMBERED:
496     if (number == -1) {
497       int i;
498       for (i = 0; i < NUM_NUMBERED_MPI; i++)
499         if (!vf->imgctx.numbered_images[i] || !vf->imgctx.numbered_images[i]->usage_count)
500           break;
501       number = i;
502     }
503     if (number < 0 || number >= NUM_NUMBERED_MPI) return NULL;
504     if (!vf->imgctx.numbered_images[number]) vf->imgctx.numbered_images[number] = new_mp_image(w2,h);
505     mpi = vf->imgctx.numbered_images[number];
506     mpi->number = number;
507     break;
508   }
509   if(mpi){
510     mpi->type=mp_imgtype;
511     mpi->w=vf->w; mpi->h=vf->h;
512     // keep buffer allocation status & color flags only:
513 //    mpi->flags&=~(MP_IMGFLAG_PRESERVE|MP_IMGFLAG_READABLE|MP_IMGFLAG_DIRECT);
514     mpi->flags&=MP_IMGFLAG_ALLOCATED|MP_IMGFLAG_TYPE_DISPLAYED|MP_IMGFLAGMASK_COLORS;
515     // accept restrictions, draw_slice and palette flags only:
516     mpi->flags|=mp_imgflag&(MP_IMGFLAGMASK_RESTRICTIONS|MP_IMGFLAG_DRAW_CALLBACK|MP_IMGFLAG_RGB_PALETTE);
517     if(!vf->draw_slice) mpi->flags&=~MP_IMGFLAG_DRAW_CALLBACK;
518     if(mpi->width!=w2 || mpi->height!=h){
519 //      printf("vf.c: MPI parameters changed!  %dx%d -> %dx%d   \n", mpi->width,mpi->height,w2,h);
520         if(mpi->flags&MP_IMGFLAG_ALLOCATED){
521             if(mpi->width<w2 || mpi->height<h){
522                 // need to re-allocate buffer memory:
523                 av_free(mpi->planes[0]);
524                 mpi->flags&=~MP_IMGFLAG_ALLOCATED;
525                 mp_msg(MSGT_VFILTER,MSGL_V,"vf.c: have to REALLOCATE buffer memory :(\n");
526             }
527 //      } else {
528         } {
529             mpi->width=w2; mpi->chroma_width=(w2 + (1<<mpi->chroma_x_shift) - 1)>>mpi->chroma_x_shift;
530             mpi->height=h; mpi->chroma_height=(h + (1<<mpi->chroma_y_shift) - 1)>>mpi->chroma_y_shift;
531         }
532     }
533     if(!mpi->bpp) mp_image_setfmt(mpi,outfmt);
534     if(!(mpi->flags&MP_IMGFLAG_ALLOCATED) && mpi->type>MP_IMGTYPE_EXPORT){
535
536         av_assert0(!vf->get_image);
537         // check libvo first!
538         if(vf->get_image) vf->get_image(vf,mpi);
539
540         if(!(mpi->flags&MP_IMGFLAG_DIRECT)){
541           // non-direct and not yet allocated image. allocate it!
542           if (!mpi->bpp) { // no way we can allocate this
543               mp_msg(MSGT_DECVIDEO, MSGL_FATAL,
544                      "vf_get_image: Tried to allocate a format that can not be allocated!\n");
545               return NULL;
546           }
547
548           // check if codec prefer aligned stride:
549           if(mp_imgflag&MP_IMGFLAG_PREFER_ALIGNED_STRIDE){
550               int align=(mpi->flags&MP_IMGFLAG_PLANAR &&
551                          mpi->flags&MP_IMGFLAG_YUV) ?
552                          (8<<mpi->chroma_x_shift)-1 : 15; // -- maybe FIXME
553               w2=((w+align)&(~align));
554               if(mpi->width!=w2){
555 #if 0
556                   // we have to change width... check if we CAN co it:
557                   int flags=vf->query_format(vf,outfmt); // should not fail
558                   if(!(flags&3)) mp_msg(MSGT_DECVIDEO,MSGL_WARN,"??? vf_get_image{vf->query_format(outfmt)} failed!\n");
559 //                printf("query -> 0x%X    \n",flags);
560                   if(flags&VFCAP_ACCEPT_STRIDE){
561 #endif
562                       mpi->width=w2;
563                       mpi->chroma_width=(w2 + (1<<mpi->chroma_x_shift) - 1)>>mpi->chroma_x_shift;
564 //                  }
565               }
566           }
567
568           mp_image_alloc_planes(mpi);
569 //        printf("clearing img!\n");
570           vf_mpi_clear(mpi,0,0,mpi->width,mpi->height);
571         }
572     }
573     av_assert0(!vf->start_slice);
574     if(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)
575         if(vf->start_slice) vf->start_slice(vf,mpi);
576     if(!(mpi->flags&MP_IMGFLAG_TYPE_DISPLAYED)){
577             mp_msg(MSGT_DECVIDEO,MSGL_V,"*** [%s] %s%s mp_image_t, %dx%dx%dbpp %s %s, %d bytes\n",
578                   "NULL"/*vf->info->name*/,
579                   (mpi->type==MP_IMGTYPE_EXPORT)?"Exporting":
580                   ((mpi->flags&MP_IMGFLAG_DIRECT)?"Direct Rendering":"Allocating"),
581                   (mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)?" (slices)":"",
582                   mpi->width,mpi->height,mpi->bpp,
583                   (mpi->flags&MP_IMGFLAG_YUV)?"YUV":((mpi->flags&MP_IMGFLAG_SWAPPED)?"BGR":"RGB"),
584                   (mpi->flags&MP_IMGFLAG_PLANAR)?"planar":"packed",
585                   mpi->bpp*mpi->width*mpi->height/8);
586             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",
587                 mpi->imgfmt, mpi->planes[0], mpi->planes[1], mpi->planes[2],
588                 mpi->stride[0], mpi->stride[1], mpi->stride[2],
589                 mpi->chroma_width, mpi->chroma_height, mpi->chroma_x_shift, mpi->chroma_y_shift);
590             mpi->flags|=MP_IMGFLAG_TYPE_DISPLAYED;
591     }
592
593   mpi->qscale = NULL;
594   }
595   mpi->usage_count++;
596 //    printf("\rVF_MPI: %p %p %p %d %d %d    \n",
597 //      mpi->planes[0],mpi->planes[1],mpi->planes[2],
598 //      mpi->stride[0],mpi->stride[1],mpi->stride[2]);
599   return mpi;
600 }
601
602
603 int vf_next_put_image(struct vf_instance *vf,mp_image_t *mpi, double pts){
604     MPContext *m= (void*)vf;
605     AVFilterLink *outlink     = m->avfctx->outputs[0];
606     AVFilterBuffer    *pic    = av_mallocz(sizeof(AVFilterBuffer));
607     AVFilterBufferRef *picref = av_mallocz(sizeof(AVFilterBufferRef));
608     int i;
609
610     av_assert0(vf->next);
611
612     av_log(m->avfctx, AV_LOG_DEBUG, "vf_next_put_image\n");
613
614     if (!pic || !picref)
615         goto fail;
616
617     picref->buf = pic;
618     picref->buf->please_use_av_free= av_free;
619     if (!(picref->video = av_mallocz(sizeof(AVFilterBufferRefVideoProps))))
620         goto fail;
621
622     pic->w = picref->video->w = mpi->w;
623     pic->h = picref->video->h = mpi->h;
624
625     /* make sure the buffer gets read permission or it's useless for output */
626     picref->perms = AV_PERM_READ | AV_PERM_REUSE2;
627 //    av_assert0(mpi->flags&MP_IMGFLAG_READABLE);
628     if(!(mpi->flags&MP_IMGFLAG_PRESERVE))
629         picref->perms |= AV_PERM_WRITE;
630
631     pic->refcount = 1;
632     picref->type = AVMEDIA_TYPE_VIDEO;
633
634     for(i=0; conversion_map[i].fmt && mpi->imgfmt != conversion_map[i].fmt; i++);
635     pic->format = picref->format = conversion_map[i].pix_fmt;
636
637     memcpy(pic->data,        mpi->planes,   FFMIN(sizeof(pic->data)    , sizeof(mpi->planes)));
638     memcpy(pic->linesize,    mpi->stride,   FFMIN(sizeof(pic->linesize), sizeof(mpi->stride)));
639     memcpy(picref->data,     pic->data,     sizeof(picref->data));
640     memcpy(picref->linesize, pic->linesize, sizeof(picref->linesize));
641
642     if(pts != MP_NOPTS_VALUE)
643         picref->pts= pts * av_q2d(outlink->time_base);
644
645     avfilter_start_frame(outlink, avfilter_ref_buffer(picref, ~0));
646     avfilter_draw_slice(outlink, 0, picref->video->h, 1);
647     avfilter_end_frame(outlink);
648     avfilter_unref_buffer(picref);
649     m->frame_returned++;
650
651     return 1;
652 fail:
653     if (picref && picref->video)
654         av_free(picref->video);
655     av_free(picref);
656     av_free(pic);
657     return 0;
658 }
659
660 int vf_next_config(struct vf_instance *vf,
661         int width, int height, int d_width, int d_height,
662         unsigned int voflags, unsigned int outfmt){
663
664     av_assert0(width>0 && height>0);
665     vf->next->w = width; vf->next->h = height;
666
667     return 1;
668 #if 0
669     int flags=vf->next->query_format(vf->next,outfmt);
670     if(!flags){
671         // hmm. colorspace mismatch!!!
672         //this is fatal for us ATM
673         return 0;
674     }
675     mp_msg(MSGT_VFILTER,MSGL_V,"REQ: flags=0x%X  req=0x%X  \n",flags,vf->default_reqs);
676     miss=vf->default_reqs - (flags&vf->default_reqs);
677     if(miss&VFCAP_ACCEPT_STRIDE){
678         // vf requires stride support but vf->next doesn't support it!
679         // let's insert the 'expand' filter, it does the job for us:
680         vf_instance_t* vf2=vf_open_filter(vf->next,"expand",NULL);
681         if(!vf2) return 0; // shouldn't happen!
682         vf->next=vf2;
683     }
684     vf->next->w = width; vf->next->h = height;
685 #endif
686     return 1;
687 }
688
689 int vf_next_control(struct vf_instance *vf, int request, void* data){
690     MPContext *m= (void*)vf;
691     av_log(m->avfctx, AV_LOG_DEBUG, "Received control %d\n", request);
692     return 0;
693 }
694
695 static int vf_default_query_format(struct vf_instance *vf, unsigned int fmt){
696     MPContext *m= (void*)vf;
697     int i;
698     av_log(m->avfctx, AV_LOG_DEBUG, "query %X\n", fmt);
699
700     for(i=0; conversion_map[i].fmt; i++){
701         if(fmt==conversion_map[i].fmt)
702             return 1; //we suport all
703     }
704     return 0;
705 }
706
707
708 static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
709 {
710     MPContext *m = ctx->priv;
711     char name[256];
712     int i;
713
714     av_log(ctx, AV_LOG_WARNING,
715 "This is a unholy filter, it will be purified by the ffmpeg exorcist team\n"
716 "which will change its syntax from dark -vf mp to light -vf.\n"
717 "Thou shalst not make spells or scripts that depend on it\n");
718
719     m->avfctx= ctx;
720
721     if(!args || 1!=sscanf(args, "%255[^:=]", name)){
722         av_log(ctx, AV_LOG_ERROR, "Invalid parameter.\n");
723         return AVERROR(EINVAL);
724     }
725     args+= strlen(name)+1;
726
727     for(i=0; ;i++){
728         if(!filters[i] || !strcmp(name, filters[i]->name))
729             break;
730     }
731
732     if(!filters[i]){
733         av_log(ctx, AV_LOG_ERROR, "Unknown filter %s\n", name);
734         return AVERROR(EINVAL);
735     }
736
737     memset(&m->vf,0,sizeof(m->vf));
738     m->vf.info= filters[i];
739
740     m->vf.next        = &m->next_vf;
741     m->vf.put_image   = vf_next_put_image;
742     m->vf.config      = vf_next_config;
743     m->vf.query_format= vf_default_query_format;
744     m->vf.control     = vf_next_control;
745     m->vf.default_caps=VFCAP_ACCEPT_STRIDE;
746     m->vf.default_reqs=0;
747     if(m->vf.info->opts)
748         av_log(ctx, AV_LOG_ERROR, "opts / m_struct_set is unsupported\n");
749 #if 0
750     if(vf->info->opts) { // vf_vo get some special argument
751       const m_struct_t* st = vf->info->opts;
752       void* vf_priv = m_struct_alloc(st);
753       int n;
754       for(n = 0 ; args && args[2*n] ; n++)
755         m_struct_set(st,vf_priv,args[2*n],args[2*n+1]);
756       vf->priv = vf_priv;
757       args = NULL;
758     } else // Otherwise we should have the '_oldargs_'
759       if(args && !strcmp(args[0],"_oldargs_"))
760         args = (char**)args[1];
761       else
762         args = NULL;
763 #endif
764     if(m->vf.info->vf_open(&m->vf, args)<=0){
765         av_log(ctx, AV_LOG_ERROR, "vf_open() of %s with arg=%s failed\n", name, args);
766         return -1;
767     }
768
769     return 0;
770 }
771
772 static int query_formats(AVFilterContext *ctx)
773 {
774     AVFilterFormats *avfmts=NULL;
775     MPContext *m = ctx->priv;
776     enum PixelFormat lastpixfmt = PIX_FMT_NONE;
777     int i;
778
779     for(i=0; conversion_map[i].fmt; i++){
780         av_log(ctx, AV_LOG_DEBUG, "query: %X\n", conversion_map[i].fmt);
781         if(m->vf.query_format(&m->vf, conversion_map[i].fmt)){
782             av_log(ctx, AV_LOG_DEBUG, "supported,adding\n");
783             if (conversion_map[i].pix_fmt != lastpixfmt) {
784                 avfilter_add_format(&avfmts, conversion_map[i].pix_fmt);
785                 lastpixfmt = conversion_map[i].pix_fmt;
786             }
787         }
788     }
789
790     //We assume all allowed input formats are also allowed output formats
791     avfilter_set_common_pixel_formats(ctx, avfmts);
792     return 0;
793 }
794
795 static int config_inprops(AVFilterLink *inlink)
796 {
797     MPContext *m = inlink->dst->priv;
798     int i;
799     for(i=0; conversion_map[i].fmt && conversion_map[i].pix_fmt != inlink->format; i++);
800
801     av_assert0(conversion_map[i].fmt && inlink->w && inlink->h);
802
803     m->vf.fmt.have_configured = 1;
804     m->vf.fmt.orig_height     = inlink->h;
805     m->vf.fmt.orig_width      = inlink->w;
806     m->vf.fmt.orig_fmt        = conversion_map[i].fmt;
807
808     if(m->vf.config(&m->vf, inlink->w, inlink->h, inlink->w, inlink->h, 0, conversion_map[i].fmt)<=0)
809         return -1;
810
811     return 0;
812 }
813
814 static int config_outprops(AVFilterLink *outlink)
815 {
816     MPContext *m = outlink->src->priv;
817
818     outlink->w = m->next_vf.w;
819     outlink->h = m->next_vf.h;
820
821     return 0;
822 }
823
824 static int request_frame(AVFilterLink *outlink)
825 {
826     MPContext *m = outlink->src->priv;
827     int ret;
828
829     av_log(m->avfctx, AV_LOG_DEBUG, "mp request_frame\n");
830
831     for(m->frame_returned=0; !m->frame_returned;){
832         ret=avfilter_request_frame(outlink->src->inputs[0]);
833         if(ret<0)
834             break;
835     }
836
837     av_log(m->avfctx, AV_LOG_DEBUG, "mp request_frame ret=%d\n", ret);
838     return ret;
839 }
840
841 static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
842 {
843 }
844
845 static void null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
846 {
847 }
848
849 static void end_frame(AVFilterLink *inlink)
850 {
851     MPContext *m = inlink->dst->priv;
852     AVFilterBufferRef *inpic  = inlink->cur_buf;
853     int i;
854     double pts= MP_NOPTS_VALUE;
855     mp_image_t* mpi = new_mp_image(inpic->video->w, inpic->video->h);
856
857     if(inpic->pts != AV_NOPTS_VALUE)
858         pts= inpic->pts / av_q2d(inlink->time_base);
859
860     for(i=0; conversion_map[i].fmt && conversion_map[i].pix_fmt != inlink->format; i++);
861     mp_image_setfmt(mpi,conversion_map[i].fmt);
862
863     memcpy(mpi->planes, inpic->data,     FFMIN(sizeof(inpic->data)    , sizeof(mpi->planes)));
864     memcpy(mpi->stride, inpic->linesize, FFMIN(sizeof(inpic->linesize), sizeof(mpi->stride)));
865
866     //FIXME pass interleced & tff flags around
867
868     // mpi->flags|=MP_IMGFLAG_ALLOCATED; ?
869     mpi->flags |= MP_IMGFLAG_READABLE;
870     if(!(inpic->perms & AV_PERM_WRITE))
871         mpi->flags |= MP_IMGFLAG_PRESERVE;
872     if(m->vf.put_image(&m->vf, mpi, pts) == 0){
873         av_log(m->avfctx, AV_LOG_DEBUG, "put_image() says skip\n");
874     }
875     free_mp_image(mpi);
876
877     avfilter_unref_buffer(inpic);
878 }
879
880 AVFilter avfilter_vf_mp = {
881     .name      = "mp",
882     .description = NULL_IF_CONFIG_SMALL("libmpcodecs wrapper."),
883     .init = init,
884     .priv_size = sizeof(MPContext),
885     .query_formats = query_formats,
886
887     .inputs    = (AVFilterPad[]) {{ .name            = "default",
888                                     .type            = AVMEDIA_TYPE_VIDEO,
889                                     .start_frame     = start_frame,
890                                     .draw_slice      = null_draw_slice,
891                                     .end_frame       = end_frame,
892                                     .config_props    = config_inprops,
893                                     .min_perms       = AV_PERM_READ, },
894                                   { .name = NULL}},
895     .outputs   = (AVFilterPad[]) {{ .name            = "default",
896                                     .type            = AVMEDIA_TYPE_VIDEO,
897                                     .request_frame   = request_frame,
898                                     .config_props    = config_outprops, },
899                                   { .name = NULL}},
900 };