Method GetZeroTimeStamp

proxyAudioDevice/ProxyAudioDevice.cpp:5095–5169

}

OSStatus ProxyAudioDevice::GetZeroTimeStamp(AudioServerPlugInDriverRef inDriver,
                                            AudioObjectID inDeviceObjectID,
                                            UInt32 inClientID,
                                            Float64 *outSampleTime,
                                            UInt64 *outHostTime,
                                            UInt64 *outSeed) {
    //    This method returns the current zero time stamp for the device. The HAL models the timing of
    //    a device as a series of time stamps that relate the sample time to a host time. The zero
    //    time stamps are spaced such that the sample times are the value of
    //    kAudioDevicePropertyZeroTimeStampPeriod apart. This is often modeled using a ring buffer
    //    where the zero time stamp is updated when wrapping around the ring buffer.
    //
    //    For this device, the zero time stamps' sample time increments every kDevice_RingBufferSize
    //    frames and the host time increments by kDevice_RingBufferSize * gDevice_HostTicksPerFrame.

#pragma unused(inClientID)
    
    //    declare the local variables
    OSStatus theAnswer = 0;
    UInt64 theCurrentHostTime;
    Float64 theHostTicksPerRingBuffer;
    Float64 theHostTickOffset;
    UInt64 theNextHostTime;

    //    check the arguments
    FailWithAction(inDriver != gAudioServerPlugInDriverRef,
                   theAnswer = kAudioHardwareBadObjectError,
                   Done,
                   "GetZeroTimeStamp: bad driver reference");
    FailWithAction(inDeviceObjectID != kObjectID_Device,
                   theAnswer = kAudioHardwareBadObjectError,
                   Done,
                   "GetZeroTimeStamp: bad device ID");

    {
        CAMutex::Locker locker(&getZeroTimestampMutex);
        
        //    get the current host time
        theCurrentHostTime = mach_absolute_time();

        // In order to keep the input and output IO in sync, we keep a running
        // average of the output IO proc's mRateScalar field for its output time.
        // Then each time we calculate the next zero timestamp we slightly adjust
        // the tick count for our ring buffer by however much the output IO proc
        // deviated from its sample rate.
        
        Float64 rateRatio = 1.0;
        
        if (outputAccumulatedRateRatioSamples > 0) {
            rateRatio = outputAccumulatedRateRatio / outputAccumulatedRateRatioSamples;
        }
        
        //    calculate the next host time
        theHostTicksPerRingBuffer =
            gDevice_HostTicksPerFrame * ((Float64)kDevice_RingBufferSize) * rateRatio;
        theHostTickOffset = gDevice_ElapsedTicks + theHostTicksPerRingBuffer;
        theNextHostTime = gDevice_AnchorHostTime + ((UInt64)theHostTickOffset);