Navigation

← Previous Change
Next Change →

Changeset a3b88389a26ac6f747f946ee36556d83d18bda71 for modules/video_filter

Timestamp:

18/07/08 22:34:03 (3 months ago)

Author:

Laurent Aimar <fenrir@videolan.org>

git-committer:

Laurent Aimar <fenrir@videolan.org> 1216413243 +0200

git-parent:

[96d0ab7fb39e46fa0bf0ef5e7ad076537899b14d]

git-author:

Laurent Aimar <fenrir@videolan.org> 1216413243 +0200

Message:

Clean up gaussianblur. There is no need to nearly duplicate all code the to
handle int/float...

Files:

modules/video_filter/gaussianblur.c (modified) (16 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

modules/video_filter/gaussianblur.c

r5d3c921	ra3b8838
40	40
41	41	/*****************************************************************************
42		* ~~Local prototypes~~
	42	* Module descriptor
43	43	*****************************************************************************/
44	44	static int Create ( vlc_object_t * );
45	45	static void Destroy ( vlc_object_t * );
46
47		~~static picture_t Filter( filter_t , picture_t * );~~
48	46
49	47	#define SIGMA_TEXT N_("Gaussian's std deviation")
…	…
54	52	#define FILTER_PREFIX "gaussianblur-"
55	53
56		/*****************************************************************************
57		* Module descriptor
58		*****************************************************************************/
59	54	vlc_module_begin();
60	55	set_description( N_("Gaussian blur video filter") );
…	…
70	65	vlc_module_end();
71	66
	67	/*****************************************************************************
	68	* Local prototypes
	69	*****************************************************************************/
	70	static picture_t Filter( filter_t , picture_t * );
	71
72	72	static const char *const ppsz_filter_options[] = {
73	73	"sigma", NULL
…	…
80	80	*/
81	81	#define DONT_USE_FLOATS
	82
	83	#ifdef DONT_USE_FLOATS
	84	# define type_t int
	85	#else
	86	# define type_t float
	87	#endif
	88
82	89	struct filter_sys_t
83	90	{
84	91	double f_sigma;
85	92	int i_dim;
86		#ifdef DONT_USE_FLOATS
87		int *pi_distribution;
88		int *pi_buffer;
89		int *pi_scale;
90		#else
91		float *pf_distribution;
92		float *pf_buffer;
93		float *pf_scale;
94		#endif
	93
	94	type_t *pt_distribution;
	95	type_t *pt_buffer;
	96	type_t *pt_scale;
95	97	};
96	98
…	…
99	101	double f_sigma = p_sys->f_sigma;
100	102	int i_dim = (int)(3.*f_sigma);
	103	type_t pt_distribution = malloc( (2i_dim+1) * sizeof( type_t ) );
	104	int x;
	105
	106	for( x = -i_dim; x <= i_dim; x++ )
	107	{
	108	const float f_distribution = sqrt( exp(-(xx)/(f_sigmaf_sigma) ) / (2.M_PIf_sigma*f_sigma) );
101	109	#ifdef DONT_USE_FLOATS
102		~~int pi_distribution = (int)malloc( (2i_dim+1) sizeof( int ) )~~;
	110	const float f_factor = 1 << 8;
103	111	#else
104		~~float pf_distribution = (float)malloc( (2i_dim+1) sizeof( float ) )~~;
	112	const float f_factor = 1;
105	113	#endif
106		int x;
107		for( x = -i_dim; x <= i_dim; x++ )
108		{
109		#ifdef DONT_USE_FLOATS
110		pi_distribution[i_dim+x] =
111		(int)( sqrt( exp(-(xx)/(f_sigmaf_sigma) )
112		/ (2.M_PIf_sigmaf_sigma) ) (double)(1<<8) );
113		printf("%d\n",pi_distribution[i_dim+x]);
114		#else
115		pf_distribution[i_dim+x] = (float)
116		sqrt( exp(-(xx)/(f_sigmaf_sigma) ) / (2.M_PIf_sigma*f_sigma) );
117		printf("%f\n",pf_distribution[i_dim+x]);
118		#endif
	114
	115	pt_distribution[i_dim+x] = (type_t)( f_distribution * f_factor );
	116	//printf("%f\n",(float)pt_distribution[i_dim+x]);
119	117	}
120	118	p_sys->i_dim = i_dim;
121		#ifdef DONT_USE_FLOATS
122		p_sys->pi_distribution = pi_distribution;
123		#else
124		p_sys->pf_distribution = pf_distribution;
125		#endif
	119	p_sys->pt_distribution = pt_distribution;
126	120	}
127	121
…	…
170	164	msg_Dbg( p_filter, "gaussian distribution is %d pixels wide",
171	165	p_filter->p_sys->i_dim*2+1 );
172		#ifdef DONT_USE_FLOATS
173		p_filter->p_sys->pi_buffer = NULL;
174		p_filter->p_sys->pi_scale = NULL;
175		#else
176		p_filter->p_sys->pf_buffer = NULL;
177		p_filter->p_sys->pf_scale = NULL;
178		#endif
	166
	167	p_filter->p_sys->pt_buffer = NULL;
	168	p_filter->p_sys->pt_scale = NULL;
179	169
180	170	return VLC_SUCCESS;
…	…
184	174	{
185	175	filter_t p_filter = (filter_t )p_this;
186		#ifdef DONT_USE_FLOATS
187		free( p_filter->p_sys->pi_distribution );
188		free( p_filter->p_sys->pi_buffer );
189		free( p_filter->p_sys->pi_scale );
190		#else
191		free( p_filter->p_sys->pf_distribution );
192		free( p_filter->p_sys->pf_buffer );
193		free( p_filter->p_sys->pf_scale );
194		#endif
	176
	177	free( p_filter->p_sys->pt_distribution );
	178	free( p_filter->p_sys->pt_buffer );
	179	free( p_filter->p_sys->pt_scale );
	180
195	181	free( p_filter->p_sys );
196	182	}
…	…
202	188	int i_plane;
203	189	const int i_dim = p_sys->i_dim;
204		#ifdef DONT_USE_FLOATS
205		int *pi_buffer;
206		int *pi_scale;
207		const int *pi_distribution = p_sys->pi_distribution;
208		#else
209		float *pf_buffer;
210		float *pf_scale;
211		const float *pf_distribution = p_sys->pf_distribution;
212		#endif
	190	type_t *pt_buffer;
	191	type_t *pt_scale;
	192	const type_t *pt_distribution = p_sys->pt_distribution;
	193
213	194	if( !p_pic ) return NULL;
214	195
…	…
220	201	return NULL;
221	202	}
222		#ifdef DONT_USE_FLOATS
223		if( !p_sys->pi_buffer )
224		{
225		p_sys->pi_buffer = (int*)realloc( p_sys->pi_buffer,
226		p_pic->p[Y_PLANE].i_visible_lines
227		* p_pic->p[Y_PLANE].i_pitch
228		* sizeof( int ) );
229		}
230		pi_buffer = p_sys->pi_buffer;
231		#else
232		if( !p_sys->pf_buffer )
233		{
234		p_sys->pf_buffer = (float*)realloc( p_sys->pf_buffer,
235		p_pic->p[Y_PLANE].i_visible_lines
236		* p_pic->p[Y_PLANE].i_pitch
237		* sizeof( float ) );
238		}
239		pf_buffer = p_sys->pf_buffer;
240		#endif
241		#ifdef DONT_USE_FLOATS
242		if( !p_sys->pi_scale )
243		#else
244		if( !p_sys->pf_scale )
245		#endif
	203	if( !p_sys->pt_buffer )
	204	{
	205	p_sys->pt_buffer = realloc( p_sys->pt_buffer,
	206	p_pic->p[Y_PLANE].i_visible_lines *
	207	p_pic->p[Y_PLANE].i_pitch *
	208	sizeof( type_t ) );
	209	}
	210
	211	pt_buffer = p_sys->pt_buffer;
	212	if( !p_sys->pt_scale )
246	213	{
247	214	const int i_visible_lines = p_pic->p[Y_PLANE].i_visible_lines;
…	…
249	216	const int i_pitch = p_pic->p[Y_PLANE].i_pitch;
250	217	int i_col, i_line;
251		#ifdef DONT_USE_FLOATS
252		p_sys->pi_scale = (int)malloc( i_visible_lines i_pitch
253		* sizeof( int ) );
254		pi_scale = p_sys->pi_scale;
255		#else
256		p_sys->pf_scale = (float)malloc( i_visible_lines i_pitch
257		* sizeof( float ) );
258		pf_scale = p_sys->pf_scale;
259		#endif
	218
	219	p_sys->pt_scale = malloc( i_visible_lines * i_pitch * sizeof( type_t ) );
	220	pt_scale = p_sys->pt_scale;
	221
260	222	for( i_line = 0 ; i_line < i_visible_lines ; i_line++ )
261	223	{
…	…
263	225	{
264	226	int x, y;
265		#ifdef DONT_USE_FLOATS
266		int value = 0;
267		#else
268		double value = 0.;
269		#endif
	227	type_t t_value = 0;
	228
270	229	for( y = __MAX( -i_dim, -i_line );
271	230	y <= __MIN( i_dim, i_visible_lines - i_line - 1 );
…	…
276	235	x++ )
277	236	{
278		#ifdef DONT_USE_FLOATS
279		value += pi_distribution[y+i_dim]
280		* pi_distribution[x+i_dim];
281		#else
282		value += ((double)pf_distribution[y+i_dim])
283		* ((double)pf_distribution[x+i_dim]);
284		#endif
	237	t_value += pt_distribution[y+i_dim] *
	238	pt_distribution[x+i_dim];
285	239	}
286	240	}
287		#ifdef DONT_USE_FLOATS
288		pi_scale[i_line*i_pitch+i_col] = value;
289		#else
290		pf_scale[i_line*i_pitch+i_col] = (float)(1./value);
291		#endif
	241	pt_scale[i_line*i_pitch+i_col] = t_value;
292	242	}
293	243	}
294	244	}
295		#ifdef DONT_USE_FLOATS
296		pi_scale = p_sys->pi_scale;
297		#else
298		pf_scale = p_sys->pf_scale;
299		#endif
300
	245
	246	pt_scale = p_sys->pt_scale;
301	247	for( i_plane = 0 ; i_plane < p_pic->i_planes ; i_plane++ )
302	248	{
…	…
317	263	for( i_col = 0; i_col < i_visible_pitch ; i_col++ )
318	264	{
319		#ifdef DONT_USE_FLOATS
320		int value = 0;
321		#else
322		float value = 0.;
323		#endif
	265	type_t t_value = 0;
324	266	int x;
325	267	const int c = i_line*i_pitch+i_col;
…	…
328	270	x++ )
329	271	{
330		#ifdef DONT_USE_FLOATS
331		value += pi_distribution[x+i_dim]
332		* p_in[c+(x>>x_factor)];
333		#else
334		value += pf_distribution[x+i_dim]
335		* (float)p_in[c+(x>>x_factor)];
336		#endif
	272	t_value += pt_distribution[x+i_dim] *
	273	p_in[c+(x>>x_factor)];
337	274	}
338		#ifdef DONT_USE_FLOATS
339		pi_buffer[c] = value;
340		#else
341		pf_buffer[c] = value;
342		#endif
	275	pt_buffer[c] = t_value;
343	276	}
344	277	}
…	…
347	280	for( i_col = 0; i_col < i_visible_pitch ; i_col++ )
348	281	{
349		#ifdef DONT_USE_FLOATS
350		int value = 0;
351		#else
352		float value = 0.;
353		#endif
	282	type_t t_value = 0;
354	283	int y;
355	284	const int c = i_line*i_pitch+i_col;
…	…
358	287	y++ )
359	288	{
360		#ifdef DONT_USE_FLOATS
361		value += pi_distribution[y+i_dim]
362		* pi_buffer[c+(y>>y_factor)*i_pitch];
363		#else
364		value += pf_distribution[y+i_dim]
365		* pf_buffer[c+(y>>y_factor)*i_pitch];
366		#endif
	289	t_value += pt_distribution[y+i_dim] *
	290	pt_buffer[c+(y>>y_factor)*i_pitch];
367	291	}
368		#ifdef DONT_USE_FLOATS
369		p_out[c] = (uint8_t)(value/pi_scale[(i_line<<y_factor)*(i_pitch<<x_factor)+(i_col<<x_factor)]);
370		#else
371		p_out[c] = (uint8_t)(valuepf_scale[(i_line<<y_factor)(i_pitch<<x_factor)+(i_col<<x_factor)]);
372		#endif
	292
	293	const type_t t_scale = pt_scale[(i_line<<y_factor)*(i_pitch<<x_factor)+(i_col<<x_factor)];
	294	p_out[c] = (uint8_t)(t_value / t_scale); // FIXME wouldn't it be better to round instead of trunc ?
373	295	}
374	296	}

Navigation

Changeset a3b88389a26ac6f747f946ee36556d83d18bda71 for modules/video_filter

Legend:

modules/video_filter/gaussianblur.c

Download in other formats: