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: 461
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


Ma cosa vuoi che ne sappia? Io ci gioco, col codice, mica ci lavoro!
PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 461
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.


Ma cosa vuoi che ne sappia? Io ci gioco, col codice, mica ci lavoro!
PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 461
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'              //



Ma cosa vuoi che ne sappia? Io ci gioco, col codice, mica ci lavoro!
PM Quote
Avatar
AldoBaldo (Member)
Expert


Messaggi: 461
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.


Ma cosa vuoi che ne sappia? Io ci gioco, col codice, mica ci lavoro!
PM Quote