/*
 * Copyright (C) 2015-2016 Teluu Inc. (http://www.teluu.com)
 * Copyright (C) 2012-2015 Zaark Technology AB
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */
/* This file is the implementation of Opus codec wrapper and was contributed by
 * Zaark Technology AB
 */

#include <pjmedia-codec/opus.h>
#include <pjmedia/errno.h>
#include <pjmedia/endpoint.h>
#include <pj/log.h>
#include <pj/math.h>

#if defined(PJMEDIA_HAS_OPUS_CODEC) && (PJMEDIA_HAS_OPUS_CODEC!=0)

#include <opus/opus.h>

#define THIS_FILE "opus.c"

/* Default packet loss concealment setting. */
#define OPUS_DEFAULT_PLC        1
/* Default Voice Activity Detector setting. */
#define OPUS_DEFAULT_VAD        0

/* Maximum size of an encoded packet. 
 * If the the actual size is bigger, the encode/parse will fail.
 */
#define MAX_ENCODED_PACKET_SIZE         1280

/* Default frame time (msec) */
#define PTIME                   20
#define PTIME_DENUM             1

/* Tracing */
#if 0
#   define TRACE_(expr) PJ_LOG(4,expr)
#else
#   define TRACE_(expr)
#endif


/* Prototypes for Opus factory */
static pj_status_t factory_test_alloc( pjmedia_codec_factory *factory, 
                                       const pjmedia_codec_info *ci );
static pj_status_t factory_default_attr( pjmedia_codec_factory *factory, 
                                         const pjmedia_codec_info *ci, 
                                         pjmedia_codec_param *attr );
static pj_status_t factory_enum_codecs( pjmedia_codec_factory *factory, 
                                        unsigned *count, 
                                        pjmedia_codec_info codecs[]);
static pj_status_t factory_alloc_codec( pjmedia_codec_factory *factory, 
                                        const pjmedia_codec_info *ci, 
                                        pjmedia_codec **p_codec);
static pj_status_t factory_dealloc_codec( pjmedia_codec_factory *factory, 
                                          pjmedia_codec *codec );


/* Prototypes for Opus implementation. */
static pj_status_t codec_init( pjmedia_codec *codec, 
                               pj_pool_t *pool );
static pj_status_t codec_open( pjmedia_codec *codec, 
                               pjmedia_codec_param *attr );
static pj_status_t codec_close( pjmedia_codec *codec );
static pj_status_t codec_modify( pjmedia_codec *codec, 
                                 const pjmedia_codec_param *attr );
static pj_status_t codec_parse( pjmedia_codec *codec,
                                void *pkt,
                                pj_size_t pkt_size,
                                const pj_timestamp *ts,
                                unsigned *frame_cnt,
                                pjmedia_frame frames[]);
static pj_status_t codec_encode( pjmedia_codec *codec, 
                                 const struct pjmedia_frame *input,
                                 unsigned output_buf_len, 
                                 struct pjmedia_frame *output);
static pj_status_t codec_decode( pjmedia_codec *codec, 
                                 const struct pjmedia_frame *input,
                                 unsigned output_buf_len, 
                                 struct pjmedia_frame *output);
static pj_status_t codec_recover( pjmedia_codec *codec,
                                  unsigned output_buf_len,
                                  struct pjmedia_frame *output);

/* Definition for Opus operations. */
static pjmedia_codec_op opus_op = 
{
    &codec_init,
    &codec_open,
    &codec_close,
    &codec_modify,
    &codec_parse,
    &codec_encode,
    &codec_decode,
    &codec_recover
};

/* Definition for Opus factory operations. */
static pjmedia_codec_factory_op opus_factory_op =
{
    &factory_test_alloc,
    &factory_default_attr,
    &factory_enum_codecs,
    &factory_alloc_codec,
    &factory_dealloc_codec,
    &pjmedia_codec_opus_deinit
};


/* Opus factory */
struct opus_codec_factory
{
    pjmedia_codec_factory  base;
    pjmedia_endpt         *endpt;
    pj_pool_t             *pool;
};

/* Opus codec private data. */
struct opus_data
{
    pj_pool_t                   *pool;
    pj_mutex_t                  *mutex;
    OpusEncoder                 *enc;
    OpusDecoder                 *dec;
    OpusRepacketizer            *enc_packer;
    OpusRepacketizer            *dec_packer;
    pjmedia_codec_opus_config    cfg;
    unsigned                     enc_ptime;
    unsigned                     enc_ptime_denum;
    unsigned                     dec_ptime;
    unsigned                     dec_ptime_denum;
    pjmedia_frame                dec_frame[2];
    int                          dec_frame_index;
    pj_size_t                    dec_frame_buf_size;
};

/* Codec factory instance */
static struct opus_codec_factory opus_codec_factory;

/* Opus default configuration */
static pjmedia_codec_opus_config opus_cfg =
{
    PJMEDIA_CODEC_OPUS_DEFAULT_SAMPLE_RATE,     /* Sample rate          */
    1,                                          /* Channel count        */
    PTIME,                                      /* Frame ptime          */
    PTIME_DENUM,                                /* Frame ptime denum    */
    PJMEDIA_CODEC_OPUS_DEFAULT_BIT_RATE,        /* Bit rate             */
    5,                                          /* Expected packet loss */
    PJMEDIA_CODEC_OPUS_DEFAULT_COMPLEXITY,      /* Complexity           */
    PJMEDIA_CODEC_OPUS_DEFAULT_CBR,             /* Constant bit rate    */
};


static int get_opus_bw_constant (unsigned sample_rate)
{
    if (sample_rate <= 8000)
        return OPUS_BANDWIDTH_NARROWBAND;
    else if (sample_rate <= 12000)
        return OPUS_BANDWIDTH_MEDIUMBAND;
    else if (sample_rate <= 16000)
        return OPUS_BANDWIDTH_WIDEBAND;
    else if (sample_rate <= 24000)
        return OPUS_BANDWIDTH_SUPERWIDEBAND;
    else
        return OPUS_BANDWIDTH_FULLBAND;
}


/*
 * Initialize and register Opus codec factory to pjmedia endpoint.
 */
PJ_DEF(pj_status_t) pjmedia_codec_opus_init( pjmedia_endpt *endpt )
{
    pj_status_t status;
    pjmedia_codec_mgr *codec_mgr;

    PJ_ASSERT_RETURN(endpt, PJ_EINVAL);

    if (opus_codec_factory.pool != NULL)
        return PJ_SUCCESS;

    /* Create the Opus codec factory */
    opus_codec_factory.base.op           = &opus_factory_op;
    opus_codec_factory.base.factory_data = &opus_codec_factory;
    opus_codec_factory.endpt             = endpt;

    opus_codec_factory.pool = pjmedia_endpt_create_pool(endpt, "opus-factory",
                                                        1024, 1024);
    if (!opus_codec_factory.pool) {
        PJ_LOG(2, (THIS_FILE, "Unable to create memory pool for Opus codec"));
        return PJ_ENOMEM;
    }

    /* Get the codec manager */
    codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
    if (!codec_mgr) {
        PJ_LOG(2, (THIS_FILE, "Unable to get the codec manager"));
        status = PJ_EINVALIDOP;
        goto on_codec_factory_error;
    }

    /* Register the codec factory */
    status = pjmedia_codec_mgr_register_factory (codec_mgr,
                                                 &opus_codec_factory.base);
    if (status != PJ_SUCCESS) {
        PJ_LOG(2, (THIS_FILE, "Unable to register the codec factory"));
        goto on_codec_factory_error;
    }

    return PJ_SUCCESS;

on_codec_factory_error:
    pj_pool_release(opus_codec_factory.pool);
    opus_codec_factory.pool = NULL;
    return status;
}


/*
 * Unregister Opus codec factory from pjmedia endpoint and
 * deinitialize the codec.
 */
PJ_DEF(pj_status_t) pjmedia_codec_opus_deinit( void )
{
    pj_status_t status;
    pjmedia_codec_mgr *codec_mgr;

    if (opus_codec_factory.pool == NULL)
        return PJ_SUCCESS;

    /* Get the codec manager */
    codec_mgr = pjmedia_endpt_get_codec_mgr(opus_codec_factory.endpt);
    if (!codec_mgr) {
        PJ_LOG(2, (THIS_FILE, "Unable to get the codec manager"));
        pj_pool_release(opus_codec_factory.pool);
        opus_codec_factory.pool = NULL;
        return PJ_EINVALIDOP;
    }

    /* Unregister the codec factory */
    status = pjmedia_codec_mgr_unregister_factory(codec_mgr,
                                                  &opus_codec_factory.base);
    if (status != PJ_SUCCESS)
        PJ_LOG(2, (THIS_FILE, "Unable to unregister the codec factory"));

    /* Release the memory pool */
    pj_pool_release(opus_codec_factory.pool);
    opus_codec_factory.pool = NULL;

    return status;
}


/**
 * Get the opus configuration for a specific sample rate.
 */
PJ_DEF(pj_status_t)
pjmedia_codec_opus_get_config( pjmedia_codec_opus_config *cfg )
{
    PJ_ASSERT_RETURN(cfg, PJ_EINVAL);

    pj_memcpy(cfg, &opus_cfg, sizeof(pjmedia_codec_opus_config));
    return PJ_SUCCESS;
}


static pj_str_t STR_MAX_PLAYBACK = {"maxplaybackrate", 15};
static pj_str_t STR_MAX_CAPTURE  = {"sprop-maxcapturerate", 20};
static pj_str_t STR_STEREO       = {"stereo", 6};
static pj_str_t STR_SPROP_STEREO = {"sprop-stereo", 12};
static pj_str_t STR_MAX_BIT_RATE = {"maxaveragebitrate", 17};
static pj_str_t STR_INBAND_FEC   = {"useinbandfec", 12};
static pj_str_t STR_DTX          = {"usedtx", 6};
static pj_str_t STR_CBR          = {"cbr", 3};

static int find_fmtp(pjmedia_codec_fmtp *fmtp, pj_str_t *name, pj_bool_t add)
{
    int i;
    for (i = 0; i < fmtp->cnt; i++) {
        if (pj_stricmp(&fmtp->param[i].name, name) == 0)
            return i;
    }
    
    if (add && (i < PJMEDIA_CODEC_MAX_FMTP_CNT)) {
        fmtp->param[i].name = *name;
        fmtp->cnt++;
        return i;
    } else
        return -1;
}

static void remove_fmtp(pjmedia_codec_fmtp *fmtp, pj_str_t *name)
{
    int i, j;
    for (i = 0; i < fmtp->cnt; i++) {
        if (pj_stricmp(&fmtp->param[i].name, name) == 0) {
            fmtp->cnt--;
            for (j = i; j < fmtp->cnt; j++) {
                fmtp->param[i].name = fmtp->param[i+1].name;
                fmtp->param[i].val = fmtp->param[i+1].val;
            }
        }
    }
}

static pj_status_t generate_fmtp(pjmedia_codec_param *attr)
{
    int idx;
    static char bitrate_str[12];
    static char clockrate_str[12];
    
    if (attr->info.clock_rate != 48000) {
        pj_ansi_snprintf(clockrate_str, sizeof(clockrate_str), "%u",
                         attr->info.clock_rate);

        idx = find_fmtp(&attr->setting.dec_fmtp, &STR_MAX_PLAYBACK, PJ_TRUE);
        if (idx >= 0)
            attr->setting.dec_fmtp.param[idx].val = pj_str(clockrate_str);

        idx = find_fmtp(&attr->setting.dec_fmtp, &STR_MAX_CAPTURE, PJ_TRUE);
        if (idx >= 0)
            attr->setting.dec_fmtp.param[idx].val = pj_str(clockrate_str);
    } else {
        remove_fmtp(&attr->setting.dec_fmtp, &STR_MAX_PLAYBACK);
        remove_fmtp(&attr->setting.dec_fmtp, &STR_MAX_CAPTURE);
    }

    /* Check if we need to set parameter 'maxaveragebitrate' */
    if (opus_cfg.bit_rate > 0) {
        idx = find_fmtp(&attr->setting.dec_fmtp, &STR_MAX_BIT_RATE, PJ_TRUE);
        if (idx >= 0) {
            pj_ansi_snprintf(bitrate_str, sizeof(bitrate_str), "%u",
                             attr->info.avg_bps);
            attr->setting.dec_fmtp.param[idx].val = pj_str(bitrate_str);
        }
    } else {
        remove_fmtp(&attr->setting.dec_fmtp, &STR_MAX_BIT_RATE);
    }

    if (attr->info.channel_cnt > 1) {
        idx = find_fmtp(&attr->setting.dec_fmtp, &STR_STEREO, PJ_TRUE);
        if (idx >= 0)
            attr->setting.dec_fmtp.param[idx].val = pj_str("1");

        idx = find_fmtp(&attr->setting.dec_fmtp, &STR_SPROP_STEREO, PJ_TRUE);
        if (idx >= 0)
            attr->setting.dec_fmtp.param[idx].val = pj_str("1");
    } else {
        remove_fmtp(&attr->setting.dec_fmtp, &STR_STEREO);
        remove_fmtp(&attr->setting.dec_fmtp, &STR_SPROP_STEREO);
    }

    if (opus_cfg.cbr) {
        idx = find_fmtp(&attr->setting.dec_fmtp, &STR_CBR, PJ_TRUE);
        if (idx >= 0)
            attr->setting.dec_fmtp.param[idx].val = pj_str("1");
    } else {
        remove_fmtp(&attr->setting.dec_fmtp, &STR_CBR);
    }

    if (attr->setting.plc) {
        idx = find_fmtp(&attr->setting.dec_fmtp, &STR_INBAND_FEC, PJ_TRUE);
        if (idx >= 0)
            attr->setting.dec_fmtp.param[idx].val = pj_str("1");
    } else {
        remove_fmtp(&attr->setting.dec_fmtp, &STR_INBAND_FEC);
    }

    if (attr->setting.vad) {
        idx = find_fmtp(&attr->setting.dec_fmtp, &STR_DTX, PJ_TRUE);
        if (idx >= 0)
            attr->setting.dec_fmtp.param[idx].val = pj_str("1");
    } else {
        remove_fmtp(&attr->setting.dec_fmtp, &STR_DTX);
    }
    
    return PJ_SUCCESS;
}

/**
 * Set the opus configuration and default param.
 */
PJ_DEF(pj_status_t)
pjmedia_codec_opus_set_default_param(const pjmedia_codec_opus_config *cfg,
                                     pjmedia_codec_param *param )
{
    const pj_str_t opus_str = {"opus", 4};
    const pjmedia_codec_info *info[1];
    pjmedia_codec_mgr *codec_mgr;
    unsigned count = 1;
    pj_status_t status;

    TRACE_((THIS_FILE, "%s:%d: - TRACE", __FUNCTION__, __LINE__));
    PJ_ASSERT_RETURN(cfg && param, PJ_EINVAL);

    codec_mgr = pjmedia_endpt_get_codec_mgr(opus_codec_factory.endpt);

    status = pjmedia_codec_mgr_find_codecs_by_id(codec_mgr, &opus_str,
                                                 &count, info, NULL);
    if (status != PJ_SUCCESS)
        return status;

    /* Set sample rate */
    if (cfg->sample_rate != 8000 && cfg->sample_rate != 12000 &&
        cfg->sample_rate != 16000 && cfg->sample_rate != 24000 &&
        cfg->sample_rate != 48000)
    {
        return PJ_EINVAL;
    }

    param->info.clock_rate = opus_cfg.sample_rate = cfg->sample_rate;
    param->info.max_bps = opus_cfg.sample_rate * 2;
    opus_cfg.frm_ptime = cfg->frm_ptime;
    opus_cfg.frm_ptime_denum = cfg->frm_ptime_denum;
    param->info.frm_ptime = (pj_uint16_t)cfg->frm_ptime;
    param->info.frm_ptime_denum = (pj_uint8_t)cfg->frm_ptime_denum;

    /* Set channel count */
    if (cfg->channel_cnt != 1 && cfg->channel_cnt != 2)
        return PJ_EINVAL;
    param->info.channel_cnt = opus_cfg.channel_cnt = cfg->channel_cnt;

    /* Set bit_rate */
    if ((cfg->bit_rate != PJMEDIA_CODEC_OPUS_DEFAULT_BIT_RATE) && 
       (cfg->bit_rate < 6000 || cfg->bit_rate > 510000)) 
    {
        return PJ_EINVAL;
    }
    opus_cfg.bit_rate = cfg->bit_rate;
    param->info.avg_bps = opus_cfg.bit_rate;

    /* Set expected packet loss */
    if (cfg->packet_loss >= 100)
        return PJ_EINVAL;
    opus_cfg.packet_loss = cfg->packet_loss;

    /* Set complexity */
    if (cfg->complexity > 10)
        return PJ_EINVAL;
    opus_cfg.complexity = cfg->complexity;

    opus_cfg.cbr = cfg->cbr;
    
    generate_fmtp(param);

    status = pjmedia_codec_mgr_set_default_param(codec_mgr, info[0], param);
    return status;
}


/*
 * Check if factory can allocate the specified codec.
 */
static pj_status_t factory_test_alloc( pjmedia_codec_factory *factory, 
                                       const pjmedia_codec_info *ci )
{
    const pj_str_t opus_tag = {"OPUS", 4};

    PJ_UNUSED_ARG(factory);
    PJ_ASSERT_RETURN(factory==&opus_codec_factory.base, PJ_EINVAL);

    /* Type MUST be audio. */
    if (ci->type != PJMEDIA_TYPE_AUDIO)
        return PJMEDIA_CODEC_EUNSUP;

    /* Check encoding name. */
    if (pj_stricmp(&ci->encoding_name, &opus_tag) != 0)
        return PJMEDIA_CODEC_EUNSUP;

    /* Check clock rate */
    if (ci->clock_rate != 8000 && ci->clock_rate != 12000 &&
        ci->clock_rate != 16000 && ci->clock_rate != 24000 &&
        ci->clock_rate != 48000)
    {
        return PJMEDIA_CODEC_EUNSUP;
    }

    return PJ_SUCCESS;
}


/*
 * Generate default attribute.
 */
static pj_status_t factory_default_attr( pjmedia_codec_factory *factory, 
                                         const pjmedia_codec_info *ci, 
                                         pjmedia_codec_param *attr )
{
    PJ_UNUSED_ARG(factory);
    TRACE_((THIS_FILE, "%s:%d: - TRACE", __FUNCTION__, __LINE__));

    pj_bzero(attr, sizeof(pjmedia_codec_param));
    attr->info.pt                  = (pj_uint8_t)ci->pt;
    attr->info.clock_rate          = opus_cfg.sample_rate;
    attr->info.channel_cnt         = opus_cfg.channel_cnt;
    attr->info.avg_bps             = opus_cfg.bit_rate;
    attr->info.max_bps             = opus_cfg.sample_rate * 2;
    attr->info.frm_ptime           = (pj_uint16_t)opus_cfg.frm_ptime;
    attr->info.frm_ptime_denum     = (pj_uint8_t)opus_cfg.frm_ptime_denum;
    attr->setting.frm_per_pkt      = 1;
    attr->info.pcm_bits_per_sample = 16;
    attr->setting.vad              = OPUS_DEFAULT_VAD;
    attr->setting.plc              = OPUS_DEFAULT_PLC;
    attr->setting.packet_loss      = opus_cfg.packet_loss;
    attr->setting.complexity       = opus_cfg.complexity;
    attr->setting.cbr              = opus_cfg.cbr;

    /* Set max RX frame size.  When codec_parse() splits a multi-frame
     * packet via opus_repacketizer_out_range(), each single-frame output
     * is a complete Opus packet (TOC + frame data + optional padding).
     * Per the Opus API docs the worst-case size is 1277 bytes per frame.
     * Use MAX_ENCODED_PACKET_SIZE (1280) for consistency with codec_parse()
     * and a small safety margin.
     */
    attr->info.max_rx_frame_size   = MAX_ENCODED_PACKET_SIZE;

    generate_fmtp(attr);

    return PJ_SUCCESS;
}


/*
 * Enum codecs supported by this factory.
 */
static pj_status_t factory_enum_codecs( pjmedia_codec_factory *factory, 
                                        unsigned *count, 
                                        pjmedia_codec_info codecs[] )
{
    PJ_UNUSED_ARG(factory);
    PJ_ASSERT_RETURN(codecs, PJ_EINVAL);

    if (*count > 0) {
        pj_bzero(&codecs[0], sizeof(pjmedia_codec_info));
        codecs[0].type          = PJMEDIA_TYPE_AUDIO;
        codecs[0].pt            = PJMEDIA_RTP_PT_OPUS;
        /*
         * RFC 7587, Section 7:
         * The media subtype ("opus") goes in SDP "a=rtpmap" as the encoding
         * name. The RTP clock rate in "a=rtpmap" MUST be 48000 and the
         * number of channels MUST be 2.
         */     
        codecs[0].encoding_name = pj_str("opus");
        codecs[0].clock_rate    = 48000;
        codecs[0].channel_cnt   = 2;
        *count = 1;
    }

    return PJ_SUCCESS;
}


/*
 * Allocate a new Opus codec instance.
 */
static pj_status_t factory_alloc_codec( pjmedia_codec_factory *factory, 
                                        const pjmedia_codec_info *ci, 
                                        pjmedia_codec **p_codec )
{
    pjmedia_codec *codec;
    pj_pool_t *pool;
    pj_status_t status;
    struct opus_data *opus_data;
    struct opus_codec_factory *f = (struct opus_codec_factory*) factory;

    PJ_UNUSED_ARG(ci);
    TRACE_((THIS_FILE, "%s:%d: - TRACE", __FUNCTION__, __LINE__));

    pool = pjmedia_endpt_create_pool(f->endpt, "opus", 4000, 4000);
    if (!pool) return PJ_ENOMEM;
    
    opus_data = PJ_POOL_ZALLOC_T(pool, struct opus_data);
    codec     = PJ_POOL_ZALLOC_T(pool, pjmedia_codec);

    status = pj_mutex_create_simple (pool, "opus_mutex", &opus_data->mutex);
    if (status != PJ_SUCCESS) {
        pj_pool_release(pool);
        return status;
    }

    pj_memcpy(&opus_data->cfg, &opus_cfg, sizeof(pjmedia_codec_opus_config));
    opus_data->pool      = pool;
    codec->op            = &opus_op;
    codec->factory       = factory;
    codec->codec_data    = opus_data;

    *p_codec = codec;
    return PJ_SUCCESS;
}


/*
 * Free codec.
 */
static pj_status_t factory_dealloc_codec( pjmedia_codec_factory *factory, 
                                          pjmedia_codec *codec )
{
    struct opus_data *opus_data;

    PJ_ASSERT_RETURN(factory && codec, PJ_EINVAL);
    PJ_ASSERT_RETURN(factory == &opus_codec_factory.base, PJ_EINVAL);

    opus_data = (struct opus_data *)codec->codec_data;
    if (opus_data) {
        pj_mutex_destroy(opus_data->mutex);
        opus_data->mutex = NULL;
        pj_pool_release(opus_data->pool);
    }

    return PJ_SUCCESS;
}


/*
 * Init codec.
 */
static pj_status_t codec_init( pjmedia_codec *codec, 
                               pj_pool_t *pool )
{
    PJ_UNUSED_ARG(codec);
    PJ_UNUSED_ARG(pool);
    return PJ_SUCCESS;
}


/*
 * Open codec.
 */
static pj_status_t  codec_open( pjmedia_codec *codec,
                                pjmedia_codec_param *attr )
{
    struct opus_data *opus_data = (struct opus_data *)codec->codec_data;
    int idx, err;
    pj_bool_t auto_bit_rate = PJ_TRUE;
    pj_bool_t enc_use_plc = PJ_FALSE;

    PJ_ASSERT_RETURN(codec && attr && opus_data, PJ_EINVAL);

    pj_mutex_lock (opus_data->mutex);

    TRACE_((THIS_FILE, "%s:%d: - TRACE", __FUNCTION__, __LINE__));

    opus_data->cfg.sample_rate = attr->info.clock_rate;
    opus_data->cfg.channel_cnt = attr->info.channel_cnt;
    opus_data->enc_ptime = opus_data->dec_ptime = attr->info.frm_ptime;
    opus_data->enc_ptime_denum = attr->info.frm_ptime_denum?
                                 attr->info.frm_ptime_denum: 1;
    opus_data->dec_ptime_denum = opus_data->enc_ptime_denum;

    /* Allocate memory used by the codec */
    if (!opus_data->enc) {
        /* Allocate memory for max 2 channels */
        opus_data->enc = pj_pool_zalloc(opus_data->pool,
                                        opus_encoder_get_size(2));
    }
    if (!opus_data->dec) {
        /* Allocate memory for max 2 channels */
        opus_data->dec = pj_pool_zalloc(opus_data->pool,
                                        opus_decoder_get_size(2));
    }
    if (!opus_data->enc_packer) {
        opus_data->enc_packer = pj_pool_zalloc(opus_data->pool,
                                               opus_repacketizer_get_size());
    }
    if (!opus_data->dec_packer) {
        opus_data->dec_packer = pj_pool_zalloc(opus_data->pool,
                                               opus_repacketizer_get_size());
    }
    if (!opus_data->enc || !opus_data->dec ||
        !opus_data->enc_packer || !opus_data->dec_packer)
    {
        PJ_LOG(2, (THIS_FILE, "Unable to allocate memory for the codec"));
        pj_mutex_unlock (opus_data->mutex);
        return PJ_ENOMEM;
    }

    /* Check max average bit rate */
    idx = find_fmtp(&attr->setting.enc_fmtp, &STR_MAX_BIT_RATE, PJ_FALSE);
    if (idx >= 0) {
        unsigned rate;
        rate = (unsigned)pj_strtoul(&attr->setting.enc_fmtp.param[idx].val);
        /* Clamp to RFC 7587 range: 6000-510000 bps */
        if (rate < 6000 || rate > 510000) {
            PJ_LOG(3, (THIS_FILE, "Clamping maxaveragebitrate %u to "
                       "valid range [6000, 510000]", rate));
            if (rate < 6000) rate = 6000;
            if (rate > 510000) rate = 510000;
        }
        if (rate < attr->info.max_bps) {
            PJ_LOG(5, (THIS_FILE, "Setting encoder bitrate to remote's "
                       "maxaveragebitrate %u", rate));
            attr->info.avg_bps = rate;
            auto_bit_rate = PJ_FALSE;
        } else {
            PJ_LOG(4, (THIS_FILE, "Ignoring remote's maxaveragebitrate "
                       "%u (>= max_bps %u)", rate, attr->info.max_bps));
        }
    }

    /* Check plc */
    idx = find_fmtp(&attr->setting.enc_fmtp, &STR_INBAND_FEC, PJ_FALSE);
    if (idx >= 0) {
        unsigned plc;
        plc = (unsigned) pj_strtoul(&attr->setting.enc_fmtp.param[idx].val);
        if (plc > 0)
            enc_use_plc = PJ_TRUE;
        /* Do not modify local PLC setting as it's used for decoding. */
        // attr->setting.plc = plc > 0? PJ_TRUE: PJ_FALSE
    }

    /* Check vad */
    idx = find_fmtp(&attr->setting.enc_fmtp, &STR_DTX, PJ_FALSE);
    if (idx >= 0) {
        unsigned vad;
        vad = (unsigned) pj_strtoul(&attr->setting.enc_fmtp.param[idx].val);
        attr->setting.vad = vad > 0? PJ_TRUE: PJ_FALSE;
    }

    /* Check cbr */
    idx = find_fmtp(&attr->setting.enc_fmtp, &STR_CBR, PJ_FALSE);
    if (idx >= 0) {
        unsigned cbr;
        cbr = (unsigned) pj_strtoul(&attr->setting.enc_fmtp.param[idx].val);
        opus_data->cfg.cbr = cbr > 0? PJ_TRUE: PJ_FALSE;
    }
    
    TRACE_((THIS_FILE, "%s:%d: sample_rate: %u",
            __FUNCTION__, __LINE__, opus_data->cfg.sample_rate));

    /* Initialize encoder */
    err = opus_encoder_init(opus_data->enc,
                            opus_data->cfg.sample_rate,
                            attr->info.channel_cnt,
                            OPUS_APPLICATION_VOIP);
    if (err != OPUS_OK) {
        PJ_LOG(2, (THIS_FILE, "Unable to create encoder: %s %d",
                   opus_strerror(err), err));
        pj_mutex_unlock (opus_data->mutex);
        return PJMEDIA_CODEC_EFAILED;
    }
    
    /* Set signal type */
    opus_encoder_ctl(opus_data->enc, OPUS_SET_SIGNAL(OPUS_SIGNAL_VOICE));
    /* Set bitrate */
    opus_encoder_ctl(opus_data->enc, OPUS_SET_BITRATE(auto_bit_rate?
                                                      OPUS_AUTO:
                                                      (int)attr->info.avg_bps));
    /* Set VAD */
    opus_encoder_ctl(opus_data->enc, OPUS_SET_DTX(attr->setting.vad ? 1 : 0));
    /* Set PLC */
    opus_encoder_ctl(opus_data->enc,
                     OPUS_SET_INBAND_FEC(enc_use_plc));
    /* Set bandwidth */
    opus_encoder_ctl(opus_data->enc,
                     OPUS_SET_MAX_BANDWIDTH(get_opus_bw_constant(
                                            opus_data->cfg.sample_rate)));
    /* Set expected packet loss */
    opus_encoder_ctl(opus_data->enc,
                OPUS_SET_PACKET_LOSS_PERC(opus_data->cfg.packet_loss));
    /* Set complexity */
    opus_encoder_ctl(opus_data->enc,
                     OPUS_SET_COMPLEXITY(opus_data->cfg.complexity));
    /* Set constant bit rate */
    opus_encoder_ctl(opus_data->enc,
                     OPUS_SET_VBR(opus_data->cfg.cbr ? 0 : 1));

    PJ_LOG(4, (THIS_FILE, "Initialize Opus encoder, sample rate: %d, ch: %d, "
                          "avg bitrate: %d%s, vad: %d, plc: %d, pkt loss: %d, "
                          "complexity: %d, constant bit rate: %d, "
                          "ptime: %d/%d",
                          opus_data->cfg.sample_rate,
                          opus_data->cfg.channel_cnt,
                          (auto_bit_rate? 0: attr->info.avg_bps),
                          (auto_bit_rate? "(auto)": ""),
                          attr->setting.vad?1:0,
                          attr->setting.plc?1:0,
                          opus_data->cfg.packet_loss,
                          opus_data->cfg.complexity,
                          opus_data->cfg.cbr?1:0,
                          opus_data->enc_ptime,
                          opus_data->enc_ptime_denum));

    /* Initialize decoder */
    err = opus_decoder_init (opus_data->dec,
                             opus_data->cfg.sample_rate,
                             attr->info.channel_cnt);
    if (err != OPUS_OK) {
        PJ_LOG(2, (THIS_FILE, "Unable to initialize decoder: %s %d",
                   opus_strerror(err), err));
        pj_mutex_unlock (opus_data->mutex);
        return PJMEDIA_CODEC_EFAILED;
    }

    /* Initialize temporary decode frames used for FEC.
     * These buffers hold encoded input data, so they must be at least
     * MAX_ENCODED_PACKET_SIZE to accept any frame from codec_parse().
     */
    opus_data->dec_frame_buf_size = (opus_data->cfg.sample_rate / 1000)
                * 60 * attr->info.channel_cnt * 2 /* bytes per sample */;
    if (opus_data->dec_frame_buf_size < MAX_ENCODED_PACKET_SIZE)
        opus_data->dec_frame_buf_size = MAX_ENCODED_PACKET_SIZE;
    opus_data->dec_frame[0].type = PJMEDIA_FRAME_TYPE_NONE;
    opus_data->dec_frame[0].buf  = pj_pool_zalloc(opus_data->pool,
                opus_data->dec_frame_buf_size);
    opus_data->dec_frame[1].type = PJMEDIA_FRAME_TYPE_NONE;
    opus_data->dec_frame[1].buf  = pj_pool_zalloc(opus_data->pool,
                opus_data->dec_frame_buf_size);
    opus_data->dec_frame_index = -1;

    /* Initialize the repacketizers */
    opus_repacketizer_init(opus_data->enc_packer);
    opus_repacketizer_init(opus_data->dec_packer);

    pj_mutex_unlock (opus_data->mutex);
    return PJ_SUCCESS;
}


/*
 * Close codec.
 */
static pj_status_t  codec_close( pjmedia_codec *codec )
{
    PJ_UNUSED_ARG(codec);
    return PJ_SUCCESS;
}


/*
 * Modify codec settings.
 */
static pj_status_t  codec_modify( pjmedia_codec *codec, 
                                  const pjmedia_codec_param *attr )
{
    struct opus_data *opus_data = (struct opus_data *)codec->codec_data;

    pj_mutex_lock (opus_data->mutex);

    TRACE_((THIS_FILE, "%s:%d: - TRACE", __FUNCTION__, __LINE__));

    /* Set encoder ptime */
    opus_data->enc_ptime = attr->info.frm_ptime;
    opus_data->enc_ptime_denum = attr->info.frm_ptime_denum?
                                 attr->info.frm_ptime_denum: 1;

    /* Set bitrate */
    opus_data->cfg.bit_rate = attr->info.avg_bps;
    opus_encoder_ctl(opus_data->enc, OPUS_SET_BITRATE(attr->info.avg_bps?
                                                      (int)attr->info.avg_bps:
                                                      OPUS_AUTO));
    /* Set VAD */
    opus_encoder_ctl(opus_data->enc, OPUS_SET_DTX(attr->setting.vad ? 1 : 0));
    /* Set PLC */
    opus_encoder_ctl(opus_data->enc,
                     OPUS_SET_INBAND_FEC(attr->setting.plc ? 1 : 0));

    /* Set bandwidth */
    opus_encoder_ctl(opus_data->enc,
                     OPUS_SET_MAX_BANDWIDTH(get_opus_bw_constant(
                                            attr->info.clock_rate)));
    /* Set expected packet loss */
    opus_encoder_ctl(opus_data->enc,
                     OPUS_SET_PACKET_LOSS_PERC(attr->setting.packet_loss));
    /* Set complexity */
    opus_encoder_ctl(opus_data->enc,
                     OPUS_SET_COMPLEXITY(attr->setting.complexity));
    /* Set constant bit rate */
    opus_encoder_ctl(opus_data->enc,
                     OPUS_SET_VBR(attr->setting.cbr ? 0 : 1));

    PJ_LOG(4, (THIS_FILE, "Modifying Opus encoder, sample rate: %d, ch: %d, "
                          "avg bitrate: %d%s, vad: %d, plc: %d, pkt loss: %d, "
                          "complexity: %d, constant bit rate: %d, "
                          "ptime: %d/%d ms",
                          attr->info.clock_rate,
                          attr->info.channel_cnt,
                          (attr->info.avg_bps? attr->info.avg_bps: 0),
                          (attr->info.avg_bps? "": "(auto)"),
                          attr->setting.vad?1:0,
                          attr->setting.plc?1:0,
                          attr->setting.packet_loss,
                          attr->setting.complexity,
                          attr->setting.cbr?1:0,
                          opus_data->enc_ptime,
                          opus_data->enc_ptime_denum));

    pj_mutex_unlock (opus_data->mutex);
    return PJ_SUCCESS;
}


/*
 * Get frames in the packet.
 */
static pj_status_t  codec_parse( pjmedia_codec *codec,
                                 void *pkt,
                                 pj_size_t pkt_size,
                                 const pj_timestamp *ts,
                                 unsigned *frame_cnt,
                                 pjmedia_frame frames[] )
{
    struct opus_data *opus_data = (struct opus_data *)codec->codec_data;
    unsigned char tmp_buf[MAX_ENCODED_PACKET_SIZE];
    int i, num_frames;
    int size, out_pos;
    unsigned samples_per_frame = 0;
#if (USE_INCOMING_WORSE_SETTINGS)
    int bw;
#endif

    PJ_ASSERT_RETURN(codec && ts && frames && frame_cnt, PJ_EINVAL);

    pj_mutex_lock (opus_data->mutex);

    if (pkt_size > sizeof(tmp_buf)) {
        PJ_LOG(5, (THIS_FILE, "Encoded size bigger than buffer"));
        pj_mutex_unlock (opus_data->mutex);
        return PJMEDIA_CODEC_EFRMTOOSHORT;
    }

    pj_memcpy(tmp_buf, pkt, pkt_size);

    opus_repacketizer_init(opus_data->dec_packer);
    opus_repacketizer_cat(opus_data->dec_packer, tmp_buf,
                          (opus_int32)pkt_size);

    num_frames = opus_repacketizer_get_nb_frames(opus_data->dec_packer);
    if (num_frames == 0) {
      PJ_LOG(2, (THIS_FILE, "No frames retrieved (num_frames = 0)"));
      pj_mutex_unlock(opus_data->mutex);
      return PJMEDIA_CODEC_EFAILED;
    }

    if (num_frames > (int)*frame_cnt) {
        PJ_LOG(4, (THIS_FILE, "Opus parse: clamping num_frames from %d to %u",
                   num_frames, *frame_cnt));
        num_frames = (int)*frame_cnt;
    }

    out_pos = 0;
    for (i = 0; i < num_frames; ++i) {
        size = opus_repacketizer_out_range(opus_data->dec_packer, i, i+1,
                                           ((unsigned char*)pkt) + out_pos,
                                           sizeof(tmp_buf));
        if (size < 0) {
            PJ_LOG(5, (THIS_FILE, "Parse failed! (pkt_size=%lu, err=%d)",
                       (unsigned long)pkt_size, size));
            pj_mutex_unlock (opus_data->mutex);
            return PJMEDIA_CODEC_EFAILED;
        }
        frames[i].type = PJMEDIA_FRAME_TYPE_AUDIO;
        frames[i].buf = ((char*)pkt) + out_pos;
        frames[i].size = size;
        frames[i].bit_info = 0;

        if (i == 0) {
            int nsamples;
            unsigned ptime;
            unsigned ptime_denum = 1;

            nsamples = opus_packet_get_nb_samples(frames[i].buf,
                                                  (opus_int32)frames[i].size,
                                                  (opus_int32)
                                                  opus_data->cfg.sample_rate);
            if (nsamples <= 0) {
                PJ_LOG(5, (THIS_FILE, "Parse failed to get samples number! "
                                      "(err=%d)", nsamples));
                pj_mutex_unlock (opus_data->mutex);
                return PJMEDIA_CODEC_EFAILED;
            }

            if ((nsamples * 1000) % opus_data->cfg.sample_rate != 0) {
                /* The only non-integer ptime that Opus supports is 2.5 ms */
                ptime_denum = 2;
            }
            ptime = nsamples * ptime_denum * 1000 / opus_data->cfg.sample_rate;

            if (ptime * opus_data->dec_ptime_denum !=
                opus_data->dec_ptime * ptime_denum)
            {
                PJ_LOG(4, (THIS_FILE, "Opus ptime change detected: %d/%d ms "
                                      "--> %d/%d ms",
                                      opus_data->dec_ptime,
                                      opus_data->dec_ptime_denum,
                                      ptime, ptime_denum));
                opus_data->dec_ptime = ptime;
                opus_data->dec_ptime_denum = ptime_denum;
                opus_data->dec_frame_index = -1;

                /* Signal to the stream about ptime change. */
                frames[i].bit_info = 0x10000 | nsamples;
            }
            samples_per_frame = nsamples;
        }

        frames[i].timestamp.u64 = ts->u64 + i * samples_per_frame;
        out_pos += size;
    }
    *frame_cnt = num_frames;

    pj_mutex_unlock (opus_data->mutex);
    return PJ_SUCCESS;
}


/*
 * Encode frame.
 */
static pj_status_t codec_encode( pjmedia_codec *codec, 
                                 const struct pjmedia_frame *input,
                                 unsigned output_buf_len, 
                                 struct pjmedia_frame *output )
{
    struct opus_data *opus_data = (struct opus_data *)codec->codec_data;
    opus_int32 size  = 0;
    unsigned in_pos  = 0;
    unsigned out_pos = 0;
    unsigned frame_size;
    unsigned samples_per_frame;
    unsigned char tmp_buf[MAX_ENCODED_PACKET_SIZE];
    unsigned tmp_bytes_left = sizeof(tmp_buf);

    pj_mutex_lock (opus_data->mutex);

    samples_per_frame = (opus_data->cfg.sample_rate *
                         opus_data->enc_ptime /
                         opus_data->enc_ptime_denum) / 1000;
    frame_size = samples_per_frame * opus_data->cfg.channel_cnt *
                 sizeof(opus_int16);

    opus_repacketizer_init(opus_data->enc_packer);
    while (input->size - in_pos >= frame_size) {
        size = opus_encode(opus_data->enc,
                           (const opus_int16*)(((char*)input->buf) + in_pos),
                           samples_per_frame,
                           tmp_buf + out_pos,
                           (tmp_bytes_left < frame_size ?
                            tmp_bytes_left : frame_size));
        if (size < 0) {
            PJ_LOG(4, (THIS_FILE, "Encode failed! (%d)", size));
            pj_mutex_unlock (opus_data->mutex);
            return PJMEDIA_CODEC_EFAILED;
        } else if (size > 0) {
            /* Only add packets containing more than the TOC */
            opus_repacketizer_cat(opus_data->enc_packer,
                                  tmp_buf + out_pos,
                                  size);
            out_pos += size;
            tmp_bytes_left -= size;
        }
        in_pos += frame_size;
    }

    if (!opus_repacketizer_get_nb_frames(opus_data->enc_packer)) {
        /* Empty packet */
        output->size      = 0;
        output->type      = PJMEDIA_FRAME_TYPE_NONE;
        output->timestamp = input->timestamp;
    }

    if (size) {
        size = opus_repacketizer_out(opus_data->enc_packer,
                                     output->buf,
                                     output_buf_len);
        if (size < 0) {
            PJ_LOG(4, (THIS_FILE, "Encode failed! (%d), out_size: %u",
                                  size, output_buf_len));
            pj_mutex_unlock (opus_data->mutex);
            return PJMEDIA_CODEC_EFAILED;
        }
    }

    output->size      = (unsigned)size;
    output->type      = PJMEDIA_FRAME_TYPE_AUDIO;
    output->timestamp = input->timestamp;

    pj_mutex_unlock (opus_data->mutex);
    return PJ_SUCCESS;
}


/*
 * Decode frame.
 */
static pj_status_t  codec_decode( pjmedia_codec *codec, 
                                  const struct pjmedia_frame *input,
                                  unsigned output_buf_len, 
                                  struct pjmedia_frame *output )
{
    struct opus_data *opus_data = (struct opus_data *)codec->codec_data;
    int decoded_samples;
    pjmedia_frame *inframe;
    int fec = 0;
    int frm_size;

    PJ_UNUSED_ARG(output_buf_len);

    pj_mutex_lock (opus_data->mutex);

    /* Validate input size against decode buffer capacity before any copy.
     * This is a safety check to ensure the pj_memcpy() calls below
     * cannot overflow dec_frame[].buf.
     */
    if (input->size > opus_data->dec_frame_buf_size) {
        PJ_LOG(4, (THIS_FILE, "Opus decode: input size (%u) exceeds decode "
                   "buffer (%u), dropping frame",
                   (unsigned)input->size,
                   (unsigned)opus_data->dec_frame_buf_size));
        pj_mutex_unlock (opus_data->mutex);
        return PJMEDIA_CODEC_EFRMTOOSHORT;
    }

    if (opus_data->dec_frame_index == -1) {
        /* First packet, buffer it. */
        opus_data->dec_frame[0].type = input->type;
        opus_data->dec_frame[0].size = input->size;
        opus_data->dec_frame[0].timestamp = input->timestamp;
        pj_memcpy(opus_data->dec_frame[0].buf, input->buf, input->size);
        opus_data->dec_frame_index = 0;

        /* Return zero decoded bytes */
        output->size = 0;
        output->type = PJMEDIA_FRAME_TYPE_NONE;
        output->timestamp = input->timestamp;

        pj_mutex_unlock (opus_data->mutex);
        return PJ_SUCCESS;
    }

    inframe = &opus_data->dec_frame[opus_data->dec_frame_index];

    if (inframe->type != PJMEDIA_FRAME_TYPE_AUDIO) {
        /* Update current frame index */
        opus_data->dec_frame_index++;
        if (opus_data->dec_frame_index > 1)
            opus_data->dec_frame_index = 0;
        /* Copy original input buffer to current indexed frame */
        inframe = &opus_data->dec_frame[opus_data->dec_frame_index];
        inframe->type = input->type;
        inframe->size = input->size;
        inframe->timestamp = input->timestamp;
        pj_memcpy(inframe->buf, input->buf, input->size);
        fec = 1;
    }

    /* From Opus doc: In the case of PLC (data==NULL) or FEC(decode_fec=1),
     * then frame_size needs to be exactly the duration of audio that
     * is missing.
     */
    frm_size = (int)output->size / (sizeof(opus_int16) *
               opus_data->cfg.channel_cnt);
    if (inframe->type != PJMEDIA_FRAME_TYPE_AUDIO || fec) {
        frm_size = PJ_MIN((unsigned)frm_size,
                          opus_data->cfg.sample_rate *
                          opus_data->dec_ptime /
                          opus_data->dec_ptime_denum / 1000);
    }
    decoded_samples = opus_decode( opus_data->dec,
                                   inframe->type==PJMEDIA_FRAME_TYPE_AUDIO ?
                                        inframe->buf : NULL,
                                   inframe->type==PJMEDIA_FRAME_TYPE_AUDIO ?
                                        (opus_int32)inframe->size : 0,
                                   (opus_int16*)output->buf,
                                   frm_size,
                                   fec);
    output->timestamp = inframe->timestamp;
     
    if (inframe->type == PJMEDIA_FRAME_TYPE_AUDIO) {
        /* Mark current indexed frame as invalid */
        inframe->type = PJMEDIA_FRAME_TYPE_NONE;
        /* Update current frame index */
        opus_data->dec_frame_index++;
        if (opus_data->dec_frame_index > 1)
            opus_data->dec_frame_index = 0;
        /* Copy original input buffer to current indexed frame */
        inframe = &opus_data->dec_frame[opus_data->dec_frame_index];
        inframe->type = input->type;
        inframe->size = input->size;
        inframe->timestamp = input->timestamp;
        pj_memcpy(inframe->buf, input->buf, input->size);
    }

    if (decoded_samples < 0) {
        PJ_LOG(4, (THIS_FILE, "Decode failed!"));
        pj_mutex_unlock (opus_data->mutex);
        return PJMEDIA_CODEC_EFAILED;
    }

    output->size = decoded_samples * sizeof(opus_int16) * 
                   opus_data->cfg.channel_cnt;
    output->type = PJMEDIA_FRAME_TYPE_AUDIO;

    pj_mutex_unlock (opus_data->mutex);
    return PJ_SUCCESS;
}


/*
 * Recover lost frame.
 */
static pj_status_t  codec_recover( pjmedia_codec *codec,
                                   unsigned output_buf_len,
                                   struct pjmedia_frame *output )
{
    struct opus_data *opus_data = (struct opus_data *)codec->codec_data;
    int decoded_samples;
    pjmedia_frame *inframe;
    int frm_size;

    pj_mutex_lock (opus_data->mutex);

    if (opus_data->dec_frame_index == -1) {
        /* Recover the first packet? Don't think so, fill it with zeroes. */
        unsigned samples_per_frame;
        samples_per_frame = opus_data->cfg.sample_rate * opus_data->dec_ptime/
                            opus_data->dec_ptime_denum / 1000;
        output->type = PJMEDIA_FRAME_TYPE_AUDIO;
        output->size = samples_per_frame << 1;
        if (output->size > output_buf_len) {
            pj_assert(!"Buffer too small");
            output->size = output_buf_len;
        }
        pjmedia_zero_samples((pj_int16_t*)output->buf, samples_per_frame);
        pj_mutex_unlock (opus_data->mutex);

        return PJ_SUCCESS;
    }

    inframe = &opus_data->dec_frame[opus_data->dec_frame_index];
    frm_size = (int)output->size / (sizeof(opus_int16) *
               opus_data->cfg.channel_cnt);
    if (inframe->type != PJMEDIA_FRAME_TYPE_AUDIO) {
        frm_size = PJ_MIN((unsigned)frm_size, opus_data->cfg.sample_rate *
                          opus_data->dec_ptime / opus_data->dec_ptime_denum /
                          1000);
    }
    decoded_samples = opus_decode(opus_data->dec,
                                  inframe->type==PJMEDIA_FRAME_TYPE_AUDIO ?
                                        inframe->buf : NULL,
                                  inframe->type==PJMEDIA_FRAME_TYPE_AUDIO ?
                                        (opus_int32)inframe->size : 0,
                                  (opus_int16*)output->buf,
                                  frm_size,
                                  0);

    /* Mark current indexed frame as invalid */
    inframe->type = PJMEDIA_FRAME_TYPE_NONE;
    
    /* Update current frame index */
    opus_data->dec_frame_index++;
    if (opus_data->dec_frame_index > 1)
        opus_data->dec_frame_index = 0;
    /* Mark current indexed frame as invalid */
    inframe = &opus_data->dec_frame[opus_data->dec_frame_index];
    inframe->type = PJMEDIA_FRAME_TYPE_NONE;

    if (decoded_samples < 0) {
        PJ_LOG(4, (THIS_FILE, "Recover failed!"));
        pj_mutex_unlock (opus_data->mutex);
        return PJMEDIA_CODEC_EFAILED;
    }

    output->size = decoded_samples * sizeof(opus_int16) * 
                   opus_data->cfg.channel_cnt;
    output->type = PJMEDIA_FRAME_TYPE_AUDIO;
    output->timestamp = inframe->timestamp;

    pj_mutex_unlock (opus_data->mutex);
    return PJ_SUCCESS;
}

#if defined(_MSC_VER)
#   pragma comment(lib, PJMEDIA_CODEC_OPUS_LIB_NAME)
#endif

#endif /* PJMEDIA_HAS_OPUS_CODEC */
