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 GST_DEBUG_CATEGORY_STATIC (gst_audio_src_debug);
  75 #define GST_CAT_DEFAULT gst_audio_src_debug
  76
  77 #define GST_TYPE_AUDIO_SRC_RING_BUFFER        \
  78         (gst_audio_src_ring_buffer_get_type())
  79 #define GST_AUDIO_SRC_RING_BUFFER(obj)        \
  80         (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_AUDIO_SRC_RING_BUFFER,GstAudioSrcRingBuffer))
  81 #define GST_AUDIO_SRC_RING_BUFFER_CLASS(klass) \
  82         (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIO_SRC_RING_BUFFER,GstAudioSrcRingBufferClass))
  83 #define GST_AUDIO_SRC_RING_BUFFER_GET_CLASS(obj) \
  84         (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_AUDIO_SRC_RING_BUFFER, GstAudioSrcRingBufferClass))
  85 #define GST_IS_AUDIO_SRC_RING_BUFFER(obj)     \
  86         (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_AUDIO_SRC_RING_BUFFER))
  87 #define GST_IS_AUDIO_SRC_RING_BUFFER_CLASS(klass)\
  88         (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIO_SRC_RING_BUFFER))
  89
  90 typedef struct _GstAudioSrcRingBuffer GstAudioSrcRingBuffer;
  91 typedef struct _GstAudioSrcRingBufferClass GstAudioSrcRingBufferClass;
  92
  93 #define GST_AUDIO_SRC_RING_BUFFER_GET_COND(buf) (((GstAudioSrcRingBuffer *)buf)->cond)
  94 #define GST_AUDIO_SRC_RING_BUFFER_WAIT(buf)     (g_cond_wait (GST_AUDIO_SRC_RING_BUFFER_GET_COND (buf), GST_OBJECT_GET_LOCK (buf)))
  95 #define GST_AUDIO_SRC_RING_BUFFER_SIGNAL(buf)   (g_cond_signal (GST_AUDIO_SRC_RING_BUFFER_GET_COND (buf)))
  96 #define GST_AUDIO_SRC_RING_BUFFER_BROADCAST(buf)(g_cond_broadcast (GST_AUDIO_SRC_RING_BUFFER_GET_COND (buf)))
  97
  98 struct _GstAudioSrcRingBuffer
  99 {
 100   GstAudioRingBuffer object;
 101
 102   gboolean running;
 103   gint queuedseg;
 104
 105   GCond *cond;
 106 };
 107
 108 struct _GstAudioSrcRingBufferClass
 109 {
 110   GstAudioRingBufferClass parent_class;
 111 };
 112
 113 static void gst_audio_src_ring_buffer_class_init (GstAudioSrcRingBufferClass *
 114     klass);
 115 static void gst_audio_src_ring_buffer_init (GstAudioSrcRingBuffer * ringbuffer,
 116     GstAudioSrcRingBufferClass * klass);
 117 static void gst_audio_src_ring_buffer_dispose (GObject * object);
 118 static void gst_audio_src_ring_buffer_finalize (GObject * object);
 119
 120 static GstAudioRingBufferClass *ring_parent_class = NULL;
 121
 122 static gboolean gst_audio_src_ring_buffer_open_device (GstAudioRingBuffer *
 123     buf);
 124 static gboolean gst_audio_src_ring_buffer_close_device (GstAudioRingBuffer *
 125     buf);
 126 static gboolean gst_audio_src_ring_buffer_acquire (GstAudioRingBuffer * buf,
 127     GstAudioRingBufferSpec * spec);
 128 static gboolean gst_audio_src_ring_buffer_release (GstAudioRingBuffer * buf);
 129 static gboolean gst_audio_src_ring_buffer_start (GstAudioRingBuffer * buf);
 130 static gboolean gst_audio_src_ring_buffer_stop (GstAudioRingBuffer * buf);
 131 static guint gst_audio_src_ring_buffer_delay (GstAudioRingBuffer * buf);
 132
 133 /* ringbuffer abstract base class */
 134 static GType
 135 gst_audio_src_ring_buffer_get_type (void)
 136 {
 137   static GType ringbuffer_type = 0;
 138
 139   if (!ringbuffer_type) {
 140     static const GTypeInfo ringbuffer_info = {
 141       sizeof (GstAudioSrcRingBufferClass),
 142       NULL,
 143       NULL,
 144       (GClassInitFunc) gst_audio_src_ring_buffer_class_init,
 145       NULL,
 146       NULL,
 147       sizeof (GstAudioSrcRingBuffer),
 148       0,
 149       (GInstanceInitFunc) gst_audio_src_ring_buffer_init,
 150       NULL
 151     };
 152
 153     ringbuffer_type =
 154         g_type_register_static (GST_TYPE_AUDIO_RING_BUFFER,
 155         "GstAudioSrcRingBuffer", &ringbuffer_info, 0);
 156   }
 157   return ringbuffer_type;
 158 }
 159
 160 static void
 161 gst_audio_src_ring_buffer_class_init (GstAudioSrcRingBufferClass * klass)
 162 {
 163   GObjectClass *gobject_class;
 164   GstAudioRingBufferClass *gstringbuffer_class;
 165
 166   gobject_class = (GObjectClass *) klass;
 167   gstringbuffer_class = (GstAudioRingBufferClass *) klass;
 168
 169   ring_parent_class = g_type_class_peek_parent (klass);
 170
 171   gobject_class->dispose = gst_audio_src_ring_buffer_dispose;
 172   gobject_class->finalize = gst_audio_src_ring_buffer_finalize;
 173
 174   gstringbuffer_class->open_device =
 175       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_open_device);
 176   gstringbuffer_class->close_device =
 177       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_close_device);
 178   gstringbuffer_class->acquire =
 179       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_acquire);
 180   gstringbuffer_class->release =
 181       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_release);
 182   gstringbuffer_class->start =
 183       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_start);
 184   gstringbuffer_class->resume =
 185       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_start);
 186   gstringbuffer_class->stop =
 187       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_stop);
 188
 189   gstringbuffer_class->delay =
 190       GST_DEBUG_FUNCPTR (gst_audio_src_ring_buffer_delay);
 191 }
 192
 193 typedef guint (*ReadFunc) (GstAudioSrc * src, gpointer data, guint length);
 194
 195 /* this internal thread does nothing else but read samples from the audio device.
 196  * It will read each segment in the ringbuffer and will update the play
 197  * pointer.
 198  * The start/stop methods control the thread.
 199  */
 200 static void
 201 audioringbuffer_thread_func (GstAudioRingBuffer * buf)
 202 {
 203   GstAudioSrc *src;
 204   GstAudioSrcClass *csrc;
 205   GstAudioSrcRingBuffer *abuf = GST_AUDIO_SRC_RING_BUFFER (buf);
 206   ReadFunc readfunc;
 207   GstMessage *message;
 208   GValue val = { 0 };
 209
 210   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 211   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 212
 213   GST_DEBUG_OBJECT (src, "enter thread");
 214
 215   readfunc = csrc->read;
 216   if (readfunc == NULL)
 217     goto no_function;
 218
 219   /* FIXME: maybe we should at least use a custom pointer type here? */
 220   g_value_init (&val, G_TYPE_POINTER);
 221   g_value_set_pointer (&val, src->thread);
 222   message = gst_message_new_stream_status (GST_OBJECT_CAST (buf),
 223       GST_STREAM_STATUS_TYPE_ENTER, GST_ELEMENT_CAST (src));
 224   gst_message_set_stream_status_object (message, &val);
 225   GST_DEBUG_OBJECT (src, "posting ENTER stream status");
 226   gst_element_post_message (GST_ELEMENT_CAST (src), message);
 227
 228   while (TRUE) {
 229     gint left, len;
 230     guint8 *readptr;
 231     gint readseg;
 232
 233     if (gst_audio_ring_buffer_prepare_read (buf, &readseg, &readptr, &len)) {
 234       gint read;
 235
 236       left = len;
 237       do {
 238         read = readfunc (src, readptr, left);
 239         GST_LOG_OBJECT (src, "transfered %d bytes of %d to segment %d", read,
 240             left, readseg);
 241         if (read < 0 || read > left) {
 242           GST_WARNING_OBJECT (src,
 243               "error reading data %d (reason: %s), skipping segment", read,
 244               g_strerror (errno));
 245           break;
 246         }
 247         left -= read;
 248         readptr += read;
 249       } while (left > 0);
 250
 251       /* we read one segment */
 252       gst_audio_ring_buffer_advance (buf, 1);
 253     } else {
 254       GST_OBJECT_LOCK (abuf);
 255       if (!abuf->running)
 256         goto stop_running;
 257       if (G_UNLIKELY (g_atomic_int_get (&buf->state) ==
 258               GST_AUDIO_RING_BUFFER_STATE_STARTED)) {
 259         GST_OBJECT_UNLOCK (abuf);
 260         continue;
 261       }
 262       GST_DEBUG_OBJECT (src, "signal wait");
 263       GST_AUDIO_SRC_RING_BUFFER_SIGNAL (buf);
 264       GST_DEBUG_OBJECT (src, "wait for action");
 265       GST_AUDIO_SRC_RING_BUFFER_WAIT (buf);
 266       GST_DEBUG_OBJECT (src, "got signal");
 267       if (!abuf->running)
 268         goto stop_running;
 269       GST_DEBUG_OBJECT (src, "continue running");
 270       GST_OBJECT_UNLOCK (abuf);
 271     }
 272   }
 273
 274   /* Will never be reached */
 275   g_assert_not_reached ();
 276   return;
 277
 278   /* ERROR */
 279 no_function:
 280   {
 281     GST_DEBUG ("no write function, exit thread");
 282     return;
 283   }
 284 stop_running:
 285   {
 286     GST_OBJECT_UNLOCK (abuf);
 287     GST_DEBUG ("stop running, exit thread");
 288     message = gst_message_new_stream_status (GST_OBJECT_CAST (buf),
 289         GST_STREAM_STATUS_TYPE_LEAVE, GST_ELEMENT_CAST (src));
 290     gst_message_set_stream_status_object (message, &val);
 291     GST_DEBUG_OBJECT (src, "posting LEAVE stream status");
 292     gst_element_post_message (GST_ELEMENT_CAST (src), message);
 293     return;
 294   }
 295 }
 296
 297 static void
 298 gst_audio_src_ring_buffer_init (GstAudioSrcRingBuffer * ringbuffer,
 299     GstAudioSrcRingBufferClass * g_class)
 300 {
 301   ringbuffer->running = FALSE;
 302   ringbuffer->queuedseg = 0;
 303
 304   ringbuffer->cond = g_cond_new ();
 305 }
 306
 307 static void
 308 gst_audio_src_ring_buffer_dispose (GObject * object)
 309 {
 310   GstAudioSrcRingBuffer *ringbuffer = GST_AUDIO_SRC_RING_BUFFER (object);
 311
 312   if (ringbuffer->cond) {
 313     g_cond_free (ringbuffer->cond);
 314     ringbuffer->cond = NULL;
 315   }
 316
 317   G_OBJECT_CLASS (ring_parent_class)->dispose (object);
 318 }
 319
 320 static void
 321 gst_audio_src_ring_buffer_finalize (GObject * object)
 322 {
 323   G_OBJECT_CLASS (ring_parent_class)->finalize (object);
 324 }
 325
 326 static gboolean
 327 gst_audio_src_ring_buffer_open_device (GstAudioRingBuffer * buf)
 328 {
 329   GstAudioSrc *src;
 330   GstAudioSrcClass *csrc;
 331   gboolean result = TRUE;
 332
 333   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 334   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 335
 336   if (csrc->open)
 337     result = csrc->open (src);
 338
 339   if (!result)
 340     goto could_not_open;
 341
 342   return result;
 343
 344 could_not_open:
 345   {
 346     return FALSE;
 347   }
 348 }
 349
 350 static gboolean
 351 gst_audio_src_ring_buffer_close_device (GstAudioRingBuffer * buf)
 352 {
 353   GstAudioSrc *src;
 354   GstAudioSrcClass *csrc;
 355   gboolean result = TRUE;
 356
 357   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 358   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 359
 360   if (csrc->close)
 361     result = csrc->close (src);
 362
 363   if (!result)
 364     goto could_not_open;
 365
 366   return result;
 367
 368 could_not_open:
 369   {
 370     return FALSE;
 371   }
 372 }
 373
 374 static gboolean
 375 gst_audio_src_ring_buffer_acquire (GstAudioRingBuffer * buf,
 376     GstAudioRingBufferSpec * spec)
 377 {
 378   GstAudioSrc *src;
 379   GstAudioSrcClass *csrc;
 380   GstAudioSrcRingBuffer *abuf;
 381   gboolean result = FALSE;
 382
 383   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 384   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 385
 386   if (csrc->prepare)
 387     result = csrc->prepare (src, spec);
 388
 389   if (!result)
 390     goto could_not_open;
 391
 392   buf->size = spec->segtotal * spec->segsize;
 393   buf->memory = g_malloc0 (buf->size);
 394
 395   abuf = GST_AUDIO_SRC_RING_BUFFER (buf);
 396   abuf->running = TRUE;
 397
 398   /* FIXME: handle thread creation failure */
 399   src->thread = g_thread_try_new ("audiosrc-ringbuffer",
 400       (GThreadFunc) audioringbuffer_thread_func, buf, NULL);
 401
 402   GST_AUDIO_SRC_RING_BUFFER_WAIT (buf);
 403
 404   return result;
 405
 406 could_not_open:
 407   {
 408     return FALSE;
 409   }
 410 }
 411
 412 /* function is called with LOCK */
 413 static gboolean
 414 gst_audio_src_ring_buffer_release (GstAudioRingBuffer * buf)
 415 {
 416   GstAudioSrc *src;
 417   GstAudioSrcClass *csrc;
 418   GstAudioSrcRingBuffer *abuf;
 419   gboolean result = FALSE;
 420
 421   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 422   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 423   abuf = GST_AUDIO_SRC_RING_BUFFER (buf);
 424
 425   abuf->running = FALSE;
 426   GST_AUDIO_SRC_RING_BUFFER_SIGNAL (buf);
 427   GST_OBJECT_UNLOCK (buf);
 428
 429   /* join the thread */
 430   g_thread_join (src->thread);
 431
 432   GST_OBJECT_LOCK (buf);
 433
 434   /* free the buffer */
 435   g_free (buf->memory);
 436   buf->memory = NULL;
 437
 438   if (csrc->unprepare)
 439     result = csrc->unprepare (src);
 440
 441   return result;
 442 }
 443
 444 static gboolean
 445 gst_audio_src_ring_buffer_start (GstAudioRingBuffer * buf)
 446 {
 447   GST_DEBUG ("start, sending signal");
 448   GST_AUDIO_SRC_RING_BUFFER_SIGNAL (buf);
 449
 450   return TRUE;
 451 }
 452
 453 static gboolean
 454 gst_audio_src_ring_buffer_stop (GstAudioRingBuffer * buf)
 455 {
 456   GstAudioSrc *src;
 457   GstAudioSrcClass *csrc;
 458
 459   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 460   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 461
 462   /* unblock any pending writes to the audio device */
 463   if (csrc->reset) {
 464     GST_DEBUG ("reset...");
 465     csrc->reset (src);
 466     GST_DEBUG ("reset done");
 467   }
 468 #if 0
 469   GST_DEBUG ("stop, waiting...");
 470   GST_AUDIO_SRC_RING_BUFFER_WAIT (buf);
 471   GST_DEBUG ("stoped");
 472 #endif
 473
 474   return TRUE;
 475 }
 476
 477 static guint
 478 gst_audio_src_ring_buffer_delay (GstAudioRingBuffer * buf)
 479 {
 480   GstAudioSrc *src;
 481   GstAudioSrcClass *csrc;
 482   guint res = 0;
 483
 484   src = GST_AUDIO_SRC (GST_OBJECT_PARENT (buf));
 485   csrc = GST_AUDIO_SRC_GET_CLASS (src);
 486
 487   if (csrc->delay)
 488     res = csrc->delay (src);
 489
 490   return res;
 491 }
 492
 493 /* AudioSrc signals and args */
 494 enum
 495 {
 496   /* FILL ME */
 497   LAST_SIGNAL
 498 };
 499
 500 enum
 501 {
 502   ARG_0,
 503 };
 504
 505 #define _do_init \
 506     GST_DEBUG_CATEGORY_INIT (gst_audio_src_debug, "audiosrc", 0, "audiosrc element");
 507 #define gst_audio_src_parent_class parent_class
 508 G_DEFINE_TYPE_WITH_CODE (GstAudioSrc, gst_audio_src,
 509     GST_TYPE_AUDIO_BASE_SRC, _do_init);
 510
 511 static GstAudioRingBuffer *gst_audio_src_create_ringbuffer (GstAudioBaseSrc *
 512     src);
 513
 514 static void
 515 gst_audio_src_class_init (GstAudioSrcClass * klass)
 516 {
 517   GstAudioBaseSrcClass *gstaudiobasesrc_class;
 518
 519   gstaudiobasesrc_class = (GstAudioBaseSrcClass *) klass;
 520
 521   gstaudiobasesrc_class->create_ringbuffer =
 522       GST_DEBUG_FUNCPTR (gst_audio_src_create_ringbuffer);
 523
 524   g_type_class_ref (GST_TYPE_AUDIO_SRC_RING_BUFFER);
 525 }
 526
 527 static void
 528 gst_audio_src_init (GstAudioSrc * audiosrc)
 529 {
 530 }
 531
 532 static GstAudioRingBuffer *
 533 gst_audio_src_create_ringbuffer (GstAudioBaseSrc * src)
 534 {
 535   GstAudioRingBuffer *buffer;
 536
 537   GST_DEBUG ("creating ringbuffer");
 538   buffer = g_object_new (GST_TYPE_AUDIO_SRC_RING_BUFFER, NULL);
 539   GST_DEBUG ("created ringbuffer @%p", buffer);
 540
 541   return buffer;
 542 }