user/src/com/google/gwt/typedarrays/client/DataViewNativeEmul.java

/*
 * Copyright 2012 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.typedarrays.client;

import com.google.gwt.typedarrays.shared.ArrayBuffer;
import com.google.gwt.typedarrays.shared.DataView;
import com.google.gwt.typedarrays.shared.Float32Array;
import com.google.gwt.typedarrays.shared.Float64Array;
import com.google.gwt.typedarrays.shared.Int16Array;
import com.google.gwt.typedarrays.shared.Int32Array;
import com.google.gwt.typedarrays.shared.Uint16Array;
import com.google.gwt.typedarrays.shared.Uint32Array;

/**
 * JS native implementation of {@link DataView} for platforms with typed array
 * support but missing DataView (ie, Firefox).
 */
public class DataViewNativeEmul implements DataView {

  private static final boolean nativeLittleEndian;

  static {
    nativeLittleEndian = isNativeLittleEndian();
  }

  /**
   * @param buffer
   * @param byteOffset
   * @param byteLength
   * @return a {@link DataView} instance
   */
  public static DataView create(ArrayBuffer buffer, int byteOffset,
      int byteLength) {
    return new DataViewNativeEmul(buffer, byteOffset, byteLength);
  }

  /**
   * @return true if this platform's typed arrays are little-endian
   */
  private static native boolean isNativeLittleEndian() /*-{
    var i8 = new Int8Array(4);
    i8[0] = 1;
    i8[1] = 2;
    i8[2] = 3;
    i8[3] = 4;
    var i32 = new Int32Array(i8.buffer);
    // TODO(jat): do we need to check for other endianness beside BE/LE?
    return i32[0] == 0x04030201;
  }-*/;

  protected final ArrayBuffer buffer;
  protected final int bufferByteOffset;
  protected final int byteLength;
  
  /**
   * A temporary buffer used for reversing bytes.
   */
  protected final Uint8ArrayNative tempBuffer;

  /**
   * A view of the underlying buffer as bytes.
   */
  protected final Uint8ArrayNative uint8Array;

  protected DataViewNativeEmul(ArrayBuffer buffer, int byteOffset, int byteLength) {
    this.buffer = buffer;
    this.bufferByteOffset = byteOffset;
    this.byteLength = byteLength;
    tempBuffer = Uint8ArrayNative.create(ArrayBufferNative.create(8), 0, 8);
    uint8Array = Uint8ArrayNative.create(buffer, byteOffset, byteLength);
  }

  @Override
  public ArrayBuffer buffer() {
    return buffer;
  }

  @Override
  public int byteLength() {
    return byteLength;
  }

  @Override
  public int byteOffset() {
    return bufferByteOffset;
  }

  @Override
  public float getFloat32(int byteOffset) {
    return getFloat32(byteOffset, false);
  }

  @Override
  public float getFloat32(int byteOffset, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int len = Float32Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(uint8Array, ofs, len, tempBuffer, 0);
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    return Float32ArrayNative.create(buf, ofs, 1).get(0);
  }

  @Override
  public double getFloat64(int byteOffset) {
    return getFloat64(byteOffset, false);
  }

  @Override
  public double getFloat64(int byteOffset, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int len = Float64Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(uint8Array, ofs, len, tempBuffer, 0);
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    return Float64ArrayNative.create(buf, ofs, 1).get(0);
  }

  @Override
  public short getInt16(int byteOffset) {
    return getInt16(byteOffset, false);
  }

  @Override
  public short getInt16(int byteOffset, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int len = Int16Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(uint8Array, ofs, len, tempBuffer, 0);
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    return Int16ArrayNative.create(buf, ofs, 1).get(0);
  }

  @Override
  public int getInt32(int byteOffset) {
    return getInt32(byteOffset, false);
  }

  @Override
  public int getInt32(int byteOffset, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int len = Int32Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(uint8Array, ofs, len, tempBuffer, 0);
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    return Int32ArrayNative.create(buf, ofs, 1).get(0);
  }

  @Override
  public byte getInt8(int byteOffset) {
    return Int8ArrayNative.create(buffer, byteOffset, 1).get(0);
  }

  @Override
  public int getUint16(int byteOffset) {
    return getUint16(byteOffset, false);
  }

  @Override
  public int getUint16(int byteOffset, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int len = Uint16Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(uint8Array, ofs, len, tempBuffer, 0);
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    return Uint16ArrayNative.create(buf, ofs, 1).get(0);
  }

  @Override
  public long getUint32(int byteOffset) {
    return getUint32(byteOffset, false);
  }

  @Override
  public long getUint32(int byteOffset, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int len = Uint32Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(uint8Array, ofs, len, tempBuffer, 0);
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    return Uint32ArrayNative.create(buf, ofs, 1).get(0);
  }

  @Override
  public double getUint32AsDouble(int byteOffset) {
    return getUint32(byteOffset, false);
  }

  @Override
  public double getUint32AsDouble(int byteOffset, boolean littleEndian) {
    return getUint32(byteOffset, littleEndian);
  }

  @Override
  public short getUint8(int byteOffset) {
    return Uint8ArrayNative.create(buffer, byteOffset, 1).get(0);
  }

  @Override
  public void setFloat32(int byteOffset, float value) {
    setFloat32(byteOffset, value, false);
  }

  @Override
  public void setFloat32(int byteOffset, float value, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int finalOfs = ofs;
    int len = Float32Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    Float32ArrayNative.create(buf, ofs, 1).set(0, value);
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(tempBuffer, 0, len, uint8Array, finalOfs);
    }
  }

  @Override
  public void setFloat64(int byteOffset, double value) {
    setFloat64(byteOffset, value, false);
  }

  @Override
  public void setFloat64(int byteOffset, double value, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int finalOfs = ofs;
    int len = Float64Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    Float64ArrayNative.create(buf, ofs, 1).set(0, value);
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(tempBuffer, 0, len, uint8Array, finalOfs);
    }
  }

  @Override
  public void setInt16(int byteOffset, int value) {
    setInt16(byteOffset, value, false);
  }

  @Override
  public void setInt16(int byteOffset, int value, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int finalOfs = ofs;
    int len = Int16Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    Int16ArrayNative.create(buf, ofs, 1).set(0, value);
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(tempBuffer, 0, len, uint8Array, finalOfs);
    }
  }

  @Override
  public void setInt32(int byteOffset, int value) {
    setInt32(byteOffset, value, false);
  }

  @Override
  public void setInt32(int byteOffset, int value, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int finalOfs = ofs;
    int len = Int32Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    Int32ArrayNative.create(buf, ofs, 1).set(0, value);
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(tempBuffer, 0, len, uint8Array, finalOfs);
    }
  }

  @Override
  public void setInt8(int byteOffset, int value) {
    Int8ArrayNative.create(buffer, byteOffset, 1).set(0, value);
  }

  @Override
  public void setUint16(int byteOffset, int value) {
    setUint16(byteOffset, value, false);
  }

  @Override
  public void setUint16(int byteOffset, int value, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int finalOfs = ofs;
    int len = Uint16Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    Uint16ArrayNative.create(buf, ofs, 1).set(0, value);
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(tempBuffer, 0, len, uint8Array, finalOfs);
    }
  }

  @Override
  public void setUint32(int byteOffset, long value) {
    setUint32(byteOffset, value, false);
  }

  @Override
  public void setUint32(int byteOffset, long value, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int finalOfs = ofs;
    int len = Uint32Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    Uint32ArrayNative.create(buf, ofs, 1).set(0, value);
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(tempBuffer, 0, len, uint8Array, finalOfs);
    }
  }

  @Override
  public void setUint32FromDouble(int byteOffset, double value) {
    setUint32FromDouble(byteOffset, value, false);
  }

  @Override
  public void setUint32FromDouble(int byteOffset, double value, boolean littleEndian) {
    ArrayBuffer buf = buffer;
    int ofs = bufferByteOffset + byteOffset;
    int finalOfs = ofs;
    int len = Uint32Array.BYTES_PER_ELEMENT;
    if (littleEndian != nativeLittleEndian) {
      buf = tempBuffer.buffer();
      ofs = 0;
    }
    Uint32ArrayNative.create(buf, ofs, 1).set(0, value);
    if (littleEndian != nativeLittleEndian) {
      reverseBytes(tempBuffer, 0, len, uint8Array, finalOfs);
    }
  }

  @Override
  public void setUint8(int byteOffset, int value) {
    Uint8ArrayNative.create(buffer, byteOffset, 1).set(0, value);
  }

  /**
   * Copy bytes from the underlying buffer to a temporary buffer, reversing them
   * in the process.
   * 
   * @param src
   * @param srcOfs offset into {@code buffer}
   * @param len number of bytes to copy
   * @param dest
   * @param destOfs
   */
  protected final void reverseBytes(Uint8ArrayNative src, int srcOfs, int len,
      Uint8ArrayNative dest, int destOfs) {
    for (int i = 0; i < len; ++i) {
      dest.set(i + destOfs, src.get(srcOfs + len - 1 - i));
    }
  }
}