From 1645110f020d26eaa9700775dbedf646918fdd23 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Stadler?= Date: Sat, 19 May 2007 10:01:45 +0000 Subject: Add replaygain playback elements (#412710). MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Original commit message from CVS: Patch by: René Stadler * docs/plugins/Makefile.am: * docs/plugins/gst-plugins-bad-plugins-docs.sgml: * docs/plugins/gst-plugins-bad-plugins-sections.txt: * docs/plugins/inspect/plugin-replaygain.xml: * gst/replaygain/Makefile.am: * gst/replaygain/gstrganalysis.c: (gst_rg_analysis_class_init), (gst_rg_analysis_start), (gst_rg_analysis_set_caps), (gst_rg_analysis_transform_ip), (gst_rg_analysis_event), (gst_rg_analysis_stop), (gst_rg_analysis_handle_tags), (gst_rg_analysis_handle_eos), (gst_rg_analysis_track_result), (gst_rg_analysis_album_result): * gst/replaygain/gstrganalysis.h: * gst/replaygain/gstrglimiter.c: (gst_rg_limiter_base_init), (gst_rg_limiter_class_init), (gst_rg_limiter_init), (gst_rg_limiter_set_property), (gst_rg_limiter_get_property), (gst_rg_limiter_transform_ip): * gst/replaygain/gstrglimiter.h: * gst/replaygain/gstrgvolume.c: (gst_rg_volume_base_init), (gst_rg_volume_class_init), (gst_rg_volume_init), (gst_rg_volume_set_property), (gst_rg_volume_get_property), (gst_rg_volume_dispose), (gst_rg_volume_change_state), (gst_rg_volume_sink_event), (gst_rg_volume_tag_event), (gst_rg_volume_reset), (gst_rg_volume_update_gain), (gst_rg_volume_determine_gain): * gst/replaygain/gstrgvolume.h: * gst/replaygain/replaygain.c: (plugin_init): * gst/replaygain/replaygain.h: * gst/replaygain/rganalysis.h: * tests/check/Makefile.am: * tests/check/elements/.cvsignore: * tests/check/elements/rganalysis.c: (send_eos_event), (GST_START_TEST): * tests/check/elements/rglimiter.c: (setup_rglimiter), (cleanup_rglimiter), (set_playing_state), (create_test_buffer), (verify_test_buffer), (GST_START_TEST), (rglimiter_suite), (main): * tests/check/elements/rgvolume.c: (event_func), (setup_rgvolume), (cleanup_rgvolume), (set_playing_state), (set_null_state), (send_eos_event), (send_tag_event), (test_buffer_new), (fail_unless_target_gain), (fail_unless_result_gain), (fail_unless_gain), (GST_START_TEST), (rgvolume_suite), (main): Add replaygain playback elements (#412710). --- gst/replaygain/Makefile.am | 12 +- gst/replaygain/gstrganalysis.c | 298 ++++++++--------- gst/replaygain/gstrganalysis.h | 2 + gst/replaygain/gstrglimiter.c | 197 ++++++++++++ gst/replaygain/gstrglimiter.h | 64 ++++ gst/replaygain/gstrgvolume.c | 702 +++++++++++++++++++++++++++++++++++++++++ gst/replaygain/gstrgvolume.h | 88 ++++++ gst/replaygain/replaygain.c | 53 ++++ gst/replaygain/replaygain.h | 36 +++ gst/replaygain/rganalysis.h | 2 - 10 files changed, 1302 insertions(+), 152 deletions(-) create mode 100644 gst/replaygain/gstrglimiter.c create mode 100644 gst/replaygain/gstrglimiter.h create mode 100644 gst/replaygain/gstrgvolume.c create mode 100644 gst/replaygain/gstrgvolume.h create mode 100644 gst/replaygain/replaygain.c create mode 100644 gst/replaygain/replaygain.h (limited to 'gst/replaygain') diff --git a/gst/replaygain/Makefile.am b/gst/replaygain/Makefile.am index d4523654..a0a3ca5a 100644 --- a/gst/replaygain/Makefile.am +++ b/gst/replaygain/Makefile.am @@ -2,12 +2,20 @@ plugin_LTLIBRARIES = libgstreplaygain.la libgstreplaygain_la_SOURCES = \ gstrganalysis.c \ + gstrglimiter.c \ + gstrgvolume.c \ + replaygain.c \ rganalysis.c -libgstreplaygain_la_CFLAGS = $(GST_CFLAGS) $(GST_BASE_CFLAGS) -libgstreplaygain_la_LIBADD = $(GST_LIBS) $(GST_BASE_LIBS) $(LIBM) +libgstreplaygain_la_CFLAGS = \ + $(GST_CFLAGS) $(GST_BASE_CFLAGS) $(GST_PLUGINS_BASE_CFLAGS) +libgstreplaygain_la_LIBADD = \ + $(GST_LIBS) $(GST_BASE_LIBS) $(GST_PLUGINS_BASE_LIBS) -lgstpbutils-0.10 $(LIBM) libgstreplaygain_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) # headers we need but don't want installed noinst_HEADERS = \ gstrganalysis.h \ + gstrglimiter.h \ + gstrgvolume.h \ + replaygain.h \ rganalysis.h diff --git a/gst/replaygain/gstrganalysis.c b/gst/replaygain/gstrganalysis.c index 9ad50e0d..24367786 100644 --- a/gst/replaygain/gstrganalysis.c +++ b/gst/replaygain/gstrganalysis.c @@ -22,103 +22,29 @@ /** * SECTION:element-rganalysis + * @see_also: rgvolume * * * - * GstRgAnalysis analyzes raw audio sample data in accordance with the - * proposed ReplayGain - * standard for calculating the ideal replay gain for music - * tracks and albums. The element is designed as a pass-through - * filter that never modifies any data. As it receives an EOS event, - * it finalizes the ongoing analysis and generates a tag list - * containing the results. It is sent downstream with a TAG event and - * posted on the message bus with a TAG message. The EOS event is - * forwarded as normal afterwards. Result tag lists at least contain - * the tags #GST_TAG_TRACK_GAIN and #GST_TAG_TRACK_PEAK. + * This element analyzes raw audio sample data in accordance with the proposed + * ReplayGain standard for + * calculating the ideal replay gain for music tracks and albums. The element + * is designed as a pass-through filter that never modifies any data. As it + * receives an EOS event, it finalizes the ongoing analysis and generates a tag + * list containing the results. It is sent downstream with a tag event and + * posted on the message bus with a tag message. The EOS event is forwarded as + * normal afterwards. Result tag lists at least contain the tags + * #GST_TAG_TRACK_GAIN, #GST_TAG_TRACK_PEAK and #GST_TAG_REFERENCE_LEVEL. * - * Album processing * - * Analyzing several streams sequentially and assigning them a common - * result gain is known as "album processing". If this gain is used - * during playback (by switching to "album mode"), all tracks receive - * the same amplification. This keeps the relative volume levels - * between the tracks intact. To enable this, set the num-tracks property to - * the number of streams that will be processed as album tracks. - * Every time an EOS event is received, the value of this property - * will be decremented by one. As it reaches zero, it is assumed that - * the last track of the album finished. The tag list for the final - * stream will contain the additional tags #GST_TAG_ALBUM_GAIN and - * #GST_TAG_ALBUM_PEAK. All other streams just get the two track tags - * posted because the values for the album tags are not known before - * all tracks are analyzed. Applications need to make sure that the - * album gain and peak values are also associated with the other - * tracks when storing the results. It is thus a bit more complex to - * implement, but should not be avoided since the album gain is - * generally more valuable for use during playback than the track - * gain. - * - * Skipping processing - * - * For assisting transcoder/converter applications, the element can - * silently skip the processing of streams that already contain the - * necessary meta data tags. Data will flow as usual but the element - * will not consume CPU time and will not generate result tags. To - * enable possible skipping, set the forced property to #FALSE. - * If used in conjunction with album processing, the element will skip - * the number of remaining album tracks if a full set of tags is found - * for the first track. If a subsequent track of the album is missing - * tags, processing cannot start again. If this is undesired, your - * application has to scan all files beforehand and enable forcing of - * processing if needed. - * - * Tips - * - * - * Because the generated metadata tags become available at the end of - * streams, downstream muxer and encoder elements are normally unable - * to save them in their output since they generally save metadata in - * the file header. Therefore, it is often necessary that - * applications read the results in a bus event handler for the tag - * message. Obtaining the values this way is always needed for album - * processing since the album gain and peak values need to be - * associated with all tracks of an album, not just the last one. - * - * - * To perform album processing, the element has to preserve data - * between streams. This cannot survive a state change to the NULL or - * READY state. If you change your pipeline's state to NULL or READY - * between tracks, lock the rganalysis element's state using - * gst_element_set_locked_state() when it is in PAUSED or PLAYING. As - * with any other element, don't forget to unlock it again and set it - * to the NULL state before dropping the last reference. - * - * - * If the total number of album tracks is unknown beforehand, set the - * num-tracks property to some large value like #G_MAXINT (or set it - * to >= 2 before each track starts). Before the last track ends, set - * the property value to 1. - * - * - * Compliance - * - * Analyzing the ReplayGain pink noise reference waveform will compute - * a result of +6.00dB instead of the expected 0.00dB because the - * default reference level is 89dB. To obtain values as lined out in - * the original proposal of ReplayGain, set the reference-level - * property to 83. Almost all software uses 89dB as a reference - * however, which works against the tendency of the algorithm to - * advise to drastically lower the volume of music with a highly - * compressed dynamic range and high average output levels. This - * tendency is normally to be fought during playback (if wanted), by - * using a default pre-amp value of at least +6.00dB. At one point, - * the majority of analyzer implementations switched to 89dB which - * moved this adjustment to the analyzing/metadata writing process. - * This change has been acknowledged by the author of the ReplayGain - * proposal, however at the time of this writing, the webpage is still - * not updated. + * Because the generated metadata tags become available at the end of streams, + * downstream muxer and encoder elements are normally unable to save them in + * their output since they generally save metadata in the file header. + * Therefore, it is often necessary that applications read the results in a bus + * event handler for the tag message. Obtaining the values this way is always + * needed for album processing + * since the album gain and peak values need to be associated with all tracks of + * an album, not just the last one. * * Example launch lines * Analyze a simple test waveform: @@ -127,18 +53,26 @@ * * Analyze a given file: * - * gst-launch -t filesrc location="Some file.ogg" ! decodebin ! audioconvert ! audioresample ! rganalysis ! fakesink + * gst-launch -t filesrc location="Some file.ogg" ! decodebin \ + * ! audioconvert ! audioresample ! rganalysis ! fakesink * * Analyze the pink noise reference file: * - * gst-launch -t gnomevfssrc location=http://replaygain.hydrogenaudio.org/ref_pink.wav ! wavparse ! rganalysis ! fakesink + * gst-launch -t gnomevfssrc location=http://replaygain.hydrogenaudio.org/ref_pink.wav \ + * ! wavparse ! rganalysis ! fakesink * + * + * The above launch line yields a result gain of +6 dB (instead of the expected + * +0 dB). This is not in error, refer to the reference-level property + * documentation for more information. + * * Acknowledgements * * This element is based on code used in the vorbisgain program - * and many others. The relevant parts are copyrighted by David - * Robinson, Glen Sawyer and Frank Klemm. + * url="http://sjeng.org/vorbisgain.html">vorbisgain program and many + * others. The relevant parts are copyrighted by David Robinson, Glen Sawyer + * and Frank Klemm. * * */ @@ -147,11 +81,11 @@ #include #endif -#include #include #include #include "gstrganalysis.h" +#include "replaygain.h" GST_DEBUG_CATEGORY_STATIC (gst_rg_analysis_debug); #define GST_CAT_DEFAULT gst_rg_analysis_debug @@ -254,18 +188,93 @@ gst_rg_analysis_class_init (GstRgAnalysisClass * klass) gobject_class->set_property = gst_rg_analysis_set_property; gobject_class->get_property = gst_rg_analysis_get_property; + /** + * GstRgAnalysis:num-tracks: + * + * Number of remaining album tracks. + * + * Analyzing several streams sequentially and assigning them a common result + * gain is known as "album processing". If this gain is used during playback + * (by switching to "album mode"), all tracks of an album receive the same + * amplification. This keeps the relative volume levels between the tracks + * intact. To enable this, set this property to the number of streams that + * will be processed as album tracks. + * + * Every time an EOS event is received, the value of this property is + * decremented by one. As it reaches zero, it is assumed that the last track + * of the album finished. The tag list for the final stream will contain the + * additional tags #GST_TAG_ALBUM_GAIN and #GST_TAG_ALBUM_PEAK. All other + * streams just get the two track tags posted because the values for the album + * tags are not known before all tracks are analyzed. Applications need to + * ensure that the album gain and peak values are also associated with the + * other tracks when storing the results. + * + * If the total number of album tracks is unknown beforehand, just ensure that + * the value is greater than 1 before each track starts. Then before the end + * of the last track, set it to the value 1. + * + * To perform album processing, the element has to preserve data between + * streams. This cannot survive a state change to the NULL or READY state. + * If you change your pipeline's state to NULL or READY between tracks, lock + * the element's state using gst_element_set_locked_state() when it is in + * PAUSED or PLAYING. + */ g_object_class_install_property (gobject_class, PROP_NUM_TRACKS, g_param_spec_int ("num-tracks", "Number of album tracks", - "Number of remaining tracks in the album", - 0, G_MAXINT, 0, G_PARAM_READWRITE)); + "Number of remaining album tracks", 0, G_MAXINT, 0, + G_PARAM_READWRITE)); + /** + * GstRgAnalysis:forced: + * + * Whether to analyze streams even when ReplayGain tags exist. + * + * For assisting transcoder/converter applications, the element can silently + * skip the processing of streams that already contain the necessary tags. + * Data will flow as usual but the element will not consume CPU time and will + * not generate result tags. To enable possible skipping, set this property + * to #FALSE. + * + * If used in conjunction with album + * processing, the element will skip the number of remaining album + * tracks if a full set of tags is found for the first track. If a subsequent + * track of the album is missing tags, processing cannot start again. If this + * is undesired, the application has to scan all files beforehand and enable + * forcing of processing if needed. + */ g_object_class_install_property (gobject_class, PROP_FORCED, - g_param_spec_boolean ("forced", "Force processing", - "Analyze streams even when ReplayGain tags exist", + g_param_spec_boolean ("forced", "Forced", + "Analyze even if ReplayGain tags exist", FORCED_DEFAULT, G_PARAM_READWRITE)); + /** + * GstRgAnalysis:reference-level: + * + * Reference level [dB]. + * + * Analyzing the ReplayGain pink noise reference waveform computes a result of + * +6 dB instead of the expected 0 dB. This is because the default reference + * level is 89 dB. To obtain values as lined out in the original proposal of + * ReplayGain, set this property to 83. + * + * Almost all software uses 89 dB as a reference however, and this value has + * become the new official value. That is to say, while the change has been + * acclaimed by the author of the ReplayGain proposal, the webpage is still outdated at the time + * of this writing. + * + * The value was changed because the original proposal recommends a default + * pre-amp value of +6 dB for playback. This seemed a bit odd, as it means + * that the algorithm has the general tendency to produce adjustment values + * that are 6 dB too low. Bumping the reference level by 6 dB compensated for + * this. + * + * The problem of the reference level being ambiguous for lack of concise + * standardization is to be solved by adopting the #GST_TAG_REFERENCE_LEVEL + * tag, which allows to store the used value alongside the gain values. + */ g_object_class_install_property (gobject_class, PROP_REFERENCE_LEVEL, g_param_spec_double ("reference-level", "Reference level", - "Reference level in dB (83.0 for original proposal)", - 0.0, G_MAXDOUBLE, RG_REFERENCE_LEVEL, G_PARAM_READWRITE)); + "Reference level [dB]", 0.0, 150., RG_REFERENCE_LEVEL, + G_PARAM_READWRITE)); trans_class = (GstBaseTransformClass *) klass; trans_class->start = GST_DEBUG_FUNCPTR (gst_rg_analysis_start); @@ -346,7 +355,7 @@ gst_rg_analysis_start (GstBaseTransform * base) filter->ctx = rg_analysis_new (); filter->analyze = NULL; - GST_DEBUG_OBJECT (filter, "Started"); + GST_LOG_OBJECT (filter, "started"); return TRUE; } @@ -357,7 +366,7 @@ gst_rg_analysis_set_caps (GstBaseTransform * base, GstCaps * in_caps, { GstRgAnalysis *filter = GST_RG_ANALYSIS (base); GstStructure *structure; - const gchar *mime_type; + const gchar *name; gint n_channels, sample_rate, sample_bit_size, sample_size; g_return_val_if_fail (filter->ctx != NULL, FALSE); @@ -367,7 +376,7 @@ gst_rg_analysis_set_caps (GstBaseTransform * base, GstCaps * in_caps, in_caps, out_caps); structure = gst_caps_get_structure (in_caps, 0); - mime_type = gst_structure_get_name (structure); + name = gst_structure_get_name (structure); if (!gst_structure_get_int (structure, "width", &sample_bit_size) || !gst_structure_get_int (structure, "channels", &n_channels) @@ -381,7 +390,7 @@ gst_rg_analysis_set_caps (GstBaseTransform * base, GstCaps * in_caps, goto invalid_format; sample_size = sample_bit_size / 8; - if (strcmp (mime_type, "audio/x-raw-float") == 0) { + if (g_str_equal (name, "audio/x-raw-float")) { if (sample_size != sizeof (gfloat)) goto invalid_format; @@ -398,7 +407,7 @@ gst_rg_analysis_set_caps (GstBaseTransform * base, GstCaps * in_caps, else goto invalid_format; - } else if (strcmp (mime_type, "audio/x-raw-int") == 0) { + } else if (g_str_equal (name, "audio/x-raw-int")) { if (sample_size != sizeof (gint16)) goto invalid_format; @@ -437,13 +446,13 @@ gst_rg_analysis_transform_ip (GstBaseTransform * base, GstBuffer * buf) { GstRgAnalysis *filter = GST_RG_ANALYSIS (base); - g_return_val_if_fail (filter->ctx != NULL, GST_FLOW_ERROR); - g_return_val_if_fail (filter->analyze != NULL, GST_FLOW_ERROR); + g_return_val_if_fail (filter->ctx != NULL, GST_FLOW_WRONG_STATE); + g_return_val_if_fail (filter->analyze != NULL, GST_FLOW_NOT_NEGOTIATED); if (filter->skip) return GST_FLOW_OK; - GST_DEBUG_OBJECT (filter, "Processing buffer of size %u", + GST_LOG_OBJECT (filter, "processing buffer of size %u", GST_BUFFER_SIZE (buf)); filter->analyze (filter->ctx, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf), @@ -463,11 +472,11 @@ gst_rg_analysis_event (GstBaseTransform * base, GstEvent * event) case GST_EVENT_EOS: { - GST_DEBUG_OBJECT (filter, "Received EOS event"); + GST_LOG_OBJECT (filter, "received EOS event"); gst_rg_analysis_handle_eos (filter); - GST_DEBUG_OBJECT (filter, "Passing on EOS event"); + GST_LOG_OBJECT (filter, "passing on EOS event"); break; } @@ -498,7 +507,7 @@ gst_rg_analysis_stop (GstBaseTransform * base) rg_analysis_destroy (filter->ctx); filter->ctx = NULL; - GST_DEBUG_OBJECT (filter, "Stopped"); + GST_LOG_OBJECT (filter, "stopped"); return TRUE; } @@ -514,13 +523,13 @@ gst_rg_analysis_handle_tags (GstRgAnalysis * filter, filter->ignore_tags = FALSE; if (filter->skip && album_processing) { - GST_INFO_OBJECT (filter, "Ignoring TAG event: Skipping album"); + GST_DEBUG_OBJECT (filter, "ignoring tag event: skipping album"); return; } else if (filter->skip) { - GST_INFO_OBJECT (filter, "Ignoring TAG event: Skipping track"); + GST_DEBUG_OBJECT (filter, "ignoring tag event: skipping track"); return; } else if (filter->ignore_tags) { - GST_INFO_OBJECT (filter, "Ignoring TAG event: Cannot skip anyways"); + GST_DEBUG_OBJECT (filter, "ignoring tag event: cannot skip anyways"); return; } @@ -534,30 +543,31 @@ gst_rg_analysis_handle_tags (GstRgAnalysis * filter, GST_TAG_ALBUM_PEAK, &dummy); if (!(filter->has_track_gain && filter->has_track_peak)) { - GST_INFO_OBJECT (filter, "Track tags not complete yet"); + GST_DEBUG_OBJECT (filter, "track tags not complete yet"); return; } if (album_processing && !(filter->has_album_gain && filter->has_album_peak)) { - GST_INFO_OBJECT (filter, "Album tags not complete yet"); + GST_DEBUG_OBJECT (filter, "album tags not complete yet"); return; } if (filter->forced) { - GST_INFO_OBJECT (filter, - "Existing tags are sufficient, but processing anyway (forced)"); + GST_DEBUG_OBJECT (filter, + "existing tags are sufficient, but processing anyway (forced)"); return; } filter->skip = TRUE; rg_analysis_reset (filter->ctx); - if (!album_processing) - GST_INFO_OBJECT (filter, - "Existing tags are sufficient, will not process this track"); - else - GST_INFO_OBJECT (filter, - "Existing tags are sufficient, will not process this album"); + if (!album_processing) { + GST_DEBUG_OBJECT (filter, + "existing tags are sufficient, will not process this track"); + } else { + GST_DEBUG_OBJECT (filter, + "existing tags are sufficient, will not process this album"); + } } static void @@ -599,7 +609,9 @@ gst_rg_analysis_handle_eos (GstRgAnalysis * filter) rg_analysis_reset_album (filter->ctx); if (track_success || album_success) { - GST_DEBUG_OBJECT (filter, "Posting tag list with results"); + GST_LOG_OBJECT (filter, "posting tag list with results"); + gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND, + GST_TAG_REFERENCE_LEVEL, filter->reference_level, NULL); /* This steals our reference to the list: */ gst_element_found_tags_for_pad (GST_ELEMENT (filter), GST_BASE_TRANSFORM_SRC_PAD (GST_BASE_TRANSFORM (filter)), tag_list); @@ -609,11 +621,12 @@ gst_rg_analysis_handle_eos (GstRgAnalysis * filter) if (album_processing) { filter->num_tracks--; - if (!album_finished) - GST_INFO_OBJECT (filter, "Album not finished yet (num-tracks is now %u)", + if (!album_finished) { + GST_DEBUG_OBJECT (filter, "album not finished yet (num-tracks is now %u)", filter->num_tracks); - else - GST_INFO_OBJECT (filter, "Album finished (num-tracks is now 0)"); + } else { + GST_DEBUG_OBJECT (filter, "album finished (num-tracks is now 0)"); + } } if (album_processing) @@ -631,10 +644,10 @@ gst_rg_analysis_track_result (GstRgAnalysis * filter, GstTagList ** tag_list) if (track_success) { track_gain += filter->reference_level - RG_REFERENCE_LEVEL; - GST_INFO_OBJECT (filter, "Track gain is %+.2f dB, peak %.6f", track_gain, + GST_INFO_OBJECT (filter, "track gain is %+.2f dB, peak %.6f", track_gain, track_peak); } else { - GST_INFO_OBJECT (filter, "Track was too short to analyze"); + GST_INFO_OBJECT (filter, "track was too short to analyze"); } if (track_success) { @@ -658,10 +671,10 @@ gst_rg_analysis_album_result (GstRgAnalysis * filter, GstTagList ** tag_list) if (album_success) { album_gain += filter->reference_level - RG_REFERENCE_LEVEL; - GST_INFO_OBJECT (filter, "Album gain is %+.2f dB, peak %.6f", album_gain, + GST_INFO_OBJECT (filter, "album gain is %+.2f dB, peak %.6f", album_gain, album_peak); } else { - GST_INFO_OBJECT (filter, "Album was too short to analyze"); + GST_INFO_OBJECT (filter, "album was too short to analyze"); } if (album_success) { @@ -673,14 +686,3 @@ gst_rg_analysis_album_result (GstRgAnalysis * filter, GstTagList ** tag_list) return album_success; } - -static gboolean -plugin_init (GstPlugin * plugin) -{ - return gst_element_register (plugin, "rganalysis", GST_RANK_NONE, - GST_TYPE_RG_ANALYSIS); -} - -GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, "replaygain", - "ReplayGain analysis", plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, - GST_PACKAGE_ORIGIN); diff --git a/gst/replaygain/gstrganalysis.h b/gst/replaygain/gstrganalysis.h index 121ce4af..fbf46830 100644 --- a/gst/replaygain/gstrganalysis.h +++ b/gst/replaygain/gstrganalysis.h @@ -78,6 +78,8 @@ struct _GstRgAnalysisClass GstBaseTransformClass parent_class; }; +GType gst_rg_analysis_get_type (void); + G_END_DECLS #endif /* __GST_RG_ANALYSIS_H__ */ diff --git a/gst/replaygain/gstrglimiter.c b/gst/replaygain/gstrglimiter.c new file mode 100644 index 00000000..609db3d7 --- /dev/null +++ b/gst/replaygain/gstrglimiter.c @@ -0,0 +1,197 @@ +/* GStreamer ReplayGain limiter + * + * Copyright (C) 2007 Rene Stadler + * + * gstrglimiter.c: Element to apply signal compression to raw audio data + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + +/** + * SECTION:element-rglimiter + * @see_also: rgvolume + * + * + * + * This element applies signal compression/limiting to raw audio data. It + * performs strict hard limiting with soft-knee characteristics, using a + * threshold of -6 dB. This type of filter is mentioned in the proposed ReplayGain standard. + * + * Example launch line + * Playback of a file: + * + * gst-launch filesrc location="Filename.ext" ! decodebin ! audioconvert \ + * ! rgvolume pre-amp=6.0 headroom=10.0 ! rglimiter \ + * ! audioconvert ! audioresample ! alsasink + * + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include + +#include "gstrglimiter.h" + +GST_DEBUG_CATEGORY_STATIC (gst_rg_limiter_debug); +#define GST_CAT_DEFAULT gst_rg_limiter_debug + +enum +{ + PROP_0, + PROP_ENABLED, +}; + +static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw-float, " + "width = (int) 32, channels = (int) [1, MAX], " + "rate = (int) [1, MAX], endianness = (int) BYTE_ORDER")); + +static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw-float, " + "width = (int) 32, channels = (int) [1, MAX], " + "rate = (int) [1, MAX], endianness = (int) BYTE_ORDER")); + +GST_BOILERPLATE (GstRgLimiter, gst_rg_limiter, GstBaseTransform, + GST_TYPE_BASE_TRANSFORM); + +static void gst_rg_limiter_class_init (GstRgLimiterClass * klass); +static void gst_rg_limiter_init (GstRgLimiter * filter, + GstRgLimiterClass * gclass); + +static void gst_rg_limiter_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_rg_limiter_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); + +static GstFlowReturn gst_rg_limiter_transform_ip (GstBaseTransform * base, + GstBuffer * buf); + +static const GstElementDetails element_details = { + "ReplayGain limiter", + "Filter/Effect/Audio", + "Apply signal compression to raw audio data", + "Ren\xc3\xa9 Stadler " +}; + +static void +gst_rg_limiter_base_init (gpointer g_class) +{ + GstElementClass *element_class = g_class; + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&src_factory)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&sink_factory)); + gst_element_class_set_details (element_class, &element_details); + + GST_DEBUG_CATEGORY_INIT (gst_rg_limiter_debug, "rglimiter", 0, + "ReplayGain limiter element"); +} + +static void +gst_rg_limiter_class_init (GstRgLimiterClass * klass) +{ + GObjectClass *gobject_class; + GstBaseTransformClass *trans_class; + + gobject_class = (GObjectClass *) klass; + + gobject_class->set_property = gst_rg_limiter_set_property; + gobject_class->get_property = gst_rg_limiter_get_property; + + g_object_class_install_property (gobject_class, PROP_ENABLED, + g_param_spec_boolean ("enabled", "Enabled", "Enable processing", TRUE, + G_PARAM_READWRITE)); + + trans_class = GST_BASE_TRANSFORM_CLASS (klass); + trans_class->transform_ip = GST_DEBUG_FUNCPTR (gst_rg_limiter_transform_ip); + trans_class->passthrough_on_same_caps = FALSE; +} + +static void +gst_rg_limiter_init (GstRgLimiter * filter, GstRgLimiterClass * gclass) +{ + filter->enabled = TRUE; + gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (filter), FALSE); +} + +static void +gst_rg_limiter_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstRgLimiter *filter = GST_RG_LIMITER (object); + + switch (prop_id) { + case PROP_ENABLED: + filter->enabled = g_value_get_boolean (value); + gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (filter), + !filter->enabled); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_rg_limiter_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstRgLimiter *filter = GST_RG_LIMITER (object); + + switch (prop_id) { + case PROP_ENABLED: + g_value_set_boolean (value, filter->enabled); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +#define LIMIT 1.0 +#define THRES 0.5 /* ca. -6 dB */ +#define COMPL 0.5 /* LIMIT - THRESH */ + +static GstFlowReturn +gst_rg_limiter_transform_ip (GstBaseTransform * base, GstBuffer * buf) +{ + GstRgLimiter *filter = GST_RG_LIMITER (base); + gfloat *input; + guint count; + guint i; + + if (!filter->enabled) + return GST_FLOW_OK; + + input = (gfloat *) GST_BUFFER_DATA (buf); + count = GST_BUFFER_SIZE (buf) / sizeof (gfloat); + + for (i = count; i--;) { + if (*input > THRES) + *input = tanhf ((*input - THRES) / COMPL) * COMPL + THRES; + else if (*input < -THRES) + *input = tanhf ((*input + THRES) / COMPL) * COMPL - THRES; + input++; + } + + return GST_FLOW_OK; +} diff --git a/gst/replaygain/gstrglimiter.h b/gst/replaygain/gstrglimiter.h new file mode 100644 index 00000000..63bd8049 --- /dev/null +++ b/gst/replaygain/gstrglimiter.h @@ -0,0 +1,64 @@ +/* GStreamer ReplayGain limiter + * + * Copyright (C) 2007 Rene Stadler + * + * gstrglimiter.h: Element to apply signal compression to raw audio data + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + +#ifndef __GST_RG_LIMITER_H__ +#define __GST_RG_LIMITER_H__ + +#include +#include + +#define GST_TYPE_RG_LIMITER \ + (gst_rg_limiter_get_type()) +#define GST_RG_LIMITER(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RG_LIMITER,GstRgLimiter)) +#define GST_RG_LIMITER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RG_LIMITER,GstRgLimiterClass)) +#define GST_IS_RG_LIMITER(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RG_LIMITER)) +#define GST_IS_RG_LIMITER_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RG_LIMITER)) + +typedef struct _GstRgLimiter GstRgLimiter; +typedef struct _GstRgLimiterClass GstRgLimiterClass; + +/** + * GstRgLimiter: + * + * Opaque data structure. + */ +struct _GstRgLimiter +{ + GstBaseTransform element; + + /*< private >*/ + + gboolean enabled; +}; + +struct _GstRgLimiterClass +{ + GstBaseTransformClass parent_class; +}; + +GType gst_rg_limiter_get_type (void); + +#endif /* __GST_RG_LIMITER_H__ */ diff --git a/gst/replaygain/gstrgvolume.c b/gst/replaygain/gstrgvolume.c new file mode 100644 index 00000000..35b4f5ef --- /dev/null +++ b/gst/replaygain/gstrgvolume.c @@ -0,0 +1,702 @@ +/* GStreamer ReplayGain volume adjustment + * + * Copyright (C) 2007 Rene Stadler + * + * gstrgvolume.c: Element to apply ReplayGain volume adjustment + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + +/** + * SECTION:element-rgvolume + * @see_also: rglimiter, + * rganalysis + * + * + * + * This element applies volume changes to streams as lined out in the proposed + * ReplayGain standard. It + * interprets the ReplayGain meta data tags and carries out the adjustment (by + * using a volume element internally). The relevant tags are: + * + * #GST_TAG_TRACK_GAIN + * #GST_TAG_TRACK_PEAK + * #GST_TAG_ALBUM_GAIN + * #GST_TAG_ALBUM_PEAK + * #GST_TAG_REFERENCE_LEVEL + * + * The information carried by these tags must have been calculated beforehand by + * performing the ReplayGain analysis. This is implemented by the rganalysis element. + * + * + * The signal compression/limiting recommendations outlined in the proposed + * standard are not implemented by this element. This has to be handled by + * separate elements because applications might want to have additional filters + * between the volume adjustment and the limiting stage. A basic limiter is + * included with this plugin: The rglimiter + * element applies -6 dB hard limiting as mentioned in the ReplayGain standard. + * + * Example launch line + * Playback of a file: + * + * gst-launch filesrc location="Filename.ext" ! decodebin ! audioconvert \ + * ! rgvolume ! audioconvert ! audioresample ! alsasink + * + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include +#include + +#include "gstrgvolume.h" +#include "replaygain.h" + +GST_DEBUG_CATEGORY_STATIC (gst_rg_volume_debug); +#define GST_CAT_DEFAULT gst_rg_volume_debug + +enum +{ + PROP_0, + PROP_ALBUM_MODE, + PROP_HEADROOM, + PROP_PRE_AMP, + PROP_FALLBACK_GAIN, + PROP_TARGET_GAIN, + PROP_RESULT_GAIN +}; + +#define DEFAULT_ALBUM_MODE TRUE +#define DEFAULT_HEADROOM 0.0 +#define DEFAULT_PRE_AMP 0.0 +#define DEFAULT_FALLBACK_GAIN 0.0 + +#define DB_TO_LINEAR(x) pow (10., (x) / 20.) +#define LINEAR_TO_DB(x) (20. * log10 (x)) + +#define GAIN_FORMAT "+.02f dB" +#define PEAK_FORMAT ".06f" + +#define VALID_GAIN(x) ((x) > -60.00 && (x) < 60.00) +#define VALID_PEAK(x) ((x) > 0.) + +/* Same template caps as GstVolume, for I don't like having just ANY caps. */ + +static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw-float, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, MAX ], " + "endianness = (int) BYTE_ORDER, " + "width = (int) 32; " + "audio/x-raw-int, " + "channels = (int) [ 1, MAX ], " + "rate = (int) [ 1, MAX ], " + "endianness = (int) BYTE_ORDER, " + "width = (int) 16, " "depth = (int) 16, " "signed = (bool) TRUE")); + +static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw-float, " + "rate = (int) [ 1, MAX ], " + "channels = (int) [ 1, MAX ], " + "endianness = (int) BYTE_ORDER, " + "width = (int) 32; " + "audio/x-raw-int, " + "channels = (int) [ 1, MAX ], " + "rate = (int) [ 1, MAX ], " + "endianness = (int) BYTE_ORDER, " + "width = (int) 16, " "depth = (int) 16, " "signed = (bool) TRUE")); + +GST_BOILERPLATE (GstRgVolume, gst_rg_volume, GstBin, GST_TYPE_BIN); + +static void gst_rg_volume_class_init (GstRgVolumeClass * klass); +static void gst_rg_volume_init (GstRgVolume * self, GstRgVolumeClass * gclass); + +static void gst_rg_volume_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_rg_volume_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); +static void gst_rg_volume_dispose (GObject * object); + +static GstStateChangeReturn gst_rg_volume_change_state (GstElement * element, + GstStateChange transition); +static gboolean gst_rg_volume_sink_event (GstPad * pad, GstEvent * event); + +static GstEvent *gst_rg_volume_tag_event (GstRgVolume * self, GstEvent * event); +static void gst_rg_volume_reset (GstRgVolume * self); +static void gst_rg_volume_update_gain (GstRgVolume * self); +static inline void gst_rg_volume_determine_gain (GstRgVolume * self, + gdouble * target_gain, gdouble * result_gain); + +static void +gst_rg_volume_base_init (gpointer g_class) +{ + GstElementClass *element_class = g_class; + + static const GstElementDetails element_details = { + "ReplayGain volume", + "Filter/Effect/Audio", + "Apply ReplayGain volume adjustment", + "Ren\xc3\xa9 Stadler " + }; + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&src_template)); + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&sink_template)); + gst_element_class_set_details (element_class, &element_details); + + GST_DEBUG_CATEGORY_INIT (gst_rg_volume_debug, "rgvolume", 0, + "ReplayGain volume element"); +} + +static void +gst_rg_volume_class_init (GstRgVolumeClass * klass) +{ + GObjectClass *gobject_class; + GstElementClass *element_class; + GstBinClass *bin_class; + + gobject_class = (GObjectClass *) klass; + + gobject_class->set_property = gst_rg_volume_set_property; + gobject_class->get_property = gst_rg_volume_get_property; + gobject_class->dispose = gst_rg_volume_dispose; + + /** + * GstRgVolume:album-mode: + * + * Whether to prefer album gain over track gain. + * + * If set to %TRUE, use album gain instead of track gain if both are + * available. This keeps the relative loudness levels of tracks from the same + * album intact. + * + * If set to %FALSE, track mode is used instead. This effectively leads to + * more extensive normalization. + * + * If album mode is enabled but the album gain tag is absent in the stream, + * the track gain is used instead. If both gain tags are missing, the value + * of the fallback-gain + * property is used instead. + */ + g_object_class_install_property (gobject_class, PROP_ALBUM_MODE, + g_param_spec_boolean ("album-mode", "Album mode", + "Prefer album over track gain", DEFAULT_ALBUM_MODE, + G_PARAM_READWRITE)); + /** + * GstRgVolume:headroom: + * + * Extra headroom [dB]. This controls the amount by which the output can + * exceed digital full scale. + * + * Only set this to a value greater than 0.0 if signal compression/limiting of + * a suitable form is applied to the output (or output is brought into the + * correct range by some other transformation). + * + * This element internally uses a volume element, which also supports + * operating on integer audio formats. These formats do not allow exceeding + * digital full scale. If extra headroom is used, make sure that the raw + * audio data format is floating point (audio/x-raw-float). Otherwise, + * clipping distortion might be introduced as part of the volume adjustment + * itself. + */ + g_object_class_install_property (gobject_class, PROP_HEADROOM, + g_param_spec_double ("headroom", "Headroom", "Extra headroom [dB]", + 0., 60., DEFAULT_HEADROOM, G_PARAM_READWRITE)); + /** + * GstRgVolume:pre-amp: + * + * Additional gain to apply globally [dB]. This controls the trade-off + * between uniformity of normalization and utilization of available dynamic + * range. + * + * Note that the default value is 0 dB because the ReplayGain reference value + * was adjusted by +6 dB (from 83 to 89 dB). At the time of this writing, the + * webpage is still outdated and + * does not reflect this change however. Where the original proposal states + * that a proper default pre-amp value is +6 dB, this translates to the used 0 + * dB. + */ + g_object_class_install_property (gobject_class, PROP_PRE_AMP, + g_param_spec_double ("pre-amp", "Pre-amp", "Extra gain [dB]", + -60., 60., DEFAULT_PRE_AMP, G_PARAM_READWRITE)); + /** + * GstRgVolume:fallback-gain: + * + * Fallback gain [dB] for streams missing ReplayGain tags. + */ + g_object_class_install_property (gobject_class, PROP_FALLBACK_GAIN, + g_param_spec_double ("fallback-gain", "Fallback gain", + "Gain for streams missing tags [dB]", + -60., 60., DEFAULT_FALLBACK_GAIN, G_PARAM_READWRITE)); + /** + * GstRgVolume:result-gain: + * + * Applied gain [dB]. This gain is applied to processed buffer data. + * + * This is set to the target + * gain if amplification by that amount can be applied safely. + * "Safely" means that the volume adjustment does not inflict clipping + * distortion. Should this not be the case, the result gain is set to an + * appropriately reduced value (by applying peak normalization). The proposed + * standard calls this "clipping prevention". + * + * The difference between target and result gain reflects the necessary amount + * of reduction. Applications can make use of this information to temporarily + * reduce the pre-amp for + * subsequent streams, as recommended by the ReplayGain standard. + * + * Note that target and result gain differing for a great majority of streams + * indicates a problem: What happens in this case is that most streams receive + * peak normalization instead of amplification by the ideal replay gain. To + * prevent this, the pre-amp has + * to be lowered and/or a limiter has to be used which facilitates the use of + * headroom. + */ + g_object_class_install_property (gobject_class, PROP_RESULT_GAIN, + g_param_spec_double ("result-gain", "Result-gain", "Applied gain [dB]", + -120., 120., 0., G_PARAM_READABLE)); + /** + * GstRgVolume:target-gain: + * + * Applicable gain [dB]. This gain is supposed to be applied. + * + * Depending on the value of the album-mode property and the + * presence of ReplayGain tags in the stream, this is set according to one of + * these simple formulas: + * + * + * pre-amp + album gain + * of the stream + * pre-amp + track gain + * of the stream + * pre-amp + fallback gain + * + */ + g_object_class_install_property (gobject_class, PROP_TARGET_GAIN, + g_param_spec_double ("target-gain", "Target-gain", + "Applicable gain [dB]", -120., 120., 0., G_PARAM_READABLE)); + + element_class = (GstElementClass *) klass; + element_class->change_state = GST_DEBUG_FUNCPTR (gst_rg_volume_change_state); + + bin_class = (GstBinClass *) klass; + /* Setting these to NULL makes gst_bin_add and _remove refuse to let anyone + * mess with our internals. */ + bin_class->add_element = NULL; + bin_class->remove_element = NULL; +} + +static void +gst_rg_volume_init (GstRgVolume * self, GstRgVolumeClass * gclass) +{ + GObjectClass *volume_class; + GstPad *volume_pad, *ghost_pad; + + self->album_mode = DEFAULT_ALBUM_MODE; + self->headroom = DEFAULT_HEADROOM; + self->pre_amp = DEFAULT_PRE_AMP; + self->fallback_gain = DEFAULT_FALLBACK_GAIN; + self->target_gain = 0.0; + self->result_gain = 0.0; + + self->volume_element = gst_element_factory_make ("volume", "rgvolume-volume"); + if (G_UNLIKELY (self->volume_element == NULL)) { + GstMessage *msg; + + GST_WARNING_OBJECT (self, "could not create volume element"); + msg = gst_missing_element_message_new (GST_ELEMENT_CAST (self), "volume"); + gst_element_post_message (GST_ELEMENT_CAST (self), msg); + + /* Nothing else to do, we will refuse the state change from NULL to READY to + * indicate that something went very wrong. It is doubtful that someone + * attempts changing our state though, since we end up having no pads! */ + return; + } + + volume_class = G_OBJECT_GET_CLASS (G_OBJECT (self->volume_element)); + self->max_volume = G_PARAM_SPEC_DOUBLE + (g_object_class_find_property (volume_class, "volume"))->maximum; + + GST_BIN_CLASS (parent_class)->add_element (GST_BIN_CAST (self), + self->volume_element); + + volume_pad = gst_element_get_pad (self->volume_element, "sink"); + ghost_pad = gst_ghost_pad_new_from_template ("sink", volume_pad, + gst_pad_get_pad_template (volume_pad)); + gst_object_unref (volume_pad); + gst_pad_set_event_function (ghost_pad, gst_rg_volume_sink_event); + gst_element_add_pad (GST_ELEMENT_CAST (self), ghost_pad); + + volume_pad = gst_element_get_pad (self->volume_element, "src"); + ghost_pad = gst_ghost_pad_new_from_template ("src", volume_pad, + gst_pad_get_pad_template (volume_pad)); + gst_object_unref (volume_pad); + gst_element_add_pad (GST_ELEMENT_CAST (self), ghost_pad); +} + +static void +gst_rg_volume_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstRgVolume *self = GST_RG_VOLUME (object); + + switch (prop_id) { + case PROP_ALBUM_MODE: + self->album_mode = g_value_get_boolean (value); + break; + case PROP_HEADROOM: + self->headroom = g_value_get_double (value); + break; + case PROP_PRE_AMP: + self->pre_amp = g_value_get_double (value); + break; + case PROP_FALLBACK_GAIN: + self->fallback_gain = g_value_get_double (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } + + gst_rg_volume_update_gain (self); +} + +static void +gst_rg_volume_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstRgVolume *self = GST_RG_VOLUME (object); + + switch (prop_id) { + case PROP_ALBUM_MODE: + g_value_set_boolean (value, self->album_mode); + break; + case PROP_HEADROOM: + g_value_set_double (value, self->headroom); + break; + case PROP_PRE_AMP: + g_value_set_double (value, self->pre_amp); + break; + case PROP_FALLBACK_GAIN: + g_value_set_double (value, self->fallback_gain); + break; + case PROP_TARGET_GAIN: + g_value_set_double (value, self->target_gain); + break; + case PROP_RESULT_GAIN: + g_value_set_double (value, self->result_gain); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gst_rg_volume_dispose (GObject * object) +{ + GstRgVolume *self = GST_RG_VOLUME (object); + + if (self->volume_element != NULL) { + /* Manually remove our child using the bin implementation of remove_element. + * This is needed because we prevent gst_bin_remove from working, which the + * parent dispose handler would use if we had any children left. */ + GST_BIN_CLASS (parent_class)->remove_element (GST_BIN_CAST (self), + self->volume_element); + self->volume_element = NULL; + } + + G_OBJECT_CLASS (parent_class)->dispose (object); +} + +static GstStateChangeReturn +gst_rg_volume_change_state (GstElement * element, GstStateChange transition) +{ + GstRgVolume *self = GST_RG_VOLUME (element); + GstStateChangeReturn res; + + switch (transition) { + case GST_STATE_CHANGE_NULL_TO_READY: + + if (G_UNLIKELY (self->volume_element == NULL)) { + /* Creating our child volume element in _init failed. */ + return GST_STATE_CHANGE_FAILURE; + } + break; + + case GST_STATE_CHANGE_READY_TO_PAUSED: + + gst_rg_volume_reset (self); + break; + + default: + break; + } + + res = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition); + + return res; +} + +/* Event function for the ghost sink pad. */ +static gboolean +gst_rg_volume_sink_event (GstPad * pad, GstEvent * event) +{ + GstRgVolume *self; + GstPad *volume_sink_pad; + GstEvent *send_event = event; + gboolean res; + + self = GST_RG_VOLUME (gst_pad_get_parent_element (pad)); + volume_sink_pad = gst_ghost_pad_get_target (GST_GHOST_PAD (pad)); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_TAG: + + GST_LOG_OBJECT (self, "received tag event"); + + send_event = gst_rg_volume_tag_event (self, event); + + if (send_event == NULL) + GST_LOG_OBJECT (self, "all tags handled, dropping event"); + + break; + + case GST_EVENT_EOS: + + gst_rg_volume_reset (self); + break; + + default: + break; + } + + if (G_LIKELY (send_event != NULL)) + res = gst_pad_send_event (volume_sink_pad, send_event); + else + res = TRUE; + + gst_object_unref (volume_sink_pad); + gst_object_unref (self); + return res; +} + +static GstEvent * +gst_rg_volume_tag_event (GstRgVolume * self, GstEvent * event) +{ + GstTagList *tag_list; + gboolean has_track_gain, has_track_peak, has_album_gain, has_album_peak; + gboolean has_ref_level; + + g_return_val_if_fail (event != NULL, NULL); + g_return_val_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_TAG, event); + + gst_event_parse_tag (event, &tag_list); + + if (gst_tag_list_is_empty (tag_list)) + return event; + + has_track_gain = gst_tag_list_get_double (tag_list, GST_TAG_TRACK_GAIN, + &self->track_gain); + has_track_peak = gst_tag_list_get_double (tag_list, GST_TAG_TRACK_PEAK, + &self->track_peak); + has_album_gain = gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_GAIN, + &self->album_gain); + has_album_peak = gst_tag_list_get_double (tag_list, GST_TAG_ALBUM_PEAK, + &self->album_peak); + has_ref_level = gst_tag_list_get_double (tag_list, GST_TAG_REFERENCE_LEVEL, + &self->reference_level); + + if (!has_track_gain && !has_track_peak && !has_album_gain && !has_album_peak) + return event; + + if (has_ref_level && (has_track_gain || has_album_gain) + && (ABS (self->reference_level - RG_REFERENCE_LEVEL) > 1.e-6)) { + /* Log a message stating the amount of adjustment that is applied below. */ + GST_DEBUG_OBJECT (self, + "compensating for reference level difference by %" GAIN_FORMAT, + RG_REFERENCE_LEVEL - self->reference_level); + } + if (has_track_gain) { + self->track_gain += RG_REFERENCE_LEVEL - self->reference_level; + } + if (has_album_gain) { + self->album_gain += RG_REFERENCE_LEVEL - self->reference_level; + } + + /* Ignore values that are obviously invalid. */ + if (G_UNLIKELY (has_track_gain && !VALID_GAIN (self->track_gain))) { + GST_DEBUG_OBJECT (self, + "ignoring bogus track gain value %" GAIN_FORMAT, self->track_gain); + has_track_gain = FALSE; + } + if (G_UNLIKELY (has_track_peak && !VALID_PEAK (self->track_peak))) { + GST_DEBUG_OBJECT (self, + "ignoring bogus track peak value %" PEAK_FORMAT, self->track_peak); + has_track_peak = FALSE; + } + if (G_UNLIKELY (has_album_gain && !VALID_GAIN (self->album_gain))) { + GST_DEBUG_OBJECT (self, + "ignoring bogus album gain value %" GAIN_FORMAT, self->album_gain); + has_album_gain = FALSE; + } + if (G_UNLIKELY (has_album_peak && !VALID_PEAK (self->album_peak))) { + GST_DEBUG_OBJECT (self, + "ignoring bogus album peak value %" PEAK_FORMAT, self->album_peak); + has_album_peak = FALSE; + } + + self->has_track_gain |= has_track_gain; + self->has_track_peak |= has_track_peak; + self->has_album_gain |= has_album_gain; + self->has_album_peak |= has_album_peak; + + event = (GstEvent *) gst_mini_object_make_writable (GST_MINI_OBJECT (event)); + gst_event_parse_tag (event, &tag_list); + + gst_tag_list_remove_tag (tag_list, GST_TAG_TRACK_GAIN); + gst_tag_list_remove_tag (tag_list, GST_TAG_TRACK_PEAK); + gst_tag_list_remove_tag (tag_list, GST_TAG_ALBUM_GAIN); + gst_tag_list_remove_tag (tag_list, GST_TAG_ALBUM_PEAK); + gst_tag_list_remove_tag (tag_list, GST_TAG_REFERENCE_LEVEL); + + gst_rg_volume_update_gain (self); + + if (gst_tag_list_is_empty (tag_list)) { + gst_event_unref (event); + event = NULL; + } + + return event; +} + +static void +gst_rg_volume_reset (GstRgVolume * self) +{ + self->has_track_gain = FALSE; + self->has_track_peak = FALSE; + self->has_album_gain = FALSE; + self->has_album_peak = FALSE; + + self->reference_level = RG_REFERENCE_LEVEL; + + gst_rg_volume_update_gain (self); +} + +static void +gst_rg_volume_update_gain (GstRgVolume * self) +{ + gdouble target_gain, result_gain, result_volume; + gboolean target_gain_changed, result_gain_changed; + + gst_rg_volume_determine_gain (self, &target_gain, &result_gain); + + result_volume = DB_TO_LINEAR (result_gain); + + /* Ensure that the result volume is within the range that the volume element + * can handle. Currently, the limit is 10. (+20 dB), which should not be + * restrictive. */ + if (G_UNLIKELY (result_volume > self->max_volume)) { + GST_INFO_OBJECT (self, + "cannot handle result gain of %" GAIN_FORMAT " (%0.6f), adjusting", + result_gain, result_volume); + + result_volume = self->max_volume; + result_gain = LINEAR_TO_DB (result_volume); + } + + /* Direct comparison is OK in this case. */ + if (target_gain == result_gain) { + GST_INFO_OBJECT (self, + "result gain is %" GAIN_FORMAT " (%0.6f), matching target", + result_gain, result_volume); + } else { + GST_INFO_OBJECT (self, + "result gain is %" GAIN_FORMAT " (%0.6f), target is %" GAIN_FORMAT, + result_gain, result_volume, target_gain); + } + + target_gain_changed = (self->target_gain != target_gain); + result_gain_changed = (self->result_gain != result_gain); + + self->target_gain = target_gain; + self->result_gain = result_gain; + + g_object_set (self->volume_element, "volume", result_volume, NULL); + + if (target_gain_changed) + g_object_notify ((GObject *) self, "target-gain"); + if (result_gain_changed) + g_object_notify ((GObject *) self, "result-gain"); +} + +static inline void +gst_rg_volume_determine_gain (GstRgVolume * self, gdouble * target_gain, + gdouble * result_gain) +{ + gdouble gain, peak; + + if (!self->has_track_gain && !self->has_album_gain) { + + GST_DEBUG_OBJECT (self, "using fallback gain"); + gain = self->fallback_gain; + peak = 1.0; + + } else if ((self->album_mode && self->has_album_gain) + || (!self->album_mode && !self->has_track_gain)) { + + gain = self->album_gain; + if (G_LIKELY (self->has_album_peak)) { + peak = self->album_peak; + } else { + GST_DEBUG_OBJECT (self, "album peak missing, assuming 1.0"); + peak = 1.0; + } + /* Falling back from track to album gain shouldn't really happen. */ + if (G_UNLIKELY (!self->album_mode)) + GST_INFO_OBJECT (self, "falling back to album gain"); + + } else { + /* !album_mode && !has_album_gain || album_mode && has_track_gain */ + + gain = self->track_gain; + if (G_LIKELY (self->has_track_peak)) { + peak = self->track_peak; + } else { + GST_DEBUG_OBJECT (self, "track peak missing, assuming 1.0"); + peak = 1.0; + } + if (self->album_mode) + GST_INFO_OBJECT (self, "falling back to track gain"); + } + + gain += self->pre_amp; + + *target_gain = gain; + *result_gain = gain; + + if (LINEAR_TO_DB (peak) + gain > self->headroom) { + *result_gain = LINEAR_TO_DB (1. / peak) + self->headroom; + } +} diff --git a/gst/replaygain/gstrgvolume.h b/gst/replaygain/gstrgvolume.h new file mode 100644 index 00000000..8fc29614 --- /dev/null +++ b/gst/replaygain/gstrgvolume.h @@ -0,0 +1,88 @@ +/* GStreamer ReplayGain volume adjustment + * + * Copyright (C) 2007 Rene Stadler + * + * gstrgvolume.h: Element to apply ReplayGain volume adjustment + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + +#ifndef __GST_RG_VOLUME_H__ +#define __GST_RG_VOLUME_H__ + +#include + +G_BEGIN_DECLS + +#define GST_TYPE_RG_VOLUME \ + (gst_rg_volume_get_type()) +#define GST_RG_VOLUME(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_RG_VOLUME,GstRgVolume)) +#define GST_RG_VOLUME_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_RG_VOLUME,GstRgVolumeClass)) +#define GST_IS_PLUGIN_TEMPLATE(obj) \ + (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_RG_VOLUME)) +#define GST_IS_PLUGIN_TEMPLATE_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_RG_VOLUME)) + +typedef struct _GstRgVolume GstRgVolume; +typedef struct _GstRgVolumeClass GstRgVolumeClass; + +/** + * GstRgVolume: + * + * Opaque data structure. + */ +struct _GstRgVolume +{ + GstBin bin; + + /*< private >*/ + + GstElement *volume_element; + gdouble max_volume; + + gboolean album_mode; + gdouble headroom; + gdouble pre_amp; + gdouble fallback_gain; + + gdouble target_gain; + gdouble result_gain; + + gdouble track_gain; + gdouble track_peak; + gdouble album_gain; + gdouble album_peak; + + gboolean has_track_gain; + gboolean has_track_peak; + gboolean has_album_gain; + gboolean has_album_peak; + + gdouble reference_level; +}; + +struct _GstRgVolumeClass +{ + GstBinClass parent_class; +}; + +GType gst_rg_volume_get_type (void); + +G_END_DECLS + +#endif /* __GST_RG_VOLUME_H__ */ diff --git a/gst/replaygain/replaygain.c b/gst/replaygain/replaygain.c new file mode 100644 index 00000000..d0127e8b --- /dev/null +++ b/gst/replaygain/replaygain.c @@ -0,0 +1,53 @@ +/* GStreamer ReplayGain plugin + * + * Copyright (C) 2006 Rene Stadler + * + * replaygain.c: Plugin providing ReplayGain related elements + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include + +#include "gstrganalysis.h" +#include "gstrglimiter.h" +#include "gstrgvolume.h" + +static gboolean +plugin_init (GstPlugin * plugin) +{ + if (!gst_element_register (plugin, "rganalysis", GST_RANK_NONE, + GST_TYPE_RG_ANALYSIS)) + return FALSE; + + if (!gst_element_register (plugin, "rglimiter", GST_RANK_NONE, + GST_TYPE_RG_LIMITER)) + return FALSE; + + if (!gst_element_register (plugin, "rgvolume", GST_RANK_NONE, + GST_TYPE_RG_VOLUME)) + return FALSE; + + return TRUE; +} + +GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, GST_VERSION_MINOR, "replaygain", + "ReplayGain volume normalization", plugin_init, VERSION, GST_LICENSE, + GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN); diff --git a/gst/replaygain/replaygain.h b/gst/replaygain/replaygain.h new file mode 100644 index 00000000..15be8885 --- /dev/null +++ b/gst/replaygain/replaygain.h @@ -0,0 +1,36 @@ +/* GStreamer ReplayGain plugin + * + * Copyright (C) 2006 Rene Stadler + * + * replaygain.h: Plugin providing ReplayGain related elements + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + +#ifndef __REPLAYGAIN_H__ +#define __REPLAYGAIN_H__ + +G_BEGIN_DECLS + +/* Reference level (in dBSPL). The 2001 proposal specifies 83. This was + * changed later in all implementations to 89, which is the new, offical value: + * David Robinson acknowledged the change but didn't update the website yet. */ + +#define RG_REFERENCE_LEVEL 89. + +G_END_DECLS + +#endif /* __REPLAYGAIN_H__ */ diff --git a/gst/replaygain/rganalysis.h b/gst/replaygain/rganalysis.h index 39bf9b41..16247361 100644 --- a/gst/replaygain/rganalysis.h +++ b/gst/replaygain/rganalysis.h @@ -29,8 +29,6 @@ G_BEGIN_DECLS -#define RG_REFERENCE_LEVEL 89. - typedef struct _RgAnalysisCtx RgAnalysisCtx; RgAnalysisCtx *rg_analysis_new (void); -- cgit v1.2.1