Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ca1c4e47 authored by Andy Hung's avatar Andy Hung
Browse files

EffectDownmix: Remove obsolete define 

Test: downmixtest, test directories identical
Bug: 187062102
Change-Id: Ifac37d34d55d133ab8cbaa39cf88f60e4a56ef1f
parent da3489fb

media/libeffects/downmix/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -33,7 +33,6 @@ cc_library_shared { 
    relative_install_path: "soundfx",



    cflags: [

        "-DBUILD_FLOAT",

        "-fvisibility=hidden",

        "-Wall",

        "-Werror",

media/libeffects/downmix/EffectDownmix.c

+3 −328
Original line number Diff line number Diff line
@@ -31,13 +31,8 @@ 
// Do not submit with DOWNMIX_ALWAYS_USE_GENERIC_DOWNMIXER defined, strictly for testing

//#define DOWNMIX_ALWAYS_USE_GENERIC_DOWNMIXER 0



#ifdef BUILD_FLOAT

#define MINUS_3_DB_IN_FLOAT 0.70710678f // -3dB = 0.70710678f

const audio_format_t gTargetFormat = AUDIO_FORMAT_PCM_FLOAT;

#else

#define MINUS_3_DB_IN_Q19_12 2896 // -3dB = 0.707 * 2^12 = 2896

const audio_format_t gTargetFormat = AUDIO_FORMAT_PCM_16_BIT;

#endif



// subset of possible audio_channel_mask_t values, and AUDIO_CHANNEL_OUT_* renamed to CHANNEL_MASK_*

typedef enum {
@@ -88,7 +83,7 @@ static const effect_descriptor_t * const gDescriptors[] = { 


// number of effects in this library

const int kNbEffects = sizeof(gDescriptors) / sizeof(const effect_descriptor_t *);

#ifdef BUILD_FLOAT



static LVM_FLOAT clamp_float(LVM_FLOAT a) {

    if (a > 1.0f) {

        return 1.0f;
@@ -100,7 +95,7 @@ static LVM_FLOAT clamp_float(LVM_FLOAT a) { 
        return a;

    }

}

#endif



/*----------------------------------------------------------------------------

 * Test code

 *--------------------------------------------------------------------------*/
@@ -303,106 +298,6 @@ int32_t DownmixLib_GetDescriptor(const effect_uuid_t *uuid, effect_descriptor_t 
    return -EINVAL;

}



#ifndef BUILD_FLOAT

/*--- Effect Control Interface Implementation ---*/



static int Downmix_Process(effect_handle_t self,

        audio_buffer_t *inBuffer, audio_buffer_t *outBuffer) {



    downmix_object_t *pDownmixer;

    int16_t *pSrc, *pDst;

    downmix_module_t *pDwmModule = (downmix_module_t *)self;



    if (pDwmModule == NULL) {

        return -EINVAL;

    }



    if (inBuffer == NULL || inBuffer->raw == NULL ||

        outBuffer == NULL || outBuffer->raw == NULL ||

        inBuffer->frameCount != outBuffer->frameCount) {

        return -EINVAL;

    }



    pDownmixer = (downmix_object_t*) &pDwmModule->context;



    if (pDownmixer->state == DOWNMIX_STATE_UNINITIALIZED) {

        ALOGE("Downmix_Process error: trying to use an uninitialized downmixer");

        return -EINVAL;

    } else if (pDownmixer->state == DOWNMIX_STATE_INITIALIZED) {

        ALOGE("Downmix_Process error: trying to use a non-configured downmixer");

        return -ENODATA;

    }



    pSrc = inBuffer->s16;

    pDst = outBuffer->s16;

    size_t numFrames = outBuffer->frameCount;



    const bool accumulate =

            (pDwmModule->config.outputCfg.accessMode == EFFECT_BUFFER_ACCESS_ACCUMULATE);

    const uint32_t downmixInputChannelMask = pDwmModule->config.inputCfg.channels;



    switch(pDownmixer->type) {



      case DOWNMIX_TYPE_STRIP:

          if (accumulate) {

              while (numFrames) {

                  pDst[0] = clamp16(pDst[0] + pSrc[0]);

                  pDst[1] = clamp16(pDst[1] + pSrc[1]);

                  pSrc += pDownmixer->input_channel_count;

                  pDst += 2;

                  numFrames--;

              }

          } else {

              while (numFrames) {

                  pDst[0] = pSrc[0];

                  pDst[1] = pSrc[1];

                  pSrc += pDownmixer->input_channel_count;

                  pDst += 2;

                  numFrames--;

              }

          }

          break;



      case DOWNMIX_TYPE_FOLD:

#ifdef DOWNMIX_ALWAYS_USE_GENERIC_DOWNMIXER

          // bypass the optimized downmix routines for the common formats

          if (!Downmix_foldGeneric(

                  downmixInputChannelMask, pSrc, pDst, numFrames, accumulate)) {

              ALOGE("Multichannel configuration 0x%" PRIx32 " is not supported", downmixInputChannelMask);

              return -EINVAL;

          }

          break;

#endif

        // optimize for the common formats

        switch((downmix_input_channel_mask_t)downmixInputChannelMask) {

        case CHANNEL_MASK_QUAD_BACK:

        case CHANNEL_MASK_QUAD_SIDE:

            Downmix_foldFromQuad(pSrc, pDst, numFrames, accumulate);

            break;

        case CHANNEL_MASK_5POINT1_BACK:

        case CHANNEL_MASK_5POINT1_SIDE:

            Downmix_foldFrom5Point1(pSrc, pDst, numFrames, accumulate);

            break;

        case CHANNEL_MASK_7POINT1:

            Downmix_foldFrom7Point1(pSrc, pDst, numFrames, accumulate);

            break;

        default:

            if (!Downmix_foldGeneric(

                    downmixInputChannelMask, pSrc, pDst, numFrames, accumulate)) {

                ALOGE("Multichannel configuration 0x%" PRIx32 " is not supported", downmixInputChannelMask);

                return -EINVAL;

            }

            break;

        }

        break;



      default:

        return -EINVAL;

    }



    return 0;

}

#else /*BUILD_FLOAT*/

/*--- Effect Control Interface Implementation ---*/



static int Downmix_Process(effect_handle_t self,
@@ -503,7 +398,6 @@ static int Downmix_Process(effect_handle_t self, 


    return 0;

}

#endif



static int Downmix_Command(effect_handle_t self, uint32_t cmdCode, uint32_t cmdSize,

        void *pCmdData, uint32_t *replySize, void *pReplyData) {
@@ -940,35 +834,6 @@ int Downmix_getParameter(downmix_object_t *pDownmixer, int32_t param, uint32_t * 
 *

 *----------------------------------------------------------------------------

 */

#ifndef BUILD_FLOAT

void Downmix_foldFromQuad(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {

    // sample at index 0 is FL

    // sample at index 1 is FR

    // sample at index 2 is RL

    // sample at index 3 is RR

    if (accumulate) {

        while (numFrames) {

            // FL + RL

            pDst[0] = clamp16(pDst[0] + ((pSrc[0] + pSrc[2]) >> 1));

            // FR + RR

            pDst[1] = clamp16(pDst[1] + ((pSrc[1] + pSrc[3]) >> 1));

            pSrc += 4;

            pDst += 2;

            numFrames--;

        }

    } else { // same code as above but without adding and clamping pDst[i] to itself

        while (numFrames) {

            // FL + RL

            pDst[0] = clamp16((pSrc[0] + pSrc[2]) >> 1);

            // FR + RR

            pDst[1] = clamp16((pSrc[1] + pSrc[3]) >> 1);

            pSrc += 4;

            pDst += 2;

            numFrames--;

        }

    }

}

#else

void Downmix_foldFromQuad(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, bool accumulate) {

    // sample at index 0 is FL

    // sample at index 1 is FR
@@ -996,7 +861,6 @@ void Downmix_foldFromQuad(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, bo 
        }

    }

}

#endif



/*----------------------------------------------------------------------------

 * Downmix_foldFrom5Point1()
@@ -1015,52 +879,6 @@ void Downmix_foldFromQuad(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, bo 
 *

 *----------------------------------------------------------------------------

 */

#ifndef BUILD_FLOAT

void Downmix_foldFrom5Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {

    int32_t lt, rt, centerPlusLfeContrib; // samples in Q19.12 format

    // sample at index 0 is FL

    // sample at index 1 is FR

    // sample at index 2 is FC

    // sample at index 3 is LFE

    // sample at index 4 is RL

    // sample at index 5 is RR

    // code is mostly duplicated between the two values of accumulate to avoid repeating the test

    // for every sample

    if (accumulate) {

        while (numFrames) {

            // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)

            centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)

                    + (pSrc[3] * MINUS_3_DB_IN_Q19_12);

            // FL + centerPlusLfeContrib + RL

            lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[4] << 12);

            // FR + centerPlusLfeContrib + RR

            rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[5] << 12);

            // accumulate in destination

            pDst[0] = clamp16(pDst[0] + (lt >> 13));

            pDst[1] = clamp16(pDst[1] + (rt >> 13));

            pSrc += 6;

            pDst += 2;

            numFrames--;

        }

    } else { // same code as above but without adding and clamping pDst[i] to itself

        while (numFrames) {

            // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)

            centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)

                    + (pSrc[3] * MINUS_3_DB_IN_Q19_12);

            // FL + centerPlusLfeContrib + RL

            lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[4] << 12);

            // FR + centerPlusLfeContrib + RR

            rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[5] << 12);

            // store in destination

            pDst[0] = clamp16(lt >> 13); // differs from when accumulate is true above

            pDst[1] = clamp16(rt >> 13); // differs from when accumulate is true above

            pSrc += 6;

            pDst += 2;

            numFrames--;

        }

    }

}

#else

void Downmix_foldFrom5Point1(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, bool accumulate) {

    LVM_FLOAT lt, rt, centerPlusLfeContrib; // samples in Q19.12 format

    // sample at index 0 is FL
@@ -1105,7 +923,6 @@ void Downmix_foldFrom5Point1(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, 
        }

    }

}

#endif



/*----------------------------------------------------------------------------

 * Downmix_foldFrom7Point1()
@@ -1124,54 +941,6 @@ void Downmix_foldFrom5Point1(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, 
 *

 *----------------------------------------------------------------------------

 */

#ifndef BUILD_FLOAT

void Downmix_foldFrom7Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {

    int32_t lt, rt, centerPlusLfeContrib; // samples in Q19.12 format

    // sample at index 0 is FL

    // sample at index 1 is FR

    // sample at index 2 is FC

    // sample at index 3 is LFE

    // sample at index 4 is RL

    // sample at index 5 is RR

    // sample at index 6 is SL

    // sample at index 7 is SR

    // code is mostly duplicated between the two values of accumulate to avoid repeating the test

    // for every sample

    if (accumulate) {

        while (numFrames) {

            // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)

            centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)

                    + (pSrc[3] * MINUS_3_DB_IN_Q19_12);

            // FL + centerPlusLfeContrib + SL + RL

            lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[6] << 12) + (pSrc[4] << 12);

            // FR + centerPlusLfeContrib + SR + RR

            rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[7] << 12) + (pSrc[5] << 12);

            //accumulate in destination

            pDst[0] = clamp16(pDst[0] + (lt >> 13));

            pDst[1] = clamp16(pDst[1] + (rt >> 13));

            pSrc += 8;

            pDst += 2;

            numFrames--;

    }

    } else { // same code as above but without adding and clamping pDst[i] to itself

        while (numFrames) {

            // centerPlusLfeContrib = FC(-3dB) + LFE(-3dB)

            centerPlusLfeContrib = (pSrc[2] * MINUS_3_DB_IN_Q19_12)

                    + (pSrc[3] * MINUS_3_DB_IN_Q19_12);

            // FL + centerPlusLfeContrib + SL + RL

            lt = (pSrc[0] << 12) + centerPlusLfeContrib + (pSrc[6] << 12) + (pSrc[4] << 12);

            // FR + centerPlusLfeContrib + SR + RR

            rt = (pSrc[1] << 12) + centerPlusLfeContrib + (pSrc[7] << 12) + (pSrc[5] << 12);

            // store in destination

            pDst[0] = clamp16(lt >> 13); // differs from when accumulate is true above

            pDst[1] = clamp16(rt >> 13); // differs from when accumulate is true above

            pSrc += 8;

            pDst += 2;

            numFrames--;

        }

    }

}

#else

void Downmix_foldFrom7Point1(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, bool accumulate) {

    LVM_FLOAT lt, rt, centerPlusLfeContrib; // samples in Q19.12 format

    // sample at index 0 is FL
@@ -1218,7 +987,7 @@ void Downmix_foldFrom7Point1(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, 
        }

    }

}

#endif



/*----------------------------------------------------------------------------

 * Downmix_foldGeneric()

 *----------------------------------------------------------------------------
@@ -1245,99 +1014,6 @@ void Downmix_foldFrom7Point1(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, 
 *

 *----------------------------------------------------------------------------

 */

#ifndef BUILD_FLOAT

bool Downmix_foldGeneric(

        uint32_t mask, int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate) {



    if (!Downmix_validChannelMask(mask)) {

        return false;

    }



    const bool hasSides = (mask & kSides) != 0;

    const bool hasBacks = (mask & kBacks) != 0;



    const int numChan = audio_channel_count_from_out_mask(mask);

    const bool hasFC = ((mask & AUDIO_CHANNEL_OUT_FRONT_CENTER) == AUDIO_CHANNEL_OUT_FRONT_CENTER);

    const bool hasLFE =

            ((mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY) == AUDIO_CHANNEL_OUT_LOW_FREQUENCY);

    const bool hasBC = ((mask & AUDIO_CHANNEL_OUT_BACK_CENTER) == AUDIO_CHANNEL_OUT_BACK_CENTER);

    // compute at what index each channel is: samples will be in the following order:

    //   FL FR FC LFE BL BR BC SL SR

    // when a channel is not present, its index is set to the same as the index of the preceding

    // channel

    const int indexFC  = hasFC    ? 2            : 1;        // front center

    const int indexLFE = hasLFE   ? indexFC + 1  : indexFC;  // low frequency

    const int indexBL  = hasBacks ? indexLFE + 1 : indexLFE; // back left

    const int indexBR  = hasBacks ? indexBL + 1  : indexBL;  // back right

    const int indexBC  = hasBC    ? indexBR + 1  : indexBR;  // back center

    const int indexSL  = hasSides ? indexBC + 1  : indexBC;  // side left

    const int indexSR  = hasSides ? indexSL + 1  : indexSL;  // side right



    int32_t lt, rt, centersLfeContrib; // samples in Q19.12 format

    // code is mostly duplicated between the two values of accumulate to avoid repeating the test

    // for every sample

    if (accumulate) {

        while (numFrames) {

            // compute contribution of FC, BC and LFE

            centersLfeContrib = 0;

            if (hasFC)  { centersLfeContrib += pSrc[indexFC]; }

            if (hasLFE) { centersLfeContrib += pSrc[indexLFE]; }

            if (hasBC)  { centersLfeContrib += pSrc[indexBC]; }

            centersLfeContrib *= MINUS_3_DB_IN_Q19_12;

            // always has FL/FR

            lt = (pSrc[0] << 12);

            rt = (pSrc[1] << 12);

            // mix in sides and backs

            if (hasSides) {

                lt += pSrc[indexSL] << 12;

                rt += pSrc[indexSR] << 12;

            }

            if (hasBacks) {

                lt += pSrc[indexBL] << 12;

                rt += pSrc[indexBR] << 12;

            }

            lt += centersLfeContrib;

            rt += centersLfeContrib;

            // accumulate in destination

            pDst[0] = clamp16(pDst[0] + (lt >> 13));

            pDst[1] = clamp16(pDst[1] + (rt >> 13));

            pSrc += numChan;

            pDst += 2;

            numFrames--;

        }

    } else {

        while (numFrames) {

            // compute contribution of FC, BC and LFE

            centersLfeContrib = 0;

            if (hasFC)  { centersLfeContrib += pSrc[indexFC]; }

            if (hasLFE) { centersLfeContrib += pSrc[indexLFE]; }

            if (hasBC)  { centersLfeContrib += pSrc[indexBC]; }

            centersLfeContrib *= MINUS_3_DB_IN_Q19_12;

            // always has FL/FR

            lt = (pSrc[0] << 12);

            rt = (pSrc[1] << 12);

            // mix in sides and backs

            if (hasSides) {

                lt += pSrc[indexSL] << 12;

                rt += pSrc[indexSR] << 12;

            }

            if (hasBacks) {

                lt += pSrc[indexBL] << 12;

                rt += pSrc[indexBR] << 12;

            }

            lt += centersLfeContrib;

            rt += centersLfeContrib;

            // store in destination

            pDst[0] = clamp16(lt >> 13); // differs from when accumulate is true above

            pDst[1] = clamp16(rt >> 13); // differs from when accumulate is true above

            pSrc += numChan;

            pDst += 2;

            numFrames--;

        }

    }

    return true;

}

#else

bool Downmix_foldGeneric(

        uint32_t mask, LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, bool accumulate) {
@@ -1429,4 +1105,3 @@ bool Downmix_foldGeneric( 
    }

    return true;

}
 
#endif

media/libeffects/downmix/EffectDownmix.h

+1 −10
Original line number Diff line number Diff line
@@ -27,9 +27,8 @@ 
*/



#define DOWNMIX_OUTPUT_CHANNELS AUDIO_CHANNEL_OUT_STEREO

#ifdef BUILD_FLOAT

#define LVM_FLOAT float

#endif



typedef enum {

    DOWNMIX_STATE_UNINITIALIZED,

    DOWNMIX_STATE_INITIALIZED,
@@ -97,18 +96,10 @@ int Downmix_Configure(downmix_module_t *pDwmModule, effect_config_t *pConfig, bo 
int Downmix_Reset(downmix_object_t *pDownmixer, bool init);

int Downmix_setParameter(downmix_object_t *pDownmixer, int32_t param, uint32_t size, void *pValue);

int Downmix_getParameter(downmix_object_t *pDownmixer, int32_t param, uint32_t *pSize, void *pValue);

#ifdef BUILD_FLOAT

void Downmix_foldFromQuad(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, bool accumulate);

void Downmix_foldFrom5Point1(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, bool accumulate);

void Downmix_foldFrom7Point1(LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, bool accumulate);

bool Downmix_foldGeneric(

        uint32_t mask, LVM_FLOAT *pSrc, LVM_FLOAT *pDst, size_t numFrames, bool accumulate);

#else

void Downmix_foldFromQuad(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);

void Downmix_foldFrom5Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);

void Downmix_foldFrom7Point1(int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);

bool Downmix_foldGeneric(

        uint32_t mask, int16_t *pSrc, int16_t*pDst, size_t numFrames, bool accumulate);

#endif



#endif /*ANDROID_EFFECTDOWNMIX_H_*/