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