1 /*
2 * GStreamer
3 * Copyright (C) 2007 Sebastian Dröge <slomo@circular-chaos.org>
4 * Copyright (C) 2006 Stefan Kost <ensonic@users.sf.net>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Library General Public License for more details.
15 *
16 * You should have received a copy of the GNU Library General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
19 * Boston, MA 02110-1301, USA.
20 */
21
22 /**
23 * SECTION:element-audioamplify
24 *
25 * Amplifies an audio stream by a given factor and allows the selection of different clipping modes.
26 * The difference between the clipping modes is best evaluated by testing.
27 *
28 * <refsect2>
29 * <title>Example launch line</title>
30 * |[
31 * gst-launch-1.0 audiotestsrc wave=saw ! audioamplify amplification=1.5 ! alsasink
32 * gst-launch-1.0 filesrc location="melo1.ogg" ! oggdemux ! vorbisdec ! audioconvert ! audioamplify amplification=1.5 clipping-method=wrap-negative ! alsasink
33 * gst-launch-1.0 audiotestsrc wave=saw ! audioconvert ! audioamplify amplification=1.5 clipping-method=wrap-positive ! audioconvert ! alsasink
34 * ]|
35 * </refsect2>
36 */
37
38 #ifdef HAVE_CONFIG_H
39 #include "config.h"
40 #endif
41
42 #include <gst/gst.h>
43 #include <gst/base/gstbasetransform.h>
44 #include <gst/audio/audio.h>
45 #include <gst/audio/gstaudiofilter.h>
46
47 #include "audioamplify.h"
48
49 #define GST_CAT_DEFAULT gst_audio_amplify_debug
50 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
51
52 /* Filter signals and args */
53 enum
54 {
55 /* FILL ME */
56 LAST_SIGNAL
57 };
58
59 enum
60 {
61 PROP_0,
62 PROP_AMPLIFICATION,
63 PROP_CLIPPING_METHOD
64 };
65
66 enum
67 {
68 METHOD_CLIP = 0,
69 METHOD_WRAP_NEGATIVE,
70 METHOD_WRAP_POSITIVE,
71 METHOD_NOCLIP,
72 NUM_METHODS
73 };
74
75 #define GST_TYPE_AUDIO_AMPLIFY_CLIPPING_METHOD (gst_audio_amplify_clipping_method_get_type ())
76 static GType
gst_audio_amplify_clipping_method_get_type(void)77 gst_audio_amplify_clipping_method_get_type (void)
78 {
79 static GType gtype = 0;
80
81 if (gtype == 0) {
82 static const GEnumValue values[] = {
83 {METHOD_CLIP, "Normal clipping (default)", "clip"},
84 {METHOD_WRAP_NEGATIVE,
85 "Push overdriven values back from the opposite side",
86 "wrap-negative"},
87 {METHOD_WRAP_POSITIVE, "Push overdriven values back from the same side",
88 "wrap-positive"},
89 {METHOD_NOCLIP, "No clipping", "none"},
90 {0, NULL, NULL}
91 };
92 gtype = g_enum_register_static ("GstAudioAmplifyClippingMethod", values);
93 }
94 return gtype;
95 }
96
97 #define ALLOWED_CAPS \
98 "audio/x-raw," \
99 " format=(string) {S8,"GST_AUDIO_NE(S16)","GST_AUDIO_NE(S32)"," \
100 GST_AUDIO_NE(F32)","GST_AUDIO_NE(F64)"}," \
101 " rate=(int)[1,MAX]," \
102 " channels=(int)[1,MAX], " \
103 " layout=(string) {interleaved, non-interleaved}"
104
105 G_DEFINE_TYPE (GstAudioAmplify, gst_audio_amplify, GST_TYPE_AUDIO_FILTER);
106
107 static gboolean gst_audio_amplify_set_process_function (GstAudioAmplify *
108 filter, gint clipping, GstAudioFormat format);
109 static void gst_audio_amplify_set_property (GObject * object, guint prop_id,
110 const GValue * value, GParamSpec * pspec);
111 static void gst_audio_amplify_get_property (GObject * object, guint prop_id,
112 GValue * value, GParamSpec * pspec);
113
114 static gboolean gst_audio_amplify_setup (GstAudioFilter * filter,
115 const GstAudioInfo * info);
116 static GstFlowReturn gst_audio_amplify_transform_ip (GstBaseTransform * base,
117 GstBuffer * buf);
118
119 #define MIN_gint8 G_MININT8
120 #define MAX_gint8 G_MAXINT8
121 #define MIN_gint16 G_MININT16
122 #define MAX_gint16 G_MAXINT16
123 #define MIN_gint32 G_MININT32
124 #define MAX_gint32 G_MAXINT32
125
126 #define MAKE_INT_FUNCS(type,largetype) \
127 static void \
128 gst_audio_amplify_transform_##type##_clip (GstAudioAmplify * filter, \
129 void * data, guint num_samples) \
130 { \
131 type *d = data; \
132 \
133 while (num_samples--) { \
134 largetype val = *d * filter->amplification; \
135 *d++ = CLAMP (val, MIN_##type, MAX_##type); \
136 } \
137 } \
138 static void \
139 gst_audio_amplify_transform_##type##_wrap_negative (GstAudioAmplify * filter, \
140 void * data, guint num_samples) \
141 { \
142 type *d = data; \
143 \
144 while (num_samples--) { \
145 largetype val = *d * filter->amplification; \
146 if (val > MAX_##type) \
147 val = MIN_##type + (val - MIN_##type) % ((largetype) MAX_##type + 1 - \
148 MIN_##type); \
149 else if (val < MIN_##type) \
150 val = MAX_##type - (MAX_##type - val) % ((largetype) MAX_##type + 1 - \
151 MIN_##type); \
152 *d++ = val; \
153 } \
154 } \
155 static void \
156 gst_audio_amplify_transform_##type##_wrap_positive (GstAudioAmplify * filter, \
157 void * data, guint num_samples) \
158 { \
159 type *d = data; \
160 \
161 while (num_samples--) { \
162 largetype val = *d * filter->amplification; \
163 do { \
164 if (val > MAX_##type) \
165 val = MAX_##type - (val - MAX_##type); \
166 else if (val < MIN_##type) \
167 val = MIN_##type + (MIN_##type - val); \
168 else \
169 break; \
170 } while (1); \
171 *d++ = val; \
172 } \
173 } \
174 static void \
175 gst_audio_amplify_transform_##type##_noclip (GstAudioAmplify * filter, \
176 void * data, guint num_samples) \
177 { \
178 type *d = data; \
179 \
180 while (num_samples--) \
181 *d++ *= filter->amplification; \
182 }
183
184 #define MAKE_FLOAT_FUNCS(type) \
185 static void \
186 gst_audio_amplify_transform_##type##_clip (GstAudioAmplify * filter, \
187 void * data, guint num_samples) \
188 { \
189 type *d = data; \
190 \
191 while (num_samples--) { \
192 type val = *d* filter->amplification; \
193 *d++ = CLAMP (val, -1.0, +1.0); \
194 } \
195 } \
196 static void \
197 gst_audio_amplify_transform_##type##_wrap_negative (GstAudioAmplify * \
198 filter, void * data, guint num_samples) \
199 { \
200 type *d = data; \
201 \
202 while (num_samples--) { \
203 type val = *d * filter->amplification; \
204 do { \
205 if (val > 1.0) \
206 val = -1.0 + (val - 1.0); \
207 else if (val < -1.0) \
208 val = 1.0 - (1.0 - val); \
209 else \
210 break; \
211 } while (1); \
212 *d++ = val; \
213 } \
214 } \
215 static void \
216 gst_audio_amplify_transform_##type##_wrap_positive (GstAudioAmplify * filter, \
217 void * data, guint num_samples) \
218 { \
219 type *d = data; \
220 \
221 while (num_samples--) { \
222 type val = *d* filter->amplification; \
223 do { \
224 if (val > 1.0) \
225 val = 1.0 - (val - 1.0); \
226 else if (val < -1.0) \
227 val = -1.0 + (-1.0 - val); \
228 else \
229 break; \
230 } while (1); \
231 *d++ = val; \
232 } \
233 } \
234 static void \
235 gst_audio_amplify_transform_##type##_noclip (GstAudioAmplify * filter, \
236 void * data, guint num_samples) \
237 { \
238 type *d = data; \
239 \
240 while (num_samples--) \
241 *d++ *= filter->amplification; \
242 }
243
244 /* *INDENT-OFF* */
MAKE_INT_FUNCS(gint8,gint)245 MAKE_INT_FUNCS (gint8,gint)
246 MAKE_INT_FUNCS (gint16,gint)
247 MAKE_INT_FUNCS (gint32,gint64)
248 MAKE_FLOAT_FUNCS (gfloat)
249 MAKE_FLOAT_FUNCS (gdouble)
250 /* *INDENT-ON* */
251
252 /* GObject vmethod implementations */
253
254 static void
255 gst_audio_amplify_class_init (GstAudioAmplifyClass * klass)
256 {
257 GObjectClass *gobject_class;
258 GstElementClass *gstelement_class;
259 GstCaps *caps;
260
261 GST_DEBUG_CATEGORY_INIT (gst_audio_amplify_debug, "audioamplify", 0,
262 "audioamplify element");
263
264 gobject_class = (GObjectClass *) klass;
265 gstelement_class = (GstElementClass *) klass;
266
267 gobject_class->set_property = gst_audio_amplify_set_property;
268 gobject_class->get_property = gst_audio_amplify_get_property;
269
270 g_object_class_install_property (gobject_class, PROP_AMPLIFICATION,
271 g_param_spec_float ("amplification", "Amplification",
272 "Factor of amplification", -G_MAXFLOAT, G_MAXFLOAT,
273 1.0,
274 G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
275
276 /**
277 * GstAudioAmplify:clipping-method
278 *
279 * Clipping method: clip mode set values higher than the maximum to the
280 * maximum. The wrap-negative mode pushes those values back from the
281 * opposite side, wrap-positive pushes them back from the same side.
282 *
283 **/
284 g_object_class_install_property (gobject_class, PROP_CLIPPING_METHOD,
285 g_param_spec_enum ("clipping-method", "Clipping method",
286 "Selects how to handle values higher than the maximum",
287 GST_TYPE_AUDIO_AMPLIFY_CLIPPING_METHOD, METHOD_CLIP,
288 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
289
290 gst_element_class_set_static_metadata (gstelement_class, "Audio amplifier",
291 "Filter/Effect/Audio",
292 "Amplifies an audio stream by a given factor",
293 "Sebastian Dröge <slomo@circular-chaos.org>");
294
295 caps = gst_caps_from_string (ALLOWED_CAPS);
296 gst_audio_filter_class_add_pad_templates (GST_AUDIO_FILTER_CLASS (klass),
297 caps);
298 gst_caps_unref (caps);
299
300 GST_BASE_TRANSFORM_CLASS (klass)->transform_ip =
301 GST_DEBUG_FUNCPTR (gst_audio_amplify_transform_ip);
302 GST_BASE_TRANSFORM_CLASS (klass)->transform_ip_on_passthrough = FALSE;
303
304 GST_AUDIO_FILTER_CLASS (klass)->setup =
305 GST_DEBUG_FUNCPTR (gst_audio_amplify_setup);
306 }
307
308 static void
gst_audio_amplify_init(GstAudioAmplify * filter)309 gst_audio_amplify_init (GstAudioAmplify * filter)
310 {
311 filter->amplification = 1.0;
312 gst_audio_amplify_set_process_function (filter, METHOD_CLIP,
313 GST_AUDIO_FORMAT_S16);
314 gst_base_transform_set_in_place (GST_BASE_TRANSFORM (filter), TRUE);
315 gst_base_transform_set_gap_aware (GST_BASE_TRANSFORM (filter), TRUE);
316 }
317
318 static GstAudioAmplifyProcessFunc
gst_audio_amplify_process_function(gint clipping,GstAudioFormat format)319 gst_audio_amplify_process_function (gint clipping, GstAudioFormat format)
320 {
321 static const struct process
322 {
323 GstAudioFormat format;
324 gint clipping;
325 GstAudioAmplifyProcessFunc func;
326 } process[] = {
327 {
328 GST_AUDIO_FORMAT_F32, METHOD_CLIP, gst_audio_amplify_transform_gfloat_clip}, {
329 GST_AUDIO_FORMAT_F32, METHOD_WRAP_NEGATIVE,
330 gst_audio_amplify_transform_gfloat_wrap_negative}, {
331 GST_AUDIO_FORMAT_F32, METHOD_WRAP_POSITIVE,
332 gst_audio_amplify_transform_gfloat_wrap_positive}, {
333 GST_AUDIO_FORMAT_F32, METHOD_NOCLIP,
334 gst_audio_amplify_transform_gfloat_noclip}, {
335 GST_AUDIO_FORMAT_F64, METHOD_CLIP,
336 gst_audio_amplify_transform_gdouble_clip}, {
337 GST_AUDIO_FORMAT_F64, METHOD_WRAP_NEGATIVE,
338 gst_audio_amplify_transform_gdouble_wrap_negative}, {
339 GST_AUDIO_FORMAT_F64, METHOD_WRAP_POSITIVE,
340 gst_audio_amplify_transform_gdouble_wrap_positive}, {
341 GST_AUDIO_FORMAT_F64, METHOD_NOCLIP,
342 gst_audio_amplify_transform_gdouble_noclip}, {
343 GST_AUDIO_FORMAT_S8, METHOD_CLIP, gst_audio_amplify_transform_gint8_clip}, {
344 GST_AUDIO_FORMAT_S8, METHOD_WRAP_NEGATIVE,
345 gst_audio_amplify_transform_gint8_wrap_negative}, {
346 GST_AUDIO_FORMAT_S8, METHOD_WRAP_POSITIVE,
347 gst_audio_amplify_transform_gint8_wrap_positive}, {
348 GST_AUDIO_FORMAT_S8, METHOD_NOCLIP,
349 gst_audio_amplify_transform_gint8_noclip}, {
350 GST_AUDIO_FORMAT_S16, METHOD_CLIP, gst_audio_amplify_transform_gint16_clip}, {
351 GST_AUDIO_FORMAT_S16, METHOD_WRAP_NEGATIVE,
352 gst_audio_amplify_transform_gint16_wrap_negative}, {
353 GST_AUDIO_FORMAT_S16, METHOD_WRAP_POSITIVE,
354 gst_audio_amplify_transform_gint16_wrap_positive}, {
355 GST_AUDIO_FORMAT_S16, METHOD_NOCLIP,
356 gst_audio_amplify_transform_gint16_noclip}, {
357 GST_AUDIO_FORMAT_S32, METHOD_CLIP, gst_audio_amplify_transform_gint32_clip}, {
358 GST_AUDIO_FORMAT_S32, METHOD_WRAP_NEGATIVE,
359 gst_audio_amplify_transform_gint32_wrap_negative}, {
360 GST_AUDIO_FORMAT_S32, METHOD_WRAP_POSITIVE,
361 gst_audio_amplify_transform_gint32_wrap_positive}, {
362 GST_AUDIO_FORMAT_S32, METHOD_NOCLIP,
363 gst_audio_amplify_transform_gint32_noclip}, {
364 0, 0, NULL}
365 };
366 const struct process *p;
367
368 for (p = process; p->func; p++)
369 if (p->format == format && p->clipping == clipping)
370 return p->func;
371 return NULL;
372 }
373
374 static gboolean
gst_audio_amplify_set_process_function(GstAudioAmplify * filter,gint clipping_method,GstAudioFormat format)375 gst_audio_amplify_set_process_function (GstAudioAmplify * filter, gint
376 clipping_method, GstAudioFormat format)
377 {
378 GstAudioAmplifyProcessFunc process;
379
380 /* set processing function */
381
382 process = gst_audio_amplify_process_function (clipping_method, format);
383 if (!process) {
384 GST_DEBUG ("wrong format");
385 return FALSE;
386 }
387
388 filter->process = process;
389 filter->clipping_method = clipping_method;
390 filter->format = format;
391
392 return TRUE;
393 }
394
395 static void
gst_audio_amplify_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)396 gst_audio_amplify_set_property (GObject * object, guint prop_id,
397 const GValue * value, GParamSpec * pspec)
398 {
399 GstAudioAmplify *filter = GST_AUDIO_AMPLIFY (object);
400
401 switch (prop_id) {
402 case PROP_AMPLIFICATION:
403 filter->amplification = g_value_get_float (value);
404 gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (filter),
405 filter->amplification == 1.0);
406 break;
407 case PROP_CLIPPING_METHOD:
408 gst_audio_amplify_set_process_function (filter, g_value_get_enum (value),
409 filter->format);
410 break;
411 default:
412 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
413 break;
414 }
415 }
416
417 static void
gst_audio_amplify_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)418 gst_audio_amplify_get_property (GObject * object, guint prop_id,
419 GValue * value, GParamSpec * pspec)
420 {
421 GstAudioAmplify *filter = GST_AUDIO_AMPLIFY (object);
422
423 switch (prop_id) {
424 case PROP_AMPLIFICATION:
425 g_value_set_float (value, filter->amplification);
426 break;
427 case PROP_CLIPPING_METHOD:
428 g_value_set_enum (value, filter->clipping_method);
429 break;
430 default:
431 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
432 break;
433 }
434 }
435
436 /* GstAudioFilter vmethod implementations */
437 static gboolean
gst_audio_amplify_setup(GstAudioFilter * base,const GstAudioInfo * info)438 gst_audio_amplify_setup (GstAudioFilter * base, const GstAudioInfo * info)
439 {
440 GstAudioAmplify *filter = GST_AUDIO_AMPLIFY (base);
441
442 return gst_audio_amplify_set_process_function (filter,
443 filter->clipping_method, GST_AUDIO_INFO_FORMAT (info));
444 }
445
446 /* GstBaseTransform vmethod implementations */
447 static GstFlowReturn
gst_audio_amplify_transform_ip(GstBaseTransform * base,GstBuffer * buf)448 gst_audio_amplify_transform_ip (GstBaseTransform * base, GstBuffer * buf)
449 {
450 GstAudioAmplify *filter = GST_AUDIO_AMPLIFY (base);
451 guint num_samples;
452 GstClockTime timestamp, stream_time;
453 GstMapInfo map;
454
455 timestamp = GST_BUFFER_TIMESTAMP (buf);
456 stream_time =
457 gst_segment_to_stream_time (&base->segment, GST_FORMAT_TIME, timestamp);
458
459 GST_DEBUG_OBJECT (filter, "sync to %" GST_TIME_FORMAT,
460 GST_TIME_ARGS (timestamp));
461
462 if (GST_CLOCK_TIME_IS_VALID (stream_time))
463 gst_object_sync_values (GST_OBJECT (filter), stream_time);
464
465 if (G_UNLIKELY (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_GAP)))
466 return GST_FLOW_OK;
467
468 gst_buffer_map (buf, &map, GST_MAP_READWRITE);
469 num_samples = map.size / GST_AUDIO_FILTER_BPS (filter);
470
471 filter->process (filter, map.data, num_samples);
472
473 gst_buffer_unmap (buf, &map);
474
475 return GST_FLOW_OK;
476 }
477