path: root/embdrv/sbc/decoder/srce/synthesis-sbc.c

/******************************************************************************
 *
 *  Copyright (C) 2014 The Android Open Source Project
 *  Copyright 2003 - 2004 Open Interface North America, Inc. All rights
 *                        reserved.
 *
 *  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.
 *
 ******************************************************************************/

/*******************************************************************************
  $Revision: #1 $
 ******************************************************************************/

/** @file

This file, along with synthesis-generated.c, contains the synthesis
filterbank routines. The operations performed correspond to the
operations described in A2DP Appendix B, Figure 12.3. Several
mathematical optimizations are performed, particularly for the
8-subband case.

One important optimization is to note that the "matrixing" operation
can be decomposed into the product of a type II discrete cosine kernel
and another, sparse matrix.

According to Fig 12.3, in the 8-subband case,
@code
    N[k][i] = cos((i+0.5)*(k+4)*pi/8), k = 0..15 and i = 0..7
@endcode

N can be factored as R * C2, where C2 is an 8-point type II discrete
cosine kernel given by
@code
    C2[k][i] = cos((i+0.5)*k*pi/8)), k = 0..7 and i = 0..7
@endcode

R turns out to be a sparse 16x8 matrix with the following non-zero
entries:
@code
    R[k][k+4]        =  1,   k = 0..3
    R[k][abs(12-k)]  = -1,   k = 5..15
@endcode

The spec describes computing V[0..15] as N * R.
@code
    V[0..15] = N * R = (R * C2) * R = R * (C2 * R)
@endcode

C2 * R corresponds to computing the discrete cosine transform of R, so
V[0..15] can be computed by taking the DCT of R followed by assignment
and selective negation of the DCT result into V.

        Although this was derived empirically using GNU Octave, it is
        formally demonstrated in, e.g., Liu, Chi-Min and Lee,
        Wen-Chieh. "A Unified Fast Algorithm for Cosine Modulated
        Filter Banks in Current Audio Coding Standards." Journal of
        the AES 47 (December 1999): 1061.

Given the shift operation performed prior to computing V[0..15], it is
clear that V[0..159] represents a rolling history of the 10 most
recent groups of blocks input to the synthesis operation. Interpreting
the matrix N in light of its factorization into C2 and R, R's
sparseness has implications for interpreting the values in V. In
particular, there is considerable redundancy in the values stored in
V. Furthermore, since R[4][0..7] are all zeros, one out of every 16
values in V will be zero regardless of the input data. Within each
block of 16 values in V, fully half of them are redundant or
irrelevant:

@code
    V[ 0] =  DCT[4]
    V[ 1] =  DCT[5]
    V[ 2] =  DCT[6]
    V[ 3] =  DCT[7]
    V[ 4] = 0
    V[ 5] = -DCT[7] = -V[3] (redundant)
    V[ 6] = -DCT[6] = -V[2] (redundant)
    V[ 7] = -DCT[5] = -V[1] (redundant)
    V[ 8] = -DCT[4] = -V[0] (redundant)
    V[ 9] = -DCT[3]
    V[10] = -DCT[2]
    V[11] = -DCT[1]
    V[12] = -DCT[0]
    V[13] = -DCT[1] = V[11] (redundant)
    V[14] = -DCT[2] = V[10] (redundant)
    V[15] = -DCT[3] = V[ 9] (redundant)
@endcode

Since the elements of V beyond 15 were originally computed the same
way during a previous run, what holds true for V[x] also holds true
for V[x+16]. Thus, so long as care is taken to maintain the mapping,
we need only actually store the unique values, which correspond to the
output of the DCT, in some cases inverted. In fact, instead of storing
V[0..159], we could store DCT[0..79] which would contain a history of
DCT results. More on this in a bit.

Going back to figure 12.3 in the spec, it should be clear that the
vector U need not actually be explicitly constructed, but that with
suitable indexing into V during the window operation, the same end can
be accomplished. In the same spirit of the pseudocode shown in the
figure, the following is the construction of W without using U:

@code
    for i=0 to 79 do
        W[i] = D[i]*VSIGN(i)*V[remap_V(i)] where remap_V(i) = 32*(int(i/16)) +
(i % 16) + (i % 16 >= 8 ? 16 : 0)
                                             and VSIGN(i) maps i%16 into {1, 1,
1, 1, 0, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1 }
                                             These values correspond to the
                                             signs of the redundant values as
                                             shown in the explanation three
                                             paragraphs above.
@endcode

We saw above how V[4..8,13..15] (and by extension
V[(4..8,13..15)+16*n]) can be defined in terms of other elements
within the subblock of V. V[0..3,9..12] correspond to DCT elements.

@code
    for i=0 to 79 do
        W[i] = D[i]*DSIGN(i)*DCT[remap_DCT(i)]
@endcode

The DCT is calculated using the Arai-Agui-Nakajima factorization,
which saves some computation by producing output that needs to be
multiplied by scaling factors before being used.

@code
    for i=0 to 79 do
        W[i] = D[i]*SCALE[i%8]*AAN_DCT[remap_DCT(i)]
@endcode

D can be premultiplied with the DCT scaling factors to yield

@code
    for i=0 to 79 do
        W[i] = DSCALED[i]*AAN_DCT[remap_DCT(i)] where DSCALED[i] =
D[i]*SCALE[i%8]
@endcode

The output samples X[0..7] are defined as sums of W:

@code
        X[j] = sum{i=0..9}(W[j+8*i])
@endcode

@ingroup codec_internal
*/

/**
@addtogroup codec_internal
@{
*/

#include "oi_codec_sbc_private.h"

const int32_t dec_window_4[21] = {
    0,      /* +0.00000000E+00 */
    97,     /* +5.36548976E-04 */
    270,    /* +1.49188357E-03 */
    495,    /* +2.73370904E-03 */
    694,    /* +3.83720193E-03 */
    704,    /* +3.89205149E-03 */
    338,    /* +1.86581691E-03 */
    -554,   /* -3.06012286E-03 */
    1974,   /* +1.09137620E-02 */
    3697,   /* +2.04385087E-02 */
    5224,   /* +2.88757392E-02 */
    5824,   /* +3.21939290E-02 */
    4681,   /* +2.58767811E-02 */
    1109,   /* +6.13245186E-03 */
    -5214,  /* -2.88217274E-02 */
    -14047, /* -7.76463494E-02 */
    24529,  /* +1.35593274E-01 */
    35274,  /* +1.94987841E-01 */
    44618,  /* +2.46636662E-01 */
    50984,  /* +2.81828203E-01 */
    53243,  /* +2.94315332E-01 */
};

#define DCTII_4_K06_FIX (11585) /* S1.14      11585   0.707107*/

#define DCTII_4_K08_FIX (21407) /* S1.14      21407   1.306563*/

#define DCTII_4_K09_FIX (-15137) /* S1.14     -15137  -0.923880*/

#define DCTII_4_K10_FIX (-8867) /* S1.14      -8867  -0.541196*/

/** Scales x by y bits to the right, adding a rounding factor.
 */
#ifndef SCALE
#define SCALE(x, y) (((x) + (1 << ((y)-1))) >> (y))
#endif

#ifndef CLIP_INT16
#define CLIP_INT16(x)                \
  do {                               \
    if ((x) > OI_INT16_MAX) {        \
      (x) = OI_INT16_MAX;            \
    } else if ((x) < OI_INT16_MIN) { \
      (x) = OI_INT16_MIN;            \
    }                                \
  } while (0)
#endif

/**
 * Default C language implementation of a 16x32->32 multiply. This function may
 * be replaced by a platform-specific version for speed.
 *
 * @param u A signed 16-bit multiplicand
 * @param v A signed 32-bit multiplier

 * @return  A signed 32-bit value corresponding to the 32 most significant bits
 * of the 48-bit product of u and v.
 */
INLINE int32_t default_mul_16s_32s_hi(int16_t u, int32_t v) {
  uint16_t v0;
  int16_t v1;

  int32_t w, x;

  v0 = (uint16_t)(v & 0xffff);
  v1 = (int16_t)(v >> 16);

  w = v1 * u;
  x = u * v0;

  return w + (x >> 16);
}

#define MUL_16S_32S_HI(_x, _y) default_mul_16s_32s_hi(_x, _y)

#define LONG_MULT_DCT(K, sample) (MUL_16S_32S_HI(K, sample) << 2)

PRIVATE void SynthWindow80_generated(int16_t* pcm,
                                     SBC_BUFFER_T const* RESTRICT buffer,
                                     OI_UINT strideShift);
PRIVATE void SynthWindow112_generated(int16_t* pcm,
                                      SBC_BUFFER_T const* RESTRICT buffer,
                                      OI_UINT strideShift);
PRIVATE void dct2_8(SBC_BUFFER_T* RESTRICT out, int32_t const* RESTRICT x);

typedef void (*SYNTH_FRAME)(OI_CODEC_SBC_DECODER_CONTEXT* context, int16_t* pcm,
                            OI_UINT blkstart, OI_UINT blkcount);

#ifndef COPY_BACKWARD_32BIT_ALIGNED_72_HALFWORDS
#define COPY_BACKWARD_32BIT_ALIGNED_72_HALFWORDS(dest, src) \
  do {                                                      \
    shift_buffer(dest, src, 72);                            \
  } while (0)
#endif

#ifndef DCT2_8
#define DCT2_8(dst, src) dct2_8(dst, src)
#endif

#ifndef SYNTH80
#define SYNTH80 SynthWindow80_generated
#endif

#ifndef SYNTH112
#define SYNTH112 SynthWindow112_generated
#endif

PRIVATE void OI_SBC_SynthFrame_80(OI_CODEC_SBC_DECODER_CONTEXT* context,
                                  int16_t* pcm, OI_UINT blkstart,
                                  OI_UINT blkcount) {
  OI_UINT blk;
  OI_UINT ch;
  OI_UINT nrof_channels = context->common.frameInfo.nrof_channels;
  OI_UINT pcmStrideShift = context->common.pcmStride == 1 ? 0 : 1;
  OI_UINT offset = context->common.filterBufferOffset;
  int32_t* s = context->common.subdata + 8 * nrof_channels * blkstart;
  OI_UINT blkstop = blkstart + blkcount;

  for (blk = blkstart; blk < blkstop; blk++) {
    if (offset == 0) {
      COPY_BACKWARD_32BIT_ALIGNED_72_HALFWORDS(
          context->common.filterBuffer[0] + context->common.filterBufferLen -
              72,
          context->common.filterBuffer[0]);
      if (nrof_channels == 2) {
        COPY_BACKWARD_32BIT_ALIGNED_72_HALFWORDS(
            context->common.filterBuffer[1] + context->common.filterBufferLen -
                72,
            context->common.filterBuffer[1]);
      }
      offset = context->common.filterBufferLen - 80;
    } else {
      offset -= 1 * 8;
    }

    for (ch = 0; ch < nrof_channels; ch++) {
      DCT2_8(context->common.filterBuffer[ch] + offset, s);
      SYNTH80(pcm + ch, context->common.filterBuffer[ch] + offset,
              pcmStrideShift);
      s += 8;
    }
    pcm += (8 << pcmStrideShift);
  }
  context->common.filterBufferOffset = offset;
}

PRIVATE void OI_SBC_SynthFrame_4SB(OI_CODEC_SBC_DECODER_CONTEXT* context,
                                   int16_t* pcm, OI_UINT blkstart,
                                   OI_UINT blkcount) {
  OI_UINT blk;
  OI_UINT ch;
  OI_UINT nrof_channels = context->common.frameInfo.nrof_channels;
  OI_UINT pcmStrideShift = context->common.pcmStride == 1 ? 0 : 1;
  OI_UINT offset = context->common.filterBufferOffset;
  int32_t* s = context->common.subdata + 8 * nrof_channels * blkstart;
  OI_UINT blkstop = blkstart + blkcount;

  for (blk = blkstart; blk < blkstop; blk++) {
    if (offset == 0) {
      COPY_BACKWARD_32BIT_ALIGNED_72_HALFWORDS(
          context->common.filterBuffer[0] + context->common.filterBufferLen -
              72,
          context->common.filterBuffer[0]);
      if (nrof_channels == 2) {
        COPY_BACKWARD_32BIT_ALIGNED_72_HALFWORDS(
            context->common.filterBuffer[1] + context->common.filterBufferLen -
                72,
            context->common.filterBuffer[1]);
      }
      offset = context->common.filterBufferLen - 80;
    } else {
      offset -= 8;
    }
    for (ch = 0; ch < nrof_channels; ch++) {
      cosineModulateSynth4(context->common.filterBuffer[ch] + offset, s);
      SynthWindow40_int32_int32_symmetry_with_sum(
          pcm + ch, context->common.filterBuffer[ch] + offset, pcmStrideShift);
      s += 4;
    }
    pcm += (4 << pcmStrideShift);
  }
  context->common.filterBufferOffset = offset;
}

#ifdef SBC_ENHANCED

PRIVATE void OI_SBC_SynthFrame_Enhanced(OI_CODEC_SBC_DECODER_CONTEXT* context,
                                        int16_t* pcm, OI_UINT blkstart,
                                        OI_UINT blkcount) {
  OI_UINT blk;
  OI_UINT ch;
  OI_UINT nrof_channels = context->common.frameInfo.nrof_channels;
  OI_UINT pcmStrideShift = context->common.pcmStride == 1 ? 0 : 1;
  OI_UINT offset = context->common.filterBufferOffset;
  int32_t* s = context->common.subdata + 8 * nrof_channels * blkstart;
  OI_UINT blkstop = blkstart + blkcount;

  for (blk = blkstart; blk < blkstop; blk++) {
    if (offset == 0) {
      COPY_BACKWARD_32BIT_ALIGNED_104_HALFWORDS(
          context->common.filterBuffer[0] + context->common.filterBufferLen -
              104,
          context->common.filterBuffer[0]);
      if (nrof_channels == 2) {
        COPY_BACKWARD_32BIT_ALIGNED_104_HALFWORDS(
            context->common.filterBuffer[1] + context->common.filterBufferLen -
                104,
            context->common.filterBuffer[1]);
      }
      offset = context->common.filterBufferLen - 112;
    } else {
      offset -= 8;
    }
    for (ch = 0; ch < nrof_channels; ++ch) {
      DCT2_8(context->common.filterBuffer[ch] + offset, s);
      SYNTH112(pcm + ch, context->common.filterBuffer[ch] + offset,
               pcmStrideShift);
      s += 8;
    }
    pcm += (8 << pcmStrideShift);
  }
  context->common.filterBufferOffset = offset;
}

static const SYNTH_FRAME SynthFrameEnhanced[] = {
    NULL,                       /* invalid */
    OI_SBC_SynthFrame_Enhanced, /* mono */
    OI_SBC_SynthFrame_Enhanced  /* stereo */
};

#endif

static const SYNTH_FRAME SynthFrame8SB[] = {
    NULL,                 /* invalid */
    OI_SBC_SynthFrame_80, /* mono */
    OI_SBC_SynthFrame_80  /* stereo */
};

static const SYNTH_FRAME SynthFrame4SB[] = {
    NULL,                  /* invalid */
    OI_SBC_SynthFrame_4SB, /* mono */
    OI_SBC_SynthFrame_4SB  /* stereo */
};

PRIVATE void OI_SBC_SynthFrame(OI_CODEC_SBC_DECODER_CONTEXT* context,
                               int16_t* pcm, OI_UINT start_block,
                               OI_UINT nrof_blocks) {
  OI_UINT nrof_subbands = context->common.frameInfo.nrof_subbands;
  OI_UINT nrof_channels = context->common.frameInfo.nrof_channels;

  OI_ASSERT(nrof_subbands == 4 || nrof_subbands == 8);
  if (nrof_subbands == 4) {
    SynthFrame4SB[nrof_channels](context, pcm, start_block, nrof_blocks);
#ifdef SBC_ENHANCED
  } else if (context->common.frameInfo.enhanced) {
    SynthFrameEnhanced[nrof_channels](context, pcm, start_block, nrof_blocks);
#endif /* SBC_ENHANCED */
  } else {
    SynthFrame8SB[nrof_channels](context, pcm, start_block, nrof_blocks);
  }
}

void SynthWindow40_int32_int32_symmetry_with_sum(int16_t* pcm,
                                                 SBC_BUFFER_T buffer[80],
                                                 OI_UINT strideShift) {
  int32_t pa;
  int32_t pb;

  /* These values should be zero, since out[2] of the 4-band cosine modulation
   * is always zero. */
  OI_ASSERT(buffer[2] == 0);
  OI_ASSERT(buffer[10] == 0);
  OI_ASSERT(buffer[18] == 0);
  OI_ASSERT(buffer[26] == 0);
  OI_ASSERT(buffer[34] == 0);
  OI_ASSERT(buffer[42] == 0);
  OI_ASSERT(buffer[50] == 0);
  OI_ASSERT(buffer[58] == 0);
  OI_ASSERT(buffer[66] == 0);
  OI_ASSERT(buffer[74] == 0);

  pa = dec_window_4[4] * (buffer[12] + buffer[76]);
  pa += dec_window_4[8] * (buffer[16] - buffer[64]);
  pa += dec_window_4[12] * (buffer[28] + buffer[60]);
  pa += dec_window_4[16] * (buffer[32] - buffer[48]);
  pa += dec_window_4[20] * buffer[44];
  pa = SCALE(-pa, 15);
  CLIP_INT16(pa);
  pcm[0 << strideShift] = (int16_t)pa;

  pa = dec_window_4[1] * buffer[1];
  pb = dec_window_4[1] * buffer[79];
  pb += dec_window_4[3] * buffer[3];
  pa += dec_window_4[3] * buffer[77];
  pa += dec_window_4[5] * buffer[13];
  pb += dec_window_4[5] * buffer[67];
  pb += dec_window_4[7] * buffer[15];
  pa += dec_window_4[7] * buffer[65];
  pa += dec_window_4[9] * buffer[17];
  pb += dec_window_4[9] * buffer[63];
  pb += dec_window_4[11] * buffer[19];
  pa += dec_window_4[11] * buffer[61];
  pa += dec_window_4[13] * buffer[29];
  pb += dec_window_4[13] * buffer[51];
  pb += dec_window_4[15] * buffer[31];
  pa += dec_window_4[15] * buffer[49];
  pa += dec_window_4[17] * buffer[33];
  pb += dec_window_4[17] * buffer[47];
  pb += dec_window_4[19] * buffer[35];
  pa += dec_window_4[19] * buffer[45];
  pa = SCALE(-pa, 15);
  CLIP_INT16(pa);
  pcm[1 << strideShift] = (int16_t)(pa);
  pb = SCALE(-pb, 15);
  CLIP_INT16(pb);
  pcm[3 << strideShift] = (int16_t)(pb);

  pa = dec_window_4[2] *
       (/*buffer[ 2] + */ buffer[78]); /* buffer[ 2] is always zero */
  pa += dec_window_4[6] *
        (buffer[14] /* + buffer[66]*/); /* buffer[66] is always zero */
  pa += dec_window_4[10] *
        (/*buffer[18] + */ buffer[62]); /* buffer[18] is always zero */
  pa += dec_window_4[14] *
        (buffer[30] /* + buffer[50]*/); /* buffer[50] is always zero */
  pa += dec_window_4[18] *
        (/*buffer[34] + */ buffer[46]); /* buffer[34] is always zero */
  pa = SCALE(-pa, 15);
  CLIP_INT16(pa);
  pcm[2 << strideShift] = (int16_t)(pa);
}

/**
  This routine implements the cosine modulation matrix for 4-subband
  synthesis. This is called "matrixing" in the SBC specification. This
  matrix, M4,  can be factored into an 8-point Type II Discrete Cosine
  Transform, DCTII_4 and a matrix S4, given here:

  @code
        __               __
       |   0   0   1   0   |
       |   0   0   0   1   |
       |   0   0   0   0   |
       |   0   0   0  -1   |
  S4 = |   0   0  -1   0   |
       |   0  -1   0   0   |
       |  -1   0   0   0   |
       |__ 0  -1   0   0 __|

  M4 * in = S4 * (DCTII_4 * in)
  @endcode

  (DCTII_4 * in) is computed using a Fast Cosine Transform. The algorithm
  here is based on an implementation computed by the SPIRAL computer
  algebra system, manually converted to fixed-point arithmetic. S4 can be
  implemented using only assignment and negation.
  */
PRIVATE void cosineModulateSynth4(SBC_BUFFER_T* RESTRICT out,
                                  int32_t const* RESTRICT in) {
  int32_t f0, f1, f2, f3, f4, f7, f8, f9, f10;
  int32_t y0, y1, y2, y3;

  f0 = (in[0] - in[3]);
  f1 = (in[0] + in[3]);
  f2 = (in[1] - in[2]);
  f3 = (in[1] + in[2]);

  f4 = f1 - f3;

  y0 = -SCALE(f1 + f3, DCT_SHIFT);
  y2 = -SCALE(LONG_MULT_DCT(DCTII_4_K06_FIX, f4), DCT_SHIFT);
  f7 = f0 + f2;
  f8 = LONG_MULT_DCT(DCTII_4_K08_FIX, f0);
  f9 = LONG_MULT_DCT(DCTII_4_K09_FIX, f7);
  f10 = LONG_MULT_DCT(DCTII_4_K10_FIX, f2);
  y3 = -SCALE(f8 + f9, DCT_SHIFT);
  y1 = -SCALE(f10 - f9, DCT_SHIFT);

  out[0] = (int16_t)-y2;
  out[1] = (int16_t)-y3;
  out[2] = (int16_t)0;
  out[3] = (int16_t)y3;
  out[4] = (int16_t)y2;
  out[5] = (int16_t)y1;
  out[6] = (int16_t)y0;
  out[7] = (int16_t)y1;
}

/**
@}
*/