gst/speed/gstspeed.c

   1 /* -*- c-basic-offset: 2 -*-
   2  * GStreamer
   3  * Copyright (C) 1999-2001 Erik Walthinsen <omega@cse.ogi.edu>
   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., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 /**
  22  * SECTION:element-speed
  23  *
  24  * Plays an audio stream at a different speed (by resampling the audio).
  25  *
  26  * Do not use this element. Either use the 'pitch' element, or do a seek with
  27  * a non-1.0 rate parameter, this will have the same effect as using the speed
  28  * element (but relies on the decoder/demuxer to handle this correctly, also
  29  * requires a fairly up-to-date gst-plugins-base, as of February 2007).
  30  *
  31  * <refsect2>
  32  * <title>Example launch line</title>
  33  * |[
  34  * gst-launch filesrc location=test.ogg ! decodebin ! audioconvert ! speed speed=1.5 ! audioconvert ! audioresample ! autoaudiosink
  35  * ]| Plays an .ogg file at 1.5x speed.
  36  * </refsect2>
  37  *
  38  * Last reviewed on 2007-02-26 (0.10.4.1)
  39  */
  40
  41 #ifdef HAVE_CONFIG_H
  42 #  include "config.h"
  43 #endif
  44
  45 #include <string.h>
  46 #include <math.h>
  47 #include <gst/gst.h>
  48 #include <gst/audio/audio.h>
  49
  50 #include "gstspeed.h"
  51
  52 GST_DEBUG_CATEGORY_STATIC (speed_debug);
  53 #define GST_CAT_DEFAULT speed_debug
  54
  55 enum
  56 {
  57   ARG_0,
  58   ARG_SPEED
  59 };
  60
  61 /* assumption here: sizeof (gfloat) = 4 */
  62 #define GST_SPEED_AUDIO_CAPS \
  63     "audio/x-raw-float, " \
  64     "rate = (int) [ 1, MAX ], " \
  65     "channels = (int) [ 1, MAX ], " \
  66     "endianness = (int) BYTE_ORDER, " \
  67     "width = (int) 32; " \
  68     \
  69     "audio/x-raw-int, " \
  70     "rate = (int) [ 1, MAX ], " \
  71     "channels = (int) [ 1, MAX ], " \
  72     "endianness = (int) BYTE_ORDER, " \
  73     "width = (int) 16, " \
  74     "depth = (int) 16, " \
  75     "signed = (boolean) true"
  76
  77 static GstStaticPadTemplate gst_speed_sink_template =
  78 GST_STATIC_PAD_TEMPLATE ("sink",
  79     GST_PAD_SINK,
  80     GST_PAD_ALWAYS,
  81     GST_STATIC_CAPS (GST_SPEED_AUDIO_CAPS)
  82     );
  83
  84 static GstStaticPadTemplate gst_speed_src_template =
  85 GST_STATIC_PAD_TEMPLATE ("src",
  86     GST_PAD_SRC,
  87     GST_PAD_ALWAYS,
  88     GST_STATIC_CAPS (GST_SPEED_AUDIO_CAPS)
  89     );
  90
  91 static void speed_base_init (gpointer g_class);
  92 static void speed_class_init (GstSpeedClass * klass);
  93 static void speed_init (GstSpeed * filter);
  94
  95 static void speed_set_property (GObject * object, guint prop_id,
  96     const GValue * value, GParamSpec * pspec);
  97 static void speed_get_property (GObject * object, guint prop_id, GValue * value,
  98     GParamSpec * pspec);
  99
 100 static gboolean speed_parse_caps (GstSpeed * filter, const GstCaps * caps);
 101
 102 static GstFlowReturn speed_chain (GstPad * pad, GstBuffer * buf);
 103
 104 static GstStateChangeReturn speed_change_state (GstElement * element,
 105     GstStateChange transition);
 106 static gboolean speed_sink_event (GstPad * pad, GstEvent * event);
 107 static gboolean speed_src_event (GstPad * pad, GstEvent * event);
 108
 109 static GstElementClass *parent_class;   /* NULL */
 110
 111 static gboolean
 112 speed_setcaps (GstPad * pad, GstCaps * caps)
 113 {
 114   GstSpeed *filter;
 115   GstPad *otherpad;
 116   gboolean ret;
 117
 118   filter = GST_SPEED (gst_pad_get_parent (pad));
 119
 120   otherpad = (pad == filter->srcpad) ? filter->sinkpad : filter->srcpad;
 121
 122   if ((ret = speed_parse_caps (filter, caps)))
 123     ret = gst_pad_set_caps (otherpad, caps);
 124
 125   gst_object_unref (filter);
 126
 127   return ret;
 128
 129 }
 130
 131 static gboolean
 132 speed_parse_caps (GstSpeed * filter, const GstCaps * caps)
 133 {
 134
 135   GstStructure *structure;
 136   gint rate, chans, width;
 137
 138   g_return_val_if_fail (filter != NULL, FALSE);
 139   g_return_val_if_fail (caps != NULL, FALSE);
 140
 141   structure = gst_caps_get_structure (caps, 0);
 142
 143
 144   if (gst_structure_has_name (structure, "audio/x-raw-float"))
 145     filter->format = GST_SPEED_FORMAT_FLOAT;
 146   else if (gst_structure_has_name (structure, "audio/x-raw-int"))
 147     filter->format = GST_SPEED_FORMAT_INT;
 148   else
 149     return FALSE;
 150
 151   if (!gst_structure_get_int (structure, "rate", &rate)
 152       || !gst_structure_get_int (structure, "width", &width)
 153       || !gst_structure_get_int (structure, "channels", &chans)) {
 154     return FALSE;
 155   }
 156
 157   filter->rate = rate;
 158   filter->width = width;
 159   filter->channels = chans;
 160
 161   if (filter->format == GST_SPEED_FORMAT_FLOAT) {
 162     filter->sample_size = filter->channels * filter->width / 8;
 163   } else {
 164     /* our caps only allow width == depth for now */
 165     filter->sample_size = filter->channels * filter->width / 8;
 166   }
 167
 168   return TRUE;
 169 }
 170
 171 GType
 172 gst_speed_get_type (void)
 173 {
 174   static GType speed_type = 0;
 175
 176   if (!speed_type) {
 177     static const GTypeInfo speed_info = {
 178       sizeof (GstSpeedClass),
 179       speed_base_init,
 180       NULL,
 181       (GClassInitFunc) speed_class_init,
 182       NULL,
 183       NULL,
 184       sizeof (GstSpeed),
 185       0,
 186       (GInstanceInitFunc) speed_init,
 187     };
 188
 189     speed_type =
 190         g_type_register_static (GST_TYPE_ELEMENT, "GstSpeed", &speed_info, 0);
 191   }
 192   return speed_type;
 193 }
 194
 195 static const GstQueryType *
 196 speed_get_query_types (GstPad * pad)
 197 {
 198   static const GstQueryType src_query_types[] = {
 199     GST_QUERY_POSITION,
 200     GST_QUERY_DURATION,
 201     0
 202   };
 203
 204   return src_query_types;
 205 }
 206
 207 static gboolean
 208 speed_src_event (GstPad * pad, GstEvent * event)
 209 {
 210   GstSpeed *filter;
 211   gboolean ret = FALSE;
 212
 213   filter = GST_SPEED (gst_pad_get_parent (pad));
 214
 215   switch (GST_EVENT_TYPE (event)) {
 216     case GST_EVENT_SEEK:{
 217       gdouble rate;
 218       GstFormat format;
 219       GstSeekFlags flags;
 220       GstSeekType start_type, stop_type;
 221       gint64 start, stop;
 222
 223       gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,
 224           &stop_type, &stop);
 225       gst_event_unref (event);
 226
 227       if (format != GST_FORMAT_TIME) {
 228         GST_DEBUG_OBJECT (filter, "only support seeks in TIME format");
 229         break;
 230       }
 231
 232       if (start_type != GST_SEEK_TYPE_NONE && start != -1) {
 233         start *= filter->speed;
 234       }
 235
 236       if (stop_type != GST_SEEK_TYPE_NONE && stop != -1) {
 237         stop *= filter->speed;
 238       }
 239
 240       event = gst_event_new_seek (rate, format, flags, start_type, start,
 241           stop_type, stop);
 242
 243       GST_LOG ("sending seek event: %" GST_PTR_FORMAT, event->structure);
 244
 245       ret = gst_pad_send_event (GST_PAD_PEER (filter->sinkpad), event);
 246       break;
 247     }
 248     default:
 249       ret = gst_pad_event_default (pad, event);
 250       break;
 251   }
 252
 253   gst_object_unref (filter);
 254   return ret;
 255
 256 }
 257
 258 static gboolean
 259 gst_speed_convert (GstPad * pad, GstFormat src_format, gint64 src_value,
 260     GstFormat * dest_format, gint64 * dest_value)
 261 {
 262   gboolean ret = TRUE;
 263   guint scale = 1;
 264   GstSpeed *filter;
 265
 266   if (src_format == *dest_format) {
 267     *dest_value = src_value;
 268     return TRUE;
 269   }
 270
 271   filter = GST_SPEED (GST_PAD_PARENT (pad));
 272
 273   switch (src_format) {
 274     case GST_FORMAT_BYTES:
 275       switch (*dest_format) {
 276         case GST_FORMAT_DEFAULT:
 277           if (filter->sample_size == 0) {
 278             ret = FALSE;
 279             break;
 280           }
 281           *dest_value = src_value / filter->sample_size;
 282           break;
 283         case GST_FORMAT_TIME:
 284         {
 285           gint byterate = filter->sample_size * filter->rate;
 286
 287           if (byterate == 0) {
 288             ret = FALSE;
 289             break;
 290           }
 291           *dest_value = src_value * GST_SECOND / byterate;
 292           break;
 293         }
 294         default:
 295           ret = FALSE;
 296       }
 297       break;
 298     case GST_FORMAT_DEFAULT:
 299       switch (*dest_format) {
 300         case GST_FORMAT_BYTES:
 301           *dest_value = src_value * filter->sample_size;
 302           break;
 303         case GST_FORMAT_TIME:
 304           if (filter->rate == 0) {
 305             ret = FALSE;
 306             break;
 307           }
 308           *dest_value = src_value * GST_SECOND / filter->rate;
 309           break;
 310         default:
 311           ret = FALSE;
 312       }
 313       break;
 314     case GST_FORMAT_TIME:
 315       switch (*dest_format) {
 316         case GST_FORMAT_BYTES:
 317           scale = filter->sample_size;
 318           /* fallthrough */
 319         case GST_FORMAT_DEFAULT:
 320           *dest_value = src_value * scale * filter->rate / GST_SECOND;
 321           break;
 322         default:
 323           ret = FALSE;
 324       }
 325       break;
 326     default:
 327       ret = FALSE;
 328   }
 329
 330   return ret;
 331
 332 }
 333
 334 static gboolean
 335 speed_src_query (GstPad * pad, GstQuery * query)
 336 {
 337   gboolean ret = TRUE;
 338   GstSpeed *filter;
 339
 340   filter = GST_SPEED (gst_pad_get_parent (pad));
 341
 342   switch (GST_QUERY_TYPE (query)) {
 343     case GST_QUERY_POSITION:
 344     {
 345       GstFormat format;
 346       GstFormat rformat = GST_FORMAT_TIME;
 347       gint64 cur;
 348       GstFormat conv_format = GST_FORMAT_TIME;
 349
 350       /* save requested format */
 351       gst_query_parse_position (query, &format, NULL);
 352
 353       /* query peer for current position in time */
 354       gst_query_set_position (query, GST_FORMAT_TIME, -1);
 355
 356       if (!gst_pad_query_peer_position (filter->sinkpad, &rformat, &cur)) {
 357         GST_LOG_OBJECT (filter, "query on peer pad failed");
 358         goto error;
 359       }
 360
 361       if (rformat == GST_FORMAT_BYTES)
 362         GST_LOG_OBJECT (filter,
 363             "peer pad returned current=%" G_GINT64_FORMAT " bytes", cur);
 364       else if (rformat == GST_FORMAT_TIME)
 365         GST_LOG_OBJECT (filter, "peer pad returned time=%" G_GINT64_FORMAT,
 366             cur);
 367
 368       /* convert to time format */
 369       if (!gst_speed_convert (pad, rformat, cur, &conv_format, &cur)) {
 370         ret = FALSE;
 371         break;
 372       }
 373
 374       /* adjust for speed factor */
 375       cur /= filter->speed;
 376
 377       /* convert to time format */
 378       if (!gst_speed_convert (pad, conv_format, cur, &format, &cur)) {
 379         ret = FALSE;
 380         break;
 381       }
 382       gst_query_set_position (query, format, cur);
 383
 384       GST_LOG_OBJECT (filter,
 385           "position query: we return %" G_GUINT64_FORMAT " (format %u)", cur,
 386           format);
 387
 388       break;
 389     }
 390     case GST_QUERY_DURATION:
 391     {
 392       GstFormat format;
 393       GstFormat rformat = GST_FORMAT_TIME;
 394       gint64 end;
 395       GstFormat conv_format = GST_FORMAT_TIME;
 396
 397       /* save requested format */
 398       gst_query_parse_duration (query, &format, NULL);
 399
 400       /* query peer for total length in time */
 401       gst_query_set_duration (query, GST_FORMAT_TIME, -1);
 402
 403       if (!gst_pad_query_peer_duration (filter->sinkpad, &rformat, &end)) {
 404         GST_LOG_OBJECT (filter, "query on peer pad failed");
 405         goto error;
 406       }
 407
 408       if (rformat == GST_FORMAT_BYTES)
 409         GST_LOG_OBJECT (filter,
 410             "peer pad returned total=%" G_GINT64_FORMAT " bytes", end);
 411       else if (rformat == GST_FORMAT_TIME)
 412         GST_LOG_OBJECT (filter, "peer pad returned time=%" G_GINT64_FORMAT,
 413             end);
 414
 415       /* convert to time format */
 416       if (!gst_speed_convert (pad, rformat, end, &conv_format, &end)) {
 417         ret = FALSE;
 418         break;
 419       }
 420
 421       /* adjust for speed factor */
 422       end /= filter->speed;
 423
 424       /* convert to time format */
 425       if (!gst_speed_convert (pad, conv_format, end, &format, &end)) {
 426         ret = FALSE;
 427         break;
 428       }
 429
 430       gst_query_set_duration (query, format, end);
 431
 432       GST_LOG_OBJECT (filter,
 433           "duration query: we return %" G_GUINT64_FORMAT " (format %u)", end,
 434           format);
 435
 436       break;
 437     }
 438     default:
 439       ret = FALSE;
 440       break;
 441   }
 442
 443   gst_object_unref (filter);
 444   return ret;
 445
 446 error:
 447
 448   gst_object_unref (filter);
 449   GST_DEBUG ("error handling query");
 450   return FALSE;
 451 }
 452
 453 static void
 454 speed_base_init (gpointer g_class)
 455 {
 456   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 457
 458   gst_element_class_set_details_simple (element_class, "Speed",
 459       "Filter/Effect/Audio",
 460       "Set speed/pitch on audio/raw streams (resampler)",
 461       "Andy Wingo <apwingo@eos.ncsu.edu>, "
 462       "Tim-Philipp Müller <tim@centricular.net>");
 463
 464   gst_element_class_add_static_pad_template (element_class,
 465       &gst_speed_src_template);
 466   gst_element_class_add_static_pad_template (element_class,
 467       &gst_speed_sink_template);
 468 }
 469
 470 static void
 471 speed_class_init (GstSpeedClass * klass)
 472 {
 473   GObjectClass *gobject_class = (GObjectClass *) klass;
 474   GstElementClass *gstelement_class = (GstElementClass *) klass;
 475
 476   gobject_class->set_property = speed_set_property;
 477   gobject_class->get_property = speed_get_property;
 478   gstelement_class->change_state = speed_change_state;
 479
 480   parent_class = g_type_class_peek_parent (klass);
 481
 482   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_SPEED,
 483       g_param_spec_float ("speed", "speed", "speed",
 484           0.1, 40.0, 1.0,
 485           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
 486 }
 487
 488 static void
 489 speed_init (GstSpeed * filter)
 490 {
 491   filter->sinkpad =
 492       gst_pad_new_from_static_template (&gst_speed_sink_template, "sink");
 493   gst_pad_set_setcaps_function (filter->sinkpad, speed_setcaps);
 494   gst_pad_set_chain_function (filter->sinkpad, speed_chain);
 495   gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad);
 496   gst_pad_set_event_function (filter->sinkpad, speed_sink_event);
 497
 498   filter->srcpad =
 499       gst_pad_new_from_static_template (&gst_speed_src_template, "src");
 500   gst_pad_set_setcaps_function (filter->srcpad, speed_setcaps);
 501   gst_pad_set_query_type_function (filter->srcpad, speed_get_query_types);
 502   gst_pad_set_query_function (filter->srcpad, speed_src_query);
 503   gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad);
 504
 505   gst_pad_set_event_function (filter->srcpad, speed_src_event);
 506
 507   filter->offset = 0;
 508   filter->timestamp = 0;
 509   filter->sample_size = 0;
 510
 511 }
 512
 513 static inline guint
 514 speed_chain_int16 (GstSpeed * filter, GstBuffer * in_buf, GstBuffer * out_buf,
 515     guint c, guint in_samples)
 516 {
 517   gint16 *in_data, *out_data;
 518   gfloat interp, lower, i_float;
 519   guint i, j;
 520
 521   in_data = ((gint16 *) GST_BUFFER_DATA (in_buf)) + c;
 522   out_data = ((gint16 *) GST_BUFFER_DATA (out_buf)) + c;
 523
 524   lower = in_data[0];
 525   i_float = 0.5 * (filter->speed - 1.0);
 526   i = (guint) ceil (i_float);
 527   j = 0;
 528
 529   while (i < in_samples) {
 530     interp = i_float - floor (i_float);
 531
 532     out_data[j * filter->channels] =
 533         lower * (1 - interp) + in_data[i * filter->channels] * interp;
 534
 535     lower = in_data[i * filter->channels];
 536
 537     i_float += filter->speed;
 538     i = (guint) ceil (i_float);
 539
 540     ++j;
 541   }
 542
 543   return j;
 544 }
 545
 546 static inline guint
 547 speed_chain_float32 (GstSpeed * filter, GstBuffer * in_buf, GstBuffer * out_buf,
 548     guint c, guint in_samples)
 549 {
 550   gfloat *in_data, *out_data;
 551   gfloat interp, lower, i_float;
 552   guint i, j;
 553
 554   in_data = ((gfloat *) GST_BUFFER_DATA (in_buf)) + c;
 555   out_data = ((gfloat *) GST_BUFFER_DATA (out_buf)) + c;
 556
 557   lower = in_data[0];
 558   i_float = 0.5 * (filter->speed - 1.0);
 559   i = (guint) ceil (i_float);
 560   j = 0;
 561
 562   while (i < in_samples) {
 563     interp = i_float - floor (i_float);
 564
 565     out_data[j * filter->channels] =
 566         lower * (1 - interp) + in_data[i * filter->channels] * interp;
 567
 568     lower = in_data[i * filter->channels];
 569
 570     i_float += filter->speed;
 571     i = (guint) ceil (i_float);
 572
 573     ++j;
 574   }
 575
 576   return j;
 577 }
 578
 579
 580 static gboolean
 581 speed_sink_event (GstPad * pad, GstEvent * event)
 582 {
 583   GstSpeed *filter;
 584   gboolean ret = FALSE;
 585
 586   filter = GST_SPEED (gst_pad_get_parent (pad));
 587
 588   switch (GST_EVENT_TYPE (event)) {
 589     case GST_EVENT_NEWSEGMENT:{
 590       gdouble rate;
 591       gboolean update = FALSE;
 592       GstFormat format;
 593       gint64 start_value, stop_value, base;
 594
 595       gst_event_parse_new_segment (event, &update, &rate, &format, &start_value,
 596           &stop_value, &base);
 597       gst_event_unref (event);
 598
 599       if (format != GST_FORMAT_TIME) {
 600         GST_WARNING_OBJECT (filter, "newsegment event not in TIME format!");
 601         break;
 602       }
 603
 604       g_assert (filter->speed > 0);
 605
 606       if (start_value >= 0)
 607         start_value /= filter->speed;
 608       if (stop_value >= 0)
 609         stop_value /= filter->speed;
 610       base /= filter->speed;
 611
 612       /* this would only really be correct if we clipped incoming data */
 613       filter->timestamp = start_value;
 614
 615       /* set to NONE so it gets reset later based on the timestamp when we have
 616        * the samplerate */
 617       filter->offset = GST_BUFFER_OFFSET_NONE;
 618
 619       ret =
 620           gst_pad_event_default (pad, gst_event_new_new_segment (update, rate,
 621               format, start_value, stop_value, base));
 622       break;
 623     }
 624     default:
 625       ret = gst_pad_event_default (pad, event);
 626       break;
 627   }
 628
 629
 630   gst_object_unref (filter);
 631
 632   return ret;
 633
 634
 635 }
 636
 637 static GstFlowReturn
 638 speed_chain (GstPad * pad, GstBuffer * in_buf)
 639 {
 640   GstBuffer *out_buf;
 641   GstSpeed *filter;
 642   guint c, in_samples, out_samples, out_size;
 643   GstFlowReturn flow;
 644
 645   filter = GST_SPEED (GST_PAD_PARENT (pad));
 646
 647   if (G_UNLIKELY (filter->sample_size == 0 || filter->rate == 0)) {
 648     flow = GST_FLOW_NOT_NEGOTIATED;
 649     goto done;
 650   }
 651
 652   if (G_UNLIKELY (filter->offset == GST_BUFFER_OFFSET_NONE)) {
 653     filter->offset =
 654         gst_util_uint64_scale_int (filter->timestamp, filter->rate, GST_SECOND);
 655   }
 656
 657   /* buffersize has to be aligned by samplesize */
 658   out_size = ceil ((gfloat) GST_BUFFER_SIZE (in_buf) / filter->speed);
 659   out_size = ((out_size + filter->sample_size - 1) / filter->sample_size) *
 660       filter->sample_size;
 661
 662   flow =
 663       gst_pad_alloc_buffer_and_set_caps (filter->srcpad, -1, out_size,
 664       GST_PAD_CAPS (filter->srcpad), &out_buf);
 665
 666   if (flow != GST_FLOW_OK)
 667     goto done;
 668
 669   in_samples = GST_BUFFER_SIZE (in_buf) / filter->sample_size;
 670
 671   out_samples = 0;
 672
 673   for (c = 0; c < filter->channels; ++c) {
 674     if (filter->format == GST_SPEED_FORMAT_INT) {
 675       out_samples = speed_chain_int16 (filter, in_buf, out_buf, c, in_samples);
 676     } else {
 677       out_samples =
 678           speed_chain_float32 (filter, in_buf, out_buf, c, in_samples);
 679     }
 680   }
 681
 682   GST_BUFFER_SIZE (out_buf) = out_samples * filter->sample_size;
 683
 684   GST_BUFFER_OFFSET (out_buf) = filter->offset;
 685   GST_BUFFER_TIMESTAMP (out_buf) = filter->timestamp;
 686
 687   filter->offset += GST_BUFFER_SIZE (out_buf) / filter->sample_size;
 688   filter->timestamp =
 689       gst_util_uint64_scale_int (filter->offset, GST_SECOND, filter->rate);
 690
 691   /* make sure it's at least nominally a perfect stream */
 692   GST_BUFFER_DURATION (out_buf) =
 693       filter->timestamp - GST_BUFFER_TIMESTAMP (out_buf);
 694
 695   flow = gst_pad_push (filter->srcpad, out_buf);
 696
 697 done:
 698
 699   if (G_UNLIKELY (flow != GST_FLOW_OK))
 700     GST_DEBUG_OBJECT (filter, "flow: %s", gst_flow_get_name (flow));
 701
 702   gst_buffer_unref (in_buf);
 703   return flow;
 704 }
 705
 706 static void
 707 speed_set_property (GObject * object, guint prop_id, const GValue * value,
 708     GParamSpec * pspec)
 709 {
 710   GstSpeed *filter = GST_SPEED (object);
 711
 712   switch (prop_id) {
 713     case ARG_SPEED:
 714       filter->speed = g_value_get_float (value);
 715       break;
 716     default:
 717       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 718       break;
 719   }
 720
 721 }
 722
 723 static void
 724 speed_get_property (GObject * object, guint prop_id, GValue * value,
 725     GParamSpec * pspec)
 726 {
 727   GstSpeed *filter = GST_SPEED (object);
 728
 729   switch (prop_id) {
 730     case ARG_SPEED:
 731       g_value_set_float (value, filter->speed);
 732       break;
 733     default:
 734       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 735       break;
 736   }
 737
 738 }
 739
 740 static GstStateChangeReturn
 741 speed_change_state (GstElement * element, GstStateChange transition)
 742 {
 743   GstSpeed *speed = GST_SPEED (element);
 744
 745   switch (transition) {
 746     case GST_STATE_CHANGE_READY_TO_PAUSED:
 747       speed->offset = GST_BUFFER_OFFSET_NONE;
 748       speed->timestamp = 0;
 749       break;
 750     default:
 751       break;
 752   }
 753
 754   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 755     return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 756
 757   return GST_STATE_CHANGE_SUCCESS;
 758 }
 759
 760 static gboolean
 761 plugin_init (GstPlugin * plugin)
 762 {
 763   GST_DEBUG_CATEGORY_INIT (speed_debug, "speed", 0, "speed element");
 764
 765   return gst_element_register (plugin, "speed", GST_RANK_NONE, GST_TYPE_SPEED);
 766 }
 767
 768 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 769     GST_VERSION_MINOR,
 770     "speed",
 771     "Set speed/pitch on audio/raw streams (resampler)",
 772     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)