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