bool decode_run(audio_chunk & p_chunk, abort_callback & p_abort)
{
size_t data_size = m_decoder->decode_frame(&sample_buffer);
if (config.format == 6)
{
p_chunk.set_data_floatingpoint_ex(
sample_buffer.get_ptr(),
data_size,
m_decoder->sample_rate,
config.speakers,
get_bps_for_format(config.format),
get_flags_for_format(config.format),
get_channel_config_for_speakers(config.speakers));
}
else
{
p_chunk.set_data_fixedpoint_ex(
sample_buffer.get_ptr(),
data_size,
m_decoder->sample_rate,
config.speakers,
get_bps_for_format(config.format),
get_flags_for_format(config.format),
get_channel_config_for_speakers(config.speakers));
}
return (data_size > 0);
}
void output_impl::process_samples(const audio_chunk & p_chunk) {
pfc::dynamic_assert(m_incoming_ptr == m_incoming.get_size());
t_samplespec spec;
spec.fromchunk(p_chunk);
if (!spec.is_valid()) pfc::throw_exception_with_message< exception_io_data >("Invalid audio stream specifications");
m_incoming_spec = spec;
t_size length = p_chunk.get_used_size();
m_incoming.set_data_fromptr(p_chunk.get_data(),length);
m_incoming_ptr = 0;
}
bool decode_run(audio_chunk &chunk, abort_callback &abort)
{
if (m_current_packet >= m_demuxer->num_packets() + 1)
return false;
int64_t pull_packet = m_current_packet;
if (m_current_packet == m_demuxer->num_packets()) {
/*
* If the end padding is shorter than the decoder delay,
* we already have fed all packets to the decoder but still
* we have to feed extra packet to pull the final delayed result.
* Due to overlap+add, samples might not be fully reconstructed
* anyway...
*/
if (decoder_delay() <= m_demuxer->end_padding())
return false;
else
pull_packet = m_current_packet - 1;
}
auto asbd = m_demuxer->format().asbd;
uint32_t fpp = asbd.mFramesPerPacket;
uint32_t npackets = m_demuxer->read_packets(pull_packet,
m_packets_per_chunk,
&m_chunk_buffer, abort);
if (npackets == 0)
return false;
m_current_packet += npackets;
int64_t trim = std::max(m_current_packet * fpp - m_demuxer->duration()
- m_demuxer->start_offset() - decoder_delay(),
static_cast<int64_t>(0));
if (trim >= fpp * npackets)
return false;
m_decoder->decode(m_chunk_buffer.data(), m_chunk_buffer.size(),
chunk, abort);
t_size nframes = chunk.get_sample_count();
unsigned nchannels = chunk.get_channels();
if (trim > 0) {
nframes = fpp * npackets - trim;
chunk.set_sample_count(nframes);
}
if (m_start_skip) {
if (m_start_skip >= nframes) {
m_start_skip -= nframes;
return decode_run(chunk, abort);
}
uint32_t rest = nframes - m_start_skip;
uint32_t bpf = nchannels * sizeof(audio_sample);
audio_sample *bp = chunk.get_data();
std::memmove(bp, bp + m_start_skip * nchannels, rest * bpf);
chunk.set_sample_count(rest);
m_start_skip = 0;
}
update_dynamic_vbr_info(m_current_packet - npackets, m_current_packet);
return true;
}
bool decode_file(char const * p_path,audio_chunk& chunk, abort_callback & p_abort)
{
try
{
input_helper helper;
file_info_impl info;
// open input
helper.open(service_ptr_t<file>(), make_playable_location(p_path, 0), input_flag_simpledecode, p_abort);
helper.get_info(0, info, p_abort);
if (info.get_length() <= 0)
throw pfc::exception("Track length invalid");
audio_chunk_impl chunk;
if (!helper.run(chunk, p_abort)) return false;
t_uint64 length_samples = audio_math::time_to_samples(info.get_length(), chunk.get_sample_rate());
while (true)
{
bool decode_done = !helper.run(chunk, p_abort);
if (decode_done) break;
}
return true;
}
catch (const exception_aborted &) {throw;}
catch (const std::exception & exc)
{
console::formatter() << exc << ": " << p_path;
return false;
}
};
void on_chunk(const audio_chunk & chunk)
{
unsigned int srate = chunk.get_srate();
if (send_play)
{
send_play = false;
slim_server->get_connection_manager().send_stream_stop_all();
slim_server->get_connection_manager().send_audio_gain_all(128, true, 255);
slim_server->get_connection_manager().send_stream_play_all(
URL_PATH_STREAM, cfg_http_port.get_value(), g_get_bps(), srate);
}
if (is_playing)
{
mem_block_container_impl_t<> data;
chunk.to_raw_data(data, g_get_bps());
std::set<http::server::connection_ptr> connections =
http_server->get_connection_manager().get_connections();
std::set<http::server::connection_ptr>::const_iterator c;
for (c = connections.begin(); c != connections.end(); ++c)
{
http::server::connection_ptr c_ptr = (http::server::connection_ptr)(*c);
// if sending data to the http stream connection returns with
// an error, close the connection and call slim server to send
// a new play command to the device.
if (c_ptr->send_data(data.get_ptr(), data.get_size()) < 0)
{
std::string mac_address = c_ptr->get_mac_address();
http_server->get_connection_manager().stop(c_ptr);
if (!mac_address.empty())
{
slim_server->get_connection_manager().send_stream_play(
mac_address, URL_PATH_STREAM, cfg_http_port.get_value(), g_get_bps(), srate);
}
}
}
}
}
bool decode_run(audio_chunk & p_chunk,abort_callback & p_abort) {
if ( settings.channels == 1 ) {
std::size_t count = mod->read( settings.samplerate, buffersize, left.data() );
if ( count == 0 ) {
return false;
}
for ( std::size_t frame = 0; frame < count; frame++ ) {
buffer[frame*1+0] = left[frame];
}
p_chunk.set_data_32( buffer.data(), count, settings.channels, settings.samplerate );
return true;
} else if ( settings.channels == 2 ) {
std::size_t count = mod->read( settings.samplerate, buffersize, left.data(), right.data() );
if ( count == 0 ) {
return false;
}
for ( std::size_t frame = 0; frame < count; frame++ ) {
buffer[frame*2+0] = left[frame];
buffer[frame*2+1] = right[frame];
}
p_chunk.set_data_32( buffer.data(), count, settings.channels, settings.samplerate );
return true;
} else if ( settings.channels == 4 ) {
std::size_t count = mod->read( settings.samplerate, buffersize, left.data(), right.data(), rear_left.data(), rear_right.data() );
if ( count == 0 ) {
return false;
}
for ( std::size_t frame = 0; frame < count; frame++ ) {
buffer[frame*4+0] = left[frame];
buffer[frame*4+1] = right[frame];
buffer[frame*4+2] = rear_left[frame];
buffer[frame*4+3] = rear_right[frame];
}
p_chunk.set_data_32( buffer.data(), count, settings.channels, settings.samplerate );
return true;
} else {
return false;
}
}
bool decode_run( audio_chunk & p_chunk, abort_callback & p_abort )
{
if (!loop && m_info.musicTimeInMs == ymMusicGetPos(m_player)) return false;
int nbSample = 500 / sizeof(ymsample);
sample_buffer.grow_size( nbSample );
ymMusicCompute(m_player,sample_buffer.get_ptr(), nbSample);
p_chunk.set_data_fixedpoint( sample_buffer.get_ptr(), nbSample * 2, 44100, 1, 16, audio_chunk::channel_config_mono );
return true;
}
bool decode_run( audio_chunk & p_chunk, abort_callback & p_abort )
{
if (!loop && is_playing == 0) return false;
int nbSample = 512;
sample_buffer.grow_size( nbSample );
is_playing = ModPlug_Read(m_player, sample_buffer.get_ptr(), nbSample*2);
p_chunk.set_data_fixedpoint( sample_buffer.get_ptr(), nbSample * 2, 44100, 2, 32, audio_chunk::channel_config_stereo );
return true;
}
bool decode_run(audio_chunk & p_chunk,abort_callback & p_abort) {
enum {
deltaread = 1024,
};
m_buffer.set_size(deltaread * raw_total_sample_width);
t_size deltaread_done = m_file->read(m_buffer.get_ptr(),deltaread * raw_total_sample_width,p_abort) / raw_total_sample_width;
if (deltaread_done == 0) return false;//EOF
p_chunk.set_data_fixedpoint(m_buffer.get_ptr(),deltaread_done * raw_total_sample_width,raw_sample_rate,raw_channels,raw_bits_per_sample,audio_chunk::g_guess_channel_config(raw_channels));
//processed successfully, no EOF
return true;
}
bool decode_run(audio_chunk &p_chunk, abort_callback &p_abort)
{
int channels = ASAPInfo_GetChannels(ASAP_GetInfo(asap));
int buffered_bytes = BUFFERED_BLOCKS * channels * (BITS_PER_SAMPLE / 8);
static BYTE buffer[BUFFERED_BLOCKS * 2 * (BITS_PER_SAMPLE / 8)];
buffered_bytes = ASAP_Generate(asap, buffer, buffered_bytes,
BITS_PER_SAMPLE == 8 ? ASAPSampleFormat_U8 : ASAPSampleFormat_S16_L_E);
if (buffered_bytes == 0)
return false;
p_chunk.set_data_fixedpoint(buffer, buffered_bytes, ASAP_SAMPLE_RATE,
channels, BITS_PER_SAMPLE,
channels == 2 ? audio_chunk::channel_config_stereo : audio_chunk::channel_config_mono);
return true;
}
bool decode_run(audio_chunk &p_chunk, abort_callback &p_abort)
{
int channels = module_info.channels;
int buffered_bytes = BUFFERED_BLOCKS * channels * (BITS_PER_SAMPLE / 8);
static
#if BITS_PER_SAMPLE == 8
byte
#else
short
#endif
buffer[BUFFERED_BLOCKS * 2];
buffered_bytes = ASAP_Generate(&asap, buffer, buffered_bytes,
(ASAP_SampleFormat) BITS_PER_SAMPLE);
if (buffered_bytes == 0)
return false;
p_chunk.set_data_fixedpoint(buffer, buffered_bytes, ASAP_SAMPLE_RATE,
channels, BITS_PER_SAMPLE,
channels == 2 ? audio_chunk::channel_config_stereo : audio_chunk::channel_config_mono);
return true;
}
void PrepareFFTChunk(audio_chunk const & source, audio_chunk & out, double centerOffset) {
const t_size channels = source.get_channel_count();
const t_uint32 sampleRate = source.get_sample_rate();
FB2K_DYNAMIC_ASSERT( sampleRate > 0 );
out.set_channels(channels, source.get_channel_config());
out.set_sample_rate(sampleRate);
const t_size inSize = source.get_sample_count();
const t_size fftSize = MatchFFTSize(inSize);
out.set_sample_count(fftSize);
out.set_data_size(fftSize * channels);
if (fftSize >= inSize) { //rare case with *REALLY* small input
pfc::memcpy_t( out.get_data(), source.get_data(), inSize * channels );
pfc::memset_null_t( out.get_data() + inSize * channels, (fftSize - inSize) * channels );
} else { //inSize > fftSize, we're using a subset of source chunk for the job, pick a subset around centerOffset.
const double baseOffset = pfc::max_t<double>(0, centerOffset - 0.5 * (double)fftSize / (double)sampleRate);
const t_size baseSample = pfc::min_t<t_size>( (t_size) audio_math::time_to_samples(baseOffset, sampleRate), inSize - fftSize);
pfc::memcpy_t( out.get_data(), source.get_data() + baseSample * channels, fftSize * channels);
}
}
