/**

 * FreeRDP: A Remote Desktop Protocol Implementation

 * Digital Sound Processing

 *

 * Copyright 2010-2011 Vic Lee

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#include <freerdp/config.h>

#include <winpr/assert.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <winpr/crt.h>

#include <freerdp/types.h>

#include <freerdp/log.h>

#include <freerdp/codec/dsp.h>

#include "dsp.h"

#if defined(WITH_FDK_AAC)

#include "dsp_fdk_aac.h"

#endif

#if defined(WITH_MEDIACODEC)

#include "dsp_mediacodec.h"

#endif

#if !defined(WITH_DSP_FFMPEG)

#if defined(WITH_GSM)

#include <gsm/gsm.h>

#endif

#if defined(WITH_LAME)

#include <lame/lame.h>

#endif

#if defined(WITH_OPUS)

#include <opus/opus.h>

#define OPUS_MAX_FRAMES 5760ull

#endif

#if defined(WITH_FAAD2)

#include <neaacdec.h>

#endif

#if defined(WITH_FAAC)

#include <faac.h>

#endif

#if defined(WITH_SOXR)

#include <soxr.h>

#endif

#else

#include "dsp_ffmpeg.h"

#endif

#if !defined(WITH_DSP_FFMPEG)

#define TAG FREERDP_TAG("dsp")

typedef union

{

  struct

  {

    size_t packet_size;

    INT16 last_sample[2];

    INT16 last_step[2];

  } ima;

  struct

  {

    BYTE predictor[2];

    INT32 delta[2];

    INT32 sample1[2];

    INT32 sample2[2];

  } ms;

} ADPCM;

struct S_FREERDP_DSP_CONTEXT

{

  FREERDP_DSP_COMMON_CONTEXT common;

  ADPCM adpcm;

#if defined(WITH_GSM)

  gsm gsm;

#endif

#if defined(WITH_LAME)

  lame_t lame;

  hip_t hip;

#endif

#if defined(WITH_OPUS)

  OpusDecoder* opus_decoder;

  OpusEncoder* opus_encoder;

  wStream* opus_input;       /* samples not encoded yet */

  size_t opus_packet_frames; /* the shortest packet to encode */

#endif

#if defined(WITH_FAAD2)

  NeAACDecHandle faad;

  BOOL faadSetup;

#endif

#if defined(WITH_FAAC)

  faacEncHandle faac;

  unsigned long faacInputSamples;

  unsigned long faacMaxOutputBytes;

#endif

#if defined(WITH_SOXR)

  soxr_t sox;

#endif

};

#if defined(WITH_OPUS)

static BOOL opus_is_valid_samplerate(const AUDIO_FORMAT* WINPR_RESTRICT format)

{

  WINPR_ASSERT(format);

  switch (format->nSamplesPerSec)

  {

    case 8000:

    case 12000:

    case 16000:

    case 24000:

    case 48000:

      return TRUE;

    default:

      return FALSE;

  }

}

#endif

static INT16 read_int16(const BYTE* WINPR_RESTRICT src)

{

  return (INT16)(src[0] | (src[1] << 8));

}

static BOOL freerdp_dsp_channel_mix(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                    const BYTE* WINPR_RESTRICT src, size_t size,

                                    const AUDIO_FORMAT* WINPR_RESTRICT srcFormat,

                                    const BYTE** WINPR_RESTRICT data, size_t* WINPR_RESTRICT length)

{

  if (!context || !data || !length)

    return FALSE;

  if (srcFormat->wFormatTag != WAVE_FORMAT_PCM)

    return FALSE;

  const UINT32 bpp = srcFormat->wBitsPerSample > 8 ? 2 : 1;

  const size_t samples = size / bpp / srcFormat->nChannels;

  if (context->common.format.nChannels == srcFormat->nChannels)

  {

    *data = src;

    *length = size;

    return TRUE;

  }

  Stream_ResetPosition(context->common.channelmix);

  /* Destination has more channels than source */

  if (context->common.format.nChannels > srcFormat->nChannels)

  {

    switch (srcFormat->nChannels)

    {

      case 1:

        if (!Stream_EnsureCapacity(context->common.channelmix, size * 2))

          return FALSE;

        for (size_t x = 0; x < samples; x++)

        {

          for (size_t y = 0; y < bpp; y++)

            Stream_Write_UINT8(context->common.channelmix, src[x * bpp + y]);

          for (size_t y = 0; y < bpp; y++)

            Stream_Write_UINT8(context->common.channelmix, src[x * bpp + y]);

        }

        Stream_SealLength(context->common.channelmix);

        *data = Stream_Buffer(context->common.channelmix);

        *length = Stream_Length(context->common.channelmix);

        return TRUE;

      case 2:  /* We only support stereo, so we can not handle this case. */

      default: /* Unsupported number of channels */

        return FALSE;

    }

  }

  /* Destination has less channels than source */

  switch (srcFormat->nChannels)

  {

    case 2:

      if (!Stream_EnsureCapacity(context->common.channelmix, size / 2))

        return FALSE;

      /* Simply drop second channel.

       * TODO: Calculate average */

      for (size_t x = 0; x < samples; x++)

      {

        for (size_t y = 0; y < bpp; y++)

          Stream_Write_UINT8(context->common.channelmix, src[2 * x * bpp + y]);

      }

      Stream_SealLength(context->common.channelmix);

      *data = Stream_Buffer(context->common.channelmix);

      *length = Stream_Length(context->common.channelmix);

      return TRUE;

    case 1:  /* Invalid, do we want to use a 0 channel sound? */

    default: /* Unsupported number of channels */

      return FALSE;

  }

  return FALSE;

}

/**

 * Microsoft Multimedia Standards Update

 * http://download.microsoft.com/download/9/8/6/9863C72A-A3AA-4DDB-B1BA-CA8D17EFD2D4/RIFFNEW.pdf

 */

static BOOL freerdp_dsp_resample(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                 const BYTE* WINPR_RESTRICT src, size_t size,

                                 const AUDIO_FORMAT* WINPR_RESTRICT srcFormat,

                                 const BYTE** WINPR_RESTRICT data, size_t* WINPR_RESTRICT length)

{

  AUDIO_FORMAT format;

  if (srcFormat->wFormatTag != WAVE_FORMAT_PCM)

  {

    WLog_ERR(TAG, "requires %s for sample input, got %s",

             audio_format_get_tag_string(WAVE_FORMAT_PCM),

             audio_format_get_tag_string(srcFormat->wFormatTag));

    return FALSE;

  }

  /* We want to ignore differences of source and destination format. */

  format = *srcFormat;

  format.wFormatTag = WAVE_FORMAT_UNKNOWN;

  format.wBitsPerSample = 0;

  if (audio_format_compatible(&format, &context->common.format))

  {

    *data = src;

    *length = size;

    return TRUE;

  }

#if defined(WITH_SOXR)

  const size_t srcBytesPerFrame = (srcFormat->wBitsPerSample > 8) ? 2 : 1;

  const size_t dstBytesPerFrame = (context->common.format.wBitsPerSample > 8) ? 2 : 1;

  const size_t srcChannels = srcFormat->nChannels;

  const size_t dstChannels = context->common.format.nChannels;

  const size_t sbytes = srcChannels * srcBytesPerFrame;

  const size_t sframes = size / sbytes;

  const size_t rbytes = dstBytesPerFrame * dstChannels;

  /* Integer rounding correct division */

  const size_t rframes =

      (sframes * context->common.format.nSamplesPerSec + (srcFormat->nSamplesPerSec + 1) / 2) /

      srcFormat->nSamplesPerSec;

  const size_t rsize = rframes * rbytes;

  if (!Stream_EnsureCapacity(context->common.resample, rsize))

    return FALSE;

  size_t idone = 0;

  size_t odone = 0;

  soxr_error_t error =

      soxr_process(context->sox, src, sframes, &idone, Stream_Buffer(context->common.resample),

                   Stream_Capacity(context->common.resample) / rbytes, &odone);

  if (!Stream_SetLength(context->common.resample, odone * rbytes))

    return FALSE;

  *data = Stream_Buffer(context->common.resample);

  *length = Stream_Length(context->common.resample);

  return (error == nullptr);

#else

  WLog_ERR(TAG, "Missing resample support, recompile -DWITH_SOXR=ON or -DWITH_DSP_FFMPEG=ON");

  return FALSE;

#endif

}

/**

 * Microsoft IMA ADPCM specification:

 *

 * http://wiki.multimedia.cx/index.php?title=Microsoft_IMA_ADPCM

 * http://wiki.multimedia.cx/index.php?title=IMA_ADPCM

 */

static const INT16 ima_step_index_table[] = {

  -1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8

};

static const INT16 ima_step_size_table[] = {

  7,     8,     9,     10,    11,    12,    13,    14,    16,    17,    19,   21,    23,

  25,    28,    31,    34,    37,    41,    45,    50,    55,    60,    66,   73,    80,

  88,    97,    107,   118,   130,   143,   157,   173,   190,   209,   230,  253,   279,

  307,   337,   371,   408,   449,   494,   544,   598,   658,   724,   796,  876,   963,

  1060,  1166,  1282,  1411,  1552,  1707,  1878,  2066,  2272,  2499,  2749, 3024,  3327,

  3660,  4026,  4428,  4871,  5358,  5894,  6484,  7132,  7845,  8630,  9493, 10442, 11487,

  12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767

};

static inline void dsp_ima_clamp_step(ADPCM* WINPR_RESTRICT adpcm, size_t channel)

{

  WINPR_ASSERT(adpcm);

  if (adpcm->ima.last_step[channel] < 0)

    adpcm->ima.last_step[channel] = 0;

  const size_t size = ARRAYSIZE(ima_step_size_table);

  if ((size_t)adpcm->ima.last_step[channel] >= size)

    adpcm->ima.last_step[channel] = (INT16)(size - 1);

}

static UINT16 dsp_decode_ima_adpcm_sample(ADPCM* WINPR_RESTRICT adpcm, unsigned int channel,

                                          BYTE sample)

{

  WINPR_ASSERT(channel < ARRAYSIZE(adpcm->ima.last_step));

  WINPR_ASSERT(channel < ARRAYSIZE(adpcm->ima.last_sample));

  const INT16 offset = adpcm->ima.last_step[channel];

  WINPR_ASSERT(offset >= 0);

  WINPR_ASSERT(WINPR_CXX_COMPAT_CAST(size_t, offset) < ARRAYSIZE(ima_step_size_table));

  const INT32 ss = ima_step_size_table[offset];

  INT32 d = (ss >> 3);

  if (sample & 1)

    d += (ss >> 2);

  if (sample & 2)

    d += (ss >> 1);

  if (sample & 4)

    d += ss;

  if (sample & 8)

    d = -d;

  d += adpcm->ima.last_sample[channel];

  if (d < -32768)

    d = -32768;

  else if (d > 32767)

    d = 32767;

  adpcm->ima.last_sample[channel] = (INT16)d;

  WINPR_ASSERT(sample < ARRAYSIZE(ima_step_index_table));

  const int32_t last = adpcm->ima.last_step[channel] + ima_step_index_table[sample];

  adpcm->ima.last_step[channel] = WINPR_ASSERTING_INT_CAST(int16_t, last);

  dsp_ima_clamp_step(adpcm, channel);

  return (UINT16)d;

}

static BOOL valid_ima_adpcm_format(const FREERDP_DSP_CONTEXT* WINPR_RESTRICT context)

{

  WINPR_ASSERT(context);

  if (context->common.format.wFormatTag != WAVE_FORMAT_DVI_ADPCM)

    return FALSE;

  if (context->common.format.nBlockAlign <= 4ULL)

    return FALSE;

  if (context->common.format.nChannels < 1)

    return FALSE;

  if (context->common.format.wBitsPerSample == 0)

    return FALSE;

  return TRUE;

}

static BOOL freerdp_dsp_decode_ima_adpcm(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                         const BYTE* WINPR_RESTRICT src, size_t size,

                                         wStream* WINPR_RESTRICT out)

{

  if (!valid_ima_adpcm_format(context))

    return FALSE;

  size_t out_size = size * 4ull;

  const UINT32 block_size = context->common.format.nBlockAlign;

  const UINT32 channels = context->common.format.nChannels;

  if (!Stream_EnsureCapacity(out, out_size))

    return FALSE;

  while (size > 0)

  {

    if (size % block_size == 0)

    {

      if (size < 4)

        return FALSE;

      context->adpcm.ima.last_sample[0] =

          (INT16)(((UINT16)(*src)) | (((UINT16)(*(src + 1))) << 8));

      context->adpcm.ima.last_step[0] = (INT16)(*(src + 2));

      dsp_ima_clamp_step(&context->adpcm, 0u);

      src += 4;

      size -= 4;

      out_size -= 16;

      if (channels > 1)

      {

        if (size < 4)

          return FALSE;

        context->adpcm.ima.last_sample[1] =

            (INT16)(((UINT16)(*src)) | (((UINT16)(*(src + 1))) << 8));

        context->adpcm.ima.last_step[1] = (INT16)(*(src + 2));

        dsp_ima_clamp_step(&context->adpcm, 1u);

        src += 4;

        size -= 4;

        out_size -= 16;

      }

    }

    if (channels > 1)

    {

      if (size < 8)

        return FALSE;

      for (size_t i = 0; i < 8; i++)

      {

        BYTE* dst = Stream_Pointer(out);

        const unsigned channel = (i < 4 ? 0 : 1);

        {

          const BYTE sample = ((*src) & 0x0f);

          const UINT16 decoded =

              dsp_decode_ima_adpcm_sample(&context->adpcm, channel, sample);

          dst[((i & 3) << 3) + (channel << 1u)] = (decoded & 0xFF);

          dst[((i & 3) << 3) + (channel << 1u) + 1] = (decoded >> 8);

        }

        {

          const BYTE sample = ((*src) >> 4);

          const UINT16 decoded =

              dsp_decode_ima_adpcm_sample(&context->adpcm, channel, sample);

          dst[((i & 3) << 3) + (channel << 1u) + 4] = (decoded & 0xFF);

          dst[((i & 3) << 3) + (channel << 1u) + 5] = (decoded >> 8);

        }

        src++;

      }

      if (!Stream_SafeSeek(out, 32))

        return FALSE;

      size -= 8;

    }

    else

    {

      if (size < 1)

        return FALSE;

      BYTE* dst = Stream_Pointer(out);

      if (!Stream_SafeSeek(out, 4))

        return FALSE;

      {

        const BYTE sample = ((*src) & 0x0f);

        const UINT16 decoded = dsp_decode_ima_adpcm_sample(&context->adpcm, 0, sample);

        *dst++ = (decoded & 0xFF);

        *dst++ = (decoded >> 8);

      }

      {

        const BYTE sample = ((*src) >> 4);

        const UINT16 decoded = dsp_decode_ima_adpcm_sample(&context->adpcm, 0, sample);

        *dst++ = (decoded & 0xFF);

        *dst++ = (decoded >> 8);

      }

      src++;

      size--;

    }

  }

  return TRUE;

}

#if defined(WITH_GSM)

static BOOL freerdp_dsp_decode_gsm610(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                      const BYTE* WINPR_RESTRICT src, size_t size,

                                      wStream* WINPR_RESTRICT out)

{

  size_t offset = 0;

  while (offset < size)

  {

    /* gsm_decode(GSM_OPT_WAV49) requires alternating fixed 33/32 bytes as input.

     * abort if the data supplied was inconsistent.

     */

    const BOOL large = (offset % 65) == 0;

    const size_t toadd = large ? 33 : 32;

    if (size - offset < toadd)

      return FALSE;

    gsm_signal gsmBlockBuffer[160] = WINPR_C_ARRAY_INIT;

    const int rc =

        gsm_decode(context->gsm,

                   WINPR_CAST_CONST_PTR_AWAY(/* API does not modify */ &src[offset], gsm_byte*),

                   gsmBlockBuffer);

    if (rc < 0)

      return FALSE;

    offset += toadd;

    if (!Stream_EnsureRemainingCapacity(out, sizeof(gsmBlockBuffer)))

      return FALSE;

    Stream_Write(out, (void*)gsmBlockBuffer, sizeof(gsmBlockBuffer));

  }

  return TRUE;

}

static BOOL freerdp_dsp_encode_gsm610(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                      const BYTE* WINPR_RESTRICT src, size_t size,

                                      wStream* WINPR_RESTRICT out)

{

  size_t offset = 0;

  while (offset < size)

  {

    const gsm_signal* signal = WINPR_PACKED_ALIGN_CAST(const gsm_signal*, &src[offset]);

    if (!Stream_EnsureRemainingCapacity(out, sizeof(gsm_frame)))

      return FALSE;

    gsm_encode(context->gsm,

               WINPR_CAST_CONST_PTR_AWAY(/* API does not modify */ signal, gsm_signal*),

               Stream_Pointer(out));

    if ((offset % 65) == 0)

      Stream_Seek(out, 33);

    else

      Stream_Seek(out, 32);

    offset += 160;

  }

  return TRUE;

}

#endif

#if defined(WITH_LAME)

static BOOL valid_mp3_format(const FREERDP_DSP_CONTEXT* WINPR_RESTRICT context)

{

  WINPR_ASSERT(context);

  if (context->common.format.wFormatTag != WAVE_FORMAT_MPEGLAYER3)

    return FALSE;

  if (context->common.format.nChannels < 1)

    return FALSE;

  if (context->common.format.wBitsPerSample == 0)

    return FALSE;

  if (context->common.format.nSamplesPerSec == 0)

    return FALSE;

  return TRUE;

}

static BOOL freerdp_dsp_decode_mp3(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                   const BYTE* WINPR_RESTRICT src, size_t size,

                                   wStream* WINPR_RESTRICT out)

{

  if (!context || !src || !out)

    return FALSE;

  if (!valid_mp3_format(context))

    return FALSE;

  const size_t buffer_size =

      2ull * context->common.format.nChannels * context->common.format.nSamplesPerSec;

  if (!Stream_EnsureCapacity(context->common.buffer, 2ull * buffer_size))

    return FALSE;

  short* pcm_l = Stream_BufferAs(context->common.buffer, short);

  short* pcm_r = Stream_BufferAs(context->common.buffer, short) + (buffer_size / sizeof(short));

  const int rc = hip_decode(

      context->hip,

      WINPR_CAST_CONST_PTR_AWAY(/* API is not modifying content */ src, unsigned char*), size,

      pcm_l, pcm_r);

  if (rc <= 0)

    return FALSE;

  if (!Stream_EnsureRemainingCapacity(out, (size_t)rc * context->common.format.nChannels * 2ull))

    return FALSE;

  for (int x = 0; x < rc; x++)

  {

    Stream_Write_UINT16(out, (UINT16)pcm_l[x]);

    Stream_Write_UINT16(out, (UINT16)pcm_r[x]);

  }

  return TRUE;

}

static BOOL freerdp_dsp_encode_mp3(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                   const BYTE* WINPR_RESTRICT src, size_t size,

                                   wStream* WINPR_RESTRICT out)

{

  if (!context || !src || !out)

    return FALSE;

  if (!valid_mp3_format(context))

    return FALSE;

  size_t samples_per_channel =

      size / context->common.format.nChannels / context->common.format.wBitsPerSample / 8;

  /* Ensure worst case buffer size for mp3 stream taken from LAME header */

  if (!Stream_EnsureRemainingCapacity(out, 5ull / 4ull * samples_per_channel + 7200ull))

    return FALSE;

  samples_per_channel = size / 2 /* size of a sample */ / context->common.format.nChannels;

  const size_t outLen = Stream_GetRemainingCapacity(out);

  if ((outLen > INT_MAX) || (samples_per_channel > INT_MAX))

    return FALSE;

  const int rc = lame_encode_buffer_interleaved(

      context->lame,

      WINPR_CAST_CONST_PTR_AWAY(WINPR_PACKED_ALIGN_CAST(const short*, src), short*),

      WINPR_ASSERTING_INT_CAST(int, samples_per_channel), Stream_Pointer(out),

      WINPR_ASSERTING_INT_CAST(int, outLen));

  if (rc < 0)

    return FALSE;

  Stream_Seek(out, (size_t)rc);

  return TRUE;

}

#endif

#if defined(WITH_FAAC)

static BOOL freerdp_dsp_encode_faac(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                    const BYTE* WINPR_RESTRICT src, size_t size,

                                    wStream* WINPR_RESTRICT out)

{

  const int16_t* inSamples = WINPR_PACKED_ALIGN_CAST(const int16_t*, src);

  if (!context || !src || !out)

    return FALSE;

  const unsigned int bpp = context->common.format.wBitsPerSample / 8;

  const size_t nrSamples = size / bpp;

  if (!Stream_EnsureRemainingCapacity(context->common.buffer, nrSamples * sizeof(int16_t)))

    return FALSE;

  for (size_t x = 0; x < nrSamples; x++)

  {

    Stream_Write_INT16(context->common.buffer, inSamples[x]);

    if (Stream_GetPosition(context->common.buffer) / bpp >= context->faacInputSamples)

    {

      if (!Stream_EnsureRemainingCapacity(out, context->faacMaxOutputBytes))

        return FALSE;

      const size_t outLen = Stream_GetRemainingCapacity(out);

      if ((outLen > UINT_MAX) || (context->faacInputSamples > UINT_MAX))

        return FALSE;

      const int rc =

          faacEncEncode(context->faac, Stream_BufferAs(context->common.buffer, int32_t),

                        WINPR_ASSERTING_INT_CAST(unsigned int, context->faacInputSamples),

                        Stream_Pointer(out), WINPR_ASSERTING_INT_CAST(unsigned int, outLen));

      if (rc < 0)

        return FALSE;

      if (rc > 0)

        Stream_Seek(out, (size_t)rc);

      Stream_ResetPosition(context->common.buffer);

    }

  }

  return TRUE;

}

#endif

#if defined(WITH_OPUS)

static BOOL freerdp_dsp_decode_opus(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                    const BYTE* WINPR_RESTRICT src, size_t size,

                                    wStream* WINPR_RESTRICT out)

{

  if (!context || !context->opus_decoder || !src || !out)

    return FALSE;

  /* Max packet duration is 120ms (5760 at 48KHz) */

  const size_t max_size = OPUS_MAX_FRAMES * context->common.format.nChannels * sizeof(int16_t);

  if (!Stream_EnsureRemainingCapacity(out, max_size))

    return FALSE;

  const opus_int32 frames =

      opus_decode(context->opus_decoder, src, WINPR_ASSERTING_INT_CAST(opus_int32, size),

                  Stream_Pointer(out), OPUS_MAX_FRAMES, 0);

  if (frames < 0)

    return FALSE;

  Stream_Seek(out, (size_t)frames * context->common.format.nChannels * sizeof(int16_t));

  return TRUE;

}

/* Packet durations opus_encode() takes, in units of 2.5 ms, longest first. */

static const UINT32 opus_packet_units[] = { 24, 16, 8, 4, 2, 1 };

static BOOL opus_is_packet_frames(UINT32 rate, size_t frames)

{

  for (size_t x = 0; x < ARRAYSIZE(opus_packet_units); x++)

  {

    if (frames == 1ull * rate * opus_packet_units[x] / 400)

      return TRUE;

  }

  return FALSE;

}

/*

 * opus_encode() only takes 2.5, 5, 10, 20, 40 or 60 ms of audio, but callers hand over what their

 * capture device delivered. Collect the samples and encode the longest valid packet, at least

 * opus_packet_frames long; keep the rest for the next call. Nothing is written until enough

 * samples arrived.

 */

static BOOL freerdp_dsp_encode_opus(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                    const BYTE* WINPR_RESTRICT src, size_t size,

                                    wStream* WINPR_RESTRICT out)

{

  if (!context || !context->opus_encoder || !context->opus_input || !src || !out)

    return FALSE;

  wStream* input = context->opus_input;

  const UINT32 rate = context->common.format.nSamplesPerSec;

  const size_t frame_bytes = sizeof(opus_int16) * context->common.format.nChannels;

  if (!Stream_EnsureRemainingCapacity(input, size))

    return FALSE;

  Stream_Write(input, src, size);

  const size_t available = Stream_GetPosition(input) / frame_bytes;

  if (available < context->opus_packet_frames)

    return TRUE;

  size_t frames = 0;

  for (size_t x = 0; x < ARRAYSIZE(opus_packet_units); x++)

  {

    frames = 1ull * rate * opus_packet_units[x] / 400;

    if (frames <= available)

      break;

  }

  /* Max packet duration is 120ms (5760 at 48KHz) */

  const size_t max_size = OPUS_MAX_FRAMES * context->common.format.nChannels * sizeof(int16_t);

  if (!Stream_EnsureRemainingCapacity(out, max_size))

    return FALSE;

  const opus_int16* src_data = WINPR_PACKED_ALIGN_CAST(const opus_int16*, Stream_Buffer(input));

  const opus_int32 bytes =

      opus_encode(context->opus_encoder, src_data, WINPR_ASSERTING_INT_CAST(opus_int32, frames),

                  Stream_Pointer(out), WINPR_ASSERTING_INT_CAST(opus_int32, max_size));

  if (bytes < 0)

    return FALSE;

  Stream_Seek(out, (size_t)bytes);

  const size_t used = frames * frame_bytes;

  const size_t left = Stream_GetPosition(input) - used;

  memmove(Stream_Buffer(input), Stream_Buffer(input) + used, left);

  return Stream_SetPosition(input, left);

}

#endif

#if defined(WITH_FAAD2)

static BOOL freerdp_dsp_decode_faad(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                    const BYTE* WINPR_RESTRICT src, size_t size,

                                    wStream* WINPR_RESTRICT out)

{

  NeAACDecFrameInfo info;

  size_t offset = 0;

  if (!context || !src || !out)

    return FALSE;

  if (!context->faadSetup)

  {

    union

    {

      const void* cpv;

      void* pv;

    } cnv;

    unsigned long samplerate = 0;

    unsigned char channels = 0;

    cnv.cpv = src;

    const long err = NeAACDecInit(context->faad, /* API is not modifying content */ cnv.pv,

                                  size, &samplerate, &channels);

    if (err != 0)

      return FALSE;

    if (channels != context->common.format.nChannels)

      return FALSE;

    if (samplerate != context->common.format.nSamplesPerSec)

      return FALSE;

    context->faadSetup = TRUE;

  }

  while (offset < size)

  {

    union

    {

      const void* cpv;

      void* pv;

    } cnv;

    const size_t outSize = context->common.format.nSamplesPerSec *

                           context->common.format.nChannels *

                           context->common.format.wBitsPerSample / 8;

    if (!Stream_EnsureRemainingCapacity(out, outSize))

      return FALSE;

    void* sample_buffer = Stream_Pointer(out);

    cnv.cpv = &src[offset];

    NeAACDecDecode2(context->faad, &info, cnv.pv, size - offset, &sample_buffer,

                    Stream_GetRemainingCapacity(out));

    if (info.error != 0)

      return FALSE;

    offset += info.bytesconsumed;

    if (info.samples == 0)

      continue;

    Stream_Seek(out, info.samples * context->common.format.wBitsPerSample / 8);

  }

  return TRUE;

}

#endif

/**

 * 0     1     2     3

 * 2 0   6 4   10 8  14 12   <left>

 *

 * 4     5     6     7

 * 3 1   7 5   11 9  15 13   <right>

 */

static const struct

{

  BYTE byte_num;

  BYTE byte_shift;

} ima_stereo_encode_map[] = { { 0, 0 }, { 4, 0 }, { 0, 4 }, { 4, 4 }, { 1, 0 }, { 5, 0 },

                            { 1, 4 }, { 5, 4 }, { 2, 0 }, { 6, 0 }, { 2, 4 }, { 6, 4 },

                            { 3, 0 }, { 7, 0 }, { 3, 4 }, { 7, 4 } };

static BYTE dsp_encode_ima_adpcm_sample(ADPCM* WINPR_RESTRICT adpcm, size_t channel, INT16 sample)

{

  WINPR_ASSERT(channel < ARRAYSIZE(adpcm->ima.last_step));

  WINPR_ASSERT(channel < ARRAYSIZE(adpcm->ima.last_sample));

  const INT16 offset = adpcm->ima.last_step[channel];

  WINPR_ASSERT(offset >= 0);

  WINPR_ASSERT(WINPR_CXX_COMPAT_CAST(size_t, offset) < ARRAYSIZE(ima_step_size_table));

  INT32 ss = ima_step_size_table[offset];

  INT32 e = sample - adpcm->ima.last_sample[channel];

  INT32 d = e;

  INT32 diff = ss >> 3;

  BYTE enc = 0;

  if (e < 0)

  {

    enc = 8;

    e = -e;

  }

  if (e >= ss)

  {

    enc |= 4;

    e -= ss;

  }

  ss >>= 1;

  if (e >= ss)

  {

    enc |= 2;

    e -= ss;

  }

  ss >>= 1;

  if (e >= ss)

  {

    enc |= 1;

    e -= ss;

  }

  if (d < 0)

    diff = d + e - diff;

  else

    diff = d - e + diff;

  diff += adpcm->ima.last_sample[channel];

  if (diff < -32768)

    diff = -32768;

  else if (diff > 32767)

    diff = 32767;

  adpcm->ima.last_sample[channel] = (INT16)diff;

  WINPR_ASSERT(enc < ARRAYSIZE(ima_step_index_table));

  const int32_t last = adpcm->ima.last_step[channel] + ima_step_index_table[enc];

  adpcm->ima.last_step[channel] = WINPR_ASSERTING_INT_CAST(int16_t, last);

  dsp_ima_clamp_step(adpcm, channel);

  return enc;

}

static BOOL freerdp_dsp_encode_ima_adpcm(FREERDP_DSP_CONTEXT* WINPR_RESTRICT context,

                                         const BYTE* WINPR_RESTRICT src, size_t size,

                                         wStream* WINPR_RESTRICT out)

{

  if (!valid_ima_adpcm_format(context))

    return FALSE;

  if (!Stream_EnsureRemainingCapacity(out, size))

    return FALSE;

  if (!Stream_EnsureRemainingCapacity(context->common.buffer, size + 64ull))

    return FALSE;

  const size_t align = (context->common.format.nChannels > 1) ? 32 : 4;

  while (size >= align)

  {

    if (Stream_GetPosition(context->common.buffer) % context->common.format.nBlockAlign == 0)

    {

      Stream_Write_UINT8(context->common.buffer, context->adpcm.ima.last_sample[0] & 0xFF);

      Stream_Write_UINT8(context->common.buffer,

                         (context->adpcm.ima.last_sample[0] >> 8) & 0xFF);

      Stream_Write_UINT8(context->common.buffer, (BYTE)context->adpcm.ima.last_step[0]);

      Stream_Write_UINT8(context->common.buffer, 0);

      if (context->common.format.nChannels > 1)

      {

        Stream_Write_UINT8(context->common.buffer,

                           context->adpcm.ima.last_sample[1] & 0xFF);

        Stream_Write_UINT8(context->common.buffer,

                           (context->adpcm.ima.last_sample[1] >> 8) & 0xFF);

        Stream_Write_UINT8(context->common.buffer, (BYTE)context->adpcm.ima.last_step[1]);

        Stream_Write_UINT8(context->common.buffer, 0);

      }

    }

    if (context->common.format.nChannels > 1)

    {

      BYTE* dst = Stream_Pointer(context->common.buffer);

      ZeroMemory(dst, 8);

      for (size_t i = 0; i < 16; i++)

      {

        const INT16 sample = (INT16)(((UINT16)(*src)) | (((UINT16)(*(src + 1))) << 8));

        src += 2;

        const BYTE encoded = dsp_encode_ima_adpcm_sample(&context->adpcm, i % 2, sample);

        dst[ima_stereo_encode_map[i].byte_num] |= encoded

                                                  << ima_stereo_encode_map[i].byte_shift;

      }

      if (!Stream_SafeSeek(context->common.buffer, 8))

        return FALSE;

      size -= 32;

    }

    else

    {

      INT16 sample = (INT16)(((UINT16)(*src)) | (((UINT16)(*(src + 1))) << 8));

      src += 2;

      BYTE encoded = dsp_encode_ima_adpcm_sample(&context->adpcm, 0, sample);

      sample = (INT16)(((UINT16)(*src)) | (((UINT16)(*(src + 1))) << 8));

      src += 2;