core: Simplify `Bitmap` creation

Change `Bitmap::new()` to accept a `ruffle_render::bitmap::Bitmap`
directly, instead of `width`, `height` and `bitmap_handle`. As a
consequence, all `RenderBackend::register_bitmap_*` methods are no
longer necessary - we can use `ruffle_redner::utils::*` to obtain
a `ruffle_render::bitmap::Bitmap` right before calling `Bitmap::new()`.

core/src/display_object/bitmap.rs

@@ -120,11 +120,22 @@ impl<'gc> Bitmap<'gc> {
     pub fn new(
         context: &mut UpdateContext<'_, 'gc, '_>,
         id: CharacterId,
-        bitmap_handle: BitmapHandle,
-        width: u16,
-        height: u16,
-    ) -> Self {
-        Self::new_with_bitmap_data(context, id, Some(bitmap_handle), width, height, None, true)
+        bitmap: ruffle_render::bitmap::Bitmap,
+    ) -> Result<Self, ruffle_render::error::Error> {
+        let width = bitmap.width() as u16;
+        let height = bitmap.height() as u16;
+        let bitmap_handle = context.renderer.register_bitmap(bitmap)?;
+        let bitmap_data = None;
+        let smoothing = true;
+        Ok(Self::new_with_bitmap_data(
+            context,
+            id,
+            Some(bitmap_handle),
+            width,
+            height,
+            bitmap_data,
+            smoothing,
+        ))
     }
 
     #[allow(dead_code)]

core/src/display_object/movie_clip.rs

@@ -3004,16 +3004,8 @@ impl<'gc, 'a> MovieClipData<'gc> {
         version: u8,
     ) -> Result<(), Error> {
         let define_bits_lossless = reader.read_define_bits_lossless(version)?;
-        let bitmap_info = context
-            .renderer
-            .register_bitmap_png(&define_bits_lossless)?;
-        let bitmap = Bitmap::new(
-            context,
-            define_bits_lossless.id,
-            bitmap_info.handle,
-            bitmap_info.width,
-            bitmap_info.height,
-        );
+        let bitmap = ruffle_render::utils::decode_define_bits_lossless(&define_bits_lossless)?;
+        let bitmap = Bitmap::new(context, define_bits_lossless.id, bitmap)?;
         context
             .library
             .library_for_movie_mut(self.movie())
@@ -3124,20 +3116,13 @@ impl<'gc, 'a> MovieClipData<'gc> {
     ) -> Result<(), Error> {
         let id = reader.read_u16()?;
         let jpeg_data = reader.read_slice_to_end();
-        let bitmap_info = context.renderer.register_bitmap_jpeg(
-            jpeg_data,
-            context
-                .library
-                .library_for_movie_mut(self.movie())
-                .jpeg_tables(),
-        )?;
-        let bitmap = Bitmap::new(
-            context,
-            id,
-            bitmap_info.handle,
-            bitmap_info.width,
-            bitmap_info.height,
-        );
+        let jpeg_tables = context
+            .library
+            .library_for_movie_mut(self.movie())
+            .jpeg_tables();
+        let jpeg_data = ruffle_render::utils::glue_tables_to_jpeg(jpeg_data, jpeg_tables);
+        let bitmap = ruffle_render::utils::decode_define_bits_jpeg(&jpeg_data, None)?;
+        let bitmap = Bitmap::new(context, id, bitmap)?;
         context
             .library
             .library_for_movie_mut(self.movie())
@@ -3153,14 +3138,8 @@ impl<'gc, 'a> MovieClipData<'gc> {
     ) -> Result<(), Error> {
         let id = reader.read_u16()?;
         let jpeg_data = reader.read_slice_to_end();
-        let bitmap_info = context.renderer.register_bitmap_jpeg_2(jpeg_data)?;
-        let bitmap = Bitmap::new(
-            context,
-            id,
-            bitmap_info.handle,
-            bitmap_info.width,
-            bitmap_info.height,
-        );
+        let bitmap = ruffle_render::utils::decode_define_bits_jpeg(jpeg_data, None)?;
+        let bitmap = Bitmap::new(context, id, bitmap)?;
         context
             .library
             .library_for_movie_mut(self.movie())
@@ -3182,16 +3161,8 @@ impl<'gc, 'a> MovieClipData<'gc> {
         }
         let jpeg_data = reader.read_slice(jpeg_len)?;
         let alpha_data = reader.read_slice_to_end();
-        let bitmap_info = context
-            .renderer
-            .register_bitmap_jpeg_3_or_4(jpeg_data, alpha_data)?;
-        let bitmap = Bitmap::new(
-            context,
-            id,
-            bitmap_info.handle,
-            bitmap_info.width,
-            bitmap_info.height,
-        );
+        let bitmap = ruffle_render::utils::decode_define_bits_jpeg(jpeg_data, Some(alpha_data))?;
+        let bitmap = Bitmap::new(context, id, bitmap)?;
         context
             .library
             .library_for_movie_mut(self.movie())

core/src/loader.rs

@@ -1367,8 +1367,8 @@ impl<'gc> Loader<'gc> {
                         Loader::movie_loader_progress(handle, uc, 0, length)?;
                     }
 
-                    let bitmap = uc.renderer.register_bitmap_jpeg_2(&data)?;
-                    let bitmap_obj = Bitmap::new(uc, 0, bitmap.handle, bitmap.width, bitmap.height);
+                    let bitmap = ruffle_render::utils::decode_define_bits_jpeg(data, None)?;
+                    let bitmap_obj = Bitmap::new(uc, 0, bitmap)?;
 
                     if let Some(mc) = clip.as_movie_clip() {
                         mc.replace_at_depth(uc, bitmap_obj.into(), 1);

render/src/backend.rs

@@ -1,10 +1,9 @@
 pub mod null;
 
-use crate::bitmap::{Bitmap, BitmapHandle, BitmapInfo, BitmapSource};
+use crate::bitmap::{Bitmap, BitmapHandle, BitmapSource};
 use crate::commands::CommandList;
 use crate::error::Error;
 use crate::shape_utils::DistilledShape;
-use crate::utils;
 use downcast_rs::{impl_downcast, Downcast};
 use swf;
 use swf::Color;
@@ -27,15 +26,6 @@ pub trait RenderBackend: Downcast {
     );
     fn register_glyph_shape(&mut self, shape: &swf::Glyph) -> ShapeHandle;
 
-    fn register_bitmap_jpeg(
-        &mut self,
-        data: &[u8],
-        jpeg_tables: Option<&[u8]>,
-    ) -> Result<BitmapInfo, Error> {
-        let data = utils::glue_tables_to_jpeg(data, jpeg_tables);
-        self.register_bitmap_jpeg_2(&data)
-    }
-
     /// Creates a new `RenderBackend` which renders directly
     /// to the texture specified by `BitmapHandle` with the given
     /// `width` and `height`. This backend is passed to the callback
@@ -54,49 +44,6 @@ pub trait RenderBackend: Downcast {
         clear_color: Color,
     ) -> Result<Bitmap, Error>;
 
-    fn register_bitmap_jpeg_2(&mut self, data: &[u8]) -> Result<BitmapInfo, Error> {
-        let bitmap = utils::decode_define_bits_jpeg(data, None)?;
-        let width = bitmap.width() as u16;
-        let height = bitmap.height() as u16;
-        let handle = self.register_bitmap(bitmap)?;
-        Ok(BitmapInfo {
-            handle,
-            width,
-            height,
-        })
-    }
-
-    fn register_bitmap_jpeg_3_or_4(
-        &mut self,
-        jpeg_data: &[u8],
-        alpha_data: &[u8],
-    ) -> Result<BitmapInfo, Error> {
-        let bitmap = utils::decode_define_bits_jpeg(jpeg_data, Some(alpha_data))?;
-        let width = bitmap.width() as u16;
-        let height = bitmap.height() as u16;
-        let handle = self.register_bitmap(bitmap)?;
-        Ok(BitmapInfo {
-            handle,
-            width,
-            height,
-        })
-    }
-
-    fn register_bitmap_png(
-        &mut self,
-        swf_tag: &swf::DefineBitsLossless,
-    ) -> Result<BitmapInfo, Error> {
-        let bitmap = utils::decode_define_bits_lossless(swf_tag)?;
-        let width = bitmap.width() as u16;
-        let height = bitmap.height() as u16;
-        let handle = self.register_bitmap(bitmap)?;
-        Ok(BitmapInfo {
-            handle,
-            width,
-            height,
-        })
-    }
-
     fn submit_frame(&mut self, clear: swf::Color, commands: CommandList);
 
     fn get_bitmap_pixels(&mut self, bitmap: BitmapHandle) -> Option<Bitmap>;