void WavFile::save(const std::string &fname)
{
FILE *wav_file = fopen(fname.c_str(), "wb");
if (!wav_file)
throw std::runtime_error("cannot open " + fname + " for writing");
unsigned byte_rate = _spec.sample_rate * _spec.channels * _spec.bytes_per_sample();
unsigned num_samples = _data.get_size() / _spec.channels / _spec.bytes_per_sample();
/* write RIFF header */
fwrite("RIFF", 1, 4, wav_file);
write_little_endian(36 + _spec.bytes_per_sample() * num_samples* _spec.channels, 4, wav_file);
fwrite("WAVE", 1, 4, wav_file);
/* write fmt subchunk */
fwrite("fmt ", 1, 4, wav_file);
write_little_endian(16, 4, wav_file); /* SubChunk1Size is 16 */
write_little_endian(1, 2, wav_file); /* PCM is format 1 */
write_little_endian(_spec.channels, 2, wav_file);
write_little_endian(_spec.sample_rate, 4, wav_file);
write_little_endian(byte_rate, 4, wav_file);
write_little_endian(_spec.channels * _spec.bytes_per_sample(), 2, wav_file); /* block align */
write_little_endian(8 * _spec.bytes_per_sample(), 2, wav_file); /* bits/sample */
/* write data subchunk */
fwrite("data", 1, 4, wav_file);
write_little_endian(_spec.bytes_per_sample() * num_samples * _spec.channels, 4, wav_file);
fwrite(_data.get_ptr(), _data.get_size(), 1, wav_file);
fclose(wav_file);
}
int main()
{
const double V=127;
FILE * wav_file;
unsigned int sample_rate = 8000;
unsigned int num_channels = 1;
unsigned int bytes_per_sample;
unsigned int byte_rate;
unsigned int num_samples = 76000;
wav_file = fopen("out.wav", "w");
num_channels = 1; /* monoaural */
bytes_per_sample = 2;
byte_rate = sample_rate*num_channels*bytes_per_sample;
// https://ccrma.stanford.edu/courses/422/projects/WaveFormat/
/* write RIFF header */
fwrite("RIFF", 1, 4, wav_file);
write_little_endian(36 + bytes_per_sample* num_samples*num_channels, 4, wav_file);
fwrite("WAVE", 1, 4, wav_file);
/* write fmt subchunk */
fwrite("fmt ", 1, 4, wav_file);
write_little_endian(16, 4, wav_file); /* SubChunk1Size is 16 */
write_little_endian(1, 2, wav_file); /* PCM is format 1 */
write_little_endian(num_channels, 2, wav_file);
write_little_endian(sample_rate, 4, wav_file);
write_little_endian(byte_rate, 4, wav_file);
write_little_endian(num_channels*bytes_per_sample, 2, wav_file); /* block align */
write_little_endian(8*bytes_per_sample, 2, wav_file); /* bits/sample */
/* write data subchunk */
fwrite("data", 1, 4, wav_file);
write_little_endian(bytes_per_sample* num_samples*num_channels, 4, wav_file);
////////////////////////////////////////////////////////////////
write_sound(wav_file, sample_rate, V, 8000, piano_note_to_frequency(C_4));
write_sound(wav_file, sample_rate, V, 8000, piano_note_to_frequency(E_4));
write_sound(wav_file, sample_rate, V, 4000, 0);
write_sound(wav_file, sample_rate, V, 8000, piano_note_to_frequency(G_4));
write_sound(wav_file, sample_rate, V, 4000, 0);
write_sound(wav_file, sample_rate, V, 4000, piano_note_to_frequency(G_4));
write_sound(wav_file, sample_rate, V, 4000, 0);
write_sound(wav_file, sample_rate, V, 4000, piano_note_to_frequency(G_4));
write_sound(wav_file, sample_rate, V, 4000, 0);
write_sound(wav_file, sample_rate, V, 4000, piano_note_to_frequency(G_4));
write_sound(wav_file, sample_rate, V, 24000, 0);
fclose(wav_file);
printf("done.\n");
return 0;
}
// Found at: http://karplus4arduino.wordpress.com/2011/10/08/making-wav-files-from-c-programs/
void Logger::rawToWav(const char *out_file, const char *in_file, int s_rate)
{
QFile wav_file;
wav_file.setFileName(out_file);
QFile raw_file;
raw_file.setFileName(in_file);
unsigned int sample_rate;
unsigned int num_channels;
unsigned int bytes_per_sample;
unsigned int byte_rate;
num_channels = 1; /* monoaural */
bytes_per_sample = 1;
if (s_rate <= 0) {
sample_rate = 44100;
} else {
sample_rate = (unsigned int)s_rate;
}
byte_rate = sample_rate * num_channels * bytes_per_sample;
wav_file.open(QIODevice::WriteOnly | QIODevice::Truncate);
raw_file.open(QIODevice::ReadOnly);
int num_samples = raw_file.size() / 2;
/* write RIFF header */
wav_file.write("RIFF", 4);
write_little_endian(36 + bytes_per_sample * num_samples * num_channels, 4, wav_file);
wav_file.write("WAVE", 4);
/* write fmt subchunk */
wav_file.write("fmt ", 4);
write_little_endian(16, 4, wav_file); /* SubChunk1Size is 16 */
write_little_endian(1, 2, wav_file); /* PCM is format 1 */
write_little_endian(num_channels, 2, wav_file);
write_little_endian(sample_rate, 4, wav_file);
write_little_endian(byte_rate, 4, wav_file);
write_little_endian(num_channels * bytes_per_sample, 2, wav_file); /* block align */
write_little_endian(8 * bytes_per_sample, 2, wav_file); /* bits/sample */
/* write data subchunk */
wav_file.write("data", 4);
for(;;) {
QByteArray d = raw_file.read(500);
if (d.isEmpty()) {
break;
}
wav_file.write(d);
}
wav_file.close();
raw_file.close();
}
std::string little_endian_string(ulong input, std::size_t size)
{
char * buffer = new char[size];
write_little_endian(input, buffer, size);
std::string output = std::string(buffer, size);
delete buffer;
return output;
}
void write_wav(char * filename, unsigned long num_samples, short int * data, int s_rate)
{
FILE* wav_file;
unsigned int sample_rate;
unsigned int num_channels;
unsigned int bytes_per_sample;
unsigned int byte_rate;
unsigned long i; /* counter for samples */
num_channels = 1; /* monoaural */
bytes_per_sample = 2;
if (s_rate<=0) sample_rate = 48000;
else sample_rate = (unsigned int) s_rate;
byte_rate = sample_rate*num_channels*bytes_per_sample;
wav_file = fopen(filename, "w");
assert(wav_file); /* make sure it opened */
/* write RIFF header */
fwrite("RIFF", 1, 4, wav_file);
write_little_endian(36 + bytes_per_sample* num_samples*num_channels, 4, wav_file);
fwrite("WAVE", 1, 4, wav_file);
/* write fmt subchunk */
fwrite("fmt ", 1, 4, wav_file);
write_little_endian(16, 4, wav_file); /* SubChunk1Size is 16 */
write_little_endian(1, 2, wav_file); /* PCM is format 1 */
write_little_endian(num_channels, 2, wav_file);
write_little_endian(sample_rate, 4, wav_file);
write_little_endian(byte_rate, 4, wav_file);
write_little_endian(num_channels*bytes_per_sample, 2, wav_file); /* block align */
write_little_endian(8*bytes_per_sample, 2, wav_file); /* bits/sample */
/* write data subchunk */
fwrite("data", 1, 4, wav_file);
write_little_endian(bytes_per_sample* num_samples*num_channels, 4, wav_file);
for (i=0; i< num_samples; i++)
{ write_little_endian((unsigned int)(data[i]),bytes_per_sample, wav_file);
}
fclose(wav_file);
}
// Write the count value to the first 32 bits of the file after the header.
void record_manager::write_count()
{
BITCOIN_ASSERT(header_size_ + sizeof(array_index) <= file_.size());
// The accessor must remain in scope until the end of the block.
auto memory = file_.access();
auto payload_size_address = REMAP_ADDRESS(memory) + header_size_;
auto serial = make_serializer(payload_size_address);
serial.write_little_endian(record_count_);
}
void write_wav_header(char * filename, unsigned int s_rate, unsigned long num_samples, unsigned int num_channels, unsigned int bits_per_sample)
{
FILE* wav_file;
unsigned int sample_rate;
unsigned int byte_rate;
/*unsigned long i; counter for samples */
if (s_rate<=0) sample_rate = 44100;
else sample_rate = (unsigned int) s_rate;
int is_stdout = !strcmp(filename, "stdout");
byte_rate = sample_rate*num_channels*bits_per_sample;
if(!is_stdout)
{
wav_file = fopen(filename, "w");
assert(wav_file); /* make sure it opened */
}
/* write RIFF header */
if(is_stdout)
{
fwrite("RIFF", 1, 4, stdout);
}
else
{
fwrite("RIFF", 1, 4, wav_file);
}
write_little_endian(bits_per_sample* num_samples*num_channels - 8, 4, wav_file, is_stdout);
if(is_stdout)
{
fwrite("WAVE", 1, 4, stdout);
}
else
{
fwrite("WAVE", 1, 4, wav_file);
}
/* write fmt subchunk */
if(is_stdout)
{
fwrite("WAVE", 1, 4, stdout);
}
else
{
fwrite("fmt ", 1, 4, wav_file);
}
write_little_endian(16, 4, wav_file, is_stdout); /* SubChunk1Size is 16 */
write_little_endian(1, 2, wav_file, is_stdout); /* PCM is format 1 */
write_little_endian(num_channels, 2, wav_file, is_stdout);
write_little_endian(sample_rate, 4, wav_file, is_stdout);
write_little_endian(byte_rate, 4, wav_file, is_stdout);
write_little_endian(num_channels*bits_per_sample, 2, wav_file, is_stdout); /* block align */
write_little_endian(bits_per_sample, 2, wav_file, is_stdout); /* bits/sample */
/* write data subchunk */
if(is_stdout)
{
fwrite("WAVE", 1, 4, stdout);
}
else
{
fwrite("data", 1, 4, wav_file);
}
write_little_endian(bits_per_sample* num_samples*num_channels, 4, wav_file, is_stdout);
/* Used for when data was passed in */
/* for (i=0; i< num_samples; i++)
{ write_little_endian((unsigned int)(data[i]),bits_per_sample, wav_file);
}*/
if(!is_stdout)
{
fclose(wav_file);
}
}
// Write the size value to the first chunk of the file.
// This write is not atomic and therefore assumes there are no readers.
void slab_allocator::write_size()
{
BITCOIN_ASSERT(size_ <= file_.size());
auto serial = make_serializer(data(0));
serial.write_little_endian(size_);
}
