From c4a50908d44bf08622f725ce121ff593d8a8c3ee Mon Sep 17 00:00:00 2001 From: NeeEoo Date: Fri, 13 Jan 2023 04:22:00 +0100 Subject: [PATCH] Support for 50 minute songs (html5 untested)) Experimental support for 3+ hour long songs comes later --- buildnumber.txt | 2 +- .../backend/html5/HTML5AudioSource.hx | 253 ++++++++++++++++++ .../backend/native/NativeAudioSource.hx | 69 ++--- source/lime/media/AudioSource.hx | 12 +- source/openfl/media/Sound.hx | 36 +-- source/openfl/media/SoundChannel.hx | 238 ++++++++++++++++ 6 files changed, 544 insertions(+), 66 deletions(-) create mode 100644 source/lime/_internal/backend/html5/HTML5AudioSource.hx create mode 100644 source/openfl/media/SoundChannel.hx diff --git a/buildnumber.txt b/buildnumber.txt index abf9e63a..4d2b2566 100644 --- a/buildnumber.txt +++ b/buildnumber.txt @@ -1 +1 @@ -2036 \ No newline at end of file +2042 \ No newline at end of file diff --git a/source/lime/_internal/backend/html5/HTML5AudioSource.hx b/source/lime/_internal/backend/html5/HTML5AudioSource.hx new file mode 100644 index 00000000..bfca4198 --- /dev/null +++ b/source/lime/_internal/backend/html5/HTML5AudioSource.hx @@ -0,0 +1,253 @@ +package lime._internal.backend.html5; + +import lime.math.Vector4; +import lime.media.AudioSource; + +@:access(lime.media.AudioBuffer) +class HTML5AudioSource +{ + private var completed:Bool; + private var gain:Float; + private var id:Int; + private var length:Float; + private var loops:Int; + private var parent:AudioSource; + private var playing:Bool; + private var position:Vector4; + + public function new(parent:AudioSource) + { + this.parent = parent; + + id = -1; + gain = 1; + position = new Vector4(); + } + + public function dispose():Void {} + + public function init():Void {} + + public function play():Void + { + #if lime_howlerjs + if (playing || parent.buffer == null || parent.buffer.__srcHowl == null) + { + return; + } + + playing = true; + + var time = getCurrentTime(); + + completed = false; + + var cacheVolume = untyped parent.buffer.__srcHowl._volume; + untyped parent.buffer.__srcHowl._volume = parent.gain; + + id = parent.buffer.__srcHowl.play(); + + untyped parent.buffer.__srcHowl._volume = cacheVolume; + // setGain (parent.gain); + + setPosition(parent.position); + + parent.buffer.__srcHowl.on("end", howl_onEnd, id); + + // Calling setCurrentTime causes html5 audio to replay from this position on next frame + #if force_html5_audio + if (time == 0) setCurrentTime(time); + #else + setCurrentTime(time); + #end + #end + } + + public function pause():Void + { + #if lime_howlerjs + playing = false; + + if (parent.buffer != null && parent.buffer.__srcHowl != null) + { + parent.buffer.__srcHowl.pause(id); + } + #end + } + + public function stop():Void + { + #if lime_howlerjs + playing = false; + + if (parent.buffer != null && parent.buffer.__srcHowl != null) + { + parent.buffer.__srcHowl.stop(id); + parent.buffer.__srcHowl.off("end", howl_onEnd, id); + } + #end + } + + // Event Handlers + private function howl_onEnd() + { + #if lime_howlerjs + playing = false; + + if (loops > 0) + { + loops--; + stop(); + // currentTime = 0; + play(); + return; + } + else if (parent.buffer != null && parent.buffer.__srcHowl != null) + { + parent.buffer.__srcHowl.stop(id); + parent.buffer.__srcHowl.off("end", howl_onEnd, id); + } + + completed = true; + parent.onComplete.dispatch(); + #end + } + + // Get & Set Methods + public function getCurrentTime():Float + { + if (id == -1) + { + return 0; + } + + #if lime_howlerjs + if (completed) + { + return getLength(); + } + else if (parent.buffer != null && parent.buffer.__srcHowl != null) + { + var time = (parent.buffer.__srcHowl.seek(id) * 1000) - parent.offset; + if (time < 0) return 0; + return time; + } + #end + + return 0; + } + + public function setCurrentTime(value:Float):Float + { + #if lime_howlerjs + if (parent.buffer != null && parent.buffer.__srcHowl != null) + { + // if (playing) buffer.__srcHowl.play (id); + var pos = (value + parent.offset) / 1000; + if (pos < 0) pos = 0; + parent.buffer.__srcHowl.seek(pos, id); + } + #end + + return value; + } + + public function getGain():Float + { + return gain; + } + + public function setGain(value:Float):Float + { + #if lime_howlerjs + // set howler volume only if we have an active id. + // Passing -1 might create issues in future play()'s. + + if (parent.buffer != null && parent.buffer.__srcHowl != null && id != -1) + { + parent.buffer.__srcHowl.volume(value, id); + } + #end + + return gain = value; + } + + public function getLength():Float + { + if (length != 0) + { + return length; + } + + #if lime_howlerjs + if (parent.buffer != null && parent.buffer.__srcHowl != null) + { + return parent.buffer.__srcHowl.duration() * 1000; + } + #end + + return 0; + } + + public function setLength(value:Float):Float + { + return length = value; + } + + public function getLoops():Int + { + return loops; + } + + public function setLoops(value:Int):Int + { + return loops = value; + } + + public function getPitch():Float + { + #if lime_howlerjs + return parent.buffer.__srcHowl.rate(); + #else + return 1; + #end + } + + public function setPitch(value:Float):Float + { + #if lime_howlerjs + parent.buffer.__srcHowl.rate(value); + #end + return getPitch(); + } + + public function getPosition():Vector4 + { + #if lime_howlerjs + // This should work, but it returns null (But checking the inside of the howl, the _pos is actually null... so ¯\_(ツ)_/¯) + /* + var arr = parent.buffer.__srcHowl.pos()) + position.x = arr[0]; + position.y = arr[1]; + position.z = arr[2]; + */ + #end + + return position; + } + + public function setPosition(value:Vector4):Vector4 + { + position.x = value.x; + position.y = value.y; + position.z = value.z; + position.w = value.w; + + #if lime_howlerjs + if (parent.buffer != null && parent.buffer.__srcHowl != null && parent.buffer.__srcHowl.pos != null) parent.buffer.__srcHowl.pos(position.x, position.y, position.z, id); + // There are more settings to the position of the sound on the "pannerAttr()" function of howler. Maybe somebody who understands sound should look into it? + #end + + return position; + } +} \ No newline at end of file diff --git a/source/lime/_internal/backend/native/NativeAudioSource.hx b/source/lime/_internal/backend/native/NativeAudioSource.hx index a4c6fdff..e7cbd821 100644 --- a/source/lime/_internal/backend/native/NativeAudioSource.hx +++ b/source/lime/_internal/backend/native/NativeAudioSource.hx @@ -34,16 +34,19 @@ class NativeAudioSource private var dataLength:Int; private var format:Int; private var handle:ALSource; - private var length:Null; + private var length:Null; private var loops:Int; private var parent:AudioSource; private var playing:Bool; private var position:Vector4; - private var samples:Int; + private var samples:Float; private var stream:Bool; private var streamTimer:Timer; private var timer:Timer; + private var pcmTotal:Int64; + private var sampleRate:Int; + var disposed:Bool = false; public function new(parent:AudioSource) @@ -107,7 +110,11 @@ class NativeAudioSource stream = true; var vorbisFile = parent.buffer.__srcVorbisFile; - dataLength = Std.int(Int64.toInt(vorbisFile.pcmTotal()) * parent.buffer.channels * (parent.buffer.bitsPerSample / 8)); + pcmTotal = vorbisFile.pcmTotal(); + var info = vorbisFile.info(); + sampleRate = info.rate; + var _dataLength = pcmTotal * Int64.ofInt(parent.buffer.channels) * (Int64.ofInt(parent.buffer.bitsPerSample) / Int64.ofInt(8)); + dataLength = Int64.toInt(_dataLength); buffers = new Array(); bufferTimeBlocks = new Array(); @@ -119,6 +126,8 @@ class NativeAudioSource } handle = AL.createSource(); + + samples = Int64.toInt(pcmTotal); } else { @@ -140,43 +149,15 @@ class NativeAudioSource { AL.sourcei(handle, AL.BUFFER, parent.buffer.__srcBuffer); } - } - samples = Std.int((dataLength * 8) / (parent.buffer.channels * parent.buffer.bitsPerSample)); + samples = Int64.toInt((Int64.make(0, dataLength) * Int64.ofInt(8)) / Int64.ofInt(parent.buffer.channels * parent.buffer.bitsPerSample)); + } initBuffers.push(this); } public function play():Void { - /*var pitch:Float = AL.getSourcef (handle, AL.PITCH); - trace(pitch); - AL.sourcef (handle, AL.PITCH, pitch*0.9); - pitch = AL.getSourcef (handle, AL.PITCH); - trace(pitch); */ - /*var pos = getPosition(); - trace(AL.DISTANCE_MODEL); - AL.distanceModel(AL.INVERSE_DISTANCE); - trace(AL.DISTANCE_MODEL); - AL.sourcef(handle, AL.ROLLOFF_FACTOR, 5); - setPosition(new Vector4(10, 10, -100)); - pos = getPosition(); - trace(pos); */ - /*var filter = AL.createFilter(); - trace(AL.getErrorString()); - - AL.filteri(filter, AL.FILTER_TYPE, AL.FILTER_LOWPASS); - trace(AL.getErrorString()); - - AL.filterf(filter, AL.LOWPASS_GAIN, 0.5); - trace(AL.getErrorString()); - - AL.filterf(filter, AL.LOWPASS_GAINHF, 0.5); - trace(AL.getErrorString()); - - AL.sourcei(handle, AL.DIRECT_FILTER, filter); - trace(AL.getErrorString()); */ - if (disposed) { trace("TRIED TO PLAY DISPOSED?? WTFFF"); trace(haxe.CallStack.toString(haxe.CallStack.callStack())); @@ -373,7 +354,7 @@ class NativeAudioSource } // Get & Set Methods - public function getCurrentTime():Int + public function getCurrentTime():Float { if (completed) { @@ -389,11 +370,11 @@ class NativeAudioSource } else { - var offset = AL.getSourcei(handle, AL.BYTE_OFFSET); + var offset:Int = AL.getSourcei(handle, AL.BYTE_OFFSET); var ratio = (offset / dataLength); var totalSeconds = samples / parent.buffer.sampleRate; - var time = Std.int(totalSeconds * ratio * 1000) - parent.offset; + var time = totalSeconds * ratio * 1000 - parent.offset; // var time = Std.int (AL.getSourcef (handle, AL.SEC_OFFSET) * 1000) - parent.offset; if (time < 0) return 0; @@ -404,7 +385,7 @@ class NativeAudioSource return 0; } - public function setCurrentTime(value:Int):Int + public function setCurrentTime(value:Float):Float { // `setCurrentTime()` has side effects and is never safe to skip. /* if (value == getCurrentTime()) @@ -434,7 +415,7 @@ class NativeAudioSource var totalSeconds = samples / parent.buffer.sampleRate; if (secondOffset < 0) secondOffset = 0; - if (secondOffset > totalSeconds) secondOffset = totalSeconds; + else if (secondOffset > totalSeconds) secondOffset = totalSeconds; var ratio = (secondOffset / totalSeconds); var totalOffset = Std.int(dataLength * ratio); @@ -451,7 +432,7 @@ class NativeAudioSource timer.stop(); } - var timeRemaining = Std.int((getLength() - value) / getPitch()); + var timeRemaining = (getLength() - value) / getPitch(); if (timeRemaining > 0) { @@ -491,17 +472,17 @@ class NativeAudioSource return value; } - public function getLength():Int + public function getLength():Float { if (length != null) { return length; } - return Std.int(samples / parent.buffer.sampleRate * 1000) - parent.offset; + return (samples / parent.buffer.sampleRate * 1000) - parent.offset; } - public function setLength(value:Int):Int + public function setLength(value:Float):Float { if (playing && length != value) { @@ -510,7 +491,7 @@ class NativeAudioSource timer.stop(); } - var timeRemaining = Std.int((value - getCurrentTime()) / getPitch()); + var timeRemaining = (value - getCurrentTime()) / getPitch(); if (timeRemaining > 0) { @@ -553,7 +534,7 @@ class NativeAudioSource timer.stop(); } - var timeRemaining = Std.int((getLength() - getCurrentTime()) / value); + var timeRemaining = (getLength() - getCurrentTime()) / value; if (timeRemaining > 0) { diff --git a/source/lime/media/AudioSource.hx b/source/lime/media/AudioSource.hx index ab0992e4..bc5948df 100644 --- a/source/lime/media/AudioSource.hx +++ b/source/lime/media/AudioSource.hx @@ -13,9 +13,9 @@ class AudioSource { public var onComplete = new EventVoid>(); public var buffer:AudioBuffer; - public var currentTime(get, set):Int; + public var currentTime(get, set):Float; public var gain(get, set):Float; - public var length(get, set):Int; + public var length(get, set):Float; public var loops(get, set):Int; public var pitch(get, set):Float; public var offset:Int; @@ -69,12 +69,12 @@ class AudioSource } // Get & Set Methods - @:noCompletion private function get_currentTime():Int + @:noCompletion private function get_currentTime():Float { return __backend.getCurrentTime(); } - @:noCompletion private function set_currentTime(value:Int):Int + @:noCompletion private function set_currentTime(value:Float):Float { return __backend.setCurrentTime(value); } @@ -89,12 +89,12 @@ class AudioSource return __backend.setGain(value); } - @:noCompletion private function get_length():Int + @:noCompletion private function get_length():Float { return __backend.getLength(); } - @:noCompletion private function set_length(value:Int):Int + @:noCompletion private function set_length(value:Float):Float { return __backend.setLength(value); } diff --git a/source/openfl/media/Sound.hx b/source/openfl/media/Sound.hx index bc073477..dfc475c1 100644 --- a/source/openfl/media/Sound.hx +++ b/source/openfl/media/Sound.hx @@ -599,16 +599,16 @@ class Sound extends EventDispatcher #end } - var changeID:Int = 0; - public function regen() { - var audioBuffer = new AudioBuffer(); + var changeID:Int = 0; + public function regen() { + var audioBuffer = new AudioBuffer(); audioBuffer.bitsPerSample = __buffer.bitsPerSample; audioBuffer.channels = __buffer.channels; audioBuffer.data = __buffer.data; audioBuffer.sampleRate = __buffer.sampleRate; __buffer = audioBuffer; - } + } /** Generates a new SoundChannel object to play back the sound. This method @@ -636,10 +636,10 @@ class Sound extends EventDispatcher return null; } - if (changeID < funkin.system.Main.changeID) { - changeID = funkin.system.Main.changeID; - regen(); - } + if (changeID < funkin.system.Main.changeID) { + changeID = funkin.system.Main.changeID; + regen(); + } if (sndTransform == null) { @@ -653,7 +653,7 @@ class Sound extends EventDispatcher var pan = SoundMixer.__soundTransform.pan + sndTransform.pan; if (pan > 1) pan = 1; - if (pan < -1) pan = -1; + else if (pan < -1) pan = -1; var volume = SoundMixer.__soundTransform.volume * sndTransform.volume; @@ -680,23 +680,29 @@ class Sound extends EventDispatcher return new ID3Info(); } - @:noCompletion private function get_length():Int + @:noCompletion private function get_length():Float { #if lime if (__buffer != null) { #if (js && html5 && howlerjs) - return Std.int(__buffer.src.duration() * 1000); + return __buffer.src.duration() * 1000; #else if (__buffer.data != null) { - var samples = (__buffer.data.length * 8) / (__buffer.channels * __buffer.bitsPerSample); - return Std.int(samples / __buffer.sampleRate * 1000); + // var samples = (__buffer.data.length * 8) / (__buffer.channels * __buffer.bitsPerSample); + // return Std.int(samples / __buffer.sampleRate * 1000); + var samples = (Int64.make(0, __buffer.data.length) * Int64.ofInt(8)) / Int64.ofInt(__buffer.channels * __buffer.bitsPerSample); + var value = samples / Int64.ofInt(__buffer.sampleRate) * Int64.ofInt(1000); + return Int64.toInt(value); } else if (__buffer.__srcVorbisFile != null) { - var samples = Int64.toInt(__buffer.__srcVorbisFile.pcmTotal()); - return Std.int(samples / __buffer.sampleRate * 1000); + //var samples = Int64.toInt(__buffer.__srcVorbisFile.pcmTotal()); + //return Std.int(samples / __buffer.sampleRate * 1000); + var samples = __buffer.__srcVorbisFile.pcmTotal(); + var value = Int64.fromFloat(__buffer.__srcVorbisFile.timeTotal()) * 1000; + return Int64.toInt(value); } else { diff --git a/source/openfl/media/SoundChannel.hx b/source/openfl/media/SoundChannel.hx new file mode 100644 index 00000000..f74d89b6 --- /dev/null +++ b/source/openfl/media/SoundChannel.hx @@ -0,0 +1,238 @@ +package openfl.media; + +#if !flash +import openfl.events.Event; +import openfl.events.EventDispatcher; +#if lime +import lime.media.AudioSource; +#end + +/** + The SoundChannel class controls a sound in an application. Every sound is + assigned to a sound channel, and the application can have multiple sound + channels that are mixed together. The SoundChannel class contains a + `stop()` method, properties for monitoring the amplitude + (volume) of the channel, and a property for assigning a SoundTransform + object to the channel. + + @event soundComplete Dispatched when a sound has finished playing. +**/ +#if !openfl_debug +@:fileXml('tags="haxe,release"') +@:noDebug +#end +@:access(openfl.media.SoundMixer) +@:final @:keep class SoundChannel extends EventDispatcher +{ + /** + The current amplitude(volume) of the left channel, from 0(silent) to 1 + (full amplitude). + **/ + public var leftPeak(default, null):Float; + + /** + When the sound is playing, the `position` property indicates in + milliseconds the current point that is being played in the sound file. + When the sound is stopped or paused, the `position` property + indicates the last point that was played in the sound file. + + A common use case is to save the value of the `position` + property when the sound is stopped. You can resume the sound later by + restarting it from that saved position. + + If the sound is looped, `position` is reset to 0 at the + beginning of each loop. + **/ + public var position(get, set):Float; + + /** + The current amplitude(volume) of the right channel, from 0(silent) to 1 + (full amplitude). + **/ + public var rightPeak(default, null):Float; + + /** + The SoundTransform object assigned to the sound channel. A SoundTransform + object includes properties for setting volume, panning, left speaker + assignment, and right speaker assignment. + **/ + public var soundTransform(get, set):SoundTransform; + + public var pitch(get, set):Float; + + @:noCompletion private var __isValid:Bool; + @:noCompletion private var __soundTransform:SoundTransform; + #if lime + @:noCompletion private var __source:AudioSource; + #end + + #if openfljs + @:noCompletion private static function __init__() + { + untyped Object.defineProperties(SoundChannel.prototype, { + "position": { + get: untyped #if haxe4 js.Syntax.code #else __js__ #end ("function () { return this.get_position (); }"), + set: untyped #if haxe4 js.Syntax.code #else __js__ #end ("function (v) { return this.set_position (v); }") + }, + "soundTransform": { + get: untyped #if haxe4 js.Syntax.code #else __js__ #end ("function () { return this.get_soundTransform (); }"), + set: untyped #if haxe4 js.Syntax.code #else __js__ #end ("function (v) { return this.set_soundTransform (v); }") + }, + }); + } + #end + + @:noCompletion private function new(source:#if lime AudioSource #else Dynamic #end = null, soundTransform:SoundTransform = null):Void + { + super(this); + + leftPeak = 1; + rightPeak = 1; + + if (soundTransform != null) + { + __soundTransform = soundTransform; + } + else + { + __soundTransform = new SoundTransform(); + } + + #if lime + if (source != null) + { + __source = source; + __source.onComplete.add(source_onComplete); + __isValid = true; + + __source.play(); + } + #end + + SoundMixer.__registerSoundChannel(this); + } + + /** + Stops the sound playing in the channel. + **/ + public function stop():Void + { + SoundMixer.__unregisterSoundChannel(this); + + if (!__isValid) return; + + #if lime + __source.stop(); + #end + __dispose(); + } + + @:noCompletion private function __dispose():Void + { + if (!__isValid) return; + + #if lime + __source.onComplete.remove(source_onComplete); + __source.dispose(); + __source = null; + #end + __isValid = false; + } + + @:noCompletion private function __updateTransform():Void + { + this.soundTransform = soundTransform; + } + + // Get & Set Methods + @:noCompletion private function get_position():Float + { + if (!__isValid) return 0; + + #if lime + return __source.currentTime + __source.offset; + #else + return 0; + #end + } + + @:noCompletion private function set_position(value:Float):Float + { + if (!__isValid) return 0; + + #if lime + __source.currentTime = value - __source.offset; + #end + return value; + } + + @:noCompletion private function get_pitch():Float + { + if (!__isValid) return 1; + + #if lime + return __source.pitch; + #else + return 1; + #end + } + + @:noCompletion private function set_pitch(value:Float):Float + { + if (!__isValid) return 1; + + #if lime + __source.pitch = value; + #end + return value; + } + + @:noCompletion private function get_soundTransform():SoundTransform + { + return __soundTransform.clone(); + } + + @:noCompletion private function set_soundTransform(value:SoundTransform):SoundTransform + { + if (value != null) + { + __soundTransform.pan = value.pan; + __soundTransform.volume = value.volume; + + var pan = SoundMixer.__soundTransform.pan + __soundTransform.pan; + + if (pan < -1) pan = -1; + else if (pan > 1) pan = 1; + + var volume = SoundMixer.__soundTransform.volume * __soundTransform.volume; + + if (__isValid) + { + #if lime + __source.gain = volume; + + var position = __source.position; + position.x = pan; + position.z = -1 * Math.sqrt(1 - Math.pow(pan, 2)); + __source.position = position; + + return value; + #end + } + } + + return value; + } + + // Event Handlers + @:noCompletion private function source_onComplete():Void + { + SoundMixer.__unregisterSoundChannel(this); + + __dispose(); + dispatchEvent(new Event(Event.SOUND_COMPLETE)); + } +} +#else +typedef SoundChannel = flash.media.SoundChannel; +#end \ No newline at end of file