Mercurial > mplayer.hg
annotate libmpcodecs/vf_unsharp.c @ 23035:e8afcfccf359
Always deallocate glyphs. Fixes a memory leak.
author | eugeni |
---|---|
date | Sat, 21 Apr 2007 10:56:28 +0000 |
parents | a46ab26b2d5e |
children | a124f3abc1ec |
rev | line source |
---|---|
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
1 /* |
22507
a46ab26b2d5e
Source files should not contain non-ASCII characters.
diego
parents:
22377
diff
changeset
|
2 Copyright (C) 2002 Remi Guyomarch <rguyom@pobox.com> |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
3 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
4 This program is free software; you can redistribute it and/or modify |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
5 it under the terms of the GNU General Public License as published by |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
6 the Free Software Foundation; either version 2 of the License, or |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
7 (at your option) any later version. |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
8 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
9 This program is distributed in the hope that it will be useful, |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
10 but WITHOUT ANY WARRANTY; without even the implied warranty of |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
12 GNU General Public License for more details. |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
13 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
14 You should have received a copy of the GNU General Public License |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
15 along with this program; if not, write to the Free Software |
17367
401b440a6d76
Update licensing information: The FSF changed postal address.
diego
parents:
17012
diff
changeset
|
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
17 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
18 */ |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
19 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
20 #include <stdio.h> |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
21 #include <stdlib.h> |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
22 #include <string.h> |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
23 #include <inttypes.h> |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
24 #include <math.h> |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
25 |
17012 | 26 #include "config.h" |
27 #include "mp_msg.h" | |
28 #include "cpudetect.h" | |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
29 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
30 #ifdef HAVE_MALLOC_H |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
31 #include <malloc.h> |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
32 #endif |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
33 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
34 #include "img_format.h" |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
35 #include "mp_image.h" |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
36 #include "vf.h" |
17012 | 37 #include "libvo/fastmemcpy.h" |
22377
fd54975f9135
Use libavutil's av_clip* instead of unreadable MIN/MAX chaos.
reimar
parents:
17906
diff
changeset
|
38 #include "libavutil/common.h" |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
39 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
40 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
41 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
42 #define MIN_MATRIX_SIZE 3 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
43 #define MAX_MATRIX_SIZE 63 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
44 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
45 typedef struct FilterParam { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
46 int msizeX, msizeY; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
47 double amount; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
48 uint32_t *SC[MAX_MATRIX_SIZE-1]; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
49 } FilterParam; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
50 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
51 struct vf_priv_s { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
52 FilterParam lumaParam; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
53 FilterParam chromaParam; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
54 unsigned int outfmt; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
55 }; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
56 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
57 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
58 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
59 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
60 /* This code is based on : |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
61 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
62 An Efficient algorithm for Gaussian blur using finite-state machines |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
63 Frederick M. Waltz and John W. V. Miller |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
64 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
65 SPIE Conf. on Machine Vision Systems for Inspection and Metrology VII |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
66 Originally published Boston, Nov 98 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
67 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
68 */ |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
69 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
70 static void unsharp( uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int width, int height, FilterParam *fp ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
71 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
72 uint32_t **SC = fp->SC; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
73 uint32_t SR[MAX_MATRIX_SIZE-1], Tmp1, Tmp2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
74 uint8_t* src2 = src; // avoid gcc warning |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
75 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
76 int32_t res; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
77 int x, y, z; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
78 int amount = fp->amount * 65536.0; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
79 int stepsX = fp->msizeX/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
80 int stepsY = fp->msizeY/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
81 int scalebits = (stepsX+stepsY)*2; |
8015
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
82 int32_t halfscale = 1 << ((stepsX+stepsY)*2-1); |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
83 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
84 if( !fp->amount ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
85 if( src == dst ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
86 return; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
87 if( dstStride == srcStride ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
88 memcpy( dst, src, srcStride*height ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
89 else |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
90 for( y=0; y<height; y++, dst+=dstStride, src+=srcStride ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
91 memcpy( dst, src, width ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
92 return; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
93 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
94 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
95 for( y=0; y<2*stepsY; y++ ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
96 memset( SC[y], 0, sizeof(SC[y][0]) * (width+2*stepsX) ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
97 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
98 for( y=-stepsY; y<height+stepsY; y++ ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
99 if( y < height ) src2 = src; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
100 memset( SR, 0, sizeof(SR[0]) * (2*stepsX-1) ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
101 for( x=-stepsX; x<width+stepsX; x++ ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
102 Tmp1 = x<=0 ? src2[0] : x>=width ? src2[width-1] : src2[x]; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
103 for( z=0; z<stepsX*2; z+=2 ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
104 Tmp2 = SR[z+0] + Tmp1; SR[z+0] = Tmp1; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
105 Tmp1 = SR[z+1] + Tmp2; SR[z+1] = Tmp2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
106 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
107 for( z=0; z<stepsY*2; z+=2 ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
108 Tmp2 = SC[z+0][x+stepsX] + Tmp1; SC[z+0][x+stepsX] = Tmp1; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
109 Tmp1 = SC[z+1][x+stepsX] + Tmp2; SC[z+1][x+stepsX] = Tmp2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
110 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
111 if( x>=stepsX && y>=stepsY ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
112 uint8_t* srx = src - stepsY*srcStride + x - stepsX; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
113 uint8_t* dsx = dst - stepsY*dstStride + x - stepsX; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
114 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
115 res = (int32_t)*srx + ( ( ( (int32_t)*srx - (int32_t)((Tmp1+halfscale) >> scalebits) ) * amount ) >> 16 ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
116 *dsx = res>255 ? 255 : res<0 ? 0 : (uint8_t)res; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
117 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
118 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
119 if( y >= 0 ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
120 dst += dstStride; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
121 src += srcStride; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
122 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
123 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
124 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
125 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
126 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
127 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
128 static int config( struct vf_instance_s* vf, |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
129 int width, int height, int d_width, int d_height, |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
130 unsigned int flags, unsigned int outfmt ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
131 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
132 int z, stepsX, stepsY; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
133 FilterParam *fp; |
8015
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
134 char *effect; |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
135 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
136 // allocate buffers |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
137 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
138 fp = &vf->priv->lumaParam; |
8015
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
139 effect = fp->amount == 0 ? "don't touch" : fp->amount < 0 ? "blur" : "sharpen"; |
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
140 mp_msg( MSGT_VFILTER, MSGL_INFO, "unsharp: %dx%d:%0.2f (%s luma) \n", fp->msizeX, fp->msizeY, fp->amount, effect ); |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
141 memset( fp->SC, 0, sizeof( fp->SC ) ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
142 stepsX = fp->msizeX/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
143 stepsY = fp->msizeY/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
144 for( z=0; z<2*stepsY; z++ ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
145 fp->SC[z] = memalign( 16, sizeof(*(fp->SC[z])) * (width+2*stepsX) ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
146 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
147 fp = &vf->priv->chromaParam; |
8015
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
148 effect = fp->amount == 0 ? "don't touch" : fp->amount < 0 ? "blur" : "sharpen"; |
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
149 mp_msg( MSGT_VFILTER, MSGL_INFO, "unsharp: %dx%d:%0.2f (%s chroma)\n", fp->msizeX, fp->msizeY, fp->amount, effect ); |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
150 memset( fp->SC, 0, sizeof( fp->SC ) ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
151 stepsX = fp->msizeX/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
152 stepsY = fp->msizeY/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
153 for( z=0; z<2*stepsY; z++ ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
154 fp->SC[z] = memalign( 16, sizeof(*(fp->SC[z])) * (width+2*stepsX) ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
155 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
156 return vf_next_config( vf, width, height, d_width, d_height, flags, outfmt ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
157 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
158 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
159 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
160 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
161 static void get_image( struct vf_instance_s* vf, mp_image_t *mpi ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
162 if( mpi->flags & MP_IMGFLAG_PRESERVE ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
163 return; // don't change |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
164 if( mpi->imgfmt!=vf->priv->outfmt ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
165 return; // colorspace differ |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
166 |
10141
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
167 vf->dmpi = vf_get_image( vf->next, mpi->imgfmt, mpi->type, mpi->flags, mpi->w, mpi->h ); |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
168 mpi->planes[0] = vf->dmpi->planes[0]; |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
169 mpi->stride[0] = vf->dmpi->stride[0]; |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
170 mpi->width = vf->dmpi->width; |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
171 if( mpi->flags & MP_IMGFLAG_PLANAR ) { |
10141
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
172 mpi->planes[1] = vf->dmpi->planes[1]; |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
173 mpi->planes[2] = vf->dmpi->planes[2]; |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
174 mpi->stride[1] = vf->dmpi->stride[1]; |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
175 mpi->stride[2] = vf->dmpi->stride[2]; |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
176 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
177 mpi->flags |= MP_IMGFLAG_DIRECT; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
178 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
179 |
17906
20aca9baf5d8
passing pts through the filter layer (lets see if pts or cola comes out at the end)
michael
parents:
17367
diff
changeset
|
180 static int put_image( struct vf_instance_s* vf, mp_image_t *mpi, double pts) { |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
181 mp_image_t *dmpi; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
182 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
183 if( !(mpi->flags & MP_IMGFLAG_DIRECT) ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
184 // no DR, so get a new image! hope we'll get DR buffer: |
10141
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
185 vf->dmpi = vf_get_image( vf->next,vf->priv->outfmt, MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE, mpi->w, mpi->h); |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
186 dmpi= vf->dmpi; |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
187 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
188 unsharp( dmpi->planes[0], mpi->planes[0], dmpi->stride[0], mpi->stride[0], mpi->w, mpi->h, &vf->priv->lumaParam ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
189 unsharp( dmpi->planes[1], mpi->planes[1], dmpi->stride[1], mpi->stride[1], mpi->w/2, mpi->h/2, &vf->priv->chromaParam ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
190 unsharp( dmpi->planes[2], mpi->planes[2], dmpi->stride[2], mpi->stride[2], mpi->w/2, mpi->h/2, &vf->priv->chromaParam ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
191 |
9934 | 192 vf_clone_mpi_attributes(dmpi, mpi); |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
193 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
194 #ifdef HAVE_MMX |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
195 if(gCpuCaps.hasMMX) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
196 asm volatile ("emms\n\t"); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
197 #endif |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
198 #ifdef HAVE_MMX2 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
199 if(gCpuCaps.hasMMX2) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
200 asm volatile ("sfence\n\t"); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
201 #endif |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
202 |
17906
20aca9baf5d8
passing pts through the filter layer (lets see if pts or cola comes out at the end)
michael
parents:
17367
diff
changeset
|
203 return vf_next_put_image( vf, dmpi, pts); |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
204 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
205 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
206 static void uninit( struct vf_instance_s* vf ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
207 unsigned int z; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
208 FilterParam *fp; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
209 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
210 if( !vf->priv ) return; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
211 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
212 fp = &vf->priv->lumaParam; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
213 for( z=0; z<sizeof(fp->SC)/sizeof(fp->SC[0]); z++ ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
214 if( fp->SC[z] ) free( fp->SC[z] ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
215 fp->SC[z] = NULL; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
216 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
217 fp = &vf->priv->chromaParam; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
218 for( z=0; z<sizeof(fp->SC)/sizeof(fp->SC[0]); z++ ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
219 if( fp->SC[z] ) free( fp->SC[z] ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
220 fp->SC[z] = NULL; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
221 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
222 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
223 free( vf->priv ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
224 vf->priv = NULL; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
225 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
226 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
227 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
228 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
229 static int query_format( struct vf_instance_s* vf, unsigned int fmt ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
230 switch(fmt) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
231 case IMGFMT_YV12: |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
232 case IMGFMT_I420: |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
233 case IMGFMT_IYUV: |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
234 return vf_next_query_format( vf, vf->priv->outfmt ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
235 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
236 return 0; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
237 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
238 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
239 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
240 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
241 static void parse( FilterParam *fp, char* args ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
242 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
243 // l7x5:0.8:c3x3:-0.2 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
244 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
245 char *z; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
246 char *pos = args; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
247 char *max = args + strlen(args); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
248 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
249 // parse matrix sizes |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
250 fp->msizeX = ( pos && pos+1<max ) ? atoi( pos+1 ) : 0; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
251 z = strchr( pos+1, 'x' ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
252 fp->msizeY = ( z && z+1<max ) ? atoi( pos=z+1 ) : fp->msizeX; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
253 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
254 // min/max & odd |
22377
fd54975f9135
Use libavutil's av_clip* instead of unreadable MIN/MAX chaos.
reimar
parents:
17906
diff
changeset
|
255 fp->msizeX = 1 | av_clip(fp->msizeX, MIN_MATRIX_SIZE, MAX_MATRIX_SIZE); |
fd54975f9135
Use libavutil's av_clip* instead of unreadable MIN/MAX chaos.
reimar
parents:
17906
diff
changeset
|
256 fp->msizeY = 1 | av_clip(fp->msizeY, MIN_MATRIX_SIZE, MAX_MATRIX_SIZE); |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
257 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
258 // parse amount |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
259 pos = strchr( pos+1, ':' ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
260 fp->amount = ( pos && pos+1<max ) ? atof( pos+1 ) : 0; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
261 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
262 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
263 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
264 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
265 static unsigned int fmt_list[] = { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
266 IMGFMT_YV12, |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
267 IMGFMT_I420, |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
268 IMGFMT_IYUV, |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
269 0 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
270 }; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
271 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
272 static int open( vf_instance_t *vf, char* args ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
273 vf->config = config; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
274 vf->put_image = put_image; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
275 vf->get_image = get_image; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
276 vf->query_format = query_format; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
277 vf->uninit = uninit; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
278 vf->priv = malloc( sizeof(struct vf_priv_s) ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
279 memset( vf->priv, 0, sizeof(struct vf_priv_s) ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
280 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
281 if( args ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
282 char *args2 = strchr( args, 'l' ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
283 if( args2 ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
284 parse( &vf->priv->lumaParam, args2 ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
285 else { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
286 vf->priv->lumaParam.amount = |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
287 vf->priv->lumaParam.msizeX = |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
288 vf->priv->lumaParam.msizeY = 0; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
289 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
290 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
291 args2 = strchr( args, 'c' ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
292 if( args2 ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
293 parse( &vf->priv->chromaParam, args2 ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
294 else { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
295 vf->priv->chromaParam.amount = |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
296 vf->priv->chromaParam.msizeX = |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
297 vf->priv->chromaParam.msizeY = 0; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
298 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
299 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
300 if( !vf->priv->lumaParam.msizeX && !vf->priv->chromaParam.msizeX ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
301 return 0; // nothing to do |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
302 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
303 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
304 // check csp: |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
305 vf->priv->outfmt = vf_match_csp( &vf->next, fmt_list, IMGFMT_YV12 ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
306 if( !vf->priv->outfmt ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
307 uninit( vf ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
308 return 0; // no csp match :( |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
309 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
310 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
311 return 1; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
312 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
313 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
314 vf_info_t vf_info_unsharp = { |
8015
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
315 "unsharp mask & gaussian blur", |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
316 "unsharp", |
22507
a46ab26b2d5e
Source files should not contain non-ASCII characters.
diego
parents:
22377
diff
changeset
|
317 "Remi Guyomarch", |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
318 "", |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
8083
diff
changeset
|
319 open, |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
8083
diff
changeset
|
320 NULL |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
321 }; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
322 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
323 //===========================================================================// |