~ubuntu-branches/ubuntu/wily/sflphone/wily

(long) ( (PaUtil_GetBufferProcessorInputLatency (&stream->blockingState->bufferProcessor) + (lBlockingBufferSize / framesPerBuffer - 1) * framesPerBuffer) * (1000.0 / sampleRate))

2395

));

2396

2397

/* Determine the size of ring buffer in bytes. */

2398

lBytesPerFrame = inputChannelCount * Pa_GetSampleSize (inputSampleFormat);

2399

2400

/* Allocate the blocking i/o input ring buffer memory. */

2401

stream->blockingState->readRingBufferData = (void*) PaUtil_AllocateMemory (lBlockingBufferSize * lBytesPerFrame);

2402

2403

if (!stream->blockingState->readRingBufferData) {

2404

result = paInsufficientMemory;

2405

PA_DEBUG ( ("ERROR! Blocking i/o input ring buffer allocation failed in OpenStream()\n"));

2406

goto error;

2407

}

2408

2409

/* Initialize the input ring buffer struct. */

2410

PaUtil_InitializeRingBuffer (&stream->blockingState->readRingBuffer ,

2411

lBytesPerFrame ,

2412

lBlockingBufferSize ,

2413

stream->blockingState->readRingBufferData);

2414

}

2415

2416

/* If output is requested. */

2417

if (outputChannelCount) {

2418

stream->blockingState->writeBuffersReadyEvent = CreateEvent (NULL, FALSE, FALSE, NULL);

2419

2420

if (stream->blockingState->writeBuffersReadyEvent == NULL) {

2421

result = paUnanticipatedHostError;

2422

PA_ASIO_SET_LAST_SYSTEM_ERROR (GetLastError());

2423

PA_DEBUG ( ("ERROR! Blocking i/o \"write buffers ready\" event creation failed in OpenStream()\n"));

2424

goto error;

2425

}

2426

2427

blockingWriteBuffersReadyEventInitialized = 1;

2428

2429

/* Create pointer buffer to access non-interleaved data in WriteStream() */

2430

stream->blockingState->writeStreamBuffer = (const void**) PaUtil_AllocateMemory (sizeof (const void*) * outputChannelCount);

2431

2432

if (!stream->blockingState->writeStreamBuffer) {

2433

result = paInsufficientMemory;

2434

PA_DEBUG ( ("ERROR! Blocking i/o write stream buffer allocation failed in OpenStream()\n"));

2435

goto error;

2436

}

2437

2438

/* The ring buffer should store as many data blocks as needed

2439

to achieve the requested latency. Whereas it must be large

2440

enough to store at least two complete data blocks.

2441

2442

1) Determine the amount of latency to be added to the

2443

prefered ASIO latency.

2444

2) Make sure we have at lest one additional latency frame.

2445

3) Divide the number of frames by the desired block size to

2446

get the number (rounded up to pure integer) of blocks to

2447

be stored in the buffer.

2448

4) Add one additional block for block processing and convert

2449

to samples frames.

2450

5) Get the next larger (or equal) power-of-two buffer size.

2451

2452

lBlockingBufferSize = suggestedOutputLatencyFrames - stream->outputLatency;

2453

lBlockingBufferSize = (lBlockingBufferSize > 0) ? lBlockingBufferSize : 1;

2454

lBlockingBufferSize = (lBlockingBufferSize + framesPerBuffer - 1) / framesPerBuffer;

2455

lBlockingBufferSize = (lBlockingBufferSize + 1) * framesPerBuffer;

2456

2457

/* The buffer size (without the additional block) corresponds

2458

to the initial number of silent samples in the output ring

2459

buffer. */

2460

stream->blockingState->writeRingBufferInitialFrames = lBlockingBufferSize - framesPerBuffer;

2461

2462

/* Get the next larger or equal power-of-two buffersize. */

2463

lBlockingBufferSizePow2 = 1;

2464

2465

while (lBlockingBufferSize > (lBlockingBufferSizePow2<<=1));

2466

2467

lBlockingBufferSize = lBlockingBufferSizePow2;

2468

2469

/* Compute total output latency in seconds */

2470

stream->streamRepresentation.streamInfo.outputLatency =

2471

(double) (PaUtil_GetBufferProcessorOutputLatency (&stream->bufferProcessor)

2472

+ PaUtil_GetBufferProcessorOutputLatency (&stream->blockingState->bufferProcessor)

2473

+ (lBlockingBufferSize / framesPerBuffer - 1) * framesPerBuffer

2474

+ stream->outputLatency)

2475

/ sampleRate;

2476

2477

/* The code below prints the ASIO latency which doesn't include

2478

the buffer processor latency nor the blocking i/o latency. It

2479

reports the added latency separately.

2480

2481

PA_DEBUG ( ("PaAsio : ASIO OutputLatency = %ld (%ld ms),\n added buffProc:%ld (%ld ms),\n added blocking:%ld (%ld ms)\n",

2482

stream->outputLatency,

2483

(long) (stream->inputLatency * (1000.0 / sampleRate)),

2484

PaUtil_GetBufferProcessorOutputLatency (&stream->bufferProcessor),

2485

(long) (PaUtil_GetBufferProcessorOutputLatency (&stream->bufferProcessor) * (1000.0 / sampleRate)),

2486

PaUtil_GetBufferProcessorOutputLatency (&stream->blockingState->bufferProcessor) + (lBlockingBufferSize / framesPerBuffer - 1) * framesPerBuffer,

2487

(long) ( (PaUtil_GetBufferProcessorOutputLatency (&stream->blockingState->bufferProcessor) + (lBlockingBufferSize / framesPerBuffer - 1) * framesPerBuffer) * (1000.0 / sampleRate))

2488

));

2489

2490

/* Determine the size of ring buffer in bytes. */

2491

lBytesPerFrame = outputChannelCount * Pa_GetSampleSize (outputSampleFormat);

2492

2493

/* Allocate the blocking i/o output ring buffer memory. */

2494

stream->blockingState->writeRingBufferData = (void*) PaUtil_AllocateMemory (lBlockingBufferSize * lBytesPerFrame);

2495

2496

if (!stream->blockingState->writeRingBufferData) {

2497

result = paInsufficientMemory;

2498

PA_DEBUG ( ("ERROR! Blocking i/o output ring buffer allocation failed in OpenStream()\n"));

2499

goto error;

2500

}

2501

2502

/* Initialize the output ring buffer struct. */

2503

PaUtil_InitializeRingBuffer (&stream->blockingState->writeRingBuffer ,

2504

lBytesPerFrame ,

2505

lBlockingBufferSize ,

2506

stream->blockingState->writeRingBufferData);

2507

}

2508

2509

stream->streamRepresentation.streamInfo.sampleRate = sampleRate;

2510

2511

2512

} else { /* Using callback interface... */

2513

result = PaUtil_InitializeBufferProcessor (&stream->bufferProcessor,

2514

inputChannelCount, inputSampleFormat, hostInputSampleFormat,

2515

outputChannelCount, outputSampleFormat, hostOutputSampleFormat,

2516

sampleRate, streamFlags, framesPerBuffer,

2517

framesPerHostBuffer, paUtilFixedHostBufferSize,

2518

streamCallback, userData);

2519

2520

if (result != paNoError) {

2521

PA_DEBUG ( ("OpenStream ERROR13\n"));

2522

goto error;

2523

}

2524

2525

callbackBufferProcessorInited = TRUE;

2526

2527

stream->streamRepresentation.streamInfo.inputLatency =

2528

(double) (PaUtil_GetBufferProcessorInputLatency (&stream->bufferProcessor)

2529

+ stream->inputLatency) / sampleRate; // seconds

2530

stream->streamRepresentation.streamInfo.outputLatency =

2531

(double) (PaUtil_GetBufferProcessorOutputLatency (&stream->bufferProcessor)

2532

+ stream->outputLatency) / sampleRate; // seconds

2533

stream->streamRepresentation.streamInfo.sampleRate = sampleRate;

2534

2535

// the code below prints the ASIO latency which doesn't include the

2536

// buffer processor latency. it reports the added latency separately

2537

PA_DEBUG ( ("PaAsio : ASIO InputLatency = %ld (%ld ms), added buffProc:%ld (%ld ms)\n",

2538

stream->inputLatency,

2539

(long) ( (stream->inputLatency*1000) / sampleRate),

2540

PaUtil_GetBufferProcessorInputLatency (&stream->bufferProcessor),

2541

(long) ( (PaUtil_GetBufferProcessorInputLatency (&stream->bufferProcessor) *1000) / sampleRate)

2542

));

2543

2544

PA_DEBUG ( ("PaAsio : ASIO OuputLatency = %ld (%ld ms), added buffProc:%ld (%ld ms)\n",

2545

stream->outputLatency,

2546

(long) ( (stream->outputLatency*1000) / sampleRate),

2547

PaUtil_GetBufferProcessorOutputLatency (&stream->bufferProcessor),

2548

(long) ( (PaUtil_GetBufferProcessorOutputLatency (&stream->bufferProcessor) *1000) / sampleRate)

2549

));

2550

}

2551

2552

stream->asioHostApi = asioHostApi;

2553

stream->framesPerHostCallback = framesPerHostBuffer;

2554

2555

stream->inputChannelCount = inputChannelCount;

2556

stream->outputChannelCount = outputChannelCount;

2557

stream->postOutput = driverInfo->postOutput;

2558

stream->isStopped = 1;

2559

stream->isActive = 0;

2560

2561

asioHostApi->openAsioDeviceIndex = asioDeviceIndex;

2562

2563

theAsioStream = stream;

2564

*s = (PaStream*) stream;

2565

2566

return result;

2567

2568

error:

2569

PA_DEBUG ( ("goto errored\n"));

2570

2571

if (stream) {

2572

if (stream->blockingState) {

2573

if (blockingBufferProcessorInited)

2574

PaUtil_TerminateBufferProcessor (&stream->blockingState->bufferProcessor);

2575

2576

if (stream->blockingState->writeRingBufferData)

2577

PaUtil_FreeMemory (stream->blockingState->writeRingBufferData);

2578

2579

if (stream->blockingState->writeStreamBuffer)

2580

PaUtil_FreeMemory (stream->blockingState->writeStreamBuffer);

2581

2582

if (blockingWriteBuffersReadyEventInitialized)

2583

CloseHandle (stream->blockingState->writeBuffersReadyEvent);

2584

2585

if (stream->blockingState->readRingBufferData)

2586

PaUtil_FreeMemory (stream->blockingState->readRingBufferData);

2587

2588

if (stream->blockingState->readStreamBuffer)

2589

PaUtil_FreeMemory (stream->blockingState->readStreamBuffer);

2590

2591

if (blockingReadFramesReadyEventInitialized)

2592

CloseHandle (stream->blockingState->readFramesReadyEvent);

2593

2594

PaUtil_FreeMemory (stream->blockingState);

2595

}

2596

2597

if (callbackBufferProcessorInited)

2598

PaUtil_TerminateBufferProcessor (&stream->bufferProcessor);

2599

2600

if (completedBuffersPlayedEventInited)

2601

CloseHandle (stream->completedBuffersPlayedEvent);

2602

2603

if (stream->asioBufferInfos)

2604

PaUtil_FreeMemory (stream->asioBufferInfos);

2605

2606

if (stream->asioChannelInfos)

2607

PaUtil_FreeMemory (stream->asioChannelInfos);

2608

2609

if (stream->bufferPtrs)

2610

PaUtil_FreeMemory (stream->bufferPtrs);

2611

2612

PaUtil_FreeMemory (stream);

2613

}

2614

2615

if (asioBuffersCreated)

2616

ASIODisposeBuffers();

2617

2618

if (asioIsInitialized) {

2619

UnloadAsioDriver();

2620

}

2621

2622

return result;

2623

}

2624

2625

2626

2627

When CloseStream() is called, the multi-api layer ensures that

2628

the stream has already been stopped or aborted.

2629

2630

static PaError CloseStream (PaStream* s)

2631

{

2632

PaError result = paNoError;

2633

PaAsioStream *stream = (PaAsioStream*) s;

2634

2635

2636

IMPLEMENT ME:

2637

- additional stream closing + cleanup

2638

2639

2640

PaUtil_TerminateBufferProcessor (&stream->bufferProcessor);

2641

PaUtil_TerminateStreamRepresentation (&stream->streamRepresentation);

2642

2643

stream->asioHostApi->openAsioDeviceIndex = paNoDevice;

2644

2645

CloseHandle (stream->completedBuffersPlayedEvent);

2646

2647

/* Using blocking i/o interface... */

2648

if (stream->blockingState) {

2649

PaUtil_TerminateBufferProcessor (&stream->blockingState->bufferProcessor);

2650

2651

if (stream->inputChannelCount) {

2652

PaUtil_FreeMemory (stream->blockingState->readRingBufferData);

2653

PaUtil_FreeMemory (stream->blockingState->readStreamBuffer);

2654

CloseHandle (stream->blockingState->readFramesReadyEvent);

2655

}

2656

2657

if (stream->outputChannelCount) {

2658

PaUtil_FreeMemory (stream->blockingState->writeRingBufferData);

2659

PaUtil_FreeMemory (stream->blockingState->writeStreamBuffer);

2660

CloseHandle (stream->blockingState->writeBuffersReadyEvent);

2661

}

2662

2663

PaUtil_FreeMemory (stream->blockingState);

2664

}

2665

2666

PaUtil_FreeMemory (stream->asioBufferInfos);

2667

PaUtil_FreeMemory (stream->asioChannelInfos);

2668

PaUtil_FreeMemory (stream->bufferPtrs);

2669

PaUtil_FreeMemory (stream);

2670

2671

ASIODisposeBuffers();

2672

UnloadAsioDriver();

2673

2674

theAsioStream = 0;

2675

2676

return result;

2677

}

2678

2679

2680

static void bufferSwitch (long index, ASIOBool directProcess)

2681

{

2682

//TAKEN FROM THE ASIO SDK

2683

2684

// the actual processing callback.

2685

// Beware that this is normally in a seperate thread, hence be sure that

2686

// you take care about thread synchronization. This is omitted here for

2687

// simplicity.

2688

2689

// as this is a "back door" into the bufferSwitchTimeInfo a timeInfo needs

2690

// to be created though it will only set the timeInfo.samplePosition and

2691

// timeInfo.systemTime fields and the according flags

2692

2693

ASIOTime timeInfo;

2694

memset (&timeInfo, 0, sizeof (timeInfo));

2695

2696

// get the time stamp of the buffer, not necessary if no

2697

// synchronization to other media is required

2698

if (ASIOGetSamplePosition (&timeInfo.timeInfo.samplePosition, &timeInfo.timeInfo.systemTime) == ASE_OK)

2699

timeInfo.timeInfo.flags = kSystemTimeValid | kSamplePositionValid;

2700

2701

// Call the real callback

2702

bufferSwitchTimeInfo (&timeInfo, index, directProcess);

2703

}

2704

2705

2706

// conversion from 64 bit ASIOSample/ASIOTimeStamp to double float

2707

#if NATIVE_INT64

2708

#define ASIO64toDouble(a) (a)

2709

#else

2710

const double twoRaisedTo32 = 4294967296.;

2711

#define ASIO64toDouble(a) ((a).lo + (a).hi * twoRaisedTo32)

2712

#endif

2713

2714

static ASIOTime *bufferSwitchTimeInfo (ASIOTime *timeInfo, long index, ASIOBool directProcess)

2715

{

2716

// the actual processing callback.

2717

// Beware that this is normally in a seperate thread, hence be sure that

2718

// you take care about thread synchronization.

2719

2720

2721

/* The SDK says the following about the directProcess flag:

2722

suggests to the host whether it should immediately start processing

2723

(directProcess == ASIOTrue), or whether its process should be deferred

2724

because the call comes from a very low level (for instance, a high level

2725

priority interrupt), and direct processing would cause timing instabilities for

2726

the rest of the system. If in doubt, directProcess should be set to ASIOFalse.

2727

2728

We just ignore directProcess. This could cause incompatibilities with

2729

drivers which really don't want the audio processing to occur in this

2730

callback, but none have been identified yet.

2731

2732

2733

(void) directProcess; /* suppress unused parameter warning */

2734

2735

#if 0

2736

// store the timeInfo for later use

2737

asioDriverInfo.tInfo = *timeInfo;

2738

2739

// get the time stamp of the buffer, not necessary if no

2740

// synchronization to other media is required

2741

2742

if (timeInfo->timeInfo.flags & kSystemTimeValid)

2743

asioDriverInfo.nanoSeconds = ASIO64toDouble (timeInfo->timeInfo.systemTime);

2744

else

2745

asioDriverInfo.nanoSeconds = 0;

2746

2747

if (timeInfo->timeInfo.flags & kSamplePositionValid)

2748

asioDriverInfo.samples = ASIO64toDouble (timeInfo->timeInfo.samplePosition);

2749

else

2750

asioDriverInfo.samples = 0;

2751

2752

if (timeInfo->timeCode.flags & kTcValid)

2753

asioDriverInfo.tcSamples = ASIO64toDouble (timeInfo->timeCode.timeCodeSamples);

2754

else

2755

asioDriverInfo.tcSamples = 0;

2756

2757

// get the system reference time

2758

asioDriverInfo.sysRefTime = get_sys_reference_time();

2759

#endif

2760

2761

#if 0

2762

// a few debug messages for the Windows device driver developer

2763

// tells you the time when driver got its interrupt and the delay until the app receives

2764

// the event notification.

2765

static double last_samples = 0;

2766

char tmp[128];

2767

sprintf (tmp, "diff: %d / %d ms / %d ms / %d samples \n", asioDriverInfo.sysRefTime - (long) (asioDriverInfo.nanoSeconds / 1000000.0), asioDriverInfo.sysRefTime, (long) (asioDriverInfo.nanoSeconds / 1000000.0), (long) (asioDriverInfo.samples - last_samples));

2768

OutputDebugString (tmp);

2769

last_samples = asioDriverInfo.samples;

2770

#endif

2771

2772

2773

if (!theAsioStream)

2774

return 0L;

2775

2776

// Keep sample position

2777

// FIXME: asioDriverInfo.pahsc_NumFramesDone = timeInfo->timeInfo.samplePosition.lo;

2778

2779

2780

// protect against reentrancy

2781

if (PaAsio_AtomicIncrement (&theAsioStream->reenterCount)) {

2782

theAsioStream->reenterError++;

2783

//DBUG(("bufferSwitchTimeInfo : reentrancy detection = %d\n", asioDriverInfo.reenterError));

2784

return 0L;

2785

}

2786

2787

int buffersDone = 0;

2788

2789

do {

2790

if (buffersDone > 0) {

2791

// this is a reentered buffer, we missed processing it on time

2792

// set the input overflow and output underflow flags as appropriate

2793

2794

if (theAsioStream->inputChannelCount > 0)

2795

theAsioStream->callbackFlags |= paInputOverflow;

2796

2797

if (theAsioStream->outputChannelCount > 0)

2798

theAsioStream->callbackFlags |= paOutputUnderflow;

2799

} else {

2800

if (theAsioStream->zeroOutput) {

2801

ZeroOutputBuffers (theAsioStream, index);

2802

2803

// Finally if the driver supports the ASIOOutputReady() optimization,

2804

// do it here, all data are in place

2805

if (theAsioStream->postOutput)

2806

ASIOOutputReady();

2807

2808

if (theAsioStream->stopProcessing) {

2809

if (theAsioStream->stopPlayoutCount < 2) {

2810

++theAsioStream->stopPlayoutCount;

2811

2812

if (theAsioStream->stopPlayoutCount == 2) {

2813

theAsioStream->isActive = 0;

2814

2815

if (theAsioStream->streamRepresentation.streamFinishedCallback != 0)

2816

theAsioStream->streamRepresentation.streamFinishedCallback (theAsioStream->streamRepresentation.userData);

2817

2818

theAsioStream->streamFinishedCallbackCalled = true;

2819

SetEvent (theAsioStream->completedBuffersPlayedEvent);

2820

}

2821

}

2822

}

2823

} else {

2824

2825

#if 0

2826

// test code to try to detect slip conditions... these may work on some systems

2827

// but neither of them work on the RME Digi96

2828

2829

// check that sample delta matches buffer size (otherwise we must have skipped

2830

// a buffer.

2831

static double last_samples = -512;

2832

double samples;

2833

//if( timeInfo->timeCode.flags & kTcValid )

2834

// samples = ASIO64toDouble(timeInfo->timeCode.timeCodeSamples);

2835

//else

2836

samples = ASIO64toDouble (timeInfo->timeInfo.samplePosition);

2837

int delta = samples - last_samples;

2838

//printf( "%d\n", delta);

2839

last_samples = samples;

2840

2841

if (delta > theAsioStream->framesPerHostCallback) {

2842

if (theAsioStream->inputChannelCount > 0)

2843

theAsioStream->callbackFlags |= paInputOverflow;

2844

2845

if (theAsioStream->outputChannelCount > 0)

2846

theAsioStream->callbackFlags |= paOutputUnderflow;

2847

}

2848

2849

// check that the buffer index is not the previous index (which would indicate

2850

// that a buffer was skipped.

2851

static int previousIndex = 1;

2852

2853

if (index == previousIndex) {

2854

if (theAsioStream->inputChannelCount > 0)

2855

theAsioStream->callbackFlags |= paInputOverflow;

2856

2857

if (theAsioStream->outputChannelCount > 0)

2858

theAsioStream->callbackFlags |= paOutputUnderflow;

2859

}

2860

2861

previousIndex = index;

2862

#endif

2863

2864

int i;

2865

2866

PaUtil_BeginCpuLoadMeasurement (&theAsioStream->cpuLoadMeasurer);

2867

2868

PaStreamCallbackTimeInfo paTimeInfo;

2869

2870

// asio systemTime is supposed to be measured according to the same

2871

// clock as timeGetTime

2872

paTimeInfo.currentTime = (ASIO64toDouble (timeInfo->timeInfo.systemTime) * .000000001);

2873

2874

/* patch from Paul Boege */

2875

paTimeInfo.inputBufferAdcTime = paTimeInfo.currentTime -

2876

( (double) theAsioStream->inputLatency/theAsioStream->streamRepresentation.streamInfo.sampleRate);

2877

2878

paTimeInfo.outputBufferDacTime = paTimeInfo.currentTime +

2879

( (double) theAsioStream->outputLatency/theAsioStream->streamRepresentation.streamInfo.sampleRate);

2880

2881

/* old version is buggy because the buffer processor also adds in its latency to the time parameters

2882

paTimeInfo.inputBufferAdcTime = paTimeInfo.currentTime - theAsioStream->streamRepresentation.streamInfo.inputLatency;

2883

paTimeInfo.outputBufferDacTime = paTimeInfo.currentTime + theAsioStream->streamRepresentation.streamInfo.outputLatency;

2884

2885

2886

/* Disabled! Stopping and re-starting the stream causes an input overflow / output undeflow. S.Fischer */

2887

#if 0

2888

// detect underflows by checking inter-callback time > 2 buffer period

2889

static double previousTime = -1;

2890

2891

if (previousTime > 0) {

2892

2893

double delta = paTimeInfo.currentTime - previousTime;

2894

2895

if (delta >= 2. * (theAsioStream->framesPerHostCallback / theAsioStream->streamRepresentation.streamInfo.sampleRate)) {

2896

if (theAsioStream->inputChannelCount > 0)

2897

theAsioStream->callbackFlags |= paInputOverflow;

2898

2899

if (theAsioStream->outputChannelCount > 0)

2900

theAsioStream->callbackFlags |= paOutputUnderflow;

2901

}

2902

}

2903

2904

previousTime = paTimeInfo.currentTime;

2905

#endif

2906

2907

// note that the above input and output times do not need to be

2908

// adjusted for the latency of the buffer processor -- the buffer

2909

// processor handles that.

2910

2911

if (theAsioStream->inputBufferConverter) {

2912

for (i=0; i<theAsioStream->inputChannelCount; i++) {

2913

theAsioStream->inputBufferConverter (theAsioStream->inputBufferPtrs[index][i],

2914

theAsioStream->inputShift, theAsioStream->framesPerHostCallback);

2915

}

2916

}

2917

2918

PaUtil_BeginBufferProcessing (&theAsioStream->bufferProcessor, &paTimeInfo, theAsioStream->callbackFlags);

2919

2920

/* reset status flags once they've been passed to the callback */

2921

theAsioStream->callbackFlags = 0;

2922

2923

PaUtil_SetInputFrameCount (&theAsioStream->bufferProcessor, 0 /* default to host buffer size */);

2924

2925

for (i=0; i<theAsioStream->inputChannelCount; ++i)

2926

PaUtil_SetNonInterleavedInputChannel (&theAsioStream->bufferProcessor, i, theAsioStream->inputBufferPtrs[index][i]);

2927

2928

PaUtil_SetOutputFrameCount (&theAsioStream->bufferProcessor, 0 /* default to host buffer size */);

2929

2930

for (i=0; i<theAsioStream->outputChannelCount; ++i)

2931

PaUtil_SetNonInterleavedOutputChannel (&theAsioStream->bufferProcessor, i, theAsioStream->outputBufferPtrs[index][i]);

2932

2933

int callbackResult;

2934

2935

if (theAsioStream->stopProcessing)

2936

callbackResult = paComplete;

2937

else

2938

callbackResult = paContinue;

2939

2940

unsigned long framesProcessed = PaUtil_EndBufferProcessing (&theAsioStream->bufferProcessor, &callbackResult);

2941

2942

if (theAsioStream->outputBufferConverter) {

2943

for (i=0; i<theAsioStream->outputChannelCount; i++) {

2944

theAsioStream->outputBufferConverter (theAsioStream->outputBufferPtrs[index][i],

2945

theAsioStream->outputShift, theAsioStream->framesPerHostCallback);

2946

}

2947

}

2948

2949

PaUtil_EndCpuLoadMeasurement (&theAsioStream->cpuLoadMeasurer, framesProcessed);

2950

2951

// Finally if the driver supports the ASIOOutputReady() optimization,

2952

// do it here, all data are in place

2953

if (theAsioStream->postOutput)

2954

ASIOOutputReady();

2955

2956

if (callbackResult == paContinue) {

2957

/* nothing special to do */

2958

} else if (callbackResult == paAbort) {

2959

/* finish playback immediately */

2960

theAsioStream->isActive = 0;

2961

2962

if (theAsioStream->streamRepresentation.streamFinishedCallback != 0)

2963

theAsioStream->streamRepresentation.streamFinishedCallback (theAsioStream->streamRepresentation.userData);

2964

2965

theAsioStream->streamFinishedCallbackCalled = true;

2966

SetEvent (theAsioStream->completedBuffersPlayedEvent);

2967

theAsioStream->zeroOutput = true;

2968

} else { /* paComplete or other non-zero value indicating complete */

2969

/* Finish playback once currently queued audio has completed. */

2970

theAsioStream->stopProcessing = true;

2971

2972

if (PaUtil_IsBufferProcessorOutputEmpty (&theAsioStream->bufferProcessor)) {

2973

theAsioStream->zeroOutput = true;

2974

theAsioStream->stopPlayoutCount = 0;

2975

}

2976

}

2977

}

2978

}

2979

2980

++buffersDone;

2981

} while (PaAsio_AtomicDecrement (&theAsioStream->reenterCount) >= 0);

2982

2983

return 0L;

2984

}

2985

2986

2987

static void sampleRateChanged (ASIOSampleRate sRate)

2988

{

2989

// TAKEN FROM THE ASIO SDK

2990

// do whatever you need to do if the sample rate changed

2991

// usually this only happens during external sync.

2992

// Audio processing is not stopped by the driver, actual sample rate

2993

// might not have even changed, maybe only the sample rate status of an

2994

// AES/EBU or S/PDIF digital input at the audio device.

2995

// You might have to update time/sample related conversion routines, etc.

2996

2997

(void) sRate; /* unused parameter */

2998

PA_DEBUG ( ("sampleRateChanged : %d \n", sRate));

2999

}

3000

3001

static long asioMessages (long selector, long value, void* message, double* opt)

3002

{

3003

// TAKEN FROM THE ASIO SDK

3004

// currently the parameters "value", "message" and "opt" are not used.

3005

long ret = 0;

3006

3007

(void) message; /* unused parameters */

3008

(void) opt;

3009

3010

PA_DEBUG ( ("asioMessages : %d , %d \n", selector, value));

3011

3012

switch (selector) {

3013

case kAsioSelectorSupported:

3014

3015

if (value == kAsioResetRequest

3016

|| value == kAsioEngineVersion

3017

|| value == kAsioResyncRequest

3018

|| value == kAsioLatenciesChanged

3019

// the following three were added for ASIO 2.0, you don't necessarily have to support them

3020

|| value == kAsioSupportsTimeInfo

3021

|| value == kAsioSupportsTimeCode

3022

|| value == kAsioSupportsInputMonitor)

3023

ret = 1L;

3024

3025

break;

3026

3027

case kAsioBufferSizeChange:

3028

//printf("kAsioBufferSizeChange \n");

3029

break;

3030

3031

case kAsioResetRequest:

3032

// defer the task and perform the reset of the driver during the next "safe" situation

3033

// You cannot reset the driver right now, as this code is called from the driver.

3034

// Reset the driver is done by completely destruct is. I.e. ASIOStop(), ASIODisposeBuffers(), Destruction

3035

// Afterwards you initialize the driver again.

3036

3037

/*FIXME: commented the next line out */

3038

//asioDriverInfo.stopped; // In this sample the processing will just stop

3039

ret = 1L;

3040

break;

3041

3042

case kAsioResyncRequest:

3043

// This informs the application, that the driver encountered some non fatal data loss.

3044

// It is used for synchronization purposes of different media.

3045

// Added mainly to work around the Win16Mutex problems in Windows 95/98 with the

3046

// Windows Multimedia system, which could loose data because the Mutex was hold too long

3047

// by another thread.

3048

// However a driver can issue it in other situations, too.

3049

ret = 1L;

3050

break;

3051

3052

case kAsioLatenciesChanged:

3053

// This will inform the host application that the drivers were latencies changed.

3054

// Beware, it this does not mean that the buffer sizes have changed!

3055

// You might need to update internal delay data.

3056

ret = 1L;

3057

//printf("kAsioLatenciesChanged \n");

3058

break;

3059

3060

case kAsioEngineVersion:

3061

// return the supported ASIO version of the host application

3062

// If a host applications does not implement this selector, ASIO 1.0 is assumed

3063

// by the driver

3064

ret = 2L;

3065

break;

3066

3067

case kAsioSupportsTimeInfo:

3068

// informs the driver wether the asioCallbacks.bufferSwitchTimeInfo() callback

3069

// is supported.

3070

// For compatibility with ASIO 1.0 drivers the host application should always support

3071

// the "old" bufferSwitch method, too.

3072

ret = 1;

3073

break;

3074

3075

case kAsioSupportsTimeCode:

3076

// informs the driver wether application is interested in time code info.

3077

// If an application does not need to know about time code, the driver has less work

3078

// to do.

3079

ret = 0;

3080

break;

3081

}

3082

3083

return ret;

3084

}

3085

3086

3087

static PaError StartStream (PaStream *s)

3088

{

3089

PaError result = paNoError;

3090

PaAsioStream *stream = (PaAsioStream*) s;

3091

PaAsioStreamBlockingState *blockingState = stream->blockingState;

3092

ASIOError asioError;

3093

3094

if (stream->outputChannelCount > 0) {

3095

ZeroOutputBuffers (stream, 0);

3096

ZeroOutputBuffers (stream, 1);

3097

}

3098

3099

PaUtil_ResetBufferProcessor (&stream->bufferProcessor);

3100

stream->stopProcessing = false;

3101

stream->zeroOutput = false;

3102

3103

/* Reentrancy counter initialisation */

3104

stream->reenterCount = -1;

3105

stream->reenterError = 0;

3106

3107

stream->callbackFlags = 0;

3108

3109

if (ResetEvent (stream->completedBuffersPlayedEvent) == 0) {

3110

result = paUnanticipatedHostError;

3111

PA_ASIO_SET_LAST_SYSTEM_ERROR (GetLastError());

3112

}

3113

3114

3115

/* Using blocking i/o interface... */

3116

if (blockingState) {

3117

/* Reset blocking i/o buffer processor. */

3118

PaUtil_ResetBufferProcessor (&blockingState->bufferProcessor);

3119

3120

/* If we're about to process some input data. */

3121

if (stream->inputChannelCount) {

3122

/* Reset callback-ReadStream sync event. */

3123

if (ResetEvent (blockingState->readFramesReadyEvent) == 0) {

3124

result = paUnanticipatedHostError;

3125

PA_ASIO_SET_LAST_SYSTEM_ERROR (GetLastError());

3126

}

3127

3128

/* Flush blocking i/o ring buffer. */

3129

PaUtil_FlushRingBuffer (&blockingState->readRingBuffer);

3130

(*blockingState->bufferProcessor.inputZeroer) (blockingState->readRingBuffer.buffer, 1, blockingState->bufferProcessor.inputChannelCount * blockingState->readRingBuffer.bufferSize);

3131

}

3132

3133

/* If we're about to process some output data. */

3134

if (stream->outputChannelCount) {

3135

/* Reset callback-WriteStream sync event. */

3136

if (ResetEvent (blockingState->writeBuffersReadyEvent) == 0) {

3137

result = paUnanticipatedHostError;

3138

PA_ASIO_SET_LAST_SYSTEM_ERROR (GetLastError());

3139

}

3140

3141

/* Flush blocking i/o ring buffer. */

3142

PaUtil_FlushRingBuffer (&blockingState->writeRingBuffer);

3143

(*blockingState->bufferProcessor.outputZeroer) (blockingState->writeRingBuffer.buffer, 1, blockingState->bufferProcessor.outputChannelCount * blockingState->writeRingBuffer.bufferSize);

3144

3145

/* Initialize the output ring buffer to "silence". */

3146

PaUtil_AdvanceRingBufferWriteIndex (&blockingState->writeRingBuffer, blockingState->writeRingBufferInitialFrames);

3147

}

3148

3149

/* Clear requested frames / buffers count. */

3150

blockingState->writeBuffersRequested = 0;

3151

blockingState->readFramesRequested = 0;

3152

blockingState->writeBuffersRequestedFlag = FALSE;

3153

blockingState->readFramesRequestedFlag = FALSE;

3154

blockingState->outputUnderflowFlag = FALSE;

3155

blockingState->inputOverflowFlag = FALSE;

3156

blockingState->stopFlag = FALSE;

3157

}

3158

3159

3160

if (result == paNoError) {

3161

assert (theAsioStream == stream); /* theAsioStream should be set correctly in OpenStream */

3162

3163

/* initialize these variables before the callback has a chance to be invoked */

3164

stream->isStopped = 0;

3165

stream->isActive = 1;

3166

stream->streamFinishedCallbackCalled = false;

3167

3168

asioError = ASIOStart();

3169

3170

if (asioError != ASE_OK) {

3171

stream->isStopped = 1;

3172

stream->isActive = 0;

3173

3174

result = paUnanticipatedHostError;

3175

PA_ASIO_SET_LAST_ASIO_ERROR (asioError);

3176

}

3177

}

3178

3179

return result;

3180

}

3181

3182

static void EnsureCallbackHasCompleted (PaAsioStream *stream)

3183

{

3184

// make sure that the callback is not still in-flight after ASIOStop()

3185

// returns. This has been observed to happen on the Hoontech DSP24 for

3186

// example.

3187

int count = 2000; // only wait for 2 seconds, rather than hanging.

3188

3189

while (stream->reenterCount != -1 && count > 0) {

3190

Sleep (1);

3191

--count;

3192

}

3193

}

3194

3195

static PaError StopStream (PaStream *s)

3196

{

3197

PaError result = paNoError;

3198

PaAsioStream *stream = (PaAsioStream*) s;

3199

PaAsioStreamBlockingState *blockingState = stream->blockingState;

3200

ASIOError asioError;

3201

3202

if (stream->isActive) {

3203

/* If blocking i/o output is in use */

3204

if (blockingState && stream->outputChannelCount) {

3205

/* Request the whole output buffer to be available. */

3206

blockingState->writeBuffersRequested = blockingState->writeRingBuffer.bufferSize;

3207

/* Signalize that additional buffers are need. */

3208

blockingState->writeBuffersRequestedFlag = TRUE;

3209

/* Set flag to indicate the playback is to be stopped. */

3210

blockingState->stopFlag = TRUE;

3211

3212

/* Wait until requested number of buffers has been freed. Time

3213

out after twice the blocking i/o ouput buffer could have

3214

been consumed. */

3215

DWORD timeout = (DWORD) (2 * blockingState->writeRingBuffer.bufferSize * 1000

3216

/ stream->streamRepresentation.streamInfo.sampleRate);

3217

DWORD waitResult = WaitForSingleObject (blockingState->writeBuffersReadyEvent, timeout);

3218

3219

/* If something seriously went wrong... */

3220

if (waitResult == WAIT_FAILED) {

3221

PA_DEBUG ( ("WaitForSingleObject() failed in StopStream()\n"));

3222

result = paUnanticipatedHostError;

3223

PA_ASIO_SET_LAST_SYSTEM_ERROR (GetLastError());

3224

} else if (waitResult == WAIT_TIMEOUT) {

3225

PA_DEBUG ( ("WaitForSingleObject() timed out in StopStream()\n"));

3226

result = paTimedOut;

3227

}

3228

}

3229

3230

stream->stopProcessing = true;

3231

3232

/* wait for the stream to finish playing out enqueued buffers.

3233

timeout after four times the stream latency.

3234

3235

@todo should use a better time out value - if the user buffer

3236

length is longer than the asio buffer size then that should

3237

be taken into account.

3238

3239

if (WaitForSingleObject (stream->completedBuffersPlayedEvent,

3240

(DWORD) (stream->streamRepresentation.streamInfo.outputLatency * 1000. * 4.))

3241

== WAIT_TIMEOUT) {

3242

PA_DEBUG ( ("WaitForSingleObject() timed out in StopStream()\n"));

3243

}

3244

}

3245

3246

asioError = ASIOStop();

3247

3248

if (asioError == ASE_OK) {

3249

EnsureCallbackHasCompleted (stream);

3250

} else {

3251

result = paUnanticipatedHostError;

3252

PA_ASIO_SET_LAST_ASIO_ERROR (asioError);

3253

}

3254

3255

stream->isStopped = 1;

3256

stream->isActive = 0;

3257

3258

if (!stream->streamFinishedCallbackCalled) {

3259

if (stream->streamRepresentation.streamFinishedCallback != 0)

3260

stream->streamRepresentation.streamFinishedCallback (stream->streamRepresentation.userData);

3261

}

3262

3263

return result;

3264

}

3265

3266

static PaError AbortStream (PaStream *s)

3267

{

3268

PaError result = paNoError;

3269

PaAsioStream *stream = (PaAsioStream*) s;

3270

ASIOError asioError;

3271

3272

stream->zeroOutput = true;

3273

3274

asioError = ASIOStop();

3275

3276

if (asioError == ASE_OK) {

3277

EnsureCallbackHasCompleted (stream);

3278

} else {

3279

result = paUnanticipatedHostError;

3280

PA_ASIO_SET_LAST_ASIO_ERROR (asioError);

3281

}

3282

3283

stream->isStopped = 1;

3284

stream->isActive = 0;

3285

3286

if (!stream->streamFinishedCallbackCalled) {

3287

if (stream->streamRepresentation.streamFinishedCallback != 0)

3288

stream->streamRepresentation.streamFinishedCallback (stream->streamRepresentation.userData);

3289

}

3290

3291

return result;

3292

}

3293

3294

3295

static PaError IsStreamStopped (PaStream *s)

3296

{

3297

PaAsioStream *stream = (PaAsioStream*) s;

3298

3299

return stream->isStopped;

3300

}

3301

3302

3303

static PaError IsStreamActive (PaStream *s)

3304

{

3305

PaAsioStream *stream = (PaAsioStream*) s;

3306

3307

return stream->isActive;

3308

}

3309

3310

3311

static PaTime GetStreamTime (PaStream *s)

3312

{

3313

(void) s; /* unused parameter */

3314

return (double) timeGetTime() * .001;

3315

}

3316

3317

3318

static double GetStreamCpuLoad (PaStream* s)

3319

{

3320

PaAsioStream *stream = (PaAsioStream*) s;

3321

3322

return PaUtil_GetCpuLoad (&stream->cpuLoadMeasurer);

3323

}

3324

3325

3326

3327

As separate stream interfaces are used for blocking and callback

3328

streams, the following functions can be guaranteed to only be called

3329

for blocking streams.

3330

3331

3332

static PaError ReadStream (PaStream *s ,

3333

void *buffer,

3334

unsigned long frames)

3335

{

3336

PaError result = paNoError; /* Initial return value. */

3337

PaAsioStream *stream = (PaAsioStream*) s; /* The PA ASIO stream. */

3338

3339

/* Pointer to the blocking i/o data struct. */

3340

PaAsioStreamBlockingState *blockingState = stream->blockingState;

3341

3342

/* Get blocking i/o buffer processor and ring buffer pointers. */

3343

PaUtilBufferProcessor *pBp = &blockingState->bufferProcessor;

3344

PaUtilRingBuffer *pRb = &blockingState->readRingBuffer;

3345

3346

/* Ring buffer segment(s) used for writing. */

3347

void *pRingBufferData1st = NULL; /* First segment. (Mandatory) */

3348

void *pRingBufferData2nd = NULL; /* Second segment. (Optional) */

3349

3350

/* Number of frames per ring buffer segment. */

3351

long lRingBufferSize1st = 0; /* First segment. (Mandatory) */

3352

long lRingBufferSize2nd = 0; /* Second segment. (Optional) */

3353

3354

/* Get number of frames to be processed per data block. */

3355

unsigned long lFramesPerBlock = stream->bufferProcessor.framesPerUserBuffer;

3356

/* Actual number of frames that has been copied into the ring buffer. */

3357

unsigned long lFramesCopied = 0;

3358

/* The number of remaining unprocessed dtat frames. */

3359

unsigned long lFramesRemaining = frames;

3360

3361

/* Copy the input argument to avoid pointer increment! */

3362

const void *userBuffer;

3363

unsigned int i; /* Just a counter. */

3364

3365

/* About the time, needed to process 8 data blocks. */

3366

DWORD timeout = (DWORD) (8 * lFramesPerBlock * 1000 / stream->streamRepresentation.streamInfo.sampleRate);

3367

DWORD waitResult = 0;

3368

3369

3370

/* Check if the stream is still available ready to gather new data. */

3371

if (blockingState->stopFlag || !stream->isActive) {

3372

PA_DEBUG ( ("Warning! Stream no longer available for reading in ReadStream()\n"));

3373

result = paStreamIsStopped;

3374

return result;

3375

}

3376

3377

/* If the stream is a input stream. */

3378

if (stream->inputChannelCount) {

3379

/* Prepare buffer access. */

3380

if (!pBp->userOutputIsInterleaved) {

3381

userBuffer = blockingState->readStreamBuffer;

3382

3383

for (i = 0; i<pBp->inputChannelCount; ++i) {

3384

( (void**) userBuffer) [i] = ( (void**) buffer) [i];

3385

}

3386

} /* Use the unchanged buffer. */

3387

else {

3388

userBuffer = buffer;

3389

}

3390

3391

do { /* Internal block processing for too large user data buffers. */

3392

/* Get the size of the current data block to be processed. */

3393

lFramesPerBlock = (lFramesPerBlock < lFramesRemaining)

3394

? lFramesPerBlock : lFramesRemaining;

3395

/* Use predefined block size for as long there are enough

3396

buffers available, thereafter reduce the processing block

3397

size to match the number of remaining buffers. So the final

3398

data block is processed although it may be incomplete. */

3399

3400

/* If the available amount of data frames is insufficient. */

3401

if (PaUtil_GetRingBufferReadAvailable (pRb) < (long) lFramesPerBlock) {

3402

/* Make sure, the event isn't already set! */

3403

/* ResetEvent( blockingState->readFramesReadyEvent ); */

3404

3405

/* Set the number of requested buffers. */

3406

blockingState->readFramesRequested = lFramesPerBlock;

3407

3408

/* Signalize that additional buffers are need. */

3409

blockingState->readFramesRequestedFlag = TRUE;

3410

3411

/* Wait until requested number of buffers has been freed. */

3412

waitResult = WaitForSingleObject (blockingState->readFramesReadyEvent, timeout);

3413

3414

/* If something seriously went wrong... */

3415

if (waitResult == WAIT_FAILED) {

3416

PA_DEBUG ( ("WaitForSingleObject() failed in ReadStream()\n"));

3417

result = paUnanticipatedHostError;

3418

PA_ASIO_SET_LAST_SYSTEM_ERROR (GetLastError());

3419

return result;

3420

} else if (waitResult == WAIT_TIMEOUT) {

3421

PA_DEBUG ( ("WaitForSingleObject() timed out in ReadStream()\n"));

3422

3423

/* If block processing has stopped, abort! */

3424

if (blockingState->stopFlag) {

3425

return result = paStreamIsStopped;

3426

}

3427

3428

/* If a timeout is encountered, give up eventually. */

3429

return result = paTimedOut;

3430

}

3431

}

3432

3433

/* Now, the ring buffer contains the required amount of data

3434

frames.

3435

(Therefor we don't need to check the return argument of

3436

PaUtil_GetRingBufferReadRegions(). ;-) )

3437

3438

3439

/* Retrieve pointer(s) to the ring buffer's current write

3440

position(s). If the first buffer segment is too small to

3441

store the requested number of bytes, an additional second

3442

segment is returned. Otherwise, i.e. if the first segment

3443

is large enough, the second segment's pointer will be NULL.

3444

3445

PaUtil_GetRingBufferReadRegions (pRb ,

3446

lFramesPerBlock ,

3447

&pRingBufferData1st,

3448

&lRingBufferSize1st,

3449

&pRingBufferData2nd,

3450

&lRingBufferSize2nd);

3451

3452

/* Set number of frames to be copied from the ring buffer. */

3453

PaUtil_SetInputFrameCount (pBp, lRingBufferSize1st);

3454

/* Setup ring buffer access. */

3455

PaUtil_SetInterleavedInputChannels (pBp , /* Buffer processor. */

3456

0 , /* The first channel's index. */

3457

pRingBufferData1st, /* First ring buffer segment. */

3458

0); /* Use all available channels. */

3459

3460

/* If a second ring buffer segment is required. */

3461

if (lRingBufferSize2nd) {

3462

/* Set number of frames to be copied from the ring buffer. */

3463

PaUtil_Set2ndInputFrameCount (pBp, lRingBufferSize2nd);

3464

/* Setup ring buffer access. */

3465

PaUtil_Set2ndInterleavedInputChannels (pBp , /* Buffer processor. */

3466

0 , /* The first channel's index. */

3467

pRingBufferData2nd, /* Second ring buffer segment. */

3468

0); /* Use all available channels. */

3469

}

3470

3471

/* Let the buffer processor handle "copy and conversion" and

3472

update the ring buffer indices manually. */

3473

lFramesCopied = PaUtil_CopyInput (pBp, &buffer, lFramesPerBlock);

3474

PaUtil_AdvanceRingBufferReadIndex (pRb, lFramesCopied);

3475

3476

/* Decrease number of unprocessed frames. */

3477

lFramesRemaining -= lFramesCopied;

3478

3479

} /* Continue with the next data chunk. */

3480

3481

while (lFramesRemaining);

3482

3483

3484

/* If there has been an input overflow within the callback */

3485

if (blockingState->inputOverflowFlag) {

3486

blockingState->inputOverflowFlag = FALSE;

3487

3488

/* Return the corresponding error code. */

3489

result = paInputOverflowed;

3490

}

3491

3492

} /* If this is not an input stream. */

3493

else {

3494

result = paCanNotReadFromAnOutputOnlyStream;

3495

}

3496

3497

return result;

3498

}

3499

3500

static PaError WriteStream (PaStream *s ,

3501

const void *buffer,

3502

unsigned long frames)

3503

{

3504

PaError result = paNoError; /* Initial return value. */

3505

PaAsioStream *stream = (PaAsioStream*) s; /* The PA ASIO stream. */

3506

3507

/* Pointer to the blocking i/o data struct. */

3508

PaAsioStreamBlockingState *blockingState = stream->blockingState;

3509

3510

/* Get blocking i/o buffer processor and ring buffer pointers. */

3511

PaUtilBufferProcessor *pBp = &blockingState->bufferProcessor;

3512

PaUtilRingBuffer *pRb = &blockingState->writeRingBuffer;

3513

3514

/* Ring buffer segment(s) used for writing. */

3515

void *pRingBufferData1st = NULL; /* First segment. (Mandatory) */

3516

void *pRingBufferData2nd = NULL; /* Second segment. (Optional) */

3517

3518

/* Number of frames per ring buffer segment. */

3519

long lRingBufferSize1st = 0; /* First segment. (Mandatory) */

3520

long lRingBufferSize2nd = 0; /* Second segment. (Optional) */

3521

3522

/* Get number of frames to be processed per data block. */

3523

unsigned long lFramesPerBlock = stream->bufferProcessor.framesPerUserBuffer;

3524

/* Actual number of frames that has been copied into the ring buffer. */

3525

unsigned long lFramesCopied = 0;

3526

/* The number of remaining unprocessed dtat frames. */

3527

unsigned long lFramesRemaining = frames;

3528

3529

/* About the time, needed to process 8 data blocks. */

3530

DWORD timeout = (DWORD) (8 * lFramesPerBlock * 1000 / stream->streamRepresentation.streamInfo.sampleRate);

3531

DWORD waitResult = 0;

3532

3533

/* Copy the input argument to avoid pointer increment! */

3534

const void *userBuffer;

3535

unsigned int i; /* Just a counter. */

3536

3537

3538

/* Check if the stream ist still available ready to recieve new data. */

3539

if (blockingState->stopFlag || !stream->isActive) {

3540

PA_DEBUG ( ("Warning! Stream no longer available for writing in WriteStream()\n"));

3541

result = paStreamIsStopped;

3542

return result;

3543

}

3544

3545

/* If the stream is a output stream. */

3546

if (stream->outputChannelCount) {

3547

/* Prepare buffer access. */

3548

if (!pBp->userOutputIsInterleaved) {

3549

userBuffer = blockingState->writeStreamBuffer;

3550

3551

for (i = 0; i<pBp->outputChannelCount; ++i) {

3552

( (const void**) userBuffer) [i] = ( (const void**) buffer) [i];

3553

}

3554

} /* Use the unchanged buffer. */

3555

else {

3556

userBuffer = buffer;

3557

}

3558

3559

3560

do { /* Internal block processing for too large user data buffers. */

3561

/* Get the size of the current data block to be processed. */

3562

lFramesPerBlock = (lFramesPerBlock < lFramesRemaining)

3563

? lFramesPerBlock : lFramesRemaining;

3564

/* Use predefined block size for as long there are enough

3565

frames available, thereafter reduce the processing block

3566

size to match the number of remaining frames. So the final

3567

data block is processed although it may be incomplete. */

3568

3569

/* If the available amount of buffers is insufficient. */

3570

if (PaUtil_GetRingBufferWriteAvailable (pRb) < (long) lFramesPerBlock) {

3571

/* Make sure, the event isn't already set! */

3572

/* ResetEvent( blockingState->writeBuffersReadyEvent ); */

3573

3574

/* Set the number of requested buffers. */

3575

blockingState->writeBuffersRequested = lFramesPerBlock;

3576

3577

/* Signalize that additional buffers are need. */

3578

blockingState->writeBuffersRequestedFlag = TRUE;

3579

3580

/* Wait until requested number of buffers has been freed. */

3581

waitResult = WaitForSingleObject (blockingState->writeBuffersReadyEvent, timeout);

3582

3583

/* If something seriously went wrong... */

3584

if (waitResult == WAIT_FAILED) {

3585

PA_DEBUG ( ("WaitForSingleObject() failed in WriteStream()\n"));

3586

result = paUnanticipatedHostError;

3587

PA_ASIO_SET_LAST_SYSTEM_ERROR (GetLastError());

3588

return result;

3589

} else if (waitResult == WAIT_TIMEOUT) {

3590

PA_DEBUG ( ("WaitForSingleObject() timed out in WriteStream()\n"));

3591

3592

/* If block processing has stopped, abort! */

3593

if (blockingState->stopFlag) {

3594

return result = paStreamIsStopped;

3595

}

3596

3597

/* If a timeout is encountered, give up eventually. */

3598

return result = paTimedOut;

3599

}

3600

}

3601

3602

/* Now, the ring buffer contains the required amount of free

3603

space to store the provided number of data frames.

3604

(Therefor we don't need to check the return argument of

3605

PaUtil_GetRingBufferWriteRegions(). ;-) )

3606

3607

3608

/* Retrieve pointer(s) to the ring buffer's current write

3609

position(s). If the first buffer segment is too small to

3610

store the requested number of bytes, an additional second

3611

segment is returned. Otherwise, i.e. if the first segment

3612

is large enough, the second segment's pointer will be NULL.

3613

3614

PaUtil_GetRingBufferWriteRegions (pRb ,

3615

lFramesPerBlock ,

3616

&pRingBufferData1st,

3617

&lRingBufferSize1st,

3618

&pRingBufferData2nd,

3619

&lRingBufferSize2nd);

3620

3621

/* Set number of frames to be copied to the ring buffer. */

3622

PaUtil_SetOutputFrameCount (pBp, lRingBufferSize1st);

3623

/* Setup ring buffer access. */

3624

PaUtil_SetInterleavedOutputChannels (pBp , /* Buffer processor. */

3625

0 , /* The first channel's index. */

3626

pRingBufferData1st, /* First ring buffer segment. */

3627

0); /* Use all available channels. */

3628

3629

/* If a second ring buffer segment is required. */

3630

if (lRingBufferSize2nd) {

3631

/* Set number of frames to be copied to the ring buffer. */

3632

PaUtil_Set2ndOutputFrameCount (pBp, lRingBufferSize2nd);

3633

/* Setup ring buffer access. */

3634

PaUtil_Set2ndInterleavedOutputChannels (pBp , /* Buffer processor. */

3635

0 , /* The first channel's index. */

3636

pRingBufferData2nd, /* Second ring buffer segment. */

3637

0); /* Use all available channels. */

3638

}

3639

3640

/* Let the buffer processor handle "copy and conversion" and

3641

update the ring buffer indices manually. */

3642

lFramesCopied = PaUtil_CopyOutput (pBp, &userBuffer, lFramesPerBlock);

3643

PaUtil_AdvanceRingBufferWriteIndex (pRb, lFramesCopied);

3644

3645

/* Decrease number of unprocessed frames. */

3646

lFramesRemaining -= lFramesCopied;

3647

3648

} /* Continue with the next data chunk. */

3649

3650

while (lFramesRemaining);

3651

3652

3653

/* If there has been an output underflow within the callback */

3654

if (blockingState->outputUnderflowFlag) {

3655

blockingState->outputUnderflowFlag = FALSE;

3656

3657

/* Return the corresponding error code. */

3658

result = paOutputUnderflowed;

3659

}

3660

3661

} /* If this is not an output stream. */

3662

else {

3663

result = paCanNotWriteToAnInputOnlyStream;

3664

}

3665

3666

return result;

3667

}

3668

3669

3670

static signed long GetStreamReadAvailable (PaStream* s)

3671

{

3672

PaAsioStream *stream = (PaAsioStream*) s;

3673

3674

/* Call buffer utility routine to get the number of available frames. */

3675

return PaUtil_GetRingBufferReadAvailable (&stream->blockingState->readRingBuffer);

3676

}

3677

3678

3679

static signed long GetStreamWriteAvailable (PaStream* s)

3680

{

3681

PaAsioStream *stream = (PaAsioStream*) s;

3682

3683

/* Call buffer utility routine to get the number of empty buffers. */

3684

return PaUtil_GetRingBufferWriteAvailable (&stream->blockingState->writeRingBuffer);

3685

}

3686

3687

3688

/* This routine will be called by the PortAudio engine when audio is needed.

3689

** It may called at interrupt level on some machines so don't do anything

3690

** that could mess up the system like calling malloc() or free().

3691

3692

static int BlockingIoPaCallback (const void *inputBuffer ,

3693

void *outputBuffer ,

3694

unsigned long framesPerBuffer,

3695

const PaStreamCallbackTimeInfo *timeInfo ,

3696

PaStreamCallbackFlags statusFlags ,

3697

void *userData)

3698

{

3699

PaError result = paNoError; /* Initial return value. */

3700

PaAsioStream *stream = * (PaAsioStream**) userData; /* The PA ASIO stream. */

3701

PaAsioStreamBlockingState *blockingState = stream->blockingState; /* Persume blockingState is valid, otherwise the callback wouldn't be running. */

3702

3703

/* Get a pointer to the stream's blocking i/o buffer processor. */

3704

PaUtilBufferProcessor *pBp = &blockingState->bufferProcessor;

3705

PaUtilRingBuffer *pRb = NULL;

3706

3707

/* If output data has been requested. */

3708

if (stream->outputChannelCount) {

3709

/* If the callback input argument signalizes a output underflow,

3710

make sure the WriteStream() function knows about it, too! */

3711

if (statusFlags & paOutputUnderflowed) {

3712

blockingState->outputUnderflowFlag = TRUE;

3713

}

3714

3715

/* Access the corresponding ring buffer. */

3716

pRb = &blockingState->writeRingBuffer;

3717

3718

/* If the blocking i/o buffer contains enough output data, */

3719

if (PaUtil_GetRingBufferReadAvailable (pRb) >= (long) framesPerBuffer) {

3720

/* Extract the requested data from the ring buffer. */

3721

PaUtil_ReadRingBuffer (pRb, outputBuffer, framesPerBuffer);

3722

} else { /* If no output data is available :-( */

3723

/* Signalize a write-buffer underflow. */

3724

blockingState->outputUnderflowFlag = TRUE;

3725

3726

/* Fill the output buffer with silence. */

3727

(*pBp->outputZeroer) (outputBuffer, 1, pBp->outputChannelCount * framesPerBuffer);

3728

3729

/* If playback is to be stopped */

3730

if (blockingState->stopFlag && PaUtil_GetRingBufferReadAvailable (pRb) < (long) framesPerBuffer) {

3731

/* Extract all the remaining data from the ring buffer,

3732

whether it is a complete data block or not. */

3733

PaUtil_ReadRingBuffer (pRb, outputBuffer, PaUtil_GetRingBufferReadAvailable (pRb));

3734

}

3735

}

3736

3737

/* Set blocking i/o event? */

3738

if (blockingState->writeBuffersRequestedFlag && PaUtil_GetRingBufferWriteAvailable (pRb) >= (long) blockingState->writeBuffersRequested) {

3739

/* Reset buffer request. */

3740

blockingState->writeBuffersRequestedFlag = FALSE;

3741

blockingState->writeBuffersRequested = 0;

3742

/* Signalize that requested buffers are ready. */

3743

SetEvent (blockingState->writeBuffersReadyEvent);

3744

/* What do we do if SetEvent() returns zero, i.e. the event

3745

could not be set? How to return errors from within the

3746

callback? - S.Fischer */

3747

}

3748

}

3749

3750

/* If input data has been supplied. */

3751

if (stream->inputChannelCount) {

3752

/* If the callback input argument signalizes a input overflow,

3753

make sure the ReadStream() function knows about it, too! */

3754

if (statusFlags & paInputOverflowed) {

3755

blockingState->inputOverflowFlag = TRUE;

3756

}

3757

3758

/* Access the corresponding ring buffer. */

3759

pRb = &blockingState->readRingBuffer;

3760

3761

/* If the blocking i/o buffer contains not enough input buffers */

3762

if (PaUtil_GetRingBufferWriteAvailable (pRb) < (long) framesPerBuffer) {

3763

/* Signalize a read-buffer overflow. */

3764

blockingState->inputOverflowFlag = TRUE;

3765

3766

/* Remove some old data frames from the buffer. */

3767

PaUtil_AdvanceRingBufferReadIndex (pRb, framesPerBuffer);

3768

}

3769

3770

/* Insert the current input data into the ring buffer. */

3771

PaUtil_WriteRingBuffer (pRb, inputBuffer, framesPerBuffer);

3772

3773

/* Set blocking i/o event? */

3774

if (blockingState->readFramesRequestedFlag && PaUtil_GetRingBufferReadAvailable (pRb) >= (long) blockingState->readFramesRequested) {

3775

/* Reset buffer request. */

3776

blockingState->readFramesRequestedFlag = FALSE;

3777

blockingState->readFramesRequested = 0;

3778

/* Signalize that requested buffers are ready. */

3779

SetEvent (blockingState->readFramesReadyEvent);

3780

/* What do we do if SetEvent() returns zero, i.e. the event

3781

could not be set? How to return errors from within the

3782

callback? - S.Fischer */

3783

/** @todo report an error with PA_DEBUG */

3784

}

3785

}

3786

3787

return paContinue;

3788

}

3789

3790

3791

PaError PaAsio_ShowControlPanel (PaDeviceIndex device, void* systemSpecific)

3792

{

3793

PaError result = paNoError;

3794

PaUtilHostApiRepresentation *hostApi;

3795

PaDeviceIndex hostApiDevice;

3796

ASIODriverInfo asioDriverInfo;

3797

ASIOError asioError;

3798

int asioIsInitialized = 0;

3799

PaAsioHostApiRepresentation *asioHostApi;

3800

PaAsioDeviceInfo *asioDeviceInfo;

3801

3802

3803

result = PaUtil_GetHostApiRepresentation (&hostApi, paASIO);

3804

3805

if (result != paNoError)

3806

goto error;

3807

3808

result = PaUtil_DeviceIndexToHostApiDeviceIndex (&hostApiDevice, device, hostApi);

3809

3810

if (result != paNoError)

3811

goto error;

3812

3813

3814

In theory we could proceed if the currently open device was the same

3815

one for which the control panel was requested, however because the

3816

window pointer is not available until this function is called we

3817

currently need to call ASIOInit() again here, which of course can't be

3818

done safely while a stream is open.

3819

3820

3821

asioHostApi = (PaAsioHostApiRepresentation*) hostApi;

3822

3823

if (asioHostApi->openAsioDeviceIndex != paNoDevice) {

3824

result = paDeviceUnavailable;

3825

goto error;

3826

}

3827

3828

asioDeviceInfo = (PaAsioDeviceInfo*) hostApi->deviceInfos[hostApiDevice];

3829

3830

/* See notes about CoInitialize(0) in LoadAsioDriver(). */

3831

CoInitialize (0);

3832

3833

if (!asioHostApi->asioDrivers->loadDriver (const_cast<char*> (asioDeviceInfo->commonDeviceInfo.name))) {

3834

result = paUnanticipatedHostError;

3835

goto error;

3836

}

3837

3838

/* CRUCIAL!!! */

3839

memset (&asioDriverInfo, 0, sizeof (ASIODriverInfo));

3840

asioDriverInfo.asioVersion = 2;

3841

asioDriverInfo.sysRef = systemSpecific;

3842

asioError = ASIOInit (&asioDriverInfo);

3843

3844

if (asioError != ASE_OK) {

3845

result = paUnanticipatedHostError;

3846

PA_ASIO_SET_LAST_ASIO_ERROR (asioError);

3847

goto error;

3848

} else {

3849

asioIsInitialized = 1;

3850

}

3851

3852

PA_DEBUG ( ("PaAsio_ShowControlPanel: ASIOInit(): %s\n", PaAsio_GetAsioErrorText (asioError)));

3853

PA_DEBUG ( ("asioVersion: ASIOInit(): %ld\n", asioDriverInfo.asioVersion));

3854

PA_DEBUG ( ("driverVersion: ASIOInit(): %ld\n", asioDriverInfo.driverVersion));

3855

PA_DEBUG ( ("Name: ASIOInit(): %s\n", asioDriverInfo.name));

3856

PA_DEBUG ( ("ErrorMessage: ASIOInit(): %s\n", asioDriverInfo.errorMessage));

3857

3858

asioError = ASIOControlPanel();

3859

3860

if (asioError != ASE_OK) {

3861

PA_DEBUG ( ("PaAsio_ShowControlPanel: ASIOControlPanel(): %s\n", PaAsio_GetAsioErrorText (asioError)));

3862

result = paUnanticipatedHostError;

3863

PA_ASIO_SET_LAST_ASIO_ERROR (asioError);

3864

goto error;

3865

}

3866

3867

PA_DEBUG ( ("PaAsio_ShowControlPanel: ASIOControlPanel(): %s\n", PaAsio_GetAsioErrorText (asioError)));

3868

3869

asioError = ASIOExit();

3870

3871

if (asioError != ASE_OK) {

3872

result = paUnanticipatedHostError;

3873

PA_ASIO_SET_LAST_ASIO_ERROR (asioError);

3874

asioIsInitialized = 0;

3875

goto error;

3876

}

3877

3878

CoUninitialize();

3879

PA_DEBUG ( ("PaAsio_ShowControlPanel: ASIOExit(): %s\n", PaAsio_GetAsioErrorText (asioError)));

3880

3881

return result;

3882

3883

error:

3884

3885

if (asioIsInitialized) {

3886

ASIOExit();

3887

}

3888

3889

CoUninitialize();

3890

3891

return result;

3892

}

3893

3894

3895

PaError PaAsio_GetInputChannelName (PaDeviceIndex device, int channelIndex,

3896

const char** channelName)

3897

{

3898

PaError result = paNoError;

3899

PaUtilHostApiRepresentation *hostApi;

3900

PaDeviceIndex hostApiDevice;

3901

PaAsioDeviceInfo *asioDeviceInfo;

3902

3903

3904

result = PaUtil_GetHostApiRepresentation (&hostApi, paASIO);

3905

3906

if (result != paNoError)

3907

goto error;

3908

3909

result = PaUtil_DeviceIndexToHostApiDeviceIndex (&hostApiDevice, device, hostApi);

3910

3911

if (result != paNoError)

3912

goto error;

3913

3914

asioDeviceInfo = (PaAsioDeviceInfo*) hostApi->deviceInfos[hostApiDevice];

3915

3916

if (channelIndex < 0 || channelIndex >= asioDeviceInfo->commonDeviceInfo.maxInputChannels) {

3917

result = paInvalidChannelCount;

3918

goto error;

3919

}

3920

3921

*channelName = asioDeviceInfo->asioChannelInfos[channelIndex].name;

3922

3923

return paNoError;

3924

3925

error:

3926

return result;

3927

}

3928

3929

3930

PaError PaAsio_GetOutputChannelName (PaDeviceIndex device, int channelIndex,

3931

const char** channelName)

3932

{

3933

PaError result = paNoError;

3934

PaUtilHostApiRepresentation *hostApi;

3935

PaDeviceIndex hostApiDevice;

3936

PaAsioDeviceInfo *asioDeviceInfo;

3937

3938

3939

result = PaUtil_GetHostApiRepresentation (&hostApi, paASIO);

3940

3941

if (result != paNoError)

3942

goto error;

3943

3944

result = PaUtil_DeviceIndexToHostApiDeviceIndex (&hostApiDevice, device, hostApi);

3945

3946

if (result != paNoError)

3947

goto error;

3948

3949

asioDeviceInfo = (PaAsioDeviceInfo*) hostApi->deviceInfos[hostApiDevice];

3950

3951

if (channelIndex < 0 || channelIndex >= asioDeviceInfo->commonDeviceInfo.maxOutputChannels) {

3952

result = paInvalidChannelCount;

3953

goto error;

3954

}

3955

3956

*channelName = asioDeviceInfo->asioChannelInfos[

3957

asioDeviceInfo->commonDeviceInfo.maxInputChannels + channelIndex].name;

3958

3959

return paNoError;

3960

3961

error:

3962

return result;

3963

}

3964

3965

3966

/* NOTE: the following functions are ASIO-stream specific, and are called directly

3967

by client code. We need to check for many more error conditions here because

3968

we don't have the benefit of pa_front.c's parameter checking.

3969

3970

3971

static PaError GetAsioStreamPointer (PaAsioStream **stream, PaStream *s)

3972

{

3973

PaError result;

3974

PaUtilHostApiRepresentation *hostApi;

3975

PaAsioHostApiRepresentation *asioHostApi;

3976

3977

result = PaUtil_ValidateStreamPointer (s);

3978

3979

if (result != paNoError)

3980

return result;

3981

3982

result = PaUtil_GetHostApiRepresentation (&hostApi, paASIO);

3983

3984

if (result != paNoError)

3985

return result;

3986

3987

asioHostApi = (PaAsioHostApiRepresentation*) hostApi;

3988

3989

if (PA_STREAM_REP (s)->streamInterface == &asioHostApi->callbackStreamInterface

3990

|| PA_STREAM_REP (s)->streamInterface == &asioHostApi->blockingStreamInterface) {

3991

/* s is an ASIO stream */

3992

*stream = (PaAsioStream *) s;

3993

return paNoError;

3994

} else {

3995

return paIncompatibleStreamHostApi;

3996

}

3997

}

3998

3999

4000

PaError PaAsio_SetStreamSampleRate (PaStream* s, double sampleRate)

4001

{

4002

PaAsioStream *stream;

4003

PaError result = GetAsioStreamPointer (&stream, s);

4004

4005

if (result != paNoError)

4006

return result;

4007

4008

if (stream != theAsioStream)

4009

return paBadStreamPtr;

4010

4011

return ValidateAndSetSampleRate (sampleRate);

4012

}

4013

Older »