GslDataHandle*
gsl_data_handle_new_reverse (GslDataHandle *src_handle)
{
static GslDataHandleFuncs reverse_handle_vtable = {
chain_handle_open,
reverse_handle_read,
chain_handle_close,
reverse_handle_destroy,
};
ReversedHandle *rhandle;
gboolean success;
g_return_val_if_fail (src_handle != NULL, NULL);
rhandle = gsl_new_struct0 (ReversedHandle, 1);
success = gsl_data_handle_common_init (&rhandle->dhandle, NULL);
if (success)
{
rhandle->dhandle.name = g_strconcat (src_handle->name, "// #reversed /", NULL);
rhandle->dhandle.vtable = &reverse_handle_vtable;
rhandle->src_handle = gsl_data_handle_ref (src_handle);
}
else
{
gsl_delete_struct (ReversedHandle, rhandle);
return NULL;
}
return &rhandle->dhandle;
}
GslDataHandle*
gsl_data_handle_new_dcached (GslDataCache *dcache)
{
static GslDataHandleFuncs dcache_handle_vtable = {
dcache_handle_open,
dcache_handle_read,
dcache_handle_close,
dcache_handle_destroy,
};
DCacheHandle *dhandle;
gboolean success;
g_return_val_if_fail (dcache != NULL, NULL);
dhandle = gsl_new_struct0 (DCacheHandle, 1);
success = gsl_data_handle_common_init (&dhandle->dhandle, NULL);
if (success)
{
dhandle->dhandle.name = g_strdup_printf ("%s// #dcache /", dcache->dhandle->name);
dhandle->dhandle.vtable = &dcache_handle_vtable;
dhandle->dcache = gsl_data_cache_ref (dcache);
dhandle->node_size = GSL_DATA_CACHE_NODE_SIZE (dcache) + dcache->padding;
}
else
{
gsl_delete_struct (DCacheHandle, dhandle);
return NULL;
}
return &dhandle->dhandle;
}
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;
}
}
GslDataHandle*
gsl_data_handle_new_insert (GslDataHandle *src_handle,
guint paste_bit_depth,
GslLong insertion_offset,
GslLong n_paste_values,
const gfloat *paste_values,
void (*free) (gpointer values))
{
static GslDataHandleFuncs insert_handle_vtable = {
insert_handle_open,
insert_handle_read,
chain_handle_close,
insert_handle_destroy,
};
InsertHandle *ihandle;
gboolean success;
g_return_val_if_fail (src_handle != NULL, NULL);
g_return_val_if_fail (n_paste_values >= 0, NULL);
if (n_paste_values)
g_return_val_if_fail (paste_values != NULL, NULL);
ihandle = gsl_new_struct0 (InsertHandle, 1);
success = gsl_data_handle_common_init (&ihandle->dhandle, NULL);
if (success)
{
ihandle->dhandle.name = g_strconcat (src_handle ? src_handle->name : "", "// #insert /", NULL);
ihandle->dhandle.vtable = &insert_handle_vtable;
ihandle->src_handle = gsl_data_handle_ref (src_handle);
ihandle->requested_paste_offset = insertion_offset;
ihandle->paste_offset = 0;
ihandle->n_paste_values = n_paste_values;
ihandle->paste_bit_depth = paste_bit_depth;
ihandle->paste_values = paste_values;
ihandle->free_values = free;
}
else
{
gsl_delete_struct (InsertHandle, ihandle);
return NULL;
}
return &ihandle->dhandle;
}
GslDataHandle*
gsl_data_handle_new_mem (guint n_channels,
guint bit_depth,
GslLong n_values,
const gfloat *values,
void (*free) (gpointer values))
{
static GslDataHandleFuncs mem_handle_vtable = {
mem_handle_open,
mem_handle_read,
mem_handle_close,
mem_handle_destroy,
};
MemHandle *mhandle;
gboolean success;
g_return_val_if_fail (n_channels > 0, NULL);
g_return_val_if_fail (bit_depth > 0, NULL);
g_return_val_if_fail (n_values >= n_channels, NULL);
if (n_values)
g_return_val_if_fail (values != NULL, NULL);
mhandle = gsl_new_struct0 (MemHandle, 1);
success = gsl_data_handle_common_init (&mhandle->dhandle, NULL);
if (success)
{
mhandle->dhandle.name = g_strconcat ("// #memory /", NULL);
mhandle->dhandle.vtable = &mem_handle_vtable;
mhandle->n_channels = n_channels;
mhandle->bit_depth = bit_depth;
mhandle->n_values = n_values / mhandle->n_channels;
mhandle->n_values *= mhandle->n_channels;
mhandle->values = values;
mhandle->free_values = free;
}
else
{
gsl_delete_struct (MemHandle, mhandle);
return NULL;
}
return &mhandle->dhandle;
}
GslDataHandle*
gsl_wave_handle_new (const gchar *file_name,
guint n_channels,
GslWaveFormatType format,
guint byte_order,
GslLong byte_offset,
GslLong n_values)
{
static GslDataHandleFuncs wave_handle_vtable = {
wave_handle_open,
wave_handle_read,
wave_handle_close,
wave_handle_destroy,
};
WaveHandle *whandle;
g_return_val_if_fail (file_name != NULL, NULL);
g_return_val_if_fail (format > GSL_WAVE_FORMAT_NONE && format < GSL_WAVE_FORMAT_LAST, NULL);
g_return_val_if_fail (byte_order == G_LITTLE_ENDIAN || byte_order == G_BIG_ENDIAN, NULL);
g_return_val_if_fail (byte_offset >= 0, NULL);
g_return_val_if_fail (n_channels >= 1, NULL);
g_return_val_if_fail (n_values >= 1 || n_values == -1, NULL);
whandle = gsl_new_struct0 (WaveHandle, 1);
if (gsl_data_handle_common_init (&whandle->dhandle, file_name))
{
whandle->dhandle.vtable = &wave_handle_vtable;
whandle->n_channels = n_channels;
whandle->format = format;
whandle->byte_order = byte_order;
whandle->byte_offset = byte_offset;
whandle->requested_length = n_values;
whandle->hfile = NULL;
return &whandle->dhandle;
}
else
{
gsl_delete_struct (WaveHandle, whandle);
return NULL;
}
}
GslDataHandle*
gsl_data_handle_new_looped (GslDataHandle *src_handle,
GslLong loop_first,
GslLong loop_last)
{
static GslDataHandleFuncs loop_handle_vtable = {
loop_handle_open,
loop_handle_read,
chain_handle_close,
loop_handle_destroy,
};
LoopHandle *lhandle;
gboolean success;
g_return_val_if_fail (src_handle != NULL, NULL);
g_return_val_if_fail (loop_first >= 0, NULL);
g_return_val_if_fail (loop_last >= loop_first, NULL);
lhandle = gsl_new_struct0 (LoopHandle, 1);
success = gsl_data_handle_common_init (&lhandle->dhandle, NULL);
if (success)
{
lhandle->dhandle.name = g_strdup_printf ("%s// #loop(0x%lx:0x%lx) /", src_handle->name, loop_first, loop_last);
lhandle->dhandle.vtable = &loop_handle_vtable;
lhandle->src_handle = gsl_data_handle_ref (src_handle);
lhandle->requested_first = loop_first;
lhandle->requested_last = loop_last;
lhandle->loop_start = 0;
lhandle->loop_width = 0;
}
else
{
gsl_delete_struct (LoopHandle, lhandle);
return NULL;
}
return &lhandle->dhandle;
}
static GslDataHandle*
gsl_data_handle_new_translate (GslDataHandle *src_handle,
GslLong cut_offset,
GslLong n_cut_values,
GslLong tail_cut)
{
static GslDataHandleFuncs cut_handle_vtable = {
cut_handle_open,
cut_handle_read,
chain_handle_close,
cut_handle_destroy,
};
CutHandle *chandle;
gboolean success;
g_return_val_if_fail (src_handle != NULL, NULL);
g_return_val_if_fail (cut_offset >= 0 && n_cut_values >= 0 && tail_cut >= 0, NULL);
chandle = gsl_new_struct0 (CutHandle, 1);
success = gsl_data_handle_common_init (&chandle->dhandle, NULL);
if (success)
{
chandle->dhandle.name = g_strconcat (src_handle->name, "// #translate /", NULL);
chandle->dhandle.vtable = &cut_handle_vtable;
chandle->src_handle = gsl_data_handle_ref (src_handle);
chandle->cut_offset = n_cut_values ? cut_offset : 0;
chandle->n_cut_values = n_cut_values;
chandle->tail_cut = tail_cut;
}
else
{
gsl_delete_struct (CutHandle, chandle);
return NULL;
}
return &chandle->dhandle;
}
