2 * This file is part of MPlayer.
4 * MPlayer is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * MPlayer is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
29 #include "img_format.h"
34 #include "libvo/fastmemcpy.h"
35 #include "libavutil/avutil.h"
38 #include "libvo/sub.h"
39 #include "libvo/osd.h"
45 static struct vf_priv_s
{
46 // These four values are a backup of the values parsed from the command line.
47 // This is necessary so that we do not get a mess upon filter reinit due to
48 // e.g. aspect changes and with only aspect specified on the command line,
49 // where we would otherwise use the values calculated for a different aspect
50 // instead of recalculating them again.
51 int cfg_exp_w
, cfg_exp_h
;
52 int cfg_exp_x
, cfg_exp_y
;
58 unsigned char* fb_ptr
;
61 } const vf_priv_dflt
= {
74 //===========================================================================//
77 static struct vf_instance
*vf
=NULL
; // fixme (needs sub.c changes)
78 static int orig_w
,orig_h
;
80 static void remove_func_2(int x0
,int y0
, int w
,int h
){
81 // TODO: let's cleanup the place
82 //printf("OSD clear: %d;%d %dx%d \n",x0,y0,w,h);
83 vf_mpi_clear(vf
->dmpi
,x0
,y0
,w
,h
);
86 static void remove_func(int x0
,int y0
, int w
,int h
){
87 if(!vo_osd_changed_flag
) return;
88 // split it to 4 parts:
89 if(y0
<vf
->priv
->exp_y
){
90 // it has parts above the image:
92 if(y
>vf
->priv
->exp_y
) y
=vf
->priv
->exp_y
;
93 remove_func_2(x0
,y0
,w
,y
-y0
);
94 if(y0
+h
<=vf
->priv
->exp_y
) return;
97 if(y0
+h
>vf
->priv
->exp_y
+orig_h
){
98 // it has parts under the image:
100 if(y
<vf
->priv
->exp_y
+orig_h
) y
=vf
->priv
->exp_y
+orig_h
;
101 remove_func_2(x0
,y
,w
,y0
+h
-y
);
102 if(y0
>=vf
->priv
->exp_y
+orig_h
) return;
105 if(x0
<vf
->priv
->exp_x
){
106 // it has parts on the left side of the image:
108 if(x
>vf
->priv
->exp_x
) x
=vf
->priv
->exp_x
;
109 remove_func_2(x0
,y0
,x
-x0
,h
);
110 if(x0
+w
<=vf
->priv
->exp_x
) return;
113 if(x0
+w
>vf
->priv
->exp_x
+orig_w
){
114 // it has parts on the right side of the image:
116 if(x
<vf
->priv
->exp_x
+orig_w
) x
=vf
->priv
->exp_x
+orig_w
;
117 remove_func_2(x
,y0
,x0
+w
-x
,h
);
118 if(x0
>=vf
->priv
->exp_x
+orig_w
) return;
123 static void draw_func(int x0
,int y0
, int w
,int h
,unsigned char* src
, unsigned char *srca
, int stride
){
125 if(!vo_osd_changed_flag
&& vf
->dmpi
->planes
[0]==vf
->priv
->fb_ptr
){
126 // ok, enough to update the area inside the video, leave the black bands
128 if(x0
<vf
->priv
->exp_x
){
129 int tmp
=vf
->priv
->exp_x
-x0
;
130 w
-=tmp
; src
+=tmp
; srca
+=tmp
; x0
+=tmp
;
132 if(y0
<vf
->priv
->exp_y
){
133 int tmp
=vf
->priv
->exp_y
-y0
;
134 h
-=tmp
; src
+=tmp
*stride
; srca
+=tmp
*stride
; y0
+=tmp
;
136 if(x0
+w
>vf
->priv
->exp_x
+orig_w
){
137 w
=vf
->priv
->exp_x
+orig_w
-x0
;
139 if(y0
+h
>vf
->priv
->exp_y
+orig_h
){
140 h
=vf
->priv
->exp_y
+orig_h
-y0
;
143 if(w
<=0 || h
<=0) return; // nothing to do...
144 // printf("OSD redraw: %d;%d %dx%d \n",x0,y0,w,h);
145 dst
=vf
->dmpi
->planes
[0]+
146 vf
->dmpi
->stride
[0]*y0
+
147 (vf
->dmpi
->bpp
>>3)*x0
;
148 switch(vf
->dmpi
->imgfmt
){
151 vo_draw_alpha_rgb12(w
, h
, src
, srca
, stride
, dst
, vf
->dmpi
->stride
[0]);
155 vo_draw_alpha_rgb15(w
,h
,src
,srca
,stride
,dst
,vf
->dmpi
->stride
[0]);
159 vo_draw_alpha_rgb16(w
,h
,src
,srca
,stride
,dst
,vf
->dmpi
->stride
[0]);
163 vo_draw_alpha_rgb24(w
,h
,src
,srca
,stride
,dst
,vf
->dmpi
->stride
[0]);
167 vo_draw_alpha_rgb32(w
,h
,src
,srca
,stride
,dst
,vf
->dmpi
->stride
[0]);
176 vo_draw_alpha_yv12(w
,h
,src
,srca
,stride
,dst
,vf
->dmpi
->stride
[0]);
179 vo_draw_alpha_yuy2(w
,h
,src
,srca
,stride
,dst
,vf
->dmpi
->stride
[0]);
182 vo_draw_alpha_yuy2(w
,h
,src
,srca
,stride
,dst
+1,vf
->dmpi
->stride
[0]);
187 static void draw_osd(struct vf_instance
*vf_
,int w
,int h
){
188 vf
=vf_
;orig_w
=w
;orig_h
=h
;
189 // printf("======================================\n");
190 if(vf
->priv
->exp_w
!=w
|| vf
->priv
->exp_h
!=h
||
191 vf
->priv
->exp_x
|| vf
->priv
->exp_y
){
192 // yep, we're expanding image, not just copy.
193 if(vf
->dmpi
->planes
[0]!=vf
->priv
->fb_ptr
){
194 // double buffering, so we need full clear :(
195 if (vf
->priv
->exp_y
> 0)
196 remove_func_2(0,0,vf
->priv
->exp_w
,vf
->priv
->exp_y
);
197 if (vf
->priv
->exp_y
+h
< vf
->priv
->exp_h
)
198 remove_func_2(0,vf
->priv
->exp_y
+h
,vf
->priv
->exp_w
,vf
->priv
->exp_h
-h
-vf
->priv
->exp_y
);
199 if (vf
->priv
->exp_x
> 0)
200 remove_func_2(0,vf
->priv
->exp_y
,vf
->priv
->exp_x
,h
);
201 if (vf
->priv
->exp_x
+w
< vf
->priv
->exp_w
)
202 remove_func_2(vf
->priv
->exp_x
+w
,vf
->priv
->exp_y
,vf
->priv
->exp_w
-w
-vf
->priv
->exp_x
,h
);
205 vo_remove_text(vf
->priv
->exp_w
,vf
->priv
->exp_h
,remove_func
);
208 vo_draw_text(vf
->priv
->exp_w
,vf
->priv
->exp_h
,draw_func
);
209 // save buffer pointer for double buffering detection - yes, i know it's
210 // ugly method, but note that codecs with DR support does the same...
212 vf
->priv
->fb_ptr
=vf
->dmpi
->planes
[0];
216 //===========================================================================//
218 static int config(struct vf_instance
*vf
,
219 int width
, int height
, int d_width
, int d_height
,
220 unsigned int flags
, unsigned int outfmt
){
221 if(outfmt
== IMGFMT_MPEGPES
) {
222 vf
->priv
->passthrough
= 1;
223 return vf_next_config(vf
,width
,height
,d_width
,d_height
,flags
,outfmt
);
225 if (outfmt
== IMGFMT_IF09
) return 0;
226 vf
->priv
->exp_x
= vf
->priv
->cfg_exp_x
;
227 vf
->priv
->exp_y
= vf
->priv
->cfg_exp_y
;
228 vf
->priv
->exp_w
= vf
->priv
->cfg_exp_w
;
229 vf
->priv
->exp_h
= vf
->priv
->cfg_exp_h
;
230 // calculate the missing parameters:
232 if(vf
->priv
->exp_w
<width
) vf
->priv
->exp_w
=width
;
233 if(vf
->priv
->exp_h
<height
) vf
->priv
->exp_h
=height
;
235 if ( vf
->priv
->exp_w
== -1 ) vf
->priv
->exp_w
=width
;
236 else if (vf
->priv
->exp_w
< -1 ) vf
->priv
->exp_w
=width
- vf
->priv
->exp_w
;
237 else if ( vf
->priv
->exp_w
<width
) vf
->priv
->exp_w
=width
;
238 if ( vf
->priv
->exp_h
== -1 ) vf
->priv
->exp_h
=height
;
239 else if ( vf
->priv
->exp_h
< -1 ) vf
->priv
->exp_h
=height
- vf
->priv
->exp_h
;
240 else if( vf
->priv
->exp_h
<height
) vf
->priv
->exp_h
=height
;
242 if (vf
->priv
->aspect
) {
243 float adjusted_aspect
= vf
->priv
->aspect
;
244 adjusted_aspect
*= ((double)width
/height
) / ((double)d_width
/d_height
);
245 if (vf
->priv
->exp_h
< vf
->priv
->exp_w
/ adjusted_aspect
) {
246 vf
->priv
->exp_h
= vf
->priv
->exp_w
/ adjusted_aspect
+ 0.5;
248 vf
->priv
->exp_w
= vf
->priv
->exp_h
* adjusted_aspect
+ 0.5;
251 if (vf
->priv
->round
> 1) { // round up.
252 vf
->priv
->exp_w
= (1 + (vf
->priv
->exp_w
- 1) / vf
->priv
->round
) * vf
->priv
->round
;
253 vf
->priv
->exp_h
= (1 + (vf
->priv
->exp_h
- 1) / vf
->priv
->round
) * vf
->priv
->round
;
256 if(vf
->priv
->exp_x
<0 || vf
->priv
->exp_x
+width
>vf
->priv
->exp_w
) vf
->priv
->exp_x
=(vf
->priv
->exp_w
-width
)/2;
257 if(vf
->priv
->exp_y
<0 || vf
->priv
->exp_y
+height
>vf
->priv
->exp_h
) vf
->priv
->exp_y
=(vf
->priv
->exp_h
-height
)/2;
258 vf
->priv
->fb_ptr
=NULL
;
260 if(!opt_screen_size_x
&& !opt_screen_size_y
){
261 d_width
=d_width
*vf
->priv
->exp_w
/width
;
262 d_height
=d_height
*vf
->priv
->exp_h
/height
;
264 return vf_next_config(vf
,vf
->priv
->exp_w
,vf
->priv
->exp_h
,d_width
,d_height
,flags
,outfmt
);
267 // there are 4 cases:
268 // codec --DR--> expand --DR--> vo
269 // codec --DR--> expand -copy-> vo
270 // codec -copy-> expand --DR--> vo
271 // codec -copy-> expand -copy-> vo (worst case)
273 static void get_image(struct vf_instance
*vf
, mp_image_t
*mpi
){
274 // if(mpi->type==MP_IMGTYPE_IPB) return; // not yet working
276 if(vf
->priv
->osd
&& (mpi
->flags
&MP_IMGFLAG_PRESERVE
)){
277 // check if we have to render osd!
278 vo_update_osd(vf
->priv
->exp_w
, vf
->priv
->exp_h
);
279 if(vo_osd_check_range_update(vf
->priv
->exp_x
,vf
->priv
->exp_y
,
280 vf
->priv
->exp_x
+mpi
->w
,vf
->priv
->exp_y
+mpi
->h
)) return;
283 if(vf
->priv
->exp_w
==mpi
->width
||
284 (mpi
->flags
&(MP_IMGFLAG_ACCEPT_STRIDE
|MP_IMGFLAG_ACCEPT_WIDTH
)) ){
286 mpi
->priv
=vf
->dmpi
=vf_get_image(vf
->next
,mpi
->imgfmt
,
287 mpi
->type
, mpi
->flags
,
288 FFMAX(vf
->priv
->exp_w
, mpi
->width
+vf
->priv
->exp_x
),
289 FFMAX(vf
->priv
->exp_h
, mpi
->height
+vf
->priv
->exp_y
));
290 if((vf
->dmpi
->flags
& MP_IMGFLAG_DRAW_CALLBACK
) &&
291 !(vf
->dmpi
->flags
& MP_IMGFLAG_DIRECT
)){
292 mp_msg(MSGT_VFILTER
, MSGL_INFO
, MSGTR_MPCODECS_FullDRNotPossible
);
295 // set up mpi as a cropped-down image of dmpi:
296 if(mpi
->flags
&MP_IMGFLAG_PLANAR
){
297 mpi
->planes
[0]=vf
->dmpi
->planes
[0]+
298 vf
->priv
->exp_y
*vf
->dmpi
->stride
[0]+vf
->priv
->exp_x
;
299 mpi
->planes
[1]=vf
->dmpi
->planes
[1]+
300 (vf
->priv
->exp_y
>>mpi
->chroma_y_shift
)*vf
->dmpi
->stride
[1]+(vf
->priv
->exp_x
>>mpi
->chroma_x_shift
);
301 mpi
->planes
[2]=vf
->dmpi
->planes
[2]+
302 (vf
->priv
->exp_y
>>mpi
->chroma_y_shift
)*vf
->dmpi
->stride
[2]+(vf
->priv
->exp_x
>>mpi
->chroma_x_shift
);
303 mpi
->stride
[1]=vf
->dmpi
->stride
[1];
304 mpi
->stride
[2]=vf
->dmpi
->stride
[2];
306 mpi
->planes
[0]=vf
->dmpi
->planes
[0]+
307 vf
->priv
->exp_y
*vf
->dmpi
->stride
[0]+
308 vf
->priv
->exp_x
*(vf
->dmpi
->bpp
/8);
310 mpi
->stride
[0]=vf
->dmpi
->stride
[0];
311 mpi
->width
=vf
->dmpi
->width
;
312 mpi
->flags
|=MP_IMGFLAG_DIRECT
;
313 mpi
->flags
&=~MP_IMGFLAG_DRAW_CALLBACK
;
314 // vf->dmpi->flags&=~MP_IMGFLAG_DRAW_CALLBACK;
318 static void start_slice(struct vf_instance
*vf
, mp_image_t
*mpi
){
319 // printf("start_slice called! flag=%d\n",mpi->flags&MP_IMGFLAG_DRAW_CALLBACK);
320 if(!vf
->next
->draw_slice
){
321 mpi
->flags
&=~MP_IMGFLAG_DRAW_CALLBACK
;
324 // they want slices!!! allocate the buffer.
326 mpi
->priv
=vf
->dmpi
=vf_get_image(vf
->next
,mpi
->imgfmt
,
327 // MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE | MP_IMGFLAG_PREFER_ALIGNED_STRIDE,
328 MP_IMGTYPE_TEMP
, mpi
->flags
,
329 FFMAX(vf
->priv
->exp_w
, mpi
->width
+vf
->priv
->exp_x
),
330 FFMAX(vf
->priv
->exp_h
, mpi
->height
+vf
->priv
->exp_y
));
331 if(!(vf
->dmpi
->flags
&MP_IMGFLAG_DRAW_CALLBACK
))
332 mp_msg(MSGT_VFILTER
, MSGL_WARN
, MSGTR_MPCODECS_WarnNextFilterDoesntSupportSlices
); // shouldn't happen.
333 vf
->priv
->first_slice
= 1;
336 static void draw_top_blackbar_slice(struct vf_instance
*vf
,
337 unsigned char** src
, int* stride
, int w
,int h
, int x
, int y
){
338 if(vf
->priv
->exp_y
>0 && y
== 0) {
339 vf_next_draw_slice(vf
, vf
->dmpi
->planes
, vf
->dmpi
->stride
,
340 vf
->dmpi
->w
,vf
->priv
->exp_y
,0,0);
345 static void draw_bottom_blackbar_slice(struct vf_instance
*vf
,
346 unsigned char** src
, int* stride
, int w
,int h
, int x
, int y
){
347 if(vf
->priv
->exp_y
+vf
->h
<vf
->dmpi
->h
&& y
+h
== vf
->h
) {
348 unsigned char *src2
[MP_MAX_PLANES
];
349 src2
[0] = vf
->dmpi
->planes
[0]
350 + (vf
->priv
->exp_y
+vf
->h
)*vf
->dmpi
->stride
[0];
351 if(vf
->dmpi
->flags
&MP_IMGFLAG_PLANAR
){
352 src2
[1] = vf
->dmpi
->planes
[1]
353 + ((vf
->priv
->exp_y
+vf
->h
)>>vf
->dmpi
->chroma_y_shift
)*vf
->dmpi
->stride
[1];
354 src2
[2] = vf
->dmpi
->planes
[2]
355 + ((vf
->priv
->exp_y
+vf
->h
)>>vf
->dmpi
->chroma_y_shift
)*vf
->dmpi
->stride
[2];
357 src2
[1] = vf
->dmpi
->planes
[1]; // passthrough rgb8 palette
359 vf_next_draw_slice(vf
, src2
, vf
->dmpi
->stride
,
360 vf
->dmpi
->w
,vf
->dmpi
->h
-(vf
->priv
->exp_y
+vf
->h
),
361 0,vf
->priv
->exp_y
+vf
->h
);
365 static void draw_slice(struct vf_instance
*vf
,
366 unsigned char** src
, int* stride
, int w
,int h
, int x
, int y
){
367 // printf("draw_slice() called %d at %d\n",h,y);
369 if (y
== 0 && y
+h
== vf
->h
) {
370 // special case - only one slice
371 draw_top_blackbar_slice(vf
, src
, stride
, w
, h
, x
, y
);
372 vf_next_draw_slice(vf
,src
,stride
,w
,h
,x
+vf
->priv
->exp_x
,y
+vf
->priv
->exp_y
);
373 draw_bottom_blackbar_slice(vf
, src
, stride
, w
, h
, x
, y
);
376 if (vf
->priv
->first_slice
) {
377 draw_top_blackbar_slice(vf
, src
, stride
, w
, h
, x
, y
);
378 draw_bottom_blackbar_slice(vf
, src
, stride
, w
, h
, x
, y
);
380 vf_next_draw_slice(vf
,src
,stride
,w
,h
,x
+vf
->priv
->exp_x
,y
+vf
->priv
->exp_y
);
381 if (!vf
->priv
->first_slice
) {
382 draw_top_blackbar_slice(vf
, src
, stride
, w
, h
, x
, y
);
383 draw_bottom_blackbar_slice(vf
, src
, stride
, w
, h
, x
, y
);
385 vf
->priv
->first_slice
= 0;
388 static int put_image(struct vf_instance
*vf
, mp_image_t
*mpi
, double pts
){
389 if (vf
->priv
->passthrough
) {
390 mp_image_t
*dmpi
= vf_get_image(vf
->next
, IMGFMT_MPEGPES
,
391 MP_IMGTYPE_EXPORT
, 0, mpi
->w
, mpi
->h
);
392 dmpi
->planes
[0]=mpi
->planes
[0];
393 return vf_next_put_image(vf
,dmpi
, pts
);
396 if(mpi
->flags
&MP_IMGFLAG_DIRECT
|| mpi
->flags
&MP_IMGFLAG_DRAW_CALLBACK
){
398 if(!vf
->dmpi
) { mp_msg(MSGT_VFILTER
, MSGL_WARN
, MSGTR_MPCODECS_FunWhydowegetNULL
); return 0; }
401 if(vf
->priv
->osd
) draw_osd(vf
,mpi
->w
,mpi
->h
);
403 // we've used DR, so we're ready...
404 if(!(mpi
->flags
&MP_IMGFLAG_PLANAR
))
405 vf
->dmpi
->planes
[1] = mpi
->planes
[1]; // passthrough rgb8 palette
406 return vf_next_put_image(vf
,vf
->dmpi
, pts
);
409 // hope we'll get DR buffer:
410 vf
->dmpi
=vf_get_image(vf
->next
,mpi
->imgfmt
,
411 MP_IMGTYPE_TEMP
, MP_IMGFLAG_ACCEPT_STRIDE
,
412 vf
->priv
->exp_w
, vf
->priv
->exp_h
);
415 if(mpi
->flags
&MP_IMGFLAG_PLANAR
){
416 memcpy_pic(vf
->dmpi
->planes
[0]+
417 vf
->priv
->exp_y
*vf
->dmpi
->stride
[0]+vf
->priv
->exp_x
,
418 mpi
->planes
[0], mpi
->w
, mpi
->h
,
419 vf
->dmpi
->stride
[0],mpi
->stride
[0]);
420 memcpy_pic(vf
->dmpi
->planes
[1]+
421 (vf
->priv
->exp_y
>>mpi
->chroma_y_shift
)*vf
->dmpi
->stride
[1]+(vf
->priv
->exp_x
>>mpi
->chroma_x_shift
),
422 mpi
->planes
[1], (mpi
->w
>>mpi
->chroma_x_shift
), (mpi
->h
>>mpi
->chroma_y_shift
),
423 vf
->dmpi
->stride
[1],mpi
->stride
[1]);
424 memcpy_pic(vf
->dmpi
->planes
[2]+
425 (vf
->priv
->exp_y
>>mpi
->chroma_y_shift
)*vf
->dmpi
->stride
[2]+(vf
->priv
->exp_x
>>mpi
->chroma_x_shift
),
426 mpi
->planes
[2], (mpi
->w
>>mpi
->chroma_x_shift
), (mpi
->h
>>mpi
->chroma_y_shift
),
427 vf
->dmpi
->stride
[2],mpi
->stride
[2]);
429 memcpy_pic(vf
->dmpi
->planes
[0]+
430 vf
->priv
->exp_y
*vf
->dmpi
->stride
[0]+vf
->priv
->exp_x
*(vf
->dmpi
->bpp
/8),
431 mpi
->planes
[0], mpi
->w
*(vf
->dmpi
->bpp
/8), mpi
->h
,
432 vf
->dmpi
->stride
[0],mpi
->stride
[0]);
433 vf
->dmpi
->planes
[1] = mpi
->planes
[1]; // passthrough rgb8 palette
436 if(vf
->priv
->osd
) draw_osd(vf
,mpi
->w
,mpi
->h
);
438 return vf_next_put_image(vf
,vf
->dmpi
, pts
);
441 //===========================================================================//
443 static int control(struct vf_instance
*vf
, int request
, void* data
){
446 case VFCTRL_DRAW_OSD
:
447 if(vf
->priv
->osd
) return CONTROL_TRUE
;
450 return vf_next_control(vf
,request
,data
);
453 static int query_format(struct vf_instance
*vf
, unsigned int fmt
){
454 return vf_next_query_format(vf
,fmt
);
457 static int vf_open(vf_instance_t
*vf
, char *args
){
460 vf
->query_format
=query_format
;
461 vf
->start_slice
=start_slice
;
462 vf
->draw_slice
=draw_slice
;
463 vf
->get_image
=get_image
;
464 vf
->put_image
=put_image
;
465 mp_msg(MSGT_VFILTER
, MSGL_INFO
, "Expand: %d x %d, %d ; %d, osd: %d, aspect: %f, round: %d\n",
476 #define ST_OFF(f) M_ST_OFF(struct vf_priv_s,f)
477 static const m_option_t vf_opts_fields
[] = {
478 {"w", ST_OFF(cfg_exp_w
), CONF_TYPE_INT
, 0, 0 ,0, NULL
},
479 {"h", ST_OFF(cfg_exp_h
), CONF_TYPE_INT
, 0, 0 ,0, NULL
},
480 {"x", ST_OFF(cfg_exp_x
), CONF_TYPE_INT
, M_OPT_MIN
, -1, 0, NULL
},
481 {"y", ST_OFF(cfg_exp_y
), CONF_TYPE_INT
, M_OPT_MIN
, -1, 0, NULL
},
482 {"osd", ST_OFF(osd
), CONF_TYPE_FLAG
, 0 , 0, 1, NULL
},
483 {"aspect", ST_OFF(aspect
), CONF_TYPE_DOUBLE
, M_OPT_MIN
, 0, 0, NULL
},
484 {"round", ST_OFF(round
), CONF_TYPE_INT
, M_OPT_MIN
, 1, 0, NULL
},
485 { NULL
, NULL
, 0, 0, 0, 0, NULL
}
488 static const m_struct_t vf_opts
= {
490 sizeof(struct vf_priv_s
),
497 const vf_info_t vf_info_expand
= {
510 //===========================================================================//