1242 lines
45 KiB
C++
1242 lines
45 KiB
C++
/* Copyright: © Copyright 2005 Apple Computer, Inc. All rights reserved.
|
|
|
|
Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc.
|
|
("Apple") in consideration of your agreement to the following terms, and your
|
|
use, installation, modification or redistribution of this Apple software
|
|
constitutes acceptance of these terms. If you do not agree with these terms,
|
|
please do not use, install, modify or redistribute this Apple software.
|
|
|
|
In consideration of your agreement to abide by the following terms, and subject
|
|
to these terms, Apple grants you a personal, non-exclusive license, under AppleÕs
|
|
copyrights in this original Apple software (the "Apple Software"), to use,
|
|
reproduce, modify and redistribute the Apple Software, with or without
|
|
modifications, in source and/or binary forms; provided that if you redistribute
|
|
the Apple Software in its entirety and without modifications, you must retain
|
|
this notice and the following text and disclaimers in all such redistributions of
|
|
the Apple Software. Neither the name, trademarks, service marks or logos of
|
|
Apple Computer, Inc. may be used to endorse or promote products derived from the
|
|
Apple Software without specific prior written permission from Apple. Except as
|
|
expressly stated in this notice, no other rights or licenses, express or implied,
|
|
are granted by Apple herein, including but not limited to any patent rights that
|
|
may be infringed by your derivative works or by other works in which the Apple
|
|
Software may be incorporated.
|
|
|
|
The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO
|
|
WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
|
|
WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN
|
|
COMBINATION WITH YOUR PRODUCTS.
|
|
|
|
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
|
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION
|
|
OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT
|
|
(INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN
|
|
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
/*=============================================================================
|
|
CAAudioFile.cpp
|
|
|
|
=============================================================================*/
|
|
|
|
#include "CAAudioFile.h"
|
|
|
|
#if !CAAF_USE_EXTAUDIOFILE
|
|
|
|
#include "CAXException.h"
|
|
#include <algorithm>
|
|
#include "CAHostTimeBase.h"
|
|
#include "CADebugMacros.h"
|
|
|
|
#if !defined(__COREAUDIO_USE_FLAT_INCLUDES__)
|
|
#include <AudioToolbox/AudioToolbox.h>
|
|
#else
|
|
#include <AudioFormat.h>
|
|
#endif
|
|
|
|
#if DEBUG
|
|
//#define VERBOSE_IO 1
|
|
//#define VERBOSE_CONVERTER 1
|
|
//#define VERBOSE_CHANNELMAP 1
|
|
//#define LOG_FUNCTION_ENTRIES 1
|
|
|
|
#if VERBOSE_CHANNELMAP
|
|
#include "CAChannelLayouts.h" // this is in Source/Tests/AudioFileTools/Utility
|
|
#endif
|
|
#endif
|
|
|
|
#if LOG_FUNCTION_ENTRIES
|
|
class FunctionLogger {
|
|
public:
|
|
FunctionLogger(const char *name, const char *fmt=NULL, ...) : mName(name) {
|
|
Indent();
|
|
printf("-> %s ", name);
|
|
if (fmt) {
|
|
va_list args;
|
|
va_start(args, fmt);
|
|
vprintf(fmt, args);
|
|
va_end(args);
|
|
}
|
|
printf("\n");
|
|
++sIndent;
|
|
}
|
|
~FunctionLogger() {
|
|
--sIndent;
|
|
Indent();
|
|
printf("<- %s\n", mName);
|
|
if (sIndent == 0)
|
|
printf("\n");
|
|
}
|
|
|
|
static void Indent() {
|
|
for (int i = sIndent; --i >= 0; ) {
|
|
putchar(' '); putchar(' ');
|
|
}
|
|
}
|
|
|
|
const char *mName;
|
|
static int sIndent;
|
|
};
|
|
int FunctionLogger::sIndent = 0;
|
|
|
|
#define LOG_FUNCTION(name, format, ...) FunctionLogger _flog(name, format, ## __VA_ARGS__);
|
|
#else
|
|
#define LOG_FUNCTION(name, format, foo)
|
|
#endif
|
|
|
|
static const UInt32 kDefaultIOBufferSizeBytes = 0x10000;
|
|
|
|
#if CAAUDIOFILE_PROFILE
|
|
#define StartTiming(af, starttime) UInt64 starttime = af->mProfiling ? CAHostTimeBase::GetTheCurrentTime() : 0
|
|
#define ElapsedTime(af, starttime, counter) if (af->mProfiling) counter += (CAHostTimeBase::GetTheCurrentTime() - starttime)
|
|
#else
|
|
#define StartTiming(af, starttime)
|
|
#define ElapsedTime(af, starttime, counter)
|
|
#endif
|
|
|
|
#define kNoMoreInputRightNow 'nein'
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
CAAudioFile::CAAudioFile() :
|
|
mAudioFile(0),
|
|
mUseCache(false),
|
|
mFinishingEncoding(false),
|
|
mMode(kClosed),
|
|
mFileDataOffset(-1),
|
|
mFramesToSkipFollowingSeek(0),
|
|
|
|
mClientOwnsIOBuffer(false),
|
|
mPacketDescs(NULL),
|
|
mNumPacketDescs(0),
|
|
mConverter(NULL),
|
|
mMagicCookie(NULL),
|
|
mWriteBufferList(NULL)
|
|
#if CAAUDIOFILE_PROFILE
|
|
,
|
|
mProfiling(false),
|
|
mTicksInConverter(0),
|
|
mTicksInReadInConverter(0),
|
|
mTicksInIO(0),
|
|
mInConverter(false)
|
|
#endif
|
|
{
|
|
mIOBufferList.mBuffers[0].mData = NULL;
|
|
mIOBufferList.mBuffers[0].mDataByteSize = 0;
|
|
mClientMaxPacketSize = 0;
|
|
mIOBufferSizeBytes = kDefaultIOBufferSizeBytes;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
CAAudioFile::~CAAudioFile()
|
|
{
|
|
Close();
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::Close()
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::Close", NULL, NULL);
|
|
if (mMode == kClosed)
|
|
return;
|
|
if (mMode == kWriting)
|
|
FlushEncoder();
|
|
CloseConverter();
|
|
if (mAudioFile != 0 && mOwnOpenFile) {
|
|
AudioFileClose(mAudioFile);
|
|
mAudioFile = 0;
|
|
}
|
|
if (!mClientOwnsIOBuffer) {
|
|
delete[] (Byte *)mIOBufferList.mBuffers[0].mData;
|
|
mIOBufferList.mBuffers[0].mData = NULL;
|
|
mIOBufferList.mBuffers[0].mDataByteSize = 0;
|
|
}
|
|
delete[] mPacketDescs; mPacketDescs = NULL; mNumPacketDescs = 0;
|
|
delete[] mMagicCookie; mMagicCookie = NULL;
|
|
delete mWriteBufferList; mWriteBufferList = NULL;
|
|
mMode = kClosed;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::CloseConverter()
|
|
{
|
|
if (mConverter) {
|
|
#if VERBOSE_CONVERTER
|
|
printf("CAAudioFile %p : CloseConverter\n", this);
|
|
#endif
|
|
AudioConverterDispose(mConverter);
|
|
mConverter = NULL;
|
|
}
|
|
}
|
|
|
|
// =======================================================================================
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::Open(const FSRef &fsref)
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::Open", "%p", this);
|
|
XThrowIf(mMode != kClosed, kExtAudioFileError_InvalidOperationOrder, "file already open");
|
|
mFSRef = fsref;
|
|
XThrowIfError(AudioFileOpen(&mFSRef, fsRdPerm, 0, &mAudioFile), "open audio file");
|
|
mOwnOpenFile = true;
|
|
mMode = kReading;
|
|
GetExistingFileInfo();
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::Wrap(AudioFileID fileID, bool forWriting)
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::Wrap", "%p", this);
|
|
XThrowIf(mMode != kClosed, kExtAudioFileError_InvalidOperationOrder, "file already open");
|
|
|
|
mAudioFile = fileID;
|
|
mOwnOpenFile = false;
|
|
mMode = forWriting ? kPreparingToWrite : kReading;
|
|
GetExistingFileInfo();
|
|
if (forWriting)
|
|
FileFormatChanged();
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::CreateNew(const FSRef &parentDir, CFStringRef filename, AudioFileTypeID filetype, const AudioStreamBasicDescription &dataFormat, const AudioChannelLayout *layout)
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::CreateNew", "%p", this);
|
|
XThrowIf(mMode != kClosed, kExtAudioFileError_InvalidOperationOrder, "file already open");
|
|
|
|
mFileDataFormat = dataFormat;
|
|
if (layout) {
|
|
mFileChannelLayout = layout;
|
|
#if VERBOSE_CHANNELMAP
|
|
printf("PrepareNew passed channel layout: %s\n", CAChannelLayouts::ConstantToString(mFileChannelLayout.Tag()));
|
|
#endif
|
|
}
|
|
mMode = kPreparingToCreate;
|
|
FileFormatChanged(&parentDir, filename, filetype);
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
// called to create the file -- or update its format/channel layout/properties based on an encoder
|
|
// setting change
|
|
void CAAudioFile::FileFormatChanged(const FSRef *parentDir, CFStringRef filename, AudioFileTypeID filetype)
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::FileFormatChanged", "%p", this);
|
|
XThrowIf(mMode != kPreparingToCreate && mMode != kPreparingToWrite, kExtAudioFileError_InvalidOperationOrder, "new file not prepared");
|
|
|
|
UInt32 propertySize;
|
|
OSStatus err;
|
|
AudioStreamBasicDescription saveFileDataFormat = mFileDataFormat;
|
|
|
|
#if VERBOSE_CONVERTER
|
|
mFileDataFormat.PrintFormat(stdout, "", "Specified file data format");
|
|
#endif
|
|
|
|
// Find out the actual format the converter will produce. This is necessary in
|
|
// case the bitrate has forced a lower sample rate, which needs to be set correctly
|
|
// in the stream description passed to AudioFileCreate.
|
|
if (mConverter != NULL) {
|
|
propertySize = sizeof(AudioStreamBasicDescription);
|
|
Float64 origSampleRate = mFileDataFormat.mSampleRate;
|
|
XThrowIfError(AudioConverterGetProperty(mConverter, kAudioConverterCurrentOutputStreamDescription, &propertySize, &mFileDataFormat), "get audio converter's output stream description");
|
|
// do the same for the channel layout being output by the converter
|
|
#if VERBOSE_CONVERTER
|
|
mFileDataFormat.PrintFormat(stdout, "", "Converter output");
|
|
#endif
|
|
if (fiszero(mFileDataFormat.mSampleRate))
|
|
mFileDataFormat.mSampleRate = origSampleRate;
|
|
err = AudioConverterGetPropertyInfo(mConverter, kAudioConverterOutputChannelLayout, &propertySize, NULL);
|
|
if (err == noErr && propertySize > 0) {
|
|
AudioChannelLayout *layout = static_cast<AudioChannelLayout *>(malloc(propertySize));
|
|
err = AudioConverterGetProperty(mConverter, kAudioConverterOutputChannelLayout, &propertySize, layout);
|
|
if (err) {
|
|
free(layout);
|
|
XThrow(err, "couldn't get audio converter's output channel layout");
|
|
}
|
|
mFileChannelLayout = layout;
|
|
#if VERBOSE_CHANNELMAP
|
|
printf("got new file's channel layout from converter: %s\n", CAChannelLayouts::ConstantToString(mFileChannelLayout.Tag()));
|
|
#endif
|
|
free(layout);
|
|
}
|
|
}
|
|
|
|
// create the output file
|
|
if (mMode == kPreparingToCreate) {
|
|
CAStreamBasicDescription newFileDataFormat = mFileDataFormat;
|
|
if (fiszero(newFileDataFormat.mSampleRate))
|
|
newFileDataFormat.mSampleRate = 44100; // just make something up for now
|
|
#if VERBOSE_CONVERTER
|
|
newFileDataFormat.PrintFormat(stdout, "", "Applied to new file");
|
|
#endif
|
|
XThrowIfError(AudioFileCreate(parentDir, filename, filetype, &newFileDataFormat, 0, &mFSRef, &mAudioFile), "create audio file");
|
|
mMode = kPreparingToWrite;
|
|
mOwnOpenFile = true;
|
|
} else if (saveFileDataFormat != mFileDataFormat || fnotequal(saveFileDataFormat.mSampleRate, mFileDataFormat.mSampleRate)) {
|
|
// second check must be explicit since operator== on ASBD treats SR of zero as "don't care"
|
|
if (fiszero(mFileDataFormat.mSampleRate))
|
|
mFileDataFormat.mSampleRate = mClientDataFormat.mSampleRate;
|
|
#if VERBOSE_CONVERTER
|
|
mFileDataFormat.PrintFormat(stdout, "", "Applied to new file");
|
|
#endif
|
|
XThrowIf(fiszero(mFileDataFormat.mSampleRate), kExtAudioFileError_InvalidDataFormat, "file's sample rate is 0");
|
|
XThrowIfError(AudioFileSetProperty(mAudioFile, kAudioFilePropertyDataFormat, sizeof(AudioStreamBasicDescription), &mFileDataFormat), "couldn't update file's data format");
|
|
}
|
|
|
|
UInt32 deferSizeUpdates = 1;
|
|
err = AudioFileSetProperty(mAudioFile, kAudioFilePropertyDeferSizeUpdates, sizeof(UInt32), &deferSizeUpdates);
|
|
|
|
if (mConverter != NULL) {
|
|
// encoder
|
|
// get the magic cookie, if any, from the converter
|
|
delete[] mMagicCookie; mMagicCookie = NULL;
|
|
mMagicCookieSize = 0;
|
|
|
|
err = AudioConverterGetPropertyInfo(mConverter, kAudioConverterCompressionMagicCookie, &propertySize, NULL);
|
|
|
|
// we can get a noErr result and also a propertySize == 0
|
|
// -- if the file format does support magic cookies, but this file doesn't have one.
|
|
if (err == noErr && propertySize > 0) {
|
|
mMagicCookie = new Byte[propertySize];
|
|
XThrowIfError(AudioConverterGetProperty(mConverter, kAudioConverterCompressionMagicCookie, &propertySize, mMagicCookie), "get audio converter's magic cookie");
|
|
mMagicCookieSize = propertySize; // the converter lies and tell us the wrong size
|
|
// now set the magic cookie on the output file
|
|
UInt32 willEatTheCookie = false;
|
|
// the converter wants to give us one; will the file take it?
|
|
err = AudioFileGetPropertyInfo(mAudioFile, kAudioFilePropertyMagicCookieData,
|
|
NULL, &willEatTheCookie);
|
|
if (err == noErr && willEatTheCookie) {
|
|
#if VERBOSE_CONVERTER
|
|
printf("Setting cookie on encoded file\n");
|
|
#endif
|
|
XThrowIfError(AudioFileSetProperty(mAudioFile, kAudioFilePropertyMagicCookieData, mMagicCookieSize, mMagicCookie), "set audio file's magic cookie");
|
|
}
|
|
}
|
|
|
|
// get maximum packet size
|
|
propertySize = sizeof(UInt32);
|
|
XThrowIfError(AudioConverterGetProperty(mConverter, kAudioConverterPropertyMaximumOutputPacketSize, &propertySize, &mFileMaxPacketSize), "get audio converter's maximum output packet size");
|
|
|
|
AllocateBuffers(true /* okToFail */);
|
|
} else {
|
|
InitFileMaxPacketSize();
|
|
}
|
|
|
|
if (mFileChannelLayout.IsValid() && mFileChannelLayout.NumberChannels() > 2) {
|
|
// don't bother tagging mono/stereo files
|
|
UInt32 isWritable;
|
|
err = AudioFileGetPropertyInfo(mAudioFile, kAudioFilePropertyChannelLayout, NULL, &isWritable);
|
|
if (!err && isWritable) {
|
|
#if VERBOSE_CHANNELMAP
|
|
printf("writing file's channel layout: %s\n", CAChannelLayouts::ConstantToString(mFileChannelLayout.Tag()));
|
|
#endif
|
|
err = AudioFileSetProperty(mAudioFile, kAudioFilePropertyChannelLayout,
|
|
mFileChannelLayout.Size(), &mFileChannelLayout.Layout());
|
|
if (err)
|
|
CAXException::Warning("could not set the file's channel layout", err);
|
|
} else {
|
|
#if VERBOSE_CHANNELMAP
|
|
printf("file won't accept a channel layout (write)\n");
|
|
#endif
|
|
}
|
|
}
|
|
|
|
UpdateClientMaxPacketSize(); // also sets mFrame0Offset
|
|
mPacketMark = 0;
|
|
mFrameMark = 0;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::InitFileMaxPacketSize()
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::InitFileMaxPacketSize", "%p", this);
|
|
UInt32 propertySize = sizeof(UInt32);
|
|
OSStatus err = AudioFileGetProperty(mAudioFile, kAudioFilePropertyMaximumPacketSize,
|
|
&propertySize, &mFileMaxPacketSize);
|
|
if (err) {
|
|
// workaround for 3361377: not all file formats' maximum packet sizes are supported
|
|
if (!mFileDataFormat.IsPCM())
|
|
XThrowIfError(err, "get audio file's maximum packet size");
|
|
mFileMaxPacketSize = mFileDataFormat.mBytesPerFrame;
|
|
}
|
|
AllocateBuffers(true /* okToFail */);
|
|
}
|
|
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
SInt64 CAAudioFile::FileDataOffset()
|
|
{
|
|
if (mFileDataOffset < 0) {
|
|
UInt32 propertySize = sizeof(SInt64);
|
|
XThrowIfError(AudioFileGetProperty(mAudioFile, kAudioFilePropertyDataOffset, &propertySize, &mFileDataOffset), "couldn't get file's data offset");
|
|
}
|
|
return mFileDataOffset;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
SInt64 CAAudioFile::GetNumberFrames() const
|
|
{
|
|
AudioFilePacketTableInfo pti;
|
|
UInt32 propertySize = sizeof(pti);
|
|
OSStatus err = AudioFileGetProperty(mAudioFile, kAudioFilePropertyPacketTableInfo, &propertySize, &pti);
|
|
if (err == noErr)
|
|
return pti.mNumberValidFrames;
|
|
return mFileDataFormat.mFramesPerPacket * GetNumberPackets() - mFrame0Offset;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::SetNumberFrames(SInt64 nFrames)
|
|
{
|
|
XThrowIf(mFileDataFormat.mFramesPerPacket != 1, kExtAudioFileError_InvalidDataFormat, "SetNumberFrames only supported for PCM");
|
|
XThrowIfError(AudioFileSetProperty(mAudioFile, kAudioFilePropertyAudioDataPacketCount, sizeof(SInt64), &nFrames), "Couldn't set number of packets on audio file");
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
// call for existing file, NOT new one - from Open() or Wrap()
|
|
void CAAudioFile::GetExistingFileInfo()
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::GetExistingFileInfo", "%p", this);
|
|
UInt32 propertySize;
|
|
OSStatus err;
|
|
|
|
// get mFileDataFormat
|
|
propertySize = sizeof(AudioStreamBasicDescription);
|
|
XThrowIfError(AudioFileGetProperty(mAudioFile, kAudioFilePropertyDataFormat, &propertySize, &mFileDataFormat), "get audio file's data format");
|
|
|
|
// get mFileChannelLayout
|
|
err = AudioFileGetPropertyInfo(mAudioFile, kAudioFilePropertyChannelLayout, &propertySize, NULL);
|
|
if (err == noErr && propertySize > 0) {
|
|
AudioChannelLayout *layout = static_cast<AudioChannelLayout *>(malloc(propertySize));
|
|
err = AudioFileGetProperty(mAudioFile, kAudioFilePropertyChannelLayout, &propertySize, layout);
|
|
if (err == noErr) {
|
|
mFileChannelLayout = layout;
|
|
#if VERBOSE_CHANNELMAP
|
|
printf("existing file's channel layout: %s\n", CAChannelLayouts::ConstantToString(mFileChannelLayout.Tag()));
|
|
#endif
|
|
}
|
|
free(layout);
|
|
XThrowIfError(err, "get audio file's channel layout");
|
|
}
|
|
if (mMode != kReading)
|
|
return;
|
|
|
|
#if 0
|
|
// get mNumberPackets
|
|
propertySize = sizeof(mNumberPackets);
|
|
XThrowIfError(AudioFileGetProperty(mAudioFile, kAudioFilePropertyAudioDataPacketCount, &propertySize, &mNumberPackets), "get audio file's packet count");
|
|
#if VERBOSE_IO
|
|
printf("CAAudioFile::GetExistingFileInfo: %qd packets\n", mNumberPackets);
|
|
#endif
|
|
#endif
|
|
|
|
// get mMagicCookie
|
|
err = AudioFileGetPropertyInfo(mAudioFile, kAudioFilePropertyMagicCookieData, &propertySize, NULL);
|
|
if (err == noErr && propertySize > 0) {
|
|
mMagicCookie = new Byte[propertySize];
|
|
mMagicCookieSize = propertySize;
|
|
XThrowIfError(AudioFileGetProperty(mAudioFile, kAudioFilePropertyMagicCookieData, &propertySize, mMagicCookie), "get audio file's magic cookie");
|
|
}
|
|
InitFileMaxPacketSize();
|
|
mPacketMark = 0;
|
|
mFrameMark = 0;
|
|
|
|
UpdateClientMaxPacketSize();
|
|
}
|
|
|
|
// =======================================================================================
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::SetFileChannelLayout(const CAAudioChannelLayout &layout)
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::SetFileChannelLayout", "%p", this);
|
|
mFileChannelLayout = layout;
|
|
#if VERBOSE_CHANNELMAP
|
|
printf("file channel layout set explicitly (%s): %s\n", mMode == kReading ? "read" : "write", CAChannelLayouts::ConstantToString(mFileChannelLayout.Tag()));
|
|
#endif
|
|
if (mMode != kReading)
|
|
FileFormatChanged();
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::SetClientFormat(const CAStreamBasicDescription &dataFormat, const CAAudioChannelLayout *layout)
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::SetClientFormat", "%p", this);
|
|
XThrowIf(!dataFormat.IsPCM(), kExtAudioFileError_NonPCMClientFormat, "non-PCM client format on audio file");
|
|
|
|
bool dataFormatChanging = (mClientDataFormat.mFormatID == 0 || mClientDataFormat != dataFormat);
|
|
|
|
if (dataFormatChanging) {
|
|
CloseConverter();
|
|
if (mWriteBufferList) {
|
|
delete mWriteBufferList;
|
|
mWriteBufferList = NULL;
|
|
}
|
|
mClientDataFormat = dataFormat;
|
|
}
|
|
|
|
if (layout && layout->IsValid()) {
|
|
XThrowIf(layout->NumberChannels() != mClientDataFormat.NumberChannels(), kExtAudioFileError_InvalidChannelMap, "inappropriate channel map");
|
|
mClientChannelLayout = *layout;
|
|
}
|
|
|
|
bool differentLayouts;
|
|
if (mClientChannelLayout.IsValid()) {
|
|
if (mFileChannelLayout.IsValid()) {
|
|
differentLayouts = mClientChannelLayout.Tag() != mFileChannelLayout.Tag();
|
|
#if VERBOSE_CHANNELMAP
|
|
printf("two valid layouts, %s\n", differentLayouts ? "different" : "same");
|
|
#endif
|
|
} else {
|
|
differentLayouts = false;
|
|
#if VERBOSE_CHANNELMAP
|
|
printf("valid client layout, unknown file layout\n");
|
|
#endif
|
|
}
|
|
} else {
|
|
differentLayouts = false;
|
|
#if VERBOSE_CHANNELMAP
|
|
if (mFileChannelLayout.IsValid())
|
|
printf("valid file layout, unknown client layout\n");
|
|
else
|
|
printf("two invalid layouts\n");
|
|
#endif
|
|
}
|
|
|
|
if (mClientDataFormat != mFileDataFormat || differentLayouts) {
|
|
// We need an AudioConverter.
|
|
if (mMode == kReading) {
|
|
// file -> client (decode)
|
|
//mFileDataFormat.PrintFormat( stdout, "", "File: ");
|
|
//mClientDataFormat.PrintFormat(stdout, "", "Client: ");
|
|
|
|
if (mConverter == NULL)
|
|
XThrowIfError(AudioConverterNew(&mFileDataFormat, &mClientDataFormat, &mConverter),
|
|
"create audio converter");
|
|
|
|
#if VERBOSE_CONVERTER
|
|
printf("CAAudioFile %p -- created converter\n", this);
|
|
CAShow(mConverter);
|
|
#endif
|
|
// set the magic cookie, if any (for decode)
|
|
if (mMagicCookie)
|
|
SetConverterProperty(kAudioConverterDecompressionMagicCookie, mMagicCookieSize, mMagicCookie, mFileDataFormat.IsPCM());
|
|
// we get cookies from some AIFF's but the converter barfs on them,
|
|
// so we set canFail to true for PCM
|
|
|
|
SetConverterChannelLayout(false, mFileChannelLayout);
|
|
SetConverterChannelLayout(true, mClientChannelLayout);
|
|
|
|
// propagate leading/trailing frame counts
|
|
if (mFileDataFormat.mBitsPerChannel == 0) {
|
|
UInt32 propertySize;
|
|
OSStatus err;
|
|
AudioFilePacketTableInfo pti;
|
|
propertySize = sizeof(pti);
|
|
err = AudioFileGetProperty(mAudioFile, kAudioFilePropertyPacketTableInfo, &propertySize, &pti);
|
|
if (err == noErr && (pti.mPrimingFrames > 0 || pti.mRemainderFrames > 0)) {
|
|
AudioConverterPrimeInfo primeInfo;
|
|
primeInfo.leadingFrames = pti.mPrimingFrames;
|
|
primeInfo.trailingFrames = pti.mRemainderFrames;
|
|
/* ignore any error. better to play it at all than not. */
|
|
/*err = */AudioConverterSetProperty(mConverter, kAudioConverterPrimeInfo, sizeof(primeInfo), &primeInfo);
|
|
//XThrowIfError(err, "couldn't set prime info on converter");
|
|
}
|
|
}
|
|
} else if (mMode == kPreparingToCreate || mMode == kPreparingToWrite) {
|
|
// client -> file (encode)
|
|
if (mConverter == NULL)
|
|
XThrowIfError(AudioConverterNew(&mClientDataFormat, &mFileDataFormat, &mConverter), "create audio converter");
|
|
mWriteBufferList = CABufferList::New("", mClientDataFormat);
|
|
SetConverterChannelLayout(false, mClientChannelLayout);
|
|
SetConverterChannelLayout(true, mFileChannelLayout);
|
|
if (mMode == kPreparingToWrite)
|
|
FileFormatChanged();
|
|
} else
|
|
XThrowIfError(kExtAudioFileError_InvalidOperationOrder, "audio file format not yet known");
|
|
}
|
|
UpdateClientMaxPacketSize();
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
OSStatus CAAudioFile::SetConverterProperty(
|
|
AudioConverterPropertyID inPropertyID,
|
|
UInt32 inPropertyDataSize,
|
|
const void* inPropertyData,
|
|
bool inCanFail)
|
|
{
|
|
OSStatus err = noErr;
|
|
//LOG_FUNCTION("ExtAudioFile::SetConverterProperty", "%p %-4.4s", this, (char *)&inPropertyID);
|
|
if (inPropertyID == kAudioConverterPropertySettings && *(CFPropertyListRef *)inPropertyData == NULL)
|
|
;
|
|
else {
|
|
err = AudioConverterSetProperty(mConverter, inPropertyID, inPropertyDataSize, inPropertyData);
|
|
if (!inCanFail) {
|
|
XThrowIfError(err, "set audio converter property");
|
|
}
|
|
}
|
|
UpdateClientMaxPacketSize();
|
|
if (mMode == kPreparingToWrite)
|
|
FileFormatChanged();
|
|
return err;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::SetConverterChannelLayout(bool output, const CAAudioChannelLayout &layout)
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::SetConverterChannelLayout", "%p", this);
|
|
OSStatus err;
|
|
|
|
if (layout.IsValid()) {
|
|
#if VERBOSE_CHANNELMAP
|
|
printf("Setting converter's %s channel layout: %s\n", output ? "output" : "input",
|
|
CAChannelLayouts::ConstantToString(mFileChannelLayout.Tag()));
|
|
#endif
|
|
if (output) {
|
|
err = AudioConverterSetProperty(mConverter, kAudioConverterOutputChannelLayout,
|
|
layout.Size(), &layout.Layout());
|
|
XThrowIf(err && err != kAudioConverterErr_OperationNotSupported, err, "couldn't set converter's output channel layout");
|
|
} else {
|
|
err = AudioConverterSetProperty(mConverter, kAudioConverterInputChannelLayout,
|
|
layout.Size(), &layout.Layout());
|
|
XThrowIf(err && err != kAudioConverterErr_OperationNotSupported, err, "couldn't set converter's input channel layout");
|
|
}
|
|
if (mMode == kPreparingToWrite)
|
|
FileFormatChanged();
|
|
}
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
CFArrayRef CAAudioFile::GetConverterConfig()
|
|
{
|
|
CFArrayRef plist;
|
|
UInt32 propertySize = sizeof(plist);
|
|
XThrowIfError(AudioConverterGetProperty(mConverter, kAudioConverterPropertySettings, &propertySize, &plist), "get converter property settings");
|
|
return plist;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::UpdateClientMaxPacketSize()
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::UpdateClientMaxPacketSize", "%p", this);
|
|
mFrame0Offset = 0;
|
|
if (mConverter != NULL) {
|
|
AudioConverterPropertyID property = (mMode == kReading) ?
|
|
kAudioConverterPropertyMaximumOutputPacketSize :
|
|
kAudioConverterPropertyMaximumInputPacketSize;
|
|
|
|
UInt32 propertySize = sizeof(UInt32);
|
|
XThrowIfError(AudioConverterGetProperty(mConverter, property, &propertySize, &mClientMaxPacketSize),
|
|
"get audio converter's maximum packet size");
|
|
|
|
if (mFileDataFormat.mBitsPerChannel == 0) {
|
|
AudioConverterPrimeInfo primeInfo;
|
|
propertySize = sizeof(primeInfo);
|
|
OSStatus err = AudioConverterGetProperty(mConverter, kAudioConverterPrimeInfo, &propertySize, &primeInfo);
|
|
if (err == noErr)
|
|
mFrame0Offset = primeInfo.leadingFrames;
|
|
#if VERBOSE_CONVERTER
|
|
printf("kAudioConverterPrimeInfo: err = %ld, leadingFrames = %ld\n", err, mFrame0Offset);
|
|
#endif
|
|
}
|
|
} else {
|
|
mClientMaxPacketSize = mFileMaxPacketSize;
|
|
}
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
// Allocates: mIOBufferList, mIOBufferSizePackets, mPacketDescs
|
|
// Dependent on: mFileMaxPacketSize, mIOBufferSizeBytes
|
|
void CAAudioFile::AllocateBuffers(bool okToFail)
|
|
{
|
|
LOG_FUNCTION("CAAudioFile::AllocateBuffers", "%p", this);
|
|
if (mFileMaxPacketSize == 0) {
|
|
if (okToFail)
|
|
return;
|
|
XThrowIf(true, kExtAudioFileError_MaxPacketSizeUnknown, "file's maximum packet size is 0");
|
|
}
|
|
UInt32 bufferSizeBytes = mIOBufferSizeBytes = std::max(mIOBufferSizeBytes, mFileMaxPacketSize);
|
|
// must be big enough for at least one maximum size packet
|
|
|
|
if (mIOBufferList.mBuffers[0].mDataByteSize != bufferSizeBytes) {
|
|
mIOBufferList.mNumberBuffers = 1;
|
|
mIOBufferList.mBuffers[0].mNumberChannels = mFileDataFormat.mChannelsPerFrame;
|
|
if (!mClientOwnsIOBuffer) {
|
|
//printf("reallocating I/O buffer\n");
|
|
delete[] (Byte *)mIOBufferList.mBuffers[0].mData;
|
|
mIOBufferList.mBuffers[0].mData = new Byte[bufferSizeBytes];
|
|
}
|
|
mIOBufferList.mBuffers[0].mDataByteSize = bufferSizeBytes;
|
|
mIOBufferSizePackets = bufferSizeBytes / mFileMaxPacketSize;
|
|
}
|
|
|
|
UInt32 propertySize = sizeof(UInt32);
|
|
UInt32 externallyFramed;
|
|
XThrowIfError(AudioFormatGetProperty(kAudioFormatProperty_FormatIsExternallyFramed,
|
|
sizeof(AudioStreamBasicDescription), &mFileDataFormat, &propertySize, &externallyFramed),
|
|
"is format externally framed");
|
|
if (mNumPacketDescs != (externallyFramed ? mIOBufferSizePackets : 0)) {
|
|
delete[] mPacketDescs;
|
|
mPacketDescs = NULL;
|
|
mNumPacketDescs = 0;
|
|
|
|
if (externallyFramed) {
|
|
//printf("reallocating packet descs\n");
|
|
mPacketDescs = new AudioStreamPacketDescription[mIOBufferSizePackets];
|
|
mNumPacketDescs = mIOBufferSizePackets;
|
|
}
|
|
}
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::SetIOBuffer(void *buf)
|
|
{
|
|
if (!mClientOwnsIOBuffer)
|
|
delete[] (Byte *)mIOBufferList.mBuffers[0].mData;
|
|
mIOBufferList.mBuffers[0].mData = buf;
|
|
|
|
if (buf == NULL) {
|
|
mClientOwnsIOBuffer = false;
|
|
SetIOBufferSizeBytes(mIOBufferSizeBytes);
|
|
} else {
|
|
mClientOwnsIOBuffer = true;
|
|
AllocateBuffers();
|
|
}
|
|
// printf("CAAudioFile::SetIOBuffer %p: %p, 0x%lx bytes, mClientOwns = %d\n", this, mIOBufferList.mBuffers[0].mData, mIOBufferSizeBytes, mClientOwnsIOBuffer);
|
|
}
|
|
|
|
// ===============================================================================
|
|
|
|
/*
|
|
For Tiger:
|
|
added kAudioFilePropertyPacketToFrame and kAudioFilePropertyFrameToPacket.
|
|
You pass in an AudioFramePacketTranslation struct, with the appropriate field filled in, to AudioFileGetProperty.
|
|
|
|
kAudioFilePropertyPacketToFrame = 'pkfr',
|
|
// pass a AudioFramePacketTranslation with mPacket filled out and get mFrame back. mFrameOffsetInPacket is ignored.
|
|
kAudioFilePropertyFrameToPacket = 'frpk',
|
|
// pass a AudioFramePacketTranslation with mFrame filled out and get mPacket and mFrameOffsetInPacket back.
|
|
|
|
struct AudioFramePacketTranslation
|
|
{
|
|
SInt64 mFrame;
|
|
SInt64 mPacket;
|
|
UInt32 mFrameOffsetInPacket;
|
|
};
|
|
*/
|
|
|
|
SInt64 CAAudioFile::PacketToFrame(SInt64 packet) const
|
|
{
|
|
AudioFramePacketTranslation trans;
|
|
UInt32 propertySize;
|
|
|
|
switch (mFileDataFormat.mFramesPerPacket) {
|
|
case 1:
|
|
return packet;
|
|
case 0:
|
|
trans.mPacket = packet;
|
|
propertySize = sizeof(trans);
|
|
XThrowIfError(AudioFileGetProperty(mAudioFile, kAudioFilePropertyPacketToFrame, &propertySize, &trans),
|
|
"packet <-> frame translation unimplemented for format with variable frames/packet");
|
|
return trans.mFrame;
|
|
}
|
|
return packet * mFileDataFormat.mFramesPerPacket;
|
|
}
|
|
|
|
SInt64 CAAudioFile::FrameToPacket(SInt64 inFrame) const
|
|
{
|
|
AudioFramePacketTranslation trans;
|
|
UInt32 propertySize;
|
|
|
|
switch (mFileDataFormat.mFramesPerPacket) {
|
|
case 1:
|
|
return inFrame;
|
|
case 0:
|
|
trans.mFrame = inFrame;
|
|
propertySize = sizeof(trans);
|
|
XThrowIfError(AudioFileGetProperty(mAudioFile, kAudioFilePropertyFrameToPacket, &propertySize, &trans),
|
|
"packet <-> frame translation unimplemented for format with variable frames/packet");
|
|
return trans.mPacket;
|
|
}
|
|
return inFrame / mFileDataFormat.mFramesPerPacket;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
|
|
SInt64 CAAudioFile::Tell() const // frameNumber
|
|
{
|
|
return mFrameMark - mFrame0Offset;
|
|
}
|
|
|
|
void CAAudioFile::SeekToPacket(SInt64 packetNumber)
|
|
{
|
|
#if VERBOSE_IO
|
|
printf("CAAudioFile::SeekToPacket: %qd\n", packetNumber);
|
|
#endif
|
|
XThrowIf(mMode != kReading || packetNumber < 0 /*|| packetNumber >= mNumberPackets*/ , kExtAudioFileError_InvalidSeek, "seek to packet in audio file");
|
|
if (mPacketMark == packetNumber)
|
|
return; // already there! don't reset converter
|
|
mPacketMark = packetNumber;
|
|
|
|
mFrameMark = PacketToFrame(packetNumber) - mFrame0Offset;
|
|
mFramesToSkipFollowingSeek = 0;
|
|
if (mConverter)
|
|
// must reset -- if we reached end of stream. converter will no longer work otherwise
|
|
AudioConverterReset(mConverter);
|
|
}
|
|
|
|
/*
|
|
Example: AAC, 1024 frames/packet, 2112 frame offset
|
|
|
|
2112
|
|
|
|
|
Absolute frames: 0 1024 2048 | 3072
|
|
+---------+---------+--|------+---------+---------+
|
|
Packets: | 0 | 1 | | 2 | 3 | 4 |
|
|
+---------+---------+--|------+---------+---------+
|
|
Client frames: -2112 -1088 -64 | 960 SeekToFrame, TellFrame
|
|
|
|
|
0
|
|
|
|
* Offset between absolute and client frames is mFrame0Offset.
|
|
*** mFrameMark is in client frames ***
|
|
|
|
Examples:
|
|
clientFrame 0 960 1000 1024
|
|
absoluteFrame 2112 3072 3112 3136
|
|
packet 0 0 0 1
|
|
tempFrameMark* -2112 -2112 -2112 -1088
|
|
mFramesToSkipFollowingSeek 2112 3072 3112 2112
|
|
*/
|
|
void CAAudioFile::Seek(SInt64 clientFrame)
|
|
{
|
|
if (clientFrame == mFrameMark)
|
|
return; // already there! don't reset converter
|
|
|
|
//SInt64 absoluteFrame = clientFrame + mFrame0Offset;
|
|
XThrowIf(mMode != kReading || clientFrame < 0 || !mClientDataFormat.IsPCM(), kExtAudioFileError_InvalidSeek, "seek to frame in audio file");
|
|
|
|
#if VERBOSE_IO
|
|
SInt64 prevFrameMark = mFrameMark;
|
|
#endif
|
|
|
|
SInt64 packet;
|
|
packet = FrameToPacket(clientFrame);
|
|
if (packet < 0)
|
|
packet = 0;
|
|
SeekToPacket(packet);
|
|
// this will have backed up mFrameMark to match the beginning of the packet
|
|
mFramesToSkipFollowingSeek = std::max(UInt32(clientFrame - mFrameMark), UInt32(0));
|
|
mFrameMark = clientFrame;
|
|
|
|
#if VERBOSE_IO
|
|
printf("CAAudioFile::SeekToFrame: frame %qd (from %qd), packet %qd, skip %ld frames\n", mFrameMark, prevFrameMark, packet, mFramesToSkipFollowingSeek);
|
|
#endif
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::Read(UInt32 &ioNumPackets, AudioBufferList *ioData)
|
|
// May read fewer packets than requested if:
|
|
// buffer is not big enough
|
|
// file does not contain that many more packets
|
|
// Note that eofErr is not fatal, just results in 0 packets returned
|
|
// ioData's buffer sizes may be shortened
|
|
{
|
|
XThrowIf(mClientMaxPacketSize == 0, kExtAudioFileError_MaxPacketSizeUnknown, "client maximum packet size is 0");
|
|
if (mIOBufferList.mBuffers[0].mData == NULL) {
|
|
#if DEBUG
|
|
printf("warning: CAAudioFile::AllocateBuffers called from ReadPackets\n");
|
|
#endif
|
|
AllocateBuffers();
|
|
}
|
|
UInt32 bufferSizeBytes = ioData->mBuffers[0].mDataByteSize;
|
|
UInt32 maxNumPackets = bufferSizeBytes / mClientMaxPacketSize;
|
|
// older versions of AudioConverterFillComplexBuffer don't do this, so do our own sanity check
|
|
UInt32 nPackets = std::min(ioNumPackets, maxNumPackets);
|
|
|
|
mMaxPacketsToRead = ~0UL;
|
|
|
|
if (mClientDataFormat.mFramesPerPacket == 1) { // PCM or equivalent
|
|
while (mFramesToSkipFollowingSeek > 0) {
|
|
UInt32 skipFrames = std::min(mFramesToSkipFollowingSeek, maxNumPackets);
|
|
UInt32 framesPerPacket;
|
|
if ((framesPerPacket=mFileDataFormat.mFramesPerPacket) > 0)
|
|
mMaxPacketsToRead = (skipFrames + framesPerPacket - 1) / framesPerPacket;
|
|
|
|
if (mConverter == NULL) {
|
|
XThrowIfError(ReadInputProc(NULL, &skipFrames, ioData, NULL, this), "read audio file");
|
|
} else {
|
|
#if CAAUDIOFILE_PROFILE
|
|
mInConverter = true;
|
|
#endif
|
|
StartTiming(this, fill);
|
|
XThrowIfError(AudioConverterFillComplexBuffer(mConverter, ReadInputProc, this, &skipFrames, ioData, NULL), "convert audio packets (pcm read)");
|
|
ElapsedTime(this, fill, mTicksInConverter);
|
|
#if CAAUDIOFILE_PROFILE
|
|
mInConverter = false;
|
|
#endif
|
|
}
|
|
if (skipFrames == 0) { // hit EOF
|
|
ioNumPackets = 0;
|
|
return;
|
|
}
|
|
mFrameMark += skipFrames;
|
|
#if VERBOSE_IO
|
|
printf("CAAudioFile::ReadPackets: skipped %ld frames\n", skipFrames);
|
|
#endif
|
|
|
|
mFramesToSkipFollowingSeek -= skipFrames;
|
|
|
|
// restore mDataByteSize
|
|
for (int i = ioData->mNumberBuffers; --i >= 0 ; )
|
|
ioData->mBuffers[i].mDataByteSize = bufferSizeBytes;
|
|
}
|
|
}
|
|
|
|
if (mFileDataFormat.mFramesPerPacket > 0)
|
|
// don't read more packets than we are being asked to produce
|
|
mMaxPacketsToRead = nPackets / mFileDataFormat.mFramesPerPacket + 1;
|
|
if (mConverter == NULL) {
|
|
XThrowIfError(ReadInputProc(NULL, &nPackets, ioData, NULL, this), "read audio file");
|
|
} else {
|
|
#if CAAUDIOFILE_PROFILE
|
|
mInConverter = true;
|
|
#endif
|
|
StartTiming(this, fill);
|
|
XThrowIfError(AudioConverterFillComplexBuffer(mConverter, ReadInputProc, this, &nPackets, ioData, NULL), "convert audio packets (read)");
|
|
ElapsedTime(this, fill, mTicksInConverter);
|
|
#if CAAUDIOFILE_PROFILE
|
|
mInConverter = false;
|
|
#endif
|
|
}
|
|
if (mClientDataFormat.mFramesPerPacket == 1)
|
|
mFrameMark += nPackets;
|
|
|
|
ioNumPackets = nPackets;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
OSStatus CAAudioFile::ReadInputProc( AudioConverterRef inAudioConverter,
|
|
UInt32* ioNumberDataPackets,
|
|
AudioBufferList* ioData,
|
|
AudioStreamPacketDescription** outDataPacketDescription,
|
|
void* inUserData)
|
|
{
|
|
CAAudioFile *This = static_cast<CAAudioFile *>(inUserData);
|
|
|
|
#if 0
|
|
SInt64 remainingPacketsInFile = This->mNumberPackets - This->mPacketMark;
|
|
if (remainingPacketsInFile <= 0) {
|
|
*ioNumberDataPackets = 0;
|
|
ioData->mBuffers[0].mDataByteSize = 0;
|
|
if (outDataPacketDescription)
|
|
*outDataPacketDescription = This->mPacketDescs;
|
|
#if VERBOSE_IO
|
|
printf("CAAudioFile::ReadInputProc: EOF\n");
|
|
#endif
|
|
return noErr; // not eofErr; EOF is signified by 0 packets/0 bytes
|
|
}
|
|
#endif
|
|
|
|
// determine how much to read
|
|
AudioBufferList *readBuffer;
|
|
UInt32 readPackets;
|
|
if (inAudioConverter != NULL) {
|
|
// getting called from converter, need to use our I/O buffer
|
|
readBuffer = &This->mIOBufferList;
|
|
readPackets = This->mIOBufferSizePackets;
|
|
} else {
|
|
// getting called directly from ReadPackets, use supplied buffer
|
|
if (This->mFileMaxPacketSize == 0)
|
|
return kExtAudioFileError_MaxPacketSizeUnknown;
|
|
readBuffer = ioData;
|
|
readPackets = std::min(*ioNumberDataPackets, readBuffer->mBuffers[0].mDataByteSize / This->mFileMaxPacketSize);
|
|
// don't attempt to read more packets than will fit in the buffer
|
|
}
|
|
// don't try to read past EOF
|
|
// if (readPackets > remainingPacketsInFile)
|
|
// readPackets = remainingPacketsInFile;
|
|
// don't read more packets than necessary to produce the requested amount of converted data
|
|
if (readPackets > This->mMaxPacketsToRead) {
|
|
#if VERBOSE_IO
|
|
printf("CAAudioFile::ReadInputProc: limiting read to %ld packets (from %ld)\n", This->mMaxPacketsToRead, readPackets);
|
|
#endif
|
|
readPackets = This->mMaxPacketsToRead;
|
|
}
|
|
|
|
// read
|
|
UInt32 bytesRead;
|
|
OSStatus err;
|
|
|
|
StartTiming(This, read);
|
|
StartTiming(This, readinconv);
|
|
err = AudioFileReadPackets(This->mAudioFile, This->mUseCache, &bytesRead, This->mPacketDescs, This->mPacketMark, &readPackets, readBuffer->mBuffers[0].mData);
|
|
#if CAAUDIOFILE_PROFILE
|
|
if (This->mInConverter) ElapsedTime(This, readinconv, This->mTicksInReadInConverter);
|
|
#endif
|
|
ElapsedTime(This, read, This->mTicksInIO);
|
|
|
|
if (err) {
|
|
DebugMessageN1("Error %ld from AudioFileReadPackets!!!\n", err);
|
|
return err;
|
|
}
|
|
|
|
#if VERBOSE_IO
|
|
printf("CAAudioFile::ReadInputProc: read %ld packets (%qd-%qd), %ld bytes, err %ld\n", readPackets, This->mPacketMark, This->mPacketMark + readPackets, bytesRead, err);
|
|
#if VERBOSE_IO >= 2
|
|
if (This->mPacketDescs) {
|
|
for (UInt32 i = 0; i < readPackets; ++i) {
|
|
printf(" read packet %qd : offset %qd, length %ld\n", This->mPacketMark + i, This->mPacketDescs[i].mStartOffset, This->mPacketDescs[i].mDataByteSize);
|
|
}
|
|
}
|
|
printf(" read buffer:"); CAShowAudioBufferList(readBuffer, 0, 4);
|
|
#endif
|
|
#endif
|
|
if (readPackets == 0) {
|
|
*ioNumberDataPackets = 0;
|
|
ioData->mBuffers[0].mDataByteSize = 0;
|
|
return noErr;
|
|
}
|
|
|
|
if (outDataPacketDescription)
|
|
*outDataPacketDescription = This->mPacketDescs;
|
|
ioData->mBuffers[0].mDataByteSize = bytesRead;
|
|
ioData->mBuffers[0].mData = readBuffer->mBuffers[0].mData;
|
|
|
|
This->mPacketMark += readPackets;
|
|
if (This->mClientDataFormat.mFramesPerPacket != 1) { // for PCM client formats we update in Read
|
|
// but for non-PCM client format (weird case) we must update here/now
|
|
if (This->mFileDataFormat.mFramesPerPacket > 0)
|
|
This->mFrameMark += readPackets * This->mFileDataFormat.mFramesPerPacket;
|
|
else {
|
|
for (UInt32 i = 0; i < readPackets; ++i)
|
|
This->mFrameMark += This->mPacketDescs[i].mVariableFramesInPacket;
|
|
}
|
|
}
|
|
*ioNumberDataPackets = readPackets;
|
|
return noErr;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::Write(UInt32 numPackets, const AudioBufferList *data)
|
|
{
|
|
if (mIOBufferList.mBuffers[0].mData == NULL) {
|
|
#if DEBUG
|
|
printf("warning: CAAudioFile::AllocateBuffers called from WritePackets\n");
|
|
#endif
|
|
AllocateBuffers();
|
|
}
|
|
|
|
if (mMode == kPreparingToWrite)
|
|
mMode = kWriting;
|
|
else
|
|
XThrowIf(mMode != kWriting, kExtAudioFileError_InvalidOperationOrder, "can't write to this file");
|
|
if (mConverter != NULL) {
|
|
mWritePackets = numPackets;
|
|
mWriteBufferList->SetFrom(data);
|
|
WritePacketsFromCallback(WriteInputProc, this);
|
|
} else {
|
|
StartTiming(this, write);
|
|
XThrowIfError(AudioFileWritePackets(mAudioFile, mUseCache, data->mBuffers[0].mDataByteSize,
|
|
NULL, mPacketMark, &numPackets, data->mBuffers[0].mData),
|
|
"write audio file");
|
|
ElapsedTime(this, write, mTicksInIO);
|
|
#if VERBOSE_IO
|
|
printf("CAAudioFile::WritePackets: wrote %ld packets at %qd, %ld bytes\n", numPackets, mPacketMark, data->mBuffers[0].mDataByteSize);
|
|
#endif
|
|
//mNumberPackets =
|
|
mPacketMark += numPackets;
|
|
if (mFileDataFormat.mFramesPerPacket > 0)
|
|
mFrameMark += numPackets * mFileDataFormat.mFramesPerPacket;
|
|
// else: shouldn't happen since we're only called when there's no converter
|
|
}
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::FlushEncoder()
|
|
{
|
|
if (mConverter != NULL) {
|
|
mFinishingEncoding = true;
|
|
WritePacketsFromCallback(WriteInputProc, this);
|
|
mFinishingEncoding = false;
|
|
|
|
// get priming info from converter, set it on the file
|
|
if (mFileDataFormat.mBitsPerChannel == 0) {
|
|
UInt32 propertySize;
|
|
OSStatus err;
|
|
AudioConverterPrimeInfo primeInfo;
|
|
propertySize = sizeof(primeInfo);
|
|
|
|
err = AudioConverterGetProperty(mConverter, kAudioConverterPrimeInfo, &propertySize, &primeInfo);
|
|
if (err == noErr) {
|
|
AudioFilePacketTableInfo pti;
|
|
propertySize = sizeof(pti);
|
|
err = AudioFileGetProperty(mAudioFile, kAudioFilePropertyPacketTableInfo, &propertySize, &pti);
|
|
if (err == noErr) {
|
|
//printf("old packet table info: %qd valid, %ld priming, %ld remainder\n", pti.mNumberValidFrames, pti.mPrimingFrames, pti.mRemainderFrames);
|
|
UInt64 totalFrames = pti.mNumberValidFrames + pti.mPrimingFrames + pti.mRemainderFrames;
|
|
pti.mPrimingFrames = primeInfo.leadingFrames;
|
|
pti.mRemainderFrames = primeInfo.trailingFrames;
|
|
pti.mNumberValidFrames = totalFrames - pti.mPrimingFrames - pti.mRemainderFrames;
|
|
//printf("new packet table info: %qd valid, %ld priming, %ld remainder\n", pti.mNumberValidFrames, pti.mPrimingFrames, pti.mRemainderFrames);
|
|
XThrowIfError(AudioFileSetProperty(mAudioFile, kAudioFilePropertyPacketTableInfo, sizeof(pti), &pti), "couldn't set packet table info on audio file");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
OSStatus CAAudioFile::WriteInputProc( AudioConverterRef /*inAudioConverter*/,
|
|
UInt32 * ioNumberDataPackets,
|
|
AudioBufferList* ioData,
|
|
AudioStreamPacketDescription ** outDataPacketDescription,
|
|
void* inUserData)
|
|
{
|
|
CAAudioFile *This = static_cast<CAAudioFile *>(inUserData);
|
|
if (This->mFinishingEncoding) {
|
|
*ioNumberDataPackets = 0;
|
|
ioData->mBuffers[0].mDataByteSize = 0;
|
|
ioData->mBuffers[0].mData = NULL;
|
|
if (outDataPacketDescription)
|
|
*outDataPacketDescription = NULL;
|
|
return noErr;
|
|
}
|
|
UInt32 numPackets = This->mWritePackets;
|
|
if (numPackets == 0) {
|
|
return kNoMoreInputRightNow;
|
|
}
|
|
This->mWriteBufferList->ToAudioBufferList(ioData);
|
|
This->mWriteBufferList->BytesConsumed(numPackets * This->mClientDataFormat.mBytesPerFrame);
|
|
*ioNumberDataPackets = numPackets;
|
|
if (outDataPacketDescription)
|
|
*outDataPacketDescription = NULL;
|
|
This->mWritePackets -= numPackets;
|
|
return noErr;
|
|
}
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
#if VERBOSE_IO
|
|
static void hexdump(const void *addr, long len)
|
|
{
|
|
const Byte *p = (Byte *)addr;
|
|
UInt32 offset = 0;
|
|
|
|
if (len > 0x400) len = 0x400;
|
|
|
|
while (len > 0) {
|
|
int n = len > 16 ? 16 : len;
|
|
printf("%08lX: ", offset);
|
|
for (int i = 0; i < 16; ++i)
|
|
if (i < n)
|
|
printf("%02X ", p[i]);
|
|
else printf(" ");
|
|
for (int i = 0; i < 16; ++i)
|
|
if (i < n)
|
|
putchar(p[i] >= ' ' && p[i] < 127 ? p[i] : '.');
|
|
else putchar(' ');
|
|
putchar('\n');
|
|
p += 16;
|
|
len -= 16;
|
|
offset += 16;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// _______________________________________________________________________________________
|
|
//
|
|
void CAAudioFile::WritePacketsFromCallback(
|
|
AudioConverterComplexInputDataProc inInputDataProc,
|
|
void * inInputDataProcUserData)
|
|
{
|
|
while (true) {
|
|
// keep writing until we exhaust the input (temporary stop), or produce no output (EOF)
|
|
UInt32 numEncodedPackets = mIOBufferSizePackets;
|
|
mIOBufferList.mBuffers[0].mDataByteSize = mIOBufferSizeBytes;
|
|
#if CAAUDIOFILE_PROFILE
|
|
mInConverter = true;
|
|
#endif
|
|
StartTiming(this, fill);
|
|
OSStatus err = AudioConverterFillComplexBuffer(mConverter, inInputDataProc, inInputDataProcUserData,
|
|
&numEncodedPackets, &mIOBufferList, mPacketDescs);
|
|
ElapsedTime(this, fill, mTicksInConverter);
|
|
#if CAAUDIOFILE_PROFILE
|
|
mInConverter = false;
|
|
#endif
|
|
XThrowIf(err != 0 && err != kNoMoreInputRightNow, err, "convert audio packets (write)");
|
|
if (numEncodedPackets == 0)
|
|
break;
|
|
Byte *buf = (Byte *)mIOBufferList.mBuffers[0].mData;
|
|
#if VERBOSE_IO
|
|
printf("CAAudioFile::WritePacketsFromCallback: wrote %ld packets, %ld bytes\n", numEncodedPackets, mIOBufferList.mBuffers[0].mDataByteSize);
|
|
if (mPacketDescs) {
|
|
for (UInt32 i = 0; i < numEncodedPackets; ++i) {
|
|
printf(" write packet %qd : offset %qd, length %ld\n", mPacketMark + i, mPacketDescs[i].mStartOffset, mPacketDescs[i].mDataByteSize);
|
|
#if VERBOSE_IO >= 2
|
|
hexdump(buf + mPacketDescs[i].mStartOffset, mPacketDescs[i].mDataByteSize);
|
|
#endif
|
|
}
|
|
}
|
|
#endif
|
|
StartTiming(this, write);
|
|
XThrowIfError(AudioFileWritePackets(mAudioFile, mUseCache, mIOBufferList.mBuffers[0].mDataByteSize, mPacketDescs, mPacketMark, &numEncodedPackets, buf), "write audio file");
|
|
ElapsedTime(this, write, mTicksInIO);
|
|
mPacketMark += numEncodedPackets;
|
|
//mNumberPackets += numEncodedPackets;
|
|
if (mFileDataFormat.mFramesPerPacket > 0)
|
|
mFrameMark += numEncodedPackets * mFileDataFormat.mFramesPerPacket;
|
|
else {
|
|
for (UInt32 i = 0; i < numEncodedPackets; ++i)
|
|
mFrameMark += mPacketDescs[i].mVariableFramesInPacket;
|
|
}
|
|
if (err == kNoMoreInputRightNow)
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endif // !CAAF_USE_EXTAUDIOFILE
|