Mercurial > mplayer.hg
annotate libmpcodecs/vf_scale.c @ 18049:77a3b0d11ca5
Limit the number of entires to the amount that does fit into the chunk.
the function need rewrite as it assumes quite many things that are not guaranteed by the specifications.
author | iive |
---|---|
date | Thu, 06 Apr 2006 20:04:02 +0000 |
parents | 3fe3b2b3a6ce |
children | 8579acff875e |
rev | line source |
---|---|
5522 | 1 #include <stdio.h> |
2 #include <stdlib.h> | |
3 #include <string.h> | |
4 #include <inttypes.h> | |
5 | |
17012 | 6 #include "config.h" |
7 #include "mp_msg.h" | |
8 #include "cpudetect.h" | |
5522 | 9 |
5607 | 10 #include "img_format.h" |
11 #include "mp_image.h" | |
5522 | 12 #include "vf.h" |
13 | |
17012 | 14 #include "libvo/fastmemcpy.h" |
15 #include "postproc/swscale.h" | |
10233
35f52ad860a0
vf_scale.h & related cleanup & some small warning fix by dominik
michael
parents:
10140
diff
changeset
|
16 #include "vf_scale.h" |
5522 | 17 |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
18 #include "m_option.h" |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
19 #include "m_struct.h" |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
20 |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
21 static struct vf_priv_s { |
5522 | 22 int w,h; |
6542
7af3fcd76d2d
support dropping some chroma src lines for a bit extra speed
michael
parents:
6536
diff
changeset
|
23 int v_chr_drop; |
13373
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
24 double param[2]; |
5523 | 25 unsigned int fmt; |
9494
543ab3909b78
sws_ prefix, more seperation between internal & external swscaler API
michael
parents:
9491
diff
changeset
|
26 struct SwsContext *ctx; |
11700 | 27 struct SwsContext *ctx2; //for interlaced slices only |
7783 | 28 unsigned char* palette; |
11700 | 29 int interlaced; |
17646
168d8eb397f1
no upscale flag so automatic downscaling is possible in mencoder
michael
parents:
17566
diff
changeset
|
30 int noup; |
11373
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
31 int query_format_cache[64]; |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
32 } vf_priv_dflt = { |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
33 -1,-1, |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
34 0, |
13373
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
35 {SWS_PARAM_DEFAULT, SWS_PARAM_DEFAULT}, |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
36 0, |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
37 NULL, |
11700 | 38 NULL, |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
39 NULL |
5522 | 40 }; |
41 | |
6060 | 42 extern int opt_screen_size_x; |
43 extern int opt_screen_size_y; | |
13268
125f1b58a325
do not modify d_width and d_height when -xy option was given, otherwise -xy has no effect with e.g. vo_gl
reimar
parents:
12475
diff
changeset
|
44 extern float screen_size_xy; |
6060 | 45 |
5522 | 46 //===========================================================================// |
47 | |
9985
3d8b145a5470
moving getFilter stuff back (vf_scale.c -> swscale.c)
michael
parents:
9975
diff
changeset
|
48 void sws_getFlagsAndFilterFromCmdLine(int *flags, SwsFilter **srcFilterParam, SwsFilter **dstFilterParam); |
3d8b145a5470
moving getFilter stuff back (vf_scale.c -> swscale.c)
michael
parents:
9975
diff
changeset
|
49 |
5523 | 50 static unsigned int outfmt_list[]={ |
12260
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
51 // YUV: |
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
52 IMGFMT_444P, |
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
53 IMGFMT_422P, |
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
54 IMGFMT_YV12, |
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
55 IMGFMT_I420, |
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
56 IMGFMT_IYUV, |
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
57 IMGFMT_YVU9, |
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
58 IMGFMT_IF09, |
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
59 IMGFMT_411P, |
14715 | 60 IMGFMT_NV12, |
61 IMGFMT_NV21, | |
12260
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
62 IMGFMT_YUY2, |
9d7e95b0a7e5
prefer yuv formats over rgb in case both are supported by hw
faust3
parents:
12017
diff
changeset
|
63 IMGFMT_UYVY, |
12475
16e673350486
give Y8 and Y800 lower conversion priority to avoid grayscaled video
reimar
parents:
12260
diff
changeset
|
64 // RGB and grayscale (Y8 and Y800): |
5523 | 65 IMGFMT_BGR32, |
7403 | 66 IMGFMT_RGB32, |
5523 | 67 IMGFMT_BGR24, |
7403 | 68 IMGFMT_RGB24, |
5523 | 69 IMGFMT_BGR16, |
7403 | 70 IMGFMT_RGB16, |
5523 | 71 IMGFMT_BGR15, |
7403 | 72 IMGFMT_RGB15, |
12475
16e673350486
give Y8 and Y800 lower conversion priority to avoid grayscaled video
reimar
parents:
12260
diff
changeset
|
73 IMGFMT_Y800, |
16e673350486
give Y8 and Y800 lower conversion priority to avoid grayscaled video
reimar
parents:
12260
diff
changeset
|
74 IMGFMT_Y8, |
6637 | 75 IMGFMT_BGR8, |
7403 | 76 IMGFMT_RGB8, |
6637 | 77 IMGFMT_BGR4, |
7403 | 78 IMGFMT_RGB4, |
9171 | 79 IMGFMT_BG4B, |
80 IMGFMT_RG4B, | |
6637 | 81 IMGFMT_BGR1, |
82 IMGFMT_RGB1, | |
6188 | 83 0 |
5523 | 84 }; |
85 | |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
86 static unsigned int find_best_out(vf_instance_t *vf){ |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
87 unsigned int best=0; |
11373
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
88 int i; |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
89 |
5523 | 90 // find the best outfmt: |
11373
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
91 for(i=0; i<sizeof(outfmt_list)/sizeof(int)-1; i++){ |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
92 const int format= outfmt_list[i]; |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
93 int ret= vf->priv->query_format_cache[i]-1; |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
94 if(ret == -1){ |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
95 ret= vf_next_query_format(vf, outfmt_list[i]); |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
96 vf->priv->query_format_cache[i]= ret+1; |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
97 } |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
98 |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
99 mp_msg(MSGT_VFILTER,MSGL_DBG2,"scale: query(%s) -> %d\n",vo_format_name(format),ret&3); |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
100 if(ret&VFCAP_CSP_SUPPORTED_BY_HW){ |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
101 best=format; // no conversion -> bingo! |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
102 break; |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
103 } |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
104 if(ret&VFCAP_CSP_SUPPORTED && !best) |
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
105 best=format; // best with conversion |
5523 | 106 } |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
107 return best; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
108 } |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
109 |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
110 static int config(struct vf_instance_s* vf, |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
111 int width, int height, int d_width, int d_height, |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
112 unsigned int flags, unsigned int outfmt){ |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
113 unsigned int best=find_best_out(vf); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
114 int vo_flags; |
6542
7af3fcd76d2d
support dropping some chroma src lines for a bit extra speed
michael
parents:
6536
diff
changeset
|
115 int int_sws_flags=0; |
14924
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
116 int round_w=0, round_h=0; |
6542
7af3fcd76d2d
support dropping some chroma src lines for a bit extra speed
michael
parents:
6536
diff
changeset
|
117 SwsFilter *srcFilter, *dstFilter; |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
118 |
5523 | 119 if(!best){ |
6138
523014df7d32
big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents:
6126
diff
changeset
|
120 mp_msg(MSGT_VFILTER,MSGL_WARN,"SwScale: no supported outfmt found :(\n"); |
5523 | 121 return 0; |
122 } | |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
123 |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
124 vo_flags=vf->next->query_format(vf->next,best); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
125 |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
126 // scaling to dwidth*d_height, if all these TRUE: |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
127 // - option -zoom |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
128 // - no other sw/hw up/down scaling avail. |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
129 // - we're after postproc |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
130 // - user didn't set w:h |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
131 if(!(vo_flags&VFCAP_POSTPROC) && (flags&4) && |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
132 vf->priv->w<0 && vf->priv->h<0){ // -zoom |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
133 int x=(vo_flags&VFCAP_SWSCALE) ? 0 : 1; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
134 if(d_width<width || d_height<height){ |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
135 // downscale! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
136 if(vo_flags&VFCAP_HWSCALE_DOWN) x=0; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
137 } else { |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
138 // upscale: |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
139 if(vo_flags&VFCAP_HWSCALE_UP) x=0; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
140 } |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
141 if(x){ |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
142 // user wants sw scaling! (-zoom) |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
143 vf->priv->w=d_width; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
144 vf->priv->h=d_height; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
145 } |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
146 } |
5523 | 147 |
17646
168d8eb397f1
no upscale flag so automatic downscaling is possible in mencoder
michael
parents:
17566
diff
changeset
|
148 if(vf->priv->noup){ |
17674
0f314c38ce57
10l (dont limit dimension components independantly if noup)
michael
parents:
17646
diff
changeset
|
149 if((vf->priv->w > width) + (vf->priv->h > height) >= vf->priv->noup){ |
17646
168d8eb397f1
no upscale flag so automatic downscaling is possible in mencoder
michael
parents:
17566
diff
changeset
|
150 vf->priv->w= width; |
168d8eb397f1
no upscale flag so automatic downscaling is possible in mencoder
michael
parents:
17566
diff
changeset
|
151 vf->priv->h= height; |
17674
0f314c38ce57
10l (dont limit dimension components independantly if noup)
michael
parents:
17646
diff
changeset
|
152 } |
17646
168d8eb397f1
no upscale flag so automatic downscaling is possible in mencoder
michael
parents:
17566
diff
changeset
|
153 } |
168d8eb397f1
no upscale flag so automatic downscaling is possible in mencoder
michael
parents:
17566
diff
changeset
|
154 |
17215 | 155 if (vf->priv->w <= -8) { |
156 vf->priv->w += 8; | |
14924
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
157 round_w = 1; |
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
158 } |
17215 | 159 if (vf->priv->h <= -8) { |
160 vf->priv->h += 8; | |
14924
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
161 round_h = 1; |
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
162 } |
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
163 |
13925
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
164 if (vf->priv->w < -3 || vf->priv->h < -3 || |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
165 (vf->priv->w < -1 && vf->priv->h < -1)) { |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
166 // TODO: establish a direct connection to the user's brain |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
167 // and find out what the heck he thinks MPlayer should do |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
168 // with this nonsense. |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
169 mp_msg(MSGT_VFILTER, MSGL_ERR, "SwScale: EUSERBROKEN Check your parameters, they make no sense!\n"); |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
170 return 0; |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
171 } |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
172 |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
173 if (vf->priv->w == -1) |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
174 vf->priv->w = width; |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
175 if (vf->priv->w == 0) |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
176 vf->priv->w = d_width; |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
177 |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
178 if (vf->priv->h == -1) |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
179 vf->priv->h = height; |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
180 if (vf->priv->h == 0) |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
181 vf->priv->h = d_height; |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
182 |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
183 if (vf->priv->w == -3) |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
184 vf->priv->w = vf->priv->h * width / height; |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
185 if (vf->priv->w == -2) |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
186 vf->priv->w = vf->priv->h * d_width / d_height; |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
187 |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
188 if (vf->priv->h == -3) |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
189 vf->priv->h = vf->priv->w * height / width; |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
190 if (vf->priv->h == -2) |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
191 vf->priv->h = vf->priv->w * d_height / d_width; |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
192 |
14924
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
193 if (round_w) |
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
194 vf->priv->w = ((vf->priv->w + 8) / 16) * 16; |
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
195 if (round_h) |
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
196 vf->priv->h = ((vf->priv->h + 8) / 16) * 16; |
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
197 |
5522 | 198 // calculate the missing parameters: |
6746
0e2b14e606ac
Round height or width to valid values when doing automatic calculation.
kmkaplan
parents:
6708
diff
changeset
|
199 switch(best) { |
0e2b14e606ac
Round height or width to valid values when doing automatic calculation.
kmkaplan
parents:
6708
diff
changeset
|
200 case IMGFMT_YV12: /* YV12 needs w & h rounded to 2 */ |
11069 | 201 case IMGFMT_I420: |
202 case IMGFMT_IYUV: | |
14715 | 203 case IMGFMT_NV12: |
204 case IMGFMT_NV21: | |
13925
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
205 vf->priv->h = (vf->priv->h + 1) & ~1; |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
206 case IMGFMT_YUY2: /* YUY2 needs w rounded to 2 */ |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
207 case IMGFMT_UYVY: |
72f8a761e714
fix for negative values for width and height (aspect-preserving scaling).
reimar
parents:
13373
diff
changeset
|
208 vf->priv->w = (vf->priv->w + 1) & ~1; |
6746
0e2b14e606ac
Round height or width to valid values when doing automatic calculation.
kmkaplan
parents:
6708
diff
changeset
|
209 } |
6126
35eb2b9c7d9c
new special w/h values: -2 and -3. based on proposal by Bohdan Horst <nexus@hoth.amu.edu.pl>
arpi
parents:
6060
diff
changeset
|
210 |
6138
523014df7d32
big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents:
6126
diff
changeset
|
211 mp_msg(MSGT_VFILTER,MSGL_DBG2,"SwScale: scaling %dx%d %s to %dx%d %s \n", |
5523 | 212 width,height,vo_format_name(outfmt), |
213 vf->priv->w,vf->priv->h,vo_format_name(best)); | |
5526 | 214 |
215 // free old ctx: | |
9494
543ab3909b78
sws_ prefix, more seperation between internal & external swscaler API
michael
parents:
9491
diff
changeset
|
216 if(vf->priv->ctx) sws_freeContext(vf->priv->ctx); |
11700 | 217 if(vf->priv->ctx2)sws_freeContext(vf->priv->ctx2); |
5523 | 218 |
5522 | 219 // new swscaler: |
9494
543ab3909b78
sws_ prefix, more seperation between internal & external swscaler API
michael
parents:
9491
diff
changeset
|
220 sws_getFlagsAndFilterFromCmdLine(&int_sws_flags, &srcFilter, &dstFilter); |
6542
7af3fcd76d2d
support dropping some chroma src lines for a bit extra speed
michael
parents:
6536
diff
changeset
|
221 int_sws_flags|= vf->priv->v_chr_drop << SWS_SRC_V_CHR_DROP_SHIFT; |
11700 | 222 vf->priv->ctx=sws_getContext(width, height >> vf->priv->interlaced, |
9697 | 223 outfmt, |
11700 | 224 vf->priv->w, vf->priv->h >> vf->priv->interlaced, |
9697 | 225 best, |
13373
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
226 int_sws_flags | get_sws_cpuflags(), srcFilter, dstFilter, vf->priv->param); |
11700 | 227 if(vf->priv->interlaced){ |
228 vf->priv->ctx2=sws_getContext(width, height >> 1, | |
229 outfmt, | |
230 vf->priv->w, vf->priv->h >> 1, | |
231 best, | |
13373
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
232 int_sws_flags | get_sws_cpuflags(), srcFilter, dstFilter, vf->priv->param); |
11700 | 233 } |
5522 | 234 if(!vf->priv->ctx){ |
235 // error... | |
6138
523014df7d32
big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents:
6126
diff
changeset
|
236 mp_msg(MSGT_VFILTER,MSGL_WARN,"Couldn't init SwScaler for this setup\n"); |
5522 | 237 return 0; |
238 } | |
5523 | 239 vf->priv->fmt=best; |
6060 | 240 |
7783 | 241 if(vf->priv->palette){ |
242 free(vf->priv->palette); | |
243 vf->priv->palette=NULL; | |
244 } | |
245 switch(best){ | |
246 case IMGFMT_BGR8: { | |
247 /* set 332 palette for 8 bpp */ | |
248 int i; | |
249 vf->priv->palette=malloc(4*256); | |
250 for(i=0; i<256; i++){ | |
251 vf->priv->palette[4*i+0]=4*(i&3)*21; | |
252 vf->priv->palette[4*i+1]=4*((i>>2)&7)*9; | |
253 vf->priv->palette[4*i+2]=4*((i>>5)&7)*9; | |
254 } | |
255 break; } | |
9171 | 256 case IMGFMT_BGR4: |
257 case IMGFMT_BG4B: { | |
7783 | 258 int i; |
259 vf->priv->palette=malloc(4*16); | |
260 for(i=0; i<16; i++){ | |
261 vf->priv->palette[4*i+0]=4*(i&1)*63; | |
262 vf->priv->palette[4*i+1]=4*((i>>1)&3)*21; | |
263 vf->priv->palette[4*i+2]=4*((i>>3)&1)*63; | |
264 } | |
265 break; } | |
266 } | |
267 | |
13268
125f1b58a325
do not modify d_width and d_height when -xy option was given, otherwise -xy has no effect with e.g. vo_gl
reimar
parents:
12475
diff
changeset
|
268 if(!opt_screen_size_x && !opt_screen_size_y && !(screen_size_xy >= 0.001)){ |
10002
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
269 // Compute new d_width and d_height, preserving aspect |
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
270 // while ensuring that both are >= output size in pixels. |
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
271 if (vf->priv->h * d_width > vf->priv->w * d_height) { |
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
272 d_width = vf->priv->h * d_width / d_height; |
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
273 d_height = vf->priv->h; |
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
274 } else { |
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
275 d_height = vf->priv->w * d_height / d_width; |
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
276 d_width = vf->priv->w; |
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
277 } |
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
278 //d_width=d_width*vf->priv->w/width; |
b2b070bf934e
generate meaningful d_width & d_height when scaling, rather than useless nonsense.
rfelker
parents:
9985
diff
changeset
|
279 //d_height=d_height*vf->priv->h/height; |
6060 | 280 } |
5525 | 281 return vf_next_config(vf,vf->priv->w,vf->priv->h,d_width,d_height,flags,best); |
5522 | 282 } |
283 | |
9491 | 284 static void start_slice(struct vf_instance_s* vf, mp_image_t *mpi){ |
285 // printf("start_slice called! flag=%d\n",mpi->flags&MP_IMGFLAG_DRAW_CALLBACK); | |
286 if(!(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)) return; // shouldn't happen | |
287 // they want slices!!! allocate the buffer. | |
10140
30cad6ad9dbc
fix segfaults with slices. support slice rendering into a filter even
rfelker
parents:
10022
diff
changeset
|
288 mpi->priv=vf->dmpi=vf_get_image(vf->next,vf->priv->fmt, |
9491 | 289 // mpi->type, mpi->flags & (~MP_IMGFLAG_DRAW_CALLBACK), |
290 MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE | MP_IMGFLAG_PREFER_ALIGNED_STRIDE, | |
291 vf->priv->w, vf->priv->h); | |
292 } | |
293 | |
11700 | 294 static void scale(struct SwsContext *sws1, struct SwsContext *sws2, uint8_t *src[3], int src_stride[3], int y, int h, |
295 uint8_t *dst[3], int dst_stride[3], int interlaced){ | |
296 if(interlaced){ | |
297 int i; | |
298 uint8_t *src2[3]={src[0], src[1], src[2]}; | |
299 uint8_t *dst2[3]={dst[0], dst[1], dst[2]}; | |
300 int src_stride2[3]={2*src_stride[0], 2*src_stride[1], 2*src_stride[2]}; | |
301 int dst_stride2[3]={2*dst_stride[0], 2*dst_stride[1], 2*dst_stride[2]}; | |
302 | |
303 sws_scale_ordered(sws1, src2, src_stride2, y>>1, h>>1, dst2, dst_stride2); | |
304 for(i=0; i<3; i++){ | |
305 src2[i] += src_stride[i]; | |
306 dst2[i] += dst_stride[i]; | |
307 } | |
308 sws_scale_ordered(sws2, src2, src_stride2, y>>1, h>>1, dst2, dst_stride2); | |
309 }else{ | |
310 sws_scale_ordered(sws1, src, src_stride, y, h, dst, dst_stride); | |
311 } | |
312 } | |
313 | |
9491 | 314 static void draw_slice(struct vf_instance_s* vf, |
315 unsigned char** src, int* stride, int w,int h, int x, int y){ | |
10140
30cad6ad9dbc
fix segfaults with slices. support slice rendering into a filter even
rfelker
parents:
10022
diff
changeset
|
316 mp_image_t *dmpi=vf->dmpi; |
9491 | 317 if(!dmpi){ |
318 mp_msg(MSGT_VFILTER,MSGL_FATAL,"vf_scale: draw_slice() called with dmpi=NULL (no get_image??)\n"); | |
319 return; | |
320 } | |
321 // printf("vf_scale::draw_slice() y=%d h=%d\n",y,h); | |
11700 | 322 scale(vf->priv->ctx, vf->priv->ctx2, src, stride, y, h, dmpi->planes, dmpi->stride, vf->priv->interlaced); |
9491 | 323 } |
324 | |
17906
20aca9baf5d8
passing pts through the filter layer (lets see if pts or cola comes out at the end)
michael
parents:
17674
diff
changeset
|
325 static int put_image(struct vf_instance_s* vf, mp_image_t *mpi, double pts){ |
9491 | 326 mp_image_t *dmpi=mpi->priv; |
5522 | 327 |
9491 | 328 // printf("vf_scale::put_image(): processing whole frame! dmpi=%p flag=%d\n", |
329 // dmpi, (mpi->flags&MP_IMGFLAG_DRAW_CALLBACK)); | |
330 | |
331 if(!(mpi->flags&MP_IMGFLAG_DRAW_CALLBACK && dmpi)){ | |
332 | |
5522 | 333 // hope we'll get DR buffer: |
5523 | 334 dmpi=vf_get_image(vf->next,vf->priv->fmt, |
6876 | 335 MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE | MP_IMGFLAG_PREFER_ALIGNED_STRIDE, |
5522 | 336 vf->priv->w, vf->priv->h); |
11700 | 337 |
338 scale(vf->priv->ctx, vf->priv->ctx, mpi->planes,mpi->stride,0,mpi->h,dmpi->planes,dmpi->stride, vf->priv->interlaced); | |
9491 | 339 } |
340 | |
5527 | 341 if(vf->priv->w==mpi->w && vf->priv->h==mpi->h){ |
342 // just conversion, no scaling -> keep postprocessing data | |
343 // this way we can apply pp filter to non-yv12 source using scaler | |
9934 | 344 vf_clone_mpi_attributes(dmpi, mpi); |
5527 | 345 } |
7783 | 346 |
347 if(vf->priv->palette) dmpi->planes[1]=vf->priv->palette; // export palette! | |
5527 | 348 |
17906
20aca9baf5d8
passing pts through the filter layer (lets see if pts or cola comes out at the end)
michael
parents:
17674
diff
changeset
|
349 return vf_next_put_image(vf,dmpi, pts); |
5522 | 350 } |
351 | |
9476
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
352 static int control(struct vf_instance_s* vf, int request, void* data){ |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
353 int *table; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
354 int *inv_table; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
355 int r; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
356 int brightness, contrast, saturation, srcRange, dstRange; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
357 vf_equalizer_t *eq; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
358 |
10632 | 359 if(vf->priv->ctx) |
9476
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
360 switch(request){ |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
361 case VFCTRL_GET_EQUALIZER: |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
362 r= sws_getColorspaceDetails(vf->priv->ctx, &inv_table, &srcRange, &table, &dstRange, &brightness, &contrast, &saturation); |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
363 if(r<0) break; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
364 |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
365 eq = data; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
366 if (!strcmp(eq->item,"brightness")) { |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
367 eq->value = ((brightness*100) + (1<<15))>>16; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
368 } |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
369 else if (!strcmp(eq->item,"contrast")) { |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
370 eq->value = (((contrast *100) + (1<<15))>>16) - 100; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
371 } |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
372 else if (!strcmp(eq->item,"saturation")) { |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
373 eq->value = (((saturation*100) + (1<<15))>>16) - 100; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
374 } |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
375 else |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
376 break; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
377 return CONTROL_TRUE; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
378 case VFCTRL_SET_EQUALIZER: |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
379 r= sws_getColorspaceDetails(vf->priv->ctx, &inv_table, &srcRange, &table, &dstRange, &brightness, &contrast, &saturation); |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
380 if(r<0) break; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
381 //printf("set %f %f %f\n", brightness/(float)(1<<16), contrast/(float)(1<<16), saturation/(float)(1<<16)); |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
382 eq = data; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
383 |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
384 if (!strcmp(eq->item,"brightness")) { |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
385 brightness = (( eq->value <<16) + 50)/100; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
386 } |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
387 else if (!strcmp(eq->item,"contrast")) { |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
388 contrast = (((eq->value+100)<<16) + 50)/100; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
389 } |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
390 else if (!strcmp(eq->item,"saturation")) { |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
391 saturation = (((eq->value+100)<<16) + 50)/100; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
392 } |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
393 else |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
394 break; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
395 |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
396 r= sws_setColorspaceDetails(vf->priv->ctx, inv_table, srcRange, table, dstRange, brightness, contrast, saturation); |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
397 if(r<0) break; |
11700 | 398 if(vf->priv->ctx2){ |
399 r= sws_setColorspaceDetails(vf->priv->ctx2, inv_table, srcRange, table, dstRange, brightness, contrast, saturation); | |
400 if(r<0) break; | |
401 } | |
9476
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
402 |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
403 return CONTROL_TRUE; |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
404 default: |
10233
35f52ad860a0
vf_scale.h & related cleanup & some small warning fix by dominik
michael
parents:
10140
diff
changeset
|
405 break; |
9476
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
406 } |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
407 |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
408 return vf_next_control(vf,request,data); |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
409 } |
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
410 |
5522 | 411 //===========================================================================// |
412 | |
9071 | 413 // supported Input formats: YV12, I420, IYUV, YUY2, UYVY, BGR32, BGR24, BGR16, BGR15, RGB32, RGB24, Y8, Y800 |
5523 | 414 |
415 static int query_format(struct vf_instance_s* vf, unsigned int fmt){ | |
416 switch(fmt){ | |
417 case IMGFMT_YV12: | |
418 case IMGFMT_I420: | |
419 case IMGFMT_IYUV: | |
9071 | 420 case IMGFMT_UYVY: |
5523 | 421 case IMGFMT_YUY2: |
422 case IMGFMT_BGR32: | |
423 case IMGFMT_BGR24: | |
424 case IMGFMT_BGR16: | |
425 case IMGFMT_BGR15: | |
426 case IMGFMT_RGB32: | |
427 case IMGFMT_RGB24: | |
6533 | 428 case IMGFMT_Y800: |
429 case IMGFMT_Y8: | |
430 case IMGFMT_YVU9: | |
6536 | 431 case IMGFMT_IF09: |
6863 | 432 case IMGFMT_444P: |
433 case IMGFMT_422P: | |
434 case IMGFMT_411P: | |
6533 | 435 { |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
436 unsigned int best=find_best_out(vf); |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
437 int flags; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
438 if(!best) return 0; // no matching out-fmt |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
439 flags=vf_next_query_format(vf,best); |
15537 | 440 if(!(flags&(VFCAP_CSP_SUPPORTED|VFCAP_CSP_SUPPORTED_BY_HW))) return 0; // huh? |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
441 if(fmt!=best) flags&=~VFCAP_CSP_SUPPORTED_BY_HW; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
442 // do not allow scaling, if we are before the PP fliter! |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
443 if(!(flags&VFCAP_POSTPROC)) flags|=VFCAP_SWSCALE; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
444 return flags; |
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
445 } |
5523 | 446 } |
5565
0b301fec999a
capabilities support -> automatic insertion of scale, expand, pp
arpi
parents:
5527
diff
changeset
|
447 return 0; // nomatching in-fmt |
5523 | 448 } |
449 | |
11537 | 450 static void uninit(struct vf_instance_s *vf){ |
451 if(vf->priv->ctx) sws_freeContext(vf->priv->ctx); | |
11700 | 452 if(vf->priv->ctx2) sws_freeContext(vf->priv->ctx2); |
11537 | 453 if(vf->priv->palette) free(vf->priv->palette); |
454 free(vf->priv); | |
455 } | |
456 | |
5522 | 457 static int open(vf_instance_t *vf, char* args){ |
458 vf->config=config; | |
9491 | 459 vf->start_slice=start_slice; |
460 vf->draw_slice=draw_slice; | |
5522 | 461 vf->put_image=put_image; |
5526 | 462 vf->query_format=query_format; |
9476
eff727517e6b
yuv2rgb brightness/contrast/saturation/different colorspaces support finished
michael
parents:
9276
diff
changeset
|
463 vf->control= control; |
11537 | 464 vf->uninit=uninit; |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
465 if(!vf->priv) { |
5522 | 466 vf->priv=malloc(sizeof(struct vf_priv_s)); |
467 // TODO: parse args -> | |
468 vf->priv->ctx=NULL; | |
11700 | 469 vf->priv->ctx2=NULL; |
5522 | 470 vf->priv->w= |
471 vf->priv->h=-1; | |
6542
7af3fcd76d2d
support dropping some chroma src lines for a bit extra speed
michael
parents:
6536
diff
changeset
|
472 vf->priv->v_chr_drop=0; |
13373
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
473 vf->priv->param[0]= |
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
474 vf->priv->param[1]=SWS_PARAM_DEFAULT; |
7783 | 475 vf->priv->palette=NULL; |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
476 } // if(!vf->priv) |
13373
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
477 if(args) sscanf(args, "%d:%d:%d:%lf:%lf", |
5522 | 478 &vf->priv->w, |
6542
7af3fcd76d2d
support dropping some chroma src lines for a bit extra speed
michael
parents:
6536
diff
changeset
|
479 &vf->priv->h, |
6637 | 480 &vf->priv->v_chr_drop, |
13373
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
481 &vf->priv->param[0], |
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
482 &vf->priv->param[1]); |
6138
523014df7d32
big cosmetics patch, cleanup of messages printed by mplayer and libs.
arpi
parents:
6126
diff
changeset
|
483 mp_msg(MSGT_VFILTER,MSGL_V,"SwScale params: %d x %d (-1=no scaling)\n", |
5522 | 484 vf->priv->w, |
485 vf->priv->h); | |
11700 | 486 |
5522 | 487 return 1; |
488 } | |
489 | |
9975 | 490 //global sws_flags from the command line |
491 int sws_flags=2; | |
492 | |
493 //global srcFilter | |
9985
3d8b145a5470
moving getFilter stuff back (vf_scale.c -> swscale.c)
michael
parents:
9975
diff
changeset
|
494 static SwsFilter *src_filter= NULL; |
9975 | 495 |
496 float sws_lum_gblur= 0.0; | |
497 float sws_chr_gblur= 0.0; | |
498 int sws_chr_vshift= 0; | |
499 int sws_chr_hshift= 0; | |
500 float sws_chr_sharpen= 0.0; | |
501 float sws_lum_sharpen= 0.0; | |
502 | |
17566
f580a7755ac5
Patch by Stefan Huehner / stefan % huehner ! org \
rathann
parents:
17215
diff
changeset
|
503 int get_sws_cpuflags(void){ |
9975 | 504 return |
505 (gCpuCaps.hasMMX ? SWS_CPU_CAPS_MMX : 0) | |
506 | (gCpuCaps.hasMMX2 ? SWS_CPU_CAPS_MMX2 : 0) | |
12017
21e5cb258a95
AltiVec support in postproc/ + altivec optimizations for yuv2yuvX patch by (Romain Dolbeau <dolbeau at irisa dot fr>)
michael
parents:
11700
diff
changeset
|
507 | (gCpuCaps.has3DNow ? SWS_CPU_CAPS_3DNOW : 0) |
21e5cb258a95
AltiVec support in postproc/ + altivec optimizations for yuv2yuvX patch by (Romain Dolbeau <dolbeau at irisa dot fr>)
michael
parents:
11700
diff
changeset
|
508 | (gCpuCaps.hasAltiVec ? SWS_CPU_CAPS_ALTIVEC : 0); |
9975 | 509 } |
510 | |
511 void sws_getFlagsAndFilterFromCmdLine(int *flags, SwsFilter **srcFilterParam, SwsFilter **dstFilterParam) | |
512 { | |
513 static int firstTime=1; | |
514 *flags=0; | |
515 | |
516 #ifdef ARCH_X86 | |
517 if(gCpuCaps.hasMMX) | |
518 asm volatile("emms\n\t"::: "memory"); //FIXME this shouldnt be required but it IS (even for non mmx versions) | |
519 #endif | |
520 if(firstTime) | |
521 { | |
522 firstTime=0; | |
523 *flags= SWS_PRINT_INFO; | |
524 } | |
17932 | 525 else if( mp_msg_test(MSGT_VFILTER,MSGL_DBG2) ) *flags= SWS_PRINT_INFO; |
9975 | 526 |
9985
3d8b145a5470
moving getFilter stuff back (vf_scale.c -> swscale.c)
michael
parents:
9975
diff
changeset
|
527 if(src_filter) sws_freeFilter(src_filter); |
9975 | 528 |
9985
3d8b145a5470
moving getFilter stuff back (vf_scale.c -> swscale.c)
michael
parents:
9975
diff
changeset
|
529 src_filter= sws_getDefaultFilter( |
3d8b145a5470
moving getFilter stuff back (vf_scale.c -> swscale.c)
michael
parents:
9975
diff
changeset
|
530 sws_lum_gblur, sws_chr_gblur, |
3d8b145a5470
moving getFilter stuff back (vf_scale.c -> swscale.c)
michael
parents:
9975
diff
changeset
|
531 sws_lum_sharpen, sws_chr_sharpen, |
11373
3b9f8ee18ff9
another lame workaround for the g1 filter layer ...
michael
parents:
11069
diff
changeset
|
532 sws_chr_hshift, sws_chr_vshift, verbose>1); |
9985
3d8b145a5470
moving getFilter stuff back (vf_scale.c -> swscale.c)
michael
parents:
9975
diff
changeset
|
533 |
9975 | 534 switch(sws_flags) |
535 { | |
536 case 0: *flags|= SWS_FAST_BILINEAR; break; | |
537 case 1: *flags|= SWS_BILINEAR; break; | |
538 case 2: *flags|= SWS_BICUBIC; break; | |
539 case 3: *flags|= SWS_X; break; | |
540 case 4: *flags|= SWS_POINT; break; | |
541 case 5: *flags|= SWS_AREA; break; | |
542 case 6: *flags|= SWS_BICUBLIN; break; | |
543 case 7: *flags|= SWS_GAUSS; break; | |
544 case 8: *flags|= SWS_SINC; break; | |
545 case 9: *flags|= SWS_LANCZOS; break; | |
546 case 10:*flags|= SWS_SPLINE; break; | |
547 default:*flags|= SWS_BILINEAR; break; | |
548 } | |
549 | |
9985
3d8b145a5470
moving getFilter stuff back (vf_scale.c -> swscale.c)
michael
parents:
9975
diff
changeset
|
550 *srcFilterParam= src_filter; |
9975 | 551 *dstFilterParam= NULL; |
552 } | |
553 | |
554 // will use sws_flags & src_filter (from cmd line) | |
555 struct SwsContext *sws_getContextFromCmdLine(int srcW, int srcH, int srcFormat, int dstW, int dstH, int dstFormat) | |
556 { | |
557 int flags; | |
558 SwsFilter *dstFilterParam, *srcFilterParam; | |
559 sws_getFlagsAndFilterFromCmdLine(&flags, &srcFilterParam, &dstFilterParam); | |
560 | |
13373
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
561 return sws_getContext(srcW, srcH, srcFormat, dstW, dstH, dstFormat, flags | get_sws_cpuflags(), srcFilterParam, dstFilterParam, NULL); |
9975 | 562 } |
563 | |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
564 /// An example of presets usage |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
565 static struct size_preset { |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
566 char* name; |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
567 int w, h; |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
568 } vf_size_presets_defs[] = { |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
569 // TODO add more 'standard' resolutions |
10814
7f34ec540e0f
size presets: added the standard resolutions as proposed by Fabrice (ffmpeg)
alex
parents:
10632
diff
changeset
|
570 { "qntsc", 352, 240 }, |
7f34ec540e0f
size presets: added the standard resolutions as proposed by Fabrice (ffmpeg)
alex
parents:
10632
diff
changeset
|
571 { "qpal", 352, 288 }, |
7f34ec540e0f
size presets: added the standard resolutions as proposed by Fabrice (ffmpeg)
alex
parents:
10632
diff
changeset
|
572 { "ntsc", 720, 480 }, |
7f34ec540e0f
size presets: added the standard resolutions as proposed by Fabrice (ffmpeg)
alex
parents:
10632
diff
changeset
|
573 { "pal", 720, 576 }, |
7f34ec540e0f
size presets: added the standard resolutions as proposed by Fabrice (ffmpeg)
alex
parents:
10632
diff
changeset
|
574 { "sntsc", 640, 480 }, |
7f34ec540e0f
size presets: added the standard resolutions as proposed by Fabrice (ffmpeg)
alex
parents:
10632
diff
changeset
|
575 { "spal", 768, 576 }, |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
576 { NULL, 0, 0} |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
577 }; |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
578 |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
579 #define ST_OFF(f) M_ST_OFF(struct size_preset,f) |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
580 static m_option_t vf_size_preset_fields[] = { |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
581 {"w", ST_OFF(w), CONF_TYPE_INT, M_OPT_MIN,1 ,0, NULL}, |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
582 {"h", ST_OFF(h), CONF_TYPE_INT, M_OPT_MIN,1 ,0, NULL}, |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
583 { NULL, NULL, 0, 0, 0, 0, NULL } |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
584 }; |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
585 |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
586 static m_struct_t vf_size_preset = { |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
587 "scale_size_preset", |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
588 sizeof(struct size_preset), |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
589 NULL, |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
590 vf_size_preset_fields |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
591 }; |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
592 |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
593 static m_struct_t vf_opts; |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
594 static m_obj_presets_t size_preset = { |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
595 &vf_size_preset, // Input struct desc |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
596 &vf_opts, // Output struct desc |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
597 vf_size_presets_defs, // The list of presets |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
598 ST_OFF(name) // At wich offset is the name field in the preset struct |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
599 }; |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
600 |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
601 /// Now the options |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
602 #undef ST_OFF |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
603 #define ST_OFF(f) M_ST_OFF(struct vf_priv_s,f) |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
604 static m_option_t vf_opts_fields[] = { |
14924
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
605 {"w", ST_OFF(w), CONF_TYPE_INT, M_OPT_MIN,-11,0, NULL}, |
7f386d84805f
subtracting 8 from negative w and h rounds the dimension to the closest multiple of 16
nicodvb
parents:
14715
diff
changeset
|
606 {"h", ST_OFF(h), CONF_TYPE_INT, M_OPT_MIN,-11,0, NULL}, |
11700 | 607 {"interlaced", ST_OFF(interlaced), CONF_TYPE_INT, M_OPT_RANGE, 0, 1, NULL}, |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
608 {"chr-drop", ST_OFF(v_chr_drop), CONF_TYPE_INT, M_OPT_RANGE, 0, 3, NULL}, |
13373
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
609 {"param" , ST_OFF(param[0]), CONF_TYPE_DOUBLE, M_OPT_RANGE, 0.0, 100.0, NULL}, |
6bd869a18d2c
passing an array or double precission parameters for the scaling function, instead of missusing a few bits of the flags
michael
parents:
13268
diff
changeset
|
610 {"param2", ST_OFF(param[1]), CONF_TYPE_DOUBLE, M_OPT_RANGE, 0.0, 100.0, NULL}, |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
611 // Note that here the 2 field is NULL (ie 0) |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
612 // As we want this option to act on the option struct itself |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
613 {"presize", 0, CONF_TYPE_OBJ_PRESETS, 0, 0, 0, &size_preset}, |
17646
168d8eb397f1
no upscale flag so automatic downscaling is possible in mencoder
michael
parents:
17566
diff
changeset
|
614 {"noup", ST_OFF(noup), CONF_TYPE_INT, M_OPT_RANGE, 0, 1, NULL}, |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
615 { NULL, NULL, 0, 0, 0, 0, NULL } |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
616 }; |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
617 |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
618 static m_struct_t vf_opts = { |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
619 "scale", |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
620 sizeof(struct vf_priv_s), |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
621 &vf_priv_dflt, |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
622 vf_opts_fields |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
623 }; |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
624 |
5522 | 625 vf_info_t vf_info_scale = { |
626 "software scaling", | |
627 "scale", | |
628 "A'rpi", | |
629 "", | |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
630 open, |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
9494
diff
changeset
|
631 &vf_opts |
5522 | 632 }; |
633 | |
634 //===========================================================================// |