Video base/stub impls

core/src/avm1/globals.rs

@@ -55,6 +55,7 @@ pub(crate) mod system_security;
 pub(crate) mod text_field;
 mod text_format;
 mod transform;
+mod video;
 mod xml;
 
 pub fn random<'gc>(
@@ -506,6 +507,8 @@ pub struct SystemPrototypes<'gc> {
     pub date: Object<'gc>,
     pub bitmap_data: Object<'gc>,
     pub bitmap_data_constructor: Object<'gc>,
+    pub video: Object<'gc>,
+    pub video_constructor: Object<'gc>,
 }
 
 /// Initialize default global scope and builtins for an AVM1 instance.
@@ -582,6 +585,8 @@ pub fn create_globals<'gc>(
     );
     let date_proto: Object<'gc> = date::create_proto(gc_context, object_proto, function_proto);
 
+    let video_proto: Object<'gc> = video::create_proto(gc_context, object_proto, function_proto);
+
     //TODO: These need to be constructors and should also set `.prototype` on each one
     let object = object::create_object_object(gc_context, object_proto, function_proto);
 
@@ -697,6 +702,13 @@ pub fn create_globals<'gc>(
         Some(function_proto),
         transform_proto,
     );
+    let video = FunctionObject::constructor(
+        gc_context,
+        Executable::Native(video::constructor),
+        constructor_to_fn!(video::constructor),
+        Some(function_proto),
+        video_proto,
+    );
 
     flash.define_value(gc_context, "geom", geom.into(), Attribute::empty());
     flash.define_value(gc_context, "filters", filters.into(), Attribute::empty());
@@ -1255,6 +1267,8 @@ pub fn create_globals<'gc>(
             date: date_proto,
             bitmap_data: bitmap_data_proto,
             bitmap_data_constructor: bitmap_data,
+            video: video_proto,
+            video_constructor: video,
         },
         globals.into(),
         broadcaster_functions,

core/src/avm1/globals/video.rs

@@ -0,0 +1,30 @@
+//! Video class
+
+use crate::avm1::activation::Activation;
+use crate::avm1::error::Error;
+use crate::avm1::globals::display_object;
+use crate::avm1::object::Object;
+use crate::avm1::value::Value;
+use crate::avm1::ScriptObject;
+use gc_arena::MutationContext;
+
+/// Implements `Video`
+pub fn constructor<'gc>(
+    _activation: &mut Activation<'_, 'gc, '_>,
+    _this: Object<'gc>,
+    _args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error<'gc>> {
+    Ok(Value::Undefined)
+}
+
+pub fn create_proto<'gc>(
+    gc_context: MutationContext<'gc, '_>,
+    proto: Object<'gc>,
+    fn_proto: Object<'gc>,
+) -> Object<'gc> {
+    let object = ScriptObject::object(gc_context, Some(proto));
+
+    display_object::define_display_object_proto(gc_context, object, fn_proto);
+
+    object.into()
+}

core/src/avm1/object/script_object.rs

@@ -842,6 +842,7 @@ mod tests {
     use crate::backend::render::NullRenderer;
     use crate::backend::storage::MemoryStorageBackend;
     use crate::backend::ui::NullUiBackend;
+    use crate::backend::video::NullVideoBackend;
     use crate::context::UpdateContext;
     use crate::display_object::MovieClip;
     use crate::focus_tracker::FocusTracker;
@@ -890,6 +891,7 @@ mod tests {
                 renderer: &mut NullRenderer::new(),
                 locale: &mut NullLocaleBackend::new(),
                 log: &mut NullLogBackend::new(),
+                video: &mut NullVideoBackend::new(),
                 mouse_hovered_object: None,
                 mouse_position: &(Twips::new(0), Twips::new(0)),
                 drag_object: &mut None,

core/src/avm1/test_utils.rs

@@ -10,6 +10,7 @@ use crate::backend::navigator::NullNavigatorBackend;
 use crate::backend::render::NullRenderer;
 use crate::backend::storage::MemoryStorageBackend;
 use crate::backend::ui::NullUiBackend;
+use crate::backend::video::NullVideoBackend;
 use crate::context::ActionQueue;
 use crate::display_object::{MovieClip, TDisplayObject};
 use crate::focus_tracker::FocusTracker;
@@ -59,6 +60,7 @@ where
             renderer: &mut NullRenderer::new(),
             locale: &mut NullLocaleBackend::new(),
             log: &mut NullLogBackend::new(),
+            video: &mut NullVideoBackend::new(),
             mouse_hovered_object: None,
             mouse_position: &(Twips::new(0), Twips::new(0)),
             drag_object: &mut None,

core/src/avm2/globals.rs

@@ -95,6 +95,7 @@ pub struct SystemPrototypes<'gc> {
     pub scene: Object<'gc>,
     pub application_domain: Object<'gc>,
     pub event: Object<'gc>,
+    pub video: Object<'gc>,
 }
 
 impl<'gc> SystemPrototypes<'gc> {
@@ -128,6 +129,7 @@ impl<'gc> SystemPrototypes<'gc> {
             scene: empty,
             application_domain: empty,
             event: empty,
+            video: empty,
         }
     }
 }
@@ -554,5 +556,20 @@ pub fn load_player_globals<'gc>(
         script,
     )?;
 
+    // package `flash.media`
+    activation
+        .context
+        .avm2
+        .system_prototypes
+        .as_mut()
+        .unwrap()
+        .video = class(
+        activation,
+        flash::media::video::create_class(mc),
+        implicit_deriver,
+        domain,
+        script,
+    )?;
+
     Ok(())
 }

core/src/avm2/globals/flash.rs

@@ -2,4 +2,5 @@
 
 pub mod display;
 pub mod events;
+pub mod media;
 pub mod system;

core/src/avm2/globals/flash/media.rs

@@ -0,0 +1,3 @@
+//! `flash.media` namespace
+
+pub mod video;

core/src/avm2/globals/flash/media/video.rs

@@ -0,0 +1,49 @@
+//! `flash.media.Video` builtin/prototype
+
+use crate::avm2::activation::Activation;
+use crate::avm2::class::{Class, ClassAttributes};
+use crate::avm2::method::Method;
+use crate::avm2::names::{Namespace, QName};
+use crate::avm2::object::Object;
+use crate::avm2::value::Value;
+use crate::avm2::Error;
+use gc_arena::{GcCell, MutationContext};
+
+/// Implements `flash.media.Video`'s instance constructor.
+pub fn instance_init<'gc>(
+    activation: &mut Activation<'_, 'gc, '_>,
+    this: Option<Object<'gc>>,
+    _args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error> {
+    if let Some(this) = this {
+        activation.super_init(this, &[])?;
+    }
+
+    Ok(Value::Undefined)
+}
+
+/// Implements `flash.media.Video`'s class constructor.
+pub fn class_init<'gc>(
+    _activation: &mut Activation<'_, 'gc, '_>,
+    _this: Option<Object<'gc>>,
+    _args: &[Value<'gc>],
+) -> Result<Value<'gc>, Error> {
+    Ok(Value::Undefined)
+}
+
+/// Construct `Video`'s class.
+pub fn create_class<'gc>(mc: MutationContext<'gc, '_>) -> GcCell<'gc, Class<'gc>> {
+    let class = Class::new(
+        QName::new(Namespace::package("flash.media"), "Video"),
+        Some(QName::new(Namespace::package("flash.media"), "DisplayObject").into()),
+        Method::from_builtin(instance_init),
+        Method::from_builtin(class_init),
+        mc,
+    );
+
+    let mut write = class.write(mc);
+
+    write.set_attributes(ClassAttributes::SEALED);
+
+    class
+}

core/src/backend.rs

@@ -5,3 +5,4 @@ pub mod navigator;
 pub mod render;
 pub mod storage;
 pub mod ui;
+pub mod video;

core/src/backend/video.rs

@@ -0,0 +1,172 @@
+//! Video decoder backends
+
+use crate::backend::render::{BitmapInfo, RenderBackend};
+use generational_arena::{Arena, Index};
+use swf::{VideoCodec, VideoDeblocking};
+
+mod software;
+
+pub use crate::backend::video::software::SoftwareVideoBackend;
+
+pub type VideoStreamHandle = Index;
+
+pub type Error = Box<dyn std::error::Error>;
+
+/// An encoded video frame of some video codec.
+pub struct EncodedFrame<'a> {
+    /// The codec used to encode the frame.
+    pub codec: VideoCodec,
+
+    /// The raw bitstream data to funnel into the codec.
+    pub data: &'a [u8],
+
+    /// A caller-specified frame ID. Frame IDs must be consistent between
+    /// subsequent uses of the same data stream.
+    pub frame_id: u32,
+}
+
+impl<'a> EncodedFrame<'a> {
+    /// Borrow this frame's data.
+    pub fn data(&'a self) -> &'a [u8] {
+        &self.data
+    }
+}
+
+/// What dependencies a given video frame has on any previous frames.
+#[derive(Copy, Clone, Debug)]
+pub enum FrameDependency {
+    /// This frame has no reference frames and can be seeked to at any time.
+    None,
+
+    /// This frame has some number of reference frames that prohibit any
+    /// out-of-order decoding.
+    ///
+    /// The only legal way to decode a `Past` frame is to decode every prior
+    /// frame from the last `None` frame. In the event that there is no prior
+    /// `None` frame, then video decoding should start from the beginning.
+    Past,
+}
+
+impl FrameDependency {
+    /// Determine if this given frame is a keyframe.
+    ///
+    /// A keyframe is a frame that can be independently seeked to without
+    /// decoding any prior or future frames.
+    pub fn is_keyframe(self) -> bool {
+        matches!(self, FrameDependency::None)
+    }
+}
+
+/// A backend that provides access to some number of video decoders.
+///
+/// Implementations of `VideoBackend` are not required to actually support
+/// decoding any video formats. However, they must interoperate with at least
+/// one `RenderBackend` so that renderable video frames may be passed from the
+/// decoder to the renderer.
+pub trait VideoBackend {
+    /// Register a new video stream.
+    ///
+    /// Most of the parameters provided to this function are advisory: the
+    /// actual video data stream provided to the decoder may vary in size or
+    /// number of frames. This function should return an `Error` if it is not
+    /// possible to decode video with the given parameters.
+    fn register_video_stream(
+        &mut self,
+        num_frames: u32,
+        size: (u16, u16),
+        codec: VideoCodec,
+        filter: VideoDeblocking,
+    ) -> Result<VideoStreamHandle, Error>;
+
+    /// Preload a frame of a given video stream.
+    ///
+    /// No decoding is intended to happen at this point in time. Instead, the
+    /// video data should be inspected to determine inter-frame dependencies
+    /// between this and any previous frames in the stream.
+    ///
+    /// Frames should be preloaded in the order that they are recieved.
+    ///
+    /// Any dependencies listed here are inherent to the video bitstream. The
+    /// containing video stream is also permitted to introduce additional
+    /// interframe dependencies.
+    fn preload_video_stream_frame(
+        &mut self,
+        stream: VideoStreamHandle,
+        encoded_frame: EncodedFrame<'_>,
+    ) -> Result<FrameDependency, Error>;
+
+    /// Decode a frame of a given video stream.
+    ///
+    /// This function is provided the external index of the frame, the codec
+    /// used to decode the data, and what codec to decode it with. The codec
+    /// provided here must match the one used to register the video stream.
+    ///
+    /// Frames may be decoded in any order that does not violate the frame
+    /// dependencies declared by the output of `preload_video_stream_frame`.
+    ///
+    /// The resulting `BitmapInfo` will be renderable only on the given
+    /// `RenderBackend`. `VideoBackend` implementations are allowed to return
+    /// an error if a drawable bitmap cannot be produced for the given
+    /// renderer.
+    fn decode_video_stream_frame(
+        &mut self,
+        stream: VideoStreamHandle,
+        encoded_frame: EncodedFrame<'_>,
+        renderer: &mut dyn RenderBackend,
+    ) -> Result<BitmapInfo, Error>;
+}
+
+pub struct NullVideoBackend {
+    streams: Arena<()>,
+}
+
+/// Implementation of video that does not decode any video.
+///
+/// Specifically:
+///
+///  * Registering a video stream succeeds but does nothing
+///  * All video frames are silently marked as keyframes (`None` dependency)
+///  * Video stream decoding fails with an error that video decoding is
+///    unimplemented
+impl NullVideoBackend {
+    pub fn new() -> Self {
+        Self {
+            streams: Arena::new(),
+        }
+    }
+}
+
+impl Default for NullVideoBackend {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl VideoBackend for NullVideoBackend {
+    fn register_video_stream(
+        &mut self,
+        _num_frames: u32,
+        _size: (u16, u16),
+        _codec: VideoCodec,
+        _filter: VideoDeblocking,
+    ) -> Result<VideoStreamHandle, Error> {
+        Ok(self.streams.insert(()))
+    }
+
+    fn preload_video_stream_frame(
+        &mut self,
+        _stream: VideoStreamHandle,
+        _encoded_frame: EncodedFrame<'_>,
+    ) -> Result<FrameDependency, Error> {
+        Ok(FrameDependency::None)
+    }
+
+    fn decode_video_stream_frame(
+        &mut self,
+        _stream: VideoStreamHandle,
+        _encoded_frame: EncodedFrame<'_>,
+        _renderer: &mut dyn RenderBackend,
+    ) -> Result<BitmapInfo, Error> {
+        Err("Video decoding not implemented".into())
+    }
+}