| /* |
| Copyright © 2011 Apple Inc. All rights reserved. |
| |
| IMPORTANT: This Apple software is supplied to you by Apple 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 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. |
| */ |
| |
| /* |
| * main.cpp |
| * |
| * Converts pcm data contained in a .wav or .caf file into Apple Lossless (ALAC) put into a .caf file |
| * or converts ALAC data from a .caf file into pcm data and put into a .wav or .caf file |
| * |
| */ |
| |
| #include <cstdio> |
| #include <cstdlib> |
| #include <cstring> |
| |
| // these are headers for the ALAC encoder and decoder |
| #include "ALACEncoder.h" |
| #include "ALACDecoder.h" |
| #include "ALACBitUtilities.h" |
| |
| // these are utility headers for this sample code |
| #include "CAFFileALAC.h" |
| #include "EndianPortable.h" |
| |
| #define kMaxBERSize 5 |
| #define kCAFFdataChunkEditsSize 4 |
| |
| #define kWAVERIFFChunkSize 12 |
| #define kWAVEfmtChunkSize 24 |
| #define kWAVEdataChunkHeaderSize 8 |
| |
| #define VERBOSE 0 |
| |
| #define kFileTypeUnknown (-1) |
| #define kFileTypeWAV (1463899717) |
| #define kFileTypeCAFF (1667327590) |
| |
| // Helper functions |
| int32_t GetInputFormat(FILE * inputFile, AudioFormatDescription * theInputFormat, uint32_t * theFileType); |
| int32_t SetOutputFormat(AudioFormatDescription theInputFormat, AudioFormatDescription * theOutputFormat); |
| int32_t FindDataStart(FILE * inputFile, uint32_t inputFileType, int32_t * dataPos, int32_t * dataSize); |
| int32_t EncodeALAC(FILE * inputFile, FILE * outputFile, AudioFormatDescription theInputFormat, AudioFormatDescription theOutputFormat, int32_t inputDataSize); |
| int32_t DecodeALAC(FILE * inputFile, FILE * outputFile, AudioFormatDescription theInputFormat, AudioFormatDescription theOutputFormat, int32_t inputDataSize, uint32_t outputFileType); |
| void GetOutputFileType(char * outputFileName, uint32_t * outputFileType); |
| ALACChannelLayoutTag GetALACChannelLayoutTag(uint32_t inChannelsPerFrame); |
| |
| // Some crude WAVE writing tools |
| void WriteWAVERIFFChunk(FILE * outputFile); |
| void WriteWAVEfmtChunk(FILE * outputFile, AudioFormatDescription theOutputFormat); |
| void WriteWAVEdataChunk(FILE * outputFile); |
| void WriteWAVEChunkSize(FILE * outputFile, uint32_t numDataBytes); |
| |
| // Adapted from CoreAudioTypes.h |
| enum |
| { |
| kTestFormatFlag_16BitSourceData = 1, |
| kTestFormatFlag_20BitSourceData = 2, |
| kTestFormatFlag_24BitSourceData = 3, |
| kTestFormatFlag_32BitSourceData = 4 |
| }; |
| |
| |
| int main (int argc, char * argv[]) |
| { |
| char * inputFileName = argv[1]; |
| char * outputFileName = argv[2]; |
| FILE * inputFile = NULL; |
| FILE * outputFile = NULL; |
| |
| bool malformed = argc < 2; |
| |
| // Parse the commandline and open the necessary files |
| for (int32_t i = 1; i < argc; ++i) |
| { |
| if (strcmp (argv[i], "-h") == 0) |
| { |
| malformed = true; |
| } |
| else |
| { |
| if (strcmp(inputFileName, "-") == 0) inputFile = stdin; |
| if (strcmp(outputFileName, "-") == 0) outputFile = stdout; |
| if (inputFile == NULL) inputFile = fopen (inputFileName, "rb"); // the b is necessary for Windows -- ignored by Unix |
| if(inputFile == NULL) |
| { |
| fprintf(stderr," Cannot open file \"%s\"\n", inputFileName); |
| exit (1); |
| } |
| |
| if (outputFile == NULL) outputFile = fopen (outputFileName, "w+b"); // the b is necessary for Windows -- ignored by Unix |
| if(outputFile == NULL) |
| { |
| fprintf(stderr," Cannot open file \"%s\"\n", outputFileName); |
| exit (1); |
| } |
| } |
| |
| if (malformed) |
| { |
| break; |
| } |
| } |
| |
| if (!malformed) |
| { |
| #if VERBOSE |
| printf("Input file: %s\n", inputFileName); |
| printf("Output file: %s\n", outputFileName); |
| #endif |
| // So at this point we have the input and output files open. Need to determine what we're dealing with |
| int32_t theError = 0; |
| AudioFormatDescription inputFormat; |
| AudioFormatDescription outputFormat; |
| int32_t inputDataPos = 0, inputDataSize = 0; |
| uint32_t inputFileType = 0; // kFileTypeCAFF or kFileTypeWAV |
| uint32_t outputFileType = 0; // kFileTypeCAFF or kFileTypeWAV |
| |
| theError = GetInputFormat(inputFile, &inputFormat, &inputFileType); |
| if (theError) |
| { |
| fprintf(stderr," Cannot determine what format file \"%s\" is\n", inputFileName); |
| exit (1); |
| } |
| |
| if (inputFileType != kFileTypeWAV && inputFileType != kFileTypeCAFF) |
| { |
| fprintf(stderr," File \"%s\" is of an unsupported type\n", outputFileName); |
| exit (1); |
| } |
| |
| if (inputFormat.mFormatID != kALACFormatAppleLossless && inputFormat.mFormatID != kALACFormatLinearPCM) |
| { |
| fprintf(stderr," File \"%s\'s\" data format is of an unsupported type\n", outputFileName); |
| exit (1); |
| } |
| |
| SetOutputFormat(inputFormat, &outputFormat); |
| |
| if (theError) |
| { |
| fprintf(stderr," Cannot determine what format file \"%s\" is\n", outputFileName); |
| exit (1); |
| } |
| FindDataStart(inputFile, inputFileType, &inputDataPos, &inputDataSize); |
| fseek(inputFile, inputDataPos, SEEK_SET); |
| |
| // We know where we are and we know what we're doing |
| if (outputFormat.mFormatID == kALACFormatAppleLossless) |
| { |
| // encoding |
| EncodeALAC(inputFile, outputFile, inputFormat, outputFormat, inputDataSize); |
| } |
| else |
| { |
| // decoding |
| outputFileType = inputFileType == kFileTypeWAV? kFileTypeCAFF : kFileTypeWAV; |
| |
| if (outputFileType == kFileTypeWAV && outputFormat.mChannelsPerFrame > 2) |
| { |
| // we don't support WAVE because we don't want to reinterleave on output |
| fprintf(stderr," Cannot decode more than two channels to WAVE\n"); |
| exit (1); |
| } |
| DecodeALAC(inputFile, outputFile, inputFormat, outputFormat, inputDataSize, outputFileType); |
| } |
| } |
| |
| if (malformed) { |
| printf ("Usage:\n"); |
| printf ("Encode:\n"); |
| printf (" alacconvert <input wav or caf file> <output caf file>\n"); |
| printf ("Decode:\n"); |
| printf (" alacconvert <input caf file> <output wav or caf file>\n"); |
| printf ("\n"); |
| return 1; |
| } |
| |
| if (inputFile) fclose(inputFile); |
| if (outputFile) fclose(outputFile); |
| |
| return 0; |
| } |
| |
| |
| int32_t GetInputFormat(FILE * inputFile, AudioFormatDescription * theInputFormat, uint32_t * theFileType) |
| { |
| // assumes the file is open |
| uint8_t theReadBuffer[20]; |
| bool done = false; |
| uint32_t chunkType = 0; |
| |
| fread(theReadBuffer, 1, 4, inputFile); |
| |
| if (theReadBuffer[0] == 'c' && theReadBuffer[1] == 'a' && theReadBuffer[2] == 'f' & theReadBuffer[3] == 'f') |
| { |
| // It's a caff file! |
| *theFileType = kFileTypeCAFF; |
| // We support pcm data for encode and alac data for decode |
| done = GetCAFFdescFormat(inputFile, theInputFormat); |
| } |
| else if (theReadBuffer[0] == 'R' && theReadBuffer[1] == 'I' && theReadBuffer[2] == 'F' & theReadBuffer[3] == 'F') |
| { |
| fread(theReadBuffer, 1, 8, inputFile); |
| if (theReadBuffer[4] == 'W' && theReadBuffer[5] == 'A' && theReadBuffer[6] == 'V' & theReadBuffer[7] == 'E') |
| { |
| // It's a WAVE file! |
| *theFileType = kFileTypeWAV; |
| // We only support pcm data |
| while (!done) |
| { |
| uint32_t theChunkSize = 0, theSampleRate = 0; |
| fread(theReadBuffer, 1, 4, inputFile); |
| chunkType = ((int32_t)(theReadBuffer[0]) << 24) + ((int32_t)(theReadBuffer[1]) << 16) + ((int32_t)(theReadBuffer[2]) << 8) + theReadBuffer[3]; |
| switch (chunkType) |
| { |
| case 'fmt ': |
| fread(theReadBuffer, 1, 20, inputFile); |
| // Remember campers we're in little endian land |
| if (theReadBuffer[4] != 1 || theReadBuffer[5] != 0) |
| { |
| // we only support PCM |
| *theFileType = 0; // clear it |
| return -1; |
| } |
| theInputFormat->mFormatID = kALACFormatLinearPCM; |
| theInputFormat->mChannelsPerFrame = theReadBuffer[6]; |
| theSampleRate = ((int32_t)(theReadBuffer[11]) << 24) + ((int32_t)(theReadBuffer[10]) << 16) + ((int32_t)(theReadBuffer[9]) << 8) + theReadBuffer[8]; |
| theInputFormat->mSampleRate = theSampleRate; |
| theInputFormat->mBitsPerChannel = theReadBuffer[18]; |
| theInputFormat->mFormatFlags = kALACFormatFlagIsSignedInteger | kALACFormatFlagIsPacked; // always little endian |
| theInputFormat->mBytesPerPacket = theInputFormat->mBytesPerFrame = (theInputFormat->mBitsPerChannel >> 3) * theInputFormat->mChannelsPerFrame; |
| theInputFormat->mFramesPerPacket = 1; |
| theInputFormat->mReserved = 0; |
| done = true; |
| break; |
| default: |
| // read the size and skip |
| fread(theReadBuffer, 1, 4, inputFile); |
| theChunkSize = ((int32_t)(theReadBuffer[3]) << 24) + ((int32_t)(theReadBuffer[2]) << 16) + ((int32_t)(theReadBuffer[1]) << 8) + theReadBuffer[0]; |
| fseek(inputFile, theChunkSize, SEEK_CUR); |
| break; |
| } |
| } |
| } |
| else |
| { |
| *theFileType = 0; // clear it |
| return -1; |
| } |
| } |
| else |
| { |
| *theFileType = 0; // clear it |
| return -1; |
| } |
| |
| if (!done) return -1; |
| |
| return 0; |
| } |
| |
| int32_t SetOutputFormat(AudioFormatDescription theInputFormat, AudioFormatDescription * theOutputFormat) |
| { |
| if (theInputFormat.mFormatID == kALACFormatLinearPCM) |
| { |
| // encoding |
| theOutputFormat->mFormatID = kALACFormatAppleLossless; |
| theOutputFormat->mSampleRate = theInputFormat.mSampleRate; |
| |
| switch(theInputFormat.mBitsPerChannel) |
| { |
| case 16: |
| theOutputFormat->mFormatFlags = kTestFormatFlag_16BitSourceData; |
| break; |
| case 20: |
| theOutputFormat->mFormatFlags = kTestFormatFlag_20BitSourceData; |
| break; |
| case 24: |
| theOutputFormat->mFormatFlags = kTestFormatFlag_24BitSourceData; |
| break; |
| case 32: |
| theOutputFormat->mFormatFlags = kTestFormatFlag_32BitSourceData; |
| break; |
| default: |
| return -1; |
| break; |
| } |
| |
| theOutputFormat->mFramesPerPacket = kALACDefaultFramesPerPacket; |
| theOutputFormat->mChannelsPerFrame = theInputFormat.mChannelsPerFrame; |
| // mBytesPerPacket == 0 because we are VBR |
| // mBytesPerFrame and mBitsPerChannel == 0 because there are no discernable bits assigned to a particular sample |
| // mReserved is always 0 |
| theOutputFormat->mBytesPerPacket = theOutputFormat->mBytesPerFrame = theOutputFormat->mBitsPerChannel = theOutputFormat->mReserved = 0; |
| } |
| else |
| { |
| // decoding |
| theOutputFormat->mFormatID = kALACFormatLinearPCM; |
| theOutputFormat->mSampleRate = theInputFormat.mSampleRate; |
| |
| switch(theInputFormat.mFormatFlags) |
| { |
| case kTestFormatFlag_16BitSourceData: |
| theOutputFormat->mBitsPerChannel = 16; |
| break; |
| case kTestFormatFlag_20BitSourceData: |
| theOutputFormat->mBitsPerChannel = 20; |
| break; |
| case kTestFormatFlag_24BitSourceData: |
| theOutputFormat->mBitsPerChannel = 24; |
| break; |
| case kTestFormatFlag_32BitSourceData: |
| theOutputFormat->mBitsPerChannel = 32; |
| break; |
| default: |
| return -1; |
| break; |
| } |
| |
| theOutputFormat->mFramesPerPacket = 1; |
| theOutputFormat->mChannelsPerFrame = theInputFormat.mChannelsPerFrame; |
| theOutputFormat->mBytesPerPacket = theOutputFormat->mBytesPerFrame = theOutputFormat->mBitsPerChannel != 20 ? theInputFormat.mChannelsPerFrame * ((theOutputFormat->mBitsPerChannel) >> 3) : (int32_t)(theInputFormat.mChannelsPerFrame * 2.5 + .5); |
| theOutputFormat->mFormatFlags = kALACFormatFlagsNativeEndian; |
| theOutputFormat->mReserved = 0; |
| } |
| return 0; |
| } |
| |
| int32_t FindDataStart(FILE * inputFile, uint32_t inputFileType, int32_t * dataPos, int32_t * dataSize) |
| { |
| // returns the absolute position within the file |
| int32_t currentPosition = ftell(inputFile); // record the current position |
| uint8_t theReadBuffer[12]; |
| uint32_t chunkType = 0, fileSize = 0, chunkSize = 0; |
| bool done = false; |
| |
| switch (inputFileType) |
| { |
| case kFileTypeWAV: |
| fseek(inputFile, 0, SEEK_SET); // start at 0 |
| fread(theReadBuffer, 1, 8, inputFile); |
| fileSize = ((int32_t)(theReadBuffer[7]) << 24) + ((int32_t)(theReadBuffer[6]) << 16) + ((int32_t)(theReadBuffer[5]) << 8) + theReadBuffer[4]; |
| fseek(inputFile, 12, SEEK_SET); // start at 12! |
| while (!done && ((uint32_t)(ftell(inputFile)) < fileSize)) |
| { |
| fread(theReadBuffer, 1, 8, inputFile); |
| chunkType = ((int32_t)(theReadBuffer[0]) << 24) + ((int32_t)(theReadBuffer[1]) << 16) + ((int32_t)(theReadBuffer[2]) << 8) + theReadBuffer[3]; |
| switch(chunkType) |
| { |
| case 'data': |
| *dataPos = ftell(inputFile); |
| // little endian size |
| *dataSize = ((int32_t)(theReadBuffer[7]) << 24) + ((int32_t)(theReadBuffer[6]) << 16) + ((int32_t)(theReadBuffer[5]) << 8) + theReadBuffer[4]; |
| done = true; |
| break; |
| default: |
| chunkSize = ((int32_t)(theReadBuffer[7]) << 24) + ((int32_t)(theReadBuffer[6]) << 16) + ((int32_t)(theReadBuffer[5]) << 8) + theReadBuffer[4]; |
| fseek(inputFile, chunkSize, SEEK_CUR); |
| break; |
| } |
| } |
| break; |
| case kFileTypeCAFF: |
| done = FindCAFFDataStart(inputFile, dataPos, dataSize); |
| break; |
| } |
| |
| fseek(inputFile, currentPosition, SEEK_SET); // start at 0 |
| |
| if (!done) return -1; |
| |
| return 0; |
| } |
| |
| int32_t EncodeALAC(FILE * inputFile, FILE * outputFile, AudioFormatDescription theInputFormat, AudioFormatDescription theOutputFormat, int32_t inputDataSize) |
| { |
| int32_t theInputPacketBytes = theInputFormat.mChannelsPerFrame * (theInputFormat.mBitsPerChannel >> 3) * theOutputFormat.mFramesPerPacket; |
| int32_t theOutputPacketBytes = theInputPacketBytes + kALACMaxEscapeHeaderBytes; |
| int32_t thePacketTableSize = 0, packetTablePos = 0, dataPos = 0, dataSizePos = 0, theBERSize = 0, packetTableSizePos; |
| uint8_t * theReadBuffer = (uint8_t *)calloc(theInputPacketBytes, 1); |
| uint8_t * theWriteBuffer = (uint8_t *)calloc(theOutputPacketBytes, 1); |
| int32_t numBytes = 0; |
| uint32_t packetTableBytesLeft = 0; |
| int64_t numDataBytes = 0; |
| port_CAFPacketTableHeader thePacketTableHeader; |
| int32_t inputDataBytesRemaining = inputDataSize; |
| uint8_t * theMagicCookie = NULL; |
| uint32_t theMagicCookieSize = 0; |
| |
| ALACEncoder * theEncoder = new ALACEncoder; |
| |
| theEncoder->SetFrameSize(theOutputFormat.mFramesPerPacket); |
| theEncoder->InitializeEncoder(theOutputFormat); |
| |
| // we only write out the caff header, the 'desc' chunk. the 'kuki' chunk, the 'pakt' chunk and the 'data' chunk |
| // write out the caff header |
| WriteCAFFcaffChunk(outputFile); |
| |
| // write out the desc chunk |
| WriteCAFFdescChunk(outputFile, theOutputFormat); |
| |
| // get the magic cookie |
| theMagicCookieSize = theEncoder->GetMagicCookieSize(theOutputFormat.mChannelsPerFrame); |
| theMagicCookie = (uint8_t *)calloc(theMagicCookieSize, 1); |
| theEncoder->GetMagicCookie(theMagicCookie, &theMagicCookieSize); |
| |
| // write out the kuki chunk |
| WriteCAFFkukiChunk(outputFile, theMagicCookie, theMagicCookieSize); |
| free(theMagicCookie); |
| |
| // We might be multi channel |
| if (theOutputFormat.mChannelsPerFrame > 2) |
| { |
| WriteCAFFchanChunk(outputFile, GetALACChannelLayoutTag(theOutputFormat.mChannelsPerFrame)); |
| } |
| |
| // Figure out the maximum size and build the base pakt header |
| BuildBasePacketTable(theInputFormat, inputDataSize, &thePacketTableSize, &thePacketTableHeader); |
| packetTableBytesLeft = thePacketTableSize; |
| |
| // This could be substantially larger than either the read or write buffer, so allocate a block of memory here |
| // all we're going to do is copy it to the file |
| uint8_t * thePacketTableEntries = (uint8_t *)calloc (thePacketTableSize, 1); |
| |
| /* move */ |
| thePacketTableSize += kMinCAFFPacketTableHeaderSize; |
| |
| WriteCAFFpaktChunkHeader(outputFile, &thePacketTableHeader, thePacketTableSize); |
| |
| packetTableSizePos = packetTablePos = ftell(outputFile); |
| packetTableSizePos -= (sizeof(int64_t) + kMinCAFFPacketTableHeaderSize); |
| |
| thePacketTableSize -= kMinCAFFPacketTableHeaderSize; |
| fwrite (thePacketTableEntries, 1, thePacketTableSize, outputFile); |
| free(thePacketTableEntries); |
| |
| // We'll write out the data chunk next. The 'data' size will start past the 'data' chunk identifier |
| dataSizePos = ftell(outputFile) + sizeof(uint32_t); |
| |
| // Finally, write out the data chunk |
| WriteCAFFdataChunk(outputFile); |
| |
| dataPos = ftell(outputFile); |
| |
| while (theInputPacketBytes <= inputDataBytesRemaining) |
| { |
| numBytes = fread(theReadBuffer, 1, theInputPacketBytes, inputFile); |
| #if VERBOSE |
| printf ("Read %i bytes\n", numBytes); |
| #endif |
| inputDataBytesRemaining -= numBytes; |
| if ((theInputFormat.mFormatFlags & 0x02) != kALACFormatFlagsNativeEndian) |
| { |
| #if VERBOSE |
| printf ("Byte Swapping!\n"); |
| #endif |
| if (theInputFormat.mBitsPerChannel == 16) |
| { |
| uint16_t * theShort = (uint16_t *)theReadBuffer; |
| for (int32_t i = 0; i < (numBytes >> 1); ++i) |
| { |
| Swap16(&(theShort[i])); |
| } |
| } |
| else if (theInputFormat.mBitsPerChannel == 32) |
| { |
| uint32_t * theLong = (uint32_t *)theReadBuffer; |
| for (int32_t i = 0; i < (numBytes >> 2); ++i) |
| { |
| Swap32(&(theLong[i])); |
| } |
| } |
| else // covers both 20 and 24 |
| { |
| for (int32_t i = 0; i < numBytes; i += 3) |
| { |
| Swap24(&(theReadBuffer[i])); |
| } |
| } |
| } |
| theEncoder->Encode(theInputFormat, theInputFormat, theReadBuffer, theWriteBuffer, &numBytes); |
| |
| GetBERInteger(numBytes, theReadBuffer, &theBERSize); |
| fseek(outputFile, packetTablePos, SEEK_SET); |
| fwrite(theReadBuffer, 1, theBERSize, outputFile); |
| packetTablePos += theBERSize; |
| packetTableBytesLeft -= theBERSize; |
| |
| fseek(outputFile, dataPos, SEEK_SET); |
| fwrite(theWriteBuffer, 1, numBytes, outputFile); |
| dataPos += numBytes; |
| numDataBytes += numBytes; |
| #if VERBOSE |
| printf ("Writing %i bytes\n", numBytes); |
| #endif |
| } |
| // encode the last partial packet |
| if (inputDataBytesRemaining) |
| { |
| numBytes = fread(theReadBuffer, 1, inputDataBytesRemaining, inputFile); |
| #if VERBOSE |
| printf ("Last Packet! Read %i bytes\n", numBytes); |
| #endif |
| inputDataBytesRemaining -= numBytes; |
| if ((theInputFormat.mFormatFlags & 0x02) != kALACFormatFlagsNativeEndian) |
| { |
| #if VERBOSE |
| printf ("Byte Swapping!\n"); |
| #endif |
| if (theInputFormat.mBitsPerChannel == 16) |
| { |
| uint16_t * theShort = (uint16_t *)theReadBuffer; |
| for (int32_t i = 0; i < (numBytes >> 1); ++i) |
| { |
| Swap16(&(theShort[i])); |
| } |
| } |
| else if (theInputFormat.mBitsPerChannel == 32) |
| { |
| uint32_t * theLong = (uint32_t *)theReadBuffer; |
| for (int32_t i = 0; i < (numBytes >> 2); ++i) |
| { |
| Swap32(&(theLong[i])); |
| } |
| } |
| else // covers both 20 and 24 |
| { |
| for (int32_t i = 0; i < numBytes; i += 3) |
| { |
| Swap24(&(theReadBuffer[i])); |
| } |
| } |
| } |
| theEncoder->Encode(theInputFormat, theInputFormat, theReadBuffer, theWriteBuffer, &numBytes); |
| |
| GetBERInteger(numBytes, theReadBuffer, &theBERSize); |
| fseek(outputFile, packetTablePos, SEEK_SET); |
| fwrite(theReadBuffer, 1, theBERSize, outputFile); |
| packetTablePos += theBERSize; |
| packetTableBytesLeft -= theBERSize; |
| |
| fseek(outputFile, dataPos, SEEK_SET); |
| fwrite(theWriteBuffer, 1, numBytes, outputFile); |
| dataPos += numBytes; |
| numDataBytes += numBytes; |
| #if VERBOSE |
| printf ("Writing %i bytes\n", numBytes); |
| #endif |
| } |
| |
| // cleanup -- if we have a lot of bytes left over in packet table, write a free chunk |
| if (packetTableBytesLeft > sizeof(port_CAFChunkHeader)) // min size required to write |
| { |
| #if VERBOSE |
| printf ("Writing %i free bytes\n", packetTableBytesLeft); |
| #endif |
| fseek(outputFile, packetTablePos, SEEK_SET); |
| WriteCAFFfreeChunk(outputFile, packetTableBytesLeft); |
| fseek(outputFile, packetTableSizePos, SEEK_SET); |
| WriteCAFFChunkSize(outputFile, thePacketTableSize - packetTableBytesLeft + kMinCAFFPacketTableHeaderSize); |
| } |
| // write out the data size |
| fseek(outputFile, dataSizePos, SEEK_SET); |
| numDataBytes += kCAFFdataChunkEditsSize; |
| #if VERBOSE |
| printf ("numDataBytes == %i bytes\n", numDataBytes); |
| #endif |
| WriteCAFFChunkSize(outputFile, numDataBytes); |
| |
| delete theEncoder; |
| |
| free(theReadBuffer); |
| free(theWriteBuffer); |
| |
| return 0; |
| } |
| |
| // There's not a whole lot of difference between encode and decode on this level |
| int32_t DecodeALAC(FILE * inputFile, FILE * outputFile, AudioFormatDescription theInputFormat, AudioFormatDescription theOutputFormat, int32_t inputDataSize, uint32_t outputFileType) |
| { |
| int32_t theInputPacketBytes = theInputFormat.mChannelsPerFrame * (theOutputFormat.mBitsPerChannel >> 3) * theInputFormat.mFramesPerPacket + kALACMaxEscapeHeaderBytes; |
| int32_t theOutputPacketBytes = theInputPacketBytes - kALACMaxEscapeHeaderBytes; |
| int32_t thePacketTableSize = 0, packetTablePos = 0, outputDataSizePos = 0, inputDataPos = 0; |
| uint8_t * theReadBuffer = (uint8_t *)calloc(theInputPacketBytes, 1); |
| uint8_t * theWriteBuffer = (uint8_t *)calloc(theOutputPacketBytes, 1); |
| int32_t numBytes = 0; |
| int64_t numDataBytes = 0; |
| uint32_t numFrames = 0; |
| BitBuffer theInputBuffer; |
| uint8_t * theMagicCookie = NULL; |
| uint32_t theMagicCookieSize = 0; |
| |
| ALACDecoder * theDecoder = new ALACDecoder; |
| |
| // We need to get the cookie from the file |
| theMagicCookieSize = GetMagicCookieSizeFromCAFFkuki(inputFile); |
| theMagicCookie = (uint8_t *)calloc(theMagicCookieSize, 1); |
| GetMagicCookieFromCAFFkuki(inputFile, theMagicCookie, &theMagicCookieSize); |
| |
| // While we don't have a use for this here, if you were using arbitrary channel layouts, you'd need to run the following check: |
| |
| theDecoder->Init(theMagicCookie, theMagicCookieSize); |
| free(theMagicCookie); |
| |
| BitBufferInit(&theInputBuffer, theReadBuffer, theInputPacketBytes); |
| inputDataPos = ftell(inputFile); |
| |
| if (outputFileType != kFileTypeWAV) |
| { |
| // we only write out the caff header, the 'desc' chunk and the 'data' chunk |
| // write out the caff header |
| WriteCAFFcaffChunk(outputFile); |
| |
| // write out the desc chunk |
| WriteCAFFdescChunk(outputFile, theOutputFormat); |
| |
| // We might be multi channel |
| if (theOutputFormat.mChannelsPerFrame > 2) |
| { |
| // we are not rearranging the output data |
| WriteCAFFchanChunk(outputFile, CAFFChannelLayoutTags[theOutputFormat.mChannelsPerFrame - 1]); |
| } |
| |
| // We'll write out the data chunk next. The 'data' size will start past the 'data' chunk identifier |
| outputDataSizePos = ftell(outputFile) + sizeof(uint32_t); |
| |
| // Finally, write out the data chunk |
| WriteCAFFdataChunk(outputFile); |
| } |
| else |
| { |
| // We're writing a mono or stereo WAVE file |
| WriteWAVERIFFChunk(outputFile); |
| WriteWAVEfmtChunk(outputFile, theOutputFormat); |
| WriteWAVEdataChunk(outputFile); |
| outputDataSizePos = ftell(outputFile) - sizeof(uint32_t); |
| } |
| |
| // We do have to get the packet size from the packet table |
| FindCAFFPacketTableStart(inputFile, &packetTablePos, &thePacketTableSize); |
| |
| fseek(inputFile, packetTablePos, SEEK_SET); |
| numBytes = fread(theReadBuffer, 1, kMaxBERSize, inputFile); |
| |
| theInputPacketBytes = ReadBERInteger(theReadBuffer, &numBytes); |
| packetTablePos += numBytes; |
| fseek(inputFile, inputDataPos, SEEK_SET); |
| inputDataPos += theInputPacketBytes; |
| |
| while ((theInputPacketBytes > 0) && ((size_t)theInputPacketBytes == fread(theReadBuffer, 1, theInputPacketBytes, inputFile))) |
| { |
| #if VERBOSE |
| printf ("Read %i bytes\n", theInputPacketBytes); |
| #endif |
| theDecoder->Decode(&theInputBuffer, theWriteBuffer, theInputFormat.mFramesPerPacket, theInputFormat.mChannelsPerFrame, &numFrames); |
| numBytes = numFrames * theOutputFormat.mBytesPerFrame; |
| #if VERBOSE |
| printf ("Writing %i bytes\n", numBytes); |
| #endif |
| fwrite(theWriteBuffer, 1, numBytes, outputFile); |
| numDataBytes += numBytes; |
| fseek(inputFile, packetTablePos, SEEK_SET); |
| numBytes = fread(theReadBuffer, 1, kMaxBERSize, inputFile); |
| |
| theInputPacketBytes = ReadBERInteger(theReadBuffer, &numBytes); |
| #if VERBOSE |
| printf ("theInputPacketBytes == %i bytes\n", theInputPacketBytes); |
| #endif |
| packetTablePos += numBytes; |
| fseek(inputFile, inputDataPos, SEEK_SET); |
| inputDataPos += theInputPacketBytes; |
| BitBufferReset(&theInputBuffer); |
| } |
| if (outputFileType != kFileTypeWAV) |
| { |
| // cleanup -- write out the data size |
| fseek(outputFile, outputDataSizePos, SEEK_SET); |
| numDataBytes += kCAFFdataChunkEditsSize; // add in the edit bytes |
| #if VERBOSE |
| printf ("numDataBytes == %i bytes\n", numDataBytes); |
| #endif |
| WriteCAFFChunkSize(outputFile, numDataBytes); |
| } |
| else |
| { |
| // cleanup -- write out the data size |
| fseek(outputFile, outputDataSizePos, SEEK_SET); |
| WriteWAVEChunkSize(outputFile, (uint32_t)numDataBytes); |
| // write out the file size |
| fseek(outputFile, 4, SEEK_SET); |
| WriteWAVEChunkSize(outputFile, numDataBytes + sizeof(outputFileType) + kWAVEdataChunkHeaderSize + kWAVEfmtChunkSize); // add in the size for kFileTypeWAV, size of the data' chunk header and the 'fmt ' chunk |
| } |
| |
| delete theDecoder; |
| |
| free(theReadBuffer); |
| free(theWriteBuffer); |
| |
| return 0; |
| } |
| |
| ALACChannelLayoutTag GetALACChannelLayoutTag(uint32_t inChannelsPerFrame) |
| { |
| return ALACChannelLayoutTags[inChannelsPerFrame - 1]; |
| } |
| |
| void WriteWAVERIFFChunk(FILE * outputFile) |
| { |
| uint8_t theReadBuffer[kWAVERIFFChunkSize] = {'R', 'I', 'F', 'F', 0, 0, 0, 0, 'W', 'A', 'V', 'E'}; |
| |
| fwrite(theReadBuffer, 1, kWAVERIFFChunkSize, outputFile); |
| } |
| |
| void WriteWAVEfmtChunk(FILE * outputFile, AudioFormatDescription theOutputFormat) |
| { |
| // we use a standard 'fmt ' chunk for our pcm data where 16 is the chunk size and 1 is the compression code |
| uint8_t theBuffer[kWAVEfmtChunkSize] = {'f', 'm', 't', ' ', 16, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| uint32_t theSampleRate = theOutputFormat.mSampleRate; |
| uint32_t theAverageBytesPerSecond = theSampleRate * theOutputFormat.mBytesPerFrame; |
| |
| theBuffer[10] = theOutputFormat.mChannelsPerFrame; |
| |
| theBuffer[12] = theSampleRate & 0xff; |
| theBuffer[13] = (theSampleRate >> 8) & 0xff; |
| theBuffer[14] = (theSampleRate >> 16) & 0xff; |
| theBuffer[15] = theSampleRate >> 24; |
| |
| theBuffer[16] = theAverageBytesPerSecond & 0xff; |
| theBuffer[17] = (theAverageBytesPerSecond >> 8) & 0xff; |
| theBuffer[18] = (theAverageBytesPerSecond >> 16) & 0xff; |
| theBuffer[19] = theAverageBytesPerSecond >> 24; |
| |
| theBuffer[20] = theOutputFormat.mBytesPerFrame; |
| |
| theBuffer[22] = theOutputFormat.mBitsPerChannel; |
| |
| fwrite(theBuffer, 1, kWAVEfmtChunkSize, outputFile); |
| } |
| |
| void WriteWAVEdataChunk(FILE * outputFile) |
| { |
| uint8_t theBuffer[kWAVEdataChunkHeaderSize] = {'d', 'a', 't', 'a', 0, 0, 0, 0}; |
| |
| fwrite(theBuffer, 1, kWAVEdataChunkHeaderSize, outputFile); |
| } |
| |
| void WriteWAVEChunkSize(FILE * outputFile, uint32_t numDataBytes) |
| { |
| uint8_t theBuffer[4]; |
| |
| theBuffer[0] = numDataBytes & 0xff; |
| theBuffer[1] = (numDataBytes >> 8) & 0xff; |
| theBuffer[2] = (numDataBytes >> 16) & 0xff; |
| theBuffer[3] = (numDataBytes >> 24) & 0xff; |
| fwrite(theBuffer, 1, 4, outputFile); |
| } |
