1423 lines
48 KiB
Objective-C
1423 lines
48 KiB
Objective-C
//
|
|
// ConverterNode.m
|
|
// Cog
|
|
//
|
|
// Created by Zaphod Beeblebrox on 8/2/05.
|
|
// Copyright 2005 __MyCompanyName__. All rights reserved.
|
|
//
|
|
|
|
#import "ConverterNode.h"
|
|
|
|
#import "BufferChain.h"
|
|
#import "OutputNode.h"
|
|
|
|
#import "Logging.h"
|
|
|
|
#import <audio/conversion/s16_to_float.h>
|
|
#import <audio/conversion/s32_to_float.h>
|
|
|
|
#import "lpc.h"
|
|
#import "util.h"
|
|
|
|
#import "hdcd_decode2.h"
|
|
|
|
#import <TargetConditionals.h>
|
|
|
|
#if TARGET_CPU_X86 || TARGET_CPU_X86_64
|
|
#include <emmintrin.h>
|
|
#elif TARGET_CPU_ARM || TARGET_CPU_ARM64
|
|
#include <arm_neon.h>
|
|
#endif
|
|
|
|
void PrintStreamDesc (AudioStreamBasicDescription *inDesc)
|
|
{
|
|
if (!inDesc) {
|
|
DLog (@"Can't print a NULL desc!\n");
|
|
return;
|
|
}
|
|
DLog (@"- - - - - - - - - - - - - - - - - - - -\n");
|
|
DLog (@" Sample Rate:%f\n", inDesc->mSampleRate);
|
|
DLog (@" Format ID:%s\n", (char*)&inDesc->mFormatID);
|
|
DLog (@" Format Flags:%X\n", inDesc->mFormatFlags);
|
|
DLog (@" Bytes per Packet:%d\n", inDesc->mBytesPerPacket);
|
|
DLog (@" Frames per Packet:%d\n", inDesc->mFramesPerPacket);
|
|
DLog (@" Bytes per Frame:%d\n", inDesc->mBytesPerFrame);
|
|
DLog (@" Channels per Frame:%d\n", inDesc->mChannelsPerFrame);
|
|
DLog (@" Bits per Channel:%d\n", inDesc->mBitsPerChannel);
|
|
DLog (@"- - - - - - - - - - - - - - - - - - - -\n");
|
|
}
|
|
|
|
@implementation ConverterNode
|
|
|
|
@synthesize inputFormat;
|
|
|
|
- (id)initWithController:(id)c previous:(id)p
|
|
{
|
|
self = [super initWithController:c previous:p];
|
|
if (self)
|
|
{
|
|
rgInfo = nil;
|
|
|
|
resampler = NULL;
|
|
resampler_data = NULL;
|
|
inputBuffer = NULL;
|
|
inputBufferSize = 0;
|
|
floatBuffer = NULL;
|
|
floatBufferSize = 0;
|
|
|
|
stopping = NO;
|
|
convertEntered = NO;
|
|
paused = NO;
|
|
outputFormatChanged = NO;
|
|
|
|
skipResampler = YES;
|
|
|
|
refillNode = nil;
|
|
originalPreviousNode = nil;
|
|
|
|
extrapolateBuffer = NULL;
|
|
extrapolateBufferSize = 0;
|
|
|
|
dsd2pcm = NULL;
|
|
dsd2pcmCount = 0;
|
|
|
|
outputResampling = @"";
|
|
|
|
hdcd_decoder = NULL;
|
|
|
|
[[NSUserDefaultsController sharedUserDefaultsController] addObserver:self forKeyPath:@"values.volumeScaling" options:0 context:nil];
|
|
[[NSUserDefaultsController sharedUserDefaultsController] addObserver:self forKeyPath:@"values.outputResampling" options:0 context:nil];
|
|
[[NSUserDefaultsController sharedUserDefaultsController] addObserver:self forKeyPath:@"values.headphoneVirtualization" options:0 context:nil];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
static const float STEREO_DOWNMIX[8-2][8][2]={
|
|
/*3.0*/
|
|
{
|
|
{0.5858F,0.0F},{0.0F,0.5858F},{0.4142F,0.4142F}
|
|
},
|
|
/*quadrophonic*/
|
|
{
|
|
{0.4226F,0.0F},{0.0F,0.4226F},{0.366F,0.2114F},{0.2114F,0.336F}
|
|
},
|
|
/*5.0*/
|
|
{
|
|
{0.651F,0.0F},{0.0F,0.651F},{0.46F,0.46F},{0.5636F,0.3254F},
|
|
{0.3254F,0.5636F}
|
|
},
|
|
/*5.1*/
|
|
{
|
|
{0.529F,0.0F},{0.0F,0.529F},{0.3741F,0.3741F},{0.3741F,0.3741F},{0.4582F,0.2645F},
|
|
{0.2645F,0.4582F}
|
|
},
|
|
/*6.1*/
|
|
{
|
|
{0.4553F,0.0F},{0.0F,0.4553F},{0.322F,0.322F},{0.322F,0.322F},{0.2788F,0.2788F},
|
|
{0.3943F,0.2277F},{0.2277F,0.3943F}
|
|
},
|
|
/*7.1*/
|
|
{
|
|
{0.3886F,0.0F},{0.0F,0.3886F},{0.2748F,0.2748F},{0.2748F,0.2748F},{0.3366F,0.1943F},
|
|
{0.1943F,0.3366F},{0.3366F,0.1943F},{0.1943F,0.3366F}
|
|
}
|
|
};
|
|
|
|
static void downmix_to_stereo(float * buffer, int channels, size_t count)
|
|
{
|
|
if (channels >= 3 && channels <= 8)
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
float left = 0, right = 0;
|
|
for (int j = 0; j < channels; ++j)
|
|
{
|
|
left += buffer[i * channels + j] * STEREO_DOWNMIX[channels - 3][j][0];
|
|
right += buffer[i * channels + j] * STEREO_DOWNMIX[channels - 3][j][1];
|
|
}
|
|
buffer[i * 2 + 0] = left;
|
|
buffer[i * 2 + 1] = right;
|
|
}
|
|
}
|
|
|
|
static void downmix_to_mono(float * buffer, int channels, size_t count)
|
|
{
|
|
if (channels >= 3 && channels <= 8)
|
|
{
|
|
downmix_to_stereo(buffer, channels, count);
|
|
channels = 2;
|
|
}
|
|
float invchannels = 1.0 / (float)channels;
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
float sample = 0;
|
|
for (int j = 0; j < channels; ++j)
|
|
{
|
|
sample += buffer[i * channels + j];
|
|
}
|
|
buffer[i] = sample * invchannels;
|
|
}
|
|
}
|
|
|
|
static void upmix(float * buffer, int inchannels, int outchannels, size_t count)
|
|
{
|
|
for (ssize_t i = count - 1; i >= 0; --i)
|
|
{
|
|
if (inchannels == 1 && outchannels == 2)
|
|
{
|
|
// upmix mono to stereo
|
|
float sample = buffer[i];
|
|
buffer[i * 2 + 0] = sample;
|
|
buffer[i * 2 + 1] = sample;
|
|
}
|
|
else if (inchannels == 1 && outchannels == 4)
|
|
{
|
|
// upmix mono to quad
|
|
float sample = buffer[i];
|
|
buffer[i * 4 + 0] = sample;
|
|
buffer[i * 4 + 1] = sample;
|
|
buffer[i * 4 + 2] = 0;
|
|
buffer[i * 4 + 3] = 0;
|
|
}
|
|
else if (inchannels == 1 && (outchannels == 3 || outchannels >= 5))
|
|
{
|
|
// upmix mono to center channel
|
|
float sample = buffer[i];
|
|
buffer[i * outchannels + 2] = sample;
|
|
for (int j = 0; j < 2; ++j)
|
|
{
|
|
buffer[i * outchannels + j] = 0;
|
|
}
|
|
for (int j = 3; j < outchannels; ++j)
|
|
{
|
|
buffer[i * outchannels + j] = 0;
|
|
}
|
|
}
|
|
else if (inchannels == 4 && outchannels >= 5)
|
|
{
|
|
float fl = buffer[i * 4 + 0];
|
|
float fr = buffer[i * 4 + 1];
|
|
float bl = buffer[i * 4 + 2];
|
|
float br = buffer[i * 4 + 3];
|
|
const int skipclfe = (outchannels == 5) ? 1 : 2;
|
|
buffer[i * outchannels + 0] = fl;
|
|
buffer[i * outchannels + 1] = fr;
|
|
buffer[i * outchannels + skipclfe + 2] = bl;
|
|
buffer[i * outchannels + skipclfe + 3] = br;
|
|
for (int j = 0; j < skipclfe; ++j)
|
|
{
|
|
buffer[i * outchannels + 2 + j] = 0;
|
|
}
|
|
for (int j = 4 + skipclfe; j < outchannels; ++j)
|
|
{
|
|
buffer[i * outchannels + j] = 0;
|
|
}
|
|
}
|
|
else if (inchannels == 5 && outchannels >= 6)
|
|
{
|
|
float fl = buffer[i * 5 + 0];
|
|
float fr = buffer[i * 5 + 1];
|
|
float c = buffer[i * 5 + 2];
|
|
float bl = buffer[i * 5 + 3];
|
|
float br = buffer[i * 5 + 4];
|
|
buffer[i * outchannels + 0] = fl;
|
|
buffer[i * outchannels + 1] = fr;
|
|
buffer[i * outchannels + 2] = c;
|
|
buffer[i * outchannels + 3] = 0;
|
|
buffer[i * outchannels + 4] = bl;
|
|
buffer[i * outchannels + 5] = br;
|
|
for (int j = 6; j < outchannels; ++j)
|
|
{
|
|
buffer[i * outchannels + j] = 0;
|
|
}
|
|
}
|
|
else if (inchannels == 7 && outchannels == 8)
|
|
{
|
|
float fl = buffer[i * 7 + 0];
|
|
float fr = buffer[i * 7 + 1];
|
|
float c = buffer[i * 7 + 2];
|
|
float lfe = buffer[i * 7 + 3];
|
|
float sl = buffer[i * 7 + 4];
|
|
float sr = buffer[i * 7 + 5];
|
|
float bc = buffer[i * 7 + 6];
|
|
buffer[i * 8 + 0] = fl;
|
|
buffer[i * 8 + 1] = fr;
|
|
buffer[i * 8 + 2] = c;
|
|
buffer[i * 8 + 3] = lfe;
|
|
buffer[i * 8 + 4] = bc;
|
|
buffer[i * 8 + 5] = bc;
|
|
buffer[i * 8 + 6] = sl;
|
|
buffer[i * 8 + 7] = sr;
|
|
}
|
|
else
|
|
{
|
|
// upmix N channels to N channels plus silence the empty channels
|
|
float samples[inchannels];
|
|
for (int j = 0; j < inchannels; ++j)
|
|
{
|
|
samples[j] = buffer[i * inchannels + j];
|
|
}
|
|
for (int j = 0; j < inchannels; ++j)
|
|
{
|
|
buffer[i * outchannels + j] = samples[j];
|
|
}
|
|
for (int j = inchannels; j < outchannels; ++j)
|
|
{
|
|
buffer[i * outchannels + j] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void scale_by_volume(float * buffer, size_t count, float volume)
|
|
{
|
|
if ( volume != 1.0 )
|
|
{
|
|
#if TARGET_CPU_X86 || TARGET_CPU_X86_64
|
|
if ( count >= 8 )
|
|
{
|
|
__m128 vgf = _mm_set1_ps(volume);
|
|
while ( count >= 8 )
|
|
{
|
|
__m128 input = _mm_loadu_ps(buffer);
|
|
__m128 input2 = _mm_loadu_ps(buffer + 4);
|
|
__m128 output = _mm_mul_ps(input, vgf);
|
|
__m128 output2 = _mm_mul_ps(input2, vgf);
|
|
|
|
_mm_storeu_ps(buffer + 0, output);
|
|
_mm_storeu_ps(buffer + 4, output2);
|
|
|
|
buffer += 8;
|
|
count -= 8;
|
|
}
|
|
}
|
|
#elif TARGET_CPU_ARM || TARGET_CPU_ARM64
|
|
if ( count >= 8 )
|
|
{
|
|
float32x4_t vgf = vdupq_n_f32(volume);
|
|
while ( count >= 8 )
|
|
{
|
|
float32x4x2_t oreg;
|
|
float32x4x2_t inreg = vld1q_f32_x2(buffer);
|
|
oreg.val[0] = vmulq_f32(inreg.val[0], vgf);
|
|
oreg.val[1] = vmulq_f32(inreg.val[1], vgf);
|
|
vst1q_f32_x2(buffer, oreg);
|
|
buffer += 8;
|
|
count -= 8;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
for (size_t i = 0; i < count; ++i)
|
|
buffer[i] *= volume;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* DSD 2 PCM: Stage 1:
|
|
* Decimate by factor 8
|
|
* (one byte (8 samples) -> one float sample)
|
|
* The bits are processed from least signicifant to most signicicant.
|
|
* @author Sebastian Gesemann
|
|
*/
|
|
|
|
#define dsd2pcm_FILTER_COEFFS_COUNT 64
|
|
static const float dsd2pcm_FILTER_COEFFS[64] =
|
|
{
|
|
0.09712411121659f, 0.09613438994044f, 0.09417884216316f, 0.09130441727307f,
|
|
0.08757947648990f, 0.08309142055179f, 0.07794369263673f, 0.07225228745463f,
|
|
0.06614191680338f, 0.05974199351302f, 0.05318259916599f, 0.04659059631228f,
|
|
0.04008603356890f, 0.03377897290478f, 0.02776684382775f, 0.02213240062966f,
|
|
0.01694232798846f, 0.01224650881275f, 0.00807793792573f, 0.00445323755944f,
|
|
0.00137370697215f,-0.00117318019994f,-0.00321193033831f,-0.00477694265140f,
|
|
-0.00591028841335f,-0.00665946056286f,-0.00707518873201f,-0.00720940203988f,
|
|
-0.00711340642819f,-0.00683632603227f,-0.00642384017266f,-0.00591723006715f,
|
|
-0.00535273320457f,-0.00476118922548f,-0.00416794965654f,-0.00359301524813f,
|
|
-0.00305135909510f,-0.00255339111833f,-0.00210551956895f,-0.00171076760278f,
|
|
-0.00136940723130f,-0.00107957856005f,-0.00083786862365f,-0.00063983084245f,
|
|
-0.00048043272086f,-0.00035442550015f,-0.00025663481039f,-0.00018217573430f,
|
|
-0.00012659899635f,-0.00008597726991f,-0.00005694188820f,-0.00003668060332f,
|
|
-0.00002290670286f,-0.00001380895679f,-0.00000799057558f,-0.00000440385083f,
|
|
-0.00000228567089f,-0.00000109760778f,-0.00000047286430f,-0.00000017129652f,
|
|
-0.00000004282776f, 0.00000000119422f, 0.00000000949179f, 0.00000000747450f
|
|
};
|
|
|
|
struct dsd2pcm_state {
|
|
/*
|
|
* This is the 2nd half of an even order symmetric FIR
|
|
* lowpass filter (to be used on a signal sampled at 44100*64 Hz)
|
|
* Passband is 0-24 kHz (ripples +/- 0.025 dB)
|
|
* Stopband starts at 176.4 kHz (rejection: 170 dB)
|
|
* The overall gain is 2.0
|
|
*/
|
|
|
|
/* These remain constant for the duration */
|
|
int FILT_LOOKUP_PARTS;
|
|
float * FILT_LOOKUP_TABLE;
|
|
uint8_t * REVERSE_BITS;
|
|
int FIFO_LENGTH;
|
|
int FIFO_OFS_MASK;
|
|
|
|
/* These are altered */
|
|
int * fifo;
|
|
int fpos;
|
|
};
|
|
|
|
static void dsd2pcm_free(void *);
|
|
static void dsd2pcm_reset(void *);
|
|
|
|
static void * dsd2pcm_alloc()
|
|
{
|
|
struct dsd2pcm_state * state = (struct dsd2pcm_state *) calloc(1, sizeof(struct dsd2pcm_state));
|
|
|
|
if (!state)
|
|
return NULL;
|
|
|
|
state->FILT_LOOKUP_PARTS = ( dsd2pcm_FILTER_COEFFS_COUNT + 7 ) / 8;
|
|
const int FILT_LOOKUP_PARTS = state->FILT_LOOKUP_PARTS;
|
|
// The current 128 tap FIR leads to an 8 KB lookup table
|
|
state->FILT_LOOKUP_TABLE = (float*) calloc(sizeof(float), FILT_LOOKUP_PARTS << 8);
|
|
if (!state->FILT_LOOKUP_TABLE)
|
|
goto fail;
|
|
float* FILT_LOOKUP_TABLE = state->FILT_LOOKUP_TABLE;
|
|
double * temp = (double*) calloc(sizeof(double), 0x100);
|
|
if (!temp)
|
|
goto fail;
|
|
for ( int part=0, sofs=0, dofs=0; part < FILT_LOOKUP_PARTS; )
|
|
{
|
|
memset( temp, 0, 0x100 * sizeof( double ) );
|
|
for ( int bit=0, bitmask=0x80; bit<8 && sofs+bit < dsd2pcm_FILTER_COEFFS_COUNT; )
|
|
{
|
|
double coeff = dsd2pcm_FILTER_COEFFS[ sofs + bit ];
|
|
for ( int bite=0; bite < 0x100; bite++ )
|
|
{
|
|
if ( ( bite & bitmask ) == 0 )
|
|
{
|
|
temp[ bite ] -= coeff;
|
|
} else {
|
|
temp[ bite ] += coeff;
|
|
}
|
|
}
|
|
bit++;
|
|
bitmask >>= 1;
|
|
}
|
|
for ( int s = 0; s < 0x100; ) {
|
|
FILT_LOOKUP_TABLE[dofs++] = (float) temp[s++];
|
|
}
|
|
part++;
|
|
sofs += 8;
|
|
}
|
|
free(temp);
|
|
{ // calculate FIFO stuff
|
|
int k = 1;
|
|
while (k<FILT_LOOKUP_PARTS*2) k<<=1;
|
|
state->FIFO_LENGTH = k;
|
|
state->FIFO_OFS_MASK = k-1;
|
|
}
|
|
state->REVERSE_BITS = (uint8_t*) calloc(1, 0x100);
|
|
if (!state->REVERSE_BITS)
|
|
goto fail;
|
|
uint8_t* REVERSE_BITS = state->REVERSE_BITS;
|
|
for (int i=0, j=0; i<0x100; i++) {
|
|
REVERSE_BITS[i] = ( uint8_t ) j;
|
|
// "reverse-increment" of j
|
|
for (int bitmask=0x80;;) {
|
|
if (((j^=bitmask) & bitmask)!=0) break;
|
|
if (bitmask==1) break;
|
|
bitmask >>= 1;
|
|
}
|
|
}
|
|
|
|
state->fifo = (int*) calloc(sizeof(int), state->FIFO_LENGTH);
|
|
if (!state->fifo)
|
|
goto fail;
|
|
|
|
dsd2pcm_reset(state);
|
|
|
|
return (void*) state;
|
|
|
|
fail:
|
|
dsd2pcm_free(state);
|
|
return NULL;
|
|
}
|
|
|
|
static void * dsd2pcm_dup(void * _state)
|
|
{
|
|
struct dsd2pcm_state * state = (struct dsd2pcm_state *) _state;
|
|
if (state)
|
|
{
|
|
struct dsd2pcm_state * newstate = (struct dsd2pcm_state *) calloc(1, sizeof(struct dsd2pcm_state));
|
|
if (newstate) {
|
|
newstate->FILT_LOOKUP_PARTS = state->FILT_LOOKUP_PARTS;
|
|
newstate->FIFO_LENGTH = state->FIFO_LENGTH;
|
|
newstate->FIFO_OFS_MASK = state->FIFO_OFS_MASK;
|
|
newstate->fpos = state->fpos;
|
|
|
|
newstate->FILT_LOOKUP_TABLE = (float*) calloc(sizeof(float), state->FILT_LOOKUP_PARTS << 8);
|
|
if (!newstate->FILT_LOOKUP_TABLE)
|
|
goto fail;
|
|
|
|
memcpy(newstate->FILT_LOOKUP_TABLE, state->FILT_LOOKUP_TABLE, sizeof(float) * (state->FILT_LOOKUP_PARTS << 8));
|
|
|
|
newstate->REVERSE_BITS = (uint8_t*) calloc(1, 0x100);
|
|
if (!newstate->REVERSE_BITS)
|
|
goto fail;
|
|
|
|
memcpy(newstate->REVERSE_BITS, state->REVERSE_BITS, 0x100);
|
|
|
|
newstate->fifo = (int*) calloc(sizeof(int), state->FIFO_LENGTH);
|
|
if (!newstate->fifo)
|
|
goto fail;
|
|
|
|
memcpy(newstate->fifo, state->fifo, sizeof(int) * state->FIFO_LENGTH);
|
|
|
|
return (void*) newstate;
|
|
}
|
|
|
|
fail:
|
|
dsd2pcm_free(newstate);
|
|
return NULL;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void dsd2pcm_free(void * _state)
|
|
{
|
|
struct dsd2pcm_state * state = (struct dsd2pcm_state *) _state;
|
|
if (state)
|
|
{
|
|
free(state->fifo);
|
|
free(state->REVERSE_BITS);
|
|
free(state->FILT_LOOKUP_TABLE);
|
|
free(state);
|
|
}
|
|
}
|
|
|
|
static void dsd2pcm_reset(void * _state)
|
|
{
|
|
struct dsd2pcm_state * state = (struct dsd2pcm_state *) _state;
|
|
const int FILT_LOOKUP_PARTS = state->FILT_LOOKUP_PARTS;
|
|
int* fifo = state->fifo;
|
|
for (int i=0; i<FILT_LOOKUP_PARTS; i++) {
|
|
fifo[i] = 0x55;
|
|
fifo[i+FILT_LOOKUP_PARTS] = 0xAA;
|
|
}
|
|
state->fpos = FILT_LOOKUP_PARTS;
|
|
}
|
|
|
|
static int dsd2pcm_latency(void * _state)
|
|
{
|
|
struct dsd2pcm_state * state = (struct dsd2pcm_state *) _state;
|
|
if (state) return state->FIFO_LENGTH;
|
|
else return 0;
|
|
}
|
|
|
|
static void dsd2pcm_process(void * _state, uint8_t * src, size_t sofs, size_t sinc, float * dest, size_t dofs, size_t dinc, size_t len)
|
|
{
|
|
struct dsd2pcm_state * state = (struct dsd2pcm_state *) _state;
|
|
int bite1, bite2, temp;
|
|
float sample;
|
|
int* fifo = state->fifo;
|
|
const uint8_t* REVERSE_BITS = state->REVERSE_BITS;
|
|
const float* FILT_LOOKUP_TABLE = state->FILT_LOOKUP_TABLE;
|
|
const int FILT_LOOKUP_PARTS = state->FILT_LOOKUP_PARTS;
|
|
const int FIFO_OFS_MASK = state->FIFO_OFS_MASK;
|
|
int fpos = state->fpos;
|
|
while ( len > 0 )
|
|
{
|
|
fifo[ fpos ] = REVERSE_BITS[ fifo[ fpos ] ] & 0xFF;
|
|
fifo[ ( fpos + FILT_LOOKUP_PARTS ) & FIFO_OFS_MASK ] = src[ sofs ] & 0xFF;
|
|
sofs += sinc;
|
|
temp = ( fpos + 1 ) & FIFO_OFS_MASK;
|
|
sample = 0;
|
|
for ( int k=0, lofs=0; k < FILT_LOOKUP_PARTS; )
|
|
{
|
|
bite1 = fifo[ ( fpos - k ) & FIFO_OFS_MASK ];
|
|
bite2 = fifo[ ( temp + k ) & FIFO_OFS_MASK ];
|
|
sample += FILT_LOOKUP_TABLE[ lofs + bite1 ] + FILT_LOOKUP_TABLE[ lofs + bite2 ];
|
|
k++;
|
|
lofs += 0x100;
|
|
}
|
|
fpos = temp;
|
|
dest[ dofs ] = sample;
|
|
dofs += dinc;
|
|
len--;
|
|
}
|
|
state->fpos = fpos;
|
|
}
|
|
|
|
static void convert_dsd_to_f32(float *output, const uint8_t *input, size_t count, size_t channels, void ** dsd2pcm)
|
|
{
|
|
for (size_t channel = 0; channel < channels; ++channel)
|
|
{
|
|
dsd2pcm_process(dsd2pcm[channel], input, channel, channels, output, channel, channels, count);
|
|
}
|
|
}
|
|
|
|
static void convert_u8_to_s16(int16_t *output, const uint8_t *input, size_t count)
|
|
{
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
uint16_t sample = (input[i] << 8) | input[i];
|
|
sample ^= 0x8080;
|
|
output[i] = (int16_t)(sample);
|
|
}
|
|
}
|
|
|
|
static void convert_s8_to_s16(int16_t *output, const uint8_t *input, size_t count)
|
|
{
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
uint16_t sample = (input[i] << 8) | input[i];
|
|
output[i] = (int16_t)(sample);
|
|
}
|
|
}
|
|
|
|
static void convert_u16_to_s16(int16_t *buffer, size_t count)
|
|
{
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
buffer[i] ^= 0x8000;
|
|
}
|
|
}
|
|
|
|
static void convert_s16_to_hdcd_input(int32_t *output, const int16_t *input, size_t count)
|
|
{
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
output[i] = input[i];
|
|
}
|
|
}
|
|
|
|
static void convert_s24_to_s32(int32_t *output, const uint8_t *input, size_t count)
|
|
{
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
int32_t sample = (input[i * 3] << 8) | (input[i * 3 + 1] << 16) | (input[i * 3 + 2] << 24);
|
|
output[i] = sample;
|
|
}
|
|
}
|
|
|
|
static void convert_u24_to_s32(int32_t *output, const uint8_t *input, size_t count)
|
|
{
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
int32_t sample = (input[i * 3] << 8) | (input[i * 3 + 1] << 16) | (input[i * 3 + 2] << 24);
|
|
output[i] = sample ^ 0x80000000;
|
|
}
|
|
}
|
|
|
|
static void convert_u32_to_s32(int32_t *buffer, size_t count)
|
|
{
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
buffer[i] ^= 0x80000000;
|
|
}
|
|
}
|
|
|
|
static void convert_f64_to_f32(float *output, const double *input, size_t count)
|
|
{
|
|
for (size_t i = 0; i < count; ++i)
|
|
{
|
|
output[i] = (float)(input[i]);
|
|
}
|
|
}
|
|
|
|
static void convert_be_to_le(uint8_t *buffer, size_t bitsPerSample, size_t bytes)
|
|
{
|
|
size_t i;
|
|
uint8_t temp;
|
|
bitsPerSample = (bitsPerSample + 7) / 8;
|
|
switch (bitsPerSample) {
|
|
case 2:
|
|
for (i = 0; i < bytes; i += 2)
|
|
{
|
|
temp = buffer[1];
|
|
buffer[1] = buffer[0];
|
|
buffer[0] = temp;
|
|
buffer += 2;
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
for (i = 0; i < bytes; i += 3)
|
|
{
|
|
temp = buffer[2];
|
|
buffer[2] = buffer[0];
|
|
buffer[0] = temp;
|
|
buffer += 3;
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
for (i = 0; i < bytes; i += 4)
|
|
{
|
|
temp = buffer[3];
|
|
buffer[3] = buffer[0];
|
|
buffer[0] = temp;
|
|
temp = buffer[2];
|
|
buffer[2] = buffer[1];
|
|
buffer[1] = temp;
|
|
buffer += 4;
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
for (i = 0; i < bytes; i += 8)
|
|
{
|
|
temp = buffer[7];
|
|
buffer[7] = buffer[0];
|
|
buffer[0] = temp;
|
|
temp = buffer[6];
|
|
buffer[6] = buffer[1];
|
|
buffer[1] = temp;
|
|
temp = buffer[5];
|
|
buffer[5] = buffer[2];
|
|
buffer[2] = temp;
|
|
temp = buffer[4];
|
|
buffer[4] = buffer[3];
|
|
buffer[3] = temp;
|
|
buffer += 8;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
-(void)process
|
|
{
|
|
char writeBuf[CHUNK_SIZE];
|
|
|
|
// Removed endOfStream check from here, since we want to be able to flush the converter
|
|
// when the end of stream is reached. Convert function instead processes what it can,
|
|
// and returns 0 samples when it has nothing more to process at the end of stream.
|
|
while ([self shouldContinue] == YES)
|
|
{
|
|
int amountConverted = [self convert:writeBuf amount:CHUNK_SIZE];
|
|
if (!amountConverted)
|
|
{
|
|
if (paused)
|
|
{
|
|
while (paused)
|
|
usleep(500);
|
|
continue;
|
|
}
|
|
else if (refillNode)
|
|
{
|
|
// refill node just ended, file resumes
|
|
[self setPreviousNode:originalPreviousNode];
|
|
[self setEndOfStream:NO];
|
|
[self setShouldContinue:YES];
|
|
refillNode = nil;
|
|
[self cleanUp];
|
|
[self setupWithInputFormat:rememberedInputFormat outputFormat:outputFormat isLossless:rememberedLossless];
|
|
continue;
|
|
}
|
|
else break;
|
|
}
|
|
[self writeData:writeBuf amount:amountConverted];
|
|
}
|
|
}
|
|
|
|
- (int)convert:(void *)dest amount:(int)amount
|
|
{
|
|
UInt32 ioNumberPackets;
|
|
int amountReadFromFC;
|
|
int amountRead = 0;
|
|
int amountToSkip;
|
|
|
|
if (stopping)
|
|
return 0;
|
|
|
|
convertEntered = YES;
|
|
|
|
tryagain:
|
|
if (stopping || [self shouldContinue] == NO)
|
|
{
|
|
convertEntered = NO;
|
|
return amountRead;
|
|
}
|
|
|
|
amountReadFromFC = 0;
|
|
|
|
if (floatOffset == floatSize) // skip this step if there's still float buffered
|
|
while (inpOffset == inpSize) {
|
|
size_t samplesRead = 0;
|
|
|
|
BOOL isFloat = !!(inputFormat.mFormatFlags & kAudioFormatFlagIsFloat);
|
|
BOOL isUnsigned = !isFloat && !(inputFormat.mFormatFlags & kAudioFormatFlagIsSignedInteger);
|
|
|
|
// Approximately the most we want on input
|
|
ioNumberPackets = (amount - amountRead) / outputFormat.mBytesPerPacket;
|
|
if (!skipResampler && ioNumberPackets < PRIME_LEN_)
|
|
ioNumberPackets = PRIME_LEN_;
|
|
|
|
// We want to upscale this count if the ratio is below zero
|
|
if (sampleRatio < 1.0)
|
|
{
|
|
ioNumberPackets = ((uint32_t)(ioNumberPackets / sampleRatio) + 15) & ~15;
|
|
}
|
|
|
|
amountToSkip = 0;
|
|
if (dsd2pcm && !is_preextrapolated_) {
|
|
amountToSkip = dsd2pcmLatency * inputFormat.mBytesPerPacket;
|
|
ioNumberPackets += dsd2pcmLatency;
|
|
}
|
|
|
|
size_t newSize = ioNumberPackets * floatFormat.mBytesPerPacket;
|
|
if (!inputBuffer || inputBufferSize < newSize)
|
|
inputBuffer = realloc( inputBuffer, inputBufferSize = newSize * 3 );
|
|
|
|
ssize_t amountToWrite = ioNumberPackets * inputFormat.mBytesPerPacket;
|
|
amountToWrite -= amountToSkip;
|
|
|
|
ssize_t bytesReadFromInput = 0;
|
|
|
|
while (bytesReadFromInput < amountToWrite && !stopping && [self shouldContinue] == YES && [self endOfStream] == NO)
|
|
{
|
|
size_t bytesRead = [self readData:inputBuffer + amountToSkip + bytesReadFromInput amount:(int)(amountToWrite - bytesReadFromInput)];
|
|
bytesReadFromInput += bytesRead;
|
|
if (!bytesRead)
|
|
{
|
|
if (refillNode)
|
|
[self setEndOfStream:YES];
|
|
else
|
|
usleep(500);
|
|
}
|
|
}
|
|
|
|
// Pad end of track with input format silence
|
|
|
|
if (stopping || [self shouldContinue] == NO || [self endOfStream] == YES)
|
|
{
|
|
if (!skipResampler && !is_postextrapolated_)
|
|
{
|
|
if (dsd2pcm) {
|
|
amountToSkip = dsd2pcmLatency * inputFormat.mBytesPerPacket;
|
|
memset(inputBuffer + bytesReadFromInput, 0x55, amountToSkip);
|
|
bytesReadFromInput += amountToSkip;
|
|
amountToSkip = 0;
|
|
}
|
|
is_postextrapolated_ = 1;
|
|
}
|
|
else if (!is_postextrapolated_ && dsd2pcm) {
|
|
is_postextrapolated_ = 3;
|
|
}
|
|
}
|
|
|
|
if (!bytesReadFromInput) {
|
|
convertEntered = NO;
|
|
return amountRead;
|
|
}
|
|
|
|
bytesReadFromInput += amountToSkip;
|
|
|
|
if (dsd2pcm && amountToSkip) {
|
|
memset(inputBuffer, 0x55, amountToSkip);
|
|
dsdLatencyEaten = (int)ceil(dsd2pcmLatency * sampleRatio);
|
|
}
|
|
|
|
if (bytesReadFromInput &&
|
|
(inputFormat.mFormatFlags & kAudioFormatFlagIsBigEndian))
|
|
{
|
|
// Time for endian swap!
|
|
convert_be_to_le(inputBuffer, inputFormat.mBitsPerChannel, bytesReadFromInput);
|
|
}
|
|
|
|
if (bytesReadFromInput && isFloat && inputFormat.mBitsPerChannel == 64)
|
|
{
|
|
// Time for precision loss from weird inputs
|
|
samplesRead = bytesReadFromInput / sizeof(double);
|
|
convert_f64_to_f32(inputBuffer + bytesReadFromInput, inputBuffer, samplesRead);
|
|
memmove(inputBuffer, inputBuffer + bytesReadFromInput, samplesRead * sizeof(float));
|
|
bytesReadFromInput = samplesRead * sizeof(float);
|
|
}
|
|
|
|
if (bytesReadFromInput && !isFloat)
|
|
{
|
|
float gain = 1.0;
|
|
size_t bitsPerSample = inputFormat.mBitsPerChannel;
|
|
if (bitsPerSample == 1) {
|
|
samplesRead = bytesReadFromInput / inputFormat.mBytesPerPacket;
|
|
convert_dsd_to_f32(inputBuffer + bytesReadFromInput, inputBuffer, samplesRead, inputFormat.mChannelsPerFrame, dsd2pcm);
|
|
memmove(inputBuffer, inputBuffer + bytesReadFromInput, samplesRead * inputFormat.mChannelsPerFrame * sizeof(float));
|
|
bitsPerSample = 32;
|
|
bytesReadFromInput = samplesRead * inputFormat.mChannelsPerFrame * sizeof(float);
|
|
isFloat = YES;
|
|
}
|
|
else if (bitsPerSample <= 8) {
|
|
samplesRead = bytesReadFromInput;
|
|
if (!isUnsigned)
|
|
convert_s8_to_s16(inputBuffer + bytesReadFromInput, inputBuffer, samplesRead);
|
|
else
|
|
convert_u8_to_s16(inputBuffer + bytesReadFromInput, inputBuffer, samplesRead);
|
|
memmove(inputBuffer, inputBuffer + bytesReadFromInput, samplesRead * 2);
|
|
bitsPerSample = 16;
|
|
bytesReadFromInput = samplesRead * 2;
|
|
isUnsigned = NO;
|
|
}
|
|
if (hdcd_decoder) { // implied bits per sample is 16, produces 32 bit int scale
|
|
samplesRead = bytesReadFromInput / 2;
|
|
if (isUnsigned)
|
|
convert_u16_to_s16(inputBuffer, samplesRead);
|
|
convert_s16_to_hdcd_input(inputBuffer + bytesReadFromInput, inputBuffer, samplesRead);
|
|
memmove(inputBuffer, inputBuffer + bytesReadFromInput, samplesRead * 4);
|
|
hdcd_process_stereo((hdcd_state_stereo_t *)hdcd_decoder, inputBuffer, (int)(samplesRead / 2));
|
|
if (((hdcd_state_stereo_t*)hdcd_decoder)->channel[0].sustain &&
|
|
((hdcd_state_stereo_t*)hdcd_decoder)->channel[1].sustain) {
|
|
[controller sustainHDCD];
|
|
}
|
|
gain = 2.0;
|
|
bitsPerSample = 32;
|
|
bytesReadFromInput = samplesRead * 4;
|
|
isUnsigned = NO;
|
|
}
|
|
else if (bitsPerSample <= 16) {
|
|
samplesRead = bytesReadFromInput / 2;
|
|
if (isUnsigned)
|
|
convert_u16_to_s16(inputBuffer, samplesRead);
|
|
convert_s16_to_float(inputBuffer + bytesReadFromInput, inputBuffer, samplesRead, 1.0);
|
|
memmove(inputBuffer, inputBuffer + bytesReadFromInput, samplesRead * sizeof(float));
|
|
bitsPerSample = 32;
|
|
bytesReadFromInput = samplesRead * sizeof(float);
|
|
isUnsigned = NO;
|
|
isFloat = YES;
|
|
}
|
|
else if (bitsPerSample <= 24) {
|
|
samplesRead = bytesReadFromInput / 3;
|
|
if (isUnsigned)
|
|
convert_u24_to_s32(inputBuffer + bytesReadFromInput, inputBuffer, samplesRead);
|
|
else
|
|
convert_s24_to_s32(inputBuffer + bytesReadFromInput, inputBuffer, samplesRead);
|
|
memmove(inputBuffer, inputBuffer + bytesReadFromInput, samplesRead * 4);
|
|
bitsPerSample = 32;
|
|
bytesReadFromInput = samplesRead * 4;
|
|
isUnsigned = NO;
|
|
}
|
|
if (!isFloat && bitsPerSample <= 32) {
|
|
samplesRead = bytesReadFromInput / 4;
|
|
if (isUnsigned)
|
|
convert_u32_to_s32(inputBuffer, samplesRead);
|
|
convert_s32_to_float(inputBuffer + bytesReadFromInput, inputBuffer, samplesRead, gain);
|
|
memmove(inputBuffer, inputBuffer + bytesReadFromInput, samplesRead * sizeof(float));
|
|
bitsPerSample = 32;
|
|
bytesReadFromInput = samplesRead * sizeof(float);
|
|
isUnsigned = NO;
|
|
isFloat = YES;
|
|
}
|
|
}
|
|
|
|
// Extrapolate start
|
|
if (!skipResampler && !is_preextrapolated_)
|
|
{
|
|
size_t samples_in_buffer = bytesReadFromInput / floatFormat.mBytesPerPacket;
|
|
size_t prime = min(samples_in_buffer, PRIME_LEN_);
|
|
size_t newSize = N_samples_to_add_ * floatFormat.mBytesPerPacket;
|
|
newSize += bytesReadFromInput;
|
|
|
|
if (newSize > inputBufferSize) {
|
|
inputBuffer = realloc(inputBuffer, inputBufferSize = newSize * 3);
|
|
}
|
|
|
|
memmove(inputBuffer + N_samples_to_add_ * floatFormat.mBytesPerPacket, inputBuffer, bytesReadFromInput);
|
|
|
|
// Great padding! And we want to eat more, based on the resampler filter size
|
|
int samplesLatency = (int)ceil(resampler->latency(resampler_data) * sampleRatio);
|
|
|
|
// Guess what? This extrapolates into the memory before its input pointer!
|
|
lpc_extrapolate_bkwd(inputBuffer + N_samples_to_add_ * floatFormat.mBytesPerPacket, samples_in_buffer, prime, floatFormat.mChannelsPerFrame, LPC_ORDER, N_samples_to_add_, &extrapolateBuffer, &extrapolateBufferSize);
|
|
bytesReadFromInput += N_samples_to_add_ * floatFormat.mBytesPerPacket;
|
|
latencyEaten = N_samples_to_drop_ + samplesLatency;
|
|
if (dsd2pcm) latencyEaten += dsdLatencyEaten;
|
|
is_preextrapolated_ = 2;
|
|
}
|
|
else if (dsd2pcm && !is_preextrapolated_) {
|
|
latencyEaten = dsd2pcmLatency;
|
|
is_preextrapolated_ = 3;
|
|
}
|
|
|
|
if (is_postextrapolated_ == 1)
|
|
{
|
|
size_t samples_in_buffer = bytesReadFromInput / floatFormat.mBytesPerPacket;
|
|
size_t prime = min(samples_in_buffer, PRIME_LEN_);
|
|
|
|
size_t newSize = bytesReadFromInput;
|
|
newSize += N_samples_to_add_ * floatFormat.mBytesPerPacket;
|
|
if (newSize > inputBufferSize) {
|
|
inputBuffer = realloc(inputBuffer, inputBufferSize = newSize * 3);
|
|
}
|
|
|
|
// And now that we've reached the end, we eat slightly less, due to the filter size
|
|
int samplesLatency = (int)resampler->latency(resampler_data);
|
|
if (dsd2pcm) samplesLatency += dsd2pcmLatency;
|
|
samplesLatency = (int)ceil(samplesLatency * sampleRatio);
|
|
|
|
lpc_extrapolate_fwd(inputBuffer, samples_in_buffer, prime, floatFormat.mChannelsPerFrame, LPC_ORDER, N_samples_to_add_, &extrapolateBuffer, &extrapolateBufferSize);
|
|
bytesReadFromInput += N_samples_to_add_ * floatFormat.mBytesPerPacket;
|
|
latencyEatenPost = N_samples_to_drop_;
|
|
if (latencyEatenPost > samplesLatency) {
|
|
latencyEatenPost -= samplesLatency;
|
|
}
|
|
else {
|
|
latencyEatenPost = 0;
|
|
}
|
|
is_postextrapolated_ = 2;
|
|
}
|
|
else if (is_postextrapolated_ == 3) { // skip end of DSD output
|
|
latencyEatenPost = dsd2pcmLatency;
|
|
}
|
|
|
|
// Input now contains bytesReadFromInput worth of floats, in the input sample rate
|
|
inpSize = bytesReadFromInput;
|
|
inpOffset = 0;
|
|
}
|
|
|
|
if (inpOffset != inpSize && floatOffset == floatSize)
|
|
{
|
|
struct resampler_data src_data;
|
|
|
|
size_t inputSamples = (inpSize - inpOffset) / floatFormat.mBytesPerPacket;
|
|
|
|
ioNumberPackets = (UInt32)inputSamples;
|
|
|
|
ioNumberPackets = (UInt32)ceil((float)ioNumberPackets * sampleRatio);
|
|
ioNumberPackets = (ioNumberPackets + 255) & ~255;
|
|
|
|
size_t newSize = ioNumberPackets * floatFormat.mBytesPerPacket;
|
|
if (newSize < (ioNumberPackets * dmFloatFormat.mBytesPerPacket))
|
|
newSize = ioNumberPackets * dmFloatFormat.mBytesPerPacket;
|
|
if (!floatBuffer || floatBufferSize < newSize)
|
|
floatBuffer = realloc( floatBuffer, floatBufferSize = newSize * 3 );
|
|
|
|
if (stopping)
|
|
{
|
|
convertEntered = NO;
|
|
return 0;
|
|
}
|
|
|
|
src_data.data_out = floatBuffer;
|
|
src_data.output_frames = 0;
|
|
|
|
src_data.data_in = (float*)(((uint8_t*)inputBuffer) + inpOffset);
|
|
src_data.input_frames = inputSamples;
|
|
|
|
src_data.ratio = sampleRatio;
|
|
|
|
if (!skipResampler)
|
|
{
|
|
resampler->process(resampler_data, &src_data);
|
|
}
|
|
else
|
|
{
|
|
memcpy(src_data.data_out, src_data.data_in, inputSamples * floatFormat.mBytesPerPacket);
|
|
src_data.output_frames = inputSamples;
|
|
}
|
|
|
|
inpOffset += inputSamples * floatFormat.mBytesPerPacket;
|
|
|
|
if (latencyEaten)
|
|
{
|
|
if (src_data.output_frames > latencyEaten)
|
|
{
|
|
src_data.output_frames -= latencyEaten;
|
|
memmove(src_data.data_out, src_data.data_out + latencyEaten * inputFormat.mChannelsPerFrame, src_data.output_frames * floatFormat.mBytesPerPacket);
|
|
latencyEaten = 0;
|
|
}
|
|
else
|
|
{
|
|
latencyEaten -= src_data.output_frames;
|
|
src_data.output_frames = 0;
|
|
}
|
|
}
|
|
else if (latencyEatenPost)
|
|
{
|
|
if (src_data.output_frames > latencyEatenPost)
|
|
{
|
|
src_data.output_frames -= latencyEatenPost;
|
|
}
|
|
else
|
|
{
|
|
src_data.output_frames = 0;
|
|
}
|
|
latencyEatenPost = 0;
|
|
}
|
|
|
|
amountReadFromFC = (int)(src_data.output_frames * floatFormat.mBytesPerPacket);
|
|
|
|
scale_by_volume( (float*) floatBuffer, amountReadFromFC / sizeof(float), volumeScale);
|
|
|
|
if ( hFilter ) {
|
|
int samples = amountReadFromFC / floatFormat.mBytesPerFrame;
|
|
[hFilter process:floatBuffer sampleCount:samples toBuffer:floatBuffer + amountReadFromFC];
|
|
memmove(floatBuffer, floatBuffer + amountReadFromFC, samples * sizeof(float) * 2);
|
|
amountReadFromFC = samples * sizeof(float) * 2;
|
|
}
|
|
else if ( inputFormat.mChannelsPerFrame > 2 && outputFormat.mChannelsPerFrame == 2 )
|
|
{
|
|
int samples = amountReadFromFC / floatFormat.mBytesPerFrame;
|
|
downmix_to_stereo( (float*) floatBuffer, inputFormat.mChannelsPerFrame, samples );
|
|
amountReadFromFC = samples * sizeof(float) * 2;
|
|
}
|
|
else if ( inputFormat.mChannelsPerFrame > 1 && outputFormat.mChannelsPerFrame == 1 )
|
|
{
|
|
int samples = amountReadFromFC / floatFormat.mBytesPerFrame;
|
|
downmix_to_mono( (float*) floatBuffer, inputFormat.mChannelsPerFrame, samples );
|
|
amountReadFromFC = samples * sizeof(float);
|
|
}
|
|
else if ( inputFormat.mChannelsPerFrame < outputFormat.mChannelsPerFrame )
|
|
{
|
|
int samples = amountReadFromFC / floatFormat.mBytesPerFrame;
|
|
upmix( (float*) floatBuffer, inputFormat.mChannelsPerFrame, outputFormat.mChannelsPerFrame, samples );
|
|
amountReadFromFC = samples * sizeof(float) * outputFormat.mChannelsPerFrame;
|
|
}
|
|
|
|
floatSize = amountReadFromFC;
|
|
floatOffset = 0;
|
|
}
|
|
|
|
if (floatOffset == floatSize)
|
|
goto tryagain;
|
|
|
|
ioNumberPackets = (amount - amountRead);
|
|
if (ioNumberPackets > (floatSize - floatOffset))
|
|
ioNumberPackets = (UInt32)(floatSize - floatOffset);
|
|
|
|
memcpy(dest + amountRead, floatBuffer + floatOffset, ioNumberPackets);
|
|
|
|
floatOffset += ioNumberPackets;
|
|
amountRead += ioNumberPackets;
|
|
|
|
convertEntered = NO;
|
|
return amountRead;
|
|
}
|
|
|
|
- (void)observeValueForKeyPath:(NSString *)keyPath
|
|
ofObject:(id)object
|
|
change:(NSDictionary *)change
|
|
context:(void *)context
|
|
{
|
|
DLog(@"SOMETHING CHANGED!");
|
|
if ([keyPath isEqualToString:@"values.volumeScaling"]) {
|
|
//User reset the volume scaling option
|
|
[self refreshVolumeScaling];
|
|
}
|
|
else if ([keyPath isEqualToString:@"values.outputResampling"]) {
|
|
// Reset resampler
|
|
if (resampler && resampler_data) {
|
|
NSString *value = [[NSUserDefaults standardUserDefaults] stringForKey:@"outputResampling"];
|
|
if (![value isEqualToString:outputResampling])
|
|
[self inputFormatDidChange:inputFormat];
|
|
}
|
|
}
|
|
else if ([keyPath isEqualToString:@"values.headphoneVirtualization"]) {
|
|
// Reset the converter, without rebuffering
|
|
if (outputFormat.mChannelsPerFrame == 2 &&
|
|
inputFormat.mChannelsPerFrame >= 1 &&
|
|
inputFormat.mChannelsPerFrame <= 8) {
|
|
[self inputFormatDidChange:inputFormat];
|
|
}
|
|
}
|
|
}
|
|
|
|
static float db_to_scale(float db)
|
|
{
|
|
return pow(10.0, db / 20);
|
|
}
|
|
|
|
- (void)refreshVolumeScaling
|
|
{
|
|
if (rgInfo == nil)
|
|
{
|
|
volumeScale = 1.0;
|
|
return;
|
|
}
|
|
|
|
NSString * scaling = [[NSUserDefaults standardUserDefaults] stringForKey:@"volumeScaling"];
|
|
BOOL useAlbum = [scaling hasPrefix:@"albumGain"];
|
|
BOOL useTrack = useAlbum || [scaling hasPrefix:@"trackGain"];
|
|
BOOL useVolume = useAlbum || useTrack || [scaling isEqualToString:@"volumeScale"];
|
|
BOOL usePeak = [scaling hasSuffix:@"WithPeak"];
|
|
float scale = 1.0;
|
|
float peak = 0.0;
|
|
if (useVolume) {
|
|
id pVolumeScale = [rgInfo objectForKey:@"volume"];
|
|
if (pVolumeScale != nil)
|
|
scale = [pVolumeScale floatValue];
|
|
}
|
|
if (useTrack) {
|
|
id trackGain = [rgInfo objectForKey:@"replayGainTrackGain"];
|
|
id trackPeak = [rgInfo objectForKey:@"replayGainTrackPeak"];
|
|
if (trackGain != nil)
|
|
scale = db_to_scale([trackGain floatValue]);
|
|
if (trackPeak != nil)
|
|
peak = [trackPeak floatValue];
|
|
}
|
|
if (useAlbum) {
|
|
id albumGain = [rgInfo objectForKey:@"replayGainAlbumGain"];
|
|
id albumPeak = [rgInfo objectForKey:@"replayGainAlbumPeak"];
|
|
if (albumGain != nil)
|
|
scale = db_to_scale([albumGain floatValue]);
|
|
if (albumPeak != nil)
|
|
peak = [albumPeak floatValue];
|
|
}
|
|
if (usePeak) {
|
|
if (scale * peak > 1.0)
|
|
scale = 1.0 / peak;
|
|
}
|
|
volumeScale = scale;
|
|
}
|
|
|
|
|
|
- (BOOL)setupWithInputFormat:(AudioStreamBasicDescription)inf outputFormat:(AudioStreamBasicDescription)outf isLossless:(BOOL)lossless
|
|
{
|
|
//Make the converter
|
|
inputFormat = inf;
|
|
outputFormat = outf;
|
|
|
|
rememberedLossless = lossless;
|
|
|
|
// These are the only sample formats we support translating
|
|
BOOL isFloat = !!(inputFormat.mFormatFlags & kAudioFormatFlagIsFloat);
|
|
if ((!isFloat && !(inputFormat.mBitsPerChannel >= 1 && inputFormat.mBitsPerChannel <= 32))
|
|
|| (isFloat && !(inputFormat.mBitsPerChannel == 32 || inputFormat.mBitsPerChannel == 64)))
|
|
return NO;
|
|
|
|
// These are really placeholders, as we're doing everything internally now
|
|
if (lossless &&
|
|
inputFormat.mBitsPerChannel == 16 &&
|
|
inputFormat.mChannelsPerFrame == 2 &&
|
|
inputFormat.mSampleRate == 44100) {
|
|
// possibly HDCD, run through decoder
|
|
hdcd_decoder = calloc(1, sizeof(hdcd_state_stereo_t));
|
|
hdcd_reset_stereo((hdcd_state_stereo_t *)hdcd_decoder, 44100);
|
|
}
|
|
|
|
floatFormat = inputFormat;
|
|
floatFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked;
|
|
floatFormat.mBitsPerChannel = 32;
|
|
floatFormat.mBytesPerFrame = (32/8)*floatFormat.mChannelsPerFrame;
|
|
floatFormat.mBytesPerPacket = floatFormat.mBytesPerFrame * floatFormat.mFramesPerPacket;
|
|
|
|
if (inputFormat.mBitsPerChannel == 1) {
|
|
// Decimate this for speed
|
|
floatFormat.mSampleRate *= 1.0 / 8.0;
|
|
dsd2pcmCount = floatFormat.mChannelsPerFrame;
|
|
dsd2pcm = calloc(dsd2pcmCount, sizeof(void*));
|
|
dsd2pcm[0] = dsd2pcm_alloc();
|
|
dsd2pcmLatency = dsd2pcm_latency(dsd2pcm[0]);
|
|
for (size_t i = 1; i < dsd2pcmCount; ++i)
|
|
{
|
|
dsd2pcm[i] = dsd2pcm_dup(dsd2pcm[0]);
|
|
}
|
|
}
|
|
|
|
inpOffset = 0;
|
|
inpSize = 0;
|
|
|
|
floatOffset = 0;
|
|
floatSize = 0;
|
|
|
|
// This is a post resampler, post-down/upmix format
|
|
|
|
dmFloatFormat = floatFormat;
|
|
dmFloatFormat.mSampleRate = outputFormat.mSampleRate;
|
|
dmFloatFormat.mChannelsPerFrame = outputFormat.mChannelsPerFrame;
|
|
dmFloatFormat.mBytesPerFrame = (32/8)*dmFloatFormat.mChannelsPerFrame;
|
|
dmFloatFormat.mBytesPerPacket = dmFloatFormat.mBytesPerFrame * floatFormat.mFramesPerPacket;
|
|
|
|
BOOL hVirt = [[[NSUserDefaultsController sharedUserDefaultsController] defaults] boolForKey:@"headphoneVirtualization"];
|
|
|
|
if (hVirt &&
|
|
outputFormat.mChannelsPerFrame == 2 &&
|
|
inputFormat.mChannelsPerFrame >= 1 &&
|
|
inputFormat.mChannelsPerFrame <= 8) {
|
|
CFURLRef appUrlRef = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("gsx"), CFSTR("wv"), NULL);
|
|
|
|
if (appUrlRef) {
|
|
hFilter = [[HeadphoneFilter alloc] initWithImpulseFile:(__bridge NSURL *)appUrlRef forSampleRate:outputFormat.mSampleRate withInputChannels:inputFormat.mChannelsPerFrame];
|
|
}
|
|
}
|
|
|
|
convert_s16_to_float_init_simd();
|
|
convert_s32_to_float_init_simd();
|
|
|
|
skipResampler = outputFormat.mSampleRate == floatFormat.mSampleRate;
|
|
|
|
sampleRatio = (double)outputFormat.mSampleRate / (double)floatFormat.mSampleRate;
|
|
|
|
if (!skipResampler)
|
|
{
|
|
enum resampler_quality quality = RESAMPLER_QUALITY_DONTCARE;
|
|
|
|
NSString * resampling = [[NSUserDefaults standardUserDefaults] stringForKey:@"outputResampling"];
|
|
if ([resampling isEqualToString:@"lowest"])
|
|
quality = RESAMPLER_QUALITY_LOWEST;
|
|
else if ([resampling isEqualToString:@"lower"])
|
|
quality = RESAMPLER_QUALITY_LOWER;
|
|
else if ([resampling isEqualToString:@"normal"])
|
|
quality = RESAMPLER_QUALITY_NORMAL;
|
|
else if ([resampling isEqualToString:@"higher"])
|
|
quality = RESAMPLER_QUALITY_HIGHER;
|
|
else if ([resampling isEqualToString:@"highest"])
|
|
quality = RESAMPLER_QUALITY_HIGHEST;
|
|
|
|
outputResampling = resampling;
|
|
|
|
if (!retro_resampler_realloc(&resampler_data, &resampler, "sinc", quality, inputFormat.mChannelsPerFrame, sampleRatio))
|
|
{
|
|
return NO;
|
|
}
|
|
|
|
PRIME_LEN_ = max(floatFormat.mSampleRate/20, 1024u);
|
|
PRIME_LEN_ = min(PRIME_LEN_, 16384u);
|
|
PRIME_LEN_ = max(PRIME_LEN_, 2*LPC_ORDER + 1);
|
|
|
|
N_samples_to_add_ = floatFormat.mSampleRate;
|
|
N_samples_to_drop_ = outputFormat.mSampleRate;
|
|
|
|
samples_len(&N_samples_to_add_, &N_samples_to_drop_, 20, 8192u);
|
|
|
|
is_preextrapolated_ = 0;
|
|
is_postextrapolated_ = 0;
|
|
}
|
|
|
|
latencyEaten = 0;
|
|
latencyEatenPost = 0;
|
|
|
|
PrintStreamDesc(&inf);
|
|
PrintStreamDesc(&outf);
|
|
|
|
[self refreshVolumeScaling];
|
|
|
|
// Move this here so process call isn't running the resampler until it's allocated
|
|
stopping = NO;
|
|
convertEntered = NO;
|
|
paused = NO;
|
|
outputFormatChanged = NO;
|
|
|
|
return YES;
|
|
}
|
|
|
|
- (void)dealloc
|
|
{
|
|
DLog(@"Decoder dealloc");
|
|
|
|
[[NSUserDefaultsController sharedUserDefaultsController] removeObserver:self forKeyPath:@"values.volumeScaling"];
|
|
[[NSUserDefaultsController sharedUserDefaultsController] removeObserver:self forKeyPath:@"values.outputResampling"];
|
|
[[NSUserDefaultsController sharedUserDefaultsController] removeObserver:self forKeyPath:@"values.headphoneVirtualization"];
|
|
|
|
paused = NO;
|
|
[self cleanUp];
|
|
}
|
|
|
|
|
|
- (void)setOutputFormat:(AudioStreamBasicDescription)format
|
|
{
|
|
DLog(@"SETTING OUTPUT FORMAT!");
|
|
previousOutputFormat = outputFormat;
|
|
outputFormat = format;
|
|
outputFormatChanged = YES;
|
|
}
|
|
|
|
- (void)inputFormatDidChange:(AudioStreamBasicDescription)format
|
|
{
|
|
DLog(@"FORMAT CHANGED");
|
|
paused = YES;
|
|
[self cleanUp];
|
|
if (outputFormatChanged && ![buffer isEmpty] &&
|
|
memcmp(&outputFormat, &previousOutputFormat, sizeof(outputFormat)) != 0)
|
|
{
|
|
// Transfer previously buffered data, remember input format
|
|
rememberedInputFormat = format;
|
|
originalPreviousNode = previousNode;
|
|
refillNode = [[RefillNode alloc] initWithController:controller previous:nil];
|
|
[self setPreviousNode:refillNode];
|
|
|
|
int dataRead = 0;
|
|
|
|
for (;;)
|
|
{
|
|
void * ptr;
|
|
dataRead = [buffer lengthAvailableToReadReturningPointer:&ptr];
|
|
if (dataRead) {
|
|
[refillNode writeData:(float*)ptr floatCount:dataRead / sizeof(float)];
|
|
[buffer didReadLength:dataRead];
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
[self setupWithInputFormat:previousOutputFormat outputFormat:outputFormat isLossless:rememberedLossless];
|
|
}
|
|
else
|
|
{
|
|
[self setupWithInputFormat:format outputFormat:outputFormat isLossless:rememberedLossless];
|
|
}
|
|
}
|
|
|
|
- (void)setRGInfo:(NSDictionary *)rgi
|
|
{
|
|
DLog(@"Setting ReplayGain info");
|
|
rgInfo = rgi;
|
|
[self refreshVolumeScaling];
|
|
}
|
|
|
|
- (void)cleanUp
|
|
{
|
|
stopping = YES;
|
|
while (convertEntered)
|
|
{
|
|
usleep(500);
|
|
}
|
|
if (hFilter) {
|
|
hFilter = nil;
|
|
}
|
|
if (hdcd_decoder)
|
|
{
|
|
free(hdcd_decoder);
|
|
hdcd_decoder = NULL;
|
|
}
|
|
if (resampler && resampler_data)
|
|
{
|
|
resampler->free(resampler, resampler_data);
|
|
resampler = NULL;
|
|
resampler_data = NULL;
|
|
}
|
|
if (dsd2pcm && dsd2pcmCount)
|
|
{
|
|
for (size_t i = 0; i < dsd2pcmCount; ++i)
|
|
{
|
|
dsd2pcm_free(dsd2pcm[i]);
|
|
dsd2pcm[i] = NULL;
|
|
}
|
|
free(dsd2pcm);
|
|
dsd2pcm = NULL;
|
|
}
|
|
if (extrapolateBuffer)
|
|
{
|
|
free(extrapolateBuffer);
|
|
extrapolateBuffer = NULL;
|
|
extrapolateBufferSize = 0;
|
|
}
|
|
if (floatBuffer)
|
|
{
|
|
free(floatBuffer);
|
|
floatBuffer = NULL;
|
|
floatBufferSize = 0;
|
|
}
|
|
if (inputBuffer) {
|
|
free(inputBuffer);
|
|
inputBuffer = NULL;
|
|
inputBufferSize = 0;
|
|
}
|
|
floatOffset = 0;
|
|
floatSize = 0;
|
|
}
|
|
|
|
- (double) secondsBuffered
|
|
{
|
|
return ((double)[buffer bufferedLength] / (outputFormat.mSampleRate * outputFormat.mBytesPerPacket));
|
|
}
|
|
|
|
@end
|