cml/libcw
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
7ed651a7c3
libcw/cwAudioFile.cpp

2239 lines
60 KiB
C++
Raw Blame History

#include "cwCommon.h"
#include "cwLog.h"
#include "cwCommonImpl.h"
#include "cwTest.h"
#include "cwMem.h"
#include "cwFile.h"
#include "cwObject.h"
#include "cwAudioFile.h"
#include "cwMath.h"
#include "cwFileSys.h"
// #define _24to32_aif( p ) ((int)( ((p[0]>127?255:0) << 24) + (((int)p[0]) << 16) + (((int)p[1]) <<8) + p[2])) // no-swap equivalent
// See note in:_cmAudioFileReadFileHdr()
// Note that this code byte swaps as it converts - this is to counter the byte swap that occurs in cmAudioFileReadInt().
#define _24to32_aif( p ) ((int)( ((p[0]>127?255:0) << 0) + (((int)p[2]) << 24) + (((int)p[1]) <<16) + (((int)p[0]) << 8)))
#define _24to32_wav( p ) ((int)( ((p[2]>127?255:0) << 24) + (((int)p[2]) << 16) + (((int)p[1]) <<8) + p[0]))
#define _cmAfSwap16(v) cwSwap16(v)
#define _cmAfSwap32(v) cwSwap32(v)
#ifdef cmBIG_ENDIAN
#define _cmAifSwapFl (0)
#define _cmWavSwapFl (1)
#else
#define _cmAifSwapFl (1)
#define _cmWavSwapFl (0)
#endif
namespace cw
{
namespace audiofile
{
enum
{
kAiffFileId = 'FORM',
kAiffChkId = 'AIFF',
kAifcChkId = 'AIFC',
kSowtCompId = 'sowt',
kNoneCompId = 'NONE',
kWavFileId = 'FFIR',
kWavChkId = 'EVAW',
};
enum
{
kWriteAudioGutsFl = 0x01,
kWriteFloatFl = 0x02
};
enum
{
kIntegerFmtId = 1,
kFloatFmtId = 3,
kBitsPerByte = 8,
kMax24Bits = 0x007fffff,
kMax16Bits = 0x00007fff,
kMax32Bits = 0x7fffffff
};
typedef struct audiofile_str
{
FILE* fp;
info_t info; // audio file details
unsigned curFrmIdx; // current frame offset
unsigned fileByteCnt; // file byte cnt
unsigned smpByteOffs; // byte offset of the first sample
marker_t* markArray;
unsigned flags;
char* fn;
} af_t;
rc_t _writeHdr( af_t* p );
af_t* _handleToPtr( handle_t h )
{ return handleToPtr<handle_t,af_t>(h); }
rc_t _destroy( af_t* p )
{
rc_t rc = kOkRC;
if( p != nullptr )
{
if( cwIsFlag(p->flags, kWriteAudioGutsFl ) )
if((rc = _writeHdr(p)) != kOkRC )
return rc;
if( p->fp != nullptr )
{
fclose(p->fp);
p->fp = nullptr;
}
mem::release(p->fn);
mem::release(p);
}
return rc;
}
rc_t _seek( af_t* p, long byteOffset, int origin )
{
if( fseek(p->fp,byteOffset,origin) != 0 )
return cwLogError(kSeekFailRC,"Audio file seek failed on '%s'.",cwStringNullGuard(p->fn));
return kOkRC;
}
rc_t _read( af_t* p, void* eleBuf, unsigned bytesPerEle, unsigned eleCnt )
{
if( fread(eleBuf,bytesPerEle,eleCnt,p->fp) != eleCnt )
return cwLogError(kReadFailRC,"Audio file read failed on '%s'.",cwStringNullGuard(p->fn));
return kOkRC;
}
rc_t _readUInt32( af_t* p, std::uint32_t* valuePtr )
{
rc_t rc;
if(( rc = _read(p, valuePtr, sizeof(*valuePtr), 1 )) != kOkRC )
return rc;
if( cwIsFlag(p->info.flags,kSwapAfFl) )
*valuePtr = _cmAfSwap32(*valuePtr);
return rc;
}
rc_t _readUInt16( af_t* p, std::uint16_t* valuePtr )
{
rc_t rc;
if(( rc = _read(p, valuePtr, sizeof(*valuePtr), 1 )) != kOkRC )
return rc;
if( cwIsFlag(p->info.flags,kSwapAfFl) )
*valuePtr = _cmAfSwap16(*valuePtr);
return rc;
}
rc_t _readPascalString( af_t* p, char s[kAudioFileLabelCharCnt] )
{
rc_t rc;
unsigned char n;
if((rc = _read(p,&n,sizeof(n),1)) != kOkRC )
return rc;
if((rc = _read(p,s,n,1)) != kOkRC )
return rc;
s[n] = '\0';
if( n % 2 == 0 )
rc = _seek(p,1,SEEK_CUR);
return rc;
}
rc_t _readString( af_t* p, char* s, unsigned sn )
{
rc_t rc;
if((rc = _read(p,s,sn,1)) != kOkRC )
return rc;
return kOkRC;
}
rc_t _readX80( af_t* p, double* x80Ptr )
{
unsigned char s[10];
rc_t rc = kOkRC;
if((rc = _read(p,s,10,1)) != kOkRC )
return rc;
*x80Ptr = math::x80ToDouble(s);
return kOkRC;
}
rc_t _readChunkHdr( af_t* p, std::uint32_t* chkIdPtr, unsigned* chkByteCntPtr )
{
rc_t rc = kOkRC;
*chkIdPtr = 0;
*chkByteCntPtr = 0;
if((rc = _readUInt32(p,chkIdPtr)) != kOkRC )
return rc;
if((rc = _readUInt32(p,chkByteCntPtr)) != kOkRC )
return rc;
// the actual on disk chunk size is always incrmented up to the next even integer
*chkByteCntPtr += (*chkByteCntPtr) % 2;
return rc;
}
rc_t _readFileHdr( af_t* p, unsigned constFormId, unsigned constAifId, bool swapFl )
{
rc_t rc = kOkRC;
std::uint32_t formId = 0;
std::uint32_t aifId = 0;
unsigned chkByteCnt = 0;
p->info.flags = 0;
p->curFrmIdx = 0;
p->fileByteCnt = 0;
if((rc = _seek(p,0,SEEK_SET)) != kOkRC )
return rc;
// set the swap flags
p->info.flags = cwEnaFlag(p->info.flags,kSwapAfFl, swapFl);
p->info.flags = cwEnaFlag(p->info.flags,kSwapSamplesAfFl,swapFl);
if((rc = _readChunkHdr(p,&formId,&p->fileByteCnt)) != kOkRC )
return rc;
//
// use -Wno-multichar on GCC cmd line to disable the multi-char warning
//
// check the FORM/RIFF id
if( formId != constFormId )
return kSyntaxErrorRC;
// read the AIFF/WAVE id
if((rc = _readChunkHdr(p,&aifId,&chkByteCnt)) != kOkRC )
return rc;
// check for the AIFC
if( formId == kAiffFileId && aifId != constAifId )
{
if( aifId == kAifcChkId )
p->info.flags = cwSetFlag(p->info.flags,kAifcAfFl);
else
return kInvalidDataTypeRC;
}
// set the audio file type flag
if( aifId==kAiffChkId || aifId==kAifcChkId )
p->info.flags = cwSetFlag(p->info.flags,kAiffAfFl);
if( aifId==kWavChkId )
p->info.flags = cwSetFlag(p->info.flags,kWavAfFl);
return rc;
}
rc_t _readCommChunk( af_t* p )
{
rc_t rc = kOkRC;
std::uint16_t ui16;
std::uint32_t ui32;
if((rc = _readUInt16(p,&ui16)) != kOkRC )
return rc;
p->info.chCnt = ui16;
if((rc = _readUInt32(p,&ui32)) != kOkRC )
return rc;
p->info.frameCnt = ui32;
if((rc = _readUInt16(p,&ui16)) != kOkRC )
return rc;
p->info.bits = ui16;
if((rc = _readX80(p,&p->info.srate)) != kOkRC )
return rc;
// if this is an AIFC format file ...
if( cwIsFlag(p->info.flags,kAifcAfFl) )
{
if((rc = _readUInt32(p,&ui32)) != kOkRC )
return rc;
switch( ui32 )
{
case kNoneCompId:
break;
case kSowtCompId:
// If the compression type is set to 'swot'
// then the samples are written in little-endian (Intel) format
// rather than the default big-endian format.
p->info.flags = cwTogFlag(p->info.flags,kSwapSamplesAfFl);
break;
default:
rc = cwLogError(kSyntaxErrorRC,"Unknown AIFC type id: 0x%x in '%s'.",ui32,cwStringNullGuard(p->fn) );
}
}
return rc;
}
rc_t _readSsndChunk( af_t* p )
{
rc_t rc = kOkRC;
std::uint32_t smpOffs=0, smpBlkSize=0;
if((rc = _readUInt32(p,&smpOffs)) != kOkRC )
return rc;
if((rc = _readUInt32(p,&smpBlkSize)) != kOkRC )
return rc;
if((rc = _seek(p,smpOffs, SEEK_CUR)) != kOkRC )
return rc;
p->smpByteOffs = ftell(p->fp);
return rc;
}
rc_t _readMarkerChunk( af_t* p )
{
rc_t rc = kOkRC;
std::uint16_t ui16;
std::uint32_t ui32;
unsigned i;
if((rc = _readUInt16(p,&ui16)) != kOkRC )
return rc;
p->info.markerCnt = ui16;
assert(p->markArray == NULL);
marker_t* m = mem::allocZ<marker_t>(p->info.markerCnt);
p->info.markerArray = m;
for(i=0; i<p->info.markerCnt; ++i)
{
if((rc = _readUInt16(p,&ui16)) != kOkRC )
return rc;
m[i].id = ui16;
if((rc = _readUInt32(p,&ui32)) != kOkRC )
return rc;
m[i].frameIdx = ui32;
if((rc = _readPascalString(p,m[i].label)) != kOkRC )
return rc;
}
return rc;
}
rc_t _readFmtChunk( af_t* p )
{
rc_t rc = kOkRC;
unsigned short fmtId, chCnt, blockAlign, bits;
unsigned srate, bytesPerSec;
if((rc = _readUInt16(p,&fmtId)) != kOkRC )
return rc;
if((rc = _readUInt16(p,&chCnt)) != kOkRC )
return rc;
if((rc = _readUInt32(p,&srate)) != kOkRC )
return rc;
if((rc = _readUInt32(p,&bytesPerSec)) != kOkRC )
return rc;
if((rc = _readUInt16(p,&blockAlign)) != kOkRC )
return rc;
if((rc = _readUInt16(p,&bits)) != kOkRC )
return rc;
p->info.chCnt = chCnt;
p->info.bits = bits;
p->info.srate = srate;
p->flags = fmtId == kFloatFmtId ? kWriteFloatFl : 0;
// if the 'data' chunk was read before the 'fmt' chunk then info.frameCnt
// holds the number of bytes in the data chunk
if( p->info.frameCnt != 0 )
p->info.frameCnt = p->info.frameCnt / (p->info.chCnt * (p->info.bits/kBitsPerByte));
return rc;
}
rc_t _readDatcmhunk( af_t* p, unsigned chkByteCnt )
{
// if the 'fmt' chunk was read before the 'data' chunk then info.chCnt is non-zero
if( p->info.chCnt != 0 )
p->info.frameCnt = chkByteCnt / (p->info.chCnt * (p->info.bits/kBitsPerByte));
else
p->info.frameCnt = chkByteCnt;
p->smpByteOffs = ftell(p->fp);
return kOkRC;
}
rc_t _readBextChunk( af_t* p)
{
rc_t rc = kOkRC;
if((rc = _readString(p,p->info.bextRecd.desc,kAfBextDescN)) != kOkRC )
return rc;
if((rc = _readString(p,p->info.bextRecd.origin,kAfBextOriginN)) != kOkRC )
return rc;
if((rc = _readString(p,p->info.bextRecd.originRef,kAfBextOriginRefN)) != kOkRC )
return rc;
if((rc = _readString(p,p->info.bextRecd.originDate,kAfBextOriginDateN)) != kOkRC )
return rc;
if((rc = _readString(p,p->info.bextRecd.originTime,kAfBextOriginTimeN)) != kOkRC )
return rc;
if((rc = _readUInt32(p,&p->info.bextRecd.timeRefLow)) != kOkRC )
return rc;
if((rc = _readUInt32(p,&p->info.bextRecd.timeRefHigh)) != kOkRC )
return rc;
return rc;
}
rc_t _open( af_t* p, const char* fname, const char* fileModeStr )
{
rc_t rc = kOkRC;
char* fn = nullptr;
// zero the info record
memset(&p->info,0,sizeof(p->info));
// expand the path
if((fn = filesys::expandPath(fname)) == nullptr )
{
rc = cwLogError(kOpFailRC,"File path expansion failed on '%s'.",cwStringNullGuard(fname));
goto errLabel;
}
// open the file
if((p->fp = fopen(fn,fileModeStr)) == NULL )
{
rc = cwLogError(kOpenFailRC,"Audio file open failed on '%s'.",cwStringNullGuard(fname));
goto errLabel;
}
// read the file header
if((rc = _readFileHdr(p,kAiffFileId,kAiffChkId,_cmAifSwapFl)) != kOkRC )
if((rc = _readFileHdr(p,kWavFileId,kWavChkId,_cmWavSwapFl)) != kOkRC )
goto errLabel;
// seek past the file header
if((rc = _seek(p,12,SEEK_SET)) != kOkRC )
goto errLabel;
// zero chCnt and frameCnt to allow the order of the 'data' and 'fmt' chunks to be noticed
p->info.chCnt = 0;
p->info.frameCnt = 0;
while( ftell(p->fp ) < p->fileByteCnt )
{
unsigned chkId, chkByteCnt;
if((rc = _readChunkHdr(p,&chkId,&chkByteCnt)) != kOkRC )
goto errLabel;
unsigned offs = ftell(p->fp);
if( cwIsFlag(p->info.flags,kAiffAfFl) )
switch(chkId)
{
case 'COMM':
if((rc = _readCommChunk(p)) != kOkRC )
goto errLabel;
break;
case 'SSND':
if((rc = _readSsndChunk(p)) != kOkRC )
goto errLabel;
break;
case 'MARK':
if((rc = _readMarkerChunk(p)) != kOkRC )
goto errLabel;
break;
}
else
switch(chkId)
{
case ' tmf':
if((rc = _readFmtChunk(p)) != kOkRC )
goto errLabel;
break;
case 'atad':
if((rc = _readDatcmhunk(p,chkByteCnt)) != kOkRC )
goto errLabel;
break;
case 'txeb':
if((rc = _readBextChunk(p)) != kOkRC )
goto errLabel;
break;
}
// seek to the end of this chunk
if((rc = _seek(p,offs+chkByteCnt,SEEK_SET)) != kOkRC )
goto errLabel;
}
errLabel:
if( rc!=kOkRC )
_destroy(p);
mem::release(fn);
return rc;
}
rc_t _writeBytes( af_t* p, const void* b, unsigned bn )
{
rc_t rc = kOkRC;
if( fwrite( b, bn, 1, p->fp ) != 1 )
return cwLogError(kWriteFailRC,"Audio file write failed on '%s'.",cwStringNullGuard(p->fn));
return rc;
}
rc_t _writeId( af_t* p, const char* s )
{ return _writeBytes( p, s, strlen(s)) ; }
rc_t _writeUInt32( af_t* p, unsigned v )
{
if( cwIsFlag(p->info.flags,kSwapAfFl) )
v = _cmAfSwap32(v);
return _writeBytes( p, &v, sizeof(v)) ;
}
rc_t _writeUInt16( af_t* p, unsigned short v )
{
if( cwIsFlag(p->info.flags,kSwapAfFl) )
v = _cmAfSwap16(v);
return _writeBytes( p, &v, sizeof(v)) ;
}
rc_t _writeAiffHdr( af_t* p )
{
rc_t rc = kOkRC;
unsigned char srateX80[10];
math::doubleToX80( p->info.srate, srateX80 );
unsigned hdrByteCnt = 54;
unsigned ssndByteCnt = 8 + (p->info.chCnt * p->info.frameCnt * (p->info.bits/kBitsPerByte));
unsigned formByteCnt = hdrByteCnt + ssndByteCnt - 8;
unsigned commByteCnt = 18;
unsigned ssndSmpOffs = 0;
unsigned ssndBlkSize = 0;
// if ssndByteCnt is odd
if( ssndByteCnt % 2 == 1 )
{
formByteCnt++;
}
if(( rc = _seek( p, 0, SEEK_SET )) != kOkRC )
return rc;
if(( rc = _writeId( p, "FORM")) != kOkRC ) return rc;
if(( rc = _writeUInt32( p, formByteCnt)) != kOkRC ) return rc;
if(( rc = _writeId( p, "AIFF")) != kOkRC ) return rc;
if(( rc = _writeId( p, "COMM")) != kOkRC ) return rc;
if(( rc = _writeUInt32( p, commByteCnt)) != kOkRC ) return rc;
if(( rc = _writeUInt16( p, p->info.chCnt)) != kOkRC ) return rc;
if(( rc = _writeUInt32( p, p->info.frameCnt)) != kOkRC ) return rc;
if(( rc = _writeUInt16( p, p->info.bits)) != kOkRC ) return rc;
if(( rc = _writeBytes( p, &srateX80,10)) != kOkRC ) return rc;
if(( rc = _writeId( p, "SSND")) != kOkRC ) return rc;
if(( rc = _writeUInt32( p, ssndByteCnt)) != kOkRC ) return rc;
if(( rc = _writeUInt32( p, ssndSmpOffs)) != kOkRC ) return rc;
if(( rc = _writeUInt32( p, ssndBlkSize)) != kOkRC ) return rc;
return rc;
}
rc_t _writeWavHdr( af_t* p )
{
rc_t rc = kOkRC;
short chCnt = p->info.chCnt;
unsigned frmCnt = p->info.frameCnt;
short bits = p->info.bits;
unsigned srate = p->info.srate;
short fmtId = p->flags & kWriteFloatFl ? kFloatFmtId : kIntegerFmtId;
unsigned bytesPerSmp = bits/kBitsPerByte;
unsigned hdrByteCnt = 36;
unsigned fmtByteCnt = 16;
unsigned blockAlignCnt = chCnt * bytesPerSmp;
unsigned sampleCnt = chCnt * frmCnt;
unsigned dataByteCnt = sampleCnt * bytesPerSmp;
if(( rc = _seek( p, 0, SEEK_SET )) != kOkRC )
return rc;
if((rc = _writeId( p, "RIFF")) != kOkRC ) goto errLabel;
if((rc = _writeUInt32( p, hdrByteCnt + dataByteCnt)) != kOkRC ) goto errLabel;
if((rc = _writeId( p, "WAVE")) != kOkRC ) goto errLabel;
if((rc = _writeId( p, "fmt ")) != kOkRC ) goto errLabel;
if((rc = _writeUInt32( p, fmtByteCnt)) != kOkRC ) goto errLabel;
if((rc = _writeUInt16( p, fmtId)) != kOkRC ) goto errLabel;
if((rc = _writeUInt16( p, chCnt)) != kOkRC ) goto errLabel;
if((rc = _writeUInt32( p, srate)) != kOkRC ) goto errLabel;
if((rc = _writeUInt32( p, srate * blockAlignCnt)) != kOkRC ) goto errLabel;
if((rc = _writeUInt16( p, blockAlignCnt)) != kOkRC ) goto errLabel;
if((rc = _writeUInt16( p, bits)) != kOkRC ) goto errLabel;
if((rc = _writeId( p, "data")) != kOkRC ) goto errLabel;
if((rc = _writeUInt32( p, dataByteCnt)) != kOkRC ) goto errLabel;
errLabel:
return rc;
}
rc_t _writeHdr( af_t* p )
{
if( cwIsFlag(p->info.flags,kWavAfFl) )
return _writeWavHdr(p);
return _writeAiffHdr(p);
}
rc_t _filenameToAudioFileType( const char* fn, unsigned& flagsRef )
{
rc_t rc = kOkRC;
filesys::pathPart_t* pp = nullptr;
if((pp = filesys::pathParts(fn)) == NULL )
{
rc = cwLogError(kInvalidArgRC,"The audio file name '%s' could not be parsed.",cwStringNullGuard(fn));
goto errLabel;
}
if(pp->extStr == nullptr )
{
rc = cwLogError(kInvalidArgRC,"The audio file name '%s' does not have an extension.",cwStringNullGuard(fn));
goto errLabel;
}
else
{
// convert the extension to upper case
unsigned extN = strlen(pp->extStr);
char ext[ extN+1 ];
for(unsigned i=0; i<extN; ++i)
ext[i] = toupper(pp->extStr[i]);
ext[extN] = 0;
if( strcmp(ext,"WAV") == 0 )
{
flagsRef = cwSetFlag(flagsRef, kWavAfFl);
flagsRef = cwClrFlag(flagsRef, kAiffAfFl);
}
else
if( strcmp(ext,"AIF")==0 || strcmp(ext,"AIFF")==0 )
{
flagsRef = cwClrFlag(flagsRef, kWavAfFl);
flagsRef = cwSetFlag(flagsRef, kAiffAfFl);
}
else
{
rc = cwLogError(kInvalidArgRC,"The audio file extension '%s' does not match WAV,AIFF,or AIF.", ext );
}
}
errLabel:
mem::release(pp);
return rc;
}
rc_t _readInt( handle_t h, unsigned totalFrmCnt, unsigned chIdx, unsigned chCnt, int* buf[], unsigned* actualFrmCntPtr, bool sumFl )
{
rc_t rc = kOkRC;
af_t* p = _handleToPtr(h);
//if( p->flags & kWriteFloatFl )
// return cwLogError(kOpFailRC,"Conversion from floating point samples to integer output is not implemented.");
if( chIdx+chCnt > p->info.chCnt )
return cwLogError(kInvalidArgRC,"Invalid channel index on read. %i > %i",chIdx+chCnt,chCnt);
if( actualFrmCntPtr != NULL )
*actualFrmCntPtr = 0;
unsigned bps = p->info.bits / kBitsPerByte; // bytes per sample
unsigned bpf = bps * p->info.chCnt; // bytes per file frame
unsigned bufFrmCnt = std::min(totalFrmCnt,(unsigned)cwAudioFile_MAX_FRAME_READ_CNT);
unsigned bytesPerBuf = bufFrmCnt * bpf;
unsigned char fbuf[ bytesPerBuf ]; // raw bytes buffer
unsigned ci;
unsigned frmCnt = 0;
unsigned totalReadFrmCnt;
int* ptrBuf[ chCnt ];
for(ci=0; ci<chCnt; ++ci)
ptrBuf[ci] = buf[ci];
for(totalReadFrmCnt=0; totalReadFrmCnt<totalFrmCnt; totalReadFrmCnt+=frmCnt )
{
// don't read past the end of the file or past the end of the buffer
frmCnt = std::min( p->info.frameCnt - p->curFrmIdx, std::min( totalFrmCnt-totalReadFrmCnt, bufFrmCnt ));
// read the file frmCnt sample
if((rc = _read(p,fbuf,frmCnt*bpf,1)) != kOkRC )
return rc;
if( actualFrmCntPtr != NULL )
*actualFrmCntPtr += frmCnt;
assert( chIdx+chCnt <= p->info.chCnt );
for(ci=0; ci<chCnt; ++ci)
{
unsigned char* sp = fbuf + (ci+chIdx)*bps;
int* dp = ptrBuf[ci];
int* ep = dp + frmCnt;
if( !sumFl )
memset(dp,0,frmCnt*sizeof(int));
// 8 bit AIF files use 'signed char' and WAV files use 'unsigned char' for the sample data type.
if( p->info.bits == 8 )
{
if( cwIsFlag(p->info.flags,kAiffAfFl) )
{
for(; dp<ep; sp+=bpf,++dp)
*dp += *(char*)sp;
}
else
{
for(; dp<ep; sp+=bpf,++dp)
{
int v = *(unsigned char*)sp;
*dp += v -= 128;
}
}
}
// handle non-8 bit files here
if( cwIsFlag(p->info.flags,kSwapSamplesAfFl) )
{
switch( p->info.bits )
{
case 8:
break;
case 16:
for(; dp<ep; sp+=bpf,++dp)
*dp += (short)_cmAfSwap16(*(short*)sp);
break;
case 24:
if( cwIsFlag(p->info.flags,kAiffAfFl) )
{
for(; dp<ep; sp+=bpf,++dp)
*dp += (int)(_cmAfSwap32(_24to32_aif(sp)));
}
else
{
for(; dp<ep; sp+=bpf,++dp)
*dp += (int)(_cmAfSwap32(_24to32_wav(sp)));
}
break;
case 32:
for(; dp<ep; sp+=bpf,++dp)
*dp += (int)_cmAfSwap32(*(int*)sp );
break;
}
}
else
{
switch(p->info.bits)
{
case 8:
break;
case 16:
for(; dp<ep; sp+=bpf,++dp)
*dp += *(short*)sp;
break;
case 24:
if( cwIsFlag(p->info.flags,kAiffAfFl) )
{
for(; dp<ep; sp+=bpf,++dp)
*dp += _24to32_aif(sp);
}
else
{
for(; dp<ep; sp+=bpf,++dp)
*dp += _24to32_wav(sp);
}
break;
case 32:
for(; dp<ep; sp+=bpf,++dp)
*dp += *(int*)sp;
break;
}
ptrBuf[ci] = dp;
assert( dp <= buf[ci] + totalFrmCnt );
}
/*
dp = ptrBuf[ci];
ep = dp + frmCnt;
while(dp<ep)
sum += (double)*dp++;
*/
}
p->curFrmIdx += frmCnt;
}
if( totalReadFrmCnt < totalFrmCnt )
{
for(ci=0; ci<chCnt; ++ci)
memset(buf[ci] + frmCnt,0,(totalFrmCnt-totalReadFrmCnt)*sizeof(int));
}
//if( actualFrmCntPtr != NULL )
// *actualFrmCntPtr = totalReadFrmCnt;
//printf("SUM: %f %f swap:%i\n", sum, sum/(totalFrmCnt*chCnt), cwIsFlag(p->info.flags,kSwapAfFl));
return rc;
}
rc_t _readRealSamples( handle_t h, unsigned totalFrmCnt, unsigned chIdx, unsigned chCnt, float** fbuf, double** dbuf, unsigned* actualFrmCntPtr, bool sumFl )
{
rc_t rc = kOkRC;
af_t* p = _handleToPtr(h);
if( actualFrmCntPtr != NULL )
*actualFrmCntPtr = 0;
unsigned totalReadCnt = 0;
unsigned bufFrmCnt = std::min( totalFrmCnt, (unsigned)cwAudioFile_MAX_FRAME_READ_CNT );
unsigned bufSmpCnt = bufFrmCnt * chCnt;
float fltMaxSmpVal = 0;
int buf[ bufSmpCnt ];
int* ptrBuf[ chCnt ];
float* fPtrBuf[ chCnt ];
double* dPtrBuf[ chCnt ];
unsigned i;
unsigned frmCnt = 0;
switch( p->info.bits )
{
case 8: fltMaxSmpVal = 0x80; break;
case 16: fltMaxSmpVal = 0x8000; break;
case 24: fltMaxSmpVal = 0x800000; break;
case 32: fltMaxSmpVal = 0x80000000; break;
default:
return cwLogError(kInvalidArgRC,"Audio file invalid sample word size:%i bits.",p->info.bits);
}
double dblMaxSmpVal = fltMaxSmpVal;
// initialize the audio ptr buffers
for(i=0; i<chCnt; ++i)
{
ptrBuf[i] = buf + (i*bufFrmCnt);
if( dbuf != NULL )
dPtrBuf[i] = dbuf[i];
if( fbuf != NULL )
fPtrBuf[i] = fbuf[i];
}
//
for(totalReadCnt=0; totalReadCnt<totalFrmCnt && p->curFrmIdx < p->info.frameCnt; totalReadCnt+=frmCnt)
{
unsigned actualReadFrmCnt = 0;
frmCnt = std::min( p->info.frameCnt - p->curFrmIdx, std::min( totalFrmCnt-totalReadCnt, bufFrmCnt ) );
// Fill the integer audio buffer from the file.
// Note that the input format may be float but this is ok since there size is the same and _readInt() does not processes the values.
if((rc = _readInt( h, frmCnt, chIdx, chCnt, ptrBuf, &actualReadFrmCnt, false )) != kOkRC )
return rc;
if( actualFrmCntPtr != NULL )
*actualFrmCntPtr += actualReadFrmCnt;
// Convert the integer buffer to floating point
for(i=0; i<chCnt; ++i)
{
// if the input is already in float format
if( p->flags & kWriteFloatFl )
{
float* sp = (float*)ptrBuf[i];
// if output is in float (not double) format
if( fbuf != NULL )
{
float* dp = fPtrBuf[i];
float* ep = dp + frmCnt;
if( sumFl )
{
for(; dp<ep; ++dp,++sp)
*dp += *sp;
}
else
{
for(; dp<ep; ++dp,++sp)
*dp = *sp;
}
assert( dp <= fbuf[i] + totalFrmCnt );
fPtrBuf[i] = dp;
}
else // uf output is in double (not float) format
{
double* dp = dPtrBuf[i];
double* ep = dp + frmCnt;
if( sumFl )
{
for(; dp<ep; ++dp,++sp)
*dp += ((double)*sp);
}
else
{
for(; dp<ep; ++dp,++sp)
*dp = ((double)*sp);
}
assert( dp <= dbuf[i] + totalFrmCnt );
dPtrBuf[i] = dp;
}
}
else // if input is an integer format (not float format)
{
int* sp = ptrBuf[i];
// if output is float (not double)
if( fbuf != NULL )
{
float* dp = fPtrBuf[i];
float* ep = dp + frmCnt;
if( sumFl )
{
for(; dp<ep; ++dp,++sp)
*dp += ((float)*sp) / fltMaxSmpVal;
}
else
{
for(; dp<ep; ++dp,++sp)
*dp = ((float)*sp) / fltMaxSmpVal;
}
assert( dp <= fbuf[i] + totalFrmCnt );
fPtrBuf[i] = dp;
}
else // output is double (not float)
{
double* dp = dPtrBuf[i];
double* ep = dp + frmCnt;
if( sumFl )
{
for(; dp<ep; ++dp,++sp)
*dp += ((double)*sp) / dblMaxSmpVal;
}
else
{
for(; dp<ep; ++dp,++sp)
*dp = ((double)*sp) / dblMaxSmpVal;
}
assert( dp <= dbuf[i] + totalFrmCnt );
dPtrBuf[i] = dp;
}
}
}
}
return rc;
}
rc_t _readFloat( handle_t h, unsigned frmCnt, unsigned chIdx, unsigned chCnt, float** buf, unsigned* actualFrmCntPtr, bool sumFl )
{
return _readRealSamples(h,frmCnt,chIdx,chCnt,buf, NULL, actualFrmCntPtr, sumFl );
}
rc_t _readDouble( handle_t h, unsigned frmCnt, unsigned chIdx, unsigned chCnt, double** buf, unsigned* actualFrmCntPtr, bool sumFl )
{
return _readRealSamples(h,frmCnt,chIdx,chCnt,NULL, buf, actualFrmCntPtr, sumFl );
}
rc_t _get( handle_t& h, const char* fn, unsigned begFrmIdx, info_t* afInfoPtr )
{
rc_t rc;
if((rc = open( h, fn, afInfoPtr )) == kOkRC )
if( begFrmIdx > 0 )
rc = seek( h, begFrmIdx );
return rc;
}
rc_t _getInt( const char* fn, unsigned begFrmIdx, unsigned frmCnt, unsigned chIdx, unsigned chCnt, int** buf, unsigned* actualFrmCntPtr, info_t* afInfoPtr, bool sumFl )
{
rc_t rc;
handle_t h;
if((rc = _get(h,fn,begFrmIdx,afInfoPtr)) == kOkRC )
rc = _readInt(h, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, sumFl );
close(h);
return rc;
}
rc_t _getFloat( const char* fn, unsigned begFrmIdx, unsigned frmCnt, unsigned chIdx, unsigned chCnt, float** buf, unsigned* actualFrmCntPtr, info_t* afInfoPtr, bool sumFl )
{
rc_t rc;
handle_t h;
if((rc = _get(h,fn,begFrmIdx,afInfoPtr)) == kOkRC )
rc = _readFloat(h, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, sumFl );
close(h);
return rc;
}
rc_t _getDouble( const char* fn, unsigned begFrmIdx, unsigned frmCnt, unsigned chIdx, unsigned chCnt, double** buf, unsigned* actualFrmCntPtr, info_t* afInfoPtr, bool sumFl )
{
rc_t rc;
handle_t h;
if((rc = _get(h,fn,begFrmIdx,afInfoPtr)) == kOkRC )
rc = _readDouble(h, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, sumFl );
close(h);
return rc;
}
rc_t _write_samples_to_file( af_t* p, unsigned bytesPerSmp, unsigned bufSmpCnt, const void* buf )
{
rc_t rc = kOkRC;
if( fwrite( (void*)buf, bufSmpCnt*bytesPerSmp, 1, p->fp ) != 1)
rc = cwLogError(kWriteFailRC,"Audio file write failed on '%s'.",cwStringNullGuard(p->fn));
return rc;
}
//
// Write 8 bit samples
//
// sample writer: int->uint8_t
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const int* sbuf, int8_t* dbuf )
{
for(unsigned i=0; i<bufSmpCnt; ++i)
dbuf[i] = (((long)sbuf[i]*255) / ((long)INT_MAX - INT_MIN)) + 127;
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
// sample writer: float->uint8_t
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const float* sbuf, int8_t* dbuf )
{
for(unsigned i=0; i<bufSmpCnt; ++i)
dbuf[i] = (uint8_t)(sbuf[i] * 128) + 127;
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
// sample writer: double->uint8_t
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const double* sbuf, int8_t* dbuf )
{
for(unsigned i=0; i<bufSmpCnt; ++i)
dbuf[i] = (uint8_t)(sbuf[i] * 128) + 127;
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
//
// Write 16 bit samples
//
// sample writer: int->short
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const int* sbuf, short* dbuf )
{
for(unsigned i=0; i<bufSmpCnt; ++i)
dbuf[i] = ((long)sbuf[i]*2*SHRT_MAX) / ((long)INT_MAX - INT_MIN);
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
// sample writer: float->short
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const float* sbuf, short* dbuf )
{
for(unsigned i=0; i<bufSmpCnt; ++i)
dbuf[i] = (short)(sbuf[i] * SHRT_MAX);
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
// sample writer: double->short
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const double* sbuf, short* dbuf )
{
for(unsigned i=0; i<bufSmpCnt; ++i)
dbuf[i] = (short)(sbuf[i] * SHRT_MAX);
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
//
// Write 24 bit samples
//
inline void int_to_24( int v, uint8_t* d )
{
uint8_t* s = (uint8_t*)(&v);
d[0] = s[0];
d[1] = s[1];
d[2] = s[2];
}
// sample writer: int->int24
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const int* sbuf, uint32_t* dbuf )
{
uint8_t* dbp = (uint8_t*)dbuf;
for(unsigned i=0; i<bufSmpCnt; dbp+=3, ++i)
int_to_24(sbuf[i],dbp);
return _write_samples_to_file(p,3,bufSmpCnt,dbuf);
}
// sample writer: float->int24
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const float* sbuf, uint32_t* dbuf )
{
uint8_t* dbp = (uint8_t*)dbuf;
for(unsigned i=0; i<bufSmpCnt; dbp+=3, ++i)
{
int ismp = sbuf[i]*kMax24Bits;
int_to_24(ismp,dbp);
}
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
// sample writer: double->int24
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const double* sbuf, uint32_t* dbuf )
{
uint8_t* dbp = (uint8_t*)dbuf;
for(unsigned i=0; i<bufSmpCnt; dbp+=3, ++i)
{
int ismp = sbuf[i]*kMax24Bits;
int_to_24(ismp,dbp);
}
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
//
// Write 32 bit samples
//
// sample writer: int->int
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const int* sbuf, int* dbuf )
{
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
// float->int
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const float* sbuf, int* dbuf )
{
for(unsigned i=0; i<bufSmpCnt; ++i)
dbuf[i] = (int)(sbuf[i] * INT_MAX);
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
// double->int
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const double* sbuf, int* dbuf )
{
for(unsigned i=0; i<bufSmpCnt; ++i)
dbuf[i] = (int)(sbuf[i] * INT_MAX);
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
//
// Write float samples
//
// int->float
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const int* sbuf, float* dbuf )
{
for(unsigned i=0; i<bufSmpCnt; ++i)
dbuf[i] = sbuf[i]/INT_MAX;
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
// float->float
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const float* sbuf, float* dbuf )
{
//memcpy(dbuf,sbuf,bufSmpCnt*sizeof(float));
//return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
return _write_samples_to_file(p,sizeof(sbuf[0]),bufSmpCnt,sbuf);
}
// double->float
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const double* sbuf, float* dbuf )
{
for(unsigned i=0; i<bufSmpCnt; ++i)
dbuf[i] = (float)(sbuf[i]);
return _write_samples_to_file(p,sizeof(dbuf[0]),bufSmpCnt,dbuf);
}
template< typename S, typename D >
rc_t _write_samples( af_t* p, unsigned bufSmpCnt, const S* sbuf, D* dbuf)
{
return cwLogError(kInvalidDataTypeRC,"The source and desintation sample types are not supported by the audio file writer.");
}
template< typename S, typename D >
rc_t _write_audio( af_t* p, unsigned srcBufFrmCnt, unsigned chCnt, const S* const * srcPtrPtr )
{
rc_t rc = kOkRC;
// Determine the size of the temporary buffer used for interleaving, type conversion and file writing
unsigned bufFrmCnt = std::min(srcBufFrmCnt,4096u);
unsigned bufSmpCnt = bufFrmCnt*chCnt;
// allocate the temp. buffers
S sbuf[ bufSmpCnt ];
D dbuf[ bufSmpCnt ];
// for each frame in the source
for(unsigned sfi=0; sfi<srcBufFrmCnt; )
{
// copy as many samples as are available into the temp. buffer
unsigned copyFrmN = std::min( bufFrmCnt, srcBufFrmCnt - sfi );
// interleave the source channel signal arrays into the temp buffer
for(unsigned fi=0,si=0; fi<copyFrmN; ++fi)
for(unsigned sci=0; sci<chCnt; ++sci)
sbuf[si++] = srcPtrPtr[sci][sfi+fi];
// convert the sample data types and write the result to the output file
if((rc = _write_samples(p,copyFrmN*chCnt,sbuf,dbuf)) != kOkRC )
break;
p->info.frameCnt += copyFrmN;
sfi += copyFrmN;
}
return rc;
}
/*
rc_t _writeRealSamples( handle_t h, unsigned frmCnt, unsigned chCnt, const void* srcPtrPtr, unsigned realSmpByteCnt )
{
rc_t rc = kOkRC;
af_t* p = _handleToPtr(h);
unsigned bufFrmCnt = 1024;
unsigned wrFrmCnt = 0;
unsigned i = 0;
int maxSmpVal = 0;
int buf[ chCnt * bufFrmCnt ];
int* srcCh[ chCnt ];
for(i=0; i<chCnt; ++i)
srcCh[i] = buf + (i*bufFrmCnt);
switch( p->info.bits )
{
case 8: maxSmpVal = 0x7f; break;
case 16: maxSmpVal = 0x7fff; break;
case 24: maxSmpVal = 0x7fffff; break;
case 32: maxSmpVal = 0x7fffffb0; break; // Note: the full range is not used for 32 bit numbers
default: // because it was found to cause difficult to detect overflows
{ assert(0); } // when the signal approached full scale.
}
// duplicate the audio buffer ptr array - this will allow the buffer ptr's to be changed
// during the float to int conversion without changing the ptrs passed in from the client
const void* ptrArray[ chCnt ];
memcpy(ptrArray,srcPtrPtr,sizeof(ptrArray));
const float** sfpp = (const float**)ptrArray;
const double** sdpp = (const double**)ptrArray;
while( wrFrmCnt < frmCnt )
{
unsigned n = std::min( frmCnt - wrFrmCnt, bufFrmCnt );
for(i=0; i<chCnt; ++i)
{
int* obp = srcCh[i];
switch( realSmpByteCnt )
{
case 4:
{
const float* sbp = sfpp[i];
const float* sep = sbp + n;
for(;sbp<sep; ++sbp)
{
*obp++ = (int)fmaxf(-maxSmpVal,fminf(maxSmpVal, *sbp * maxSmpVal));
}
sfpp[i] = sbp;
}
break;
case 8:
{
const double* sbp = sdpp[i];
const double* sep = sbp + n;
for(; sbp<sep; ++sbp)
{
*obp++ = (int)fmax(-maxSmpVal,fmin(maxSmpVal,*sbp * maxSmpVal));
}
sdpp[i] = sbp;
}
break;
default:
{ assert(0); }
}
}
if((rc = writeInt( h, n, chCnt, srcCh )) != kOkRC )
break;
wrFrmCnt += n;
}
return rc;
}
*/
void _test( const char* audioFn )
{
info_t afInfo;
rc_t rc;
// open an audio file
handle_t afH;
if((rc = open( afH, audioFn, &afInfo )) == kOkRC )
{
report( afH, log::globalHandle(), 0, 0);
close(afH);
}
}
rc_t _testReport( const object_t* cfg )
{
rc_t rc = kOkRC;
const char* fn = nullptr;
unsigned begIdx = 0;
unsigned frmN = 0;
if((rc = cfg->getv("fn",fn,"begIdx",begIdx,"frmCnt",frmN)) != kOkRC )
return cwLogError(kSyntaxErrorRC,"Invalid parameter to audio file report test.");
char* afn = filesys::expandPath(fn);
rc = reportFn(afn,log::globalHandle(),begIdx,frmN);
mem::release(afn);
return rc;
}
}
}
cw::rc_t cw::audiofile::open( handle_t& h, const char* fn, info_t* info )
{
rc_t rc;
if((rc = close(h)) != kOkRC )
return rc;
af_t* p = mem::allocZ<af_t>(1);
// read the file header
if((rc = _open(p, fn, "rb" )) != kOkRC )
goto errLabel;
// seek to the first sample offset
if((rc = _seek(p,p->smpByteOffs,SEEK_SET)) != kOkRC )
goto errLabel;
p->fn = mem::duplStr( fn );
if( info != NULL)
memcpy(info,&p->info,sizeof(info_t));
h.set(p);
errLabel:
return rc;
}
cw::rc_t cw::audiofile::create( handle_t& h, const char* fname, double srate, unsigned bits, unsigned chCnt )
{
rc_t rc = kOkRC;
af_t* p = nullptr;
char* fn = nullptr;
if((rc = close(h)) != kOkRC )
return rc;
if( fname == NULL || strlen(fname)==0 )
return cwLogError(kInvalidArgRC,"Audio file create failed. The file name is blank.");
if((fn = filesys::expandPath(fname)) == nullptr )
{
rc = cwLogError(kOpFailRC,"File path expansion failed on '%s'.",cwStringNullGuard(fname));
goto errLabel;
}
p = mem::allocZ<af_t>(1);
if((rc = _filenameToAudioFileType(fn, p->info.flags )) != kOkRC )
goto errLabel;
// open the file for writing
if((p->fp = fopen(fn,"wb")) == NULL )
{
rc = cwLogError(kOpenFailRC,"Audio file create failed on '%s'.",cwStringNullGuard(fn));
goto errLabel;
}
else
{
p->fn = mem::duplStr( fn );
p->info.srate = srate;
p->info.bits = bits==0 ? sizeof(float)*kBitsPerByte : bits;
p->info.chCnt = chCnt;
p->info.frameCnt = 0;
p->flags = kWriteAudioGutsFl + (bits==0 ? kWriteFloatFl : 0);
// set the swap flags
bool swapFl = cwIsFlag(p->info.flags,kWavAfFl) ? _cmWavSwapFl : _cmAifSwapFl;
p->info.flags = cwEnaFlag( p->info.flags, kSwapAfFl, swapFl);
p->info.flags = cwEnaFlag( p->info.flags, kSwapSamplesAfFl, swapFl);
if((rc = _writeHdr(p)) != kOkRC )
goto errLabel;
h.set(p);
}
errLabel:
mem::release(fn);
if( rc != kOkRC )
_destroy(p);
return rc;
}
cw::rc_t cw::audiofile::close( handle_t& h )
{
rc_t rc = kOkRC;
if( !h.isValid() )
return rc;
af_t* p = _handleToPtr(h);
if((rc = _destroy(p)) != kOkRC )
return rc;
h.clear();
return rc;
}
bool cw::audiofile::isOpen( handle_t h )
{
if( !h.isValid() )
return false;
return _handleToPtr(h)->fp != NULL;
}
bool cw::audiofile::isEOF( handle_t h )
{
af_t* p = _handleToPtr(h);
return (p->curFrmIdx >= p->info.frameCnt) || (p->fp==NULL) || feof(p->fp) ? true : false;
}
unsigned cw::audiofile::tell( handle_t h )
{
af_t* p = _handleToPtr(h);
return p->curFrmIdx;
}
cw::rc_t cw::audiofile::seek( handle_t h, unsigned frmIdx )
{
rc_t rc = kOkRC;
af_t* p = _handleToPtr(h);
if((rc = _seek(p,p->smpByteOffs + (frmIdx * p->info.chCnt * (p->info.bits/kBitsPerByte)), SEEK_SET)) != kOkRC )
return rc;
p->curFrmIdx = frmIdx;
return rc;
}
cw::rc_t cw::audiofile::readInt( handle_t h, unsigned frmCnt, unsigned chIdx, unsigned chCnt, int** buf, unsigned* actualFrmCntPtr )
{ return _readInt( h, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, false ); }
cw::rc_t cw::audiofile::readFloat( handle_t h, unsigned frmCnt, unsigned chIdx, unsigned chCnt, float** buf, unsigned* actualFrmCntPtr )
{ return _readFloat( h, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, false ); }
cw::rc_t cw::audiofile::readDouble( handle_t h, unsigned frmCnt, unsigned chIdx, unsigned chCnt, double** buf, unsigned* actualFrmCntPtr )
{ return _readDouble( h, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, false ); }
cw::rc_t cw::audiofile::readSumInt( handle_t h, unsigned frmCnt, unsigned chIdx, unsigned chCnt, int** buf, unsigned* actualFrmCntPtr )
{ return _readInt( h, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, true ); }
cw::rc_t cw::audiofile::readSumFloat( handle_t h, unsigned frmCnt, unsigned chIdx, unsigned chCnt, float** buf, unsigned* actualFrmCntPtr )
{ return _readFloat( h, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, true ); }
cw::rc_t cw::audiofile::readSumDouble( handle_t h, unsigned frmCnt, unsigned chIdx, unsigned chCnt, double** buf, unsigned* actualFrmCntPtr )
{ return _readDouble( h, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, true ); }
cw::rc_t cw::audiofile::getInt( const char* fn, unsigned begFrmIdx, unsigned frmCnt, unsigned chIdx, unsigned chCnt, int** buf, unsigned* actualFrmCntPtr, info_t* afInfoPtr )
{ return _getInt( fn, begFrmIdx, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, afInfoPtr, false ); }
cw::rc_t cw::audiofile::getFloat( const char* fn, unsigned begFrmIdx, unsigned frmCnt, unsigned chIdx, unsigned chCnt, float** buf, unsigned* actualFrmCntPtr, info_t* afInfoPtr )
{ return _getFloat( fn, begFrmIdx, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, afInfoPtr, false ); }
cw::rc_t cw::audiofile::getDouble( const char* fn, unsigned begFrmIdx, unsigned frmCnt, unsigned chIdx, unsigned chCnt, double** buf, unsigned* actualFrmCntPtr, info_t* afInfoPtr )
{ return _getDouble( fn, begFrmIdx, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, afInfoPtr, false); }
cw::rc_t cw::audiofile::getSumInt( const char* fn, unsigned begFrmIdx, unsigned frmCnt, unsigned chIdx, unsigned chCnt, int** buf, unsigned* actualFrmCntPtr, info_t* afInfoPtr )
{ return _getInt( fn, begFrmIdx, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, afInfoPtr, true ); }
cw::rc_t cw::audiofile::getSumFloat( const char* fn, unsigned begFrmIdx, unsigned frmCnt, unsigned chIdx, unsigned chCnt, float** buf, unsigned* actualFrmCntPtr, info_t* afInfoPtr )
{ return _getFloat( fn, begFrmIdx, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, afInfoPtr, true ); }
cw::rc_t cw::audiofile::getSumDouble( const char* fn, unsigned begFrmIdx, unsigned frmCnt, unsigned chIdx, unsigned chCnt, double** buf, unsigned* actualFrmCntPtr, info_t* afInfoPtr )
{ return _getDouble( fn, begFrmIdx, frmCnt, chIdx, chCnt, buf, actualFrmCntPtr, afInfoPtr, true ); }
cw::rc_t cw::audiofile::allocFloatBuf( const char* fn, float**& chBufRef, unsigned& chCntRef, unsigned& frmCntRef, info_t& afInfo, unsigned begFrmIdx, unsigned frmCnt, unsigned chIdx, unsigned chCnt )
{
rc_t rc;
unsigned actualFrmCnt = 0;
frmCntRef = 0;
chCntRef = 0;
if((rc = getInfo(fn, &afInfo )) != kOkRC )
goto errLabel;
if( chCnt == 0 )
chCnt = afInfo.chCnt;
else
{
if( chIdx + chCnt > afInfo.chCnt )
{
cwLogError(kInvalidArgRC,"Requested channel indexes %i to %i exceeds available channel count %i.",chIdx,chIdx+chCnt-1,afInfo,chCnt);
goto errLabel;
}
}
if( frmCnt == 0 )
frmCnt = afInfo.frameCnt;
if( begFrmIdx + frmCnt > afInfo.frameCnt )
{
cwLogError(kInvalidArgRC,"Requested frames %i to %i exceeds available frame count %i.",begFrmIdx,begFrmIdx+frmCnt,afInfo.frameCnt);
goto errLabel;
}
chBufRef = mem::allocZ< float* >(chCnt);
for(unsigned i=0; i<chCnt; ++i)
chBufRef[i] = mem::alloc<float>(frmCnt);
if((rc = getFloat(fn, begFrmIdx, frmCnt, chIdx, chCnt, chBufRef, &actualFrmCnt, nullptr)) != kOkRC )
goto errLabel;
frmCntRef = actualFrmCnt;
chCntRef = chCnt;
errLabel:
if( rc != kOkRC )
cwLogError(rc,"Audio file allocFloat() failed.");
return rc;
}
cw::rc_t cw::audiofile::freeFloatBuf( float** floatBuf, unsigned chCnt )
{
for(unsigned i=0; i<chCnt; ++i)
mem::release(floatBuf[i]);
mem::release(floatBuf);
return kOkRC;
}
cw::rc_t cw::audiofile::writeInt( handle_t h, unsigned frmCnt, unsigned chCnt, const int* const* srcPtrPtr )
{
rc_t rc = kOkRC;
af_t* p = _handleToPtr(h);
unsigned bytesPerSmp = p->info.bits / kBitsPerByte;
unsigned bufFrmCnt = 1024;
unsigned bufByteCnt = bufFrmCnt * bytesPerSmp;
unsigned ci;
unsigned wrFrmCnt = 0;
char buf[ bufByteCnt * chCnt ];
while( wrFrmCnt < frmCnt )
{
unsigned n = std::min( frmCnt-wrFrmCnt, bufFrmCnt );
// interleave each channel into buf[]
for(ci=0; ci<chCnt; ++ci)
{
// get the begin and end source pointers
const int* sbp = srcPtrPtr[ci] + wrFrmCnt;
const int* sep = sbp + n;
// 8 bit samples can't be byte swapped
if( p->info.bits == 8 )
{
char* dbp = buf + ci;
for(; sbp < sep; dbp+=chCnt )
*dbp = (char)*sbp++;
}
else
{
// if the samples do need to be byte swapped
if( cwIsFlag(p->info.flags,kSwapSamplesAfFl) )
{
switch( p->info.bits )
{
case 16:
{
short* dbp = (short*)buf;
for(dbp+=ci; sbp < sep; dbp+=chCnt, ++sbp )
*dbp = _cmAfSwap16((short)*sbp);
}
break;
case 24:
{
unsigned char* dbp = (unsigned char*)buf;
for( dbp+=(ci*3); sbp < sep; dbp+=(3*chCnt), ++sbp)
{
unsigned char* s = (unsigned char*)sbp;
dbp[0] = s[2];
dbp[1] = s[1];
dbp[2] = s[0];
}
}
break;
case 32:
{
int* dbp = (int*)buf;
for(dbp+=ci; sbp < sep; dbp+=chCnt, ++sbp )
*dbp = _cmAfSwap32(*sbp);
}
break;
default:
{ assert(0);}
}
}
else // interleave without byte swapping
{
switch( p->info.bits )
{
case 16:
{
short* dbp = (short*)buf;
for(dbp+=ci; sbp < sep; dbp+=chCnt, ++sbp )
*dbp = (short)*sbp;
}
break;
case 24:
{
unsigned char* dbp = (unsigned char*)buf;
for( dbp+=(ci*3); sbp < sep; dbp+=(3*chCnt), ++sbp)
{
unsigned char* s = (unsigned char*)sbp;
dbp[0] = s[0];
dbp[1] = s[1];
dbp[2] = s[2];
}
}
break;
case 32:
{
int* dbp = (int*)buf;
for(dbp+=ci; sbp < sep; dbp+=chCnt, ++sbp )
*dbp = *sbp;
}
break;
default:
{ assert(0);}
} // switch
} // don't swap
} // 8 bits
} // ch
// advance the source pointer index
wrFrmCnt+=n;
if( fwrite( buf, n*bytesPerSmp*chCnt, 1, p->fp ) != 1)
{
rc = cwLogError(kWriteFailRC,"Audio file write failed on '%s'.",cwStringNullGuard(p->fn));
break;
}
} // while
p->info.frameCnt += wrFrmCnt;
return rc;
}
cw::rc_t cw::audiofile::writeFloat( handle_t h, unsigned frmCnt, unsigned chCnt, const float* const* srcPtrPtr )
{
rc_t rc = kOkRC;
af_t* p = _handleToPtr(h);
if( p->flags & kWriteFloatFl )
rc = _write_audio<float,float>( p, frmCnt, chCnt, srcPtrPtr );
else
{
switch(p->info.bits)
{
case 8:
rc = _write_audio<float,uint8_t>( p, frmCnt, chCnt, srcPtrPtr );
break;
case 16:
rc = _write_audio<float,short>( p, frmCnt, chCnt, srcPtrPtr );
break;
case 24:
assert(0);
break;
case 32:
rc = _write_audio<float,int>( p, frmCnt, chCnt, srcPtrPtr );
break;
default:
cwLogError(kInvalidArgRC,"Invalid bit depth:%i",p->info.bits);
}
}
return rc;
//return _writeRealSamples(h,frmCnt,chCnt,bufPtrPtr,sizeof(float));
}
cw::rc_t cw::audiofile::writeDouble( handle_t h, unsigned frmCnt, unsigned chCnt, const double* const* srcPtrPtr )
{
rc_t rc = kOkRC;
af_t* p = _handleToPtr(h);
if( p->flags & kWriteFloatFl )
rc = _write_audio<double,float>( p, frmCnt, chCnt, srcPtrPtr );
else
{
switch(p->info.bits)
{
case 8:
rc = _write_audio<double,uint8_t>( p, frmCnt, chCnt, srcPtrPtr );
break;
case 16:
rc = _write_audio<double,short>( p, frmCnt, chCnt, srcPtrPtr );
break;
case 24:
break;
case 32:
rc = _write_audio<double,int>( p, frmCnt, chCnt, srcPtrPtr );
break;
default:
cwLogError(kInvalidArgRC,"Invalid bit depth:%i",p->info.bits);
}
}
return rc;
//return _writeRealSamples(h,frmCnt,chCnt,bufPtrPtr,sizeof(double));
}
cw::rc_t cw::audiofile::writeFloatInterleaved( handle_t h, unsigned frmCnt, unsigned chCnt, const float* bufPtr )
{
rc_t rc = kOkRC;
af_t* p = _handleToPtr(h);
if((rc = _write_samples_to_file(p,sizeof(float),frmCnt*chCnt,bufPtr)) == kOkRC )
{
p->info.frameCnt += frmCnt;
}
return rc;
}
cw::rc_t cw::audiofile::minMaxMean( handle_t h, unsigned chIdx, float* minPtr, float* maxPtr, float* meanPtr )
{
assert( minPtr != NULL && maxPtr != NULL && meanPtr != NULL );
*minPtr = -FLT_MAX;
*maxPtr = FLT_MAX;
*meanPtr = 0;
rc_t rc = kOkRC;
af_t* p = _handleToPtr(h);
unsigned orgFrmIdx = p->curFrmIdx;
if((rc = seek(h,0)) != kOkRC )
return rc;
*minPtr = FLT_MAX;
*maxPtr = -FLT_MAX;
unsigned bufN = 1024;
float buf[ bufN ];
unsigned frmCnt = 0;
unsigned actualFrmCnt;
float* bufPtr[1] = { &buf[0] };
for(; frmCnt<p->info.frameCnt; frmCnt+=actualFrmCnt)
{
actualFrmCnt = 0;
unsigned n = std::min( p->info.frameCnt-frmCnt, bufN );
if((rc = readFloat(h, n, chIdx, 1, bufPtr, &actualFrmCnt)) != kOkRC )
return rc;
const float* sbp = buf;
const float* sep = buf + actualFrmCnt;
for(; sbp < sep; ++sbp )
{
*meanPtr += *sbp;
if( *minPtr > *sbp )
*minPtr = *sbp;
if( *maxPtr < *sbp )
*maxPtr = *sbp;
}
}
if( frmCnt > 0 )
*meanPtr /= frmCnt;
else
*minPtr = *maxPtr = 0;
return seek( h, orgFrmIdx );
}
cw::rc_t cw::audiofile::writeFileInt( const char* fn, double srate, unsigned bits, unsigned frmCnt, unsigned chCnt, const int* const* bufPtrPtr )
{
rc_t rc;
handle_t h;
if(( rc = create(h,fn,srate,bits,chCnt)) != kOkRC )
{
rc = writeInt( h, frmCnt, chCnt, bufPtrPtr );
close(h);
}
return rc;
}
cw::rc_t cw::audiofile::writeFileFloat( const char* fn, double srate, unsigned bits, unsigned frmCnt, unsigned chCnt, const float* const* bufPtrPtr )
{
rc_t rc;
handle_t h;
if(( rc = create(h,fn,srate,bits,chCnt)) == kOkRC )
{
rc = writeFloat( h, frmCnt, chCnt, bufPtrPtr );
close(h);
}
return rc;
}
cw::rc_t cw::audiofile::writeFileDouble( const char* fn, double srate, unsigned bits, unsigned frmCnt, unsigned chCnt, const double* const* bufPtrPtr )
{
rc_t rc;
handle_t h;
if(( rc = create(h,fn,srate,bits,chCnt)) == kOkRC )
{
rc = writeDouble( h, frmCnt, chCnt, bufPtrPtr );
close(h);
}
return rc;
}
cw::rc_t cw::audiofile::minMaxMeanFn( const char* fn, unsigned chIdx, float* minPtr, float* maxPtr, float* meanPtr )
{
rc_t rc = kOkRC;
handle_t h;
if((rc = open(h,fn,nullptr)) == kOkRC )
{
rc = minMaxMean( h, chIdx, minPtr, maxPtr, meanPtr );
close(h);
}
return rc;
}
const char* cw::audiofile::name( handle_t h )
{
af_t* p = _handleToPtr(h);
return p->fn;
}
unsigned cw::audiofile::channelCount( handle_t h )
{
af_t* p = _handleToPtr(h);
return p->info.chCnt;
}
double cw::audiofile::sampleRate( handle_t h )
{
af_t* p = _handleToPtr(h);
return p->info.srate;
}
cw::rc_t cw::audiofile::getInfo( const char* fn, info_t* infoPtr )
{
rc_t rc = kOkRC;
handle_t h;
if((rc = open(h,fn,infoPtr)) == kOkRC )
close(h);
return rc;
}
void cw::audiofile::printInfo( const info_t* infoPtr, log::handle_t logH )
{
const char* typeStr = "AIFF";
const char* swapStr = "";
const char* aifcStr = "";
unsigned i;
if( cwIsFlag(infoPtr->flags,kWavAfFl) )
typeStr = "WAV";
if( cwIsFlag(infoPtr->flags,kSwapAfFl) )
swapStr = "Swap:On";
if( cwIsFlag(infoPtr->flags,kAifcAfFl))
aifcStr = "AIFC";
cwLogPrintH(logH,"bits:%i chs:%i srate:%f frames:%i type:%s %s %s\n", infoPtr->bits, infoPtr->chCnt, infoPtr->srate, infoPtr->frameCnt, typeStr, swapStr, aifcStr );
for(i=0; i<infoPtr->markerCnt; ++i)
cwLogPrintH(logH,"%i %i %s\n", infoPtr->markerArray[i].id, infoPtr->markerArray[i].frameIdx, infoPtr->markerArray[i].label);
if( strlen(infoPtr->bextRecd.desc) )
cwLogPrintH(logH,"Bext Desc:%s\n",infoPtr->bextRecd.desc );
if( strlen(infoPtr->bextRecd.origin) )
cwLogPrintH(logH,"Bext Origin:%s\n",infoPtr->bextRecd.origin );
if( strlen(infoPtr->bextRecd.originRef) )
cwLogPrintH(logH,"Bext Origin Ref:%s\n",infoPtr->bextRecd.originRef );
if( strlen(infoPtr->bextRecd.originDate) )
cwLogPrintH(logH,"Bext Origin Date:%s\n",infoPtr->bextRecd.originDate );
if( strlen(infoPtr->bextRecd.originTime ) )
cwLogPrintH(logH,"Bext Origin Time:%s\n",infoPtr->bextRecd.originTime );
cwLogPrintH(logH,"Bext time high:%i low:%i 0x%x%x\n",infoPtr->bextRecd.timeRefHigh,infoPtr->bextRecd.timeRefLow, infoPtr->bextRecd.timeRefHigh,infoPtr->bextRecd.timeRefLow);
}
cw::rc_t cw::audiofile::reportInfo( const char* audioFn )
{
rc_t rc;
info_t info;
if((rc = getInfo(audioFn,&info)) != kOkRC )
return rc;
printInfo(&info,log::globalHandle());
return rc;
}
cw::rc_t cw::audiofile::report( handle_t h, log::handle_t logH, unsigned frmIdx, unsigned frmCnt )
{
rc_t rc = kOkRC;
af_t* p = _handleToPtr(h);
cwLogPrintH(logH,"function cm_audio_file_test()\n");
cwLogPrintH(logH,"#{\n");
printInfo(&p->info,logH);
cwLogPrintH(logH,"#}\n");
if( frmCnt == kInvalidCnt )
frmCnt = p->info.frameCnt;
float buf[ p->info.chCnt * frmCnt ];
float* bufPtr[p->info.chCnt];
unsigned i,j,cmtFrmCnt=0;
for(i=0; i<p->info.chCnt; ++i)
bufPtr[i] = buf + (i*frmCnt);
if((rc = seek(h,frmIdx)) != kOkRC )
return rc;
if((rc= readFloat(h,frmCnt,0,p->info.chCnt,bufPtr,&cmtFrmCnt )) != kOkRC)
return rc;
cwLogPrintH(logH,"m = [\n");
for(i=0; i<frmCnt; i++)
{
for(j=0; j<p->info.chCnt; ++j)
cwLogPrintH(logH,"%f ", bufPtr[j][i] );
cwLogPrintH(logH,"\n");
}
cwLogPrintH(logH,"];\nplot(m)\nendfunction\n");
return rc;
}
cw::rc_t cw::audiofile::reportFn( const char* fn, log::handle_t logH, unsigned frmIdx, unsigned frmCnt )
{
rc_t rc;
handle_t h;
if((rc = open(h,fn,nullptr)) == kOkRC )
{
rc = report(h,logH,frmIdx,frmCnt);
close(h);
}
return rc;
}
cw::rc_t cw::audiofile::setSrate( const char* fn, unsigned srate )
{
rc_t rc = kOkRC;
af_t af;
af_t* p = &af;
memset(&af,0,sizeof(af));
if((rc = _open(p, fn, "r+b")) != kOkRC )
goto errLabel;
if( p->info.srate != srate )
{
// change the sample rate
p->info.srate = srate;
// write the file header
if((rc = _writeHdr(p)) != kOkRC )
goto errLabel;
}
errLabel:
if( p->fp != NULL )
fclose(p->fp);
return rc;
}
/// [example]
cw::rc_t cw::audiofile::test( const object_t* cfg )
{
rc_t rc = kOkRC;
const object_t* o;
if((o = cfg->find("rpt")) != nullptr )
rc = _testReport(o);
if((o = cfg->find("mix")) != nullptr )
rc = _testReport(o);
/*
switch( argc )
{
case 3:
//_test(argv[2],&ctx->rpt);
reportFn(argv[2],0,0,&ctx->rpt);
break;
case 4:
{
errno = 0;
long srate = strtol(argv[3], NULL, 10);
if( srate == 0 && errno != 0 )
rc = cwLogError(kInvalidArgRC,"Invalid sample rate argument to test().");
else
setSrate(argv[2],srate);
}
break;
case 8:
{
errno = 0;
double srate = strtod(argv[3],NULL);
unsigned bits = strtol(argv[4],NULL,10);
double hz = strtod(argv[5],NULL);
double gain = strtod(argv[6],NULL);
double secs = strtod(argv[7],NULL);
if( errno != 0 )
rc = cwLogError(kInvalidArgRC,"Invalid arg. to test().");
sine( ctx, argv[2], srate, bits, hz, gain, secs );
}
break;
default:
rc = cwLogError(kInvalidArgRC,"Invalid argument count to test().");
break;
}
*/
return rc;
}
/// [example]
Reference in New Issue View Git Blame Copy Permalink