mirror of https://github.com/xiph/flac
first pass at 8-bit and 24-bit support, plus dithering
This commit is contained in:
Josh Coalson
parent
412fa3b7a2
commit
10a2a48c57
|
|
@ -1,6 +1,10 @@
|
|||
/* in_flac - Winamp2 FLAC input plugin
|
||||
* Copyright (C) 2000,2001,2002 Josh Coalson
|
||||
*
|
||||
* dithering routine derived from (other GPLed source):
|
||||
* mad - MPEG audio decoder
|
||||
* Copyright (C) 2000-2001 Robert Leslie
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation; either version 2
|
||||
|
|
@ -25,6 +29,9 @@
|
|||
#include "in2.h"
|
||||
#include "FLAC/all.h"
|
||||
|
||||
|
||||
#define MAX_SUPPORTED_CHANNELS 2
|
||||
|
||||
typedef struct {
|
||||
FLAC__byte raw[128];
|
||||
char title[31];
|
||||
|
|
@ -67,9 +74,9 @@ char lastfn_[MAX_PATH]; /* currently playing file (used for getting info on the
|
|||
int decode_pos_ms_; /* current decoding position, in milliseconds */
|
||||
int paused_; /* are we paused? */
|
||||
int seek_needed_; /* if != -1, it is the point that the decode thread should seek to, in ms. */
|
||||
FLAC__int16 reservoir_[FLAC__MAX_BLOCK_SIZE * 2 * 2]; /* *2 for max channels, another *2 for overflow */
|
||||
char sample_buffer_[576 * 2 * (16/8) * 2]; /* 2 for max channels, (16/8) for max bytes per sample, and 2 for who knows what */
|
||||
unsigned samples_in_reservoir_;
|
||||
FLAC__int32 reservoir_[FLAC__MAX_BLOCK_SIZE * 2/*for overflow*/ * MAX_SUPPORTED_CHANNELS];
|
||||
char sample_buffer_[576 * MAX_SUPPORTED_CHANNELS * (24/8) * 2]; /* (24/8) for max bytes per sample, and 2 for who knows what */
|
||||
unsigned wide_samples_in_reservoir_;
|
||||
static file_info_struct file_info_;
|
||||
static FLAC__FileDecoder *decoder_;
|
||||
|
||||
|
|
@ -78,6 +85,173 @@ HANDLE thread_handle = INVALID_HANDLE_VALUE; /* the handle to the decode thread
|
|||
|
||||
DWORD WINAPI __stdcall DecodeThread(void *b); /* the decode thread procedure */
|
||||
|
||||
|
||||
/* 32-bit pseudo-random number generator */
|
||||
static inline FLAC__uint32 prng(FLAC__uint32 state)
|
||||
{
|
||||
return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
|
||||
}
|
||||
|
||||
/* dither routine derived from MAD winamp plugin */
|
||||
|
||||
typedef struct {
|
||||
FLAC__int32 error[3];
|
||||
FLAC__int32 random;
|
||||
} dither_state;
|
||||
|
||||
static inline FLAC__int32 linear_dither(unsigned source_bps, unsigned target_bps, FLAC__int32 sample, dither_state *dither, const FLAC__int32 MIN, const FLAC__int32 MAX)
|
||||
{
|
||||
unsigned scalebits;
|
||||
FLAC__int32 output, mask, random;
|
||||
|
||||
FLAC__ASSERT(source_bps < 32);
|
||||
FLAC__ASSERT(target_bps <= 24);
|
||||
FLAC__ASSERT(target_bps <= source_bps);
|
||||
|
||||
/* noise shape */
|
||||
sample += dither->error[0] - dither->error[1] + dither->error[2];
|
||||
|
||||
dither->error[2] = dither->error[1];
|
||||
dither->error[1] = dither->error[0] / 2;
|
||||
|
||||
/* bias */
|
||||
output = sample + (1L << (source_bps - target_bps - 1));
|
||||
|
||||
scalebits = source_bps - target_bps;
|
||||
mask = (1L << scalebits) - 1;
|
||||
|
||||
/* dither */
|
||||
random = (FLAC__int32)prng(dither->random);
|
||||
output += (random & mask) - (dither->random & mask);
|
||||
|
||||
dither->random = random;
|
||||
|
||||
/* clip */
|
||||
if(output > MAX) {
|
||||
output = MAX;
|
||||
|
||||
if(sample > MAX)
|
||||
sample = MAX;
|
||||
}
|
||||
else if(output < MIN) {
|
||||
output = MIN;
|
||||
|
||||
if(sample < MIN)
|
||||
sample = MIN;
|
||||
}
|
||||
|
||||
/* quantize */
|
||||
output &= ~mask;
|
||||
|
||||
/* error feedback */
|
||||
dither->error[0] = sample - output;
|
||||
|
||||
/* scale */
|
||||
return output >> scalebits;
|
||||
}
|
||||
|
||||
static unsigned pack_pcm(FLAC__byte *data, FLAC__int32 *input, unsigned wide_samples, unsigned channels, unsigned source_bps, unsigned target_bps)
|
||||
{
|
||||
static dither_state dither[MAX_SUPPORTED_CHANNELS];
|
||||
FLAC__byte * const start = data;
|
||||
FLAC__int32 sample;
|
||||
const unsigned bytes_per_sample = target_bps / 8;
|
||||
const unsigned samples = wide_samples * channels;
|
||||
|
||||
FLAC__ASSERT(MAX_SUPPORTED_CHANNELS == 2);
|
||||
FLAC__ASSERT(channels > 0 && channels <= MAX_SUPPORTED_CHANNELS);
|
||||
FLAC__ASSERT(source_bps < 32);
|
||||
FLAC__ASSERT(target_bps <= 24);
|
||||
FLAC__ASSERT(target_bps <= source_bps);
|
||||
FLAC__ASSERT(source_bps & 7 == 0);
|
||||
FLAC__ASSERT(target_bps & 7 == 0);
|
||||
|
||||
if(source_bps != target_bps) {
|
||||
const FLAC__int32 MIN = source_bps == -(1L << source_bps);
|
||||
const FLAC__int32 MAX = ~MIN; /*(1L << (source_bps-1)) - 1 */
|
||||
const unsigned dither_twiggle = channels - 1;
|
||||
unsigned dither_source = 0;
|
||||
|
||||
while(samples--) {
|
||||
sample = linear_dither(source_bps, target_bps, *input++, &dither[dither_source], MIN, MAX);
|
||||
dither_source ^= dither_twiggle;
|
||||
|
||||
switch(target_bps) {
|
||||
case 8:
|
||||
data[0] = sample ^ 0x80;
|
||||
break;
|
||||
case 24:
|
||||
data[2] = sample >> 16;
|
||||
/* fall through */
|
||||
case 16:
|
||||
data[1] = sample >> 8;
|
||||
data[0] = sample >> 0;
|
||||
}
|
||||
|
||||
data += bytes_per_sample;
|
||||
}
|
||||
}
|
||||
else {
|
||||
while(samples--) {
|
||||
sample = *input++;
|
||||
|
||||
switch(target_bps) {
|
||||
case 8:
|
||||
data[0] = sample ^ 0x80;
|
||||
break;
|
||||
case 24:
|
||||
data[2] = sample >> 16;
|
||||
/* fall through */
|
||||
case 16:
|
||||
data[1] = sample >> 8;
|
||||
data[0] = sample >> 0;
|
||||
}
|
||||
|
||||
data += bytes_per_sample;
|
||||
}
|
||||
}
|
||||
|
||||
return data - start;
|
||||
}
|
||||
|
||||
#if 0
|
||||
@@@@ incorporate this
|
||||
static void do_vis(char *data, int nch, int resolution, int position)
|
||||
{
|
||||
static char vis_buffer[PCM_CHUNK * 2];
|
||||
char *ptr;
|
||||
int size, count;
|
||||
|
||||
/*
|
||||
* Winamp visuals may have problems accepting sample sizes larger than
|
||||
* 16 bits, so we reduce the sample size here if necessary.
|
||||
*/
|
||||
|
||||
switch(resolution) {
|
||||
case 32:
|
||||
case 24:
|
||||
size = resolution / 8;
|
||||
count = PCM_CHUNK * nch;
|
||||
|
||||
ptr = vis_buffer;
|
||||
while(count--) {
|
||||
data += size;
|
||||
*ptr++ = data[-1] ^ 0x80;
|
||||
}
|
||||
|
||||
data = vis_buffer;
|
||||
resolution = 8;
|
||||
|
||||
/* fall through */
|
||||
case 16:
|
||||
case 8:
|
||||
default:
|
||||
module.SAAddPCMData(data, nch, resolution, position);
|
||||
module.VSAAddPCMData(data, nch, resolution, position);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void config(HWND hwndParent)
|
||||
{
|
||||
MessageBox(hwndParent, "No configuration.", "Configuration", MB_OK);
|
||||
|
|
@ -127,10 +301,10 @@ int play(char *fn)
|
|||
paused_ = 0;
|
||||
decode_pos_ms_ = 0;
|
||||
seek_needed_ = -1;
|
||||
samples_in_reservoir_ = 0;
|
||||
wide_samples_in_reservoir_ = 0;
|
||||
|
||||
maxlatency = mod_.outMod->Open(file_info_.sample_rate, file_info_.channels, file_info_.bits_per_sample, -1, -1);
|
||||
if (maxlatency < 0) { /* error opening device */
|
||||
if(maxlatency < 0) { /* error opening device */
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -168,9 +342,9 @@ int ispaused()
|
|||
|
||||
void stop()
|
||||
{
|
||||
if (thread_handle != INVALID_HANDLE_VALUE) {
|
||||
if(thread_handle != INVALID_HANDLE_VALUE) {
|
||||
killDecodeThread = 1;
|
||||
if (WaitForSingleObject(thread_handle, INFINITE) == WAIT_TIMEOUT) {
|
||||
if(WaitForSingleObject(thread_handle, INFINITE) == WAIT_TIMEOUT) {
|
||||
MessageBox(mod_.hMainWindow, "error asking thread to die!\n", "error killing decode thread", 0);
|
||||
TerminateThread(thread_handle, 0);
|
||||
}
|
||||
|
|
@ -215,7 +389,7 @@ void getfileinfo(char *filename, char *title, int *length_in_msec)
|
|||
|
||||
if(0 == filename || filename[0] == '\0') {
|
||||
filename = lastfn_;
|
||||
if (length_in_msec) {
|
||||
if(length_in_msec) {
|
||||
*length_in_msec = getlength();
|
||||
length_in_msec = 0; /* force skip in following code */
|
||||
}
|
||||
|
|
@ -248,12 +422,12 @@ DWORD WINAPI __stdcall DecodeThread(void *b)
|
|||
{
|
||||
int done = 0;
|
||||
|
||||
while (! *((int *)b) ) {
|
||||
while(! *((int *)b) ) {
|
||||
unsigned channels = file_info_.channels;
|
||||
unsigned bits_per_sample = file_info_.bits_per_sample;
|
||||
unsigned bytes_per_sample = (bits_per_sample+7)/8;
|
||||
unsigned sample_rate = file_info_.sample_rate;
|
||||
if (seek_needed_ != -1) {
|
||||
if(seek_needed_ != -1) {
|
||||
const double distance = (double)seek_needed_ / (double)getlength();
|
||||
unsigned target_sample = (unsigned)(distance * (double)file_info_.total_samples);
|
||||
if(FLAC__file_decoder_seek_absolute(decoder_, (FLAC__uint64)target_sample)) {
|
||||
|
|
@ -263,15 +437,15 @@ DWORD WINAPI __stdcall DecodeThread(void *b)
|
|||
mod_.outMod->Flush(decode_pos_ms_);
|
||||
}
|
||||
}
|
||||
if (done) {
|
||||
if (!mod_.outMod->IsPlaying()) {
|
||||
if(done) {
|
||||
if(!mod_.outMod->IsPlaying()) {
|
||||
PostMessage(mod_.hMainWindow, WM_WA_MPEG_EOF, 0, 0);
|
||||
return 0;
|
||||
}
|
||||
Sleep(10);
|
||||
}
|
||||
else if (mod_.outMod->CanWrite() >= ((int)(576*channels*bytes_per_sample) << (mod_.dsp_isactive()?1:0))) {
|
||||
while(samples_in_reservoir_ < 576) {
|
||||
else if(mod_.outMod->CanWrite() >= ((int)(576*channels*bytes_per_sample) << (mod_.dsp_isactive()?1:0))) {
|
||||
while(wide_samples_in_reservoir_ < 576) {
|
||||
if(FLAC__file_decoder_get_state(decoder_) == FLAC__FILE_DECODER_END_OF_FILE) {
|
||||
done = 1;
|
||||
break;
|
||||
|
|
@ -283,28 +457,25 @@ DWORD WINAPI __stdcall DecodeThread(void *b)
|
|||
}
|
||||
}
|
||||
|
||||
if (samples_in_reservoir_ == 0) {
|
||||
if(wide_samples_in_reservoir_ == 0) {
|
||||
done = 1;
|
||||
}
|
||||
else {
|
||||
unsigned i, n = min(samples_in_reservoir_, 576), delta;
|
||||
int bytes;
|
||||
signed short *ssbuffer = (signed short *)sample_buffer_;
|
||||
const unsigned target_bps = 16;
|
||||
const unsigned n = min(wide_samples_in_reservoir_, 576);
|
||||
const unsigned delta = n * channels;
|
||||
int bytes = (int)pack_pcm(sample_buffer_, reservoir_, n, channels, bits_per_sample, target_bps);
|
||||
unsigned i;
|
||||
|
||||
for(i = 0; i < n*channels; i++)
|
||||
ssbuffer[i] = reservoir_[i];
|
||||
delta = i;
|
||||
for( ; i < samples_in_reservoir_ * channels; i++)
|
||||
for(i = delta; i < wide_samples_in_reservoir_ * channels; i++)
|
||||
reservoir_[i-delta] = reservoir_[i];
|
||||
samples_in_reservoir_ -= n;
|
||||
wide_samples_in_reservoir_ -= n;
|
||||
|
||||
mod_.SAAddPCMData((char *)sample_buffer_, channels, bits_per_sample, decode_pos_ms_);
|
||||
mod_.VSAAddPCMData((char *)sample_buffer_, channels, bits_per_sample, decode_pos_ms_);
|
||||
mod_.SAAddPCMData((char *)sample_buffer_, channels, target_bps, decode_pos_ms_);
|
||||
mod_.VSAAddPCMData((char *)sample_buffer_, channels, target_bps, decode_pos_ms_);
|
||||
decode_pos_ms_ += (n*1000 + sample_rate/2)/sample_rate;
|
||||
if (mod_.dsp_isactive())
|
||||
bytes = mod_.dsp_dosamples((short *)sample_buffer_, n, bits_per_sample, channels, sample_rate) * (channels*bytes_per_sample);
|
||||
else
|
||||
bytes = n * channels * bytes_per_sample;
|
||||
if(mod_.dsp_isactive())
|
||||
bytes = mod_.dsp_dosamples((short *)sample_buffer_, n, target_bps, channels, sample_rate) * (channels*target_bps/8);
|
||||
mod_.outMod->Write(sample_buffer_, bytes);
|
||||
}
|
||||
}
|
||||
|
|
@ -414,18 +585,18 @@ FLAC__StreamDecoderWriteStatus write_callback_(const FLAC__FileDecoder *decoder,
|
|||
{
|
||||
file_info_struct *file_info_ = (file_info_struct *)client_data;
|
||||
const unsigned bps = file_info_->bits_per_sample, channels = file_info_->channels, wide_samples = frame->header.blocksize;
|
||||
unsigned wide_sample, sample, channel;
|
||||
unsigned wide_sample, offset_sample, channel;
|
||||
|
||||
(void)decoder;
|
||||
|
||||
if(file_info_->abort_flag)
|
||||
return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
|
||||
|
||||
for(sample = samples_in_reservoir_ * channels, wide_sample = 0; wide_sample < wide_samples; wide_sample++)
|
||||
for(channel = 0; channel < channels; channel++, sample++)
|
||||
reservoir_[sample] = (FLAC__int16)buffer[channel][wide_sample];
|
||||
for(offset_sample = wide_samples_in_reservoir_ * channels, wide_sample = 0; wide_sample < wide_samples; wide_sample++)
|
||||
for(channel = 0; channel < channels; channel++, offset_sample++)
|
||||
reservoir_[offset_sample] = buffer[channel][wide_sample];
|
||||
|
||||
samples_in_reservoir_ += wide_samples;
|
||||
wide_samples_in_reservoir_ += wide_samples;
|
||||
|
||||
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue