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