gst-libs/gst/audio/gstaudiosrc.c

   1 /* GStreamer
   2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
   3  *                    2005 Wim Taymans <wim@fluendo.com>
   4  *
   5  * gstaudiosrc.c: simple audio src base class
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /**
  24  * SECTION:gstaudiosrc
  25  * @short_description: Simple base class for audio sources
  26  * @see_also: #GstAudioBaseSrc, #GstAudioRingBuffer, #GstAudioSrc.
  27  *
  28  * This is the most simple base class for audio sources that only requires
  29  * subclasses to implement a set of simple functions:
  30  *
  31  * <variablelist>
  32  *   <varlistentry>
  33  *     <term>open()</term>
  34  *     <listitem><para>Open the device.</para></listitem>
  35  *   </varlistentry>
  36  *   <varlistentry>
  37  *     <term>prepare()</term>
  38  *     <listitem><para>Configure the device with the specified format.</para></listitem>
  39  *   </varlistentry>
  40  *   <varlistentry>
  41  *     <term>read()</term>
  42  *     <listitem><para>Read samples from the device.</para></listitem>
  43  *   </varlistentry>
  44  *   <varlistentry>
  45  *     <term>reset()</term>
  46  *     <listitem><para>Unblock reads and flush the device.</para></listitem>
  47  *   </varlistentry>
  48  *   <varlistentry>
  49  *     <term>delay()</term>
  50  *     <listitem><para>Get the number of samples in the device but not yet read.
  51  *     </para></listitem>
  52  *   </varlistentry>
  53  *   <varlistentry>
  54  *     <term>unprepare()</term>
  55  *     <listitem><para>Undo operations done by prepare.</para></listitem>
  56  *   </varlistentry>
  57  *   <varlistentry>
  58  *     <term>close()</term>
  59  *     <listitem><para>Close the device.</para></listitem>
  60  *   </varlistentry>
  61  * </variablelist>
  62  *
  63  * All scheduling of samples and timestamps is done in this base class
  64  * together with #GstAudioBaseSrc using a default implementation of a
  65  * #GstAudioRingBuffer that uses threads.
  66  *
  67  * Last reviewed on 2006-09-27 (0.10.12)
  68  */
  69
  70 #include <string.h>
  71
  72 #include "gstaudiosrc.h"
  73
  74 #include "gst/glib-compat-private.h"
  75
  76 GST_DEBUG_CATEGORY_STATIC (gst_audio_src_debug);
  77 #define GST_CAT_DEFAULT gst_audio_src_debug
  78
  79 #define GST_TYPE_AUDIO_SRC_RING_BUFFER        \
  80         (gst_audio_src_ring_buffer_get_type())
  81 #define GST_AUDIO_SRC_RING_BUFFER(obj)        \
  82         (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_SRC_RING_BUFFER,GstAudioSrcRingBuffer))
  83 #define GST_AUDIO_SRC_RING_BUFFER_CLASS(klass) \
  84         (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIO_SRC_RING_BUFFER,GstAudioSrcRingBufferClass))
  85 #define GST_AUDIO_SRC_RING_BUFFER_GET_CLASS(obj) \
  86         (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_AUDIO_SRC_RING_BUFFER, GstAudioSrcRingBufferClass))
  87 #define GST_IS_AUDIO_SRC_RING_BUFFER(obj)     \
  88         (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_SRC_RING_BUFFER))
  89 #define GST_IS_AUDIO_SRC_RING_BUFFER_CLASS(klass)\
  90         (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIO_SRC_RING_BUFFER))
  91
  92 typedef struct _GstAudioSrcRingBuffer GstAudioSrcRingBuffer;
  93 typedef struct _GstAudioSrcRingBufferClass GstAudioSrcRingBufferClass;
  94
  95 #define GST_AUDIO_SRC_RING_BUFFER_GET_COND(buf) (((GstAudioSrcRingBuffer *)buf)->cond)
  96 #define GST_AUDIO_SRC_RING_BUFFER_WAIT(buf)     (g_cond_wait (GST_AUDIO_SRC_RING_BUFFER_GET_COND (buf), GST_OBJECT_GET_LOCK (buf)))
  97 #define GST_AUDIO_SRC_RING_BUFFER_SIGNAL(buf)   (g_cond_signal (GST_AUDIO_SRC_RING_BUFFER_GET_COND (buf)))
  98 #define GST_AUDIO_SRC_RING_BUFFER_BROADCAST(buf)(g_cond_broadcast (GST_AUDIO_SRC_RING_BUFFER_GET_COND (buf)))
  99
 100 struct _GstAudioSrcRingBuffer
 101 {
 102   GstAudioRingBuffer object;
 103
 104   gboolean running;
 105   gint queuedseg;
 106
 107   GCond *cond;
 108 };
 109
 110 struct _GstAudioSrcRingBufferClass
 111 {
 112   GstAudioRingBufferClass parent_class;
 113 };
 114
 115 static void gst_audio_src_ring_buffer_class_init (GstAudioSrcRingBufferClass *
 116     klass);
 117 static void gst_audio_src_ring_buffer_init (GstAudioSrcRingBuffer * ringbuffer,
 118     GstAudioSrcRingBufferClass * klass);
 119 static void gst_audio_src_ring_buffer_dispose (GObject * object);
 120 static void gst_audio_src_ring_buffer_finalize (GObject * object);
 121
 122 static GstAudioRingBufferClass *ring_parent_class = NULL;
 123
 124 static gboolean gst_audio_src_ring_buffer_open_device (GstAudioRingBuffer *
 125     buf);
 126 static gboolean gst_audio_src_ring_buffer_close_device (GstAudioRingBuffer *
 127     buf);
 128 static gboolean gst_audio_src_ring_buffer_acquire (GstAudioRingBuffer * buf,
 129     GstAudioRingBufferSpec * spec);
 130 static gboolean gst_audio_src_ring_buffer_release (GstAudioRingBuffer * buf);
 131 static gboolean gst_audio_src_ring_buffer_start (GstAudioRingBuffer * buf);
 132 static gboolean gst_audio_src_ring_buffer_stop (GstAudioRingBuffer * buf);
 133 static guint gst_audio_src_ring_buffer_delay (GstAudioRingBuffer * buf);
 134
 135 /* ringbuffer abstract base class */
 136 static GType
 137 gst_audio_src_ring_buffer_get_type (void)
 138 {
 139   static GType ringbuffer_type = 0;
 140
 141   if (!ringbuffer_type) {
 142     static const GTypeInfo ringbuffer_info = {
 143       sizeof (GstAudioSrcRingBufferClass),
 144       NULL,
 145       NULL,
 146       (GClassInitFunc) gst_audio_src_ring_buffer_class_init,
 147       NULL,
 148       NULL,
 149       sizeof (GstAudioSrcRingBuffer),
 150       0,
 151       (GInstanceInitFunc) gst_audio_src_ring_buffer_init,
 152       NULL
 153     };
 154
 155     ringbuffer_type =
 156         g_type_register_static (GST_TYPE_AUDIO_RING_BUFFER,
 157         "GstAudioSrcRingBuffer", &ringbuffer_info, 0);
 158   }
 159   return ringbuffer_type;
 160 }
 161
 162 static void
 163 gst_audio_src_ring_buffer_class_init (GstAudioSrcRingBufferClass * klass)
 164 {
 165   GObjectClass *gobject_class;
 166   GstAudioRingBufferClass *gstringbuffer_class;
 167
 168   gobject_class = (GObjectClass *) klass;
 169   gstringbuffer_class = (GstAudioRingBufferClass *) klass;
 170
 171   ring_parent_class = g_type_class_peek_parent (klass);
 172
 173   gobject_class->dispose = gst_audio_src_ring_buffer_dispose;
 174   gobject_class->finalize = gst_audio_src_ring_buffer_finalize;
 175
 176   gstringbuffer_class->open_device =
 177       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_open_device);
 178   gstringbuffer_class->close_device =
 179       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_close_device);
 180   gstringbuffer_class->acquire =
 181       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_acquire);
 182   gstringbuffer_class->release =
 183       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_release);
 184   gstringbuffer_class->start =
 185       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_start);
 186   gstringbuffer_class->resume =
 187       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_start);
 188   gstringbuffer_class->stop =
 189       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_stop);
 190
 191   gstringbuffer_class->delay =
 192       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_delay);
 193 }
 194
 195 typedef guint (*ReadFunc) (GstAudioSrc * src, gpointer data, guint length);
 196
 197 /* this internal thread does nothing else but read samples from the audio device.
 198  * It will read each segment in the ringbuffer and will update the play
 199  * pointer.
 200  * The start/stop methods control the thread.
 201  */
 202 static void
 203 audioringbuffer_thread_func (GstAudioRingBuffer * buf)
 204 {
 205   GstAudioSrc *src;
 206   GstAudioSrcClass *csrc;
 207   GstAudioSrcRingBuffer *abuf = GST_AUDIO_SRC_RING_BUFFER (buf);
 208   ReadFunc readfunc;
 209   GstMessage *message;
 210   GValue val = { 0 };
 211
 212   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 213   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 214
 215   GST_DEBUG_OBJECT (src, "enter thread");
 216
 217   readfunc = csrc->read;
 218   if (readfunc == NULL)
 219     goto no_function;
 220
 221   /* FIXME: maybe we should at least use a custom pointer type here? */
 222   g_value_init (&val, G_TYPE_POINTER);
 223   g_value_set_pointer (&val, src->thread);
 224   message = gst_message_new_stream_status (GST_OBJECT_CAST (buf),
 225       GST_STREAM_STATUS_TYPE_ENTER, GST_ELEMENT_CAST (src));
 226   gst_message_set_stream_status_object (message, &val);
 227   GST_DEBUG_OBJECT (src, "posting ENTER stream status");
 228   gst_element_post_message (GST_ELEMENT_CAST (src), message);
 229
 230   while (TRUE) {
 231     gint left, len;
 232     guint8 *readptr;
 233     gint readseg;
 234
 235     if (gst_audio_ring_buffer_prepare_read (buf, &readseg, &readptr, &len)) {
 236       gint read;
 237
 238       left = len;
 239       do {
 240         read = readfunc (src, readptr, left);
 241         GST_LOG_OBJECT (src, "transfered %d bytes of %d to segment %d", read,
 242             left, readseg);
 243         if (read < 0 || read > left) {
 244           GST_WARNING_OBJECT (src,
 245               "error reading data %d (reason: %s), skipping segment", read,
 246               g_strerror (errno));
 247           break;
 248         }
 249         left -= read;
 250         readptr += read;
 251       } while (left > 0);
 252
 253       /* we read one segment */
 254       gst_audio_ring_buffer_advance (buf, 1);
 255     } else {
 256       GST_OBJECT_LOCK (abuf);
 257       if (!abuf->running)
 258         goto stop_running;
 259       if (G_UNLIKELY (g_atomic_int_get (&buf->state) ==
 260               GST_AUDIO_RING_BUFFER_STATE_STARTED)) {
 261         GST_OBJECT_UNLOCK (abuf);
 262         continue;
 263       }
 264       GST_DEBUG_OBJECT (src, "signal wait");
 265       GST_AUDIO_SRC_RING_BUFFER_SIGNAL (buf);
 266       GST_DEBUG_OBJECT (src, "wait for action");
 267       GST_AUDIO_SRC_RING_BUFFER_WAIT (buf);
 268       GST_DEBUG_OBJECT (src, "got signal");
 269       if (!abuf->running)
 270         goto stop_running;
 271       GST_DEBUG_OBJECT (src, "continue running");
 272       GST_OBJECT_UNLOCK (abuf);
 273     }
 274   }
 275
 276   /* Will never be reached */
 277   g_assert_not_reached ();
 278   return;
 279
 280   /* ERROR */
 281 no_function:
 282   {
 283     GST_DEBUG ("no write function, exit thread");
 284     return;
 285   }
 286 stop_running:
 287   {
 288     GST_OBJECT_UNLOCK (abuf);
 289     GST_DEBUG ("stop running, exit thread");
 290     message = gst_message_new_stream_status (GST_OBJECT_CAST (buf),
 291         GST_STREAM_STATUS_TYPE_LEAVE, GST_ELEMENT_CAST (src));
 292     gst_message_set_stream_status_object (message, &val);
 293     GST_DEBUG_OBJECT (src, "posting LEAVE stream status");
 294     gst_element_post_message (GST_ELEMENT_CAST (src), message);
 295     return;
 296   }
 297 }
 298
 299 static void
 300 gst_audio_src_ring_buffer_init (GstAudioSrcRingBuffer * ringbuffer,
 301     GstAudioSrcRingBufferClass * g_class)
 302 {
 303   ringbuffer->running = FALSE;
 304   ringbuffer->queuedseg = 0;
 305
 306   ringbuffer->cond = g_cond_new ();
 307 }
 308
 309 static void
 310 gst_audio_src_ring_buffer_dispose (GObject * object)
 311 {
 312   GstAudioSrcRingBuffer *ringbuffer = GST_AUDIO_SRC_RING_BUFFER (object);
 313
 314   if (ringbuffer->cond) {
 315     g_cond_free (ringbuffer->cond);
 316     ringbuffer->cond = NULL;
 317   }
 318
 319   G_OBJECT_CLASS (ring_parent_class)->dispose (object);
 320 }
 321
 322 static void
 323 gst_audio_src_ring_buffer_finalize (GObject * object)
 324 {
 325   G_OBJECT_CLASS (ring_parent_class)->finalize (object);
 326 }
 327
 328 static gboolean
 329 gst_audio_src_ring_buffer_open_device (GstAudioRingBuffer * buf)
 330 {
 331   GstAudioSrc *src;
 332   GstAudioSrcClass *csrc;
 333   gboolean result = TRUE;
 334
 335   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 336   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 337
 338   if (csrc->open)
 339     result = csrc->open (src);
 340
 341   if (!result)
 342     goto could_not_open;
 343
 344   return result;
 345
 346 could_not_open:
 347   {
 348     return FALSE;
 349   }
 350 }
 351
 352 static gboolean
 353 gst_audio_src_ring_buffer_close_device (GstAudioRingBuffer * buf)
 354 {
 355   GstAudioSrc *src;
 356   GstAudioSrcClass *csrc;
 357   gboolean result = TRUE;
 358
 359   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 360   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 361
 362   if (csrc->close)
 363     result = csrc->close (src);
 364
 365   if (!result)
 366     goto could_not_open;
 367
 368   return result;
 369
 370 could_not_open:
 371   {
 372     return FALSE;
 373   }
 374 }
 375
 376 static gboolean
 377 gst_audio_src_ring_buffer_acquire (GstAudioRingBuffer * buf,
 378     GstAudioRingBufferSpec * spec)
 379 {
 380   GstAudioSrc *src;
 381   GstAudioSrcClass *csrc;
 382   GstAudioSrcRingBuffer *abuf;
 383   gboolean result = FALSE;
 384
 385   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 386   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 387
 388   if (csrc->prepare)
 389     result = csrc->prepare (src, spec);
 390
 391   if (!result)
 392     goto could_not_open;
 393
 394   buf->size = spec->segtotal * spec->segsize;
 395   buf->memory = g_malloc0 (buf->size);
 396
 397   abuf = GST_AUDIO_SRC_RING_BUFFER (buf);
 398   abuf->running = TRUE;
 399
 400   /* FIXME: handle thread creation failure */
 401   src->thread = g_thread_try_new ("audiosrc-ringbuffer",
 402       (GThreadFunc) audioringbuffer_thread_func, buf, NULL);
 403
 404   GST_AUDIO_SRC_RING_BUFFER_WAIT (buf);
 405
 406   return result;
 407
 408 could_not_open:
 409   {
 410     return FALSE;
 411   }
 412 }
 413
 414 /* function is called with LOCK */
 415 static gboolean
 416 gst_audio_src_ring_buffer_release (GstAudioRingBuffer * buf)
 417 {
 418   GstAudioSrc *src;
 419   GstAudioSrcClass *csrc;
 420   GstAudioSrcRingBuffer *abuf;
 421   gboolean result = FALSE;
 422
 423   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 424   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 425   abuf = GST_AUDIO_SRC_RING_BUFFER (buf);
 426
 427   abuf->running = FALSE;
 428   GST_AUDIO_SRC_RING_BUFFER_SIGNAL (buf);
 429   GST_OBJECT_UNLOCK (buf);
 430
 431   /* join the thread */
 432   g_thread_join (src->thread);
 433
 434   GST_OBJECT_LOCK (buf);
 435
 436   /* free the buffer */
 437   g_free (buf->memory);
 438   buf->memory = NULL;
 439
 440   if (csrc->unprepare)
 441     result = csrc->unprepare (src);
 442
 443   return result;
 444 }
 445
 446 static gboolean
 447 gst_audio_src_ring_buffer_start (GstAudioRingBuffer * buf)
 448 {
 449   GST_DEBUG ("start, sending signal");
 450   GST_AUDIO_SRC_RING_BUFFER_SIGNAL (buf);
 451
 452   return TRUE;
 453 }
 454
 455 static gboolean
 456 gst_audio_src_ring_buffer_stop (GstAudioRingBuffer * buf)
 457 {
 458   GstAudioSrc *src;
 459   GstAudioSrcClass *csrc;
 460
 461   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 462   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 463
 464   /* unblock any pending writes to the audio device */
 465   if (csrc->reset) {
 466     GST_DEBUG ("reset...");
 467     csrc->reset (src);
 468     GST_DEBUG ("reset done");
 469   }
 470 #if 0
 471   GST_DEBUG ("stop, waiting...");
 472   GST_AUDIO_SRC_RING_BUFFER_WAIT (buf);
 473   GST_DEBUG ("stoped");
 474 #endif
 475
 476   return TRUE;
 477 }
 478
 479 static guint
 480 gst_audio_src_ring_buffer_delay (GstAudioRingBuffer * buf)
 481 {
 482   GstAudioSrc *src;
 483   GstAudioSrcClass *csrc;
 484   guint res = 0;
 485
 486   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 487   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 488
 489   if (csrc->delay)
 490     res = csrc->delay (src);
 491
 492   return res;
 493 }
 494
 495 /* AudioSrc signals and args */
 496 enum
 497 {
 498   /* FILL ME */
 499   LAST_SIGNAL
 500 };
 501
 502 enum
 503 {
 504   ARG_0,
 505 };
 506
 507 #define _do_init \
 508     GST_DEBUG_CATEGORY_INIT (gst_audio_src_debug, "audiosrc", 0, "audiosrc element");
 509 #define gst_audio_src_parent_class parent_class
 510 G_DEFINE_TYPE_WITH_CODE (GstAudioSrc, gst_audio_src,
 511     GST_TYPE_AUDIO_BASE_SRC, _do_init);
 512
 513 static GstAudioRingBuffer *gst_audio_src_create_ringbuffer (GstAudioBaseSrc *
 514     src);
 515
 516 static void
 517 gst_audio_src_class_init (GstAudioSrcClass * klass)
 518 {
 519   GstAudioBaseSrcClass *gstaudiobasesrc_class;
 520
 521   gstaudiobasesrc_class = (GstAudioBaseSrcClass *) klass;
 522
 523   gstaudiobasesrc_class->create_ringbuffer =
 524       GST_DEBUG_FUNCPTR (gst_audio_src_create_ringbuffer);
 525
 526   g_type_class_ref (GST_TYPE_AUDIO_SRC_RING_BUFFER);
 527 }
 528
 529 static void
 530 gst_audio_src_init (GstAudioSrc * audiosrc)
 531 {
 532 }
 533
 534 static GstAudioRingBuffer *
 535 gst_audio_src_create_ringbuffer (GstAudioBaseSrc * src)
 536 {
 537   GstAudioRingBuffer *buffer;
 538
 539   GST_DEBUG ("creating ringbuffer");
 540   buffer = g_object_new (GST_TYPE_AUDIO_SRC_RING_BUFFER, NULL);
 541   GST_DEBUG ("created ringbuffer @%p", buffer);
 542
 543   return buffer;
 544 }