laden & spielen Sie eine mjpeg via flash mit as3 - Socket Fehler

Habe ich konfrontiert mit dem gleichen problem. Die Lösung wurde in der Verwendung der URLStream-statt-Buchse.
Hier arbeitet die source-code mit kleinen änderungen, die ich gemacht habe MXML-Komponente zur Verwendung in Flex.

package ru.idecide.olimpstroy
{
    import com.dynamicflash.util.Base64;

    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.display.Loader;
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.events.HTTPStatusEvent;
    import flash.events.IOErrorEvent;
    import flash.events.ProgressEvent;
    import flash.events.SecurityErrorEvent;
    import flash.net.Socket;
    import flash.net.URLLoader;
    import flash.net.URLLoaderDataFormat;
    import flash.net.URLRequest;
    import flash.net.URLRequestHeader;
    import flash.net.URLRequestMethod;
    import flash.net.URLStream;
    import flash.utils.ByteArray;

    import mx.core.IMXMLObject;

    public class  MJPG extends EventDispatcher implements IMXMLObject
    {
        [Bindable]
        public var user:String;                       //Auth user name
        [Bindable]
        public var pass:String;                       //Auth user password
        [Bindable]
        public var host:String;                       //host server of stream
        [Bindable]
        public var port:int = 80;                     //port of stream
        [Bindable]
        public var file:String;                       //Location of MJPEG


        private var start:int = 0;                    //marker for start of jpg

        private var imageBuffer:ByteArray = new ByteArray();  //image holder


        public function MJPG()
        {
            loader = new Loader;
        }

        private var stream:URLStream;

        public function initialized(document:Object, id:String):void
        {
            stream = new URLStream();
            var request:URLRequest = new URLRequest(host + ":" + port.toString() + file);
            request.requestHeaders.push(new URLRequestHeader("Authorization", "Basic " + Base64.encode(user + ":" + pass)));
            configureListeners(stream);
            try {
                stream.load(request);
            } catch (error:Error) {
                trace("Unable to load requested URL.");
            }
        }

        private function configureListeners(dispatcher:EventDispatcher):void {
            dispatcher.addEventListener(Event.COMPLETE, completeHandler);
            dispatcher.addEventListener(HTTPStatusEvent.HTTP_STATUS, httpStatusHandler);
            dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
            dispatcher.addEventListener(Event.OPEN, openHandler);
            dispatcher.addEventListener(ProgressEvent.PROGRESS, progressHandler);
            dispatcher.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
        }

        private function parseHeader():void {
            trace("parseHeader", "length: " + imageBuffer.length);
            stream.readBytes(imageBuffer, imageBuffer.length)

            while(findImages()){
                //donothing
            }
        }

        private function completeHandler(event:Event):void {
            trace("completeHandler: " + event);
            parseHeader();
        }

        private function openHandler(event:Event):void {
            trace("openHandler: " + event);
        }

        private function progressHandler(event:Event):void {
            trace("progressHandler: " + event);
            parseHeader();
        }

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

        private function httpStatusHandler(event:HTTPStatusEvent):void {
            trace("httpStatusHandler: " + event);
        }

        private function ioErrorHandler(event:IOErrorEvent):void {
            trace("ioErrorHandler: " + event);
        }

        private function onLoaded(e:Event):void {
            //var bytes:ByteArray = loader.data;
            while(findImages()){
                //donothing
            }
        }

        private function findImages():Boolean
        {
            var x:int = start;
            var startMarker:ByteArray = new ByteArray();    
            var end:int = 0;
            var image:ByteArray;

            if (imageBuffer.length > 1) {
                if(start == 0){
                    //Check for start of JPG
                    for (x; x < imageBuffer.length - 1; x++) {
                        //get the first two bytes.
                        imageBuffer.position = x;
                        imageBuffer.readBytes(startMarker, 0, 2);

                        //Check for end of JPG
                        if (startMarker[0] == 255 && startMarker[1] == 216) {
                            start = x;
                            break;                  
                        }
                    }
                }
                for (x; x < imageBuffer.length - 1; x++) {
                    //get the first two bytes.
                    imageBuffer.position = x;
                    imageBuffer.readBytes(startMarker, 0, 2);
                    if (startMarker[0] == 255 && startMarker[1] == 217){
                        end = x;

                        image = new ByteArray();
                        imageBuffer.position = start;
                        imageBuffer.readBytes(image, 0, end - start);

                        displayImage(image);

                        //truncate the imageBuffer
                        var newImageBuffer:ByteArray = new ByteArray();

                        imageBuffer.position = end;
                        imageBuffer.readBytes(newImageBuffer, 0);
                        imageBuffer = newImageBuffer;

                        start = 0;
                        x = 0;
                        return true;
                    }
                }
            }

            return false;
        }

        private var loader:Loader;

        private var _bitmapData:BitmapData;

        private function displayImage(image:ByteArray):void
        {
            loader.loadBytes(image);
            loader.contentLoaderInfo.addEventListener(Event.COMPLETE, loaderComplete_handler);
        }

        private function loaderComplete_handler(event:Event):void
        {
            if (_bitmapData)
                _bitmapData.dispose();
            _bitmapData = Bitmap(loader.content).bitmapData;
            dispatchEvent(new Event("bitmapDataUpdate"));
        }

        [Bindable(event="bitmapDataUpdate")]
        public function get bitmapData():BitmapData
        {
            return _bitmapData;
        }
    }
}

Ich diese Art der Nutzung:

<fx:Declarations>
<mp:MJPG host=""http://example.com" file="/mjpg/video.mjpg" user="{user}" pass="{password}" id="videoProvider"/>
</fx:Declarations>
<s:BitmapImage source="{videoProvider.bitmapData}" smooth="true" width="100%"/>

Ich rate Ihnen, nicht zu verwenden, Loader, wie in Ihrem Beispiel, denn es macht das Bild zucken. In meinem Beispiel funktioniert es auch.

bist du den Aufruf der Methode falsch, sollte so sein:

var cam:MJPEG = new MJPEG("192.168.1.10", "/video.mjpeg",8080);

(drop-das führende http://in der host -)