C/C++ - Scrivere e leggere punti di loop in un file WAV

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? 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.

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.

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:

001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // "roba" che c'è tra qui
007: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // e il byte #020? Mistero
008: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
009: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
010: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
011: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
012: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
013: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
014: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
015: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
016: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
017: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
018: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
019: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
020: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // si ripete esattamente la
023: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // stessa "roba" misteriosa
024: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
025: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
026: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
027: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
028: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
029: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
030: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
031: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
032: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
033: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
034: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
035: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
036: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //

037: ''              // Da qui fino al byte #052
038: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // ancora la stessa quantita'
039: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // di byte, il primo dei quali
040: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // e' pero' '' anziche' '<'
                       //
041: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
042: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
043: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
044: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
045: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
046: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
047: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
048: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
049: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
050: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
051: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
052: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
' // rappresenta il
056: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
' // che rappresenta
060: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
' // il loop point end

061: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // 8 byte azzerati?
062: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // a che scopo sono li'?
063: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
064: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
065: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
066: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
067: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
068: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // ...e questi
075: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // 4 byte? boh!
076: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
' //

085: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // a seguire, ben 24 byte
086: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // azzerati: che ci fa tutta
087: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // questa "roba" apparentemente
088: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // inutile IN CODA al file?
                       //
089: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
090: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
091: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
092: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
093: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
094: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
095: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
096: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
097: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
098: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
099: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
100: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
101: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
102: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
103: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
104: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
105: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
106: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
107: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
108: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //

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

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // ...e questi
075: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // 4 byte? boh!
076: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
' //

085: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // a seguire, ben 24 byte
086: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // azzerati: che ci fa tutta
087: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // questa "roba" apparentemente
088: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              // inutile IN CODA al file?
                       //
089: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
090: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
091: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
092: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
093: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
094: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
095: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
096: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
097: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
098: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
099: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
100: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
101: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
102: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
103: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
104: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
                       //
105: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
106: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
107: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //
108: '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:



001: 's'  // questi 4 byte sono
002: 'm'  // chiaramente un ID
003: 'p'  // che sta per "sample"
004: 'l'  // ma perche' sono qui?

005: '<'  // ASCII 60  // Cosa sarà mai tutta la
006: '{parsed_message}'              // "roba" che c'è tra qui
007: '{parsed_message}'              // e il byte #020? Mistero
008: '{parsed_message}'              //
                       //
009: '{parsed_message}'              //
010: '{parsed_message}'              //
011: '{parsed_message}'              //
012: '{parsed_message}'              //
                       //
013: '{parsed_message}'              //
014: '{parsed_message}'              //
015: '{parsed_message}'              //
016: '{parsed_message}'              //
                       //
017: '{parsed_message}'              //
018: '{parsed_message}'              //
019: '{parsed_message}'              //
020: '{parsed_message}'              //

021: '<'  // ASCII 60  // Da qui fino al byte #036
022: '{parsed_message}'              // si ripete esattamente la
023: '{parsed_message}'              // stessa "roba" misteriosa
024: '{parsed_message}'              //
                       //
025: '{parsed_message}'              //
026: '{parsed_message}'              //
027: '{parsed_message}'              //
028: '{parsed_message}'              //
                       //
029: '{parsed_message}'              //
030: '{parsed_message}'              //
031: '{parsed_message}'              //
032: '{parsed_message}'              //
                       //
033: '{parsed_message}'              //
034: '{parsed_message}'              //
035: '{parsed_message}'              //
036: '{parsed_message}'              //

037: ''              // Da qui fino al byte #052
038: '{parsed_message}'              // ancora la stessa quantita'
039: '{parsed_message}'              // di byte, il primo dei quali
040: '{parsed_message}'              // e' pero' '' anziche' '<'
                       //
041: '{parsed_message}'              //
042: '{parsed_message}'              //
043: '{parsed_message}'              //
044: '{parsed_message}'              //
                       //
045: '{parsed_message}'              //
046: '{parsed_message}'              //
047: '{parsed_message}'              //
048: '{parsed_message}'              //
                       //
049: '{parsed_message}'              //
050: '{parsed_message}'              //
051: '{parsed_message}'              //
052: '{parsed_message}'              //

053: '€'  // questi 4 byte
054: '&'  // sono un DWORD che
055: '{parsed_message}' // rappresenta il
056: '{parsed_message}' // loop point start

057: 'æ'  // questi 4 byte
058: 'ª'  // sono un DWORD
059: '{parsed_message}' // che rappresenta
060: '{parsed_message}' // il loop point end

061: '{parsed_message}'              // 8 byte azzerati?
062: '{parsed_message}'              // a che scopo sono li'?
063: '{parsed_message}'              //
064: '{parsed_message}'              //
                       //
065: '{parsed_message}'              //
066: '{parsed_message}'              //
067: '{parsed_message}'              //
068: '{parsed_message}'              //

069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere una
071: 'U'  // specie di ID del programma (Wavosaur)
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //




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



069: 'S'  //
070: 'A'  // questi 4 byte sembrano essere
071: 'U'  // una specie di ID del programma
072: 'R'  //

073: ' '               //
074: '{parsed_message}'              // ...e questi
075: '{parsed_message}'              // 4 byte? boh!
076: '{parsed_message}'              //

077: '1'  //
078: '.'  //
079: '3'  // questi 8 byte sembrano
080: '.'  // essere una stringa che
081: '0'  // descrive la versione
082: '.'  // del programma
083: '0'  //
084: '{parsed_message}' //

085: '{parsed_message}'              // a seguire, ben 24 byte
086: '{parsed_message}'              // azzerati: che ci fa tutta
087: '{parsed_message}'              // questa "roba" apparentemente
088: '{parsed_message}'              // inutile IN CODA al file?
                       //
089: '{parsed_message}'              //
090: '{parsed_message}'              //
091: '{parsed_message}'              //
092: '{parsed_message}'              //
                       //
093: '{parsed_message}'              //
094: '{parsed_message}'              //
095: '{parsed_message}'              //
096: '{parsed_message}'              //
                       //
097: '{parsed_message}'              //
098: '{parsed_message}'              //
099: '{parsed_message}'              //
100: '{parsed_message}'              //
                       //
101: '{parsed_message}'              //
102: '{parsed_message}'              //
103: '{parsed_message}'              //
104: '{parsed_message}'              //
                       //
105: '{parsed_message}'              //
106: '{parsed_message}'              //
107: '{parsed_message}'              //
108: '{parsed_message}'              //
'              //

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.

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'...

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:

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.