stproc.hpp

Go to the documentation of this file.

/* ***** BEGIN LICENSE BLOCK ***** 
 * Version: RCSL 1.0/RPSL 1.0 
 *  
 * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
 *      
 * The contents of this file, and the files included with this file, are 
 * subject to the current version of the RealNetworks Public Source License 
 * Version 1.0 (the "RPSL") available at 
 * http://www.helixcommunity.org/content/rpsl unless you have licensed 
 * the file under the RealNetworks Community Source License Version 1.0 
 * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
 * in which case the RCSL will apply. You may also obtain the license terms 
 * directly from RealNetworks.  You may not use this file except in 
 * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
 * applicable to this file, the RCSL.  Please see the applicable RPSL or 
 * RCSL for the rights, obligations and limitations governing use of the 
 * contents of the file.  
 *  
 * This file is part of the Helix DNA Technology. RealNetworks is the 
 * developer of the Original Code and owns the copyrights in the portions 
 * it created. 
 *  
 * This file, and the files included with this file, is distributed and made 
 * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
 * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
 * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
 * 
 * Technology Compatibility Kit Test Suite(s) Location: 
 *    http://www.helixcommunity.org/content/tck 
 * 
 * Contributor(s): 
 *  
 * ***** END LICENSE BLOCK ***** */ 
 
/**************************************************************************************
 * Fixed-point MP3 decoder
 * Jon Recker (jrecker@real.com), Ken Cooke (kenc@real.com)
 * June 2003
 *
 * stproc.c - mid-side and intensity (MPEG1 and MPEG2) stereo processing
 **************************************************************************************/
 
#include "coder.h"
#include "fl/stl/stdint.h"
#include "fl/stl/noexcept.h"
#include "assembly.h"
 
namespace fl {
namespace third_party {
 
 
 
/**************************************************************************************
 * Function:    MidSideProc
 *
 * Description: sum-difference stereo reconstruction
 *
 * Inputs:      vector x with dequantized samples from left and right channels
 *              number of non-zero samples (MAX of left and right)
 *              assume 1 guard bit in input
 *              guard bit mask (left and right channels)
 *
 * Outputs:     updated sample vector x
 *              updated guard bit mask
 *
 * Return:      none
 *
 * Notes:       assume at least 1 GB in input
 **************************************************************************************/
void MidSideProc(int32_t x[MAX_NCHAN][MAX_NSAMP], int32_t nSamps, int32_t mOut[2]) FL_NOEXCEPT
{
    int32_t i, xr, xl, mOutL, mOutR;
    
    /* L = (M+S)/sqrt(2), R = (M-S)/sqrt(2) 
     * NOTE: 1/sqrt(2) done in DequantChannel() - see comments there
     */
    mOutL = mOutR = 0;
    for(i = 0; i < nSamps; i++) {
        xl = x[0][i];
        xr = x[1][i];
        x[0][i] = xl + xr;
        x[1][i] = xl - xr;
        mOutL |= FASTABS(x[0][i]);
        mOutR |= FASTABS(x[1][i]);
    }
    mOut[0] |= mOutL;
    mOut[1] |= mOutR;
}
 
/**************************************************************************************
 * Function:    IntensityProcMPEG1
 *
 * Description: intensity stereo processing for MPEG1
 *
 * Inputs:      vector x with dequantized samples from left and right channels
 *              number of non-zero samples in left channel
 *              valid FrameHeader struct
 *              two each of ScaleFactorInfoSub, CriticalBandInfo structs (both channels)
 *              flags indicating midSide on/off, mixedBlock on/off
 *              guard bit mask (left and right channels)
 *
 * Outputs:     updated sample vector x
 *              updated guard bit mask
 *
 * Return:      none
 *
 * Notes:       assume at least 1 GB in input
 *
 * TODO:        combine MPEG1/2 into one function (maybe)
 *              make sure all the mixed-block and IIP logic is right
 **************************************************************************************/
void IntensityProcMPEG1(int32_t x[MAX_NCHAN][MAX_NSAMP], int32_t nSamps, FrameHeader *fh, ScaleFactorInfoSub *sfis,
                        CriticalBandInfo *cbi, int32_t midSideFlag, int32_t mixFlag, int32_t mOut[2]) FL_NOEXCEPT
{
    (void)mixFlag;  // Unused parameter - reserved for future use
    int32_t i=0, j=0, n=0, cb=0, w=0;
    int32_t sampsLeft, isf, mOutL, mOutR, xl, xr;
    int32_t fl, fr, fls[3], frs[3];
    int32_t cbStartL=0, cbStartS=0, cbEndL=0, cbEndS=0;
    int32_t *isfTab;
    
    /* NOTE - this works fine for mixed blocks, as long as the switch point starts in the
     *  short block section (i.e. on or after sample 36 = sfBand->l[8] = 3*sfBand->s[3]
     * is this a safe assumption?
     * TODO - intensity + mixed not quite right (diff = 11 on he_mode)
     *  figure out correct implementation (spec ambiguous about when to do short block reorder)
     */
    if (cbi[1].cbType == 0) {
        /* long block */
        cbStartL = cbi[1].cbEndL + 1;
        cbEndL =   cbi[0].cbEndL + 1;
        cbStartS = cbEndS = 0;
        i = fh->sfBand->l[cbStartL];
    } else if (cbi[1].cbType == 1 || cbi[1].cbType == 2) {
        /* short or mixed block */
        cbStartS = cbi[1].cbEndSMax + 1;
        cbEndS =   cbi[0].cbEndSMax + 1;
        cbStartL = cbEndL = 0;
        i = 3 * fh->sfBand->s[cbStartS];
    }
 
    sampsLeft = nSamps - i;     /* process to length of left */
    isfTab = (int32_t *)ISFMpeg1[midSideFlag];
    mOutL = mOutR = 0;
 
    /* long blocks */
    for (cb = cbStartL; cb < cbEndL && sampsLeft > 0; cb++) {
        isf = sfis->l[cb];
        if (isf == 7) {
            fl = ISFIIP[midSideFlag][0];
            fr = ISFIIP[midSideFlag][1];
        } else {
            fl = isfTab[isf]; 
            fr = isfTab[6] - isfTab[isf];
        }
 
        n = fh->sfBand->l[cb + 1] - fh->sfBand->l[cb];
        for (j = 0; j < n && sampsLeft > 0; j++, i++) {
            xr = MULSHIFT32(fr, x[0][i]) << 2;   x[1][i] = xr; mOutR |= FASTABS(xr);
            xl = MULSHIFT32(fl, x[0][i]) << 2; x[0][i] = xl; mOutL |= FASTABS(xl);
            sampsLeft--;
        }
    }
 
    /* short blocks */
    for (cb = cbStartS; cb < cbEndS && sampsLeft >= 3; cb++) {
        for (w = 0; w < 3; w++) {
            isf = sfis->s[cb][w];
            if (isf == 7) {
                fls[w] = ISFIIP[midSideFlag][0];
                frs[w] = ISFIIP[midSideFlag][1];
            } else {
                fls[w] = isfTab[isf];
                frs[w] = isfTab[6] - isfTab[isf];
            }
        }
 
        n = fh->sfBand->s[cb + 1] - fh->sfBand->s[cb];
        for (j = 0; j < n && sampsLeft >= 3; j++, i+=3) {
            xr = MULSHIFT32(frs[0], x[0][i+0]) << 2; x[1][i+0] = xr;    mOutR |= FASTABS(xr);
            xl = MULSHIFT32(fls[0], x[0][i+0]) << 2; x[0][i+0] = xl;    mOutL |= FASTABS(xl);
            xr = MULSHIFT32(frs[1], x[0][i+1]) << 2; x[1][i+1] = xr;    mOutR |= FASTABS(xr);
            xl = MULSHIFT32(fls[1], x[0][i+1]) << 2; x[0][i+1] = xl;    mOutL |= FASTABS(xl);
            xr = MULSHIFT32(frs[2], x[0][i+2]) << 2; x[1][i+2] = xr;    mOutR |= FASTABS(xr);
            xl = MULSHIFT32(fls[2], x[0][i+2]) << 2; x[0][i+2] = xl;    mOutL |= FASTABS(xl);
            sampsLeft -= 3;
        }
    }
    mOut[0] = mOutL;
    mOut[1] = mOutR;
    
    return;
}
 
/**************************************************************************************
 * Function:    IntensityProcMPEG2
 *
 * Description: intensity stereo processing for MPEG2
 *
 * Inputs:      vector x with dequantized samples from left and right channels
 *              number of non-zero samples in left channel
 *              valid FrameHeader struct
 *              two each of ScaleFactorInfoSub, CriticalBandInfo structs (both channels)
 *              ScaleFactorJS struct with joint stereo info from UnpackSFMPEG2()
 *              flags indicating midSide on/off, mixedBlock on/off
 *              guard bit mask (left and right channels)
 *
 * Outputs:     updated sample vector x
 *              updated guard bit mask
 *
 * Return:      none
 *
 * Notes:       assume at least 1 GB in input
 *
 * TODO:        combine MPEG1/2 into one function (maybe)
 *              make sure all the mixed-block and IIP logic is right
 *                probably redo IIP logic to be simpler
 **************************************************************************************/
void IntensityProcMPEG2(int32_t x[MAX_NCHAN][MAX_NSAMP], int32_t nSamps, FrameHeader *fh, ScaleFactorInfoSub *sfis,
                        CriticalBandInfo *cbi, ScaleFactorJS *sfjs, int32_t midSideFlag, int32_t mixFlag, int32_t mOut[2]) FL_NOEXCEPT
{
    (void)mixFlag;  // Unused parameter - reserved for future use
    int32_t i, j, k, n, r, cb, w;
    int32_t fl, fr, mOutL, mOutR, xl, xr;
    int32_t sampsLeft;
    int32_t isf, sfIdx, tmp, il[23];
    int32_t *isfTab;
    int32_t cbStartL, cbStartS, cbEndL, cbEndS;
    
    isfTab = (int32_t *)ISFMpeg2[sfjs->intensityScale][midSideFlag];
    mOutL = mOutR = 0;
 
    /* fill buffer with illegal intensity positions (depending on slen) */
    for (k = r = 0; r < 4; r++) {
        tmp = (1 << sfjs->slen[r]) - 1;
        for (j = 0; j < sfjs->nr[r]; j++, k++) 
            il[k] = tmp;
    }
 
    if (cbi[1].cbType == 0) {
        /* long blocks */
        il[21] = il[22] = 1;
        cbStartL = cbi[1].cbEndL + 1;   /* start at end of right */
        cbEndL =   cbi[0].cbEndL + 1;   /* process to end of left */
        i = fh->sfBand->l[cbStartL];
        sampsLeft = nSamps - i;
 
        for(cb = cbStartL; cb < cbEndL; cb++) {
            sfIdx = sfis->l[cb];
            if (sfIdx == il[cb]) {
                fl = ISFIIP[midSideFlag][0];
                fr = ISFIIP[midSideFlag][1];
            } else {
                isf = (sfis->l[cb] + 1) >> 1;
                fl = isfTab[(sfIdx & 0x01 ? isf : 0)];
                fr = isfTab[(sfIdx & 0x01 ? 0 : isf)];
            }
            n = MIN(fh->sfBand->l[cb + 1] - fh->sfBand->l[cb], sampsLeft);
 
            for(j = 0; j < n; j++, i++) {
                xr = MULSHIFT32(fr, x[0][i]) << 2;   x[1][i] = xr;  mOutR |= FASTABS(xr);
                xl = MULSHIFT32(fl, x[0][i]) << 2; x[0][i] = xl;  mOutL |= FASTABS(xl);
            }
 
            /* early exit once we've used all the non-zero samples */
            sampsLeft -= n;
            if (sampsLeft == 0)     
                break;
        }
    } else {
        /* short or mixed blocks */
        il[12] = 1;
 
        for(w = 0; w < 3; w++) {
            cbStartS = cbi[1].cbEndS[w] + 1;        /* start at end of right */
            cbEndS =   cbi[0].cbEndS[w] + 1;        /* process to end of left */
            i = 3 * fh->sfBand->s[cbStartS] + w;
 
            /* skip through sample array by 3, so early-exit logic would be more tricky */
            for(cb = cbStartS; cb < cbEndS; cb++) {
                sfIdx = sfis->s[cb][w];
                if (sfIdx == il[cb]) {
                    fl = ISFIIP[midSideFlag][0];
                    fr = ISFIIP[midSideFlag][1];
                } else {
                    isf = (sfis->s[cb][w] + 1) >> 1;
                    fl = isfTab[(sfIdx & 0x01 ? isf : 0)];
                    fr = isfTab[(sfIdx & 0x01 ? 0 : isf)];
                }
                n = fh->sfBand->s[cb + 1] - fh->sfBand->s[cb];
 
                for(j = 0; j < n; j++, i+=3) {
                    xr = MULSHIFT32(fr, x[0][i]) << 2;   x[1][i] = xr;  mOutR |= FASTABS(xr);
                    xl = MULSHIFT32(fl, x[0][i]) << 2; x[0][i] = xl;  mOutL |= FASTABS(xl);
                }
            }
        }
    }
    mOut[0] = mOutL;
    mOut[1] = mOutR;
 
    return;
}
 
}  // namespace third_party
}  // namespace fl