Javascript Tableaux Typés et Endianness

Je suis en utilisant WebGL pour rendre un binaire codé fichier de maillage. Le fichier binaire est écrit en format big-endian (je peux le vérifier en ouvrant le fichier dans un éditeur hexadécimal, ou de visualiser le trafic réseau à l'aide de fiddler). Lorsque je tente de lire la réponse binaire à l'aide d'un Float32Array ou Int32Array, le binaire est interprété comme little-endian et de mes valeurs sont fausses:

//Interpret first 32bits in buffer as an int
var wrongValue = new Int32Array(binaryArrayBuffer)[0];

Je ne trouve pas de références à la valeur par défaut boutisme de tableaux typés dans http://www.khronos.org/registry/typedarray/specs/latest/ alors je me demandais quel est le problème? Dois-je supposer que toutes les données binaires doivent être little-endian lors de la lecture à l'aide de tableaux typés?

Pour contourner le problème, je peux utiliser un objet DataView (voir le lien précédent) et de l'appeler:

//Interpret first 32bits in buffer as an int
var correctValue = new DataView(binaryArrayBuffer).getInt32(0);

Le DataView des fonctions telles que "getInt32" lire big-endian valeurs par défaut.

(Note: j'ai testé avec Google Chrome 15 et Firefox 8 et ils se comportent de la même manière)

  • Dans le cas où certains se poseraient la question, je pense que la réponse est qu'il faut que j'écrive mon fichier à l'aide de little-endian.
  • Qui a appelé à éviter le problème au lieu de le combler.
InformationsquelleAutor Bob | 2011-10-23
  1. 61

    Le comportement actuel, un peu tristement, c'est que l'endianness, c'est que du matériel sous-jacent. Comme presque tous les ordinateurs de bureau sont x86, ce qui signifie little-endian. La plupart des BRAS de Systèmes d'exploitation little-endian mode (les processeurs ARM sont bi-endian et peut donc fonctionner en mode).

    La raison pour laquelle c'est un peu triste, c'est le fait que cela signifie que presque personne ne va vérifier qu'un code fonctionne sur big-endian matériel, mal ce qu'elle fait, et le fait que l'ensemble de la plate-forme web a été conçu autour du code de travail de façon uniforme à travers les implémentations et les plates-formes, ce qui les sauts de.

    • Quelque part, je pensais que ce serait le cas.
    • Il n'est pas malheureux du tout. Tableaux typés suivez la plate-forme de l'endianness parce que nous les utiliser pour interagir avec les Api natives, qui œuvre dans la plate-forme de stockage. Si les tableaux typés avait une endianness, nous perdions un énorme montant de la prestation d'utilisation (sur les plates-formes qui ne s'est pas produit pour correspondre au boutisme qui a été choisi). Pour les situations comme l'OP, où il y a un fichier en question (ou pour interagir avec les différents protocoles qui définissent un spécifique endian ordre, tels que TCP, etc.), c'est ce que DataView est pour.
    • Il y a certainement une utilisation pour la machine-boutisme, mais le plus grand problème est que la majorité de l'usage que nous en voyons des tableaux typés sur le web n'ont pas besoin de s'inquiéter à propos de la sous-jacentes de la machine endianness, et si vous ne compter sur la machine de l'endianness il est très probable à cassé sur big endian les systèmes (étant donné environ personne n'aura testé leur JS sur une). (Note que je travaillais à l'Opéra à l'époque, j'ai écrit ci-dessus, qui, probablement, à ce jour compte pour la majorité des navigateurs, livré en big-endian systèmes).
    • Eh bien, je ne peux pas prétendre avoir une profonde familiarité avec le sujet, mais la revendication de ceux qui travaillent sur ce dès le début du développement de ce genre de choses par le biais de la mise en œuvre a été que l'utilisation de la machine boutisme dans les tableaux typés était important pour l'interopérabilité avec les Api natives, ce qui semble solide pour moi. Je vais faire confiance à ce que les nombreuses et diverses personnes impliquées qui ont cette connaissance profonde n'a pas seulement collectivement se tromper. 🙂
    • Rappelez-vous tableaux typés ont grandi hors de WebGL (où oui, la machine endianness est utile), plutôt que d'une proposition distincte. Par le moment, il a commencé à s'habituer à l'extérieur de WebGL, presque entièrement dans les endroits où l'endianness n'a pas d'importance, le chat est sorti du sac avec la valeur par défaut de la machine boutisme. Fondamentalement, étant donné que personne ne les essais sur big-endian systèmes, soit vous vous cassez la plupart des WebGL cas swap (endianness lors du passage à la GL de mise en œuvre, qui, je crois, est ce que les navigateurs en fait, ne), ou de briser la plupart des non-WebGL cas.
    • Citation "quels sont les navigateurs en fait le faire"? Bien que je suppose qu'il n'a pas vraiment d'importance, c'est ce qu'elle est, et les gens vont penser que c'est de la chance ou non en fonction de ce qu'ils utilisent pour...

    InformationsquelleAutor gsnedders
  2. 26

    Prises à partir d'ici http://www.khronos.org/registry/typedarray/specs/latest/ (quand celui-spec est pleinement mis en œuvre), vous pouvez utiliser:

    new DataView(binaryArrayBuffer).getInt32(0, true) //For little endian
new DataView(binaryArrayBuffer).getInt32(0, false) //For big endian

    Toutefois, si vous ne pouvez pas utiliser ceux de la méthode, car ils ne sont pas mis en œuvre, vous pouvez toujours vérifier le dossier de la magie de la valeur (presque tous les formats a une valeur magique) sur l'en-tête afin de voir si vous devez inverser en fonction de vos endiannes.

    Aussi, vous pouvez enregistrer endiannes fichiers spécifiques sur votre serveur et de les utiliser en conséquence à la détection de l'hôte endiannes.

    • Hm c'est une bonne idée! J'ai été en utilisant DataView avant, mais seulement Chrome prend en charge pour le moment.
    • Tout comme un suivi, je me suis mise en œuvre de mes propres binaires écrivain sur le JavaScript, et il semble fonctionner sur firefox et chrome.
    InformationsquelleAutor Chiguireitor
  3. 26

    Pour info, vous pouvez utiliser la fonction javascript suivante pour déterminer le boutisme de la machine, après quoi vous pourrez passer un bon format de fichier pour le client (vous pouvez stocker des deux versions du fichier sur le serveur, big endian et little endian):

    function checkEndian() {
    var arrayBuffer = new ArrayBuffer(2);
    var uint8Array = new Uint8Array(arrayBuffer);
    var uint16array = new Uint16Array(arrayBuffer);
    uint8Array[0] = 0xAA; //set first byte
    uint8Array[1] = 0xBB; //set second byte
    if(uint16array[0] === 0xBBAA) return "little endian";
    if(uint16array[0] === 0xAABB) return "big endian";
    else throw new Error("Something crazy just happened");
}

    Dans votre cas, vous devrez probablement soit de recréer le fichier en little endian, ou courir à travers l'ensemble de la structure de données pour la rendre little-endian. À l'aide d'une torsion de la méthode ci-dessus, vous pouvez échanger les endianness à la volée (pas vraiment recommandé et n'a de sens que si l'ensemble de la structure est la même serrées types, en réalité, vous pouvez créer un talon de fonction que les swaps d'octets en tant que de besoin):

    function swapBytes(buf, size) {
    var bytes = new Uint8Array(buf);
    var len = bytes.length;
    var holder;

    if (size == 'WORD') {
        //16 bit
        for (var i = 0; i<len; i+=2) {
            holder = bytes[i];
            bytes[i] = bytes[i+1];
            bytes[i+1] = holder;
        }
    } else if (size == 'DWORD') {
        //32 bit
        for (var i = 0; i<len; i+=4) {
            holder = bytes[i];
            bytes[i] = bytes[i+3];
            bytes[i+3] = holder;
            holder = bytes[i+1];
            bytes[i+1] = bytes[i+2];
            bytes[i+2] = holder;
        }
    }
}
    • Nice one! J'ai juste ajouté new et return bytes; à votre code. Ces ateliers ont permis de rendre le code à exécuter pour moi. Merci.
    • En fait le retour n'était pas nécessaire que la mémoire tampon est échangé.
    • texte de remplissage juste pour ce faire: 😀
    • pourquoi utilisez-vous le 4 octets au lieu de 2?
    • cela est dû à 32 bits, par exemple un Uint32ArrayBuffer
    • ouais, mais Uint16Array pourrait avoir été utilisé
    • Dépend de l'objectif. Dans mon cas, je n'ai besoin de la mémoire tampon échangé pour un Uint32ArrayBuffer. Parce que Uint32Array de l'utilisation de vos machines endianness, comme le mien est en Little Endian et je n'ai besoin de l'avoir en Big Endian, ainsi PNG est codée en tant que ÊTRE. Si vous avez utilisé WORD, vous auriez désordre de la mémoire tampon. Parce que tu voudrais permuter tous les deux octets, au lieu de quatre octets de l'inversion de l'ordre
    • non, je parlais de checkEndian fonction. Endianess fonctionne sur des octets, de sorte que deux octets doit être suffisante pour déterminer si l'ordre est le même, non? D'où la question pourquoi utiliser 4 pour déterminer quand les 2 ont été utilisé?
    • jep, vous avez entièrement raison sur cette! Un Uint16Array est tout à fait satisfaisant
    • excellent, je voulais juste confirmer que. Merci pour vous commentaires 🙂

    InformationsquelleAutor Ryan
  4. 15

    Les autres réponses semblent un peu vieillot pour moi, donc voici un lien vers le dernier spec:

    http://www.khronos.org/registry/typedarray/specs/latest/#2.1

    En particulier:

    Le tableau typé afficher les types de fonctionner avec le boutisme de l'ordinateur hôte.

    Le DataView type opère sur les données avec un certain endianness (big-endian ou little-endian).

    Donc, si vous voulez lire/écrire des données dans des Big Endian (Network Byte Order), voir:
    http://www.khronos.org/registry/typedarray/specs/latest/#DATAVIEW

    //For multi-byte values, the optional littleEndian argument
//indicates whether a big-endian or little-endian value should be
//read. If false or undefined, a big-endian value is read.
    • "Si elle est fausse ou non, un big-endian valeur est lue." - tout m'a coûté quelques heures ou ma vie.
    InformationsquelleAutor user1338062
  5. 5

    Moyen rapide de vérifier l'endianness

    /** @returns {Boolean} true if system is big endian */
function isBigEndian() {
    const array = new Uint8Array(4);
    const view = new Uint32Array(array.buffer);
    return !((view[0] = 1) & array[0]);
}

    Comment cela fonctionne:

    • un tableau de 4 octets est créé;
    • une version 32 bits de vue enveloppe la matrice;
    • view[0] = 1 définit le tableau pour 32-bit de valeur 1;
    • maintenant vient la partie importante: si le système est en big endian, que 1 est en cours par le plus à droite de l'octet (le petit dernier); si elle est en little endian, c'est l'octet le plus à qui stocke (peu de vient en premier). Donc en faisant un bit à bit ET avec l'octet le plus retourne false si la machine est en big endian;
    • la fonction enfin la convertit en une valeur booléenne par l'application de la ! exploitant à la suite de la & opération, tout en l'inversant de sorte qu'elle retourne vrai pour big endian.
    InformationsquelleAutor Lucio Paiva