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");
}
static int init_audio_encoder(CSSession *cs)
{
int rc = OPUS_OK;
cs->audio_encoder = opus_encoder_create(cs->audio_encoder_sample_rate,
cs->audio_encoder_channels, OPUS_APPLICATION_AUDIO, &rc);
if ( rc != OPUS_OK ) {
LOGGER_ERROR("Error while starting audio encoder: %s", opus_strerror(rc));
return -1;
}
rc = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_BITRATE(cs->audio_encoder_bitrate));
if ( rc != OPUS_OK ) {
LOGGER_ERROR("Error while setting encoder ctl: %s", opus_strerror(rc));
return -1;
}
rc = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_COMPLEXITY(10));
if ( rc != OPUS_OK ) {
LOGGER_ERROR("Error while setting encoder ctl: %s", opus_strerror(rc));
return -1;
}
return 0;
}
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;
}
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;
}
OpusSM* sm_init(int samplerate, int channels)
{
OpusSM* sm = (OpusSM*)malloc(sizeof(OpusSM));
sm->error = SM_OK;
if (samplerate != SM_SUPPORTED_SAMPLERATE) {
sm->error = SM_ERR_UNSUPPORTED_SAMPLERATE;
sm->opus_enc = NULL;
return sm;
}
/* application can be: (see opus_encoder_init() in src/opus_encoder.c)
OPUS_APPLICATION_VOIP
OPUS_APPLICATION_AUDIO
OPUS_APPLICATION_RESTRICTED_LOWDELAY */
int error;
sm->opus_enc = opus_encoder_create(samplerate, channels, OPUS_APPLICATION_VOIP, &error);
if (error != 0) {
sm->error = SM_ERR_OPUS_ENC_CREATE_FAILED;
return sm;
}
sm->celt_enc = (CELTEncoder*)((char*)sm->opus_enc + sm->opus_enc->celt_enc_offset);
celt_encoder_ctl(sm->celt_enc, CELT_GET_MODE(&sm->celt_mode));
sm->lsb_depth = IMIN(16, sm->opus_enc->lsb_depth);
sm->delay_compensation = 0;
if (sm->opus_enc->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY) sm->delay_compensation = sm->opus_enc->delay_compensation;
return sm;
}
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;
}
virtual bool Construct()
{
int error;
if ((m_encoder = opus_encoder_create(m_sampleRate, m_channels, OPUS_APPLICATION_VOIP, &error)) != NULL)
return true;
PTRACE(1, MY_CODEC_LOG, "Encoder create error " << error << ' ' << opus_strerror(error));
return false;
}
JNIEXPORT jlong JNICALL Java_org_echocat_jopus_OpusEncoderJNI_create
(JNIEnv *env, jclass thisClass, jint samplingRateInHz, jint numberOfChannels, jint application) {
int error;
long result = (long) opus_encoder_create((int) samplingRateInHz, (int) numberOfChannels, application, &error);
Java_org_echocat_jogg_OggJNISupport_checkResponse(env, error);
return result;
}
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;
}
int init_audio_encoder(CodecState *cs, uint32_t audio_channels)
{
int err = OPUS_OK;
cs->audio_encoder = opus_encoder_create(cs->audio_sample_rate, audio_channels, OPUS_APPLICATION_AUDIO, &err);
err = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_BITRATE(cs->audio_bitrate));
err = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_COMPLEXITY(10));
return err == OPUS_OK ? 0 : -1;
}
nsresult
OpusTrackEncoder::Init(int aChannels, int aSamplingRate)
{
// This monitor is used to wake up other methods that are waiting for encoder
// to be completely initialized.
ReentrantMonitorAutoEnter mon(mReentrantMonitor);
NS_ENSURE_TRUE((aChannels <= MAX_SUPPORTED_AUDIO_CHANNELS) && (aChannels > 0),
NS_ERROR_FAILURE);
// This version of encoder API only support 1 or 2 channels,
// So set the mChannels less or equal 2 and
// let InterleaveTrackData downmix pcm data.
mChannels = aChannels > MAX_CHANNELS ? MAX_CHANNELS : aChannels;
// Reject non-audio sample rates.
NS_ENSURE_TRUE(aSamplingRate >= 8000, NS_ERROR_INVALID_ARG);
NS_ENSURE_TRUE(aSamplingRate <= 192000, NS_ERROR_INVALID_ARG);
// According to www.opus-codec.org, creating an opus encoder requires the
// sampling rate of source signal be one of 8000, 12000, 16000, 24000, or
// 48000. If this constraint is not satisfied, we resample the input to 48kHz.
nsTArray<int> supportedSamplingRates;
supportedSamplingRates.AppendElements(kOpusSupportedInputSamplingRates,
ArrayLength(kOpusSupportedInputSamplingRates));
if (!supportedSamplingRates.Contains(aSamplingRate)) {
int error;
mResampler = speex_resampler_init(mChannels,
aSamplingRate,
kOpusSamplingRate,
SPEEX_RESAMPLER_QUALITY_DEFAULT,
&error);
if (error != RESAMPLER_ERR_SUCCESS) {
return NS_ERROR_FAILURE;
}
}
mSamplingRate = aSamplingRate;
NS_ENSURE_TRUE(mSamplingRate > 0, NS_ERROR_FAILURE);
int error = 0;
mEncoder = opus_encoder_create(GetOutputSampleRate(), mChannels,
OPUS_APPLICATION_AUDIO, &error);
mInitialized = (error == OPUS_OK);
if (mAudioBitrate) {
opus_encoder_ctl(mEncoder, OPUS_SET_BITRATE(static_cast<int>(mAudioBitrate)));
}
mReentrantMonitor.NotifyAll();
return error == OPUS_OK ? NS_OK : NS_ERROR_FAILURE;
}
bool OpusEncode::Open(int sample_rate, int channels, int app)
{
if(m_encoder)
return false;
int err = 0;
m_encoder = opus_encoder_create(sample_rate, channels, app, &err);
assert(err == 0);
return m_encoder != NULL;
}
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;
}
//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 (
}
JNIEXPORT jlong JNICALL
Java_org_jitsi_impl_neomedia_codec_audio_opus_Opus_encoder_1create
(JNIEnv *env, jclass clazz, jint Fs, jint channels)
{
int error;
OpusEncoder *encoder
= opus_encoder_create(Fs, channels, OPUS_APPLICATION_VOIP, &error);
if (OPUS_OK != error)
encoder = 0;
return (jlong) (intptr_t) encoder;
}
Encoder::Encoder(QObject *parent) :
QObject(parent),
encoder_(NULL),
position_(0),
framesize_(2880)
{
int error = 0;
encoder_ = opus_encoder_create(Consts::Audio::sampling_rate, 2, OPUS_APPLICATION_AUDIO, &error);
if (error != 0) {
qWarning() << "opus_encoder_create() falied:" << error;
}
}
int opus_enc_init(opus_enc *opus)
{
int err;
err = 0;
opus->header = (OpusHeader *)calloc(1, sizeof(OpusHeader));
opus->header_data = (unsigned char *)calloc (1, 1024);
opus->tags = (unsigned char *)calloc (1, 1024);
opus->buffer = (unsigned char *)calloc (1, 4 * 4096);
srand(time(NULL));
ogg_stream_init(&opus->os, rand());
opus->header->gain = 0;
opus->header->channels = opus->channel;
if ((opus->bitrate < 8000) || (opus->bitrate > 320000)) {
opus->bitrate = DEFAULT_OPUS_BITRATE;
}
opus->header->input_sample_rate = 48000;
opus->encoder = opus_encoder_create (opus->header->input_sample_rate, opus->channel, OPUS_APPLICATION_AUDIO, &err);
opus_encoder_ctl (opus->encoder, OPUS_SET_BITRATE(opus->bitrate));
if (opus->encoder == NULL) {
printf("Opus Encoder creation error: %s\n", opus_strerror (err));
return 1;
}
opus->last_bitrate = opus->bitrate;
opus_encoder_ctl (opus->encoder, OPUS_GET_LOOKAHEAD (&opus->header->preskip));
opus->header_size = opus_header_to_packet (opus->header, opus->header_data, 100);
opus->tags_size =
8 + 4 + strlen (opus_get_version_string ()) + 4 + 4 + strlen ("ENCODER=") + strlen (VERSION);
memcpy (opus->tags, "OpusTags", 8);
opus->tags[8] = strlen (opus_get_version_string ());
memcpy (opus->tags + 12, opus_get_version_string (), strlen (opus_get_version_string ()));
opus->tags[12 + strlen (opus_get_version_string ())] = 1;
opus->tags[12 + strlen (opus_get_version_string ()) + 4] = strlen ("ENCODER=") + strlen (VERSION);
memcpy (opus->tags + 12 + strlen (opus_get_version_string ()) + 4 + 4, "ENCODER=", strlen ("ENCODER="));
memcpy (opus->tags + 12 + strlen (opus_get_version_string ()) + 4 + 4 + strlen ("ENCODER="),
VERSION,
strlen (VERSION));
//printf("Opus Encoder Created\n");
return 0;
}
OpusEncoder *create_audio_encoder(Logger *log, int32_t bit_rate, int32_t sampling_rate, int32_t channel_count)
{
int status = OPUS_OK;
OpusEncoder *rc = opus_encoder_create(sampling_rate, channel_count, OPUS_APPLICATION_VOIP, &status);
if (status != OPUS_OK) {
LOGGER_ERROR(log, "Error while starting audio encoder: %s", opus_strerror(status));
return NULL;
}
status = opus_encoder_ctl(rc, OPUS_SET_BITRATE(bit_rate));
if (status != OPUS_OK) {
LOGGER_ERROR(log, "Error while setting encoder ctl: %s", opus_strerror(status));
goto FAILURE;
}
/* Enable in-band forward error correction in codec */
status = opus_encoder_ctl(rc, OPUS_SET_INBAND_FEC(1));
if (status != OPUS_OK) {
LOGGER_ERROR(log, "Error while setting encoder ctl: %s", opus_strerror(status));
goto FAILURE;
}
/* Make codec resistant to up to 10% packet loss
* NOTE This could also be adjusted on the fly, rather than hard-coded,
* with feedback from the receiving client.
*/
status = opus_encoder_ctl(rc, OPUS_SET_PACKET_LOSS_PERC(10));
if (status != OPUS_OK) {
LOGGER_ERROR(log, "Error while setting encoder ctl: %s", opus_strerror(status));
goto FAILURE;
}
/* Set algorithm to the highest complexity, maximizing compression */
status = opus_encoder_ctl(rc, OPUS_SET_COMPLEXITY(10));
if (status != OPUS_OK) {
LOGGER_ERROR(log, "Error while setting encoder ctl: %s", opus_strerror(status));
goto FAILURE;
}
return rc;
FAILURE:
opus_encoder_destroy(rc);
return NULL;
}
int16_t WebRtcOpus_EncoderCreate(OpusEncInst** inst, int32_t channels) {
OpusEncInst* state;
state = (OpusEncInst*) calloc(1, sizeof(OpusEncInst));
if (state) {
int error;
state->encoder = opus_encoder_create(48000, channels, OPUS_APPLICATION_VOIP,
&error);
if (error == OPUS_OK || state->encoder != NULL ) {
*inst = state;
return 0;
}
free(state);
}
return -1;
}
bool FVoiceEncoderOpus::Init(int32 InSampleRate, int32 InNumChannels)
{
UE_LOG(LogVoiceEncode, Display, TEXT("EncoderVersion: %s"), ANSI_TO_TCHAR(opus_get_version_string()));
SampleRate = InSampleRate;
NumChannels = InNumChannels;
// 20ms frame sizes are a good choice for most applications (1000ms / 20ms = 50)
FrameSize = SampleRate / NUM_OPUS_FRAMES_PER_SEC;
//MaxFrameSize = FrameSize * MAX_OPUS_FRAMES;
int32 EncError = 0;
#if USE_UE4_MEM_ALLOC
int32 EncSize = opus_encoder_get_size(NumChannels);
Encoder = (OpusEncoder*)FMemory::Malloc(EncSize);
EncError = opus_encoder_init(Encoder, SampleRate, NumChannels, OPUS_APPLICATION_VOIP);
#else
Encoder = opus_encoder_create(SampleRate, NumChannels, OPUS_APPLICATION_VOIP, &EncError);
#endif
if (EncError != OPUS_OK)
{
UE_LOG(LogVoiceEncode, Warning, TEXT("Failed to init Opus Encoder: %s"), ANSI_TO_TCHAR(opus_strerror(EncError)));
Destroy();
}
// Turn on variable bit rate encoding
int32 UseVbr = 1;
opus_encoder_ctl(Encoder, OPUS_SET_VBR(UseVbr));
// Turn off constrained VBR
int32 UseCVbr = 0;
opus_encoder_ctl(Encoder, OPUS_SET_VBR_CONSTRAINT(UseCVbr));
// Complexity (1-10)
int32 Complexity = 1;
opus_encoder_ctl(Encoder, OPUS_SET_COMPLEXITY(Complexity));
// Forward error correction
int32 InbandFEC = 0;
opus_encoder_ctl(Encoder, OPUS_SET_INBAND_FEC(InbandFEC));
#if DEBUG_OPUS
DebugEncoderInfo(Encoder);
#endif // DEBUG_OPUS
return EncError == OPUS_OK;
}
WebRtc_Word16 WebRtcOpus_CreateEnc(OPUS_encinst_t** inst, WebRtc_Word16 samplFreq) {
*inst=(OPUS_encinst_t*)malloc(sizeof(OPUS_Enc_Inst_t));
if (*inst==NULL) {
return(-1);
}
int err;
((OPUS_Enc_Inst_t*)*inst)->enc = opus_encoder_create(16000, 1, OPUS_APPLICATION_VOIP, &err);
if(err != OPUS_OK || ((OPUS_Enc_Inst_t*)*inst)->enc==NULL) {
return(-1);
}
return(0);
}
static void ms_opus_enc_preprocess(MSFilter *f) {
int error;
OpusEncData *d = (OpusEncData *)f->data;
/* create the encoder */
d->state = opus_encoder_create(d->samplerate, d->channels, d->application, &error);
if (error != OPUS_OK) {
ms_error("Opus encoder creation failed: %s", opus_strerror(error));
return;
}
/* set complexity to 0 for single processor arm devices */
#if defined(__arm__) || defined(_M_ARM)
if (ms_factory_get_cpu_count(f->factory)==1){
opus_encoder_ctl(d->state, OPUS_SET_COMPLEXITY(0));
}else{
opus_encoder_ctl(d->state, OPUS_SET_COMPLEXITY(5));
}
#endif
error = opus_encoder_ctl(d->state, OPUS_SET_PACKET_LOSS_PERC(10));
if (error != OPUS_OK) {
ms_error("Could not set default loss percentage to opus encoder: %s", opus_strerror(error));
}
/* set the encoder parameters: VBR, IN_BAND_FEC, DTX and bitrate settings */
ms_opus_enc_set_vbr(f);
ms_opus_enc_set_inbandfec(f);
ms_opus_enc_set_dtx(f);
/* if decoder prefers mono signal, force encoder to output mono signal */
if (d->stereo == 0) {
error = opus_encoder_ctl(d->state, OPUS_SET_FORCE_CHANNELS(1));
if (error != OPUS_OK) {
ms_error("could not force mono channel to opus encoder: %s", opus_strerror(error));
}
if (d->channels == 2) ms_message("Opus encoder configured to encode mono despite it is feed with stereo.");
}else if (d->channels == 2){
ms_message("Opus encoder configured to encode stereo.");
}
ms_filter_lock(f);
// set bitrate wasn't call, compute it with the default network bitrate (36000)
if (d->bitrate==-1) {
compute_max_bitrate(d, 0);
}
apply_max_bitrate(d);
ms_filter_unlock(f);
}
int init_send_audio(codec_state *cs)
{
cs->support_send_audio = 0;
const ALchar *pDeviceList = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
int i = 0;
const ALchar *device_names[20];
if (pDeviceList) {
printf("\nAvailable Capture Devices are:\n");
while (*pDeviceList) {
device_names[i] = pDeviceList;
printf("%d) %s\n", i, device_names[i]);
pDeviceList += strlen(pDeviceList) + 1;
++i;
}
}
printf("enter capture device number: \n");
char dev[2];
fgets(dev, sizeof(dev), stdin);
cs->audio_capture_device = alcCaptureOpenDevice(device_names[dev[0] - 48], AUDIO_SAMPLE_RATE, AL_FORMAT_MONO16,
AUDIO_FRAME_SIZE * 4);
if (alcGetError(cs->audio_capture_device) != AL_NO_ERROR) {
printf("could not start capture device! %d\n", alcGetError(cs->audio_capture_device));
return 0;
}
int err = OPUS_OK;
cs->audio_bitrate = AUDIO_BITRATE;
cs->audio_encoder = opus_encoder_create(AUDIO_SAMPLE_RATE, 1, OPUS_APPLICATION_VOIP, &err);
err = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_BITRATE(cs->audio_bitrate));
err = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_COMPLEXITY(10));
err = opus_encoder_ctl(cs->audio_encoder, OPUS_SET_SIGNAL(OPUS_SIGNAL_VOICE));
opus_encoder_init(cs->audio_encoder, AUDIO_SAMPLE_RATE, 1, OPUS_APPLICATION_VOIP);
int nfo;
err = opus_encoder_ctl(cs->audio_encoder, OPUS_GET_LOOKAHEAD(&nfo));
/* printf("Encoder lookahead delay : %d\n", nfo); */
printf("init audio encoder successful\n");
return 1;
}
static void audio_encoder_init(uint32_t samplerate, int complexity,
uint32_t bitrate)
{
assert(opus_enc == NULL);
int err = 0;
/* 1 channel (mono), OPUS audio profile */
opus_enc = opus_encoder_create(samplerate, 1, OPUS_APPLICATION_AUDIO, &err);
if (!opus_enc) {
fprintf(stderr, "ERROR: opus_encoder_create() has failed - %d\n", err);
exit(EXIT_FAILURE);
}
opus_encoder_ctl(opus_enc, OPUS_SET_COMPLEXITY(complexity));
opus_encoder_ctl(opus_enc, OPUS_SET_BITRATE(bitrate));
opus_encoder_ctl(opus_enc, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC));
opus_encoder_ctl(opus_enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND));
}
int16_t WebRtcOpus_EncoderCreate(OpusEncInst** inst, int32_t channels) {
OpusEncInst* state;
state = (OpusEncInst*) calloc(1, sizeof(OpusEncInst));
if (state) {
int error;
// Default to VoIP application for mono, and AUDIO for stereo.
int application = (channels == 1) ?
OPUS_APPLICATION_VOIP : OPUS_APPLICATION_AUDIO;
state->encoder = opus_encoder_create(48000, channels, application, &error);
if (error == OPUS_OK || state->encoder != NULL ) {
*inst = state;
return 0;
}
free(state);
}
return -1;
}
OpusEncoder *tc_opus_create_encoder(int sample_rate, int channels, int bitrate)
{
int err;
OpusEncoder *encoder = opus_encoder_create(sample_rate, channels, OPUS_APPLICATION_AUDIO, &err);
if (err<0){
pa_log_error("failed to create an encoder: %s", opus_strerror(err));
return NULL;
}
err = opus_encoder_ctl(encoder, OPUS_SET_BITRATE(bitrate));
if (err<0)
{
pa_log_error("failed to set bitrate: %s", opus_strerror(err));
return NULL;
}
return encoder;
}
JNIEXPORT jlong JNICALL Java_aopus_OpusLibrary_encoderCreate
(JNIEnv *env, jobject obj, jint clockRate, jint channels, jint packetTime)
{
Encoder *encoder = malloc(sizeof* encoder);
encoder->frameSizePerChannel = (clockRate * packetTime) / 1000;
encoder->maxBufferSize = 4000;
encoder->buffer = malloc(encoder->maxBufferSize);
// initialize encoder
int error;
encoder->enc = opus_encoder_create(clockRate, channels, OPUS_APPLICATION_VOIP, &error);
if (error != OPUS_OK)
{
__android_log_print(ANDROID_LOG_ERROR, "fm.libopus", "Could not initialize encoder. %d", error);
return 0;
}
return encoder;
}
opus_encoder::opus_encoder()
{
int err;
_opus = opus_encoder_create(SAMPLE_RATE,CHANNELS, OPUS_APPLICATION_VOIP, &err);
if(err != OPUS_OK)
{
LOG << "opus encoder create error: ";
log_opus_error(err);
}
opus_encoder_ctl(_opus, OPUS_SET_BITRATE(OPUS_AUTO));
opus_encoder_ctl(_opus, OPUS_SET_VBR(1));
opus_encoder_ctl(_opus, OPUS_SET_FORCE_CHANNELS(1)); //force mono
opus_encoder_ctl(_opus, OPUS_SET_PACKET_LOSS_PERC(2));
ENSURE(_opus);
}
static void ms_opus_enc_preprocess(MSFilter *f) {
int error;
OpusEncData *d = (OpusEncData *)f->data;
/* create the encoder */
d->state = opus_encoder_create(d->samplerate, d->channels, d->application, &error);
if (error != OPUS_OK) {
ms_error("Opus encoder creation failed: %s", opus_strerror(error));
return;
}
/* set complexity to 0 for arm devices */
#ifdef __arm__
opus_encoder_ctl(d->state, OPUS_SET_COMPLEXITY(0));
#endif
error = opus_encoder_ctl(d->state, OPUS_SET_PACKET_LOSS_PERC(10));
if (error != OPUS_OK) {
ms_error("Could not set default loss percentage to opus encoder: %s", opus_strerror(error));
}
/* set the encoder parameters: VBR, IN_BAND_FEC, DTX and bitrate settings */
ms_opus_enc_set_vbr(f);
ms_opus_enc_set_inbandfec(f);
ms_opus_enc_set_dtx(f);
/* if decoder prefers mono signal, force encoder to output mono signal */
if (d->stereo == 0) {
error = opus_encoder_ctl(d->state, OPUS_SET_FORCE_CHANNELS(1));
if (error != OPUS_OK) {
ms_error("could not force mono channel to opus encoder: %s", opus_strerror(error));
}
}
ms_filter_lock(f);
if (d->ptime==-1) { // set ptime wasn't call, set default:20ms
d->ptime = 20;
}
if (d->bitrate==-1) { // set bitrate wasn't call, compute it with the default network bitrate (36000)
compute_max_bitrate(d, 0);
}
apply_max_bitrate(d);
ms_filter_unlock(f);
}
