4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>
8 * This library is free software; you can redistribute it and/or modify it under
9 * the terms of the GNU Lesser General Public License as published by the
10 * Free Software Foundation; either version 2.1 of the License, or (at your option)
13 * This library is distributed in the hope that it will be useful, but WITHOUT ANY
14 * WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
16 * License for more details.
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this library; if not, write to the Free Software Foundation, Inc., 51
20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include <gst/gstutils.h>
31 #include "gstavsysaudiosink.h"
34 #define __REPLACE_RESET_WITH_CLOSE_AND_REOPEN__
36 #define CONVERT_MUTE_VALUE(_mute) ((_mute) ? AVSYS_AUDIO_MUTE : AVSYS_AUDIO_UNMUTE)
38 GST_DEBUG_CATEGORY_EXTERN (avsystem_sink_debug);
39 #define GST_CAT_DEFAULT avsystem_sink_debug
41 #define DEFAULT_USER_ROUTE AVSYSAUDIOSINK_USERROUTE_AUTO
42 #define DEFAULT_AUDIO_ROUTE AVSYSAUDIOSINK_AUDIOROUTE_USE_EXTERNAL_SETTING
43 #define DEFAULT_VOLUME_TYPE AVSYS_AUDIO_VOLUME_TYPE_MEDIA
44 #define DEFAULT_MEDIACALL_MODE AVSYS_AUDIO_ECHO_MODE_NONE
45 #define DEFAULT_FADEUP_VOLUME FALSE
46 #define DEFAULT_AUDIO_MUTE AVSYSAUDIOSINK_AUDIO_UNMUTE
47 #define DEFAULT_AUDIO_LATENCY AVSYSAUDIOSINK_LATENCY_MID
48 #define DEFAULT_AUDIO_CLOSE_HANDLE_ON_PREPARE FALSE
49 #define DEFAULT_AUDIO_OPEN_FORCEDLY FALSE
51 //GST_DEBUG_CATEGORY_STATIC (gst_avsystemsink_debug);
53 /* element factory information */
54 static const GstElementDetails gst_avsysaudiosink_details =
55 GST_ELEMENT_DETAILS ("AV-system Audio OUT",
57 "Output to AV System",
58 "Samsung Electronics co., ltd");
60 static const avsys_audio_channel_pos_t gst_pos_to_avsys[GST_AUDIO_CHANNEL_POSITION_NUM] = {
61 [GST_AUDIO_CHANNEL_POSITION_FRONT_MONO] = AVSYS_AUDIO_CHANNEL_POSITION_MONO,
62 [GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT] = AVSYS_AUDIO_CHANNEL_POSITION_FRONT_LEFT,
63 [GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT] = AVSYS_AUDIO_CHANNEL_POSITION_FRONT_RIGHT,
64 [GST_AUDIO_CHANNEL_POSITION_REAR_CENTER] = AVSYS_AUDIO_CHANNEL_POSITION_REAR_CENTER,
65 [GST_AUDIO_CHANNEL_POSITION_REAR_LEFT] = AVSYS_AUDIO_CHANNEL_POSITION_REAR_LEFT,
66 [GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT] = AVSYS_AUDIO_CHANNEL_POSITION_REAR_RIGHT,
67 [GST_AUDIO_CHANNEL_POSITION_LFE] = AVSYS_AUDIO_CHANNEL_POSITION_LFE,
68 [GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER] = AVSYS_AUDIO_CHANNEL_POSITION_FRONT_CENTER,
69 [GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER] = AVSYS_AUDIO_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER,
70 [GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER] = AVSYS_AUDIO_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER,
71 [GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT] = AVSYS_AUDIO_CHANNEL_POSITION_SIDE_LEFT,
72 [GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT] = AVSYS_AUDIO_CHANNEL_POSITION_SIDE_RIGHT,
73 [GST_AUDIO_CHANNEL_POSITION_NONE] = AVSYS_AUDIO_CHANNEL_POSITION_INVALID
80 PROP_AUDIO_VOLUME_TYPE,
82 PROP_AUDIO_FADEUPVOLUME,
83 PROP_AUDIO_ROUTE_POLICY,
84 PROP_AUDIO_USER_ROUTE,
88 PROP_AUDIO_CLOSE_HANDLE_ON_PREPARE,
89 PROP_AUDIO_OPEN_FORCEDLY,
90 #ifdef USE_PA_AUDIO_FILTER
93 PROP_FILTER_OUTPUT_MODE,
100 #ifdef USE_PA_AUDIO_FILTER
101 #define AUDIOVSP_DEFAULT_PLAYBACK_RATE 1.0
102 #define AUDIOVSP_MIN_PLAYBACK_RATE 0.5
103 #define AUDIOVSP_MAX_PLAYBACK_RATE 2.0
105 #define DEFAULT_FILTER_ACTION FILTER_NONE
106 #define DEFAULT_FILTER_OUTPUT_MODE OUTPUT_SPK
107 #define DEFAULT_PRESET_MODE PRESET_NORMAL
109 enum FilterActionType
113 FILTER_ADVANCED_SETTING
136 PRESET_EXTERNALIZATION,
152 gst_avsysaudiosink_audio_mute_get_type (void)
154 static GType avaudio_mute_type = 0;
155 static const GEnumValue avaudio_mute[] = {
156 {AVSYSAUDIOSINK_AUDIO_UNMUTE, "Unmute", "unmute"},
157 {AVSYSAUDIOSINK_AUDIO_MUTE, "Mute immediately", "mute"},
158 {AVSYSAUDIOSINK_AUDIO_MUTE_WITH_FADEDOWN_EFFECT, "Mute with fadedown effect", "fadedown"},
162 if (!avaudio_mute_type) {
164 g_enum_register_static ("GstAvsysAudioSinkAudioMute", avaudio_mute);
166 return avaudio_mute_type;
170 gst_avsysaudiosink_user_route_get_type (void)
172 static GType user_route_type = 0;
173 static const GEnumValue user_route[] = {
174 {AVSYSAUDIOSINK_USERROUTE_AUTO, "Route automatically", "auto"},
175 {AVSYSAUDIOSINK_USERROUTE_PHONE, "Route to phone only", "phone"},
176 {AVSYSAUDIOSINK_USERROUTE_ALL, "Route to all", "all"},
180 if (!user_route_type) {
182 g_enum_register_static ("GstAvsysAudioSinkUserRoutePolicy",user_route);
184 return user_route_type;
188 gst_avsysaudiosink_audio_route_get_type (void)
190 static GType playback_audio_route_type = 0;
191 static const GEnumValue playback_audio_route[] = {
192 {AVSYSAUDIOSINK_AUDIOROUTE_USE_EXTERNAL_SETTING, "Use external sound path", "external"},
193 {AVSYSAUDIOSINK_AUDIOROUTE_PLAYBACK_NORMAL, "Auto change between speaker & earphone", "normal"},
194 {AVSYSAUDIOSINK_AUDIOROUTE_PLAYBACK_ALERT, "Play via both speaker & earphone", "alert"},
195 {AVSYSAUDIOSINK_AUDIOROUTE_PLAYBACK_HEADSET_ONLY, "Play via earphone only", "headset"},
199 if (!playback_audio_route_type) {
200 playback_audio_route_type =
201 g_enum_register_static ("GstAvsysAudioSinkAudioRoutePolicy", playback_audio_route);
203 return playback_audio_route_type;
207 gst_avsysaudiosink_latency_get_type (void)
209 static GType avsysaudio_latency_type = 0;
210 static const GEnumValue avsysaudio_latency[] = {
211 {AVSYSAUDIOSINK_LATENCY_LOW, "Low latency", "low"},
212 {AVSYSAUDIOSINK_LATENCY_MID, "Mid latency", "mid"},
213 {AVSYSAUDIOSINK_LATENCY_HIGH, "High latency", "high"},
217 if (!avsysaudio_latency_type) {
218 avsysaudio_latency_type =
219 g_enum_register_static ("GstAvsysAudioSinkLatency", avsysaudio_latency);
221 return avsysaudio_latency_type;
224 static void gst_avsysaudiosink_init_interfaces (GType type);
226 //#define GST_BOILERPLATE_FULL(type, type_as_function, parent_type, parent_type_macro, additional_initializations)
228 GST_BOILERPLATE_FULL (GstAvsysAudioSink, gst_avsysaudiosink, GstAudioSink,
229 GST_TYPE_AUDIO_SINK, gst_avsysaudiosink_init_interfaces);
232 static void gst_avsysaudiosink_finalise (GObject * object);
233 static void gst_avsysaudiosink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec);
234 static void gst_avsysaudiosink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec);
236 static GstCaps *gst_avsysaudiosink_getcaps (GstBaseSink * bsink);
239 static gboolean gst_avsysaudiosink_avsys_close(GstAvsysAudioSink *avsys_audio);
240 static gboolean gst_avsysaudiosink_avsys_open(GstAvsysAudioSink *avsys_audio);
242 static gboolean gst_avsysaudiosink_open (GstAudioSink * asink);
243 static gboolean gst_avsysaudiosink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec);
244 static gboolean gst_avsysaudiosink_unprepare (GstAudioSink * asink);
245 static gboolean gst_avsysaudiosink_close (GstAudioSink * asink);
246 static guint gst_avsysaudiosink_write (GstAudioSink * asink, gpointer data, guint length);
247 static guint gst_avsysaudiosink_delay (GstAudioSink * asink);
248 static void gst_avsysaudiosink_reset (GstAudioSink * asink);
249 static gboolean avsysaudiosink_post_message(GstAvsysAudioSink* self,int errorcode);
252 #define AVSYS_AUDIO_FACTORY_ENDIANNESS "LITTLE_ENDIAN"
255 static GstStaticPadTemplate avsysaudiosink_sink_factory =
256 GST_STATIC_PAD_TEMPLATE ("sink",
259 GST_STATIC_CAPS ("audio/x-raw-int, "
260 "endianness = (int) { " AVSYS_AUDIO_FACTORY_ENDIANNESS " }, "
261 "signed = (boolean) { TRUE }, "
264 "rate = (int) 44100, "
265 "channels = (int) [ 1, 6 ]; "
267 "signed = (boolean) { FALSE }, "
270 "rate = (int) 44100, "
271 "channels = (int) [ 1, 6 ] "
275 static inline guint _time_to_sample(GstAvsysAudioSink * asink, GstClockTime diff)
278 result =(GST_TIME_AS_USECONDS(diff) * asink->audio_param.samplerate)/1000000;
284 gst_avsysaudiosink_finalise (GObject * object)
286 GstAvsysAudioSink *sink = NULL;
287 sink = GST_AVSYS_AUDIO_SINK (object);
289 GST_WARNING(">> Start(%d)", sink->audio_handle);
291 GST_AVSYS_AUDIO_SINK_LOCK(sink);
292 gst_avsysaudiosink_avsys_close(sink);
293 GST_AVSYS_AUDIO_SINK_UNLOCK(sink);
294 g_mutex_free (sink->avsys_audio_lock);
295 g_mutex_free (sink->avsys_audio_delay_lock);
296 g_mutex_free (sink->avsys_audio_reset_lock);
298 GST_WARNING("<< End(%d)", sink->audio_handle);
300 G_OBJECT_CLASS (parent_class)->finalize (object);
304 gst_avsysaudiosink_init_interfaces (GType type)
310 gst_avsysaudiosink_base_init (gpointer g_class)
312 GstElementClass *element_class = NULL;
314 element_class = GST_ELEMENT_CLASS (g_class);
315 gst_element_class_set_details (element_class, &gst_avsysaudiosink_details);
316 gst_element_class_add_pad_template (element_class, gst_static_pad_template_get (&avsysaudiosink_sink_factory));
319 static GstStateChangeReturn
320 gst_avsyssudiosink_change_state (GstElement *element, GstStateChange transition);
324 gst_avsysaudiosink_class_init (GstAvsysAudioSinkClass * klass)
326 GObjectClass *gobject_class;
327 GstElementClass *gstelement_class;
328 GstBaseSinkClass *gstbasesink_class;
329 GstBaseAudioSinkClass *gstbaseaudiosink_class;
330 GstAudioSinkClass *gstaudiosink_class;
332 gobject_class = (GObjectClass *) klass;
333 gstelement_class = (GstElementClass *) klass;
334 gstbasesink_class = (GstBaseSinkClass *) klass;
335 gstbaseaudiosink_class = (GstBaseAudioSinkClass *) klass;
336 gstaudiosink_class = (GstAudioSinkClass *) klass;
338 parent_class = g_type_class_peek_parent (klass);
339 gstelement_class->change_state = GST_DEBUG_FUNCPTR(gst_avsyssudiosink_change_state);
341 gobject_class->finalize = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_finalise);
342 gobject_class->get_property = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_get_property);
343 gobject_class->set_property = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_set_property);
345 // gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_getcaps);
347 gstaudiosink_class->open = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_open);
348 gstaudiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_prepare);
349 gstaudiosink_class->unprepare = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_unprepare);
350 gstaudiosink_class->close = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_close);
351 gstaudiosink_class->write = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_write);
352 gstaudiosink_class->delay = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_delay);
353 gstaudiosink_class->reset = GST_DEBUG_FUNCPTR (gst_avsysaudiosink_reset);
355 g_object_class_install_property ( gobject_class, PROP_AUDIO_VOLUME_TYPE,
356 g_param_spec_int ("volumetype", "Avsystem Volume Type",
357 "Select avsystem audio software volume type", 0, G_MAXINT,
358 DEFAULT_VOLUME_TYPE, G_PARAM_READWRITE));
360 g_object_class_install_property ( gobject_class, PROP_AUDIO_PRIORITY,
361 g_param_spec_int ("priority", "Avsystem Sound Priority", "Avsystem sound priority",
362 AVSYS_AUDIO_PRIORITY_NORMAL, AVSYS_AUDIO_PRIORITY_MAX - 1,
363 AVSYS_AUDIO_PRIORITY_NORMAL, G_PARAM_READWRITE));
365 g_object_class_install_property ( gobject_class, PROP_AUDIO_HANDLE,
366 g_param_spec_pointer("audio-handle", "Avsystem handle",
367 "Avsystem audio handle",
370 g_object_class_install_property ( gobject_class, PROP_AUDIO_CALLBACK,
371 g_param_spec_pointer("audio-callback", "Avsystem callback",
372 "Avsystem audio callback",
375 g_object_class_install_property (gobject_class, PROP_AUDIO_FADEUPVOLUME,
376 g_param_spec_boolean ("fadeup", "Avsystem fadeup volume",
377 "Enable avsystem audio fadeup volume when pause to play",
378 DEFAULT_FADEUP_VOLUME, G_PARAM_READWRITE));
380 g_object_class_install_property (gobject_class ,PROP_AUDIO_MUTE,
381 g_param_spec_enum("mute", "Avsystem mute",
382 "Avsystem audio mute",
383 GST_AVSYS_AUDIO_SINK_MUTE, DEFAULT_AUDIO_MUTE,
384 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ));
386 g_object_class_install_property (gobject_class ,PROP_AUDIO_ROUTE_POLICY,
387 g_param_spec_enum("audio-route", "Audio Route Policy",
388 "Audio route policy of system",
389 GST_AVSYS_AUDIO_SINK_AUDIO_ROUTE, DEFAULT_AUDIO_ROUTE,
390 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ));
392 g_object_class_install_property (gobject_class ,PROP_AUDIO_USER_ROUTE,
393 g_param_spec_enum("user-route", "User Route Policy",
395 GST_AVSYS_AUDIO_SINK_USER_ROUTE, DEFAULT_USER_ROUTE,
396 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ));
398 g_object_class_install_property (gobject_class ,PROP_AUDIO_LATENCY,
399 g_param_spec_enum("latency", "Audio Backend Latency",
400 "Audio backend latency",
401 GST_AVSYS_AUDIO_SINK_LATENCY_TYPE, DEFAULT_AUDIO_LATENCY,
402 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS ));
404 g_object_class_install_property (gobject_class, PROP_AUDIO_CLOSE_HANDLE_ON_PREPARE,
405 g_param_spec_boolean ("close-handle-on-prepare", "Close Handle on Prepare",
406 "Close Handle on Prepare",
407 DEFAULT_AUDIO_CLOSE_HANDLE_ON_PREPARE, G_PARAM_READWRITE));
409 g_object_class_install_property (gobject_class, PROP_AUDIO_OPEN_FORCEDLY,
410 g_param_spec_boolean ("open-audio", "Open Audio",
412 DEFAULT_AUDIO_OPEN_FORCEDLY, G_PARAM_READWRITE));
414 #ifdef USE_PA_AUDIO_FILTER
415 g_object_class_install_property(gobject_class, PROP_SPEED,
416 g_param_spec_float("speed", "speed", "speed",
417 AUDIOVSP_MIN_PLAYBACK_RATE,
418 AUDIOVSP_MAX_PLAYBACK_RATE,
419 AUDIOVSP_DEFAULT_PLAYBACK_RATE,
422 g_object_class_install_property(gobject_class, PROP_FILTER_ACTION,
423 g_param_spec_uint("filter-action", "filter action", "(0)none (1)preset (2)advanced setting",
424 0, 2, DEFAULT_FILTER_ACTION, G_PARAM_READWRITE));
426 g_object_class_install_property(gobject_class, PROP_FILTER_OUTPUT_MODE,
427 g_param_spec_uint("filter-output-mode", "filter output mode", "(0)Speaker (1)Ear (2)Others",
428 0, 2, DEFAULT_FILTER_OUTPUT_MODE, G_PARAM_READWRITE));
430 g_object_class_install_property(gobject_class, PROP_PRESET_MODE,
431 g_param_spec_uint("preset-mode", "preset mode", "(0)normal (1)pop (2)rock (3)dance (4)jazz (5)classic (6)vocal (7)bass boost (8)treble boost (9)mtheater (10)externalization (11)cafe (12)concert hall (13)voice (14)movie (15)virt 5.1 (16)hip-hop (17)R&B (18)flat (19)tube",
432 0, 19, DEFAULT_PRESET_MODE, G_PARAM_READWRITE));
434 g_object_class_install_property (gobject_class, PROP_CUSTOM_EQ,
435 g_param_spec_pointer("custom-eq", "custom eq level array",
436 "pointer for array of EQ bands level", G_PARAM_READWRITE));
438 g_object_class_install_property (gobject_class, PROP_CUSTOM_EXT,
439 g_param_spec_pointer("custom-ext", "custom ext level array",
440 "pointer for array of custom effect level", G_PARAM_READWRITE));
445 gst_avsysaudiosink_set_property (GObject * object, guint prop_id,
446 const GValue * value, GParamSpec * pspec)
448 GstAvsysAudioSink *sink = NULL;
450 gboolean nbool = FALSE;
451 #ifdef USE_PA_AUDIO_FILTER
455 sink = GST_AVSYS_AUDIO_SINK (object);
458 case PROP_AUDIO_VOLUME_TYPE:
459 nvalue = g_value_get_int(value);
460 sink->volume_type = nvalue;
461 if (sink->audio_handle != (avsys_handle_t)-1) {
462 avsys_audio_update_volume_config(sink->audio_handle, sink->volume_type);
465 case PROP_AUDIO_PRIORITY:
466 nvalue = g_value_get_int(value);
467 sink->sound_priority = nvalue;
468 GST_INFO_OBJECT(sink, "Set audio priority(%d)", nvalue);
469 if (sink->audio_handle != (avsys_handle_t)-1) {
470 int error = AVSYS_STATE_ERR_UNKNOWN;
471 int handle_route = 0;
472 sink->audio_param.priority = sink->sound_priority;
473 error = avsys_audio_handle_update_priority(sink->audio_handle, nvalue, handle_route, AVSYS_AUDIO_SET_PRIORITY);
474 if (AVSYS_FAIL(error)) {
475 GST_ERROR_OBJECT(sink, "Failed to set audio priority(%d) to audio handle(%d)", nvalue, sink->audio_handle);
480 case PROP_AUDIO_MUTE:
481 nvalue = g_value_get_enum(value);
482 if (sink->audio_handle != (avsys_handle_t)-1) {
483 if (nvalue == AVSYSAUDIOSINK_AUDIO_MUTE_WITH_FADEDOWN_EFFECT) {
484 if(AVSYS_SUCCESS(avsys_audio_set_mute_fadedown(sink->audio_handle)))
487 if(AVSYS_SUCCESS(avsys_audio_set_mute(sink->audio_handle, nvalue)))
494 case PROP_AUDIO_FADEUPVOLUME:
495 nbool = g_value_get_boolean(value);
496 sink->use_fadeup_volume = nbool;
498 case PROP_AUDIO_ROUTE_POLICY:
499 nvalue = g_value_get_enum(value);
500 sink->audio_route_policy = nvalue;
501 switch (sink->audio_route_policy) {
502 case AVSYSAUDIOSINK_AUDIOROUTE_USE_EXTERNAL_SETTING:
503 GST_INFO_OBJECT(sink, "use external audio route setting");
506 g_print("AVSYSAUDIOSINK :: Unknown audio route option %d\n", sink->audio_route_policy);
507 GST_ERROR_OBJECT(sink, "Unknown audio route option %d", sink->audio_route_policy);
511 case PROP_AUDIO_USER_ROUTE:
512 nvalue = g_value_get_enum(value);
513 sink->user_route_policy = nvalue;
515 case PROP_AUDIO_LATENCY:
516 nvalue = g_value_get_enum(value);
517 sink->latency = nvalue;
519 case PROP_AUDIO_HANDLE:
520 sink->cbHandle = g_value_get_pointer(value);
522 case PROP_AUDIO_CALLBACK:
523 sink->audio_stream_cb = g_value_get_pointer(value);
525 case PROP_AUDIO_CLOSE_HANDLE_ON_PREPARE:
526 nbool = g_value_get_boolean(value);
527 sink->close_handle_on_prepare = nbool;
529 case PROP_AUDIO_OPEN_FORCEDLY:
530 nbool = g_value_get_boolean(value);
532 GST_AVSYS_AUDIO_SINK_LOCK(sink);
533 if (gst_avsysaudiosink_avsys_open(sink) == FALSE) {
534 GST_ERROR_OBJECT(sink, "gst_avsysaudiosink_avsys_open() failed");
536 GST_AVSYS_AUDIO_SINK_UNLOCK (sink);
539 #ifdef USE_PA_AUDIO_FILTER
541 GST_INFO_OBJECT(sink, "request setting filter speed:%f (current:%f)",
542 g_value_get_float(value), sink->playback_rate);
543 sink->playback_rate = g_value_get_float(value);
544 if (sink->audio_handle != -1) {
545 avsys_audio_set_vsp_speed(sink->audio_handle, (guint)(sink->playback_rate * 1000));
548 case PROP_FILTER_ACTION:
549 sink->filter_action = g_value_get_uint(value);
550 if (sink->audio_handle != -1) {
551 avsys_audio_set_soundalive_filter_action(sink->audio_handle, sink->filter_action);
552 if (sink->filter_action == FILTER_ADVANCED_SETTING) {
553 avsys_audio_set_soundalive_eq(sink->audio_handle, sink->custom_eq);
554 avsys_audio_set_soundalive_ext(sink->audio_handle, sink->custom_ext);
558 case PROP_FILTER_OUTPUT_MODE:
559 GST_INFO_OBJECT(sink, "request setting filter_output_mode:%d (current:%d)",
560 g_value_get_uint(value), sink->filter_output_mode);
561 sink->filter_output_mode = g_value_get_uint(value);
562 if (sink->audio_handle != -1)
563 avsys_audio_set_soundalive_device(sink->audio_handle, sink->filter_output_mode);
565 case PROP_PRESET_MODE:
566 sink->preset_mode = g_value_get_uint(value);
567 if (sink->audio_handle != -1)
568 avsys_audio_set_soundalive_preset_mode(sink->audio_handle, sink->preset_mode);
571 pointer = g_value_get_pointer(value);
573 gint *custom_eq = (gint *)pointer;
574 GST_INFO_OBJECT(sink, "request setting custom_eq:%d,%d,%d,%d,%d,%d,%d (current:%d,%d,%d,%d,%d,%d,%d)",
575 custom_eq[0], custom_eq[1], custom_eq[2], custom_eq[3], custom_eq[4], custom_eq[5], custom_eq[6],
576 sink->custom_eq[0], sink->custom_eq[1], sink->custom_eq[2], sink->custom_eq[3],
577 sink->custom_eq[4], sink->custom_eq[5], sink->custom_eq[6]);
578 memcpy(sink->custom_eq, pointer, sizeof(gint) * CUSTOM_EQ_BAND_MAX);
579 if ((sink->audio_handle != -1) && (sink->filter_action == FILTER_ADVANCED_SETTING)) {
580 avsys_audio_set_soundalive_eq(sink->audio_handle, sink->custom_eq);
584 case PROP_CUSTOM_EXT:
585 pointer = g_value_get_pointer(value);
587 gint *custom_ext = (gint *)pointer;
588 GST_INFO_OBJECT(sink, "request setting custom_ext:%d,%d,%d,%d,%d (current:%d,%d,%d,%d,%d)",
589 custom_ext[CUSTOM_EXT_3D_LEVEL], custom_ext[CUSTOM_EXT_BASS_LEVEL],
590 custom_ext[CUSTOM_EXT_CONCERT_HALL_LEVEL], custom_ext[CUSTOM_EXT_CONCERT_HALL_VOLUME],
591 custom_ext[CUSTOM_EXT_CLARITY_LEVEL],
592 sink->custom_ext[CUSTOM_EXT_3D_LEVEL], sink->custom_ext[CUSTOM_EXT_BASS_LEVEL],
593 sink->custom_ext[CUSTOM_EXT_CONCERT_HALL_LEVEL], sink->custom_ext[CUSTOM_EXT_CONCERT_HALL_VOLUME],
594 sink->custom_ext[CUSTOM_EXT_CLARITY_LEVEL]);
595 memcpy(sink->custom_ext, pointer, sizeof(gint) * CUSTOM_EXT_PARAM_MAX);
596 if ((sink->audio_handle != -1) && (sink->filter_action == FILTER_ADVANCED_SETTING)) {
597 avsys_audio_set_soundalive_ext(sink->audio_handle, sink->custom_ext);
603 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
609 gst_avsysaudiosink_get_property (GObject * object, guint prop_id,
610 GValue * value, GParamSpec * pspec)
612 GstAvsysAudioSink *sink = NULL;
614 sink = GST_AVSYS_AUDIO_SINK (object);
617 case PROP_AUDIO_VOLUME_TYPE:
618 g_value_set_int(value, sink->volume_type);
620 case PROP_AUDIO_PRIORITY:
621 g_value_set_int(value, sink->sound_priority);
623 case PROP_AUDIO_MUTE:
624 g_value_set_enum(value, sink->mute);
626 case PROP_AUDIO_FADEUPVOLUME:
627 g_value_set_boolean(value, sink->use_fadeup_volume);
629 case PROP_AUDIO_ROUTE_POLICY:
630 g_value_set_enum(value, sink->audio_route_policy);
632 case PROP_AUDIO_USER_ROUTE:
633 g_value_set_enum(value, sink->user_route_policy);
635 case PROP_AUDIO_LATENCY:
636 g_value_set_enum(value, sink->latency);
638 case PROP_AUDIO_HANDLE:
639 g_value_set_pointer(value, sink->cbHandle);
641 case PROP_AUDIO_CALLBACK:
642 g_value_set_pointer(value, sink->audio_stream_cb);
644 case PROP_AUDIO_CLOSE_HANDLE_ON_PREPARE:
645 g_value_set_boolean(value, sink->close_handle_on_prepare);
647 case PROP_AUDIO_OPEN_FORCEDLY:
649 #ifdef USE_PA_AUDIO_FILTER
651 g_value_set_float(value, sink->playback_rate);
653 case PROP_FILTER_ACTION:
654 g_value_set_uint(value, sink->filter_action);
656 case PROP_FILTER_OUTPUT_MODE:
657 g_value_set_uint(value, sink->filter_output_mode);
659 case PROP_PRESET_MODE:
660 g_value_set_uint(value, sink->preset_mode);
663 g_value_set_pointer(value, sink->custom_eq);
665 case PROP_CUSTOM_EXT:
666 g_value_set_pointer(value, sink->custom_ext);
670 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
676 gst_avsysaudiosink_init (GstAvsysAudioSink * avsysaudiosink, GstAvsysAudioSinkClass * g_class)
678 GST_DEBUG_OBJECT (avsysaudiosink, "initializing avsysaudiosink");
680 avsysaudiosink->audio_handle = (avsys_handle_t)-1;
681 avsysaudiosink->cached_caps = NULL;
682 avsysaudiosink->avsys_audio_lock = g_mutex_new ();
683 avsysaudiosink->avsys_audio_delay_lock = g_mutex_new ();
684 avsysaudiosink->avsys_audio_reset_lock = g_mutex_new ();
685 avsysaudiosink->volume_type = DEFAULT_VOLUME_TYPE;
686 avsysaudiosink->sound_priority = AVSYS_AUDIO_PRIORITY_NORMAL;
687 avsysaudiosink->mute = DEFAULT_AUDIO_MUTE;
688 avsysaudiosink->use_fadeup_volume = DEFAULT_FADEUP_VOLUME;
689 avsysaudiosink->latency = DEFAULT_AUDIO_LATENCY;
690 avsysaudiosink->audio_route_policy = DEFAULT_AUDIO_ROUTE;
691 avsysaudiosink->bytes_per_sample = 1;
692 avsysaudiosink->close_handle_on_prepare = DEFAULT_AUDIO_CLOSE_HANDLE_ON_PREPARE;
693 avsysaudiosink->first_write = FALSE;
694 #if defined (LPCM_DUMP_SUPPORT)
695 avsysaudiosink->dumpFp = NULL;
697 avsysaudiosink->audio_param.format = AVSYS_AUDIO_FORMAT_UNKNOWN;
698 #ifdef USE_PA_AUDIO_FILTER
699 avsysaudiosink->filter_action = DEFAULT_FILTER_ACTION;
700 avsysaudiosink->filter_output_mode = DEFAULT_FILTER_OUTPUT_MODE;
701 avsysaudiosink->preset_mode = DEFAULT_PRESET_MODE;
702 memset(avsysaudiosink->custom_eq, 0x00, sizeof(gint) * CUSTOM_EQ_BAND_MAX);
703 memset(avsysaudiosink->custom_ext, 0x00, sizeof(gint) * CUSTOM_EXT_PARAM_MAX);
704 avsysaudiosink->playback_rate = AUDIOVSP_DEFAULT_PLAYBACK_RATE;
709 gst_avsysaudiosink_getcaps (GstBaseSink * bsink)
711 GstElementClass *element_class = NULL;
712 GstPadTemplate *pad_template = NULL;
713 GstAvsysAudioSink *sink = GST_AVSYS_AUDIO_SINK (bsink);
718 sink = GST_AVSYS_AUDIO_SINK (bsink);
719 if (sink->audio_handle == -1)
721 GST_DEBUG_OBJECT (sink, "avsystem audio not open, using template caps");
722 return NULL; /* base class will get template caps for us */
725 if (sink->cached_caps)
727 GST_LOG_OBJECT (sink, "Returning cached caps");
728 return gst_caps_ref (sink->cached_caps);
731 element_class = GST_ELEMENT_GET_CLASS (sink);
732 pad_template = gst_element_class_get_pad_template (element_class, "sink");
733 g_return_val_if_fail (pad_template != NULL, NULL);
735 // todo : get supported format.
736 //caps = gst_avsysaudio_probe_supported_formats (GST_OBJECT (sink), sink->,
737 //gst_pad_template_get_caps (pad_template));
740 //sink->cached_caps = gst_caps_ref (caps);
743 GST_INFO_OBJECT (sink, "returning caps %" GST_PTR_FORMAT, caps);
749 static avsys_audio_channel_pos_t *
750 gst_avsysaudiosink_gst_to_channel_map (avsys_audio_channel_pos_t * map,
751 const GstRingBufferSpec * spec)
754 GstAudioChannelPosition *pos;
756 for (i = 0; i < AVSYS_CHANNEL_MAX; i++) {
757 map[i] = AVSYS_AUDIO_CHANNEL_POSITION_INVALID;
760 if (!(pos = gst_audio_get_channel_positions (gst_caps_get_structure (spec->caps, 0)))) {
764 for (i = 0; i < spec->channels; i++) {
765 if (pos[i] == GST_AUDIO_CHANNEL_POSITION_NONE) {
768 } else if (pos[i] < GST_AUDIO_CHANNEL_POSITION_NUM) {
769 map[i] = gst_pos_to_avsys[pos[i]];
771 map[i] = AVSYS_AUDIO_CHANNEL_POSITION_INVALID;
781 avsysaudiosink_parse_spec (GstAvsysAudioSink * avsys_audio, GstRingBufferSpec * spec)
784 if (spec->type != GST_BUFTYPE_LINEAR ||
785 spec->channels > 6 || spec->channels < 1 ||
786 !(spec->format == GST_S8 || spec->format == GST_S16_LE) )
789 switch (spec->format) {
791 avsys_audio->audio_param.format = AVSYS_AUDIO_FORMAT_8BIT;
792 avsys_audio->bytes_per_sample = 1;
795 avsys_audio->audio_param.format = AVSYS_AUDIO_FORMAT_16BIT;
796 avsys_audio->bytes_per_sample = 2;
802 /// set audio parameter for avsys audio open
803 switch (avsys_audio->latency) {
804 case AVSYSAUDIOSINK_LATENCY_LOW:
805 avsys_audio->audio_param.mode = AVSYS_AUDIO_MODE_OUTPUT_VIDEO;
807 case AVSYSAUDIOSINK_LATENCY_MID:
808 avsys_audio->audio_param.mode = AVSYS_AUDIO_MODE_OUTPUT;
810 case AVSYSAUDIOSINK_LATENCY_HIGH:
811 avsys_audio->audio_param.mode = AVSYS_AUDIO_MODE_OUTPUT_CLOCK;
815 avsys_audio->audio_param.priority = 0;
816 avsys_audio->audio_param.samplerate = spec->rate;
817 avsys_audio->audio_param.channels = spec->channels;
818 avsys_audio->bytes_per_sample *= spec->channels;
819 gst_avsysaudiosink_gst_to_channel_map (avsys_audio->audio_param.map, spec);
821 /* set software volume table type */
822 avsys_audio->audio_param.vol_type = avsys_audio->volume_type;
823 avsys_audio->audio_param.priority = avsys_audio->sound_priority;
824 avsys_audio->audio_param.handle_route = avsys_audio->user_route_policy;
830 gst_avsysaudiosink_open (GstAudioSink * asink)
836 gst_avsysaudiosink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec)
838 guint p_time = 0, b_time = 0;
839 gboolean ret = FALSE;
840 gboolean close_on_exit = FALSE;
841 GstAvsysAudioSink *avsys_audio = GST_AVSYS_AUDIO_SINK (asink);
843 GST_WARNING(">> Start(%d)", avsys_audio->audio_handle);
845 GST_AVSYS_AUDIO_SINK_LOCK(avsys_audio);
847 // set avsys audio param
848 if (!avsysaudiosink_parse_spec (avsys_audio, spec)) {
849 GST_ELEMENT_ERROR (avsys_audio, RESOURCE, SETTINGS, (NULL),
850 ("Setting of swparams failed: " ));
855 if (gst_avsysaudiosink_avsys_open(avsys_audio) == FALSE) {
856 GST_ERROR_OBJECT(avsys_audio, "gst_avsysaudiosink_avsys_open() failed");
860 /* Ring buffer size */
861 if (AVSYS_STATE_SUCCESS ==
862 avsys_audio_get_period_buffer_time(avsys_audio->audio_handle, &p_time, &b_time)) {
863 if(p_time == 0 || b_time == 0) {
864 GST_WARNING_OBJECT(avsys_audio, "");
865 close_on_exit = TRUE;
868 spec->latency_time = (guint64)p_time;
869 spec->buffer_time = (guint64)b_time;
871 GST_WARNING_OBJECT(avsys_audio, "");
872 close_on_exit = TRUE;
875 spec->segsize = avsys_audio->avsys_size; /* '/16' see avsys_audio_open */
876 spec->segtotal = (b_time / p_time) + (((b_time % p_time)/p_time > 0.5) ? 1: 0);
878 GST_WARNING ("latency time %u, buffer time %u, seg total %u\n",
879 (unsigned int)(spec->latency_time/1000), (unsigned int)(spec->buffer_time/1000), spec->segtotal);
881 /* Close if needed */
882 close_on_exit = avsys_audio->close_handle_on_prepare;
888 if (gst_avsysaudiosink_avsys_close(avsys_audio) == FALSE) {
889 GST_ERROR_OBJECT(avsys_audio, "gst_avsysaudiosink_avsys_close() failed");
893 GST_AVSYS_AUDIO_SINK_UNLOCK (avsys_audio);
894 GST_WARNING("<< End(%d), ret=%d", avsys_audio->audio_handle, ret);
898 avsysaudiosink_post_message(avsys_audio, GST_RESOURCE_ERROR_OPEN_READ);
899 GST_AVSYS_AUDIO_SINK_UNLOCK (avsys_audio);
900 GST_WARNING("<< End(%d), ret=%d", avsys_audio->audio_handle, ret);
905 gst_avsysaudiosink_unprepare (GstAudioSink * asink)
908 GstAvsysAudioSink *avsys_audio = GST_AVSYS_AUDIO_SINK (asink);
910 GST_WARNING(">> Start(%d)", avsys_audio->audio_handle);
911 GST_AVSYS_AUDIO_SINK_LOCK(avsys_audio);
912 if(!gst_avsysaudiosink_avsys_close(avsys_audio)) {
913 GST_ERROR_OBJECT(avsys_audio, "gst_avsysaudiosink_avsys_close() failed");
916 GST_AVSYS_AUDIO_SINK_UNLOCK(avsys_audio);
917 GST_WARNING("<< End(%d), ret=%d", avsys_audio->audio_handle, ret);
923 gst_avsysaudiosink_close (GstAudioSink * asink)
925 GstAvsysAudioSink *avsys_audio = GST_AVSYS_AUDIO_SINK (asink);
926 gst_caps_replace (&avsys_audio->cached_caps, NULL);
933 * Underrun and suspend recovery
937 gst_avsysaudiosink_write (GstAudioSink * asink, gpointer data, guint length)
939 GstAvsysAudioSink *avsys_audio = GST_AVSYS_AUDIO_SINK (asink);
943 GST_AVSYS_AUDIO_SINK_LOCK (asink);
945 if (avsys_audio->audio_stream_cb == NULL) {
946 #if defined (LPCM_DUMP_SUPPORT)
947 fwrite(data, 1, write_len, avsys_audio->dumpFp); //This is for original data (no volume convert)
949 write_len = avsys_audio_write(avsys_audio->audio_handle, data, length);
950 if(write_len == length) {
953 if(AVSYS_FAIL(write_len)) {
954 GST_ERROR_OBJECT(avsys_audio, "avsys_audio_write() failed with %d\n", write_len);
956 ret = length; /* skip one period */
959 if(!avsys_audio->audio_stream_cb(data, length, avsys_audio->cbHandle)) {
960 GST_ERROR_OBJECT(avsys_audio,"auido stream callback failed\n");
965 if (avsys_audio->first_write) {
966 GST_WARNING("First write (%d/%d)", ret, length);
967 avsys_audio->first_write = FALSE;
970 GST_AVSYS_AUDIO_SINK_UNLOCK (asink);
976 gst_avsysaudiosink_delay (GstAudioSink * asink)
978 GstAvsysAudioSink *avsys_audio = NULL;
982 avsys_audio = GST_AVSYS_AUDIO_SINK (asink);
983 GST_AVSYS_AUDIO_SINK_DELAY_LOCK (asink);
984 if ((int)avsys_audio->audio_handle != -1) {
985 if (AVSYS_STATE_SUCCESS == avsys_audio_delay(avsys_audio->audio_handle, &delay)) {
989 GST_AVSYS_AUDIO_SINK_DELAY_UNLOCK (asink);
994 gst_avsysaudiosink_reset (GstAudioSink * asink)
996 int avsys_result = AVSYS_STATE_SUCCESS;
997 GstAvsysAudioSink *avsys_audio = GST_AVSYS_AUDIO_SINK (asink);
999 GST_WARNING(">> Start(%d)", avsys_audio->audio_handle);
1000 GST_AVSYS_AUDIO_SINK_LOCK (asink);
1002 #if defined(__REPLACE_RESET_WITH_CLOSE_AND_REOPEN__)
1003 if(!gst_avsysaudiosink_avsys_close(avsys_audio)) {
1004 GST_ERROR_OBJECT(avsys_audio, "gst_avsysaudiosink_avsys_close() failed");
1007 if(AVSYS_STATE_SUCCESS != avsys_audio_reset(avsys_audio->audio_handle)) {
1008 GST_ERROR_OBJECT (avsys_audio, "avsys-reset: internal error: ");
1012 GST_AVSYS_AUDIO_SINK_UNLOCK (asink);
1013 GST_WARNING("<< End(%d)", avsys_audio->audio_handle);
1020 gst_avsysaudiosink_avsys_open(GstAvsysAudioSink *avsys_audio)
1022 gboolean ret = TRUE;
1024 int available = FALSE;
1026 if (avsys_audio->audio_handle == (avsys_handle_t)-1) {
1027 GST_LOG_OBJECT (avsys_audio, "avsys_audio_open() with user policy [%d] ", avsys_audio->user_route_policy);
1029 /* workaround for PA audio filter */
1030 if (avsys_audio->latency == AVSYSAUDIOSINK_LATENCY_HIGH) {
1031 avsys_audio_is_available_high_latency(&available);
1032 if (available == FALSE) {
1033 avsys_audio->latency = AVSYSAUDIOSINK_LATENCY_MID;
1034 avsys_audio->audio_param.mode = AVSYS_AUDIO_MODE_OUTPUT;
1038 avsys_result = avsys_audio_open(&avsys_audio->audio_param, &avsys_audio->audio_handle, &avsys_audio->avsys_size);
1039 if (avsys_result != AVSYS_STATE_SUCCESS) {
1040 GST_ERROR_OBJECT(avsys_audio, "avsys_audio_open() failed with 0x%x", avsys_result);
1041 avsysaudiosink_post_message(avsys_audio, GST_RESOURCE_ERROR_OPEN_READ);
1044 GST_WARNING("avsys_audio_open() success [%d]", avsys_audio->audio_handle);
1045 avsys_audio->first_write = TRUE;
1047 #ifdef USE_PA_AUDIO_FILTER
1048 avsys_audio_set_vsp_speed(avsys_audio->audio_handle, (guint)(avsys_audio->playback_rate * 1000));
1051 // check audio handle was already muted.
1052 if(avsys_audio->mute == TRUE) {
1053 if(AVSYS_SUCCESS(avsys_audio_set_mute(avsys_audio->audio_handle, AVSYS_AUDIO_MUTE)))
1054 GST_DEBUG("avsys_audio_set_mute() success. mute handle open success.\n");
1056 GST_DEBUG("avsys_audio_set mute() fail.\n");
1060 GST_WARNING("audio handle has already opened");
1063 #if defined (LPCM_DUMP_SUPPORT)
1064 if (avsys_audio->dumpFp == NULL) {
1065 avsys_audio->dumpFp = fopen("/root/dump.lpcm","w");
1072 gst_avsysaudiosink_avsys_close(GstAvsysAudioSink *avsys_audio)
1074 gboolean ret = TRUE;
1075 int avsys_result = AVSYS_STATE_SUCCESS;
1077 if (avsys_audio->audio_handle != (avsys_handle_t)-1 ) {
1078 avsys_result = avsys_audio_close(avsys_audio->audio_handle);
1079 if (AVSYS_FAIL(avsys_result)) {
1080 GST_ERROR_OBJECT(avsys_audio, "avsys_audio_close() failed with 0x%x", avsys_result);
1083 GST_WARNING("avsys_audio_close(%d) success", avsys_audio->audio_handle);
1084 avsys_audio->audio_handle = (avsys_handle_t) -1;
1087 GST_INFO("audio handle has already closed");
1090 #if defined (LPCM_DUMP_SUPPORT)
1091 if(avsys_audio->dumpFp != NULL)
1093 fclose(avsys_audio->dumpFp);
1094 avsys_audio->dumpFp = NULL;
1100 static GstStateChangeReturn
1101 gst_avsyssudiosink_change_state (GstElement *element, GstStateChange transition)
1103 GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
1104 GstAvsysAudioSink *avsys_audio = GST_AVSYS_AUDIO_SINK (element);
1106 int avsys_result = AVSYS_STATE_SUCCESS;
1108 switch (transition) {
1109 case GST_STATE_CHANGE_NULL_TO_READY:
1111 case GST_STATE_CHANGE_READY_TO_PAUSED:
1113 case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
1114 #if defined(_ALSA_DAPM_)
1115 switch(avsys_audio->audio_route_policy) {
1116 case AVSYSAUDIOSINK_AUDIOROUTE_USE_EXTERNAL_SETTING:
1117 GST_INFO_OBJECT(avsys_audio, "audio route uses external setting");
1120 GST_ERROR_OBJECT(avsys_audio, "Unknown audio route option %d\n", avsys_audio->audio_route_policy);
1124 GST_AVSYS_AUDIO_SINK_LOCK (avsys_audio);
1125 #if defined(__REPLACE_RESET_WITH_CLOSE_AND_REOPEN__)
1126 if (avsys_audio->audio_handle == (avsys_handle_t)-1 &&
1127 avsys_audio->audio_param.format != AVSYS_AUDIO_FORMAT_UNKNOWN) {
1128 if (gst_avsysaudiosink_avsys_open(avsys_audio) == FALSE) {
1129 GST_ERROR_OBJECT(avsys_audio, "gst_avsysaudiosink_avsys_open() failed");
1130 GST_AVSYS_AUDIO_SINK_UNLOCK (avsys_audio);
1131 return GST_STATE_CHANGE_FAILURE;
1135 if (avsys_audio->use_fadeup_volume) {
1136 GST_INFO_OBJECT(avsys_audio, "Set fadeup volume");
1137 avsys_audio_set_volume_fadeup(avsys_audio->audio_handle);
1139 GST_AVSYS_AUDIO_SINK_UNLOCK (avsys_audio);
1142 if(AVSYS_STATE_SUCCESS != avsys_audio_set_mute(avsys_audio->audio_handle, CONVERT_MUTE_VALUE(avsys_audio->mute)))
1144 GST_ERROR_OBJECT(avsys_audio, "Set mute failed %d", CONVERT_MUTE_VALUE(avsys_audio->mute));
1151 ret = GST_ELEMENT_CLASS(parent_class)->change_state (element, transition);
1152 if (ret == GST_STATE_CHANGE_FAILURE) {
1155 switch (transition) {
1156 case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
1158 case GST_STATE_CHANGE_PAUSED_TO_READY:
1160 case GST_STATE_CHANGE_READY_TO_NULL:
1170 avsysaudiosink_post_message(GstAvsysAudioSink* self,int errorcode)
1172 GST_DEBUG("avsysaudiosink_post_message\n");
1173 gboolean ret = TRUE;
1174 GstMessage *Msg = NULL;
1176 gboolean status = FALSE;
1177 GError *error = NULL;
1181 error_code = errorcode;
1183 error_code = GST_STREAM_ERROR_TYPE_NOT_FOUND; */
1184 error_code = errorcode;
1185 domain = gst_resource_error_quark();
1186 error = g_error_new (domain, error_code, "AVSYSAUDIOSINK_RESOURCE_ERROR");
1187 Msg = gst_message_new_error(GST_ELEMENT(self), error, "AVSYSAUDIOSINK_ERROR");
1188 status = gst_element_post_message (GST_ELEMENT(self), Msg);
1189 if (status == FALSE)
1191 GST_ERROR("Error in posting message on the bus ...\n");