/** * @note This function returns by reference an open file reference (ExtAudioFileRef). You are responsbile for releasing this * this reference yourself when you are finished with it by calling ExtAudioFileDispose(). */ ExtAudioFileRef MyGetExtAudioFileRef(CFURLRef file_url, AudioStreamBasicDescription* audio_description) { OSStatus error_status = noErr; AudioStreamBasicDescription file_format; UInt32 property_size = sizeof(file_format); ExtAudioFileRef ext_file_ref = NULL; AudioStreamBasicDescription output_format; /* Open a file with ExtAudioFileOpen() */ error_status = ExtAudioFileOpenURL(file_url, &ext_file_ref); if(noErr != error_status) { printf("MyGetExtAudioFileRef: ExtAudioFileOpenURL failed, Error = %ld\n", error_status); if(NULL != ext_file_ref) { ExtAudioFileDispose(ext_file_ref); } return NULL; } /* Get the audio data format */ error_status = ExtAudioFileGetProperty(ext_file_ref, kExtAudioFileProperty_FileDataFormat, &property_size, &file_format); if(noErr != error_status) { printf("MyGetExtAudioFileRef: ExtAudioFileGetProperty(kExtAudioFileProperty_FileDataFormat) failed, Error = %ld\n", error_status); ExtAudioFileDispose(ext_file_ref); return NULL; } /* Don't know how to handle sounds with more than 2 channels (i.e. stereo) * Remember that OpenAL sound effects must be mono to be spatialized anyway. */ if(file_format.mChannelsPerFrame > 2) { printf("MyGetExtAudioFileRef: Unsupported Format, channel count (=%d) is greater than stereo\n", file_format.mChannelsPerFrame); ExtAudioFileDispose(ext_file_ref); return NULL; } /* The output format must be linear PCM because that's the only type OpenAL knows how to deal with. * Set the client format to 16 bit signed integer (native-endian) data because that is the most * optimal format on iPhone/iPod Touch hardware. * Maintain the channel count and sample rate of the original source format. */ output_format.mSampleRate = file_format.mSampleRate; // preserve the original sample rate output_format.mChannelsPerFrame = file_format.mChannelsPerFrame; // preserve the number of channels output_format.mFormatID = kAudioFormatLinearPCM; // We want linear PCM data output_format.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger; output_format.mFramesPerPacket = 1; // We know for linear PCM, the definition is 1 frame per packet output_format.mBitsPerChannel = 16; // We know we want 16-bit output_format.mBytesPerPacket = 2 * output_format.mChannelsPerFrame; // We know we are using 16-bit, so 2-bytes per channel per frame output_format.mBytesPerFrame = 2 * output_format.mChannelsPerFrame; // For PCM, since 1 frame is 1 packet, it is the same as mBytesPerPacket /* Set the desired client (output) data format */ error_status = ExtAudioFileSetProperty(ext_file_ref, kExtAudioFileProperty_ClientDataFormat, sizeof(output_format), &output_format); if(noErr != error_status) { printf("MyGetExtAudioFileRef: ExtAudioFileSetProperty(kExtAudioFileProperty_ClientDataFormat) failed, Error = %ld\n", error_status); ExtAudioFileDispose(ext_file_ref); return NULL; } /* Copy the output format to the audio_description that was passed in so the * info will be returned to the user. */ memcpy(audio_description, &output_format, sizeof(output_format)); return ext_file_ref; }
void* MyGetOpenALAudioData(CFURLRef inFileURL, ALsizei *outDataSize, ALenum *outDataFormat, ALsizei* outSampleRate) { OSStatus err = noErr; SInt64 theFileLengthInFrames = 0; AudioStreamBasicDescription theFileFormat; UInt32 thePropertySize = sizeof(theFileFormat); ExtAudioFileRef extRef = NULL; void* theData = NULL; AudioStreamBasicDescription theOutputFormat; // Open a file with ExtAudioFileOpen() err = ExtAudioFileOpenURL(inFileURL, &extRef); if(err) { printf("MyGetOpenALAudioData: ExtAudioFileOpenURL FAILED, Error = %ld\n", err); goto Exit; } // Get the audio data format err = ExtAudioFileGetProperty(extRef, kExtAudioFileProperty_FileDataFormat, &thePropertySize, &theFileFormat); if(err) { printf("MyGetOpenALAudioData: ExtAudioFileGetProperty(kExtAudioFileProperty_FileDataFormat) FAILED, Error = %ld\n", err); goto Exit; } if (theFileFormat.mChannelsPerFrame > 2) { printf("MyGetOpenALAudioData - Unsupported Format, channel count is greater than stereo\n"); goto Exit;} // Set the client format to 16 bit signed integer (native-endian) data // Maintain the channel count and sample rate of the original source format theOutputFormat.mSampleRate = theFileFormat.mSampleRate; theOutputFormat.mChannelsPerFrame = theFileFormat.mChannelsPerFrame; theOutputFormat.mFormatID = kAudioFormatLinearPCM; theOutputFormat.mBytesPerPacket = 2 * theOutputFormat.mChannelsPerFrame; theOutputFormat.mFramesPerPacket = 1; theOutputFormat.mBytesPerFrame = 2 * theOutputFormat.mChannelsPerFrame; theOutputFormat.mBitsPerChannel = 16; theOutputFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger; // Set the desired client (output) data format err = ExtAudioFileSetProperty(extRef, kExtAudioFileProperty_ClientDataFormat, sizeof(theOutputFormat), &theOutputFormat); if(err) { printf("MyGetOpenALAudioData: ExtAudioFileSetProperty(kExtAudioFileProperty_ClientDataFormat) FAILED, Error = %ld\n", err); goto Exit; } // Get the total frame count thePropertySize = sizeof(theFileLengthInFrames); err = ExtAudioFileGetProperty(extRef, kExtAudioFileProperty_FileLengthFrames, &thePropertySize, &theFileLengthInFrames); if(err) { printf("MyGetOpenALAudioData: ExtAudioFileGetProperty(kExtAudioFileProperty_FileLengthFrames) FAILED, Error = %ld\n", err); goto Exit; } // Read all the data into memory UInt32 dataSize = theFileLengthInFrames * theOutputFormat.mBytesPerFrame;; theData = malloc(dataSize); if (theData) { AudioBufferList theDataBuffer; theDataBuffer.mNumberBuffers = 1; theDataBuffer.mBuffers[0].mDataByteSize = dataSize; theDataBuffer.mBuffers[0].mNumberChannels = theOutputFormat.mChannelsPerFrame; theDataBuffer.mBuffers[0].mData = theData; // Read the data into an AudioBufferList err = ExtAudioFileRead(extRef, (UInt32*)&theFileLengthInFrames, &theDataBuffer); if(err == noErr) { // success *outDataSize = (ALsizei)dataSize; *outDataFormat = (theOutputFormat.mChannelsPerFrame > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16; *outSampleRate = (ALsizei)theOutputFormat.mSampleRate; } else { // failure free (theData); theData = NULL; // make sure to return NULL printf("MyGetOpenALAudioData: ExtAudioFileRead FAILED, Error = %ld\n", err); goto Exit; } } Exit: // Dispose the ExtAudioFileRef, it is no longer needed if (extRef) ExtAudioFileDispose(extRef); return theData; }
// soundsource overrides SoundSource::OpenResult SoundSourceCoreAudio::tryOpen(const AudioSourceConfig& audioSrcCfg) { const QString fileName(getLocalFileName()); //Open the audio file. OSStatus err; /** This code blocks works with OS X 10.5+ only. DO NOT DELETE IT for now. */ CFStringRef urlStr = CFStringCreateWithCharacters(0, reinterpret_cast<const UniChar *>(fileName.unicode()), fileName.size()); CFURLRef urlRef = CFURLCreateWithFileSystemPath(nullptr, urlStr, kCFURLPOSIXPathStyle, false); err = ExtAudioFileOpenURL(urlRef, &m_audioFile); CFRelease(urlStr); CFRelease(urlRef); /** TODO: Use FSRef for compatibility with 10.4 Tiger. Note that ExtAudioFileOpen() is deprecated above Tiger, so we must maintain both code paths if someone finishes this part of the code. FSRef fsRef; CFURLGetFSRef(reinterpret_cast<CFURLRef>(url.get()), &fsRef); err = ExtAudioFileOpen(&fsRef, &m_audioFile); */ if (err != noErr) { qDebug() << "SSCA: Error opening file " << fileName; return OpenResult::FAILED; } // get the input file format UInt32 inputFormatSize = sizeof(m_inputFormat); err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_FileDataFormat, &inputFormatSize, &m_inputFormat); if (err != noErr) { qDebug() << "SSCA: Error getting file format (" << fileName << ")"; return OpenResult::UNSUPPORTED_FORMAT; } m_bFileIsMp3 = m_inputFormat.mFormatID == kAudioFormatMPEGLayer3; // create the output format const UInt32 numChannels = audioSrcCfg.hasValidChannelCount() ? audioSrcCfg.getChannelCount() : 2; m_outputFormat = CAStreamBasicDescription(m_inputFormat.mSampleRate, numChannels, CAStreamBasicDescription::kPCMFormatFloat32, true); // set the client format err = ExtAudioFileSetProperty(m_audioFile, kExtAudioFileProperty_ClientDataFormat, sizeof(m_outputFormat), &m_outputFormat); if (err != noErr) { qDebug() << "SSCA: Error setting file property"; return OpenResult::FAILED; } //get the total length in frames of the audio file - copypasta: http://discussions.apple.com/thread.jspa?threadID=2364583&tstart=47 SInt64 totalFrameCount; UInt32 totalFrameCountSize = sizeof(totalFrameCount); err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_FileLengthFrames, &totalFrameCountSize, &totalFrameCount); if (err != noErr) { qDebug() << "SSCA: Error getting number of frames"; return OpenResult::FAILED; } // // WORKAROUND for bug in ExtFileAudio // AudioConverterRef acRef; UInt32 acrsize = sizeof(AudioConverterRef); err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_AudioConverter, &acrsize, &acRef); //_ThrowExceptionIfErr(@"kExtAudioFileProperty_AudioConverter", err); AudioConverterPrimeInfo primeInfo; UInt32 piSize = sizeof(AudioConverterPrimeInfo); memset(&primeInfo, 0, piSize); err = AudioConverterGetProperty(acRef, kAudioConverterPrimeInfo, &piSize, &primeInfo); if (err != kAudioConverterErr_PropertyNotSupported) { // Only if decompressing //_ThrowExceptionIfErr(@"kAudioConverterPrimeInfo", err); m_headerFrames = primeInfo.leadingFrames; } else { m_headerFrames = 0; } setChannelCount(m_outputFormat.NumberChannels()); setSamplingRate(m_inputFormat.mSampleRate); // NOTE(uklotzde): This is what I found when migrating // the code from SoundSource (sample-oriented) to the new // AudioSource (frame-oriented) API. It is not documented // when m_headerFrames > 0 and what the consequences are. setFrameCount(totalFrameCount/* - m_headerFrames*/); //Seek to position 0, which forces us to skip over all the header frames. //This makes sure we're ready to just let the Analyzer rip and it'll //get the number of samples it expects (ie. no header frames). seekSampleFrame(0); return OpenResult::SUCCEEDED; }
// soundsource overrides int SoundSourceCoreAudio::open() { //m_file.open(QIODevice::ReadOnly); //Open the audio file. OSStatus err; /** This code blocks works with OS X 10.5+ only. DO NOT DELETE IT for now. */ CFStringRef urlStr = CFStringCreateWithCharacters( 0, reinterpret_cast<const UniChar *>(m_qFilename.unicode()), m_qFilename.size()); CFURLRef urlRef = CFURLCreateWithFileSystemPath(NULL, urlStr, kCFURLPOSIXPathStyle, false); err = ExtAudioFileOpenURL(urlRef, &m_audioFile); CFRelease(urlStr); CFRelease(urlRef); /** TODO: Use FSRef for compatibility with 10.4 Tiger. Note that ExtAudioFileOpen() is deprecated above Tiger, so we must maintain both code paths if someone finishes this part of the code. FSRef fsRef; CFURLGetFSRef(reinterpret_cast<CFURLRef>(url.get()), &fsRef); err = ExtAudioFileOpen(&fsRef, &m_audioFile); */ if (err != noErr) { qDebug() << "SSCA: Error opening file " << m_qFilename; return ERR; } // get the input file format CAStreamBasicDescription inputFormat; UInt32 size = sizeof(inputFormat); m_inputFormat = inputFormat; err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_FileDataFormat, &size, &inputFormat); if (err != noErr) { qDebug() << "SSCA: Error getting file format (" << m_qFilename << ")"; return ERR; } //Debugging: //printf ("Source File format: "); inputFormat.Print(); //printf ("Dest File format: "); outputFormat.Print(); // create the output format m_outputFormat = CAStreamBasicDescription( inputFormat.mSampleRate, 2, CAStreamBasicDescription::kPCMFormatInt16, true); // set the client format err = ExtAudioFileSetProperty(m_audioFile, kExtAudioFileProperty_ClientDataFormat, sizeof(m_outputFormat), &m_outputFormat); if (err != noErr) { qDebug() << "SSCA: Error setting file property"; return ERR; } // Set m_iChannels and m_samples. m_iChannels = m_outputFormat.NumberChannels(); //get the total length in frames of the audio file - copypasta: http://discussions.apple.com/thread.jspa?threadID=2364583&tstart=47 UInt32 dataSize; SInt64 totalFrameCount; dataSize = sizeof(totalFrameCount); //XXX: This looks sketchy to me - Albert err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_FileLengthFrames, &dataSize, &totalFrameCount); if (err != noErr) { qDebug() << "SSCA: Error getting number of frames"; return ERR; } // // WORKAROUND for bug in ExtFileAudio // AudioConverterRef acRef; UInt32 acrsize=sizeof(AudioConverterRef); err = ExtAudioFileGetProperty(m_audioFile, kExtAudioFileProperty_AudioConverter, &acrsize, &acRef); //_ThrowExceptionIfErr(@"kExtAudioFileProperty_AudioConverter", err); AudioConverterPrimeInfo primeInfo; UInt32 piSize=sizeof(AudioConverterPrimeInfo); memset(&primeInfo, 0, piSize); err = AudioConverterGetProperty(acRef, kAudioConverterPrimeInfo, &piSize, &primeInfo); if (err != kAudioConverterErr_PropertyNotSupported) { // Only if decompressing //_ThrowExceptionIfErr(@"kAudioConverterPrimeInfo", err); m_headerFrames=primeInfo.leadingFrames; } m_samples = (totalFrameCount/*-m_headerFrames*/)*m_iChannels; m_iDuration = m_samples / (inputFormat.mSampleRate * m_iChannels); m_iSampleRate = inputFormat.mSampleRate; qDebug() << m_samples << totalFrameCount << m_iChannels; //Seek to position 0, which forces us to skip over all the header frames. //This makes sure we're ready to just let the Analyser rip and it'll //get the number of samples it expects (ie. no header frames). seek(0); return OK; }
int ConvertFile (CFURLRef inputFileURL, CAStreamBasicDescription &inputFormat, CFURLRef outputFileURL, AudioFileTypeID outputFileType, CAStreamBasicDescription &outputFormat, UInt32 outputBitRate) { ExtAudioFileRef infile, outfile; // first open the input file OSStatus err = ExtAudioFileOpenURL (inputFileURL, &infile); XThrowIfError (err, "ExtAudioFileOpen"); // if outputBitRate is specified, this can change the sample rate of the output file // so we let this "take care of itself" if (outputBitRate) outputFormat.mSampleRate = 0.; // create the output file (this will erase an exsiting file) err = ExtAudioFileCreateWithURL (outputFileURL, outputFileType, &outputFormat, NULL, kAudioFileFlags_EraseFile, &outfile); XThrowIfError (err, "ExtAudioFileCreateNew"); // get and set the client format - it should be lpcm CAStreamBasicDescription clientFormat = (inputFormat.mFormatID == kAudioFormatLinearPCM ? inputFormat : outputFormat); UInt32 size = sizeof(clientFormat); err = ExtAudioFileSetProperty(infile, kExtAudioFileProperty_ClientDataFormat, size, &clientFormat); XThrowIfError (err, "ExtAudioFileSetProperty inFile, kExtAudioFileProperty_ClientDataFormat"); size = sizeof(clientFormat); err = ExtAudioFileSetProperty(outfile, kExtAudioFileProperty_ClientDataFormat, size, &clientFormat); XThrowIfError (err, "ExtAudioFileSetProperty outFile, kExtAudioFileProperty_ClientDataFormat"); if( outputBitRate > 0 ) { printf ("Dest bit rate: %d\n", (int)outputBitRate); AudioConverterRef outConverter; size = sizeof(outConverter); err = ExtAudioFileGetProperty(outfile, kExtAudioFileProperty_AudioConverter, &size, &outConverter); XThrowIfError (err, "ExtAudioFileGetProperty outFile, kExtAudioFileProperty_AudioConverter"); err = AudioConverterSetProperty(outConverter, kAudioConverterEncodeBitRate, sizeof(outputBitRate), &outputBitRate); XThrowIfError (err, "AudioConverterSetProperty, kAudioConverterEncodeBitRate"); // we have changed the converter, so we should do this in case // setting a converter property changes the converter used by ExtAF in some manner CFArrayRef config = NULL; err = ExtAudioFileSetProperty(outfile, kExtAudioFileProperty_ConverterConfig, sizeof(config), &config); XThrowIfError (err, "ExtAudioFileSetProperty outFile, kExtAudioFileProperty_ConverterConfig"); } // set up buffers char srcBuffer[kSrcBufSize]; // do the read and write - the conversion is done on and by the write call while (1) { AudioBufferList fillBufList; fillBufList.mNumberBuffers = 1; fillBufList.mBuffers[0].mNumberChannels = inputFormat.mChannelsPerFrame; fillBufList.mBuffers[0].mDataByteSize = kSrcBufSize; fillBufList.mBuffers[0].mData = srcBuffer; // client format is always linear PCM - so here we determine how many frames of lpcm // we can read/write given our buffer size UInt32 numFrames = (kSrcBufSize / clientFormat.mBytesPerFrame); // printf("test %d\n", numFrames); err = ExtAudioFileRead (infile, &numFrames, &fillBufList); XThrowIfError (err, "ExtAudioFileRead"); if (!numFrames) { // this is our termination condition break; } err = ExtAudioFileWrite(outfile, numFrames, &fillBufList); XThrowIfError (err, "ExtAudioFileWrite"); } // close ExtAudioFileDispose(outfile); ExtAudioFileDispose(infile); return 0; }
void *GetOpenALAudioData(CFURLRef inFileURL, ALsizei *outDataSize, ALenum *outDataFormat, ALsizei *outSampleRate) { OSStatus err = noErr; ExtAudioFileRef extRef = NULL; err = ExtAudioFileOpenURL(inFileURL, &extRef); if (err != noErr) { printf("GetOpenALAudioData: ExtAudioFileOpenURL FAILED, Error = %ld\n", err); return NULL; } AudioStreamBasicDescription theFileFormat; UInt32 thePropertySize = sizeof(theFileFormat); err = ExtAudioFileGetProperty(extRef, kExtAudioFileProperty_FileDataFormat, &thePropertySize, &theFileFormat); if (err != noErr) { printf("GetOpenALAudioData: ExtAudioFileGetProperty(kExtAudioFileProperty_FileDataFormat) FAILED, Error = %ld\n", err); ExtAudioFileDispose(extRef); return NULL; } if (theFileFormat.mChannelsPerFrame > 2) { printf("GetOpenALAudioData: Unsupported format, channel count is greater than stereo\n"); ExtAudioFileDispose(extRef); return NULL; } // Set the output format to 16 bit signed integer (native-endian) data // Maintain the channel count and sample rate of the original source format AudioStreamBasicDescription theOutputFormat; theOutputFormat.mSampleRate = theFileFormat.mSampleRate; theOutputFormat.mChannelsPerFrame = theFileFormat.mChannelsPerFrame; theOutputFormat.mFormatID = kAudioFormatLinearPCM; theOutputFormat.mBytesPerPacket = 2 * theOutputFormat.mChannelsPerFrame; theOutputFormat.mFramesPerPacket = 1; theOutputFormat.mBytesPerFrame = 2 * theOutputFormat.mChannelsPerFrame; theOutputFormat.mBitsPerChannel = 16; theOutputFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger; err = ExtAudioFileSetProperty(extRef, kExtAudioFileProperty_ClientDataFormat, sizeof(theOutputFormat), &theOutputFormat); if (err != noErr) { printf("GetOpenALAudioData: ExtAudioFileSetProperty(kExtAudioFileProperty_ClientDataFormat) FAILED, Error = %ld\n", err); ExtAudioFileDispose(extRef); return NULL; } SInt64 theFileLengthInFrames = 0; thePropertySize = sizeof(theFileLengthInFrames); err = ExtAudioFileGetProperty(extRef, kExtAudioFileProperty_FileLengthFrames, &thePropertySize, &theFileLengthInFrames); if (err != noErr) { printf("GetOpenALAudioData: ExtAudioFileGetProperty(kExtAudioFileProperty_FileLengthFrames) FAILED, Error = %ld\n", err); ExtAudioFileDispose(extRef); return NULL; } UInt32 dataSize = theFileLengthInFrames * theOutputFormat.mBytesPerFrame; void *theData = malloc(dataSize); if (theData == NULL) { printf("GetOpenALAudioData: malloc FAILED\n"); ExtAudioFileDispose(extRef); return NULL; } AudioBufferList theDataBuffer; theDataBuffer.mNumberBuffers = 1; theDataBuffer.mBuffers[0].mDataByteSize = dataSize; theDataBuffer.mBuffers[0].mNumberChannels = theOutputFormat.mChannelsPerFrame; theDataBuffer.mBuffers[0].mData = theData; err = ExtAudioFileRead(extRef, (UInt32 *)&theFileLengthInFrames, &theDataBuffer); if (err != noErr) { printf("GetOpenALAudioData: ExtAudioFileRead FAILED, Error = %ld\n", err); free(theData); ExtAudioFileDispose(extRef); return NULL; } *outDataSize = (ALsizei)dataSize; *outDataFormat = (theOutputFormat.mChannelsPerFrame > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16; *outSampleRate = (ALsizei)theOutputFormat.mSampleRate; ExtAudioFileDispose(extRef); return theData; }
aubio_source_apple_audio_t * new_aubio_source_apple_audio(char_t * path, uint_t samplerate, uint_t block_size) { aubio_source_apple_audio_t * s = AUBIO_NEW(aubio_source_apple_audio_t); s->path = path; s->block_size = block_size; OSStatus err = noErr; UInt32 propSize; // open the resource url CFURLRef fileURL = getURLFromPath(path); err = ExtAudioFileOpenURL(fileURL, &s->audioFile); if (err) { AUBIO_ERR("error when trying to access %s, in ExtAudioFileOpenURL, %d\n", s->path, (int)err); goto beach;} // create an empty AudioStreamBasicDescription AudioStreamBasicDescription fileFormat; propSize = sizeof(fileFormat); memset(&fileFormat, 0, sizeof(AudioStreamBasicDescription)); // fill it with the file description err = ExtAudioFileGetProperty(s->audioFile, kExtAudioFileProperty_FileDataFormat, &propSize, &fileFormat); if (err) { AUBIO_ERROR("error in ExtAudioFileGetProperty, %d\n", (int)err); goto beach;} if (samplerate == 0) { samplerate = fileFormat.mSampleRate; //AUBIO_DBG("sampling rate set to 0, automagically adjusting to %d\n", samplerate); } s->samplerate = samplerate; s->source_samplerate = fileFormat.mSampleRate; s->channels = fileFormat.mChannelsPerFrame; AudioStreamBasicDescription clientFormat; propSize = sizeof(clientFormat); memset(&clientFormat, 0, sizeof(AudioStreamBasicDescription)); clientFormat.mFormatID = kAudioFormatLinearPCM; clientFormat.mSampleRate = (Float64)(s->samplerate); clientFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked; clientFormat.mChannelsPerFrame = s->channels; clientFormat.mBitsPerChannel = sizeof(short) * 8; clientFormat.mFramesPerPacket = 1; clientFormat.mBytesPerFrame = clientFormat.mBitsPerChannel * clientFormat.mChannelsPerFrame / 8; clientFormat.mBytesPerPacket = clientFormat.mFramesPerPacket * clientFormat.mBytesPerFrame; clientFormat.mReserved = 0; // set the client format description err = ExtAudioFileSetProperty(s->audioFile, kExtAudioFileProperty_ClientDataFormat, propSize, &clientFormat); if (err) { AUBIO_ERROR("error in ExtAudioFileSetProperty, %d\n", (int)err); #if 1 // print client and format descriptions AUBIO_DBG("Opened %s\n", s->path); AUBIO_DBG("file/client Format.mFormatID: : %3c%c%c%c / %c%c%c%c\n", (int)RT_BYTE4(fileFormat.mFormatID), (int)RT_BYTE3(fileFormat.mFormatID), (int)RT_BYTE2(fileFormat.mFormatID), (int)RT_BYTE1(fileFormat.mFormatID), (int)RT_BYTE4(clientFormat.mFormatID), (int)RT_BYTE3(clientFormat.mFormatID), (int)RT_BYTE2(clientFormat.mFormatID), (int)RT_BYTE1(clientFormat.mFormatID) ); AUBIO_DBG("file/client Format.mSampleRate : %6.0f / %.0f\n", fileFormat.mSampleRate , clientFormat.mSampleRate); AUBIO_DBG("file/client Format.mFormatFlags : %6d / %d\n", (int)fileFormat.mFormatFlags , (int)clientFormat.mFormatFlags); AUBIO_DBG("file/client Format.mChannelsPerFrame : %6d / %d\n", (int)fileFormat.mChannelsPerFrame, (int)clientFormat.mChannelsPerFrame); AUBIO_DBG("file/client Format.mBitsPerChannel : %6d / %d\n", (int)fileFormat.mBitsPerChannel , (int)clientFormat.mBitsPerChannel); AUBIO_DBG("file/client Format.mFramesPerPacket : %6d / %d\n", (int)fileFormat.mFramesPerPacket , (int)clientFormat.mFramesPerPacket); AUBIO_DBG("file/client Format.mBytesPerFrame : %6d / %d\n", (int)fileFormat.mBytesPerFrame , (int)clientFormat.mBytesPerFrame); AUBIO_DBG("file/client Format.mBytesPerPacket : %6d / %d\n", (int)fileFormat.mBytesPerPacket , (int)clientFormat.mBytesPerPacket); AUBIO_DBG("file/client Format.mReserved : %6d / %d\n", (int)fileFormat.mReserved , (int)clientFormat.mReserved); #endif goto beach; } // compute the size of the segments needed to read the input file UInt32 samples = s->block_size * clientFormat.mChannelsPerFrame; Float64 rateRatio = clientFormat.mSampleRate / fileFormat.mSampleRate; uint_t segmentSize= (uint_t)(samples * rateRatio + .5); if (rateRatio < 1.) { segmentSize = (uint_t)(samples / rateRatio + .5); } else if (rateRatio > 1.) { AUBIO_WRN("up-sampling %s from %0.2fHz to %0.2fHz\n", s->path, fileFormat.mSampleRate, clientFormat.mSampleRate); } else { assert ( segmentSize == samples ); //AUBIO_DBG("not resampling, segmentSize %d, block_size %d\n", segmentSize, s->block_size); } // allocate the AudioBufferList if (createAubioBufferList(&s->bufferList, s->channels, segmentSize)) err = -1; return s; beach: AUBIO_FREE(s); return NULL; }
static void* GetOpenALAudioData( KLAL* p, CFURLRef fileURL, ALsizei* dataSize, ALenum* dataFormat, ALsizei *sampleRate) { OSStatus err; UInt32 size; UInt32 bufferSize; void* data = NULL; AudioBufferList dataBuffer; // オーディオファイルを開く ExtAudioFileRef audioFile; err = ExtAudioFileOpenURL(fileURL, &audioFile); if (err) { KLLog("[KLAL] GetOpenALAudioData(A):%d\n",(int)err); goto Exit; } //CFRelease(fileURL); // オーディオデータフォーマットを取得する AudioStreamBasicDescription fileFormat; size = sizeof(fileFormat); err = ExtAudioFileGetProperty(audioFile, kExtAudioFileProperty_FileDataFormat, &size, &fileFormat); if (err) { KLLog("[KLAL] GetOpenALAudioData(B):%d\n",(int)err); goto Exit; } // アウトプットフォーマットを設定する AudioStreamBasicDescription outputFormat; outputFormat.mSampleRate = fileFormat.mSampleRate; outputFormat.mChannelsPerFrame = fileFormat.mChannelsPerFrame; outputFormat.mFormatID = kAudioFormatLinearPCM; outputFormat.mBytesPerPacket = 2 * outputFormat.mChannelsPerFrame; outputFormat.mFramesPerPacket = 1; outputFormat.mBytesPerFrame = 2 * outputFormat.mChannelsPerFrame; outputFormat.mBitsPerChannel = 16;//fileFormat.mBitsPerChannel; outputFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger; p->wav.channel = outputFormat.mChannelsPerFrame; p->wav.bit = fileFormat.mBitsPerChannel; p->wav.freq = fileFormat.mSampleRate; err = ExtAudioFileSetProperty( audioFile, kExtAudioFileProperty_ClientDataFormat, sizeof(outputFormat), &outputFormat); if (err) { KLLog("[KLAL] GetOpenALAudioData(C):%d\n",(int)err); goto Exit; } // フレーム数を取得する SInt64 fileLengthFrames = 0; size = sizeof(fileLengthFrames); err = ExtAudioFileGetProperty( audioFile, kExtAudioFileProperty_FileLengthFrames, &size, &fileLengthFrames); if (err) { KLLog("[KLAL] GetOpenALAudioData(D):%d\n",(int)err); goto Exit; } // バッファを用意する bufferSize = (UInt32) fileLengthFrames * (UInt32) outputFormat.mBytesPerFrame; data = Malloc(bufferSize); dataBuffer.mNumberBuffers = 1; dataBuffer.mBuffers[0].mDataByteSize = bufferSize; dataBuffer.mBuffers[0].mNumberChannels = outputFormat.mChannelsPerFrame; dataBuffer.mBuffers[0].mData = data; p->wav.sz = bufferSize; // バッファにデータを読み込む err = ExtAudioFileRead(audioFile, (UInt32*)&fileLengthFrames, &dataBuffer); if (err) { KLLog("[KLAL] GetOpenALAudioData(E):%d\n",(int)err); sfree(data); goto Exit; } // 出力値を設定する *dataSize = (ALsizei)bufferSize; *dataFormat = (outputFormat.mChannelsPerFrame > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16; *sampleRate = (ALsizei)outputFormat.mSampleRate; Exit: // オーディオファイルを破棄する if (audioFile) { ExtAudioFileDispose(audioFile); } return data; }
CoreAudioReadStream::CoreAudioReadStream(string path) : m_path(path), m_d(new D) { m_channelCount = 0; m_sampleRate = 0; if (!QFile(m_path).exists()) { throw FileNotFound(m_path); } QByteArray ba = m_path.toLocal8Bit(); CFURLRef url = CFURLCreateFromFileSystemRepresentation (kCFAllocatorDefault, (const UInt8 *)ba.data(), (CFIndex)ba.length(), false); //!!! how do we find out if the file open fails because of DRM protection? #if (MACOSX_DEPLOYMENT_TARGET <= 1040 && MAC_OS_X_VERSION_MIN_REQUIRED <= 1040) FSRef fsref; if (!CFURLGetFSRef(url, &fsref)) { // returns Boolean, not error code m_error = "CoreAudioReadStream: Error looking up FS ref (file not found?)"; throw FileReadFailed(m_path); } m_d->err = ExtAudioFileOpen(&fsref, &m_d->file); #else m_d->err = ExtAudioFileOpenURL(url, &m_d->file); #endif CFRelease(url); if (m_d->err) { m_error = "CoreAudioReadStream: Error opening file: code " + codestr(m_d->err); throw InvalidFileFormat(path, "failed to open audio file"); } if (!m_d->file) { m_error = "CoreAudioReadStream: Failed to open file, but no error reported!"; throw InvalidFileFormat(path, "failed to open audio file"); } UInt32 propsize = sizeof(AudioStreamBasicDescription); m_d->err = ExtAudioFileGetProperty (m_d->file, kExtAudioFileProperty_FileDataFormat, &propsize, &m_d->asbd); if (m_d->err) { m_error = "CoreAudioReadStream: Error in getting basic description: code " + codestr(m_d->err); ExtAudioFileDispose(m_d->file); throw FileOperationFailed(m_path, "get basic description", codestr(m_d->err)); } m_channelCount = m_d->asbd.mChannelsPerFrame; m_sampleRate = m_d->asbd.mSampleRate; cerr << "CoreAudioReadStream: " << m_channelCount << " channels, " << m_sampleRate << " Hz" << std::endl; m_d->asbd.mSampleRate = getSampleRate(); m_d->asbd.mFormatID = kAudioFormatLinearPCM; m_d->asbd.mFormatFlags = kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked | kAudioFormatFlagsNativeEndian; m_d->asbd.mBitsPerChannel = sizeof(float) * 8; m_d->asbd.mBytesPerFrame = sizeof(float) * m_channelCount; m_d->asbd.mBytesPerPacket = sizeof(float) * m_channelCount; m_d->asbd.mFramesPerPacket = 1; m_d->asbd.mReserved = 0; m_d->err = ExtAudioFileSetProperty (m_d->file, kExtAudioFileProperty_ClientDataFormat, propsize, &m_d->asbd); if (m_d->err) { m_error = "CoreAudioReadStream: Error in setting client format: code " + codestr(m_d->err); throw FileOperationFailed(m_path, "set client format", codestr(m_d->err)); } m_d->buffer.mNumberBuffers = 1; m_d->buffer.mBuffers[0].mNumberChannels = m_channelCount; m_d->buffer.mBuffers[0].mDataByteSize = 0; m_d->buffer.mBuffers[0].mData = 0; }