summaryrefslogtreecommitdiffstats
path: root/gst/replaygain
diff options
context:
space:
mode:
authorRené Stadler <mail@renestadler.de>2007-05-19 10:01:45 +0000
committerTim-Philipp Müller <tim@centricular.net>2007-05-19 10:01:45 +0000
commit1645110f020d26eaa9700775dbedf646918fdd23 (patch)
treee58b53d9e4dd90f1e2b129bee0851a9695258950 /gst/replaygain
parent8d971fb7fab676c42e2bc64f4f0a5e633591ec72 (diff)
downloadgst-plugins-bad-1645110f020d26eaa9700775dbedf646918fdd23.tar.gz
gst-plugins-bad-1645110f020d26eaa9700775dbedf646918fdd23.tar.bz2
gst-plugins-bad-1645110f020d26eaa9700775dbedf646918fdd23.zip
Add replaygain playback elements (#412710).
Original commit message from CVS: Patch by: René Stadler <mail at renestadler de> * 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).
Diffstat (limited to 'gst/replaygain')
-rw-r--r--gst/replaygain/Makefile.am12
-rw-r--r--gst/replaygain/gstrganalysis.c298
-rw-r--r--gst/replaygain/gstrganalysis.h2
-rw-r--r--gst/replaygain/gstrglimiter.c197
-rw-r--r--gst/replaygain/gstrglimiter.h64
-rw-r--r--gst/replaygain/gstrgvolume.c702
-rw-r--r--gst/replaygain/gstrgvolume.h88
-rw-r--r--gst/replaygain/replaygain.c53
-rw-r--r--gst/replaygain/replaygain.h36
-rw-r--r--gst/replaygain/rganalysis.h2
10 files changed, 1302 insertions, 152 deletions
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: <link linkend="GstRgVolume">rgvolume</link>
*
* <refsect2>
* <para>
- * GstRgAnalysis analyzes raw audio sample data in accordance with the
- * proposed <ulink url="http://replaygain.org">ReplayGain
- * standard</ulink> 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
+ * <ulink url="http://replaygain.org">ReplayGain standard</ulink> 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.
* </para>
- * <title>Album processing</title>
* <para>
- * 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 <link
- * linkend="GstRgAnalysis--num-tracks">num-tracks</link> 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.
- * </para>
- * <title>Skipping processing</title>
- * <para>
- * 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 <link
- * linkend="GstRgAnalysis--forced">forced</link> 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.
- * </para>
- * <title>Tips</title>
- * <itemizedlist>
- * <listitem><para>
- * 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.
- * </para></listitem>
- * <listitem><para>
- * 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.
- * </para></listitem>
- * <listitem><para>
- * 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.
- * </para></listitem>
- * </itemizedlist>
- * <title>Compliance</title>
- * <para>
- * 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 <link
- * linkend="GstRgAnalysis--reference-level">reference-level</link>
- * 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 <link linkend="GstRgAnalysis--num-tracks">album processing</link>
+ * since the album gain and peak values need to be associated with all tracks of
+ * an album, not just the last one.
* </para>
* <title>Example launch lines</title>
* <para>Analyze a simple test waveform:</para>
@@ -127,18 +53,26 @@
* </programlisting>
* <para>Analyze a given file:</para>
* <programlisting>
- * 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
* </programlisting>
* <para>Analyze the pink noise reference file:</para>
* <programlisting>
- * 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
* </programlisting>
+ * <para>
+ * 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 <link
+ * linkend="GstRgAnalysis--reference-level">reference-level</link> property
+ * documentation for more information.
+ * </para>
* <title>Acknowledgements</title>
* <para>
* This element is based on code used in the <ulink
- * url="http://sjeng.org/vorbisgain.html">vorbisgain</ulink> program
- * and many others. The relevant parts are copyrighted by David
- * Robinson, Glen Sawyer and Frank Klemm.
+ * url="http://sjeng.org/vorbisgain.html">vorbisgain</ulink> program and many
+ * others. The relevant parts are copyrighted by David Robinson, Glen Sawyer
+ * and Frank Klemm.
* </para>
* </refsect2>
*/
@@ -147,11 +81,11 @@
#include <config.h>
#endif
-#include <string.h>
#include <gst/gst.h>
#include <gst/base/gstbasetransform.h>
#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 <link linkend="GstRgAnalysis--num-tracks">album
+ * processing</link>, 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 <ulink
+ * url="http://replaygain.org">webpage</ulink> 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 <mail@renestadler.de>
+ *
+ * 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: <link linkend="GstRgVolume">rgvolume</link>
+ *
+ * <refsect2>
+ * <para>
+ * 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 <ulink
+ * url="http://replaygain.org">ReplayGain standard</ulink>.
+ * </para>
+ * <title>Example launch line</title>
+ * <para>Playback of a file:</para>
+ * <programlisting>
+ * gst-launch filesrc location="Filename.ext" ! decodebin ! audioconvert \
+ * ! rgvolume pre-amp=6.0 headroom=10.0 ! rglimiter \
+ * ! audioconvert ! audioresample ! alsasink
+ * </programlisting>
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gst/gst.h>
+#include <math.h>
+
+#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 <mail@renestadler.de>"
+};
+
+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 <mail@renestadler.de>
+ *
+ * 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 <gst/gst.h>
+#include <gst/base/gstbasetransform.h>
+
+#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 <mail@renestadler.de>
+ *
+ * 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: <link linkend="GstRgLimiter">rglimiter</link>,
+ * <link linkend="GstRgAnalysis">rganalysis</link>
+ *
+ * <refsect2>
+ * <para>
+ * This element applies volume changes to streams as lined out in the proposed
+ * <ulink url="http://replaygain.org">ReplayGain standard</ulink>. It
+ * interprets the ReplayGain meta data tags and carries out the adjustment (by
+ * using a volume element internally). The relevant tags are:
+ * <itemizedlist>
+ * <listitem>#GST_TAG_TRACK_GAIN</listitem>
+ * <listitem>#GST_TAG_TRACK_PEAK</listitem>
+ * <listitem>#GST_TAG_ALBUM_GAIN</listitem>
+ * <listitem>#GST_TAG_ALBUM_PEAK</listitem>
+ * <listitem>#GST_TAG_REFERENCE_LEVEL</listitem>
+ * </itemizedlist>
+ * The information carried by these tags must have been calculated beforehand by
+ * performing the ReplayGain analysis. This is implemented by the <link
+ * linkend="GstRgAnalysis">rganalysis</link> element.
+ * </para>
+ * <para>
+ * 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 <link linkend="GstRgLimiter">rglimiter</link>
+ * element applies -6 dB hard limiting as mentioned in the ReplayGain standard.
+ * </para>
+ * <title>Example launch line</title>
+ * <para>Playback of a file:</para>
+ * <programlisting>
+ * gst-launch filesrc location="Filename.ext" ! decodebin ! audioconvert \
+ * ! rgvolume ! audioconvert ! audioresample ! alsasink
+ * </programlisting>
+ * </refsect2>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gst/gst.h>
+#include <gst/pbutils/pbutils.h>
+#include <math.h>
+
+#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 <mail@renestadler.de>"
+ };
+
+ 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 <link linkend="GstRgVolume--fallback-gain">fallback-gain</link>
+ * 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
+ * <ulink url="http://replaygain.org">webpage</ulink> 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 <link linkend="GstRgVolume--target-gain">target
+ * gain</link> 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 <link linkend="GstRgVolume--pre-amp">pre-amp</link> 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 <link linkend="GstRgVolume--pre-amp">pre-amp</link> has
+ * to be lowered and/or a limiter has to be used which facilitates the use of
+ * <link linkend="GstRgVolume--headroom">headroom</link>.
+ */
+ 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 <link
+ * linkend="GstRgVolume--album-mode">album-mode</link> property and the
+ * presence of ReplayGain tags in the stream, this is set according to one of
+ * these simple formulas:
+ *
+ * <itemizedlist>
+ * <listitem><link linkend="GstRgVolume--pre-amp">pre-amp</link> + album gain
+ * of the stream</listitem>
+ * <listitem><link linkend="GstRgVolume--pre-amp">pre-amp</link> + track gain
+ * of the stream</listitem>
+ * <listitem><link linkend="GstRgVolume--pre-amp">pre-amp</link> + <link
+ * linkend="GstRgVolume--fallback-gain">fallback gain</link></listitem>
+ * </itemizedlist>
+ */
+ 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 <mail@renestadler.de>
+ *
+ * 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 <gst/gst.h>
+
+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 <mail@renestadler.de>
+ *
+ * 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 <config.h>
+#endif
+
+#include <gst/gst.h>
+
+#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 <mail@renestadler.de>
+ *
+ * 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);