3 #include <glib/gi18n-lib.h>
4 #include <libchimara/glk.h>
10 #include "chimara-glk-private.h"
16 #define VOLUME_TIMER_RESOLUTION 1.0 /* In milliseconds */
18 extern GPrivate *glk_data_key;
20 #ifdef GSTREAMER_SOUND
21 /* Stop any currently playing sound on this channel, and remove any
22 format-specific GStreamer elements from the channel. */
24 clean_up_after_playing_sound(schanid_t chan)
26 if(!gst_element_set_state(chan->pipeline, GST_STATE_NULL))
27 WARNING_S(_("Could not set GstElement state to"), "NULL");
30 gst_bin_remove(GST_BIN(chan->pipeline), chan->demux);
35 gst_bin_remove(GST_BIN(chan->pipeline), chan->decode);
40 /* This signal is thrown whenever the GStreamer pipeline generates a message.
41 Most messages are harmless. */
43 on_pipeline_message(GstBus *bus, GstMessage *message, schanid_t s)
45 /* g_printerr("Got %s message\n", GST_MESSAGE_TYPE_NAME(message)); */
50 switch(GST_MESSAGE_TYPE(message)) {
51 case GST_MESSAGE_ERROR:
53 gst_message_parse_error(message, &err, &debug_message);
54 IO_WARNING(_("GStreamer error"), err->message, debug_message);
56 g_free(debug_message);
57 clean_up_after_playing_sound(s);
60 case GST_MESSAGE_WARNING:
62 gst_message_parse_warning(message, &err, &debug_message);
63 IO_WARNING(_("GStreamer warning"), err->message, debug_message);
65 g_free(debug_message);
68 case GST_MESSAGE_INFO:
70 gst_message_parse_info(message, &err, &debug_message);
71 g_message("GStreamer info \"%s\": %s", err->message, debug_message);
73 g_free(debug_message);
76 case GST_MESSAGE_EOS: /* End of stream */
77 /* Decrease repeats if not set to forever */
78 if(s->repeats != (glui32)-1)
81 if(!gst_element_seek_simple(s->pipeline, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT, 0)) {
82 WARNING(_("Could not execute GStreamer seek"));
83 clean_up_after_playing_sound(s);
86 clean_up_after_playing_sound(s);
87 /* Sound ended normally, send a notification if requested */
89 event_throw(s->glk, evtype_SoundNotify, NULL, s->resource, s->notify);
93 /* unhandled message */
98 /* This signal is thrown when the OGG demuxer element has decided what kind of
99 outputs it will output. We connect the decoder element dynamically. */
101 on_ogg_demuxer_pad_added(GstElement *demux, GstPad *pad, schanid_t s)
105 /* We can now link this pad with the vorbis-decoder sink pad */
106 sinkpad = gst_element_get_static_pad(s->decode, "sink");
107 if(gst_pad_link(pad, sinkpad) != GST_PAD_LINK_OK)
108 WARNING(_("Could not link OGG demuxer with Vorbis decoder"));
109 gst_object_unref(sinkpad);
112 /* This signal is thrown when the typefinder element has found the type of its
113 input. Now that we know what kind of input stream we have, we can connect the
114 proper demuxer/decoder elements. */
116 on_type_found(GstElement *typefind, guint probability, GstCaps *caps, schanid_t s)
118 gchar *type = gst_caps_to_string(caps);
119 if(strcmp(type, "application/ogg") == 0) {
120 s->demux = gst_element_factory_make("oggdemux", NULL);
121 s->decode = gst_element_factory_make("vorbisdec", NULL);
122 if(!s->demux || !s->decode) {
123 WARNING(_("Could not create one or more GStreamer elements"));
126 gst_bin_add_many(GST_BIN(s->pipeline), s->demux, s->decode, NULL);
127 if(!gst_element_link(s->typefind, s->demux) || !gst_element_link(s->decode, s->convert)) {
128 WARNING(_("Could not link GStreamer elements"));
131 /* We link the demuxer and decoder together dynamically, since the
132 demuxer doesn't know what source pads it will have until it starts
133 demuxing the stream */
134 g_signal_connect(s->demux, "pad-added", G_CALLBACK(on_ogg_demuxer_pad_added), s);
135 } else if(strcmp(type, "audio/x-aiff") == 0) {
136 s->decode = gst_element_factory_make("aiffparse", NULL);
138 WARNING(_("Could not create 'aiffparse' GStreamer element"));
141 gst_bin_add(GST_BIN(s->pipeline), s->decode);
142 if(!gst_element_link_many(s->typefind, s->decode, s->convert, NULL)) {
143 WARNING(_("Could not link GStreamer elements"));
146 } else if(strcmp(type, "audio/x-mod") == 0) {
147 s->decode = gst_element_factory_make("modplug", NULL);
149 WARNING(_("Could not create 'modplug' GStreamer element"));
152 gst_bin_add(GST_BIN(s->pipeline), s->decode);
153 if(!gst_element_link_many(s->typefind, s->decode, s->convert, NULL)) {
154 WARNING(_("Could not link GStreamer elements"));
158 WARNING_S(_("Unexpected audio type in blorb"), type);
164 #endif /* GSTREAMER_SOUND */
167 * glk_schannel_create:
168 * @rock: The rock value to give the new sound channel.
170 * This creates a sound channel, about as you'd expect.
172 * Remember that it is possible that the library will be unable to create a new
173 * channel, in which case glk_schannel_create() will return %NULL.
175 * When you create a channel using glk_schannel_create(), it has full volume,
176 * represented by the value 0x10000. Half volume would be 0x8000, three-quarters
177 * volume would be 0xC000, and so on. A volume of zero represents silence.
179 * You can overdrive the volume of a channel by setting a volume greater than
180 * 0x10000. However, this is not recommended; the library may be unable to
181 * increase the volume past full, or the sound may become distorted. You should
182 * always create sound resources with the maximum volume you will need, and then
183 * reduce the volume when appropriate using the channel-volume calls.
186 * Mathematically, these volume changes should be taken as linear
187 * multiplication of a waveform represented as linear samples. As I
188 * understand it, linear PCM encodes the sound pressure, and therefore a
189 * volume of 0x8000 should represent a 6 dB drop.
192 * Returns: A new sound channel, or %NULL.
195 glk_schannel_create(glui32 rock)
197 return glk_schannel_create_ext(rock, 0x10000);
201 * glk_schannel_create_ext:
202 * @rock: The rock value to give the new sound channel.
203 * @volume: Integer representing the volume; 0x10000 is 100%.
205 * The glk_schannel_create_ext() call lets you create a channel with the volume
206 * already set at a given level.
208 * Not all libraries support glk_schannel_create_ext(). You should test the
209 * %gestalt_Sound2 selector before you rely on it; see <link
210 * linkend="chimara-Testing-for-Sound-Capabilities">Testing for Sound
211 * Capabilities</link>.
213 * Returns: A new sound channel, or %NULL.
216 glk_schannel_create_ext(glui32 rock, glui32 volume)
218 #ifdef GSTREAMER_SOUND
219 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
221 schanid_t s = g_new0(struct glk_schannel_struct, 1);
222 s->magic = MAGIC_SCHANNEL;
224 if(glk_data->register_obj)
225 s->disprock = (*glk_data->register_obj)(s, gidisp_Class_Schannel);
227 /* Add it to the global sound channel list */
228 glk_data->schannel_list = g_list_prepend(glk_data->schannel_list, s);
229 s->schannel_list = glk_data->schannel_list;
231 /* Add a pointer to the ChimaraGlk widget, for convenience */
232 s->glk = glk_data->self;
234 /* Create a GStreamer pipeline for the sound channel */
235 gchar *pipeline_name = g_strdup_printf("pipeline-%p", s);
236 s->pipeline = gst_pipeline_new(pipeline_name);
237 g_free(pipeline_name);
239 /* Watch for messages from the pipeline */
240 GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(s->pipeline));
241 gst_bus_add_signal_watch(bus);
242 g_signal_connect(bus, "message", G_CALLBACK(on_pipeline_message), s);
243 gst_object_unref(bus);
245 /* Create GStreamer elements to put in the pipeline */
246 s->source = gst_element_factory_make("giostreamsrc", NULL);
247 s->typefind = gst_element_factory_make("typefind", NULL);
248 s->convert = gst_element_factory_make("audioconvert", NULL);
249 s->filter = gst_element_factory_make("volume", NULL);
250 s->sink = gst_element_factory_make("autoaudiosink", NULL);
251 if(!s->source || !s->typefind || !s->convert || !s->filter || !s->sink) {
252 WARNING(_("Could not create one or more GStreamer elements"));
256 /* Set the initial volume */
257 glk_schannel_set_volume(s, volume);
259 /* Put the elements in the pipeline and link as many together as we can
260 without knowing the type of the audio stream */
261 gst_bin_add_many(GST_BIN(s->pipeline), s->source, s->typefind, s->convert, s->filter, s->sink, NULL);
262 /* Link elements: Source -> typefinder -> ??? -> Converter -> Volume filter -> Sink */
263 if(!gst_element_link(s->source, s->typefind) || !gst_element_link_many(s->convert, s->filter, s->sink, NULL)) {
264 WARNING(_("Could not link GStreamer elements"));
267 g_signal_connect(s->typefind, "have-type", G_CALLBACK(on_type_found), s);
272 glk_schannel_destroy(s);
276 #endif /* GSTREAMER_SOUND */
280 * glk_schannel_destroy:
281 * @chan: The sound channel to destroy.
283 * Destroys the channel. If the channel is playing a sound, the sound stops
284 * immediately (with no notification event).
287 glk_schannel_destroy(schanid_t chan)
289 VALID_SCHANNEL(chan, return);
291 #ifdef GSTREAMER_SOUND
292 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
294 if(!gst_element_set_state(chan->pipeline, GST_STATE_NULL))
295 WARNING_S(_("Could not set GstElement state to"), "NULL");
297 glk_data->schannel_list = g_list_delete_link(glk_data->schannel_list, chan->schannel_list);
299 if(glk_data->unregister_obj)
301 (*glk_data->unregister_obj)(chan, gidisp_Class_Schannel, chan->disprock);
302 chan->disprock.ptr = NULL;
305 /* This also frees all the objects inside the pipeline */
307 gst_object_unref(chan->pipeline);
309 chan->magic = MAGIC_FREE;
315 * glk_schannel_iterate:
316 * @chan: A sound channel, or %NULL.
317 * @rockptr: Return location for the next sound channel's rock, or %NULL.
319 * This function can be used to iterate through the list of all open channels.
320 * See <link linkend="chimara-Iterating-Through-Opaque-Objects">Iterating
321 * Through Opaque Objects</link>.
323 * As that section describes, the order in which channels are returned is
326 * Returns: the next sound channel, or %NULL if there are no more.
329 glk_schannel_iterate(schanid_t chan, glui32 *rockptr)
331 VALID_SCHANNEL_OR_NULL(chan, return NULL);
333 #ifdef GSTREAMER_SOUND
334 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
338 retnode = glk_data->schannel_list;
340 retnode = chan->schannel_list->next;
341 schanid_t retval = retnode? (schanid_t)retnode->data : NULL;
343 /* Store the sound channel's rock in rockptr */
344 if(retval && rockptr)
345 *rockptr = glk_schannel_get_rock(retval);
350 #endif /* GSTREAMER_SOUND */
354 * glk_schannel_get_rock:
355 * @chan: A sound channel.
357 * Retrieves the channel's rock value. See <link
358 * linkend="chimara-Rocks">Rocks</link>.
360 * Returns: A rock value.
363 glk_schannel_get_rock(schanid_t chan)
365 VALID_SCHANNEL(chan, return 0);
371 * @chan: Channel to play the sound in.
372 * @snd: Resource number of the sound to play.
374 * Begins playing the given sound on the channel. If the channel was already
375 * playing a sound (even the same one), the old sound is stopped (with no
376 * notification event.
378 * This returns 1 if the sound actually started playing, and 0 if there was any
381 * The most obvious problem is if there is no sound resource with the given
382 * identifier. But other problems can occur. For example, the MOD-playing
383 * facility in a library might be unable to handle two MODs at the same time,
384 * in which case playing a MOD resource would fail if one was already playing.
387 * Returns: 1 on success, 0 on failure.
390 glk_schannel_play(schanid_t chan, glui32 snd)
392 return glk_schannel_play_ext(chan, snd, 1, 0);
396 * glk_schannel_play_ext:
397 * @chan: Channel to play the sound in.
398 * @snd: Resource number of the sound to play.
399 * @repeats: Number of times to repeat the sound.
400 * @notify: If nonzero, requests a notification when the sound is finished.
402 * This works the same as glk_schannel_play(), but lets you specify additional
403 * options. <code>glk_schannel_play(chan, snd)</code> is exactly equivalent to
404 * <code>glk_schannel_play_ext(chan, snd, 1, 0)</code>.
406 * The @repeats value is the number of times the sound should be repeated. A
407 * repeat value of -1 (or rather 0xFFFFFFFF) means that the sound should repeat
408 * forever. A repeat value of 0 means that the sound will not be played at all;
409 * nothing happens. (Although a previous sound on the channel will be stopped,
410 * and the function will return 1.)
412 * The @notify value should be nonzero in order to request a sound notification
413 * event. If you do this, when the sound is completed, you will get an event
414 * with type %evtype_SoundNotify. The @window will be %NULL, @val1 will be the
415 * sound's resource id, and @val2 will be the nonzero value you passed as
418 * If you request sound notification, and the repeat value is greater than one,
419 * you will get the event only after the last repetition. If the repeat value is
420 * 0 or -1, you will never get a notification event at all. Similarly, if the
421 * sound is stopped or interrupted, or if the channel is destroyed while the
422 * sound is playing, there will be no notification event.
424 * Not all libraries support sound notification. You should test the
425 * %gestalt_Sound2 selector before you rely on it; see <link
426 * linkend="chimara-Testing-for-Sound-Capabilities">Testing for Sound
427 * Capabilities</link>.
429 * Note that you can play a sound on a channel whose volume is zero. This has
430 * no audible result, unless you later change the volume; but it produces
431 * notifications as usual. You can also play a sound on a paused channel; the
432 * sound is paused immediately, and does not progress.
434 * Returns: 1 on success, 0 on failure.
437 glk_schannel_play_ext(schanid_t chan, glui32 snd, glui32 repeats, glui32 notify)
439 VALID_SCHANNEL(chan, return 0);
440 #ifdef GSTREAMER_SOUND
441 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
442 GInputStream *stream;
444 /* Stop the previous sound */
445 clean_up_after_playing_sound(chan);
447 /* Don't play if repeats = 0 */
453 /* Load the sound into a GInputStream, by whatever method */
454 if(!glk_data->resource_map) {
455 if(!glk_data->resource_load_callback) {
456 WARNING(_("No resource map has been loaded yet."));
459 gchar *filename = glk_data->resource_load_callback(CHIMARA_RESOURCE_SOUND, snd, glk_data->resource_load_callback_data);
461 WARNING(_("Error loading resource from alternative location."));
466 GFile *file = g_file_new_for_path(filename);
467 stream = G_INPUT_STREAM(g_file_read(file, NULL, &err));
469 IO_WARNING(_("Error loading resource from file"), filename, err->message);
471 g_object_unref(file);
475 g_object_unref(file);
477 giblorb_result_t resource;
478 giblorb_err_t result = giblorb_load_resource(glk_data->resource_map, giblorb_method_Memory, &resource, giblorb_ID_Snd, snd);
479 if(result != giblorb_err_None) {
480 WARNING_S( _("Error loading resource"), giblorb_get_error_message(result) );
483 stream = g_memory_input_stream_new_from_data(resource.data.ptr, resource.length, NULL);
486 chan->repeats = repeats;
487 chan->resource = snd;
488 chan->notify = notify;
489 g_object_set(chan->source, "stream", stream, NULL);
490 g_object_unref(stream); /* Now owned by GStreamer element */
492 /* Play the sound; unless the channel is paused, then pause it instead */
493 if(!gst_element_set_state(chan->pipeline, chan->paused? GST_STATE_PAUSED : GST_STATE_PLAYING)) {
494 WARNING_S(_("Could not set GstElement state to"), chan->paused? "PAUSED" : "PLAYING");
504 * glk_schannel_play_multi:
505 * @chanarray: Array of #schanid_t structures.
506 * @chancount: Length of @chanarray.
507 * @sndarray: Array of sound resource numbers.
508 * @soundcount: Length of @sndarray, must be equal to @chanarray.
509 * @notify: If nonzero, request a notification when each sound finishes.
511 * This works the same as glk_schannel_play_ext(), except that you can specify
512 * more than one sound. The channel references and sound resource numbers are
513 * given as two arrays, which must be the same length. The @notify argument
514 * applies to all the sounds; the repeats value for all the sounds is 1.
516 * All the sounds will begin at exactly the same time.
518 * This returns the number of sounds that began playing correctly. (This will be
519 * a number from 0 to @soundcount.)
522 * If the @notify argument is nonzero, you will get a separate sound
523 * notification event as each sound finishes. They will all have the same
527 * Note that you have to supply @chancount and @soundcount as separate
528 * arguments, even though they are required to be the same. This is an awkward
529 * consequence of the way array arguments are dispatched in Glulx.
532 * Returns: The number of sounds that started playing correctly.
535 glk_schannel_play_multi(schanid_t *chanarray, glui32 chancount, glui32 *sndarray, glui32 soundcount, glui32 notify)
537 g_return_val_if_fail(chancount == soundcount, 0);
538 g_return_val_if_fail(chanarray != NULL || chancount == 0, 0);
539 g_return_val_if_fail(sndarray != NULL || soundcount == 0, 0);
542 for(count = 0; count < chancount; count++)
543 VALID_SCHANNEL(chanarray[count], return 0);
545 #ifdef GSTREAMER_SOUND
546 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
547 GInputStream *stream;
549 if(!glk_data->resource_map && !glk_data->resource_load_callback) {
550 WARNING(_("No resource map has been loaded yet."));
554 /* We keep an array of sounds to skip if any of them have errors */
555 gboolean *skiparray = g_new0(gboolean, chancount);
557 /* Set up all the channels one by one */
558 for(count = 0; count < chancount; count++) {
559 /* Stop the previous sound */
560 clean_up_after_playing_sound(chanarray[count]);
562 /* Load the sound into a GInputStream, by whatever method */
563 if(!glk_data->resource_map) {
564 gchar *filename = glk_data->resource_load_callback(CHIMARA_RESOURCE_SOUND, sndarray[count], glk_data->resource_load_callback_data);
566 WARNING(_("Error loading resource from alternative location."));
567 skiparray[count] = TRUE;
572 GFile *file = g_file_new_for_path(filename);
573 stream = G_INPUT_STREAM(g_file_read(file, NULL, &err));
575 IO_WARNING(_("Error loading resource from file"), filename, err->message);
577 g_object_unref(file);
578 skiparray[count] = TRUE;
582 g_object_unref(file);
584 giblorb_result_t resource;
585 giblorb_err_t result = giblorb_load_resource(glk_data->resource_map, giblorb_method_Memory, &resource, giblorb_ID_Snd, sndarray[count]);
586 if(result != giblorb_err_None) {
587 WARNING_S( _("Error loading resource"), giblorb_get_error_message(result) );
588 skiparray[count] = TRUE;
591 stream = g_memory_input_stream_new_from_data(resource.data.ptr, resource.length, NULL);
594 chanarray[count]->repeats = 1;
595 chanarray[count]->resource = sndarray[count];
596 chanarray[count]->notify = notify;
597 g_object_set(chanarray[count]->source, "stream", stream, NULL);
598 g_object_unref(stream); /* Now owned by GStreamer element */
601 /* Start all the sounds as close to each other as possible. */
602 /* FIXME: Is there a way to start them exactly at the same time? */
603 glui32 successes = 0;
604 for(count = 0; count < chancount; count++) {
607 /* Play the sound; unless the channel is paused, then pause it instead */
608 if(!gst_element_set_state(chanarray[count]->pipeline, chanarray[count]->paused? GST_STATE_PAUSED : GST_STATE_PLAYING)) {
609 WARNING_S(_("Could not set GstElement state to"), chanarray[count]->paused? "PAUSED" : "PLAYING");
610 skiparray[count] = TRUE;
624 * @chan: Channel to silence.
626 * Stops any sound playing in the channel. No notification event is generated,
627 * even if you requested one. If no sound is playing, this has no effect.
630 glk_schannel_stop(schanid_t chan)
632 VALID_SCHANNEL(chan, return);
633 #ifdef GSTREAMER_SOUND
634 clean_up_after_playing_sound(chan);
639 * glk_schannel_pause:
640 * @chan: Channel to pause.
642 * Pause any sound playing in the channel. This does not generate any
643 * notification events. If the channel is already paused, this does nothing.
645 * New sounds started in a paused channel are paused immediately.
647 * A volume change in progress is <emphasis>not</emphasis> paused, and may
648 * proceed to completion, generating a notification if appropriate.
651 glk_schannel_pause(schanid_t chan)
653 VALID_SCHANNEL(chan, return);
656 return; /* Silently do nothing */
658 /* Mark the channel as paused even if there is no sound playing yet */
662 if(gst_element_get_state(chan->pipeline, &state, NULL, GST_CLOCK_TIME_NONE) != GST_STATE_CHANGE_SUCCESS) {
663 WARNING(_("Could not get GstElement state"));
666 if(state != GST_STATE_PLAYING)
667 return; /* Silently do nothing if no sound is playing */
669 if(!gst_element_set_state(chan->pipeline, GST_STATE_PAUSED)) {
670 WARNING_S(_("Could not set GstElement state to"), "PAUSED");
676 * glk_schannel_unpause:
677 * @chan: Channel to unpause.
679 * Unpause the channel. Any paused sounds begin playing where they left off. If
680 * the channel is not already paused, this does nothing.
683 * This means, for example, that you can pause a channel that is currently
684 * not playing any sounds. If you then add a sound to the channel, it will
685 * not start playing; it will be paused at its beginning. If you later
686 * unpaise the channel, the sound will commence.
690 glk_schannel_unpause(schanid_t chan)
692 VALID_SCHANNEL(chan, return);
695 return; /* Silently do nothing */
697 /* Mark the channel as not paused in any case */
698 chan->paused = FALSE;
701 if(gst_element_get_state(chan->pipeline, &state, NULL, GST_CLOCK_TIME_NONE) != GST_STATE_CHANGE_SUCCESS) {
702 WARNING(_("Could not get GstElement state"));
705 if(state != GST_STATE_PAUSED)
706 return; /* Silently do nothing */
708 if(!gst_element_set_state(chan->pipeline, GST_STATE_PLAYING)) {
709 WARNING_S(_("Could not set GstElement state to"), "PLAYING");
715 * glk_schannel_set_volume:
716 * @chan: Channel to set the volume of.
717 * @vol: Integer representing the volume; 0x10000 is 100%.
719 * Sets the volume in the channel, from 0 (silence) to 0x10000 (full volume).
720 * Again, you can overdrive the volume by setting a value greater than 0x10000,
721 * but this is not recommended.
723 * The glk_schannel_set_volume() function does not include duration and notify
724 * values. Both are assumed to be zero: immediate change, no notification.
726 * You can call this function between sounds, or while a sound is playing.
727 * However, a zero-duration change while a sound is playing may produce
730 * At most one volume change can be occurring on a sound channel at any time.
731 * If you call this function while a previous volume change is in progress, the
732 * previous change is interrupted.
734 * Not all libraries support this function. You should test the
735 * %gestalt_SoundVolume selector before you rely on it; see <link
736 * linkend="chimara-Testing-for-Sound-Capabilities">Testing for Sound
737 * Capabilities</link>.
739 * <note><title>Chimara</title>
740 * <para>Chimara supports volumes from 0 to 1000%, that is, values of
741 * @vol up to 0xA0000.</para>
745 glk_schannel_set_volume(schanid_t chan, glui32 vol)
747 glk_schannel_set_volume_ext(chan, vol, 0, 0);
751 volume_glk_to_gstreamer(glui32 volume_glk)
753 return CLAMP(((double)volume_glk / 0x10000), 0.0, 10.0);
756 #ifdef GSTREAMER_SOUND
758 volume_change_timeout(schanid_t chan)
761 g_get_current_time(&now);
763 if(now.tv_sec >= chan->target_time_sec && now.tv_usec >= chan->target_time_usec) {
764 /* We're done - make sure the volume is at the requested level */
765 g_object_set(chan->filter, "volume", chan->target_volume, NULL);
767 if(chan->volume_notify)
768 event_throw(chan->glk, evtype_VolumeNotify, NULL, 0, chan->volume_notify);
770 chan->volume_timer_id = 0;
774 /* Calculate the appropriate step every time - a busy system may delay or
775 * drop timer ticks */
776 double time_left_msec = (chan->target_time_sec - now.tv_sec) * 1000.0
777 + (chan->target_time_usec - now.tv_usec) / 1000.0;
778 double steps_left = time_left_msec / VOLUME_TIMER_RESOLUTION;
779 double current_volume;
780 g_object_get(chan->filter, "volume", ¤t_volume, NULL);
781 double volume_step = (chan->target_volume - current_volume) / steps_left;
783 g_object_set(chan->filter, "volume", current_volume + volume_step, NULL);
787 #endif /* GSTREAMER_SOUND */
790 * glk_schannel_set_volume_ext:
791 * @chan: Channel to set the volume of.
792 * @vol: Integer representing the volume; 0x10000 is 100%.
793 * @duration: Length of volume change in milliseconds, or 0 for immediate.
794 * @notify: If nonzero, requests a notification when the volume change finishes.
796 * Sets the volume in the channel, from 0 (silence) to 0x10000 (full volume).
797 * Again, you can overdrive the volume by setting a value greater than 0x10000,
798 * but this is not recommended.
800 * If the @duration is zero, the change is immediate. Otherwise, the change
801 * begins immediately, and occurs smoothly over the next @duration milliseconds.
803 * The @notify value should be nonzero in order to request a volume notification
804 * event. If you do this, when the volume change is completed, you will get an
805 * event with type #evtype_VolumeNotify. The window will be %NULL, @val1 will be
806 * zero, and @val2 will be the nonzero value you passed as @notify.
808 * You can call this function between sounds, or while a sound is playing.
809 * However, a zero-duration change while a sound is playing may produce
812 * At most one volume change can be occurring on a sound channel at any time. If
813 * you call this function while a previous volume change is in progress, the
814 * previous change is interrupted. The beginning point of the new volume change
815 * should be wherever the previous volume change was interrupted (rather than
816 * the previous change's beginning or ending point).
818 * Not all libraries support these functions. You should test the appropriate
819 * gestalt selectors before you rely on them; see "Testing for Sound
823 glk_schannel_set_volume_ext(schanid_t chan, glui32 vol, glui32 duration, glui32 notify)
825 VALID_SCHANNEL(chan, return);
826 /* Silently ignore out-of-range volume values */
828 #ifdef GSTREAMER_SOUND
829 /* Interrupt a previous volume change */
830 if(chan->volume_timer_id > 0)
831 g_source_remove(chan->volume_timer_id);
833 double target_volume = volume_glk_to_gstreamer(vol);
836 g_object_set(chan->filter, "volume", target_volume, NULL);
839 event_throw(chan->glk, evtype_VolumeNotify, NULL, 0, notify);
844 GTimeVal target_time;
845 g_get_current_time(&target_time);
846 g_time_val_add(&target_time, (long)duration * 1000);
848 chan->target_volume = target_volume;
849 chan->target_time_sec = target_time.tv_sec;
850 chan->target_time_usec = target_time.tv_usec;
851 chan->volume_notify = notify;
853 /* Set up a timer for the volume */
854 chan->volume_timer_id = g_timeout_add(VOLUME_TIMER_RESOLUTION, (GSourceFunc)volume_change_timeout, chan);
859 * glk_sound_load_hint:
860 * @snd: Resource number of a sound.
861 * @flag: Nonzero to tell the library to load the sound, zero to tell the
862 * library to unload it.
864 * This gives the library a hint about whether the given sound should be loaded
865 * or not. If the @flag is nonzero, the library may preload the sound or do
866 * other initialization, so that glk_schannel_play() will be faster. If the
867 * @flag is zero, the library may release memory or other resources associated
868 * with the sound. Calling this function is always optional, and it has no
869 * effect on what the library actually plays.
872 glk_sound_load_hint(glui32 snd, glui32 flag)
874 #ifdef GSTREAMER_SOUND
875 ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
876 giblorb_result_t resource;
877 giblorb_err_t result;
879 /* Sound load hints only work for Blorb resource maps */
880 if(!glk_data->resource_map)
884 /* The sound load hint simply loads the resource from the resource map;
885 loading a chunk more than once does nothing */
886 result = giblorb_load_resource(glk_data->resource_map, giblorb_method_Memory, &resource, giblorb_ID_Snd, snd);
887 if(result != giblorb_err_None) {
888 WARNING_S( _("Error loading resource"), giblorb_get_error_message(result) );
892 /* Get the Blorb chunk number by loading the resource with
893 method_DontLoad, then unload that chunk - has no effect if the chunk
895 result = giblorb_load_resource(glk_data->resource_map, giblorb_method_DontLoad, &resource, giblorb_ID_Snd, snd);
896 if(result != giblorb_err_None) {
897 WARNING_S( _("Error loading resource"), giblorb_get_error_message(result) );
900 result = giblorb_unload_chunk(glk_data->resource_map, resource.chunknum);
901 if(result != giblorb_err_None) {
902 WARNING_S( _("Error unloading chunk"), giblorb_get_error_message(result) );
906 #endif /* GSTREAMER_SOUND */