~ubuntu-branches/ubuntu/gutsy/audacity/gutsy-backports

<a class="qindex" href="index.html">Tutorial</a>   <a class="qindex" href="annotated.html">Class/Enum List</a>   <a class="qindex" href="files.html">File List</a>   <a class="qindex" href="functions.html">Compound Members</a>   </CENTER>

<HR>

<h1>RtAudio.h</h1><div class="fragment"><pre>00001 /************************************************************************/

00038 /************************************************************************/

00039

00040 // RtAudio: Version 3.0.1, 22 March 2004

00041

00042 #ifndef __RTAUDIO_H

00043 #define __RTAUDIO_H

00044

00045 #include "RtError.h"

00046 #include <string>

00047 #include <vector>

00048

00049 // Operating system dependent thread functionality.

00050 #if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__)

00051 #include <windows.h>

00052 #include <process.h>

00053

00054 typedef unsigned long ThreadHandle;

00055 typedef CRITICAL_SECTION StreamMutex;

00056

00057 #else // Various unix flavors with pthread support.

00058 #include <pthread.h>

00059

00060 typedef pthread_t ThreadHandle;

00061 typedef pthread_mutex_t StreamMutex;

00062

00063 #endif

00064

00065 // This global structure type is used to pass callback information

00066 // between the private RtAudio stream structure and global callback

00067 // handling functions.

00068 struct CallbackInfo {

00069 void *object; // Used as a "this" pointer.

00070 ThreadHandle thread;

00071 bool usingCallback;

00072 void *callback;

00073 void *userData;

00074 void *apiInfo; // void pointer for API specific callback information

00075

00076 // Default constructor.

00077 CallbackInfo()

00078 :object(0), usingCallback(false), callback(0),

00079 userData(0), apiInfo(0) {}

00080 };

00081

00082 // Support for signed integers and floats. Audio data fed to/from

00083 // the tickStream() routine is assumed to ALWAYS be in host

00084 // byte order. The internal routines will automatically take care of

00085 // any necessary byte-swapping between the host format and the

00086 // soundcard. Thus, endian-ness is not a concern in the following

00087 // format definitions.

00088 typedef unsigned long RtAudioFormat;

00089 static const RtAudioFormat RTAUDIO_SINT8 = 0x1;

00090 static const RtAudioFormat RTAUDIO_SINT16 = 0x2;

00091 static const RtAudioFormat RTAUDIO_SINT24 = 0x4;

00092 static const RtAudioFormat RTAUDIO_SINT32 = 0x8;

00093 static const RtAudioFormat RTAUDIO_FLOAT32 = 0x10;

00094 static const RtAudioFormat RTAUDIO_FLOAT64 = 0x20;

00096 typedef int (*RtAudioCallback)(char *buffer, int bufferSize, void *userData);

00097

<a name="l00099"></a><a class="code" href="structRtAudioDeviceInfo.html">00099</a> struct <a class="code" href="structRtAudioDeviceInfo.html">RtAudioDeviceInfo</a> {

<a name="l00100"></a><a class="code" href="structRtAudioDeviceInfo.html#o0">00100</a> std::string <a class="code" href="structRtAudioDeviceInfo.html#o0">name</a>;

<a name="l00101"></a><a class="code" href="structRtAudioDeviceInfo.html#o1">00101</a> bool <a class="code" href="structRtAudioDeviceInfo.html#o1">probed</a>;

<a name="l00102"></a><a class="code" href="structRtAudioDeviceInfo.html#o2">00102</a> int <a class="code" href="structRtAudioDeviceInfo.html#o2">outputChannels</a>;

<a name="l00103"></a><a class="code" href="structRtAudioDeviceInfo.html#o3">00103</a> int <a class="code" href="structRtAudioDeviceInfo.html#o3">inputChannels</a>;

<a name="l00104"></a><a class="code" href="structRtAudioDeviceInfo.html#o4">00104</a> int <a class="code" href="structRtAudioDeviceInfo.html#o4">duplexChannels</a>;

<a name="l00105"></a><a class="code" href="structRtAudioDeviceInfo.html#o5">00105</a> bool <a class="code" href="structRtAudioDeviceInfo.html#o5">isDefault</a>;

<a name="l00106"></a><a class="code" href="structRtAudioDeviceInfo.html#o6">00106</a> std::vector<int> <a class="code" href="structRtAudioDeviceInfo.html#o6">sampleRates</a>;

<a name="l00107"></a><a class="code" href="structRtAudioDeviceInfo.html#o7">00107</a> RtAudioFormat <a class="code" href="structRtAudioDeviceInfo.html#o7">nativeFormats</a>;

00109 // Default constructor.

00110 <a class="code" href="structRtAudioDeviceInfo.html">RtAudioDeviceInfo</a>()

00111 :<a class="code" href="structRtAudioDeviceInfo.html#o1">probed</a>(false), <a class="code" href="structRtAudioDeviceInfo.html#o2">outputChannels</a>(0), <a class="code" href="structRtAudioDeviceInfo.html#o3">inputChannels</a>(0),

00112 <a class="code" href="structRtAudioDeviceInfo.html#o4">duplexChannels</a>(0), <a class="code" href="structRtAudioDeviceInfo.html#o5">isDefault</a>(false), <a class="code" href="structRtAudioDeviceInfo.html#o7">nativeFormats</a>(0) {}

00113 };

00114

00115 // **************************************************************** //

00116 //

00117 // RtApi class declaration.

00118 //

00119 // Note that RtApi is an abstract base class and cannot be

00120 // explicitly instantiated. The class RtAudio will create an

00121 // instance of an RtApi subclass (RtApiOss, RtApiAlsa,

00122 // RtApiJack, RtApiCore, RtApiAl, RtApiDs, or RtApiAsio).

00123 //

00124 // **************************************************************** //

00125

00126 class RtApi

00127 {

00128 public:

100

00129

101

00130 RtApi();

102

00131 virtual ~RtApi();

103

00132 void openStream( int outputDevice, int outputChannels,

104

00133 int inputDevice, int inputChannels,

105

00134 RtAudioFormat format, int sampleRate,

106

00135 int *bufferSize, int numberOfBuffers );

107

00136 virtual void setStreamCallback( RtAudioCallback callback, void *userData ) = 0;

108

00137 virtual void cancelStreamCallback() = 0;

109

00138 int getDeviceCount(void);

110

00139 <a class="code" href="structRtAudioDeviceInfo.html">RtAudioDeviceInfo</a> getDeviceInfo( int device );

111

00140 char * const getStreamBuffer();

112

00141 virtual void tickStream() = 0;

113

00142 virtual void closeStream();

114

00143 virtual void startStream() = 0;

115

00144 virtual void stopStream() = 0;

116

00145 virtual void abortStream() = 0;

117

00146

118

00147 protected:

119

00148

120

00149 static const unsigned int MAX_SAMPLE_RATES;

121

00150 static const unsigned int SAMPLE_RATES[];

122

00151

123

00152 enum { FAILURE, SUCCESS };

124

00153

125

00154 enum StreamMode {

126

00155 OUTPUT,

127

00156 INPUT,

128

00157 DUPLEX,

129

00158 UNINITIALIZED = -75

130

00159 };

131

00160

132

00161 enum StreamState {

133

00162 STREAM_STOPPED,

134

00163 STREAM_RUNNING

135

00164 };

136

00165

137

00166 // A protected structure for audio streams.

138

00167 struct RtApiStream {

139

00168 int device[2]; // Playback and record, respectively.

140

00169 void *apiHandle; // void pointer for API specific stream handle information

141

00170 StreamMode mode; // OUTPUT, INPUT, or DUPLEX.

142

00171 StreamState state; // STOPPED or RUNNING

143

00172 char *userBuffer;

144

00173 char *deviceBuffer;

145

00174 bool doConvertBuffer[2]; // Playback and record, respectively.

146

00175 bool deInterleave[2]; // Playback and record, respectively.

147

00176 bool doByteSwap[2]; // Playback and record, respectively.

148

00177 int sampleRate;

149

00178 int bufferSize;

150

00179 int nBuffers;

151

00180 int nUserChannels[2]; // Playback and record, respectively.

152

00181 int nDeviceChannels[2]; // Playback and record channels, respectively.

153

00182 RtAudioFormat userFormat;

154

00183 RtAudioFormat deviceFormat[2]; // Playback and record, respectively.

155

00184 StreamMutex mutex;

156

00185 CallbackInfo callbackInfo;

157

00186

158

00187 RtApiStream()

159

00188 :apiHandle(0), userBuffer(0), deviceBuffer(0) {}

160

00189 // mode(UNINITIALIZED), state(STREAM_STOPPED),

161

00190 };

162

00191

163

00192 // A protected device structure for audio devices.

164

00193 struct RtApiDevice {

165

00194 std::string name;

166

00195 bool probed;

167

00196 void *apiDeviceId; // void pointer for API specific device information

168

00197 int maxOutputChannels;

169

00198 int maxInputChannels;

170

00199 int maxDuplexChannels;

171

00200 int minOutputChannels;

172

00201 int minInputChannels;

173

00202 int minDuplexChannels;

174

00203 bool hasDuplexSupport;

175

00204 bool isDefault;

176

00205 std::vector<int> sampleRates;

177

00206 RtAudioFormat nativeFormats;

178

00208 // Default constructor.

179

00209 RtApiDevice()

180

00210 :probed(false), apiDeviceId(0), maxOutputChannels(0), maxInputChannels(0),

181

00211 maxDuplexChannels(0), minOutputChannels(0), minInputChannels(0),

182

00212 minDuplexChannels(0), isDefault(false), nativeFormats(0) {}

183

00213 };

184

00214

185

00215 typedef signed short Int16;

186

00216 typedef signed int Int32;

187

00217 typedef float Float32;

188

00218 typedef double Float64;

189

00219

190

00220 char message_[256];

191

00221 int nDevices_;

192

00222 std::vector<RtApiDevice> devices_;

193

00223 RtApiStream stream_;

194

00224

195

00229 virtual void initialize(void) = 0;

196

00230

197

00239 virtual void probeDeviceInfo( RtApiDevice *info );

198

00240

199

00249 virtual bool probeDeviceOpen( int device, StreamMode mode, int channels,

200

00250 int sampleRate, RtAudioFormat format,

201

00251 int *bufferSize, int numberOfBuffers );

202

00252

203

00257 virtual int getDefaultInputDevice(void);

204

00258

205

00263 virtual int getDefaultOutputDevice(void);

206

00264

207

00266 void clearDeviceInfo( RtApiDevice *info );

208

00267

209

00269 void clearStreamInfo();

210

00270

211

00272 void error( RtError::Type type );

212

00273

213

00278 void verifyStream();

214

00279

215

00284 void convertStreamBuffer( StreamMode mode );

216

00285

217

00287 void byteSwapBuffer( char *buffer, int samples, RtAudioFormat format );

218

00288

219

00290 int formatBytes( RtAudioFormat format );

220

00291 };

221

00292

222

00293

223

00294 // **************************************************************** //

224

00295 //

225

00296 // RtAudio class declaration.

226

00297 //

227

00298 // RtAudio is a "controller" used to select an available audio i/o

228

00299 // interface. It presents a common API for the user to call but all

229

00300 // functionality is implemented by the class RtAudioApi and its

230

00301 // subclasses. RtAudio creates an instance of an RtAudioApi subclass

231

00302 // based on the user's API choice. If no choice is made, RtAudio

232

00303 // attempts to make a "logical" API selection.

233

00304 //

234

00305 // **************************************************************** //

235

00306

236

<a name="l00307"></a><a class="code" href="classRtAudio.html">00307</a> class <a class="code" href="classRtAudio.html">RtAudio</a>

237

00308 {

238

00309 public:

239

00310

240

<a name="l00312"></a><a class="code" href="classRtAudio.html#w8">00312</a> enum <a class="code" href="classRtAudio.html#w8">RtAudioApi</a> {

241

00313 <a class="code" href="classRtAudio.html#w8w0">UNSPECIFIED</a>,

242

00314 <a class="code" href="classRtAudio.html#w8w1">LINUX_ALSA</a>,

243

00315 <a class="code" href="classRtAudio.html#w8w2">LINUX_OSS</a>,

244

00316 <a class="code" href="classRtAudio.html#w8w3">LINUX_JACK</a>,

245

00317 <a class="code" href="classRtAudio.html#w8w4">MACOSX_CORE</a>,

246

00318 <a class="code" href="classRtAudio.html#w8w5">IRIX_AL</a>,

247

00319 <a class="code" href="classRtAudio.html#w8w6">WINDOWS_ASIO</a>,

248

00320 <a class="code" href="classRtAudio.html#w8w7">WINDOWS_DS</a>

249

00321 };

250

00322

251

00324

252

00334 <a class="code" href="classRtAudio.html#a0">RtAudio</a>( RtAudioApi api=UNSPECIFIED );

253

00335

254

00337

255

00348 <a class="code" href="classRtAudio.html#a0">RtAudio</a>( int outputDevice, int outputChannels,

256

00349 int inputDevice, int inputChannels,

257

00350 RtAudioFormat format, int sampleRate,

258

00351 int *bufferSize, int numberOfBuffers, RtAudioApi api=UNSPECIFIED );

259

00352

260

00354

261

00358 <a class="code" href="classRtAudio.html#a2">~RtAudio</a>();

262

00359

263

00361

264

00387 void <a class="code" href="classRtAudio.html#a3">openStream</a>( int outputDevice, int outputChannels,

265

00388 int inputDevice, int inputChannels,

266

00389 RtAudioFormat format, int sampleRate,

267

00390 int *bufferSize, int numberOfBuffers );

268

00391

269

00393

270

<a name="l00412"></a><a class="code" href="classRtAudio.html#a4">00412</a> void <a class="code" href="classRtAudio.html#a4">setStreamCallback</a>(RtAudioCallback callback, void *userData) { rtapi_->setStreamCallback( callback, userData ); };

271

00413

272

00415

273

<a name="l00422"></a><a class="code" href="classRtAudio.html#a5">00422</a> void <a class="code" href="classRtAudio.html#a5">cancelStreamCallback</a>() { rtapi_->cancelStreamCallback(); };

274

00423

275

<a name="l00425"></a><a class="code" href="classRtAudio.html#a6">00425</a> int <a class="code" href="classRtAudio.html#a6">getDeviceCount</a>(void) { return rtapi_->getDeviceCount(); };

276

00426

277

00428

278

<a name="l00436"></a><a class="code" href="classRtAudio.html#a7">00436</a> <a class="code" href="structRtAudioDeviceInfo.html">RtAudioDeviceInfo</a> <a class="code" href="classRtAudio.html#a7">getDeviceInfo</a>(int device) { return rtapi_->getDeviceInfo( device ); };

279

00437

280

00439

281

<a name="l00444"></a><a class="code" href="classRtAudio.html#a8">00444</a> char * const <a class="code" href="classRtAudio.html#a8">getStreamBuffer</a>() { return rtapi_->getStreamBuffer(); };

282

00445

283

00447

284

<a name="l00452"></a><a class="code" href="classRtAudio.html#a9">00452</a> void <a class="code" href="classRtAudio.html#a9">tickStream</a>() { rtapi_->tickStream(); };

285

00453

286

00455

287

<a name="l00459"></a><a class="code" href="classRtAudio.html#a10">00459</a> void <a class="code" href="classRtAudio.html#a10">closeStream</a>() { rtapi_->closeStream(); };

288

00460

289

00462

290

<a name="l00466"></a><a class="code" href="classRtAudio.html#a11">00466</a> void <a class="code" href="classRtAudio.html#a11">startStream</a>() { rtapi_->startStream(); };

291

00467

292

00469

293

<a name="l00473"></a><a class="code" href="classRtAudio.html#a12">00473</a> void <a class="code" href="classRtAudio.html#a12">stopStream</a>() { rtapi_->stopStream(); };

294

00474

295

00476

296

<a name="l00480"></a><a class="code" href="classRtAudio.html#a13">00480</a> void <a class="code" href="classRtAudio.html#a13">abortStream</a>() { rtapi_->abortStream(); };

297

00481

298

00482

299

00483 protected:

300

00484

301

00485 void initialize( RtAudioApi api );

302

00486

303

00487 RtApi *rtapi_;

304

00488 };

305

00489

306

00490

307

00491 // RtApi Subclass prototypes.

308

00492

309

00493 #if defined(__LINUX_ALSA__)

310

00494

311

00495 class RtApiAlsa: public RtApi

312

00496 {

313

00497 public:

314

00498

315

00499 RtApiAlsa();

316

00500 ~RtApiAlsa();

317

00501 void tickStream();

318

00502 void closeStream();

319

00503 void startStream();

320

00504 void stopStream();

321

00505 void abortStream();

322

00506 int streamWillBlock();

323

00507 void setStreamCallback( RtAudioCallback callback, void *userData );

324

00508 void cancelStreamCallback();

325

00509

326

00510 private:

327

00511

328

00512 void initialize(void);

329

00513 void probeDeviceInfo( RtApiDevice *info );

330

00514 bool probeDeviceOpen( int device, StreamMode mode, int channels,

331

00515 int sampleRate, RtAudioFormat format,

332

00516 int *bufferSize, int numberOfBuffers );

333

00517 };

334

00518

335

00519 #endif

336

00520

337

00521 #if defined(__LINUX_JACK__)

338

00522

339

00523 class RtApiJack: public RtApi

340

00524 {

341

00525 public:

342

00526

343

00527 RtApiJack();

344

00528 ~RtApiJack();

345

00529 void tickStream();

346

00530 void closeStream();

347

00531 void startStream();

348

00532 void stopStream();

349

00533 void abortStream();

350

00534 void setStreamCallback( RtAudioCallback callback, void *userData );

351

00535 void cancelStreamCallback();

352

00536 // This function is intended for internal use only. It must be

353

00537 // public because it is called by the internal callback handler,

354

00538 // which is not a member of RtAudio. External use of this function

355

00539 // will most likely produce highly undesireable results!

356

00540 void callbackEvent( unsigned long nframes );

357

00541

358

00542 private:

359

00543

360

00544 void initialize(void);

361

00545 void probeDeviceInfo( RtApiDevice *info );

362

00546 bool probeDeviceOpen( int device, StreamMode mode, int channels,

363

00547 int sampleRate, RtAudioFormat format,

364

00548 int *bufferSize, int numberOfBuffers );

365

00549 };

366

00550

367

00551 #endif

368

00552

369

00553 #if defined(__LINUX_OSS__)

370

00554

371

00555 class RtApiOss: public RtApi

372

00556 {

373

00557 public:

374

00558

375

00559 RtApiOss();

376

00560 ~RtApiOss();

377

00561 void tickStream();

378

00562 void closeStream();

379

00563 void startStream();

380

00564 void stopStream();

381

00565 void abortStream();

382

00566 int streamWillBlock();

383

00567 void setStreamCallback( RtAudioCallback callback, void *userData );

384

00568 void cancelStreamCallback();

385

00569

386

00570 private:

387

00571

388

00572 void initialize(void);

389

00573 void probeDeviceInfo( RtApiDevice *info );

390

00574 bool probeDeviceOpen( int device, StreamMode mode, int channels,

391

00575 int sampleRate, RtAudioFormat format,

392

00576 int *bufferSize, int numberOfBuffers );

393

00577 };

394

00578

395

00579 #endif

396

00580

397

00581 #if defined(__MACOSX_CORE__)

398

00582

399

00583 #include <CoreAudio/AudioHardware.h>

400

00584

401

00585 class RtApiCore: public RtApi

402

00586 {

403

00587 public:

404

00588

405

00589 RtApiCore();

406

00590 ~RtApiCore();

407

00591 int getDefaultOutputDevice(void);

408

00592 int getDefaultInputDevice(void);

409

00593 void tickStream();

410

00594 void closeStream();

411

00595 void startStream();

412

00596 void stopStream();

413

00597 void abortStream();

414

00598 void setStreamCallback( RtAudioCallback callback, void *userData );

415

00599 void cancelStreamCallback();

416

00600

417

00601 // This function is intended for internal use only. It must be

418

00602 // public because it is called by the internal callback handler,

419

00603 // which is not a member of RtAudio. External use of this function

420

00604 // will most likely produce highly undesireable results!

421

00605 void callbackEvent( AudioDeviceID deviceId, void *inData, void *outData );

422

00606

423

00607 private:

424

00608

425

00609 void initialize(void);

426

00610 void probeDeviceInfo( RtApiDevice *info );

427

00611 bool probeDeviceOpen( int device, StreamMode mode, int channels,

428

00612 int sampleRate, RtAudioFormat format,

429

00613 int *bufferSize, int numberOfBuffers );

430

00614 };

431

00615

432

00616 #endif

433

00617

434

00618 #if defined(__WINDOWS_DS__)

435

00619

436

00620 class RtApiDs: public RtApi

437

00621 {

438

00622 public:

439

00623

440

00624 RtApiDs();

441

00625 ~RtApiDs();

442

00626 int getDefaultOutputDevice(void);

443

00627 int getDefaultInputDevice(void);

444

00628 void tickStream();

445

00629 void closeStream();

446

00630 void startStream();

447

00631 void stopStream();

448

00632 void abortStream();

449

00633 int streamWillBlock();

450

00634 void setStreamCallback( RtAudioCallback callback, void *userData );

451

00635 void cancelStreamCallback();

452

00636

453

00637 private:

454

00638

455

00639 void initialize(void);

456

00640 void probeDeviceInfo( RtApiDevice *info );

457

00641 bool probeDeviceOpen( int device, StreamMode mode, int channels,

458

00642 int sampleRate, RtAudioFormat format,

459

00643 int *bufferSize, int numberOfBuffers );

460

00644 };

461

00645

462

00646 #endif

463

00647

464

00648 #if defined(__WINDOWS_ASIO__)

465

00649

466

00650 class RtApiAsio: public RtApi

467

00651 {

468

00652 public:

469

00653

470

00654 RtApiAsio();

471

00655 ~RtApiAsio();

472

00656 void tickStream();

473

00657 void closeStream();

474

00658 void startStream();

475

00659 void stopStream();

476

00660 void abortStream();

477

00661 void setStreamCallback( RtAudioCallback callback, void *userData );

478

00662 void cancelStreamCallback();

479

00663

480

00664 // This function is intended for internal use only. It must be

481

00665 // public because it is called by the internal callback handler,

482

00666 // which is not a member of RtAudio. External use of this function

483

00667 // will most likely produce highly undesireable results!

484

00668 void callbackEvent( long bufferIndex );

485

00669

486

00670 private:

487

00671

488

00672 void initialize(void);

489

00673 void probeDeviceInfo( RtApiDevice *info );

490

00674 bool probeDeviceOpen( int device, StreamMode mode, int channels,

491

00675 int sampleRate, RtAudioFormat format,

492

00676 int *bufferSize, int numberOfBuffers );

493

00677 };

494

00678

495

00679 #endif

496

00680

497

00681 #if defined(__IRIX_AL__)

498

00682

499

00683 class RtApiAl: public RtApi

500

00684 {

501

00685 public:

502

00686

503

00687 RtApiAl();

504

00688 ~RtApiAl();

505

00689 int getDefaultOutputDevice(void);

506

00690 int getDefaultInputDevice(void);

507

00691 void tickStream();

508

00692 void closeStream();

509

00693 void startStream();

510

00694 void stopStream();

511

00695 void abortStream();

512

00696 int streamWillBlock();

513

00697 void setStreamCallback( RtAudioCallback callback, void *userData );

514

00698 void cancelStreamCallback();

515

00699

516

00700 private:

517

00701

518

00702 void initialize(void);

519

00703 void probeDeviceInfo( RtApiDevice *info );

520

00704 bool probeDeviceOpen( int device, StreamMode mode, int channels,

521

00705 int sampleRate, RtAudioFormat format,

522

00706 int *bufferSize, int numberOfBuffers );

523

00707 };

524

00708

525

00709 #endif

526

00710

527

00711 // Define the following flag to have extra information spewed to stderr.

528

00712 //#define __RTAUDIO_DEBUG__

529

00713

530

00714 #endif

531

</pre></div><HR>

532

533

534

535

Maintained by Gary P. Scavone, <a href="mailto:gary@music.mcgill.ca">gary@music.mcgill.ca</a></td></tr>

536

</table>

537

538

</BODY>

539

</HTML>

Older »