just add a video to the stage (name it vid) and play a netstream file (or live!) and add a movieclip next to it (name it mc2)

create some kind of interval sequence to trigger the myFunction function and thats that.

once you see it works swap out myLoad function call for a localconnection call. take the myLoad function and put it in the target localconnection file.

Thanks again for this the possibilities are endless.

What i am attempting to do is to take an animation or in this case video and instead of
of sending only one image, to send a series of images. in this scenraio I take a
snapshot of a netstream every few seconds and send to another function in teh same fla
another function where the pieces are put back together, turned back into a bitmap
and then display it in a movieclip next to the video object on the stage. i am able
to do this with one frame successfully, however everytime another snapshot is taken,
instead of it being the current image played in the video, somehow, it is the same image
as the first snapshot. The problem escapes me. Any help would be greatly appreaciated.

on the stage i have a video playing a netstream named vid and the target movieclip named mc2
positioned right next to it, and a button i click which triggers the myFunction function.

var w=214;
var h=214;
function myFunction():void {
var bmpData=new BitmapData(w,h,true);
bmpData.draw(vid);
var bytes:ByteArray=bmpData.getPixels(new Rectangle(0,0,w,h));
var tempByteArray:ByteArray;
var byteLimit:uint=uint(40000);
if (bytes.length>byteLimit) {
var currentSize:uint=byteLimit;
var position:uint=0;
var totalSize:uint=0;
while (totalSize byteLimit) {
currentSize=byteLimit;
}
}
}
}
function myLoad(bytes,bytesLength,w,h) {
var byteArray:ByteArray=bytes as ByteArray;
byteArraySnapShot = new ByteArray();
byteArraySnapShot.length=bytesLength;
byteArraySnapShot.position=0;
byteArraySnapShot.writeBytes(byteArray);
if (byteArraySnapShot.bytesAvailable==0) {
var bitmapDataSnapShot:BitmapData=new BitmapData(w,h);
byteArraySnapShot.position=0;
bitmapDataSnapShot.setPixels(new Rectangle(0, 0, w, h),byteArraySnapShot);
var bitmapSnapShot:Bitmap=new Bitmap(bitmapDataSnapShot);
var snapShotImg=bitmapSnapShot;
mc2.addChild(bitmapSnapShot);
}
}

I had to send bitmapdata from an as2 module to an as3 app and hit the 40k limit let alone the headache that the AV1Movie ‘black box’ class causes (i’m actually glad as2 gets almost zero access to as3)…

in the end i decided to move the bitmap editing logic from a hidious as2 module into my app and spent the whole night refactoring sloppy code…

@GMalartre: i am going to try out the shared object hack and see if i can actually build an api around it… it’s bound to come in handy one of these days…

@Dennis i really like what you did with that bytearray… certainly something to consider using…

(you might find this funny… that nasty as2 module had a whopping 938 lines of procedural script in a single frame, i almost lost my mind…)

You could store the data in a LocalSharedObject without splitting it and listen for a change in the other applications.

Of course it mean some different handling, but in my case the LocalSharedObject is already a prerequist.