avm2: Implement SoundChannel.position

Fix various issues with `SoundChannel`:
 * Change `avm2::Object::as_sound_instance` to `as_sound_channel`.
 * Cache sound position in `SoundChannelObject`.
 * `SoundInfo::in_sample` is in units of 44100Hz.
 * Clamp `num_loops` to 1.

Author: Herschel

core/src/avm2.rs

@@ -50,7 +50,7 @@ pub use crate::avm2::domain::Domain;
 pub use crate::avm2::events::Event;
 pub use crate::avm2::names::{Namespace, QName};
 pub use crate::avm2::object::{
-    ArrayObject, ClassObject, Object, ScriptObject, StageObject, TObject,
+    ArrayObject, ClassObject, Object, ScriptObject, SoundChannelObject, StageObject, TObject,
 };
 pub use crate::avm2::value::Value;
 

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

@@ -124,7 +124,7 @@ pub fn play<'gc>(
             .get(1)
             .cloned()
             .unwrap_or_else(|| 0.into())
-            .coerce_to_i32(activation)? as u16;
+            .coerce_to_i32(activation)?;
         let sound_transform = args
             .get(2)
             .cloned()
@@ -138,14 +138,8 @@ pub fn play<'gc>(
             }
         }
 
-        let sample_rate = if let Some(format) = activation.context.audio.get_sound_format(sound) {
-            format.sample_rate
-        } else {
-            return Ok(Value::Null);
-        };
-
         let in_sample = if position > 0.0 {
-            Some((position / 1000.0 * sample_rate as f64) as u32)
+            Some((position / 1000.0 * 44100.0) as u32)
         } else {
             None
         };
@@ -154,7 +148,7 @@ pub fn play<'gc>(
             event: SoundEvent::Start,
             in_sample,
             out_sample: None,
-            num_loops,
+            num_loops: num_loops.max(1) as u16,
             envelope: None,
         };
 

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

@@ -53,10 +53,13 @@ pub fn right_peak<'gc>(
 /// Impl `SoundChannel.position`
 pub fn position<'gc>(
     _activation: &mut Activation<'_, 'gc, '_>,
-    _this: Option<Object<'gc>>,
+    this: Option<Object<'gc>>,
     _args: &[Value<'gc>],
 ) -> Result<Value<'gc>, Error> {
-    Err("Sound.position is a stub.".into())
+    if let Some(instance) = this.and_then(|this| this.as_sound_channel()) {
+        return Ok(instance.position().into());
+    }
+    Ok(Value::Undefined)
 }
 
 /// Implements `soundTransform`'s getter
@@ -65,7 +68,10 @@ pub fn sound_transform<'gc>(
     this: Option<Object<'gc>>,
     _args: &[Value<'gc>],
 ) -> Result<Value<'gc>, Error> {
-    if let Some(instance) = this.and_then(|this| this.as_sound_instance()) {
+    if let Some(instance) = this
+        .and_then(|this| this.as_sound_channel())
+        .and_then(|channel| channel.instance())
+    {
         let dobj_st = activation.context.local_sound_transform(instance).cloned();
 
         if let Some(dobj_st) = dobj_st {
@@ -82,7 +88,10 @@ pub fn set_sound_transform<'gc>(
     this: Option<Object<'gc>>,
     args: &[Value<'gc>],
 ) -> Result<Value<'gc>, Error> {
-    if let Some(instance) = this.and_then(|this| this.as_sound_instance()) {
+    if let Some(instance) = this
+        .and_then(|this| this.as_sound_channel())
+        .and_then(|channel| channel.instance())
+    {
         let as3_st = args
             .get(0)
             .cloned()
@@ -104,7 +113,10 @@ pub fn stop<'gc>(
     this: Option<Object<'gc>>,
     _args: &[Value<'gc>],
 ) -> Result<Value<'gc>, Error> {
-    if let Some(instance) = this.and_then(|this| this.as_sound_instance()) {
+    if let Some(instance) = this
+        .and_then(|this| this.as_sound_channel())
+        .and_then(|channel| channel.instance())
+    {
         activation.context.stop_sound(instance);
     }
 

core/src/avm2/object.rs

@@ -1197,7 +1197,7 @@ pub trait TObject<'gc>: 'gc + Collect + Debug + Into<Object<'gc>> + Clone + Copy
     fn set_sound(self, _mc: MutationContext<'gc, '_>, _sound: SoundHandle) {}
 
     /// Unwrap this object's sound instance handle.
-    fn as_sound_instance(self) -> Option<SoundInstanceHandle> {
+    fn as_sound_channel(self) -> Option<SoundChannelObject<'gc>> {
         None
     }
 

core/src/avm2/object/soundchannel_object.rs

@@ -20,7 +20,11 @@ pub fn soundchannel_allocator<'gc>(
 
     Ok(SoundChannelObject(GcCell::allocate(
         activation.context.gc_context,
-        SoundChannelObjectData { base, sound: None },
+        SoundChannelObjectData {
+            base,
+            sound: None,
+            position: 0.0,
+        },
     ))
     .into())
 }
@@ -38,14 +42,17 @@ pub struct SoundChannelObjectData<'gc> {
     /// The sound this object holds.
     #[collect(require_static)]
     sound: Option<SoundInstanceHandle>,
+
+    /// Position of the last playing sound in milliseconds.
+    position: f64,
 }
 
 impl<'gc> SoundChannelObject<'gc> {
     /// Convert a bare sound instance into it's object representation.
     pub fn from_sound_instance(
         activation: &mut Activation<'_, 'gc, '_>,
         sound: SoundInstanceHandle,
-    ) -> Result<Object<'gc>, Error> {
+    ) -> Result<Self, Error> {
         let class = activation.avm2().classes().soundchannel;
         let proto = class
             .get_property(
@@ -56,20 +63,35 @@ impl<'gc> SoundChannelObject<'gc> {
             .coerce_to_object(activation)?;
         let base = ScriptObjectData::base_new(Some(proto), Some(class));
 
-        let mut sound_object: Object<'gc> = SoundChannelObject(GcCell::allocate(
+        let mut sound_object = SoundChannelObject(GcCell::allocate(
             activation.context.gc_context,
             SoundChannelObjectData {
                 base,
                 sound: Some(sound),
+                position: 0.0,
             },
-        ))
-        .into();
+        ));
         sound_object.install_instance_traits(activation, class)?;
 
-        class.call_native_init(Some(sound_object), &[], activation, Some(class))?;
+        class.call_native_init(Some(sound_object.into()), &[], activation, Some(class))?;
 
         Ok(sound_object)
     }
+
+    /// Return the backend handle to the currently playing sound instance.
+    pub fn instance(self) -> Option<SoundInstanceHandle> {
+        self.0.read().sound
+    }
+
+    /// Return the position of the playing sound in seconds.
+    pub fn position(self) -> f64 {
+        self.0.read().position
+    }
+
+    /// Set the position of the playing sound in seconds.
+    pub fn set_position(self, mc: MutationContext<'gc, '_>, value: f64) {
+        self.0.write(mc).position = value;
+    }
 }
 
 impl<'gc> TObject<'gc> for SoundChannelObject<'gc> {
@@ -94,13 +116,17 @@ impl<'gc> TObject<'gc> for SoundChannelObject<'gc> {
 
         Ok(SoundChannelObject(GcCell::allocate(
             activation.context.gc_context,
-            SoundChannelObjectData { base, sound: None },
+            SoundChannelObjectData {
+                base,
+                sound: None,
+                position: 0.0,
+            },
         ))
         .into())
     }
 
-    fn as_sound_instance(self) -> Option<SoundInstanceHandle> {
-        self.0.read().sound
+    fn as_sound_channel(self) -> Option<SoundChannelObject<'gc>> {
+        Some(self)
     }
 
     fn set_sound_instance(self, mc: MutationContext<'gc, '_>, sound: SoundInstanceHandle) {

core/src/backend/audio.rs

@@ -1,7 +1,7 @@
 use crate::{
     avm1::SoundObject,
     avm2::Event as Avm2Event,
-    avm2::Object as Avm2Object,
+    avm2::SoundChannelObject,
     display_object::{self, DisplayObject, MovieClip, TDisplayObject},
 };
 use downcast_rs::Downcast;
@@ -272,18 +272,19 @@ impl<'gc> AudioManager<'gc> {
                 // Sounds still playing; update position.
                 if let Some(avm1_object) = sound.avm1_object {
                     avm1_object.set_position(gc_context, pos.round() as u32);
+                } else if let Some(avm2_object) = sound.avm2_object {
+                    avm2_object.set_position(gc_context, pos);
                 }
                 true
             } else {
                 // Sound ended.
+                let duration = sound
+                    .sound
+                    .and_then(|sound| audio.get_sound_duration(sound))
+                    .unwrap_or_default();
                 if let Some(object) = sound.avm1_object {
-                    // Set position to end of sound.
-                    if let Some(duration) = sound
-                        .sound
-                        .and_then(|sound| audio.get_sound_duration(sound))
-                    {
-                        object.set_position(gc_context, duration.round() as u32);
-                    }
+                    object.set_position(gc_context, duration.round() as u32);
+
                     // Fire soundComplete event.
                     action_queue.queue_actions(
                         root,
@@ -297,13 +298,15 @@ impl<'gc> AudioManager<'gc> {
                 }
 
                 if let Some(object) = sound.avm2_object {
+                    object.set_position(gc_context, duration);
+
                     //TODO: AVM2 events are usually not queued, but we can't
                     //hold the update context in the audio manager yet.
                     action_queue.queue_actions(
                         root,
                         crate::context::ActionType::Event2 {
                             event: Avm2Event::new("soundComplete"),
-                            target: object,
+                            target: object.into(),
                         },
                         false,
                     )
@@ -346,7 +349,7 @@ impl<'gc> AudioManager<'gc> {
     pub fn attach_avm2_sound_channel(
         &mut self,
         instance: SoundInstanceHandle,
-        avm2_object: Avm2Object<'gc>,
+        avm2_object: SoundChannelObject<'gc>,
     ) {
         if let Some(i) = self
             .sounds
@@ -556,8 +559,8 @@ pub struct SoundInstance<'gc> {
     /// The AVM1 `Sound` object associated with this sound, if any.
     avm1_object: Option<SoundObject<'gc>>,
 
-    /// The AVM2 `Sound` object associated with this sound, if any.
-    avm2_object: Option<Avm2Object<'gc>>,
+    /// The AVM2 `SoundChannel` object associated with this sound, if any.
+    avm2_object: Option<SoundChannelObject<'gc>>,
 }
 
 /// A sound transform for a playing sound, for use by audio backends.

core/src/context.rs

@@ -2,7 +2,9 @@
 
 use crate::avm1::globals::system::SystemProperties;
 use crate::avm1::{Avm1, Object as Avm1Object, Timers, Value as Avm1Value};
-use crate::avm2::{Avm2, Event as Avm2Event, Object as Avm2Object, Value as Avm2Value};
+use crate::avm2::{
+    Avm2, Event as Avm2Event, Object as Avm2Object, SoundChannelObject, Value as Avm2Value,
+};
 use crate::backend::{
     audio::{AudioBackend, AudioManager, SoundHandle, SoundInstanceHandle},
     locale::LocaleBackend,
@@ -212,7 +214,7 @@ impl<'a, 'gc, 'gc_context> UpdateContext<'a, 'gc, 'gc_context> {
     pub fn attach_avm2_sound_channel(
         &mut self,
         instance: SoundInstanceHandle,
-        avm2_object: Avm2Object<'gc>,
+        avm2_object: SoundChannelObject<'gc>,
     ) {
         self.audio_manager
             .attach_avm2_sound_channel(instance, avm2_object);