void Mixer::clear(int length) { m_buffer.assureSize(length * m_specs.channels * AUD_SAMPLE_SIZE(m_specs)); m_length = length; std::memset(m_buffer.getBuffer(), 0, length * m_specs.channels * AUD_SAMPLE_SIZE(m_specs)); }
void AUD_FileWriter::writeReader(AUD_Reference<AUD_IReader> reader, AUD_Reference<AUD_IWriter> writer, unsigned int length, unsigned int buffersize) { AUD_Buffer buffer(buffersize * AUD_SAMPLE_SIZE(writer->getSpecs())); sample_t* buf = buffer.getBuffer(); int len; bool eos = false; int channels = writer->getSpecs().channels; for(unsigned int pos = 0; ((pos < length) || (length <= 0)) && !eos; pos += len) { len = buffersize; if((len > length - pos) && (length > 0)) len = length - pos; reader->read(len, eos, buf); for(int i = 0; i < len * channels; i++) { // clamping! if(buf[i] > 1) buf[i] = 1; else if(buf[i] < -1) buf[i] = -1; } writer->write(len, buf); } }
void AUD_FileWriter::writeReader(AUD_Reference<AUD_IReader> reader, std::vector<AUD_Reference<AUD_IWriter> >& writers, unsigned int length, unsigned int buffersize) { AUD_Buffer buffer(buffersize * AUD_SAMPLE_SIZE(reader->getSpecs())); AUD_Buffer buffer2(buffersize * sizeof(sample_t)); sample_t* buf = buffer.getBuffer(); sample_t* buf2 = buffer2.getBuffer(); int len; bool eos = false; int channels = reader->getSpecs().channels; for(unsigned int pos = 0; ((pos < length) || (length <= 0)) && !eos; pos += len) { len = buffersize; if((len > length - pos) && (length > 0)) len = length - pos; reader->read(len, eos, buf); for(int channel = 0; channel < channels; channel++) { for(int i = 0; i < len; i++) { // clamping! if(buf[i * channels + channel] > 1) buf2[i] = 1; else if(buf[i * channels + channel] < -1) buf2[i] = -1; else buf2[i] = buf[i * channels + channel]; } writers[channel]->write(len, buf2); } } }
void AUD_SuperposeReader::read(int& length, bool& eos, sample_t* buffer) { AUD_Specs specs = m_reader1->getSpecs(); AUD_Specs s2 = m_reader2->getSpecs(); if(!AUD_COMPARE_SPECS(specs, s2)) AUD_THROW(AUD_ERROR_SPECS, specs_error); int samplesize = AUD_SAMPLE_SIZE(specs); m_buffer.assureSize(length * samplesize); int len1 = length; m_reader1->read(len1, eos, buffer); if(len1 < length) memset(buffer + len1 * specs.channels, 0, (length - len1) * samplesize); int len2 = length; bool eos2; sample_t* buf = m_buffer.getBuffer(); m_reader2->read(len2, eos2, buf); for(int i = 0; i < len2 * specs.channels; i++) buffer[i] += buf[i]; length = AUD_MAX(len1, len2); eos &= eos2; }
void AUD_SuperposeReader::read(int & length, sample_t* & buffer) { AUD_Specs specs = m_reader1->getSpecs(); int samplesize = AUD_SAMPLE_SIZE(specs); if(m_buffer.getSize() < length * samplesize) m_buffer.resize(length * samplesize); buffer = m_buffer.getBuffer(); int len1 = length; sample_t* buf; m_reader1->read(len1, buf); memcpy(buffer, buf, len1 * samplesize); if(len1 < length) memset(buffer + len1 * specs.channels, 0, (length - len1) * samplesize); int len2 = length; m_reader2->read(len2, buf); for(int i = 0; i < len2 * specs.channels; i++) buffer[i] += buf[i]; length = AUD_MAX(len1, len2); }
void AUD_BaseIIRFilterReader::read(int & length, sample_t* & buffer) { sample_t* buf; int samplesize = AUD_SAMPLE_SIZE(m_reader->getSpecs()); m_reader->read(length, buf); if(m_buffer.getSize() < length * samplesize) m_buffer.resize(length * samplesize); buffer = m_buffer.getBuffer(); for(m_channel = 0; m_channel < m_channels; m_channel++) { for(int i = 0; i < length; i++) { m_x[m_xpos * CC] = buf[i * CC]; m_y[m_ypos * CC] = buffer[i * CC] = filter(); m_xpos = (m_xpos + 1) % m_xlen; m_ypos = (m_ypos + 1) % m_ylen; } } }
AUD_NAMESPACE_BEGIN void JackDevice::updateRingBuffers() { size_t size, temp; unsigned int samplesize = AUD_SAMPLE_SIZE(m_specs); unsigned int i, j; unsigned int channels = m_specs.channels; sample_t* buffer = m_buffer.getBuffer(); float* deinterleave = m_deinterleavebuf.getBuffer(); jack_transport_state_t state; jack_position_t position; std::unique_lock<std::mutex> lock(m_mixingLock); while(m_valid) { if(m_sync > 1) { if(m_syncFunc) { state = AUD_jack_transport_query(m_client, &position); m_syncFunc(m_syncFuncData, state != JackTransportStopped, position.frame / (float) m_specs.rate); } for(i = 0; i < channels; i++) AUD_jack_ringbuffer_reset(m_ringbuffers[i]); } size = AUD_jack_ringbuffer_write_space(m_ringbuffers[0]); for(i = 1; i < channels; i++) if((temp = AUD_jack_ringbuffer_write_space(m_ringbuffers[i])) < size) size = temp; while(size > samplesize) { size /= samplesize; mix((data_t*)buffer, size); for(i = 0; i < channels; i++) { for(j = 0; j < size; j++) deinterleave[i * size + j] = buffer[i + j * channels]; AUD_jack_ringbuffer_write(m_ringbuffers[i], (char*)(deinterleave + i * size), size * sizeof(float)); } size = AUD_jack_ringbuffer_write_space(m_ringbuffers[0]); for(i = 1; i < channels; i++) if((temp = AUD_jack_ringbuffer_write_space(m_ringbuffers[i])) < size) size = temp; } if(m_sync > 1) { m_sync = 3; } m_mixingCondition.wait(lock); } }
AUD_NAMESPACE_BEGIN LimiterReader::LimiterReader(std::shared_ptr<IReader> reader, float start, float end) : EffectReader(reader), m_start(start), m_end(end) { if(m_start > 0) { Specs specs = m_reader->getSpecs(); Specs specs2; if(m_reader->isSeekable()) m_reader->seek(m_start * specs.rate); else { // skip first m_start samples by reading them int length = AUD_DEFAULT_BUFFER_SIZE; Buffer buffer(AUD_DEFAULT_BUFFER_SIZE * AUD_SAMPLE_SIZE(specs)); bool eos = false; for(int len = m_start * specs.rate; length > 0 && !eos; len -= length) { if(len < AUD_DEFAULT_BUFFER_SIZE) length = len; m_reader->read(length, eos, buffer.getBuffer()); specs2 = m_reader->getSpecs(); if(specs2.rate != specs.rate) { len = len * specs2.rate / specs.rate; specs.rate = specs2.rate; } if(specs2.channels != specs.channels) { specs = specs2; buffer.assureSize(AUD_DEFAULT_BUFFER_SIZE * AUD_SAMPLE_SIZE(specs)); } } } } }
long AUD_SRCResampleReader::doCallback(float** data) { int length = m_buffer.getSize() / AUD_SAMPLE_SIZE(m_tspecs); sample_t* buffer; m_reader->read(length, buffer); *data = buffer; return length; }
AUD_LinearResampleReader::AUD_LinearResampleReader(boost::shared_ptr<AUD_IReader> reader, AUD_Specs specs) : AUD_ResampleReader(reader, specs.rate), m_channels(reader->getSpecs().channels), m_cache_pos(0), m_cache_ok(false) { specs.channels = m_channels; m_cache.resize(2 * AUD_SAMPLE_SIZE(specs)); }
void FFMPEGWriter::write(unsigned int length, sample_t* buffer) { unsigned int samplesize = AUD_SAMPLE_SIZE(m_specs); if(m_input_size) { sample_t* inbuf = m_input_buffer.getBuffer(); while(length) { unsigned int len = std::min(m_input_size - m_input_samples, length); std::memcpy(inbuf + m_input_samples * m_specs.channels, buffer, len * samplesize); buffer += len * m_specs.channels; m_input_samples += len; m_position += len; length -= len; if(m_input_samples == m_input_size) { encode(); m_input_samples = 0; } } } else // PCM data, can write directly! { int samplesize = AUD_SAMPLE_SIZE(m_specs); m_input_buffer.assureSize(length * std::max(AUD_DEVICE_SAMPLE_SIZE(m_specs), samplesize)); sample_t* buf = m_input_buffer.getBuffer(); m_convert(reinterpret_cast<data_t*>(buf), reinterpret_cast<data_t*>(buffer), length * m_specs.channels); m_input_samples = length; m_position += length; encode(); } }
void AUD_FFMPEGWriter::write(unsigned int length, sample_t* buffer) { unsigned int samplesize = AUD_SAMPLE_SIZE(m_specs); if(m_input_size) { sample_t* inbuf = m_input_buffer.getBuffer(); while(length) { unsigned int len = AUD_MIN(m_input_size - m_input_samples, length); memcpy(inbuf + m_input_samples * m_specs.channels, buffer, len * samplesize); buffer += len * m_specs.channels; m_input_samples += len; m_position += len; length -= len; if(m_input_samples == m_input_size) { encode(inbuf); m_input_samples = 0; } } } else // PCM data, can write directly! { int samplesize = AUD_SAMPLE_SIZE(m_specs); if(m_output_buffer.getSize() != length * m_specs.channels * m_codecCtx->bits_per_coded_sample / 8) m_output_buffer.resize(length * m_specs.channels * m_codecCtx->bits_per_coded_sample / 8); m_input_buffer.assureSize(length * AUD_MAX(AUD_DEVICE_SAMPLE_SIZE(m_specs), samplesize)); sample_t* buf = m_input_buffer.getBuffer(); m_convert(reinterpret_cast<data_t*>(buf), reinterpret_cast<data_t*>(buffer), length * m_specs.channels); encode(buf); m_position += length; } }
void AUD_ConverterReader::read(int& length, bool& eos, sample_t* buffer) { AUD_Specs specs = m_reader->getSpecs(); int samplesize = AUD_SAMPLE_SIZE(specs); m_buffer.assureSize(length * samplesize); m_reader->read(length, eos, m_buffer.getBuffer()); m_convert((data_t*)buffer, (data_t*)m_buffer.getBuffer(), length * specs.channels); }
AUD_NAMESPACE_BEGIN LinearResampleReader::LinearResampleReader(std::shared_ptr<IReader> reader, Specs specs) : ResampleReader(reader, specs.rate), m_channels(reader->getSpecs().channels), m_cache_pos(0), m_cache_ok(false) { specs.channels = m_channels; m_cache.resize(2 * AUD_SAMPLE_SIZE(specs)); }
long AUD_SRCResampleReader::doCallback(float** data) { AUD_Specs specs; specs.channels = m_channels; specs.rate = m_rate; int length = m_buffer.getSize() / AUD_SAMPLE_SIZE(specs); *data = m_buffer.getBuffer(); m_reader->read(length, m_eos, *data); return length; }
void AUD_SRCResampleReader::read(int & length, sample_t* & buffer) { int size = length * AUD_SAMPLE_SIZE(m_tspecs); if(m_buffer.getSize() < size) m_buffer.resize(size); buffer = m_buffer.getBuffer(); length = src_callback_read(m_src, m_factor, length, buffer); m_position += length; }
int AUD_readSound(AUD_Sound* sound, sample_t* buffer, int length, int samples_per_second) { AUD_DeviceSpecs specs; sample_t* buf; AUD_Buffer aBuffer; specs.rate = AUD_RATE_INVALID; specs.channels = AUD_CHANNELS_MONO; specs.format = AUD_FORMAT_INVALID; AUD_Reference<AUD_IReader> reader = AUD_ChannelMapperFactory(*sound, specs).createReader(); specs.specs = reader->getSpecs(); int len; float samplejump = specs.rate / samples_per_second; float min, max, power; bool eos; for(int i = 0; i < length; i++) { len = floor(samplejump * (i+1)) - floor(samplejump * i); aBuffer.assureSize(len * AUD_SAMPLE_SIZE(specs)); buf = aBuffer.getBuffer(); reader->read(len, eos, buf); max = min = *buf; power = *buf * *buf; for(int j = 1; j < len; j++) { if(buf[j] < min) min = buf[j]; if(buf[j] > max) max = buf[j]; power += buf[j] * buf[j]; } buffer[i * 3] = min; buffer[i * 3 + 1] = max; buffer[i * 3 + 2] = sqrt(power) / len; if(eos) { length = i; break; } } return length; }
void AUD_SndFileReader::read(int & length, sample_t* & buffer) { int sample_size = AUD_SAMPLE_SIZE(m_specs); // resize output buffer if necessary if(m_buffer.getSize() < length*sample_size) m_buffer.resize(length*sample_size); buffer = m_buffer.getBuffer(); length = sf_readf_float(m_sndfile, buffer, length); m_position += length; }
void AUD_ChannelMapperReader::read(int & length, sample_t* & buffer) { sample_t* in = buffer; m_reader->read(length, in); if(m_buffer.getSize() < length * AUD_SAMPLE_SIZE(m_specs)) m_buffer.resize(length * AUD_SAMPLE_SIZE(m_specs)); buffer = m_buffer.getBuffer(); sample_t sum; for(int i = 0; i < length; i++) { for(int j = 0; j < m_specs.channels; j++) { sum = 0; for(int k = 0; k < m_rch; k++) sum += m_mapping[j][k] * in[i * m_rch + k]; buffer[i * m_specs.channels + j] = sum; } } }
void AUD_LoopReader::read(int & length, sample_t* & buffer) { AUD_Specs specs = m_reader->getSpecs(); int samplesize = AUD_SAMPLE_SIZE(specs); int len = length; m_reader->read(len, buffer); if(len < length && m_left) { int pos = 0; if(m_buffer.getSize() < length * samplesize) m_buffer.resize(length * samplesize); sample_t* buf = m_buffer.getBuffer(); memcpy(buf + pos * specs.channels, buffer, len * samplesize); pos += len; while(pos < length && m_left) { if(m_left > 0) m_left--; m_reader->seek(0); len = length - pos; m_reader->read(len, buffer); // prevent endless loop if(!len) break; memcpy(buf + pos * specs.channels, buffer, len * samplesize); pos += len; } length = pos; buffer = buf; } else length = len; }
void AUD_ReverseReader::read(int & length, sample_t* & buffer) { // first correct the length if(m_position + length > m_length) length = m_length - m_position; if(length <= 0) { length = 0; return; } AUD_Specs specs = getSpecs(); int samplesize = AUD_SAMPLE_SIZE(specs); // resize buffer if needed if(m_buffer.getSize() < length * samplesize) m_buffer.resize(length * samplesize); buffer = m_buffer.getBuffer(); sample_t* buf; int len = length; // read from reader m_reader->seek(m_length - m_position - len); m_reader->read(len, buf); // set null if reader didn't give enough data if(len < length) { memset(buffer, 0, (length - len) * samplesize); buffer += (length - len) * specs.channels; } // copy the samples reverted for(int i = 0; i < len; i++) memcpy(buffer + i * specs.channels, buf + (len - 1 - i) * specs.channels, samplesize); m_position += length; buffer = m_buffer.getBuffer(); }
void AUD_LoopReader::read(int & length, sample_t* & buffer) { int samplesize = AUD_SAMPLE_SIZE(m_reader->getSpecs()); int len = length; m_reader->read(len, buffer); if(len < length && m_loop != 0) { int pos = 0; if(m_buffer->getSize() < length*samplesize) m_buffer->resize(length*samplesize); memcpy(m_buffer->getBuffer() + pos * samplesize, buffer, len * samplesize); pos += len; while(pos < length && m_loop != 0) { if(m_loop > 0) m_loop--; m_reader->seek(0); len = length - pos; m_reader->read(len, buffer); // prevent endless loop if(!len) break; memcpy(m_buffer->getBuffer() + pos * samplesize, buffer, len * samplesize); pos += len; } length = pos; buffer = m_buffer->getBuffer(); } else length = len; }
void FaderReader::read(int& length, bool& eos, sample_t* buffer) { int position = m_reader->getPosition(); Specs specs = m_reader->getSpecs(); int samplesize = AUD_SAMPLE_SIZE(specs); m_reader->read(length, eos, buffer); if((position + length) / (float)specs.rate <= m_start) { if(m_type != FADE_OUT) { std::memset(buffer, 0, length * samplesize); } } else if(position / (float)specs.rate >= m_start+m_length) { if(m_type == FADE_OUT) { std::memset(buffer, 0, length * samplesize); } } else { float volume = 1.0f; for(int i = 0; i < length * specs.channels; i++) { if(i % specs.channels == 0) { volume = (((position+i)/(float)specs.rate)-m_start) / m_length; if(volume > 1.0f) volume = 1.0f; else if(volume < 0.0f) volume = 0.0f; if(m_type == FADE_OUT) volume = 1.0f - volume; } buffer[i] = buffer[i] * volume; } } }
void AUD_SRCResampleReader::read(int& length, bool& eos, sample_t* buffer) { AUD_Specs specs = m_reader->getSpecs(); double factor = double(m_rate) / double(specs.rate); specs.rate = m_rate; int size = length; m_buffer.assureSize(length * AUD_SAMPLE_SIZE(specs)); if(specs.channels != m_channels) { src_delete(m_src); m_channels = specs.channels; int error; m_src = src_callback_new(src_callback, SRC_SINC_MEDIUM_QUALITY, m_channels, &error, this); if(!m_src) { // XXX printf("%s\n", src_strerror(error)); AUD_THROW(AUD_ERROR_SRC, state_error); } } m_eos = false; length = src_callback_read(m_src, factor, length, buffer); m_position += length; eos = m_eos && (length < size); }
void ReverseReader::read(int& length, bool& eos, sample_t* buffer) { // first correct the length if(m_position + length > m_length) length = m_length - m_position; if(length <= 0) { length = 0; eos = true; return; } const Specs specs = getSpecs(); const int samplesize = AUD_SAMPLE_SIZE(specs); sample_t temp[CHANNEL_MAX]; int len = length; // read from reader m_reader->seek(m_length - m_position - len); m_reader->read(len, eos, buffer); // set null if reader didn't give enough data if(len < length) std::memset(buffer, 0, (length - len) * samplesize); // copy the samples reverted for(int i = 0; i < length / 2; i++) { std::memcpy(temp, buffer + (len - 1 - i) * specs.channels, samplesize); std::memcpy(buffer + (len - 1 - i) * specs.channels, buffer + i * specs.channels, samplesize); std::memcpy(buffer + i * specs.channels, temp, samplesize); } m_position += length; eos = false; }
AUD_NAMESPACE_BEGIN StreamBuffer::StreamBuffer(std::shared_ptr<ISound> sound) : m_buffer(new Buffer()) { std::shared_ptr<IReader> reader = sound->createReader(); m_specs = reader->getSpecs(); int sample_size = AUD_SAMPLE_SIZE(m_specs); int length; int index = 0; bool eos = false; // get an approximated size if possible int size = reader->getLength(); if(size <= 0) size = BUFFER_RESIZE_BYTES / sample_size; else size += m_specs.rate; // as long as the end of the stream is not reached while(!eos) { // increase m_buffer->resize(size*sample_size, true); // read more length = size-index; reader->read(length, eos, m_buffer->getBuffer() + index * m_specs.channels); if(index == m_buffer->getSize() / sample_size) size += BUFFER_RESIZE_BYTES / sample_size; index += length; } m_buffer->resize(index * sample_size, true); }
void AUD_BufferReader::read(int& length, bool& eos, sample_t* buffer) { eos = false; int sample_size = AUD_SAMPLE_SIZE(m_specs); sample_t* buf = m_buffer->getBuffer() + m_position * m_specs.channels; // in case the end of the buffer is reached if(m_buffer->getSize() < (m_position + length) * sample_size) { length = m_buffer->getSize() / sample_size - m_position; eos = true; } if(length < 0) { length = 0; return; } m_position += length; memcpy(buffer, buf, length * sample_size); }
void AUD_SoftwareDevice::mix(data_t* buffer, int length) { m_buffer.assureSize(length * AUD_SAMPLE_SIZE(m_specs)); lock(); { AUD_Reference<AUD_SoftwareDevice::AUD_SoftwareHandle> sound; int len; int pos; bool eos; std::list<AUD_Reference<AUD_SoftwareDevice::AUD_SoftwareHandle> > stopSounds; std::list<AUD_Reference<AUD_SoftwareDevice::AUD_SoftwareHandle> > pauseSounds; sample_t* buf = m_buffer.getBuffer(); m_mixer->clear(length); // for all sounds AUD_HandleIterator it = m_playingSounds.begin(); while(it != m_playingSounds.end()) { sound = *it; // increment the iterator to make sure it's valid, // in case the sound gets deleted after stopping ++it; // get the buffer from the source pos = 0; len = length; // update 3D Info sound->update(); sound->m_reader->read(len, eos, buf); // in case of looping while(pos + len < length && sound->m_loopcount && eos) { m_mixer->mix(buf, pos, len, sound->m_volume); pos += len; if(sound->m_loopcount > 0) sound->m_loopcount--; sound->m_reader->seek(0); len = length - pos; sound->m_reader->read(len, eos, buf); // prevent endless loop if(!len) break; } m_mixer->mix(buf, pos, len, sound->m_volume); // in case the end of the sound is reached if(eos && !sound->m_loopcount) { if(sound->m_stop) sound->m_stop(sound->m_stop_data); if(sound->m_keep) pauseSounds.push_back(sound); else stopSounds.push_back(sound); } } // superpose m_mixer->read(buffer, m_volume); // cleanup while(!stopSounds.empty()) { sound = stopSounds.front(); stopSounds.pop_front(); sound->stop(); } while(!pauseSounds.empty()) { sound = pauseSounds.front(); pauseSounds.pop_front(); sound->pause(); } } unlock(); }
AUD_NAMESPACE_BEGIN void FFMPEGWriter::encode() { sample_t* data = m_input_buffer.getBuffer(); if(m_deinterleave) { m_deinterleave_buffer.assureSize(m_input_buffer.getSize()); sample_t* dbuf = m_deinterleave_buffer.getBuffer(); // deinterleave int single_size = sizeof(sample_t); for(int channel = 0; channel < m_specs.channels; channel++) { for(int i = 0; i < m_input_buffer.getSize() / AUD_SAMPLE_SIZE(m_specs); i++) { std::memcpy(((data_t*)dbuf) + (m_input_samples * channel + i) * single_size, ((data_t*)data) + ((m_specs.channels * i) + channel) * single_size, single_size); } } // convert first if(m_input_size) m_convert(reinterpret_cast<data_t*>(data), reinterpret_cast<data_t*>(dbuf), m_input_samples * m_specs.channels); else std::memcpy(data, dbuf, m_input_buffer.getSize()); } else // convert first if(m_input_size) m_convert(reinterpret_cast<data_t*>(data), reinterpret_cast<data_t*>(data), m_input_samples * m_specs.channels); AVPacket packet; packet.data = nullptr; packet.size = 0; av_init_packet(&packet); AVFrame* frame = av_frame_alloc(); av_frame_unref(frame); int got_packet; frame->nb_samples = m_input_samples; frame->format = m_codecCtx->sample_fmt; frame->channel_layout = m_codecCtx->channel_layout; if(avcodec_fill_audio_frame(frame, m_specs.channels, m_codecCtx->sample_fmt, reinterpret_cast<data_t*>(data), m_input_buffer.getSize(), 0) < 0) AUD_THROW(FileException, "File couldn't be written, filling the audio frame failed with ffmpeg."); AVRational sample_time = { 1, static_cast<int>(m_specs.rate) }; frame->pts = av_rescale_q(m_position - m_input_samples, m_codecCtx->time_base, sample_time); if(avcodec_encode_audio2(m_codecCtx, &packet, frame, &got_packet)) { av_frame_free(&frame); AUD_THROW(FileException, "File couldn't be written, audio encoding failed with ffmpeg."); } if(got_packet) { packet.flags |= AV_PKT_FLAG_KEY; packet.stream_index = m_stream->index; if(av_write_frame(m_formatCtx, &packet) < 0) { av_free_packet(&packet); av_frame_free(&frame); AUD_THROW(FileException, "Frame couldn't be writen to the file with ffmpeg."); } av_free_packet(&packet); } av_frame_free(&frame); }
FFMPEGWriter::FFMPEGWriter(std::string filename, DeviceSpecs specs, Container format, Codec codec, unsigned int bitrate) : m_position(0), m_specs(specs), m_input_samples(0), m_deinterleave(false) { static const char* formats[] = { nullptr, "ac3", "flac", "matroska", "mp2", "mp3", "ogg", "wav" }; if(avformat_alloc_output_context2(&m_formatCtx, nullptr, formats[format], filename.c_str()) < 0) AUD_THROW(FileException, "File couldn't be written, format couldn't be found with ffmpeg."); m_outputFmt = m_formatCtx->oformat; if(!m_outputFmt) { avformat_free_context(m_formatCtx); AUD_THROW(FileException, "File couldn't be written, output format couldn't be found with ffmpeg."); } m_outputFmt->audio_codec = AV_CODEC_ID_NONE; switch(codec) { case CODEC_AAC: m_outputFmt->audio_codec = AV_CODEC_ID_AAC; break; case CODEC_AC3: m_outputFmt->audio_codec = AV_CODEC_ID_AC3; break; case CODEC_FLAC: m_outputFmt->audio_codec = AV_CODEC_ID_FLAC; break; case CODEC_MP2: m_outputFmt->audio_codec = AV_CODEC_ID_MP2; break; case CODEC_MP3: m_outputFmt->audio_codec = AV_CODEC_ID_MP3; break; case CODEC_OPUS: m_outputFmt->audio_codec = AV_CODEC_ID_OPUS; break; case CODEC_PCM: switch(specs.format) { case FORMAT_U8: m_outputFmt->audio_codec = AV_CODEC_ID_PCM_U8; break; case FORMAT_S16: m_outputFmt->audio_codec = AV_CODEC_ID_PCM_S16LE; break; case FORMAT_S24: m_outputFmt->audio_codec = AV_CODEC_ID_PCM_S24LE; break; case FORMAT_S32: m_outputFmt->audio_codec = AV_CODEC_ID_PCM_S32LE; break; case FORMAT_FLOAT32: m_outputFmt->audio_codec = AV_CODEC_ID_PCM_F32LE; break; case FORMAT_FLOAT64: m_outputFmt->audio_codec = AV_CODEC_ID_PCM_F64LE; break; default: m_outputFmt->audio_codec = AV_CODEC_ID_NONE; break; } break; case CODEC_VORBIS: m_outputFmt->audio_codec = AV_CODEC_ID_VORBIS; break; default: m_outputFmt->audio_codec = AV_CODEC_ID_NONE; break; } try { if(m_outputFmt->audio_codec == AV_CODEC_ID_NONE) AUD_THROW(FileException, "File couldn't be written, audio codec not found with ffmpeg."); AVCodec* codec = avcodec_find_encoder(m_outputFmt->audio_codec); if(!codec) AUD_THROW(FileException, "File couldn't be written, audio encoder couldn't be found with ffmpeg."); m_stream = avformat_new_stream(m_formatCtx, codec); if(!m_stream) AUD_THROW(FileException, "File couldn't be written, stream creation failed with ffmpeg."); m_stream->id = m_formatCtx->nb_streams - 1; m_codecCtx = m_stream->codec; switch(m_specs.format) { case FORMAT_U8: m_convert = convert_float_u8; m_codecCtx->sample_fmt = AV_SAMPLE_FMT_U8; break; case FORMAT_S16: m_convert = convert_float_s16; m_codecCtx->sample_fmt = AV_SAMPLE_FMT_S16; break; case FORMAT_S32: m_convert = convert_float_s32; m_codecCtx->sample_fmt = AV_SAMPLE_FMT_S32; break; case FORMAT_FLOAT64: m_convert = convert_float_double; m_codecCtx->sample_fmt = AV_SAMPLE_FMT_DBL; break; default: m_convert = convert_copy<sample_t>; m_codecCtx->sample_fmt = AV_SAMPLE_FMT_FLT; break; } if(m_formatCtx->oformat->flags & AVFMT_GLOBALHEADER) m_codecCtx->flags |= CODEC_FLAG_GLOBAL_HEADER; bool format_supported = false; for(int i = 0; codec->sample_fmts[i] != -1; i++) { if(av_get_alt_sample_fmt(codec->sample_fmts[i], false) == m_codecCtx->sample_fmt) { m_deinterleave = av_sample_fmt_is_planar(codec->sample_fmts[i]); m_codecCtx->sample_fmt = codec->sample_fmts[i]; format_supported = true; } } if(!format_supported) { int chosen_index = 0; auto chosen = av_get_alt_sample_fmt(codec->sample_fmts[chosen_index], false); for(int i = 1; codec->sample_fmts[i] != -1; i++) { auto fmt = av_get_alt_sample_fmt(codec->sample_fmts[i], false); if((fmt > chosen && chosen < m_codecCtx->sample_fmt) || (fmt > m_codecCtx->sample_fmt && fmt < chosen)) { chosen = fmt; chosen_index = i; } } m_codecCtx->sample_fmt = codec->sample_fmts[chosen_index]; m_deinterleave = av_sample_fmt_is_planar(m_codecCtx->sample_fmt); switch(av_get_alt_sample_fmt(m_codecCtx->sample_fmt, false)) { case AV_SAMPLE_FMT_U8: specs.format = FORMAT_U8; m_convert = convert_float_u8; break; case AV_SAMPLE_FMT_S16: specs.format = FORMAT_S16; m_convert = convert_float_s16; break; case AV_SAMPLE_FMT_S32: specs.format = FORMAT_S32; m_convert = convert_float_s32; break; case AV_SAMPLE_FMT_FLT: specs.format = FORMAT_FLOAT32; m_convert = convert_copy<sample_t>; break; case AV_SAMPLE_FMT_DBL: specs.format = FORMAT_FLOAT64; m_convert = convert_float_double; break; default: AUD_THROW(FileException, "File couldn't be written, sample format not supported with ffmpeg."); } } m_codecCtx->sample_rate = 0; if(codec->supported_samplerates) { for(int i = 0; codec->supported_samplerates[i]; i++) { if(codec->supported_samplerates[i] == m_specs.rate) { m_codecCtx->sample_rate = codec->supported_samplerates[i]; break; } else if((codec->supported_samplerates[i] > m_codecCtx->sample_rate && m_specs.rate > m_codecCtx->sample_rate) || (codec->supported_samplerates[i] < m_codecCtx->sample_rate && m_specs.rate < codec->supported_samplerates[i])) { m_codecCtx->sample_rate = codec->supported_samplerates[i]; } } } if(m_codecCtx->sample_rate == 0) m_codecCtx->sample_rate = m_specs.rate; m_specs.rate = m_codecCtx->sample_rate; m_codecCtx->codec_id = m_outputFmt->audio_codec; m_codecCtx->codec_type = AVMEDIA_TYPE_AUDIO; m_codecCtx->bit_rate = bitrate; m_codecCtx->channels = m_specs.channels; m_stream->time_base.num = m_codecCtx->time_base.num = 1; m_stream->time_base.den = m_codecCtx->time_base.den = m_codecCtx->sample_rate; if(avcodec_open2(m_codecCtx, codec, nullptr) < 0) AUD_THROW(FileException, "File couldn't be written, encoder couldn't be opened with ffmpeg."); int samplesize = std::max(int(AUD_SAMPLE_SIZE(m_specs)), AUD_DEVICE_SAMPLE_SIZE(m_specs)); if((m_input_size = m_codecCtx->frame_size)) m_input_buffer.resize(m_input_size * samplesize); if(avio_open(&m_formatCtx->pb, filename.c_str(), AVIO_FLAG_WRITE)) AUD_THROW(FileException, "File couldn't be written, file opening failed with ffmpeg."); avformat_write_header(m_formatCtx, nullptr); } catch(Exception&) { avformat_free_context(m_formatCtx); throw; } }