www.pudn.com > helix.src.0812.rar > xfade.c
/* ***** 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 ***** */
#include
#include "xfade.h"
#include "math64.h"
#ifndef MIN
#define MIN(a,b) ((a)<=(b)?(a):(b))
#endif
#define HEADROOM 0
#define NALPHA 256
#define FRACBITS 16
#define EXTRABITS 8
#define FRACMASK ((1<nChannels = nChannels ;
instance->coeff = coeff ;
instance->tabacc = NALPHA << FRACBITS ; // end of fade
// make sure batchsize is divisible by nChannels
instance->batchSize = BATCHSIZE - BATCHSIZE % nChannels ;
}
return instance ;
}
void XFader_free(XFADER_STATE* instance)
{
if (instance) free(instance) ;
}
void XFader_start(int nSamples, XFADER_STATE* instance)
{
nSamples /= instance->nChannels ;
instance->tabacc = 0 ;
if (nSamples < 1) nSamples = 1 ;
// (tabstep * nSamples) >> FRACBITS = NALPHA
// instance->tabstep = ((NALPHA << FRACBITS) + nSamples - 1) / nSamples ; // round up
instance->tabstep = ((NALPHA << FRACBITS) + nSamples/2) / nSamples ; // round nearest
}
int XFader_active(XFADER_STATE* instance)
{
unsigned int tabacc = instance->tabacc ;
unsigned int tabint = tabacc >> FRACBITS ;
return (tabint < NALPHA) ;
}
/* In-place crossfading functionality currently untested */
#if 0
static int XFader_feed_mono(const INT32* in, INT32* inout, int nSamples, XFADER_STATE* instance)
{
int i ;
unsigned int tabacc = instance->tabacc ;
unsigned int tabstep = instance->tabstep ;
unsigned int tabint = tabacc >> FRACBITS ;
for (i = 0 ; i < nSamples && tabint < NALPHA ; i++)
{
INT32 gain1, gain2 ;
/* interpolate new alpha */
gain1 = instance->coeff[tabint].gain ;
gain1 += (instance->coeff[tabint].delta * (signed)(tabacc & FRACMASK)) >> (FRACBITS - EXTRABITS) ;
gain2 = instance->coeff[tabint+NALPHA+1].gain ;
gain2 += (instance->coeff[tabint+NALPHA+1].delta * (signed)(tabacc & FRACMASK)) >> (FRACBITS - EXTRABITS) ;
/* next table step */
tabacc += tabstep;
tabint = tabacc >> FRACBITS;
// creates one guard bit
*inout = MulShift31(*in++, gain1) + MulShift31(*inout, gain2) ;
inout++ ;
}
instance->tabacc = tabacc ;
return nSamples ;
}
static int XFader_feed_stereo(const INT32* in, INT32* inout, int nSamples, XFADER_STATE* instance)
{
int i ;
unsigned int tabacc = instance->tabacc ;
unsigned int tabstep = instance->tabstep ;
unsigned int tabint = tabacc >> FRACBITS ;
for (i = 0 ; i < nSamples && tabint < NALPHA ; i+=2)
{
INT32 gain1, gain2 ;
/* interpolate new alpha */
gain1 = instance->coeff[tabint].gain ;
gain1 += (instance->coeff[tabint].delta * (signed)(tabacc & FRACMASK)) >> (FRACBITS - EXTRABITS) ;
gain2 = instance->coeff[tabint+NALPHA+1].gain ;
gain2 += (instance->coeff[tabint+NALPHA+1].delta * (signed)(tabacc & FRACMASK)) >> (FRACBITS - EXTRABITS) ;
/* next table step */
tabacc += tabstep;
tabint = tabacc >> FRACBITS;
// creates one guard bit
*inout = MulShift31(*in++, gain1) + MulShift31(*inout, gain2) ;
inout++ ;
*inout = MulShift31(*in++, gain1) + MulShift31(*inout, gain2) ;
inout++ ;
}
instance->tabacc = tabacc ;
return nSamples ;
}
static const INT32 silence[BATCHSIZE] ; // a bunch of zeros
int XFader_feed(const INT32* in, INT32* inout, int nSamples, XFADER_STATE* instance)
{
int nRead = 0 ;
while (nRead < nSamples)
{
int nBatch = MIN(nSamples - nRead, instance->batchSize) ;
const INT32 *in1 = in ? (in + nRead) : silence ;
int i ;
switch (instance->nChannels)
{
case 1:
i = XFader_feed_mono (in1, inout + nRead, nBatch, instance) ;
break ;
case 2:
i = XFader_feed_stereo(in1, inout + nRead, nBatch, instance) ;
break ;
}
#if HEADROOM > 0
for (; i < nBatch ; i++)
{
inout[nRead + i] >>= HEADROOM ;
}
#endif
nRead += nBatch ;
}
return nSamples ;
}
#endif
int Fader_feed_mono(INT32 *inout, int nSamples, int fadeout, XFADER_STATE* instance)
{
int i ;
unsigned int tabacc = instance->tabacc ;
unsigned int tabstep = instance->tabstep ;
unsigned int tabint = tabacc >> FRACBITS ;
const struct COEFF *coeff = instance->coeff + (fadeout ? 0 : (NALPHA+1)) ;
for (i = 0 ; i < nSamples && tabint < NALPHA ; i++)
{
/* interpolate new alpha */
INT32 gain = coeff[tabint].gain ;
gain += (coeff[tabint].delta * (signed)(tabacc & FRACMASK)) >> (FRACBITS - EXTRABITS) ;
/* next table step */
tabacc += tabstep;
tabint = tabacc >> FRACBITS;
inout[0] = MulShift30(inout[0], gain) ;
inout++ ;
}
instance->tabacc = tabacc ;
return i ;
}
int Fader_feed_stereo(INT32 *inout, int nSamples, int fadeout, XFADER_STATE* instance)
{
int i ;
unsigned int tabacc = instance->tabacc ;
unsigned int tabstep = instance->tabstep ;
unsigned int tabint = tabacc >> FRACBITS ;
const struct COEFF *coeff = instance->coeff + (fadeout ? 0 : (NALPHA+1)) ;
for (i = 0 ; i < nSamples && tabint < NALPHA ; i+=2)
{
/* interpolate new alpha */
INT32 gain = coeff[tabint].gain ;
gain += (coeff[tabint].delta * (signed)(tabacc & FRACMASK)) >> (FRACBITS - EXTRABITS) ;
/* next table step */
tabacc += tabstep;
tabint = tabacc >> FRACBITS;
inout[0] = MulShift30(inout[0], gain) ;
inout[1] = MulShift30(inout[1], gain) ;
inout+=2 ;
}
instance->tabacc = tabacc ;
return i ;
}
int Fader_feed(INT32 *inout, int nSamples, int fadeout, XFADER_STATE* instance)
{
int i ;
ASSERT(fadeout ==1 || fadeout==0);
switch (instance->nChannels)
{
case 1:
i = Fader_feed_mono (inout, nSamples, fadeout, instance) ;
break ;
case 2:
i = Fader_feed_stereo(inout, nSamples, fadeout, instance) ;
break ;
}
if (fadeout)
for (; i < nSamples ; i++) inout[i] = 0 ;
#if HEADROOM > 0
else
for (; i < nSamples ; i++) inout[i] >>= HEADROOM ;
#endif
return nSamples ;
}
#if 0 // use just for table initialization
static void setupDelta(struct COEFF* c)
{
int i ;
for (i = 0 ; i < NALPHA ; i++)
{
c[i].delta = (c[i+1].gain - c[i].gain + (1<<(EXTRABITS-1))) >> EXTRABITS ;
assert(c[i].delta < (1<<(31-FRACBITS)));
c[i+NALPHA+1].delta = (c[i+NALPHA+2].gain - c[i+NALPHA+1].gain + (1<<(EXTRABITS-1))) >> EXTRABITS ;
assert(c[i+NALPHA+1].delta < (1<<(31-FRACBITS)));
}
c[i].delta = c[i+NALPHA+1].delta = 0 ;
}
#include
#include
#include
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
struct COEFF* sintab(void)
{
int i ;
struct COEFF* c = (struct COEFF*) calloc(NALPHA+1, 2*sizeof(struct COEFF)) ;
for (i = 0 ; i <= NALPHA ; i++)
{
double x = i * 0.5 * M_PI / NALPHA ;
double x1 = cos(x) ;
double x2 = sin(x) ;
x1 *= x1 ;
x2 *= x2 ;
c[i].gain = (int)floor(0.5 + x1*(1L<<(30-HEADROOM))) ;
c[i+NALPHA+1].gain = (int)floor(0.5 + x2*(1L<<(30-HEADROOM))) ;
}
setupDelta(c) ;
{
FILE *f = fopen("c:\\temp\\table.c","w") ;
fprintf(f,"const struct COEFF XFader_sin2tab[2*%d] = {\n /* fade out table */\n",
NALPHA+1) ;
for (i=0; i