/* Copyright (c) 2010 Xiph.Org Foundation, Skype Limited

   Copyright (c) 2024 Arm Limited

   Written by Jean-Marc Valin and Koen Vos */

/*

   Redistribution and use in source and binary forms, with or without

   modification, are permitted provided that the following conditions

   are met:

   - Redistributions of source code must retain the above copyright

   notice, this list of conditions and the following disclaimer.

   - Redistributions in binary form must reproduce the above copyright

   notice, this list of conditions and the following disclaimer in the

   documentation and/or other materials provided with the distribution.

   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER

   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#ifndef OPUS_BUILD

# error "OPUS_BUILD _MUST_ be defined to build Opus. This probably means you need other defines as well, as in a config.h. See the included build files for details."

#endif

#if defined(__GNUC__) && (__GNUC__ >= 2) && !defined(__OPTIMIZE__) && !defined(OPUS_WILL_BE_SLOW)

# pragma message "You appear to be compiling without optimization, if so opus will be very slow."

#endif

#include <stdarg.h>

#include "celt.h"

#include "opus.h"

#include "entdec.h"

#include "modes.h"

#include "API.h"

#include "stack_alloc.h"

#include "float_cast.h"

#include "opus_private.h"

#include "os_support.h"

#include "structs.h"

#include "define.h"

#include "mathops.h"

#include "cpu_support.h"

#ifdef ENABLE_DEEP_PLC

#include "dred_rdovae_dec_data.h"

#include "dred_rdovae_dec.h"

#endif

#ifdef ENABLE_OSCE

#include "osce.h"

#endif

struct OpusDecoder {

   int          celt_dec_offset;

   int          silk_dec_offset;

   int          channels;

   opus_int32   Fs;          /** Sampling rate (at the API level) */

   silk_DecControlStruct DecControl;

   int          decode_gain;

   int          complexity;

   int          ignore_extensions;

   int          arch;

#ifdef ENABLE_DEEP_PLC

    LPCNetPLCState lpcnet;

#endif

   /* Everything beyond this point gets cleared on a reset */

#define OPUS_DECODER_RESET_START stream_channels

   int          stream_channels;

   int          bandwidth;

   int          mode;

   int          prev_mode;

   int          frame_size;

   int          prev_redundancy;

   int          last_packet_duration;

#ifndef FIXED_POINT

   opus_val16   softclip_mem[2];

#endif

   opus_uint32  rangeFinal;

};

#if defined(ENABLE_HARDENING) || defined(ENABLE_ASSERTIONS)

static void validate_opus_decoder(OpusDecoder *st)

{

   celt_assert(st->channels == 1 || st->channels == 2);

#ifdef ENABLE_QEXT

   celt_assert(st->Fs == 96000 || st->Fs == 48000 || st->Fs == 24000 || st->Fs == 16000 || st->Fs == 12000 || st->Fs == 8000);

#else

   celt_assert(st->Fs == 48000 || st->Fs == 24000 || st->Fs == 16000 || st->Fs == 12000 || st->Fs == 8000);

#endif

   celt_assert(st->DecControl.API_sampleRate == st->Fs);

   celt_assert(st->DecControl.internalSampleRate == 0 || st->DecControl.internalSampleRate == 16000 || st->DecControl.internalSampleRate == 12000 || st->DecControl.internalSampleRate == 8000);

   celt_assert(st->DecControl.nChannelsAPI == st->channels);

   celt_assert(st->DecControl.nChannelsInternal == 0 || st->DecControl.nChannelsInternal == 1 || st->DecControl.nChannelsInternal == 2);

   celt_assert(st->DecControl.payloadSize_ms == 0 || st->DecControl.payloadSize_ms == 10 || st->DecControl.payloadSize_ms == 20 || st->DecControl.payloadSize_ms == 40 || st->DecControl.payloadSize_ms == 60);

#ifdef OPUS_ARCHMASK

   celt_assert(st->arch >= 0);

   celt_assert(st->arch <= OPUS_ARCHMASK);

#endif

   celt_assert(st->stream_channels == 1 || st->stream_channels == 2);

}

#define VALIDATE_OPUS_DECODER(st) validate_opus_decoder(st)

#else

#define VALIDATE_OPUS_DECODER(st)

#endif

int opus_decoder_get_size(int channels)

{

   int silkDecSizeBytes, celtDecSizeBytes;

   int ret;

   if (channels<1 || channels > 2)

      return 0;

   ret = silk_Get_Decoder_Size( &silkDecSizeBytes );

   if(ret)

      return 0;

   silkDecSizeBytes = align(silkDecSizeBytes);

   celtDecSizeBytes = celt_decoder_get_size(channels);

   return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes;

}

int opus_decoder_init(OpusDecoder *st, opus_int32 Fs, int channels)

{

   void *silk_dec;

   CELTDecoder *celt_dec;

   int ret, silkDecSizeBytes;

   if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000

#ifdef ENABLE_QEXT

         &&Fs!=96000

#endif

         )

    || (channels!=1&&channels!=2))

      return OPUS_BAD_ARG;

   OPUS_CLEAR((char*)st, opus_decoder_get_size(channels));

   /* Initialize SILK decoder */

   ret = silk_Get_Decoder_Size(&silkDecSizeBytes);

   if (ret)

      return OPUS_INTERNAL_ERROR;

   silkDecSizeBytes = align(silkDecSizeBytes);

   st->silk_dec_offset = align(sizeof(OpusDecoder));

   st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;

   silk_dec = (char*)st+st->silk_dec_offset;

   celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);

   st->stream_channels = st->channels = channels;

   st->complexity = 0;

   st->Fs = Fs;

   st->DecControl.API_sampleRate = st->Fs;

   st->DecControl.nChannelsAPI      = st->channels;

   /* Reset decoder */

   ret = silk_InitDecoder( silk_dec );

   if(ret)return OPUS_INTERNAL_ERROR;

   /* Initialize CELT decoder */

   ret = celt_decoder_init(celt_dec, Fs, channels);

   if(ret!=OPUS_OK)return OPUS_INTERNAL_ERROR;

   celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));

   st->prev_mode = 0;

   st->frame_size = Fs/400;

#ifdef ENABLE_DEEP_PLC

    lpcnet_plc_init( &st->lpcnet);

#endif

   st->arch = opus_select_arch();

   return OPUS_OK;

}

OpusDecoder *opus_decoder_create(opus_int32 Fs, int channels, int *error)

{

   int ret;

   OpusDecoder *st;

   if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000

#ifdef ENABLE_QEXT

         &&Fs!=96000

#endif

         )

    || (channels!=1&&channels!=2))

   {

      if (error)

         *error = OPUS_BAD_ARG;

      return NULL;

   }

   st = (OpusDecoder *)opus_alloc(opus_decoder_get_size(channels));

   if (st == NULL)

   {

      if (error)

         *error = OPUS_ALLOC_FAIL;

      return NULL;

   }

   ret = opus_decoder_init(st, Fs, channels);

   if (error)

      *error = ret;

   if (ret != OPUS_OK)

   {

      opus_free(st);

      st = NULL;

   }

   return st;

}

#ifdef ENABLE_RES24

static void smooth_fade(const opus_res *in1, const opus_res *in2,

      opus_res *out, int overlap, int channels,

      const celt_coef *window, opus_int32 Fs)

{

   int i, c;

   int inc = 48000/Fs;

   for (c=0;c<channels;c++)

   {

      for (i=0;i<overlap;i++)

      {

         celt_coef w = MULT_COEF(window[i*inc], window[i*inc]);

         out[i*channels+c] = ADD32(MULT_COEF_32(w,in2[i*channels+c]),

                                   MULT_COEF_32(COEF_ONE-w, in1[i*channels+c]));

      }

   }

}

opus_decoder.c:smooth_fade

Line

Count

Source

223

25.3k

{

224

25.3k

   int i, c;

225

25.3k

   int inc = 48000/Fs;

226

65.3k

   for (c=0;c<channels;c++)

227

39.9k

   {

228

3.17M

      for (i=0;i<overlap;i++)

229

3.13M

      {

230

3.13M

         celt_coef w = MULT_COEF(window[i*inc], window[i*inc]);

231

3.13M

         out[i*channels+c] = ADD32(MULT_COEF_32(w,in2[i*channels+c]),

232

3.13M

                                   MULT_COEF_32(COEF_ONE-w, in1[i*channels+c]));

233

3.13M

      }

234

39.9k

   }

235

25.3k

}

opus_decoder.c:smooth_fade

Line

Count

Source

223

25.3k

{

224

25.3k

   int i, c;

225

25.3k

   int inc = 48000/Fs;

226

65.3k

   for (c=0;c<channels;c++)

227

39.9k

   {

228

3.17M

      for (i=0;i<overlap;i++)

229

3.13M

      {

230

3.13M

         celt_coef w = MULT_COEF(window[i*inc], window[i*inc]);

231

3.13M

         out[i*channels+c] = ADD32(MULT_COEF_32(w,in2[i*channels+c]),

232

3.13M

                                   MULT_COEF_32(COEF_ONE-w, in1[i*channels+c]));

233

3.13M

      }

234

39.9k

   }

235

25.3k

}

#else

static void smooth_fade(const opus_res *in1, const opus_res *in2,

      opus_res *out, int overlap, int channels,

      const opus_val16 *window, opus_int32 Fs)

{

   int i, c;

   int inc = 48000/Fs;

   for (c=0;c<channels;c++)

   {

      for (i=0;i<overlap;i++)

      {

         opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);

         out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),

                                   Q15ONE-w, in1[i*channels+c]), 15);

      }

   }

}

#endif

static int opus_packet_get_mode(const unsigned char *data)

{

   int mode;

   if (data[0]&0x80)

   {

      mode = MODE_CELT_ONLY;

   } else if ((data[0]&0x60) == 0x60)

   {

      mode = MODE_HYBRID;

   } else {

      mode = MODE_SILK_ONLY;

   }

   return mode;

}

static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,

      opus_int32 len, opus_res *pcm, int frame_size, int decode_fec ARG_QEXT(opus_extension_data *ext))

{

   void *silk_dec;

   CELTDecoder *celt_dec;

   int i, silk_ret=0, celt_ret=0;

   ec_dec dec;

   opus_int32 silk_frame_size;

   int pcm_transition_silk_size;

   VARDECL(opus_res, pcm_transition_silk);

   int pcm_transition_celt_size;

   VARDECL(opus_res, pcm_transition_celt);

   opus_res *pcm_transition=NULL;

   int redundant_audio_size;

   VARDECL(opus_res, redundant_audio);

   int audiosize;

   int mode;

   int bandwidth;

   int transition=0;

   int start_band;

   int redundancy=0;

   int redundancy_bytes = 0;

   int celt_to_silk=0;

   int c;

   int F2_5, F5, F10, F20;

   const celt_coef *window;

   opus_uint32 redundant_rng = 0;

   int celt_accum;

   ALLOC_STACK;

   silk_dec = (char*)st+st->silk_dec_offset;

   celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);

   F20 = st->Fs/50;

   F10 = F20>>1;

   F5 = F10>>1;

   F2_5 = F5>>1;

   if (frame_size < F2_5)

   {

      RESTORE_STACK;

      return OPUS_BUFFER_TOO_SMALL;

   }

   /* Limit frame_size to avoid excessive stack allocations. */

   frame_size = IMIN(frame_size, st->Fs/25*3);

   /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */

   if (len<=1)

   {

      data = NULL;

      /* In that case, don't conceal more than what the ToC says */

      frame_size = IMIN(frame_size, st->frame_size);

   }

   if (data != NULL)

   {

      audiosize = st->frame_size;

      mode = st->mode;

      bandwidth = st->bandwidth;

      ec_dec_init(&dec,(unsigned char*)data,len);

   } else {

      audiosize = frame_size;

      /* Run PLC using last used mode (CELT if we ended with CELT redundancy) */

      mode = st->prev_redundancy ? MODE_CELT_ONLY : st->prev_mode;

      bandwidth = 0;

      if (mode == 0)

      {

         /* If we haven't got any packet yet, all we can do is return zeros */

         for (i=0;i<audiosize*st->channels;i++)

            pcm[i] = 0;

         RESTORE_STACK;

         return audiosize;

      }

      /* Avoids trying to run the PLC on sizes other than 2.5 (CELT), 5 (CELT),

         10, or 20 (e.g. 12.5 or 30 ms). */

      if (audiosize > F20)

      {

         do {

            int ret = opus_decode_frame(st, NULL, 0, pcm, IMIN(audiosize, F20), 0 ARG_QEXT(NULL));

            if (ret<0)

            {

               RESTORE_STACK;

               return ret;

            }

            pcm += ret*st->channels;

            audiosize -= ret;

         } while (audiosize > 0);

         RESTORE_STACK;

         return frame_size;

      } else if (audiosize < F20)

      {

         if (audiosize > F10)

            audiosize = F10;

         else if (mode != MODE_SILK_ONLY && audiosize > F5 && audiosize < F10)

            audiosize = F5;

      }

   }

   /* In fixed-point, we can tell CELT to do the accumulation on top of the

      SILK PCM buffer. This saves some stack space. */

   celt_accum = (mode != MODE_CELT_ONLY);

   pcm_transition_silk_size = ALLOC_NONE;

   pcm_transition_celt_size = ALLOC_NONE;

   if (data!=NULL && st->prev_mode > 0 && (

       (mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY && !st->prev_redundancy)

    || (mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) )

      )

   {

      transition = 1;

      /* Decide where to allocate the stack memory for pcm_transition */

      if (mode == MODE_CELT_ONLY)

         pcm_transition_celt_size = F5*st->channels;

      else

         pcm_transition_silk_size = F5*st->channels;

   }

   ALLOC(pcm_transition_celt, pcm_transition_celt_size, opus_res);

   if (transition && mode == MODE_CELT_ONLY)

   {

      pcm_transition = pcm_transition_celt;

      opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0 ARG_QEXT(NULL));

   }

   if (audiosize > frame_size)

   {

      /*fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);*/

      RESTORE_STACK;

      return OPUS_BAD_ARG;

   } else {

      frame_size = audiosize;

   }

   /* SILK processing */

   if (mode != MODE_CELT_ONLY)

   {

      int lost_flag, decoded_samples;

      opus_res *pcm_ptr;

      int pcm_too_small;

      int pcm_silk_size = ALLOC_NONE;

      VARDECL(opus_res, pcm_silk);

      pcm_too_small = (frame_size < F10);

      if (pcm_too_small)

         pcm_silk_size = F10*st->channels;

      ALLOC(pcm_silk, pcm_silk_size, opus_res);

      if (pcm_too_small)

         pcm_ptr = pcm_silk;

      else

         pcm_ptr = pcm;

      if (st->prev_mode==MODE_CELT_ONLY)

         silk_ResetDecoder( silk_dec );

      /* The SILK PLC cannot produce frames of less than 10 ms */

      st->DecControl.payloadSize_ms = IMAX(10, 1000 * audiosize / st->Fs);

      if (data != NULL)

      {

        st->DecControl.nChannelsInternal = st->stream_channels;

        if( mode == MODE_SILK_ONLY ) {

           if( bandwidth == OPUS_BANDWIDTH_NARROWBAND ) {

              st->DecControl.internalSampleRate = 8000;

           } else if( bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) {

              st->DecControl.internalSampleRate = 12000;

           } else if( bandwidth == OPUS_BANDWIDTH_WIDEBAND ) {

              st->DecControl.internalSampleRate = 16000;

           } else {

              st->DecControl.internalSampleRate = 16000;

              celt_assert( 0 );

           }

        } else {

           /* Hybrid mode */

           st->DecControl.internalSampleRate = 16000;

        }

     }

     st->DecControl.enable_deep_plc = st->complexity >= 5;

#ifdef ENABLE_OSCE

     st->DecControl.osce_method = OSCE_METHOD_NONE;

#ifndef DISABLE_LACE

     if (st->complexity >= 6) {st->DecControl.osce_method = OSCE_METHOD_LACE;}

#endif

#ifndef DISABLE_NOLACE

     if (st->complexity >= 7) {st->DecControl.osce_method = OSCE_METHOD_NOLACE;}

#endif

#ifdef ENABLE_OSCE_BWE

     if (st->complexity >= 4 && st->DecControl.enable_osce_bwe &&

         st->Fs == 48000 && st->DecControl.internalSampleRate == 16000 &&

         ((mode == MODE_SILK_ONLY) || (data == NULL))) {

         /* request WB -> FB signal extension */

         st->DecControl.osce_extended_mode = OSCE_MODE_SILK_BBWE;

     } else {

         /* at this point, mode can only be MODE_SILK_ONLY or MODE_HYBRID */

         st->DecControl.osce_extended_mode = mode == MODE_SILK_ONLY ? OSCE_MODE_SILK_ONLY : OSCE_MODE_HYBRID;

     }

     if (st->prev_mode == MODE_CELT_ONLY) {

         /* Update extended mode for CELT->SILK transition */

         st->DecControl.prev_osce_extended_mode = OSCE_MODE_CELT_ONLY;

     }

#endif

#endif

     lost_flag = data == NULL ? 1 : 2 * !!decode_fec;

     decoded_samples = 0;

     do {

        /* Call SILK decoder */

        int first_frame = decoded_samples == 0;

        silk_ret = silk_Decode( silk_dec, &st->DecControl,

                                lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size,

#ifdef ENABLE_DEEP_PLC

                                &st->lpcnet,

#endif

                                st->arch );

        if( silk_ret ) {

           if (lost_flag) {

              /* PLC failure should not be fatal */

              silk_frame_size = frame_size;

              for (i=0;i<frame_size*st->channels;i++)

                 pcm_ptr[i] = 0;

           } else {

             RESTORE_STACK;

             return OPUS_INTERNAL_ERROR;

           }

        }

        pcm_ptr += silk_frame_size * st->channels;

        decoded_samples += silk_frame_size;

      } while( decoded_samples < frame_size );

     if (pcm_too_small) {

        OPUS_COPY(pcm, pcm_silk, frame_size*st->channels);

     }

   }

   start_band = 0;

   if (!decode_fec && mode != MODE_CELT_ONLY && data != NULL

    && ec_tell(&dec)+17+20*(mode == MODE_HYBRID) <= 8*len)

   {

      /* Check if we have a redundant 0-8 kHz band */

      if (mode == MODE_HYBRID)

         redundancy = ec_dec_bit_logp(&dec, 12);

      else

         redundancy = 1;

      if (redundancy)

      {

         celt_to_silk = ec_dec_bit_logp(&dec, 1);

         /* redundancy_bytes will be at least two, in the non-hybrid

            case due to the ec_tell() check above */

         redundancy_bytes = mode==MODE_HYBRID ?

               (opus_int32)ec_dec_uint(&dec, 256)+2 :

               len-((ec_tell(&dec)+7)>>3);

         len -= redundancy_bytes;

         /* This is a sanity check. It should never happen for a valid

            packet, so the exact behaviour is not normative. */

         if (len*8 < ec_tell(&dec))

         {

            len = 0;

            redundancy_bytes = 0;

            redundancy = 0;

         }

         /* Shrink decoder because of raw bits */

         dec.storage -= redundancy_bytes;

      }

   }

   if (mode != MODE_CELT_ONLY)

      start_band = 17;

   if (redundancy)

   {

      transition = 0;

      pcm_transition_silk_size=ALLOC_NONE;

   }

   ALLOC(pcm_transition_silk, pcm_transition_silk_size, opus_res);

   if (transition && mode != MODE_CELT_ONLY)

   {

      pcm_transition = pcm_transition_silk;

      opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0 ARG_QEXT(NULL));

   }

   if (bandwidth)

   {

      int endband=21;

      switch(bandwidth)

      {

      case OPUS_BANDWIDTH_NARROWBAND:

         endband = 13;

         break;

      case OPUS_BANDWIDTH_MEDIUMBAND:

      case OPUS_BANDWIDTH_WIDEBAND:

         endband = 17;

         break;

      case OPUS_BANDWIDTH_SUPERWIDEBAND:

         endband = 19;

         break;

      case OPUS_BANDWIDTH_FULLBAND:

         endband = 21;

         break;

      default:

         celt_assert(0);

         break;

      }

      MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband)));

   }

   MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels)));

   /* Only allocation memory for redundancy if/when needed */

   redundant_audio_size = redundancy ? F5*st->channels : ALLOC_NONE;

   ALLOC(redundant_audio, redundant_audio_size, opus_res);

   /* 5 ms redundant frame for CELT->SILK*/

   if (redundancy && celt_to_silk)

   {

      /* If the previous frame did not use CELT (the first redundancy frame in

         a transition from SILK may have been lost) then the CELT decoder is

         stale at this point and the redundancy audio is not useful, however

         the final range is still needed (for testing), so the redundancy is

         always decoded but the decoded audio may not be used */

      MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0)));

      celt_decode_with_ec(celt_dec, data+len, redundancy_bytes,

                          redundant_audio, F5, NULL, 0);

      MUST_SUCCEED(celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng)));

   }

   /* MUST be after PLC */

   MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band)));

#ifdef ENABLE_OSCE_BWE

   if (mode != MODE_SILK_ONLY && st->DecControl.osce_extended_mode != OSCE_MODE_SILK_BBWE)

#else

   if (mode != MODE_SILK_ONLY)

#endif

   {

      int celt_frame_size = IMIN(F20, frame_size);

      /* Make sure to discard any previous CELT state */

      if (mode != st->prev_mode && st->prev_mode > 0 && !st->prev_redundancy)

         MUST_SUCCEED(celt_decoder_ctl(celt_dec, OPUS_RESET_STATE));

      /* Decode CELT */

      celt_ret = celt_decode_with_ec_dred(celt_dec, decode_fec ? NULL : data,

                                     len, pcm, celt_frame_size, &dec, celt_accum

#ifdef ENABLE_DEEP_PLC

                                     , &st->lpcnet

#endif

                                     ARG_QEXT(ext ? ext->data : NULL) ARG_QEXT(ext ? ext->len : 0));

      celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&st->rangeFinal));

   } else {

      unsigned char silence[2] = {0xFF, 0xFF};

      if (!celt_accum)

      {

         for (i=0;i<frame_size*st->channels;i++)

            pcm[i] = 0;

      }

      /* For hybrid -> SILK transitions, we let the CELT MDCT

         do a fade-out by decoding a silence frame */

      if (st->prev_mode == MODE_HYBRID && !(redundancy && celt_to_silk && st->prev_redundancy) )

      {

         MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0)));

         celt_decode_with_ec(celt_dec, silence, 2, pcm, F2_5, NULL, celt_accum);

      }

      st->rangeFinal = dec.rng;

   }

   {

      const CELTMode *celt_mode;

      MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_GET_MODE(&celt_mode)));

      window = celt_mode->window;

   }

   /* 5 ms redundant frame for SILK->CELT */

   if (redundancy && !celt_to_silk)

   {

      MUST_SUCCEED(celt_decoder_ctl(celt_dec, OPUS_RESET_STATE));

      MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0)));

      celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL, 0);

      MUST_SUCCEED(celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng)));

      smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,

                  pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);

   }

   /* 5ms redundant frame for CELT->SILK; ignore if the previous frame did not

      use CELT (the first redundancy frame in a transition from SILK may have

      been lost) */

   if (redundancy && celt_to_silk && (st->prev_mode != MODE_SILK_ONLY || st->prev_redundancy))

   {

      for (c=0;c<st->channels;c++)

      {

         for (i=0;i<F2_5;i++)

            pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];

      }

      smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,

                  pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);

   }

   if (transition)

   {

      if (audiosize >= F5)

      {

         for (i=0;i<st->channels*F2_5;i++)

            pcm[i] = pcm_transition[i];

         smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,

                     pcm+st->channels*F2_5, F2_5,

                     st->channels, window, st->Fs);

      } else {

         /* Not enough time to do a clean transition, but we do it anyway

            This will not preserve amplitude perfectly and may introduce

            a bit of temporal aliasing, but it shouldn't be too bad and

            that's pretty much the best we can do. In any case, generating this

            transition it pretty silly in the first place */

         smooth_fade(pcm_transition, pcm,

                     pcm, F2_5,

                     st->channels, window, st->Fs);

      }

   }

   if(st->decode_gain)

   {

      opus_val32 gain;

      gain = celt_exp2(MULT16_16_P15(QCONST16(6.48814081e-4f, 25), st->decode_gain));

      for (i=0;i<frame_size*st->channels;i++)

      {

         opus_val32 x;

#ifdef ENABLE_RES24

         x = MULT32_32_Q16(pcm[i],gain);

#else

         x = MULT16_32_P16(pcm[i],gain);

#endif

         pcm[i] = SATURATE(x, 32767);

      }

   }

   if (len <= 1)

      st->rangeFinal = 0;

   else

      st->rangeFinal ^= redundant_rng;

   st->prev_mode = mode;

   st->prev_redundancy = redundancy && !celt_to_silk;

   if (celt_ret>=0)

   {

      if (OPUS_CHECK_ARRAY(pcm, audiosize*st->channels))

         OPUS_PRINT_INT(audiosize);

   }

   RESTORE_STACK;

   return celt_ret < 0 ? celt_ret : audiosize;

}

opus_decoder.c:opus_decode_frame

Line

Count

Source

272

924k

{

273

924k

   void *silk_dec;

274

924k

   CELTDecoder *celt_dec;

275

924k

   int i, silk_ret=0, celt_ret=0;

276

924k

   ec_dec dec;

277

924k

   opus_int32 silk_frame_size;

278

924k

   int pcm_transition_silk_size;

279

924k

   VARDECL(opus_res, pcm_transition_silk);

280

924k

   int pcm_transition_celt_size;

281

924k

   VARDECL(opus_res, pcm_transition_celt);

282

924k

   opus_res *pcm_transition=NULL;

283

924k

   int redundant_audio_size;

284

924k

   VARDECL(opus_res, redundant_audio);

285

286

924k

   int audiosize;

287

924k

   int mode;

288

924k

   int bandwidth;

289

924k

   int transition=0;

290

924k

   int start_band;

291

924k

   int redundancy=0;

292

924k

   int redundancy_bytes = 0;

293

924k

   int celt_to_silk=0;

294

924k

   int c;

295

924k

   int F2_5, F5, F10, F20;

296

924k

   const celt_coef *window;

297

924k

   opus_uint32 redundant_rng = 0;

298

924k

   int celt_accum;

299

924k

   ALLOC_STACK;

300

301

924k

   silk_dec = (char*)st+st->silk_dec_offset;

302

924k

   celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);

303

924k

   F20 = st->Fs/50;

304

924k

   F10 = F20>>1;

305

924k

   F5 = F10>>1;

306

924k

   F2_5 = F5>>1;

307

924k

   if (frame_size < F2_5)

308

0

   {

309

0

      RESTORE_STACK;

310

0

      return OPUS_BUFFER_TOO_SMALL;

311

0

   }

312

   /* Limit frame_size to avoid excessive stack allocations. */

313

924k

   frame_size = IMIN(frame_size, st->Fs/25*3);

314

   /* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */

315

924k

   if (len<=1)

316

811k

   {

317

811k

      data = NULL;

318

      /* In that case, don't conceal more than what the ToC says */

319

811k

      frame_size = IMIN(frame_size, st->frame_size);

320

811k

   }

321

924k

   if (data != NULL)

322

113k

   {

323

113k

      audiosize = st->frame_size;

324

113k

      mode = st->mode;

325

113k

      bandwidth = st->bandwidth;

326

113k

      ec_dec_init(&dec,(unsigned char*)data,len);

327

811k

   } else {

328

811k

      audiosize = frame_size;

329

      /* Run PLC using last used mode (CELT if we ended with CELT redundancy) */

330

811k

      mode = st->prev_redundancy ? MODE_CELT_ONLY : st->prev_mode;

331

811k

      bandwidth = 0;

332

333

811k

      if (mode == 0)

334

729k

      {

335

         /* If we haven't got any packet yet, all we can do is return zeros */

336

58.5M

         for (i=0;i<audiosize*st->channels;i++)

337

57.7M

            pcm[i] = 0;

338

729k

         RESTORE_STACK;

339

729k

         return audiosize;

340

729k

      }

341

342

      /* Avoids trying to run the PLC on sizes other than 2.5 (CELT), 5 (CELT),

343

         10, or 20 (e.g. 12.5 or 30 ms). */

344

81.2k

      if (audiosize > F20)

345

3.47k

      {

346

10.3k

         do {

347

10.3k

            int ret = opus_decode_frame(st, NULL, 0, pcm, IMIN(audiosize, F20), 0 ARG_QEXT(NULL));

348

10.3k

            if (ret<0)

349

0

            {

350

0

               RESTORE_STACK;

351

0

               return ret;

352

0

            }

353

10.3k

            pcm += ret*st->channels;

354

10.3k

            audiosize -= ret;

355

10.3k

         } while (audiosize > 0);

356

3.47k

         RESTORE_STACK;

357

3.47k

         return frame_size;

358

77.8k

      } else if (audiosize < F20)

359

64.7k

      {

360

64.7k

         if (audiosize > F10)

361

0

            audiosize = F10;

362

64.7k

         else if (mode != MODE_SILK_ONLY && audiosize > F5 && audiosize < F10)

363

0

            audiosize = F5;

364

64.7k

      }

365

81.2k

   }

366

367

   /* In fixed-point, we can tell CELT to do the accumulation on top of the

368

      SILK PCM buffer. This saves some stack space. */

369

190k

   celt_accum = (mode != MODE_CELT_ONLY);

370

371

190k

   pcm_transition_silk_size = ALLOC_NONE;

372

190k

   pcm_transition_celt_size = ALLOC_NONE;

373

190k

   if (data!=NULL && st->prev_mode > 0 && (

374

58.3k

       (mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY && !st->prev_redundancy)

375

58.3k

    || (mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) )

376

190k

      )

377

128

   {

378

128

      transition = 1;

379

      /* Decide where to allocate the stack memory for pcm_transition */

380

128

      if (mode == MODE_CELT_ONLY)

381

0

         pcm_transition_celt_size = F5*st->channels;

382

128

      else

383

128

         pcm_transition_silk_size = F5*st->channels;

384

128

   }

385

190k

   ALLOC(pcm_transition_celt, pcm_transition_celt_size, opus_res);

386

190k

   if (transition && mode == MODE_CELT_ONLY)

387

0

   {

388

0

      pcm_transition = pcm_transition_celt;

389

0

      opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0 ARG_QEXT(NULL));

390

0

   }

391

190k

   if (audiosize > frame_size)

392

0

   {

393

      /*fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);*/

394

0

      RESTORE_STACK;

395

0

      return OPUS_BAD_ARG;

396

190k

   } else {

397

190k

      frame_size = audiosize;

398

190k

   }

399

400

   /* SILK processing */

401

190k

   if (mode != MODE_CELT_ONLY)

402

68.3k

   {

403

68.3k

      int lost_flag, decoded_samples;

404

68.3k

      opus_res *pcm_ptr;

405

68.3k

      int pcm_too_small;

406

68.3k

      int pcm_silk_size = ALLOC_NONE;

407

68.3k

      VARDECL(opus_res, pcm_silk);

408

68.3k

      pcm_too_small = (frame_size < F10);

409

68.3k

      if (pcm_too_small)

410

0

         pcm_silk_size = F10*st->channels;

411

68.3k

      ALLOC(pcm_silk, pcm_silk_size, opus_res);

412

68.3k

      if (pcm_too_small)

413

0

         pcm_ptr = pcm_silk;

414

68.3k

      else

415

68.3k

         pcm_ptr = pcm;

416

417

68.3k

      if (st->prev_mode==MODE_CELT_ONLY)

418

128

         silk_ResetDecoder( silk_dec );

419

420

      /* The SILK PLC cannot produce frames of less than 10 ms */

421

68.3k

      st->DecControl.payloadSize_ms = IMAX(10, 1000 * audiosize / st->Fs);

422

423

68.3k

      if (data != NULL)

424

46.3k

      {

425

46.3k

        st->DecControl.nChannelsInternal = st->stream_channels;

426

46.3k

        if( mode == MODE_SILK_ONLY ) {

427

35.6k

           if( bandwidth == OPUS_BANDWIDTH_NARROWBAND ) {

428

14.7k

              st->DecControl.internalSampleRate = 8000;

429

20.9k

           } else if( bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) {

430

13.5k

              st->DecControl.internalSampleRate = 12000;

431

13.5k

           } else if( bandwidth == OPUS_BANDWIDTH_WIDEBAND ) {

432

7.31k

              st->DecControl.internalSampleRate = 16000;

433

7.31k

           } else {

434

0

              st->DecControl.internalSampleRate = 16000;

435

0

              celt_assert( 0 );

436

0

           }

437

35.6k

        } else {

438

           /* Hybrid mode */

439

10.6k

           st->DecControl.internalSampleRate = 16000;

440

10.6k

        }

441

46.3k

     }

442

68.3k

     st->DecControl.enable_deep_plc = st->complexity >= 5;

443

#ifdef ENABLE_OSCE

444

     st->DecControl.osce_method = OSCE_METHOD_NONE;

445

#ifndef DISABLE_LACE

446

     if (st->complexity >= 6) {st->DecControl.osce_method = OSCE_METHOD_LACE;}

447

#endif

448

#ifndef DISABLE_NOLACE

449

     if (st->complexity >= 7) {st->DecControl.osce_method = OSCE_METHOD_NOLACE;}

450

#endif

451

#ifdef ENABLE_OSCE_BWE

452

     if (st->complexity >= 4 && st->DecControl.enable_osce_bwe &&

453

         st->Fs == 48000 && st->DecControl.internalSampleRate == 16000 &&

454

         ((mode == MODE_SILK_ONLY) || (data == NULL))) {

455

         /* request WB -> FB signal extension */

456

         st->DecControl.osce_extended_mode = OSCE_MODE_SILK_BBWE;

457

     } else {

458

         /* at this point, mode can only be MODE_SILK_ONLY or MODE_HYBRID */

459

         st->DecControl.osce_extended_mode = mode == MODE_SILK_ONLY ? OSCE_MODE_SILK_ONLY : OSCE_MODE_HYBRID;

460

     }

461

     if (st->prev_mode == MODE_CELT_ONLY) {

462

         /* Update extended mode for CELT->SILK transition */

463

         st->DecControl.prev_osce_extended_mode = OSCE_MODE_CELT_ONLY;

464

     }

465

#endif

466

#endif

467

468

68.3k

     lost_flag = data == NULL ? 1 : 2 * !!decode_fec;

469

68.3k

     decoded_samples = 0;

470

105k

     do {

471

        /* Call SILK decoder */

472

105k

        int first_frame = decoded_samples == 0;

473

105k

        silk_ret = silk_Decode( silk_dec, &st->DecControl,

474

105k

                                lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size,

475

#ifdef ENABLE_DEEP_PLC

476

                                &st->lpcnet,

477

#endif

478

105k

                                st->arch );

479

105k

        if( silk_ret ) {

480

0

           if (lost_flag) {

481

              /* PLC failure should not be fatal */

482

0

              silk_frame_size = frame_size;

483

0

              for (i=0;i<frame_size*st->channels;i++)

484

0

                 pcm_ptr[i] = 0;

485

0

           } else {

486

0

             RESTORE_STACK;

487

0

             return OPUS_INTERNAL_ERROR;

488

0

           }

489

0

        }

490

105k

        pcm_ptr += silk_frame_size * st->channels;

491

105k

        decoded_samples += silk_frame_size;

492

105k

      } while( decoded_samples < frame_size );

493

68.3k

     if (pcm_too_small) {

494

0

        OPUS_COPY(pcm, pcm_silk, frame_size*st->channels);

495

0

     }

496

68.3k

   }

497

498

190k

   start_band = 0;

499

190k

   if (!decode_fec && mode != MODE_CELT_ONLY && data != NULL

500

37.3k

    && ec_tell(&dec)+17+20*(mode == MODE_HYBRID) <= 8*len)

501

9.33k

   {

502

      /* Check if we have a redundant 0-8 kHz band */

503

9.33k

      if (mode == MODE_HYBRID)

504

1.92k

         redundancy = ec_dec_bit_logp(&dec, 12);

505

7.41k

      else

506

7.41k

         redundancy = 1;

507

9.33k

      if (redundancy)

508

7.52k

      {

509

7.52k

         celt_to_silk = ec_dec_bit_logp(&dec, 1);

510

         /* redundancy_bytes will be at least two, in the non-hybrid

511

            case due to the ec_tell() check above */

512

7.52k

         redundancy_bytes = mode==MODE_HYBRID ?

513

110

               (opus_int32)ec_dec_uint(&dec, 256)+2 :

514

7.52k

               len-((ec_tell(&dec)+7)>>3);

515

7.52k

         len -= redundancy_bytes;

516

         /* This is a sanity check. It should never happen for a valid

517

            packet, so the exact behaviour is not normative. */

518

7.52k

         if (len*8 < ec_tell(&dec))

519

73

         {

520

73

            len = 0;

521

73

            redundancy_bytes = 0;

522

73

            redundancy = 0;

523

73

         }

524

         /* Shrink decoder because of raw bits */

525

7.52k

         dec.storage -= redundancy_bytes;

526

7.52k

      }

527

9.33k

   }

528

190k

   if (mode != MODE_CELT_ONLY)

529

68.3k

      start_band = 17;

530

531

190k

   if (redundancy)