Sync the gameplay with audio and music

    Still, for some games (mainly, rhythm games), it may be required to synchronize player actions with something happening in a song (usually in sync with the BPM). For this, having more precise timing information for an exact playback position is useful.

    Achieving very low playback timing precision is difficult. This is because many factors are at play during audio playback:

    • Audio is mixed in chunks (not continuously), depending on the size of audio buffers used (check latency in project settings).

    • Mixed chunks of audio are not played immediately.

    • Graphics APIs display two or three frames late.

    • When playing on TVs, some delay may be added due to image processing.

    The most common way to reduce latency is to shrink the audio buffers (again, by editing the latency setting in the project settings). The problem is that when latency is too small, sound mixing will require considerably more CPU. This increases the risk of skipping (a crack in sound because a mix callback was lost).

    The problem, in the end, is not this slight delay but synchronizing graphics and audio for games that require it. Beginning with Godot 3.2, some helpers were added to obtain more precise playback timing.

    As mentioned before, If you call AudioStreamPlayer.play(), sound will not begin immediately, but when the audio thread processes the next chunk.

    This delay can’t be avoided but it can be estimated by calling .

    The output latency (what happens after the mix) can also be estimated by calling AudioServer.get_output_latency().

    Add these two and it’s possible to guess almost exactly when sound or music will begin playing in the speakers during _process():

    GDScript   C#

    2. private double _timeDelay;
    4. public override void _Ready()
    5.     _timeBegin = OS.GetTicksUsec();
    6.     _timeDelay = AudioServer.GetTimeToNextMix() + AudioServer.GetOutputLatency();
    7.     GetNode<AudioStreamPlayer>("Player").Play();
    8. }
    11. {
    12.     double time = (OS.GetTicksUsec() - _timeBegin) / 1000000.0d;
    13.     time = Math.Max(0.0d, time - _timeDelay);
    14.     GD.Print(string.Format("Time is: {0}", time));
    15. }

    In the long run, though, as the sound hardware clock is never exactly in sync with the system clock, the timing information will slowly drift away.

    Using AudioStreamPlayer.get_playback_position() to obtain the current position for the song sounds ideal, but it’s not that useful as-is. This value will increment in chunks (every time the audio callback mixed a block of sound), so many calls can return the same value. Added to this, the value will be out of sync with the speakers too because of the previously mentioned reasons.

    To compensate for the “chunked” output, there is a function that can help: .

    Adding the return value from this function to get_playback_position() increases precision:

    GDScript   C#

      To increase precision, subtract the latency information (how much it takes for the audio to be heard after it was mixed):

      GDScript   C#

      1. double time = GetNode<AudioStreamPlayer>("Player").GetPlaybackPosition() + AudioServer.GetTimeSinceLastMix() - AudioServer.GetOutputLatency();

      The result may be a bit jittery due how multiple threads work. Just check that the value is not less than in the previous frame (discard it if so). This is also a less precise approach than the one before, but it will work for songs of any length, or synchronizing anything (sound effects, as an example) to music.

      GDScript   C#

      1. public override void _Ready()
      2. {
      4. }
      6. public override void _Process(float _delta)
      7. {
      8.     double time = GetNode<AudioStreamPlayer>("Player").GetPlaybackPosition() + AudioServer.GetTimeSinceLastMix();
      9.     // Compensate for output latency.
      10.     time -= AudioServer.GetOutputLatency();
      11. }