void _dumb_init_cubic(void)
{
static int done = 0;
if (done) return;
resampler_init();
done = 1;
}
//USRP initialisation
bool usrp_init (const char *rx_subdev_par, const char *tx_subdev_par)
{
uhd::device_addr_t hint;
hint["type"] = "usrp1";
//discover the usrps and print the results
uhd::device_addrs_t device_addrs = uhd::device::find(hint);
if (device_addrs.size() == 0){
std::cerr << "*** FATAL: No UHD devices Found" << std::endl;
return false;
}
for (size_t i = 0; i < device_addrs.size(); i++){
std::cout << "--------------------------------------------------" << std::endl;
std::cout << "-- UHD Device " << i << std::endl;
std::cout << "--------------------------------------------------" << std::endl;
std::cout << device_addrs[i].to_pp_string() << std::endl << std::endl;
usrp.tx_enabled = false;
// USRP create
usrp.sdev = uhd::usrp::multi_usrp::make(device_addrs[i]);
//Lock mboard clocks
usrp.sdev->set_clock_config(uhd::clock_config_t::internal(), 0);
//std::cerr << boost::format("USRP Subdev specs: %s\n") % subdev_specs << std::endl;
usrp_set_subdev_args(rx_subdev_par, tx_subdev_par);
//set the USRP rx standard sample rate 256000 for minimum bandwidth.
usrp.sdev->set_rx_rate(USRP_RX_SAMPLERATE);
//std::cout << boost::format("USRP RX Rate: %f Msps") % (usrp.sdev->get_rx_rate()/1e6) << std::endl;
//set the USRP tx standard sample rate 320000 - USRP interpolation is automatic
usrp.sdev->set_tx_rate(USRP_TX_SAMPLERATE);
//std::cout << boost::format("USRP TX Rate: %f Msps") % (usrp.sdev->get_tx_rate()/1e6) << std::endl;
usrp_set_frequency(DEFAULT_RX_FREQUENCY); //TEMPORARY
sleep(1); //allow for some setup time
usrp.dev = usrp.sdev->get_device();
MAX_USRP_RX_BUFFER = usrp.dev->get_max_recv_samps_per_packet();
MAX_USRP_TX_BUFFER = usrp.dev->get_max_send_samps_per_packet();
ZERO_CPX_VECTOR = std::vector<std::complex<float> >(MAX_USRP_RX_BUFFER, CPX_ZERO);
setup_rx_queue();
setup_tx_queue();
pthread_mutex_init(&RECEIVER_CYCLE_lock, NULL );
resampler_init();
return true;
}
return false;
}
USFPlayer(const std::string &fileName) {
usf_state = new usf_loader_state;
usf_state->emu_state = malloc( usf_get_state_size() );
usf_clear( usf_state->emu_state );
sample_rate = 0;
char temp[fileName.length()+1];
strcpy(temp, fileName.c_str());
LOGD("Trying to load USF %s", string(temp));
if ( psf_load( temp, &psf_file_system, 0x21, usf_loader, usf_state, usf_info, usf_state, 1 ) < 0 )
throw player_exception();
usf_set_hle_audio(usf_state->emu_state, 1);
PSFFile psf { fileName };
if(psf.valid()) {
auto &tags = psf.tags();
int seconds = psf.songLength();
setMeta("composer", tags["artist"],
"sub_title", tags["title"],
"game", tags["game"],
"format", "Nintendo 64",
"length", seconds
);
}
usf_set_compare( usf_state->emu_state, usf_state->enable_compare );
usf_set_fifo_full( usf_state->emu_state, usf_state->enable_fifo_full );
const char *err = usf_render(usf_state->emu_state, 0, 0, &sample_rate);
if(err)
LOGD("ERROR %s", err);
LOGD("######### RATE %d", sample_rate);
resampler_init();
for(auto &r : resampler) {
r = resampler_create();
resampler_set_quality(r, RESAMPLER_QUALITY_CUBIC);
resampler_set_rate(r, (float)sample_rate / 44100.0);
//resampler_set_rate(r, 44100.0 / (float)sample_rate);
resampler_clear(r);
}
}
bool stream_transcode(stream_t *stream, codec_type_t codec_type, int bitrate)
{
int result;
enum AVCodecID dst_codec_id;
AVCodec *dst_codec = NULL;
AVCodecContext *decoder = NULL, *encoder = NULL;
enum AVSampleFormat dst_sample_fmt;
int dst_sample_rate;
resampler_t *resampler = NULL;
if (codec_type == CODEC_TYPE_MP3) {
dst_codec_id = AV_CODEC_ID_MP3;
} else if (codec_type == CODEC_TYPE_OGG_VORBIS) {
dst_codec_id = AV_CODEC_ID_VORBIS;
} else if (codec_type == CODEC_TYPE_FLAC) {
dst_codec_id = AV_CODEC_ID_FLAC;
} else if (codec_type == CODEC_TYPE_AAC) {
dst_codec_id = AV_CODEC_ID_AAC;
} else if (codec_type == CODEC_TYPE_OPUS) {
dst_codec_id = AV_CODEC_ID_OPUS;
} else {
musicd_log(LOG_ERROR, "stream", "unsupported encoder requested");
return false;;
}
dst_codec = avcodec_find_encoder(dst_codec_id);
if (!dst_codec) {
musicd_log(LOG_ERROR, "stream", "requested encoder not found");
return false;
}
decoder = stream->src_ctx->streams[0]->codec;
/* Try to figure out common sample format to skip format conversion */
decoder->request_sample_fmt =
find_common_sample_fmt(stream->src_codec->sample_fmts,
dst_codec->sample_fmts);
result = avcodec_open2(decoder, stream->src_codec, NULL);
if (result < 0) {
musicd_log(LOG_ERROR, "stream", "can't open decoder: %s",
strerror(AVUNERROR(result)));
goto fail;
}
dst_sample_fmt = find_sample_fmt(decoder->sample_fmt,
dst_codec->sample_fmts);
dst_sample_rate = find_sample_rate(decoder->sample_rate,
dst_codec->supported_samplerates);
/** @todo FIXME Hard-coded values. */
if (bitrate < 64000 || bitrate > 320000) {
bitrate = 196000;
}
if (decoder->channel_layout == 0) {
decoder->channel_layout = av_get_default_channel_layout(decoder->channels);
}
encoder = avcodec_alloc_context3(dst_codec);
encoder->sample_rate = dst_sample_rate;
encoder->channels = decoder->channels;
encoder->sample_fmt = dst_sample_fmt;
encoder->channel_layout = decoder->channel_layout;
encoder->bit_rate = bitrate;
result = avcodec_open2(encoder, dst_codec, NULL);
if (result < 0) {
musicd_log(LOG_ERROR, "stream", "can't open encoder: %s",
strerror(AVUNERROR(result)));
goto fail;
}
if (decoder->channel_layout != encoder->channel_layout ||
decoder->sample_fmt != encoder->sample_fmt ||
decoder->sample_rate != encoder->sample_rate) {
resampler = resampler_alloc();
av_opt_set_int(resampler, "in_channel_layout", decoder->channel_layout, 0);
av_opt_set_int(resampler, "out_channel_layout", encoder->channel_layout, 0);
av_opt_set_int(resampler, "in_sample_rate", decoder->sample_rate, 0);
av_opt_set_int(resampler, "out_sample_rate", encoder->sample_rate, 0);
av_opt_set_int(resampler, "in_sample_fmt", decoder->sample_fmt, 0);
av_opt_set_int(resampler, "out_sample_fmt", encoder->sample_fmt, 0);
result = resampler_init(resampler);
if (result < 0) {
musicd_log(LOG_ERROR, "stream", "can't open resampler: %s",
strerror(AVUNERROR(result)));
goto fail;
}
musicd_log(LOG_DEBUG, "stream",
"resample: ch:%d(%d) rate:%d fmt:%d -> ch:%d(%d) rate:%d fmt:%d",
decoder->channel_layout, decoder->channels,
decoder->sample_rate, decoder->sample_fmt,
encoder->channel_layout, encoder->channels,
encoder->sample_rate, encoder->sample_fmt);
}
stream->decoder = decoder;
stream->encoder = encoder;
stream->dst_codec = dst_codec;
stream->dst_codec_type = codec_type;
stream->resampler = resampler;
format_from_av(encoder, &stream->format);
stream->src_buf = av_audio_fifo_alloc(encoder->sample_fmt, encoder->channels, encoder->frame_size);
stream->decode_frame = avcodec_alloc_frame();
if (stream->resampler) {
/* The buffer will be allocated dynamically */
stream->resample_frame = avcodec_alloc_frame();
}
int buf_size = av_samples_get_buffer_size(NULL, stream->encoder->channels,
stream->encoder->frame_size,
stream->encoder->sample_fmt, 0);
stream->encode_buf = av_mallocz(buf_size);
stream->encode_frame = avcodec_alloc_frame();
stream->encode_frame->nb_samples = stream->encoder->frame_size;
avcodec_fill_audio_frame(stream->encode_frame,
stream->encoder->channels,
stream->encoder->sample_fmt,
stream->encode_buf, buf_size, 0);
return true;
fail:
if (decoder) {
avcodec_close(decoder);
}
if (encoder) {
avcodec_close(encoder);
av_free(encoder);
}
if (resampler) {
resampler_free(&resampler);
}
return false;
}
