Mercurial > mplayer.hg
annotate libmpcodecs/vf.c @ 9490:48ac3ce565ab
start_slice() added - similar to get_image(), but is called when using slices
author | arpi |
---|---|
date | Sun, 23 Feb 2003 20:40:21 +0000 |
parents | 356963ad4784 |
children | 08264c647f46 |
rev | line source |
---|---|
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
1 #include <stdio.h> |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
2 #include <stdlib.h> |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
3 #include <string.h> |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
4 |
7127 | 5 #include "../config.h" |
6188 | 6 #ifdef HAVE_MALLOC_H |
7 #include <malloc.h> | |
8 #endif | |
9 | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
10 #include "../mp_msg.h" |
6994 | 11 #include "../help_mp.h" |
12 | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
13 |
5607 | 14 #include "img_format.h" |
15 #include "mp_image.h" | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
16 #include "vf.h" |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
17 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
18 extern vf_info_t vf_info_vo; |
6820
a99c7700e4f1
New plugin to test crop parameters. Arguments are the same as for the
kmkaplan
parents:
6708
diff
changeset
|
19 extern vf_info_t vf_info_rectangle; |
7855 | 20 extern vf_info_t vf_info_bmovl; |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
21 extern vf_info_t vf_info_crop; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
22 extern vf_info_t vf_info_expand; |
5512 | 23 extern vf_info_t vf_info_pp; |
5522 | 24 extern vf_info_t vf_info_scale; |
5845 | 25 #ifdef USE_LIBFAME |
5536 | 26 extern vf_info_t vf_info_fame; |
5845 | 27 #endif |
5539 | 28 extern vf_info_t vf_info_format; |
29 extern vf_info_t vf_info_yuy2; | |
5557 | 30 extern vf_info_t vf_info_flip; |
5594 | 31 extern vf_info_t vf_info_rgb2bgr; |
5696 | 32 extern vf_info_t vf_info_rotate; |
5763 | 33 extern vf_info_t vf_info_mirror; |
5774 | 34 extern vf_info_t vf_info_palette; |
5873 | 35 extern vf_info_t vf_info_lavc; |
6000
34e396477d36
passthru mode for filters which don't alter image just config parameters (query_format/control/config)
arpi
parents:
5874
diff
changeset
|
36 extern vf_info_t vf_info_dvbscale; |
6061 | 37 extern vf_info_t vf_info_cropdetect; |
6278 | 38 extern vf_info_t vf_info_test; |
6424 | 39 extern vf_info_t vf_info_noise; |
6486 | 40 extern vf_info_t vf_info_yvu9; |
6859 | 41 extern vf_info_t vf_info_lavcdeint; |
7062
9eae15166ebb
soft video equalizer filter, currently supports brightness and
rfelker
parents:
6997
diff
changeset
|
42 extern vf_info_t vf_info_eq; |
7517
9d433771b6d0
-vf eq2, LUT-based brightness/contrast/gamma correction (Y-only)
arpi
parents:
7369
diff
changeset
|
43 extern vf_info_t vf_info_eq2; |
7155
66019eb62edc
"halfpack" (yuv planar 4:2:0 -> packed 4:2:2, half height) video filter
rfelker
parents:
7127
diff
changeset
|
44 extern vf_info_t vf_info_halfpack; |
7369
b34b005ab4f8
drop-deinterlace (dint) filter by Andriy N. Gritsenko <andrej@lucky.net>
arpi
parents:
7368
diff
changeset
|
45 extern vf_info_t vf_info_dint; |
7755
7637b72ef1f9
new filter: 1bpp - converts 1bpp image to yuv/rgb 8/16/32 bpp
arpi
parents:
7697
diff
changeset
|
46 extern vf_info_t vf_info_1bpp; |
7919 | 47 extern vf_info_t vf_info_2xsai; |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
7919
diff
changeset
|
48 extern vf_info_t vf_info_unsharp; |
8002 | 49 extern vf_info_t vf_info_swapuv; |
8004
30789258ca66
(de)interleave filter (can be used to split/merge an interlaced image so other non interlaced filters an be used with idividual fields)
michael
parents:
8002
diff
changeset
|
50 extern vf_info_t vf_info_il; |
8010 | 51 extern vf_info_t vf_info_boxblur; |
8100 | 52 extern vf_info_t vf_info_sab; |
8106 | 53 extern vf_info_t vf_info_smartblur; |
8112 | 54 extern vf_info_t vf_info_perspective; |
9404
7a43a52b9f60
down3dright filter by kabi (converts between 2 common stereoscopic systems)
michael
parents:
9179
diff
changeset
|
55 extern vf_info_t vf_info_down3dright; |
9072
d7237ee9db7f
new video filter to extract a single field using stride arithmetic,
rfelker
parents:
8631
diff
changeset
|
56 extern vf_info_t vf_info_field; |
9179
e93a0dd3ed56
new video filter: denoise3d - temporal&spatial noise reduction
arpi
parents:
9072
diff
changeset
|
57 extern vf_info_t vf_info_denoise3d; |
9441
85fa92f14e99
vf_hqdn3d: High-Quality version of the denoise3d filter
arpi
parents:
9404
diff
changeset
|
58 extern vf_info_t vf_info_hqdn3d; |
9467
9fae4150ec43
experimental de-telecine filter. not documented or configurable yet,
rfelker
parents:
9441
diff
changeset
|
59 extern vf_info_t vf_info_detc; |
9468
356963ad4784
filter for applying 3:2 telecine to 23.976 fps progressive material.
rfelker
parents:
9467
diff
changeset
|
60 extern vf_info_t vf_info_telecine; |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
61 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
62 char** vo_plugin_args=(char**) NULL; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
63 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
64 // list of available filters: |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
65 static vf_info_t* filter_list[]={ |
6820
a99c7700e4f1
New plugin to test crop parameters. Arguments are the same as for the
kmkaplan
parents:
6708
diff
changeset
|
66 &vf_info_rectangle, |
7855 | 67 &vf_info_bmovl, |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
68 &vf_info_crop, |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
69 &vf_info_expand, |
5512 | 70 &vf_info_pp, |
5522 | 71 &vf_info_scale, |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
72 // &vf_info_osd, |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
73 &vf_info_vo, |
5845 | 74 #ifdef USE_LIBFAME |
5536 | 75 &vf_info_fame, |
5845 | 76 #endif |
5539 | 77 &vf_info_format, |
78 &vf_info_yuy2, | |
5557 | 79 &vf_info_flip, |
5594 | 80 &vf_info_rgb2bgr, |
5696 | 81 &vf_info_rotate, |
5763 | 82 &vf_info_mirror, |
5774 | 83 &vf_info_palette, |
5874 | 84 #ifdef USE_LIBAVCODEC |
5873 | 85 &vf_info_lavc, |
6859 | 86 &vf_info_lavcdeint, |
5874 | 87 #endif |
6000
34e396477d36
passthru mode for filters which don't alter image just config parameters (query_format/control/config)
arpi
parents:
5874
diff
changeset
|
88 &vf_info_dvbscale, |
6061 | 89 &vf_info_cropdetect, |
6278 | 90 &vf_info_test, |
6424 | 91 &vf_info_noise, |
6486 | 92 &vf_info_yvu9, |
7062
9eae15166ebb
soft video equalizer filter, currently supports brightness and
rfelker
parents:
6997
diff
changeset
|
93 &vf_info_eq, |
7517
9d433771b6d0
-vf eq2, LUT-based brightness/contrast/gamma correction (Y-only)
arpi
parents:
7369
diff
changeset
|
94 &vf_info_eq2, |
7155
66019eb62edc
"halfpack" (yuv planar 4:2:0 -> packed 4:2:2, half height) video filter
rfelker
parents:
7127
diff
changeset
|
95 &vf_info_halfpack, |
7369
b34b005ab4f8
drop-deinterlace (dint) filter by Andriy N. Gritsenko <andrej@lucky.net>
arpi
parents:
7368
diff
changeset
|
96 &vf_info_dint, |
7755
7637b72ef1f9
new filter: 1bpp - converts 1bpp image to yuv/rgb 8/16/32 bpp
arpi
parents:
7697
diff
changeset
|
97 &vf_info_1bpp, |
7919 | 98 &vf_info_2xsai, |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
7919
diff
changeset
|
99 &vf_info_unsharp, |
8002 | 100 &vf_info_swapuv, |
8004
30789258ca66
(de)interleave filter (can be used to split/merge an interlaced image so other non interlaced filters an be used with idividual fields)
michael
parents:
8002
diff
changeset
|
101 &vf_info_il, |
8010 | 102 &vf_info_boxblur, |
8100 | 103 &vf_info_sab, |
8106 | 104 &vf_info_smartblur, |
8112 | 105 &vf_info_perspective, |
9404
7a43a52b9f60
down3dright filter by kabi (converts between 2 common stereoscopic systems)
michael
parents:
9179
diff
changeset
|
106 &vf_info_down3dright, |
9072
d7237ee9db7f
new video filter to extract a single field using stride arithmetic,
rfelker
parents:
8631
diff
changeset
|
107 &vf_info_field, |
9179
e93a0dd3ed56
new video filter: denoise3d - temporal&spatial noise reduction
arpi
parents:
9072
diff
changeset
|
108 &vf_info_denoise3d, |
9441
85fa92f14e99
vf_hqdn3d: High-Quality version of the denoise3d filter
arpi
parents:
9404
diff
changeset
|
109 &vf_info_hqdn3d, |
9467
9fae4150ec43
experimental de-telecine filter. not documented or configurable yet,
rfelker
parents:
9441
diff
changeset
|
110 &vf_info_detc, |
9468
356963ad4784
filter for applying 3:2 telecine to 23.976 fps progressive material.
rfelker
parents:
9467
diff
changeset
|
111 &vf_info_telecine, |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
112 NULL |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
113 }; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
114 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
115 //============================================================================ |
5661 | 116 // mpi stuff: |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
117 |
5661 | 118 void vf_mpi_clear(mp_image_t* mpi,int x0,int y0,int w,int h){ |
119 int y; | |
120 if(mpi->flags&MP_IMGFLAG_PLANAR){ | |
5668 | 121 y0&=~1;h+=h&1; |
5663 | 122 if(x0==0 && w==mpi->width){ |
5661 | 123 // full width clear: |
124 memset(mpi->planes[0]+mpi->stride[0]*y0,0,mpi->stride[0]*h); | |
6539
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
125 memset(mpi->planes[1]+mpi->stride[1]*(y0>>mpi->chroma_y_shift),128,mpi->stride[1]*(h>>mpi->chroma_y_shift)); |
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
126 memset(mpi->planes[2]+mpi->stride[2]*(y0>>mpi->chroma_y_shift),128,mpi->stride[2]*(h>>mpi->chroma_y_shift)); |
5668 | 127 } else |
5661 | 128 for(y=y0;y<y0+h;y+=2){ |
129 memset(mpi->planes[0]+x0+mpi->stride[0]*y,0,w); | |
130 memset(mpi->planes[0]+x0+mpi->stride[0]*(y+1),0,w); | |
6539
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
131 memset(mpi->planes[1]+(x0>>mpi->chroma_x_shift)+mpi->stride[1]*(y>>mpi->chroma_y_shift),128,(w>>mpi->chroma_x_shift)); |
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
132 memset(mpi->planes[2]+(x0>>mpi->chroma_x_shift)+mpi->stride[2]*(y>>mpi->chroma_y_shift),128,(w>>mpi->chroma_x_shift)); |
5661 | 133 } |
5668 | 134 return; |
5661 | 135 } |
136 // packed: | |
137 for(y=y0;y<y0+h;y++){ | |
138 unsigned char* dst=mpi->planes[0]+mpi->stride[0]*y+(mpi->bpp>>3)*x0; | |
139 if(mpi->flags&MP_IMGFLAG_YUV){ | |
6138
523014df7d32
big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents:
6081
diff
changeset
|
140 unsigned int* p=(unsigned int*) dst; |
5661 | 141 int size=(mpi->bpp>>3)*w/4; |
142 int i; | |
143 if(mpi->flags&MP_IMGFLAG_SWAPPED){ | |
144 for(i=0;i<size;i+=4) p[i]=p[i+1]=p[i+2]=p[i+3]=0x00800080; | |
145 for(;i<size;i++) p[i]=0x00800080; | |
146 } else { | |
147 for(i=0;i<size;i+=4) p[i]=p[i+1]=p[i+2]=p[i+3]=0x80008000; | |
148 for(;i<size;i++) p[i]=0x80008000; | |
149 } | |
150 } else | |
151 memset(dst,0,(mpi->bpp>>3)*w); | |
152 } | |
153 } | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
154 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
155 mp_image_t* vf_get_image(vf_instance_t* vf, unsigned int outfmt, int mp_imgtype, int mp_imgflag, int w, int h){ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
156 mp_image_t* mpi=NULL; |
6875 | 157 int w2=(mp_imgflag&MP_IMGFLAG_ACCEPT_ALIGNED_STRIDE)?((w+15)&(~15)):w; |
6000
34e396477d36
passthru mode for filters which don't alter image just config parameters (query_format/control/config)
arpi
parents:
5874
diff
changeset
|
158 |
34e396477d36
passthru mode for filters which don't alter image just config parameters (query_format/control/config)
arpi
parents:
5874
diff
changeset
|
159 if(vf->put_image==vf_next_put_image){ |
34e396477d36
passthru mode for filters which don't alter image just config parameters (query_format/control/config)
arpi
parents:
5874
diff
changeset
|
160 // passthru mode, if the plugin uses the fallback/default put_image() code |
34e396477d36
passthru mode for filters which don't alter image just config parameters (query_format/control/config)
arpi
parents:
5874
diff
changeset
|
161 return vf_get_image(vf->next,outfmt,mp_imgtype,mp_imgflag,w,h); |
34e396477d36
passthru mode for filters which don't alter image just config parameters (query_format/control/config)
arpi
parents:
5874
diff
changeset
|
162 } |
34e396477d36
passthru mode for filters which don't alter image just config parameters (query_format/control/config)
arpi
parents:
5874
diff
changeset
|
163 |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
164 // Note: we should call libvo first to check if it supports direct rendering |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
165 // and if not, then fallback to software buffers: |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
166 switch(mp_imgtype){ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
167 case MP_IMGTYPE_EXPORT: |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
168 if(!vf->imgctx.export_images[0]) vf->imgctx.export_images[0]=new_mp_image(w2,h); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
169 mpi=vf->imgctx.export_images[0]; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
170 break; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
171 case MP_IMGTYPE_STATIC: |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
172 if(!vf->imgctx.static_images[0]) vf->imgctx.static_images[0]=new_mp_image(w2,h); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
173 mpi=vf->imgctx.static_images[0]; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
174 break; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
175 case MP_IMGTYPE_TEMP: |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
176 if(!vf->imgctx.temp_images[0]) vf->imgctx.temp_images[0]=new_mp_image(w2,h); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
177 mpi=vf->imgctx.temp_images[0]; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
178 break; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
179 case MP_IMGTYPE_IPB: |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
180 if(!(mp_imgflag&MP_IMGFLAG_READABLE)){ // B frame: |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
181 if(!vf->imgctx.temp_images[0]) vf->imgctx.temp_images[0]=new_mp_image(w2,h); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
182 mpi=vf->imgctx.temp_images[0]; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
183 break; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
184 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
185 case MP_IMGTYPE_IP: |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
186 if(!vf->imgctx.static_images[vf->imgctx.static_idx]) vf->imgctx.static_images[vf->imgctx.static_idx]=new_mp_image(w2,h); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
187 mpi=vf->imgctx.static_images[vf->imgctx.static_idx]; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
188 vf->imgctx.static_idx^=1; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
189 break; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
190 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
191 if(mpi){ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
192 mpi->type=mp_imgtype; |
6875 | 193 // keep buffer allocation status & color flags only: |
194 // mpi->flags&=~(MP_IMGFLAG_PRESERVE|MP_IMGFLAG_READABLE|MP_IMGFLAG_DIRECT); | |
195 mpi->flags&=MP_IMGFLAG_ALLOCATED|MP_IMGFLAG_TYPE_DISPLAYED|MP_IMGFLAGMASK_COLORS; | |
196 // accept restrictions & draw_slice flags only: | |
197 mpi->flags|=mp_imgflag&(MP_IMGFLAGMASK_RESTRICTIONS|MP_IMGFLAG_DRAW_CALLBACK); | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
198 if(!vf->draw_slice) mpi->flags&=~MP_IMGFLAG_DRAW_CALLBACK; |
8631 | 199 if(mpi->width!=w2 || mpi->height!=h){ |
200 // printf("vf.c: MPI parameters changed! %dx%d -> %dx%d \n", mpi->width,mpi->height,w2,h); | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
201 if(mpi->flags&MP_IMGFLAG_ALLOCATED){ |
8631 | 202 if(mpi->width<w2 || mpi->height<h){ |
203 // need to re-allocate buffer memory: | |
204 free(mpi->planes[0]); | |
205 mpi->flags&=~MP_IMGFLAG_ALLOCATED; | |
206 printf("vf.c: have to REALLOCATE buffer memory :(\n"); | |
207 } | |
208 } else { | |
209 mpi->width=w2; mpi->chroma_width=w2>>mpi->chroma_x_shift; | |
210 mpi->height=h; mpi->chroma_height=h>>mpi->chroma_y_shift; | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
211 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
212 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
213 if(!mpi->bpp) mp_image_setfmt(mpi,outfmt); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
214 if(!(mpi->flags&MP_IMGFLAG_ALLOCATED) && mpi->type>MP_IMGTYPE_EXPORT){ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
215 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
216 // check libvo first! |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
217 if(vf->get_image) vf->get_image(vf,mpi); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
218 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
219 if(!(mpi->flags&MP_IMGFLAG_DIRECT)){ |
6524 | 220 // non-direct and not yet allocated image. allocate it! |
6875 | 221 |
222 // check if codec prefer aligned stride: | |
223 if(mp_imgflag&MP_IMGFLAG_PREFER_ALIGNED_STRIDE){ | |
224 int align=(mpi->flags&MP_IMGFLAG_PLANAR && | |
225 mpi->flags&MP_IMGFLAG_YUV) ? | |
226 (8<<mpi->chroma_x_shift)-1 : 15; // -- maybe FIXME | |
7697
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
227 w2=((w+align)&(~align)); |
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
228 if(mpi->width!=w2){ |
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
229 // we have to change width... check if we CAN co it: |
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
230 int flags=vf->query_format(vf,outfmt); // should not fail |
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
231 if(!(flags&3)) mp_msg(MSGT_DECVIDEO,MSGL_WARN,"??? vf_get_image{vf->query_format(outfmt)} failed!\n"); |
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
232 // printf("query -> 0x%X \n",flags); |
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
233 if(flags&VFCAP_ACCEPT_STRIDE){ |
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
234 mpi->width=w2; |
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
235 mpi->chroma_width=w2>>mpi->chroma_x_shift; |
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
236 } |
a3c57c0c4ae2
don't honor stride hints if the next filter(chain) doesn't support stride
arpi
parents:
7517
diff
changeset
|
237 } |
6875 | 238 } |
239 | |
6524 | 240 // IF09 - allocate space for 4. plane delta info - unused |
6539
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
241 if (mpi->imgfmt == IMGFMT_IF09) |
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
242 { |
6524 | 243 mpi->planes[0]=memalign(64, mpi->bpp*mpi->width*(mpi->height+2)/8+ |
6539
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
244 mpi->chroma_width*mpi->chroma_height); |
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
245 /* delta table, just for fun ;) */ |
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
246 mpi->planes[3]=mpi->planes[0]+2*(mpi->chroma_width*mpi->chroma_height); |
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
247 } |
6524 | 248 else |
249 mpi->planes[0]=memalign(64, mpi->bpp*mpi->width*(mpi->height+2)/8); | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
250 if(mpi->flags&MP_IMGFLAG_PLANAR){ |
6524 | 251 // YV12/I420/YVU9/IF09. feel free to add other planar formats here... |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
252 if(!mpi->stride[0]) mpi->stride[0]=mpi->width; |
6539
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
253 if(!mpi->stride[1]) mpi->stride[1]=mpi->stride[2]=mpi->chroma_width; |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
254 if(mpi->flags&MP_IMGFLAG_SWAPPED){ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
255 // I420/IYUV (Y,U,V) |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
256 mpi->planes[1]=mpi->planes[0]+mpi->width*mpi->height; |
6539
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
257 mpi->planes[2]=mpi->planes[1]+mpi->chroma_width*mpi->chroma_height; |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
258 } else { |
6539
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
259 // YV12,YVU9,IF09 (Y,V,U) |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
260 mpi->planes[2]=mpi->planes[0]+mpi->width*mpi->height; |
6539
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
261 mpi->planes[1]=mpi->planes[2]+mpi->chroma_width*mpi->chroma_height; |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
262 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
263 } else { |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
264 if(!mpi->stride[0]) mpi->stride[0]=mpi->width*mpi->bpp/8; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
265 } |
8631 | 266 // printf("clearing img!\n"); |
5663 | 267 vf_mpi_clear(mpi,0,0,mpi->width,mpi->height); |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
268 mpi->flags|=MP_IMGFLAG_ALLOCATED; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
269 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
270 } |
9490
48ac3ce565ab
start_slice() added - similar to get_image(), but is called when using slices
arpi
parents:
9468
diff
changeset
|
271 if(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK) |
48ac3ce565ab
start_slice() added - similar to get_image(), but is called when using slices
arpi
parents:
9468
diff
changeset
|
272 if(vf->start_slice) vf->start_slice(vf,mpi); |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
273 if(!(mpi->flags&MP_IMGFLAG_TYPE_DISPLAYED)){ |
9490
48ac3ce565ab
start_slice() added - similar to get_image(), but is called when using slices
arpi
parents:
9468
diff
changeset
|
274 mp_msg(MSGT_DECVIDEO,MSGL_V,"*** [%s] %s%s mp_image_t, %dx%dx%dbpp %s %s, %d bytes\n", |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
275 vf->info->name, |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
276 (mpi->type==MP_IMGTYPE_EXPORT)?"Exporting": |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
277 ((mpi->flags&MP_IMGFLAG_DIRECT)?"Direct Rendering":"Allocating"), |
9490
48ac3ce565ab
start_slice() added - similar to get_image(), but is called when using slices
arpi
parents:
9468
diff
changeset
|
278 (mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)?" (slices)":"", |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
279 mpi->width,mpi->height,mpi->bpp, |
6708
8058078f1248
support for external pp by divx4. some fixes/cosmetics?
alex
parents:
6539
diff
changeset
|
280 (mpi->flags&MP_IMGFLAG_YUV)?"YUV":((mpi->flags&MP_IMGFLAG_SWAPPED)?"BGR":"RGB"), |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
281 (mpi->flags&MP_IMGFLAG_PLANAR)?"planar":"packed", |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
282 mpi->bpp*mpi->width*mpi->height/8); |
6539
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
283 mp_msg(MSGT_DECVIDEO,MSGL_DBG2,"(imgfmt: %x, planes: %x,%x,%x strides: %d,%d,%d, chroma: %dx%d, shift: h:%d,v:%d)\n", |
6486 | 284 mpi->imgfmt, mpi->planes[0], mpi->planes[1], mpi->planes[2], |
6539
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
285 mpi->stride[0], mpi->stride[1], mpi->stride[2], |
79b536a37e40
better planar support, chroma subsampling support and Y8/Y800 support
alex
parents:
6524
diff
changeset
|
286 mpi->chroma_width, mpi->chroma_height, mpi->chroma_x_shift, mpi->chroma_y_shift); |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
287 mpi->flags|=MP_IMGFLAG_TYPE_DISPLAYED; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
288 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
289 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
290 } |
8631 | 291 // printf("\rVF_MPI: %p %p %p %d %d %d \n", |
292 // mpi->planes[0],mpi->planes[1],mpi->planes[2], | |
293 // mpi->stride[0],mpi->stride[1],mpi->stride[2]); | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
294 return mpi; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
295 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
296 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
297 //============================================================================ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
298 |
7979
64f468cbedcd
The default query_format shouldn't accept IMGFMT_MPEGPES
albeu
parents:
7966
diff
changeset
|
299 // By default vf doesn't accept MPEGPES |
64f468cbedcd
The default query_format shouldn't accept IMGFMT_MPEGPES
albeu
parents:
7966
diff
changeset
|
300 static int vf_default_query_format(struct vf_instance_s* vf, unsigned int fmt){ |
64f468cbedcd
The default query_format shouldn't accept IMGFMT_MPEGPES
albeu
parents:
7966
diff
changeset
|
301 if(fmt == IMGFMT_MPEGPES) return 0; |
64f468cbedcd
The default query_format shouldn't accept IMGFMT_MPEGPES
albeu
parents:
7966
diff
changeset
|
302 return vf_next_query_format(vf,fmt); |
64f468cbedcd
The default query_format shouldn't accept IMGFMT_MPEGPES
albeu
parents:
7966
diff
changeset
|
303 } |
64f468cbedcd
The default query_format shouldn't accept IMGFMT_MPEGPES
albeu
parents:
7966
diff
changeset
|
304 |
5550 | 305 vf_instance_t* vf_open_plugin(vf_info_t** filter_list, vf_instance_t* next, char *name, char *args){ |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
306 vf_instance_t* vf; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
307 int i; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
308 for(i=0;;i++){ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
309 if(!filter_list[i]){ |
6993 | 310 mp_msg(MSGT_VFILTER,MSGL_ERR,MSGTR_CouldNotFindVideoFilter,name); |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
311 return NULL; // no such filter! |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
312 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
313 if(!strcmp(filter_list[i]->name,name)) break; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
314 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
315 vf=malloc(sizeof(vf_instance_t)); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
316 memset(vf,0,sizeof(vf_instance_t)); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
317 vf->info=filter_list[i]; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
318 vf->next=next; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
319 vf->config=vf_next_config; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
320 vf->control=vf_next_control; |
7979
64f468cbedcd
The default query_format shouldn't accept IMGFMT_MPEGPES
albeu
parents:
7966
diff
changeset
|
321 vf->query_format=vf_default_query_format; |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
322 vf->put_image=vf_next_put_image; |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
323 vf->default_caps=VFCAP_ACCEPT_STRIDE; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
324 vf->default_reqs=0; |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
325 if(vf->info->open(vf,args)>0) return vf; // Success! |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
326 free(vf); |
6993 | 327 mp_msg(MSGT_VFILTER,MSGL_ERR,MSGTR_CouldNotOpenVideoFilter,name); |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
328 return NULL; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
329 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
330 |
5550 | 331 vf_instance_t* vf_open_filter(vf_instance_t* next, char *name, char *args){ |
6138
523014df7d32
big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents:
6081
diff
changeset
|
332 if(strcmp(name,"vo")) |
523014df7d32
big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents:
6081
diff
changeset
|
333 mp_msg(MSGT_VFILTER,MSGL_INFO, |
6997 | 334 args ? MSGTR_OpeningVideoFilter "[%s=%s]\n" |
335 : MSGTR_OpeningVideoFilter "[%s]\n",name,args); | |
5550 | 336 return vf_open_plugin(filter_list,next,name,args); |
337 } | |
338 | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
339 //============================================================================ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
340 |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
341 unsigned int vf_match_csp(vf_instance_t** vfp,unsigned int* list,unsigned int preferred){ |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
342 vf_instance_t* vf=*vfp; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
343 unsigned int* p; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
344 unsigned int best=0; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
345 int ret; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
346 if((p=list)) while(*p){ |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
347 ret=vf->query_format(vf,*p); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
348 mp_msg(MSGT_VFILTER,MSGL_V,"[%s] query(%s) -> %d\n",vf->info->name,vo_format_name(*p),ret&3); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
349 if(ret&2){ best=*p; break;} // no conversion -> bingo! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
350 if(ret&1 && !best) best=*p; // best with conversion |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
351 ++p; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
352 } |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
353 if(best) return best; // bingo, they have common csp! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
354 // ok, then try with scale: |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
355 if(vf->info == &vf_info_scale) return 0; // avoid infinite recursion! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
356 vf=vf_open_filter(vf,"scale",NULL); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
357 if(!vf) return 0; // failed to init "scale" |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
358 // try the preferred csp first: |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
359 if(preferred && vf->query_format(vf,preferred)) best=preferred; else |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
360 // try the list again, now with "scaler" : |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
361 if((p=list)) while(*p){ |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
362 ret=vf->query_format(vf,*p); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
363 mp_msg(MSGT_VFILTER,MSGL_V,"[%s] query(%s) -> %d\n",vf->info->name,vo_format_name(*p),ret&3); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
364 if(ret&2){ best=*p; break;} // no conversion -> bingo! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
365 if(ret&1 && !best) best=*p; // best with conversion |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
366 ++p; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
367 } |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
368 if(best) *vfp=vf; // else uninit vf !FIXME! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
369 return best; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
370 } |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
371 |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
372 int vf_next_config(struct vf_instance_s* vf, |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
373 int width, int height, int d_width, int d_height, |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
374 unsigned int voflags, unsigned int outfmt){ |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
375 int miss; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
376 int flags=vf->next->query_format(vf->next,outfmt); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
377 if(!flags){ |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
378 // hmm. colorspace mismatch!!! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
379 // let's insert the 'scale' filter, it does the job for us: |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
380 vf_instance_t* vf2; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
381 if(vf->next->info==&vf_info_scale) return 0; // scale->scale |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
382 vf2=vf_open_filter(vf->next,"scale",NULL); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
383 if(!vf2) return 0; // shouldn't happen! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
384 vf->next=vf2; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
385 flags=vf->next->query_format(vf->next,outfmt); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
386 if(!flags){ |
6993 | 387 mp_msg(MSGT_VFILTER,MSGL_ERR,MSGTR_CannotFindColorspace); |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
388 return 0; // FAIL |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
389 } |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
390 } |
6138
523014df7d32
big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents:
6081
diff
changeset
|
391 mp_msg(MSGT_VFILTER,MSGL_V,"REQ: flags=0x%X req=0x%X \n",flags,vf->default_reqs); |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
392 miss=vf->default_reqs - (flags&vf->default_reqs); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
393 if(miss&VFCAP_ACCEPT_STRIDE){ |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
394 // vf requires stride support but vf->next doesn't support it! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
395 // let's insert the 'expand' filter, it does the job for us: |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
396 vf_instance_t* vf2=vf_open_filter(vf->next,"expand",NULL); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
397 if(!vf2) return 0; // shouldn't happen! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
398 vf->next=vf2; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
399 } |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
400 return vf->next->config(vf->next,width,height,d_width,d_height,voflags,outfmt); |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
401 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
402 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
403 int vf_next_control(struct vf_instance_s* vf, int request, void* data){ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
404 return vf->next->control(vf->next,request,data); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
405 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
406 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
407 int vf_next_query_format(struct vf_instance_s* vf, unsigned int fmt){ |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
408 int flags=vf->next->query_format(vf->next,fmt); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
409 if(flags) flags|=vf->default_caps; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5557
diff
changeset
|
410 return flags; |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
411 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
412 |
7368 | 413 int vf_next_put_image(struct vf_instance_s* vf,mp_image_t *mpi){ |
414 return vf->next->put_image(vf->next,mpi); | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
415 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
416 |
8367 | 417 void vf_next_draw_slice(struct vf_instance_s* vf,unsigned char** src, int * stride,int w, int h, int x, int y){ |
418 vf->next->draw_slice(vf->next,src,stride,w,h,x,y); | |
419 } | |
420 | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
421 //============================================================================ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
422 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
423 vf_instance_t* append_filters(vf_instance_t* last){ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
424 vf_instance_t* vf; |
5843 | 425 char** plugin_args = vo_plugin_args; |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
426 if(!vo_plugin_args) return last; |
5843 | 427 while(*plugin_args){ |
428 char* name=strdup(*plugin_args); | |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
429 char* args=strchr(name,'='); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
430 if(args){args[0]=0;++args;} |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
431 vf=vf_open_filter(last,name,args); |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
432 if(vf) last=vf; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
433 free(name); |
5843 | 434 ++plugin_args; |
5507
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
435 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
436 return last; |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
437 } |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
438 |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
439 //============================================================================ |
d0d029fda134
video filter layer - written from scratch, but inspired a lot by Fredrik Kuivinen's patch
arpi
parents:
diff
changeset
|
440 |
5737 | 441 void vf_uninit_filter(vf_instance_t* vf){ |
442 if(vf->uninit) vf->uninit(vf); | |
443 free_mp_image(vf->imgctx.static_images[0]); | |
444 free_mp_image(vf->imgctx.static_images[1]); | |
445 free_mp_image(vf->imgctx.temp_images[0]); | |
446 free_mp_image(vf->imgctx.export_images[0]); | |
447 free(vf); | |
448 } | |
449 | |
450 void vf_uninit_filter_chain(vf_instance_t* vf){ | |
451 while(vf){ | |
452 vf_instance_t* next=vf->next; | |
453 vf_uninit_filter(vf); | |
454 vf=next; | |
455 } | |
456 } | |
6081
47d6a4b0f971
-vop help, patch by Julian J. M. <bandit@telecable.es>
arpi
parents:
6061
diff
changeset
|
457 |
47d6a4b0f971
-vop help, patch by Julian J. M. <bandit@telecable.es>
arpi
parents:
6061
diff
changeset
|
458 void vf_list_plugins(){ |
47d6a4b0f971
-vop help, patch by Julian J. M. <bandit@telecable.es>
arpi
parents:
6061
diff
changeset
|
459 int i=0; |
47d6a4b0f971
-vop help, patch by Julian J. M. <bandit@telecable.es>
arpi
parents:
6061
diff
changeset
|
460 while(filter_list[i]){ |
47d6a4b0f971
-vop help, patch by Julian J. M. <bandit@telecable.es>
arpi
parents:
6061
diff
changeset
|
461 mp_msg(MSGT_VFILTER,MSGL_INFO,"\t%-10s: %s\n",filter_list[i]->name,filter_list[i]->info); |
47d6a4b0f971
-vop help, patch by Julian J. M. <bandit@telecable.es>
arpi
parents:
6061
diff
changeset
|
462 i++; |
47d6a4b0f971
-vop help, patch by Julian J. M. <bandit@telecable.es>
arpi
parents:
6061
diff
changeset
|
463 } |
47d6a4b0f971
-vop help, patch by Julian J. M. <bandit@telecable.es>
arpi
parents:
6061
diff
changeset
|
464 } |