textdump.java

利用opensource的开源jar实现生成flash文件

            if (format == 2) // MP3
                coder.readWord("latency", 2, true); 

            coder.endObject();
        }

        void decodeStartSound(SWFDecoder coder)
        {
            coder.beginObject("startSound", "StartSound");
            decodeMovieObject(coder);
            decodeSound(coder);
            coder.endObject();
        }

        void decodeUnknownObject(SWFDecoder coder)
        {
            coder.beginObject("unknownObject", "UnknownObject");
            int length = decodeMovieObject(coder);
            coder.readBytes("data", length); 
            coder.endObject();
        }

        int decodeActionObject(SWFDecoder coder)
        {
            int length = 0;
            
            if (coder.readWord("type", 1, false) >= 128)
                length = coder.readWord("length", 2, false);

            return length;
        }

        void decodeGetUrl(SWFDecoder coder)
        {
            coder.beginObject("getUrl", "GetUrl");
            decodeActionObject(coder);
            coder.readString("url");
            coder.readString("target");
            coder.endObject();
        }

        void decodeGotoFrame(SWFDecoder coder)
        {
            coder.beginObject("gotoFrame", "GotoFrame");
            decodeActionObject(coder);
            coder.readWord("frameNumber", 2, false);
            coder.endObject();
        }

        void decodeUnknownAction(SWFDecoder coder)
        {
            coder.beginObject("unknownAction", "UnknownAction");
            int length = decodeActionObject(coder);

            if (length > 0)
                coder.readBytes("data", length);

            coder.endObject();
        }
        
        void decodeTextRecord(SWFDecoder coder)
        {
            coder.beginObject("text", "Text");
            
            coder.readBits("type", 1, false); // 
            coder.readBits("reserved", 3, false); // 
            
            boolean _containsFont = coder.readBool("hasFont");
            boolean _containsColor = coder.readBool("hasColor");
            boolean _containsBaseline = coder.readBool("hasBaseline");
            boolean _containsIndent = coder.readBool("hasIndent");

            if (_containsFont)
                coder.readWord("identifier", 2, false);

            if (_containsColor)
                decodeColor("color", coder);

            if (_containsIndent)
                coder.readWord("indent", 2, true);
            if (_containsBaseline)
                coder.readWord("baseline", 2, true);
            if (_containsFont)
                coder.readWord("height", 2, false);

            int charCount = coder.readWord("characterCount", 1, false);
            
            coder.beginArray("characters");
                
            for (int i=0; i<charCount; i++)
                decodeCharacter(coder);
            
            coder.alignToByte();
            
            coder.endObject();
            coder.endObject();
        }
        
        void decodeCharacter(SWFDecoder coder)
        {
            coder.beginObject("character", "Character");
            coder.readBits("glyphIndex", coder.context[SWFDecoder.NumberOfGlyphBits], false);
            coder.readBits("advance", coder.context[SWFDecoder.NumberOfAdvanceBits], true);
            coder.endObject();
        }

        int decodeDefineObject(SWFDecoder coder)
        {
            int length = decodeMovieObject(coder);
            
            coder.readWord("identifier", 2, false);
            
            return length;
        }

        void decodeButtonRecord(SWFDecoder coder)
        {
            coder.beginObject("button", "Button");
            
            coder.readBits("reserved", 4, false);
            coder.readBool("isActive");
            coder.readBool("isDown");
            coder.readBool("isOver");
            coder.readBool("isUp");
            coder.readWord("identifier", 2, false);
            coder.readWord("layer", 2, false);
            decodeCoordTransform("coordTransform", coder);

            if (coder.context[SWFDecoder.Type] == DefineButton2)
                decodeColorTransform("colorTransform", coder);

            coder.endObject();
        }

        void decodeDefineButton(SWFDecoder coder)
        {
            coder.beginObject("defineButton", "DefineButton");
            decodeDefineObject(coder);
            
            coder.beginArray("buttonRecords");
            
            while (coder.scanWord(1, false) != 0)
                decodeButtonRecord(coder);
                
            coder.readWord("endOfRecords", 1, false);

            coder.endObject();

            coder.beginArray("actions");
            
            while (decodeAction(coder) != 0);
            
            coder.endObject();
            coder.endObject();
        }

        void decodeDefineFont(SWFDecoder coder)
        {
            coder.beginObject("defineFont", "DefineFont");
            decodeDefineObject(coder);
            
            int shapeCount = coder.scanWord(2, false) / 2;

            coder.beginArray("offsetTable");

            for (int i=0; i<shapeCount; i++)
                coder.readWord("offset", 2, false);
                
            coder.endObject();
            coder.beginArray("glyphs");

            for (int i=0; i<shapeCount; i++)
                decodeShape(coder);

            coder.endObject();
            coder.endObject();
        }

        void decodeDefineJPEGImage(SWFDecoder coder)
        {
            coder.beginObject("defineJPEGImage", "DefineJPEGImage");
            int length = decodeDefineObject(coder);
            coder.readBytes("image", length-2);
            coder.endObject();
        }

        void decodeDefineShape(SWFDecoder coder)
        {
            coder.beginObject("defineShape", "DefineShape");
            decodeDefineObject(coder);

            decodeBounds("bounds", coder);
            
            int fillStyleCount = coder.readWord("fillStyleCount", 1, false);

            if (fillStyleCount > 0)
            {
                coder.beginArray("fillStyles");
                
                for (int i=0; i<fillStyleCount; i++)
                {
                    switch (coder.scanWord(1, false))
                    {
                        case Solid:
                            decodeSolidFill(coder);
                            break;
                        case Linear:
                            decodeGradientFill(coder);
                            break;
                        case Radial:
                            decodeGradientFill(coder);
                            break;
                        case Tiled:
                        case Unsmoothed_Tiled:
                            decodeBitmapFill(coder);
                            break;
                        case Clipped:
                        case Unsmoothed_Clipped:
                            decodeBitmapFill(coder);
                            break;
                    }        
                }           
                coder.endObject();
            }

            int lineStyleCount = coder.readWord("lineStyleCount", 1, false);

            if (lineStyleCount > 0)
            {
                coder.beginArray("lineStyles");
        
                for (int i=0; i<lineStyleCount; i++)
                    decodeSolidLine(coder);
        
                coder.endObject();
            }
            decodeShape(coder);

            coder.endObject();
        }
        
        void decodeDefineSound(SWFDecoder coder)
        {
            coder.beginObject("defineSound", "DefineSound");
            int length = decodeDefineObject(coder);
            
            coder.readBits("format", 4, false);
            coder.readBits("playbackRate", 2, false);
            coder.readBits("playbackSampleSize", 1, false);
            coder.readBits("playbackChannels", 1, false);
            coder.readWord("sampleCount", 4, false);
            coder.readBytes("sound data", length-7);
            coder.endObject();
        }
        
        void decodeDefineText(SWFDecoder coder)
        {
            coder.beginObject("defineText", "DefineText");
            decodeDefineObject(coder); // length

            decodeBounds("bounds", coder);

            // This code is used to get round a bug in Flash - sometimes 16, 
            // 8-bit zeroes are written out before the transform. The root 
            // cause in Flash is unknown but seems to be related to the 
            // bounds not being set - all values are zero.

            boolean bytesAreZero = true;
            int start = coder.getPointer();
            
            for (int i=0; i<16; i++)
            {
                if (coder.scanWord(1, false) != 0)
                     bytesAreZero = false;
                     
                 coder.adjustPointer(8);
            }
            
            coder.setPointer(start);
            
            if (bytesAreZero)
            {
                for (int i=0; i<16; i++)
                {
                    coder.scanWord(1, false);
                    coder.adjustPointer(8);
                }
            }
     
            decodeCoordTransform("coordTransform", coder);

            coder.context[SWFDecoder.NumberOfGlyphBits] = coder.readWord("numberOfGlyphBits", 1, false);
            coder.context[SWFDecoder.NumberOfAdvanceBits] = coder.readWord("numberOfAdvanceBits", 1, false);
            
            coder.beginArray("textRecords");

            while (coder.scanBits(8, false) != 0)
                decodeTextRecord(coder);

            coder.readBits("endOfText", 8, false);
            coder.endObject();

            coder.context[SWFDecoder.NumberOfGlyphBits] = 0;
            coder.context[SWFDecoder.NumberOfAdvanceBits] = 0;
            coder.endObject();
        }
        
        int decodeAction(SWFDecoder coder)
        {
            int type = coder.scanWord(1, false);
            int length = 0;
            int start = coder.getPointer() + 8;
            int next = start;
        
            if (type == 0)
            {
                coder.setPointer(next);
                return 0;
            }
            
            if (type > 128)
            {
                coder.adjustPointer(8);
                length = coder.scanWord(2, false);
                start = coder.getPointer() + 16;
                next = start + (length << 3);
                coder.adjustPointer(-8);
            }
            
            boolean decoded = false;
            
            // Flash 1
            switch (type)
            {
                case NextFrame:
                case PrevFrame:
                case Play:
                case Stop:
                case ToggleQuality:
                case StopSounds:
                    decodeActionCode(coder);
                    decoded = true;
                    break;
                case GetUrl:
                    decodeGetUrl(coder);
                    decoded = true;
                    break;
                case GotoFrame:
                    decodeGotoFrame(coder);
                    decoded = true;
                    break;
                // Flash 2
                // Flash 3
                case GotoLabel:
                    decodeGotoLabel(coder);
                    decoded = true;
                    break;