1 /* GStreamer

     2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>

     3  * Copyright (C) <2006-2007> Jan Schmidt <thaytan@mad.scientist.com>

     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 #ifdef HAVE_CONFIG_H

    22 #include "../../config.h"

    23 #endif

    24 

    25 #include <string.h>

    26 

    27 #include "gstmpegaudioparse.h"

    28 

    29 GST_DEBUG_CATEGORY_STATIC (mp3parse_debug);

    30 #define GST_CAT_DEFAULT mp3parse_debug

    31 

    32 #define MP3_CHANNEL_MODE_UNKNOWN -1

    33 #define MP3_CHANNEL_MODE_STEREO 0

    34 #define MP3_CHANNEL_MODE_JOINT_STEREO 1

    35 #define MP3_CHANNEL_MODE_DUAL_CHANNEL 2

    36 #define MP3_CHANNEL_MODE_MONO 3

    37 

    38 #define CRC_UNKNOWN -1

    39 #define CRC_PROTECTED 0

    40 #define CRC_NOT_PROTECTED 1

    41 

    42 #define XING_FRAMES_FLAG     0x0001

    43 #define XING_BYTES_FLAG      0x0002

    44 #define XING_TOC_FLAG        0x0004

    45 #define XING_VBR_SCALE_FLAG  0x0008

    46 

    47 #ifndef GST_READ_UINT24_BE

    48 #define GST_READ_UINT24_BE(p) (p[2] | (p[1] << 8) | (p[0] << 16))

    49 #endif

    50 

    51 /* Minimum number of consecutive, valid-looking frames to consider

    52    for resyncing */

    53 #define MIN_RESYNC_FRAMES 3

    54 

    55 static inline MPEGAudioSeekEntry *

    56 mpeg_audio_seek_entry_new ()

    57 {

    58   return g_slice_new (MPEGAudioSeekEntry);

    59 }

    60 

    61 static inline void

    62 mpeg_audio_seek_entry_free (MPEGAudioSeekEntry * entry)

    63 {

    64   g_slice_free (MPEGAudioSeekEntry, entry);

    65 }

    66 

    67 /* elementfactory information */

    68 static GstElementDetails mp3parse_details = {

    69   "MPEG1 Audio Parser",

    70   "Codec/Parser/Audio",

    71   "Parses and frames mpeg1 audio streams (levels 1-3), provides seek",

    72   "Jan Schmidt <thaytan@mad.scientist.com>\n"

    73       "Erik Walthinsen <omega@cse.ogi.edu>"

    74 };

    75 

    76 static GstStaticPadTemplate mp3_src_template = GST_STATIC_PAD_TEMPLATE ("src",

    77     GST_PAD_SRC,

    78     GST_PAD_ALWAYS,

    79     GST_STATIC_CAPS ("audio/mpeg, "

    80         "mpegversion = (int) 1, "

    81         "layer = (int) [ 1, 3 ], "

    82         "rate = (int) [ 8000, 48000 ], channels = (int) [ 1, 2 ],"

    83         "parsed=(boolean) true")

    84     );

    85 

    86 static GstStaticPadTemplate mp3_sink_template = GST_STATIC_PAD_TEMPLATE ("sink",

    87     GST_PAD_SINK,

    88     GST_PAD_ALWAYS,

    89     GST_STATIC_CAPS ("audio/mpeg, mpegversion = (int) 1, parsed=(boolean)false")

    90     );

    91 

    92 /* GstMPEGAudioParse signals and args */

    93 enum

    94 {

    95   /* FILL ME */

    96   LAST_SIGNAL

    97 };

    98 

    99 enum

   100 {

   101   ARG_0,

   102   ARG_SKIP,

   103   ARG_BIT_RATE

   104       /* FILL ME */

   105 };

   106 

   107 

   108 static void gst_mp3parse_class_init (GstMPEGAudioParseClass * klass);

   109 static void gst_mp3parse_base_init (gpointer klass);

   110 static void gst_mp3parse_init (GstMPEGAudioParse * mp3parse,

   111     GstMPEGAudioParseClass * klass);

   112 

   113 static gboolean gst_mp3parse_sink_event (GstPad * pad, GstEvent * event);

   114 static GstFlowReturn gst_mp3parse_chain (GstPad * pad, GstBuffer * buffer);

   115 static gboolean mp3parse_src_query (GstPad * pad, GstQuery * query);

   116 static const GstQueryType *mp3parse_get_query_types (GstPad * pad);

   117 static gboolean mp3parse_src_event (GstPad * pad, GstEvent * event);

   118 

   119 static int head_check (GstMPEGAudioParse * mp3parse, unsigned long head);

   120 

   121 static void gst_mp3parse_dispose (GObject * object);

   122 static void gst_mp3parse_set_property (GObject * object, guint prop_id,

   123     const GValue * value, GParamSpec * pspec);

   124 static void gst_mp3parse_get_property (GObject * object, guint prop_id,

   125     GValue * value, GParamSpec * pspec);

   126 static GstStateChangeReturn gst_mp3parse_change_state (GstElement * element,

   127     GstStateChange transition);

   128 static GstFlowReturn

   129 gst_mp3parse_handle_data (GstMPEGAudioParse * mp3parse, gboolean at_eos);

   130 

   131 static gboolean mp3parse_bytepos_to_time (GstMPEGAudioParse * mp3parse,

   132     gint64 bytepos, GstClockTime * ts, gboolean from_total_time);

   133 static gboolean

   134 mp3parse_total_bytes (GstMPEGAudioParse * mp3parse, gint64 * total);

   135 static gboolean

   136 mp3parse_total_time (GstMPEGAudioParse * mp3parse, GstClockTime * total);

   137 

   138 GST_BOILERPLATE (GstMPEGAudioParse, gst_mp3parse, GstElement, GST_TYPE_ELEMENT);

   139 

   140 #define GST_TYPE_MP3_CHANNEL_MODE (gst_mp3_channel_mode_get_type())

   141 

   142 static const GEnumValue mp3_channel_mode[] = {

   143   {MP3_CHANNEL_MODE_UNKNOWN, "Unknown", "unknown"},

   144   {MP3_CHANNEL_MODE_MONO, "Mono", "mono"},

   145   {MP3_CHANNEL_MODE_DUAL_CHANNEL, "Dual Channel", "dual-channel"},

   146   {MP3_CHANNEL_MODE_JOINT_STEREO, "Joint Stereo", "joint-stereo"},

   147   {MP3_CHANNEL_MODE_STEREO, "Stereo", "stereo"},

   148   {0, NULL, NULL},

   149 };

   150 

   151 static GType

   152 gst_mp3_channel_mode_get_type (void)

   153 {

   154   static GType mp3_channel_mode_type = 0;

   155 

   156   if (!mp3_channel_mode_type) {

   157     mp3_channel_mode_type =

   158         g_enum_register_static ("GstMp3ChannelMode", mp3_channel_mode);

   159   }

   160   return mp3_channel_mode_type;

   161 }

   162 

   163 static const gchar *

   164 gst_mp3_channel_mode_get_nick (gint mode)

   165 {

   166   guint i;

   167   for (i = 0; i < G_N_ELEMENTS (mp3_channel_mode); i++) {

   168     if (mp3_channel_mode[i].value == mode)

   169       return mp3_channel_mode[i].value_nick;

   170   }

   171   return NULL;

   172 }

   173 

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

   175   {

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

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

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

   179       },

   180   {

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

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

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

   184       },

   185 };

   186 

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

   188 {22050, 24000, 16000},

   189 {11025, 12000, 8000}

   190 };

   191 

   192 static inline guint

   193 mp3_type_frame_length_from_header (GstMPEGAudioParse * mp3parse, guint32 header,

   194     guint * put_version, guint * put_layer, guint * put_channels,

   195     guint * put_bitrate, guint * put_samplerate, guint * put_mode,

   196     guint * put_crc)

   197 {

   198   guint length;

   199   gulong mode, samplerate, bitrate, layer, channels, padding, crc;

   200   gulong version;

   201   gint lsf, mpg25;

   202 

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

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

   205     mpg25 = 0;

   206   } else {

   207     lsf = 1;

   208     mpg25 = 1;

   209   }

   210 

   211   version = 1 + lsf + mpg25;

   212 

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

   214 

   215   crc = (header >> 16) & 0x1;

   216 

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

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

   219   /* The caller has ensured we have a valid header, so bitrate can't be

   220      zero here. */

   221   g_assert (bitrate != 0);

   222 

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

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

   225 

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

   227 

   228   mode = (header >> 6) & 0x3;

   229   channels = (mode == 3) ? 1 : 2;

   230 

   231   switch (layer) {

   232     case 1:

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

   234       break;

   235     case 2:

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

   237       break;

   238     default:

   239     case 3:

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

   241       break;

   242   }

   243 

   244   GST_DEBUG_OBJECT (mp3parse, "Calculated mp3 frame length of %u bytes",

   245       length);

   246   GST_DEBUG_OBJECT (mp3parse, "samplerate = %lu, bitrate = %lu, version = %lu, "

   247       "layer = %lu, channels = %lu, mode = %s", samplerate, bitrate, version,

   248       layer, channels, gst_mp3_channel_mode_get_nick (mode));

   249 

   250   if (put_version)

   251     *put_version = version;

   252   if (put_layer)

   253     *put_layer = layer;

   254   if (put_channels)

   255     *put_channels = channels;

   256   if (put_bitrate)

   257     *put_bitrate = bitrate;

   258   if (put_samplerate)

   259     *put_samplerate = samplerate;

   260   if (put_mode)

   261     *put_mode = mode;

   262   if (put_crc)

   263     *put_crc = crc;

   264 

   265   return length;

   266 }

   267 

   268 static GstCaps *

   269 mp3_caps_create (guint version, guint layer, guint channels, guint samplerate)

   270 {

   271   GstCaps *new;

   272 

   273   g_assert (version);

   274   g_assert (layer);

   275   g_assert (samplerate);

   276   g_assert (channels);

   277 

   278   new = gst_caps_new_simple ("audio/mpeg",

   279       "mpegversion", G_TYPE_INT, 1,

   280       "mpegaudioversion", G_TYPE_INT, version,

   281       "layer", G_TYPE_INT, layer,

   282       "rate", G_TYPE_INT, samplerate,

   283       "channels", G_TYPE_INT, channels, "parsed", G_TYPE_BOOLEAN, TRUE, NULL);

   284 

   285   return new;

   286 }

   287 

   288 static void

   289 gst_mp3parse_base_init (gpointer klass)

   290 {

   291   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);

   292 

   293   gst_element_class_add_pad_template (element_class,

   294       gst_static_pad_template_get (&mp3_sink_template));

   295   gst_element_class_add_pad_template (element_class,

   296       gst_static_pad_template_get (&mp3_src_template));

   297 

   298   GST_DEBUG_CATEGORY_INIT (mp3parse_debug, "mp3parse", 0, "MPEG Audio Parser");

   299 

   300   gst_element_class_set_details (element_class, &mp3parse_details);

   301 }

   302 

   303 static void

   304 gst_mp3parse_class_init (GstMPEGAudioParseClass * klass)

   305 {

   306   GObjectClass *gobject_class;

   307   GstElementClass *gstelement_class;

   308 

   309   gobject_class = (GObjectClass *) klass;

   310   gstelement_class = (GstElementClass *) klass;

   311 

   312   parent_class = g_type_class_peek_parent (klass);

   313 

   314   gobject_class->set_property = gst_mp3parse_set_property;

   315   gobject_class->get_property = gst_mp3parse_get_property;

   316   gobject_class->dispose = gst_mp3parse_dispose;

   317 

   318   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SKIP,

   319       g_param_spec_int ("skip", "skip", "skip",

   320           G_MININT, G_MAXINT, 0, G_PARAM_READWRITE));

   321   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BIT_RATE,

   322       g_param_spec_int ("bitrate", "Bitrate", "Bit Rate",

   323           G_MININT, G_MAXINT, 0, G_PARAM_READABLE));

   324 

   325   gstelement_class->change_state = gst_mp3parse_change_state;

   326 

   327 /* register tags */

   328 #define GST_TAG_CRC    "has-crc"

   329 #define GST_TAG_MODE     "channel-mode"

   330 

   331   gst_tag_register (GST_TAG_CRC, GST_TAG_FLAG_META, G_TYPE_BOOLEAN,

   332       "has crc", "Using CRC", NULL);

   333   gst_tag_register (GST_TAG_MODE, GST_TAG_FLAG_ENCODED, G_TYPE_STRING,

   334       "channel mode", "MPEG audio channel mode", NULL);

   335 

   336   g_type_class_ref (GST_TYPE_MP3_CHANNEL_MODE);

   337 }

   338 

   339 static void

   340 gst_mp3parse_reset (GstMPEGAudioParse * mp3parse)

   341 {

   342   mp3parse->skip = 0;

   343   mp3parse->resyncing = TRUE;

   344   mp3parse->next_ts = GST_CLOCK_TIME_NONE;

   345   mp3parse->cur_offset = -1;

   346 

   347   mp3parse->sync_offset = 0;

   348   mp3parse->tracked_offset = 0;

   349   mp3parse->pending_ts = GST_CLOCK_TIME_NONE;

   350   mp3parse->pending_offset = -1;

   351 

   352   gst_adapter_clear (mp3parse->adapter);

   353 

   354   mp3parse->rate = mp3parse->channels = mp3parse->layer = -1;

   355   mp3parse->version = 1;

   356   mp3parse->max_bitreservoir = GST_CLOCK_TIME_NONE;

   357 

   358   mp3parse->avg_bitrate = 0;

   359   mp3parse->bitrate_sum = 0;

   360   mp3parse->last_posted_bitrate = 0;

   361   mp3parse->frame_count = 0;

   362   mp3parse->sent_codec_tag = FALSE;

   363 

   364   mp3parse->last_posted_crc = CRC_UNKNOWN;

   365   mp3parse->last_posted_channel_mode = MP3_CHANNEL_MODE_UNKNOWN;

   366 

   367   mp3parse->xing_flags = 0;

   368   mp3parse->xing_bitrate = 0;

   369   mp3parse->xing_frames = 0;

   370   mp3parse->xing_total_time = 0;

   371   mp3parse->xing_bytes = 0;

   372   mp3parse->xing_vbr_scale = 0;

   373   memset (mp3parse->xing_seek_table, 0, 100);

   374   memset (mp3parse->xing_seek_table_inverse, 0, 256);

   375 

   376   mp3parse->vbri_bitrate = 0;

   377   mp3parse->vbri_frames = 0;

   378   mp3parse->vbri_total_time = 0;

   379   mp3parse->vbri_bytes = 0;

   380   mp3parse->vbri_seek_points = 0;

   381   g_free (mp3parse->vbri_seek_table);

   382   mp3parse->vbri_seek_table = NULL;

   383 

   384   if (mp3parse->seek_table) {

   385     g_list_foreach (mp3parse->seek_table, (GFunc) mpeg_audio_seek_entry_free,

   386         NULL);

   387     g_list_free (mp3parse->seek_table);

   388     mp3parse->seek_table = NULL;

   389   }

   390 

   391   g_mutex_lock (mp3parse->pending_seeks_lock);

   392   if (mp3parse->pending_accurate_seeks) {

   393     g_slist_foreach (mp3parse->pending_accurate_seeks, (GFunc) g_free, NULL);

   394     g_slist_free (mp3parse->pending_accurate_seeks);

   395     mp3parse->pending_accurate_seeks = NULL;

   396   }

   397   if (mp3parse->pending_nonaccurate_seeks) {

   398     g_slist_foreach (mp3parse->pending_nonaccurate_seeks, (GFunc) g_free, NULL);

   399     g_slist_free (mp3parse->pending_nonaccurate_seeks);

   400     mp3parse->pending_nonaccurate_seeks = NULL;

   401   }

   402   g_mutex_unlock (mp3parse->pending_seeks_lock);

   403 

   404   if (mp3parse->pending_segment) {

   405     GstEvent **eventp = &mp3parse->pending_segment;

   406 

   407     gst_event_replace (eventp, NULL);

   408   }

   409 

   410   mp3parse->exact_position = FALSE;

   411   gst_segment_init (&mp3parse->segment, GST_FORMAT_TIME);

   412 }

   413 

   414 static void

   415 gst_mp3parse_init (GstMPEGAudioParse * mp3parse, GstMPEGAudioParseClass * klass)

   416 {

   417   mp3parse->sinkpad =

   418       gst_pad_new_from_static_template (&mp3_sink_template, "sink");

   419   gst_pad_set_event_function (mp3parse->sinkpad, gst_mp3parse_sink_event);

   420   gst_pad_set_chain_function (mp3parse->sinkpad, gst_mp3parse_chain);

   421   gst_element_add_pad (GST_ELEMENT (mp3parse), mp3parse->sinkpad);

   422 

   423   mp3parse->srcpad =

   424       gst_pad_new_from_static_template (&mp3_src_template, "src");

   425   gst_pad_use_fixed_caps (mp3parse->srcpad);

   426   gst_pad_set_event_function (mp3parse->srcpad, mp3parse_src_event);

   427   gst_pad_set_query_function (mp3parse->srcpad, mp3parse_src_query);

   428   gst_pad_set_query_type_function (mp3parse->srcpad, mp3parse_get_query_types);

   429   gst_element_add_pad (GST_ELEMENT (mp3parse), mp3parse->srcpad);

   430 

   431   mp3parse->adapter = gst_adapter_new ();

   432   mp3parse->pending_seeks_lock = g_mutex_new ();

   433 

   434   gst_mp3parse_reset (mp3parse);

   435 }

   436 

   437 static void

   438 gst_mp3parse_dispose (GObject * object)

   439 {

   440   GstMPEGAudioParse *mp3parse = GST_MP3PARSE (object);

   441 

   442   gst_mp3parse_reset (mp3parse);

   443 

   444   if (mp3parse->adapter) {

   445     g_object_unref (mp3parse->adapter);

   446     mp3parse->adapter = NULL;

   447   }

   448   g_mutex_free (mp3parse->pending_seeks_lock);

   449   mp3parse->pending_seeks_lock = NULL;

   450 

   451   g_list_foreach (mp3parse->pending_events, (GFunc) gst_mini_object_unref,

   452       NULL);

   453   g_list_free (mp3parse->pending_events);

   454   mp3parse->pending_events = NULL;

   455 

   456   G_OBJECT_CLASS (parent_class)->dispose (object);

   457 }

   458 

   459 static gboolean

   460 gst_mp3parse_sink_event (GstPad * pad, GstEvent * event)

   461 {

   462   gboolean res = TRUE;

   463   GstMPEGAudioParse *mp3parse;

   464   GstEvent **eventp;

   465 

   466   mp3parse = GST_MP3PARSE (gst_pad_get_parent (pad));

   467 

   468   switch (GST_EVENT_TYPE (event)) {

   469     case GST_EVENT_NEWSEGMENT:

   470     {

   471       gdouble rate, applied_rate;

   472       GstFormat format;

   473       gint64 start, stop, pos;

   474       gboolean update;

   475       MPEGAudioPendingAccurateSeek *seek = NULL;

   476       GSList *node;

   477 

   478       gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,

   479           &format, &start, &stop, &pos);

   480 

   481       g_mutex_lock (mp3parse->pending_seeks_lock);

   482       if (format == GST_FORMAT_BYTES && mp3parse->pending_accurate_seeks) {

   483 

   484         for (node = mp3parse->pending_accurate_seeks; node; node = node->next) {

   485           MPEGAudioPendingAccurateSeek *tmp = node->data;

   486 

   487           if (tmp->upstream_start == pos) {

   488             seek = tmp;

   489             break;

   490           }

   491         }

   492         if (seek) {

   493           GstSegment *s = &seek->segment;

   494 

   495           event =

   496               gst_event_new_new_segment_full (FALSE, s->rate, s->applied_rate,

   497               GST_FORMAT_TIME, s->start, s->stop, s->last_stop);

   498 

   499           mp3parse->segment = seek->segment;

   500 

   501           mp3parse->resyncing = FALSE;

   502           mp3parse->cur_offset = pos;

   503           mp3parse->next_ts = seek->timestamp_start;

   504           mp3parse->pending_ts = GST_CLOCK_TIME_NONE;

   505           mp3parse->tracked_offset = 0;

   506           mp3parse->sync_offset = 0;

   507 

   508           gst_event_parse_new_segment_full (event, &update, &rate,

   509               &applied_rate, &format, &start, &stop, &pos);

   510 

   511           GST_DEBUG_OBJECT (mp3parse,

   512               "Pushing accurate newseg rate %g, applied rate %g, "

   513               "format %d, start %" G_GINT64_FORMAT ", stop %" G_GINT64_FORMAT

   514               ", pos %" G_GINT64_FORMAT, rate, applied_rate, format, start,

   515               stop, pos);

   516 

   517           g_free (seek);

   518           mp3parse->pending_accurate_seeks =

   519               g_slist_delete_link (mp3parse->pending_accurate_seeks, node);

   520 

   521           g_mutex_unlock (mp3parse->pending_seeks_lock);

   522           res = gst_pad_push_event (mp3parse->srcpad, event);

   523 

   524           return res;

   525         } else {

   526           GST_WARNING_OBJECT (mp3parse,

   527               "Accurate seek not possible, didn't get an appropiate upstream segment");

   528         }

   529       }

   530       g_mutex_unlock (mp3parse->pending_seeks_lock);

   531 

   532       mp3parse->exact_position = FALSE;

   533 

   534       if (format == GST_FORMAT_BYTES) {

   535         GstClockTime seg_start, seg_stop, seg_pos;

   536 

   537         /* stop time is allowed to be open-ended, but not start & pos */

   538         if (!mp3parse_bytepos_to_time (mp3parse, stop, &seg_stop, FALSE))

   539           seg_stop = GST_CLOCK_TIME_NONE;

   540         if (mp3parse_bytepos_to_time (mp3parse, start, &seg_start, FALSE) &&

   541             mp3parse_bytepos_to_time (mp3parse, pos, &seg_pos, FALSE)) {

   542           gst_event_unref (event);

   543 

   544           /* search the pending nonaccurate seeks */

   545           g_mutex_lock (mp3parse->pending_seeks_lock);

   546           seek = NULL;

   547           for (node = mp3parse->pending_nonaccurate_seeks; node;

   548               node = node->next) {

   549             MPEGAudioPendingAccurateSeek *tmp = node->data;

   550 

   551             if (tmp->upstream_start == pos) {

   552               seek = tmp;

   553               break;

   554             }

   555           }

   556 

   557           if (seek) {

   558             if (seek->segment.stop == -1) {

   559               /* corrent the segment end, because non-accurate seeks might make

   560                * our streaming end earlier (see bug #603695) */

   561               seg_stop = -1;

   562             }

   563             g_free (seek);

   564             mp3parse->pending_nonaccurate_seeks =

   565                 g_slist_delete_link (mp3parse->pending_nonaccurate_seeks, node);

   566           }

   567           g_mutex_unlock (mp3parse->pending_seeks_lock);

   568 

   569           event = gst_event_new_new_segment_full (update, rate, applied_rate,

   570               GST_FORMAT_TIME, seg_start, seg_stop, seg_pos);

   571           format = GST_FORMAT_TIME;

   572           GST_DEBUG_OBJECT (mp3parse, "Converted incoming segment to TIME. "

   573               "start = %" GST_TIME_FORMAT ", stop = %" GST_TIME_FORMAT

   574               ", pos = %" GST_TIME_FORMAT, GST_TIME_ARGS (seg_start),

   575               GST_TIME_ARGS (seg_stop), GST_TIME_ARGS (seg_pos));

   576         }

   577       }

   578 

   579       if (format != GST_FORMAT_TIME) {

   580         /* Unknown incoming segment format. Output a default open-ended 

   581          * TIME segment */

   582         gst_event_unref (event);

   583         event = gst_event_new_new_segment_full (update, rate, applied_rate,

   584             GST_FORMAT_TIME, 0, GST_CLOCK_TIME_NONE, 0);

   585       }

   586 

   587       mp3parse->resyncing = TRUE;

   588       mp3parse->cur_offset = -1;

   589       mp3parse->next_ts = GST_CLOCK_TIME_NONE;

   590       mp3parse->pending_ts = GST_CLOCK_TIME_NONE;

   591       mp3parse->tracked_offset = 0;

   592       mp3parse->sync_offset = 0;

   593       /* also clear leftover data if clearing so much state */

   594       gst_adapter_clear (mp3parse->adapter);

   595 

   596       gst_event_parse_new_segment_full (event, &update, &rate, &applied_rate,

   597           &format, &start, &stop, &pos);

   598       GST_DEBUG_OBJECT (mp3parse, "Pushing newseg rate %g, applied rate %g, "

   599           "format %d, start %" G_GINT64_FORMAT ", stop %" G_GINT64_FORMAT

   600           ", pos %" G_GINT64_FORMAT, rate, applied_rate, format, start, stop,

   601           pos);

   602 

   603       gst_segment_set_newsegment_full (&mp3parse->segment, update, rate,

   604           applied_rate, format, start, stop, pos);

   605 

   606       /* save the segment for later, right before we push a new buffer so that

   607        * the caps are fixed and the next linked element can receive the segment. */

   608       eventp = &mp3parse->pending_segment;

   609       gst_event_replace (eventp, event);

   610       gst_event_unref (event);

   611       res = TRUE;

   612       break;

   613     }

   614     case GST_EVENT_FLUSH_STOP:

   615       /* Clear our adapter and set up for a new position */

   616       gst_adapter_clear (mp3parse->adapter);

   617       eventp = &mp3parse->pending_segment;

   618       gst_event_replace (eventp, NULL);

   619       res = gst_pad_push_event (mp3parse->srcpad, event);

   620       break;

   621     case GST_EVENT_EOS:

   622       /* If we haven't processed any frames yet, then make sure we process

   623          at least whatever's in our adapter */

   624       if (mp3parse->frame_count == 0) {

   625         gst_mp3parse_handle_data (mp3parse, TRUE);

   626 

   627         /* If we STILL have zero frames processed, fire an error */

   628         if (mp3parse->frame_count == 0) {

   629           GST_ELEMENT_ERROR (mp3parse, STREAM, WRONG_TYPE,

   630               ("No valid frames found before end of stream"), (NULL));

   631         }

   632       }

   633       /* fall through */

   634     default:

   635       if (mp3parse->pending_segment &&

   636           (GST_EVENT_TYPE (event) != GST_EVENT_EOS) &&

   637           (GST_EVENT_TYPE (event) != GST_EVENT_FLUSH_START)) {

   638         /* Cache all events except EOS and the ones above if we have

   639          * a pending segment */

   640         mp3parse->pending_events =

   641             g_list_append (mp3parse->pending_events, event);

   642       } else {

   643         res = gst_pad_push_event (mp3parse->srcpad, event);

   644       }

   645       break;

   646   }

   647 

   648   gst_object_unref (mp3parse);

   649 

   650   return res;

   651 }

   652 

   653 static void

   654 gst_mp3parse_add_index_entry (GstMPEGAudioParse * mp3parse, guint64 offset,

   655     GstClockTime ts)

   656 {

   657   MPEGAudioSeekEntry *entry, *last;

   658 

   659   if (G_LIKELY (mp3parse->seek_table != NULL)) {

   660     last = mp3parse->seek_table->data;

   661 

   662     if (last->byte >= offset)

   663       return;

   664 

   665     if (GST_CLOCK_DIFF (last->timestamp, ts) < mp3parse->idx_interval)

   666       return;

   667   }

   668 

   669   entry = mpeg_audio_seek_entry_new ();

   670   entry->byte = offset;

   671   entry->timestamp = ts;

   672   mp3parse->seek_table = g_list_prepend (mp3parse->seek_table, entry);

   673 

   674   GST_LOG_OBJECT (mp3parse, "Adding index entry %" GST_TIME_FORMAT " @ offset "

   675       "0x%08" G_GINT64_MODIFIER "x", GST_TIME_ARGS (ts), offset);

   676 }

   677 

   678 /* Prepare a buffer of the indicated size, timestamp it and output */

   679 static GstFlowReturn

   680 gst_mp3parse_emit_frame (GstMPEGAudioParse * mp3parse, guint size,

   681     guint mode, guint crc)

   682 {

   683   GstBuffer *outbuf;

   684   guint bitrate;

   685   GstFlowReturn ret = GST_FLOW_OK;

   686   GstClockTime push_start;

   687   GstTagList *taglist;

   688 

   689   outbuf = gst_adapter_take_buffer (mp3parse->adapter, size);

   690 

   691   GST_BUFFER_DURATION (outbuf) =

   692       gst_util_uint64_scale (GST_SECOND, mp3parse->spf, mp3parse->rate);

   693 

   694   GST_BUFFER_OFFSET (outbuf) = mp3parse->cur_offset;

   695 

   696   /* Check if we have a pending timestamp from an incoming buffer to apply

   697    * here */

   698   if (GST_CLOCK_TIME_IS_VALID (mp3parse->pending_ts)) {

   699     if (mp3parse->tracked_offset >= mp3parse->pending_offset) {

   700       /* If the incoming timestamp differs from our expected by more than 

   701        * half a frame, then take it instead of our calculated timestamp.

   702        * This avoids creating imperfect streams just because of 

   703        * quantization in the container timestamping */

   704       GstClockTimeDiff diff = mp3parse->next_ts - mp3parse->pending_ts;

   705       GstClockTimeDiff thresh = GST_BUFFER_DURATION (outbuf) / 2;

   706 

   707       if (diff < -thresh || diff > thresh) {

   708         GST_DEBUG_OBJECT (mp3parse, "Updating next_ts from %" GST_TIME_FORMAT

   709             " to pending ts %" GST_TIME_FORMAT

   710             " at offset %" G_GINT64_FORMAT " (pending offset was %"

   711             G_GINT64_FORMAT ")", GST_TIME_ARGS (mp3parse->next_ts),

   712             GST_TIME_ARGS (mp3parse->pending_ts), mp3parse->tracked_offset,

   713             mp3parse->pending_offset);

   714         mp3parse->next_ts = mp3parse->pending_ts;

   715       }

   716       mp3parse->pending_ts = GST_CLOCK_TIME_NONE;

   717     }

   718   }

   719 

   720   /* Decide what timestamp we're going to apply */

   721   if (GST_CLOCK_TIME_IS_VALID (mp3parse->next_ts)) {

   722     GST_BUFFER_TIMESTAMP (outbuf) = mp3parse->next_ts;

   723   } else {

   724     GstClockTime ts;

   725 

   726     /* No timestamp yet, convert our offset to a timestamp if we can, or

   727      * start at 0 */

   728     if (mp3parse_bytepos_to_time (mp3parse, mp3parse->cur_offset, &ts, FALSE) &&

   729         GST_CLOCK_TIME_IS_VALID (ts))

   730       GST_BUFFER_TIMESTAMP (outbuf) = ts;

   731     else {

   732       GST_BUFFER_TIMESTAMP (outbuf) = 0;

   733     }

   734   }

   735 

   736   if (GST_BUFFER_TIMESTAMP (outbuf) == 0)

   737     mp3parse->exact_position = TRUE;

   738 

   739   if (mp3parse->seekable &&

   740       mp3parse->exact_position && GST_BUFFER_TIMESTAMP_IS_VALID (outbuf) &&

   741       mp3parse->cur_offset != GST_BUFFER_OFFSET_NONE) {

   742     gst_mp3parse_add_index_entry (mp3parse, mp3parse->cur_offset,

   743         GST_BUFFER_TIMESTAMP (outbuf));

   744   }

   745 

   746   /* Update our byte offset tracking */

   747   if (mp3parse->cur_offset != -1) {

   748     mp3parse->cur_offset += size;

   749   }

   750   mp3parse->tracked_offset += size;

   751 

   752   if (GST_BUFFER_TIMESTAMP_IS_VALID (outbuf))

   753     mp3parse->next_ts =

   754         GST_BUFFER_TIMESTAMP (outbuf) + GST_BUFFER_DURATION (outbuf);

   755 

   756   gst_buffer_set_caps (outbuf, GST_PAD_CAPS (mp3parse->srcpad));

   757 

   758   /* Post a bitrate tag if we need to before pushing the buffer */

   759   if (mp3parse->xing_bitrate != 0)

   760     bitrate = mp3parse->xing_bitrate;

   761   else if (mp3parse->vbri_bitrate != 0)

   762     bitrate = mp3parse->vbri_bitrate;

   763   else

   764     bitrate = mp3parse->avg_bitrate;

   765 

   766   /* we will create a taglist (if any of the parameters has changed)

   767    * to add the tags that changed */

   768   taglist = NULL;

   769   if ((mp3parse->last_posted_bitrate / 10000) != (bitrate / 10000)) {

   770     taglist = gst_tag_list_new ();

   771     mp3parse->last_posted_bitrate = bitrate;

   772     gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_BITRATE,

   773         mp3parse->last_posted_bitrate, NULL);

   774 

   775     /* Post a new duration message if the average bitrate changes that much

   776      * so applications can update their cached values

   777      */

   778     if ((mp3parse->xing_flags & XING_TOC_FLAG) == 0

   779         && mp3parse->vbri_total_time == 0) {

   780       gst_element_post_message (GST_ELEMENT (mp3parse),

   781           gst_message_new_duration (GST_OBJECT (mp3parse), GST_FORMAT_TIME,

   782               -1));

   783     }

   784   }

   785 

   786   if (mp3parse->last_posted_crc != crc) {

   787     gboolean using_crc;

   788 

   789     if (!taglist) {

   790       taglist = gst_tag_list_new ();

   791     }

   792     mp3parse->last_posted_crc = crc;

   793     if (mp3parse->last_posted_crc == CRC_PROTECTED) {

   794       using_crc = TRUE;

   795     } else {

   796       using_crc = FALSE;

   797     }

   798     gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_CRC,

   799         using_crc, NULL);

   800   }

   801 

   802   if (mp3parse->last_posted_channel_mode != mode) {

   803     if (!taglist) {

   804       taglist = gst_tag_list_new ();

   805     }

   806     mp3parse->last_posted_channel_mode = mode;

   807 

   808     gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_MODE,

   809         gst_mp3_channel_mode_get_nick (mode), NULL);

   810   }

   811 

   812   /* if the taglist exists, we need to send it */

   813   if (taglist) {

   814     gst_element_found_tags_for_pad (GST_ELEMENT (mp3parse),

   815         mp3parse->srcpad, taglist);

   816   }

   817 

   818   /* We start pushing 9 frames earlier (29 frames for MPEG2) than

   819    * segment start to be able to decode the first frame we want.

   820    * 9 (29) frames are the theoretical maximum of frames that contain

   821    * data for the current frame (bit reservoir).

   822    */

   823   if (mp3parse->segment.start == 0) {

   824     push_start = 0;

   825   } else if (GST_CLOCK_TIME_IS_VALID (mp3parse->max_bitreservoir)) {

   826     if (GST_CLOCK_TIME_IS_VALID (mp3parse->segment.start) &&

   827         mp3parse->segment.start > mp3parse->max_bitreservoir)

   828       push_start = mp3parse->segment.start - mp3parse->max_bitreservoir;

   829     else

   830       push_start = 0;

   831   } else {

   832     push_start = mp3parse->segment.start;

   833   }

   834 

   835   if (G_UNLIKELY ((GST_CLOCK_TIME_IS_VALID (push_start) &&

   836               GST_BUFFER_TIMESTAMP_IS_VALID (outbuf) &&

   837               GST_BUFFER_TIMESTAMP (outbuf) + GST_BUFFER_DURATION (outbuf)

   838               < push_start))) {

   839     GST_DEBUG_OBJECT (mp3parse,

   840         "Buffer before configured segment range %" GST_TIME_FORMAT

   841         " to %" GST_TIME_FORMAT ", dropping, timestamp %"

   842         GST_TIME_FORMAT " duration %" GST_TIME_FORMAT

   843         ", offset 0x%08" G_GINT64_MODIFIER "x", GST_TIME_ARGS (push_start),

   844         GST_TIME_ARGS (mp3parse->segment.stop),

   845         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),

   846         GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)),

   847         GST_BUFFER_OFFSET (outbuf));

   848 

   849     gst_buffer_unref (outbuf);

   850     ret = GST_FLOW_OK;

   851   } else if (G_UNLIKELY (GST_BUFFER_TIMESTAMP_IS_VALID (outbuf) &&

   852           GST_CLOCK_TIME_IS_VALID (mp3parse->segment.stop) &&

   853           GST_BUFFER_TIMESTAMP (outbuf) >=

   854           mp3parse->segment.stop + GST_BUFFER_DURATION (outbuf))) {

   855     /* Some mp3 streams have an offset in the timestamps, for which we have to

   856      * push the frame *after* the end position in order for the decoder to be

   857      * able to decode everything up until the segment.stop position.

   858      * That is the reason of the calculated offset */

   859     GST_DEBUG_OBJECT (mp3parse,

   860         "Buffer after configured segment range %" GST_TIME_FORMAT " to %"

   861         GST_TIME_FORMAT ", returning GST_FLOW_UNEXPECTED, timestamp %"

   862         GST_TIME_FORMAT " duration %" GST_TIME_FORMAT ", offset 0x%08"

   863         G_GINT64_MODIFIER "x", GST_TIME_ARGS (push_start),

   864         GST_TIME_ARGS (mp3parse->segment.stop),

   865         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),

   866         GST_TIME_ARGS (GST_BUFFER_DURATION (outbuf)),

   867         GST_BUFFER_OFFSET (outbuf));

   868 

   869     gst_buffer_unref (outbuf);

   870     ret = GST_FLOW_UNEXPECTED;

   871   } else {

   872     GST_DEBUG_OBJECT (mp3parse,

   873         "pushing buffer of %d bytes, timestamp %" GST_TIME_FORMAT

   874         ", offset 0x%08" G_GINT64_MODIFIER "x", size,

   875         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),

   876         GST_BUFFER_OFFSET (outbuf));

   877     mp3parse->segment.last_stop = GST_BUFFER_TIMESTAMP (outbuf);

   878     /* push any pending segment now */

   879     if (mp3parse->pending_segment) {

   880       gst_pad_push_event (mp3parse->srcpad, mp3parse->pending_segment);

   881       mp3parse->pending_segment = NULL;

   882     }

   883     if (mp3parse->pending_events) {

   884       GList *l;

   885 

   886       for (l = mp3parse->pending_events; l != NULL; l = l->next) {

   887         gst_pad_push_event (mp3parse->srcpad, GST_EVENT (l->data));

   888       }

   889       g_list_free (mp3parse->pending_events);

   890       mp3parse->pending_events = NULL;

   891     }

   892 

   893     /* set discont if needed */

   894     if (mp3parse->discont) {

   895       GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);

   896       mp3parse->discont = FALSE;

   897     }

   898 

   899     ret = gst_pad_push (mp3parse->srcpad, outbuf);

   900   }

   901 

   902   return ret;

   903 }

   904 

   905 static void

   906 gst_mp3parse_handle_first_frame (GstMPEGAudioParse * mp3parse)

   907 {

   908   GstTagList *taglist;

   909   gchar *codec;

   910   const guint32 xing_id = 0x58696e67;   /* 'Xing' in hex */

   911   const guint32 info_id = 0x496e666f;   /* 'Info' in hex - found in LAME CBR files */

   912   const guint32 vbri_id = 0x56425249;   /* 'VBRI' in hex */

   913 

   914   gint offset;

   915 

   916   guint64 avail;

   917   gint64 upstream_total_bytes = 0;

   918   guint32 read_id;

   919   const guint8 *data;

   920 

   921   /* Output codec tag */

   922   if (!mp3parse->sent_codec_tag) {

   923     if (mp3parse->layer == 3) {

   924       codec = g_strdup_printf ("MPEG %d Audio, Layer %d (MP3)",

   925           mp3parse->version, mp3parse->layer);

   926     } else {

   927       codec = g_strdup_printf ("MPEG %d Audio, Layer %d",

   928           mp3parse->version, mp3parse->layer);

   929     }

   930 

   931     taglist = gst_tag_list_new ();

   932     gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE,

   933         GST_TAG_AUDIO_CODEC, codec, NULL);

   934     gst_element_found_tags_for_pad (GST_ELEMENT (mp3parse),

   935         mp3parse->srcpad, taglist);

   936     g_free (codec);

   937 

   938     mp3parse->sent_codec_tag = TRUE;

   939   }

   940   /* end setting the tag */

   941 

   942   /* Check first frame for Xing info */

   943   if (mp3parse->version == 1) { /* MPEG-1 file */

   944     if (mp3parse->channels == 1)

   945       offset = 0x11;

   946     else

   947       offset = 0x20;

   948   } else {                      /* MPEG-2 header */

   949     if (mp3parse->channels == 1)

   950       offset = 0x09;

   951     else

   952       offset = 0x11;

   953   }

   954   /* Skip the 4 bytes of the MP3 header too */

   955   offset += 4;

   956 

   957   /* Check if we have enough data to read the Xing header */

   958   avail = gst_adapter_available (mp3parse->adapter);

   959 

   960   if (avail < offset + 8)

   961     return;

   962 

   963   data = gst_adapter_peek (mp3parse->adapter, offset + 8);

   964   if (data == NULL)

   965     return;

   966   /* The header starts at the provided offset */

   967   data += offset;

   968 

   969   /* obtain real upstream total bytes */

   970   mp3parse_total_bytes (mp3parse, &upstream_total_bytes);

   971 

   972   read_id = GST_READ_UINT32_BE (data);

   973   if (read_id == xing_id || read_id == info_id) {

   974     guint32 xing_flags;

   975     guint bytes_needed = offset + 8;

   976     gint64 total_bytes;

   977     GstClockTime total_time;

   978 

   979     GST_DEBUG_OBJECT (mp3parse, "Found Xing header marker 0x%x", xing_id);

   980 

   981     /* Read 4 base bytes of flags, big-endian */

   982     xing_flags = GST_READ_UINT32_BE (data + 4);

   983     if (xing_flags & XING_FRAMES_FLAG)

   984       bytes_needed += 4;

   985     if (xing_flags & XING_BYTES_FLAG)

   986       bytes_needed += 4;

   987     if (xing_flags & XING_TOC_FLAG)

   988       bytes_needed += 100;

   989     if (xing_flags & XING_VBR_SCALE_FLAG)

   990       bytes_needed += 4;

   991     if (avail < bytes_needed) {

   992       GST_DEBUG_OBJECT (mp3parse,

   993           "Not enough data to read Xing header (need %d)", bytes_needed);

   994       return;

   995     }

   996 

   997     GST_DEBUG_OBJECT (mp3parse, "Reading Xing header");

   998     mp3parse->xing_flags = xing_flags;

   999     data = gst_adapter_peek (mp3parse->adapter, bytes_needed);

  1000     data += offset + 8;

  1001 

  1002     if (xing_flags & XING_FRAMES_FLAG) {

  1003       mp3parse->xing_frames = GST_READ_UINT32_BE (data);

  1004       if (mp3parse->xing_frames == 0) {

  1005         GST_WARNING_OBJECT (mp3parse,

  1006             "Invalid number of frames in Xing header");

  1007         mp3parse->xing_flags &= ~XING_FRAMES_FLAG;

  1008       } else {

  1009         mp3parse->xing_total_time = gst_util_uint64_scale (GST_SECOND,

  1010             (guint64) (mp3parse->xing_frames) * (mp3parse->spf),

  1011             mp3parse->rate);

  1012       }

  1013 

  1014       data += 4;

  1015     } else {

  1016       mp3parse->xing_frames = 0;

  1017       mp3parse->xing_total_time = 0;

  1018     }

  1019 

  1020     if (xing_flags & XING_BYTES_FLAG) {

  1021       mp3parse->xing_bytes = GST_READ_UINT32_BE (data);

  1022       if (mp3parse->xing_bytes == 0) {

  1023         GST_WARNING_OBJECT (mp3parse, "Invalid number of bytes in Xing header");

  1024         mp3parse->xing_flags &= ~XING_BYTES_FLAG;

  1025       }

  1026 

  1027       data += 4;

  1028     } else {

  1029       mp3parse->xing_bytes = 0;

  1030     }

  1031 

  1032     /* If we know the upstream size and duration, compute the

  1033      * total bitrate, rounded up to the nearest kbit/sec */

  1034     if ((total_time = mp3parse->xing_total_time) &&

  1035         (total_bytes = mp3parse->xing_bytes)) {

  1036       mp3parse->xing_bitrate = gst_util_uint64_scale (total_bytes,

  1037           8 * GST_SECOND, total_time);

  1038       mp3parse->xing_bitrate += 500;

  1039       mp3parse->xing_bitrate -= mp3parse->xing_bitrate % 1000;

  1040     }

  1041 

  1042     if (xing_flags & XING_TOC_FLAG) {

  1043       int i, percent = 0;

  1044       guchar *table = mp3parse->xing_seek_table;

  1045       guchar old = 0, new;

  1046       guint first;

  1047 

  1048       first = data[0];

  1049       GST_DEBUG_OBJECT (mp3parse,

  1050           "Subtracting initial offset of %d bytes from Xing TOC", first);

  1051 

  1052       /* xing seek table: percent time -> 1/256 bytepos */

  1053       for (i = 0; i < 100; i++) {

  1054         new = data[i] - first;

  1055         if (old > new) {

  1056           GST_WARNING_OBJECT (mp3parse, "Skipping broken Xing TOC");

  1057           mp3parse->xing_flags &= ~XING_TOC_FLAG;

  1058           goto skip_toc;

  1059         }

  1060         mp3parse->xing_seek_table[i] = old = new;

  1061       }

  1062 

  1063       /* build inverse table: 1/256 bytepos -> 1/100 percent time */

  1064       for (i = 0; i < 256; i++) {

  1065         while (percent < 99 && table[percent + 1] <= i)

  1066           percent++;

  1067 

  1068         if (table[percent] == i) {

  1069           mp3parse->xing_seek_table_inverse[i] = percent * 100;

  1070         } else if (table[percent] < i && percent < 99) {

  1071           gdouble fa, fb, fx;

  1072           gint a = percent, b = percent + 1;

  1073 

  1074           fa = table[a];

  1075           fb = table[b];

  1076           fx = (b - a) / (fb - fa) * (i - fa) + a;

  1077           mp3parse->xing_seek_table_inverse[i] = (guint16) (fx * 100);

  1078         } else if (percent == 99) {

  1079           gdouble fa, fb, fx;

  1080           gint a = percent, b = 100;

  1081 

  1082           fa = table[a];

  1083           fb = 256.0;

  1084           fx = (b - a) / (fb - fa) * (i - fa) + a;

  1085           mp3parse->xing_seek_table_inverse[i] = (guint16) (fx * 100);

  1086         }

  1087       }

  1088     skip_toc:

  1089       data += 100;

  1090     } else {

  1091       memset (mp3parse->xing_seek_table, 0, 100);

  1092       memset (mp3parse->xing_seek_table_inverse, 0, 256);

  1093     }

  1094 

  1095     if (xing_flags & XING_VBR_SCALE_FLAG) {

  1096       mp3parse->xing_vbr_scale = GST_READ_UINT32_BE (data);

  1097     } else

  1098       mp3parse->xing_vbr_scale = 0;

  1099 

  1100     GST_DEBUG_OBJECT (mp3parse, "Xing header reported %u frames, time %"

  1101         GST_TIME_FORMAT ", %u bytes, vbr scale %u", mp3parse->xing_frames,

  1102         GST_TIME_ARGS (mp3parse->xing_total_time), mp3parse->xing_bytes,

  1103         mp3parse->xing_vbr_scale);

  1104 

  1105     /* check for truncated file */

  1106     if (upstream_total_bytes && mp3parse->xing_bytes &&

  1107         mp3parse->xing_bytes * 0.8 > upstream_total_bytes) {

  1108       GST_WARNING_OBJECT (mp3parse, "File appears to have been truncated; "

  1109           "invalidating Xing header duration and size");

  1110       mp3parse->xing_flags &= ~XING_BYTES_FLAG;

  1111       mp3parse->xing_flags &= ~XING_FRAMES_FLAG;

  1112     }

  1113   } else if (read_id == vbri_id) {

  1114     gint64 total_bytes, total_frames;

  1115     GstClockTime total_time;

  1116     guint16 nseek_points;

  1117 

  1118     GST_DEBUG_OBJECT (mp3parse, "Found VBRI header marker 0x%x", vbri_id);

  1119     if (avail < offset + 26) {

  1120       GST_DEBUG_OBJECT (mp3parse,

  1121           "Not enough data to read VBRI header (need %d)", offset + 26);

  1122       return;

  1123     }

  1124 

  1125     GST_DEBUG_OBJECT (mp3parse, "Reading VBRI header");

  1126     data = gst_adapter_peek (mp3parse->adapter, offset + 26);

  1127     data += offset + 4;

  1128 

  1129     if (GST_READ_UINT16_BE (data) != 0x0001) {

  1130       GST_WARNING_OBJECT (mp3parse,

  1131           "Unsupported VBRI version 0x%x", GST_READ_UINT16_BE (data));

  1132       return;

  1133     }

  1134     data += 2;