Is there a way to encode bitmap data into PNG for use with a FileReference.Save() method in AS3? I assume I need an encoder library.
Where can I get a library that encode BitpmapData into PNG?
Shameless plug!
I just wrote a new PNG encoder called PNGEncoder2. It's extremely fast, offers three compression levels, supports huge images, and offers true asynchronous encoding (no pause at the end during the compression step).
More details, including usage examples and the full feature list, can be found in the README on GitHub. I also wrote a blog post about it, which includes a benchmark comparing it to other encoders (including Adobe's and blooddy's).
You're looking for: https://github.com/mikechambers/as3corelib
There are probably other solutions, but this is widely used and well tested. I've used it myself on several occasions without issue.
I've been using blooddy_crypto.swc which you can read about and download here: http://va.lent.in/blog/2010/06/23/100x-times-faster-md5-and-more/ - I found it approx. 3 times faster than the adobe PNGEncoder.
Related
I'm looking for some simple (free!) entry level software that will allow me to create simple 3d models and export them in a format (JSON?) that can then be read into a webGL programme.
Simple geometry would be a start, then textures would be nice too... I've looked at Blender, and it's just far too advanced for me, and the tutorials I've found are hopeless.
Something simple like sketchup would be good, but afaik you can't export in JSON. I've found some converters that will do .dae to .json, but the ones I've found seem to be for advanced users.
WebGL is new enough that there aren't many packages like this built up around it just yet. That doesn't mean you don't have some options though:
Blender is a good modeler, and if you are willing to put a little bit more time into learning it you can use exporters from Three.js or some others that are around the net. This seems to be the most popular option at the moment.
Unity 3D is more of a scene builder than a modeling app, but it has a lot of ways to get content into it and both J3D and myself have implemented exporters from it.
Maya is a great modeling tool if you have a way to get access to it (it's commercial), and has Inka to get WebGL content out.
If you want to use something like SketchUp, it should be able to export to COLLADA, which can then be imported into Blender/Unity/What have you and exported from there using one of the previous methods.
As far as formats go, there's no real standards just yet. Most of the exporters will spit out JSON, mine uses a mix of JSON and Binary for speed/size, and some will actually give you Javascript code to execute. Which format to use probably depends on what you want to do with it. I encourage you to experiment with several and see what you like and what you don't.
I'm thinking about using Haxe in place of AS3.
What are the disadventages of that? I can think about:
Difficulties with using native AS3 libraries.
Difficulity of debugging after language translation.
Haxe is quite young, it may have some rough edges. Does it?
Does any one of you have expirience with Haxe dark sides?
What are the adventages? I've heard:
Performance.
Multiple targets (But I don't see how that is useful)
Better typing that AS3
Maybe better syntax.
Haxe is big enough that there should be more. What are the pros of Haxe?
Edit:
If there are no real disadvantages then why Haxe is not replacing AS3?
Your first point is surely true. Some "native" libraries (such as Flex) may require a little of gym to be included in your project. In the vast majority of cases it is a quite smooth process. Haxe supports multiple -swf-lib which permit to have the code of the imported assets immediately available in your application. Note that the imported libs are not just embedded but are recognized as code asset, so if your IDE is integrated with Haxe you will have type completion for that too.
About the debugging there are no issues at all for the translation, that because the language is not translated to AS3 but directly compiled to AVM2 bytecode. When the -debug switch is on, the full stack trace with source code references (filename, line and position) is fully preserved. An uncaught exception will point you exactly at the line of code that generated it.
Haxe is not really that young and for sure the AVM2 output is the one with the best support of all. There are no rough edges in my opinion.
Of the pros you have outlined I want to underline that multiple targets can be huge. Of course to take really advantage of it you can't really rely on external libs specific for AS3. Even so there are always big chunks of code that you want/can reuse across projects.
To mention a few other advantages:
macros are a recent addition which add a huge pool of possibilities.
Molehill API is already available for Haxe (SVN version) and Nicolas is working on a Shader system that makes it even bigger.
Haxe is evolving constantly bringing new (important) features at each release.
I'm wondering if someone can help me with references or code snippet of H.264 files splitting.
It is not possible to split an h.264 file directly in AS3.
With out more information it is difficult to suggestion anything. But I'll try. What you can do is, somehow, communicate to an external process to split the file for you. E.g.: Java, C#, Python, something running outside of the browser (or Adobe AIR.)
Splitting an h.264 video is non-trivial. More than likely you will need to use third party software. Two suggestions jump to mind:
ffmpeg (with x264)
MP4Box
Again, this is non-trivial and there are more than one approaches to the problem. Without more details, we cannot help.
It is certainly possible to split h.264, it just might be difficult. Thibault Imbert made a
FLVSlicer
Inside a Java project I use Google Protocol Buffers (GPB) for serializing my objects. I can use the same .proto files in auxiliary Python code, which is great. Now I'm adding a Flex client to the whole thing and I'd like to use the same .proto files once more.
It seems there's a couple of projects out there which compile .proto files to Actionscript. From a few glances at the projects' homepages, it seems to me that protobuf-actionscript3 is actually the most advanced and most "alive" of these projects.
Has anybody had practical experience with GPB to AS3 compilers and which one(s) can you recommend (or recommend against)?
If you're sure you want to use GPB, then protobuf-actionscript3 is your best option. It builds on the semi-successful protocol-buffers-actionscript project: http://code.google.com/p/protocol-buffers-actionscript/
If you're open to looking at other formats, there's always Adobe's own AMF3. It seems to have a good amount of community support behind it.
The only choice now is https://code.google.com/p/protoc-gen-as3/. All the other Protobuf/AS3 projects are out-of-date, and lack of features.
I want to study the .vce format. It's a binary format and it seems more complicated than a simple object serialization. Does it exist any tool or technique to analyze a binary format?
You might need to "Reverse-Code-Engineer" a programm using this file format (http://www.openrce.org/). Tools used for this kind of analysis are: brain, disassembler (IDA Pro for example) and Debugger (OllyDBG for example). But beware - the way for successfull reverse engineering a file format is veeeeeerrry hard.
And reversing an application might be illegal depending on where you live!
You'll have to get a library that can read the format (or create one yourself).
Here is some of the microsoft office binary format specifications
I believe it would only be possible through some nasty reversed-engineering. It would be very useful to have access to application that uses mentioned format, so that you can generate few simple files and compare them in hex editor. You cannot get far with this method, but you might be able to figure out the header.
It would also be useful to study some binary format mechanisms, such as encryption and compression. If you're talking about Visual CertExam file format, than it is likely that useful data will be strongly encrypted.
My 2 cents:
Start by reversing the application reading the files themselves. Particularly android applications are helpful, as the resulting java source is easier to read (you might want to try A+ vce reader for android for example). This program indicates that vce uses/embeds sqlite in the file (in line with what is hinted here: Reverse Engineer a File Format).
Where to go from here? You might want to explore sqlite file carving tools to see if there might be a way to programatically identify the patterns in the file. Good luck!