int16_t WebRtcOpus_DecoderCreate(OpusDecInst** inst, int channels) { int error_l; int error_r; OpusDecInst* state; // Create Opus decoder memory. state = (OpusDecInst*) calloc(1, sizeof(OpusDecInst)); if (state == NULL) { return -1; } // Create new memory for left and right channel, always at 48000 Hz. state->decoder_left = opus_decoder_create(48000, channels, &error_l); state->decoder_right = opus_decoder_create(48000, channels, &error_r); if (error_l == OPUS_OK && error_r == OPUS_OK && state->decoder_left != NULL && state->decoder_right != NULL) { // Creation of memory all ok. state->channels = channels; *inst = state; return 0; } // If memory allocation was unsuccessful, free the entire state. if (state->decoder_left) { opus_decoder_destroy(state->decoder_left); } if (state->decoder_right) { opus_decoder_destroy(state->decoder_right); } free(state); state = NULL; return -1; }
static void audio_renderer_init() { int rc; decoder = opus_decoder_create(SAMPLE_RATE, CHANNEL_COUNT, &rc); snd_pcm_hw_params_t *hw_params; snd_pcm_sw_params_t *sw_params; snd_pcm_uframes_t period_size = FRAME_SIZE * CHANNEL_COUNT * 2; snd_pcm_uframes_t buffer_size = 12 * period_size; unsigned int sampleRate = SAMPLE_RATE; /* Open PCM device for playback. */ CHECK_RETURN(snd_pcm_open(&handle, audio_device, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)) /* Set hardware parameters */ CHECK_RETURN(snd_pcm_hw_params_malloc(&hw_params)); CHECK_RETURN(snd_pcm_hw_params_any(handle, hw_params)); CHECK_RETURN(snd_pcm_hw_params_set_access(handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)); CHECK_RETURN(snd_pcm_hw_params_set_format(handle, hw_params, SND_PCM_FORMAT_S16_LE)); CHECK_RETURN(snd_pcm_hw_params_set_rate_near(handle, hw_params, &sampleRate, NULL)); CHECK_RETURN(snd_pcm_hw_params_set_channels(handle, hw_params, CHANNEL_COUNT)); CHECK_RETURN(snd_pcm_hw_params_set_buffer_size_near(handle, hw_params, &buffer_size)); CHECK_RETURN(snd_pcm_hw_params_set_period_size_near(handle, hw_params, &period_size, NULL)); CHECK_RETURN(snd_pcm_hw_params(handle, hw_params)); snd_pcm_hw_params_free(hw_params); /* Set software parameters */ CHECK_RETURN(snd_pcm_sw_params_malloc(&sw_params)); CHECK_RETURN(snd_pcm_sw_params_current(handle, sw_params)); CHECK_RETURN(snd_pcm_sw_params_set_start_threshold(handle, sw_params, buffer_size - period_size)); CHECK_RETURN(snd_pcm_sw_params_set_avail_min(handle, sw_params, period_size)); CHECK_RETURN(snd_pcm_sw_params(handle, sw_params)); snd_pcm_sw_params_free(sw_params); CHECK_RETURN(snd_pcm_prepare(handle)); }
static int opus_decoder_construct(struct ast_trans_pvt *pvt, int sampling_rate) { struct opus_coder_pvt *opvt = pvt->pvt; int error = 0; if (!valid_sampling_rate(sampling_rate)) { return -1; } opvt->sampling_rate = sampling_rate; opvt->multiplier = 48000/sampling_rate; opvt->fec = USE_FEC; /* FIXME: should be triggered by chan_sip */ opvt->opus = opus_decoder_create(sampling_rate, 1, &error); if (error != OPUS_OK) { ast_log(LOG_ERROR, "Error creating the Opus decoder: %s\n", opus_strerror(error)); return -1; } opvt->id = ast_atomic_fetchadd_int(&usage.decoder_id, 1) + 1; ast_atomic_fetchadd_int(&usage.decoders, +1); ast_debug(3, "Created decoder #%d (opus -> %d)\n", opvt->id, sampling_rate); return 0; }
static int tdav_codec_opus_open(tmedia_codec_t* self) { tdav_codec_opus_t* opus = (tdav_codec_opus_t*)self; int opus_err; if(!opus) { TSK_DEBUG_ERROR("Invalid parameter"); return -1; } // Initialize the decoder if(!opus->decoder.inst) { TSK_DEBUG_INFO("[OPUS] Open decoder: rate=%d, channels=%d", (int)self->in.rate, (int)TMEDIA_CODEC_AUDIO(self)->in.channels); if(!(opus->decoder.inst = opus_decoder_create((opus_int32)self->in.rate, (int)TMEDIA_CODEC_AUDIO(self)->in.channels, &opus_err)) || opus_err != OPUS_OK) { TSK_DEBUG_ERROR("Failed to create Opus decoder(rate=%d, channels=%d) instance with error code=%d.", (int)self->in.rate, (int)TMEDIA_CODEC_AUDIO(self)->in.channels, opus_err); return -2; } } opus->decoder.last_seq = 0; // Initialize the encoder if(!opus->encoder.inst) { TSK_DEBUG_INFO("[OPUS] Open encoder: rate=%d, channels=%d", (int)self->out.rate, (int)TMEDIA_CODEC_AUDIO(self)->out.channels); if(!(opus->encoder.inst = opus_encoder_create((opus_int32)self->out.rate, (int)TMEDIA_CODEC_AUDIO(self)->out.channels, OPUS_APPLICATION_VOIP, &opus_err)) || opus_err != OPUS_OK) { TSK_DEBUG_ERROR("Failed to create Opus decoder(rate=%d, channels=%d) instance with error code=%d.", (int)self->out.rate, (int)TMEDIA_CODEC_AUDIO(self)->out.channels, opus_err); return -2; } } #if TDAV_UNDER_MOBILE /* iOS, Android and WP8 */ opus_encoder_ctl(opus->encoder.inst, OPUS_SET_COMPLEXITY(3)); #endif opus_encoder_ctl(opus->encoder.inst, OPUS_SET_SIGNAL(OPUS_SIGNAL_VOICE)); return 0; }
void SoundOpusData::onRender() { if(_samples && samplesDecodingProgress != _frames) { Decoder* dec = 0; foreach(e, decoders) { if(e->first == 0) { dec = e; break; } } if(!dec) { dec = decoders.push(); int err; dec->decoder = opus_decoder_create(AUDIOLIB_FRAME_RATE, _channels, &err); dec->first = 0; dec->end = 0; } if(dec->end == samplesDecodingProgress) { uint packet = dec->end / SOUNDLIB_OPUS_PACKET_FRAMES; opus_decode(dec->decoder, _opusData + SOUNDLIB_OPUS_PACKET_SIZE * _channels * packet, SOUNDLIB_OPUS_PACKET_SIZE * _channels, _samples + _channels * packet * SOUNDLIB_OPUS_PACKET_FRAMES, SOUNDLIB_OPUS_PACKET_FRAMES, 0); dec->end += SOUNDLIB_OPUS_PACKET_FRAMES; dec->unusedCount = 0; } samplesDecodingProgress = dec->end; }
bool reconfigure_audio_decoder(ACSession *ac, int32_t sampling_rate, int8_t channels) { if (sampling_rate != ac->ld_sample_rate || channels != ac->ld_channel_count) { if (current_time_monotonic() - ac->ldrts < 500) { return false; } int status; OpusDecoder *new_dec = opus_decoder_create(sampling_rate, channels, &status); if (status != OPUS_OK) { LOGGER_ERROR(ac->log, "Error while starting audio decoder(%d %d): %s", sampling_rate, channels, opus_strerror(status)); return false; } ac->ld_sample_rate = sampling_rate; ac->ld_channel_count = channels; ac->ldrts = current_time_monotonic(); opus_decoder_destroy(ac->decoder); ac->decoder = new_dec; LOGGER_DEBUG(ac->log, "Reconfigured audio decoder sr: %d cc: %d", sampling_rate, channels); } return true; }
EncodeManager::EncodeManager() { _enc = opus_encoder_create(SAMPLE_RATE, 2, OPUS_APPLICATION_VOIP, &_err); _dec = opus_decoder_create(SAMPLE_RATE, 2, &_err); opus_encoder_ctl(this->_enc, OPUS_GET_BANDWIDTH(&this->_len)); this->_len = FRAMES_PER_BUFFER; }
long opus_create(const char* format_parameters, const char** format_parameters_out, amci_codec_fmt_info_t** format_description) { opus_state_t* codec_inst; int error; unsigned int maxbandwidth = _OPUS_RATE; int useinbandfec = _OPUS_INBAND_FEC_; int stereo = 0; if (format_parameters) { DBG("OPUS params: >>%s<<.\n", format_parameters); decode_format_parameters(format_parameters, &maxbandwidth, &useinbandfec, &stereo); } codec_inst = (opus_state_t*)malloc(sizeof(opus_state_t)); if (!codec_inst) return -1; DBG("OPUS: creating encoder with maxbandwidth=%u, stereo=%s, useinbandfec=%s\n", maxbandwidth, stereo?"true":"false", useinbandfec?"true":"false"); codec_inst->opus_enc = opus_encoder_create(_OPUS_RATE,1,_OPUS_APPLICATION_,&error); if (error) { DBG("OPUS: error %d while creating encoder state.\n", error); return -1; } opus_encoder_ctl(codec_inst->opus_enc, OPUS_SET_FORCE_CHANNELS(stereo ? 2:1)); unsigned int opus_set_bw = _OPUS_RATE; if (maxbandwidth <= 8000) { opus_set_bw = OPUS_BANDWIDTH_NARROWBAND; } else if (maxbandwidth <= 12000) { opus_set_bw = OPUS_BANDWIDTH_MEDIUMBAND; } else if (maxbandwidth <= 16000) { opus_set_bw = OPUS_BANDWIDTH_WIDEBAND; } else if (maxbandwidth <= 24000) { opus_set_bw = OPUS_BANDWIDTH_SUPERWIDEBAND; } else { opus_set_bw = OPUS_BANDWIDTH_FULLBAND; } opus_encoder_ctl(codec_inst->opus_enc, OPUS_SET_MAX_BANDWIDTH(opus_set_bw)); opus_encoder_ctl(codec_inst->opus_enc, OPUS_SET_PACKET_LOSS_PERC(_OPUS_PKT_LOSS_PCT_)); opus_encoder_ctl(codec_inst->opus_enc, OPUS_SET_COMPLEXITY(_OPUS_COMPLEXITY_)); opus_encoder_ctl(codec_inst->opus_enc, OPUS_SET_INBAND_FEC(useinbandfec ? 1:0)); opus_encoder_ctl(codec_inst->opus_enc, OPUS_SET_DTX(_OPUS_DTX_)); codec_inst->opus_dec = opus_decoder_create(_OPUS_RATE,1,&error); if (error) { DBG("OPUS: error %d while creating decoder state.\n", error); opus_encoder_destroy(codec_inst->opus_enc); return -1; } *format_description = opus_fmt_description; return (long)codec_inst; }
void Opus::setOptimalFormat(uint32_t sample_rate, uint8_t channels) { // Use a SR higher or equal to sample_rate. // Typical case: 44.1kHz => 48kHz. unsigned i = 0; while (i < VALID_SAMPLING_RATE_NUM - 1 and VALID_SAMPLING_RATE[i] < sample_rate) i++; sample_rate = VALID_SAMPLING_RATE[i]; // Opus supports 1 or 2 channels. channels = std::max(std::min(channels, (uint8_t) 2), (uint8_t) 1); if (not (!encoder_ || !decoder_ || sample_rate != clockRateCur_ || channels != channelsCur_)) return; clockRateCur_ = sample_rate; channelsCur_ = channels; int err; if (encoder_) opus_encoder_destroy(encoder_); encoder_ = opus_encoder_create(sample_rate, channels, OPUS_APPLICATION_VOIP, &err); if (err) throw std::runtime_error("opus: could not create encoder"); if (decoder_) opus_decoder_destroy(decoder_); lastDecodedFrameSize_ = 0; decoder_ = opus_decoder_create(sample_rate, channels, &err); if (err) throw std::runtime_error("opus: could not create decoder"); }
bool FVoiceDecoderOpus::Init(int32 InSampleRate, int32 InNumChannels) { UE_LOG(LogVoiceDecode, Display, TEXT("DecoderVersion: %s"), ANSI_TO_TCHAR(opus_get_version_string())); SampleRate = InSampleRate; NumChannels = InNumChannels; FrameSize = SampleRate / 50; int32 DecSize = 0; int32 DecError = 0; #if USE_UE4_MEM_ALLOC DecSize = opus_decoder_get_size(NumChannels); Decoder = (OpusDecoder*)FMemory::Malloc(DecSize); DecError = opus_decoder_init(Decoder, SampleRate, NumChannels); #else Decoder = opus_decoder_create(SampleRate, NumChannels, &DecError); #endif if (DecError != OPUS_OK) { UE_LOG(LogVoiceDecode, Warning, TEXT("Failed to init Opus Decoder: %s"), ANSI_TO_TCHAR(opus_strerror(DecError))); Destroy(); } return DecError == OPUS_OK; }
static int alloc(struct aucodec_st **stp, struct aucodec *ac, struct aucodec_prm *encp, struct aucodec_prm *decp, const char *fmtp) { struct aucodec_st *st; const uint32_t srate = aucodec_srate(ac); const uint8_t ch = aucodec_ch(ac); uint32_t ptime = DEFAULT_PTIME; int use_inbandfec; int use_dtx; int err = 0; int opuserr; (void)decp; (void)fmtp; st = mem_zalloc(sizeof(*st), destructor); if (!st) return ENOMEM; if (encp && encp->ptime) ptime = encp->ptime; st->ac = mem_ref(ac); st->frame_size = srate * ptime / 1000; st->fsize = 2 * st->frame_size * ch; /* Encoder */ st->enc = opus_encoder_create(srate, ch, opus.app, &opuserr); if (!st->enc) { err = ENOMEM; goto out; } use_inbandfec = 1; use_dtx = 1; opus_encoder_ctl(st->enc, OPUS_SET_BITRATE(opus.bitrate)); opus_encoder_ctl(st->enc, OPUS_SET_BANDWIDTH(opus.bandwidth)); opus_encoder_ctl(st->enc, OPUS_SET_VBR(opus.vbr)); opus_encoder_ctl(st->enc, OPUS_SET_COMPLEXITY(opus.complex)); opus_encoder_ctl(st->enc, OPUS_SET_INBAND_FEC(use_inbandfec)); opus_encoder_ctl(st->enc, OPUS_SET_DTX(use_dtx)); /* Decoder */ st->dec = opus_decoder_create(srate, ch, &opuserr); if (!st->dec) { err = ENOMEM; goto out; } out: if (err) mem_deref(st); else *stp = st; return err; }
int init_receive_audio(codec_state *cs) { int err = OPUS_OK; cs->audio_decoder = opus_decoder_create(48000, 1, &err); opus_decoder_init(cs->audio_decoder, 48000, 1); printf("init audio decoder successful\n"); return 1; }
// This function must be called before // any other decoding functions int nv_opus_init(void) { int err; decoder = opus_decoder_create( nv_opus_get_sample_rate(), nv_opus_get_channel_count(), &err); return err; }
virtual bool Construct() { int error; if ((m_decoder = opus_decoder_create(m_sampleRate, m_channels, &error)) != NULL) return true; PTRACE(1, MY_CODEC_LOG, "Decoder create error " << error << ' ' << opus_strerror(error)); return false; }
EMSCRIPTEN_KEEPALIVE Encoder* create_encoder_and_decoder(opus_int32 sample_rate, int channels, int application) { Encoder* enc = malloc(sizeof(Encoder)); enc->encoder = opus_encoder_create( sample_rate, channels, application, &enc->encoder_error ); enc->decoder = opus_decoder_create( sample_rate, channels, &enc->decoder_error ); return enc; }
static void ms_opus_dec_preprocess(MSFilter *f) { int error; OpusDecData *d = (OpusDecData *)f->data; d->state = opus_decoder_create(d->samplerate, d->channels, &error); if (error != OPUS_OK) { ms_error("Opus decoder creation failed: %s", opus_strerror(error)); } /* initialise the concealer context */ d->concealer = ms_concealer_context_new(UINT32_MAX); }
AudioCodec::AudioCodec() { this->FrameSize = 24000; this->num_channels = 2; this->enc = opus_encoder_create(this->FrameSize, this->num_channels, OPUS_APPLICATION_VOIP, &this->error); this->dec = opus_decoder_create(this->FrameSize, this->num_channels, &this->error); opus_int32 size; opus_encoder_ctl(enc, OPUS_GET_BANDWIDTH(&size)); this->data_size = size; }
JNIEXPORT jlong JNICALL Java_org_jitsi_impl_neomedia_codec_audio_opus_Opus_decoder_1create (JNIEnv *env, jclass clazz, jint Fs, jint channels) { int error; OpusDecoder *decoder = opus_decoder_create(Fs, channels, &error); if (OPUS_OK != error) decoder = 0; return (jlong) (intptr_t) decoder; }
int init_audio_decoder(CodecState *cs, uint32_t audio_channels) { int rc; cs->audio_decoder = opus_decoder_create(cs->audio_sample_rate, audio_channels, &rc ); if ( rc != OPUS_OK ) { LOGGER_ERROR("Error while starting audio decoder: %s", opus_strerror(rc)); return -1; } return 0; }
opus_decoder::opus_decoder() { int err; _opus = opus_decoder_create(SAMPLE_RATE, CHANNELS, &err); if(err != OPUS_OK) { LOG << "opus decoder create error: "; log_opus_error(err); } ENSURE(_opus); }
//function sets up the encoder/decoder structs and buffers, returns required samples/frame int setup_codecs(){ //create the encoder and decoder state structs int error = 0; if(!(enc_state = opus_encoder_create(SAMPLE_RATE,1,APP_MODE,&error))) printf("Error Creating Encoder: %d\n",error); if(!(dec_state = opus_decoder_create(SAMPLE_RATE,1,&error))) printf("Error Creating Decoder: %d\n",error); opus_encoder_ctl(enc_state, OPUS_SET_COMPLEXITY(QUALITY)); return FRAME_SIZE; //return the frame size ( }
static int init_audio_decoder(CSSession *cs) { int rc; cs->audio_decoder = opus_decoder_create(cs->audio_decoder_sample_rate, cs->audio_decoder_channels, &rc ); if ( rc != OPUS_OK ) { LOGGER_ERROR("Error while starting audio decoder: %s", opus_strerror(rc)); return -1; } return 0; }
OpusDecoder *tc_opus_create_decoder(int sample_rate, int channels) { int err; OpusDecoder * decoder = opus_decoder_create(sample_rate, channels, &err); if (err<0) { pa_log_error("failed to create decoder: %s", opus_strerror(err)); return NULL; } return decoder; }
int init_audio_decoder(CodecState *cs, uint32_t audio_channels) { int rc; cs->audio_decoder = opus_decoder_create(cs->audio_sample_rate, audio_channels, &rc ); if ( rc != OPUS_OK ) { fprintf(stderr, "Error while starting audio decoder!\n"); return -1; } return 0; }
WebRtc_Word16 WebRtcOpus_CreateDec(OPUS_decinst_t** inst, WebRtc_Word16 samplFreq){ *inst=(OPUS_decinst_t*)malloc(sizeof(OPUS_Dec_Inst_t)); if (*inst==NULL) { return(-1); } int err; ((OPUS_Dec_Inst_t*)*inst)->dec = opus_decoder_create(16000, 1, &err); if(err != OPUS_OK || ((OPUS_Dec_Inst_t*)*inst)->dec==NULL) { return (-1); } return(0); }
int16_t WebRtcOpus_DecoderCreate(OpusDecInst** inst, int channels) { OpusDecInst* state; state = (OpusDecInst*) calloc(1, sizeof(OpusDecInst)); if (state) { int error; // Always create a 48000 Hz Opus decoder. state->decoder = opus_decoder_create(48000, channels, &error); if (error == OPUS_OK && state->decoder != NULL ) { *inst = state; return 0; } free(state); state = NULL; } return -1; }
void OpusDecode::start(int CHANNELS, int SAMPLE_RATE) { initialized = false; /* Create a new decoder state. */ int err; decoder = opus_decoder_create(SAMPLE_RATE, CHANNELS, &err); if (err<0) { qDebug() << "failed to create decoder:" << opus_strerror(err); return; } channels = CHANNELS; initialized = true; }
void OpusDecoderClass::startPrivate(int sample_rate, int channels, int frame_size, int max_frame_size) { if (m_initialized) return; /* Create a new decoder state. */ int err; m_decoder = opus_decoder_create(sample_rate, channels, &err); if (err < 0) { emit error(QString("Failed to create Opus decoder: %0").arg(opus_strerror(err))); return; } m_channels = channels; m_frame_size = frame_size; m_max_frame_size = max_frame_size; m_initialized = true; }
JNIEXPORT jlong JNICALL Java_aopus_OpusLibrary_decoderCreate (JNIEnv *env, jobject obj, jint clockRate, jint channels, jint packetTime) { Decoder *decoder = malloc(sizeof* decoder); decoder->frameSizePerChannel = (clockRate * packetTime) / 1000; decoder->maxBufferSize = clockRate * channels * packetTime * 2 / 1000; // 2 bytes per sample, 1000 ms per second decoder->buffer = malloc(decoder->maxBufferSize); decoder->channels = channels; decoder->previousPacketInvalid = 0; // initialize decoder int error; decoder->dec = opus_decoder_create(clockRate, channels, &error); if (error != OPUS_OK) { __android_log_print(ANDROID_LOG_ERROR, "fm.libopus", "Could not initialize decoder. %d", error); return 0; } return decoder; }
static void sdl_renderer_init() { int rc; decoder = opus_decoder_create(SAMPLE_RATE, CHANNEL_COUNT, &rc); SDL_InitSubSystem(SDL_INIT_AUDIO); SDL_AudioSpec want, have; SDL_zero(want); want.freq = SAMPLE_RATE; want.format = AUDIO_S16LSB; want.channels = CHANNEL_COUNT; want.samples = 4096; dev = SDL_OpenAudioDevice(NULL, 0, &want, &have, SDL_AUDIO_ALLOW_FORMAT_CHANGE); if (dev == 0) { printf("Failed to open audio: %s\n", SDL_GetError()); } else { if (have.format != want.format) // we let this one thing change. printf("We didn't get requested audio format.\n"); SDL_PauseAudioDevice(dev, 0); // start audio playing. } }