[Vorbis-dev] Flash Vorbis player

[Tor-Einar Jarnbjo]

Arek Korbik schrieb:
> I could definitely use other people's opinion on the licensing of that
> code. I would like to make it as non-restrictive as possible,
> obviously, but the code is pretty clearly based on cortado's jorbis,
> which is lgpl-ed itself. Unless I go and do my own port from C, which
> I actually started at some point - with Tremor, hoping to get a better
> performance with non-floatingpoint implementation - I don't think
> there is much I can do about the current fvorbis license. Though,
> asking jorbis's authors to re/double-license their code would be one
> option.
>   
If you are interested in taking a look at my AS code, you are welcome to 
do so:

http://flash.j-ogg.de/fxogg-src.zip

It's only an implementation of the actual Vorbis decoder and may lack 
some classes to compile, but I think it should be pretty forward to 
understand. It's based on the Java J-Ogg (www.j-ogg.de) Vorbis decoder, 
which is released under a "do whatever you like, just mention me" 
license. I am planning some rework on the J-Ogg library, making it 
easier to integrate with Video decoders (Theora or Dirac) and to 
rerelease everything under the Mozilla license.
> That would be great. Have you thought or tried porting the Tremor to
> java? Flash floating point operations seem to be 2-4 times slower than
> integer ones. But my quick port of Tremor's mdct part showed almost no
> speed gain. That could be due to the fact that tremor relies on
> pointer pointing inside arrays, while in haxe I had to use more base
> offsetting index operations to achieve similar effect, which I think
> canceled possible speed improvements. But maybe that could be written
> in a better way.
>   
I was not sure what caused the poor performance of the Flash AS JIT, so 
I made some attempts as well to compare floating point vs fixed point 
operations to see if that would speed up decoding. I also have a fixed 
point Java decoder (for J2ME), so it wouldn't be too difficult to base 
the AS implementation on that, but I didn't get any performance gain by 
avoiding floating point operations in AS (the required bit shifting 
seemed to eat up the advantage). As the floating point code is easier to 
understand and not so bloated as the fixed point code, I decided to go 
for floating point code in the AS implementation.

Tor