gst/replaygain/gstrganalysis.c

   1 /* GStreamer ReplayGain analysis
   2  *
   3  * Copyright (C) 2006 Rene Stadler <mail@renestadler.de>
   4  *
   5  * gstrganalysis.c: Element that performs the ReplayGain analysis
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public License
   9  * as published by the Free Software Foundation; either version 2.1 of
  10  * the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  */
  22
  23 /**
  24  * SECTION:element-rganalysis
  25  * @see_also: #GstRgVolume
  26  *
  27  * This element analyzes raw audio sample data in accordance with the proposed
  28  * <ulink url="http://replaygain.org">ReplayGain standard</ulink> for
  29  * calculating the ideal replay gain for music tracks and albums.  The element
  30  * is designed as a pass-through filter that never modifies any data.  As it
  31  * receives an EOS event, it finalizes the ongoing analysis and generates a tag
  32  * list containing the results.  It is sent downstream with a tag event and
  33  * posted on the message bus with a tag message.  The EOS event is forwarded as
  34  * normal afterwards.  Result tag lists at least contain the tags
  35  * #GST_TAG_TRACK_GAIN, #GST_TAG_TRACK_PEAK and #GST_TAG_REFERENCE_LEVEL.
  36  *
  37  * Because the generated metadata tags become available at the end of streams,
  38  * downstream muxer and encoder elements are normally unable to save them in
  39  * their output since they generally save metadata in the file header.
  40  * Therefore, it is often necessary that applications read the results in a bus
  41  * event handler for the tag message.  Obtaining the values this way is always
  42  * needed for <link linkend="GstRgAnalysis--num-tracks">album processing</link>
  43  * since the album gain and peak values need to be associated with all tracks of
  44  * an album, not just the last one.
  45  *
  46  * <refsect2>
  47  * <title>Example launch lines</title>
  48  * |[
  49  * gst-launch -t audiotestsrc wave=sine num-buffers=512 ! rganalysis ! fakesink
  50  * ]| Analyze a simple test waveform
  51  * |[
  52  * gst-launch -t filesrc location=filename.ext ! decodebin \
  53  *     ! audioconvert ! audioresample ! rganalysis ! fakesink
  54  * ]| Analyze a given file
  55  * |[
  56  * gst-launch -t gnomevfssrc location=http://replaygain.hydrogenaudio.org/ref_pink.wav \
  57  *     ! wavparse ! rganalysis ! fakesink
  58  * ]| Analyze the pink noise reference file
  59  * <para>
  60  * The above launch line yields a result gain of +6 dB (instead of the expected
  61  * +0 dB).  This is not in error, refer to the #GstRgAnalysis:reference-level
  62  * property documentation for more information.
  63  * </para>
  64  * </refsect2>
  65  * <refsect2>
  66  * <title>Acknowledgements</title>
  67  * <para>
  68  * This element is based on code used in the <ulink
  69  * url="http://sjeng.org/vorbisgain.html">vorbisgain</ulink> program and many
  70  * others.  The relevant parts are copyrighted by David Robinson, Glen Sawyer
  71  * and Frank Klemm.
  72  * </para>
  73  * </refsect2>
  74  */
  75
  76 #ifdef HAVE_CONFIG_H
  77 #include <config.h>
  78 #endif
  79
  80 #include <gst/gst.h>
  81 #include <gst/base/gstbasetransform.h>
  82
  83 #include "gstrganalysis.h"
  84 #include "replaygain.h"
  85
  86 GST_DEBUG_CATEGORY_STATIC (gst_rg_analysis_debug);
  87 #define GST_CAT_DEFAULT gst_rg_analysis_debug
  88
  89 /* Default property value. */
  90 #define FORCED_DEFAULT TRUE
  91 #define DEFAULT_MESSAGE FALSE
  92
  93 enum
  94 {
  95   PROP_0,
  96   PROP_NUM_TRACKS,
  97   PROP_FORCED,
  98   PROP_REFERENCE_LEVEL,
  99   PROP_MESSAGE
 100 };
 101
 102 /* The ReplayGain algorithm is intended for use with mono and stereo
 103  * audio.  The used implementation has filter coefficients for the
 104  * "usual" sample rates in the 8000 to 48000 Hz range. */
 105 #define REPLAY_GAIN_CAPS                                                \
 106   "channels = (int) { 1, 2 }, "                                         \
 107   "rate = (int) { 8000, 11025, 12000, 16000, 22050, 24000, 32000, "     \
 108   "44100, 48000 }"
 109
 110 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
 111     GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw-float, "
 112         "width = (int) 32, " "endianness = (int) BYTE_ORDER, "
 113         REPLAY_GAIN_CAPS "; "
 114         "audio/x-raw-int, "
 115         "width = (int) 16, " "depth = (int) [ 1, 16 ], "
 116         "signed = (boolean) true, " "endianness = (int) BYTE_ORDER, "
 117         REPLAY_GAIN_CAPS));
 118
 119 static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
 120     GST_PAD_SRC, GST_PAD_ALWAYS, GST_STATIC_CAPS ("audio/x-raw-float, "
 121         "width = (int) 32, " "endianness = (int) BYTE_ORDER, "
 122         REPLAY_GAIN_CAPS "; "
 123         "audio/x-raw-int, "
 124         "width = (int) 16, " "depth = (int) [ 1, 16 ], "
 125         "signed = (boolean) true, " "endianness = (int) BYTE_ORDER, "
 126         REPLAY_GAIN_CAPS));
 127
 128 #define gst_rg_analysis_parent_class parent_class
 129 G_DEFINE_TYPE (GstRgAnalysis, gst_rg_analysis, GST_TYPE_BASE_TRANSFORM);
 130
 131 static void gst_rg_analysis_set_property (GObject * object, guint prop_id,
 132     const GValue * value, GParamSpec * pspec);
 133 static void gst_rg_analysis_get_property (GObject * object, guint prop_id,
 134     GValue * value, GParamSpec * pspec);
 135
 136 static gboolean gst_rg_analysis_start (GstBaseTransform * base);
 137 static gboolean gst_rg_analysis_set_caps (GstBaseTransform * base,
 138     GstCaps * incaps, GstCaps * outcaps);
 139 static GstFlowReturn gst_rg_analysis_transform_ip (GstBaseTransform * base,
 140     GstBuffer * buf);
 141 static gboolean gst_rg_analysis_sink_event (GstBaseTransform * base,
 142     GstEvent * event);
 143 static gboolean gst_rg_analysis_stop (GstBaseTransform * base);
 144
 145 static void gst_rg_analysis_handle_tags (GstRgAnalysis * filter,
 146     const GstTagList * tag_list);
 147 static void gst_rg_analysis_handle_eos (GstRgAnalysis * filter);
 148 static gboolean gst_rg_analysis_track_result (GstRgAnalysis * filter,
 149     GstTagList ** tag_list);
 150 static gboolean gst_rg_analysis_album_result (GstRgAnalysis * filter,
 151     GstTagList ** tag_list);
 152
 153 static void
 154 gst_rg_analysis_class_init (GstRgAnalysisClass * klass)
 155 {
 156   GObjectClass *gobject_class;
 157   GstElementClass *element_class;
 158   GstBaseTransformClass *trans_class;
 159
 160   gobject_class = (GObjectClass *) klass;
 161   element_class = (GstElementClass *) klass;
 162
 163   gobject_class->set_property = gst_rg_analysis_set_property;
 164   gobject_class->get_property = gst_rg_analysis_get_property;
 165
 166   /**
 167    * GstRgAnalysis:num-tracks:
 168    *
 169    * Number of remaining album tracks.
 170    *
 171    * Analyzing several streams sequentially and assigning them a common result
 172    * gain is known as "album processing".  If this gain is used during playback
 173    * (by switching to "album mode"), all tracks of an album receive the same
 174    * amplification.  This keeps the relative volume levels between the tracks
 175    * intact.  To enable this, set this property to the number of streams that
 176    * will be processed as album tracks.
 177    *
 178    * Every time an EOS event is received, the value of this property is
 179    * decremented by one.  As it reaches zero, it is assumed that the last track
 180    * of the album finished.  The tag list for the final stream will contain the
 181    * additional tags #GST_TAG_ALBUM_GAIN and #GST_TAG_ALBUM_PEAK.  All other
 182    * streams just get the two track tags posted because the values for the album
 183    * tags are not known before all tracks are analyzed.  Applications need to
 184    * ensure that the album gain and peak values are also associated with the
 185    * other tracks when storing the results.
 186    *
 187    * If the total number of album tracks is unknown beforehand, just ensure that
 188    * the value is greater than 1 before each track starts.  Then before the end
 189    * of the last track, set it to the value 1.
 190    *
 191    * To perform album processing, the element has to preserve data between
 192    * streams.  This cannot survive a state change to the NULL or READY state.
 193    * If you change your pipeline's state to NULL or READY between tracks, lock
 194    * the element's state using gst_element_set_locked_state() when it is in
 195    * PAUSED or PLAYING.
 196    */
 197   g_object_class_install_property (gobject_class, PROP_NUM_TRACKS,
 198       g_param_spec_int ("num-tracks", "Number of album tracks",
 199           "Number of remaining album tracks", 0, G_MAXINT, 0,
 200           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 201   /**
 202    * GstRgAnalysis:forced:
 203    *
 204    * Whether to analyze streams even when ReplayGain tags exist.
 205    *
 206    * For assisting transcoder/converter applications, the element can silently
 207    * skip the processing of streams that already contain the necessary tags.
 208    * Data will flow as usual but the element will not consume CPU time and will
 209    * not generate result tags.  To enable possible skipping, set this property
 210    * to #FALSE.
 211    *
 212    * If used in conjunction with <link linkend="GstRgAnalysis--num-tracks">album
 213    * processing</link>, the element will skip the number of remaining album
 214    * tracks if a full set of tags is found for the first track.  If a subsequent
 215    * track of the album is missing tags, processing cannot start again.  If this
 216    * is undesired, the application has to scan all files beforehand and enable
 217    * forcing of processing if needed.
 218    */
 219   g_object_class_install_property (gobject_class, PROP_FORCED,
 220       g_param_spec_boolean ("forced", "Forced",
 221           "Analyze even if ReplayGain tags exist",
 222           FORCED_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 223   /**
 224    * GstRgAnalysis:reference-level:
 225    *
 226    * Reference level [dB].
 227    *
 228    * Analyzing the ReplayGain pink noise reference waveform computes a result of
 229    * +6 dB instead of the expected 0 dB.  This is because the default reference
 230    * level is 89 dB.  To obtain values as lined out in the original proposal of
 231    * ReplayGain, set this property to 83.
 232    *
 233    * Almost all software uses 89 dB as a reference however, and this value has
 234    * become the new official value.  That is to say, while the change has been
 235    * acclaimed by the author of the ReplayGain proposal, the <ulink
 236    * url="http://replaygain.org">webpage</ulink> is still outdated at the time
 237    * of this writing.
 238    *
 239    * The value was changed because the original proposal recommends a default
 240    * pre-amp value of +6 dB for playback.  This seemed a bit odd, as it means
 241    * that the algorithm has the general tendency to produce adjustment values
 242    * that are 6 dB too low.  Bumping the reference level by 6 dB compensated for
 243    * this.
 244    *
 245    * The problem of the reference level being ambiguous for lack of concise
 246    * standardization is to be solved by adopting the #GST_TAG_REFERENCE_LEVEL
 247    * tag, which allows to store the used value alongside the gain values.
 248    */
 249   g_object_class_install_property (gobject_class, PROP_REFERENCE_LEVEL,
 250       g_param_spec_double ("reference-level", "Reference level",
 251           "Reference level [dB]", 0.0, 150., RG_REFERENCE_LEVEL,
 252           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 253
 254   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MESSAGE,
 255       g_param_spec_boolean ("message", "Message",
 256           "Post statics messages",
 257           DEFAULT_MESSAGE,
 258           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 259
 260   trans_class = (GstBaseTransformClass *) klass;
 261   trans_class->start = GST_DEBUG_FUNCPTR (gst_rg_analysis_start);
 262   trans_class->set_caps = GST_DEBUG_FUNCPTR (gst_rg_analysis_set_caps);
 263   trans_class->transform_ip = GST_DEBUG_FUNCPTR (gst_rg_analysis_transform_ip);
 264   trans_class->sink_event = GST_DEBUG_FUNCPTR (gst_rg_analysis_sink_event);
 265   trans_class->stop = GST_DEBUG_FUNCPTR (gst_rg_analysis_stop);
 266   trans_class->passthrough_on_same_caps = TRUE;
 267
 268   gst_element_class_add_pad_template (element_class,
 269       gst_static_pad_template_get (&src_factory));
 270   gst_element_class_add_pad_template (element_class,
 271       gst_static_pad_template_get (&sink_factory));
 272   gst_element_class_set_details_simple (element_class, "ReplayGain analysis",
 273       "Filter/Analyzer/Audio",
 274       "Perform the ReplayGain analysis",
 275       "Ren\xc3\xa9 Stadler <mail@renestadler.de>");
 276
 277   GST_DEBUG_CATEGORY_INIT (gst_rg_analysis_debug, "rganalysis", 0,
 278       "ReplayGain analysis element");
 279 }
 280
 281 static void
 282 gst_rg_analysis_init (GstRgAnalysis * filter)
 283 {
 284   GstBaseTransform *base = GST_BASE_TRANSFORM (filter);
 285
 286   gst_base_transform_set_gap_aware (base, TRUE);
 287
 288   filter->num_tracks = 0;
 289   filter->forced = FORCED_DEFAULT;
 290   filter->message = DEFAULT_MESSAGE;
 291   filter->reference_level = RG_REFERENCE_LEVEL;
 292
 293   filter->ctx = NULL;
 294   filter->analyze = NULL;
 295 }
 296
 297 static void
 298 gst_rg_analysis_set_property (GObject * object, guint prop_id,
 299     const GValue * value, GParamSpec * pspec)
 300 {
 301   GstRgAnalysis *filter = GST_RG_ANALYSIS (object);
 302
 303   GST_OBJECT_LOCK (filter);
 304   switch (prop_id) {
 305     case PROP_NUM_TRACKS:
 306       filter->num_tracks = g_value_get_int (value);
 307       break;
 308     case PROP_FORCED:
 309       filter->forced = g_value_get_boolean (value);
 310       break;
 311     case PROP_REFERENCE_LEVEL:
 312       filter->reference_level = g_value_get_double (value);
 313       break;
 314     case PROP_MESSAGE:
 315       filter->message = g_value_get_boolean (value);
 316       break;
 317     default:
 318       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 319       break;
 320   }
 321   GST_OBJECT_UNLOCK (filter);
 322 }
 323
 324 static void
 325 gst_rg_analysis_get_property (GObject * object, guint prop_id,
 326     GValue * value, GParamSpec * pspec)
 327 {
 328   GstRgAnalysis *filter = GST_RG_ANALYSIS (object);
 329
 330   GST_OBJECT_LOCK (filter);
 331   switch (prop_id) {
 332     case PROP_NUM_TRACKS:
 333       g_value_set_int (value, filter->num_tracks);
 334       break;
 335     case PROP_FORCED:
 336       g_value_set_boolean (value, filter->forced);
 337       break;
 338     case PROP_REFERENCE_LEVEL:
 339       g_value_set_double (value, filter->reference_level);
 340       break;
 341     case PROP_MESSAGE:
 342       g_value_set_boolean (value, filter->message);
 343       break;
 344     default:
 345       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 346       break;
 347   }
 348   GST_OBJECT_UNLOCK (filter);
 349 }
 350
 351 static void
 352 gst_rg_analysis_post_message (gpointer rganalysis, GstClockTime timestamp,
 353     GstClockTime duration, gdouble rglevel)
 354 {
 355   GstRgAnalysis *filter = GST_RG_ANALYSIS (rganalysis);
 356   if (filter->message) {
 357     GstMessage *m;
 358
 359     m = gst_message_new_element (GST_OBJECT_CAST (rganalysis),
 360         gst_structure_new ("rganalysis",
 361             "timestamp", G_TYPE_UINT64, timestamp,
 362             "duration", G_TYPE_UINT64, duration,
 363             "rglevel", G_TYPE_DOUBLE, rglevel, NULL));
 364
 365     gst_element_post_message (GST_ELEMENT_CAST (rganalysis), m);
 366   }
 367 }
 368
 369
 370 static gboolean
 371 gst_rg_analysis_start (GstBaseTransform * base)
 372 {
 373   GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
 374
 375   filter->ignore_tags = FALSE;
 376   filter->skip = FALSE;
 377   filter->has_track_gain = FALSE;
 378   filter->has_track_peak = FALSE;
 379   filter->has_album_gain = FALSE;
 380   filter->has_album_peak = FALSE;
 381
 382   filter->ctx = rg_analysis_new ();
 383   GST_OBJECT_LOCK (filter);
 384   rg_analysis_init_silence_detection (filter->ctx, gst_rg_analysis_post_message,
 385       filter);
 386   GST_OBJECT_UNLOCK (filter);
 387   filter->analyze = NULL;
 388
 389   GST_LOG_OBJECT (filter, "started");
 390
 391   return TRUE;
 392 }
 393
 394 static gboolean
 395 gst_rg_analysis_set_caps (GstBaseTransform * base, GstCaps * in_caps,
 396     GstCaps * out_caps)
 397 {
 398   GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
 399   GstStructure *structure;
 400   const gchar *name;
 401   gint n_channels, sample_rate, sample_bit_size, sample_size;
 402
 403   g_return_val_if_fail (filter->ctx != NULL, FALSE);
 404
 405   GST_DEBUG_OBJECT (filter,
 406       "set_caps in %" GST_PTR_FORMAT " out %" GST_PTR_FORMAT,
 407       in_caps, out_caps);
 408
 409   structure = gst_caps_get_structure (in_caps, 0);
 410   name = gst_structure_get_name (structure);
 411
 412   if (!gst_structure_get_int (structure, "width", &sample_bit_size)
 413       || !gst_structure_get_int (structure, "channels", &n_channels)
 414       || !gst_structure_get_int (structure, "rate", &sample_rate))
 415     goto invalid_format;
 416
 417   if (!rg_analysis_set_sample_rate (filter->ctx, sample_rate))
 418     goto invalid_format;
 419
 420   if (sample_bit_size % 8 != 0)
 421     goto invalid_format;
 422   sample_size = sample_bit_size / 8;
 423
 424   if (g_str_equal (name, "audio/x-raw-float")) {
 425
 426     if (sample_size != sizeof (gfloat))
 427       goto invalid_format;
 428
 429     /* The depth is not variable for float formats of course.  It just
 430      * makes the transform function nice and simple if the
 431      * rg_analysis_analyze_* functions have a common signature. */
 432     filter->depth = sizeof (gfloat) * 8;
 433
 434     if (n_channels == 1)
 435       filter->analyze = rg_analysis_analyze_mono_float;
 436     else if (n_channels == 2)
 437       filter->analyze = rg_analysis_analyze_stereo_float;
 438     else
 439       goto invalid_format;
 440
 441   } else if (g_str_equal (name, "audio/x-raw-int")) {
 442
 443     if (sample_size != sizeof (gint16))
 444       goto invalid_format;
 445
 446     if (!gst_structure_get_int (structure, "depth", &filter->depth))
 447       goto invalid_format;
 448     if (filter->depth < 1 || filter->depth > 16)
 449       goto invalid_format;
 450
 451     if (n_channels == 1)
 452       filter->analyze = rg_analysis_analyze_mono_int16;
 453     else if (n_channels == 2)
 454       filter->analyze = rg_analysis_analyze_stereo_int16;
 455     else
 456       goto invalid_format;
 457
 458   } else {
 459
 460     goto invalid_format;
 461   }
 462
 463   return TRUE;
 464
 465   /* Errors. */
 466 invalid_format:
 467   {
 468     filter->analyze = NULL;
 469     GST_ELEMENT_ERROR (filter, CORE, NEGOTIATION,
 470         ("Invalid incoming caps: %" GST_PTR_FORMAT, in_caps), (NULL));
 471     return FALSE;
 472   }
 473 }
 474
 475 static GstFlowReturn
 476 gst_rg_analysis_transform_ip (GstBaseTransform * base, GstBuffer * buf)
 477 {
 478   GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
 479   guint8 *data;
 480   gsize size;
 481
 482   g_return_val_if_fail (filter->ctx != NULL, GST_FLOW_WRONG_STATE);
 483   g_return_val_if_fail (filter->analyze != NULL, GST_FLOW_NOT_NEGOTIATED);
 484
 485   if (filter->skip)
 486     return GST_FLOW_OK;
 487
 488   data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
 489   GST_LOG_OBJECT (filter, "processing buffer of size %" G_GSIZE_FORMAT, size);
 490
 491   rg_analysis_start_buffer (filter->ctx, GST_BUFFER_TIMESTAMP (buf));
 492   filter->analyze (filter->ctx, data, size, filter->depth);
 493
 494   gst_buffer_unmap (buf, data, size);
 495
 496   return GST_FLOW_OK;
 497 }
 498
 499 static gboolean
 500 gst_rg_analysis_sink_event (GstBaseTransform * base, GstEvent * event)
 501 {
 502   GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
 503
 504   g_return_val_if_fail (filter->ctx != NULL, TRUE);
 505
 506   switch (GST_EVENT_TYPE (event)) {
 507
 508     case GST_EVENT_EOS:
 509     {
 510       GST_LOG_OBJECT (filter, "received EOS event");
 511
 512       gst_rg_analysis_handle_eos (filter);
 513
 514       GST_LOG_OBJECT (filter, "passing on EOS event");
 515
 516       break;
 517     }
 518     case GST_EVENT_TAG:
 519     {
 520       GstTagList *tag_list;
 521
 522       /* The reference to the tag list is borrowed. */
 523       gst_event_parse_tag (event, &tag_list);
 524       gst_rg_analysis_handle_tags (filter, tag_list);
 525
 526       break;
 527     }
 528     default:
 529       break;
 530   }
 531
 532   return GST_BASE_TRANSFORM_CLASS (parent_class)->sink_event (base, event);
 533 }
 534
 535 static gboolean
 536 gst_rg_analysis_stop (GstBaseTransform * base)
 537 {
 538   GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
 539
 540   g_return_val_if_fail (filter->ctx != NULL, FALSE);
 541
 542   rg_analysis_destroy (filter->ctx);
 543   filter->ctx = NULL;
 544
 545   GST_LOG_OBJECT (filter, "stopped");
 546
 547   return TRUE;
 548 }
 549
 550 static void
 551 gst_rg_analysis_handle_tags (GstRgAnalysis * filter,
 552     const GstTagList * tag_list)
 553 {
 554   gboolean album_processing = (filter->num_tracks > 0);
 555   gdouble dummy;
 556
 557   if (!album_processing)
 558     filter->ignore_tags = FALSE;
 559
 560   if (filter->skip && album_processing) {
 561     GST_DEBUG_OBJECT (filter, "ignoring tag event: skipping album");
 562     return;
 563   } else if (filter->skip) {
 564     GST_DEBUG_OBJECT (filter, "ignoring tag event: skipping track");
 565     return;
 566   } else if (filter->ignore_tags) {
 567     GST_DEBUG_OBJECT (filter, "ignoring tag event: cannot skip anyways");
 568     return;
 569   }
 570
 571   filter->has_track_gain |= gst_tag_list_get_double (tag_list,
 572       GST_TAG_TRACK_GAIN, &dummy);
 573   filter->has_track_peak |= gst_tag_list_get_double (tag_list,
 574       GST_TAG_TRACK_PEAK, &dummy);
 575   filter->has_album_gain |= gst_tag_list_get_double (tag_list,
 576       GST_TAG_ALBUM_GAIN, &dummy);
 577   filter->has_album_peak |= gst_tag_list_get_double (tag_list,
 578       GST_TAG_ALBUM_PEAK, &dummy);
 579
 580   if (!(filter->has_track_gain && filter->has_track_peak)) {
 581     GST_DEBUG_OBJECT (filter, "track tags not complete yet");
 582     return;
 583   }
 584
 585   if (album_processing && !(filter->has_album_gain && filter->has_album_peak)) {
 586     GST_DEBUG_OBJECT (filter, "album tags not complete yet");
 587     return;
 588   }
 589
 590   if (filter->forced) {
 591     GST_DEBUG_OBJECT (filter,
 592         "existing tags are sufficient, but processing anyway (forced)");
 593     return;
 594   }
 595
 596   filter->skip = TRUE;
 597   rg_analysis_reset (filter->ctx);
 598
 599   if (!album_processing) {
 600     GST_DEBUG_OBJECT (filter,
 601         "existing tags are sufficient, will not process this track");
 602   } else {
 603     GST_DEBUG_OBJECT (filter,
 604         "existing tags are sufficient, will not process this album");
 605   }
 606 }
 607
 608 static void
 609 gst_rg_analysis_handle_eos (GstRgAnalysis * filter)
 610 {
 611   gboolean album_processing = (filter->num_tracks > 0);
 612   gboolean album_finished = (filter->num_tracks == 1);
 613   gboolean album_skipping = album_processing && filter->skip;
 614
 615   filter->has_track_gain = FALSE;
 616   filter->has_track_peak = FALSE;
 617
 618   if (album_finished) {
 619     filter->ignore_tags = FALSE;
 620     filter->skip = FALSE;
 621     filter->has_album_gain = FALSE;
 622     filter->has_album_peak = FALSE;
 623   } else if (!album_skipping) {
 624     filter->skip = FALSE;
 625   }
 626
 627   /* We might have just fully processed a track because it has
 628    * incomplete tags.  If we do album processing and allow skipping
 629    * (not forced), prevent switching to skipping if a later track with
 630    * full tags comes along: */
 631   if (!filter->forced && album_processing && !album_finished)
 632     filter->ignore_tags = TRUE;
 633
 634   if (!filter->skip) {
 635     GstTagList *tag_list = NULL;
 636     gboolean track_success;
 637     gboolean album_success = FALSE;
 638
 639     track_success = gst_rg_analysis_track_result (filter, &tag_list);
 640
 641     if (album_finished)
 642       album_success = gst_rg_analysis_album_result (filter, &tag_list);
 643     else if (!album_processing)
 644       rg_analysis_reset_album (filter->ctx);
 645
 646     if (track_success || album_success) {
 647       GST_LOG_OBJECT (filter, "posting tag list with results");
 648       gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND,
 649           GST_TAG_REFERENCE_LEVEL, filter->reference_level, NULL);
 650       /* This steals our reference to the list: */
 651       gst_element_found_tags_for_pad (GST_ELEMENT (filter),
 652           GST_BASE_TRANSFORM_SRC_PAD (GST_BASE_TRANSFORM (filter)), tag_list);
 653     }
 654   }
 655
 656   if (album_processing) {
 657     filter->num_tracks--;
 658
 659     if (!album_finished) {
 660       GST_DEBUG_OBJECT (filter, "album not finished yet (num-tracks is now %u)",
 661           filter->num_tracks);
 662     } else {
 663       GST_DEBUG_OBJECT (filter, "album finished (num-tracks is now 0)");
 664     }
 665   }
 666
 667   if (album_processing)
 668     g_object_notify (G_OBJECT (filter), "num-tracks");
 669 }
 670
 671 static gboolean
 672 gst_rg_analysis_track_result (GstRgAnalysis * filter, GstTagList ** tag_list)
 673 {
 674   gboolean track_success;
 675   gdouble track_gain, track_peak;
 676
 677   track_success = rg_analysis_track_result (filter->ctx, &track_gain,
 678       &track_peak);
 679
 680   if (track_success) {
 681     track_gain += filter->reference_level - RG_REFERENCE_LEVEL;
 682     GST_INFO_OBJECT (filter, "track gain is %+.2f dB, peak %.6f", track_gain,
 683         track_peak);
 684   } else {
 685     GST_INFO_OBJECT (filter, "track was too short to analyze");
 686   }
 687
 688   if (track_success) {
 689     if (*tag_list == NULL)
 690       *tag_list = gst_tag_list_new ();
 691     gst_tag_list_add (*tag_list, GST_TAG_MERGE_APPEND,
 692         GST_TAG_TRACK_PEAK, track_peak, GST_TAG_TRACK_GAIN, track_gain, NULL);
 693   }
 694
 695   return track_success;
 696 }
 697
 698 static gboolean
 699 gst_rg_analysis_album_result (GstRgAnalysis * filter, GstTagList ** tag_list)
 700 {
 701   gboolean album_success;
 702   gdouble album_gain, album_peak;
 703
 704   album_success = rg_analysis_album_result (filter->ctx, &album_gain,
 705       &album_peak);
 706
 707   if (album_success) {
 708     album_gain += filter->reference_level - RG_REFERENCE_LEVEL;
 709     GST_INFO_OBJECT (filter, "album gain is %+.2f dB, peak %.6f", album_gain,
 710         album_peak);
 711   } else {
 712     GST_INFO_OBJECT (filter, "album was too short to analyze");
 713   }
 714
 715   if (album_success) {
 716     if (*tag_list == NULL)
 717       *tag_list = gst_tag_list_new ();
 718     gst_tag_list_add (*tag_list, GST_TAG_MERGE_APPEND,
 719         GST_TAG_ALBUM_PEAK, album_peak, GST_TAG_ALBUM_GAIN, album_gain, NULL);
 720   }
 721
 722   return album_success;
 723 }