static void
wav_start_write(int fd, WAVEHDR *fileheader, struct ng_audio_fmt *audio)
{
wav_init_header(fileheader,audio);
write(fd,fileheader,sizeof(WAVEHDR));
}
/**
* Record directly from a device to a file.
* @param device The device.
* @param file The file.
* @return Error code.
*/
int drecord(const char *device, const char *file)
{
int ret = EOK;
audio_pcm_sess_t *session = NULL;
if (str_cmp(device, "default") == 0) {
session = audio_pcm_open_default();
} else {
session = audio_pcm_open(device);
}
if (!session) {
printf("Failed to connect to device %s.\n", device);
return 1;
}
printf("Recording on device: %s.\n", device);
if (audio_pcm_query_cap(session, AUDIO_CAP_CAPTURE) <= 0) {
printf("Device %s does not support recording\n", device);
ret = ENOTSUP;
goto close_session;
}
const char* info = NULL;
ret = audio_pcm_get_info_str(session, &info);
if (ret != EOK) {
printf("Failed to get PCM info.\n");
goto close_session;
}
printf("Capturing on %s.\n", info);
free(info);
record_t rec;
record_initialize(&rec, session);
ret = audio_pcm_get_buffer(rec.device, &rec.buffer.base,
&rec.buffer.size);
if (ret != EOK) {
printf("Failed to get PCM buffer: %s.\n", str_error(ret));
goto close_session;
}
printf("Buffer: %p %zu.\n", rec.buffer.base, rec.buffer.size);
rec.file = fopen(file, "w");
if (rec.file == NULL) {
ret = ENOENT;
printf("Failed to open file: %s.\n", file);
goto cleanup;
}
wave_header_t header;
fseek(rec.file, sizeof(header), SEEK_SET);
if (ret != EOK) {
printf("Error parsing wav header\n");
goto cleanup;
}
if (audio_pcm_query_cap(rec.device, AUDIO_CAP_INTERRUPT) > 0)
record_fragment(&rec, format);
else
printf("Recording method is not supported");
//TODO consider buffer position interface
wav_init_header(&header, format, ftell(rec.file) - sizeof(header));
fseek(rec.file, 0, SEEK_SET);
fwrite(&header, sizeof(header), 1, rec.file);
cleanup:
fclose(rec.file);
as_area_destroy(rec.buffer.base);
audio_pcm_release_buffer(rec.device);
close_session:
audio_pcm_close(session);
return ret == EOK ? 0 : 1;
}
static void wav_start_write(FILE* fd, WAVEHDR *fileheader)
{
wav_init_header(fileheader);
fwrite(fileheader,1, sizeof(WAVEHDR), fd);
}
NuvieIOBuffer *ConverseSpeech::load_speech(std::string filename, uint16 sample_num)
{
unsigned char *compressed_data, *raw_audio, *wav_data;
sint16 *converted_audio;
uint32 decomp_size;
uint32 upsampled_size;
sint16 sample=0, prev_sample;
U6Lib_n sam_file;
U6Lzw lzw;
NuvieIOBuffer *wav_buffer = 0;
uint32 j, k;
sam_file.open(filename, 4);
compressed_data = sam_file.get_item(sample_num, NULL);
raw_audio = lzw.decompress_buffer(compressed_data, sam_file.get_item_size(sample_num), decomp_size);
free(compressed_data);
if(raw_audio != NULL)
{
wav_buffer = new NuvieIOBuffer();
upsampled_size = decomp_size + (int)floor((decomp_size - 1) / 4) * (2 + 2 + 2 + 1);
switch((decomp_size - 1) % 4)
{
case 1 : upsampled_size += 2; break;
case 2 : upsampled_size += 4; break;
case 3 : upsampled_size += 6; break;
}
DEBUG(0,LEVEL_DEBUGGING,"decomp_size %d, upsampled_size %d\n", decomp_size, upsampled_size);
wav_data = (unsigned char *)malloc(upsampled_size * sizeof(sint16) + 44); // 44 = size of wav header
wav_buffer->open(wav_data, upsampled_size * sizeof(sint16) + 44, false);
wav_init_header(wav_buffer, upsampled_size);
converted_audio = (sint16 *)&wav_data[44];
prev_sample = convert_sample(raw_audio[0]);
for(j=1,k=0;j<decomp_size;j++,k++)
{
converted_audio[k] = prev_sample;
sample = convert_sample(raw_audio[j]);
switch(j % 4) // calculate the in-between samples using linear interpolation.
{
case 0 :
case 1 :
case 2 :
converted_audio[k+1] = (sint16)(0.666 * (float)prev_sample + 0.333 * (float)sample);
converted_audio[k+2] = (sint16)(0.333 * (float)prev_sample + 0.666 * (float)sample);
k += 2;
break;
case 3 : converted_audio[k+1] = (sint16)(0.5 * (float)(prev_sample + sample));
k += 1;
break;
}
prev_sample = sample;
}
converted_audio[k] = sample;
}
free(raw_audio);
return wav_buffer;
}
