コード例 #1
0
/**
 * bt_wave_new:
 * @song: the song the new instance belongs to
 * @name: the display name for the new wave
 * @uri: the location of the sample data
 * @index: the list slot for the new wave
 * @volume: the volume of the wave
 * @loop_mode: loop playback mode
 * @channels: number of audio channels
 *
 * Create a new instance
 *
 * Returns: the new instance or %NULL in case of an error
 */
BtWave *
bt_wave_new (const BtSong * const song, const gchar * const name,
    const gchar * const uri, const gulong index, const gdouble volume,
    const BtWaveLoopMode loop_mode, const guint channels)
{
  return BT_WAVE (g_object_new (BT_TYPE_WAVE, "song", song, "name", name,
          "uri", uri, "index", index, "volume", volume, "loop-mode",
          loop_mode, "channels", channels, NULL));
}
コード例 #2
0
static xmlNodePtr
bt_wave_persistence_save (const BtPersistence * const persistence,
    const xmlNodePtr const parent_node)
{
  const BtWave *const self = BT_WAVE (persistence);
  xmlNodePtr node = NULL;
  xmlNodePtr child_node;

  GST_DEBUG ("PERSISTENCE::wave");

  if ((node = xmlNewChild (parent_node, NULL, XML_CHAR_PTR ("wave"), NULL))) {
    BtSongIONative *song_io;

    // we need to have a uri
    if (!self->priv->uri)
      self->priv->uri = g_strdup (self->priv->name);

    xmlNewProp (node, XML_CHAR_PTR ("index"),
        XML_CHAR_PTR (bt_str_format_ulong (self->priv->index)));
    xmlNewProp (node, XML_CHAR_PTR ("name"), XML_CHAR_PTR (self->priv->name));
    xmlNewProp (node, XML_CHAR_PTR ("uri"), XML_CHAR_PTR (self->priv->uri));
    xmlNewProp (node, XML_CHAR_PTR ("volume"),
        XML_CHAR_PTR (bt_str_format_double (self->priv->volume)));
    xmlNewProp (node, XML_CHAR_PTR ("loop-mode"),
        XML_CHAR_PTR (bt_str_format_enum (BT_TYPE_WAVE_LOOP_MODE,
                self->priv->loop_mode)));

    // check if we need to save external data
    g_object_get (self->priv->song, "song-io", &song_io, NULL);
    if (song_io) {
      if (BT_IS_SONG_IO_NATIVE_BZT (song_io)) {
        gchar *uri = NULL;

        if (self->priv->ext_fd == -1) {
          // need to write in memory data to a wav
          bt_wave_save_to_fd (self);
        }
        uri = g_strdup_printf ("fd://%d", self->priv->ext_fd);
        bt_wave_save_from_fd (self, song_io, uri);
        g_free (uri);
      }
      g_object_unref (song_io);
    }
    // save wavelevels
    if ((child_node =
            xmlNewChild (node, NULL, XML_CHAR_PTR ("wavelevels"), NULL))) {
      bt_persistence_save_list (self->priv->wavelevels, child_node);
    }
  }
  return node;
}
コード例 #3
0
ファイル: wavetable.c プロジェクト: Buzztrax/buzztrax
/**
 * bt_wavetable_get_wave_by_index:
 * @self: the wavetable to search for the wave
 * @index: the index of the wave
 *
 * Search the wavetable for a wave by the supplied index.
 * The wave must have been added previously to this wavetable with
 * bt_wavetable_add_wave().
 *
 * Returns: (transfer full): #BtWave instance or %NULL if not found. Unref the
 * wave, when done with it.
 */
BtWave *
bt_wavetable_get_wave_by_index (const BtWavetable * const self,
    const gulong index)
{
  const GList *node;
  gulong wave_index;

  g_assert (BT_IS_WAVETABLE (self));

  for (node = self->priv->waves; node; node = g_list_next (node)) {
    BtWave *const wave = BT_WAVE (node->data);
    g_object_get (wave, "index", &wave_index, NULL);
    if (index == wave_index)
      return g_object_ref (wave);
  }
  return NULL;
}
コード例 #4
0
ファイル: wavetable.c プロジェクト: Buzztrax/buzztrax
static BtPersistence *
bt_wavetable_persistence_load (const GType type,
    const BtPersistence * const persistence, xmlNodePtr node, GError ** err,
    va_list var_args)
{
  const BtWavetable *const self = BT_WAVETABLE (persistence);
  xmlNodePtr child_node;

  GST_DEBUG ("PERSISTENCE::wavetable");
  g_assert (node);

  for (child_node = node->children; child_node; child_node = child_node->next) {
    if ((!xmlNodeIsText (child_node))
        && (!strncmp ((char *) child_node->name, "wave\0", 5))) {
      GError *err = NULL;

      BtWave *const wave =
          BT_WAVE (bt_persistence_load (BT_TYPE_WAVE, NULL, child_node, &err,
              "song", self->priv->song, NULL));
      if (err != NULL) {
        // collect failed waves
        gchar *const name, *const uri;

        g_object_get (wave, "name", &name, "uri", &uri, NULL);
        gchar *const str = g_strdup_printf ("%s: %s", name, uri);
        bt_wavetable_remember_missing_wave (self, str);
        g_free (name);
        g_free (uri);
        GST_WARNING ("Can't create wavetable: %s", err->message);
        g_error_free (err);
      }
      g_object_unref (wave);
    }
  }
  return BT_PERSISTENCE (persistence);
}
コード例 #5
0
ファイル: wavelevel.c プロジェクト: Buzztrax/buzztrax
static void
bt_wavelevel_set_property (GObject * const object, const guint property_id,
    const GValue * const value, GParamSpec * const pspec)
{
  const BtWavelevel *const self = BT_WAVELEVEL (object);
  return_if_disposed ();
  switch (property_id) {
    case WAVELEVEL_SONG:
      self->priv->song = BT_SONG (g_value_get_object (value));
      g_object_try_weak_ref (self->priv->song);
      //GST_DEBUG("set the song for wavelevel: %p",self->priv->song);
      break;
    case WAVELEVEL_WAVE:
      self->priv->wave = BT_WAVE (g_value_get_object (value));
      g_object_try_weak_ref (self->priv->wave);
      GST_DEBUG ("set the wave for wavelevel: %p", self->priv->wave);
      break;
    case WAVELEVEL_ROOT_NOTE:
      self->priv->root_note = g_value_get_enum (value);
      GST_DEBUG ("set the root-note for wavelevel: %d", self->priv->root_note);
      break;
    case WAVELEVEL_LENGTH:
      self->priv->length = g_value_get_ulong (value);
      GST_DEBUG ("set the length for wavelevel: %lu", self->priv->length);
      break;
    case WAVELEVEL_LOOP_START:
      self->priv->loop_start = g_value_get_ulong (value);
      GST_INFO ("loop: 0 / %lu .. %lu / %lu", self->priv->loop_start,
          self->priv->loop_end, self->priv->length);
      // make sure its less then loop_end/length
      if (self->priv->loop_end > 0) {
        if (self->priv->loop_start >= self->priv->loop_end) {
          GST_DEBUG ("clip loop-start by loop-end: %lu", self->priv->loop_end);
          self->priv->loop_start = self->priv->loop_end - 1;
        }
      }
      if (self->priv->length > 0) {
        if (self->priv->loop_start >= self->priv->length) {
          GST_DEBUG ("clip loop-start by length: %lu", self->priv->length);
          self->priv->loop_start = self->priv->length - 1;
        }
      }
      GST_DEBUG ("set the loop-start for wavelevel: %lu",
          self->priv->loop_start);
      break;
    case WAVELEVEL_LOOP_END:
      self->priv->loop_end = g_value_get_ulong (value);
      GST_INFO ("loop: 0 / %lu .. %lu / %lu", self->priv->loop_start,
          self->priv->loop_end, self->priv->length);
      // make sure its more then loop-start
      if (self->priv->loop_start > 0) {
        if (self->priv->loop_end < self->priv->loop_start) {
          GST_DEBUG ("clip loop-end by loop-start: %lu",
              self->priv->loop_start);
          self->priv->loop_end = self->priv->loop_start + 1;
        }
      }
      // make sure its less then or equal to length
      if (self->priv->length > 0) {
        if (self->priv->loop_end > self->priv->length) {
          GST_DEBUG ("clip loop-end by length: %lu", self->priv->length);
          self->priv->loop_end = self->priv->length;
        }
      }
      GST_DEBUG ("set the loop-start for wavelevel: %lu",
          self->priv->loop_start);
      break;
    case WAVELEVEL_RATE:
      self->priv->rate = g_value_get_ulong (value);
      GST_DEBUG ("set the rate for wavelevel: %lu", self->priv->rate);
      break;
    case WAVELEVEL_DATA:
      g_free (self->priv->sample);
      self->priv->sample = g_value_get_pointer (value);
      GST_DEBUG ("set the data-pointer for wavelevel: %p", self->priv->sample);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
  }
}