mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-11-21 20:01:13 +00:00
343 lines
9.4 KiB
C++
343 lines
9.4 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition Source Code 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <malloc.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
static const int SAMPLE_RATE = 60;
|
|
|
|
enum errorCodes_t {
|
|
E_OK = 0,
|
|
E_ARGS,
|
|
E_OPEN_IN,
|
|
E_OPEN_OUT,
|
|
E_PROCESSING
|
|
};
|
|
|
|
struct chunk_t {
|
|
unsigned int id;
|
|
unsigned int size;
|
|
unsigned int offset;
|
|
};
|
|
|
|
static unsigned short FORMAT_PCM = 0x0001;
|
|
|
|
struct format_t {
|
|
unsigned short formatTag;
|
|
unsigned short numChannels;
|
|
unsigned int samplesPerSec;
|
|
unsigned int avgBytesPerSec;
|
|
unsigned short sampleSize;
|
|
unsigned short bitsPerSample;
|
|
};
|
|
|
|
#define SwapBytes( x, y ) { unsigned char t = (x); (x) = (y); (y) = t; }
|
|
|
|
template<class type> static void Swap( type &c ) {
|
|
if ( sizeof( type ) == 1 ) {
|
|
} else if ( sizeof( type ) == 2 ) {
|
|
unsigned char * b = (unsigned char *)&c;
|
|
SwapBytes( b[0], b[1] );
|
|
} else if ( sizeof( type ) == 4 ) {
|
|
unsigned char * b = (unsigned char *)&c;
|
|
SwapBytes( b[0], b[3] );
|
|
SwapBytes( b[1], b[2] );
|
|
} else if ( sizeof( type ) == 8 ) {
|
|
unsigned char * b = (unsigned char *)&c;
|
|
SwapBytes( b[0], b[7] );
|
|
SwapBytes( b[1], b[6]);
|
|
SwapBytes( b[2], b[5] );
|
|
SwapBytes( b[3], b[4] );
|
|
} else {
|
|
int * null = 0;
|
|
c = *null;
|
|
}
|
|
}
|
|
|
|
int WAVE_ReadHeader( FILE * f ) {
|
|
struct header_t {
|
|
unsigned int id;
|
|
unsigned int size;
|
|
unsigned int format;
|
|
} header;
|
|
|
|
fread( &header, sizeof( header ), 1, f );
|
|
Swap( header.id );
|
|
Swap( header.format );
|
|
|
|
if ( header.id != 'RIFF' || header.format != 'WAVE' || header.size < 4 ) {
|
|
return 0;
|
|
}
|
|
|
|
return header.size;
|
|
}
|
|
|
|
int WAVE_ReadChunks( FILE * f, unsigned int fileSize, chunk_t * chunks, int maxChunks ) {
|
|
unsigned int offset = ftell( f );
|
|
int numChunks = 0;
|
|
|
|
while ( offset < fileSize ) {
|
|
struct chuckHeader_t {
|
|
unsigned int id;
|
|
unsigned int size;
|
|
} chunkHeader;
|
|
if ( fread( &chunkHeader, sizeof( chunkHeader ), 1, f ) != 1 ) {
|
|
return numChunks;
|
|
}
|
|
Swap( chunkHeader.id );
|
|
offset += sizeof( chunkHeader );
|
|
|
|
if ( numChunks == maxChunks ) {
|
|
return maxChunks + 1;
|
|
}
|
|
|
|
chunks[numChunks].id = chunkHeader.id;
|
|
chunks[numChunks].size = chunkHeader.size;
|
|
chunks[numChunks].offset = offset;
|
|
numChunks++;
|
|
|
|
offset += chunkHeader.size;
|
|
fseek( f, offset, SEEK_SET );
|
|
}
|
|
|
|
return numChunks;
|
|
}
|
|
|
|
bool Process( FILE * in, FILE * out ) {
|
|
|
|
int headerSize = WAVE_ReadHeader( in );
|
|
if ( headerSize == 0 ) {
|
|
printf( "Header invalid\n" );
|
|
return false;
|
|
}
|
|
|
|
static const int MAX_CHUNKS = 32;
|
|
chunk_t chunks[MAX_CHUNKS] = {};
|
|
|
|
int numChunks = WAVE_ReadChunks( in, headerSize + 8, chunks, MAX_CHUNKS );
|
|
if ( numChunks == 0 ) {
|
|
printf( "No chunks\n" );
|
|
return false;
|
|
}
|
|
if ( numChunks > MAX_CHUNKS ) {
|
|
printf( "Too many chunks\n" );
|
|
return false;
|
|
}
|
|
|
|
format_t format;
|
|
bool foundFormat = false;
|
|
unsigned int dataOffset = 0;
|
|
unsigned int dataSize = 0;
|
|
for ( int i = 0; i < numChunks; i++ ) {
|
|
if ( chunks[i].id == 'fmt ' ) {
|
|
if ( foundFormat ) {
|
|
printf( "Found multiple format chunks\n" );
|
|
return false;
|
|
}
|
|
if ( chunks[i].size < sizeof( format ) ) {
|
|
printf( "Format chunk too small\n" );
|
|
return false;
|
|
}
|
|
fseek( in, chunks[i].offset, SEEK_SET );
|
|
fread( &format, sizeof( format ), 1, in );
|
|
foundFormat = true;
|
|
}
|
|
if ( chunks[i].id == 'data' ) {
|
|
if ( dataOffset > 0 ) {
|
|
printf( "Found multiple data chunks\n" );
|
|
return false;
|
|
}
|
|
dataOffset = chunks[i].offset;
|
|
dataSize = chunks[i].size;
|
|
}
|
|
}
|
|
if ( dataOffset == 0 ) {
|
|
printf( "Colud not find data chunk\n" );
|
|
return false;
|
|
}
|
|
if ( !foundFormat ) {
|
|
printf( "Could not find fmt chunk\n" );
|
|
return false;
|
|
}
|
|
if ( format.formatTag != FORMAT_PCM ) {
|
|
printf( "Only PCM files supported (%d)\n", format.formatTag );
|
|
return false;
|
|
}
|
|
if ( format.bitsPerSample != 8 && format.bitsPerSample != 16 ) {
|
|
printf( "Only 8 or 16 bit files supported (%d)\n", format.bitsPerSample );
|
|
return false;
|
|
}
|
|
if ( format.numChannels != 1 && format.numChannels != 2 ) {
|
|
printf( "Only stereo or mono files supported (%d)\n", format.numChannels );
|
|
return false;
|
|
}
|
|
unsigned short expectedSampleSize = format.numChannels * format.bitsPerSample / 8;
|
|
if ( format.sampleSize != expectedSampleSize ) {
|
|
printf( "Invalid sampleSize (%d, expected %d)\n", format.sampleSize, expectedSampleSize );
|
|
return false;
|
|
}
|
|
unsigned int numSamples = dataSize / expectedSampleSize;
|
|
|
|
void * inputData = malloc( dataSize );
|
|
if ( inputData == NULL ) {
|
|
printf( "Out of memory\n" );
|
|
return false;
|
|
}
|
|
fseek( in, dataOffset, SEEK_SET );
|
|
fread( inputData, dataSize, 1, in );
|
|
|
|
int numOutputSamples = 1 + ( numSamples * SAMPLE_RATE / format.samplesPerSec );
|
|
float * min = (float *)malloc( numOutputSamples * sizeof( float ) );
|
|
float * max = (float *)malloc( numOutputSamples * sizeof( float ) );
|
|
unsigned char * outputData = (unsigned char *)malloc( numOutputSamples );
|
|
if ( min == NULL || max == NULL || outputData == NULL ) {
|
|
printf( "Out of memory\n" );
|
|
free( inputData );
|
|
free( min );
|
|
free( max );
|
|
free( outputData );
|
|
return false;
|
|
}
|
|
for ( int i = 0; i < numOutputSamples; i++ ) {
|
|
max[i] = -1.0f;
|
|
min[i] = 1.0f;
|
|
}
|
|
|
|
if ( format.bitsPerSample == 16 ) {
|
|
short * sdata = (short *)inputData;
|
|
if ( format.numChannels == 1 ) {
|
|
for ( unsigned int i = 0; i < numSamples; i++ ) {
|
|
unsigned int index = i * SAMPLE_RATE / format.samplesPerSec;
|
|
float fdata = (float)sdata[i] / 32767.0f;
|
|
min[index] = __min( min[index], fdata );
|
|
max[index] = __max( max[index], fdata );
|
|
}
|
|
} else {
|
|
unsigned int j = 0;
|
|
for ( unsigned int i = 0; i < numSamples; i++ ) {
|
|
unsigned int index = i * SAMPLE_RATE / format.samplesPerSec;
|
|
for ( unsigned int c = 0; c < format.numChannels; c++ ) {
|
|
float fdata = (float)sdata[j++] / 32767.0f;
|
|
min[index] = __min( min[index], fdata );
|
|
max[index] = __max( max[index], fdata );
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
unsigned char * bdata = (unsigned char *)inputData;
|
|
if ( format.numChannels == 1 ) {
|
|
for ( unsigned int i = 0; i < numSamples; i++ ) {
|
|
unsigned int index = i * SAMPLE_RATE / format.samplesPerSec;
|
|
float fdata = ( (float)bdata[i] - 128.0f ) / 127.0f;
|
|
min[index] = __min( min[index], fdata );
|
|
max[index] = __max( max[index], fdata );
|
|
}
|
|
} else {
|
|
unsigned int j = 0;
|
|
for ( unsigned int i = 0; i < numSamples; i++ ) {
|
|
unsigned int index = i * SAMPLE_RATE / format.samplesPerSec;
|
|
for ( unsigned int c = 0; c < format.numChannels; c++ ) {
|
|
float fdata = ( (float)bdata[j++] - 128.0f ) / 127.0f;
|
|
min[index] = __min( min[index], fdata );
|
|
max[index] = __max( max[index], fdata );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for ( int i = 0; i < numOutputSamples; i++ ) {
|
|
float amp = atan( max[i] - min[i] ) / 0.7853981633974483f;
|
|
int o = (int)( amp * 255.0f );
|
|
if ( o > 255 ) {
|
|
outputData[i] = 255;
|
|
} else if ( o < 0 ) {
|
|
outputData[i] = 0;
|
|
} else {
|
|
outputData[i] = (unsigned char)o;
|
|
}
|
|
}
|
|
fwrite( outputData, numOutputSamples, 1, out );
|
|
|
|
free( inputData );
|
|
free( min );
|
|
free( max );
|
|
free( outputData );
|
|
|
|
printf( "Success\n" );
|
|
return true;
|
|
}
|
|
|
|
int main(int argc, char * argv[]) {
|
|
|
|
if ( argc < 2 ) {
|
|
printf( "Usage: %s <wav>\n", argv[0] );
|
|
return E_ARGS;
|
|
}
|
|
const char * inputFileName = argv[1];
|
|
|
|
printf( "Processing %s: ", inputFileName );
|
|
|
|
FILE * in = NULL;
|
|
if ( fopen_s( &in, inputFileName, "rb" ) != 0 ) {
|
|
printf( "Could not open input file\n" );
|
|
return E_OPEN_IN;
|
|
}
|
|
char outputFileName[1024] = {0};
|
|
if ( strcpy_s( outputFileName, inputFileName ) != 0 ) {
|
|
printf( "Filename too long\n" );
|
|
return E_ARGS;
|
|
}
|
|
char * dot = strrchr( outputFileName, '.' );
|
|
if ( dot == NULL ) {
|
|
dot = outputFileName + strlen( outputFileName );
|
|
}
|
|
if ( strcpy_s( dot, sizeof( outputFileName ) - ( dot - outputFileName ), ".amp" ) != 0 ) {
|
|
printf( "Filename too long\n" );
|
|
return E_ARGS;
|
|
}
|
|
|
|
FILE * out = NULL;
|
|
if ( fopen_s( &out, outputFileName, "wb" ) != 0 ) {
|
|
printf( "Could not open output file %s\n", outputFileName );
|
|
return E_OPEN_OUT;
|
|
}
|
|
|
|
bool success = Process( in, out );
|
|
|
|
fclose( in );
|
|
fclose( out );
|
|
|
|
if ( !success ) {
|
|
remove( outputFileName );
|
|
return E_PROCESSING;
|
|
}
|
|
|
|
return E_OK;
|
|
}
|