code de forme d'onde .. ..J'ai besoin d'aide ... s'il vous plaît

Question

Pouvez-vous s'il vous plaît, expliquez-moi (en mots) ce que fait ce code? merci

Mes préoccupations sont en fait ces deux parties: 1)

double y_new = (double) (h * (128 - my_byte)/256); 
lines.add(new Line2D.Double(x, y_last, x, y_new)); 
y_last = y_new; 

2) la boucle, je dont'understand ... c'est 32768? my_byte?

 int numChannels = format.getChannels(); 
     for (double x = 0; x < w && audioData != null; x++) { 

     int idx = (int) (frames_per_pixel * numChannels * x); 
     // se a 8 bit è immediato 
     if (format.getSampleSizeInBits() == 8) { 
      my_byte = (byte) audioData[idx]; 
     } else { 
      my_byte = (byte) (128 * audioData[idx]/32768); 

Voici le code. Elle a été prise à partir d'ici: http://www.koders.com/java/fid3508156A13C80A263E7CE65C4C9D6F5D8651AF5D.aspx?s=%22David+Anderson%22 (classe d'échantillonnage Graphique)

 int frames_per_pixel = audioBytes.size()/format.getFrameSize()/w; 
     byte my_byte = 0; 
     double y_last = 0; 
     int numChannels = format.getChannels(); 
     for (double x = 0; x < w && audioData != null; x++) { 
     // scegli quale byte visualizzare 
     int idx = (int) (frames_per_pixel * numChannels * x); 
     // se a 8 bit è immediato 
     if (format.getSampleSizeInBits() == 8) { 
      my_byte = (byte) audioData[idx]; 
     } else { 

      my_byte = (byte) (128 * audioData[idx]/32768); 
     } 

     double y_new = (double) (h * (128 - my_byte)/256); 
     lines.add(new Line2D.Double(x, y_last, x, y_new)); 
     y_last = y_new; 
     } 

     repaint(); 

Answer 1

Je ne sais pas si ça aide, mais

128 * someInt/32768 

est le même que

someInt <<7>> 15 

Answer 2

Vous devriez à la première place apprendre comment un fichier sonore est organisé. Mais de toute façon ..

double y_new = (double) (h * (128 - my_byte)/256); 
     lines.add(new Line2D.Double(x, y_last, x, y_new)); 
     y_last = y_new; 

Les positions Y des lignes que dessine cet exemple représentent les valeurs d'échantillon du fichier son. Comme vous le savez peut-être un échantillon peut être 8/16/32 ... bit. Dans cet exemple, ils redimensionnent toutes les valeurs binaires à 8 (1 octet). Le ne Y aura son centre dans la position médiane de l'écran (c'est un fichier son signé). h est la hauteur de l'écran - nous voulons l'échelle comme si 127 est le haut de l'écran et -127 le pixel inférieur de l'écran. 2) 32768 est la valeur maximale d'un entier signé de 16 bits. Ainsi, la valeur d'échantillon maximale pour un fichier audio de 16 bits. myByte: un fichier son est enregistré en tant que flux d'octets. Donc, si vous utilisez des échantillons 16 bits, vous devrez créer votre entier (16 bits, 32bin en Java) à partir des 2 octets de l'écran. Dans cet exemple, ils ne fonctionnent qu'avec des échantillons de données 8bit, donc si cet exemple lit un fichier audio 16bit, il vous permet de convertir les valeurs d'échantillon à 8 bits dans cette ligne:

my_byte = (byte) (128 * audioData[idx]/32768); 

Donc, mon octet contient la valeur de l'échantillon de cadre " idx ".

Answer 3

double y_new = (double) (h * (128 - my_byte)/256); 

Cette ligne de code fait partie d'un procédé pour tracer une séquence d'octets sur une « fenêtres » (rectangle, le système de coordonnées, que vous le souhaitez)

h  := the height of the drawable area in pixel 
my_byte := a byte [-128,127] (a 8 bit sample from an audio file?) 

(128 - my_byte) convertit l'entrée [-128,127] à [256, 1]. La division par 256 transforme cette gamme de [1, 1/256] et en multipliant la hauteur h résultats dans l'application prévue de [-128,127] ->[~0,h]

Ce qui suit sont des lignes pour tracer une ligne depuis le point représentant l'octet précédent au point courant. Le point réel deviendra alors le point précédent pour l'itération suivante.

---

my_byte = (byte) (128 * audioData[idx]/32768); 

Cette ligne de code est d'exécuter si la taille de l'échantillon est de 16 bits. Mais nous avons besoin d'une valeur 8Bit juste pour le traçage.Un int en Java est de 32 bits, nous avons un échantillon de 16 bits, donc les 16 bits supérieurs sont 0, les 16 bits inférieurs stockent la valeur d'échantillon audio. L'algorithme se déplace maintenant la valeur 7 positions à gauche, puis 15 à droite:

00000000 00000000 11111111 11111111 
-> 00000000 01111111 11111111 10000000 // * 128, << 7 
-> 00000000 00000000 00000000 11111111 // : 32768, >> 15 

Honnêtement, je ne sais pas pourquoi l'auteur n'a pas seulement diviser par 256 fois, qui devrait donner le même résultat.

Mais de toute façon - le résultat est un octet qui représente les huit bits les plus significatifs de l'échantillon. Soit dit en passant, assez inexact, parce que si vous avez un enregistrement 16 bits très calme, vous ne verrez rien sur le panneau de vagues.