Question

我将视频导入舞台（将其命名为flvControl），将autoPlay设置为true，然后我尝试使用以下代码执行此作业，但它无法正常工作。

function completeHandler(event:fl.video.VideoEvent):void
{
    flvControl.play();
}

flvControl.addEventListener(fl.video.VideoEvent.COMPLETE, completeHandler);

当您在Flash中测试电影时，它在播放之间有半秒钟的白屏闪烁，但是当您在浏览器中测试时（我的是Chrome）不仅闪烁在中间，在随后的游戏中视频似乎冻结大约1-2秒，然后从视频开始大约1-2秒开始播放。这实际上使循环完全无法播放。

有谁知道如何在Flash中无缝地进行视频循环？（并且在浏览器中看起来也是无缝的？）

Answer 1

我发现无缝循环视频的唯一方法是将整个剪辑加载到内存ByteArray中，然后使用连接到Video实例的NetStream的appendBytes函数。

这是一个非常基本的帮助类

package 
{
    import flash.events.AsyncErrorEvent;
    import flash.events.NetStatusEvent;
    import flash.events.SecurityErrorEvent;
    import flash.events.TimerEvent;
    import flash.media.Video;
    import flash.net.NetConnection;
    import flash.net.NetStream;
    import flash.net.NetStreamAppendBytesAction;
    import flash.utils.ByteArray;
    import flash.utils.Timer;
    import flash.utils.setTimeout;


    /** 
    * @author   Michael Archbold (ma&#64;distriqt.com)
    */
    public class AppendByteVideoLoop
    {
        public function AppendByteVideoLoop(video:Video, data:ByteArray):void
        {
            _video = video;
            connect(data);
        }

        private var _video:Video;
        private var _connection:NetConnection;
        private var _stream:NetStream;
        private var _byteArray:ByteArray;
        private var _timer:Timer;

        private var _paused : Boolean = false;
        public function get paused():Boolean { return _paused; }


        public function play():void
        {
            if (_stream)
                _stream.resume();
        }


        public function pause():void
        {
            if (_stream)
                _stream.pause();
        }


        public function togglePause():void
        {
            if (_stream)
                _stream.togglePause();
        }


        private function connect(byteArray:ByteArray):void
        {
            _byteArray = byteArray;

            _connection = new NetConnection();
            _connection.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
            _connection.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
            _connection.connect(null);
        }


        private function addToStream():void
        {
            _stream.appendBytesAction(NetStreamAppendBytesAction.RESET_BEGIN);
            _stream.appendBytes(_byteArray);
        }


        public function onMetaData(metaData:Object):void
        {
//          _video.width  = metaData.width;
//          _video.height = metaData.height;
        }


        public function onXMPData(xmp:Object):void
        {
        }


        public function onPlayStatus(status:Object):void
        {
        }


        private function connectStream():void
        {
            _stream = new NetStream(_connection);
            _stream.client = this;
            _stream.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
            _stream.addEventListener(AsyncErrorEvent.ASYNC_ERROR, asyncErrorHandler);
            _video.attachNetStream(_stream);
            _stream.play(null);
            _stream.appendBytes(_byteArray);
            _stream.pause();
        }


        private function netStatusHandler(event:NetStatusEvent):void
        {
            trace(event.info.code);
            switch (event.info.code)
            {
                case "NetConnection.Connect.Success": 
                    connectStream();
                    break;

                case "NetStream.Play.StreamNotFound": 
                    trace( "Unable to locate video " );
                    break;

                case "NetStream.Pause.Notify":
                    _paused = true;
                    break;

                case "NetStream.Unpause.Notify":
                    _paused = false;
                    break;

                case "NetStream.Buffer.Empty":
                    addToStream();
                    break;

                case "NetStream.Buffer.Full":
                    break;

            }
        }


        private function securityErrorHandler(event:SecurityErrorEvent):void
        {
            trace( "securityErrorHandler: " + event.text );
        }


        private function asyncErrorHandler(event:AsyncErrorEvent):void
        {
            trace( "asyncErrorHandler: " + event.error.message );
        }

    }
}

然后使用类似这样的东西：

var video:Video = new Video();
video.smoothing = false;
if (stage)
{
    video.width  = stage.stageWidth;
    video.height = stage.stageHeight;
}
addChild( video );

loader = new URLLoader();
loader.dataFormat = URLLoaderDataFormat.BINARY;
loader.addEventListener( Event.COMPLETE, loader_completeHandler, false, 0, true );
loader.addEventListener( IOErrorEvent.IO_ERROR, loader_ioErrorHandler, false, 0, true );
loader.load( new URLRequest( "URL_OF_VIDEO" ) );


...


function loader_completeHandler( event:Event ):void
{
    var data:ByteArray = ByteArray( loader.data );

    var player:AppendByteVideoLoop = new AppendByteVideoLoop( _video, _data );
    player.play();
}

希望有所帮助。

如何在Adobe Flash中无缝循环播放视频？

1 个答案: