25 Sep
2014
25 Sep
'14
9:50 p.m.
Does someone know about writing WAV using libsndfile?
My file becomes 174M big as using sf_writef_short() within 8s
please take a look at
http://ags.sf.net
25 Sep
25 Sep
10:02 p.m.
On Thu, Sep 25, 2014 at 8:50 PM, Joël Krähemann <weedlight(a)gmail.com> wrote:
Does someone know about writing WAV using libsndfile?
My file becomes 174M big as using sf_writef_short() within 8s
Are you sure you're only writing each sample once? Sounds like there's
an error in writing "nframe" samples for each sample or something.
Its pretty easy: and there's a brilliant to-the-point blog post on
using C++ interface (sndfile.hh) here:
http://parumi.wordpress.com/2007/12/16/how-to-write-wav-files-in-c-using-li…
If there's still issues, please pastebin some code, or ask a more
specific question :)
HTH, -Harry
11:51 p.m.
On Thu, 2014-09-25 at 21:02 +0100, Harry van Haaren wrote:
On Thu, Sep 25, 2014 at 8:50 PM, Joël Krähemann
<weedlight(a)gmail.com> wrote:
There probably only those three functions involved:
void
ags_export_output_launch(AgsTask *task)
{
AgsExportOutput *export_output;
AgsExportThread *export_thread;
AgsDevout *devout;
AgsAudioFile *audio_file;
gchar *filename;
export_output = AGS_EXPORT_OUTPUT(task);
devout = export_output->devout;
export_thread = export_output->export_thread;
filename = export_output->filename;
/* open read/write audio file */
audio_file = ags_audio_file_new(filename,
devout,
0, devout->dsp_channels);
audio_file->samplerate = (int) devout->frequency;
audio_file->channels = devout->dsp_channels;
// audio_file->format = devout->bits;
audio_file->frames = export_output->frames;
ags_audio_file_rw_open(audio_file,
TRUE);
g_message("export output");
/* start export thread */
g_object_set(G_OBJECT(export_thread),
"audio-file\0", audio_file,
NULL);
ags_thread_start(export_thread);
}
void
ags_export_thread_run(AgsThread *thread)
{
AgsExportThread *export_thread;
AgsDevout *devout;
export_thread = AGS_EXPORT_THREAD(thread);
devout = thread->devout;
if((AGS_DEVOUT_BUFFER1 & (devout->flags)) != 0){
ags_audio_file_write(export_thread->audio_file,
devout->buffer[0], devout->buffer_size);
}else if((AGS_DEVOUT_BUFFER2 & (devout->flags)) != 0){
ags_audio_file_write(export_thread->audio_file,
devout->buffer[1], devout->buffer_size);
}else if((AGS_DEVOUT_BUFFER3 & (devout->flags)) != 0){
ags_audio_file_write(export_thread->audio_file,
devout->buffer[2], devout->buffer_size);
}else if((AGS_DEVOUT_BUFFER0 & (devout->flags)) != 0){
ags_audio_file_write(export_thread->audio_file,
devout->buffer[3], devout->buffer_size1);
}
}
void
ags_sndfile_write(AgsPlayable *playable, signed short *buffer, guint
buffer_length)
{
AgsSndfile *sndfile;
sf_count_t multi_frames, retval;
sndfile = AGS_SNDFILE(playable);
multi_frames = buffer_length;
retval = sf_write_short(sndfile->file, buffer, multi_frames);
if(retval > multi_frames){
// sf_seek(sndfile->file, (multi_frames - retval),
SEEK_CUR);
}
}
Does someone know about writing WAV using
libsndfile?
My file becomes 174M big as using sf_writef_short() within 8s
Are you sure you're only writing each sample once? Sounds like there's
an error in writing "nframe" samples for each sample or something.
Its pretty easy: and there's a brilliant to-the-point blog post on
using C++ interface (sndfile.hh) here:
http://parumi.wordpress.com/2007/12/16/how-to-write-wav-files-in-c-using-li…
If there's still issues, please pastebin some code, or ask a more
specific question :)
HTH, -Harry 
26 Sep
26 Sep
10:22 a.m.
On 09/25/2014 11:50 PM, Joël Krähemann wrote:
void
ags_sndfile_write(AgsPlayable *playable, signed short *buffer, guint
buffer_length)
{
AgsSndfile *sndfile;
sf_count_t multi_frames, retval;
sndfile = AGS_SNDFILE(playable);
multi_frames = buffer_length;
retval = sf_write_short(sndfile->file, buffer, multi_frames);
If buffer_length gives the number of bytes of the buffer,
you may be in trouble here. For sf_write_short, /usr/include/sndfile.h
says:
** All of these read/write function return number of items read/written.
See also the libsndfile FAQ:
http://www.mega-nerd.com/libsndfile/FAQ.html#Q012
HTH
if(retval > multi_frames){
// sf_seek(sndfile->file, (multi_frames - retval),
SEEK_CUR);
}
}
12:15 p.m.
On Fri, 2014-09-26 at 10:20 +0200, Cedric Roux wrote:
On 09/25/2014 11:50 PM, Joël Krähemann wrote:
This is how the buffer is allocated. Strange to me is
multi_frames = buffer_length;
or
multi_frames = sndfile->file->info->channels * buffer_length;
gives about the same size of file.
/* buffer */
devout->buffer = (signed short **) malloc(4 * sizeof(signed short*));
devout->buffer[0] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
devout->buffer[1] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
devout->buffer[2] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
devout->buffer[3] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
void
ags_sndfile_write(AgsPlayable *playable, signed short *buffer, guint
buffer_length)
{
AgsSndfile *sndfile;
sf_count_t multi_frames, retval;
sndfile = AGS_SNDFILE(playable);
multi_frames = buffer_length;
retval = sf_write_short(sndfile->file, buffer, multi_frames);
If buffer_length gives the number of bytes of the buffer,
you may be in trouble here. For sf_write_short, /usr/include/sndfile.h
says:
** All of these read/write function return number of items read/written.
See also the libsndfile FAQ:
http://www.mega-nerd.com/libsndfile/FAQ.html#Q012
HTH
>
> if(retval > multi_frames){
> // sf_seek(sndfile->file, (multi_frames - retval),
> SEEK_CUR);
> }
> }
1:40 p.m.
On Fri, 2014-09-26 at 12:15 +0200, Joël Krähemann wrote:
On Fri, 2014-09-26 at 10:20 +0200, Cedric Roux wrote:
The code should be correct rather a problem with the thread tree, once
more.
On 09/25/2014 11:50 PM, Joël Krähemann wrote:
This is how the buffer is allocated. Strange to me is
multi_frames = buffer_length;
or
multi_frames = sndfile->file->info->channels * buffer_length;
gives about the same size of file.
/* buffer */
devout->buffer = (signed short **) malloc(4 * sizeof(signed short*));
devout->buffer[0] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
devout->buffer[1] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
devout->buffer[2] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
devout->buffer[3] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
void
ags_sndfile_write(AgsPlayable *playable, signed short *buffer, guint
buffer_length)
{
AgsSndfile *sndfile;
sf_count_t multi_frames, retval;
sndfile = AGS_SNDFILE(playable);
multi_frames = buffer_length;
retval = sf_write_short(sndfile->file, buffer, multi_frames);
If buffer_length gives the number of bytes of the buffer,
you may be in trouble here. For sf_write_short, /usr/include/sndfile.h
says:
** All of these read/write function return number of items read/written.
See also the libsndfile FAQ:
http://www.mega-nerd.com/libsndfile/FAQ.html#Q012
HTH
>
> if(retval > multi_frames){
> // sf_seek(sndfile->file, (multi_frames - retval),
> SEEK_CUR);
> }
> }
27 Sep
27 Sep
7:11 a.m.
On Fri, 2014-09-26 at 13:40 +0200, Joël Krähemann wrote:
On Fri, 2014-09-26 at 12:15 +0200, Joël Krähemann
wrote:
Am I correct assuming 1 sample of stereo frames will be written 44100
times by a rate of 44100 Hz audio sampled data?
Whereby one sample contains 2 frames. For one second, this would be a
sized array of:
CHANNELS = 2
buffer_size_per_second = CHANNELS * 44100 * sizeof(signed short);
On Fri, 2014-09-26 at 10:20 +0200, Cedric Roux
wrote:
The code should be correct rather a problem with the thread tree, once
more.
On 09/25/2014 11:50 PM, Joël Krähemann wrote:
This is how the buffer is allocated. Strange to me is
multi_frames = buffer_length;
or
multi_frames = sndfile->file->info->channels * buffer_length;
gives about the same size of file.
/* buffer */
devout->buffer = (signed short **) malloc(4 * sizeof(signed short*));
devout->buffer[0] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
devout->buffer[1] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
devout->buffer[2] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
devout->buffer[3] = (signed short *) malloc(devout->dsp_channels *
devout->buffer_size * sizeof(signed short));
void
ags_sndfile_write(AgsPlayable *playable, signed short *buffer, guint
buffer_length)
{
AgsSndfile *sndfile;
sf_count_t multi_frames, retval;
sndfile = AGS_SNDFILE(playable);
multi_frames = buffer_length;
retval = sf_write_short(sndfile->file, buffer, multi_frames);
If buffer_length gives the number of bytes of the buffer,
you may be in trouble here. For sf_write_short, /usr/include/sndfile.h
says:
** All of these read/write function return number of items read/written.
See also the libsndfile FAQ:
http://www.mega-nerd.com/libsndfile/FAQ.html#Q012
HTH
>
> if(retval > multi_frames){
> // sf_seek(sndfile->file, (multi_frames - retval),
> SEEK_CUR);
> }
> }
10:36 a.m.
On Sat, Sep 27, 2014 at 6:11 AM, Joël Krähemann <weedlight(a)gmail.com> wrote:
Am I correct assuming 1 sample of stereo frames will
be written 44100
times by a rate of 44100 Hz audio sampled data?
Yes. Just to be 100% clear, a
"sample" is a *single* point of data.
In a mono situation: a "frame" refers to the single sample for that channel.
In stereo: a "frame" refers to 2 samples, one for *each* channel.
So the difference between a frame and a sample is that a sample is
literally a single data point, while a frame is a single "data point"
for each channel.
Whereby one sample contains 2 frames.
See above
:)
CHANNELS = 2
buffer_size_per_second = CHANNELS * 44100 * sizeof(signed short);
Yep. The link
below is useful for double checking, and for quick disk
space calculations:
http://www.sounddevices.com/calculator/
I've written a tutorial on using SndFile to write to disk: perhaps a
useful resource to check / play with:
https://github.com/harryhaaren/openAudioProgrammingTutorials/blob/master/wr…
HTH, -Harry
--
www.openavproductions.com
12:34 p.m.
On sab, 2014-09-27 at 09:36 +0100, Harry van Haaren wrote:
On Sat, Sep 27, 2014 at 6:11 AM, Joël Krähemann
<weedlight(a)gmail.com> wrote:
Do you know that WAV is interleaved? Currently I'm looking for something
like encoding multi-channel sources.
Am I correct assuming 1 sample of stereo frames
will be written 44100
times by a rate of 44100 Hz audio sampled data?
Yes. Just to be 100% clear, a
"sample" is a *single* point of data.
In a mono situation: a "frame" refers to the single sample for that channel.
In stereo: a "frame" refers to 2 samples, one for *each* channel.
So the difference between a frame and a sample is that a sample is
literally a single data point, while a frame is a single "data point"
for each channel.
Whereby one sample contains 2 frames.
See
above :)
CHANNELS = 2
buffer_size_per_second = CHANNELS * 44100 * sizeof(signed short);
Yep. The link
below is useful for double checking, and for quick disk
space calculations:
http://www.sounddevices.com/calculator/
I've written a tutorial on using SndFile to write to disk: perhaps a
useful resource to check / play with:
https://github.com/harryhaaren/openAudioProgrammingTutorials/blob/master/wr…
HTH, -Harry
3497
days inactive
3499
days old
linux-audio-dev@lists.linuxaudio.org
8 comments
3 participants
participants (3)
-
Cedric Roux -
Harry van Haaren -
Joël Krähemann