La gestione dei file audio mediante il componente gb.openal

Il componente gb.openal utilizza le risorse dell'API di Openal.

E' possibile eseguire un file audio sia mediante le risorse delle Classi Al ed Alure ^{[nota 1]} del componente gb.openal, sia solo con le Classi Alc e Al.

Conoscere la durata di un file audio

Per conoscere la durata di un file audio con le risorse della Classe Alure, si porrà la seguente formula:

durata_audio = Alure.GetStreamLength(Stream As AlureStream) / Alure.GetStreamFrequency(Stream As AlureStream)

laddove il Metodo Alure.GetStreamLength() equivale alla formula: (quantità_dati_audio_grezzi \ ((bit \ 8) * canali))

Eseguire un file audio con le risorse della Classe Al e della Classe Alure

Vi sono almeno tre modalità - sia in ambiente garfico che a riga di comando - per eseguire un file audio mediante le risorse della Classe Al e della Classe Alure del componente gb.openal.
E' possibile riprodurre file audio dei seguenti tipi:

• WAV;
• MP3;
• OGG.

1^a modalità

Private src As Integer[]
Private ast As Alurestream


Public Sub Form_Open()

 Dim err As Boolean

' Inizializza la libreria "Alure":
 err = Alure.InitDevice(Null, Null)
 If err == False Then Error.Raise("Impossibile inizializzare la libreria 'Alure' !")

End
 

Public Sub Button1_Click()    ' Avvia l'esecuzione del file audio

 Dim fileAudio As String = "/percorso/del/file/audio"
 Dim lungh As Integer
 Dim l As Byte = 1
  
 src = Al.GenSources(1)
 If IsNull(src) Then Error.Raise("Errore !")
  
' Individua la lunghezza del file audio caricato da eseguire:
 lungh = Stat(fileAudio).Size
  
' Se il file audio è un "mp3" o un "ogg", allora il valore della variabile "lungh" deve essere moltiplicato almeno per 4, altrimenti l'esecuzione audio terminerà anticipatamente:
 If Lower(File.Ext(fileAudio)) <> "wav" Then l = 4
  
 ast = Alure.CreateStreamFromFile(fileAudio, lungh * l, 0)
 If IsNull(ast) Then Error.Raise("Errore !")

' Esegue il flusso di dati audio.
' Il terzo parametro della funzione rappresenta il numero dei buffer utilizzati da accodare alla fonte di "OpenAL".
' Ogni buffer verrà riempito con la lunghezza del "chunk" specificato quando il flusso è stato creato.
' Tale valore nell'esecuzione di un file audio deve essere di almeno 2.
 Alure.PlaySourceStream(src[0], ast, 3, 0)

 Dim tm As Date = Now

 While (DateDiff(tm, Now, gb.Millisecond) < Alure.GetStreamLength(ast))
   Me.Title = Format(Time(0, 0, 0, DateDiff(tm, Now, gb.Millisecond)), "hh.nn.ss")
   Wait 0.1
   If Not Object.IsValid(ast) Then Break 
 Wend

End

 
Public Sub Button2_Click()    ' Arresta l'esecuzione del file audio

 If IsNull(ast) Then Return
 Alure.StopSource(src[0])
    
End


Public Sub Button3_Click()    ' Arresta l'esecuzione del file audio e chiude la finestra del programma
      
 If IsNull(ast) = False Then
   Alure.DestroyStream(ast)
   Alure.StopSource(src[0])
   al.DeleteSources(src)
 Endif
   
 Alure.ShutdownDevice()
 
 Me.Close
 
End

2^a modalità

Private source As Integer


Public Sub Form_Open()

 Dim err As Boolean

' Inizializza la libreria "Alure":
 err = Alure.InitDevice(Null, Null)
 If err == False Then Error.Raise("Impossibile inizializzare la libreria 'Alure' !")

End


Public Sub Button1_Click()    ' Avvia l'esecuzione del file audio

 Dim buffer As Integer
  
 buffer = alure.CreateBufferFromFile("/percorso/del/file/audio")
 
' Crea una sorgente sonora:
 source = al.GenSources(1)[0]
 
' Viene utilizzata la variabile "buffer" per riempire la sorgente.
' Il secondo argomento indica  al buffer di fornire campioni sonori:
 al.Sourcei(source, al.BUFFER, buffer)
 
' Esegue il flusso di dati audio.
 al.SourcePlay(source)

End


Public Sub ToggleButton1_Click()

 If ToggleButton1.Value Then
' Mette in pausa l'esecuzione del file audio
   al.SourcePause(source)
 Else
' Fa proseguire l'esecuzione del file audio
   al.SourcePlay(source)
 Endif

End


Public Sub Button2_Click()    ' Arresta l'esecuzione del file audio

 al.SourceStop(source)
 al.DeleteSources(al.GenSources(1))

End

3^a modalità

Private ags As Integer
 

Public Sub Button1_Click()    ' Avvia l'esecuzione del file audio
 
 Dim err As Boolean
 Dim fileAudio As String = "/percorso/del/file/audio"
 Dim agb As Integer

' Inizializza la libreria "Alure":
 err = Alure.InitDevice(Null, Null)
 If err == False Then Error.Raise("Impossibile inizializzare la libreria 'Alure' !")

' Genera le sorgenti sonore ed i buffer:
 ags = al.GenSources(1)[0]

 agb = al.GenBuffers(ags)[0]

 err = alure.BufferDataFromFile(fileAudio, agb)
 If err == False Then Error.Raise("Impossibile creare un buffer-data dal file audio !")

 al.Sourcei(ags, al.BUFFER, agb)

' Esegue il file audio:
 al.SourcePlay(ags)

End

 
Public Sub ToggleButton1_Click()

 If ToggleButton1.Value Then
' Mette in pausa l'esecuzione del file audio
   al.SourcePause(ags)
 Else
' Fa proseguire l'esecuzione del file audio
   al.SourcePlay(ags)
 Endif

End

 
Public Sub Button2_Click()    ' Arresta l'esecuzione del file audio

 al.DeleteBuffers(al.GenBuffers(ags))
 al.SourceStop(ags)
 al.DeleteSources(al.GenSources(1))

End

Caso di applicazione a riga di comando

Nel caso in cui l'applicazione per l'esecuzione di file audio sia stata realizzata senza componenti grafici, e dunque a riga di comando, al termine del codice sarà assolutamente necessario prevedere un ciclo.

E' possibile porre in Pausa l'esecuzione immettendo nel Terminale o nell'apposito spazio della console il carattere "p" e quindi premendo il tasto Invio. Per riprendere l'esecuzione basterà premere il solo tasto "Invio". In altri casi si è visto essere necessario inserire in console/terminale un carattere e poi premere "Invio".
E' altresì possibile arrestare l'esecuzione premendo il tasto Invio.

1^a modalità

Nel seguente esempio il percorso del file audio va inserito nell'apposito spazio sottostante della console (ovvero nel Terminale, ma in questo caso il percorso deve essere privo di apici). Alla fine dell'esecuzione o anche durante l'esecuzione medesima di un file audio è possibile - sempre con la modalità prima descritta inserire il percorso di un altro file audio ed eseguirlo oppure terminare il programma.

Public Sub Main()

 Dim s As String
 
' Il ciclo dura fino a che non viene inserito nell'apposito spazio della console (o nel Terminale, ma senza apici) il percorso di un file audio:
 Repeat
   Line Input s
 Until s Begins "/"

 Esecuzione(s)
 
End

 
Private Procedure Esecuzione(audio As String)
 
 Dim err As Boolean
 Dim src, lungh As Integer
 Dim ast As Alurestream
 Dim l As Byte = 1
   
' Inizializza la libreria "Alure":
 err = Alure.InitDevice(Null, Null)
 If err == False Then Error.Raise("Impossibile inizializzare la libreria 'Alure' !")
  
 src = Al.GenSources(1)[0]
  
 lungh = Stat(audio).Size

 If Lower(File.Ext(audio)) <> "wav" Then l = 4

 ast = Alure.CreateStreamFromFile(audio, lungh * l, 0)
 If IsNull(ast) Then Error.Raise("Errore !")

 Alure.PlaySourceStream(src, ast, 3, 0)
 
' 1) Inviando il tasto "p" dalla console, l'esecuzione è posta in "Pausa"; premendo il tasto "Invio", l'esecuzione viene ripresa. In altri casi si è visto essere necessario inserire in console/terminale un carattere e poi premere "Invio".
' 2) Se l'esecuzione non è in "Pausa" e si preme il tasto "Invio", allora si esce dal ciclo e l'esecuzione viene terminata. In altri casi si è visto essere necessario inserire in console/terminale un carattere e poi premere "Invio".
' 3) Se durante l'esecuzione di un file audio si invia in console/terminale il percorso di un altro file audio, il programma comincerà a eseguire in nuovo file audio.
 Repeat
   Input audio
   If audio == "p" Then Pausa(src)
 Until audio <> "p"
 
 Alure.DestroyStream(ast)
 al.DeleteSources([src])
 Alure.StopSource(src)
 Alure.ShutdownDevice()
  
 If audio Begins "/" Then Esecuzione(audio)
  
End


Private Procedure Pausa(i As Integer)
 
 Dim ripresa As String
 
 al.SourcePause(i)
 Print "Pausa !"
  
' Per riprendere l'esecuzione, è sufficiente premere in console/terminale il tasto "Invio".
' In altri casi si è visto essere necessario inserire in console/terminale un carattere e poi premere "Invio".
 Input ripresa
 al.SourcePlayv([i])
  
 Print "Riprende esecuzione."
 
End

2^a modalità

Public Sub Main()
 
 Dim err As Boolean
 Dim buffer, source As Integer
 Dim s As String

 s = "/percorso/del/file/audio"
 
' Inizializza la libreria "Alure":
 err = Alure.InitDevice(Null, Null)
 If err == False Then Error.Raise("Impossibile inizializzare la libreria 'Alure' !")
  
 buffer = alure.CreateBufferFromFile(s)

' Crea una sorgente sonora:
 source = al.GenSources(1)[0]
 
' Viene utilizzata la variabile "buffer" per riempire la sorgente.
' Il secondo argomento indica  al buffer di fornire campioni sonori:
 al.Sourcei(source, al.BUFFER, buffer)
 
' Esegue il flusso di dati audio.
 al.SourcePlay(source)

' Inviando il carattere il tasto "p" dalla console, l'esecuzione è posta in "Pausa"; premendo il tasto "Invio", l'esecuzione viene ripresa. In altri casi si è visto essere necessario inserire in console/terminale un carattere e poi premere "Invio".
' Se si preme il tasto "s" si esce dal ciclo e l'esecuzione viene terminata.
 Repeat
   Input s
   If s == "p" Then Pausa(source)
 Until s == "s"

 al.DeleteBuffers([buffer])
 Alure.StopSource(source)
 al.DeleteSources([source])
 Alure.ShutdownDevice()
  
End


Private Procedure Pausa(i As Integer)
 
 Dim ripresa As String
 
 al.SourcePause(i)
 Print "Pausa !"
  
' Per riprendere l'esecuzione, è sufficiente premere il tasto "Invio":
' In altri casi si è visto essere necessario inserire in console/terminale un carattere e poi premere "Invio".
 Input ripresa
 al.SourcePlay(i)
  
 Print "Riprende esecuzione."
 
End

3^a modalità

Public Sub Main()

 Dim err As Boolean
 Dim fileAudio, s As String
 Dim agb, ags As Integer
 
 fileAudio = "/percorso/del/file/audio" 
  
' Inizializza la libreria "Alure":
 err = Alure.InitDevice(Null, Null)
 If err == False Then Error.Raise("Impossibile inizializzare la libreria 'Alure' !")

 ags = al.GenSources(1)[0]

 agb = al.GenBuffers(ags)[0]

 err = alure.BufferDataFromFile(fileAudio, agb)
 If err == False Then Error.Raise("Impossibile creare un buffer-data dal file audio !")
 
 al.Sourcei(ags, al.BUFFER, agb)
  
 al.SourcePlay(ags)
 
' Inviando il tasto "p" dalla console, l'esecuzione è posta in "Pausa"; premendo il tasto "Invio", l'esecuzione viene ripresa. In altri casi si è visto essere necessario inserire in console/terminale un carattere e poi premere "Invio".
' Se si preme il tasto "s" si esce dal ciclo e l'esecuzione viene terminata.
 Repeat
   Input s
   If s == "p" Then Pausa(ags)
 Until s == "s"
  
 al.DeleteBuffers([agb])
 al.DeleteSources([ags])
 Alure.StopSource(ags)
 Alure.ShutdownDevice()
      
End


Private Procedure Pausa(i As Integer)
 
 Dim ripresa As String
 
 al.SourcePause(i)
 Print "Pausa !"
  
' Per riprendere l'esecuzione, è sufficiente premere il tasto "Invio".
' In altri casi si è visto essere necessario inserire in console/terminale un carattere e poi premere "Invio".
 Input ripresa
 al.SourcePlay(i)
  
 Print "Riprende esecuzione."
 
End

4^a modalità

Private s As String


Public Sub Main()

 Dim err As Boolean
 Dim src As Integer[]
 Dim lungh As Integer
 Dim ast As AlureStream
   
 s = "/percorso/del/file/audio"
 
' Inizializza la libreria "Alure":
 err = Alure.InitDevice(Null, Null)
 If err == False Then Error.Raise("Impossibile inizializzare la libreria 'Alure' !")

 src = Al.GenSources(1)

 lungh = Stat(s).Size

 ast = Alure.CreateStreamFromFile(s, lungh, 0)
 If IsNull(ast) Then Error.Raise("Impossibile creare il flusso di dati audio dal file !")

 Alure.PlaySourceStream(src[0], ast, 3, 0)

 s = Null

' Inviando il carattere "p" dal Terminale o dalla console, l'esecuzione è posta in "Pausa", inviando ogni altro carattere essa viene terminata:
 Repeat
   Alure.Update()
   Wait 0.01
   If s == "p" Then Pausa(src[0])
 Until s <> Null
 
' Va in chiusura:
 Alure.DestroyStream(ast)
 Alure.StopSource(src[0])
 Al.DeleteSources(src)
 Alure.ShutdownDevice()
  
 Quit
      
End


Private Procedure Pausa(sAl As Integer)

 Dim ripresa As String

 Al.SourcePause(sAl)
 Print "Pausa !"
 
' Per riprendere l'esecuzione, è sufficiente premere il tasto "Invio". In altri casi si è visto essere necessario inserire in console/terminale un carattere e poi premere "Invio".
 Input ripresa
 Al.SourcePlayv([sal])

 Print "Riprende esecuzione."
 s = Null

End


Public Sub Application_Read()

 Line Input s

End

Eseguire un file audio con l'uso delle Classi Alc e Al e caricando direttamente i dati audio grezzi nel buffer audio

In quest'altra modalità non si farà uso della Classe Alure, bensì le risorse delle Classi Al ed Alc (con la quale saranno impostati il dispositivo ed il contesto audio). Inoltre si provvederà a caricare direttamente i soli dati audio grezzi del file audio nel Buffer audio impostato con la Classe Al.

Mostriamo un esempio con un file di formato WAV:

Public Struct InfoWAV
  fileWAV As String
  canali As Short
  frequenza As Integer
  bit As Short
  block_align As Short
  durata As Float
  sonora As Byte[]
End Struct


Public Sub Main()
 
 Dim dispositivo As AlcDevice
 Dim contesto As AlcContext
 Dim src, buffer As Integer[]
 Dim err As Boolean
 Dim iw As New InfoWAV
 Dim formato As Integer
 
' Imposta il dispositivo audio con la Classe "Alc":
 dispositivo = Alc.OpenDevice(Null)
 If IsNull(dispositivo) Then Error.Raise("Impossibile impostare il dispositivo audio !")
  
' Imposta il contesto audio con la Classe "Alc":
 contesto = Alc.CreateContext(dispositivo)
 If IsNull(contesto) Then Error.Raise("Impossibile impostare il contesto audio !")
 
 err = contesto.MakeCurrent()
 If err == False Then Error.Raise("Impossibile creare il contesto audio !")

 src = Al.GenSources(1)
 If IsNull(src) Then Error.Raise("Errore !")

' Imposta il buffer audio:
 buffer = Al.GenBuffers(1)
 If IsNull(buffer) Then Error.Raise("Errore !")
  
 iw.fileWAV = "/percorso/del/file.wav"

 datiAudio(iw)
 
 Select Case iw.canali + iw.bit
   Case 9
     formato = Al.FORMAT_MONO8
   Case 10
     formato = Al.FORMAT_STEREO8
   Case 17
     formato = Al.FORMAT_MONO16
   Case 18
     formato = Al.FORMAT_STEREO16
 End Select

' I dati audio grezzi del file wav sono caricati nel buffer audio:
 Al.BufferData(buffer[0], formato, iw.sonora.ToString(0, iw.sonora.Count), iw.sonora.Count, iw.frequenza)
  
' Connette il buffer audio al sorgente audio:
 Al.Sourcei(src[0], Al.BUFFER, buffer[0])
  
' Esegue il sorgente audio:
 Al.SourcePlay(src[0])
  
' Consente l'esecuzione per l'intera durata del brano:
 Wait iw.durata
  
 Al.SourceStop(src[0])
  
' Va in chiusura:
 Al.DeleteBuffers(buffer)
 Alure.StopSource(src[0])
 Al.DeleteSources(src)
 Alc.DestroyContext(contesto)
 Alc.CloseDevice(dispositivo)
  
End


Private Function datiAudio(iwav As InfoWAV)
 
 Dim fl As File
 Dim d As Short
 
 Print "File wav caricato:  "; iwav.fileWAV
  
' Carica il file audio Wav:
 fl = Open iwav.fileWAV For Read

 d = InStr(File.Load(iwav.fileWAV), "data")
 
 iwav.sonora = New Byte[Lof(fl) - (d + 7)]

' Spostiamo il puntatore all'interno del flusso del file sul primo byte successivo all'header del file wav, per caricare tutti i dati audio grezzi:
 Seek #fl, d + 7
 iwav.sonora.Read(fl, 0, Lof(fl) - (d + 7))
 
' Leggiamo il numero dei canali:
 Seek #fl, 22
 iwav.canali = Read #fl As Short
 Print "Numero canali:      "; iwav.canali
 
' Leggiamo la frequenza di campionamento dei dati audio:
 Seek #fl, 24
 iwav.frequenza = Read #fl As Integer
 Print "Frequenza campion.: "; iwav.frequenza; " hertz"
 
' Leggiamo il valore del "block align":
 Seek #fl, 32 
 iwav.block_align = Read #fl As Short
 
' Leggiamo la risoluzione bit del campionamento:
 Seek #fl, 34 
 iwav.bit = Read #fl As Short
 Print "Risoluzione:        "; iwav.bit; " bit"
 
' Calcoliamo la durata del brano audio:
 iwav.durata = (iwav.sonora.Count / iwav.block_align) / iwav.frequenza
 Print "Durata esecuzione:  "; CStr(Time(0, 0, 0, iwav.durata * 1000))
 
 fl.Close
  
End

Il seguente codice è come il precedente con la differenza che esso consente di vedere il tempo trascorso dall'inizio dell'esecuzione, ed è possibile terminare l'esecuzione del file WAV, scrivendo nell'apposito spazio inferiore della console uno o più caratteri qualsiasi e premendo il tasto "Invio" della tastiera.

Public Struct InfoWAV
  fileWAV As String
  canali As Short
  frequenza As Integer
  bit As Short
  block_align As Short
  durata As Float
  sonora As Byte[]
End Struct

Private s As String


Public Sub Main()
 
 Dim dispositivo As AlcDevice
 Dim contesto As AlcContext
 Dim src, buffer As Integer[]
 Dim err As Boolean
 Dim iw As New InfoWAV
 Dim formato As Integer
 Dim t As Date
 
' Imposta il dispositivo audio con la Classe "Alc":
 dispositivo = Alc.OpenDevice(Null)
 If IsNull(dispositivo) Then Error.Raise("Impossibile impostare il dispositivo audio !")
  
' Imposta il contesto audio con la Classe "Alc":
 contesto = Alc.CreateContext(dispositivo)
 If IsNull(contesto) Then Error.Raise("Impossibile impostare il contesto audio !")

 err = contesto.MakeCurrent()
 If err == False Then Error.Raise("Impossibile creare il contesto audio !")

 src = Al.GenSources(1)
 If IsNull(src) Then Error.Raise("Errore !")

' Imposta il buffer audio:
 buffer = Al.GenBuffers(1)
 If IsNull(buffer) Then Error.Raise("Errore !")

 iw.fileWAV = "/percorso/del/file.wav"

 datiAudio(iw)
 
 Select Case iw.canali + iw.bit
   Case 9
     formato = Al.FORMAT_MONO8
   Case 10
     formato = Al.FORMAT_STEREO8
   Case 17
     formato = Al.FORMAT_MONO16
   Case 18
     formato = Al.FORMAT_STEREO16
 End Select

' I dati audio grezzi del file wav sono caricati nel buffer audio:
 Al.BufferData(buffer[0], formato, iw.sonora.ToString(0, iw.sonora.Count), iw.sonora.Count, iw.frequenza)

' Connette il buffer audio al sorgente audio:
 Al.Sourcei(src[0], Al.BUFFER, buffer[0])

' Esegue il sorgente audio:
 Al.SourcePlay(src[0])

 t = Time

' Consente l'esecuzione per l'intera durata del brano:
 Repeat
' La funzione "Wait" è necessaria per consentire al programma di ricevere il carattere inviato dalla console con il tasto "Invio" della tastiera:
   Wait 0.001
' Scrive nello "standard output" il tempo trascorso dall'inizio dell'esecuzione del file wav:
   Write #File.Out, CStr(Time(0, 0, 0, DateDiff(t, Time, gb.Millisecond))) & "\r"
 Until (DateDiff(t, Time, gb.Millisecond) >= iw.durata * 1000) Or Not IsNull(s)
  
 Al.SourceStop(src[0])
  
' Va in chiusura:
 Al.DeleteBuffers(buffer)
 Alure.StopSource(src[0])
 Al.DeleteSources(src)
 Alc.DestroyContext(contesto)
 Alc.CloseDevice(dispositivo)
 Quit
  
End

 
Public Sub Application_Read()    ' Se riceve dallo "standard input" uno o più caratteri qualsiasi, termina l'esecuzione
  
 Input s
 
End


Private Function datiAudio(iwav As InfoWAV)
 
 Dim fl As File
 Dim d As Short
 
 Print "File wav caricato:          "; iwav.fileWAV
  
' Carica il file audio Wav:
 fl = Open iwav.fileWAV For Read

 d = InStr(File.Load(iwav.fileWAV), "data")
 
 iwav.sonora = New Byte[Lof(fl) - (d + 7)]

' Spostiamo il puntatore all'interno del flusso del file sul primo byte successivo all'header del file wav, per caricare tutti i dati audio grezzi:
 Seek #fl, d + 7
 iwav.sonora.Read(fl, 0, Lof(fl) - (d + 7))
 
' Leggiamo il numero dei canali:
 Seek #fl, 22
 iwav.canali = Read #fl As Short
 Print "Numero canali audio:        "; iwav.canali
 
' Leggiamo la frequenza di campionamento dei dati audio:
 Seek #fl, 24
 iwav.frequenza = Read #fl As Integer
 Print "Frequenza di campionamento: "; iwav.frequenza
 
' Leggiamo il valore del "block align":
 Seek #fl, 32 
 iwav.block_align = Read #fl As Short
 
' Leggiamo la risoluzione bit del campionamento:
 Seek #fl, 34 
 iwav.bit = Read #fl As Short
 Print "Risoluzione audio:          "; iwav.bit; " bit"
 
' Calcoliamo la durata del brano audio:
 iwav.durata = (iwav.sonora.Count / iwav.block_align) / iwav.frequenza
 Print "Durata esecuzione:          "; CStr(Time(0, 0, 0, iwav.durata * 1000))
 
 fl.Close
  
End

In quest'altro esempio il file audio di formato WAV sarà letto e gestito come stringa:

Private s As String


Public Sub Main()
 
 Dim per As String
 Dim d, i, campionamento, formato, durata As Integer
 Dim canali, bit As Short
 Dim disp As AlcDevice
 Dim cont As AlcContext
 Dim src, buffer As Integer[]
 Dim err As Boolean
 Dim dati As Short[]

' Estrae alcune informazioni sul file:
 per = "/percorso/del/file.wav"
 Print "Percorso del file audio:    "; per
 s = File.Load(per)
 Print "Dimensione del file:        "; Len(s); " byte"
 campionamento = Int@(s[d + 11, SizeOf(gb.Integer)])
 Print "Frequenza di campionamento: "; campionamento; " hertz"
 canali = Short@(s[d + 9, gb.Short])
 Print "Numero canali audio:        "; canali
 bit = Short@(s[d + 21, gb.Short])

 d = InStr(s, "data", 0, gb.Binary)
 Int@(s[d + 3, 4])
 Print "Totale dei soli byte audio: "; i; " byte"
 d = InStr(s, "fmt ", 0, gb.Binary)
 canali = Short@(s[d + 9, 2])
 Print "Numero canali audio:        "; canali
 campionamento = Int@(VarPtr(s) + d + 11)
 Select Case bit + canali
   Case 9
     formato = Al.FORMAT_MONO8
   Case 10
     formato = Al.FORMAT_STEREO8
   Case 17
     formato = Al.FORMAT_MONO16
   Case 18
     formato = Al.FORMAT_STEREO16
 End Select
 Print "Profondità campionamento:   "; bit; " bit"
 durata = (i * 8) / (campionamento * bit * canali)
 Print "Durata del brano audio:     "; CStr(Time(0, 0, 0, durata * 1000))

' Configura il dispositivo audio con la Classe "Alc":
 disp = Alc.OpenDevice(Null)
 If IsNull(disp) Then Error.Raise("Impossibile configurare il dispositivo audio !")

' Configura il contesto audio con la Classe "Alc":
 cont = Alc.CreateContext(disp)
 If IsNull(cont) Then Error.Raise("Impossibile configurare il contesto audio !")

 err = cont.MakeCurrent()
 If err == False Then Error.Raise("Impossibile creare il contesto audio !")

 src = Al.GenSources(1)
 If IsNull(src) Then Error.Raise("Errore !")

' Configura il buffer audio:
 buffer = Al.GenBuffers(1)
 If IsNull(buffer) Then Error.Raise("Errore !")
 
' Raccoglie i soli byte dei dati audio grezzi:
 s = Right(s, i)

' I dati audio sono caricati nel buffer audio:
 Al.BufferData(buffer[0], formato, s, i, campionamento)

' Connette il buffer audio al sorgente audio:
 Al.Sourcei(src[0], Al.BUFFER, buffer[0])

' Esegue il sorgente audio:
 Al.SourcePlay(src[0])

' Consente l'esecuzione per l'intera durata dell'onda sonora:
 Wait durata

 Al.SourceStop(src[0])
 
' Libera la memoria:
 Al.DeleteBuffers(buffer)
 Alure.StopSource(src[0])
 Al.DeleteSources(src)
 Alc.DestroyContext(cont)
 Alc.CloseDevice(disp)
  
End

Note

[1] La Classe Alure del componente gb.openal consente di gestire le funzioni di ALURE, che è una libreria di supporto di Openal.