The class:

 
package nl.debit.net.bonjour
{
	import flash.events.TimerEvent;
	import flash.net.DatagramSocket;
	import flash.utils.ByteArray;
	import flash.utils.Timer;
 
	public class DaapAnnouncer
	{
		private var _aSocket:DatagramSocket;
		private var _ip:String;
		private var _port:int;
		private var _ttl:int;
 
		private var _name:String;
		private var _timer:Timer;
 
		public function DaapAnnouncer(name:String, ip:String, port:int = 3689, ttl:int = 120)
		{
			_name = name;
			_ip = ip;
			_port = port;
			_ttl = ttl;
 
			init();
		}
 
		private function init():void
		{
			_aSocket = new DatagramSocket();
 
			_timer = new Timer((_ttl / 2) * 1000);
			_timer.addEventListener(TimerEvent.TIMER, sendAnnounceData);
			_timer.start();
			sendAnnounceData(null);
		}
 
		private function sendAnnounceData(event:TimerEvent):void
		{
			_aSocket.send(getAnnounceBytes(_ttl),0,0,"224.0.0.251",5353);
		}
 
		public function start():void
		{
			if(_timer.running)
				return;
 
			_timer.start();
			sendAnnounceData(null);
		}
 
		public function stop():void
		{
			_timer.stop();
			_aSocket.send(getAnnounceBytes(0),0,0,"224.0.0.251",5353);
		}
 
		public function dispose():void
		{
			stop();
			_timer.removeEventListener(TimerEvent.TIMER, sendAnnounceData);
			_timer = null;
			_aSocket = null;
		}
 
		private function getAnnounceBytes(ttl:int):ByteArray
		{
			var bytes:ByteArray = new ByteArray();
 
			bytes.writeShort(0x00); // Transaction ID: 0x0000
			bytes.writeShort(0x8400); // Flags
			bytes.writeShort(0x00); // Question
			bytes.writeShort(0x03); // Answer RRs
			bytes.writeShort(0x00); // Authority RRs
			bytes.writeShort(0x01); // Additional RRs
 
			writeString(bytes, _name + "._daap._tcp.local");
			bytes.writeByte(0x00);
 
			//SRV record
			bytes.writeShort(0x21); //Type
			bytes.writeByte(0x80); // FlushCache
			bytes.writeByte(0x01); // Class IN
			bytes.writeUnsignedInt(ttl); //Time to live
			bytes.writeShort(8 + _ip.length); //Data length
			bytes.writeShort(0x00); //priority
			bytes.writeShort(0x00); //weight
			bytes.writeShort(_port); //port
			writeString(bytes, _ip);
			bytes.writeByte(0x00); //end
 
			//TXT Record
			bytes.writeShort(0xC00C); //Name ^^^
			bytes.writeShort(0x10); //Type TXT
			bytes.writeByte(0x80); //Flush Cache
			bytes.writeByte(0x01); // Class IN
			bytes.writeUnsignedInt(ttl);//TTL
			bytes.writeShort(0x01); //Data length
			bytes.writeByte(0x00); //Data
 
			//PTR Record
			bytes.writeByte(0xC0);
			bytes.writeByte(0x0D + _name.length);
			bytes.writeShort(0x0C); //Type PTR
			bytes.writeByte(0x00); //Flush Cache
			bytes.writeByte(0x01); // Class IN
			bytes.writeUnsignedInt(ttl);//TTL
			bytes.writeShort(0x02); //Data length
			bytes.writeShort(0xC00C); //Data 
 
			//Additional Record
			bytes.writeShort(0xC00C); //Name ^^^
			bytes.writeShort(0x2F); //Type NSEC
			bytes.writeByte(0x80); //Flush Cache
			bytes.writeByte(0x01); // Class IN
			bytes.writeUnsignedInt(ttl); //TTL
			bytes.writeShort(0x09); //Data length
			bytes.writeShort(0xC00C); //Data Next domain name
			bytes.writeUnsignedInt(0x50000); //Dunno
			bytes.writeByte(0x80); // RR type TXT
			bytes.writeByte(0x00);
			bytes.writeByte(0x40); // RR type SRV
 
			return bytes;
		}
 
		private function writeString(bytes:ByteArray, string:String):void
		{
			var ar:Array = string.split(".");
			var len:int = ar.length;
 
			for (var i:int = 0; i < len; i++)
			{
				bytes.writeByte((ar[i] as String).length);
				bytes.writeUTFBytes(ar[i]);
			}
		}
	}
}
 

The code needs some cleaning but I think the idea is obvious.

A Simple AIR example: download

Alchemy C:

#include
#include 
 
#include "AS3.h"
 
static AS3_Val readFile(void* self, AS3_Val args)
{
	char * fileName;
	FILE * file;
	long fileSize;
	char * buffer;
 
	AS3_ArrayValue(args, "StrType", &fileName);
 
	file = fopen(fileName,"rb");
 
	//Get file size
	fseek (file, 0, SEEK_END);
	fileSize = ftell(file);
	rewind(file);
 
	//Allocate buffer
	buffer = (char*) malloc(sizeof(char)*fileSize);
 
	//Read file into buffer
	fread(buffer, 1, fileSize, file);
 
	//close file and free allocated buffer
	fclose (file);
	free (buffer);
 
	return AS3_String((char*)buffer);
}
 
int main()
{
	AS3_Val readMethod = AS3_Function(NULL, readFile);
 
	AS3_Val result = AS3_Object("readFile: AS3ValType", readMethod);
 
	AS3_Release(readMethod);
	AS3_LibInit(result);
 
	return 0;
}

Actionscript:

package
{
	import cmodule.dataTest1.CLibInit;
 
	import flash.display.Sprite;
	import flash.utils.ByteArray;		
 
	public class Main extends Sprite
	{
		public function Main()
		{
 
			var loader:CLibInit = new CLibInit();
			var lib:Object = loader.init();
 
			var byteArray:ByteArray = new ByteArray();
			byteArray.writeUTFBytes("Hello World!");
 
			loader.supplyFile("testFile.txt", byteArray);
 
			trace(lib.readFile("testFile.txt"));
		}
	}
}

The method of reading a "file" as shown above is read-only in C. That's not because I opened the file "rb" (Read Binary) that's just the way it is. But as you can see it's a really simple solution to read data in C. The bytearray you provide can be any bytearray you like, for example: data from a FileReference.
The filename is a unique identifier for the bytearray. You could just use fopen("testFile.txt","rb") in C and not give the filename as an argument.

Memory allocation in C with direct access in Actionscript (FAST!!)

Alchemy C:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include "AS3.h"
 
unsigned char* buffer;
int bufferSize;
 
static AS3_Val initByteArray(void* self, AS3_Val args)
{
 
	AS3_ArrayValue(args, "IntType", &bufferSize);
 
	//Allocate buffer of size "bufferSize"
	buffer = (unsigned char*)malloc(bufferSize*sizeof(char));
 
	//return pointer to the location in memory
	return AS3_Int((int)buffer);
}
 
static AS3_Val writeData(void* self, AS3_Val args)
{
	char *tempBuffer;
	AS3_ArrayValue(args, "StrType", &tempBuffer);
 
	//copy string to buffer
	strcpy((char*)buffer, (char*)tempBuffer);
 
	return AS3_String((char*)tempBuffer);
}
 
static AS3_Val clearByteArray(void* self, AS3_Val args)
{
	//free the buffer
	free(buffer);
	*buffer = 0;
	return 0;
}
 
int main()
{
	AS3_Val initByteArrayMethod = AS3_Function(NULL, initByteArray);
	AS3_Val writeDataMethod = AS3_Function(NULL, writeData);
	AS3_Val clearByteArrayMethod = AS3_Function(NULL, clearByteArray);
 
	AS3_Val result = AS3_Object("initByteArray:AS3ValType, writeData:AS3ValType, clearByteArray:AS3ValType", initByteArrayMethod, writeDataMethod, clearByteArrayMethod);
 
	AS3_Release(initByteArrayMethod);
	AS3_Release(writeDataMethod);
	AS3_Release(clearByteArrayMethod);
	AS3_LibInit(result);
 
	return 0;
}

Actionscript:

package
{
	import cmodule.dataTest2.CLibInit;
 
	import flash.display.Sprite;
	import flash.utils.ByteArray;		
 
	public class Main extends Sprite
	{
		private var _dataPosition:uint;
 
		public function Main()
		{
 
			var loader:CLibInit = new CLibInit();
			var lib:Object = loader.init();
 
			var ns:Namespace = new Namespace("cmodule.dataTest2");
			var byteArray:ByteArray = (ns::gstate).ds; //point to memory
 
			_dataPosition = lib.initByteArray(12); //This is the position of the data in memory			
 
			lib.writeData("Hello "); //example function to write data in C
 
			byteArray.position = _dataPosition + 6; //Move to the next free location
 
			byteArray.writeUTFBytes("World!"); //write text at the current position
 
			byteArray.position = _dataPosition; //reset position
 
			trace(byteArray.readUTFBytes(12));//read bytearray
 
			lib.clearByteArray(); //Free the bytearray
		}
	}
}

This method is the fastest method to use data between C and Actionscript. In C you allocate a chunk of memory of the given size and it's position is returned to Actionscript. In Actionscript you can set a reference to the Alchemy memory as shown with the namespace.
You MUST postition the bytearray to the position given back by C, because that's where your data is.

I've tested this method with coloring a 640x400px bitmap looping over the rainbow colors.
I applied the bytearray to the bitmap with setPixels(ba:ByteArray, rect:Rectangle); and filled the 640x400 bytearray in both Actionscript and C. I was very surprised about the difference in speed.
In Actionscript the framerate maxed out at 10fps, but filling the bytearray in C gave me a rate of 60fps (max on my mac).

funopen and bytearray pointer

Alchemy C:

#include <stdlib.h>
#include <stdio.h>
 
#include "AS3.h"
 
/* Does a FILE * read against a ByteArray */
static int readByteArray(void *cookie, char *dst, int size)
{
	return AS3_ByteArray_readBytes(dst, (AS3_Val)cookie, size);
}
 
/* Does a FILE * write against a ByteArray */
static int writeByteArray(void *cookie, const char *src, int size)
{
	return AS3_ByteArray_writeBytes((AS3_Val)cookie, (char *)src, size);
}
 
/* Does a FILE * lseek against a ByteArray */
static fpos_t seekByteArray(void *cookie, fpos_t offs, int whence)
{
	return AS3_ByteArray_seek((AS3_Val)cookie, offs, whence);
}
 
/* Does a FILE * close against a ByteArray */
static int closeByteArray(void * cookie)
{
	AS3_Val zero = AS3_Int(0);
 
	/* just reset the position */
	AS3_SetS((AS3_Val)cookie, "position", zero);
	AS3_Release(zero);
	return 0;
}
 
static AS3_Val doMagic(void* self, AS3_Val args)
{
	FILE * file;
	long fileSize;
	char * buffer;
	void * dest;
 
	AS3_ArrayValue(args, "AS3ValType", &dest);
 
	file = funopen((void *)dest, readByteArray, writeByteArray, seekByteArray, closeByteArray);
 
	char buffer2[] = {'H','e','l','l','o',' ','W','o','r','l','d','!'};
 
	fwrite (buffer2, 1, sizeof(buffer2), file);
 
	// get file size
	fseek (file, 0, SEEK_END);
	fileSize = ftell(file);
	rewind (file);
 
	//Allocate memory for the buffer
	buffer = (char*) malloc (sizeof(char)*fileSize);
 
	//Copy the file into the buffer
	fread (buffer, 1, fileSize, file);
 
	//Close file and clear
	fclose (file);
	free (buffer);
 
	return AS3_String(buffer);
}
 
int main()
{
	AS3_Val doMagicMethod = AS3_Function(NULL, doMagic);
 
	AS3_Val result = AS3_Object("doMagic:AS3ValType", doMagicMethod);
 
	AS3_Release(doMagicMethod);
	AS3_LibInit(result);
 
	return 0;
}

ActionScript:

package
{
	import cmodule.dataTest3.CLibInit;
 
	import flash.display.Sprite;
	import flash.utils.ByteArray;		
 
	public class Main extends Sprite
	{
		public function Main()
		{
			var loader:CLibInit = new CLibInit();
			var lib:Object = loader.init();
 
			var byteArray:ByteArray = new ByteArray();
 
			var result:String = lib.doMagic(byteArray);
 
			trace(result);
			trace(byteArray.readUTFBytes(byteArray.length));
		}
	}
}

As you can see you pass a ByteArray to C and it uses funopen to open the bytearray as a FILE. The functions provided at the funopen function map the FILE functions to bytearray functions, so the bytearray acts as a file.
In ActionScript you can see that the bytearray holds the data C has writen to it.
This way you can use normal FILE function in C and for example save the data in Actionscript with the FileReference.

If you have any questions or remarks please let me hear them!

I started searching for C code which implements a MP3 Encoder and found the 8Hz MP3 implementation.
I could have used LAME, but hey.. have you looked at the file count!
The 8Hz implementation uses about 10 files, so it's readable. It's not the best encoder, but good enough to test the possibilities.

I was very surprised that the 8Hz code would compile with llvm-gcc (Alchemy)! That is a good starting point, now I only have to rewrite some code to get input from and output to Actionscript.

The original source used fopen to read and write files. This isn't possible with Alchemy so I replaced fopen with funopen and gave a pointer to Actionscript bytearrays.

The next problem I encountered was the execution timeout in Flash. When encoding large WAV files (more then 30 seconds of sound on my MacBook Pro) the flashplayer will trigger an error about exceeding the maximum execution time. I tried to alter it with the compiler option "-default-script-limits" but no luck (maybe it has something to do with Alchemy).
But it forced me to take a deeper look in the encoding source. I've rewritten the layer3.c file to process a few frames and then give feedback to Actionscript. This way no timeout occurs.

I'm still working on speed optimization, because encoding is slow at the moment.
I will keep you updated!

Here is the first version:

A simple Flash 10 example, haven't tested all possible MP3 rates so if someone encounters a bug, please let me know.
(Just found out that some MP3's with embedded art-work won't work... added to my TODO's).

Code snippet which writes the MP3 data to a SWF bytearray:

while(mp3.audioFrames.length > currentAudioFrame)
{
	var needSamples:int = 0.001 * ((1000/(__frameRate))*i) * audioRate;
	var startSamples:int = currentSamples;
	var audioData:ByteArray = new ByteArray();
 
	while(mp3.audioFrames.length > currentAudioFrame && currentSamples< needSamples)
	{
		var aframe:AudioFrame = AudioFrame(mp3.audioFrames[currentAudioFrame]);
		audioData.writeBytes(aframe.frameData);
		currentSamples = (currentAudioFrame+1) * (576*2);
		currentAudioFrame++;
	}
 
	var samples:int = currentSamples - startSamples;
	var seek:int = startSamples ? needSamples - startSamples : 0;
 
	var af:AudioFrame = mp3.audioFrames[i] as AudioFrame;
	_swfBytes.writeShort(createHeader(SWFTags.SOUNDSTREAMBLOCK,63));
	_swfBytes.writeInt(audioData.length+4);
	_swfBytes.writeShort(samples);
	_swfBytes.writeShort(seek);
	_swfBytes.writeBytes(audioData);
	_swfBytes.writeShort(createHeader(SWFTags.PLACE_OBJECT2,3)); //Place frame data
	_swfBytes.writeByte(1);
	_swfBytes.writeShort(1); //depth
	_swfBytes.writeShort(createHeader(SWFTags.SHOWFRAME,0));
 
	i++;
}

This way I write all SWF headers the correct way and not like most other code out there which uses a precompiled SWF and replace the sound object.

Searching can be done by keyword or by regular expression!
Doc? provides two plugins, one for Flash and one for Eclipse (Flex, FDT etc..). These plugins send the selected text to Doc? and Doc? will search it's database for matching items.

I love it

http://www.airdoc.be

Screenshot with the PV3D ASdocs imported:

Papervion API in Doc?

var testString:String = "This is a test with a – character and a ’";
testString = testString.replace(/&#([0-9]+);/g, replaceCharacters);
 
private function replaceCharacters(...args):String
{
	return String.fromCharCode(parseInt(args[1]));
}