jackaudio
/
jack1
mirror of https://github.com/jackaudio/jack1
1
0
Fork 0
Code Releases 19 Activity
jack1 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
558 Commits
4 Branches
6.8MB
Tree: c94066f80a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c94066f80a'
${ noResults }
jack1/drivers/coreaudio/AudioRender.cpp

462 lines
13KB
Raw Blame History 

  1. /*

  2.  *  AudioRender.cpp

  3.  *

  4.  *  Copyright (c) 2004 Johnny Petrantoni. All rights reserved.

  5.  *

  6.  *  This program is free software; you can redistribute it and/or

  7.  *  modify it under the terms of the GNU Lesser General Public License

  8.  *  as published by the Free Software Foundation; either version 2.1

  9.  *  of the License, or (at your option) any later version.

  10.  *

  11.  *  This program is distributed in the hope that it will be useful,

  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  *  Lesser General Public License for more details.

  15.  *

  16.  *  You should have received a copy of the GNU Lesser General Public

  17.  *  License along with this program; if not, write to the Free

  18.  *  Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

  19.  *  02111-1307, USA.

  20.  *

  21.  *  Created by Johnny Petrantoni on Fri Jan 30 2004.

  22.  *  This code is part of Panda framework (moduleloader.cpp)

  23.  *  http://xpanda.sourceforge.net

  24.  */

  25. 

  26. #include <unistd.h>

  27. #include "AudioRender.h"

  28. 

  29. float AudioRender::gSampleRate = 0.0;

  30. long AudioRender::gBufferSize = 0;

  31. int AudioRender::gInputChannels = 0;

  32. int AudioRender::gOutputChannels = 0;

  33. AudioRender *AudioRender::theRender = NULL;

  34. bool AudioRender::isProcessing = false;

  35. const AudioTimeStamp *AudioRender::gTime;

  36. 

  37. #define PRINTDEBUG 1

  38. 

  39. extern "C" void JCALog(char *fmt, ...)

  40. {

  41. #ifdef PRINTDEBUG

  42.     va_list ap;

  43.     va_start(ap, fmt);

  44.     fprintf(stderr, "JCA: ");

  45.     vfprintf(stderr, fmt, ap);

  46.     va_end(ap);

  47. #endif

  48. }

  49. 

  50. static OSStatus GetTotalChannels(AudioDeviceID device, UInt32  *channelCount, Boolean isInput) 

  51. {

  52.     OSStatus err = noErr;

  53.     UInt32 outSize;

  54.     Boolean outWritable;

  55.     AudioBufferList *bufferList = NULL;

  56.     unsigned short i;

  57. 

  58.     *channelCount = 0;

  59.     err = AudioDeviceGetPropertyInfo(device, 0, isInput, kAudioDevicePropertyStreamConfiguration,  &outSize, &outWritable);

  60.     if (err == noErr)

  61.     {

  62. 		JCALog("AudioDeviceGetPropertyInfo kAudioDevicePropertyStreamConfiguration: OK\n");

  63.         bufferList = (AudioBufferList*)malloc(outSize);

  64.         

  65.         err = AudioDeviceGetProperty(device, 0, isInput, kAudioDevicePropertyStreamConfiguration, &outSize, bufferList);

  66.         if (err == noErr) {                                                               

  67.             for (i = 0; i < bufferList->mNumberBuffers; i++) 

  68.                 *channelCount += bufferList->mBuffers[i].mNumberChannels;

  69.         }

  70.         free(bufferList);

  71.     }

  72.  

  73.     return (err);

  74. }

  75. 

  76. static void PrintStreamDesc(AudioStreamBasicDescription * inDesc)

  77. {

  78.     if (!inDesc) {

  79. 		JCALog("Can't print a NULL desc!\n");

  80. 		return;

  81.     }

  82. 

  83.     JCALog("- - - - - - - - - - - - - - - - - - - -\n");

  84.     JCALog("  Sample Rate:%f\n", inDesc->mSampleRate);

  85.     JCALog("  Format ID:%.*s\n", (int) sizeof(inDesc->mFormatID),

  86. 	   (char *) &inDesc->mFormatID);

  87.     JCALog("  Format Flags:%lX\n", inDesc->mFormatFlags);

  88.     JCALog("  Bytes per Packet:%ld\n", inDesc->mBytesPerPacket);

  89.     JCALog("  Frames per Packet:%ld\n", inDesc->mFramesPerPacket);

  90.     JCALog("  Bytes per Frame:%ld\n", inDesc->mBytesPerFrame);

  91.     JCALog("  Channels per Frame:%ld\n", inDesc->mChannelsPerFrame);

  92.     JCALog("  Bits per Channel:%ld\n", inDesc->mBitsPerChannel);

  93.     JCALog("- - - - - - - - - - - - - - - - - - - -\n");

  94. }

  95. 

  96. static void printError(OSStatus err) 

  97. {

  98. #ifdef PRINTDEBUG

  99. 	switch (err) {

  100. 		case kAudioHardwareNoError:

  101. 			JCALog("error code : kAudioHardwareNoError\n");

  102. 			break;

  103. 		 case kAudioHardwareNotRunningError:

  104. 			JCALog("error code : kAudioHardwareNotRunningError\n");

  105. 			break;

  106. 		case kAudioHardwareUnspecifiedError:

  107. 			printf("error code : kAudioHardwareUnspecifiedError\n");

  108. 		case kAudioHardwareUnknownPropertyError:

  109. 			JCALog("error code : kAudioHardwareUnknownPropertyError\n");

  110. 			break;

  111. 		case kAudioHardwareBadPropertySizeError:

  112. 			JCALog("error code : kAudioHardwareBadPropertySizeError\n");

  113. 			break;

  114. 		case kAudioHardwareIllegalOperationError:

  115. 			JCALog("error code : kAudioHardwareIllegalOperationError\n");

  116. 			break;

  117. 		case kAudioHardwareBadDeviceError:

  118. 			JCALog("error code : kAudioHardwareBadDeviceError\n");

  119. 			break;

  120. 		case kAudioHardwareBadStreamError:

  121. 			JCALog("error code : kAudioHardwareBadStreamError\n");

  122. 			break;

  123. 		case kAudioDeviceUnsupportedFormatError:

  124. 			JCALog("error code : kAudioDeviceUnsupportedFormatError\n");

  125. 			break;

  126. 		case kAudioDevicePermissionsError:

  127. 			JCALog("error code : kAudioDevicePermissionsError\n");

  128. 			break;

  129. 		default:

  130. 			JCALog("error code : unknown\n");

  131. 			break;

  132. 	}

  133. #endif

  134. }

  135. 

  136. 

  137. AudioRender::AudioRender(float sampleRate, long bufferSize, int inChannels,

  138. 			 int outChannels,

  139. 			 char *device):vSampleRate(sampleRate),

  140. vBufferSize(bufferSize)

  141. {

  142.     inBuffers = NULL;

  143.     outBuffers = NULL;

  144.     status =

  145. 	ConfigureAudioProc(sampleRate, bufferSize, outChannels, inChannels,

  146. 			   device);

  147. 

  148.     AudioRender::gSampleRate = vSampleRate;

  149.     AudioRender::gBufferSize = vBufferSize;

  150.     AudioRender::gInputChannels = vInChannels;

  151.     AudioRender::gOutputChannels = vOutChannels;

  152.     AudioRender::theRender = this;

  153.     isProcessing = false;

  154. 

  155.     if (status) {

  156. 		inBuffers = (float **) malloc(sizeof(float *) * vInChannels);

  157. 		outBuffers = (float **) malloc(sizeof(float *) * vOutChannels);

  158. 		JCALog("AudioRender created.\n");

  159. 		JCALog("Standard driver.\n");

  160.     } else

  161. 		JCALog("error while creating AudioRender.\n");

  162. }

  163. 

  164. AudioRender::~AudioRender()

  165. {

  166.     if (status) {

  167. 		if (isProcessing)

  168. 			AudioDeviceStop(vDevice, process);

  169. 		OSStatus err = AudioDeviceRemoveIOProc(vDevice, process);

  170. 		if (err == noErr)

  171. 			status = false;

  172. 		free(inBuffers);

  173. 		free(outBuffers);

  174.     }

  175. }

  176. 

  177. bool AudioRender::ConfigureAudioProc(float sampleRate, long bufferSize,

  178. 				     int channels, int inChannels,

  179. 				     char *device)

  180. {

  181. 

  182.     OSStatus err;

  183.     UInt32 size;

  184.     Boolean isWritable;

  185. 

  186.     JCALog("Wanted DEVICE: %s\n", device);

  187. 

  188.     err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &size,

  189. 										&isWritable);

  190.     if (err != noErr) return false;

  191. 

  192.     int manyDevices = size / sizeof(AudioDeviceID);

  193. 

  194.     AudioDeviceID devices[manyDevices];

  195.     err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &size,

  196. 									&devices);

  197.     if (err != noErr) return false;

  198. 

  199.     bool found = false;

  200. 

  201.     for (int i = 0; i < manyDevices; i++) {

  202. 		size = sizeof(char) * 256;

  203. 		char name[256];

  204. 		err =

  205. 			AudioDeviceGetProperty(devices[i], 0, false,

  206. 					   kAudioDevicePropertyDeviceName, &size,

  207. 					   &name);

  208. 		JCALog("Read DEVICE: %s\n", name);

  209. 		if (err != noErr)

  210. 			return false;

  211. 		if (strncmp(device, name, strlen(device)) == 0) {	// steph : name seems to be limited to 32 character, thus compare the common part only 

  212. 			JCALog("Found DEVICE: %s %ld\n", name, devices[i]);

  213. 			vDevice = devices[i];

  214. 			found = true;

  215. 		}

  216.     }

  217. 

  218.     if (!found) {

  219. 		JCALog("Cannot find device \"%s\".\n", device);

  220. 		return false;

  221.     }

  222. 

  223.     char deviceName[256];

  224.     err = AudioDeviceGetProperty(vDevice, 0, false,

  225. 								kAudioDevicePropertyDeviceName, &size,

  226. 								&deviceName);

  227.     if (err != noErr) return false;

  228. 

  229.     JCALog("DEVICE: %s.\n", deviceName);

  230. 

  231.     size = sizeof(AudioStreamBasicDescription);

  232.     AudioStreamBasicDescription SR;

  233.     err = AudioDeviceGetProperty(vDevice, 0, false,

  234. 								kAudioDevicePropertyStreamFormat, &size,

  235. 								&SR);

  236.     if (err != noErr) {

  237. 		JCALog("AudioDeviceGetPropertyInfo kAudioDevicePropertyStreamFormat error: %ld\n",err);

  238. 		printError(err);

  239. 		return false;

  240. 	}

  241. 	JCALog("AudioDeviceGetPropertyInfo kAudioDevicePropertyStreamFormat: OK\n");

  242. 

  243.     err = AudioDeviceGetPropertyInfo(vDevice, 0, false,

  244. 									kAudioDevicePropertyStreams, &size,

  245. 									&isWritable);

  246.     if (err != noErr) {

  247. 		JCALog("AudioDeviceGetPropertyInfo kAudioDevicePropertyStreams error: %ld\n",err);

  248. 		printError(err);

  249. 		return false;

  250. 	}

  251. 	JCALog("AudioDeviceGetPropertyInfo kAudioDevicePropertyStreams: OK\n");

  252. 

  253. 	err = GetTotalChannels(vDevice,(UInt32*)&vOutChannels,false);

  254. 	if (err != noErr) return false;

  255. 	

  256.     n_out_streams = size / sizeof(AudioStreamID);

  257. 

  258.     if (channels > vOutChannels) {

  259. 		JCALog("cannot find requested output channels\n");

  260. 		return false;

  261.     }

  262. 

  263.     if (vOutChannels >= channels)

  264. 		vOutChannels = channels;

  265. 

  266.     JCALog("OUTPUT CHANNELS: %d.\n", vOutChannels);

  267. 

  268.     err = AudioDeviceGetPropertyInfo(vDevice, 0, true,

  269. 									kAudioDevicePropertyStreamFormat, &size,

  270. 									&isWritable);

  271.     if (err != noErr) {

  272. 		vInChannels = 0;

  273. 		goto endInChan;

  274.     }

  275. 

  276.     size = sizeof(AudioStreamBasicDescription);

  277.     AudioStreamBasicDescription inSR;

  278.     err = AudioDeviceGetProperty(vDevice, 0, true,

  279. 								kAudioDevicePropertyStreamFormat, &size,

  280. 								&inSR);

  281.     if (err != noErr) return false;

  282. 	JCALog("AudioDeviceGetPropertyInfo kAudioDevicePropertyStreamFormat: OK\n");

  283. 	

  284.     err = AudioDeviceGetPropertyInfo(vDevice, 0, true,

  285. 									kAudioDevicePropertyStreams, &size,

  286. 									&isWritable);

  287.     if (err != noErr) return false;

  288. 	JCALog("AudioDeviceGetPropertyInfo kAudioDevicePropertyStreams: OK\n");

  289. 

  290. 	err = GetTotalChannels(vDevice,(UInt32*)&vInChannels,true);

  291. 	if (err != noErr) return false;

  292. 

  293.     n_in_streams = size / sizeof(AudioStreamID);

  294. 

  295.   endInChan:

  296. 

  297.     if (inChannels > vInChannels) {

  298. 		JCALog("cannot find requested input channels\n");

  299. 		return false;

  300.     }

  301. 

  302.     if (vInChannels >= inChannels)

  303. 	vInChannels = inChannels;

  304. 

  305.     JCALog("INPUT CHANNELS: %d.\n", vInChannels);

  306. 

  307.     UInt32 bufFrame;

  308.     size = sizeof(UInt32);

  309.     err = AudioDeviceGetProperty(vDevice, 0, false,

  310. 			       kAudioDevicePropertyBufferFrameSize, &size,

  311. 			       &bufFrame);

  312.     if (err != noErr) return false;

  313. 

  314.     vBufferSize = (long) bufFrame;

  315. 

  316.     if ((long) bufFrame != bufferSize) {

  317. 		JCALog("I'm trying to set a new buffer size.\n");

  318. 		UInt32 theSize = sizeof(UInt32);

  319. 		UInt32 newBufferSize = (UInt32) bufferSize;

  320. 		err =

  321. 	    AudioDeviceSetProperty(vDevice, NULL, 0, false,

  322. 				   kAudioDevicePropertyBufferFrameSize,

  323. 				   theSize, &newBufferSize);

  324. 		if (err != noErr) {

  325. 			JCALog("Cannot set a new buffer size.\n");

  326. 			return false;

  327. 		} else {

  328. 			UInt32 newBufFrame;

  329. 			size = sizeof(UInt32);

  330. 			err =

  331. 			AudioDeviceGetProperty(vDevice, 0, false,

  332. 						   kAudioDevicePropertyBufferFrameSize,

  333. 						   &size, &newBufFrame);

  334. 			if (err != noErr) return false;

  335. 			vBufferSize = (long) newBufFrame;

  336. 		}

  337.     }

  338. 

  339.     JCALog("BUFFER SIZE: %ld.\n", vBufferSize);

  340. 

  341.     vSampleRate = (float) SR.mSampleRate;

  342. 

  343.     if ((float) SR.mSampleRate != sampleRate) {

  344. 		JCALog("I'm trying to set a new sample rate.\n");

  345. 		UInt32 theSize = sizeof(AudioStreamBasicDescription);

  346. 		SR.mSampleRate = (Float64) sampleRate;

  347. 		err = AudioDeviceSetProperty(vDevice, NULL, 0, false,

  348. 					   kAudioDevicePropertyStreamFormat,

  349. 					   theSize, &SR);

  350. 		if (err != noErr) {

  351. 			JCALog("Cannot set a new sample rate.\n");

  352. 			return false;

  353. 		} else {

  354. 			size = sizeof(AudioStreamBasicDescription);

  355. 			AudioStreamBasicDescription newCheckSR;

  356. 			err =

  357. 			AudioDeviceGetProperty(vDevice, 0, false,

  358. 						   kAudioDevicePropertyStreamFormat,

  359. 						   &size, &newCheckSR);

  360. 			if (err != noErr) return false;

  361. 			vSampleRate = (float) newCheckSR.mSampleRate;

  362. 		}

  363.     }

  364. 

  365.     JCALog("SAMPLE RATE: %f.\n", vSampleRate);

  366. 

  367.     PrintStreamDesc(&SR);

  368. 

  369.     err = AudioDeviceAddIOProc(vDevice, process, this);

  370.     if (err != noErr) return false;

  371. 

  372.     return true;

  373. }

  374. 

  375. bool AudioRender::StartAudio()

  376. {

  377.     if (status) {

  378. 		OSStatus err = AudioDeviceStart(vDevice, process);

  379. 		if (err != noErr)

  380. 			return false;

  381. 		AudioRender::isProcessing = true;

  382. 		return true;

  383.     }

  384.     return false;

  385. }

  386. 

  387. bool AudioRender::StopAudio()

  388. {

  389.     if (status) {

  390. 		OSStatus err = AudioDeviceStop(vDevice, process);

  391. 		if (err != noErr)

  392. 			return false;

  393. 		AudioRender::isProcessing = false;

  394. 		return true;

  395.     }

  396.     return false;

  397. }

  398. 

  399. OSStatus AudioRender::process(AudioDeviceID inDevice,

  400. 			      const AudioTimeStamp * inNow,

  401. 			      const AudioBufferList * inInputData,

  402. 			      const AudioTimeStamp * inInputTime,

  403. 			      AudioBufferList * outOutputData,

  404. 			      const AudioTimeStamp * inOutputTime,

  405. 			      void *inClientData)

  406. {

  407.     AudioRender *classe = (AudioRender *) inClientData;

  408.     int channel = 0;

  409. 

  410.     AudioRender::gTime = inInputTime;

  411. 

  412.     *classe->isInterleaved = (inInputData->mNumberBuffers != 0

  413. 			      && inInputData->mBuffers[0].

  414. 			      mNumberChannels == 1) ? FALSE : TRUE;

  415. 

  416. 	if (!*classe->isInterleaved) {

  417. 		for (unsigned int a = 0; a < inInputData->mNumberBuffers; a++) {

  418. 			classe->inBuffers[channel] =

  419. 			(float *) inInputData->mBuffers[a].mData;

  420. 			channel++;

  421. 			if (channel == classe->vInChannels)

  422. 			break;

  423. 		}

  424. 		channel = 0;

  425. 		for (unsigned int a = 0; a < outOutputData->mNumberBuffers; a++) {

  426. 			classe->outBuffers[channel] =

  427. 			(float *) outOutputData->mBuffers[a].mData;

  428. 			channel++;

  429. 			if (channel == classe->vOutChannels)

  430. 			break;

  431. 		}

  432. 	} else {

  433. 		for (unsigned int b = 0; b < inInputData->mNumberBuffers; b++) {

  434. 			classe->channelsPerStream[b] =

  435. 			(int) inInputData->mBuffers[b].mNumberChannels;

  436. 			classe->inBuffers[b] = (float *) inInputData->mBuffers[b].mData;	// but jack will read only the inBuffers[0], anyway that should not be a problem.

  437. 		}

  438. 		for (unsigned int b = 0; b < outOutputData->mNumberBuffers; b++) {

  439. 			classe->out_channelsPerStream[b] =

  440. 			(int) outOutputData->mBuffers[b].mNumberChannels;

  441. 			classe->outBuffers[b] = (float *) outOutputData->mBuffers[b].mData;	// but jack will read only the outBuffers[0], anyway that should not be a problem.

  442. 		}

  443.     }

  444. 

  445.     classe->f_JackRunCycle(classe->jackData, classe->vBufferSize);

  446.     return noErr;

  447. }

  448. 

  449. float **AudioRender::getADC()

  450. {

  451.     if (AudioRender::theRender == NULL)

  452. 		return NULL;

  453.     return AudioRender::theRender->inBuffers;

  454. }

  455. 

  456. float **AudioRender::getDAC()

  457. {

  458.     if (AudioRender::theRender == NULL)

  459. 		return NULL;

  460.     return AudioRender::theRender->outBuffers;

  461. }