1 /*

     2  * Copyright (c) 2006 Christophe Fergeau  <teuf@gnome.org>

     3  * Copyright (c) 2008 Sebastian Dröge  <slomo@circular-chaos.org>

     4  *

     5  * This library is free software; you can redistribute it and/or

     6  * modify it under the terms of the GNU Library General Public

     7  * License as published by the Free Software Foundation; either

     8  * version 2 of the License, or (at your option) any later version.

     9  *

    10  * This library is distributed in the hope that it will be useful,

    11  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13  * Library General Public License for more details.

    14  *

    15  * You should have received a copy of the GNU Library General Public

    16  * License along with this library; if not, write to the

    17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    18  * Boston, MA 02111-1307, USA.

    19  */

    20 

    21 /* Xing SDK: http://www.mp3-tech.org/programmer/sources/vbrheadersdk.zip */

    22 

    23 

    24 /**

    25  * SECTION:element-xingmux

    26  *

    27  * xingmux adds a Xing header to MP3 files. This contains information about the duration and size

    28  * of the file and a seek table and is very useful for getting an almost correct duration and better

    29  * seeking on VBR MP3 files.

    30  * 

    31  * This element will remove any existing Xing, LAME or VBRI headers from the beginning of the file.

    32  *

    33  * <refsect2>

    34  * <title>Example launch line</title>

    35  * |[

    36  * gst-launch audiotestsrc num-buffers=1000 ! audioconvert ! lame ! xingmux ! filesink location=test.mp3

    37  * gst-launch filesrc location=test.mp3 ! xingmux ! filesink location=test2.mp3

    38  * gst-launch filesrc location=test.mp3 ! mp3parse ! xingmux ! filesink location=test2.mp3

    39  * ]|

    40  * </refsect2>

    41  */

    42 

    43 #ifdef HAVE_CONFIG_H

    44 #include "../../config.h"

    45 #endif

    46 

    47 #include <string.h>

    48 #include "gstxingmux.h"

    49 

    50 GST_DEBUG_CATEGORY_STATIC (xing_mux_debug);

    51 #define GST_CAT_DEFAULT xing_mux_debug

    52 

    53 GST_BOILERPLATE (GstXingMux, gst_xing_mux, GstElement, GST_TYPE_ELEMENT);

    54 

    55 /* Xing Header stuff */

    56 #define GST_XING_FRAME_FIELD   (1 << 0)

    57 #define GST_XING_BYTES_FIELD   (1 << 1)

    58 #define GST_XING_TOC_FIELD     (1 << 2)

    59 #define GST_XING_QUALITY_FIELD (1 << 3)

    60 

    61 typedef struct _GstXingSeekEntry

    62 {

    63   gint64 timestamp;

    64   gint byte;

    65 } GstXingSeekEntry;

    66 

    67 static inline GstXingSeekEntry *

    68 gst_xing_seek_entry_new ()

    69 {

    70   return g_slice_new (GstXingSeekEntry);

    71 }

    72 

    73 static inline void

    74 gst_xing_seek_entry_free (GstXingSeekEntry * entry)

    75 {

    76   g_slice_free (GstXingSeekEntry, entry);

    77 }

    78 

    79 static void gst_xing_mux_finalize (GObject * obj);

    80 static GstStateChangeReturn

    81 gst_xing_mux_change_state (GstElement * element, GstStateChange transition);

    82 static GstFlowReturn gst_xing_mux_chain (GstPad * pad, GstBuffer * buffer);

    83 static gboolean gst_xing_mux_sink_event (GstPad * pad, GstEvent * event);

    84 

    85 static GstStaticPadTemplate gst_xing_mux_sink_template =

    86 GST_STATIC_PAD_TEMPLATE ("sink",

    87     GST_PAD_SINK,

    88     GST_PAD_ALWAYS,

    89     GST_STATIC_CAPS ("audio/mpeg, "

    90         "mpegversion = (int) 1, " "layer = (int) [ 1, 3 ]"));

    91 

    92 

    93 static GstStaticPadTemplate gst_xing_mux_src_template =

    94 GST_STATIC_PAD_TEMPLATE ("src",

    95     GST_PAD_SRC,

    96     GST_PAD_ALWAYS,

    97     GST_STATIC_CAPS ("audio/mpeg, "

    98         "mpegversion = (int) 1, " "layer = (int) [ 1, 3 ]"));

    99 static const guint mp3types_bitrates[2][3][16] = {

   100   {

   101         {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448,},

   102         {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384,},

   103         {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320,}

   104       },

   105   {

   106         {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256,},

   107         {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,},

   108         {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160,}

   109       },

   110 };

   111 

   112 static const guint mp3types_freqs[3][3] = { {44100, 48000, 32000},

   113 {22050, 24000, 16000},

   114 {11025, 12000, 8000}

   115 };

   116 

   117 static gboolean

   118 parse_header (guint32 header, guint * ret_size, guint * ret_spf,

   119     gulong * ret_rate)

   120 {

   121   guint length, spf;

   122   gulong samplerate, bitrate, layer, padding;

   123   gint lsf, mpg25;

   124 

   125   if ((header & 0xffe00000) != 0xffe00000) {

   126     g_warning ("invalid sync");

   127     return FALSE;

   128   }

   129 

   130   if (((header >> 19) & 3) == 0x01) {

   131     g_warning ("invalid MPEG version");

   132     return FALSE;

   133   }

   134 

   135   if (((header >> 17) & 3) == 0x00) {

   136     g_warning ("invalid MPEG layer");

   137     return FALSE;

   138   }

   139 

   140   if (((header >> 12) & 0xf) == 0xf || ((header >> 12) & 0xf) == 0x0) {

   141     g_warning ("invalid bitrate");

   142     return FALSE;

   143   }

   144 

   145   if (((header >> 10) & 0x3) == 0x3) {

   146     g_warning ("invalid sampling rate");

   147     return FALSE;

   148   }

   149 

   150   if (header & 0x00000002) {

   151     g_warning ("invalid emphasis");

   152     return FALSE;

   153   }

   154 

   155   if (header & (1 << 20)) {

   156     lsf = (header & (1 << 19)) ? 0 : 1;

   157     mpg25 = 0;

   158   } else {

   159     lsf = 1;

   160     mpg25 = 1;

   161   }

   162 

   163   layer = 4 - ((header >> 17) & 0x3);

   164 

   165   bitrate = (header >> 12) & 0xF;

   166   bitrate = mp3types_bitrates[lsf][layer - 1][bitrate] * 1000;

   167   if (bitrate == 0)

   168     return 0;

   169 

   170   samplerate = (header >> 10) & 0x3;

   171   samplerate = mp3types_freqs[lsf + mpg25][samplerate];

   172 

   173   padding = (header >> 9) & 0x1;

   174 

   175   switch (layer) {

   176     case 1:

   177       length = 4 * ((bitrate * 12) / samplerate + padding);

   178       break;

   179     case 2:

   180       length = (bitrate * 144) / samplerate + padding;

   181       break;

   182     default:

   183     case 3:

   184       length = (bitrate * 144) / (samplerate << lsf) + padding;

   185       break;

   186   }

   187 

   188   if (layer == 1)

   189     spf = 384;

   190   else if (layer == 2 || lsf == 0)

   191     spf = 1152;

   192   else

   193     spf = 576;

   194 

   195   if (ret_size)

   196     *ret_size = length;

   197   if (ret_spf)

   198     *ret_spf = spf;

   199   if (ret_rate)

   200     *ret_rate = samplerate;

   201 

   202   return TRUE;

   203 }

   204 

   205 static guint

   206 get_xing_offset (guint32 header)

   207 {

   208   guint mpeg_version = (header >> 19) & 0x3;

   209   guint channel_mode = (header >> 6) & 0x3;

   210 

   211   if (mpeg_version == 0x3) {

   212     if (channel_mode == 0x3) {

   213       return 0x11;

   214     } else {

   215       return 0x20;

   216     }

   217   } else {

   218     if (channel_mode == 0x3) {

   219       return 0x09;

   220     } else {

   221       return 0x11;

   222     }

   223   }

   224 }

   225 

   226 static gboolean

   227 has_xing_header (guint32 header, guchar * data, gsize size)

   228 {

   229   data += 4;

   230   data += get_xing_offset (header);

   231 

   232   if (memcmp (data, "Xing", 4) == 0 ||

   233       memcmp (data, "Info", 4) == 0 || memcmp (data, "VBRI", 4) == 0)

   234     return TRUE;

   235   else

   236     return FALSE;

   237 }

   238 

   239 static GstBuffer *

   240 generate_xing_header (GstXingMux * xing)

   241 {

   242   guint8 *xing_flags;

   243   guint32 xing_flags_tmp = 0;

   244   GstBuffer *xing_header;

   245   guchar *data;

   246 

   247   guint32 header;

   248   guint32 header_be;

   249   guint size, spf, xing_offset;

   250   gulong rate;

   251   guint bitrate = 0x00;

   252 

   253   gint64 duration;

   254   gint64 byte_count;

   255 

   256   header = xing->first_header;

   257 

   258   /* Set bitrate and choose lowest possible size */

   259   do {

   260     bitrate++;

   261 

   262     header &= 0xffff0fff;

   263     header |= bitrate << 12;

   264 

   265     parse_header (header, &size, &spf, &rate);

   266     xing_offset = get_xing_offset (header);

   267   } while (size < (4 + xing_offset + 4 + 4 + 4 + 4 + 100) && bitrate < 0xe);

   268 

   269   if (bitrate == 0xe) {

   270     GST_ERROR ("No usable bitrate found!");

   271     return NULL;

   272   }

   273 

   274   if (gst_pad_alloc_buffer_and_set_caps (xing->srcpad, 0, size,

   275           GST_PAD_CAPS (xing->srcpad), &xing_header) != GST_FLOW_OK) {

   276     xing_header = gst_buffer_new_and_alloc (size);

   277     gst_buffer_set_caps (xing_header, GST_PAD_CAPS (xing->srcpad));

   278   }

   279 

   280   data = GST_BUFFER_DATA (xing_header);

   281   memset (data, 0, size);

   282   header_be = GUINT32_TO_BE (header);

   283   memcpy (data, &header_be, 4);

   284 

   285   data += 4;

   286   data += xing_offset;

   287 

   288   memcpy (data, "Xing", 4);

   289   data += 4;

   290 

   291   xing_flags = data;

   292   data += 4;

   293 

   294   if (xing->duration != GST_CLOCK_TIME_NONE) {

   295     duration = xing->duration;

   296   } else {

   297     GstFormat fmt = GST_FORMAT_TIME;

   298 

   299     if (!gst_pad_query_peer_duration (xing->sinkpad, &fmt, &duration))

   300       duration = GST_CLOCK_TIME_NONE;

   301   }

   302 

   303   if (duration != GST_CLOCK_TIME_NONE) {

   304     guint32 number_of_frames;

   305 

   306     /* The Xing Header contains a NumberOfFrames field, which verifies to:

   307      * Duration = NumberOfFrames *SamplesPerFrame/SamplingRate

   308      * SamplesPerFrame and SamplingRate are values for the current frame. 

   309      */

   310     number_of_frames = gst_util_uint64_scale (duration, rate, GST_SECOND) / spf;

   311     GST_DEBUG ("Setting number of frames to %u", number_of_frames);

   312     number_of_frames = GUINT32_TO_BE (number_of_frames);

   313     memcpy (data, &number_of_frames, 4);

   314     xing_flags_tmp |= GST_XING_FRAME_FIELD;

   315     data += 4;

   316   }

   317 

   318   if (xing->byte_count != 0) {

   319     byte_count = xing->byte_count;

   320   } else {

   321     GstFormat fmt = GST_FORMAT_BYTES;

   322 

   323     if (!gst_pad_query_peer_duration (xing->sinkpad, &fmt, &byte_count))

   324       byte_count = 0;

   325     if (byte_count == -1)

   326       byte_count = 0;

   327   }

   328 

   329   if (byte_count != 0) {

   330     guint32 nbytes;

   331 

   332     if (byte_count > G_MAXUINT32) {

   333       GST_DEBUG ("Too large stream: %" G_GINT64_FORMAT " > %u bytes",

   334           byte_count, G_MAXUINT32);

   335     } else {

   336       nbytes = byte_count;

   337       GST_DEBUG ("Setting number of bytes to %u", nbytes);

   338       nbytes = GUINT32_TO_BE (nbytes);

   339       memcpy (data, &nbytes, 4);

   340       xing_flags_tmp |= GST_XING_BYTES_FIELD;

   341       data += 4;

   342     }

   343   }

   344 

   345   if (xing->seek_table != NULL && byte_count != 0

   346       && duration != GST_CLOCK_TIME_NONE) {

   347     GList *it;

   348     gint percent = 0;

   349 

   350     xing_flags_tmp |= GST_XING_TOC_FIELD;

   351 

   352     GST_DEBUG ("Writing seek table");

   353     for (it = xing->seek_table; it != NULL && percent < 100; it = it->next) {

   354       GstXingSeekEntry *entry = (GstXingSeekEntry *) it->data;

   355       gint64 pos;

   356       guchar byte;

   357 

   358       while ((entry->timestamp * 100) / duration >= percent) {

   359         pos = (entry->byte * 256) / byte_count;

   360         GST_DEBUG ("  %d %% -- %" G_GINT64_FORMAT " 1/256", percent, pos);

   361         byte = (guchar) pos;

   362         memcpy (data, &byte, 1);

   363         data++;

   364         percent++;

   365       }

   366     }

   367 

   368     if (percent < 100) {

   369       guchar b;

   370       gint i;

   371 

   372       memcpy (&b, data - 1, 1);

   373 

   374       for (i = percent; i < 100; i++) {

   375         GST_DEBUG ("  %d %% -- %d 1/256", i, b);

   376         memcpy (data, &b, 1);

   377         data++;

   378       }

   379     }

   380   }

   381 

   382   GST_DEBUG ("Setting Xing flags to 0x%x\n", xing_flags_tmp);

   383   xing_flags_tmp = GUINT32_TO_BE (xing_flags_tmp);

   384   memcpy (xing_flags, &xing_flags_tmp, 4);

   385   return xing_header;

   386 }

   387 

   388 static void

   389 gst_xing_mux_base_init (gpointer g_class)

   390 {

   391   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

   392 

   393   static const GstElementDetails gst_xing_mux_details =

   394       GST_ELEMENT_DETAILS ("MP3 Xing muxer",

   395       "Formatter/Metadata",

   396       "Adds a Xing header to the beginning of a VBR MP3 file",

   397       "Christophe Fergeau <teuf@gnome.org>");

   398 

   399   gst_element_class_add_pad_template (element_class,

   400       gst_static_pad_template_get (&gst_xing_mux_src_template));

   401   gst_element_class_add_pad_template (element_class,

   402       gst_static_pad_template_get (&gst_xing_mux_sink_template));

   403 

   404   GST_DEBUG_CATEGORY_INIT (xing_mux_debug, "xingmux", 0, "Xing Header Muxer");

   405 

   406   gst_element_class_set_details (element_class, &gst_xing_mux_details);

   407 }

   408 

   409 static void

   410 gst_xing_mux_class_init (GstXingMuxClass * klass)

   411 {

   412   GObjectClass *gobject_class;

   413   GstElementClass *gstelement_class;

   414 

   415   gobject_class = (GObjectClass *) klass;

   416   gstelement_class = (GstElementClass *) klass;

   417 

   418   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_xing_mux_finalize);

   419   gstelement_class->change_state =

   420       GST_DEBUG_FUNCPTR (gst_xing_mux_change_state);

   421 }

   422 

   423 static void

   424 gst_xing_mux_finalize (GObject * obj)

   425 {

   426   GstXingMux *xing = GST_XING_MUX (obj);

   427 

   428   if (xing->adapter) {

   429     g_object_unref (xing->adapter);

   430     xing->adapter = NULL;

   431   }

   432 

   433   if (xing->seek_table) {

   434     g_list_foreach (xing->seek_table, (GFunc) gst_xing_seek_entry_free, NULL);

   435     g_list_free (xing->seek_table);

   436     xing->seek_table = NULL;

   437   }

   438 

   439   G_OBJECT_CLASS (parent_class)->finalize (obj);

   440 }

   441 

   442 static void

   443 xing_reset (GstXingMux * xing)

   444 {

   445   xing->duration = GST_CLOCK_TIME_NONE;

   446   xing->byte_count = 0;

   447 

   448   gst_adapter_clear (xing->adapter);

   449 

   450   if (xing->seek_table) {

   451     g_list_foreach (xing->seek_table, (GFunc) gst_xing_seek_entry_free, NULL);

   452     g_list_free (xing->seek_table);

   453     xing->seek_table = NULL;

   454   }

   455 

   456   xing->sent_xing = FALSE;

   457 }

   458 

   459 

   460 static void

   461 gst_xing_mux_init (GstXingMux * xing, GstXingMuxClass * xingmux_class)

   462 {

   463   GstElementClass *klass = GST_ELEMENT_CLASS (xingmux_class);

   464 

   465   /* pad through which data comes in to the element */

   466   xing->sinkpad =

   467       gst_pad_new_from_template (gst_element_class_get_pad_template (klass,

   468           "sink"), "sink");

   469   gst_pad_set_setcaps_function (xing->sinkpad,

   470       GST_DEBUG_FUNCPTR (gst_pad_proxy_setcaps));

   471   gst_pad_set_chain_function (xing->sinkpad,

   472       GST_DEBUG_FUNCPTR (gst_xing_mux_chain));

   473   gst_pad_set_event_function (xing->sinkpad,

   474       GST_DEBUG_FUNCPTR (gst_xing_mux_sink_event));

   475   gst_element_add_pad (GST_ELEMENT (xing), xing->sinkpad);

   476 

   477   /* pad through which data goes out of the element */

   478   xing->srcpad =

   479       gst_pad_new_from_template (gst_element_class_get_pad_template (klass,

   480           "src"), "src");

   481   gst_element_add_pad (GST_ELEMENT (xing), xing->srcpad);

   482 

   483   xing->adapter = gst_adapter_new ();

   484 

   485   xing_reset (xing);

   486 }

   487 

   488 static GstFlowReturn

   489 gst_xing_mux_chain (GstPad * pad, GstBuffer * buffer)

   490 {

   491   GstXingMux *xing = GST_XING_MUX (GST_PAD_PARENT (pad));

   492   GstFlowReturn ret = GST_FLOW_OK;

   493 

   494   gst_adapter_push (xing->adapter, buffer);

   495 

   496   while (gst_adapter_available (xing->adapter) >= 4) {

   497     const guchar *data = gst_adapter_peek (xing->adapter, 4);

   498     guint32 header;

   499     GstBuffer *outbuf;

   500     GstClockTime duration;

   501     guint size, spf;

   502     gulong rate;

   503     GstXingSeekEntry *seek_entry;

   504 

   505     header = GST_READ_UINT32_BE (data);

   506 

   507     if (!parse_header (header, &size, &spf, &rate)) {

   508       GST_DEBUG ("Lost sync, resyncing");

   509       gst_adapter_flush (xing->adapter, 1);

   510       continue;

   511     }

   512 

   513     if (gst_adapter_available (xing->adapter) < size)

   514       break;

   515 

   516     outbuf = gst_adapter_take_buffer (xing->adapter, size);

   517     gst_buffer_set_caps (outbuf, GST_PAD_CAPS (xing->srcpad));

   518 

   519     if (!xing->sent_xing) {

   520       if (has_xing_header (header, GST_BUFFER_DATA (outbuf), size)) {

   521         GST_LOG_OBJECT (xing, "Dropping old Xing header");

   522         gst_buffer_unref (outbuf);

   523         continue;

   524       } else {

   525         GstBuffer *xing_header;

   526         guint64 xing_header_size;

   527 

   528         xing->first_header = header;

   529 

   530         xing_header = generate_xing_header (xing);

   531 

   532         if (xing_header == NULL) {

   533           GST_ERROR ("Can't generate Xing header");

   534           gst_buffer_unref (outbuf);

   535           return GST_FLOW_ERROR;

   536         }

   537 

   538         xing_header_size = GST_BUFFER_SIZE (xing_header);

   539 

   540         if (GST_FLOW_IS_FATAL (ret = gst_pad_push (xing->srcpad, xing_header))) {

   541           GST_ERROR_OBJECT (xing, "Failed to push Xing header: %s",

   542               gst_flow_get_name (ret));

   543           gst_buffer_unref (xing_header);

   544           gst_buffer_unref (outbuf);

   545           return ret;

   546         }

   547 

   548         xing->byte_count += xing_header_size;

   549         xing->sent_xing = TRUE;

   550       }

   551     }

   552 

   553     seek_entry = gst_xing_seek_entry_new ();

   554     seek_entry->timestamp =

   555         (xing->duration == GST_CLOCK_TIME_NONE) ? 0 : xing->duration;

   556     /* Workaround for parsers checking that the first seek table entry is 0 */

   557     seek_entry->byte = (seek_entry->timestamp == 0) ? 0 : xing->byte_count;

   558     xing->seek_table = g_list_append (xing->seek_table, seek_entry);

   559 

   560     duration = gst_util_uint64_scale (spf, GST_SECOND, rate);

   561 

   562     GST_BUFFER_TIMESTAMP (outbuf) =

   563         (xing->duration == GST_CLOCK_TIME_NONE) ? 0 : xing->duration;

   564     GST_BUFFER_DURATION (outbuf) = duration;

   565     GST_BUFFER_OFFSET (outbuf) = xing->byte_count;

   566     GST_BUFFER_OFFSET_END (outbuf) =

   567         xing->byte_count + GST_BUFFER_SIZE (outbuf);

   568 

   569     xing->byte_count += GST_BUFFER_SIZE (outbuf);

   570 

   571     if (xing->duration == GST_CLOCK_TIME_NONE)

   572       xing->duration = duration;

   573     else

   574       xing->duration += duration;

   575 

   576     if (GST_FLOW_IS_FATAL (ret = gst_pad_push (xing->srcpad, outbuf))) {

   577       GST_ERROR_OBJECT (xing, "Failed to push MP3 frame: %s",

   578           gst_flow_get_name (ret));

   579       return ret;

   580     }

   581   }

   582 

   583   return ret;

   584 }

   585 

   586 static gboolean

   587 gst_xing_mux_sink_event (GstPad * pad, GstEvent * event)

   588 {

   589   GstXingMux *xing;

   590   gboolean result;

   591 

   592   xing = GST_XING_MUX (gst_pad_get_parent (pad));

   593 

   594   switch (GST_EVENT_TYPE (event)) {

   595     case GST_EVENT_NEWSEGMENT:

   596       if (xing->sent_xing) {

   597         GST_ERROR ("Already sent Xing header, dropping NEWSEGMENT event!");

   598         gst_event_unref (event);

   599         result = FALSE;

   600       } else {

   601         GstFormat fmt;

   602 

   603         gst_event_parse_new_segment (event, NULL, NULL, &fmt, NULL, NULL, NULL);

   604 

   605         if (fmt == GST_FORMAT_BYTES) {

   606           result = gst_pad_push_event (xing->srcpad, event);

   607         } else {

   608           gst_event_unref (event);

   609 

   610           event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,

   611               0, GST_CLOCK_TIME_NONE, 0);

   612 

   613           result = gst_pad_push_event (xing->srcpad, event);

   614         }

   615       }

   616       break;

   617 

   618     case GST_EVENT_EOS:{

   619       GstEvent *n_event;

   620 

   621       GST_DEBUG_OBJECT (xing, "handling EOS event");

   622 

   623       if (xing->sent_xing) {

   624 

   625         n_event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,

   626             0, GST_CLOCK_TIME_NONE, 0);

   627 

   628         if (G_UNLIKELY (!gst_pad_push_event (xing->srcpad, n_event))) {

   629           GST_WARNING

   630               ("Failed to seek to position 0 for pushing the Xing header");

   631         } else {

   632           GstBuffer *header;

   633           GstFlowReturn ret;

   634 

   635           header = generate_xing_header (xing);

   636 

   637           if (header == NULL) {

   638             GST_ERROR ("Can't generate Xing header");

   639           } else {

   640 

   641             GST_INFO ("Writing real Xing header to beginning of stream");

   642 

   643             if (GST_FLOW_IS_FATAL (ret = gst_pad_push (xing->srcpad, header)))

   644               GST_WARNING ("Failed to push updated Xing header: %s\n",

   645                   gst_flow_get_name (ret));

   646           }

   647         }

   648       }

   649       result = gst_pad_push_event (xing->srcpad, event);

   650       break;

   651     }

   652     default:

   653       result = gst_pad_event_default (pad, event);

   654       break;

   655   }

   656   gst_object_unref (GST_OBJECT (xing));

   657 

   658   return result;

   659 }

   660 

   661 

   662 static GstStateChangeReturn

   663 gst_xing_mux_change_state (GstElement * element, GstStateChange transition)

   664 {

   665   GstXingMux *xing;

   666   GstStateChangeReturn result;

   667 

   668   xing = GST_XING_MUX (element);

   669 

   670   result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);

   671 

   672   switch (transition) {

   673     case GST_STATE_CHANGE_PAUSED_TO_READY:

   674       xing_reset (xing);

   675       break;

   676     default:

   677       break;

   678   }

   679 

   680   return result;

   681 }