Mercurial > mplayer.hg
annotate libmpcodecs/vf_unsharp.c @ 20966:dc1a02e98cb6
clarify syncpoint placement recommanditions
(note i would also like to add a "there MUST be 1 syncpoint per second" rule)
author | michael |
---|---|
date | Fri, 17 Nov 2006 13:32:45 +0000 |
parents | 20aca9baf5d8 |
children | fd54975f9135 |
rev | line source |
---|---|
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
1 /* |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
2 Copyright (C) 2002 Rémi Guyomarch <rguyom@pobox.com> |
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" |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
38 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
39 #ifndef MIN |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
40 #define MIN(a,b) (((a)<(b))?(a):(b)) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
41 #endif |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
42 #ifndef MAX |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
43 #define MAX(a,b) (((a)>(b))?(a):(b)) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
44 #endif |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
45 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
46 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
47 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
48 #define MIN_MATRIX_SIZE 3 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
49 #define MAX_MATRIX_SIZE 63 |
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 typedef struct FilterParam { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
52 int msizeX, msizeY; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
53 double amount; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
54 uint32_t *SC[MAX_MATRIX_SIZE-1]; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
55 } FilterParam; |
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 struct vf_priv_s { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
58 FilterParam lumaParam; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
59 FilterParam chromaParam; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
60 unsigned int outfmt; |
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 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
63 |
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 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
66 /* This code is based on : |
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 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
|
69 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
|
70 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
71 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
|
72 Originally published Boston, Nov 98 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
73 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
74 */ |
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 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
|
77 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
78 uint32_t **SC = fp->SC; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
79 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
|
80 uint8_t* src2 = src; // avoid gcc warning |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
81 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
82 int32_t res; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
83 int x, y, z; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
84 int amount = fp->amount * 65536.0; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
85 int stepsX = fp->msizeX/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
86 int stepsY = fp->msizeY/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
87 int scalebits = (stepsX+stepsY)*2; |
8015
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
88 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
|
89 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
90 if( !fp->amount ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
91 if( src == dst ) |
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 if( dstStride == srcStride ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
94 memcpy( dst, src, srcStride*height ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
95 else |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
96 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
|
97 memcpy( dst, src, width ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
98 return; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
99 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
100 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
101 for( y=0; y<2*stepsY; y++ ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
102 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
|
103 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
104 for( y=-stepsY; y<height+stepsY; y++ ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
105 if( y < height ) src2 = src; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
106 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
|
107 for( x=-stepsX; x<width+stepsX; x++ ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
108 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
|
109 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
|
110 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
|
111 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
|
112 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
113 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
|
114 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
|
115 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
|
116 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
117 if( x>=stepsX && y>=stepsY ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
118 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
|
119 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
|
120 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
121 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
|
122 *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
|
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 if( y >= 0 ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
126 dst += dstStride; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
127 src += srcStride; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
128 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
129 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
130 } |
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 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
133 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
134 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
|
135 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
|
136 unsigned int flags, unsigned int outfmt ) { |
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 int z, stepsX, stepsY; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
139 FilterParam *fp; |
8015
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
140 char *effect; |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
141 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
142 // allocate buffers |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
143 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
144 fp = &vf->priv->lumaParam; |
8015
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
145 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
|
146 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
|
147 memset( fp->SC, 0, sizeof( fp->SC ) ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
148 stepsX = fp->msizeX/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
149 stepsY = fp->msizeY/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
150 for( z=0; z<2*stepsY; z++ ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
151 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
|
152 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
153 fp = &vf->priv->chromaParam; |
8015
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
154 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
|
155 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
|
156 memset( fp->SC, 0, sizeof( fp->SC ) ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
157 stepsX = fp->msizeX/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
158 stepsY = fp->msizeY/2; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
159 for( z=0; z<2*stepsY; z++ ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
160 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
|
161 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
162 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
|
163 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
164 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
165 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
166 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
167 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
|
168 if( mpi->flags & MP_IMGFLAG_PRESERVE ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
169 return; // don't change |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
170 if( mpi->imgfmt!=vf->priv->outfmt ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
171 return; // colorspace differ |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
172 |
10141
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
173 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
|
174 mpi->planes[0] = vf->dmpi->planes[0]; |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
175 mpi->stride[0] = vf->dmpi->stride[0]; |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
176 mpi->width = vf->dmpi->width; |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
177 if( mpi->flags & MP_IMGFLAG_PLANAR ) { |
10141
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
178 mpi->planes[1] = vf->dmpi->planes[1]; |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
179 mpi->planes[2] = vf->dmpi->planes[2]; |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
180 mpi->stride[1] = vf->dmpi->stride[1]; |
7d6a854a5fe5
cleanup, use vf->dmpi rather than vf->priv->dmpi for consistency
rfelker
parents:
9934
diff
changeset
|
181 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
|
182 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
183 mpi->flags |= MP_IMGFLAG_DIRECT; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
184 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
185 |
17906
20aca9baf5d8
passing pts through the filter layer (lets see if pts or cola comes out at the end)
michael
parents:
17367
diff
changeset
|
186 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
|
187 mp_image_t *dmpi; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
188 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
189 if( !(mpi->flags & MP_IMGFLAG_DIRECT) ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
190 // 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
|
191 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
|
192 dmpi= vf->dmpi; |
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 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
|
195 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
|
196 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
|
197 |
9934 | 198 vf_clone_mpi_attributes(dmpi, mpi); |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
199 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
200 #ifdef HAVE_MMX |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
201 if(gCpuCaps.hasMMX) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
202 asm volatile ("emms\n\t"); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
203 #endif |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
204 #ifdef HAVE_MMX2 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
205 if(gCpuCaps.hasMMX2) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
206 asm volatile ("sfence\n\t"); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
207 #endif |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
208 |
17906
20aca9baf5d8
passing pts through the filter layer (lets see if pts or cola comes out at the end)
michael
parents:
17367
diff
changeset
|
209 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
|
210 } |
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 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
|
213 unsigned int z; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
214 FilterParam *fp; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
215 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
216 if( !vf->priv ) return; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
217 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
218 fp = &vf->priv->lumaParam; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
219 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
|
220 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
|
221 fp->SC[z] = NULL; |
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 fp = &vf->priv->chromaParam; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
224 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
|
225 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
|
226 fp->SC[z] = NULL; |
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 free( vf->priv ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
230 vf->priv = NULL; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
231 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
232 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
233 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
234 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
235 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
|
236 switch(fmt) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
237 case IMGFMT_YV12: |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
238 case IMGFMT_I420: |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
239 case IMGFMT_IYUV: |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
240 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
|
241 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
242 return 0; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
243 } |
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 //===========================================================================// |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
246 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
247 static void parse( FilterParam *fp, char* 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 // l7x5:0.8:c3x3:-0.2 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
250 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
251 char *z; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
252 char *pos = args; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
253 char *max = args + strlen(args); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
254 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
255 // parse matrix sizes |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
256 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
|
257 z = strchr( pos+1, 'x' ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
258 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
|
259 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
260 // min/max & odd |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
261 fp->msizeX = 1 | MIN( MAX( fp->msizeX, MIN_MATRIX_SIZE ), MAX_MATRIX_SIZE ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
262 fp->msizeY = 1 | MIN( MAX( fp->msizeY, MIN_MATRIX_SIZE ), MAX_MATRIX_SIZE ); |
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 // parse amount |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
265 pos = strchr( pos+1, ':' ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
266 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
|
267 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
268 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
269 //===========================================================================// |
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 static unsigned int fmt_list[] = { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
272 IMGFMT_YV12, |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
273 IMGFMT_I420, |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
274 IMGFMT_IYUV, |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
275 0 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
276 }; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
277 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
278 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
|
279 vf->config = config; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
280 vf->put_image = put_image; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
281 vf->get_image = get_image; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
282 vf->query_format = query_format; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
283 vf->uninit = uninit; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
284 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
|
285 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
|
286 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
287 if( args ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
288 char *args2 = strchr( args, 'l' ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
289 if( args2 ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
290 parse( &vf->priv->lumaParam, args2 ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
291 else { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
292 vf->priv->lumaParam.amount = |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
293 vf->priv->lumaParam.msizeX = |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
294 vf->priv->lumaParam.msizeY = 0; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
295 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
296 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
297 args2 = strchr( args, 'c' ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
298 if( args2 ) |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
299 parse( &vf->priv->chromaParam, args2 ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
300 else { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
301 vf->priv->chromaParam.amount = |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
302 vf->priv->chromaParam.msizeX = |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
303 vf->priv->chromaParam.msizeY = 0; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
304 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
305 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
306 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
|
307 return 0; // nothing to do |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
308 } |
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 // check csp: |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
311 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
|
312 if( !vf->priv->outfmt ) { |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
313 uninit( vf ); |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
314 return 0; // no csp match :( |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
315 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
316 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
317 return 1; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
318 } |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
319 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
320 vf_info_t vf_info_unsharp = { |
8015
403f7a58ccf2
vf_unsharp: proper rounding & print if sharpening or bluring
arpi
parents:
7966
diff
changeset
|
321 "unsharp mask & gaussian blur", |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
322 "unsharp", |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
323 "Rémi Guyomarch", |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
324 "", |
9593
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
8083
diff
changeset
|
325 open, |
e9a2af584986
Add the new -vf option wich is the same as vop in reverse order.
albeu
parents:
8083
diff
changeset
|
326 NULL |
7966
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
327 }; |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
328 |
a03235a5f395
new video filter: unsharp - does image (l/c/l+c) sharping/bluring
arpi
parents:
diff
changeset
|
329 //===========================================================================// |