AUD_FFMPEGReader::AUD_FFMPEGReader(boost::shared_ptr<AUD_Buffer> buffer) : m_pkgbuf(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1), m_membuffer(buffer), m_membufferpos(0) { m_membuf = reinterpret_cast<data_t*>(av_malloc(FF_MIN_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE)); m_aviocontext = avio_alloc_context(m_membuf, FF_MIN_BUFFER_SIZE, 0, this, read_packet, NULL, seek_packet); if(!m_aviocontext) { av_free(m_aviocontext); AUD_THROW(AUD_ERROR_FILE, fileopen_error); } m_formatCtx = avformat_alloc_context(); m_formatCtx->pb = m_aviocontext; if(avformat_open_input(&m_formatCtx, "", NULL, NULL)!=0) { av_free(m_aviocontext); AUD_THROW(AUD_ERROR_FILE, streamopen_error); } try { init(); } catch(AUD_Exception&) { avformat_close_input(&m_formatCtx); av_free(m_aviocontext); throw; } }
void FFMPEGWriter::close() { int got_packet = true; while(got_packet) { AVPacket packet; packet.data = nullptr; packet.size = 0; av_init_packet(&packet); if(avcodec_encode_audio2(m_codecCtx, &packet, nullptr, &got_packet)) AUD_THROW(FileException, "File end 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)) { av_free_packet(&packet); AUD_THROW(FileException, "Final frames couldn't be writen to the file with ffmpeg."); } av_free_packet(&packet); } } }
OpenALDevice::OpenALHandle::OpenALHandle(OpenALDevice* device, ALenum format, std::shared_ptr<IReader> reader, bool keep) : m_isBuffered(false), m_reader(reader), m_keep(keep), m_format(format), m_eos(false), m_loopcount(0), m_stop(nullptr), m_stop_data(nullptr), m_status(STATUS_PLAYING), m_device(device) { DeviceSpecs specs = m_device->m_specs; specs.specs = m_reader->getSpecs(); // OpenAL playback code alGenBuffers(CYCLE_BUFFERS, m_buffers); if(alGetError() != AL_NO_ERROR) AUD_THROW(DeviceException, "Buffer generation failed while staring playback with OpenAL."); try { m_device->m_buffer.assureSize(m_device->m_buffersize * AUD_DEVICE_SAMPLE_SIZE(specs)); int length; bool eos; for(m_current = 0; m_current < CYCLE_BUFFERS; m_current++) { length = m_device->m_buffersize; reader->read(length, eos, m_device->m_buffer.getBuffer()); if(length == 0) break; alBufferData(m_buffers[m_current], m_format, m_device->m_buffer.getBuffer(), length * AUD_DEVICE_SAMPLE_SIZE(specs), specs.rate); if(alGetError() != AL_NO_ERROR) AUD_THROW(DeviceException, "Filling the buffer with data failed while starting playback with OpenAL."); } alGenSources(1, &m_source); if(alGetError() != AL_NO_ERROR) AUD_THROW(DeviceException, "Source generation failed while starting playback with OpenAL."); try { alSourceQueueBuffers(m_source, m_current, m_buffers); if(alGetError() != AL_NO_ERROR) AUD_THROW(DeviceException, "Buffer queuing failed while starting playback with OpenAL."); } catch(Exception&) { alDeleteSources(1, &m_source); throw; } } catch(Exception&) { alDeleteBuffers(CYCLE_BUFFERS, m_buffers); throw; } alSourcei(m_source, AL_SOURCE_RELATIVE, 1); }
AUD_OpenALDevice::AUD_OpenALHandle::AUD_OpenALHandle(AUD_OpenALDevice* device, ALenum format, AUD_Reference<AUD_IReader> reader, bool keep) : m_isBuffered(false), m_reader(reader), m_keep(keep), m_format(format), m_current(0), m_eos(false), m_loopcount(0), m_stop(NULL), m_stop_data(NULL), m_status(AUD_STATUS_PLAYING), m_device(device) { AUD_DeviceSpecs specs = m_device->m_specs; specs.specs = m_reader->getSpecs(); // OpenAL playback code alGenBuffers(CYCLE_BUFFERS, m_buffers); if(alGetError() != AL_NO_ERROR) AUD_THROW(AUD_ERROR_OPENAL, genbuffer_error); try { m_device->m_buffer.assureSize(m_device->m_buffersize * AUD_DEVICE_SAMPLE_SIZE(specs)); int length; bool eos; for(int i = 0; i < CYCLE_BUFFERS; i++) { length = m_device->m_buffersize; reader->read(length, eos, m_device->m_buffer.getBuffer()); alBufferData(m_buffers[i], m_format, m_device->m_buffer.getBuffer(), length * AUD_DEVICE_SAMPLE_SIZE(specs), specs.rate); if(alGetError() != AL_NO_ERROR) AUD_THROW(AUD_ERROR_OPENAL, bufferdata_error); } alGenSources(1, &m_source); if(alGetError() != AL_NO_ERROR) AUD_THROW(AUD_ERROR_OPENAL, gensource_error); try { alSourceQueueBuffers(m_source, CYCLE_BUFFERS, m_buffers); if(alGetError() != AL_NO_ERROR) AUD_THROW(AUD_ERROR_OPENAL, queue_error); } catch(AUD_Exception&) { alDeleteSources(1, &m_source); throw; } } catch(AUD_Exception&) { alDeleteBuffers(CYCLE_BUFFERS, m_buffers); throw; } alSourcei(m_source, AL_SOURCE_RELATIVE, 1); }
AUD_IReader* AUD_FileFactory::createReader() const { #ifdef WITH_SNDFILE try { if(m_buffer.get()) return new AUD_SndFileReader(m_buffer); else return new AUD_SndFileReader(m_filename); } catch(AUD_Exception&) {} #endif #ifdef WITH_FFMPEG try { if(m_buffer.get()) return new AUD_FFMPEGReader(m_buffer); else return new AUD_FFMPEGReader(m_filename); } catch(AUD_Exception&) {} #endif AUD_THROW(AUD_ERROR_FILE, read_error); }
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; }
AUD_ReverseReader::AUD_ReverseReader(AUD_IReader* reader) : AUD_EffectReader(reader), m_length(reader->getLength()), m_position(0) { if(m_length < 0 || !reader->isSeekable()) AUD_THROW(AUD_ERROR_PROPS, props_error); }
AUD_NAMESPACE_BEGIN ReverseReader::ReverseReader(std::shared_ptr<IReader> reader) : EffectReader(reader), m_length(reader->getLength()), m_position(0) { if(m_length < 0 || !reader->isSeekable()) AUD_THROW(StateException, "A reader has to be seekable and have finite length to be reversible."); }
void FFMPEGWriter::close() { #ifdef FFMPEG_OLD_CODE int got_packet = true; while(got_packet) { m_packet->data = nullptr; m_packet->size = 0; av_init_packet(m_packet); if(avcodec_encode_audio2(m_codecCtx, m_packet, nullptr, &got_packet)) AUD_THROW(FileException, "File end couldn't be written, audio encoding failed with ffmpeg."); if(got_packet) { m_packet->flags |= AV_PKT_FLAG_KEY; m_packet->stream_index = m_stream->index; if(av_write_frame(m_formatCtx, m_packet)) { av_free_packet(m_packet); AUD_THROW(FileException, "Final frames couldn't be writen to the file with ffmpeg."); } av_free_packet(m_packet); } } #else if(avcodec_send_frame(m_codecCtx, nullptr) < 0) AUD_THROW(FileException, "File couldn't be written, audio encoding failed with ffmpeg."); while(avcodec_receive_packet(m_codecCtx, m_packet) == 0) { m_packet->stream_index = m_stream->index; if(av_write_frame(m_formatCtx, m_packet) < 0) AUD_THROW(FileException, "Frame couldn't be writen to the file with ffmpeg."); } #endif }
AUD_SDLDevice::AUD_SDLDevice(AUD_DeviceSpecs specs, int buffersize) { if(specs.channels == AUD_CHANNELS_INVALID) specs.channels = AUD_CHANNELS_STEREO; if(specs.format == AUD_FORMAT_INVALID) specs.format = AUD_FORMAT_S16; if(specs.rate == AUD_RATE_INVALID) specs.rate = AUD_RATE_44100; m_specs = specs; SDL_AudioSpec format, obtained; format.freq = m_specs.rate; if(m_specs.format == AUD_FORMAT_U8) format.format = AUDIO_U8; else format.format = AUDIO_S16SYS; format.channels = m_specs.channels; format.samples = buffersize; format.callback = AUD_SDLDevice::SDL_mix; format.userdata = this; if(SDL_OpenAudio(&format, &obtained) != 0) AUD_THROW(AUD_ERROR_SDL, open_error); m_specs.rate = (AUD_SampleRate)obtained.freq; m_specs.channels = (AUD_Channels)obtained.channels; if(obtained.format == AUDIO_U8) m_specs.format = AUD_FORMAT_U8; else if(obtained.format == AUDIO_S16LSB || obtained.format == AUDIO_S16MSB) m_specs.format = AUD_FORMAT_S16; else { SDL_CloseAudio(); AUD_THROW(AUD_ERROR_SDL, format_error); } create(); }
AUD_OpenALDevice::AUD_OpenALDevice(AUD_Specs specs, int buffersize) { // cannot determine how many channels or which format OpenAL uses, but // it at least is able to play 16 bit stereo audio specs.channels = AUD_CHANNELS_STEREO; specs.format = AUD_FORMAT_S16; m_device = alcOpenDevice(NULL); if(!m_device) AUD_THROW(AUD_ERROR_OPENAL); // at least try to set the frequency ALCint attribs[] = { ALC_FREQUENCY, specs.rate, 0 }; ALCint* attributes = attribs; if(specs.rate == AUD_RATE_INVALID) attributes = NULL; m_context = alcCreateContext(m_device, attributes); alcMakeContextCurrent(m_context); alcGetIntegerv(m_device, ALC_FREQUENCY, 1, (ALCint*)&specs.rate); // check for specific formats and channel counts to be played back if(alIsExtensionPresent("AL_EXT_FLOAT32") == AL_TRUE) specs.format = AUD_FORMAT_FLOAT32; m_useMC = alIsExtensionPresent("AL_EXT_MCFORMATS") == AL_TRUE; alGetError(); m_converter = new AUD_ConverterFactory(specs); AUD_NEW("factory") m_specs = specs; m_buffersize = buffersize; m_playing = false; m_playingSounds = new std::list<AUD_OpenALHandle*>(); AUD_NEW("list") m_pausedSounds = new std::list<AUD_OpenALHandle*>(); AUD_NEW("list") m_bufferedFactories = new std::list<AUD_OpenALBufferedFactory*>(); AUD_NEW("list") pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&m_mutex, &attr); pthread_mutexattr_destroy(&attr); }
AUD_SndFileReader::AUD_SndFileReader(std::string filename) : m_position(0) { SF_INFO sfinfo; sfinfo.format = 0; m_sndfile = sf_open(filename.c_str(), SFM_READ, &sfinfo); if(!m_sndfile) AUD_THROW(AUD_ERROR_FILE, fileopen_error); m_specs.channels = (AUD_Channels) sfinfo.channels; m_specs.rate = (AUD_SampleRate) sfinfo.samplerate; m_length = sfinfo.frames; m_seekable = sfinfo.seekable; }
SndFileReader::SndFileReader(std::string filename) : m_position(0) { SF_INFO sfinfo; sfinfo.format = 0; m_sndfile = sf_open(filename.c_str(), SFM_READ, &sfinfo); if(!m_sndfile) AUD_THROW(FileException, "The file couldn't be opened with libsndfile."); m_specs.channels = (Channels) sfinfo.channels; m_specs.rate = (SampleRate) sfinfo.samplerate; m_length = sfinfo.frames; m_seekable = sfinfo.seekable; }
AUD_SRCResampleReader::AUD_SRCResampleReader(AUD_Reference<AUD_IReader> reader, AUD_Specs specs) : AUD_ResampleReader(reader, specs.rate), m_channels(reader->getSpecs().channels), m_position(0) { 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); } }
AUD_NAMESPACE_BEGIN OpenALReader::OpenALReader(Specs specs, int buffersize) : m_specs(specs), m_position(0), m_device(nullptr) { if((specs.channels != CHANNELS_MONO) && (specs.channels != CHANNELS_STEREO)) specs.channels = CHANNELS_MONO; m_device = alcCaptureOpenDevice(nullptr, specs.rate, specs.channels == CHANNELS_MONO ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16, buffersize * specs.channels * 2); if(!m_device) AUD_THROW(DeviceException, "The capture device couldn't be opened with OpenAL."); alcCaptureStart(m_device); }
AUD_SuperposeReader::AUD_SuperposeReader(AUD_IReader* reader1, AUD_IReader* reader2) : m_reader1(reader1), m_reader2(reader2) { try { AUD_Specs s1, s2; s1 = reader1->getSpecs(); s2 = reader2->getSpecs(); if(memcmp(&s1, &s2, sizeof(AUD_Specs))) AUD_THROW(AUD_ERROR_SPECS, specs_error); } catch(AUD_Exception&) { delete reader1; delete reader2; throw; } }
OpenALDevice::OpenALDevice(DeviceSpecs specs, int buffersize, std::string name) : m_playing(false), m_buffersize(buffersize) { // cannot determine how many channels or which format OpenAL uses, but // it at least is able to play 16 bit stereo audio specs.format = FORMAT_S16; if(name.empty()) m_device = alcOpenDevice(nullptr); else m_device = alcOpenDevice(name.c_str()); if(!m_device) AUD_THROW(DeviceException, "The audio device couldn't be opened with OpenAL."); // at least try to set the frequency ALCint attribs[] = { ALC_FREQUENCY, (ALCint)specs.rate, 0 }; ALCint* attributes = attribs; if(specs.rate == RATE_INVALID) attributes = nullptr; m_context = alcCreateContext(m_device, attributes); alcMakeContextCurrent(m_context); alcGetIntegerv(m_device, ALC_FREQUENCY, 1, (ALCint*)&specs.rate); // check for specific formats and channel counts to be played back if(alIsExtensionPresent("AL_EXT_FLOAT32") == AL_TRUE) specs.format = FORMAT_FLOAT32; m_useMC = alIsExtensionPresent("AL_EXT_MCFORMATS") == AL_TRUE; if((!m_useMC && specs.channels > CHANNELS_STEREO) || specs.channels == CHANNELS_STEREO_LFE || specs.channels == CHANNELS_SURROUND5) specs.channels = CHANNELS_STEREO; alGetError(); alcGetError(m_device); m_specs = specs; }
AUD_FFMPEGReader::AUD_FFMPEGReader(std::string filename) : m_pkgbuf(AVCODEC_MAX_AUDIO_FRAME_SIZE<<1), m_formatCtx(NULL), m_aviocontext(NULL), m_membuf(NULL) { // open file if(avformat_open_input(&m_formatCtx, filename.c_str(), NULL, NULL)!=0) AUD_THROW(AUD_ERROR_FILE, fileopen_error); try { init(); } catch(AUD_Exception&) { avformat_close_input(&m_formatCtx); throw; } }
AUD_Reference<AUD_IWriter> AUD_FileWriter::createWriter(std::string filename,AUD_DeviceSpecs specs, AUD_Container format, AUD_Codec codec, unsigned int bitrate) { #ifdef WITH_SNDFILE try { return new AUD_SndFileWriter(filename, specs, format, codec, bitrate); } catch(AUD_Exception&) {} #endif #ifdef WITH_FFMPEG try { return new AUD_FFMPEGWriter(filename, specs, format, codec, bitrate); } catch(AUD_Exception&) {} #endif AUD_THROW(AUD_ERROR_SPECS, write_error); }
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); }
AUD_SRCResampleReader::AUD_SRCResampleReader(AUD_IReader* reader, AUD_Specs specs) : AUD_EffectReader(reader), m_sspecs(reader->getSpecs()), m_factor(double(specs.rate) / double(m_sspecs.rate)), m_tspecs(specs), m_position(0) { m_tspecs.channels = m_sspecs.channels; int error; m_src = src_callback_new(src_callback, SRC_SINC_MEDIUM_QUALITY, m_sspecs.channels, &error, this); if(!m_src) { // XXX printf("%s\n", src_strerror(error)); AUD_THROW(AUD_ERROR_SRC, state_error); } }
AUD_SndFileReader::AUD_SndFileReader(AUD_Reference<AUD_Buffer> buffer) : m_position(0), m_membuffer(buffer), m_memoffset(0) { m_vio.get_filelen = vio_get_filelen; m_vio.read = vio_read; m_vio.seek = vio_seek; m_vio.tell = vio_tell; m_vio.write = NULL; SF_INFO sfinfo; sfinfo.format = 0; m_sndfile = sf_open_virtual(&m_vio, SFM_READ, &sfinfo, this); if(!m_sndfile) AUD_THROW(AUD_ERROR_FILE, fileopen_error); m_specs.channels = (AUD_Channels) sfinfo.channels; m_specs.rate = (AUD_SampleRate) sfinfo.samplerate; m_length = sfinfo.frames; m_seekable = sfinfo.seekable; }
SndFileReader::SndFileReader(std::shared_ptr<Buffer> buffer) : m_position(0), m_membuffer(buffer), m_memoffset(0) { m_vio.get_filelen = vio_get_filelen; m_vio.read = vio_read; m_vio.seek = vio_seek; m_vio.tell = vio_tell; m_vio.write = nullptr; SF_INFO sfinfo; sfinfo.format = 0; m_sndfile = sf_open_virtual(&m_vio, SFM_READ, &sfinfo, this); if(!m_sndfile) AUD_THROW(FileException, "The buffer couldn't be read with libsndfile."); m_specs.channels = (Channels) sfinfo.channels; m_specs.rate = (SampleRate) sfinfo.samplerate; m_length = sfinfo.frames; m_seekable = sfinfo.seekable; }
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; } }
AUD_OpenALDevice::AUD_OpenALDevice(AUD_DeviceSpecs specs, int buffersize) { // cannot determine how many channels or which format OpenAL uses, but // it at least is able to play 16 bit stereo audio specs.channels = AUD_CHANNELS_STEREO; specs.format = AUD_FORMAT_S16; #if 0 if(alcIsExtensionPresent(NULL, "ALC_ENUMERATION_EXT") == AL_TRUE) { ALCchar* devices = const_cast<ALCchar*>(alcGetString(NULL, ALC_DEVICE_SPECIFIER)); printf("OpenAL devices (standard is: %s):\n", alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER)); while(*devices) { printf("%s\n", devices); devices += strlen(devices) + 1; } } #endif m_device = alcOpenDevice(NULL); if(!m_device) AUD_THROW(AUD_ERROR_OPENAL, open_error); // at least try to set the frequency ALCint attribs[] = { ALC_FREQUENCY, specs.rate, 0 }; ALCint* attributes = attribs; if(specs.rate == AUD_RATE_INVALID) attributes = NULL; m_context = alcCreateContext(m_device, attributes); alcMakeContextCurrent(m_context); alcGetIntegerv(m_device, ALC_FREQUENCY, 1, (ALCint*)&specs.rate); // check for specific formats and channel counts to be played back if(alIsExtensionPresent("AL_EXT_FLOAT32") == AL_TRUE) specs.format = AUD_FORMAT_FLOAT32; m_useMC = alIsExtensionPresent("AL_EXT_MCFORMATS") == AL_TRUE; alGetError(); alcGetError(m_device); m_specs = specs; m_buffersize = buffersize; m_playing = false; // m_bufferedFactories = new std::list<AUD_OpenALBufferedFactory*>(); pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&m_mutex, &attr); pthread_mutexattr_destroy(&attr); start(false); }
JackDevice::JackDevice(std::string name, DeviceSpecs specs, int buffersize) : m_synchronizer(this) { if(specs.channels == CHANNELS_INVALID) specs.channels = CHANNELS_STEREO; // jack uses floats m_specs = specs; m_specs.format = FORMAT_FLOAT32; jack_options_t options = JackNullOption; jack_status_t status; // open client m_client = AUD_jack_client_open(name.c_str(), options, &status); if(m_client == nullptr) AUD_THROW(DeviceException, "Connecting to the JACK server failed."); // set callbacks AUD_jack_set_process_callback(m_client, JackDevice::jack_mix, this); AUD_jack_on_shutdown(m_client, JackDevice::jack_shutdown, this); AUD_jack_set_sync_callback(m_client, JackDevice::jack_sync, this); // register our output channels which are called ports in jack m_ports = new jack_port_t*[m_specs.channels]; try { char portname[64]; for(int i = 0; i < m_specs.channels; i++) { sprintf(portname, "out %d", i+1); m_ports[i] = AUD_jack_port_register(m_client, portname, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); if(m_ports[i] == nullptr) AUD_THROW(DeviceException, "Registering output port with JACK failed."); } } catch(Exception&) { AUD_jack_client_close(m_client); delete[] m_ports; throw; } m_specs.rate = (SampleRate)AUD_jack_get_sample_rate(m_client); buffersize *= sizeof(sample_t); m_ringbuffers = new jack_ringbuffer_t*[specs.channels]; for(unsigned int i = 0; i < specs.channels; i++) m_ringbuffers[i] = AUD_jack_ringbuffer_create(buffersize); buffersize *= specs.channels; m_deinterleavebuf.resize(buffersize); m_buffer.resize(buffersize); create(); m_valid = true; m_sync = 0; m_syncFunc = nullptr; m_nextState = m_state = AUD_jack_transport_query(m_client, nullptr); // activate the client if(AUD_jack_activate(m_client)) { AUD_jack_client_close(m_client); delete[] m_ports; for(unsigned int i = 0; i < specs.channels; i++) AUD_jack_ringbuffer_free(m_ringbuffers[i]); delete[] m_ringbuffers; destroy(); AUD_THROW(DeviceException, "Client activation with JACK failed."); } const char** ports = AUD_jack_get_ports(m_client, nullptr, nullptr, JackPortIsPhysical | JackPortIsInput); if(ports != nullptr) { for(int i = 0; i < m_specs.channels && ports[i]; i++) AUD_jack_connect(m_client, AUD_jack_port_name(m_ports[i]), ports[i]); AUD_jack_free(ports); } m_mixingThread = std::thread(&JackDevice::updateRingBuffers, this); }
void AUD_FFMPEGReader::init() { m_position = 0; m_pkgbuf_left = 0; if(avformat_find_stream_info(m_formatCtx, NULL) < 0) AUD_THROW(AUD_ERROR_FFMPEG, streaminfo_error); // find audio stream and codec m_stream = -1; for(unsigned int i = 0; i < m_formatCtx->nb_streams; i++) { if((m_formatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) && (m_stream < 0)) { m_stream=i; break; } } if(m_stream == -1) AUD_THROW(AUD_ERROR_FFMPEG, noaudio_error); m_codecCtx = m_formatCtx->streams[m_stream]->codec; // get a decoder and open it AVCodec *aCodec = avcodec_find_decoder(m_codecCtx->codec_id); if(!aCodec) AUD_THROW(AUD_ERROR_FFMPEG, nodecoder_error); if(avcodec_open2(m_codecCtx, aCodec, NULL) < 0) AUD_THROW(AUD_ERROR_FFMPEG, codecopen_error); // XXX this prints file information to stdout: //dump_format(m_formatCtx, 0, NULL, 0); m_specs.channels = (AUD_Channels) m_codecCtx->channels; m_tointerleave = av_sample_fmt_is_planar(m_codecCtx->sample_fmt); switch(av_get_packed_sample_fmt(m_codecCtx->sample_fmt)) { case AV_SAMPLE_FMT_U8: m_convert = AUD_convert_u8_float; m_specs.format = AUD_FORMAT_U8; break; case AV_SAMPLE_FMT_S16: m_convert = AUD_convert_s16_float; m_specs.format = AUD_FORMAT_S16; break; case AV_SAMPLE_FMT_S32: m_convert = AUD_convert_s32_float; m_specs.format = AUD_FORMAT_S32; break; case AV_SAMPLE_FMT_FLT: m_convert = AUD_convert_copy<float>; m_specs.format = AUD_FORMAT_FLOAT32; break; case AV_SAMPLE_FMT_DBL: m_convert = AUD_convert_double_float; m_specs.format = AUD_FORMAT_FLOAT64; break; default: AUD_THROW(AUD_ERROR_FFMPEG, format_error); } m_specs.rate = (AUD_SampleRate) m_codecCtx->sample_rate; }
AUD_JackDevice::AUD_JackDevice(std::string name, AUD_DeviceSpecs specs, int buffersize) { if(specs.channels == AUD_CHANNELS_INVALID) specs.channels = AUD_CHANNELS_STEREO; // jack uses floats m_specs = specs; m_specs.format = AUD_FORMAT_FLOAT32; jack_options_t options = JackNullOption; jack_status_t status; // open client m_client = jack_client_open(name.c_str(), options, &status); if(m_client == NULL) AUD_THROW(AUD_ERROR_JACK, clientopen_error); // set callbacks jack_set_process_callback(m_client, AUD_JackDevice::jack_mix, this); jack_on_shutdown(m_client, AUD_JackDevice::jack_shutdown, this); jack_set_sync_callback(m_client, AUD_JackDevice::jack_sync, this); // register our output channels which are called ports in jack m_ports = new jack_port_t*[m_specs.channels]; try { char portname[64]; for(int i = 0; i < m_specs.channels; i++) { sprintf(portname, "out %d", i+1); m_ports[i] = jack_port_register(m_client, portname, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0); if(m_ports[i] == NULL) AUD_THROW(AUD_ERROR_JACK, port_error); } } catch(AUD_Exception&) { jack_client_close(m_client); delete[] m_ports; throw; } m_specs.rate = (AUD_SampleRate)jack_get_sample_rate(m_client); buffersize *= sizeof(sample_t); m_ringbuffers = new jack_ringbuffer_t*[specs.channels]; for(unsigned int i = 0; i < specs.channels; i++) m_ringbuffers[i] = jack_ringbuffer_create(buffersize); buffersize *= specs.channels; m_deinterleavebuf.resize(buffersize); m_buffer.resize(buffersize); create(); m_valid = true; m_sync = 0; m_syncFunc = NULL; m_nextState = m_state = jack_transport_query(m_client, NULL); pthread_mutex_init(&m_mixingLock, NULL); pthread_cond_init(&m_mixingCondition, NULL); // activate the client if(jack_activate(m_client)) { jack_client_close(m_client); delete[] m_ports; for(unsigned int i = 0; i < specs.channels; i++) jack_ringbuffer_free(m_ringbuffers[i]); delete[] m_ringbuffers; pthread_mutex_destroy(&m_mixingLock); pthread_cond_destroy(&m_mixingCondition); destroy(); AUD_THROW(AUD_ERROR_JACK, activate_error); } const char** ports = jack_get_ports(m_client, NULL, NULL, JackPortIsPhysical | JackPortIsInput); if(ports != NULL) { for(int i = 0; i < m_specs.channels && ports[i]; i++) jack_connect(m_client, jack_port_name(m_ports[i]), ports[i]); free(ports); } pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&m_mixingThread, &attr, runMixingThread, this); pthread_attr_destroy(&attr); }
AUD_NAMESPACE_BEGIN SndFileWriter::SndFileWriter(std::string filename, DeviceSpecs specs, Container format, Codec codec, unsigned int bitrate) : m_position(0), m_specs(specs) { SF_INFO sfinfo; sfinfo.channels = specs.channels; sfinfo.samplerate = int(specs.rate); switch(format) { case CONTAINER_FLAC: sfinfo.format = SF_FORMAT_FLAC; switch(specs.format) { case FORMAT_S16: sfinfo.format |= SF_FORMAT_PCM_16; break; case FORMAT_S24: sfinfo.format |= SF_FORMAT_PCM_24; break; case FORMAT_S32: sfinfo.format |= SF_FORMAT_PCM_32; break; case FORMAT_FLOAT32: sfinfo.format |= SF_FORMAT_FLOAT; break; case FORMAT_FLOAT64: sfinfo.format |= SF_FORMAT_DOUBLE; break; default: sfinfo.format = 0; break; } break; case CONTAINER_OGG: if(codec == CODEC_VORBIS) sfinfo.format = SF_FORMAT_OGG | SF_FORMAT_VORBIS; else sfinfo.format = 0; break; case CONTAINER_WAV: sfinfo.format = SF_FORMAT_WAV; switch(specs.format) { case FORMAT_U8: sfinfo.format |= SF_FORMAT_PCM_U8; break; case FORMAT_S16: sfinfo.format |= SF_FORMAT_PCM_16; break; case FORMAT_S24: sfinfo.format |= SF_FORMAT_PCM_24; break; case FORMAT_S32: sfinfo.format |= SF_FORMAT_PCM_32; break; case FORMAT_FLOAT32: sfinfo.format |= SF_FORMAT_FLOAT; break; case FORMAT_FLOAT64: sfinfo.format |= SF_FORMAT_DOUBLE; break; default: sfinfo.format = 0; break; } break; default: sfinfo.format = 0; break; } if(sfinfo.format == 0) AUD_THROW(FileException, "This format couldn't be written with libsndfile."); m_sndfile = sf_open(filename.c_str(), SFM_WRITE, &sfinfo); if(!m_sndfile) AUD_THROW(FileException, "The file couldn't be written with libsndfile."); }