gst/dtmf/gstdtmfsrc.c

   1 /* GStreamer DTMF source
   2  *
   3  * gstdtmfsrc.c:
   4  *
   5  * Copyright (C) <2007> Collabora.
   6  *   Contact: Youness Alaoui <youness.alaoui@collabora.co.uk>
   7  * Copyright (C) <2007> Nokia Corporation.
   8  *   Contact: Zeeshan Ali <zeeshan.ali@nokia.com>
   9  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
  10  *               2000,2005 Wim Taymans <wim@fluendo.com>
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Library General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public
  23  * License along with this library; if not, write to the
  24  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25  * Boston, MA 02111-1307, USA.
  26  */
  27
  28 /**
  29  * SECTION:element-dtmfsrc
  30  * @short_description: Generates DTMF packets
  31  *
  32  * <refsect2>
  33  *
  34  * <para>
  35  * The DTMFSrc element generates DTMF (ITU-T Q.23 Specification) tone packets on request
  36  * from application. The application communicates the beginning and end of a
  37  * DTMF event using custom upstream gstreamer events. To report a DTMF event, an
  38  * application must send an event of type GST_EVENT_CUSTOM_UPSTREAM, having a
  39  * structure of name "dtmf-event" with fields set according to the following
  40  * table:
  41  * </para>
  42  *
  43  * <para>
  44  * <informaltable>
  45  * <tgroup cols='4'>
  46  * <colspec colname='Name' />
  47  * <colspec colname='Type' />
  48  * <colspec colname='Possible values' />
  49  * <colspec colname='Purpose' />
  50  *
  51  * <thead>
  52  * <row>
  53  * <entry>Name</entry>
  54  * <entry>GType</entry>
  55  * <entry>Possible values</entry>
  56  * <entry>Purpose</entry>
  57  * </row>
  58  * </thead>
  59  *
  60  * <tbody>
  61  * <row>
  62  * <entry>type</entry>
  63  * <entry>G_TYPE_INT</entry>
  64  * <entry>0-1</entry>
  65  * <entry>The application uses this field to specify which of the two methods
  66  * specified in RFC 2833 to use. The value should be 0 for tones and 1 for
  67  * named events. This element is only capable of generating tones.
  68  * </entry>
  69  * </row>
  70  * <row>
  71  * <entry>number</entry>
  72  * <entry>G_TYPE_INT</entry>
  73  * <entry>0-16</entry>
  74  * <entry>The event number.</entry>
  75  * </row>
  76  * <row>
  77  * <entry>volume</entry>
  78  * <entry>G_TYPE_INT</entry>
  79  * <entry>0-36</entry>
  80  * <entry>This field describes the power level of the tone, expressed in dBm0
  81  * after dropping the sign. Power levels range from 0 to -63 dBm0. The range of
  82  * valid DTMF is from 0 to -36 dBm0. Can be omitted if start is set to FALSE.
  83  * </entry>
  84  * </row>
  85  * <row>
  86  * <entry>start</entry>
  87  * <entry>G_TYPE_BOOLEAN</entry>
  88  * <entry>True or False</entry>
  89  * <entry>Whether the event is starting or ending.</entry>
  90  * </row>
  91  * <row>
  92  * <entry>method</entry>
  93  * <entry>G_TYPE_INT</entry>
  94  * <entry>1</entry>
  95  * <entry>The method used for sending event, this element will react if this field
  96  * is absent or 2.
  97  * </entry>
  98  * </row>
  99  * </tbody>
 100  * </tgroup>
 101  * </informaltable>
 102  * </para>
 103  *
 104  * <para>For example, the following code informs the pipeline (and in turn, the
 105  * DTMFSrc element inside the pipeline) about the start of a DTMF named
 106  * event '1' of volume -25 dBm0:
 107  * </para>
 108  *
 109  * <para>
 110  * <programlisting>
 111  * structure = gst_structure_new ("dtmf-event",
 112  *                    "type", G_TYPE_INT, 0,
 113  *                    "number", G_TYPE_INT, 1,
 114  *                    "volume", G_TYPE_INT, 25,
 115  *                    "start", G_TYPE_BOOLEAN, TRUE, NULL);
 116  *
 117  * event = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM, structure);
 118  * gst_element_send_event (pipeline, event);
 119  * </programlisting>
 120  * </para>
 121  *
 122  * </refsect2>
 123  */
 124
 125 #ifdef HAVE_CONFIG_H
 126 #  include "config.h"
 127 #endif
 128
 129 #include <stdlib.h>
 130 #include <string.h>
 131 #include <math.h>
 132
 133 #include <glib.h>
 134
 135 #ifndef M_PI
 136 # define M_PI           3.14159265358979323846  /* pi */
 137 #endif
 138
 139
 140 #include "gstdtmfsrc.h"
 141
 142 #define GST_TONE_DTMF_TYPE_EVENT 0
 143 #define DEFAULT_PACKET_INTERVAL  50 /* ms */
 144 #define MIN_PACKET_INTERVAL      10 /* ms */
 145 #define MAX_PACKET_INTERVAL      50 /* ms */
 146 #define SAMPLE_RATE              8000
 147 #define SAMPLE_SIZE              16
 148 #define CHANNELS                 1
 149 #define MIN_EVENT                0
 150 #define MAX_EVENT                16
 151 #define MIN_VOLUME               0
 152 #define MAX_VOLUME               36
 153 #define MIN_INTER_DIGIT_INTERVAL 100
 154 #define MIN_PULSE_DURATION       250
 155 #define MIN_DUTY_CYCLE           (MIN_INTER_DIGIT_INTERVAL + MIN_PULSE_DURATION)
 156
 157
 158 typedef struct st_dtmf_key {
 159         char *event_name;
 160         int event_encoding;
 161         float low_frequency;
 162         float high_frequency;
 163 } DTMF_KEY;
 164
 165 static const DTMF_KEY DTMF_KEYS[] = {
 166         {"DTMF_KEY_EVENT_0",  0, 941, 1336},
 167         {"DTMF_KEY_EVENT_1",  1, 697, 1209},
 168         {"DTMF_KEY_EVENT_2",  2, 697, 1336},
 169         {"DTMF_KEY_EVENT_3",  3, 697, 1477},
 170         {"DTMF_KEY_EVENT_4",  4, 770, 1209},
 171         {"DTMF_KEY_EVENT_5",  5, 770, 1336},
 172         {"DTMF_KEY_EVENT_6",  6, 770, 1477},
 173         {"DTMF_KEY_EVENT_7",  7, 852, 1209},
 174         {"DTMF_KEY_EVENT_8",  8, 852, 1336},
 175         {"DTMF_KEY_EVENT_9",  9, 852, 1477},
 176         {"DTMF_KEY_EVENT_S", 10, 941, 1209},
 177         {"DTMF_KEY_EVENT_P", 11, 941, 1477},
 178         {"DTMF_KEY_EVENT_A", 12, 697, 1633},
 179         {"DTMF_KEY_EVENT_B", 13, 770, 1633},
 180         {"DTMF_KEY_EVENT_C", 14, 852, 1633},
 181         {"DTMF_KEY_EVENT_D", 15, 941, 1633},
 182 };
 183
 184 #define MAX_DTMF_EVENTS 16
 185
 186 enum {
 187 DTMF_KEY_EVENT_1 = 1,
 188 DTMF_KEY_EVENT_2 = 2,
 189 DTMF_KEY_EVENT_3 = 3,
 190 DTMF_KEY_EVENT_4 = 4,
 191 DTMF_KEY_EVENT_5 = 5,
 192 DTMF_KEY_EVENT_6 = 6,
 193 DTMF_KEY_EVENT_7 = 7,
 194 DTMF_KEY_EVENT_8 = 8,
 195 DTMF_KEY_EVENT_9 = 9,
 196 DTMF_KEY_EVENT_0 = 0,
 197 DTMF_KEY_EVENT_STAR = 10,
 198 DTMF_KEY_EVENT_POUND = 11,
 199 DTMF_KEY_EVENT_A = 12,
 200 DTMF_KEY_EVENT_B = 13,
 201 DTMF_KEY_EVENT_C = 14,
 202 DTMF_KEY_EVENT_D = 15,
 203 };
 204
 205 /* elementfactory information */
 206 static const GstElementDetails gst_dtmf_src_details =
 207 GST_ELEMENT_DETAILS ("DTMF tone generator",
 208     "Source/Audio",
 209     "Generates DTMF tones",
 210     "Youness Alaoui <youness.alaoui@collabora.co.uk>");
 211
 212 GST_DEBUG_CATEGORY_STATIC (gst_dtmf_src_debug);
 213 #define GST_CAT_DEFAULT gst_dtmf_src_debug
 214
 215 enum
 216 {
 217   PROP_0,
 218   PROP_INTERVAL,
 219 };
 220
 221 static GstStaticPadTemplate gst_dtmf_src_template =
 222 GST_STATIC_PAD_TEMPLATE ("src",
 223     GST_PAD_SRC,
 224     GST_PAD_ALWAYS,
 225     GST_STATIC_CAPS ("audio/x-raw-int, "
 226         "width = (int) 16, "
 227         "depth = (int) 16, "
 228         "endianness = (int) 1234, "
 229         "signed = (bool) true, "
 230         "rate = (int) 8000, "
 231         "channels = (int) 1")
 232     );
 233
 234 static GstElementClass *parent_class = NULL;
 235
 236 static void gst_dtmf_src_base_init (gpointer g_class);
 237 static void gst_dtmf_src_class_init (GstDTMFSrcClass * klass);
 238 static void gst_dtmf_src_init (GstDTMFSrc * dtmfsrc, gpointer g_class);
 239 static void gst_dtmf_src_finalize (GObject * object);
 240
 241 GType
 242 gst_dtmf_src_get_type (void)
 243 {
 244   static GType base_src_type = 0;
 245
 246   if (G_UNLIKELY (base_src_type == 0)) {
 247     static const GTypeInfo base_src_info = {
 248       sizeof (GstDTMFSrcClass),
 249       (GBaseInitFunc) gst_dtmf_src_base_init,
 250       NULL,
 251       (GClassInitFunc) gst_dtmf_src_class_init,
 252       NULL,
 253       NULL,
 254       sizeof (GstDTMFSrc),
 255       0,
 256       (GInstanceInitFunc) gst_dtmf_src_init,
 257     };
 258
 259     base_src_type = g_type_register_static (GST_TYPE_ELEMENT,
 260         "GstDTMFSrc", &base_src_info, 0);
 261   }
 262   return base_src_type;
 263 }
 264
 265 static void gst_dtmf_src_set_property (GObject * object, guint prop_id,
 266     const GValue * value, GParamSpec * pspec);
 267 static void gst_dtmf_src_get_property (GObject * object, guint prop_id,
 268     GValue * value, GParamSpec * pspec);
 269 static gboolean gst_dtmf_src_handle_event (GstPad * pad, GstEvent * event);
 270 static GstStateChangeReturn gst_dtmf_src_change_state (GstElement * element,
 271     GstStateChange transition);
 272 static void gst_dtmf_src_generate_tone(GstDTMFSrcEvent *event, DTMF_KEY key,
 273     float duration, GstBuffer * buffer);
 274 static void gst_dtmf_src_push_next_tone_packet (GstDTMFSrc *dtmfsrc);
 275 static void gst_dtmf_src_start (GstDTMFSrc *dtmfsrc);
 276 static void gst_dtmf_src_stop (GstDTMFSrc *dtmfsrc);
 277 static void gst_dtmf_src_add_start_event (GstDTMFSrc *dtmfsrc,
 278     gint event_number, gint event_volume);
 279 static void gst_dtmf_src_add_stop_event (GstDTMFSrc *dtmfsrc);
 280
 281 static void
 282 gst_dtmf_src_base_init (gpointer g_class)
 283 {
 284   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 285
 286   GST_DEBUG_CATEGORY_INIT (gst_dtmf_src_debug,
 287           "dtmfsrc", 0, "dtmfsrc element");
 288
 289   gst_element_class_add_pad_template (element_class,
 290       gst_static_pad_template_get (&gst_dtmf_src_template));
 291
 292   gst_element_class_set_details (element_class, &gst_dtmf_src_details);
 293 }
 294
 295 static void
 296 gst_dtmf_src_class_init (GstDTMFSrcClass * klass)
 297 {
 298   GObjectClass *gobject_class;
 299   GstElementClass *gstelement_class;
 300
 301   gobject_class = G_OBJECT_CLASS (klass);
 302   gstelement_class = GST_ELEMENT_CLASS (klass);
 303
 304   parent_class = g_type_class_peek_parent (klass);
 305
 306   gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_dtmf_src_finalize);
 307   gobject_class->set_property =
 308       GST_DEBUG_FUNCPTR (gst_dtmf_src_set_property);
 309   gobject_class->get_property =
 310       GST_DEBUG_FUNCPTR (gst_dtmf_src_get_property);
 311
 312   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_INTERVAL,
 313       g_param_spec_int ("interval", "Interval between tone packets",
 314           "Interval in ms between two tone packets", MIN_PACKET_INTERVAL,
 315           MAX_PACKET_INTERVAL, DEFAULT_PACKET_INTERVAL, G_PARAM_READWRITE));
 316
 317   gstelement_class->change_state =
 318       GST_DEBUG_FUNCPTR (gst_dtmf_src_change_state);
 319 }
 320
 321 static void
 322 gst_dtmf_src_init (GstDTMFSrc * dtmfsrc, gpointer g_class)
 323 {
 324   dtmfsrc->srcpad =
 325       gst_pad_new_from_static_template (&gst_dtmf_src_template, "src");
 326   GST_DEBUG_OBJECT (dtmfsrc, "adding src pad");
 327   gst_element_add_pad (GST_ELEMENT (dtmfsrc), dtmfsrc->srcpad);
 328
 329   gst_pad_set_event_function (dtmfsrc->srcpad, gst_dtmf_src_handle_event);
 330
 331   dtmfsrc->interval = DEFAULT_PACKET_INTERVAL;
 332
 333   dtmfsrc->event_queue = g_async_queue_new ();
 334   dtmfsrc->last_event = NULL;
 335
 336   dtmfsrc->clock_id = NULL;
 337   dtmfsrc->task_paused = TRUE;
 338
 339   GST_DEBUG_OBJECT (dtmfsrc, "init done");
 340 }
 341
 342 static void
 343 gst_dtmf_src_finalize (GObject * object)
 344 {
 345   GstDTMFSrc *dtmfsrc;
 346
 347   dtmfsrc = GST_DTMF_SRC (object);
 348
 349
 350   gst_dtmf_src_stop (dtmfsrc);
 351
 352   if (dtmfsrc->event_queue) {
 353     g_async_queue_unref (dtmfsrc->event_queue);
 354     dtmfsrc->event_queue = NULL;
 355   }
 356
 357   G_OBJECT_CLASS (parent_class)->finalize (object);
 358 }
 359
 360 static gboolean
 361 gst_dtmf_src_handle_dtmf_event (GstDTMFSrc *dtmfsrc,
 362         const GstStructure * event_structure)
 363 {
 364   gint event_type;
 365   gboolean start;
 366   gint method;
 367
 368   if (!gst_structure_get_int (event_structure, "type", &event_type) ||
 369       !gst_structure_get_boolean (event_structure, "start", &start) ||
 370       (start == TRUE && event_type != GST_TONE_DTMF_TYPE_EVENT))
 371     goto failure;
 372
 373   if (gst_structure_get_int (event_structure, "method", &method)) {
 374     if (method != 2) {
 375       goto failure;
 376     }
 377   }
 378
 379   if (start) {
 380     gint event_number;
 381     gint event_volume;
 382
 383     if (!gst_structure_get_int (event_structure, "number", &event_number) ||
 384             !gst_structure_get_int (event_structure, "volume", &event_volume))
 385       goto failure;
 386
 387     GST_DEBUG_OBJECT (dtmfsrc, "Received start event %d with volume %d",
 388             event_number, event_volume);
 389     gst_dtmf_src_add_start_event (dtmfsrc, event_number, event_volume);
 390   }
 391
 392   else {
 393     GST_DEBUG_OBJECT (dtmfsrc, "Received stop event");
 394     gst_dtmf_src_add_stop_event (dtmfsrc);
 395   }
 396
 397   return TRUE;
 398 failure:
 399   return FALSE;
 400 }
 401
 402 static gboolean
 403 gst_dtmf_src_handle_custom_upstream (GstDTMFSrc *dtmfsrc,
 404     GstEvent * event)
 405 {
 406   gboolean result = FALSE;
 407   const GstStructure *structure;
 408   GstState state;
 409   GstStateChangeReturn ret;
 410
 411   ret = gst_element_get_state (GST_ELEMENT (dtmfsrc), &state, NULL, 0);
 412   if (ret != GST_STATE_CHANGE_SUCCESS || state != GST_STATE_PLAYING) {
 413     GST_DEBUG_OBJECT (dtmfsrc, "Received event while not in PLAYING state");
 414     goto ret;
 415   }
 416
 417   GST_DEBUG_OBJECT (dtmfsrc, "Received event is of our interest");
 418   structure = gst_event_get_structure (event);
 419   if (structure && gst_structure_has_name (structure, "dtmf-event"))
 420     result = gst_dtmf_src_handle_dtmf_event (dtmfsrc, structure);
 421
 422 ret:
 423   return result;
 424 }
 425
 426 static gboolean
 427 gst_dtmf_src_handle_event (GstPad * pad, GstEvent * event)
 428 {
 429   GstDTMFSrc *dtmfsrc;
 430   gboolean result = FALSE;
 431   GstElement *parent = gst_pad_get_parent_element (pad);
 432   dtmfsrc = GST_DTMF_SRC (parent);
 433
 434   GST_DEBUG_OBJECT (dtmfsrc, "Received an event on the src pad");
 435   switch (GST_EVENT_TYPE (event)) {
 436     case GST_EVENT_CUSTOM_UPSTREAM:
 437     {
 438       result = gst_dtmf_src_handle_custom_upstream (dtmfsrc, event);
 439       break;
 440     }
 441     /* Ideally this element should not be flushed but let's handle the event
 442      * just in case it is */
 443     case GST_EVENT_FLUSH_START:
 444       gst_dtmf_src_stop (dtmfsrc);
 445       result = TRUE;
 446       break;
 447     case GST_EVENT_FLUSH_STOP:
 448       gst_segment_init (&dtmfsrc->segment, GST_FORMAT_TIME);
 449       break;
 450     default:
 451       result = gst_pad_event_default (pad, event);
 452       break;
 453   }
 454
 455   gst_object_unref (parent);
 456   gst_event_unref (event);
 457   return result;
 458 }
 459
 460 static void
 461 gst_dtmf_src_set_property (GObject * object, guint prop_id,
 462     const GValue * value, GParamSpec * pspec)
 463 {
 464   GstDTMFSrc *dtmfsrc;
 465
 466   dtmfsrc = GST_DTMF_SRC (object);
 467
 468   switch (prop_id) {
 469     case PROP_INTERVAL:
 470       dtmfsrc->interval = g_value_get_int (value);
 471       break;
 472     default:
 473       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 474       break;
 475   }
 476 }
 477
 478 static void
 479 gst_dtmf_src_get_property (GObject * object, guint prop_id, GValue * value,
 480     GParamSpec * pspec)
 481 {
 482   GstDTMFSrc *dtmfsrc;
 483
 484   dtmfsrc = GST_DTMF_SRC (object);
 485
 486   switch (prop_id) {
 487     case PROP_INTERVAL:
 488       g_value_set_uint (value, dtmfsrc->interval);
 489       break;
 490     default:
 491       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 492       break;
 493   }
 494 }
 495
 496 static void
 497 gst_dtmf_src_set_stream_lock (GstDTMFSrc *dtmfsrc, gboolean lock)
 498 {
 499    GstEvent *event;
 500    GstStructure *structure;
 501
 502    structure = gst_structure_new ("stream-lock",
 503                       "lock", G_TYPE_BOOLEAN, lock, NULL);
 504
 505    event = gst_event_new_custom (GST_EVENT_CUSTOM_DOWNSTREAM_OOB, structure);
 506    if (!gst_pad_push_event (dtmfsrc->srcpad, event)) {
 507      GST_WARNING_OBJECT (dtmfsrc, "stream-lock event not handled");
 508    }
 509 }
 510
 511 static void
 512 gst_dtmf_prepare_timestamps (GstDTMFSrc *dtmfsrc)
 513 {
 514   GstClock *clock;
 515
 516   clock = gst_element_get_clock (GST_ELEMENT (dtmfsrc));
 517   if (clock != NULL) {
 518     dtmfsrc->timestamp = gst_clock_get_time (clock);
 519     gst_object_unref (clock);
 520   } else {
 521     gchar *dtmf_name = gst_element_get_name (dtmfsrc);
 522     GST_ERROR_OBJECT (dtmfsrc, "No clock set for element %s", dtmf_name);
 523     dtmfsrc->timestamp = GST_CLOCK_TIME_NONE;
 524     g_free (dtmf_name);
 525   }
 526 }
 527
 528 static void
 529 gst_dtmf_src_start (GstDTMFSrc *dtmfsrc)
 530 {
 531   const GstCaps * caps = gst_pad_get_pad_template_caps (dtmfsrc->srcpad);
 532
 533   if (!gst_pad_set_caps (dtmfsrc->srcpad, (GstCaps *)caps))
 534     GST_ERROR_OBJECT (dtmfsrc,
 535             "Failed to set caps %" GST_PTR_FORMAT " on src pad", caps);
 536   else
 537     GST_DEBUG_OBJECT (dtmfsrc,
 538             "caps %" GST_PTR_FORMAT " set on src pad", caps);
 539
 540   dtmfsrc->task_paused = FALSE;
 541   if (!gst_pad_start_task (dtmfsrc->srcpad,
 542       (GstTaskFunction) gst_dtmf_src_push_next_tone_packet, dtmfsrc)) {
 543     GST_ERROR_OBJECT (dtmfsrc, "Failed to start task on src pad");
 544   }
 545 }
 546
 547 static void
 548 gst_dtmf_src_stop (GstDTMFSrc *dtmfsrc)
 549 {
 550   GstDTMFSrcEvent *event = NULL;
 551
 552   dtmfsrc->task_paused = TRUE;
 553   GST_OBJECT_LOCK (dtmfsrc);
 554   if (dtmfsrc->clock_id != NULL) {
 555     gst_clock_id_unschedule(dtmfsrc->clock_id);
 556   }
 557   GST_OBJECT_UNLOCK (dtmfsrc);
 558
 559   event = g_malloc (sizeof(GstDTMFSrcEvent));
 560   event->event_type = DTMF_EVENT_TYPE_PAUSE_TASK;
 561   g_async_queue_push (dtmfsrc->event_queue, event);
 562
 563   event = NULL;
 564
 565   if (!gst_pad_pause_task (dtmfsrc->srcpad)) {
 566     GST_ERROR_OBJECT (dtmfsrc, "Failed to pause task on src pad");
 567     return;
 568   }
 569
 570   if (dtmfsrc->last_event) {
 571     /* Don't forget to release the stream lock */
 572     gst_dtmf_src_set_stream_lock (dtmfsrc, FALSE);
 573     g_free (dtmfsrc->last_event);
 574     dtmfsrc->last_event = NULL;
 575   }
 576
 577   /* Flushing the event queue */
 578   event = g_async_queue_try_pop (dtmfsrc->event_queue);
 579
 580   while (event != NULL) {
 581     g_free (event);
 582     event = g_async_queue_try_pop (dtmfsrc->event_queue);
 583   }
 584
 585 }
 586
 587 static void
 588 gst_dtmf_src_add_start_event (GstDTMFSrc *dtmfsrc, gint event_number,
 589     gint event_volume)
 590 {
 591
 592   GstDTMFSrcEvent * event = g_malloc (sizeof(GstDTMFSrcEvent));
 593   event->event_type = DTMF_EVENT_TYPE_START;
 594   event->sample = 0;
 595   event->event_number = CLAMP (event_number, MIN_EVENT, MAX_EVENT);
 596   event->volume = CLAMP (event_volume, MIN_VOLUME, MAX_VOLUME);
 597
 598   g_async_queue_push (dtmfsrc->event_queue, event);
 599 }
 600
 601 static void
 602 gst_dtmf_src_add_stop_event (GstDTMFSrc *dtmfsrc)
 603 {
 604
 605   GstDTMFSrcEvent * event = g_malloc (sizeof(GstDTMFSrcEvent));
 606   event->event_type = DTMF_EVENT_TYPE_STOP;
 607   event->sample = 0;
 608   event->event_number = 0;
 609   event->volume = 0;
 610
 611   g_async_queue_push (dtmfsrc->event_queue, event);
 612 }
 613
 614 static void
 615 gst_dtmf_src_generate_silence(GstBuffer * buffer, float duration)
 616 {
 617   gint buf_size;
 618
 619   /* Create a buffer with data set to 0 */
 620   buf_size = ((duration/1000)*SAMPLE_RATE*SAMPLE_SIZE*CHANNELS)/8;
 621   GST_BUFFER_SIZE (buffer) = buf_size;
 622   GST_BUFFER_MALLOCDATA (buffer) = g_malloc0(buf_size);
 623   GST_BUFFER_DATA (buffer) = GST_BUFFER_MALLOCDATA (buffer);
 624
 625 }
 626
 627 static void
 628 gst_dtmf_src_generate_tone(GstDTMFSrcEvent *event, DTMF_KEY key, float duration,
 629     GstBuffer * buffer)
 630 {
 631   gint16 *p;
 632   gint tone_size;
 633   double i = 0;
 634   double amplitude, f1, f2;
 635   double volume_factor;
 636
 637   /* Create a buffer for the tone */
 638   tone_size = ((duration/1000)*SAMPLE_RATE*SAMPLE_SIZE*CHANNELS)/8;
 639   GST_BUFFER_SIZE (buffer) = tone_size;
 640   GST_BUFFER_MALLOCDATA (buffer) = g_malloc(tone_size);
 641   GST_BUFFER_DATA (buffer) = GST_BUFFER_MALLOCDATA (buffer);
 642
 643   p = (gint16 *) GST_BUFFER_MALLOCDATA (buffer);
 644
 645   volume_factor = pow (10, (-event->volume) / 20);
 646
 647   /*
 648    * For each sample point we calculate 'x' as the
 649    * the amplitude value.
 650    */
 651   for (i = 0; i < (tone_size / (SAMPLE_SIZE/8)); i++) {
 652     /*
 653      * We add the fundamental frequencies together.
 654      */
 655     f1 = sin(2 * M_PI * key.low_frequency * (event->sample / SAMPLE_RATE));
 656     f2 = sin(2 * M_PI * key.high_frequency * (event->sample / SAMPLE_RATE));
 657
 658     amplitude = (f1 + f2) / 2;
 659
 660     /* Adjust the volume */
 661     amplitude *= volume_factor;
 662
 663     /* Make the [-1:1] interval into a [-32767:32767] interval */
 664     amplitude *= 32767;
 665
 666     /* Store it in the data buffer */
 667     *(p++) = (gint16) amplitude;
 668
 669     (event->sample)++;
 670   }
 671 }
 672
 673 static void
 674 gst_dtmf_src_wait_for_buffer_ts (GstDTMFSrc *dtmfsrc, GstBuffer * buf)
 675 {
 676   GstClock *clock;
 677
 678   clock = gst_element_get_clock (GST_ELEMENT (dtmfsrc));
 679   if (clock != NULL) {
 680     GstClockReturn clock_ret;
 681     GstClockID clock_id;
 682
 683     clock_id = gst_clock_new_single_shot_id (clock, GST_BUFFER_TIMESTAMP (buf));
 684     gst_object_unref (clock);
 685
 686     GST_OBJECT_LOCK (dtmfsrc);
 687     dtmfsrc->clock_id = clock_id;
 688     GST_OBJECT_UNLOCK (dtmfsrc);
 689
 690     if (dtmfsrc->task_paused) {
 691       clock_ret = GST_CLOCK_UNSCHEDULED;
 692     } else {
 693       clock_ret = gst_clock_id_wait (dtmfsrc->clock_id, NULL);
 694     }
 695
 696     GST_OBJECT_LOCK (dtmfsrc);
 697     dtmfsrc->clock_id = NULL;
 698     gst_clock_id_unref (clock_id);
 699     GST_OBJECT_UNLOCK (dtmfsrc);
 700
 701     if (clock_ret == GST_CLOCK_UNSCHEDULED) {
 702       GST_DEBUG_OBJECT (dtmfsrc, "Clock wait unscheduled");
 703     } else {
 704       if (clock_ret != GST_CLOCK_OK && clock_ret != GST_CLOCK_EARLY) {
 705         gchar *clock_name = NULL;
 706
 707         clock = gst_element_get_clock (GST_ELEMENT (dtmfsrc));
 708         clock_name = gst_element_get_name (clock);
 709         gst_object_unref (clock);
 710
 711         GST_ERROR_OBJECT (dtmfsrc, "Failed to wait on clock %s", clock_name);
 712         g_free (clock_name);
 713       }
 714     }
 715   } else {
 716     gchar *dtmf_name = gst_element_get_name (dtmfsrc);
 717     GST_ERROR_OBJECT (dtmfsrc, "No clock set for element %s", dtmf_name);
 718     g_free (dtmf_name);
 719   }
 720 }
 721
 722
 723 static GstBuffer *
 724 gst_dtmf_src_create_next_tone_packet (GstDTMFSrc *dtmfsrc,
 725     GstDTMFSrcEvent *event)
 726 {
 727   GstBuffer *buf = NULL;
 728   gboolean send_silence = FALSE;
 729
 730   GST_DEBUG_OBJECT (dtmfsrc, "Creating buffer for tone %s",
 731       DTMF_KEYS[event->event_number].event_name);
 732
 733   /* create buffer to hold the tone */
 734   buf = gst_buffer_new ();
 735
 736   if (event->packet_count * dtmfsrc->interval < MIN_INTER_DIGIT_INTERVAL) {
 737     send_silence = TRUE;
 738   }
 739
 740   if (send_silence) {
 741     GST_DEBUG_OBJECT (dtmfsrc,  "Generating silence");
 742     gst_dtmf_src_generate_silence (buf, dtmfsrc->interval);
 743   } else {
 744     GST_DEBUG_OBJECT (dtmfsrc,  "Generating tone");
 745     gst_dtmf_src_generate_tone(event, DTMF_KEYS[event->event_number],
 746         dtmfsrc->interval, buf);
 747   }
 748   event->packet_count++;
 749
 750
 751   /* timestamp and duration of GstBuffer */
 752   GST_BUFFER_DURATION (buf) = dtmfsrc->interval * GST_MSECOND;
 753   GST_BUFFER_TIMESTAMP (buf) = dtmfsrc->timestamp;
 754   dtmfsrc->timestamp += GST_BUFFER_DURATION (buf);
 755
 756   /* FIXME: Should we sync to clock ourselves or leave it to sink */
 757   gst_dtmf_src_wait_for_buffer_ts (dtmfsrc, buf);
 758
 759   /* Set caps on the buffer before pushing it */
 760   gst_buffer_set_caps (buf, GST_PAD_CAPS (dtmfsrc->srcpad));
 761
 762   return buf;
 763 }
 764
 765 static void
 766 gst_dtmf_src_push_next_tone_packet (GstDTMFSrc *dtmfsrc)
 767 {
 768   GstBuffer *buf = NULL;
 769   GstFlowReturn ret;
 770   GstDTMFSrcEvent *event;
 771
 772   g_async_queue_ref (dtmfsrc->event_queue);
 773
 774   if (dtmfsrc->last_event == NULL) {
 775     event = g_async_queue_pop (dtmfsrc->event_queue);
 776
 777     if (event->event_type == DTMF_EVENT_TYPE_STOP) {
 778       GST_WARNING_OBJECT (dtmfsrc,
 779           "Received a DTMF stop event when already stopped");
 780     } else if (event->event_type == DTMF_EVENT_TYPE_START) {
 781       gst_dtmf_prepare_timestamps (dtmfsrc);
 782
 783       /* Don't forget to get exclusive access to the stream */
 784       gst_dtmf_src_set_stream_lock (dtmfsrc, TRUE);
 785
 786       event->packet_count = 0;
 787       dtmfsrc->last_event = event;
 788     } else if (event->event_type == DTMF_EVENT_TYPE_PAUSE_TASK) {
 789       /*
 790        * We're pushing it back because it has to stay in there until
 791        * the task is really paused (and the queue will then be flushed
 792        */
 793       g_async_queue_push (dtmfsrc->event_queue, event);
 794       g_async_queue_unref (dtmfsrc->event_queue);
 795       return;
 796     }
 797   } else if (dtmfsrc->last_event->packet_count  * dtmfsrc->interval >=
 798       MIN_DUTY_CYCLE) {
 799     event = g_async_queue_try_pop (dtmfsrc->event_queue);
 800
 801     if (event != NULL) {
 802       if (event->event_type == DTMF_EVENT_TYPE_START) {
 803         GST_WARNING_OBJECT (dtmfsrc,
 804             "Received two consecutive DTMF start events");
 805       } else if (event->event_type == DTMF_EVENT_TYPE_STOP) {
 806         gst_dtmf_src_set_stream_lock (dtmfsrc, FALSE);
 807         g_free (dtmfsrc->last_event);
 808         dtmfsrc->last_event = NULL;
 809       }
 810     }
 811   }
 812   g_async_queue_unref (dtmfsrc->event_queue);
 813
 814   if (dtmfsrc->last_event) {
 815     buf = gst_dtmf_src_create_next_tone_packet (dtmfsrc, dtmfsrc->last_event);
 816
 817     gst_buffer_ref(buf);
 818
 819     GST_DEBUG_OBJECT (dtmfsrc,
 820         "pushing buffer on src pad of size %d", GST_BUFFER_SIZE (buf));
 821     ret = gst_pad_push (dtmfsrc->srcpad, buf);
 822     if (ret != GST_FLOW_OK) {
 823       GST_ERROR_OBJECT (dtmfsrc, "Failed to push buffer on src pad");
 824     }
 825
 826     gst_buffer_unref(buf);
 827     GST_DEBUG_OBJECT (dtmfsrc, "pushed DTMF tone on src pad");
 828   }
 829
 830 }
 831
 832 static GstStateChangeReturn
 833 gst_dtmf_src_change_state (GstElement * element, GstStateChange transition)
 834 {
 835   GstDTMFSrc *dtmfsrc;
 836   GstStateChangeReturn result;
 837   gboolean no_preroll = FALSE;
 838
 839   dtmfsrc = GST_DTMF_SRC (element);
 840
 841   switch (transition) {
 842     case GST_STATE_CHANGE_READY_TO_PAUSED:
 843       gst_segment_init (&dtmfsrc->segment, GST_FORMAT_TIME);
 844       gst_pad_push_event (dtmfsrc->srcpad, gst_event_new_new_segment (FALSE,
 845               dtmfsrc->segment.rate, dtmfsrc->segment.format,
 846               dtmfsrc->segment.start, dtmfsrc->segment.stop,
 847               dtmfsrc->segment.time));
 848       /* Indicate that we don't do PRE_ROLL */
 849       no_preroll = TRUE;
 850       break;
 851     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 852       gst_dtmf_src_start (dtmfsrc);
 853       break;
 854     default:
 855       break;
 856   }
 857
 858   if ((result =
 859           GST_ELEMENT_CLASS (parent_class)->change_state (element,
 860               transition)) == GST_STATE_CHANGE_FAILURE)
 861     goto failure;
 862
 863   switch (transition) {
 864     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 865       /* Indicate that we don't do PRE_ROLL */
 866       gst_dtmf_src_stop (dtmfsrc);
 867       no_preroll = TRUE;
 868       break;
 869     default:
 870       break;
 871   }
 872
 873   if (no_preroll && result == GST_STATE_CHANGE_SUCCESS)
 874     result = GST_STATE_CHANGE_NO_PREROLL;
 875
 876   return result;
 877
 878   /* ERRORS */
 879 failure:
 880   {
 881     GST_ERROR_OBJECT (dtmfsrc, "parent failed state change");
 882     return result;
 883   }
 884 }
 885
 886 gboolean
 887 gst_dtmf_src_plugin_init (GstPlugin * plugin)
 888 {
 889   return gst_element_register (plugin, "dtmfsrc",
 890       GST_RANK_NONE, GST_TYPE_DTMF_SRC);
 891 }
 892