Move prepare_pixels helper functions to canvas_traits

components/canvas_traits/Cargo.toml

@@ -14,14 +14,17 @@ path = "lib.rs"
 webgl_backtrace = []
 
 [dependencies]
+byteorder = "1"
 cssparser = "0.25"
 euclid = "0.19"
 ipc-channel = "0.11"
-gleam = "0.6"
+gleam = "0.6.7"
+half = "1"
 lazy_static = "1"
 malloc_size_of = { path = "../malloc_size_of" }
 malloc_size_of_derive = { path = "../malloc_size_of_derive" }
 offscreen_gl_context = {version = "0.21", features = ["serde"]}
+pixels = {path = "../pixels"}
 serde = "1.0"
 serde_bytes = "0.10"
 servo_config = {path = "../config"}

components/canvas_traits/lib.rs

@@ -14,5 +14,6 @@ extern crate malloc_size_of_derive;
 extern crate serde;
 
 pub mod canvas;
+#[macro_use]
 pub mod webgl;
 mod webgl_channel;

components/canvas_traits/webgl.rs

@@ -2,10 +2,13 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use byteorder::{ByteOrder, NativeEndian, WriteBytesExt};
 use euclid::{Rect, Size2D};
 use gleam::gl;
+use half::f16;
 use ipc_channel::ipc::{IpcBytesReceiver, IpcBytesSender};
 use offscreen_gl_context::{GLContextAttributes, GLLimits};
+use pixels;
 use serde_bytes::ByteBuf;
 use std::borrow::Cow;
 use std::num::NonZeroU32;
@@ -650,3 +653,371 @@ pub fn is_gles() -> bool {
     // making assumptions based on platform
     cfg!(any(target_os = "android", target_os = "ios"))
 }
+
+#[macro_export]
+macro_rules! gl_enums {
+    ($(pub enum $name:ident { $($variant:ident = $mod:ident::$constant:ident,)+ })*) => {
+        $(
+            #[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq)]
+            #[repr(u32)]
+            pub enum $name { $($variant = $mod::$constant,)+ }
+
+            impl $name {
+                pub fn from_gl_constant(constant: u32) -> Option<Self> {
+                    Some(match constant {
+                        $($mod::$constant => $name::$variant, )+
+                        _ => return None,
+                    })
+                }
+
+                #[inline]
+                pub fn as_gl_constant(&self) -> u32 {
+                    *self as u32
+                }
+            }
+        )*
+    }
+}
+
+gl_enums! {
+    pub enum TexFormat {
+        DepthComponent = gl::DEPTH_COMPONENT,
+        Alpha = gl::ALPHA,
+        RGB = gl::RGB,
+        RGBA = gl::RGBA,
+        Luminance = gl::LUMINANCE,
+        LuminanceAlpha = gl::LUMINANCE_ALPHA,
+    }
+
+    pub enum TexDataType {
+        UnsignedByte = gl::UNSIGNED_BYTE,
+        UnsignedShort4444 = gl::UNSIGNED_SHORT_4_4_4_4,
+        UnsignedShort5551 = gl::UNSIGNED_SHORT_5_5_5_1,
+        UnsignedShort565 = gl::UNSIGNED_SHORT_5_6_5,
+        Float = gl::FLOAT,
+        HalfFloat = gl::HALF_FLOAT_OES,
+    }
+}
+
+impl TexFormat {
+    /// Returns how many components does this format need. For example, RGBA
+    /// needs 4 components, while RGB requires 3.
+    pub fn components(&self) -> u32 {
+        match *self {
+            TexFormat::DepthComponent => 1,
+            TexFormat::Alpha => 1,
+            TexFormat::Luminance => 1,
+            TexFormat::LuminanceAlpha => 2,
+            TexFormat::RGB => 3,
+            TexFormat::RGBA => 4,
+        }
+    }
+}
+
+impl TexDataType {
+    /// Returns the size in bytes of each element of data.
+    pub fn element_size(&self) -> u32 {
+        use self::*;
+        match *self {
+            TexDataType::UnsignedByte => 1,
+            TexDataType::UnsignedShort4444 |
+            TexDataType::UnsignedShort5551 |
+            TexDataType::UnsignedShort565 => 2,
+            TexDataType::Float => 4,
+            TexDataType::HalfFloat => 2,
+        }
+    }
+
+    /// Returns how many components a single element may hold. For example, a
+    /// UnsignedShort4444 holds four components, each with 4 bits of data.
+    pub fn components_per_element(&self) -> u32 {
+        match *self {
+            TexDataType::UnsignedByte => 1,
+            TexDataType::UnsignedShort565 => 3,
+            TexDataType::UnsignedShort5551 => 4,
+            TexDataType::UnsignedShort4444 => 4,
+            TexDataType::Float => 1,
+            TexDataType::HalfFloat => 1,
+        }
+    }
+}
+
+/// Translates an image in rgba8 (red in the first byte) format to
+/// the format that was requested of TexImage.
+pub fn rgba8_image_to_tex_image_data(
+    format: TexFormat,
+    data_type: TexDataType,
+    mut pixels: Vec<u8>,
+) -> Vec<u8> {
+    // hint for vector allocation sizing.
+    let pixel_count = pixels.len() / 4;
+
+    match (format, data_type) {
+        (TexFormat::RGBA, TexDataType::UnsignedByte) => pixels,
+        (TexFormat::RGB, TexDataType::UnsignedByte) => {
+            for i in 0..pixel_count {
+                let rgb = {
+                    let rgb = &pixels[i * 4..i * 4 + 3];
+                    [rgb[0], rgb[1], rgb[2]]
+                };
+                pixels[i * 3..i * 3 + 3].copy_from_slice(&rgb);
+            }
+            pixels.truncate(pixel_count * 3);
+            pixels
+        },
+        (TexFormat::Alpha, TexDataType::UnsignedByte) => {
+            for i in 0..pixel_count {
+                let p = pixels[i * 4 + 3];
+                pixels[i] = p;
+            }
+            pixels.truncate(pixel_count);
+            pixels
+        },
+        (TexFormat::Luminance, TexDataType::UnsignedByte) => {
+            for i in 0..pixel_count {
+                let p = pixels[i * 4];
+                pixels[i] = p;
+            }
+            pixels.truncate(pixel_count);
+            pixels
+        },
+        (TexFormat::LuminanceAlpha, TexDataType::UnsignedByte) => {
+            for i in 0..pixel_count {
+                let (lum, a) = {
+                    let rgba = &pixels[i * 4..i * 4 + 4];
+                    (rgba[0], rgba[3])
+                };
+                pixels[i * 2] = lum;
+                pixels[i * 2 + 1] = a;
+            }
+            pixels.truncate(pixel_count * 2);
+            pixels
+        },
+        (TexFormat::RGBA, TexDataType::UnsignedShort4444) => {
+            for i in 0..pixel_count {
+                let p = {
+                    let rgba = &pixels[i * 4..i * 4 + 4];
+                    (rgba[0] as u16 & 0xf0) << 8 |
+                        (rgba[1] as u16 & 0xf0) << 4 |
+                        (rgba[2] as u16 & 0xf0) |
+                        (rgba[3] as u16 & 0xf0) >> 4
+                };
+                NativeEndian::write_u16(&mut pixels[i * 2..i * 2 + 2], p);
+            }
+            pixels.truncate(pixel_count * 2);
+            pixels
+        },
+        (TexFormat::RGBA, TexDataType::UnsignedShort5551) => {
+            for i in 0..pixel_count {
+                let p = {
+                    let rgba = &pixels[i * 4..i * 4 + 4];
+                    (rgba[0] as u16 & 0xf8) << 8 |
+                        (rgba[1] as u16 & 0xf8) << 3 |
+                        (rgba[2] as u16 & 0xf8) >> 2 |
+                        (rgba[3] as u16) >> 7
+                };
+                NativeEndian::write_u16(&mut pixels[i * 2..i * 2 + 2], p);
+            }
+            pixels.truncate(pixel_count * 2);
+            pixels
+        },
+        (TexFormat::RGB, TexDataType::UnsignedShort565) => {
+            for i in 0..pixel_count {
+                let p = {
+                    let rgb = &pixels[i * 4..i * 4 + 3];
+                    (rgb[0] as u16 & 0xf8) << 8 |
+                        (rgb[1] as u16 & 0xfc) << 3 |
+                        (rgb[2] as u16 & 0xf8) >> 3
+                };
+                NativeEndian::write_u16(&mut pixels[i * 2..i * 2 + 2], p);
+            }
+            pixels.truncate(pixel_count * 2);
+            pixels
+        },
+        (TexFormat::RGBA, TexDataType::Float) => {
+            let mut rgbaf32 = Vec::<u8>::with_capacity(pixel_count * 16);
+            for rgba8 in pixels.chunks(4) {
+                rgbaf32.write_f32::<NativeEndian>(rgba8[0] as f32).unwrap();
+                rgbaf32.write_f32::<NativeEndian>(rgba8[1] as f32).unwrap();
+                rgbaf32.write_f32::<NativeEndian>(rgba8[2] as f32).unwrap();
+                rgbaf32.write_f32::<NativeEndian>(rgba8[3] as f32).unwrap();
+            }
+            rgbaf32
+        },
+
+        (TexFormat::RGB, TexDataType::Float) => {
+            let mut rgbf32 = Vec::<u8>::with_capacity(pixel_count * 12);
+            for rgba8 in pixels.chunks(4) {
+                rgbf32.write_f32::<NativeEndian>(rgba8[0] as f32).unwrap();
+                rgbf32.write_f32::<NativeEndian>(rgba8[1] as f32).unwrap();
+                rgbf32.write_f32::<NativeEndian>(rgba8[2] as f32).unwrap();
+            }
+            rgbf32
+        },
+
+        (TexFormat::Alpha, TexDataType::Float) => {
+            for rgba8 in pixels.chunks_mut(4) {
+                let p = rgba8[3] as f32;
+                NativeEndian::write_f32(rgba8, p);
+            }
+            pixels
+        },
+
+        (TexFormat::Luminance, TexDataType::Float) => {
+            for rgba8 in pixels.chunks_mut(4) {
+                let p = rgba8[0] as f32;
+                NativeEndian::write_f32(rgba8, p);
+            }
+            pixels
+        },
+
+        (TexFormat::LuminanceAlpha, TexDataType::Float) => {
+            let mut data = Vec::<u8>::with_capacity(pixel_count * 8);
+            for rgba8 in pixels.chunks(4) {
+                data.write_f32::<NativeEndian>(rgba8[0] as f32).unwrap();
+                data.write_f32::<NativeEndian>(rgba8[3] as f32).unwrap();
+            }
+            data
+        },
+
+        (TexFormat::RGBA, TexDataType::HalfFloat) => {
+            let mut rgbaf16 = Vec::<u8>::with_capacity(pixel_count * 8);
+            for rgba8 in pixels.chunks(4) {
+                rgbaf16
+                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[0] as f32).as_bits())
+                    .unwrap();
+                rgbaf16
+                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[1] as f32).as_bits())
+                    .unwrap();
+                rgbaf16
+                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[2] as f32).as_bits())
+                    .unwrap();
+                rgbaf16
+                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[3] as f32).as_bits())
+                    .unwrap();
+            }
+            rgbaf16
+        },
+
+        (TexFormat::RGB, TexDataType::HalfFloat) => {
+            let mut rgbf16 = Vec::<u8>::with_capacity(pixel_count * 6);
+            for rgba8 in pixels.chunks(4) {
+                rgbf16
+                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[0] as f32).as_bits())
+                    .unwrap();
+                rgbf16
+                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[1] as f32).as_bits())
+                    .unwrap();
+                rgbf16
+                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[2] as f32).as_bits())
+                    .unwrap();
+            }
+            rgbf16
+        },
+        (TexFormat::Alpha, TexDataType::HalfFloat) => {
+            for i in 0..pixel_count {
+                let p = f16::from_f32(pixels[i * 4 + 3] as f32).as_bits();
+                NativeEndian::write_u16(&mut pixels[i * 2..i * 2 + 2], p);
+            }
+            pixels.truncate(pixel_count * 2);
+            pixels
+        },
+        (TexFormat::Luminance, TexDataType::HalfFloat) => {
+            for i in 0..pixel_count {
+                let p = f16::from_f32(pixels[i * 4] as f32).as_bits();
+                NativeEndian::write_u16(&mut pixels[i * 2..i * 2 + 2], p);
+            }
+            pixels.truncate(pixel_count * 2);
+            pixels
+        },
+        (TexFormat::LuminanceAlpha, TexDataType::HalfFloat) => {
+            for rgba8 in pixels.chunks_mut(4) {
+                let lum = f16::from_f32(rgba8[0] as f32).as_bits();
+                let a = f16::from_f32(rgba8[3] as f32).as_bits();
+                NativeEndian::write_u16(&mut rgba8[0..2], lum);
+                NativeEndian::write_u16(&mut rgba8[2..4], a);
+            }
+            pixels
+        },
+
+        // Validation should have ensured that we only hit the
+        // above cases, but we haven't turned the (format, type)
+        // into an enum yet so there's a default case here.
+        _ => unreachable!("Unsupported formats {:?} {:?}", format, data_type),
+    }
+}
+
+pub fn premultiply_inplace(format: TexFormat, data_type: TexDataType, pixels: &mut [u8]) {
+    match (format, data_type) {
+        (TexFormat::RGBA, TexDataType::UnsignedByte) => {
+            pixels::premultiply_inplace(pixels);
+        },
+        (TexFormat::LuminanceAlpha, TexDataType::UnsignedByte) => {
+            for la in pixels.chunks_mut(2) {
+                la[0] = pixels::multiply_u8_color(la[0], la[1]);
+            }
+        },
+        (TexFormat::RGBA, TexDataType::UnsignedShort5551) => {
+            for rgba in pixels.chunks_mut(2) {
+                if NativeEndian::read_u16(rgba) & 1 == 0 {
+                    NativeEndian::write_u16(rgba, 0);
+                }
+            }
+        },
+        (TexFormat::RGBA, TexDataType::UnsignedShort4444) => {
+            for rgba in pixels.chunks_mut(2) {
+                let pix = NativeEndian::read_u16(rgba);
+                let extend_to_8_bits = |val| (val | val << 4) as u8;
+                let r = extend_to_8_bits(pix >> 12 & 0x0f);
+                let g = extend_to_8_bits(pix >> 8 & 0x0f);
+                let b = extend_to_8_bits(pix >> 4 & 0x0f);
+                let a = extend_to_8_bits(pix & 0x0f);
+                NativeEndian::write_u16(
+                    rgba,
+                    ((pixels::multiply_u8_color(r, a) & 0xf0) as u16) << 8 |
+                        ((pixels::multiply_u8_color(g, a) & 0xf0) as u16) << 4 |
+                        ((pixels::multiply_u8_color(b, a) & 0xf0) as u16) |
+                        ((a & 0x0f) as u16),
+                );
+            }
+        },
+        // Other formats don't have alpha, so return their data untouched.
+        _ => {},
+    }
+}
+
+pub fn unmultiply_inplace(pixels: &mut [u8]) {
+    for rgba in pixels.chunks_mut(4) {
+        let a = (rgba[3] as f32) / 255.0;
+        rgba[0] = (rgba[0] as f32 / a) as u8;
+        rgba[1] = (rgba[1] as f32 / a) as u8;
+        rgba[2] = (rgba[2] as f32 / a) as u8;
+    }
+}
+
+/// Flips the pixels in the Vec on the Y axis.
+pub fn flip_pixels_y(
+    internal_format: TexFormat,
+    data_type: TexDataType,
+    width: usize,
+    height: usize,
+    unpacking_alignment: usize,
+    pixels: Vec<u8>,
+) -> Vec<u8> {
+    let cpp = (data_type.element_size() * internal_format.components() /
+        data_type.components_per_element()) as usize;
+
+    let stride = (width * cpp + unpacking_alignment - 1) & !(unpacking_alignment - 1);
+
+    let mut flipped = Vec::<u8>::with_capacity(pixels.len());
+
+    for y in 0..height {
+        let flipped_y = height - 1 - y;
+        let start = flipped_y * stride;
+
+        flipped.extend_from_slice(&pixels[start..(start + width * cpp)]);
+        flipped.extend(vec![0u8; stride - width * cpp]);
+    }
+
+    flipped
+}

components/script/Cargo.toml

@@ -53,7 +53,6 @@ enum-iterator = "0.2.0"
 euclid = "0.19"
 fnv = "1.0"
 gleam = "0.6"
-half = "1.0"
 headers-core = "0.0.1"
 headers-ext = "0.0.3"
 html5ever = "0.22"

components/script/dom/bindings/trace.rs

@@ -34,11 +34,11 @@ use canvas_traits::canvas::{
     CanvasGradientStop, CanvasId, LinearGradientStyle, RadialGradientStyle,
 };
 use canvas_traits::canvas::{CompositionOrBlending, LineCapStyle, LineJoinStyle, RepetitionStyle};
-use canvas_traits::webgl::{ActiveAttribInfo, ActiveUniformInfo, WebGLBufferId, WebGLChan};
-use canvas_traits::webgl::{WebGLContextShareMode, WebGLError, WebGLFramebufferId, WebGLMsgSender};
-use canvas_traits::webgl::{WebGLPipeline, WebGLProgramId, WebGLReceiver, WebGLRenderbufferId};
-use canvas_traits::webgl::{WebGLSLVersion, WebGLSender, WebGLShaderId, WebGLTextureId};
-use canvas_traits::webgl::{WebGLVersion, WebGLVertexArrayId};
+use canvas_traits::webgl::{ActiveAttribInfo, ActiveUniformInfo, TexDataType, TexFormat};
+use canvas_traits::webgl::{WebGLBufferId, WebGLChan, WebGLContextShareMode, WebGLError};
+use canvas_traits::webgl::{WebGLFramebufferId, WebGLMsgSender, WebGLPipeline, WebGLProgramId};
+use canvas_traits::webgl::{WebGLReceiver, WebGLRenderbufferId, WebGLSLVersion, WebGLSender};
+use canvas_traits::webgl::{WebGLShaderId, WebGLTextureId, WebGLVersion, WebGLVertexArrayId};
 use crate::dom::bindings::cell::DomRefCell;
 use crate::dom::bindings::error::Error;
 use crate::dom::bindings::refcounted::{Trusted, TrustedPromise};
@@ -148,6 +148,8 @@ unsafe_no_jsmanaged_fields!(Reflector);
 
 unsafe_no_jsmanaged_fields!(Duration);
 
+unsafe_no_jsmanaged_fields!(TexDataType, TexFormat);
+
 /// Trace a `JSVal`.
 pub fn trace_jsval(tracer: *mut JSTracer, description: &str, val: &Heap<JSVal>) {
     unsafe {

components/script/dom/webgl_validations/tex_image_2d.rs

@@ -2,9 +2,9 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use super::types::{TexDataType, TexFormat, TexImageTarget};
+use super::types::TexImageTarget;
 use super::WebGLValidator;
-use canvas_traits::webgl::WebGLError::*;
+use canvas_traits::webgl::{TexDataType, TexFormat, WebGLError::*};
 use crate::dom::bindings::root::DomRoot;
 use crate::dom::webglrenderingcontext::WebGLRenderingContext;
 use crate::dom::webgltexture::WebGLTexture;

components/script/dom/webgl_validations/types.rs

@@ -2,47 +2,21 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-use crate::dom::bindings::codegen::Bindings::OESTextureHalfFloatBinding::OESTextureHalfFloatConstants;
-use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants as constants;
+use canvas_traits::gl_enums;
+use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextConstants;
 
-/// This macro creates type-safe wrappers for WebGL types, associating variants
-/// with gl constants.
-macro_rules! type_safe_wrapper {
-    ($name: ident, $($variant:ident => $mod:ident::$constant:ident, )+) => {
-        #[derive(Clone, Copy, Debug, Eq, Hash, JSTraceable, MallocSizeOf, PartialEq)]
-        #[repr(u32)]
-        pub enum $name {
-            $(
-                $variant = $mod::$constant,
-            )+
-        }
-
-        impl $name {
-            pub fn from_gl_constant(constant: u32) -> Option<Self> {
-                Some(match constant {
-                    $($mod::$constant => $name::$variant, )+
-                    _ => return None,
-                })
-            }
-
-            #[inline]
-            pub fn as_gl_constant(&self) -> u32 {
-                *self as u32
-            }
-        }
+gl_enums! {
+    pub enum TexImageTarget {
+        Texture2D = WebGLRenderingContextConstants::TEXTURE_2D,
+        CubeMapPositiveX = WebGLRenderingContextConstants::TEXTURE_CUBE_MAP_POSITIVE_X,
+        CubeMapNegativeX = WebGLRenderingContextConstants::TEXTURE_CUBE_MAP_NEGATIVE_X,
+        CubeMapPositiveY = WebGLRenderingContextConstants::TEXTURE_CUBE_MAP_POSITIVE_Y,
+        CubeMapNegativeY = WebGLRenderingContextConstants::TEXTURE_CUBE_MAP_NEGATIVE_Y,
+        CubeMapPositiveZ = WebGLRenderingContextConstants::TEXTURE_CUBE_MAP_POSITIVE_Z,
+        CubeMapNegativeZ = WebGLRenderingContextConstants::TEXTURE_CUBE_MAP_NEGATIVE_Z,
     }
 }
 
-type_safe_wrapper! { TexImageTarget,
-    Texture2D => constants::TEXTURE_2D,
-    CubeMapPositiveX => constants::TEXTURE_CUBE_MAP_POSITIVE_X,
-    CubeMapNegativeX => constants::TEXTURE_CUBE_MAP_NEGATIVE_X,
-    CubeMapPositiveY => constants::TEXTURE_CUBE_MAP_POSITIVE_Y,
-    CubeMapNegativeY => constants::TEXTURE_CUBE_MAP_NEGATIVE_Y,
-    CubeMapPositiveZ => constants::TEXTURE_CUBE_MAP_POSITIVE_Z,
-    CubeMapNegativeZ => constants::TEXTURE_CUBE_MAP_NEGATIVE_Z,
-}
-
 impl TexImageTarget {
     pub fn is_cubic(&self) -> bool {
         match *self {
@@ -51,64 +25,3 @@ impl TexImageTarget {
         }
     }
 }
-
-type_safe_wrapper! { TexDataType,
-    UnsignedByte => constants::UNSIGNED_BYTE,
-    UnsignedShort4444 => constants::UNSIGNED_SHORT_4_4_4_4,
-    UnsignedShort5551 => constants::UNSIGNED_SHORT_5_5_5_1,
-    UnsignedShort565 => constants::UNSIGNED_SHORT_5_6_5,
-    Float => constants::FLOAT,
-    HalfFloat => OESTextureHalfFloatConstants::HALF_FLOAT_OES,
-}
-
-impl TexDataType {
-    /// Returns the size in bytes of each element of data.
-    pub fn element_size(&self) -> u32 {
-        use self::TexDataType::*;
-        match *self {
-            UnsignedByte => 1,
-            UnsignedShort4444 | UnsignedShort5551 | UnsignedShort565 => 2,
-            Float => 4,
-            HalfFloat => 2,
-        }
-    }
-
-    /// Returns how many components a single element may hold. For example, a
-    /// UnsignedShort4444 holds four components, each with 4 bits of data.
-    pub fn components_per_element(&self) -> u32 {
-        use self::TexDataType::*;
-        match *self {
-            UnsignedByte => 1,
-            UnsignedShort565 => 3,
-            UnsignedShort5551 => 4,
-            UnsignedShort4444 => 4,
-            Float => 1,
-            HalfFloat => 1,
-        }
-    }
-}
-
-type_safe_wrapper! { TexFormat,
-    DepthComponent => constants::DEPTH_COMPONENT,
-    Alpha => constants::ALPHA,
-    RGB => constants::RGB,
-    RGBA => constants::RGBA,
-    Luminance => constants::LUMINANCE,
-    LuminanceAlpha => constants::LUMINANCE_ALPHA,
-}
-
-impl TexFormat {
-    /// Returns how many components does this format need. For example, RGBA
-    /// needs 4 components, while RGB requires 3.
-    pub fn components(&self) -> u32 {
-        use self::TexFormat::*;
-        match *self {
-            DepthComponent => 1,
-            Alpha => 1,
-            Luminance => 1,
-            LuminanceAlpha => 2,
-            RGB => 3,
-            RGBA => 4,
-        }
-    }
-}

components/script/dom/webglrenderingcontext.rs

@@ -4,13 +4,13 @@
 
 #[cfg(feature = "webgl_backtrace")]
 use backtrace::Backtrace;
-use byteorder::{ByteOrder, NativeEndian, WriteBytesExt};
 use canvas_traits::webgl::WebGLError::*;
-use canvas_traits::webgl::{webgl_channel, WebGLVersion, WebVRCommand};
-use canvas_traits::webgl::{DOMToTextureCommand, Parameter, WebGLCommandBacktrace};
-use canvas_traits::webgl::{TexParameter, WebGLCommand, WebGLContextShareMode, WebGLError};
-use canvas_traits::webgl::{WebGLFramebufferBindingRequest, WebGLMsg, WebGLMsgSender};
-use canvas_traits::webgl::{WebGLProgramId, WebGLResult, WebGLSLVersion, WebGLSender};
+use canvas_traits::webgl::{
+    self, webgl_channel, DOMToTextureCommand, Parameter, TexDataType, TexFormat, TexParameter,
+    WebGLCommand, WebGLCommandBacktrace, WebGLContextShareMode, WebGLError,
+    WebGLFramebufferBindingRequest, WebGLMsg, WebGLMsgSender, WebGLProgramId, WebGLResult,
+    WebGLSLVersion, WebGLSender, WebGLVersion, WebVRCommand,
+};
 use crate::dom::bindings::codegen::Bindings::ANGLEInstancedArraysBinding::ANGLEInstancedArraysConstants;
 use crate::dom::bindings::codegen::Bindings::EXTBlendMinmaxBinding::EXTBlendMinmaxConstants;
 use crate::dom::bindings::codegen::Bindings::OESVertexArrayObjectBinding::OESVertexArrayObjectConstants;
@@ -38,7 +38,7 @@ use crate::dom::webgl_validations::tex_image_2d::{
     CommonTexImage2DValidator, CommonTexImage2DValidatorResult,
 };
 use crate::dom::webgl_validations::tex_image_2d::{TexImage2DValidator, TexImage2DValidatorResult};
-use crate::dom::webgl_validations::types::{TexDataType, TexFormat, TexImageTarget};
+use crate::dom::webgl_validations::types::TexImageTarget;
 use crate::dom::webgl_validations::WebGLValidator;
 use crate::dom::webglactiveinfo::WebGLActiveInfo;
 use crate::dom::webglbuffer::WebGLBuffer;
@@ -57,7 +57,6 @@ use crate::dom::webglvertexarrayobjectoes::WebGLVertexArrayObjectOES;
 use crate::dom::window::Window;
 use dom_struct::dom_struct;
 use euclid::{Point2D, Rect, Size2D};
-use half::f16;
 use ipc_channel::ipc;
 use js::jsapi::{JSContext, JSObject, Type};
 use js::jsval::{BooleanValue, DoubleValue, Int32Value, JSVal, UInt32Value};
@@ -70,6 +69,7 @@ use js::typedarray::{TypedArray, TypedArrayElementCreator};
 use net_traits::image::base::PixelFormat;
 use net_traits::image_cache::ImageResponse;
 use offscreen_gl_context::{GLContextAttributes, GLLimits};
+use pixels;
 use script_layout_interface::HTMLCanvasDataSource;
 use serde::{Deserialize, Serialize};
 use servo_config::prefs::PREFS;
@@ -638,92 +638,6 @@ impl WebGLRenderingContext {
         }
     }
 
-    /// Flips the pixels in the Vec on the Y axis if
-    /// UNPACK_FLIP_Y_WEBGL is currently enabled.
-    fn flip_teximage_y(
-        &self,
-        pixels: Vec<u8>,
-        internal_format: TexFormat,
-        data_type: TexDataType,
-        width: usize,
-        height: usize,
-        unpacking_alignment: usize,
-    ) -> Vec<u8> {
-        if !self
-            .texture_unpacking_settings
-            .get()
-            .contains(TextureUnpacking::FLIP_Y_AXIS)
-        {
-            return pixels;
-        }
-
-        let cpp = (data_type.element_size() * internal_format.components() /
-            data_type.components_per_element()) as usize;
-
-        let stride = (width * cpp + unpacking_alignment - 1) & !(unpacking_alignment - 1);
-
-        let mut flipped = Vec::<u8>::with_capacity(pixels.len());
-
-        for y in 0..height {
-            let flipped_y = height - 1 - y;
-            let start = flipped_y * stride;
-
-            flipped.extend_from_slice(&pixels[start..(start + width * cpp)]);
-            flipped.extend(vec![0u8; stride - width * cpp]);
-        }
-
-        flipped
-    }
-
-    /// Performs premultiplication of the pixels if
-    /// UNPACK_PREMULTIPLY_ALPHA_WEBGL is currently enabled.
-    fn premultiply_pixels(&self, format: TexFormat, data_type: TexDataType, pixels: &mut [u8]) {
-        if !self
-            .texture_unpacking_settings
-            .get()
-            .contains(TextureUnpacking::PREMULTIPLY_ALPHA)
-        {
-            return;
-        }
-
-        match (format, data_type) {
-            (TexFormat::RGBA, TexDataType::UnsignedByte) => {
-                pixels::premultiply_inplace(pixels);
-            },
-            (TexFormat::LuminanceAlpha, TexDataType::UnsignedByte) => {
-                for la in pixels.chunks_mut(2) {
-                    la[0] = pixels::multiply_u8_color(la[0], la[1]);
-                }
-            },
-            (TexFormat::RGBA, TexDataType::UnsignedShort5551) => {
-                for rgba in pixels.chunks_mut(2) {
-                    if NativeEndian::read_u16(rgba) & 1 == 0 {
-                        NativeEndian::write_u16(rgba, 0);
-                    }
-                }
-            },
-            (TexFormat::RGBA, TexDataType::UnsignedShort4444) => {
-                for rgba in pixels.chunks_mut(2) {
-                    let pix = NativeEndian::read_u16(rgba);
-                    let extend_to_8_bits = |val| (val | val << 4) as u8;
-                    let r = extend_to_8_bits(pix >> 12 & 0x0f);
-                    let g = extend_to_8_bits(pix >> 8 & 0x0f);
-                    let b = extend_to_8_bits(pix >> 4 & 0x0f);
-                    let a = extend_to_8_bits(pix & 0x0f);
-                    NativeEndian::write_u16(
-                        rgba,
-                        ((pixels::multiply_u8_color(r, a) & 0xf0) as u16) << 8 |
-                            ((pixels::multiply_u8_color(g, a) & 0xf0) as u16) << 4 |
-                            ((pixels::multiply_u8_color(b, a) & 0xf0) as u16) |
-                            ((a & 0x0f) as u16),
-                    );
-                }
-            },
-            // Other formats don't have alpha, so return their data untouched.
-            _ => {},
-        }
-    }
-
     fn prepare_pixels(
         &self,
         internal_format: TexFormat,
@@ -735,34 +649,36 @@ impl WebGLRenderingContext {
         source_from_image_or_canvas: bool,
         mut pixels: Vec<u8>,
     ) -> Vec<u8> {
-        let dest_premultiply = self
-            .texture_unpacking_settings
-            .get()
-            .contains(TextureUnpacking::PREMULTIPLY_ALPHA);
+        let settings = self.texture_unpacking_settings.get();
+        let dest_premultiply = settings.contains(TextureUnpacking::PREMULTIPLY_ALPHA);
         if !source_premultiplied && dest_premultiply {
             if source_from_image_or_canvas {
                 // When the pixels come from image or canvas or imagedata, use RGBA8 format
-                self.premultiply_pixels(TexFormat::RGBA, TexDataType::UnsignedByte, &mut pixels);
+                webgl::premultiply_inplace(TexFormat::RGBA, TexDataType::UnsignedByte, &mut pixels);
             } else {
-                self.premultiply_pixels(internal_format, data_type, &mut pixels);
+                webgl::premultiply_inplace(internal_format, data_type, &mut pixels);
             }
         } else if source_premultiplied && !dest_premultiply {
-            remove_premultiplied_alpha(&mut pixels);
+            webgl::unmultiply_inplace(&mut pixels);
         }
 
         if source_from_image_or_canvas {
-            pixels = rgba8_image_to_tex_image_data(internal_format, data_type, pixels);
+            pixels = webgl::rgba8_image_to_tex_image_data(internal_format, data_type, pixels);
         }
 
-        // FINISHME: Consider doing premultiply and flip in a single mutable Vec.
-        self.flip_teximage_y(
-            pixels,
-            internal_format,
-            data_type,
-            width as usize,
-            height as usize,
-            unpacking_alignment as usize,
-        )
+        if settings.contains(TextureUnpacking::FLIP_Y_AXIS) {
+            // FINISHME: Consider doing premultiply and flip in a single mutable Vec.
+            pixels = webgl::flip_pixels_y(
+                internal_format,
+                data_type,
+                width as usize,
+                height as usize,
+                unpacking_alignment as usize,
+                pixels,
+            );
+        }
+
+        pixels
     }
 
     fn tex_image_2d(
@@ -4328,234 +4244,6 @@ impl TextureUnit {
     }
 }
 
-// Remove premultiplied alpha.
-// This is only called when texImage2D is called using a canvas2d source and
-// UNPACK_PREMULTIPLY_ALPHA_WEBGL is disabled. Pixels got from a canvas2D source
-// are always RGBA8 with premultiplied alpha, so we don't have to worry about
-// additional formats as happens in the premultiply_pixels method.
-fn remove_premultiplied_alpha(pixels: &mut [u8]) {
-    for rgba in pixels.chunks_mut(4) {
-        let a = (rgba[3] as f32) / 255.0;
-        rgba[0] = (rgba[0] as f32 / a) as u8;
-        rgba[1] = (rgba[1] as f32 / a) as u8;
-        rgba[2] = (rgba[2] as f32 / a) as u8;
-    }
-}
-
-/// Translates an image in rgba8 (red in the first byte) format to
-/// the format that was requested of TexImage.
-///
-/// From the WebGL 1.0 spec, 5.14.8:
-///
-///     "The source image data is conceptually first converted to
-///      the data type and format specified by the format and type
-///      arguments, and then transferred to the WebGL
-///      implementation. If a packed pixel format is specified
-///      which would imply loss of bits of precision from the image
-///      data, this loss of precision must occur."
-fn rgba8_image_to_tex_image_data(
-    format: TexFormat,
-    data_type: TexDataType,
-    mut pixels: Vec<u8>,
-) -> Vec<u8> {
-    // hint for vector allocation sizing.
-    let pixel_count = pixels.len() / 4;
-
-    match (format, data_type) {
-        (TexFormat::RGBA, TexDataType::UnsignedByte) => pixels,
-        (TexFormat::RGB, TexDataType::UnsignedByte) => {
-            for i in 0..pixel_count {
-                let rgb = {
-                    let rgb = &pixels[i * 4..i * 4 + 3];
-                    [rgb[0], rgb[1], rgb[2]]
-                };
-                pixels[i * 3..i * 3 + 3].copy_from_slice(&rgb);
-            }
-            pixels.truncate(pixel_count * 3);
-            pixels
-        },
-        (TexFormat::Alpha, TexDataType::UnsignedByte) => {
-            for i in 0..pixel_count {
-                let p = pixels[i * 4 + 3];
-                pixels[i] = p;
-            }
-            pixels.truncate(pixel_count);
-            pixels
-        },
-        (TexFormat::Luminance, TexDataType::UnsignedByte) => {
-            for i in 0..pixel_count {
-                let p = pixels[i * 4];
-                pixels[i] = p;
-            }
-            pixels.truncate(pixel_count);
-            pixels
-        },
-        (TexFormat::LuminanceAlpha, TexDataType::UnsignedByte) => {
-            for i in 0..pixel_count {
-                let (lum, a) = {
-                    let rgba = &pixels[i * 4..i * 4 + 4];
-                    (rgba[0], rgba[3])
-                };
-                pixels[i * 2] = lum;
-                pixels[i * 2 + 1] = a;
-            }
-            pixels.truncate(pixel_count * 2);
-            pixels
-        },
-        (TexFormat::RGBA, TexDataType::UnsignedShort4444) => {
-            for i in 0..pixel_count {
-                let p = {
-                    let rgba = &pixels[i * 4..i * 4 + 4];
-                    (rgba[0] as u16 & 0xf0) << 8 |
-                        (rgba[1] as u16 & 0xf0) << 4 |
-                        (rgba[2] as u16 & 0xf0) |
-                        (rgba[3] as u16 & 0xf0) >> 4
-                };
-                NativeEndian::write_u16(&mut pixels[i * 2..i * 2 + 2], p);
-            }
-            pixels.truncate(pixel_count * 2);
-            pixels
-        },
-        (TexFormat::RGBA, TexDataType::UnsignedShort5551) => {
-            for i in 0..pixel_count {
-                let p = {
-                    let rgba = &pixels[i * 4..i * 4 + 4];
-                    (rgba[0] as u16 & 0xf8) << 8 |
-                        (rgba[1] as u16 & 0xf8) << 3 |
-                        (rgba[2] as u16 & 0xf8) >> 2 |
-                        (rgba[3] as u16) >> 7
-                };
-                NativeEndian::write_u16(&mut pixels[i * 2..i * 2 + 2], p);
-            }
-            pixels.truncate(pixel_count * 2);
-            pixels
-        },
-        (TexFormat::RGB, TexDataType::UnsignedShort565) => {
-            for i in 0..pixel_count {
-                let p = {
-                    let rgb = &pixels[i * 4..i * 4 + 3];
-                    (rgb[0] as u16 & 0xf8) << 8 |
-                        (rgb[1] as u16 & 0xfc) << 3 |
-                        (rgb[2] as u16 & 0xf8) >> 3
-                };
-                NativeEndian::write_u16(&mut pixels[i * 2..i * 2 + 2], p);
-            }
-            pixels.truncate(pixel_count * 2);
-            pixels
-        },
-        (TexFormat::RGBA, TexDataType::Float) => {
-            let mut rgbaf32 = Vec::<u8>::with_capacity(pixel_count * 16);
-            for rgba8 in pixels.chunks(4) {
-                rgbaf32.write_f32::<NativeEndian>(rgba8[0] as f32).unwrap();
-                rgbaf32.write_f32::<NativeEndian>(rgba8[1] as f32).unwrap();
-                rgbaf32.write_f32::<NativeEndian>(rgba8[2] as f32).unwrap();
-                rgbaf32.write_f32::<NativeEndian>(rgba8[3] as f32).unwrap();
-            }
-            rgbaf32
-        },
-
-        (TexFormat::RGB, TexDataType::Float) => {
-            let mut rgbf32 = Vec::<u8>::with_capacity(pixel_count * 12);
-            for rgba8 in pixels.chunks(4) {
-                rgbf32.write_f32::<NativeEndian>(rgba8[0] as f32).unwrap();
-                rgbf32.write_f32::<NativeEndian>(rgba8[1] as f32).unwrap();
-                rgbf32.write_f32::<NativeEndian>(rgba8[2] as f32).unwrap();
-            }
-            rgbf32
-        },
-
-        (TexFormat::Alpha, TexDataType::Float) => {
-            for rgba8 in pixels.chunks_mut(4) {
-                let p = rgba8[3] as f32;
-                NativeEndian::write_f32(rgba8, p);
-            }
-            pixels
-        },
-
-        (TexFormat::Luminance, TexDataType::Float) => {
-            for rgba8 in pixels.chunks_mut(4) {
-                let p = rgba8[0] as f32;
-                NativeEndian::write_f32(rgba8, p);
-            }
-            pixels
-        },
-
-        (TexFormat::LuminanceAlpha, TexDataType::Float) => {
-            let mut data = Vec::<u8>::with_capacity(pixel_count * 8);
-            for rgba8 in pixels.chunks(4) {
-                data.write_f32::<NativeEndian>(rgba8[0] as f32).unwrap();
-                data.write_f32::<NativeEndian>(rgba8[3] as f32).unwrap();
-            }
-            data
-        },
-
-        (TexFormat::RGBA, TexDataType::HalfFloat) => {
-            let mut rgbaf16 = Vec::<u8>::with_capacity(pixel_count * 8);
-            for rgba8 in pixels.chunks(4) {
-                rgbaf16
-                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[0] as f32).as_bits())
-                    .unwrap();
-                rgbaf16
-                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[1] as f32).as_bits())
-                    .unwrap();
-                rgbaf16
-                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[2] as f32).as_bits())
-                    .unwrap();
-                rgbaf16
-                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[3] as f32).as_bits())
-                    .unwrap();
-            }
-            rgbaf16
-        },
-
-        (TexFormat::RGB, TexDataType::HalfFloat) => {
-            let mut rgbf16 = Vec::<u8>::with_capacity(pixel_count * 6);
-            for rgba8 in pixels.chunks(4) {
-                rgbf16
-                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[0] as f32).as_bits())
-                    .unwrap();
-                rgbf16
-                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[1] as f32).as_bits())
-                    .unwrap();
-                rgbf16
-                    .write_u16::<NativeEndian>(f16::from_f32(rgba8[2] as f32).as_bits())
-                    .unwrap();
-            }
-            rgbf16
-        },
-        (TexFormat::Alpha, TexDataType::HalfFloat) => {
-            for i in 0..pixel_count {
-                let p = f16::from_f32(pixels[i * 4 + 3] as f32).as_bits();
-                NativeEndian::write_u16(&mut pixels[i * 2..i * 2 + 2], p);
-            }
-            pixels.truncate(pixel_count * 2);
-            pixels
-        },
-        (TexFormat::Luminance, TexDataType::HalfFloat) => {
-            for i in 0..pixel_count {
-                let p = f16::from_f32(pixels[i * 4] as f32).as_bits();
-                NativeEndian::write_u16(&mut pixels[i * 2..i * 2 + 2], p);
-            }
-            pixels.truncate(pixel_count * 2);
-            pixels
-        },
-        (TexFormat::LuminanceAlpha, TexDataType::HalfFloat) => {
-            for rgba8 in pixels.chunks_mut(4) {
-                let lum = f16::from_f32(rgba8[0] as f32).as_bits();
-                let a = f16::from_f32(rgba8[3] as f32).as_bits();
-                NativeEndian::write_u16(&mut rgba8[0..2], lum);
-                NativeEndian::write_u16(&mut rgba8[2..4], a);
-            }
-            pixels
-        },
-
-        // Validation should have ensured that we only hit the
-        // above cases, but we haven't turned the (format, type)
-        // into an enum yet so there's a default case here.
-        _ => unreachable!("Unsupported formats {:?} {:?}", format, data_type),
-    }
-}
-
 struct TexPixels {
     data: Vec<u8>,
     size: Size2D<u32>,

components/script/dom/webgltexture.rs

@@ -4,7 +4,7 @@
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/webgl.idl
 
-use canvas_traits::webgl::{webgl_channel, WebGLResult, WebGLTextureId};
+use canvas_traits::webgl::{webgl_channel, TexDataType, TexFormat, WebGLResult, WebGLTextureId};
 use canvas_traits::webgl::{DOMToTextureCommand, WebGLCommand, WebGLError};
 use crate::dom::bindings::cell::DomRefCell;
 use crate::dom::bindings::codegen::Bindings::EXTTextureFilterAnisotropicBinding::EXTTextureFilterAnisotropicConstants;
@@ -13,7 +13,7 @@ use crate::dom::bindings::codegen::Bindings::WebGLTextureBinding;
 use crate::dom::bindings::inheritance::Castable;
 use crate::dom::bindings::reflector::{reflect_dom_object, DomObject};
 use crate::dom::bindings::root::DomRoot;
-use crate::dom::webgl_validations::types::{TexDataType, TexFormat, TexImageTarget};
+use crate::dom::webgl_validations::types::TexImageTarget;
 use crate::dom::webglobject::WebGLObject;
 use crate::dom::webglrenderingcontext::WebGLRenderingContext;
 use dom_struct::dom_struct;