gst/wavparse/gstwavparse.c

   1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: t; c-basic-offset: 2 -*- */
   2 /* GStreamer
   3  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   4  * Copyright (C) <2006> Nokia Corporation, Stefan Kost <stefan.kost@nokia.com>.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 /**
  23  * SECTION:element-wavparse
  24  *
  25  * Parse a .wav file into raw or compressed audio.
  26  *
  27  * Wavparse supports both push and pull mode operations, making it possible to
  28  * stream from a network source.
  29  *
  30  * <refsect2>
  31  * <title>Example launch line</title>
  32  * |[
  33  * gst-launch-1.0 filesrc location=sine.wav ! wavparse ! audioconvert ! alsasink
  34  * ]| Read a wav file and output to the soundcard using the ALSA element. The
  35  * wav file is assumed to contain raw uncompressed samples.
  36  * |[
  37  * gst-launch-1.0 gnomevfssrc location=http://www.example.org/sine.wav ! queue ! wavparse ! audioconvert ! alsasink
  38  * ]| Stream data from a network url.
  39  * </refsect2>
  40  */
  41
  42 /*
  43  * TODO:
  44  * http://replaygain.hydrogenaudio.org/file_format_wav.html
  45  */
  46
  47 #ifdef HAVE_CONFIG_H
  48 #include "config.h"
  49 #endif
  50
  51 #include <string.h>
  52 #include <math.h>
  53
  54 #include "gstwavparse.h"
  55 #include "gst/riff/riff-media.h"
  56 #include <gst/base/gsttypefindhelper.h>
  57 #include <gst/gst-i18n-plugin.h>
  58
  59 GST_DEBUG_CATEGORY_STATIC (wavparse_debug);
  60 #define GST_CAT_DEFAULT (wavparse_debug)
  61
  62 /* Data size chunk of RF64,
  63  * see http://tech.ebu.ch/docs/tech/tech3306-2009.pdf */
  64 #define GST_RS64_TAG_DS64 GST_MAKE_FOURCC ('d','s','6','4')
  65
  66 static void gst_wavparse_dispose (GObject * object);
  67
  68 static gboolean gst_wavparse_sink_activate (GstPad * sinkpad,
  69     GstObject * parent);
  70 static gboolean gst_wavparse_sink_activate_mode (GstPad * sinkpad,
  71     GstObject * parent, GstPadMode mode, gboolean active);
  72 static gboolean gst_wavparse_send_event (GstElement * element,
  73     GstEvent * event);
  74 static GstStateChangeReturn gst_wavparse_change_state (GstElement * element,
  75     GstStateChange transition);
  76
  77 static gboolean gst_wavparse_pad_query (GstPad * pad, GstObject * parent,
  78     GstQuery * query);
  79 static gboolean gst_wavparse_pad_convert (GstPad * pad, GstFormat src_format,
  80     gint64 src_value, GstFormat * dest_format, gint64 * dest_value);
  81
  82 static GstFlowReturn gst_wavparse_chain (GstPad * pad, GstObject * parent,
  83     GstBuffer * buf);
  84 static gboolean gst_wavparse_sink_event (GstPad * pad, GstObject * parent,
  85     GstEvent * event);
  86 static void gst_wavparse_loop (GstPad * pad);
  87 static gboolean gst_wavparse_srcpad_event (GstPad * pad, GstObject * parent,
  88     GstEvent * event);
  89
  90 static void gst_wavparse_set_property (GObject * object, guint prop_id,
  91     const GValue * value, GParamSpec * pspec);
  92 static void gst_wavparse_get_property (GObject * object, guint prop_id,
  93     GValue * value, GParamSpec * pspec);
  94
  95 #define DEFAULT_IGNORE_LENGTH FALSE
  96
  97 enum
  98 {
  99   PROP_0,
 100   PROP_IGNORE_LENGTH,
 101 };
 102
 103 static GstStaticPadTemplate sink_template_factory =
 104 GST_STATIC_PAD_TEMPLATE ("sink",
 105     GST_PAD_SINK,
 106     GST_PAD_ALWAYS,
 107     GST_STATIC_CAPS ("audio/x-wav")
 108     );
 109
 110 #define DEBUG_INIT \
 111   GST_DEBUG_CATEGORY_INIT (wavparse_debug, "wavparse", 0, "WAV parser");
 112
 113 #define gst_wavparse_parent_class parent_class
 114 G_DEFINE_TYPE_WITH_CODE (GstWavParse, gst_wavparse, GST_TYPE_ELEMENT,
 115     DEBUG_INIT);
 116
 117 typedef struct
 118 {
 119   /* Offset Size    Description   Value
 120    * 0x00   4       ID            unique identification value
 121    * 0x04   4       Position      play order position
 122    * 0x08   4       Data Chunk ID RIFF ID of corresponding data chunk
 123    * 0x0c   4       Chunk Start   Byte Offset of Data Chunk *
 124    * 0x10   4       Block Start   Byte Offset to sample of First Channel
 125    * 0x14   4       Sample Offset Byte Offset to sample byte of First Channel
 126    */
 127   guint32 id;
 128   guint32 position;
 129   guint32 data_chunk_id;
 130   guint32 chunk_start;
 131   guint32 block_start;
 132   guint32 sample_offset;
 133 } GstWavParseCue;
 134
 135 typedef struct
 136 {
 137   /* Offset Size    Description     Value
 138    * 0x08   4       Cue Point ID    0 - 0xFFFFFFFF
 139    * 0x0c           Text
 140    */
 141   guint32 cue_point_id;
 142   gchar *text;
 143 } GstWavParseLabl, GstWavParseNote;
 144
 145 static void
 146 gst_wavparse_class_init (GstWavParseClass * klass)
 147 {
 148   GstElementClass *gstelement_class;
 149   GObjectClass *object_class;
 150   GstPadTemplate *src_template;
 151
 152   gstelement_class = (GstElementClass *) klass;
 153   object_class = (GObjectClass *) klass;
 154
 155   parent_class = g_type_class_peek_parent (klass);
 156
 157   object_class->dispose = gst_wavparse_dispose;
 158
 159   object_class->set_property = gst_wavparse_set_property;
 160   object_class->get_property = gst_wavparse_get_property;
 161
 162   /**
 163    * GstWavParse:ignore-length:
 164    *
 165    * This selects whether the length found in a data chunk
 166    * should be ignored. This may be useful for streamed audio
 167    * where the length is unknown until the end of streaming,
 168    * and various software/hardware just puts some random value
 169    * in there and hopes it doesn't break too much.
 170    */
 171   g_object_class_install_property (object_class, PROP_IGNORE_LENGTH,
 172       g_param_spec_boolean ("ignore-length",
 173           "Ignore length",
 174           "Ignore length from the Wave header",
 175           DEFAULT_IGNORE_LENGTH, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
 176       );
 177
 178   gstelement_class->change_state = gst_wavparse_change_state;
 179   gstelement_class->send_event = gst_wavparse_send_event;
 180
 181   /* register pads */
 182   gst_element_class_add_static_pad_template (gstelement_class,
 183       &sink_template_factory);
 184
 185   src_template = gst_pad_template_new ("src", GST_PAD_SRC,
 186       GST_PAD_ALWAYS, gst_riff_create_audio_template_caps ());
 187   gst_element_class_add_pad_template (gstelement_class, src_template);
 188
 189   gst_element_class_set_static_metadata (gstelement_class, "WAV audio demuxer",
 190       "Codec/Demuxer/Audio",
 191       "Parse a .wav file into raw audio",
 192       "Erik Walthinsen <omega@cse.ogi.edu>");
 193 }
 194
 195 static void
 196 gst_wavparse_reset (GstWavParse * wav)
 197 {
 198   wav->state = GST_WAVPARSE_START;
 199
 200   /* These will all be set correctly in the fmt chunk */
 201   wav->depth = 0;
 202   wav->rate = 0;
 203   wav->width = 0;
 204   wav->channels = 0;
 205   wav->blockalign = 0;
 206   wav->bps = 0;
 207   wav->fact = 0;
 208   wav->offset = 0;
 209   wav->end_offset = 0;
 210   wav->dataleft = 0;
 211   wav->datasize = 0;
 212   wav->datastart = 0;
 213   wav->duration = 0;
 214   wav->got_fmt = FALSE;
 215   wav->first = TRUE;
 216
 217   if (wav->seek_event)
 218     gst_event_unref (wav->seek_event);
 219   wav->seek_event = NULL;
 220   if (wav->adapter) {
 221     gst_adapter_clear (wav->adapter);
 222     g_object_unref (wav->adapter);
 223     wav->adapter = NULL;
 224   }
 225   if (wav->tags)
 226     gst_tag_list_unref (wav->tags);
 227   wav->tags = NULL;
 228   if (wav->toc)
 229     gst_toc_unref (wav->toc);
 230   wav->toc = NULL;
 231   if (wav->cues)
 232     g_list_free_full (wav->cues, g_free);
 233   wav->cues = NULL;
 234   if (wav->labls)
 235     g_list_free_full (wav->labls, g_free);
 236   wav->labls = NULL;
 237   if (wav->caps)
 238     gst_caps_unref (wav->caps);
 239   wav->caps = NULL;
 240   if (wav->start_segment)
 241     gst_event_unref (wav->start_segment);
 242   wav->start_segment = NULL;
 243 }
 244
 245 static void
 246 gst_wavparse_dispose (GObject * object)
 247 {
 248   GstWavParse *wav = GST_WAVPARSE (object);
 249
 250   GST_DEBUG_OBJECT (wav, "WAV: Dispose");
 251   gst_wavparse_reset (wav);
 252
 253   G_OBJECT_CLASS (parent_class)->dispose (object);
 254 }
 255
 256 static void
 257 gst_wavparse_init (GstWavParse * wavparse)
 258 {
 259   gst_wavparse_reset (wavparse);
 260
 261   /* sink */
 262   wavparse->sinkpad =
 263       gst_pad_new_from_static_template (&sink_template_factory, "sink");
 264   gst_pad_set_activate_function (wavparse->sinkpad,
 265       GST_DEBUG_FUNCPTR (gst_wavparse_sink_activate));
 266   gst_pad_set_activatemode_function (wavparse->sinkpad,
 267       GST_DEBUG_FUNCPTR (gst_wavparse_sink_activate_mode));
 268   gst_pad_set_chain_function (wavparse->sinkpad,
 269       GST_DEBUG_FUNCPTR (gst_wavparse_chain));
 270   gst_pad_set_event_function (wavparse->sinkpad,
 271       GST_DEBUG_FUNCPTR (gst_wavparse_sink_event));
 272   gst_element_add_pad (GST_ELEMENT_CAST (wavparse), wavparse->sinkpad);
 273
 274   /* src */
 275   wavparse->srcpad =
 276       gst_pad_new_from_template (gst_element_class_get_pad_template
 277       (GST_ELEMENT_GET_CLASS (wavparse), "src"), "src");
 278   gst_pad_use_fixed_caps (wavparse->srcpad);
 279   gst_pad_set_query_function (wavparse->srcpad,
 280       GST_DEBUG_FUNCPTR (gst_wavparse_pad_query));
 281   gst_pad_set_event_function (wavparse->srcpad,
 282       GST_DEBUG_FUNCPTR (gst_wavparse_srcpad_event));
 283   gst_element_add_pad (GST_ELEMENT_CAST (wavparse), wavparse->srcpad);
 284 }
 285
 286 static gboolean
 287 gst_wavparse_parse_file_header (GstElement * element, GstBuffer * buf)
 288 {
 289   guint32 doctype;
 290
 291   if (!gst_riff_parse_file_header (element, buf, &doctype))
 292     return FALSE;
 293
 294   if (doctype != GST_RIFF_RIFF_WAVE)
 295     goto not_wav;
 296
 297   return TRUE;
 298
 299   /* ERRORS */
 300 not_wav:
 301   {
 302     GST_ELEMENT_ERROR (element, STREAM, WRONG_TYPE, (NULL),
 303         ("File is not a WAVE file: 0x%" G_GINT32_MODIFIER "x", doctype));
 304     return FALSE;
 305   }
 306 }
 307
 308 static GstFlowReturn
 309 gst_wavparse_stream_init (GstWavParse * wav)
 310 {
 311   GstFlowReturn res;
 312   GstBuffer *buf = NULL;
 313
 314   if ((res = gst_pad_pull_range (wav->sinkpad,
 315               wav->offset, 12, &buf)) != GST_FLOW_OK)
 316     return res;
 317   else if (!gst_wavparse_parse_file_header (GST_ELEMENT_CAST (wav), buf))
 318     return GST_FLOW_ERROR;
 319
 320   wav->offset += 12;
 321
 322   return GST_FLOW_OK;
 323 }
 324
 325 static gboolean
 326 gst_wavparse_time_to_bytepos (GstWavParse * wav, gint64 ts, gint64 * bytepos)
 327 {
 328   /* -1 always maps to -1 */
 329   if (ts == -1) {
 330     *bytepos = -1;
 331     return TRUE;
 332   }
 333
 334   /* 0 always maps to 0 */
 335   if (ts == 0) {
 336     *bytepos = 0;
 337     return TRUE;
 338   }
 339
 340   if (wav->bps > 0) {
 341     *bytepos = gst_util_uint64_scale_ceil (ts, (guint64) wav->bps, GST_SECOND);
 342     return TRUE;
 343   } else if (wav->fact) {
 344     guint64 bps = gst_util_uint64_scale (wav->datasize, wav->rate, wav->fact);
 345     *bytepos = gst_util_uint64_scale_ceil (ts, bps, GST_SECOND);
 346     return TRUE;
 347   }
 348
 349   return FALSE;
 350 }
 351
 352 /* This function is used to perform seeks on the element.
 353  *
 354  * It also works when event is NULL, in which case it will just
 355  * start from the last configured segment. This technique is
 356  * used when activating the element and to perform the seek in
 357  * READY.
 358  */
 359 static gboolean
 360 gst_wavparse_perform_seek (GstWavParse * wav, GstEvent * event)
 361 {
 362   gboolean res;
 363   gdouble rate;
 364   GstFormat format, bformat;
 365   GstSeekFlags flags;
 366   GstSeekType cur_type = GST_SEEK_TYPE_NONE, stop_type;
 367   gint64 cur, stop, upstream_size;
 368   gboolean flush;
 369   gboolean update;
 370   GstSegment seeksegment = { 0, };
 371   gint64 last_stop;
 372   guint32 seqnum = 0;
 373
 374   if (event) {
 375     GST_DEBUG_OBJECT (wav, "doing seek with event");
 376
 377     gst_event_parse_seek (event, &rate, &format, &flags,
 378         &cur_type, &cur, &stop_type, &stop);
 379     seqnum = gst_event_get_seqnum (event);
 380
 381     /* no negative rates yet */
 382     if (rate < 0.0)
 383       goto negative_rate;
 384
 385     if (format != wav->segment.format) {
 386       GST_INFO_OBJECT (wav, "converting seek-event from %s to %s",
 387           gst_format_get_name (format),
 388           gst_format_get_name (wav->segment.format));
 389       res = TRUE;
 390       if (cur_type != GST_SEEK_TYPE_NONE)
 391         res =
 392             gst_pad_query_convert (wav->srcpad, format, cur,
 393             wav->segment.format, &cur);
 394       if (res && stop_type != GST_SEEK_TYPE_NONE)
 395         res =
 396             gst_pad_query_convert (wav->srcpad, format, stop,
 397             wav->segment.format, &stop);
 398       if (!res)
 399         goto no_format;
 400
 401       format = wav->segment.format;
 402     }
 403   } else {
 404     GST_DEBUG_OBJECT (wav, "doing seek without event");
 405     flags = 0;
 406     rate = 1.0;
 407     cur_type = GST_SEEK_TYPE_SET;
 408     stop_type = GST_SEEK_TYPE_SET;
 409   }
 410
 411   /* in push mode, we must delegate to upstream */
 412   if (wav->streaming) {
 413     gboolean res = FALSE;
 414
 415     /* if streaming not yet started; only prepare initial newsegment */
 416     if (!event || wav->state != GST_WAVPARSE_DATA) {
 417       if (wav->start_segment)
 418         gst_event_unref (wav->start_segment);
 419       wav->start_segment = gst_event_new_segment (&wav->segment);
 420       res = TRUE;
 421     } else {
 422       /* convert seek positions to byte positions in data sections */
 423       if (format == GST_FORMAT_TIME) {
 424         /* should not fail */
 425         if (!gst_wavparse_time_to_bytepos (wav, cur, &cur))
 426           goto no_position;
 427         if (!gst_wavparse_time_to_bytepos (wav, stop, &stop))
 428           goto no_position;
 429       }
 430       /* mind sample boundary and header */
 431       if (cur >= 0) {
 432         cur -= (cur % wav->bytes_per_sample);
 433         cur += wav->datastart;
 434       }
 435       if (stop >= 0) {
 436         stop -= (stop % wav->bytes_per_sample);
 437         stop += wav->datastart;
 438       }
 439       GST_DEBUG_OBJECT (wav, "Pushing BYTE seek rate %g, "
 440           "start %" G_GINT64_FORMAT ", stop %" G_GINT64_FORMAT, rate, cur,
 441           stop);
 442       /* BYTE seek event */
 443       event = gst_event_new_seek (rate, GST_FORMAT_BYTES, flags, cur_type, cur,
 444           stop_type, stop);
 445       gst_event_set_seqnum (event, seqnum);
 446       res = gst_pad_push_event (wav->sinkpad, event);
 447     }
 448     return res;
 449   }
 450
 451   /* get flush flag */
 452   flush = flags & GST_SEEK_FLAG_FLUSH;
 453
 454   /* now we need to make sure the streaming thread is stopped. We do this by
 455    * either sending a FLUSH_START event downstream which will cause the
 456    * streaming thread to stop with a WRONG_STATE.
 457    * For a non-flushing seek we simply pause the task, which will happen as soon
 458    * as it completes one iteration (and thus might block when the sink is
 459    * blocking in preroll). */
 460   if (flush) {
 461     GstEvent *fevent;
 462     GST_DEBUG_OBJECT (wav, "sending flush start");
 463
 464     fevent = gst_event_new_flush_start ();
 465     gst_event_set_seqnum (fevent, seqnum);
 466     gst_pad_push_event (wav->sinkpad, gst_event_ref (fevent));
 467     gst_pad_push_event (wav->srcpad, fevent);
 468   } else {
 469     gst_pad_pause_task (wav->sinkpad);
 470   }
 471
 472   /* we should now be able to grab the streaming thread because we stopped it
 473    * with the above flush/pause code */
 474   GST_PAD_STREAM_LOCK (wav->sinkpad);
 475
 476   /* save current position */
 477   last_stop = wav->segment.position;
 478
 479   GST_DEBUG_OBJECT (wav, "stopped streaming at %" G_GINT64_FORMAT, last_stop);
 480
 481   /* copy segment, we need this because we still need the old
 482    * segment when we close the current segment. */
 483   memcpy (&seeksegment, &wav->segment, sizeof (GstSegment));
 484
 485   /* configure the seek parameters in the seeksegment. We will then have the
 486    * right values in the segment to perform the seek */
 487   if (event) {
 488     GST_DEBUG_OBJECT (wav, "configuring seek");
 489     gst_segment_do_seek (&seeksegment, rate, format, flags,
 490         cur_type, cur, stop_type, stop, &update);
 491   }
 492
 493   /* figure out the last position we need to play. If it's configured (stop !=
 494    * -1), use that, else we play until the total duration of the file */
 495   if ((stop = seeksegment.stop) == -1)
 496     stop = seeksegment.duration;
 497
 498   GST_DEBUG_OBJECT (wav, "cur_type =%d", cur_type);
 499   if ((cur_type != GST_SEEK_TYPE_NONE)) {
 500     /* bring offset to bytes, if the bps is 0, we have the segment in BYTES and
 501      * we can just copy the last_stop. If not, we use the bps to convert TIME to
 502      * bytes. */
 503     if (!gst_wavparse_time_to_bytepos (wav, seeksegment.position,
 504             (gint64 *) & wav->offset))
 505       wav->offset = seeksegment.position;
 506     GST_LOG_OBJECT (wav, "offset=%" G_GUINT64_FORMAT, wav->offset);
 507     wav->offset -= (wav->offset % wav->bytes_per_sample);
 508     GST_LOG_OBJECT (wav, "offset=%" G_GUINT64_FORMAT, wav->offset);
 509     wav->offset += wav->datastart;
 510     GST_LOG_OBJECT (wav, "offset=%" G_GUINT64_FORMAT, wav->offset);
 511   } else {
 512     GST_LOG_OBJECT (wav, "continue from offset=%" G_GUINT64_FORMAT,
 513         wav->offset);
 514   }
 515
 516   if (stop_type != GST_SEEK_TYPE_NONE) {
 517     if (!gst_wavparse_time_to_bytepos (wav, stop, (gint64 *) & wav->end_offset))
 518       wav->end_offset = stop;
 519     GST_LOG_OBJECT (wav, "end_offset=%" G_GUINT64_FORMAT, wav->end_offset);
 520     wav->end_offset -= (wav->end_offset % wav->bytes_per_sample);
 521     GST_LOG_OBJECT (wav, "end_offset=%" G_GUINT64_FORMAT, wav->end_offset);
 522     wav->end_offset += wav->datastart;
 523     GST_LOG_OBJECT (wav, "end_offset=%" G_GUINT64_FORMAT, wav->end_offset);
 524   } else {
 525     GST_LOG_OBJECT (wav, "continue to end_offset=%" G_GUINT64_FORMAT,
 526         wav->end_offset);
 527   }
 528
 529   /* make sure filesize is not exceeded due to rounding errors or so,
 530    * same precaution as in _stream_headers */
 531   bformat = GST_FORMAT_BYTES;
 532   if (gst_pad_peer_query_duration (wav->sinkpad, bformat, &upstream_size))
 533     wav->end_offset = MIN (wav->end_offset, upstream_size);
 534
 535   if (wav->datasize > 0 && wav->end_offset > wav->datastart + wav->datasize)
 536     wav->end_offset = wav->datastart + wav->datasize;
 537
 538   /* this is the range of bytes we will use for playback */
 539   wav->offset = MIN (wav->offset, wav->end_offset);
 540   wav->dataleft = wav->end_offset - wav->offset;
 541
 542   GST_DEBUG_OBJECT (wav,
 543       "seek: rate %lf, offset %" G_GUINT64_FORMAT ", end %" G_GUINT64_FORMAT
 544       ", segment %" GST_TIME_FORMAT " -- %" GST_TIME_FORMAT, rate, wav->offset,
 545       wav->end_offset, GST_TIME_ARGS (seeksegment.start), GST_TIME_ARGS (stop));
 546
 547   /* prepare for streaming again */
 548   if (flush) {
 549     GstEvent *fevent;
 550
 551     /* if we sent a FLUSH_START, we now send a FLUSH_STOP */
 552     GST_DEBUG_OBJECT (wav, "sending flush stop");
 553
 554     fevent = gst_event_new_flush_stop (TRUE);
 555     gst_event_set_seqnum (fevent, seqnum);
 556     gst_pad_push_event (wav->sinkpad, gst_event_ref (fevent));
 557     gst_pad_push_event (wav->srcpad, fevent);
 558   }
 559
 560   /* now we did the seek and can activate the new segment values */
 561   memcpy (&wav->segment, &seeksegment, sizeof (GstSegment));
 562
 563   /* if we're doing a segment seek, post a SEGMENT_START message */
 564   if (wav->segment.flags & GST_SEEK_FLAG_SEGMENT) {
 565     gst_element_post_message (GST_ELEMENT_CAST (wav),
 566         gst_message_new_segment_start (GST_OBJECT_CAST (wav),
 567             wav->segment.format, wav->segment.position));
 568   }
 569
 570   /* now create the newsegment */
 571   GST_DEBUG_OBJECT (wav, "Creating newsegment from %" G_GINT64_FORMAT
 572       " to %" G_GINT64_FORMAT, wav->segment.position, stop);
 573
 574   /* store the newsegment event so it can be sent from the streaming thread. */
 575   if (wav->start_segment)
 576     gst_event_unref (wav->start_segment);
 577   wav->start_segment = gst_event_new_segment (&wav->segment);
 578   gst_event_set_seqnum (wav->start_segment, seqnum);
 579
 580   /* mark discont if we are going to stream from another position. */
 581   if (last_stop != wav->segment.position) {
 582     GST_DEBUG_OBJECT (wav, "mark DISCONT, we did a seek to another position");
 583     wav->discont = TRUE;
 584   }
 585
 586   /* and start the streaming task again */
 587   if (!wav->streaming) {
 588     gst_pad_start_task (wav->sinkpad, (GstTaskFunction) gst_wavparse_loop,
 589         wav->sinkpad, NULL);
 590   }
 591
 592   GST_PAD_STREAM_UNLOCK (wav->sinkpad);
 593
 594   return TRUE;
 595
 596   /* ERRORS */
 597 negative_rate:
 598   {
 599     GST_DEBUG_OBJECT (wav, "negative playback rates are not supported yet.");
 600     return FALSE;
 601   }
 602 no_format:
 603   {
 604     GST_DEBUG_OBJECT (wav, "unsupported format given, seek aborted.");
 605     return FALSE;
 606   }
 607 no_position:
 608   {
 609     GST_DEBUG_OBJECT (wav,
 610         "Could not determine byte position for desired time");
 611     return FALSE;
 612   }
 613 }
 614
 615 /*
 616  * gst_wavparse_peek_chunk_info:
 617  * @wav Wavparse object
 618  * @tag holder for tag
 619  * @size holder for tag size
 620  *
 621  * Peek next chunk info (tag and size)
 622  *
 623  * Returns: %TRUE when the chunk info (header) is available
 624  */
 625 static gboolean
 626 gst_wavparse_peek_chunk_info (GstWavParse * wav, guint32 * tag, guint32 * size)
 627 {
 628   const guint8 *data = NULL;
 629
 630   if (gst_adapter_available (wav->adapter) < 8)
 631     return FALSE;
 632
 633   data = gst_adapter_map (wav->adapter, 8);
 634   *tag = GST_READ_UINT32_LE (data);
 635   *size = GST_READ_UINT32_LE (data + 4);
 636   gst_adapter_unmap (wav->adapter);
 637
 638   GST_DEBUG ("Next chunk size is %u bytes, type %" GST_FOURCC_FORMAT, *size,
 639       GST_FOURCC_ARGS (*tag));
 640
 641   return TRUE;
 642 }
 643
 644 /*
 645  * gst_wavparse_peek_chunk:
 646  * @wav Wavparse object
 647  * @tag holder for tag
 648  * @size holder for tag size
 649  *
 650  * Peek enough data for one full chunk
 651  *
 652  * Returns: %TRUE when the full chunk is available
 653  */
 654 static gboolean
 655 gst_wavparse_peek_chunk (GstWavParse * wav, guint32 * tag, guint32 * size)
 656 {
 657   guint32 peek_size = 0;
 658   guint available;
 659
 660   if (!gst_wavparse_peek_chunk_info (wav, tag, size))
 661     return FALSE;
 662
 663   /* size 0 -> empty data buffer would surprise most callers,
 664    * large size -> do not bother trying to squeeze that into adapter,
 665    * so we throw poor man's exception, which can be caught if caller really
 666    * wants to handle 0 size chunk */
 667   if (!(*size) || (*size) >= (1 << 30)) {
 668     GST_INFO ("Invalid/unexpected chunk size %u for tag %" GST_FOURCC_FORMAT,
 669         *size, GST_FOURCC_ARGS (*tag));
 670     /* chain should give up */
 671     wav->abort_buffering = TRUE;
 672     return FALSE;
 673   }
 674   peek_size = (*size + 1) & ~1;
 675   available = gst_adapter_available (wav->adapter);
 676
 677   if (available >= (8 + peek_size)) {
 678     return TRUE;
 679   } else {
 680     GST_LOG ("but only %u bytes available now", available);
 681     return FALSE;
 682   }
 683 }
 684
 685 /*
 686  * gst_wavparse_calculate_duration:
 687  * @wav: wavparse object
 688  *
 689  * Calculate duration on demand and store in @wav. Prefer bps, but use fact as a
 690  * fallback.
 691  *
 692  * Returns: %TRUE if duration is available.
 693  */
 694 static gboolean
 695 gst_wavparse_calculate_duration (GstWavParse * wav)
 696 {
 697   if (wav->duration > 0)
 698     return TRUE;
 699
 700   if (wav->bps > 0) {
 701     GST_INFO_OBJECT (wav, "Got datasize %" G_GUINT64_FORMAT, wav->datasize);
 702     wav->duration =
 703         gst_util_uint64_scale_ceil (wav->datasize, GST_SECOND,
 704         (guint64) wav->bps);
 705     GST_INFO_OBJECT (wav, "Got duration (bps) %" GST_TIME_FORMAT,
 706         GST_TIME_ARGS (wav->duration));
 707     return TRUE;
 708   } else if (wav->fact) {
 709     wav->duration =
 710         gst_util_uint64_scale_ceil (GST_SECOND, wav->fact, wav->rate);
 711     GST_INFO_OBJECT (wav, "Got duration (fact) %" GST_TIME_FORMAT,
 712         GST_TIME_ARGS (wav->duration));
 713     return TRUE;
 714   }
 715   return FALSE;
 716 }
 717
 718 static gboolean
 719 gst_waveparse_ignore_chunk (GstWavParse * wav, GstBuffer * buf, guint32 tag,
 720     guint32 size)
 721 {
 722   guint flush;
 723
 724   if (wav->streaming) {
 725     if (!gst_wavparse_peek_chunk (wav, &tag, &size))
 726       return FALSE;
 727   }
 728   GST_DEBUG_OBJECT (wav, "Ignoring tag %" GST_FOURCC_FORMAT,
 729       GST_FOURCC_ARGS (tag));
 730   flush = 8 + ((size + 1) & ~1);
 731   wav->offset += flush;
 732   if (wav->streaming) {
 733     gst_adapter_flush (wav->adapter, flush);
 734   } else {
 735     gst_buffer_unref (buf);
 736   }
 737
 738   return TRUE;
 739 }
 740
 741 /*
 742  * gst_wavparse_cue_chunk:
 743  * @wav GstWavParse object
 744  * @data holder for data
 745  * @size holder for data size
 746  *
 747  * Parse cue chunk from @data to wav->cues.
 748  *
 749  * Returns: %TRUE when cue chunk is available
 750  */
 751 static gboolean
 752 gst_wavparse_cue_chunk (GstWavParse * wav, const guint8 * data, guint32 size)
 753 {
 754   guint32 i, ncues;
 755   GList *cues = NULL;
 756   GstWavParseCue *cue;
 757
 758   if (wav->cues) {
 759     GST_WARNING_OBJECT (wav, "found another cue's");
 760     return TRUE;
 761   }
 762
 763   ncues = GST_READ_UINT32_LE (data);
 764
 765   if (size < 4 + ncues * 24) {
 766     GST_WARNING_OBJECT (wav, "broken file %d %d", size, ncues);
 767     return FALSE;
 768   }
 769
 770   /* parse data */
 771   data += 4;
 772   for (i = 0; i < ncues; i++) {
 773     cue = g_new0 (GstWavParseCue, 1);
 774     cue->id = GST_READ_UINT32_LE (data);
 775     cue->position = GST_READ_UINT32_LE (data + 4);
 776     cue->data_chunk_id = GST_READ_UINT32_LE (data + 8);
 777     cue->chunk_start = GST_READ_UINT32_LE (data + 12);
 778     cue->block_start = GST_READ_UINT32_LE (data + 16);
 779     cue->sample_offset = GST_READ_UINT32_LE (data + 20);
 780     cues = g_list_append (cues, cue);
 781     data += 24;
 782   }
 783
 784   wav->cues = cues;
 785
 786   return TRUE;
 787 }
 788
 789 /*
 790  * gst_wavparse_labl_chunk:
 791  * @wav GstWavParse object
 792  * @data holder for data
 793  * @size holder for data size
 794  *
 795  * Parse labl from @data to wav->labls.
 796  *
 797  * Returns: %TRUE when labl chunk is available
 798  */
 799 static gboolean
 800 gst_wavparse_labl_chunk (GstWavParse * wav, const guint8 * data, guint32 size)
 801 {
 802   GstWavParseLabl *labl;
 803
 804   if (size < 5)
 805     return FALSE;
 806
 807   labl = g_new0 (GstWavParseLabl, 1);
 808
 809   /* parse data */
 810   data += 8;
 811   labl->cue_point_id = GST_READ_UINT32_LE (data);
 812   labl->text = g_memdup (data + 4, size - 4);
 813
 814   wav->labls = g_list_append (wav->labls, labl);
 815
 816   return TRUE;
 817 }
 818
 819 /*
 820  * gst_wavparse_note_chunk:
 821  * @wav GstWavParse object
 822  * @data holder for data
 823  * @size holder for data size
 824  *
 825  * Parse note from @data to wav->notes.
 826  *
 827  * Returns: %TRUE when note chunk is available
 828  */
 829 static gboolean
 830 gst_wavparse_note_chunk (GstWavParse * wav, const guint8 * data, guint32 size)
 831 {
 832   GstWavParseNote *note;
 833
 834   if (size < 5)
 835     return FALSE;
 836
 837   note = g_new0 (GstWavParseNote, 1);
 838
 839   /* parse data */
 840   data += 8;
 841   note->cue_point_id = GST_READ_UINT32_LE (data);
 842   note->text = g_memdup (data + 4, size - 4);
 843
 844   wav->notes = g_list_append (wav->notes, note);
 845
 846   return TRUE;
 847 }
 848
 849 /*
 850  * gst_wavparse_smpl_chunk:
 851  * @wav GstWavParse object
 852  * @data holder for data
 853  * @size holder for data size
 854  *
 855  * Parse smpl chunk from @data.
 856  *
 857  * Returns: %TRUE when cue chunk is available
 858  */
 859 static gboolean
 860 gst_wavparse_smpl_chunk (GstWavParse * wav, const guint8 * data, guint32 size)
 861 {
 862   guint32 note_number;
 863
 864   /*
 865      manufacturer_id = GST_READ_UINT32_LE (data);
 866      product_id = GST_READ_UINT32_LE (data + 4);
 867      sample_period = GST_READ_UINT32_LE (data + 8);
 868    */
 869   note_number = GST_READ_UINT32_LE (data + 12);
 870   /*
 871      pitch_fraction = GST_READ_UINT32_LE (data + 16);
 872      SMPTE_format = GST_READ_UINT32_LE (data + 20);
 873      SMPTE_offset = GST_READ_UINT32_LE (data + 24);
 874      num_sample_loops = GST_READ_UINT32_LE (data + 28);
 875      List of Sample Loops, 24 bytes each
 876    */
 877
 878   if (!wav->tags)
 879     wav->tags = gst_tag_list_new_empty ();
 880   gst_tag_list_add (wav->tags, GST_TAG_MERGE_REPLACE,
 881       GST_TAG_MIDI_BASE_NOTE, (guint) note_number, NULL);
 882   return TRUE;
 883 }
 884
 885 /*
 886  * gst_wavparse_adtl_chunk:
 887  * @wav GstWavParse object
 888  * @data holder for data
 889  * @size holder for data size
 890  *
 891  * Parse adtl from @data.
 892  *
 893  * Returns: %TRUE when adtl chunk is available
 894  */
 895 static gboolean
 896 gst_wavparse_adtl_chunk (GstWavParse * wav, const guint8 * data, guint32 size)
 897 {
 898   guint32 ltag, lsize, offset = 0;
 899
 900   while (size >= 8) {
 901     ltag = GST_READ_UINT32_LE (data + offset);
 902     lsize = GST_READ_UINT32_LE (data + offset + 4);
 903
 904     if (lsize + 8 > size) {
 905       GST_WARNING_OBJECT (wav, "Invalid adtl size: %u + 8 > %u", lsize, size);
 906       return FALSE;
 907     }
 908
 909     switch (ltag) {
 910       case GST_RIFF_TAG_labl:
 911         gst_wavparse_labl_chunk (wav, data + offset, size);
 912         break;
 913       case GST_RIFF_TAG_note:
 914         gst_wavparse_note_chunk (wav, data + offset, size);
 915         break;
 916       default:
 917         GST_WARNING_OBJECT (wav, "Unknowm adtl %" GST_FOURCC_FORMAT,
 918             GST_FOURCC_ARGS (ltag));
 919         GST_MEMDUMP_OBJECT (wav, "Unknowm adtl", &data[offset], lsize);
 920         break;
 921     }
 922     offset += 8 + GST_ROUND_UP_2 (lsize);
 923     size -= 8 + GST_ROUND_UP_2 (lsize);
 924   }
 925
 926   return TRUE;
 927 }
 928
 929 static GstTagList *
 930 gst_wavparse_get_tags_toc_entry (GstToc * toc, gchar * id)
 931 {
 932   GstTagList *tags = NULL;
 933   GstTocEntry *entry = NULL;
 934
 935   entry = gst_toc_find_entry (toc, id);
 936   if (entry != NULL) {
 937     tags = gst_toc_entry_get_tags (entry);
 938     if (tags == NULL) {
 939       tags = gst_tag_list_new_empty ();
 940       gst_toc_entry_set_tags (entry, tags);
 941     }
 942   }
 943
 944   return tags;
 945 }
 946
 947 /*
 948  * gst_wavparse_create_toc:
 949  * @wav GstWavParse object
 950  *
 951  * Create TOC from wav->cues and wav->labls.
 952  */
 953 static gboolean
 954 gst_wavparse_create_toc (GstWavParse * wav)
 955 {
 956   gint64 start, stop;
 957   gchar *id;
 958   GList *list;
 959   GstWavParseCue *cue;
 960   GstWavParseLabl *labl;
 961   GstWavParseNote *note;
 962   GstTagList *tags;
 963   GstToc *toc;
 964   GstTocEntry *entry = NULL, *cur_subentry = NULL, *prev_subentry = NULL;
 965
 966   GST_OBJECT_LOCK (wav);
 967   if (wav->toc) {
 968     GST_OBJECT_UNLOCK (wav);
 969     GST_WARNING_OBJECT (wav, "found another TOC");
 970     return FALSE;
 971   }
 972
 973   if (!wav->cues) {
 974     GST_OBJECT_UNLOCK (wav);
 975     return TRUE;
 976   }
 977
 978   /* FIXME: send CURRENT scope toc too */
 979   toc = gst_toc_new (GST_TOC_SCOPE_GLOBAL);
 980
 981   /* add cue edition */
 982   entry = gst_toc_entry_new (GST_TOC_ENTRY_TYPE_EDITION, "cue");
 983   gst_toc_entry_set_start_stop_times (entry, 0, wav->duration);
 984   gst_toc_append_entry (toc, entry);
 985
 986   /* add tracks in cue edition */
 987   list = wav->cues;
 988   while (list) {
 989     cue = list->data;
 990     prev_subentry = cur_subentry;
 991     /* previous track stop time = current track start time */
 992     if (prev_subentry != NULL) {
 993       gst_toc_entry_get_start_stop_times (prev_subentry, &start, NULL);
 994       stop = gst_util_uint64_scale_round (cue->position, GST_SECOND, wav->rate);
 995       gst_toc_entry_set_start_stop_times (prev_subentry, start, stop);
 996     }
 997     id = g_strdup_printf ("%08x", cue->id);
 998     cur_subentry = gst_toc_entry_new (GST_TOC_ENTRY_TYPE_TRACK, id);
 999     g_free (id);
1000     start = gst_util_uint64_scale_round (cue->position, GST_SECOND, wav->rate);
1001     stop = wav->duration;
1002     gst_toc_entry_set_start_stop_times (cur_subentry, start, stop);
1003     gst_toc_entry_append_sub_entry (entry, cur_subentry);
1004     list = g_list_next (list);
1005   }
1006
1007   /* add tags in tracks */
1008   list = wav->labls;
1009   while (list) {
1010     labl = list->data;
1011     id = g_strdup_printf ("%08x", labl->cue_point_id);
1012     tags = gst_wavparse_get_tags_toc_entry (toc, id);
1013     g_free (id);
1014     if (tags != NULL) {
1015       gst_tag_list_add (tags, GST_TAG_MERGE_APPEND, GST_TAG_TITLE, labl->text,
1016           NULL);
1017     }
1018     list = g_list_next (list);
1019   }
1020   list = wav->notes;
1021   while (list) {
1022     note = list->data;
1023     id = g_strdup_printf ("%08x", note->cue_point_id);
1024     tags = gst_wavparse_get_tags_toc_entry (toc, id);
1025     g_free (id);
1026     if (tags != NULL) {
1027       gst_tag_list_add (tags, GST_TAG_MERGE_PREPEND, GST_TAG_COMMENT,
1028           note->text, NULL);
1029     }
1030     list = g_list_next (list);
1031   }
1032
1033   /* send data as TOC */
1034   wav->toc = toc;
1035
1036   /* send TOC event */
1037   if (wav->toc) {
1038     GST_OBJECT_UNLOCK (wav);
1039     gst_pad_push_event (wav->srcpad, gst_event_new_toc (wav->toc, FALSE));
1040   }
1041
1042   return TRUE;
1043 }
1044
1045 #define MAX_BUFFER_SIZE 4096
1046
1047 static gboolean
1048 parse_ds64 (GstWavParse * wav, GstBuffer * buf)
1049 {
1050   GstMapInfo map;
1051   guint32 dataSizeLow, dataSizeHigh;
1052   guint32 sampleCountLow, sampleCountHigh;
1053
1054   gst_buffer_map (buf, &map, GST_MAP_READ);
1055   dataSizeLow = GST_READ_UINT32_LE (map.data + 2 * 4);
1056   dataSizeHigh = GST_READ_UINT32_LE (map.data + 3 * 4);
1057   sampleCountLow = GST_READ_UINT32_LE (map.data + 4 * 4);
1058   sampleCountHigh = GST_READ_UINT32_LE (map.data + 5 * 4);
1059   gst_buffer_unmap (buf, &map);
1060   if (dataSizeHigh != 0xFFFFFFFF && dataSizeLow != 0xFFFFFFFF) {
1061     wav->datasize = ((guint64) dataSizeHigh << 32) | dataSizeLow;
1062   }
1063   if (sampleCountHigh != 0xFFFFFFFF && sampleCountLow != 0xFFFFFFFF) {
1064     wav->fact = ((guint64) sampleCountHigh << 32) | sampleCountLow;
1065   }
1066
1067   GST_DEBUG_OBJECT (wav, "Got 'ds64' TAG, datasize : %" G_GINT64_FORMAT
1068       " fact: %" G_GINT64_FORMAT, wav->datasize, wav->fact);
1069   return TRUE;
1070 }
1071
1072 static GstFlowReturn
1073 gst_wavparse_stream_headers (GstWavParse * wav)
1074 {
1075   GstFlowReturn res = GST_FLOW_OK;
1076   GstBuffer *buf = NULL;
1077   gst_riff_strf_auds *header = NULL;
1078   guint32 tag, size;
1079   gboolean gotdata = FALSE;
1080   GstCaps *caps = NULL;
1081   gchar *codec_name = NULL;
1082   gint64 upstream_size = 0;
1083   GstStructure *s;
1084
1085   /* search for "_fmt" chunk, which must be before "data" */
1086   while (!wav->got_fmt) {
1087     GstBuffer *extra;
1088
1089     if (wav->streaming) {
1090       if (!gst_wavparse_peek_chunk (wav, &tag, &size))
1091         return res;
1092
1093       gst_adapter_flush (wav->adapter, 8);
1094       wav->offset += 8;
1095
1096       if (size) {
1097         buf = gst_adapter_take_buffer (wav->adapter, size);
1098         if (size & 1)
1099           gst_adapter_flush (wav->adapter, 1);
1100         wav->offset += GST_ROUND_UP_2 (size);
1101       } else {
1102         buf = gst_buffer_new ();
1103       }
1104     } else {
1105       if ((res = gst_riff_read_chunk (GST_ELEMENT_CAST (wav), wav->sinkpad,
1106                   &wav->offset, &tag, &buf)) != GST_FLOW_OK)
1107         return res;
1108     }
1109
1110     if (tag == GST_RS64_TAG_DS64) {
1111       if (!parse_ds64 (wav, buf))
1112         goto fail;
1113       else
1114         continue;
1115     }
1116
1117     if (tag != GST_RIFF_TAG_fmt) {
1118       GST_DEBUG_OBJECT (wav, "skipping %" GST_FOURCC_FORMAT " chunk",
1119           GST_FOURCC_ARGS (tag));
1120       gst_buffer_unref (buf);
1121       buf = NULL;
1122       continue;
1123     }
1124
1125     if (!(gst_riff_parse_strf_auds (GST_ELEMENT_CAST (wav), buf, &header,
1126                 &extra)))
1127       goto parse_header_error;
1128
1129     buf = NULL;                 /* parse_strf_auds() took ownership of buffer */
1130
1131     /* do sanity checks of header fields */
1132     if (header->channels == 0)
1133       goto no_channels;
1134     if (header->rate == 0)
1135       goto no_rate;
1136
1137     GST_DEBUG_OBJECT (wav, "creating the caps");
1138
1139     /* Note: gst_riff_create_audio_caps might need to fix values in
1140      * the header header depending on the format, so call it first */
1141     /* FIXME: Need to handle the channel reorder map */
1142     caps = gst_riff_create_audio_caps (header->format, NULL, header, extra,
1143         NULL, &codec_name, NULL);
1144
1145     if (extra)
1146       gst_buffer_unref (extra);
1147
1148     if (!caps)
1149       goto unknown_format;
1150
1151     /* If we got raw audio from upstream, we remove the codec_data field,
1152      * which may have been added if the wav header included an extended
1153      * chunk. We want to keep it for non raw audio.
1154      */
1155     s = gst_caps_get_structure (caps, 0);
1156     if (s && gst_structure_has_name (s, "audio/x-raw")) {
1157       gst_structure_remove_field (s, "codec_data");
1158     }
1159
1160     /* do more sanity checks of header fields
1161      * (these can be sanitized by gst_riff_create_audio_caps()
1162      */
1163     wav->format = header->format;
1164     wav->rate = header->rate;
1165     wav->channels = header->channels;
1166     wav->blockalign = header->blockalign;
1167     wav->depth = header->bits_per_sample;
1168     wav->av_bps = header->av_bps;
1169     wav->vbr = FALSE;
1170
1171     g_free (header);
1172     header = NULL;
1173
1174     /* do format specific handling */
1175     switch (wav->format) {
1176       case GST_RIFF_WAVE_FORMAT_MPEGL12:
1177       case GST_RIFF_WAVE_FORMAT_MPEGL3:
1178       {
1179         /* Note: workaround for mp2/mp3 embedded in wav, that relies on the
1180          * bitrate inside the mpeg stream */
1181         GST_INFO ("resetting bps from %u to 0 for mp2/3", wav->av_bps);
1182         wav->bps = 0;
1183         break;
1184       }
1185       case GST_RIFF_WAVE_FORMAT_PCM:
1186         if (wav->blockalign > wav->channels * ((wav->depth + 7) / 8))
1187           goto invalid_blockalign;
1188         /* fall through */
1189       default:
1190         if (wav->av_bps > wav->blockalign * wav->rate)
1191           goto invalid_bps;
1192         /* use the configured bps */
1193         wav->bps = wav->av_bps;
1194         break;
1195     }
1196
1197     wav->width = (wav->blockalign * 8) / wav->channels;
1198     wav->bytes_per_sample = wav->channels * wav->width / 8;
1199
1200     if (wav->bytes_per_sample <= 0)
1201       goto no_bytes_per_sample;
1202
1203     GST_DEBUG_OBJECT (wav, "blockalign = %u", (guint) wav->blockalign);
1204     GST_DEBUG_OBJECT (wav, "width      = %u", (guint) wav->width);
1205     GST_DEBUG_OBJECT (wav, "depth      = %u", (guint) wav->depth);
1206     GST_DEBUG_OBJECT (wav, "av_bps     = %u", (guint) wav->av_bps);
1207     GST_DEBUG_OBJECT (wav, "frequency  = %u", (guint) wav->rate);
1208     GST_DEBUG_OBJECT (wav, "channels   = %u", (guint) wav->channels);
1209     GST_DEBUG_OBJECT (wav, "bytes_per_sample = %u", wav->bytes_per_sample);
1210
1211     /* bps can be 0 when we don't have a valid bitrate (mostly for compressed
1212      * formats). This will make the element output a BYTE format segment and
1213      * will not timestamp the outgoing buffers.
1214      */
1215     GST_DEBUG_OBJECT (wav, "bps        = %u", (guint) wav->bps);
1216
1217     GST_DEBUG_OBJECT (wav, "caps = %" GST_PTR_FORMAT, caps);
1218
1219     /* create pad later so we can sniff the first few bytes
1220      * of the real data and correct our caps if necessary */
1221     gst_caps_replace (&wav->caps, caps);
1222     gst_caps_replace (&caps, NULL);
1223
1224     wav->got_fmt = TRUE;
1225
1226     if (codec_name) {
1227       wav->tags = gst_tag_list_new_empty ();
1228
1229       gst_tag_list_add (wav->tags, GST_TAG_MERGE_REPLACE,
1230           GST_TAG_AUDIO_CODEC, codec_name, NULL);
1231
1232       g_free (codec_name);
1233       codec_name = NULL;
1234     }
1235
1236   }
1237
1238   gst_pad_peer_query_duration (wav->sinkpad, GST_FORMAT_BYTES, &upstream_size);
1239   GST_DEBUG_OBJECT (wav, "upstream size %" G_GUINT64_FORMAT, upstream_size);
1240
1241   /* loop headers until we get data */
1242   while (!gotdata) {
1243     if (wav->streaming) {
1244       if (!gst_wavparse_peek_chunk_info (wav, &tag, &size))
1245         goto exit;
1246     } else {
1247       GstMapInfo map;
1248
1249       buf = NULL;
1250       if ((res =
1251               gst_pad_pull_range (wav->sinkpad, wav->offset, 8,
1252                   &buf)) != GST_FLOW_OK)
1253         goto header_read_error;
1254       gst_buffer_map (buf, &map, GST_MAP_READ);
1255       tag = GST_READ_UINT32_LE (map.data);
1256       size = GST_READ_UINT32_LE (map.data + 4);
1257       gst_buffer_unmap (buf, &map);
1258     }
1259
1260     GST_INFO_OBJECT (wav,
1261         "Got TAG: %" GST_FOURCC_FORMAT ", offset %" G_GUINT64_FORMAT ", size %"
1262         G_GUINT32_FORMAT, GST_FOURCC_ARGS (tag), wav->offset, size);
1263
1264     /* Maximum valid size is INT_MAX */
1265     if (size & 0x80000000) {
1266       GST_WARNING_OBJECT (wav, "Invalid size, clipping to 0x7fffffff");
1267       size = 0x7fffffff;
1268     }
1269
1270     /* Clip to upstream size if known */
1271     if (wav->datasize > 0 && size + wav->offset > wav->datasize) {
1272       GST_WARNING_OBJECT (wav, "Clipping chunk size to file size");
1273       size = wav->datasize - wav->offset;
1274     }
1275
1276     /* wav is a st00pid format, we don't know for sure where data starts.
1277      * So we have to go bit by bit until we find the 'data' header
1278      */
1279     switch (tag) {
1280       case GST_RIFF_TAG_data:{
1281         guint64 size64;
1282
1283         GST_DEBUG_OBJECT (wav, "Got 'data' TAG, size : %u", size);
1284         size64 = size;
1285         if (wav->ignore_length) {
1286           GST_DEBUG_OBJECT (wav, "Ignoring length");
1287           size64 = 0;
1288         }
1289         if (wav->streaming) {
1290           gst_adapter_flush (wav->adapter, 8);
1291           gotdata = TRUE;
1292         } else {
1293           gst_buffer_unref (buf);
1294         }
1295         wav->offset += 8;
1296         wav->datastart = wav->offset;
1297         /* use size from ds64 chunk if available */
1298         if (size64 == -1 && wav->datasize > 0) {
1299           GST_DEBUG_OBJECT (wav, "Using ds64 datasize");
1300           size64 = wav->datasize;
1301         }
1302         /* If size is zero, then the data chunk probably actually extends to
1303            the end of the file */
1304         if (size64 == 0 && upstream_size) {
1305           size64 = upstream_size - wav->datastart;
1306         }
1307         /* Or the file might be truncated */
1308         else if (upstream_size) {
1309           size64 = MIN (size64, (upstream_size - wav->datastart));
1310         }
1311         wav->datasize = size64;
1312         wav->dataleft = size64;
1313         wav->end_offset = size64 + wav->datastart;
1314         if (!wav->streaming) {
1315           /* We will continue parsing tags 'till end */
1316           wav->offset += size64;
1317         }
1318         GST_DEBUG_OBJECT (wav, "datasize = %" G_GUINT64_FORMAT, size64);
1319         break;
1320       }
1321       case GST_RIFF_TAG_fact:{
1322         if (wav->fact == 0 &&
1323             wav->format != GST_RIFF_WAVE_FORMAT_MPEGL12 &&
1324             wav->format != GST_RIFF_WAVE_FORMAT_MPEGL3) {
1325           const guint data_size = 4;
1326
1327           GST_INFO_OBJECT (wav, "Have fact chunk");
1328           if (size < data_size) {
1329             if (!gst_waveparse_ignore_chunk (wav, buf, tag, size)) {
1330               /* need more data */
1331               goto exit;
1332             }
1333             GST_DEBUG_OBJECT (wav, "need %u, available %u; ignoring chunk",
1334                 data_size, size);
1335             break;
1336           }
1337           /* number of samples (for compressed formats) */
1338           if (wav->streaming) {
1339             const guint8 *data = NULL;
1340
1341             if (!gst_wavparse_peek_chunk (wav, &tag, &size)) {
1342               goto exit;
1343             }
1344             gst_adapter_flush (wav->adapter, 8);
1345             data = gst_adapter_map (wav->adapter, data_size);
1346             wav->fact = GST_READ_UINT32_LE (data);
1347             gst_adapter_unmap (wav->adapter);
1348             gst_adapter_flush (wav->adapter, GST_ROUND_UP_2 (size));
1349           } else {
1350             gst_buffer_unref (buf);
1351             buf = NULL;
1352             if ((res =
1353                     gst_pad_pull_range (wav->sinkpad, wav->offset + 8,
1354                         data_size, &buf)) != GST_FLOW_OK)
1355               goto header_read_error;
1356             gst_buffer_extract (buf, 0, &wav->fact, 4);
1357             wav->fact = GUINT32_FROM_LE (wav->fact);
1358             gst_buffer_unref (buf);
1359           }
1360           GST_DEBUG_OBJECT (wav, "have fact %" G_GUINT64_FORMAT, wav->fact);
1361           wav->offset += 8 + GST_ROUND_UP_2 (size);
1362           break;
1363         } else {
1364           if (!gst_waveparse_ignore_chunk (wav, buf, tag, size)) {
1365             /* need more data */
1366             goto exit;
1367           }
1368         }
1369         break;
1370       }
1371       case GST_RIFF_TAG_acid:{
1372         const gst_riff_acid *acid = NULL;
1373         const guint data_size = sizeof (gst_riff_acid);
1374         gfloat tempo;
1375
1376         GST_INFO_OBJECT (wav, "Have acid chunk");
1377         if (size < data_size) {
1378           if (!gst_waveparse_ignore_chunk (wav, buf, tag, size)) {
1379             /* need more data */
1380             goto exit;
1381           }
1382           GST_DEBUG_OBJECT (wav, "need %u, available %u; ignoring chunk",
1383               data_size, size);
1384           break;
1385         }
1386         if (wav->streaming) {
1387           if (!gst_wavparse_peek_chunk (wav, &tag, &size)) {
1388             goto exit;
1389           }
1390           gst_adapter_flush (wav->adapter, 8);
1391           acid = (const gst_riff_acid *) gst_adapter_map (wav->adapter,
1392               data_size);
1393           tempo = acid->tempo;
1394           gst_adapter_unmap (wav->adapter);
1395         } else {
1396           GstMapInfo map;
1397           gst_buffer_unref (buf);
1398           buf = NULL;
1399           if ((res =
1400                   gst_pad_pull_range (wav->sinkpad, wav->offset + 8,
1401                       size, &buf)) != GST_FLOW_OK)
1402             goto header_read_error;
1403           gst_buffer_map (buf, &map, GST_MAP_READ);
1404           acid = (const gst_riff_acid *) map.data;
1405           tempo = acid->tempo;
1406           gst_buffer_unmap (buf, &map);
1407         }
1408         /* send data as tags */
1409         if (!wav->tags)
1410           wav->tags = gst_tag_list_new_empty ();
1411         gst_tag_list_add (wav->tags, GST_TAG_MERGE_REPLACE,
1412             GST_TAG_BEATS_PER_MINUTE, tempo, NULL);
1413
1414         size = GST_ROUND_UP_2 (size);
1415         if (wav->streaming) {
1416           gst_adapter_flush (wav->adapter, size);
1417         } else {
1418           gst_buffer_unref (buf);
1419         }
1420         wav->offset += 8 + size;
1421         break;
1422       }
1423         /* FIXME: all list tags after data are ignored in streaming mode */
1424       case GST_RIFF_TAG_LIST:{
1425         guint32 ltag;
1426
1427         if (wav->streaming) {
1428           const guint8 *data = NULL;
1429
1430           if (gst_adapter_available (wav->adapter) < 12) {
1431             goto exit;
1432           }
1433           data = gst_adapter_map (wav->adapter, 12);
1434           ltag = GST_READ_UINT32_LE (data + 8);
1435           gst_adapter_unmap (wav->adapter);
1436         } else {
1437           gst_buffer_unref (buf);
1438           buf = NULL;
1439           if ((res =
1440                   gst_pad_pull_range (wav->sinkpad, wav->offset, 12,
1441                       &buf)) != GST_FLOW_OK)
1442             goto header_read_error;
1443           gst_buffer_extract (buf, 8, &ltag, 4);
1444           ltag = GUINT32_FROM_LE (ltag);
1445         }
1446         switch (ltag) {
1447           case GST_RIFF_LIST_INFO:{
1448             const gint data_size = size - 4;
1449             GstTagList *new;
1450
1451             GST_INFO_OBJECT (wav, "Have LIST chunk INFO size %u", data_size);
1452             if (wav->streaming) {
1453               if (!gst_wavparse_peek_chunk (wav, &tag, &size)) {
1454                 goto exit;
1455               }
1456               gst_adapter_flush (wav->adapter, 12);
1457               wav->offset += 12;
1458               if (data_size > 0) {
1459                 buf = gst_adapter_take_buffer (wav->adapter, data_size);
1460                 if (data_size & 1)
1461                   gst_adapter_flush (wav->adapter, 1);
1462               }
1463             } else {
1464               wav->offset += 12;
1465               gst_buffer_unref (buf);
1466               buf = NULL;
1467               if (data_size > 0) {
1468                 if ((res =
1469                         gst_pad_pull_range (wav->sinkpad, wav->offset,
1470                             data_size, &buf)) != GST_FLOW_OK)
1471                   goto header_read_error;
1472               }
1473             }
1474             if (data_size > 0) {
1475               /* parse tags */
1476               gst_riff_parse_info (GST_ELEMENT (wav), buf, &new);
1477               if (new) {
1478                 GstTagList *old = wav->tags;
1479                 wav->tags =
1480                     gst_tag_list_merge (old, new, GST_TAG_MERGE_REPLACE);
1481                 if (old)
1482                   gst_tag_list_unref (old);
1483                 gst_tag_list_unref (new);
1484               }
1485               gst_buffer_unref (buf);
1486               wav->offset += GST_ROUND_UP_2 (data_size);
1487             }
1488             break;
1489           }
1490           case GST_RIFF_LIST_adtl:{
1491             const gint data_size = size - 4;
1492
1493             GST_INFO_OBJECT (wav, "Have 'adtl' LIST, size %u", data_size);
1494             if (wav->streaming) {
1495               const guint8 *data = NULL;
1496
1497               gst_adapter_flush (wav->adapter, 12);
1498               wav->offset += 12;
1499               data = gst_adapter_map (wav->adapter, data_size);
1500               gst_wavparse_adtl_chunk (wav, data, data_size);
1501               gst_adapter_unmap (wav->adapter);
1502             } else {
1503               GstMapInfo map;
1504
1505               gst_buffer_unref (buf);
1506               buf = NULL;
1507               wav->offset += 12;
1508               if ((res =
1509                       gst_pad_pull_range (wav->sinkpad, wav->offset,
1510                           data_size, &buf)) != GST_FLOW_OK)
1511                 goto header_read_error;
1512               gst_buffer_map (buf, &map, GST_MAP_READ);
1513               gst_wavparse_adtl_chunk (wav, (const guint8 *) map.data,
1514                   data_size);
1515               gst_buffer_unmap (buf, &map);
1516             }
1517             wav->offset += GST_ROUND_UP_2 (data_size);
1518             break;
1519           }
1520           default:
1521             GST_WARNING_OBJECT (wav, "Ignoring LIST chunk %" GST_FOURCC_FORMAT,
1522                 GST_FOURCC_ARGS (ltag));
1523             if (!gst_waveparse_ignore_chunk (wav, buf, tag, size))
1524               /* need more data */
1525               goto exit;
1526             break;
1527         }
1528         break;
1529       }
1530       case GST_RIFF_TAG_cue:{
1531         const guint data_size = size;
1532
1533         GST_DEBUG_OBJECT (wav, "Have 'cue' TAG, size : %u", data_size);
1534         if (wav->streaming) {
1535           const guint8 *data = NULL;
1536
1537           if (!gst_wavparse_peek_chunk (wav, &tag, &size)) {
1538             goto exit;
1539           }
1540           gst_adapter_flush (wav->adapter, 8);
1541           wav->offset += 8;
1542           data = gst_adapter_map (wav->adapter, data_size);
1543           if (!gst_wavparse_cue_chunk (wav, data, data_size)) {
1544             goto header_read_error;
1545           }
1546           gst_adapter_unmap (wav->adapter);
1547         } else {
1548           GstMapInfo map;
1549
1550           wav->offset += 8;
1551           gst_buffer_unref (buf);
1552           buf = NULL;
1553           if ((res =
1554                   gst_pad_pull_range (wav->sinkpad, wav->offset,
1555                       data_size, &buf)) != GST_FLOW_OK)
1556             goto header_read_error;
1557           gst_buffer_map (buf, &map, GST_MAP_READ);
1558           if (!gst_wavparse_cue_chunk (wav, (const guint8 *) map.data,
1559                   data_size)) {
1560             goto header_read_error;
1561           }
1562           gst_buffer_unmap (buf, &map);
1563         }
1564         size = GST_ROUND_UP_2 (size);
1565         if (wav->streaming) {
1566           gst_adapter_flush (wav->adapter, size);
1567         } else {
1568           gst_buffer_unref (buf);
1569         }
1570         size = GST_ROUND_UP_2 (size);
1571         wav->offset += size;
1572         break;
1573       }
1574       case GST_RIFF_TAG_smpl:{
1575         const gint data_size = size;
1576
1577         GST_DEBUG_OBJECT (wav, "Have 'smpl' TAG, size : %u", data_size);
1578         if (wav->streaming) {
1579           const guint8 *data = NULL;
1580
1581           if (!gst_wavparse_peek_chunk (wav, &tag, &size)) {
1582             goto exit;
1583           }
1584           gst_adapter_flush (wav->adapter, 8);
1585           wav->offset += 8;
1586           data = gst_adapter_map (wav->adapter, data_size);
1587           if (!gst_wavparse_smpl_chunk (wav, data, data_size)) {
1588             goto header_read_error;
1589           }
1590           gst_adapter_unmap (wav->adapter);
1591         } else {
1592           GstMapInfo map;
1593
1594           wav->offset += 8;
1595           gst_buffer_unref (buf);
1596           buf = NULL;
1597           if ((res =
1598                   gst_pad_pull_range (wav->sinkpad, wav->offset,
1599                       data_size, &buf)) != GST_FLOW_OK)
1600             goto header_read_error;
1601           gst_buffer_map (buf, &map, GST_MAP_READ);
1602           if (!gst_wavparse_smpl_chunk (wav, (const guint8 *) map.data,
1603                   data_size)) {
1604             goto header_read_error;
1605           }
1606           gst_buffer_unmap (buf, &map);
1607         }
1608         size = GST_ROUND_UP_2 (size);
1609         if (wav->streaming) {
1610           gst_adapter_flush (wav->adapter, size);
1611         } else {
1612           gst_buffer_unref (buf);
1613         }
1614         size = GST_ROUND_UP_2 (size);
1615         wav->offset += size;
1616         break;
1617       }
1618       default:
1619         GST_WARNING_OBJECT (wav, "Ignoring chunk %" GST_FOURCC_FORMAT,
1620             GST_FOURCC_ARGS (tag));
1621         if (!gst_waveparse_ignore_chunk (wav, buf, tag, size))
1622           /* need more data */
1623           goto exit;
1624         break;
1625     }
1626
1627     if (upstream_size && (wav->offset >= upstream_size)) {
1628       /* Now we are gone through the whole file */
1629       gotdata = TRUE;
1630     }
1631   }
1632
1633   GST_DEBUG_OBJECT (wav, "Finished parsing headers");
1634
1635   if (wav->bps <= 0 && wav->fact) {
1636 #if 0
1637     /* not a good idea, as for embedded mp2/mp3 we set bps to 0 earlier */
1638     wav->bps =
1639         (guint32) gst_util_uint64_scale ((guint64) wav->rate, wav->datasize,
1640         (guint64) wav->fact);
1641     GST_INFO_OBJECT (wav, "calculated bps : %u, enabling VBR", wav->bps);
1642 #endif
1643     wav->vbr = TRUE;
1644   }
1645
1646   if (gst_wavparse_calculate_duration (wav)) {
1647     gst_segment_init (&wav->segment, GST_FORMAT_TIME);
1648     if (!wav->ignore_length)
1649       wav->segment.duration = wav->duration;
1650     if (!wav->toc)
1651       gst_wavparse_create_toc (wav);
1652   } else {
1653     /* no bitrate, let downstream peer do the math, we'll feed it bytes. */
1654     gst_segment_init (&wav->segment, GST_FORMAT_BYTES);
1655     if (!wav->ignore_length)
1656       wav->segment.duration = wav->datasize;
1657   }
1658
1659   /* now we have all the info to perform a pending seek if any, if no
1660    * event, this will still do the right thing and it will also send
1661    * the right newsegment event downstream. */
1662   gst_wavparse_perform_seek (wav, wav->seek_event);
1663   /* remove pending event */
1664   gst_event_replace (&wav->seek_event, NULL);
1665
1666   /* we just started, we are discont */
1667   wav->discont = TRUE;
1668
1669   wav->state = GST_WAVPARSE_DATA;
1670
1671   /* determine reasonable max buffer size,
1672    * that is, buffers not too small either size or time wise
1673    * so we do not end up with too many of them */
1674   /* var abuse */
1675   if (gst_wavparse_time_to_bytepos (wav, 40 * GST_MSECOND, &upstream_size))
1676     wav->max_buf_size = upstream_size;
1677   else
1678     wav->max_buf_size = 0;
1679   wav->max_buf_size = MAX (wav->max_buf_size, MAX_BUFFER_SIZE);
1680   if (wav->blockalign > 0)
1681     wav->max_buf_size -= (wav->max_buf_size % wav->blockalign);
1682
1683   GST_DEBUG_OBJECT (wav, "max buffer size %u", wav->max_buf_size);
1684
1685   return GST_FLOW_OK;
1686
1687   /* ERROR */
1688 exit:
1689   {
1690     g_free (codec_name);
1691     g_free (header);
1692     if (caps)
1693       gst_caps_unref (caps);
1694     return res;
1695   }
1696 fail:
1697   {
1698     res = GST_FLOW_ERROR;
1699     goto exit;
1700   }
1701 parse_header_error:
1702   {
1703     GST_ELEMENT_ERROR (wav, STREAM, DEMUX, (NULL),
1704         ("Couldn't parse audio header"));
1705     goto fail;
1706   }
1707 no_channels:
1708   {
1709     GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
1710         ("Stream claims to contain no channels - invalid data"));
1711     goto fail;
1712   }
1713 no_rate:
1714   {
1715     GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
1716         ("Stream with sample_rate == 0 - invalid data"));
1717     goto fail;
1718   }
1719 invalid_blockalign:
1720   {
1721     GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
1722         ("Stream claims blockalign = %u, which is more than %u - invalid data",
1723             wav->blockalign, wav->channels * ((wav->depth + 7) / 8)));
1724     goto fail;
1725   }
1726 invalid_bps:
1727   {
1728     GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
1729         ("Stream claims av_bsp = %u, which is more than %u - invalid data",
1730             wav->av_bps, wav->blockalign * wav->rate));
1731     goto fail;
1732   }
1733 no_bytes_per_sample:
1734   {
1735     GST_ELEMENT_ERROR (wav, STREAM, FAILED, (NULL),
1736         ("Could not caluclate bytes per sample - invalid data"));
1737     goto fail;
1738   }
1739 unknown_format:
1740   {
1741     GST_ELEMENT_ERROR (wav, STREAM, TYPE_NOT_FOUND, (NULL),
1742         ("No caps found for format 0x%x, %u channels, %u Hz",
1743             wav->format, wav->channels, wav->rate));
1744     goto fail;
1745   }
1746 header_read_error:
1747   {
1748     GST_ELEMENT_ERROR (wav, STREAM, DEMUX, (NULL),
1749         ("Couldn't read in header %d (%s)", res, gst_flow_get_name (res)));
1750     goto fail;
1751   }
1752 }
1753
1754 /*
1755  * Read WAV file tag when streaming
1756  */
1757 static GstFlowReturn
1758 gst_wavparse_parse_stream_init (GstWavParse * wav)
1759 {
1760   if (gst_adapter_available (wav->adapter) >= 12) {
1761     GstBuffer *tmp;
1762
1763     /* _take flushes the data */
1764     tmp = gst_adapter_take_buffer (wav->adapter, 12);
1765
1766     GST_DEBUG ("Parsing wav header");
1767     if (!gst_wavparse_parse_file_header (GST_ELEMENT_CAST (wav), tmp))
1768       return GST_FLOW_ERROR;
1769
1770     wav->offset += 12;
1771     /* Go to next state */
1772     wav->state = GST_WAVPARSE_HEADER;
1773   }
1774   return GST_FLOW_OK;
1775 }
1776
1777 /* handle an event sent directly to the element.
1778  *
1779  * This event can be sent either in the READY state or the
1780  * >READY state. The only event of interest really is the seek
1781  * event.
1782  *
1783  * In the READY state we can only store the event and try to
1784  * respect it when going to PAUSED. We assume we are in the
1785  * READY state when our parsing state != GST_WAVPARSE_DATA.
1786  *
1787  * When we are steaming, we can simply perform the seek right
1788  * away.
1789  */
1790 static gboolean
1791 gst_wavparse_send_event (GstElement * element, GstEvent * event)
1792 {
1793   GstWavParse *wav = GST_WAVPARSE (element);
1794   gboolean res = FALSE;
1795
1796   GST_DEBUG_OBJECT (wav, "received event %s", GST_EVENT_TYPE_NAME (event));
1797
1798   switch (GST_EVENT_TYPE (event)) {
1799     case GST_EVENT_SEEK:
1800       if (wav->state == GST_WAVPARSE_DATA) {
1801         /* we can handle the seek directly when streaming data */
1802         res = gst_wavparse_perform_seek (wav, event);
1803       } else {
1804         GST_DEBUG_OBJECT (wav, "queuing seek for later");
1805
1806         gst_event_replace (&wav->seek_event, event);
1807
1808         /* we always return true */
1809         res = TRUE;
1810       }
1811       break;
1812     default:
1813       break;
1814   }
1815   gst_event_unref (event);
1816   return res;
1817 }
1818
1819 static gboolean
1820 gst_wavparse_have_dts_caps (const GstCaps * caps, GstTypeFindProbability prob)
1821 {
1822   GstStructure *s;
1823
1824   s = gst_caps_get_structure (caps, 0);
1825   if (!gst_structure_has_name (s, "audio/x-dts"))
1826     return FALSE;
1827   /* typefind behavior for DTS:
1828    *  MAXIMUM: multiple frame syncs detected, certainly DTS
1829    *  LIKELY: single frame sync at offset 0.  Maybe DTS?
1830    *  POSSIBLE: single frame sync, not at offset 0.  Highly unlikely
1831    *    to be DTS.  */
1832   if (prob > GST_TYPE_FIND_LIKELY)
1833     return TRUE;
1834   if (prob <= GST_TYPE_FIND_POSSIBLE)
1835     return FALSE;
1836   /* for maybe, check for at least a valid-looking rate and channels */
1837   if (!gst_structure_has_field (s, "channels"))
1838     return FALSE;
1839   /* and for extra assurance we could also check the rate from the DTS frame
1840    * against the one in the wav header, but for now let's not do that */
1841   return gst_structure_has_field (s, "rate");
1842 }
1843
1844 static GstTagList *
1845 gst_wavparse_get_upstream_tags (GstWavParse * wav, GstTagScope scope)
1846 {
1847   GstTagList *tags = NULL;
1848   GstEvent *ev;
1849   gint i;
1850
1851   i = 0;
1852   while ((ev = gst_pad_get_sticky_event (wav->sinkpad, GST_EVENT_TAG, i++))) {
1853     gst_event_parse_tag (ev, &tags);
1854     if (tags != NULL && gst_tag_list_get_scope (tags) == scope) {
1855       tags = gst_tag_list_copy (tags);
1856       gst_tag_list_remove_tag (tags, GST_TAG_CONTAINER_FORMAT);
1857       gst_event_unref (ev);
1858       break;
1859     }
1860     tags = NULL;
1861     gst_event_unref (ev);
1862   }
1863   return tags;
1864 }
1865
1866 static void
1867 gst_wavparse_add_src_pad (GstWavParse * wav, GstBuffer * buf)
1868 {
1869   GstStructure *s;
1870   GstTagList *tags, *utags;
1871
1872   GST_DEBUG_OBJECT (wav, "adding src pad");
1873
1874   g_assert (wav->caps != NULL);
1875
1876   s = gst_caps_get_structure (wav->caps, 0);
1877   if (s && gst_structure_has_name (s, "audio/x-raw") && buf != NULL) {
1878     GstTypeFindProbability prob;
1879     GstCaps *tf_caps;
1880
1881     tf_caps = gst_type_find_helper_for_buffer (GST_OBJECT (wav), buf, &prob);
1882     if (tf_caps != NULL) {
1883       GST_LOG ("typefind caps = %" GST_PTR_FORMAT ", P=%d", tf_caps, prob);
1884       if (gst_wavparse_have_dts_caps (tf_caps, prob)) {
1885         GST_INFO_OBJECT (wav, "Found DTS marker in file marked as raw PCM");
1886         gst_caps_unref (wav->caps);
1887         wav->caps = tf_caps;
1888
1889         gst_tag_list_add (wav->tags, GST_TAG_MERGE_REPLACE,
1890             GST_TAG_AUDIO_CODEC, "dts", NULL);
1891       } else {
1892         GST_DEBUG_OBJECT (wav, "found caps %" GST_PTR_FORMAT " for stream "
1893             "marked as raw PCM audio, but ignoring for now", tf_caps);
1894         gst_caps_unref (tf_caps);
1895       }
1896     }
1897   }
1898
1899   gst_pad_set_caps (wav->srcpad, wav->caps);
1900   gst_caps_replace (&wav->caps, NULL);
1901
1902   if (wav->start_segment) {
1903     GST_DEBUG_OBJECT (wav, "Send start segment event on newpad");
1904     gst_pad_push_event (wav->srcpad, wav->start_segment);
1905     wav->start_segment = NULL;
1906   }
1907
1908   /* upstream tags, e.g. from id3/ape tag before the wav file; assume for now
1909    * that there'll be only one scope/type of tag list from upstream, if any */
1910   utags = gst_wavparse_get_upstream_tags (wav, GST_TAG_SCOPE_GLOBAL);
1911   if (utags == NULL)
1912     utags = gst_wavparse_get_upstream_tags (wav, GST_TAG_SCOPE_STREAM);
1913
1914   /* if there's a tag upstream it's probably been added to override the
1915    * tags from inside the wav header, so keep upstream tags if in doubt */
1916   tags = gst_tag_list_merge (utags, wav->tags, GST_TAG_MERGE_KEEP);
1917
1918   if (wav->tags != NULL) {
1919     gst_tag_list_unref (wav->tags);
1920     wav->tags = NULL;
1921   }
1922
1923   if (utags != NULL)
1924     gst_tag_list_unref (utags);
1925
1926   /* send tags downstream, if any */
1927   if (tags != NULL)
1928     gst_pad_push_event (wav->srcpad, gst_event_new_tag (tags));
1929 }
1930
1931 static GstFlowReturn
1932 gst_wavparse_stream_data (GstWavParse * wav)
1933 {
1934   GstBuffer *buf = NULL;
1935   GstFlowReturn res = GST_FLOW_OK;
1936   guint64 desired, obtained;
1937   GstClockTime timestamp, next_timestamp, duration;
1938   guint64 pos, nextpos;
1939
1940 iterate_adapter:
1941   GST_LOG_OBJECT (wav,
1942       "offset: %" G_GINT64_FORMAT " , end: %" G_GINT64_FORMAT " , dataleft: %"
1943       G_GINT64_FORMAT, wav->offset, wav->end_offset, wav->dataleft);
1944
1945   /* Get the next n bytes and output them */
1946   if (wav->dataleft == 0 || wav->dataleft < wav->blockalign)
1947     goto found_eos;
1948
1949   /* scale the amount of data by the segment rate so we get equal
1950    * amounts of data regardless of the playback rate */
1951   desired =
1952       MIN (gst_guint64_to_gdouble (wav->dataleft),
1953       wav->max_buf_size * ABS (wav->segment.rate));
1954
1955   if (desired >= wav->blockalign && wav->blockalign > 0)
1956     desired -= (desired % wav->blockalign);
1957
1958   GST_LOG_OBJECT (wav, "Fetching %" G_GINT64_FORMAT " bytes of data "
1959       "from the sinkpad", desired);
1960
1961   if (wav->streaming) {
1962     guint avail = gst_adapter_available (wav->adapter);
1963     guint extra;
1964
1965     /* flush some bytes if evil upstream sends segment that starts
1966      * before data or does is not send sample aligned segment */
1967     if (G_LIKELY (wav->offset >= wav->datastart)) {
1968       extra = (wav->offset - wav->datastart) % wav->bytes_per_sample;
1969     } else {
1970       extra = wav->datastart - wav->offset;
1971     }
1972
1973     if (G_UNLIKELY (extra)) {
1974       extra = wav->bytes_per_sample - extra;
1975       if (extra <= avail) {
1976         GST_DEBUG_OBJECT (wav, "flushing %u bytes to sample boundary", extra);
1977         gst_adapter_flush (wav->adapter, extra);
1978         wav->offset += extra;
1979         wav->dataleft -= extra;
1980         goto iterate_adapter;
1981       } else {
1982         GST_DEBUG_OBJECT (wav, "flushing %u bytes", avail);
1983         gst_adapter_clear (wav->adapter);
1984         wav->offset += avail;
1985         wav->dataleft -= avail;
1986         return GST_FLOW_OK;
1987       }
1988     }
1989
1990     if (avail < desired) {
1991       GST_LOG_OBJECT (wav, "Got only %u bytes of data from the sinkpad", avail);
1992       return GST_FLOW_OK;
1993     }
1994
1995     buf = gst_adapter_take_buffer (wav->adapter, desired);
1996   } else {
1997     if ((res = gst_pad_pull_range (wav->sinkpad, wav->offset,
1998                 desired, &buf)) != GST_FLOW_OK)
1999       goto pull_error;
2000
2001     /* we may get a short buffer at the end of the file */
2002     if (gst_buffer_get_size (buf) < desired) {
2003       gsize size = gst_buffer_get_size (buf);
2004
2005       GST_LOG_OBJECT (wav, "Got only %" G_GSIZE_FORMAT " bytes of data", size);
2006       if (size >= wav->blockalign) {
2007         if (wav->blockalign > 0) {
2008           buf = gst_buffer_make_writable (buf);
2009           gst_buffer_resize (buf, 0, size - (size % wav->blockalign));
2010         }
2011       } else {
2012         gst_buffer_unref (buf);
2013         goto found_eos;
2014       }
2015     }
2016   }
2017
2018   obtained = gst_buffer_get_size (buf);
2019
2020   /* our positions in bytes */
2021   pos = wav->offset - wav->datastart;
2022   nextpos = pos + obtained;
2023
2024   /* update offsets, does not overflow. */
2025   buf = gst_buffer_make_writable (buf);
2026   GST_BUFFER_OFFSET (buf) = pos / wav->bytes_per_sample;
2027   GST_BUFFER_OFFSET_END (buf) = nextpos / wav->bytes_per_sample;
2028
2029   /* first chunk of data? create the source pad. We do this only here so
2030    * we can detect broken .wav files with dts disguised as raw PCM (sigh) */
2031   if (G_UNLIKELY (wav->first)) {
2032     wav->first = FALSE;
2033     /* this will also push the segment events */
2034     gst_wavparse_add_src_pad (wav, buf);
2035   } else {
2036     /* If we have a pending start segment, send it now. */
2037     if (G_UNLIKELY (wav->start_segment != NULL)) {
2038       gst_pad_push_event (wav->srcpad, wav->start_segment);
2039       wav->start_segment = NULL;
2040     }
2041   }
2042
2043   if (wav->bps > 0) {
2044     /* and timestamps if we have a bitrate, be careful for overflows */
2045     timestamp =
2046         gst_util_uint64_scale_ceil (pos, GST_SECOND, (guint64) wav->bps);
2047     next_timestamp =
2048         gst_util_uint64_scale_ceil (nextpos, GST_SECOND, (guint64) wav->bps);
2049     duration = next_timestamp - timestamp;
2050
2051     /* update current running segment position */
2052     if (G_LIKELY (next_timestamp >= wav->segment.start))
2053       wav->segment.position = next_timestamp;
2054   } else if (wav->fact) {
2055     guint64 bps =
2056         gst_util_uint64_scale_int (wav->datasize, wav->rate, wav->fact);
2057     /* and timestamps if we have a bitrate, be careful for overflows */
2058     timestamp = gst_util_uint64_scale_ceil (pos, GST_SECOND, bps);
2059     next_timestamp = gst_util_uint64_scale_ceil (nextpos, GST_SECOND, bps);
2060     duration = next_timestamp - timestamp;
2061   } else {
2062     /* no bitrate, all we know is that the first sample has timestamp 0, all
2063      * other positions and durations have unknown timestamp. */
2064     if (pos == 0)
2065       timestamp = 0;
2066     else
2067       timestamp = GST_CLOCK_TIME_NONE;
2068     duration = GST_CLOCK_TIME_NONE;
2069     /* update current running segment position with byte offset */
2070     if (G_LIKELY (nextpos >= wav->segment.start))
2071       wav->segment.position = nextpos;
2072   }
2073   if ((pos > 0) && wav->vbr) {
2074     /* don't set timestamps for VBR files if it's not the first buffer */
2075     timestamp = GST_CLOCK_TIME_NONE;
2076     duration = GST_CLOCK_TIME_NONE;
2077   }
2078   if (wav->discont) {
2079     GST_DEBUG_OBJECT (wav, "marking DISCONT");
2080     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
2081     wav->discont = FALSE;
2082   }
2083
2084   GST_BUFFER_TIMESTAMP (buf) = timestamp;
2085   GST_BUFFER_DURATION (buf) = duration;
2086
2087   GST_LOG_OBJECT (wav,
2088       "Got buffer. timestamp:%" GST_TIME_FORMAT " , duration:%" GST_TIME_FORMAT
2089       ", size:%" G_GSIZE_FORMAT, GST_TIME_ARGS (timestamp),
2090       GST_TIME_ARGS (duration), gst_buffer_get_size (buf));
2091
2092   if ((res = gst_pad_push (wav->srcpad, buf)) != GST_FLOW_OK)
2093     goto push_error;
2094
2095   if (obtained < wav->dataleft) {
2096     wav->offset += obtained;
2097     wav->dataleft -= obtained;
2098   } else {
2099     wav->offset += wav->dataleft;
2100     wav->dataleft = 0;
2101   }
2102
2103   /* Iterate until need more data, so adapter size won't grow */
2104   if (wav->streaming) {
2105     GST_LOG_OBJECT (wav,
2106         "offset: %" G_GINT64_FORMAT " , end: %" G_GINT64_FORMAT, wav->offset,
2107         wav->end_offset);
2108     goto iterate_adapter;
2109   }
2110   return res;
2111
2112   /* ERROR */
2113 found_eos:
2114   {
2115     GST_DEBUG_OBJECT (wav, "found EOS");
2116     return GST_FLOW_EOS;
2117   }
2118 pull_error:
2119   {
2120     /* check if we got EOS */
2121     if (res == GST_FLOW_EOS)
2122       goto found_eos;
2123
2124     GST_WARNING_OBJECT (wav,
2125         "Error getting %" G_GINT64_FORMAT " bytes from the "
2126         "sinkpad (dataleft = %" G_GINT64_FORMAT ")", desired, wav->dataleft);
2127     return res;
2128   }
2129 push_error:
2130   {
2131     GST_INFO_OBJECT (wav,
2132         "Error pushing on srcpad %s:%s, reason %s, is linked? = %d",
2133         GST_DEBUG_PAD_NAME (wav->srcpad), gst_flow_get_name (res),
2134         gst_pad_is_linked (wav->srcpad));
2135     return res;
2136   }
2137 }
2138
2139 static void
2140 gst_wavparse_loop (GstPad * pad)
2141 {
2142   GstFlowReturn ret;
2143   GstWavParse *wav = GST_WAVPARSE (GST_PAD_PARENT (pad));
2144   GstEvent *event;
2145   gchar *stream_id;
2146
2147   GST_LOG_OBJECT (wav, "process data");
2148
2149   switch (wav->state) {
2150     case GST_WAVPARSE_START:
2151       GST_INFO_OBJECT (wav, "GST_WAVPARSE_START");
2152       if ((ret = gst_wavparse_stream_init (wav)) != GST_FLOW_OK)
2153         goto pause;
2154
2155       stream_id =
2156           gst_pad_create_stream_id (wav->srcpad, GST_ELEMENT_CAST (wav), NULL);
2157       event = gst_event_new_stream_start (stream_id);
2158       gst_event_set_group_id (event, gst_util_group_id_next ());
2159       gst_pad_push_event (wav->srcpad, event);
2160       g_free (stream_id);
2161
2162       wav->state = GST_WAVPARSE_HEADER;
2163       /* fall-through */
2164
2165     case GST_WAVPARSE_HEADER:
2166       GST_INFO_OBJECT (wav, "GST_WAVPARSE_HEADER");
2167       if ((ret = gst_wavparse_stream_headers (wav)) != GST_FLOW_OK)
2168         goto pause;
2169
2170       wav->state = GST_WAVPARSE_DATA;
2171       GST_INFO_OBJECT (wav, "GST_WAVPARSE_DATA");
2172       /* fall-through */
2173
2174     case GST_WAVPARSE_DATA:
2175       if ((ret = gst_wavparse_stream_data (wav)) != GST_FLOW_OK)
2176         goto pause;
2177       break;
2178     default:
2179       g_assert_not_reached ();
2180   }
2181   return;
2182
2183   /* ERRORS */
2184 pause:
2185   {
2186     const gchar *reason = gst_flow_get_name (ret);
2187
2188     GST_DEBUG_OBJECT (wav, "pausing task, reason %s", reason);
2189     gst_pad_pause_task (pad);
2190
2191     if (ret == GST_FLOW_EOS) {
2192       /* handle end-of-stream/segment */
2193       /* so align our position with the end of it, if there is one
2194        * this ensures a subsequent will arrive at correct base/acc time */
2195       if (wav->segment.format == GST_FORMAT_TIME) {
2196         if (wav->segment.rate > 0.0 &&
2197             GST_CLOCK_TIME_IS_VALID (wav->segment.stop))
2198           wav->segment.position = wav->segment.stop;
2199         else if (wav->segment.rate < 0.0)
2200           wav->segment.position = wav->segment.start;
2201       }
2202       if (wav->state == GST_WAVPARSE_START) {
2203         GST_ELEMENT_ERROR (wav, STREAM, WRONG_TYPE, (NULL),
2204             ("No valid input found before end of stream"));
2205         gst_pad_push_event (wav->srcpad, gst_event_new_eos ());
2206       } else {
2207         /* add pad before we perform EOS */
2208         if (G_UNLIKELY (wav->first)) {
2209           wav->first = FALSE;
2210           gst_wavparse_add_src_pad (wav, NULL);
2211         }
2212
2213         /* perform EOS logic */
2214         if (wav->segment.flags & GST_SEEK_FLAG_SEGMENT) {
2215           GstClockTime stop;
2216
2217           if ((stop = wav->segment.stop) == -1)
2218             stop = wav->segment.duration;
2219
2220           gst_element_post_message (GST_ELEMENT_CAST (wav),
2221               gst_message_new_segment_done (GST_OBJECT_CAST (wav),
2222                   wav->segment.format, stop));
2223           gst_pad_push_event (wav->srcpad,
2224               gst_event_new_segment_done (wav->segment.format, stop));
2225         } else {
2226           gst_pad_push_event (wav->srcpad, gst_event_new_eos ());
2227         }
2228       }
2229     } else if (ret == GST_FLOW_NOT_LINKED || ret < GST_FLOW_EOS) {
2230       /* for fatal errors we post an error message, post the error
2231        * first so the app knows about the error first. */
2232       GST_ELEMENT_ERROR (wav, STREAM, FAILED,
2233           (_("Internal data flow error.")),
2234           ("streaming task paused, reason %s (%d)", reason, ret));
2235       gst_pad_push_event (wav->srcpad, gst_event_new_eos ());
2236     }
2237     return;
2238   }
2239 }
2240
2241 static GstFlowReturn
2242 gst_wavparse_chain (GstPad * pad, GstObject * parent, GstBuffer * buf)
2243 {
2244   GstFlowReturn ret;
2245   GstWavParse *wav = GST_WAVPARSE (parent);
2246
2247   GST_LOG_OBJECT (wav, "adapter_push %" G_GSIZE_FORMAT " bytes",
2248       gst_buffer_get_size (buf));
2249
2250   gst_adapter_push (wav->adapter, buf);
2251
2252   switch (wav->state) {
2253     case GST_WAVPARSE_START:
2254       GST_INFO_OBJECT (wav, "GST_WAVPARSE_START");
2255       if ((ret = gst_wavparse_parse_stream_init (wav)) != GST_FLOW_OK)
2256         goto done;
2257
2258       if (wav->state != GST_WAVPARSE_HEADER)
2259         break;
2260
2261       /* otherwise fall-through */
2262     case GST_WAVPARSE_HEADER:
2263       GST_INFO_OBJECT (wav, "GST_WAVPARSE_HEADER");
2264       if ((ret = gst_wavparse_stream_headers (wav)) != GST_FLOW_OK)
2265         goto done;
2266
2267       if (!wav->got_fmt || wav->datastart == 0)
2268         break;
2269
2270       wav->state = GST_WAVPARSE_DATA;
2271       GST_INFO_OBJECT (wav, "GST_WAVPARSE_DATA");
2272
2273       /* fall-through */
2274     case GST_WAVPARSE_DATA:
2275       if (buf && GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DISCONT))
2276         wav->discont = TRUE;
2277       if ((ret = gst_wavparse_stream_data (wav)) != GST_FLOW_OK)
2278         goto done;
2279       break;
2280     default:
2281       g_return_val_if_reached (GST_FLOW_ERROR);
2282   }
2283 done:
2284   if (G_UNLIKELY (wav->abort_buffering)) {
2285     wav->abort_buffering = FALSE;
2286     ret = GST_FLOW_ERROR;
2287     /* sort of demux/parse error */
2288     GST_ELEMENT_ERROR (wav, STREAM, DEMUX, (NULL), ("unhandled buffer size"));
2289   }
2290
2291   return ret;
2292 }
2293
2294 static GstFlowReturn
2295 gst_wavparse_flush_data (GstWavParse * wav)
2296 {
2297   GstFlowReturn ret = GST_FLOW_OK;
2298   guint av;
2299
2300   if ((av = gst_adapter_available (wav->adapter)) > 0) {
2301     ret = gst_wavparse_stream_data (wav);
2302   }
2303
2304   return ret;
2305 }
2306
2307 static gboolean
2308 gst_wavparse_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
2309 {
2310   GstWavParse *wav = GST_WAVPARSE (parent);
2311   gboolean ret = TRUE;
2312
2313   GST_LOG_OBJECT (wav, "handling %s event", GST_EVENT_TYPE_NAME (event));
2314
2315   switch (GST_EVENT_TYPE (event)) {
2316     case GST_EVENT_CAPS:
2317     {
2318       /* discard, we'll come up with proper src caps */
2319       gst_event_unref (event);
2320       break;
2321     }
2322     case GST_EVENT_SEGMENT:
2323     {
2324       gint64 start, stop, offset = 0, end_offset = -1;
2325       GstSegment segment;
2326
2327       /* some debug output */
2328       gst_event_copy_segment (event, &segment);
2329       GST_DEBUG_OBJECT (wav, "received newsegment %" GST_SEGMENT_FORMAT,
2330           &segment);
2331
2332       if (wav->state != GST_WAVPARSE_DATA) {
2333         GST_DEBUG_OBJECT (wav, "still starting, eating event");
2334         goto exit;
2335       }
2336
2337       /* now we are either committed to TIME or BYTE format,
2338        * and we only expect a BYTE segment, e.g. following a seek */
2339       if (segment.format == GST_FORMAT_BYTES) {
2340         /* handle (un)signed issues */
2341         start = segment.start;
2342         stop = segment.stop;
2343         if (start > 0) {
2344           offset = start;
2345           start -= wav->datastart;
2346           start = MAX (start, 0);
2347         }
2348         if (stop > 0) {
2349           end_offset = stop;
2350           stop -= wav->datastart;
2351           stop = MAX (stop, 0);
2352         }
2353         if (wav->segment.format == GST_FORMAT_TIME) {
2354           guint64 bps = wav->bps;
2355
2356           /* operating in format TIME, so we can convert */
2357           if (!bps && wav->fact)
2358             bps =
2359                 gst_util_uint64_scale_int (wav->datasize, wav->rate, wav->fact);
2360           if (bps) {
2361             if (start >= 0)
2362               start =
2363                   gst_util_uint64_scale_ceil (start, GST_SECOND,
2364                   (guint64) wav->bps);
2365             if (stop >= 0)
2366               stop =
2367                   gst_util_uint64_scale_ceil (stop, GST_SECOND,
2368                   (guint64) wav->bps);
2369           }
2370         }
2371       } else {
2372         GST_DEBUG_OBJECT (wav, "unsupported segment format, ignoring");
2373         goto exit;
2374       }
2375
2376       segment.start = start;
2377       segment.stop = stop;
2378
2379       /* accept upstream's notion of segment and distribute along */
2380       segment.format = wav->segment.format;
2381       segment.time = segment.position = segment.start;
2382       segment.duration = wav->segment.duration;
2383       segment.base = gst_segment_to_running_time (&wav->segment,
2384           GST_FORMAT_TIME, wav->segment.position);
2385
2386       gst_segment_copy_into (&segment, &wav->segment);
2387
2388       /* also store the newsegment event for the streaming thread */
2389       if (wav->start_segment)
2390         gst_event_unref (wav->start_segment);
2391       GST_DEBUG_OBJECT (wav, "Storing newseg %" GST_SEGMENT_FORMAT, &segment);
2392       wav->start_segment = gst_event_new_segment (&segment);
2393
2394       /* stream leftover data in current segment */
2395       gst_wavparse_flush_data (wav);
2396       /* and set up streaming thread for next one */
2397       wav->offset = offset;
2398       wav->end_offset = end_offset;
2399
2400       if (wav->datasize > 0 && (wav->end_offset == -1
2401               || wav->end_offset > wav->datastart + wav->datasize))
2402         wav->end_offset = wav->datastart + wav->datasize;
2403
2404       if (wav->end_offset != -1) {
2405         wav->dataleft = wav->end_offset - wav->offset;
2406       } else {
2407         /* infinity; upstream will EOS when done */
2408         wav->dataleft = G_MAXUINT64;
2409       }
2410     exit:
2411       gst_event_unref (event);
2412       break;
2413     }
2414     case GST_EVENT_EOS:
2415       if (wav->state == GST_WAVPARSE_START) {
2416         GST_ELEMENT_ERROR (wav, STREAM, WRONG_TYPE, (NULL),
2417             ("No valid input found before end of stream"));
2418       } else {
2419         /* add pad if needed so EOS is seen downstream */
2420         if (G_UNLIKELY (wav->first)) {
2421           wav->first = FALSE;
2422           gst_wavparse_add_src_pad (wav, NULL);
2423         } else {
2424           /* stream leftover data in current segment */
2425           gst_wavparse_flush_data (wav);
2426         }
2427       }
2428
2429       /* fall-through */
2430     case GST_EVENT_FLUSH_STOP:
2431     {
2432       GstClockTime dur;
2433
2434       gst_adapter_clear (wav->adapter);
2435       wav->discont = TRUE;
2436       dur = wav->segment.duration;
2437       gst_segment_init (&wav->segment, wav->segment.format);
2438       wav->segment.duration = dur;
2439       /* fall-through */
2440     }
2441     default:
2442       ret = gst_pad_event_default (wav->sinkpad, parent, event);
2443       break;
2444   }
2445
2446   return ret;
2447 }
2448
2449 #if 0
2450 /* convert and query stuff */
2451 static const GstFormat *
2452 gst_wavparse_get_formats (GstPad * pad)
2453 {
2454   static const GstFormat formats[] = {
2455     GST_FORMAT_TIME,
2456     GST_FORMAT_BYTES,
2457     GST_FORMAT_DEFAULT,         /* a "frame", ie a set of samples per Hz */
2458     0
2459   };
2460
2461   return formats;
2462 }
2463 #endif
2464
2465 static gboolean
2466 gst_wavparse_pad_convert (GstPad * pad,
2467     GstFormat src_format, gint64 src_value,
2468     GstFormat * dest_format, gint64 * dest_value)
2469 {
2470   GstWavParse *wavparse;
2471   gboolean res = TRUE;
2472
2473   wavparse = GST_WAVPARSE (GST_PAD_PARENT (pad));
2474
2475   if (*dest_format == src_format) {
2476     *dest_value = src_value;
2477     return TRUE;
2478   }
2479
2480   if ((wavparse->bps == 0) && !wavparse->fact)
2481     goto no_bps_fact;
2482
2483   GST_INFO_OBJECT (wavparse, "converting value from %s to %s",
2484       gst_format_get_name (src_format), gst_format_get_name (*dest_format));
2485
2486   switch (src_format) {
2487     case GST_FORMAT_BYTES:
2488       switch (*dest_format) {
2489         case GST_FORMAT_DEFAULT:
2490           *dest_value = src_value / wavparse->bytes_per_sample;
2491           /* make sure we end up on a sample boundary */
2492           *dest_value -= *dest_value % wavparse->bytes_per_sample;
2493           break;
2494         case GST_FORMAT_TIME:
2495           /* src_value + datastart = offset */
2496           GST_INFO_OBJECT (wavparse,
2497               "src=%" G_GINT64_FORMAT ", offset=%" G_GINT64_FORMAT, src_value,
2498               wavparse->offset);
2499           if (wavparse->bps > 0)
2500             *dest_value = gst_util_uint64_scale_ceil (src_value, GST_SECOND,
2501                 (guint64) wavparse->bps);
2502           else if (wavparse->fact) {
2503             guint64 bps = gst_util_uint64_scale_int_ceil (wavparse->datasize,
2504                 wavparse->rate, wavparse->fact);
2505
2506             *dest_value =
2507                 gst_util_uint64_scale_int_ceil (src_value, GST_SECOND, bps);
2508           } else {
2509             res = FALSE;
2510           }
2511           break;
2512         default:
2513           res = FALSE;
2514           goto done;
2515       }
2516       break;
2517
2518     case GST_FORMAT_DEFAULT:
2519       switch (*dest_format) {
2520         case GST_FORMAT_BYTES:
2521           *dest_value = src_value * wavparse->bytes_per_sample;
2522           break;
2523         case GST_FORMAT_TIME:
2524           *dest_value = gst_util_uint64_scale (src_value, GST_SECOND,
2525               (guint64) wavparse->rate);
2526           break;
2527         default:
2528           res = FALSE;
2529           goto done;
2530       }
2531       break;
2532
2533     case GST_FORMAT_TIME:
2534       switch (*dest_format) {
2535         case GST_FORMAT_BYTES:
2536           if (wavparse->bps > 0)
2537             *dest_value = gst_util_uint64_scale (src_value,
2538                 (guint64) wavparse->bps, GST_SECOND);
2539           else {
2540             guint64 bps = gst_util_uint64_scale_int (wavparse->datasize,
2541                 wavparse->rate, wavparse->fact);
2542
2543             *dest_value = gst_util_uint64_scale (src_value, bps, GST_SECOND);
2544           }
2545           /* make sure we end up on a sample boundary */
2546           *dest_value -= *dest_value % wavparse->blockalign;
2547           break;
2548         case GST_FORMAT_DEFAULT:
2549           *dest_value = gst_util_uint64_scale (src_value,
2550               (guint64) wavparse->rate, GST_SECOND);
2551           break;
2552         default:
2553           res = FALSE;
2554           goto done;
2555       }
2556       break;
2557
2558     default:
2559       res = FALSE;
2560       goto done;
2561   }
2562
2563 done:
2564   return res;
2565
2566   /* ERRORS */
2567 no_bps_fact:
2568   {
2569     GST_DEBUG_OBJECT (wavparse, "bps 0 or no fact chunk, cannot convert");
2570     res = FALSE;
2571     goto done;
2572   }
2573 }
2574
2575 /* handle queries for location and length in requested format */
2576 static gboolean
2577 gst_wavparse_pad_query (GstPad * pad, GstObject * parent, GstQuery * query)
2578 {
2579   gboolean res = TRUE;
2580   GstWavParse *wav = GST_WAVPARSE (parent);
2581
2582   /* only if we know */
2583   if (wav->state != GST_WAVPARSE_DATA) {
2584     return FALSE;
2585   }
2586
2587   GST_LOG_OBJECT (pad, "%s query", GST_QUERY_TYPE_NAME (query));
2588
2589   switch (GST_QUERY_TYPE (query)) {
2590     case GST_QUERY_POSITION:
2591     {
2592       gint64 curb;
2593       gint64 cur;
2594       GstFormat format;
2595
2596       /* this is not very precise, as we have pushed severla buffer upstream for prerolling */
2597       curb = wav->offset - wav->datastart;
2598       gst_query_parse_position (query, &format, NULL);
2599       GST_INFO_OBJECT (wav, "pos query at %" G_GINT64_FORMAT, curb);
2600
2601       switch (format) {
2602         case GST_FORMAT_BYTES:
2603           format = GST_FORMAT_BYTES;
2604           cur = curb;
2605           break;
2606         default:
2607           res = gst_wavparse_pad_convert (pad, GST_FORMAT_BYTES, curb,
2608               &format, &cur);
2609           break;
2610       }
2611       if (res)
2612         gst_query_set_position (query, format, cur);
2613       break;
2614     }
2615     case GST_QUERY_DURATION:
2616     {
2617       gint64 duration = 0;
2618       GstFormat format;
2619
2620       if (wav->ignore_length) {
2621         res = FALSE;
2622         break;
2623       }
2624
2625       gst_query_parse_duration (query, &format, NULL);
2626
2627       switch (format) {
2628         case GST_FORMAT_BYTES:{
2629           format = GST_FORMAT_BYTES;
2630           duration = wav->datasize;
2631           break;
2632         }
2633         case GST_FORMAT_TIME:
2634           if ((res = gst_wavparse_calculate_duration (wav))) {
2635             duration = wav->duration;
2636           }
2637           break;
2638         default:
2639           res = FALSE;
2640           break;
2641       }
2642       if (res)
2643         gst_query_set_duration (query, format, duration);
2644       break;
2645     }
2646     case GST_QUERY_CONVERT:
2647     {
2648       gint64 srcvalue, dstvalue;
2649       GstFormat srcformat, dstformat;
2650
2651       gst_query_parse_convert (query, &srcformat, &srcvalue,
2652           &dstformat, &dstvalue);
2653       res = gst_wavparse_pad_convert (pad, srcformat, srcvalue,
2654           &dstformat, &dstvalue);
2655       if (res)
2656         gst_query_set_convert (query, srcformat, srcvalue, dstformat, dstvalue);
2657       break;
2658     }
2659     case GST_QUERY_SEEKING:{
2660       GstFormat fmt;
2661       gboolean seekable = FALSE;
2662
2663       gst_query_parse_seeking (query, &fmt, NULL, NULL, NULL);
2664       if (fmt == wav->segment.format) {
2665         if (wav->streaming) {
2666           GstQuery *q;
2667
2668           q = gst_query_new_seeking (GST_FORMAT_BYTES);
2669           if ((res = gst_pad_peer_query (wav->sinkpad, q))) {
2670             gst_query_parse_seeking (q, &fmt, &seekable, NULL, NULL);
2671             GST_LOG_OBJECT (wav, "upstream BYTE seekable %d", seekable);
2672           }
2673           gst_query_unref (q);
2674         } else {
2675           GST_LOG_OBJECT (wav, "looping => seekable");
2676           seekable = TRUE;
2677           res = TRUE;
2678         }
2679       } else if (fmt == GST_FORMAT_TIME) {
2680         res = TRUE;
2681       }
2682       if (res) {
2683         gst_query_set_seeking (query, fmt, seekable, 0, wav->segment.duration);
2684       }
2685       break;
2686     }
2687     default:
2688       res = gst_pad_query_default (pad, parent, query);
2689       break;
2690   }
2691   return res;
2692 }
2693
2694 static gboolean
2695 gst_wavparse_srcpad_event (GstPad * pad, GstObject * parent, GstEvent * event)
2696 {
2697   GstWavParse *wavparse = GST_WAVPARSE (parent);
2698   gboolean res = FALSE;
2699
2700   GST_DEBUG_OBJECT (wavparse, "%s event", GST_EVENT_TYPE_NAME (event));
2701
2702   switch (GST_EVENT_TYPE (event)) {
2703     case GST_EVENT_SEEK:
2704       /* can only handle events when we are in the data state */
2705       if (wavparse->state == GST_WAVPARSE_DATA) {
2706         res = gst_wavparse_perform_seek (wavparse, event);
2707       }
2708       gst_event_unref (event);
2709       break;
2710
2711     case GST_EVENT_TOC_SELECT:
2712     {
2713       char *uid = NULL;
2714       GstTocEntry *entry = NULL;
2715       GstEvent *seek_event;
2716       gint64 start_pos;
2717
2718       if (!wavparse->toc) {
2719         GST_DEBUG_OBJECT (wavparse, "no TOC to select");
2720         return FALSE;
2721       } else {
2722         gst_event_parse_toc_select (event, &uid);
2723         if (uid != NULL) {
2724           GST_OBJECT_LOCK (wavparse);
2725           entry = gst_toc_find_entry (wavparse->toc, uid);
2726           if (entry == NULL) {
2727             GST_OBJECT_UNLOCK (wavparse);
2728             GST_WARNING_OBJECT (wavparse, "no TOC entry with given UID: %s",
2729                 uid);
2730             res = FALSE;
2731           } else {
2732             gst_toc_entry_get_start_stop_times (entry, &start_pos, NULL);
2733             GST_OBJECT_UNLOCK (wavparse);
2734             seek_event = gst_event_new_seek (1.0,
2735                 GST_FORMAT_TIME,
2736                 GST_SEEK_FLAG_FLUSH,
2737                 GST_SEEK_TYPE_SET, start_pos, GST_SEEK_TYPE_SET, -1);
2738             res = gst_wavparse_perform_seek (wavparse, seek_event);
2739             gst_event_unref (seek_event);
2740           }
2741           g_free (uid);
2742         } else {
2743           GST_WARNING_OBJECT (wavparse, "received empty TOC select event");
2744           res = FALSE;
2745         }
2746       }
2747       gst_event_unref (event);
2748       break;
2749     }
2750
2751     default:
2752       res = gst_pad_push_event (wavparse->sinkpad, event);
2753       break;
2754   }
2755   return res;
2756 }
2757
2758 static gboolean
2759 gst_wavparse_sink_activate (GstPad * sinkpad, GstObject * parent)
2760 {
2761   GstWavParse *wav = GST_WAVPARSE (parent);
2762   GstQuery *query;
2763   gboolean pull_mode;
2764
2765   if (wav->adapter) {
2766     gst_adapter_clear (wav->adapter);
2767     g_object_unref (wav->adapter);
2768     wav->adapter = NULL;
2769   }
2770
2771   query = gst_query_new_scheduling ();
2772
2773   if (!gst_pad_peer_query (sinkpad, query)) {
2774     gst_query_unref (query);
2775     goto activate_push;
2776   }
2777
2778   pull_mode = gst_query_has_scheduling_mode_with_flags (query,
2779       GST_PAD_MODE_PULL, GST_SCHEDULING_FLAG_SEEKABLE);
2780   gst_query_unref (query);
2781
2782   if (!pull_mode)
2783     goto activate_push;
2784
2785   GST_DEBUG_OBJECT (sinkpad, "activating pull");
2786   wav->streaming = FALSE;
2787   return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PULL, TRUE);
2788
2789 activate_push:
2790   {
2791     GST_DEBUG_OBJECT (sinkpad, "activating push");
2792     wav->streaming = TRUE;
2793     wav->adapter = gst_adapter_new ();
2794     return gst_pad_activate_mode (sinkpad, GST_PAD_MODE_PUSH, TRUE);
2795   }
2796 }
2797
2798
2799 static gboolean
2800 gst_wavparse_sink_activate_mode (GstPad * sinkpad, GstObject * parent,
2801     GstPadMode mode, gboolean active)
2802 {
2803   gboolean res;
2804
2805   switch (mode) {
2806     case GST_PAD_MODE_PUSH:
2807       res = TRUE;
2808       break;
2809     case GST_PAD_MODE_PULL:
2810       if (active) {
2811         /* if we have a scheduler we can start the task */
2812         res = gst_pad_start_task (sinkpad, (GstTaskFunction) gst_wavparse_loop,
2813             sinkpad, NULL);
2814       } else {
2815         res = gst_pad_stop_task (sinkpad);
2816       }
2817       break;
2818     default:
2819       res = FALSE;
2820       break;
2821   }
2822   return res;
2823 }
2824
2825 static GstStateChangeReturn
2826 gst_wavparse_change_state (GstElement * element, GstStateChange transition)
2827 {
2828   GstStateChangeReturn ret;
2829   GstWavParse *wav = GST_WAVPARSE (element);
2830
2831   switch (transition) {
2832     case GST_STATE_CHANGE_NULL_TO_READY:
2833       break;
2834     case GST_STATE_CHANGE_READY_TO_PAUSED:
2835       gst_wavparse_reset (wav);
2836       break;
2837     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
2838       break;
2839     default:
2840       break;
2841   }
2842
2843   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
2844
2845   switch (transition) {
2846     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
2847       break;
2848     case GST_STATE_CHANGE_PAUSED_TO_READY:
2849       gst_wavparse_reset (wav);
2850       break;
2851     case GST_STATE_CHANGE_READY_TO_NULL:
2852       break;
2853     default:
2854       break;
2855   }
2856   return ret;
2857 }
2858
2859 static void
2860 gst_wavparse_set_property (GObject * object, guint prop_id,
2861     const GValue * value, GParamSpec * pspec)
2862 {
2863   GstWavParse *self;
2864
2865   g_return_if_fail (GST_IS_WAVPARSE (object));
2866   self = GST_WAVPARSE (object);
2867
2868   switch (prop_id) {
2869     case PROP_IGNORE_LENGTH:
2870       self->ignore_length = g_value_get_boolean (value);
2871       break;
2872     default:
2873       G_OBJECT_WARN_INVALID_PROPERTY_ID (self, prop_id, pspec);
2874   }
2875
2876 }
2877
2878 static void
2879 gst_wavparse_get_property (GObject * object, guint prop_id,
2880     GValue * value, GParamSpec * pspec)
2881 {
2882   GstWavParse *self;
2883
2884   g_return_if_fail (GST_IS_WAVPARSE (object));
2885   self = GST_WAVPARSE (object);
2886
2887   switch (prop_id) {
2888     case PROP_IGNORE_LENGTH:
2889       g_value_set_boolean (value, self->ignore_length);
2890       break;
2891     default:
2892       G_OBJECT_WARN_INVALID_PROPERTY_ID (self, prop_id, pspec);
2893   }
2894 }
2895
2896 static gboolean
2897 plugin_init (GstPlugin * plugin)
2898 {
2899   gst_riff_init ();
2900
2901   return gst_element_register (plugin, "wavparse", GST_RANK_PRIMARY,
2902       GST_TYPE_WAVPARSE);
2903 }
2904
2905 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
2906     GST_VERSION_MINOR,
2907     wavparse,
2908     "Parse a .wav file into raw audio",
2909     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)