AVAudioPlayerNode - Versionsgeschichte

134.3.86.14 am 22. Januar 2023 um 12:39 Uhr

2023-01-22T12:39:24Z

Änderungen zeigen

134.3.86.14: /* Beispiel Sine Wave */

2023-01-14T09:08:36Z

Beispiel Sine Wave

134.3.86.14 am 14. Januar 2023 um 09:07 Uhr

2023-01-14T09:07:10Z

134.3.86.14: /* Scheduled Audio for timing accurate playback */

2023-01-14T06:13:09Z

Scheduled Audio for timing accurate playback

134.3.86.14 am 14. Januar 2023 um 06:10 Uhr

2023-01-14T06:10:21Z

134.3.86.14 am 14. Januar 2023 um 06:02 Uhr

2023-01-14T06:02:42Z

134.3.86.14: Die Seite wurde neu angelegt: „you can use AVAudioEngine and AVAudioPlayerNode to schedule buffers for timing accurate playback. The AVAudioPlayerNode class has a method called scheduleBuffe…“

2023-01-12T18:13:15Z

Die Seite wurde neu angelegt: „you can use AVAudioEngine and AVAudioPlayerNode to schedule buffers for timing accurate playback. The AVAudioPlayerNode class has a method called scheduleBuffe…“

Neue Seite

you can use AVAudioEngine and AVAudioPlayerNode to schedule buffers for timing accurate playback. The AVAudioPlayerNode class has a method called scheduleBuffer(_:at:options:completionHandler:) that allows you to schedule a buffer for playback at a specific time in the future. This can be used to achieve timing accurate playback.

Here is an example of how you can use AVAudioEngine and AVAudioPlayerNode to schedule buffers for timing accurate playback:
<syntaxhighlight lang="swift">
let engine = AVAudioEngine()
let player = AVAudioPlayerNode()
engine.attach(player)
engine.connect(player, to: engine.mainMixerNode, format: engine.mainMixerNode.outputFormat(forBus: 0))

// Prepare a buffer with your audio data
let buffer = AVAudioPCMBuffer(pcmFormat: player.outputFormat(forBus: 0), frameCapacity: 1024)!
// ... fill buffer with your audio data

// Schedule the buffer for playback
let sampleTime = AVAudioFramePosition(44100) // the sample time you want the buffer to start playing
player.scheduleBuffer(buffer, at: nil, options: .interrupts, completionHandler: nil)
engine.startAndReturnError(nil)
</syntaxhighlight>

In this example, it first creates an instance of AVAudioEngine and AVAudioPlayerNode, attaches the player to the engine, connects the player to the engine's main mixer node, then create a buffer with the audio data. Finally, it schedules the buffer for playback at a specific time (in this case, 44100 samples) by calling the scheduleBuffer(_:at:options:completionHandler:) method of the player.

The scheduleBuffer(_:at:options:completionHandler:) method allows you to specify the sample time at which the buffer should start playing. If you pass nil to the atTime parameter, the buffer will start playing as soon as possible.

It's worth noting that you should also set the engine.mainMixerNode.outputLatency to 0 or a low value to reduce delay between the scheduled time and the actual playback.

Please let me know if this helps, or if you have any other questions.

'''How can I use this to play a sound in accurate intervals for example 120 times a minute
'''
You can use the AVAudioPlayerNode's scheduleBuffer(_:at:options:completionHandler:) method to schedule multiple buffers for playback in accurate intervals to achieve a metronome like functionality.

Here's an example of how you can use this to play a sound 120 times per minute:

<syntaxhighlight lang="swift">
let engine = AVAudioEngine()
let player = AVAudioPlayerNode()
engine.attach(player)
engine.connect(player, to: engine.mainMixerNode, format: engine.mainMixerNode.outputFormat(forBus: 0))

// Prepare a buffer with your audio data
let buffer = AVAudioPCMBuffer(pcmFormat: player.outputFormat(forBus: 0), frameCapacity: 1024)!
// ... fill buffer with your audio data

// schedule the buffer for playback
let samplesPerMinute = 44100 * 60
let samplesPerClick = samplesPerMinute / 120

var nextClickSampleTime = engine.outputNode.lastRenderTime.sampleTime + samplesPerClick

for _ in 0..<120 {
player.scheduleBuffer(buffer, at: nil, options: .interrupts, completionHandler: nil)
nextClickSampleTime += samplesPerClick
}

engine.startAndReturnError(nil)
</syntaxhighlight>

In this example, it first creates an instance of AVAudioEngine and AVAudioPlayerNode, attaches the player to the engine, connects the player to the engine's main mixer node. Then it creates a buffer with the audio data that should be played. After that, it calculates the number of samples per minute and number of samples per click, using the sample rate of the audio format (44100 samples per second) and the desired number of clicks per minute (120). It sets the nextClickSampleTime to the current sample time plus the number of samples per click and then it schedules 120 buffers for playback at the nextClickSampleTime with the scheduleBuffer(_:at:options:completionHandler:) method.

The scheduleBuffer(_:at:options:completionHandler:) method allows you to specify the sample time at which the buffer should start playing, so by scheduling the buffer at the nextClickSampleTime variable, you are scheduling the playback of the buffer at accurate intervals.

It's worth noting that you should also set the engine.mainMixerNode.outputLatency to 0 or a low value to reduce delay between the scheduled time and the actual playback.

@@ Zeile 98: / Zeile 98: @@
 <syntaxhighlight lang="swift">
 ae = AVAudioEngine()
-        player = AVAudioPlayerNode()
+player = AVAudioPlayerNode()
-        mixer = ae?.mainMixerNode;
+mixer = ae?.mainMixerNode;
-        buffer = AVAudioPCMBuffer(pcmFormat: (player?.outputFormat(forBus: 0))!, frameCapacity: 100)
+buffer = AVAudioPCMBuffer(pcmFormat: (player?.outputFormat(forBus: 0))!, frameCapacity: 100)
-        buffer?.frameLength = 100
+buffer?.frameLength = 100
-        // generate sine wave
+// setup audio engine
-        let sr:Float = Float((mixer?.outputFormat(forBus: 0).sampleRate)!)
+ae?.attach(player!)
-        let n_channels = mixer?.outputFormat(forBus: 0).channelCount
+ae?.connect(player!, to: mixer!, format: player?.outputFormat(forBus: 0))
-        for i in stride(from:0, to: Int((buffer?.frameLength)!), by: Int(n_channels!)) {
-        // play player and buffer
+// play player and buffer
-        player?.play()
+player?.play()
-        player?.scheduleBuffer(buffer!, at: nil, options: .loops, completionHandler: nil)
+player?.scheduleBuffer(buffer!, at: nil, options: .loops, completionHandler: nil)
 </syntaxhighlight>

@@ Zeile 93: / Zeile 93: @@
      data[i] = sin(Float(i) / 44100 * 2 * Float.pi * 440)
+}
 </syntaxhighlight>

@@ Zeile 3: / Zeile 3: @@
   [[Swift (Programmiersprache)]]
 You can use AVAudioEngine and AVAudioPlayerNode to schedule buffers for timing accurate playback. The AVAudioPlayerNode class has a method called scheduleBuffer(_:at:options:completionHandler:) that allows you to schedule a buffer for playback at a specific time in the future. This can be used to achieve timing accurate playback.
@@ Zeile 30: / Zeile 32: @@
 Please let me know if this helps, or if you have any other questions.
-'''How can I use this to play a sound in accurate intervals for example 120 times a minute
+=== Play in intervals ===
-'''
+'''How can I use this to play a sound in accurate intervals for example 120 times a minute'''
 You can use the AVAudioPlayerNode's scheduleBuffer(_:at:options:completionHandler:) method to schedule multiple buffers for playback in accurate intervals to achieve a metronome like functionality.
@@ Zeile 60: / Zeile 62: @@
 </syntaxhighlight>
-In this example, it first creates an instance of AVAudioEngine and AVAudioPlayerNode, attaches the player to the engine, connects the player to the engine's main mixer node. Then it creates a buffer with the audio data that should be played. After that, it calculates the number of samples per minute and number of samples per click, using the sample rate of the audio format (44100 samples per second) and the desired number of clicks per minute (120). It sets the nextClickSampleTime to the current sample time plus the number of samples per click and then it schedules 120 buffers for playback at the nextClickSampleTime with the scheduleBuffer(_:at:options:completionHandler:) method.
+In this example, it first creates an instance of AVAudioEngine and AVAudioPlayerNode, attaches the player to the engine, connects the player to the engine's main mixer node. Then it creates a buffer with the audio data that should be played. After that, it '''calculates the number of samples per minute''' and '''number of samples per click''', using the '''sample rate''' of the audio format (44100 samples per second) and the '''desired number of clicks per minute''' (120). It sets the nextClickSampleTime to the current sample time plus the number of samples per click and then it schedules 120 buffers for playback at the nextClickSampleTime with the scheduleBuffer(_:at:options:completionHandler:) method.
-The scheduleBuffer(_:at:options:completionHandler:) method allows you to specify the sample time at which the buffer should start playing, so by scheduling the buffer at the nextClickSampleTime variable, you are scheduling the playback of the buffer at accurate intervals.
+let buffer = AVAudioPCMBuffer(pcmFormat: file.processingFormat, frameCapacity: AVAudioFrameCount(file.length))!
-It's worth noting that you should also set the engine.mainMixerNode.outputLatency to 0 or a low value to reduce delay between the scheduled time and the actual playback.
+In this example, it first constructs a file url of the audio file, then creates an instance of AVAudioFile using this url, then it creates an instance of AVAudioPCMBuffer with the same format as the file and with the enough frame capacity to hold the audio data, and then it reads the file's data into the buffer using the read(into:) method of the file instance.

← Nächstältere Version		Version vom 14. Januar 2023, 06:02 Uhr
Zeile 1:		Zeile 1:
−	~~you~~ can use AVAudioEngine and AVAudioPlayerNode to schedule buffers for timing accurate playback. The AVAudioPlayerNode class has a method called scheduleBuffer(_:at:options:completionHandler:) that allows you to schedule a buffer for playback at a specific time in the future. This can be used to achieve timing accurate playback.	+	== Links ==
		+	[[Swift (Programmiersprache)#Swift - Audio]]
		+	[[Swift (Programmiersprache)]]
		+
		+	You can use AVAudioEngine and AVAudioPlayerNode to schedule buffers for timing accurate playback. The AVAudioPlayerNode class has a method called scheduleBuffer(_:at:options:completionHandler:) that allows you to schedule a buffer for playback at a specific time in the future. This can be used to achieve timing accurate playback.

	Here is an example of how you can use AVAudioEngine and AVAudioPlayerNode to schedule buffers for timing accurate playback:		Here is an example of how you can use AVAudioEngine and AVAudioPlayerNode to schedule buffers for timing accurate playback:

@@ Zeile 24: / Zeile 24: @@
 </syntaxhighlight>
-In this example, it first creates an instance of AVAudioEngine and AVAudioPlayerNode, attaches the player to the engine, connects the player to the engine's main mixer node, then create a buffer with the audio data. Finally, it schedules the buffer for playback at a specific time (in this case, 44100 samples) by calling the scheduleBuffer(_:at:options:completionHandler:) method of the player.
+In this example, it first creates an instance of '''AVAudioEngine''' and '''AVAudioPlayerNode''', attaches the '''player''' to the engine, connects the player to the engine's main '''mixer''' node, then create a '''buffer''' with the audio data. Finally, it '''schedules the buffer''' for playback at a specific time (in this case, 44100 samples) by calling the '''scheduleBuffer(_:at:options:completionHandler:)''' method of the player.
 The scheduleBuffer(_:at:options:completionHandler:) method allows you to specify the sample time at which the buffer should start playing. If you pass nil to the atTime parameter, the buffer will start playing as soon as possible.
-It's worth noting that you should also set the engine.mainMixerNode.outputLatency to 0 or a low value to reduce delay between the scheduled time and the actual playback.
+It's worth noting that you should also set the '''engine.mainMixerNode.outputLatency''' to 0 or a '''low value''' to reduce delay between the scheduled time and the actual playback.
 Please let me know if this helps, or if you have any other questions.
-=== Play in intervals ===
+=== Play in accurate intervals ===
 '''How can I use this to play a sound in accurate intervals for example 120 times a minute'''
 You can use the AVAudioPlayerNode's scheduleBuffer(_:at:options:completionHandler:) method to schedule multiple buffers for playback in accurate intervals to achieve a metronome like functionality.
 Here's an example of how you can use this to play a sound 120 times per minute: