annotate libmpcodecs/vf_unsharp.c @ 25836:bc425ba00960

added code to check and handle the presence of LATM streams in the init() and decode() functions
author nicodvb
date Sat, 26 Jan 2008 18:45:11 +0000
parents 00fff9a3b735
children 82601a38e2a7
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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
6ff3379a0862 Unify include path handling, -I.. is in CFLAGS.
diego
parents: 14542
diff changeset
26 #include "config.h"
6ff3379a0862 Unify include path handling, -I.. is in CFLAGS.
diego
parents: 14542
diff changeset
27 #include "mp_msg.h"
6ff3379a0862 Unify include path handling, -I.. is in CFLAGS.
diego
parents: 14542
diff changeset
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
6ff3379a0862 Unify include path handling, -I.. is in CFLAGS.
diego
parents: 14542
diff changeset
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 )
23457
a124f3abc1ec Replace implicit use of fast_memcpy via macro by explicit use to allow
reimar
parents: 22507
diff changeset
88 fast_memcpy( dst, src, srcStride*height );
7966
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 )
23457
a124f3abc1ec Replace implicit use of fast_memcpy via macro by explicit use to allow
reimar
parents: 22507
diff changeset
91 fast_memcpy( dst, src, width );
7966
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
89da8ec89558 vf_clone_mpi_attributes()
michael
parents: 9593
diff changeset
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
25221
00fff9a3b735 Make all vf_info_t structs const
reimar
parents: 23457
diff changeset
314 const 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 //===========================================================================//