static void
bse_wave_store_private (BseObject *object,
BseStorage *storage)
{
BseWave *wave = BSE_WAVE (object);
/* chain parent class' handler */
BSE_OBJECT_CLASS (parent_class)->store_private (object, storage);
if (wave->locator_set && !BSE_STORAGE_SELF_CONTAINED (storage))
{
bse_storage_break (storage);
bse_storage_printf (storage, "(load-wave \"%s\" \"%s\")", wave->file_name, wave->wave_name);
}
if (!wave->locator_set || BSE_STORAGE_SELF_CONTAINED (storage))
{
if (wave->xinfos && wave->xinfos[0])
{
bse_storage_break (storage);
bse_storage_puts (storage, "(xinfos ");
bse_storage_put_xinfos (storage, wave->xinfos);
bse_storage_putc (storage, ')');
}
bse_storage_break (storage);
SfiRing *ring;
for (ring = wave->wave_chunks; ring; ring = sfi_ring_walk (ring, wave->wave_chunks))
{
GslWaveChunk *wchunk = ring->data;
BseErrorType error = gsl_data_handle_open (wchunk->dcache->dhandle);
if (error)
{
bse_storage_warn (storage, "failed to open data handle (%s): %s",
gsl_data_handle_name (wchunk->dcache->dhandle),
bse_error_blurb (error));
continue;
}
bse_storage_break (storage);
bse_storage_puts (storage, "(wave-chunk ");
bse_storage_push_level (storage);
if (wchunk->dcache->dhandle->setup.xinfos)
{
gchar **xinfos = bse_xinfos_dup_consolidated (wchunk->dcache->dhandle->setup.xinfos, FALSE);
xinfos = bse_xinfos_del_value (xinfos, "osc-freq");
if (xinfos && xinfos[0])
{
bse_storage_break (storage);
bse_storage_puts (storage, "(xinfos ");
bse_storage_put_xinfos (storage, xinfos);
bse_storage_putc (storage, ')');
}
g_strfreev (xinfos);
}
bse_storage_break (storage);
bse_storage_put_data_handle (storage, 0, wchunk->dcache->dhandle);
gsl_data_handle_close (wchunk->dcache->dhandle);
bse_storage_pop_level (storage);
bse_storage_putc (storage, ')');
}
}
}
static void
chain_handle_close (GslDataHandle *dhandle)
{
ChainHandle *chandle = (ChainHandle*) dhandle;
gsl_data_handle_close (chandle->src_handle);
}
void
gsl_vorbis1_handle_destroy (GslVorbis1Handle *v1h)
{
if (v1h->vcutter)
gsl_vorbis_cutter_destroy (v1h->vcutter);
if (v1h->rfile)
gsl_rfile_close (v1h->rfile);
gsl_data_handle_close (v1h->dhandle);
v1h->dhandle = NULL;
g_free (v1h);
}
static GslDataHandle*
gsl_data_handle_new_ogg_vorbis_any (const gchar *file_name,
guint lbitstream,
gfloat osc_freq,
gboolean add_zoffset,
guint byte_offset,
guint byte_size,
guint *n_channelsp,
gfloat *mix_freqp)
{
if (n_channelsp)
*n_channelsp = 0;
if (mix_freqp)
*mix_freqp = 0;
VorbisHandle *vhandle = sfi_new_struct0 (VorbisHandle, 1);
gboolean success = gsl_data_handle_common_init (&vhandle->dhandle, file_name);
if (success)
{
BseErrorType error;
vhandle->dhandle.vtable = &dh_vorbis_vtable;
vhandle->n_bitstreams = 0;
vhandle->bitstream = lbitstream;
vhandle->osc_freq = osc_freq;
vhandle->rfile_byte_offset = byte_offset;
vhandle->rfile_add_zoffset = add_zoffset != FALSE;
vhandle->rfile_byte_length = byte_size;
/* we can only check matters upon opening and need
* to initialize things like the bitstream_serialno.
*/
error = gsl_data_handle_open (&vhandle->dhandle);
if (!error)
{
if (n_channelsp)
*n_channelsp = vhandle->dhandle.setup.n_channels;
if (mix_freqp)
*mix_freqp = vhandle->dhandle.setup.mix_freq;
gsl_data_handle_close (&vhandle->dhandle);
return &vhandle->dhandle;
}
else
{
gsl_data_handle_unref (&vhandle->dhandle);
return NULL;
}
}
else
{
sfi_delete_struct (VorbisHandle, vhandle);
return NULL;
}
}
static void
findx ()
{
GslDataCache *dcache = gsl_data_cache_new (global_handle, 1);
GslDataHandle *shandle = gsl_data_handle_new_dcached (dcache);
GslLong length = gsl_data_handle_length (shandle);
GslLong l, start = 0, end = 0, lsize = gsl_data_handle_length (shandle) / 2;
gdouble score = 0, least = GSL_MAXLONG;
gsl_data_cache_unref (dcache);
gsl_data_handle_open (shandle);
while (lsize)
{
for (l = 0; l < length - lsize; l++)
{
GslDataHandle *dhandle = gsl_data_handle_new_looped (shandle, l, l + lsize);
gsl_data_handle_open (dhandle);
score = score_loop (shandle, dhandle);
gsl_data_handle_close (dhandle);
gsl_data_handle_unref (dhandle);
if (score < least)
{
start = l;
end = l + lsize;
g_print ("\nimproved: %f < %f: [0x%lx..0x%lx] (%lu)\n", score, least, start, end, lsize);
least = score;
}
g_print ("\rprocessed: %lu / %lu\r", l, length - lsize);
}
lsize -= 1;
}
gsl_data_handle_close (shandle);
gsl_data_handle_unref (shandle);
}
static GslErrorType
dcache_handle_open (GslDataHandle *dhandle,
GslDataHandleSetup *setup)
{
DCacheHandle *chandle = (DCacheHandle*) dhandle;
GslErrorType error;
error = gsl_data_handle_open (chandle->dcache->dhandle);
if (error != GSL_ERROR_NONE)
return error;
gsl_data_cache_open (chandle->dcache);
*setup = chandle->dcache->dhandle->setup;
gsl_data_handle_close (chandle->dcache->dhandle);
return GSL_ERROR_NONE;
}
void
bse_wave_clear (BseWave *wave)
{
g_return_if_fail (BSE_IS_WAVE (wave));
/* delete all wave chunks */
while (wave->wave_chunks)
bse_wave_remove_chunk (wave, wave->wave_chunks->data);
while (wave->open_handles)
gsl_data_handle_close (sfi_ring_pop_head (&wave->open_handles));
/* free fields */
g_free (wave->file_name);
wave->file_name = NULL;
g_free (wave->wave_name);
wave->wave_name = NULL;
g_strfreev (wave->xinfos);
wave->xinfos = NULL;
}
void
gsl_data_cache_close (GslDataCache *dcache)
{
gboolean need_unref;
g_return_if_fail (dcache != NULL);
g_return_if_fail (dcache->ref_count > 0);
g_return_if_fail (dcache->open_count > 0);
GSL_SPIN_LOCK (&dcache->mutex);
dcache->open_count--;
need_unref = !dcache->open_count;
if (!dcache->open_count)
{
dcache->high_persistency = FALSE;
gsl_data_handle_close (dcache->dhandle);
}
GSL_SPIN_UNLOCK (&dcache->mutex);
if (need_unref)
gsl_data_cache_unref (dcache);
}
void
bse_wave_remove_chunk (BseWave *wave,
GslWaveChunk *wchunk)
{
g_return_if_fail (BSE_IS_WAVE (wave));
g_return_if_fail (wchunk != NULL);
wave->wave_chunks = sfi_ring_remove (wave->wave_chunks, wchunk);
wave->n_wchunks--;
SfiRing *ring;
for (ring = wave->open_handles; ring; ring = sfi_ring_walk (ring, wave->open_handles))
if (ring->data == (void*) wchunk->dcache->dhandle)
{
gsl_data_handle_close (wchunk->dcache->dhandle);
wave->open_handles = sfi_ring_remove_node (wave->open_handles, ring);
break;
}
gsl_wave_chunk_unref (wchunk);
wave->index_dirty = TRUE;
}
