core: Support bitmaps larger than 65535x65535

DefineBitsJPEG2 can define bitmaps larger than 65535x65535, FP supports
it, and some games use it for e.g. defining sprites on a very large
bitmap.

This patch migrates bitmap width/height from u16 to u32, as that's the
maximum theoretical size of a PNG image. It also overall fits better
with the current codebase and requires less conversions.

Author: kjarosh

core/src/avm1/globals/movie_clip.rs

@@ -583,8 +583,8 @@ fn begin_bitmap_fill<'gc>(
             let handle = bitmap_data.bitmap_handle(activation.gc(), activation.context.renderer);
             let bitmap = ruffle_render::bitmap::BitmapInfo {
                 handle,
-                width: bitmap_data.width() as u16,
-                height: bitmap_data.height() as u16,
+                width: bitmap_data.width(),
+                height: bitmap_data.height(),
             };
             let id = movie_clip.drawing_mut().add_bitmap(bitmap);
 

core/src/avm2/globals/flash/display/graphics.rs

@@ -80,8 +80,8 @@ pub fn begin_bitmap_fill<'gc>(
 
         let bitmap = ruffle_render::bitmap::BitmapInfo {
             handle,
-            width: bitmap.width() as u16,
-            height: bitmap.height() as u16,
+            width: bitmap.width(),
+            height: bitmap.height(),
         };
         let scale_matrix = Matrix::scale(
             (Twips::TWIPS_PER_PIXEL as i16).into(),
@@ -1322,8 +1322,8 @@ pub fn line_bitmap_style<'gc>(
 
         let bitmap = ruffle_render::bitmap::BitmapInfo {
             handle,
-            width: bitmap.width() as u16,
-            height: bitmap.height() as u16,
+            width: bitmap.width(),
+            height: bitmap.height(),
         };
         let scale_matrix = Matrix::scale(
             Fixed16::from_f64(bitmap.width as f64),
@@ -1789,8 +1789,8 @@ fn handle_bitmap_fill<'gc>(
 
     let bitmap = ruffle_render::bitmap::BitmapInfo {
         handle,
-        width: bitmap_data.width() as u16,
-        height: bitmap_data.height() as u16,
+        width: bitmap_data.width(),
+        height: bitmap_data.height(),
     };
 
     let scale_matrix = Matrix::scale(

core/src/character.rs

@@ -90,8 +90,8 @@ pub enum CompressedBitmap {
     Jpeg {
         data: Vec<u8>,
         alpha: Option<Vec<u8>>,
-        width: u16,
-        height: u16,
+        width: u32,
+        height: u32,
     },
     Lossless(DefineBitsLossless<'static>),
 }
@@ -104,8 +104,8 @@ impl CompressedBitmap {
                 height: *height,
             },
             CompressedBitmap::Lossless(define_bits_lossless) => BitmapSize {
-                width: define_bits_lossless.width,
-                height: define_bits_lossless.height,
+                width: define_bits_lossless.width.into(),
+                height: define_bits_lossless.height.into(),
             },
         }
     }

core/src/display_object.rs

@@ -98,10 +98,10 @@ pub struct BitmapCache {
     matrix_d: f32,
 
     /// The width of the original bitmap, pre-filters
-    source_width: u16,
+    source_width: u32,
 
     /// The height of the original bitmap, pre-filters
-    source_height: u16,
+    source_height: u32,
 
     /// The offset used to draw the final bitmap (i.e. if a filter increases the size)
     draw_offset: Point<i32>,
@@ -122,7 +122,7 @@ impl BitmapCache {
         self.matrix_a = f32::NAN;
     }
 
-    fn is_dirty(&self, other: &Matrix, source_width: u16, source_height: u16) -> bool {
+    fn is_dirty(&self, other: &Matrix, source_width: u32, source_height: u32) -> bool {
         self.matrix_a != other.a
             || self.matrix_b != other.b
             || self.matrix_c != other.c
@@ -138,10 +138,10 @@ impl BitmapCache {
         &mut self,
         renderer: &mut dyn RenderBackend,
         matrix: Matrix,
-        source_width: u16,
-        source_height: u16,
-        actual_width: u16,
-        actual_height: u16,
+        source_width: u32,
+        source_height: u32,
+        actual_width: u32,
+        actual_height: u32,
         draw_offset: Point<i32>,
         swf_version: u8,
     ) {
@@ -158,7 +158,7 @@ impl BitmapCache {
             }
         }
         let acceptable_size = if swf_version > 9 {
-            let total = actual_width as u32 * actual_height as u32;
+            let total = actual_width * actual_height;
             actual_width < 8191 && actual_height < 8191 && total < 16777215
         } else {
             actual_width < 2880 && actual_height < 2880
@@ -168,7 +168,7 @@ impl BitmapCache {
             && actual_height > 0
             && acceptable_size
         {
-            let handle = renderer.create_empty_texture(actual_width as u32, actual_height as u32);
+            let handle = renderer.create_empty_texture(actual_width, actual_height);
             self.bitmap = handle.ok().map(|handle| BitmapInfo {
                 width: actual_width,
                 height: actual_height,
@@ -944,8 +944,8 @@ pub fn render_base<'gc>(
             let width = bounds.width().to_pixels().ceil().max(0.0);
             let height = bounds.height().to_pixels().ceil().max(0.0);
             if width <= u16::MAX as f64 && height <= u16::MAX as f64 {
-                let width = width as u16;
-                let height = height as u16;
+                let width = width as u32;
+                let height = height as u32;
                 let mut filter_rect = Rectangle {
                     x_min: Twips::ZERO,
                     x_max: Twips::from_pixels_i32(width as i32),
@@ -971,8 +971,8 @@ pub fn render_base<'gc>(
                         base_transform.matrix,
                         width,
                         height,
-                        filter_rect.width() as u16,
-                        filter_rect.height() as u16,
+                        filter_rect.width() as u32,
+                        filter_rect.height() as u32,
                         draw_offset,
                         swf_version,
                     );

render/src/bitmap.rs

@@ -24,14 +24,14 @@ pub trait BitmapHandleImpl: Any + Debug {}
 #[derive(Clone, Debug)]
 pub struct BitmapInfo {
     pub handle: BitmapHandle,
-    pub width: u16,
-    pub height: u16,
+    pub width: u32,
+    pub height: u32,
 }
 
 #[derive(Copy, Clone, Debug)]
 pub struct BitmapSize {
-    pub width: u16,
-    pub height: u16,
+    pub width: u32,
+    pub height: u32,
 }
 
 /// An object that returns a bitmap given an ID.

render/src/tessellator.rs

@@ -117,8 +117,8 @@ impl ShapeTessellator {
                             DrawType::Bitmap(Bitmap {
                                 matrix: swf_bitmap_to_gl_matrix(
                                     (*matrix).into(),
-                                    bitmap.width.into(),
-                                    bitmap.height.into(),
+                                    bitmap.width,
+                                    bitmap.height,
                                 ),
                                 bitmap_id: *id,
                                 is_smoothed: *is_smoothed,

render/src/utils.rs

@@ -47,12 +47,12 @@ pub fn decode_define_bits_jpeg(
     }
 }
 
-pub fn decode_define_bits_jpeg_dimensions(data: &[u8]) -> Result<(u16, u16), Error> {
+pub fn decode_define_bits_jpeg_dimensions(data: &[u8]) -> Result<(u32, u32), Error> {
     let format = determine_jpeg_tag_format(data);
     match format {
-        JpegTagFormat::Jpeg => decode_jpeg_dimensions(data),
+        JpegTagFormat::Jpeg => decode_jpeg_dimensions(data).map(|(w, h)| (w.into(), h.into())),
         JpegTagFormat::Png => decode_png_dimensions(data),
-        JpegTagFormat::Gif => decode_gif_dimensions(data),
+        JpegTagFormat::Gif => decode_gif_dimensions(data).map(|(w, h)| (w.into(), h.into())),
         JpegTagFormat::Unknown => Err(Error::UnknownType),
     }
 }
@@ -358,18 +358,15 @@ pub fn decode_define_bits_lossless(
     ))
 }
 
-fn decode_png_dimensions(data: &[u8]) -> Result<(u16, u16), Error> {
+fn decode_png_dimensions(data: &[u8]) -> Result<(u32, u32), Error> {
     use png::Transformations;
 
     let mut decoder = png::Decoder::new(Cursor::new(data));
     // Normalize output to 8-bit grayscale or RGB.
     // Ideally we'd want to normalize to 8-bit RGB only, but seems like the `png` crate provides no such a feature.
     decoder.set_transformations(Transformations::normalize_to_color8());
     let reader = decoder.read_info()?;
-    Ok((
-        reader.info().width.try_into().expect("Invalid PNG width"),
-        reader.info().height.try_into().expect("Invalid PNG height"),
-    ))
+    Ok((reader.info().width, reader.info().height))
 }
 
 /// Decodes the bitmap data in DefineBitsLossless tag into RGBA.

video/external/src/backend.rs

@@ -183,11 +183,15 @@ impl VideoBackend for ExternalVideoBackend {
             ProxyOrStream::Owned(stream) => {
                 let frame = stream.decoder.decode_frame(encoded_frame)?;
 
-                let w = frame.width();
-                let h = frame.height();
+                let width = frame.width();
+                let height = frame.height();
 
                 let handle = if let Some(bitmap) = stream.bitmap.clone() {
-                    renderer.update_texture(&bitmap, frame, PixelRegion::for_whole_size(w, h))?;
+                    renderer.update_texture(
+                        &bitmap,
+                        frame,
+                        PixelRegion::for_whole_size(width, height),
+                    )?;
                     bitmap
                 } else {
                     renderer.register_bitmap(frame)?
@@ -196,8 +200,8 @@ impl VideoBackend for ExternalVideoBackend {
 
                 Ok(BitmapInfo {
                     handle,
-                    width: w as u16,
-                    height: h as u16,
+                    width,
+                    height,
                 })
             }
         }

video/software/src/backend.rs

@@ -88,11 +88,11 @@ impl VideoBackend for SoftwareVideoBackend {
 
         let frame = stream.decoder.decode_frame(encoded_frame)?;
 
-        let w = frame.width();
-        let h = frame.height();
+        let width = frame.width();
+        let height = frame.height();
 
         let handle = if let Some(bitmap) = stream.bitmap.clone() {
-            renderer.update_texture(&bitmap, frame, PixelRegion::for_whole_size(w, h))?;
+            renderer.update_texture(&bitmap, frame, PixelRegion::for_whole_size(width, height))?;
             bitmap
         } else {
             renderer.register_bitmap(frame)?
@@ -101,8 +101,8 @@ impl VideoBackend for SoftwareVideoBackend {
 
         Ok(BitmapInfo {
             handle,
-            width: w as u16,
-            height: h as u16,
+            width,
+            height,
         })
     }
 }