#include <libchimara/glk.h>
#ifdef GSTREAMER_SOUND
#include <gst/gst.h>
+#include <gst/controller/gstcontroller.h>
#endif
#include "magic.h"
#include "schannel.h"
glk_schannel_play_ext(schanid_t chan, glui32 snd, glui32 repeats, glui32 notify)
{
VALID_SCHANNEL(chan, return 0);
- g_printerr("Play sound %d with repeats %d and notify %d\n", snd, repeats, notify);
#ifdef GSTREAMER_SOUND
ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
GInputStream *stream;
g_object_set(chan->source, "stream", stream, NULL);
g_object_unref(stream); /* Now owned by GStreamer element */
- if(!gst_element_set_state(chan->pipeline, GST_STATE_PLAYING)) {
- WARNING_S(_("Could not set GstElement state to"), "PLAYING");
+ /* Play the sound; unless the channel is paused, then pause it instead */
+ if(!gst_element_set_state(chan->pipeline, chan->paused? GST_STATE_PAUSED : GST_STATE_PLAYING)) {
+ WARNING_S(_("Could not set GstElement state to"), chan->paused? "PAUSED" : "PLAYING");
return 0;
}
return 1;
/**
* glk_schannel_play_multi:
- * @chanarray:
- * @chancount:
- * @sndarray:
- * @soundcount:
- * @notify:
+ * @chanarray: Array of #schanid_t structures.
+ * @chancount: Length of @chanarray.
+ * @sndarray: Array of sound resource numbers.
+ * @soundcount: Length of @sndarray, must be equal to @chanarray.
+ * @notify: If nonzero, request a notification when each sound finishes.
*
* [DRAFT SPEC]
*
glk_schannel_play_multi(schanid_t *chanarray, glui32 chancount, glui32 *sndarray, glui32 soundcount, glui32 notify)
{
g_return_val_if_fail(chancount == soundcount, 0);
- g_return_val_if_fail(chanarray == NULL && chancount != 0, 0);
- g_return_val_if_fail(sndarray == NULL && soundcount != 0, 0);
+ g_return_val_if_fail(chanarray != NULL || chancount == 0, 0);
+ g_return_val_if_fail(sndarray != NULL || soundcount == 0, 0);
int count;
for(count = 0; count < chancount; count++)
VALID_SCHANNEL(chanarray[count], return 0);
-
- g_warning("Not implemented");
+
+#ifdef GSTREAMER_SOUND
+ ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
+ GInputStream *stream;
+
+ if(!glk_data->resource_map && !glk_data->resource_load_callback) {
+ WARNING(_("No resource map has been loaded yet."));
+ return 0;
+ }
+
+ /* We keep an array of sounds to skip if any of them have errors */
+ gboolean *skiparray = g_new0(gboolean, chancount);
+
+ /* Set up all the channels one by one */
+ for(count = 0; count < chancount; count++) {
+ /* Stop the previous sound */
+ clean_up_after_playing_sound(chanarray[count]);
+
+ /* Load the sound into a GInputStream, by whatever method */
+ if(!glk_data->resource_map) {
+ gchar *filename = glk_data->resource_load_callback(CHIMARA_RESOURCE_SOUND, sndarray[count], glk_data->resource_load_callback_data);
+ if(!filename) {
+ WARNING(_("Error loading resource from alternative location."));
+ skiparray[count] = TRUE;
+ continue;
+ }
+
+ GError *err = NULL;
+ GFile *file = g_file_new_for_path(filename);
+ stream = G_INPUT_STREAM(g_file_read(file, NULL, &err));
+ if(!stream) {
+ IO_WARNING(_("Error loading resource from file"), filename, err->message);
+ g_free(filename);
+ g_object_unref(file);
+ skiparray[count] = TRUE;
+ continue;
+ }
+ g_free(filename);
+ g_object_unref(file);
+ } else {
+ giblorb_result_t resource;
+ giblorb_err_t result = giblorb_load_resource(glk_data->resource_map, giblorb_method_Memory, &resource, giblorb_ID_Snd, sndarray[count]);
+ if(result != giblorb_err_None) {
+ WARNING_S( _("Error loading resource"), giblorb_get_error_message(result) );
+ skiparray[count] = TRUE;
+ continue;
+ }
+ stream = g_memory_input_stream_new_from_data(resource.data.ptr, resource.length, NULL);
+ }
+
+ chanarray[count]->repeats = 1;
+ chanarray[count]->resource = sndarray[count];
+ chanarray[count]->notify = notify;
+ g_object_set(chanarray[count]->source, "stream", stream, NULL);
+ g_object_unref(stream); /* Now owned by GStreamer element */
+ }
+
+ /* Start all the sounds as close to each other as possible. */
+ /* FIXME: Is there a way to start them exactly at the same time? */
+ glui32 successes = 0;
+ for(count = 0; count < chancount; count++) {
+ if(skiparray[count])
+ continue;
+ /* Play the sound; unless the channel is paused, then pause it instead */
+ if(!gst_element_set_state(chanarray[count]->pipeline, chanarray[count]->paused? GST_STATE_PAUSED : GST_STATE_PLAYING)) {
+ WARNING_S(_("Could not set GstElement state to"), chanarray[count]->paused? "PAUSED" : "PLAYING");
+ skiparray[count] = TRUE;
+ continue;
+ }
+ successes++;
+ }
+ g_free(skiparray);
+ return successes;
+#else
return 0;
+#endif
}
/**
if(chan->paused)
return; /* Silently do nothing */
+
+ /* Mark the channel as paused even if there is no sound playing yet */
+ chan->paused = TRUE;
+
GstState state;
if(gst_element_get_state(chan->pipeline, &state, NULL, GST_CLOCK_TIME_NONE) != GST_STATE_CHANGE_SUCCESS) {
WARNING(_("Could not get GstElement state"));
WARNING_S(_("Could not set GstElement state to"), "PAUSED");
return;
}
- chan->paused = TRUE;
}
/**
if(!chan->paused)
return; /* Silently do nothing */
+ /* Mark the channel as not paused in any case */
+ chan->paused = FALSE;
+
GstState state;
if(gst_element_get_state(chan->pipeline, &state, NULL, GST_CLOCK_TIME_NONE) != GST_STATE_CHANGE_SUCCESS) {
WARNING(_("Could not get GstElement state"));
WARNING_S(_("Could not set GstElement state to"), "PLAYING");
return;
}
- chan->paused = FALSE;
+}
+
+static double
+volume_glk_to_gstreamer(glui32 volume_glk)
+{
+ return CLAMP(((double)volume_glk / 0x10000), 0.0, 10.0);
+}
+
+static void
+channel_set_volume_immediately(schanid_t chan, double volume, glui32 notify)
+{
+ g_object_set(chan->filter, "volume", volume, NULL);
+
+ if(notify != 0) {
+ /* Send a notification */
+ }
}
/**
void
glk_schannel_set_volume(schanid_t chan, glui32 vol)
{
- glk_schannel_set_volume_ext(chan, vol, 0, 0);
+ VALID_SCHANNEL(chan, return);
+ /* Silently ignore out-of-range volume values */
+
+#ifdef GSTREAMER_SOUND
+ double volume = volume_glk_to_gstreamer(vol);
+ channel_set_volume_immediately(chan, volume, 0);
+#endif
}
/**
* volume change should be wherever the previous volume change was interrupted
* (rather than the previous change's beginning or ending point).
*
- * Not all libraries support thse functions. You should test the appropriate
+ * Not all libraries support these functions. You should test the appropriate
* gestalt selectors before you rely on them; see "Testing for Sound
* Capabilities".
*/
/* Silently ignore out-of-range volume values */
#ifdef GSTREAMER_SOUND
- gdouble volume_gst = (gdouble)vol / 0x10000;
- g_object_set(chan->filter, "volume", CLAMP(volume_gst, 0.0, 10.0), NULL);
-#endif
+ double volume = volume_glk_to_gstreamer(vol);
+
+ /* TODO: If channel is not playing, change the volume anyway */
- /* Not implemented */
+ if(duration == 0) {
+ channel_set_volume_immediately(chan, volume, notify);
+ return;
+ }
+
+ /* Get the volume levels as GValues */
+ GValue current_volume = { 0 };
+ GValue target_volume = { 0 };
+ g_value_init(¤t_volume, G_TYPE_DOUBLE);
+ g_value_init(&target_volume, G_TYPE_DOUBLE);
+ g_object_get_property(G_OBJECT(chan->filter), "volume", ¤t_volume);
+ g_value_set_double(&target_volume, volume);
+
+ /* Make a controller for the volume */
+ GstController *controller = gst_object_control_properties(G_OBJECT(chan->filter), "volume", NULL);
+ if(controller == NULL) {
+ WARNING(_("Couldn't get controller for volume change"));
+ goto fail;
+ }
+ GstInterpolationControlSource *csource = gst_interpolation_control_source_new();
+ gst_interpolation_control_source_set_interpolation_mode(csource, GST_INTERPOLATE_LINEAR);
+ if(!gst_controller_set_control_source(controller, "volume", GST_CONTROL_SOURCE(csource))) {
+ WARNING(_("Couldn't set control source for volume change"));
+ goto fail;
+ }
+
+ /* Get the current time on the pipeline */
+ GstClock *clock = gst_pipeline_get_clock(GST_PIPELINE(chan->pipeline));
+ GstClockTime current = gst_clock_get_time(clock);
+ g_object_unref(clock);
+
+ if(!gst_interpolation_control_source_set(csource, current, ¤t_volume)) {
+ WARNING(_("Couldn't program volume change"));
+ goto fail;
+ }
+ if(!gst_interpolation_control_source_set(csource, current + duration * GST_MSECOND, &target_volume)) {
+ WARNING(_("Couldn't program volume change"));
+ goto fail;
+ }
+
+ /* TODO: SET UP NOTIFICATION */
+
+ return;
+
+fail:
+ /* Changing the volume dynamically didn't work; just do it immediately. */
+ channel_set_volume_immediately(chan, volume, notify);
+#endif
}
/**
projects / projects / chimara / chimara.git / blobdiff