ext/speex/gstspeexdec.c

   1 /* GStreamer
   2  * Copyright (C) 2004 Wim Taymans <wim@fluendo.com>
   3  * Copyright (C) 2006 Tim-Philipp Müller <tim centricular net>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-speexdec
  23  * @see_also: speexenc, oggdemux
  24  *
  25  * This element decodes a Speex stream to raw integer audio.
  26  * <ulink url="http://www.speex.org/">Speex</ulink> is a royalty-free
  27  * audio codec maintained by the <ulink url="http://www.xiph.org/">Xiph.org
  28  * Foundation</ulink>.
  29  *
  30  * <refsect2>
  31  * <title>Example pipelines</title>
  32  * |[
  33  * gst-launch-1.0 -v filesrc location=speex.ogg ! oggdemux ! speexdec ! audioconvert ! audioresample ! alsasink
  34  * ]| Decode an Ogg/Speex file. To create an Ogg/Speex file refer to the
  35  * documentation of speexenc.
  36  * </refsect2>
  37  */
  38
  39 #ifdef HAVE_CONFIG_H
  40 #  include "config.h"
  41 #endif
  42
  43 #include "gstspeexdec.h"
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <gst/tag/tag.h>
  47 #include <gst/audio/audio.h>
  48
  49 GST_DEBUG_CATEGORY_STATIC (speexdec_debug);
  50 #define GST_CAT_DEFAULT speexdec_debug
  51
  52 #define DEFAULT_ENH   TRUE
  53
  54 enum
  55 {
  56   ARG_0,
  57   ARG_ENH
  58 };
  59
  60 #define FORMAT_STR GST_AUDIO_NE(S16)
  61
  62 static GstStaticPadTemplate speex_dec_src_factory =
  63 GST_STATIC_PAD_TEMPLATE ("src",
  64     GST_PAD_SRC,
  65     GST_PAD_ALWAYS,
  66     GST_STATIC_CAPS ("audio/x-raw, "
  67         "format = (string) " FORMAT_STR ", "
  68         "layout = (string) interleaved, "
  69         "rate = (int) [ 6000, 48000 ], " "channels = (int) [ 1, 2 ]")
  70     );
  71
  72 static GstStaticPadTemplate speex_dec_sink_factory =
  73 GST_STATIC_PAD_TEMPLATE ("sink",
  74     GST_PAD_SINK,
  75     GST_PAD_ALWAYS,
  76     GST_STATIC_CAPS ("audio/x-speex")
  77     );
  78
  79 #define gst_speex_dec_parent_class parent_class
  80 G_DEFINE_TYPE (GstSpeexDec, gst_speex_dec, GST_TYPE_AUDIO_DECODER);
  81
  82 static gboolean gst_speex_dec_start (GstAudioDecoder * dec);
  83 static gboolean gst_speex_dec_stop (GstAudioDecoder * dec);
  84 static gboolean gst_speex_dec_set_format (GstAudioDecoder * bdec,
  85     GstCaps * caps);
  86 static GstFlowReturn gst_speex_dec_handle_frame (GstAudioDecoder * dec,
  87     GstBuffer * buffer);
  88
  89 static void gst_speex_dec_get_property (GObject * object, guint prop_id,
  90     GValue * value, GParamSpec * pspec);
  91 static void gst_speex_dec_set_property (GObject * object, guint prop_id,
  92     const GValue * value, GParamSpec * pspec);
  93
  94 static void
  95 gst_speex_dec_class_init (GstSpeexDecClass * klass)
  96 {
  97   GObjectClass *gobject_class;
  98   GstElementClass *gstelement_class;
  99   GstAudioDecoderClass *base_class;
 100
 101   gobject_class = (GObjectClass *) klass;
 102   gstelement_class = (GstElementClass *) klass;
 103   base_class = (GstAudioDecoderClass *) klass;
 104
 105   gobject_class->set_property = gst_speex_dec_set_property;
 106   gobject_class->get_property = gst_speex_dec_get_property;
 107
 108   base_class->start = GST_DEBUG_FUNCPTR (gst_speex_dec_start);
 109   base_class->stop = GST_DEBUG_FUNCPTR (gst_speex_dec_stop);
 110   base_class->set_format = GST_DEBUG_FUNCPTR (gst_speex_dec_set_format);
 111   base_class->handle_frame = GST_DEBUG_FUNCPTR (gst_speex_dec_handle_frame);
 112
 113   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_ENH,
 114       g_param_spec_boolean ("enh", "Enh", "Enable perceptual enhancement",
 115           DEFAULT_ENH, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 116
 117   gst_element_class_add_pad_template (gstelement_class,
 118       gst_static_pad_template_get (&speex_dec_src_factory));
 119   gst_element_class_add_pad_template (gstelement_class,
 120       gst_static_pad_template_get (&speex_dec_sink_factory));
 121   gst_element_class_set_static_metadata (gstelement_class,
 122       "Speex audio decoder", "Codec/Decoder/Audio",
 123       "decode speex streams to audio", "Wim Taymans <wim@fluendo.com>");
 124
 125   GST_DEBUG_CATEGORY_INIT (speexdec_debug, "speexdec", 0,
 126       "speex decoding element");
 127 }
 128
 129 static void
 130 gst_speex_dec_reset (GstSpeexDec * dec)
 131 {
 132   dec->packetno = 0;
 133   dec->frame_size = 0;
 134   dec->frame_duration = 0;
 135   dec->mode = NULL;
 136   free (dec->header);
 137   dec->header = NULL;
 138   speex_bits_destroy (&dec->bits);
 139   speex_bits_set_bit_buffer (&dec->bits, NULL, 0);
 140
 141   gst_buffer_replace (&dec->streamheader, NULL);
 142   gst_buffer_replace (&dec->vorbiscomment, NULL);
 143
 144   if (dec->stereo) {
 145     speex_stereo_state_destroy (dec->stereo);
 146     dec->stereo = NULL;
 147   }
 148
 149   if (dec->state) {
 150     speex_decoder_destroy (dec->state);
 151     dec->state = NULL;
 152   }
 153 }
 154
 155 static void
 156 gst_speex_dec_init (GstSpeexDec * dec)
 157 {
 158   gst_audio_decoder_set_needs_format (GST_AUDIO_DECODER (dec), TRUE);
 159
 160   dec->enh = DEFAULT_ENH;
 161
 162   gst_speex_dec_reset (dec);
 163 }
 164
 165 static gboolean
 166 gst_speex_dec_start (GstAudioDecoder * dec)
 167 {
 168   GstSpeexDec *sd = GST_SPEEX_DEC (dec);
 169
 170   GST_DEBUG_OBJECT (dec, "start");
 171   gst_speex_dec_reset (sd);
 172
 173   /* we know about concealment */
 174   gst_audio_decoder_set_plc_aware (dec, TRUE);
 175
 176   return TRUE;
 177 }
 178
 179 static gboolean
 180 gst_speex_dec_stop (GstAudioDecoder * dec)
 181 {
 182   GstSpeexDec *sd = GST_SPEEX_DEC (dec);
 183
 184   GST_DEBUG_OBJECT (dec, "stop");
 185   gst_speex_dec_reset (sd);
 186
 187   return TRUE;
 188 }
 189
 190 static GstFlowReturn
 191 gst_speex_dec_parse_header (GstSpeexDec * dec, GstBuffer * buf)
 192 {
 193   GstMapInfo map;
 194   GstAudioInfo info;
 195   static const GstAudioChannelPosition chan_pos[2][2] = {
 196     {GST_AUDIO_CHANNEL_POSITION_MONO},
 197     {GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
 198         GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT}
 199   };
 200
 201   /* get the header */
 202   gst_buffer_map (buf, &map, GST_MAP_READ);
 203   dec->header = speex_packet_to_header ((gchar *) map.data, map.size);
 204   gst_buffer_unmap (buf, &map);
 205
 206   if (!dec->header)
 207     goto no_header;
 208
 209   if (dec->header->mode >= SPEEX_NB_MODES || dec->header->mode < 0)
 210     goto mode_too_old;
 211
 212   dec->mode = speex_lib_get_mode (dec->header->mode);
 213
 214   /* initialize the decoder */
 215   dec->state = speex_decoder_init (dec->mode);
 216   if (!dec->state)
 217     goto init_failed;
 218
 219   speex_decoder_ctl (dec->state, SPEEX_SET_ENH, &dec->enh);
 220   speex_decoder_ctl (dec->state, SPEEX_GET_FRAME_SIZE, &dec->frame_size);
 221
 222   if (dec->header->nb_channels != 1) {
 223     dec->stereo = speex_stereo_state_init ();
 224     dec->callback.callback_id = SPEEX_INBAND_STEREO;
 225     dec->callback.func = speex_std_stereo_request_handler;
 226     dec->callback.data = dec->stereo;
 227     speex_decoder_ctl (dec->state, SPEEX_SET_HANDLER, &dec->callback);
 228   }
 229
 230   speex_decoder_ctl (dec->state, SPEEX_SET_SAMPLING_RATE, &dec->header->rate);
 231
 232   dec->frame_duration = gst_util_uint64_scale_int (dec->frame_size,
 233       GST_SECOND, dec->header->rate);
 234
 235   speex_bits_init (&dec->bits);
 236
 237   /* set caps */
 238   gst_audio_info_init (&info);
 239   gst_audio_info_set_format (&info,
 240       GST_AUDIO_FORMAT_S16,
 241       dec->header->rate,
 242       dec->header->nb_channels, chan_pos[dec->header->nb_channels - 1]);
 243
 244   if (!gst_audio_decoder_set_output_format (GST_AUDIO_DECODER (dec), &info))
 245     goto nego_failed;
 246
 247   return GST_FLOW_OK;
 248
 249   /* ERRORS */
 250 no_header:
 251   {
 252     GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
 253         (NULL), ("couldn't read header"));
 254     return GST_FLOW_ERROR;
 255   }
 256 mode_too_old:
 257   {
 258     GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
 259         (NULL),
 260         ("Mode number %d does not (yet/any longer) exist in this version",
 261             dec->header->mode));
 262     return GST_FLOW_ERROR;
 263   }
 264 init_failed:
 265   {
 266     GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
 267         (NULL), ("couldn't initialize decoder"));
 268     return GST_FLOW_ERROR;
 269   }
 270 nego_failed:
 271   {
 272     GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
 273         (NULL), ("couldn't negotiate format"));
 274     return GST_FLOW_NOT_NEGOTIATED;
 275   }
 276 }
 277
 278 static GstFlowReturn
 279 gst_speex_dec_parse_comments (GstSpeexDec * dec, GstBuffer * buf)
 280 {
 281   GstTagList *list;
 282   gchar *ver, *encoder = NULL;
 283
 284   list = gst_tag_list_from_vorbiscomment_buffer (buf, NULL, 0, &encoder);
 285
 286   if (!list) {
 287     GST_WARNING_OBJECT (dec, "couldn't decode comments");
 288     list = gst_tag_list_new_empty ();
 289   }
 290
 291   if (encoder) {
 292     gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
 293         GST_TAG_ENCODER, encoder, NULL);
 294   }
 295
 296   gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
 297       GST_TAG_AUDIO_CODEC, "Speex", NULL);
 298
 299   ver = g_strndup (dec->header->speex_version, SPEEX_HEADER_VERSION_LENGTH);
 300   g_strstrip (ver);
 301
 302   if (ver != NULL && *ver != '\0') {
 303     gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
 304         GST_TAG_ENCODER_VERSION, ver, NULL);
 305   }
 306
 307   if (dec->header->bitrate > 0) {
 308     gst_tag_list_add (list, GST_TAG_MERGE_REPLACE,
 309         GST_TAG_BITRATE, (guint) dec->header->bitrate, NULL);
 310   }
 311
 312   GST_INFO_OBJECT (dec, "tags: %" GST_PTR_FORMAT, list);
 313
 314   gst_audio_decoder_merge_tags (GST_AUDIO_DECODER (dec), list,
 315       GST_TAG_MERGE_REPLACE);
 316   gst_tag_list_unref (list);
 317
 318   g_free (encoder);
 319   g_free (ver);
 320
 321   return GST_FLOW_OK;
 322 }
 323
 324 static gboolean
 325 gst_speex_dec_set_format (GstAudioDecoder * bdec, GstCaps * caps)
 326 {
 327   GstSpeexDec *dec = GST_SPEEX_DEC (bdec);
 328   gboolean ret = TRUE;
 329   GstStructure *s;
 330   const GValue *streamheader;
 331
 332   s = gst_caps_get_structure (caps, 0);
 333   if ((streamheader = gst_structure_get_value (s, "streamheader")) &&
 334       G_VALUE_HOLDS (streamheader, GST_TYPE_ARRAY) &&
 335       gst_value_array_get_size (streamheader) >= 2) {
 336     const GValue *header, *vorbiscomment;
 337     GstBuffer *buf;
 338     GstFlowReturn res = GST_FLOW_OK;
 339
 340     header = gst_value_array_get_value (streamheader, 0);
 341     if (header && G_VALUE_HOLDS (header, GST_TYPE_BUFFER)) {
 342       buf = gst_value_get_buffer (header);
 343       res = gst_speex_dec_parse_header (dec, buf);
 344       if (res != GST_FLOW_OK)
 345         goto done;
 346       gst_buffer_replace (&dec->streamheader, buf);
 347     }
 348
 349     vorbiscomment = gst_value_array_get_value (streamheader, 1);
 350     if (vorbiscomment && G_VALUE_HOLDS (vorbiscomment, GST_TYPE_BUFFER)) {
 351       buf = gst_value_get_buffer (vorbiscomment);
 352       res = gst_speex_dec_parse_comments (dec, buf);
 353       if (res != GST_FLOW_OK)
 354         goto done;
 355       gst_buffer_replace (&dec->vorbiscomment, buf);
 356     }
 357   }
 358
 359 done:
 360   return ret;
 361 }
 362
 363 static GstFlowReturn
 364 gst_speex_dec_parse_data (GstSpeexDec * dec, GstBuffer * buf)
 365 {
 366   GstFlowReturn res = GST_FLOW_OK;
 367   gint i, fpp;
 368   SpeexBits *bits;
 369   GstMapInfo map;
 370
 371   if (!dec->frame_duration)
 372     goto not_negotiated;
 373
 374   if (G_LIKELY (gst_buffer_get_size (buf))) {
 375     /* send data to the bitstream */
 376     gst_buffer_map (buf, &map, GST_MAP_READ);
 377     speex_bits_read_from (&dec->bits, (gchar *) map.data, map.size);
 378     gst_buffer_unmap (buf, &map);
 379
 380     fpp = dec->header->frames_per_packet;
 381     bits = &dec->bits;
 382
 383     GST_DEBUG_OBJECT (dec, "received buffer of size %" G_GSIZE_FORMAT
 384         ", fpp %d, %d bits", map.size, fpp, speex_bits_remaining (bits));
 385   } else {
 386     /* FIXME ? actually consider how much concealment is needed */
 387     /* concealment data, pass NULL as the bits parameters */
 388     GST_DEBUG_OBJECT (dec, "creating concealment data");
 389     fpp = dec->header->frames_per_packet;
 390     bits = NULL;
 391   }
 392
 393   /* now decode each frame, catering for unknown number of them (e.g. rtp) */
 394   for (i = 0; i < fpp; i++) {
 395     GstBuffer *outbuf;
 396     gboolean corrupted = FALSE;
 397     gint ret;
 398
 399     GST_LOG_OBJECT (dec, "decoding frame %d/%d, %d bits remaining", i, fpp,
 400         bits ? speex_bits_remaining (bits) : -1);
 401 #if 0
 402     res =
 403         gst_pad_alloc_buffer_and_set_caps (GST_AUDIO_DECODER_SRC_PAD (dec),
 404         GST_BUFFER_OFFSET_NONE, dec->frame_size * dec->header->nb_channels * 2,
 405         GST_PAD_CAPS (GST_AUDIO_DECODER_SRC_PAD (dec)), &outbuf);
 406
 407     if (res != GST_FLOW_OK) {
 408       GST_DEBUG_OBJECT (dec, "buf alloc flow: %s", gst_flow_get_name (res));
 409       return res;
 410     }
 411 #endif
 412     /* FIXME, we can use a bufferpool because we have fixed size buffers. We
 413      * could also use an allocator */
 414     outbuf =
 415         gst_buffer_new_allocate (NULL,
 416         dec->frame_size * dec->header->nb_channels * 2, NULL);
 417
 418     gst_buffer_map (outbuf, &map, GST_MAP_WRITE);
 419     ret = speex_decode_int (dec->state, bits, (spx_int16_t *) map.data);
 420
 421     if (ret == -1) {
 422       /* uh? end of stream */
 423       GST_WARNING_OBJECT (dec, "Unexpected end of stream found");
 424       corrupted = TRUE;
 425     } else if (ret == -2) {
 426       GST_WARNING_OBJECT (dec, "Decoding error: corrupted stream?");
 427       corrupted = TRUE;
 428     }
 429
 430     if (bits && speex_bits_remaining (bits) < 0) {
 431       GST_WARNING_OBJECT (dec, "Decoding overflow: corrupted stream?");
 432       corrupted = TRUE;
 433     }
 434     if (dec->header->nb_channels == 2)
 435       speex_decode_stereo_int ((spx_int16_t *) map.data, dec->frame_size,
 436           dec->stereo);
 437
 438     gst_buffer_unmap (outbuf, &map);
 439
 440     if (!corrupted) {
 441       res = gst_audio_decoder_finish_frame (GST_AUDIO_DECODER (dec), outbuf, 1);
 442     } else {
 443       res = gst_audio_decoder_finish_frame (GST_AUDIO_DECODER (dec), NULL, 1);
 444       gst_buffer_unref (outbuf);
 445     }
 446
 447     if (res != GST_FLOW_OK) {
 448       GST_DEBUG_OBJECT (dec, "flow: %s", gst_flow_get_name (res));
 449       break;
 450     }
 451   }
 452
 453   return res;
 454
 455   /* ERRORS */
 456 not_negotiated:
 457   {
 458     GST_ELEMENT_ERROR (dec, CORE, NEGOTIATION, (NULL),
 459         ("decoder not initialized"));
 460     return GST_FLOW_NOT_NEGOTIATED;
 461   }
 462 }
 463
 464 static gboolean
 465 memcmp_buffers (GstBuffer * buf1, GstBuffer * buf2)
 466 {
 467   GstMapInfo map;
 468   gsize size1, size2;
 469   gboolean res;
 470
 471   size1 = gst_buffer_get_size (buf1);
 472   size2 = gst_buffer_get_size (buf2);
 473
 474   if (size1 != size2)
 475     return FALSE;
 476
 477   gst_buffer_map (buf1, &map, GST_MAP_READ);
 478   res = gst_buffer_memcmp (buf2, 0, map.data, map.size) == 0;
 479   gst_buffer_unmap (buf1, &map);
 480
 481   return res;
 482 }
 483
 484 static GstFlowReturn
 485 gst_speex_dec_handle_frame (GstAudioDecoder * bdec, GstBuffer * buf)
 486 {
 487   GstFlowReturn res;
 488   GstSpeexDec *dec;
 489
 490   /* no fancy draining */
 491   if (G_UNLIKELY (!buf))
 492     return GST_FLOW_OK;
 493
 494   dec = GST_SPEEX_DEC (bdec);
 495
 496   /* If we have the streamheader and vorbiscomment from the caps already
 497    * ignore them here */
 498   if (dec->streamheader && dec->vorbiscomment) {
 499     if (memcmp_buffers (dec->streamheader, buf)) {
 500       GST_DEBUG_OBJECT (dec, "found streamheader");
 501       gst_audio_decoder_finish_frame (bdec, NULL, 1);
 502       res = GST_FLOW_OK;
 503     } else if (memcmp_buffers (dec->vorbiscomment, buf)) {
 504       GST_DEBUG_OBJECT (dec, "found vorbiscomments");
 505       gst_audio_decoder_finish_frame (bdec, NULL, 1);
 506       res = GST_FLOW_OK;
 507     } else {
 508       res = gst_speex_dec_parse_data (dec, buf);
 509     }
 510   } else {
 511     /* Otherwise fall back to packet counting and assume that the
 512      * first two packets are the headers. */
 513     switch (dec->packetno) {
 514       case 0:
 515         GST_DEBUG_OBJECT (dec, "counted streamheader");
 516         res = gst_speex_dec_parse_header (dec, buf);
 517         gst_audio_decoder_finish_frame (bdec, NULL, 1);
 518         break;
 519       case 1:
 520         GST_DEBUG_OBJECT (dec, "counted vorbiscomments");
 521         res = gst_speex_dec_parse_comments (dec, buf);
 522         gst_audio_decoder_finish_frame (bdec, NULL, 1);
 523         break;
 524       default:
 525       {
 526         res = gst_speex_dec_parse_data (dec, buf);
 527         break;
 528       }
 529     }
 530   }
 531
 532   dec->packetno++;
 533
 534   return res;
 535 }
 536
 537 static void
 538 gst_speex_dec_get_property (GObject * object, guint prop_id,
 539     GValue * value, GParamSpec * pspec)
 540 {
 541   GstSpeexDec *speexdec;
 542
 543   speexdec = GST_SPEEX_DEC (object);
 544
 545   switch (prop_id) {
 546     case ARG_ENH:
 547       g_value_set_boolean (value, speexdec->enh);
 548       break;
 549     default:
 550       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 551       break;
 552   }
 553 }
 554
 555 static void
 556 gst_speex_dec_set_property (GObject * object, guint prop_id,
 557     const GValue * value, GParamSpec * pspec)
 558 {
 559   GstSpeexDec *speexdec;
 560
 561   speexdec = GST_SPEEX_DEC (object);
 562
 563   switch (prop_id) {
 564     case ARG_ENH:
 565       speexdec->enh = g_value_get_boolean (value);
 566       break;
 567     default:
 568       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 569       break;
 570   }
 571 }