gst/audiofx/audioamplify.c

   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 method=wrap-negative ! alsasink
  33  * gst-launch-1.0 audiotestsrc wave=saw ! audioconvert ! audioamplify amplification=1.5 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
  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* */
 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
 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
 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
 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
 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
 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
 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
 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 }