| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package flash.swf; |
| |
| import flash.swf.tags.*; |
| import flash.swf.types.ButtonCondAction; |
| import flash.swf.types.ButtonRecord; |
| import flash.swf.types.CXForm; |
| import flash.swf.types.CXFormWithAlpha; |
| import flash.swf.types.CurvedEdgeRecord; |
| import flash.swf.types.EdgeRecord; |
| import flash.swf.types.FillStyle; |
| import flash.swf.types.GlyphEntry; |
| import flash.swf.types.GradRecord; |
| import flash.swf.types.ImportRecord; |
| import flash.swf.types.KerningRecord; |
| import flash.swf.types.LineStyle; |
| import flash.swf.types.Matrix; |
| import flash.swf.types.MorphFillStyle; |
| import flash.swf.types.MorphGradRecord; |
| import flash.swf.types.MorphLineStyle; |
| import flash.swf.types.Rect; |
| import flash.swf.types.Shape; |
| import flash.swf.types.ShapeRecord; |
| import flash.swf.types.ShapeWithStyle; |
| import flash.swf.types.SoundInfo; |
| import flash.swf.types.StraightEdgeRecord; |
| import flash.swf.types.StyleChangeRecord; |
| import flash.swf.types.TextRecord; |
| import flash.swf.types.Filter; |
| import flash.swf.types.DropShadowFilter; |
| import flash.swf.types.BlurFilter; |
| import flash.swf.types.ColorMatrixFilter; |
| import flash.swf.types.GlowFilter; |
| import flash.swf.types.ConvolutionFilter; |
| import flash.swf.types.BevelFilter; |
| import flash.swf.types.GradientGlowFilter; |
| import flash.swf.types.GradientBevelFilter; |
| import flash.swf.types.Gradient; |
| import flash.swf.types.FocalGradient; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * A SWF tag encoder. It is typically used by calling one or more of |
| * the TagHandler methods and then writeTo(). |
| */ |
| public class TagEncoder extends TagHandler |
| implements TagValues |
| { |
| // changed from private to protected to support Flash Authoring - jkamerer 2007.07.30 |
| protected SwfEncoder writer; |
| private SwfEncoder tagw; |
| private int width; |
| private int height; |
| private int frames; |
| private int framecountPos; |
| protected DebugEncoder debug; |
| private Header header; |
| |
| protected Dictionary dict; |
| private int uuidOffset; |
| |
| public TagEncoder() |
| { |
| dict = new Dictionary(); |
| } |
| |
| public TagEncoder( Dictionary dict ) |
| { |
| this.dict = dict; |
| } |
| |
| public void productInfo(ProductInfo tag) |
| { |
| tagw.write32( tag.getProduct() ); |
| tagw.write32( tag.getEdition() ); |
| tagw.write( new byte[] { tag.getMajorVersion(), tag.getMinorVersion() } ); |
| tagw.write64( tag.getBuild() ); |
| tagw.write64( tag.getCompileDate() ); |
| encodeTag(tag); |
| } |
| |
| public void fileAttributes(FileAttributes tag) |
| { |
| tagw.writeUBits(0, 1); |
| tagw.writeBit(tag.useDirectBlit); |
| tagw.writeBit(tag.useGPU); |
| tagw.writeBit(tag.hasMetadata); |
| tagw.writeBit(tag.actionScript3); |
| tagw.writeBit(tag.suppressCrossDomainCaching); |
| tagw.writeBit(tag.swfRelativeUrls); |
| tagw.writeBit(tag.useNetwork); |
| tagw.writeBit(tag.brokerProductManager); |
| tagw.writeBit(tag.brokerLocalConnection); |
| tagw.writeUBits(0, 22); |
| encodeTag(tag); |
| } |
| |
| public void enableTelemetry(EnableTelemetry tag) |
| { |
| if (tag.enabled) { |
| tagw.writeUBits(0, 16); //reserved |
| encodeTag(tag); |
| } |
| } |
| |
| public void metadata(Metadata tag) |
| { |
| tagw.writeString( tag.xml ); |
| encodeTag(tag); |
| } |
| |
| public int getPos() |
| { |
| return writer.getPos(); |
| } |
| |
| protected int getSwfVersion() |
| { |
| return header.version; |
| } |
| |
| protected int getFrameRate() |
| { |
| return header.rate; |
| } |
| |
| public void setEncoderDictionary(Dictionary dict) |
| { |
| assert ( (this.dict == null) || (this.dict.ids.size() == 0)); |
| this.dict = dict; |
| } |
| |
| public Dictionary getDictionary() |
| { |
| return dict; |
| } |
| |
| protected SwfEncoder createEncoder(int swfVersion) |
| { |
| return new SwfEncoder(swfVersion); |
| } |
| |
| public boolean isDebug() |
| { |
| return debug != null; |
| } |
| |
| public CompressionLevel getCompressionLevel() |
| { |
| return isDebug() ? CompressionLevel.BestSpeed : CompressionLevel.BestCompression; |
| } |
| |
| public void header(Header header) |
| { |
| // get some header properties we need to know |
| int swfVersion = header.version; |
| this.header = header; |
| this.writer = createEncoder(swfVersion); |
| this.tagw = createEncoder(swfVersion); |
| width = header.size.getWidth(); |
| height = header.size.getHeight(); |
| frames = 0; |
| |
| // write the header |
| writer.writeUI8(header.compressed ? 'C' : 'F'); |
| writer.writeUI8('W'); |
| writer.writeUI8('S'); |
| writer.writeUI8(header.version); |
| writer.write32((int)header.length); |
| if (header.compressed) |
| { |
| writer.markComp(); |
| } |
| encodeRect(header.size, writer); |
| writer.writeUI8(header.rate >> 8); |
| writer.writeUI8(header.rate & 255); |
| framecountPos = writer.getPos(); |
| writer.writeUI16(header.framecount); |
| } |
| |
| public int getWidth() |
| { |
| return width/20; |
| } |
| |
| public int getHeight() |
| { |
| return height/20; |
| } |
| |
| public void finish() |
| { |
| // write end marker |
| writer.writeUI16(0); |
| |
| // update the length |
| writer.write32at(4, writer.getPos()); |
| |
| // update the frame count |
| writer.writeUI16at(framecountPos, frames); |
| } |
| |
| public void writeTo(OutputStream out) throws IOException |
| { |
| writer.writeTo(out, getCompressionLevel()); |
| } |
| |
| public void writeDebugTo(OutputStream out) throws IOException |
| { |
| debug.writeTo(out); |
| } |
| |
| public void setMainDebugScript(String path) |
| { |
| debug.setMainDebugScript(path); |
| } |
| |
| public void encodeRect(Rect r, SwfEncoder w) |
| { |
| int nBits = r.nbits(); |
| w.writeUBits(nBits, 5); |
| w.writeSBits(r.xMin, nBits); |
| w.writeSBits(r.xMax, nBits); |
| w.writeSBits(r.yMin, nBits); |
| w.writeSBits(r.yMax, nBits); |
| w.flushBits(); |
| } |
| |
| public void debugID(DebugID tag) |
| { |
| encodeTagHeader(tag.code, tag.uuid.bytes.length, false); |
| uuidOffset = writer.getPos(); |
| writer.write(tag.uuid.bytes); |
| |
| debug = new DebugEncoder(); |
| debug.header(getSwfVersion()); |
| debug.uuid(tag.uuid); |
| } |
| |
| private void encodeTag(Tag tag) |
| { |
| try |
| { |
| tagw.compress(getCompressionLevel()); |
| encodeTagHeader(tag.code, tagw.getPos(), isLongHeader(tag)); |
| tagw.writeTo(writer, getCompressionLevel()); |
| tagw.reset(); |
| } |
| catch (IOException e) |
| { |
| assert (false); |
| } |
| } |
| |
| private boolean isLongHeader(Tag t) |
| { |
| switch(t.code) |
| { |
| // [preilly] In the player code, ScriptThread::DefineBits() assumes all DefineBits |
| // tags use a long header. See "ch->data = AttachData(pos-8);". If the player |
| // also supported a short header, it would use "pos-4". |
| case stagDefineBits: |
| case stagDefineBitsJPEG2: |
| case stagDefineBitsJPEG3: |
| case stagDefineBitsLossless: |
| case stagDefineBitsLossless2: |
| return true; |
| |
| // [ed] the FlashPaper codebase also indicates that stagSoundStreamBlock must use |
| // a long format header. todo - verify by looking at the player code. |
| case stagSoundStreamBlock: |
| return true; |
| |
| // [edsmith] these tags have code in them. When we're writing a SWD, we use long headers |
| // so we can predict SWF offsets correctly when writing SWD line/offset records. |
| case stagDefineButton: |
| case stagDefineButton2: |
| case stagDefineSprite: |
| case stagDoInitAction: |
| case stagDoAction: |
| return isDebug(); |
| |
| case stagPlaceObject2: |
| return isDebug() && ((PlaceObject)t).hasClipAction(); |
| |
| // all other tags will use short/long headers depending on their length |
| default: |
| return false; |
| } |
| } |
| |
| private void encodeTagHeader(int code, int length, boolean longHeader) |
| { |
| if (longHeader || length >= 63) |
| { |
| writer.writeUI16((code << 6) | 63); |
| writer.write32(length); |
| } |
| else |
| { |
| writer.writeUI16((code << 6) | length); |
| } |
| } |
| |
| public void defineScalingGrid(DefineScalingGrid tag) |
| { |
| int idref = dict.getId(tag.scalingTarget); |
| tagw.writeUI16(idref); |
| encodeRect(tag.rect, tagw); |
| encodeTag(tag); |
| } |
| |
| public void defineBinaryData(DefineBinaryData tag) |
| { |
| encodeTagHeader(tag.code, 6+tag.data.length, false); |
| int id = dict.add(tag); |
| writer.writeUI16(id); |
| writer.write32(tag.reserved); |
| writer.write(tag.data); |
| } |
| |
| public void defineBits(DefineBits tag) |
| { |
| encodeTagHeader(tag.code, 2+tag.data.length, true); |
| int id = dict.add(tag); |
| writer.writeUI16(id); |
| writer.write(tag.data); |
| } |
| |
| public void defineBitsJPEG2(DefineBits tag) |
| { |
| defineBits(tag); |
| } |
| |
| public void defineBitsJPEG3(DefineBitsJPEG3 tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| tagw.write32(tag.data.length); |
| tagw.write(tag.data); |
| tagw.markComp(); |
| tagw.write(tag.alphaData); |
| encodeTag(tag); |
| } |
| |
| public void defineBitsLossless(DefineBitsLossless tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| tagw.writeUI8(tag.format); |
| tagw.writeUI16(tag.width); |
| tagw.writeUI16(tag.height); |
| switch (tag.format) |
| { |
| case 3: |
| tagw.writeUI8(tag.colorData.length - 1); |
| tagw.markComp(); |
| encodeColorMapData(tag.colorData, tag.data, tagw); |
| break; |
| case 4: |
| case 5: |
| tagw.markComp(); |
| encodeBitmapData(tag.data, tagw); |
| break; |
| } |
| encodeTag(tag); |
| } |
| |
| private void encodeBitmapData(byte[] data, SwfEncoder w) |
| { |
| w.write(data); |
| } |
| |
| private void encodeColorMapData(int[] colorData, byte[] pixelData, SwfEncoder w) |
| { |
| for (int i = 0; i < colorData.length; i++) |
| { |
| encodeRGB(colorData[i], w); |
| } |
| w.write(pixelData); |
| } |
| |
| /** |
| * @param rgb as 0x00RRGGBB |
| * @param w |
| */ |
| private void encodeRGB(int rgb, SwfEncoder w) |
| { |
| w.writeUI8(rgb>>>16); // red. we don't mask this because if rgb has an Alpha value, something's wrong |
| w.writeUI8((rgb>>>8)&255); |
| w.writeUI8(rgb&255); // blue |
| } |
| |
| public void defineBitsLossless2(DefineBitsLossless tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| tagw.writeUI8(tag.format); |
| tagw.writeUI16(tag.width); |
| tagw.writeUI16(tag.height); |
| switch (tag.format) |
| { |
| case 3: |
| tagw.writeUI8(tag.colorData.length - 1); |
| tagw.markComp(); |
| encodeAlphaColorMapData(tag.colorData, tag.data, tagw); |
| break; |
| case 4: |
| case 5: |
| tagw.markComp(); |
| encodeBitmapData(tag.data, tagw); |
| break; |
| } |
| encodeTag(tag); |
| } |
| |
| private void encodeAlphaColorMapData(int[] colorData, byte[] pixelData, SwfEncoder w) |
| { |
| for (int i = 0; i < colorData.length; i++) |
| { |
| encodeRGBA(colorData[i], w); |
| } |
| w.write(pixelData); |
| } |
| |
| /** |
| * @param rgba as 0xAARRGGBB |
| * @param w |
| */ |
| private void encodeRGBA(int rgba, SwfEncoder w) |
| { |
| w.writeUI8((rgba>>>16)&255); // red |
| w.writeUI8((rgba>>>8)&255); // green |
| w.writeUI8(rgba&255); // blue |
| w.writeUI8(rgba>>>24); // alpha |
| } |
| |
| public void defineButton(DefineButton tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| |
| if (isDebug()) |
| { |
| debug.adjust = writer.getPos()+6; |
| } |
| |
| for (int i = 0; i < tag.buttonRecords.length; i++) |
| { |
| encodeButtonRecord(tag.buttonRecords[i], tagw, tag.code); |
| } |
| tagw.writeUI8(0); // no more button records |
| |
| // assume there is only one condition we will handle |
| new ActionEncoder(tagw,debug).encode(tag.condActions[0].actionList); |
| tagw.writeUI8(0); // write action end flag, must be zero |
| encodeTag(tag); |
| |
| if (isDebug()) |
| { |
| debug.adjust = 0; |
| } |
| } |
| |
| private void encodeButtonRecord(ButtonRecord record, SwfEncoder w, int defineButton) |
| { |
| if (defineButton == stagDefineButton2) |
| { |
| w.writeUBits(0, 2); |
| w.writeBit(record.blendMode != -1); |
| w.writeBit(record.filters != null); |
| } |
| else |
| { |
| w.writeUBits(0, 4); |
| } |
| w.writeBit(record.hitTest); |
| w.writeBit(record.down); |
| w.writeBit(record.over); |
| w.writeBit(record.up); |
| |
| w.writeUI16(dict.getId(record.characterRef)); |
| w.writeUI16(record.placeDepth); |
| encodeMatrix(record.placeMatrix, w); |
| |
| if (defineButton == stagDefineButton2) |
| { |
| encodeCxforma(record.colorTransform, w); |
| if (record.filters != null) |
| { |
| this.encodeFilterList(record.filters, w); |
| } |
| if (record.blendMode != -1) |
| { |
| w.writeUI8(record.blendMode); |
| } |
| } |
| } |
| |
| private void encodeCxforma(CXFormWithAlpha cxforma, SwfEncoder w) |
| { |
| w.writeBit(cxforma.hasAdd); |
| w.writeBit(cxforma.hasMult); |
| |
| int nbits = cxforma.nbits(); |
| w.writeUBits(nbits, 4); |
| |
| if (cxforma.hasMult) |
| { |
| w.writeSBits(cxforma.redMultTerm, nbits); |
| w.writeSBits(cxforma.greenMultTerm, nbits); |
| w.writeSBits(cxforma.blueMultTerm, nbits); |
| w.writeSBits(cxforma.alphaMultTerm, nbits); |
| } |
| |
| if (cxforma.hasAdd) |
| { |
| w.writeSBits(cxforma.redAddTerm, nbits); |
| w.writeSBits(cxforma.greenAddTerm, nbits); |
| w.writeSBits(cxforma.blueAddTerm, nbits); |
| w.writeSBits(cxforma.alphaAddTerm, nbits); |
| } |
| |
| w.flushBits(); |
| } |
| |
| private void encodeMatrix(Matrix matrix, SwfEncoder w) |
| { |
| w.writeBit(matrix.hasScale); |
| if (matrix.hasScale) |
| { |
| int nScaleBits = matrix.nScaleBits(); |
| w.writeUBits(nScaleBits, 5); |
| w.writeSBits(matrix.scaleX, nScaleBits); |
| w.writeSBits(matrix.scaleY, nScaleBits); |
| } |
| |
| w.writeBit(matrix.hasRotate); |
| if (matrix.hasRotate) |
| { |
| int nRotateBits = matrix.nRotateBits(); |
| w.writeUBits(nRotateBits, 5); |
| w.writeSBits(matrix.rotateSkew0, nRotateBits); |
| w.writeSBits(matrix.rotateSkew1, nRotateBits); |
| } |
| |
| int nTranslateBits = matrix.nTranslateBits(); |
| w.writeUBits(nTranslateBits, 5); |
| w.writeSBits(matrix.translateX, nTranslateBits); |
| w.writeSBits(matrix.translateY, nTranslateBits); |
| |
| w.flushBits(); |
| } |
| |
| public void defineButton2(DefineButton tag) |
| { |
| if (isDebug()) |
| { |
| debug.adjust = writer.getPos()+6; |
| } |
| |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| tagw.writeUBits(0, 7); // reserved |
| tagw.writeBit(tag.trackAsMenu); |
| int offsetPos = tagw.getPos(); |
| tagw.writeUI16(0); // actionOffset |
| |
| for (int i = 0; i < tag.buttonRecords.length; i++) |
| { |
| encodeButtonRecord(tag.buttonRecords[i], tagw, tag.code); |
| } |
| |
| tagw.writeUI8(0); // charEndFlag |
| |
| if (tag.condActions.length > 0) |
| { |
| tagw.writeUI16at(offsetPos, tagw.getPos()-offsetPos); |
| |
| for (int i = 0; i < tag.condActions.length; i++) |
| { |
| boolean isLast = i+1 == tag.condActions.length; |
| encodeButtonCondAction(tag.condActions[i], tagw, isLast); |
| } |
| } |
| encodeTag(tag); |
| |
| if (isDebug()) |
| { |
| debug.adjust = 0; |
| } |
| } |
| |
| private void encodeButtonCondAction(ButtonCondAction condAction, SwfEncoder w, boolean last) |
| { |
| int pos = w.getPos(); |
| w.writeUI16(0); |
| |
| w.writeUBits(condAction.keyPress, 7); |
| w.writeBit(condAction.overDownToIdle); |
| |
| w.writeBit(condAction.idleToOverDown); |
| w.writeBit(condAction.outDownToIdle); |
| w.writeBit(condAction.outDownToOverDown); |
| w.writeBit(condAction.overDownToOutDown); |
| w.writeBit(condAction.overDownToOverUp); |
| w.writeBit(condAction.overUpToOverDown); |
| w.writeBit(condAction.overUpToIdle); |
| w.writeBit(condAction.idleToOverUp); |
| |
| new ActionEncoder(w,debug).encode(condAction.actionList); |
| w.writeUI8(0); // end action byte |
| |
| if (!last) |
| { |
| w.writeUI16at(pos, w.getPos()-pos); |
| } |
| } |
| |
| public void defineButtonCxform(DefineButtonCxform tag) |
| { |
| int idref = dict.getId(tag.button); |
| tagw.writeUI16(idref); |
| encodeCxform(tag.colorTransform, tagw); |
| encodeTag(tag); |
| } |
| |
| private void encodeCxform(CXForm cxform, SwfEncoder w) |
| { |
| |
| w.writeBit(cxform.hasAdd); |
| w.writeBit(cxform.hasMult); |
| |
| int nbits = cxform.nbits(); |
| w.writeUBits(nbits, 4); |
| |
| if (cxform.hasMult) |
| { |
| w.writeSBits(cxform.redMultTerm, nbits); |
| w.writeSBits(cxform.greenMultTerm, nbits); |
| w.writeSBits(cxform.blueMultTerm, nbits); |
| } |
| |
| if (cxform.hasAdd) |
| { |
| w.writeSBits(cxform.redAddTerm, nbits); |
| w.writeSBits(cxform.greenAddTerm, nbits); |
| w.writeSBits(cxform.blueAddTerm, nbits); |
| } |
| |
| w.flushBits(); |
| } |
| |
| public void defineButtonSound(DefineButtonSound tag) |
| { |
| int idref = dict.getId(tag.button); |
| tagw.writeUI16(idref); |
| if (tag.sound0 != null) |
| { |
| tagw.writeUI16(dict.getId(tag.sound0)); |
| encodeSoundInfo(tag.info0, tagw); |
| } |
| else |
| { |
| tagw.writeUI16(0); |
| } |
| if (tag.sound1 != null) |
| { |
| tagw.writeUI16(dict.getId(tag.sound1)); |
| encodeSoundInfo(tag.info1, tagw); |
| } |
| else |
| { |
| tagw.writeUI16(0); |
| } |
| if (tag.sound2 != null) |
| { |
| tagw.writeUI16(dict.getId(tag.sound2)); |
| encodeSoundInfo(tag.info2, tagw); |
| } |
| else |
| { |
| tagw.writeUI16(0); |
| } |
| if (tag.sound3 != null) |
| { |
| tagw.writeUI16(dict.getId(tag.sound3)); |
| encodeSoundInfo(tag.info3, tagw); |
| } |
| else |
| { |
| tagw.writeUI16(0); |
| } |
| encodeTag(tag); |
| } |
| |
| private void encodeSoundInfo(SoundInfo info, SwfEncoder w) |
| { |
| w.writeUBits(0, 2); // reserved |
| w.writeBit(info.syncStop); |
| w.writeBit(info.syncNoMultiple); |
| w.writeBit(info.records != null); |
| w.writeBit(info.loopCount != SoundInfo.UNINITIALIZED); |
| w.writeBit(info.outPoint != SoundInfo.UNINITIALIZED); |
| w.writeBit(info.inPoint != SoundInfo.UNINITIALIZED); |
| |
| if (info.inPoint != SoundInfo.UNINITIALIZED) |
| { |
| w.write32((int)info.inPoint); |
| } |
| if (info.outPoint != SoundInfo.UNINITIALIZED) |
| { |
| w.write32((int)info.outPoint); |
| } |
| if (info.loopCount != SoundInfo.UNINITIALIZED) |
| { |
| w.writeUI16(info.loopCount); |
| } |
| if (info.records != null) |
| { |
| w.writeUI8(info.records.length); |
| for (int k = 0; k < info.records.length; k++) |
| { |
| w.write64(info.records[k]); |
| } |
| } |
| } |
| |
| public void defineEditText(DefineEditText tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| encodeRect(tag.bounds, tagw); |
| |
| tagw.writeBit(tag.hasText); |
| tagw.writeBit(tag.wordWrap); |
| tagw.writeBit(tag.multiline); |
| tagw.writeBit(tag.password); |
| tagw.writeBit(tag.readOnly); |
| tagw.writeBit(tag.hasTextColor); |
| tagw.writeBit(tag.hasMaxLength); |
| tagw.writeBit(tag.hasFont); |
| |
| tagw.writeBit(tag.hasFontClass && !tag.hasFont); // FP 9.0.45 or later |
| tagw.writeBit(tag.autoSize); |
| tagw.writeBit(tag.hasLayout); |
| tagw.writeBit(tag.noSelect); |
| tagw.writeBit(tag.border); |
| tagw.writeBit(tag.wasStatic); |
| tagw.writeBit(tag.html); |
| tagw.writeBit(tag.useOutlines); |
| |
| tagw.flushBits(); |
| |
| if (tag.hasFont) |
| { |
| int idref = dict.getId(tag.font); |
| tagw.writeUI16(idref); |
| tagw.writeUI16(tag.height); |
| } |
| else if (tag.hasFontClass) |
| { |
| tagw.writeString(tag.fontClass); |
| tagw.writeUI16(tag.height); |
| } |
| |
| if (tag.hasTextColor) |
| { |
| encodeRGBA(tag.color, tagw); |
| } |
| |
| if (tag.hasMaxLength) |
| { |
| tagw.writeUI16(tag.maxLength); |
| } |
| |
| if (tag.hasLayout) |
| { |
| tagw.writeUI8(tag.align); |
| tagw.writeUI16(tag.leftMargin); |
| tagw.writeUI16(tag.rightMargin); |
| tagw.writeUI16(tag.ident); |
| tagw.writeSI16(tag.leading); // see errata, leading is signed |
| } |
| |
| tagw.writeString(tag.varName); |
| if (tag.hasText) |
| { |
| tagw.writeString(tag.initialText); |
| } |
| encodeTag(tag); |
| } |
| |
| public void defineFont(DefineFont1 tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| |
| int count = tag.glyphShapeTable.length; |
| |
| int offsetPos = tagw.getPos(); |
| |
| // write offset placeholders |
| for (int i = 0; i < count; i++) |
| { |
| tagw.writeUI16(0); |
| } |
| |
| // now write glyphs and update the encoded offset table |
| for (int i = 0; i < count; i++) |
| { |
| tagw.writeUI16at(offsetPos+2*i, tagw.getPos()-offsetPos); |
| encodeShape(tag.glyphShapeTable[i], tagw, stagDefineShape3, 1, 0); |
| } |
| |
| encodeTag(tag); |
| } |
| |
| public void encodeShape(Shape s, SwfEncoder w, int shape, int nFillStyles, int nLineStyles) |
| { |
| int[] numFillBits = new int[] { SwfEncoder.minBits(nFillStyles,0) }; |
| int[] numLineBits = new int[] { SwfEncoder.minBits(nLineStyles,0) }; |
| |
| w.writeUBits(numFillBits[0], 4); |
| w.writeUBits(numLineBits[0], 4); |
| |
| if (s != null && s.shapeRecords != null) |
| { |
| Iterator<ShapeRecord> it = s.shapeRecords.iterator(); |
| while (it.hasNext()) |
| { |
| ShapeRecord record = it.next(); |
| if (record instanceof StyleChangeRecord) |
| { |
| // style change |
| w.writeBit(false); |
| StyleChangeRecord change = (StyleChangeRecord) record; |
| encodeStyleChangeRecord(w, change, numFillBits, numLineBits, shape); |
| } |
| else |
| { |
| // edge |
| w.writeBit(true); |
| EdgeRecord e = (EdgeRecord) record; |
| boolean straight = e instanceof StraightEdgeRecord; |
| w.writeBit(straight); |
| int nbits = straight ? calcBits((StraightEdgeRecord)e) : calcBits((CurvedEdgeRecord)e); |
| if (nbits < 2) |
| nbits = 2; |
| w.writeUBits(nbits-2, 4); |
| if (straight) |
| { |
| // line |
| StraightEdgeRecord line = (StraightEdgeRecord) e; |
| encodeStraightEdgeRecord(line, w, nbits); |
| } |
| else |
| { |
| // curve |
| CurvedEdgeRecord curve = (CurvedEdgeRecord) e; |
| w.writeSBits(curve.controlDeltaX, nbits); |
| w.writeSBits(curve.controlDeltaY, nbits); |
| w.writeSBits(curve.anchorDeltaX, nbits); |
| w.writeSBits(curve.anchorDeltaY, nbits); |
| } |
| } |
| } |
| } |
| |
| // endshaperecord |
| w.writeUBits(0, 6); |
| |
| w.flushBits(); |
| } |
| |
| private int calcBits(StraightEdgeRecord edge) |
| { |
| return SwfEncoder.minBits(SwfEncoder.maxNum(edge.deltaX,edge.deltaY,0,0),1); |
| } |
| |
| private int calcBits(CurvedEdgeRecord edge) |
| { |
| return SwfEncoder.minBits(SwfEncoder.maxNum(edge.controlDeltaX, |
| edge.controlDeltaY, |
| edge.anchorDeltaX, |
| edge.anchorDeltaY), 1); |
| } |
| |
| private void encodeStraightEdgeRecord(StraightEdgeRecord line, SwfEncoder w, int nbits) |
| { |
| if (line.deltaX == 0) |
| { |
| w.writeUBits(01, 2); // vertical line |
| w.writeSBits(line.deltaY, nbits); |
| } |
| else if (line.deltaY == 0) |
| { |
| w.writeUBits(00, 2); // horizontal line |
| w.writeSBits(line.deltaX, nbits); |
| } |
| else |
| { |
| w.writeBit(true); // general line |
| w.writeSBits(line.deltaX, nbits); |
| w.writeSBits(line.deltaY, nbits); |
| } |
| } |
| |
| private void encodeStyleChangeRecord(SwfEncoder w, StyleChangeRecord s, |
| int[] numFillBits, int[] numLineBits, int shape) |
| { |
| w.writeBit(s.stateNewStyles); |
| w.writeBit(s.stateLineStyle); |
| w.writeBit(s.stateFillStyle1); |
| w.writeBit(s.stateFillStyle0); |
| w.writeBit(s.stateMoveTo); |
| |
| if (s.stateMoveTo) |
| { |
| int moveBits = s.nMoveBits(); |
| w.writeUBits(moveBits, 5); |
| w.writeSBits(s.moveDeltaX, moveBits); |
| w.writeSBits(s.moveDeltaY, moveBits); |
| } |
| |
| if (s.stateFillStyle0) |
| { |
| w.writeUBits(s.fillstyle0, numFillBits[0]); |
| } |
| |
| if (s.stateFillStyle1) |
| { |
| w.writeUBits(s.fillstyle1, numFillBits[0]); |
| } |
| |
| if (s.stateLineStyle) |
| { |
| w.writeUBits(s.linestyle, numLineBits[0]); |
| } |
| |
| if (s.stateNewStyles) |
| { |
| w.flushBits(); |
| |
| encodeFillstyles(s.fillstyles, w, shape); |
| encodeLinestyles(s.linestyles, w, shape); |
| |
| numFillBits[0] = SwfEncoder.minBits(s.fillstyles.size(), 0); |
| numLineBits[0] = SwfEncoder.minBits(s.linestyles.size(), 0); |
| w.writeUBits(numFillBits[0], 4); |
| w.writeUBits(numLineBits[0], 4); |
| } |
| } |
| |
| private void encodeLinestyles(ArrayList<LineStyle> linestyles, SwfEncoder w, int shape) |
| { |
| int count = 0; |
| |
| if (linestyles != null) |
| count = linestyles.size(); |
| |
| if (count > 0xFF) |
| { |
| w.writeUI8(0xFF); |
| w.writeUI16(count); |
| } |
| else |
| { |
| w.writeUI8(count); |
| } |
| |
| for (int i = 0; i < count; i++) |
| { |
| encodeLineStyle((LineStyle)linestyles.get(i), w, shape); |
| } |
| } |
| |
| private void encodeLineStyle(LineStyle lineStyle, SwfEncoder w, int shape) |
| { |
| w.writeUI16(lineStyle.width); |
| |
| if (shape == stagDefineShape4) |
| { |
| w.writeUI16( lineStyle.flags ); |
| if (lineStyle.hasMiterJoint()) |
| w.writeUI16( lineStyle.miterLimit ); |
| } |
| |
| if (shape == stagDefineShape4 && lineStyle.hasFillStyle()) |
| { |
| encodeFillStyle( lineStyle.fillStyle, w, shape ); |
| } |
| else if ((shape == stagDefineShape3) || (shape == stagDefineShape4)) |
| { |
| encodeRGBA(lineStyle.color, w); |
| } |
| else |
| { |
| encodeRGB(lineStyle.color, w); |
| } |
| } |
| |
| private void encodeFillstyles(ArrayList<FillStyle> fillstyles, SwfEncoder w, int shape) |
| { |
| int count = 0; |
| if (fillstyles != null) |
| count = fillstyles.size(); |
| |
| if (count >= 0xFF) |
| { |
| w.writeUI8(0xFF); |
| w.writeUI16(count); |
| } |
| else |
| { |
| w.writeUI8(count); |
| } |
| |
| if (count > 0) |
| { |
| Iterator<FillStyle> it = fillstyles.iterator(); |
| while (it.hasNext()) |
| { |
| FillStyle style = (FillStyle) it.next(); |
| encodeFillStyle(style, w, shape); |
| } |
| } |
| } |
| |
| private void encodeFillStyle(FillStyle style, SwfEncoder w, int shape) |
| { |
| w.writeUI8(style.type); |
| switch (style.type) |
| { |
| case FillStyle.FILL_SOLID: // 0x00 |
| if ((shape == stagDefineShape3) || (shape == stagDefineShape4)) encodeRGBA(style.color, w); |
| else encodeRGB(style.color, w); |
| break; |
| case FillStyle.FILL_GRADIENT: // 0x10 linear gradient fill |
| case FillStyle.FILL_RADIAL_GRADIENT: // 0x12 radial gradient fill |
| case FillStyle.FILL_FOCAL_RADIAL_GRADIENT: // 0x13 focal radial gradient fill |
| encodeMatrix(style.matrix, w); |
| encodeGradient(style.gradient, w, shape); |
| break; |
| case FillStyle.FILL_BITS: // 0x40 tiled bitmap fill |
| case (FillStyle.FILL_BITS | FillStyle.FILL_BITS_CLIP): // 0x41 clipped bitmap fill |
| case (FillStyle.FILL_BITS | FillStyle.FILL_BITS_NOSMOOTH): // 0x42 tiled non-smoothed fill |
| case (FillStyle.FILL_BITS | FillStyle.FILL_BITS_CLIP | FillStyle.FILL_BITS_NOSMOOTH): // 0x43 clipped non-smoothed fill |
| int id = dict.add(style.bitmap); |
| w.writeUI16(id); |
| encodeMatrix(style.matrix, w); |
| break; |
| } |
| } |
| |
| private void encodeGradient( Gradient gradient, SwfEncoder w, int shape) |
| { |
| w.writeUBits( gradient.spreadMode, 2 ); |
| w.writeUBits( gradient.interpolationMode, 2 ); |
| w.writeUBits( gradient.records.length, 4 ); |
| for (int i = 0; i < gradient.records.length; i++) |
| { |
| encodeGradRecord(gradient.records[i], w, shape); |
| } |
| if (gradient instanceof FocalGradient) |
| { |
| w.writeFixed8( ((FocalGradient)gradient).focalPoint ); |
| } |
| } |
| |
| private void encodeGradRecord(GradRecord record, SwfEncoder w, int shape) |
| { |
| w.writeUI8(record.ratio); |
| if ((shape == stagDefineShape3) || (shape == stagDefineShape4)) |
| encodeRGBA(record.color, w); |
| else |
| encodeRGB(record.color, w); |
| } |
| |
| public void defineFont2(DefineFont2 tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| int startPos = tagw.getPos(); |
| boolean again; |
| |
| if (tag.code == stagDefineFont3) |
| { |
| tag.wideCodes = true; |
| } |
| |
| if (! tag.wideCodes) |
| { |
| for (int i=0; i < tag.codeTable.length; i++) |
| { |
| if (tag.codeTable[i] > 255) |
| { |
| tag.wideCodes = true; |
| break; |
| } |
| } |
| } |
| |
| loop: |
| do |
| { |
| again = false; |
| tagw.writeBit(tag.hasLayout); |
| tagw.writeBit(tag.shiftJIS); |
| tagw.writeBit(tag.smallText); |
| tagw.writeBit(tag.ansi); |
| tagw.writeBit(tag.wideOffsets); |
| tagw.writeBit(tag.wideCodes); |
| tagw.writeBit(tag.italic); |
| tagw.writeBit(tag.bold); |
| tagw.flushBits(); |
| |
| tagw.writeUI8(tag.langCode); |
| |
| tagw.writeLengthString(tag.fontName); |
| int count = tag.glyphShapeTable.length; |
| |
| tagw.writeUI16(count); |
| int offsetPos = tagw.getPos(); |
| |
| // save space for the offset table |
| if (tag.wideOffsets) |
| { |
| for (int i=0; i < count; i++) |
| { |
| tagw.write32(0); |
| } |
| } |
| else |
| { |
| for (int i=0; i < count; i++) |
| { |
| tagw.writeUI16(0); |
| } |
| } |
| |
| //PJF: write placeholder for codeTableOffset, this will be changed after shapes encoded |
| if (count > 0) |
| { |
| if (tag.wideOffsets) |
| { |
| tagw.write32(0); |
| } |
| else |
| { |
| tagw.writeUI16(0); |
| } |
| } |
| |
| for (int i = 0; i < count; i++) |
| { |
| // save offset to this glyph |
| int offset = tagw.getPos()-offsetPos; |
| if (!tag.wideOffsets && offset > 65535) |
| { |
| again = true; |
| tag.wideOffsets = true; |
| tagw.setPos(startPos); |
| continue loop; |
| } |
| if (tag.wideOffsets) |
| tagw.write32at(offsetPos+4*i, offset); |
| else |
| tagw.writeUI16at(offsetPos+2*i, offset); |
| |
| encodeShape(tag.glyphShapeTable[i], tagw, stagDefineShape3, 1, 0); |
| } |
| |
| // update codeTableOffset |
| int offset = tagw.getPos()-offsetPos; |
| if (!tag.wideOffsets && offset > 65535) |
| { |
| again = true; |
| tag.wideOffsets = true; |
| tagw.setPos(startPos); |
| continue loop; |
| } |
| if (tag.wideOffsets) |
| { |
| tagw.write32at(offsetPos+4*count, offset); |
| } |
| else |
| { |
| tagw.writeUI16at(offsetPos+2*count, offset); |
| } |
| |
| // now write the codetable |
| |
| if (tag.wideCodes) |
| { |
| for (int i = 0; i < tag.codeTable.length; i++) |
| { |
| tagw.writeUI16(tag.codeTable[i]); |
| } |
| } |
| else |
| { |
| for (int i = 0; i < tag.codeTable.length; i++) |
| { |
| tagw.writeUI8(tag.codeTable[i]); |
| } |
| } |
| |
| if (tag.hasLayout) |
| { |
| tagw.writeSI16(tag.ascent); |
| tagw.writeSI16(tag.descent); |
| tagw.writeSI16(tag.leading); |
| |
| for (int i = 0; i < tag.advanceTable.length; i++) |
| { |
| tagw.writeSI16(tag.advanceTable[i]); |
| } |
| |
| for (int i = 0; i < tag.boundsTable.length; i++) |
| { |
| encodeRect(tag.boundsTable[i], tagw); |
| } |
| |
| tagw.writeUI16(tag.kerningTable.length); |
| |
| for (int i = 0; i < tag.kerningTable.length; i++) |
| { |
| if (!tag.wideCodes && ((tag.kerningTable[i].code1 > 255) || |
| (tag.kerningTable[i].code2 > 255))) |
| { |
| again = true; |
| tag.wideCodes = true; |
| tagw.setPos(startPos); |
| continue loop; |
| } |
| |
| encodeKerningRecord(tag.kerningTable[i], tagw, tag.wideCodes); |
| } |
| } |
| } |
| while (again); |
| |
| encodeTag(tag); |
| } |
| |
| public void defineFont3(DefineFont3 tag) |
| { |
| defineFont2(tag); |
| } |
| |
| public void defineFont4(DefineFont4 tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| |
| tagw.writeUBits(0, 5); // reserved |
| tagw.writeBit(tag.hasFontData); |
| //tagw.writeBit(tag.smallText); |
| tagw.writeBit(tag.italic); |
| tagw.writeBit(tag.bold); |
| tagw.flushBits(); |
| |
| //tagw.writeUI8(tag.langCode); |
| tagw.writeString(tag.fontName); |
| if (tag.hasFontData) |
| { |
| tagw.write(tag.data); |
| } |
| |
| encodeTag(tag); |
| } |
| |
| public void defineFontAlignZones(DefineFontAlignZones tag) |
| { |
| int fontID = dict.getId(tag.font); |
| tagw.writeUI16(fontID); |
| tagw.writeUBits(tag.csmTableHint, 2); |
| tagw.writeUBits(0, 6); // reserved |
| for (int i = 0; i < tag.zoneTable.length; i++) |
| { |
| ZoneRecord record = tag.zoneTable[i]; |
| tagw.writeUI8(record.numZoneData); |
| for (int j = 0; j < record.numZoneData; j++) |
| { |
| tagw.write32((int)record.zoneData[j]); |
| } |
| tagw.writeUI8(record.zoneMask); |
| } |
| encodeTag(tag); |
| } |
| |
| public void csmTextSettings(CSMTextSettings tag) |
| { |
| int textID = 0; |
| if (tag.textReference != null) |
| { |
| textID = dict.getId(tag.textReference); |
| } |
| tagw.writeUI16(textID); |
| tagw.writeUBits(tag.styleFlagsUseSaffron, 2); |
| tagw.writeUBits(tag.gridFitType, 3); |
| tagw.writeUBits(0, 3); // reserved |
| // FIXME: thickness/sharpness should be written out as 32 bit IEEE Single Precision format in little Endian |
| tagw.writeUBits((int)tag.thickness, 32); |
| tagw.writeUBits((int)tag.sharpness, 32); |
| tagw.writeUBits(0, 8); //reserved |
| |
| encodeTag(tag); |
| } |
| |
| public void defineFontName(DefineFontName tag) |
| { |
| int fontID = dict.getId(tag.font); |
| tagw.writeUI16(fontID); |
| if (tag.fontName != null) |
| { |
| tagw.writeString(tag.fontName); |
| } |
| else |
| { |
| tagw.writeString(""); |
| } |
| if (tag.copyright != null) |
| { |
| tagw.writeString(tag.copyright); |
| } |
| else |
| { |
| tagw.writeString(""); |
| } |
| |
| encodeTag(tag); |
| } |
| |
| private void encodeKerningRecord(KerningRecord kerningRecord, SwfEncoder w, boolean wideCodes) |
| { |
| if (wideCodes) |
| { |
| w.writeUI16(kerningRecord.code1); |
| w.writeUI16(kerningRecord.code2); |
| } |
| else |
| { |
| w.writeUI8(kerningRecord.code1); |
| w.writeUI8(kerningRecord.code2); |
| } |
| w.writeUI16(kerningRecord.adjustment); |
| } |
| |
| public void defineFontInfo(DefineFontInfo tag) |
| { |
| int idref = dict.getId(tag.font); |
| tagw.writeUI16(idref); |
| |
| tagw.writeLengthString(tag.name); |
| |
| tagw.writeUBits(0, 3); // reserved |
| tagw.writeBit(tag.shiftJIS); |
| tagw.writeBit(tag.ansi); |
| tagw.writeBit(tag.italic); |
| tagw.writeBit(tag.bold); |
| |
| if (tag.code == stagDefineFontInfo2) |
| { |
| tagw.writeBit(tag.wideCodes = true); |
| tagw.writeUI8(tag.langCode); |
| } |
| else |
| { |
| if (! tag.wideCodes) |
| { |
| for (int i=0; i < tag.codeTable.length; i++) |
| { |
| if (tag.codeTable[i] > 255) |
| { |
| tag.wideCodes = true; |
| break; |
| } |
| } |
| } |
| tagw.writeBit(tag.wideCodes); |
| } |
| |
| if (tag.wideCodes) |
| { |
| for (int i = 0; i < tag.codeTable.length; i++) |
| tagw.writeUI16(tag.codeTable[i]); |
| } |
| else |
| { |
| for (int i = 0; i < tag.codeTable.length; i++) |
| tagw.writeUI8(tag.codeTable[i]); |
| } |
| encodeTag(tag); |
| } |
| |
| public void defineFontInfo2(DefineFontInfo tag) |
| { |
| defineFontInfo(tag); |
| } |
| |
| public void defineMorphShape(DefineMorphShape tag) |
| { |
| defineMorphShape2(tag); |
| } |
| |
| public void defineMorphShape2(DefineMorphShape tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| encodeRect(tag.startBounds, tagw); |
| encodeRect(tag.endBounds, tagw); |
| if (tag.code == stagDefineMorphShape2) |
| { |
| encodeRect(tag.startEdgeBounds, tagw); |
| encodeRect(tag.endEdgeBounds, tagw); |
| tagw.writeUBits(tag.reserved, 6); |
| tagw.writeUBits(tag.usesNonScalingStrokes ? 1 : 0, 1); |
| tagw.writeUBits(tag.usesScalingStrokes ? 1 : 0, 1); |
| } |
| tagw.write32(0); |
| int pos = tagw.getPos(); |
| encodeMorphFillstyles(tag.fillStyles, tagw, tag.code); |
| encodeMorphLinestyles(tag.lineStyles, tagw, tag.code); |
| encodeShape(tag.startEdges, tagw, stagDefineShape3, tag.fillStyles.length, tag.lineStyles.length); |
| tagw.write32at(pos-4, tagw.getPos() - pos); |
| // end shape contains only edges, no style information |
| encodeShape(tag.endEdges, tagw, stagDefineShape3, 0, 0); |
| encodeTag(tag); |
| } |
| |
| private void encodeMorphFillstyles(MorphFillStyle[] fillStyles, SwfEncoder w, int code) |
| { |
| int count = fillStyles.length; |
| if (count >= 0xFF) |
| { |
| w.writeUI8(0xFF); |
| w.writeUI16(count); |
| } |
| else |
| { |
| w.writeUI8(count); |
| } |
| |
| for (int i = 0; i < count; i++) |
| { |
| encodeMorphFillstyle(fillStyles[i], w, code); |
| } |
| } |
| |
| private void encodeMorphFillstyle(MorphFillStyle style, SwfEncoder w, int code) |
| { |
| w.writeUI8(style.type); |
| switch (style.type) |
| { |
| case FillStyle.FILL_SOLID: // 0x00 |
| encodeRGBA(style.startColor, w); |
| encodeRGBA(style.endColor, w); |
| break; |
| case FillStyle.FILL_GRADIENT: // 0x10 linear gradient fill |
| case FillStyle.FILL_RADIAL_GRADIENT: // 0x12 radial gradient fill |
| case FillStyle.FILL_FOCAL_RADIAL_GRADIENT: // 0x13 focal radial gradient fill |
| encodeMatrix(style.startGradientMatrix, w); |
| encodeMatrix(style.endGradientMatrix, w); |
| encodeMorphGradient(style.gradRecords, w); |
| if (style.type == FillStyle.FILL_FOCAL_RADIAL_GRADIENT && code == stagDefineMorphShape2) |
| { |
| w.writeSI16(style.ratio1); |
| w.writeSI16(style.ratio2); |
| } |
| break; |
| case FillStyle.FILL_BITS: // 0x40 tiled bitmap fill |
| case (FillStyle.FILL_BITS | FillStyle.FILL_BITS_CLIP): // 0x41 clipped bitmap fill |
| case (FillStyle.FILL_BITS | FillStyle.FILL_BITS_NOSMOOTH): // 0x42 tiled non-smoothed fill |
| case (FillStyle.FILL_BITS | FillStyle.FILL_BITS_CLIP | FillStyle.FILL_BITS_NOSMOOTH): // 0x43 clipped non-smoothed fill |
| int id = dict.add(style.bitmap); |
| w.writeUI16(id); |
| encodeMatrix(style.startBitmapMatrix, w); |
| encodeMatrix(style.endBitmapMatrix, w); |
| break; |
| default: |
| assert (false); |
| //throw new IOException("unrecognized fill style type: " + style.type); |
| } |
| } |
| |
| private void encodeMorphGradient(MorphGradRecord[] gradRecords, SwfEncoder w) |
| { |
| w.writeUI8(gradRecords.length); |
| for (int i = 0; i < gradRecords.length; i++) |
| { |
| MorphGradRecord record = gradRecords[i]; |
| w.writeUI8(record.startRatio); |
| encodeRGBA(record.startColor, w); |
| w.writeUI8(record.endRatio); |
| encodeRGBA(record.endColor, w); |
| } |
| } |
| |
| private void encodeMorphLinestyles(MorphLineStyle[] lineStyles, SwfEncoder w, int code) |
| { |
| if (lineStyles.length >= 0xFF) |
| { |
| w.writeUI8(0xFF); |
| w.writeUI16(lineStyles.length); |
| } |
| else |
| { |
| w.writeUI8(lineStyles.length); |
| } |
| |
| for (int i = 0; i < lineStyles.length; i++) |
| { |
| MorphLineStyle style = lineStyles[i]; |
| w.writeUI16(style.startWidth); |
| w.writeUI16(style.endWidth); |
| if (code == stagDefineMorphShape2) |
| { |
| w.writeUBits(style.startCapsStyle, 2); |
| w.writeUBits(style.jointStyle, 2); |
| w.writeBit(style.hasFill); |
| w.writeBit(style.noHScale); |
| w.writeBit(style.noVScale); |
| w.writeBit(style.pixelHinting); |
| w.writeUBits(0, 5); // reserved |
| w.writeBit(style.noClose); |
| w.writeUBits(style.endCapsStyle, 2); |
| if (style.jointStyle == 2) |
| { |
| w.writeUI16(style.miterLimit); |
| } |
| } |
| if (!style.hasFill) |
| { |
| encodeRGBA(style.startColor,w); |
| encodeRGBA(style.endColor,w); |
| } |
| if (style.hasFill) |
| { |
| encodeMorphFillstyle(style.fillType, w, code); |
| } |
| } |
| } |
| |
| public void defineShape(DefineShape tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| encodeRect(tag.bounds, tagw); |
| if (tag.code == stagDefineShape4) |
| { |
| encodeRect(tag.edgeBounds, tagw); |
| tagw.writeUBits(0, 5); |
| tagw.writeBit(tag.usesFillWindingRule); |
| tagw.writeBit(tag.usesNonScalingStrokes); |
| tagw.writeBit(tag.usesScalingStrokes); |
| } |
| encodeShapeWithStyle(tag.shapeWithStyle, tagw, tag.code); |
| encodeTag(tag); |
| } |
| |
| private void encodeShapeWithStyle(ShapeWithStyle sws, SwfEncoder w, int shape) |
| { |
| encodeFillstyles(sws.fillstyles, w, shape); |
| encodeLinestyles(sws.linestyles, w, shape); |
| |
| int fillStyleCount = sws.fillstyles == null ? 0 : sws.fillstyles.size(); |
| int lineStyleCount = sws.linestyles == null ? 0 : sws.linestyles.size(); |
| encodeShape(sws, w, shape, fillStyleCount, lineStyleCount); |
| } |
| |
| public void defineShape2(DefineShape tag) |
| { |
| defineShape(tag); |
| } |
| |
| public void defineShape3(DefineShape tag) |
| { |
| defineShape(tag); |
| } |
| |
| public void defineShape4(DefineShape tag) |
| { |
| defineShape(tag); |
| } |
| |
| public void defineSound(DefineSound tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| tagw.writeUBits(tag.format, 4); |
| tagw.writeUBits(tag.rate, 2); |
| tagw.writeUBits(tag.size, 1); |
| tagw.writeUBits(tag.type, 1); |
| tagw.write32((int)tag.sampleCount); |
| tagw.write(tag.data); |
| encodeTag(tag); |
| } |
| |
| public void defineSprite(DefineSprite tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| tagw.writeUI16(tag.framecount); |
| |
| if (isDebug()) |
| { |
| debug.adjust = writer.getPos()+6; |
| } |
| |
| // save frame count |
| int oldFrames = frames; |
| frames = 0; |
| |
| // save the movie writer, and push a new writer |
| SwfEncoder oldWriter = writer; |
| writer = tagw; |
| tagw = createEncoder(getSwfVersion()); |
| |
| // write sprite tags |
| List tags = tag.tagList.tags; |
| int size = tags.size(); |
| for (int i = 0; i < size; i++) |
| { |
| Tag t = (Tag) tags.get(i); |
| if (!(t instanceof DefineTag)) |
| t.visit(this); |
| } |
| |
| // terminate with end marker |
| writer.writeUI16(0); |
| |
| // update frame count |
| writer.writeUI16at(2, frames); |
| |
| // restore writers |
| tagw = writer; |
| writer = oldWriter; |
| frames = oldFrames; |
| |
| if (isDebug()) |
| { |
| debug.adjust = 0; |
| } |
| |
| encodeTag(tag); |
| } |
| |
| public void defineText(DefineText tag) |
| { |
| encodeDefineText(tag, tagw, tag.code); |
| encodeTag(tag); |
| } |
| |
| private void encodeDefineText(DefineText tag, SwfEncoder w, int type) |
| { |
| int id = dict.add(tag); |
| w.writeUI16(id); |
| encodeRect(tag.bounds, w); |
| encodeMatrix(tag.matrix, w); |
| int length = tag.records.size(); |
| |
| // compute necessary bit width |
| int glyphBits = 0; |
| int advanceBits = 0; |
| for (int i=0; i < length; i++) |
| { |
| TextRecord tr = tag.records.get(i); |
| |
| for (int j = 0; j < tr.entries.length; j++) |
| { |
| GlyphEntry entry = tr.entries[j]; |
| |
| while (entry.getIndex() > (1<<glyphBits)) |
| glyphBits++; |
| while (Math.abs(entry.advance) > (1<<advanceBits)) |
| advanceBits++; |
| } |
| } |
| |
| // increment to get from bit index to bit count. |
| ++glyphBits; |
| ++advanceBits; |
| |
| w.writeUI8(glyphBits); |
| w.writeUI8(++advanceBits); // add one extra bit because advances are signed |
| |
| for (int i = 0; i < length; i++) |
| { |
| TextRecord record = tag.records.get(i); |
| encodeTextRecord(record, w, type, glyphBits, advanceBits); |
| } |
| |
| w.writeUI8(0); |
| } |
| |
| private void encodeFilterList(List<Filter> filters, SwfEncoder w) |
| { |
| int count = filters.size(); |
| w.writeUI8( count ); |
| for (Iterator<Filter> it = filters.iterator(); it.hasNext();) |
| { |
| Filter f = (Filter) it.next(); |
| w.writeUI8(f.getID()); |
| // I've never quite understood why the serialization code isn't in the tags themselves.. |
| switch(f.getID()) |
| { |
| case DropShadowFilter.ID: encodeDropShadowFilter( w, (DropShadowFilter) f ); break; |
| case BlurFilter.ID: encodeBlurFilter( w, (BlurFilter) f ); break; |
| case ConvolutionFilter.ID: encodeConvolutionFilter( w, (ConvolutionFilter) f ); break; |
| case GlowFilter.ID: encodeGlowFilter( w, (GlowFilter) f ); break; |
| case BevelFilter.ID: encodeBevelFilter( w, (BevelFilter) f ); break; |
| case ColorMatrixFilter.ID: encodeColorMatrixFilter( w, (ColorMatrixFilter) f ); break; |
| case GradientGlowFilter.ID: encodeGradientGlowFilter( w, (GradientGlowFilter) f ); break; |
| case GradientBevelFilter.ID: encodeGradientBevelFilter( w, (GradientBevelFilter) f ); break; |
| |
| } |
| |
| } |
| } |
| |
| private void encodeDropShadowFilter( SwfEncoder w, DropShadowFilter f ) |
| { |
| encodeRGBA( f.color, w ); |
| w.write32( f.blurX ); |
| w.write32( f.blurY ); |
| w.write32( f.angle ); |
| w.write32( f.distance ); |
| w.writeUI16( f.strength ); |
| w.writeUI8( f.flags ); |
| } |
| |
| private void encodeBlurFilter( SwfEncoder w, BlurFilter f ) |
| { |
| w.write32( f.blurX ); |
| w.write32( f.blurY ); |
| w.writeUI8( f.passes ); |
| } |
| private void encodeColorMatrixFilter( SwfEncoder w, ColorMatrixFilter f ) |
| { |
| for (int i = 0; i < 20; ++i) |
| { |
| w.writeFloat( f.values[i]); |
| } |
| } |
| private void encodeConvolutionFilter( SwfEncoder w, ConvolutionFilter f ) |
| { |
| w.writeUI8( f.matrixX ); |
| w.writeUI8( f.matrixY ); |
| w.writeFloat( f.divisor ); |
| w.writeFloat( f.bias ); |
| for (int i = 0; i < f.matrix.length; ++i) |
| w.writeFloat( f.matrix[i] ); |
| w.writeUI8( f.flags ); |
| } |
| private void encodeGlowFilter( SwfEncoder w, GlowFilter f ) |
| { |
| encodeRGBA( f.color, w ); |
| w.write32( f.blurX ); |
| w.write32( f.blurY ); |
| w.writeUI16( f.strength ); |
| w.writeUI8( f.flags ); |
| } |
| private void encodeBevelFilter( SwfEncoder w, BevelFilter f ) |
| { |
| encodeRGBA(f.highlightColor, w); |
| encodeRGBA(f.shadowColor, w); |
| w.write32( f.blurX ); |
| w.write32( f.blurY ); |
| w.write32( f.angle ); |
| w.write32( f.distance ); |
| w.writeUI16( f.strength ); |
| w.writeUI8( f.flags ); |
| } |
| |
| private void encodeGradientGlowFilter( SwfEncoder w, GradientGlowFilter f ) |
| { |
| w.writeUI8( f.numcolors ); |
| for (int i = 0; i < f.numcolors; ++i) |
| encodeRGBA( f.gradientColors[i], w ); |
| for (int i = 0; i < f.numcolors; ++i) |
| w.writeUI8( f.gradientRatio[i] ); |
| //w.write32( f.color ); |
| w.write32( f.blurX ); |
| w.write32( f.blurY ); |
| w.write32( f.angle ); |
| w.write32( f.distance ); |
| w.writeUI16( f.strength ); |
| w.writeUI8( f.flags ); |
| |
| } |
| private void encodeGradientBevelFilter( SwfEncoder w, GradientBevelFilter f ) |
| { |
| w.writeUI8( f.numcolors ); |
| for (int i = 0; i < f.numcolors; ++i) |
| encodeRGBA( f.gradientColors[i], w ); |
| for (int i = 0; i < f.numcolors; ++i) |
| w.writeUI8( f.gradientRatio[i] ); |
| |
| // w.write32( f.shadowColor ); |
| // w.write32( f.highlightColor ); |
| w.write32( f.blurX ); |
| w.write32( f.blurY ); |
| w.write32( f.angle ); |
| w.write32( f.distance ); |
| w.writeUI16( f.strength ); |
| w.writeUI8( f.flags ); |
| |
| } |
| |
| private void encodeTextRecord(TextRecord record, SwfEncoder w, int type, int glyphBits, int advanceBits) |
| { |
| w.writeUI8(record.flags); |
| |
| if (record.hasFont()) |
| { |
| w.writeUI16(dict.getId(record.font)); |
| } |
| |
| if (record.hasColor()) |
| { |
| if (type == stagDefineText2) |
| encodeRGBA(record.color, w); |
| else |
| encodeRGB(record.color, w); |
| } |
| |
| if (record.hasX()) |
| { |
| w.writeSI16(record.xOffset); |
| } |
| |
| if (record.hasY()) |
| { |
| w.writeSI16(record.yOffset); |
| } |
| |
| if (record.hasHeight()) |
| { |
| w.writeUI16(record.height); |
| } |
| |
| w.writeUI8(record.entries.length); |
| |
| for (int i = 0; i < record.entries.length; i++) |
| { |
| w.writeUBits(record.entries[i].getIndex(), glyphBits); |
| w.writeSBits(record.entries[i].advance, advanceBits); |
| } |
| w.flushBits(); |
| } |
| |
| public void defineText2(DefineText tag) |
| { |
| defineText(tag); |
| } |
| |
| public void defineVideoStream(DefineVideoStream tag) |
| { |
| int id = dict.add(tag); |
| tagw.writeUI16(id); |
| tagw.writeUI16(tag.numFrames); |
| tagw.writeUI16(tag.width); |
| tagw.writeUI16(tag.height); |
| |
| tagw.writeUBits(0, 4); // reserved |
| tagw.writeUBits(tag.deblocking, 3); |
| tagw.writeBit(tag.smoothing); |
| |
| tagw.writeUI8(tag.codecID); |
| encodeTag(tag); |
| } |
| |
| public void doAction(DoAction tag) |
| { |
| int adjust = 0; |
| if (isDebug()) |
| { |
| adjust = writer.getPos()+6; |
| debug.adjust += adjust; |
| } |
| |
| new ActionEncoder(tagw,debug).encode(tag.actionList); |
| tagw.writeUI8(0); |
| encodeTag(tag); |
| |
| if (isDebug()) |
| { |
| debug.adjust -= adjust; |
| } |
| } |
| |
| public void doInitAction(DoInitAction tag) |
| { |
| int adjust = 0; |
| if (isDebug()) |
| { |
| adjust = writer.getPos()+6; |
| debug.adjust += adjust; |
| } |
| |
| int idref = dict.getId(tag.sprite); |
| tagw.writeUI16(idref); |
| new ActionEncoder(tagw,debug).encode(tag.actionList); |
| tagw.writeUI8(0); |
| encodeTag(tag); |
| |
| if (isDebug()) |
| { |
| debug.adjust -= adjust; |
| } |
| } |
| |
| public void enableDebugger(EnableDebugger tag) |
| { |
| tagw.writeString(tag.password); |
| encodeTag(tag); |
| } |
| |
| public void enableDebugger2(EnableDebugger tag) |
| { |
| // This corresponds to the constant used in the player, |
| // core/splay.cpp, in ScriptThread::EnableDebugger(). |
| tagw.writeUI16(0x1975); |
| tagw.writeString(tag.password); |
| encodeTag(tag); |
| } |
| |
| public void exportAssets(ExportAssets tag) |
| { |
| tagw.writeUI16(tag.exports.size()); |
| Iterator it = tag.exports.iterator(); |
| while (it.hasNext()) |
| { |
| DefineTag ref = (DefineTag) it.next(); |
| int idref = dict.getId(ref); |
| tagw.writeUI16(idref); |
| assert (ref.name != null); // exported symbols must have names |
| tagw.writeString(ref.name); |
| dict.addName(ref, ref.name); |
| } |
| encodeTag(tag); |
| } |
| |
| public void symbolClass(SymbolClass tag) |
| { |
| tagw.writeUI16(tag.class2tag.size() + (tag.topLevelClass != null ? 1 : 0)); |
| Iterator it = tag.class2tag.entrySet().iterator(); |
| while (it.hasNext()) |
| { |
| Map.Entry e = (Map.Entry) it.next(); |
| String name = (String) e.getKey(); |
| DefineTag ref = (DefineTag) e.getValue(); |
| |
| int idref = dict.getId(ref); |
| tagw.writeUI16(idref); |
| tagw.writeString(name); |
| } |
| if (tag.topLevelClass != null) |
| { |
| tagw.writeUI16(0); |
| tagw.writeString(tag.topLevelClass); |
| } |
| encodeTag(tag); |
| } |
| |
| public void frameLabel(FrameLabel tag) |
| { |
| tagw.writeString(tag.label); |
| if (tag.anchor && getSwfVersion() >= 6) |
| { |
| tagw.writeUI8(1); |
| } |
| encodeTag(tag); |
| } |
| |
| public void importAssets(ImportAssets tag) |
| { |
| tagw.writeString(tag.url); |
| if (tag.code == stagImportAssets2) |
| { |
| tagw.writeUI8(tag.downloadNow ? 1 : 0); |
| tagw.writeUI8(tag.SHA1 != null ? 1 : 0); |
| if (tag.SHA1 != null) |
| { |
| tagw.write(tag.SHA1); |
| } |
| } |
| tagw.writeUI16(tag.importRecords.size()); |
| Iterator<ImportRecord> it = tag.importRecords.iterator(); |
| while (it.hasNext()) |
| { |
| ImportRecord record = (ImportRecord) it.next(); |
| int id = dict.add(record); |
| tagw.writeUI16(id); |
| tagw.writeString(record.name); |
| } |
| encodeTag(tag); |
| } |
| |
| public void importAssets2(ImportAssets tag) |
| { |
| importAssets(tag); |
| } |
| |
| public void jpegTables(GenericTag tag) |
| { |
| encodeTagHeader(tag.code, tag.data.length, false); |
| writer.write(tag.data); |
| } |
| |
| public void placeObject(PlaceObject tag) |
| { |
| int idref = dict.getId(tag.ref); |
| tagw.writeUI16(idref); |
| tagw.writeUI16(tag.depth); |
| encodeMatrix(tag.matrix, tagw); |
| if (tag.colorTransform != null) |
| { |
| encodeCxform(tag.colorTransform, tagw); |
| } |
| encodeTag(tag); |
| } |
| |
| public void placeObject2(PlaceObject tag) |
| { |
| placeObject23(tag); |
| } |
| |
| public void placeObject3(PlaceObject tag) |
| { |
| placeObject23(tag); |
| } |
| |
| public void placeObject23(PlaceObject tag) |
| { |
| tagw.writeUI8(tag.flags); |
| if (tag.code == stagPlaceObject3) |
| { |
| tagw.writeUI8(tag.flags2); |
| } |
| tagw.writeUI16(tag.depth); |
| if (tag.hasClassName()) { |
| tagw.writeString(tag.className); |
| } |
| if (tag.hasCharID()) |
| { |
| int idref = dict.getId(tag.ref); |
| tagw.writeUI16(idref); |
| } |
| if (tag.hasMatrix()) |
| { |
| encodeMatrix(tag.matrix, tagw); |
| } |
| if (tag.hasCxform()) |
| { |
| // ed 5/22/03 the SWF 6 file format spec says this should be a CXFORM, but |
| // the spec is wrong. the player expects a CXFORMA. |
| encodeCxforma(((CXFormWithAlpha) tag.colorTransform), tagw); |
| } |
| if (tag.hasRatio()) |
| { |
| tagw.writeUI16(tag.ratio); |
| } |
| if (tag.hasName()) |
| { |
| tagw.writeString(tag.name); |
| } |
| if (tag.hasClipDepth()) |
| { |
| tagw.writeUI16(tag.clipDepth); |
| } |
| if (tag.code == stagPlaceObject3) |
| { |
| if (tag.hasFilterList()) |
| { |
| encodeFilterList( tag.filters, tagw ); |
| } |
| if (tag.hasBlendMode()) |
| { |
| tagw.writeUI8(tag.blendMode); |
| } |
| } |
| if (tag.hasClipAction()) |
| { |
| int adjust=0; |
| if (isDebug()) |
| { |
| adjust = writer.getPos()+6; |
| debug.adjust += adjust; |
| } |
| new ActionEncoder(tagw,debug).encodeClipActions(tag.clipActions); |
| if (isDebug()) |
| { |
| debug.adjust -= adjust; |
| } |
| } |
| encodeTag(tag); |
| } |
| |
| public void protect(GenericTag tag) |
| { |
| if (tag.data != null) |
| { |
| encodeTagHeader(tag.code, tag.data.length, false); |
| writer.write(tag.data); |
| } |
| else |
| { |
| encodeTagHeader(tag.code, 0, false); |
| } |
| } |
| |
| public void removeObject(RemoveObject tag) |
| { |
| encodeTagHeader(tag.code, 4, false); |
| int idref = dict.getId(tag.ref); |
| writer.writeUI16(idref); |
| writer.writeUI16(tag.depth); |
| } |
| |
| public void removeObject2(RemoveObject tag) |
| { |
| encodeTagHeader(tag.code, 2, false); |
| writer.writeUI16(tag.depth); |
| } |
| |
| public void setBackgroundColor(SetBackgroundColor tag) |
| { |
| encodeTagHeader(tag.code, 3, false); |
| encodeRGB(tag.color, writer); |
| } |
| |
| public void showFrame(ShowFrame tag) |
| { |
| encodeTagHeader(tag.code, 0, false); |
| frames++; |
| } |
| |
| public void soundStreamBlock(GenericTag tag) |
| { |
| encodeTagHeader(tag.code, tag.data.length, false); |
| writer.write(tag.data); |
| } |
| |
| public void soundStreamHead(SoundStreamHead tag) |
| { |
| int length = 4; |
| |
| // we need to add two bytes for an extra SI16 (latencySeek) |
| if (tag.compression == SoundStreamHead.sndCompressMP3) |
| { |
| length += 2; |
| } |
| |
| encodeTagHeader(tag.code, length, false); |
| |
| // 1 byte |
| writer.writeUBits(0, 4); // reserved |
| writer.writeUBits(tag.playbackRate, 2); |
| writer.writeUBits(tag.playbackSize, 1); |
| writer.writeUBits(tag.playbackType, 1); |
| |
| // 1 byte |
| writer.writeUBits(tag.compression, 4); |
| writer.writeUBits(tag.streamRate, 2); |
| writer.writeUBits(tag.streamSize, 1); |
| writer.writeUBits(tag.streamType, 1); |
| |
| // 2 bytes |
| writer.writeUI16(tag.streamSampleCount); |
| |
| if (tag.compression == SoundStreamHead.sndCompressMP3) |
| { |
| // 2 bytes |
| writer.writeSI16(tag.latencySeek); |
| } |
| } |
| |
| public void soundStreamHead2(SoundStreamHead tag) |
| { |
| soundStreamHead(tag); |
| } |
| |
| public void startSound(StartSound tag) |
| { |
| int idref = dict.getId(tag.sound); |
| tagw.writeUI16(idref); |
| encodeSoundInfo(tag.soundInfo, tagw); |
| encodeTag(tag); |
| } |
| |
| public void videoFrame(VideoFrame tag) |
| { |
| encodeTagHeader(tag.code, 4+tag.videoData.length, false); |
| int idref = dict.getId(tag.stream); |
| writer.writeUI16(idref); |
| writer.writeUI16(tag.frameNum); |
| writer.write(tag.videoData); |
| } |
| |
| public void defineSceneAndFrameLabelData(DefineSceneAndFrameLabelData tag) |
| { |
| encodeTagHeader(tag.code, tag.data.length, false); |
| writer.write(tag.data); |
| } |
| |
| public void doABC(DoABC tag) |
| { |
| if (tag.code == stagDoABC2) |
| { |
| encodeTagHeader(tag.code, 4 + tag.name.length() + 1 + tag.abc.length, false); |
| writer.write32( tag.flag ); |
| writer.writeString( tag.name ); |
| |
| } |
| else |
| { |
| encodeTagHeader(tag.code, tag.abc.length, false); |
| } |
| |
| writer.write(tag.abc); |
| } |
| |
| public void unknown(GenericTag tag) |
| { |
| encodeTagHeader(tag.code, tag.data.length, false); |
| writer.write(tag.data); |
| } |
| |
| public byte[] toByteArray() throws IOException |
| { |
| //TODO this could be improved, tricky bit is that writeTo is not trivial |
| // and has the side effect of compressing (meaning the writer.size() |
| // may be larger than necessary) |
| ByteArrayOutputStream out = new ByteArrayOutputStream(writer.size()); |
| writeTo(out); |
| return out.toByteArray(); |
| } |
| |
| public void scriptLimits(ScriptLimits tag) |
| { |
| tagw.writeUI16(tag.scriptRecursionLimit); |
| tagw.writeUI16(tag.scriptTimeLimit); |
| encodeTag(tag); |
| } |
| |
| public void setTabIndex(SetTabIndex tag) |
| { |
| tagw.writeUI16(tag.depth); |
| tagw.writeUI16(tag.index); |
| encodeTag(tag); |
| } |
| } |
