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 GST_BOILERPLATE (GstRgAnalysis, gst_rg_analysis, GstBaseTransform,
 129     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_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_base_init (gpointer g_class)
 155 {
 156   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 157
 158   gst_element_class_add_static_pad_template (element_class, &src_factory);
 159   gst_element_class_add_static_pad_template (element_class, &sink_factory);
 160   gst_element_class_set_details_simple (element_class, "ReplayGain analysis",
 161       "Filter/Analyzer/Audio",
 162       "Perform the ReplayGain analysis",
 163       "Ren\xc3\xa9 Stadler <mail@renestadler.de>");
 164
 165   GST_DEBUG_CATEGORY_INIT (gst_rg_analysis_debug, "rganalysis", 0,
 166       "ReplayGain analysis element");
 167 }
 168
 169 static void
 170 gst_rg_analysis_class_init (GstRgAnalysisClass * klass)
 171 {
 172   GObjectClass *gobject_class;
 173   GstBaseTransformClass *trans_class;
 174
 175   gobject_class = (GObjectClass *) klass;
 176   gobject_class->set_property = gst_rg_analysis_set_property;
 177   gobject_class->get_property = gst_rg_analysis_get_property;
 178
 179   /**
 180    * GstRgAnalysis:num-tracks:
 181    *
 182    * Number of remaining album tracks.
 183    *
 184    * Analyzing several streams sequentially and assigning them a common result
 185    * gain is known as "album processing".  If this gain is used during playback
 186    * (by switching to "album mode"), all tracks of an album receive the same
 187    * amplification.  This keeps the relative volume levels between the tracks
 188    * intact.  To enable this, set this property to the number of streams that
 189    * will be processed as album tracks.
 190    *
 191    * Every time an EOS event is received, the value of this property is
 192    * decremented by one.  As it reaches zero, it is assumed that the last track
 193    * of the album finished.  The tag list for the final stream will contain the
 194    * additional tags #GST_TAG_ALBUM_GAIN and #GST_TAG_ALBUM_PEAK.  All other
 195    * streams just get the two track tags posted because the values for the album
 196    * tags are not known before all tracks are analyzed.  Applications need to
 197    * ensure that the album gain and peak values are also associated with the
 198    * other tracks when storing the results.
 199    *
 200    * If the total number of album tracks is unknown beforehand, just ensure that
 201    * the value is greater than 1 before each track starts.  Then before the end
 202    * of the last track, set it to the value 1.
 203    *
 204    * To perform album processing, the element has to preserve data between
 205    * streams.  This cannot survive a state change to the NULL or READY state.
 206    * If you change your pipeline's state to NULL or READY between tracks, lock
 207    * the element's state using gst_element_set_locked_state() when it is in
 208    * PAUSED or PLAYING.
 209    */
 210   g_object_class_install_property (gobject_class, PROP_NUM_TRACKS,
 211       g_param_spec_int ("num-tracks", "Number of album tracks",
 212           "Number of remaining album tracks", 0, G_MAXINT, 0,
 213           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 214   /**
 215    * GstRgAnalysis:forced:
 216    *
 217    * Whether to analyze streams even when ReplayGain tags exist.
 218    *
 219    * For assisting transcoder/converter applications, the element can silently
 220    * skip the processing of streams that already contain the necessary tags.
 221    * Data will flow as usual but the element will not consume CPU time and will
 222    * not generate result tags.  To enable possible skipping, set this property
 223    * to #FALSE.
 224    *
 225    * If used in conjunction with <link linkend="GstRgAnalysis--num-tracks">album
 226    * processing</link>, the element will skip the number of remaining album
 227    * tracks if a full set of tags is found for the first track.  If a subsequent
 228    * track of the album is missing tags, processing cannot start again.  If this
 229    * is undesired, the application has to scan all files beforehand and enable
 230    * forcing of processing if needed.
 231    */
 232   g_object_class_install_property (gobject_class, PROP_FORCED,
 233       g_param_spec_boolean ("forced", "Forced",
 234           "Analyze even if ReplayGain tags exist",
 235           FORCED_DEFAULT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 236   /**
 237    * GstRgAnalysis:reference-level:
 238    *
 239    * Reference level [dB].
 240    *
 241    * Analyzing the ReplayGain pink noise reference waveform computes a result of
 242    * +6 dB instead of the expected 0 dB.  This is because the default reference
 243    * level is 89 dB.  To obtain values as lined out in the original proposal of
 244    * ReplayGain, set this property to 83.
 245    *
 246    * Almost all software uses 89 dB as a reference however, and this value has
 247    * become the new official value.  That is to say, while the change has been
 248    * acclaimed by the author of the ReplayGain proposal, the <ulink
 249    * url="http://replaygain.org">webpage</ulink> is still outdated at the time
 250    * of this writing.
 251    *
 252    * The value was changed because the original proposal recommends a default
 253    * pre-amp value of +6 dB for playback.  This seemed a bit odd, as it means
 254    * that the algorithm has the general tendency to produce adjustment values
 255    * that are 6 dB too low.  Bumping the reference level by 6 dB compensated for
 256    * this.
 257    *
 258    * The problem of the reference level being ambiguous for lack of concise
 259    * standardization is to be solved by adopting the #GST_TAG_REFERENCE_LEVEL
 260    * tag, which allows to store the used value alongside the gain values.
 261    */
 262   g_object_class_install_property (gobject_class, PROP_REFERENCE_LEVEL,
 263       g_param_spec_double ("reference-level", "Reference level",
 264           "Reference level [dB]", 0.0, 150., RG_REFERENCE_LEVEL,
 265           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 266
 267   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_MESSAGE,
 268       g_param_spec_boolean ("message", "Message",
 269           "Post statics messages",
 270           DEFAULT_MESSAGE,
 271           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 272
 273   trans_class = (GstBaseTransformClass *) klass;
 274   trans_class->start = GST_DEBUG_FUNCPTR (gst_rg_analysis_start);
 275   trans_class->set_caps = GST_DEBUG_FUNCPTR (gst_rg_analysis_set_caps);
 276   trans_class->transform_ip = GST_DEBUG_FUNCPTR (gst_rg_analysis_transform_ip);
 277   trans_class->event = GST_DEBUG_FUNCPTR (gst_rg_analysis_event);
 278   trans_class->stop = GST_DEBUG_FUNCPTR (gst_rg_analysis_stop);
 279   trans_class->passthrough_on_same_caps = TRUE;
 280 }
 281
 282 static void
 283 gst_rg_analysis_init (GstRgAnalysis * filter, GstRgAnalysisClass * gclass)
 284 {
 285   GstBaseTransform *base = GST_BASE_TRANSFORM (filter);
 286
 287   gst_base_transform_set_gap_aware (base, TRUE);
 288
 289   filter->num_tracks = 0;
 290   filter->forced = FORCED_DEFAULT;
 291   filter->message = DEFAULT_MESSAGE;
 292   filter->reference_level = RG_REFERENCE_LEVEL;
 293
 294   filter->ctx = NULL;
 295   filter->analyze = NULL;
 296 }
 297
 298 static void
 299 gst_rg_analysis_set_property (GObject * object, guint prop_id,
 300     const GValue * value, GParamSpec * pspec)
 301 {
 302   GstRgAnalysis *filter = GST_RG_ANALYSIS (object);
 303
 304   GST_OBJECT_LOCK (filter);
 305   switch (prop_id) {
 306     case PROP_NUM_TRACKS:
 307       filter->num_tracks = g_value_get_int (value);
 308       break;
 309     case PROP_FORCED:
 310       filter->forced = g_value_get_boolean (value);
 311       break;
 312     case PROP_REFERENCE_LEVEL:
 313       filter->reference_level = g_value_get_double (value);
 314       break;
 315     case PROP_MESSAGE:
 316       filter->message = g_value_get_boolean (value);
 317       break;
 318     default:
 319       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 320       break;
 321   }
 322   GST_OBJECT_UNLOCK (filter);
 323 }
 324
 325 static void
 326 gst_rg_analysis_get_property (GObject * object, guint prop_id,
 327     GValue * value, GParamSpec * pspec)
 328 {
 329   GstRgAnalysis *filter = GST_RG_ANALYSIS (object);
 330
 331   GST_OBJECT_LOCK (filter);
 332   switch (prop_id) {
 333     case PROP_NUM_TRACKS:
 334       g_value_set_int (value, filter->num_tracks);
 335       break;
 336     case PROP_FORCED:
 337       g_value_set_boolean (value, filter->forced);
 338       break;
 339     case PROP_REFERENCE_LEVEL:
 340       g_value_set_double (value, filter->reference_level);
 341       break;
 342     case PROP_MESSAGE:
 343       g_value_set_boolean (value, filter->message);
 344       break;
 345     default:
 346       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 347       break;
 348   }
 349   GST_OBJECT_UNLOCK (filter);
 350 }
 351
 352 static void
 353 gst_rg_analysis_post_message (gpointer rganalysis, GstClockTime timestamp,
 354     GstClockTime duration, gdouble rglevel)
 355 {
 356   GstRgAnalysis *filter = GST_RG_ANALYSIS (rganalysis);
 357   if (filter->message) {
 358     GstMessage *m;
 359
 360     m = gst_message_new_element (GST_OBJECT_CAST (rganalysis),
 361         gst_structure_new ("rganalysis",
 362             "timestamp", G_TYPE_UINT64, timestamp,
 363             "duration", G_TYPE_UINT64, duration,
 364             "rglevel", G_TYPE_DOUBLE, rglevel, NULL));
 365
 366     gst_element_post_message (GST_ELEMENT_CAST (rganalysis), m);
 367   }
 368 }
 369
 370
 371 static gboolean
 372 gst_rg_analysis_start (GstBaseTransform * base)
 373 {
 374   GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
 375
 376   filter->ignore_tags = FALSE;
 377   filter->skip = FALSE;
 378   filter->has_track_gain = FALSE;
 379   filter->has_track_peak = FALSE;
 380   filter->has_album_gain = FALSE;
 381   filter->has_album_peak = FALSE;
 382
 383   filter->ctx = rg_analysis_new ();
 384   GST_OBJECT_LOCK (filter);
 385   rg_analysis_init_silence_detection (filter->ctx, gst_rg_analysis_post_message,
 386       filter);
 387   GST_OBJECT_UNLOCK (filter);
 388   filter->analyze = NULL;
 389
 390   GST_LOG_OBJECT (filter, "started");
 391
 392   return TRUE;
 393 }
 394
 395 static gboolean
 396 gst_rg_analysis_set_caps (GstBaseTransform * base, GstCaps * in_caps,
 397     GstCaps * out_caps)
 398 {
 399   GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
 400   GstStructure *structure;
 401   const gchar *name;
 402   gint n_channels, sample_rate, sample_bit_size, sample_size;
 403
 404   g_return_val_if_fail (filter->ctx != NULL, FALSE);
 405
 406   GST_DEBUG_OBJECT (filter,
 407       "set_caps in %" GST_PTR_FORMAT " out %" GST_PTR_FORMAT,
 408       in_caps, out_caps);
 409
 410   structure = gst_caps_get_structure (in_caps, 0);
 411   name = gst_structure_get_name (structure);
 412
 413   if (!gst_structure_get_int (structure, "width", &sample_bit_size)
 414       || !gst_structure_get_int (structure, "channels", &n_channels)
 415       || !gst_structure_get_int (structure, "rate", &sample_rate))
 416     goto invalid_format;
 417
 418   if (!rg_analysis_set_sample_rate (filter->ctx, sample_rate))
 419     goto invalid_format;
 420
 421   if (sample_bit_size % 8 != 0)
 422     goto invalid_format;
 423   sample_size = sample_bit_size / 8;
 424
 425   if (g_str_equal (name, "audio/x-raw-float")) {
 426
 427     if (sample_size != sizeof (gfloat))
 428       goto invalid_format;
 429
 430     /* The depth is not variable for float formats of course.  It just
 431      * makes the transform function nice and simple if the
 432      * rg_analysis_analyze_* functions have a common signature. */
 433     filter->depth = sizeof (gfloat) * 8;
 434
 435     if (n_channels == 1)
 436       filter->analyze = rg_analysis_analyze_mono_float;
 437     else if (n_channels == 2)
 438       filter->analyze = rg_analysis_analyze_stereo_float;
 439     else
 440       goto invalid_format;
 441
 442   } else if (g_str_equal (name, "audio/x-raw-int")) {
 443
 444     if (sample_size != sizeof (gint16))
 445       goto invalid_format;
 446
 447     if (!gst_structure_get_int (structure, "depth", &filter->depth))
 448       goto invalid_format;
 449     if (filter->depth < 1 || filter->depth > 16)
 450       goto invalid_format;
 451
 452     if (n_channels == 1)
 453       filter->analyze = rg_analysis_analyze_mono_int16;
 454     else if (n_channels == 2)
 455       filter->analyze = rg_analysis_analyze_stereo_int16;
 456     else
 457       goto invalid_format;
 458
 459   } else {
 460
 461     goto invalid_format;
 462   }
 463
 464   return TRUE;
 465
 466   /* Errors. */
 467 invalid_format:
 468   {
 469     filter->analyze = NULL;
 470     GST_ELEMENT_ERROR (filter, CORE, NEGOTIATION,
 471         ("Invalid incoming caps: %" GST_PTR_FORMAT, in_caps), (NULL));
 472     return FALSE;
 473   }
 474 }
 475
 476 static GstFlowReturn
 477 gst_rg_analysis_transform_ip (GstBaseTransform * base, GstBuffer * buf)
 478 {
 479   GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
 480
 481   g_return_val_if_fail (filter->ctx != NULL, GST_FLOW_WRONG_STATE);
 482   g_return_val_if_fail (filter->analyze != NULL, GST_FLOW_NOT_NEGOTIATED);
 483
 484   if (filter->skip)
 485     return GST_FLOW_OK;
 486
 487   GST_LOG_OBJECT (filter, "processing buffer of size %u",
 488       GST_BUFFER_SIZE (buf));
 489
 490   rg_analysis_start_buffer (filter->ctx, GST_BUFFER_TIMESTAMP (buf));
 491   filter->analyze (filter->ctx, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf),
 492       filter->depth);
 493
 494   return GST_FLOW_OK;
 495 }
 496
 497 static gboolean
 498 gst_rg_analysis_event (GstBaseTransform * base, GstEvent * event)
 499 {
 500   GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
 501
 502   g_return_val_if_fail (filter->ctx != NULL, TRUE);
 503
 504   switch (GST_EVENT_TYPE (event)) {
 505
 506     case GST_EVENT_EOS:
 507     {
 508       GST_LOG_OBJECT (filter, "received EOS event");
 509
 510       gst_rg_analysis_handle_eos (filter);
 511
 512       GST_LOG_OBJECT (filter, "passing on EOS event");
 513
 514       break;
 515     }
 516     case GST_EVENT_TAG:
 517     {
 518       GstTagList *tag_list;
 519
 520       /* The reference to the tag list is borrowed. */
 521       gst_event_parse_tag (event, &tag_list);
 522       gst_rg_analysis_handle_tags (filter, tag_list);
 523
 524       break;
 525     }
 526     default:
 527       break;
 528   }
 529
 530   return GST_BASE_TRANSFORM_CLASS (parent_class)->event (base, event);
 531 }
 532
 533 static gboolean
 534 gst_rg_analysis_stop (GstBaseTransform * base)
 535 {
 536   GstRgAnalysis *filter = GST_RG_ANALYSIS (base);
 537
 538   g_return_val_if_fail (filter->ctx != NULL, FALSE);
 539
 540   rg_analysis_destroy (filter->ctx);
 541   filter->ctx = NULL;
 542
 543   GST_LOG_OBJECT (filter, "stopped");
 544
 545   return TRUE;
 546 }
 547
 548 static void
 549 gst_rg_analysis_handle_tags (GstRgAnalysis * filter,
 550     const GstTagList * tag_list)
 551 {
 552   gboolean album_processing = (filter->num_tracks > 0);
 553   gdouble dummy;
 554
 555   if (!album_processing)
 556     filter->ignore_tags = FALSE;
 557
 558   if (filter->skip && album_processing) {
 559     GST_DEBUG_OBJECT (filter, "ignoring tag event: skipping album");
 560     return;
 561   } else if (filter->skip) {
 562     GST_DEBUG_OBJECT (filter, "ignoring tag event: skipping track");
 563     return;
 564   } else if (filter->ignore_tags) {
 565     GST_DEBUG_OBJECT (filter, "ignoring tag event: cannot skip anyways");
 566     return;
 567   }
 568
 569   filter->has_track_gain |= gst_tag_list_get_double (tag_list,
 570       GST_TAG_TRACK_GAIN, &dummy);
 571   filter->has_track_peak |= gst_tag_list_get_double (tag_list,
 572       GST_TAG_TRACK_PEAK, &dummy);
 573   filter->has_album_gain |= gst_tag_list_get_double (tag_list,
 574       GST_TAG_ALBUM_GAIN, &dummy);
 575   filter->has_album_peak |= gst_tag_list_get_double (tag_list,
 576       GST_TAG_ALBUM_PEAK, &dummy);
 577
 578   if (!(filter->has_track_gain && filter->has_track_peak)) {
 579     GST_DEBUG_OBJECT (filter, "track tags not complete yet");
 580     return;
 581   }
 582
 583   if (album_processing && !(filter->has_album_gain && filter->has_album_peak)) {
 584     GST_DEBUG_OBJECT (filter, "album tags not complete yet");
 585     return;
 586   }
 587
 588   if (filter->forced) {
 589     GST_DEBUG_OBJECT (filter,
 590         "existing tags are sufficient, but processing anyway (forced)");
 591     return;
 592   }
 593
 594   filter->skip = TRUE;
 595   rg_analysis_reset (filter->ctx);
 596
 597   if (!album_processing) {
 598     GST_DEBUG_OBJECT (filter,
 599         "existing tags are sufficient, will not process this track");
 600   } else {
 601     GST_DEBUG_OBJECT (filter,
 602         "existing tags are sufficient, will not process this album");
 603   }
 604 }
 605
 606 static void
 607 gst_rg_analysis_handle_eos (GstRgAnalysis * filter)
 608 {
 609   gboolean album_processing = (filter->num_tracks > 0);
 610   gboolean album_finished = (filter->num_tracks == 1);
 611   gboolean album_skipping = album_processing && filter->skip;
 612
 613   filter->has_track_gain = FALSE;
 614   filter->has_track_peak = FALSE;
 615
 616   if (album_finished) {
 617     filter->ignore_tags = FALSE;
 618     filter->skip = FALSE;
 619     filter->has_album_gain = FALSE;
 620     filter->has_album_peak = FALSE;
 621   } else if (!album_skipping) {
 622     filter->skip = FALSE;
 623   }
 624
 625   /* We might have just fully processed a track because it has
 626    * incomplete tags.  If we do album processing and allow skipping
 627    * (not forced), prevent switching to skipping if a later track with
 628    * full tags comes along: */
 629   if (!filter->forced && album_processing && !album_finished)
 630     filter->ignore_tags = TRUE;
 631
 632   if (!filter->skip) {
 633     GstTagList *tag_list = NULL;
 634     gboolean track_success;
 635     gboolean album_success = FALSE;
 636
 637     track_success = gst_rg_analysis_track_result (filter, &tag_list);
 638
 639     if (album_finished)
 640       album_success = gst_rg_analysis_album_result (filter, &tag_list);
 641     else if (!album_processing)
 642       rg_analysis_reset_album (filter->ctx);
 643
 644     if (track_success || album_success) {
 645       GST_LOG_OBJECT (filter, "posting tag list with results");
 646       gst_tag_list_add (tag_list, GST_TAG_MERGE_APPEND,
 647           GST_TAG_REFERENCE_LEVEL, filter->reference_level, NULL);
 648       /* This steals our reference to the list: */
 649       gst_element_found_tags_for_pad (GST_ELEMENT (filter),
 650           GST_BASE_TRANSFORM_SRC_PAD (GST_BASE_TRANSFORM (filter)), tag_list);
 651     }
 652   }
 653
 654   if (album_processing) {
 655     filter->num_tracks--;
 656
 657     if (!album_finished) {
 658       GST_DEBUG_OBJECT (filter, "album not finished yet (num-tracks is now %u)",
 659           filter->num_tracks);
 660     } else {
 661       GST_DEBUG_OBJECT (filter, "album finished (num-tracks is now 0)");
 662     }
 663   }
 664
 665   if (album_processing)
 666     g_object_notify (G_OBJECT (filter), "num-tracks");
 667 }
 668
 669 static gboolean
 670 gst_rg_analysis_track_result (GstRgAnalysis * filter, GstTagList ** tag_list)
 671 {
 672   gboolean track_success;
 673   gdouble track_gain, track_peak;
 674
 675   track_success = rg_analysis_track_result (filter->ctx, &track_gain,
 676       &track_peak);
 677
 678   if (track_success) {
 679     track_gain += filter->reference_level - RG_REFERENCE_LEVEL;
 680     GST_INFO_OBJECT (filter, "track gain is %+.2f dB, peak %.6f", track_gain,
 681         track_peak);
 682   } else {
 683     GST_INFO_OBJECT (filter, "track was too short to analyze");
 684   }
 685
 686   if (track_success) {
 687     if (*tag_list == NULL)
 688       *tag_list = gst_tag_list_new ();
 689     gst_tag_list_add (*tag_list, GST_TAG_MERGE_APPEND,
 690         GST_TAG_TRACK_PEAK, track_peak, GST_TAG_TRACK_GAIN, track_gain, NULL);
 691   }
 692
 693   return track_success;
 694 }
 695
 696 static gboolean
 697 gst_rg_analysis_album_result (GstRgAnalysis * filter, GstTagList ** tag_list)
 698 {
 699   gboolean album_success;
 700   gdouble album_gain, album_peak;
 701
 702   album_success = rg_analysis_album_result (filter->ctx, &album_gain,
 703       &album_peak);
 704
 705   if (album_success) {
 706     album_gain += filter->reference_level - RG_REFERENCE_LEVEL;
 707     GST_INFO_OBJECT (filter, "album gain is %+.2f dB, peak %.6f", album_gain,
 708         album_peak);
 709   } else {
 710     GST_INFO_OBJECT (filter, "album was too short to analyze");
 711   }
 712
 713   if (album_success) {
 714     if (*tag_list == NULL)
 715       *tag_list = gst_tag_list_new ();
 716     gst_tag_list_add (*tag_list, GST_TAG_MERGE_APPEND,
 717         GST_TAG_ALBUM_PEAK, album_peak, GST_TAG_ALBUM_GAIN, album_gain, NULL);
 718   }
 719
 720   return album_success;
 721 }