mirror of
https://github.com/coop-deluxe/sm64coopdx.git
synced 2024-11-26 14:03:01 +00:00
342 lines
8.1 KiB
C
342 lines
8.1 KiB
C
/*
|
|
* Copyright (c) 2011 Apple Inc. All rights reserved.
|
|
*
|
|
* @APPLE_APACHE_LICENSE_HEADER_START@
|
|
*
|
|
* 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.
|
|
*
|
|
* @APPLE_APACHE_LICENSE_HEADER_END@
|
|
*/
|
|
|
|
/*
|
|
File: matrix_enc.c
|
|
|
|
Contains: ALAC mixing/matrixing encode routines.
|
|
|
|
Copyright: (c) 2004-2011 Apple, Inc.
|
|
*/
|
|
|
|
#include "matrixlib.h"
|
|
#include "ALACAudioTypes.h"
|
|
|
|
// up to 24-bit "offset" macros for the individual bytes of a 20/24-bit word
|
|
#if TARGET_RT_BIG_ENDIAN
|
|
#define LBYTE 2
|
|
#define MBYTE 1
|
|
#define HBYTE 0
|
|
#else
|
|
#define LBYTE 0
|
|
#define MBYTE 1
|
|
#define HBYTE 2
|
|
#endif
|
|
|
|
/*
|
|
There is no plain middle-side option; instead there are various mixing
|
|
modes including middle-side, each lossless, as embodied in the mix()
|
|
and unmix() functions. These functions exploit a generalized middle-side
|
|
transformation:
|
|
|
|
u := [(rL + (m-r)R)/m];
|
|
v := L - R;
|
|
|
|
where [ ] denotes integer floor. The (lossless) inverse is
|
|
|
|
L = u + v - [rV/m];
|
|
R = L - v;
|
|
*/
|
|
|
|
// 16-bit routines
|
|
|
|
void mix16( int16_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples, int32_t mixbits, int32_t mixres )
|
|
{
|
|
int16_t * ip = in;
|
|
int32_t j;
|
|
|
|
if ( mixres != 0 )
|
|
{
|
|
int32_t mod = 1 << mixbits;
|
|
int32_t m2;
|
|
|
|
/* matrixed stereo */
|
|
m2 = mod - mixres;
|
|
for ( j = 0; j < numSamples; j++ )
|
|
{
|
|
int32_t l, r;
|
|
|
|
l = (int32_t) ip[0];
|
|
r = (int32_t) ip[1];
|
|
ip += stride;
|
|
u[j] = (mixres * l + m2 * r) >> mixbits;
|
|
v[j] = l - r;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Conventional separated stereo. */
|
|
for ( j = 0; j < numSamples; j++ )
|
|
{
|
|
u[j] = (int32_t) ip[0];
|
|
v[j] = (int32_t) ip[1];
|
|
ip += stride;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 20-bit routines
|
|
// - the 20 bits of data are left-justified in 3 bytes of storage but right-aligned for input/output predictor buffers
|
|
|
|
void mix20( uint8_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples, int32_t mixbits, int32_t mixres )
|
|
{
|
|
int32_t l, r;
|
|
uint8_t * ip = in;
|
|
int32_t j;
|
|
|
|
if ( mixres != 0 )
|
|
{
|
|
/* matrixed stereo */
|
|
int32_t mod = 1 << mixbits;
|
|
int32_t m2 = mod - mixres;
|
|
|
|
for ( j = 0; j < numSamples; j++ )
|
|
{
|
|
l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
l = (l << 8) >> 12;
|
|
ip += 3;
|
|
|
|
r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
r = (r << 8) >> 12;
|
|
ip += (stride - 1) * 3;
|
|
|
|
u[j] = (mixres * l + m2 * r) >> mixbits;
|
|
v[j] = l - r;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Conventional separated stereo. */
|
|
for ( j = 0; j < numSamples; j++ )
|
|
{
|
|
l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
u[j] = (l << 8) >> 12;
|
|
ip += 3;
|
|
|
|
r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
v[j] = (r << 8) >> 12;
|
|
ip += (stride - 1) * 3;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 24-bit routines
|
|
// - the 24 bits of data are right-justified in the input/output predictor buffers
|
|
|
|
void mix24( uint8_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples,
|
|
int32_t mixbits, int32_t mixres, uint16_t * shiftUV, int32_t bytesShifted )
|
|
{
|
|
int32_t l, r;
|
|
uint8_t * ip = in;
|
|
int32_t shift = bytesShifted * 8;
|
|
uint32_t mask = (1ul << shift) - 1;
|
|
int32_t j, k;
|
|
|
|
if ( mixres != 0 )
|
|
{
|
|
/* matrixed stereo */
|
|
int32_t mod = 1 << mixbits;
|
|
int32_t m2 = mod - mixres;
|
|
|
|
if ( bytesShifted != 0 )
|
|
{
|
|
for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
|
|
{
|
|
l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
l = (l << 8) >> 8;
|
|
ip += 3;
|
|
|
|
r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
r = (r << 8) >> 8;
|
|
ip += (stride - 1) * 3;
|
|
|
|
shiftUV[k + 0] = (uint16_t)(l & mask);
|
|
shiftUV[k + 1] = (uint16_t)(r & mask);
|
|
|
|
l >>= shift;
|
|
r >>= shift;
|
|
|
|
u[j] = (mixres * l + m2 * r) >> mixbits;
|
|
v[j] = l - r;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( j = 0; j < numSamples; j++ )
|
|
{
|
|
l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
l = (l << 8) >> 8;
|
|
ip += 3;
|
|
|
|
r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
r = (r << 8) >> 8;
|
|
ip += (stride - 1) * 3;
|
|
|
|
u[j] = (mixres * l + m2 * r) >> mixbits;
|
|
v[j] = l - r;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Conventional separated stereo. */
|
|
if ( bytesShifted != 0 )
|
|
{
|
|
for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
|
|
{
|
|
l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
l = (l << 8) >> 8;
|
|
ip += 3;
|
|
|
|
r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
r = (r << 8) >> 8;
|
|
ip += (stride - 1) * 3;
|
|
|
|
shiftUV[k + 0] = (uint16_t)(l & mask);
|
|
shiftUV[k + 1] = (uint16_t)(r & mask);
|
|
|
|
l >>= shift;
|
|
r >>= shift;
|
|
|
|
u[j] = l;
|
|
v[j] = r;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for ( j = 0; j < numSamples; j++ )
|
|
{
|
|
l = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
u[j] = (l << 8) >> 8;
|
|
ip += 3;
|
|
|
|
r = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
v[j] = (r << 8) >> 8;
|
|
ip += (stride - 1) * 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 32-bit routines
|
|
// - note that these really expect the internal data width to be < 32 but the arrays are 32-bit
|
|
// - otherwise, the calculations might overflow into the 33rd bit and be lost
|
|
// - therefore, these routines deal with the specified "unused lower" bytes in the "shift" buffers
|
|
|
|
void mix32( int32_t * in, uint32_t stride, int32_t * u, int32_t * v, int32_t numSamples,
|
|
int32_t mixbits, int32_t mixres, uint16_t * shiftUV, int32_t bytesShifted )
|
|
{
|
|
int32_t * ip = in;
|
|
int32_t shift = bytesShifted * 8;
|
|
uint32_t mask = (1ul << shift) - 1;
|
|
int32_t l, r;
|
|
int32_t j, k;
|
|
|
|
if ( mixres != 0 )
|
|
{
|
|
int32_t mod = 1 << mixbits;
|
|
int32_t m2;
|
|
|
|
//Assert( bytesShifted != 0 );
|
|
|
|
/* matrixed stereo with shift */
|
|
m2 = mod - mixres;
|
|
for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
|
|
{
|
|
l = ip[0];
|
|
r = ip[1];
|
|
ip += stride;
|
|
|
|
shiftUV[k + 0] = (uint16_t)(l & mask);
|
|
shiftUV[k + 1] = (uint16_t)(r & mask);
|
|
|
|
l >>= shift;
|
|
r >>= shift;
|
|
|
|
u[j] = (mixres * l + m2 * r) >> mixbits;
|
|
v[j] = l - r;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( bytesShifted == 0 )
|
|
{
|
|
/* de-interleaving w/o shift */
|
|
for ( j = 0; j < numSamples; j++ )
|
|
{
|
|
u[j] = ip[0];
|
|
v[j] = ip[1];
|
|
ip += stride;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* de-interleaving with shift */
|
|
for ( j = 0, k = 0; j < numSamples; j++, k += 2 )
|
|
{
|
|
l = ip[0];
|
|
r = ip[1];
|
|
ip += stride;
|
|
|
|
shiftUV[k + 0] = (uint16_t)(l & mask);
|
|
shiftUV[k + 1] = (uint16_t)(r & mask);
|
|
|
|
l >>= shift;
|
|
r >>= shift;
|
|
|
|
u[j] = l;
|
|
v[j] = r;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 20/24-bit <-> 32-bit helper routines (not really matrixing but convenient to put here)
|
|
|
|
void copy20ToPredictor( uint8_t * in, uint32_t stride, int32_t * out, int32_t numSamples )
|
|
{
|
|
uint8_t * ip = in;
|
|
int32_t j;
|
|
|
|
for ( j = 0; j < numSamples; j++ )
|
|
{
|
|
int32_t val;
|
|
|
|
// 20-bit values are left-aligned in the 24-bit input buffer but right-aligned in the 32-bit output buffer
|
|
val = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
out[j] = (val << 8) >> 12;
|
|
ip += stride * 3;
|
|
}
|
|
}
|
|
|
|
void copy24ToPredictor( uint8_t * in, uint32_t stride, int32_t * out, int32_t numSamples )
|
|
{
|
|
uint8_t * ip = in;
|
|
int32_t j;
|
|
|
|
for ( j = 0; j < numSamples; j++ )
|
|
{
|
|
int32_t val;
|
|
|
|
val = (int32_t)( ((uint32_t)ip[HBYTE] << 16) | ((uint32_t)ip[MBYTE] << 8) | (uint32_t)ip[LBYTE] );
|
|
out[j] = (val << 8) >> 8;
|
|
ip += stride * 3;
|
|
}
|
|
}
|