Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Scrivere e leggere punti di loop in un file WAV
Forum - C/C++ - Scrivere e leggere punti di loop in un file WAV

Avatar
AldoBaldo (Member)
Expert


Messaggi: 543
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 9:32
Venerdì, 20/03/2020
Ciao a tutti. Ho una domanda difficilissima (per me). Ho cercato le informazioni sul web in tutti i modi che mi sono venuti in mente senza venire a capo di niente.

La finalità è: trovare un modo per leggere i punti di loop eventualmente inglobati in un file WAV monofonico.

Quel che so già fare è: scandagliare l'header di un file WAV standard (in merito al quale ho la documentazione); trovare il punto d'inizio dei dati audio veri e propri; leggere i dati audio dal file.

Quel che vorrei sapere è: dove e come vengono memorizzati nel file (sicuramente nell'header WAV) i punti di loop? Ad esempio, dove li mette un programma come Wavosaur? https://www.wavosaur.com/

Se mi sapete (e volete) dare una risposta mi evitate di dover passare ore a fare esperimenti e tentativi, rischiando per di più di ottenere risposte che riguardano casi particolari e non lo standard in generale. Un metodo per prove e tentativi che potrei usare sarebbe salvare con Wavosaur uno stesso suono nello stesso formato, con e senza punti di loop, per poi confrontare gli header dei due file risultanti... Potrebbe essere divertente, ma non so quanto sarebbe affidabile.

Ultima modifica effettuata da AldoBaldo il 20/03/2020 alle 9:33


ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 543
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 9:53
Sabato, 21/03/2020
Sto tentando la strada "autonoma".
Descrivo il procedimento (chissà che ispiri qualche risposta).
Con Audacity o creato un piccolo file WAV mono a 16 bit, frequenza di campionamento a 44100Hz.
Il file contiene un'onda sinusoidale con la classica frequenza del LA a 440Hz, durata 1 secondo.

Con Wavosaur ho aperto il file.
"Salva come..." e l'ho sovrascritto con quel programma.
Ho aggiunto due punti di loop in posizioni scelte senza troppi pensieri.
"Salva come..." e ho scritto un secondo file, identico al primo se non per i punti di loop aggiunti.

Speranzoso di trovarci delle differenze, ho "letto" entrambi gli header WAV.
Nessuna differenza. Le informazioni non sono lì. [1]

Ho provato a confrontare i byte successivi agli header, sperando di trovarli immediatamente diversi (sarebbe stato il segno che in qualche modo i due punti di loop erano stati aggiunti appena in coda all'header WAV). Speranza delusa. Le differenze si presentano MOLTO più avanti, apparentemente già nell'area dei dati della sinusoide. (?!?)

In mancanza di suggerimenti da parte vostra, proseguirò le mie "indagini".

[1] Mentre scrivo, mi viene in mente che il formato WAV prevede la possibilità di estendere l'header... devo rivedere questo punto.


ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 543
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 12:16
Domenica, 22/03/2020
Oh, terza puntata di questo seguitissimo soliloquio che sta attizzando la fantasia di mezza Italia.

Ho trovato quel che cercavo in un posto dove proprio non mi aspettavo di trovarlo: in coda ai dati audio.
Il fatto è che lì ho trovato anche una quantità di "roba" che non ho idea di cosa possa rappresentare.

Ecco cosa ho trovato in fondo al file audio che incorpora i punti di loop:

Codice sorgente - presumibilmente C/C++

  1. 001: 's'  // questi 4 byte sono
  2. 002: 'm'  // chiaramente un ID
  3. 003: 'p'  // che sta per "sample"
  4. 004: 'l'  // ma perche' sono qui?
  5.  
  6. 005: '<'  // ASCII 60  // Cosa sarà mai tutta la
  7. 006: '\0'              // "roba" che c'è tra qui
  8. 007: '\0'              // e il byte #020? Mistero
  9. 008: '\0'              //
  10.                        //
  11. 009: '\0'              //
  12. 010: '\0'              //
  13. 011: '\0'              //
  14. 012: '\0'              //
  15.                        //
  16. 013: '\0'              //
  17. 014: '\0'              //
  18. 015: '\0'              //
  19. 016: '\0'              //
  20.                        //
  21. 017: '\0'              //
  22. 018: '\0'              //
  23. 019: '\0'              //
  24. 020: '\0'              //
  25.  
  26. 021: '<'  // ASCII 60  // Da qui fino al byte #036
  27. 022: '\0'              // si ripete esattamente la
  28. 023: '\0'              // stessa "roba" misteriosa
  29. 024: '\0'              //
  30.                        //
  31. 025: '\0'              //
  32. 026: '\0'              //
  33. 027: '\0'              //
  34. 028: '\0'              //
  35.                        //
  36. 029: '\0'              //
  37. 030: '\0'              //
  38. 031: '\0'              //
  39. 032: '\0'              //
  40.                        //
  41. 033: '\0'              //
  42. 034: '\0'              //
  43. 035: '\0'              //
  44. 036: '\0'              //
  45.  
  46. 037: '\1'              // Da qui fino al byte #052
  47. 038: '\0'              // ancora la stessa quantita'
  48. 039: '\0'              // di byte, il primo dei quali
  49. 040: '\0'              // e' pero' '\1' anziche' '<'
  50.                        //
  51. 041: '\0'              //
  52. 042: '\0'              //
  53. 043: '\0'              //
  54. 044: '\0'              //
  55.                        //
  56. 045: '\0'              //
  57. 046: '\0'              //
  58. 047: '\0'              //
  59. 048: '\0'              //
  60.                        //
  61. 049: '\0'              //
  62. 050: '\0'              //
  63. 051: '\0'              //
  64. 052: '\0'              //
  65.  
  66. 053: '€'  // questi 4 byte
  67. 054: '&'  // sono un DWORD che
  68. 055: '\0' // rappresenta il
  69. 056: '\0' // loop point start
  70.  
  71. 057: 'æ'  // questi 4 byte
  72. 058: 'ª'  // sono un DWORD
  73. 059: '\0' // che rappresenta
  74. 060: '\0' // il loop point end
  75.  
  76. 061: '\0'              // 8 byte azzerati?
  77. 062: '\0'              // a che scopo sono li'?
  78. 063: '\0'              //
  79. 064: '\0'              //
  80.                        //
  81. 065: '\0'              //
  82. 066: '\0'              //
  83. 067: '\0'              //
  84. 068: '\0'              //
  85.  
  86. 069: 'S'  //
  87. 070: 'A'  // questi 4 byte sembrano essere una
  88. 071: 'U'  // specie di ID del programma (Wavosaur)
  89. 072: 'R'  //
  90.  
  91. 073: ' '               //
  92. 074: '\0'              // ...e questi
  93. 075: '\0'              // 4 byte? boh!
  94. 076: '\0'              //
  95.  
  96. 077: '1'  //
  97. 078: '.'  //
  98. 079: '3'  // questi 8 byte sembrano
  99. 080: '.'  // essere una stringa che
  100. 081: '0'  // descrive la versione
  101. 082: '.'  // del programma
  102. 083: '0'  //
  103. 084: '\0' //
  104.  
  105. 085: '\0'              // a seguire, ben 24 byte
  106. 086: '\0'              // azzerati: che ci fa tutta
  107. 087: '\0'              // questa "roba" apparentemente
  108. 088: '\0'              // inutile IN CODA al file?
  109.                        //
  110. 089: '\0'              //
  111. 090: '\0'              //
  112. 091: '\0'              //
  113. 092: '\0'              //
  114.                        //
  115. 093: '\0'              //
  116. 094: '\0'              //
  117. 095: '\0'              //
  118. 096: '\0'              //
  119.                        //
  120. 097: '\0'              //
  121. 098: '\0'              //
  122. 099: '\0'              //
  123. 100: '\0'              //
  124.                        //
  125. 101: '\0'              //
  126. 102: '\0'              //
  127. 103: '\0'              //
  128. 104: '\0'              //
  129.                        //
  130. 105: '\0'              //
  131. 106: '\0'              //
  132. 107: '\0'              //
  133. 108: '\0'              //



Ed ecco cosa ho trovato in fondo al file nel quale non ho inserito i punti di loop:

Codice sorgente - presumibilmente C/C++

  1. 069: 'S'  //
  2. 070: 'A'  // questi 4 byte sembrano essere
  3. 071: 'U'  // una specie di ID del programma
  4. 072: 'R'  //
  5.  
  6. 073: ' '               //
  7. 074: '\0'              // ...e questi
  8. 075: '\0'              // 4 byte? boh!
  9. 076: '\0'              //
  10.  
  11. 077: '1'  //
  12. 078: '.'  //
  13. 079: '3'  // questi 8 byte sembrano
  14. 080: '.'  // essere una stringa che
  15. 081: '0'  // descrive la versione
  16. 082: '.'  // del programma
  17. 083: '0'  //
  18. 084: '\0' //
  19.  
  20. 085: '\0'              // a seguire, ben 24 byte
  21. 086: '\0'              // azzerati: che ci fa tutta
  22. 087: '\0'              // questa "roba" apparentemente
  23. 088: '\0'              // inutile IN CODA al file?
  24.                        //
  25. 089: '\0'              //
  26. 090: '\0'              //
  27. 091: '\0'              //
  28. 092: '\0'              //
  29.                        //
  30. 093: '\0'              //
  31. 094: '\0'              //
  32. 095: '\0'              //
  33. 096: '\0'              //
  34.                        //
  35. 097: '\0'              //
  36. 098: '\0'              //
  37. 099: '\0'              //
  38. 100: '\0'              //
  39.                        //
  40. 101: '\0'              //
  41. 102: '\0'              //
  42. 103: '\0'              //
  43. 104: '\0'              //
  44.                        //
  45. 105: '\0'              //
  46. 106: '\0'              //
  47. 107: '\0'              //
  48. 108: '\0'              //



ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 543
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 14:21
Giovedì, 26/03/2020
Insistendo (quando ho tempo) nelle mie ricerche, ho scoperto che anche Audacity, nell'esportare i dati audio in formato WAV, aggiunge TALORA dati "misteriosi" DOPO la sezione del file dedicata a quelli puramente riferiti all'onda sonora. Nel caso specifico, sono dati che si riferiscono a cose tipo autore, titolo, data, commenti vari... L'organizzazione pare essere simile nella tipologia, ma non uniforme nella disposizione dei dati; pressoché sempre:

1) ======
4 byte (che possono mancare) occupati da una sequenza di caratteri, tipo un id

2) ======
4 byte (apparentemente sempre presenti) che contengono un valore che rappresenta la quantità dei byte occupati successivamente

3) ======
una serie di byte in quantità equivalente a quanti indicato dai 4 byte precedenti, che possono contenere qualsiasi cosa (finora ho trovato più che altro stringhe di caratteri)

Il modello può essere ripetuto un numero variabile di volte, ma mantiene la stessa organizzazione generica.

Non sono riuscito a capire se esiste un segnalatore di fine file o se ci si limiti a considerare che i dati terminano quando si arriva a EOF e finita lì (esplorerò ancora, appena avrò tempo).

Trovo curioso che si aggiungano dati "accessori" DOPO il corpo dei dati principali (i dati della forma d'onda). Me li sarei aspettati in coda all'header, subito prima dei dati principali.


ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 543
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 21:37
Sabato, 28/03/2020
Ieri sera ho fatto una scoperta importante. I più informati tra voi penseranno "accidenti, quanto sei tordo!". Eh, pensatelo pure, ma per me tanto ovvio non è: nelle mie ricerche avrei dovuto usare la parola chiave "metadata". Infatti quel che si trova in un file WAV dopo la serie dei dati riferiti alla forma d'onda rientra nella categoria dei "metadata".

La brutta notizia è che pare non esistere un vero e proprio standard in base al quale quei "metadata" vengono aggiunti in coda, e che gli stessi punti di loop vengono inseriti in più di un modo a seconda delle scelte dei vari sviluppatori. Insomma, non esiste quello standard che speravo di scoprire.

Quel che è incoraggiante, invece, è che la mia perplessità, se non altro, aveva valide ragioni di essere. Va be'...

Ultima modifica effettuata da AldoBaldo il 28/03/2020 alle 21:39


ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 543
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 19:31
Mercoledì, 01/04/2020
A rilento per via del carico di lavoro aggiuntivo determinato dal dover gestire quella vaccata della "didattica a distanza", ma sto continuando imperterrito a cercare informazioni per quel programmino che ho in mente per aggiungere o modificare i punti di loop di un file WAV. Questa volta scrivo perché, girovagando, ho scoperto un programmino "furbo" del quale vorrei segnalare l'esistenza, dal momento che si sta rivelando MOLTO utile per certe mie attività di creazione di strumenti campionati in formato .sfz.

Il programma è questo:

http://loopauditioneer.sourceforge.net/

Se vi occupate di creare file audio in loop per strumenti campionati e ancora non lo conoscete, vale la pena darci un'occhiata.

Ultima modifica effettuata da AldoBaldo il 01/04/2020 alle 19:32


ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
PM Quote