recording.m

#import <Foundation/Foundation.h>
#import <CoreServices/CoreServices.h>
#import <AudioUnit/AudioUnit.h>
#import <AudioToolBox/AudioToolBox.h>

typedef struct
{
	AudioUnit *unit;
	NSMutableArray *buffers;
	AudioStreamBasicDescription *asbd;
	size_t tmpBufferSize;
	void *tmpBuffer;
} sharedData;

static int end;

static void signalHandler(int sig)
{
	fprintf(stderr,"stopping\n");
	end = 1;
}

static OSStatus inputProc(
				   void *inRefCon,
				   AudioUnitRenderActionFlags *ioActionFlags,
				   const AudioTimeStamp *inTimeStamp,
				   UInt32 inBusNumber,
				   UInt32 inNumberFrames,
				   AudioBufferList * ioData)
{
	OSStatus err = noErr;
	AudioBufferList list;
	sharedData *sharedData = inRefCon;
	list.mNumberBuffers = 1;
	list.mBuffers[0].mNumberChannels = sharedData->asbd->mChannelsPerFrame;
	list.mBuffers[0].mDataByteSize = sharedData->asbd->mBytesPerFrame*inNumberFrames;
	if(sharedData->tmpBufferSize < list.mBuffers[0].mDataByteSize) {
		sharedData->tmpBuffer = (unsigned char *)realloc(sharedData->tmpBuffer,list.mBuffers[0].mDataByteSize);
		sharedData->tmpBufferSize = list.mBuffers[0].mDataByteSize;
	}
	list.mBuffers[0].mData = sharedData->tmpBuffer;
	
    err = AudioUnitRender(*sharedData->unit,
						  ioActionFlags,
						  inTimeStamp,
						  inBusNumber,
						  inNumberFrames,
						  &list);
	
	if(err == noErr) {
		NSData *data = [[NSData alloc] initWithBytes:list.mBuffers[0].mData length:list.mBuffers[0].mDataByteSize];
		@synchronized(sharedData->buffers) {
			[sharedData->buffers addObject:data];
		}
		[data release];
	}
	
    return err;
}

int main(void)
{
	AudioUnit inputUnit;
	AudioStreamBasicDescription inFormat, outFormat;
	ComponentDescription desc;
	Component comp;
	AURenderCallbackStruct  inCallback;
	UInt32 enableIO;
	UInt32 size=0;
	OSStatus	err ;
	AudioDeviceID inputDevice;
	sharedData sharedData;
	ExtAudioFileRef file;
	FSRef dirFSRef;
	
	/* Open AUHAL for input */
	desc.componentType = kAudioUnitType_Output; 
	desc.componentSubType = kAudioUnitSubType_HALOutput;
	desc.componentManufacturer = kAudioUnitManufacturer_Apple;
	desc.componentFlags = 0;
	desc.componentFlagsMask = 0;
	comp = FindNextComponent(NULL, &desc);
	if (comp == NULL) {
		fprintf(stderr, "can't find HAL output unit\n");
		return -1;
	}
	
	err = OpenAComponent(comp, &inputUnit);
	if (err)  {
		fprintf(stderr, "can't open HAL output unit\n");
		return -1;
	}
	
	/* Configure AUHAL */
	err = AudioUnitInitialize(inputUnit);
	if(err != noErr) {
		fprintf(stderr, "AudioUnitInitialize failed.\n");
		CloseComponent(inputUnit);
		return -1;
	}
	
	enableIO = 1;
	AudioUnitSetProperty(inputUnit,
						 kAudioOutputUnitProperty_EnableIO,
						 kAudioUnitScope_Input,
						 1,
						 &enableIO,
						 sizeof(enableIO));
	
	enableIO = 0;
	AudioUnitSetProperty(inputUnit,
						 kAudioOutputUnitProperty_EnableIO,
						 kAudioUnitScope_Output,
						 0,
						 &enableIO,
						 sizeof(enableIO));
	
	/* Get default input device */
	size = sizeof(AudioDeviceID);
    err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultInputDevice,
								   &size,
								   &inputDevice);
	if (err)  {
		fprintf(stderr, "can't get default input device\n");
		CloseComponent(inputUnit);
		return -1;
	}
	
	size = 100;
	char buf[100];
	err = AudioDeviceGetProperty(inputDevice, 0, false, kAudioDevicePropertyDeviceName, &size, buf);
	fprintf(stderr,"Device: %s\n",buf);
	
	err = AudioUnitSetProperty(inputUnit,
							   kAudioOutputUnitProperty_CurrentDevice,
							   kAudioUnitScope_Global,
							   0,
							   &inputDevice,
							   sizeof(inputDevice));
	if (err)  {
		fprintf(stderr, "can't set default input device\n");
		CloseComponent(inputUnit);
		return -1;
	}
	
	/* Setup input/output format */
	size = sizeof(AudioStreamBasicDescription);
	err = AudioUnitGetProperty(inputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 1, &inFormat, &size);
	if(err != noErr) {
		fprintf(stderr, "AudioUnitGetProperty(input format) failed.\n");
		CloseComponent(inputUnit);
		return -1;
	}
	err = AudioUnitSetProperty(inputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &inFormat, sizeof(AudioStreamBasicDescription));
	if(err != noErr) {
		fprintf(stderr, "AudioUnitSetProperty(input format) failed.\n");
		CloseComponent(inputUnit);
		return -1;
	}
	
	/* Setup callback */
	memset(&sharedData,0,sizeof(sharedData));
	sharedData.unit = &inputUnit;
	sharedData.buffers = [[NSMutableArray alloc] init];
	sharedData.asbd = &inFormat;
	memset(&inCallback, 0, sizeof(AURenderCallbackStruct));
	inCallback.inputProc = inputProc;
	inCallback.inputProcRefCon = &sharedData;
	err = AudioUnitSetProperty (inputUnit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &inCallback, sizeof(AURenderCallbackStruct));
	if(err != noErr) {
		fprintf(stderr, "AudioUnitSetProperty(input) failed.\n");
		CloseComponent(inputUnit);
		return -1;
	}
	
	/* Setup output codec */
	memset(&outFormat,0,sizeof(AudioStreamBasicDescription));
	outFormat.mFormatID = kAudioFormatAppleLossless;
	outFormat.mBitsPerChannel = 16;
	outFormat.mFormatFlags = kAppleLosslessFormatFlag_16BitSourceData;
	outFormat.mSampleRate = inFormat.mSampleRate;
	outFormat.mChannelsPerFrame = inFormat.mChannelsPerFrame;
	
	FSPathMakeRef((UInt8*)realpath(".",NULL) ,&dirFSRef,NULL);
	remove("recording.m4a");
	if(ExtAudioFileCreateNew(&dirFSRef, CFSTR("recording.m4a"), kAudioFileM4AType, &outFormat, NULL, &file) != noErr)
	{
		fprintf(stderr, "ExtAudioFileCreateNew failed.\n");
		CloseComponent(inputUnit);
		return -1;
	}
	
	if(ExtAudioFileSetProperty(file, kExtAudioFileProperty_ClientDataFormat, sizeof(AudioStreamBasicDescription), &inFormat) != noErr) {
		fprintf(stderr, "ExtAudioFileSetProperty failed.\n");
		CloseComponent(inputUnit);
		ExtAudioFileDispose(file);
		return -1;
	}
	
	/* register signal handler */
	signal(SIGINT, signalHandler);
	signal(SIGHUP, signalHandler);
	
	/* start recording */
	AudioOutputUnitStart(inputUnit);
	
	while(!end)
	{
		NSArray *buffers = nil;
		@synchronized(sharedData.buffers) {
			if([sharedData.buffers count]) {
				buffers = [[NSArray alloc] initWithArray:sharedData.buffers];
				[sharedData.buffers removeAllObjects];
			}
		}
		if(buffers) {
			int i;
			AudioBufferList list;
			for(i=0;i<[buffers count];i++) {
				list.mNumberBuffers = 1;
				list.mBuffers[0].mNumberChannels = inFormat.mChannelsPerFrame;
				list.mBuffers[0].mDataByteSize = [[buffers objectAtIndex:i] length];
				list.mBuffers[0].mData = (void *)[[buffers objectAtIndex:i] bytes];
				if((err = ExtAudioFileWrite(file, list.mBuffers[0].mDataByteSize/inFormat.mBytesPerFrame, &list)) != noErr) {
					fprintf(stderr, "ExtAudioFileWrite failed.\n");
					goto last;
				}
			}
			
			[buffers release];
		}
		else {
			usleep(10000);
		}
	}
	
  last:
	AudioOutputUnitStop(inputUnit);
	CloseComponent(inputUnit);
	ExtAudioFileDispose(file);
	
	return 0;
}