*

*  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.

*

*/

* The implementation of SWF tag, type encoding logic. The SWF file body are

* buffered in memory using {@code IOutputBitStream}. ZLIB compression is

* optional. If enabled, compression is on-the-fly via a filtered output stream.

*/

     * Default SWF writer factory.

     */

    private static class SWFWriterFactory implements ISWFWriterFactory

    {

        @Override

        public ISWFWriter createSWFWriter(ISWF swf, Compression useCompression,

                boolean enableDebug)

        {

            return new SWFWriter(swf, useCompression, enableDebug);

        }

    }

    /**

     * A factory for default SWF writers. These SWF writers just write SWFs

     * without any additional features.

     */

    public static final ISWFWriterFactory DEFAULT_SWF_WRITER_FACTORY = new SWFWriterFactory();

    private static final int RESERVED = 0;

    private static final int SHORT_TAG_MAX_LENGTH = 62;

    /**

     * Compares the absolute values of 4 signed integers and returns the

     * unsigned magnitude of the number with the greatest absolute value.

     */

    public static int maxNum(int a, int b, int c, int d)

    {

        // take the absolute values of the given numbers

        a = Math.abs(a);

        b = Math.abs(b);

        c = Math.abs(c);

        d = Math.abs(d);

        // compare the numbers and return the unsigned value of the one with the greatest magnitude

        return Ints.max(a, b, c, d);

    }

    /**

     * Compares the absolute values of 4 signed doubles and returns the unsigned

     * magnitude of the number with the greatest absolute value.

     */

    public static double maxNum(double a, double b, double c, double d)

    {

        // take the absolute values of the given numbers

        a = Math.abs(a);

        b = Math.abs(b);

        c = Math.abs(c);

        d = Math.abs(d);

        // compare the numbers and return the unsigned value of the one with the greatest magnitude

        return Doubles.max(a, b, c, d);

    }

    /**

     * Calculate number of bits required to represent the given value in double

     * bit value.

     *

     * @param value signed integer

     * @return number of bits required for SB[]

     */

    public static int requireFBCount(double value)

    {

        return requireSBCount((int)(value * 0x10000));

    }

    /**

     * Calculate number of bits required to represent the given value in signed

     * bit values.

     *

     * @param value signed integer

     * @return number of bits required for SB[]

     */

    public static int requireSBCount(int value)

    {

        return minBits(Math.abs(value), 1);

    }

    public static int requireSBCount(int... values)

    {

        final int array[] = new int[values.length];

        for (int i = 0; i < values.length; i++)

            array[i] = requireSBCount(values[i]);

        Arrays.sort(array); // ascending order: last one is the biggest

        return array[array.length - 1];

    }

    /**

     * Calculate number of bits required to represent the given value in

     * unsigned bit values.

     *

     * @param value signed integer

     * @return number of bits required for SB[]

     */

    public static int requireUBCount(int value)

    {

        assert (value >= 0) : "requireUBCount called with negative number";

        return minBits(value, 0);

    }

    /**

     * Calculates the minimum number of bits necessary to represent the given

     * number. The number should be given in its unsigned form with the starting

     * bits equal to 1 if it is signed. Repeatedly compares number to another

     * unsigned int called x. x is initialized to 1. The value of x is shifted

     * left i times until x is greater than number. Now i is equal to the number

     * of bits the UNSIGNED value of number needs. The signed value will need

     * one more bit for the sign so i+1 is returned if the number is signed, and

     * i is returned if the number is unsigned.

     *

     * @param number the number to compute the size of

     * @param bits 1 if number is signed, 0 if unsigned

     */

    private static int minBits(int number, int bits)

    {

        int val = 1;

        for (int x = 1; val <= number && !(bits > 32); x <<= 1)

        {

            val = val | x;

            bits++;

        }

        assert (bits <= 32) : ("minBits " + bits + " must not exceed 32");

        return bits;

    }

    private void writeLengthString(String name)

    {

        try

        {

            assert (tagBuffer.getBitPos() == 8);

            byte[] b = swf.getVersion() >= 6 ? name.getBytes("UTF8") : name.getBytes();

            // [paul] Flash Authoring and the player expect the String

            // to be null terminated.

            tagBuffer.writeUI8(b.length + 1);

            tagBuffer.write(b);

            tagBuffer.writeUI8(0);

        }

        catch (UnsupportedEncodingException e)

        {

            assert false;

        }

    }

    // Tag buffer

    protected IOutputBitStream tagBuffer;

    // SWF model

    private final ISWF swf;

    // This buffer contains the SWF data after FileLength field.

    protected final IOutputBitStream outputBuffer;

    // True if the encoded SWF file is compressed.

    private final Header.Compression useCompression;

    private final boolean enableDebug; // if true enable debugging of the SWF.

    // Current frame index. Updated in writeFrames().

    private int currentFrameIndex;

    // Prevent writing out the same tag twice.

    private Set<ITag> writtenTags;

    /**

     * Create a SWF writer.

     *

     * @param swf the SWF model to be encoded

     * @param useCompression use ZLIB compression if true

     */

    public SWFWriter(ISWF swf, Header.Compression useCompression)

    {

        this(swf, useCompression, false);

    }

    /**

     * Create a SWF writer.

     *

     * @param swf the SWF model to be encoded

     * @param useCompression use ZLIB compression if true

     * @param enableDebug enable debugging of the SWF if true

     */

    public SWFWriter(ISWF swf, Header.Compression useCompression, boolean enableDebug)

    {

        this.swf = swf;

        this.useCompression = useCompression;

        this.enableDebug = enableDebug;

        this.outputBuffer = new OutputBitStream(false);

        this.tagBuffer = new OutputBitStream(false);

        computeCharacterID();

    }

    /**

     * Compute the character ID for all the {@code ICharacterTag}s.

     */

    private void computeCharacterID()

    {

        int id = 1; // need to start at 1, as index 0 has special meaning

        for (int frameIndex = 0; frameIndex < swf.getFrameCount(); frameIndex++)

        {

            final SWFFrame frame = swf.getFrameAt(frameIndex);

            for (final ITag tag : frame)

            {

                if (tag instanceof CharacterTag)

                {

                    final CharacterTag characterTag = (CharacterTag)tag;

                    characterTag.setCharacterID(id);

                    id++;

                }

            }

        }

    }

    /**

     * Compute the tag length for the tag header, then write the header and the

     * buffered tag body to target output stream.

     *

     * @param tag tag object

     * @param tagData serialized tag body

     * @param out target output stream

     */

    protected void finishTag(

            final ITag tag,

            final IOutputBitStream tagData,

            final IOutputBitStream out)

    {

        tagData.flush();

        final int tagLength = tagData.size();

        // write tag header

        if (tag instanceof IAlwaysLongTag || tagLength > SHORT_TAG_MAX_LENGTH)

        {

            // use long tag header

            out.writeUI16((tag.getTagType().getValue() << 6) | 0x3F);

            out.writeSI32(tagLength);

        }

        else

        {

            // use short tag header

            out.writeUI16((tag.getTagType().getValue() << 6) | tagLength);

        }

        out.write(tagData.getBytes(), 0, tagLength);

    }

    public void writeARGB(ARGB argb)

    {

        tagBuffer.writeUI8(argb.getAlpha());

        tagBuffer.writeUI8(argb.getRed());

        tagBuffer.writeUI8(argb.getGreen());

        tagBuffer.writeUI8(argb.getBlue());

    }

    protected void writeCompressibleHeader()

    {

        // Frame size

        final Rect rect = swf.getFrameSize();

        tagBuffer.reset();

        writeRect(rect);

        outputBuffer.write(tagBuffer.getBytes(), 0, tagBuffer.size());

        // Frame rate

        outputBuffer.writeFIXED8(swf.getFrameRate());

        // Frame count

        outputBuffer.writeUI16(swf.getFrameCount());

    }

    /**

     * @see SWFReader#readCurvedEdgeRecord

     */

    private void writeCurvedEdgeRecord(CurvedEdgeRecord shape)

    {

        tagBuffer.writeBit(true); // This is an edge. Always 1.

        tagBuffer.writeBit(false); // StraightFlag is always false.

        int numBits = shape.getNumBits();

        tagBuffer.writeUB(numBits, 4);

        tagBuffer.writeSB(shape.getControlDeltaX(), numBits + 2);

        tagBuffer.writeSB(shape.getControlDeltaY(), numBits + 2);

        tagBuffer.writeSB(shape.getAnchorDeltaX(), numBits + 2);

        tagBuffer.writeSB(shape.getAnchorDeltaY(), numBits + 2);

    }

    private void writeDefineBinaryData(DefineBinaryDataTag tag)

    {

        tagBuffer.writeUI16(tag.getCharacterID());

        tagBuffer.writeUI32(0); // Reserved, always zero.

        tagBuffer.write(tag.getData());

    }

    /**

     * This method treats the bytes after the color table as a binary blob so

     * both the lossless and lossless2 tags can be written using this method.

     *

     * @param tag

     */

    private void writeDefineBitsLossless(DefineBitsLosslessTag tag)

    {

        tagBuffer.writeUI16(tag.getCharacterID());

        tagBuffer.writeUI8(tag.getBitmapFormat());

        tagBuffer.writeUI16(tag.getBitmapWidth());

        tagBuffer.writeUI16(tag.getBitmapHeight());

        if (DefineBitsLossless2Tag.BF_8BIT_COLORMAPPED_IMAGE == tag.getBitmapFormat())

        {

            tagBuffer.writeUI8(tag.getBitmapColorTableSize() - 1);

        }

        tagBuffer.write(tag.getZlibBitmapData());

    }

    /**

     * @see SWFReader#readDefineShape

     */

    private void writeDefineShape(DefineShapeTag tag)

    {

        tagBuffer.writeUI16(tag.getCharacterID());

        writeRect(tag.getShapeBounds());

        writeShapeWithStyle(tag.getShapes(), tag.getTagType());

    }

    /**

     * @see SWFReader#readDefineShape2

     */

    private void writeDefineShape2(DefineShape2Tag tag)

    {

        writeDefineShape(tag);

    }

    /**

     * @see SWFReader#readDefineShape3

     */

    private void writeDefineShape3(DefineShape3Tag tag)

    {

        writeDefineShape2(tag);

    }

    /**

     * @see SWFReader#readDefineShape4

     */

    private void writeDefineShape4(DefineShape4Tag tag)

    {

        tagBuffer.writeUI16(tag.getCharacterID());

        writeRect(tag.getShapeBounds());

        writeRect(tag.getEdgeBounds());

        tagBuffer.byteAlign();

        tagBuffer.writeUB(0, 5); // Reserved. Must be 0.

        tagBuffer.writeBit(tag.isUsesFillWindingRule());

        tagBuffer.writeBit(tag.isUsesNonScalingStrokes());

        tagBuffer.writeBit(tag.isUsesScalingStrokes());

        tagBuffer.byteAlign();

        writeShapeWithStyle(tag.getShapes(), tag.getTagType());

    }

    /**

     * @see SWFReader#readDefineMorphShape2

     * @see SWFWriter#writeDefineMorphShape

     */

    private void writeDefineMorphShape2(DefineMorphShape2Tag tag)

    {

        writeDefineMorphShape(tag);

    }

    /**

     * @see SWFReader#readDefineMorphShape

     */

    private void writeDefineMorphShape(DefineMorphShapeTag tag)

    {

        // Write to another buffer to calculate offset to EndEdges field.

        final IOutputBitStream originalTagBuffer = tagBuffer;

        tagBuffer = new OutputBitStream();

        // fields before "offset"

        tagBuffer.writeUI16(tag.getCharacterID());

        writeRect(tag.getStartBounds());

        writeRect(tag.getEndBounds());

        if (TagType.DefineMorphShape2 == tag.getTagType())

        {

            final DefineMorphShape2Tag tag2 = (DefineMorphShape2Tag)tag;

            writeRect(tag2.getStartEdgeBounds());

            writeRect(tag2.getEndEdgeBounds());

            tagBuffer.writeUB(0, 6);

            tagBuffer.writeBit(tag2.isUsesNonScalingStrokes());

            tagBuffer.writeBit(tag2.isUsesScalingStrokes());

            tagBuffer.byteAlign();

        }

        final int sizeBeforeOffset = tagBuffer.size();

        // fields after "offset"

        Shape startEdges = tag.getStartEdges();

        writeShapeWithStyle((ShapeWithStyle)startEdges, tag.getTagType());

        final int sizeAfterOffsetToEnd = tagBuffer.size() - sizeBeforeOffset;

        // put together

        originalTagBuffer.write(tagBuffer.getBytes(), 0, sizeBeforeOffset);

        originalTagBuffer.writeUI32(sizeAfterOffsetToEnd);

        originalTagBuffer.write(tagBuffer.getBytes(), sizeBeforeOffset, sizeAfterOffsetToEnd);

        // recover current tag buffer

        tagBuffer = originalTagBuffer;

        writeShape(tag.getEndEdges(), tag.getTagType(), 0, 0);

    }

    /**

     * @see SWFReader#readShape

     */

    private void writeShape(Shape shape, TagType tagType, int fillStyleCount, int lineStyleCount)

    {

        CurrentStyles currentStyles = new CurrentStyles();

        currentStyles.numFillBits = requireUBCount(fillStyleCount);

        currentStyles.numLineBits = requireUBCount(lineStyleCount);

        writeShape(shape, tagType, currentStyles);

    }

    /**

     * @see SWFReader#readShape

     */

    private void writeShape(Shape shape, TagType tagType, CurrentStyles currentStyles)

    {

        tagBuffer.writeUB(currentStyles.numFillBits, 4);

        tagBuffer.writeUB(currentStyles.numLineBits, 4);

        for (final ShapeRecord shapeRecord : shape.getShapeRecords())

        {

            writeShapeRecord(shapeRecord, tagType, currentStyles);

        }

        writeShapeRecord(new EndShapeRecord(), tagType, currentStyles);

        tagBuffer.byteAlign();

    }

    /**

     * @see SWFReader#readMorphLineStyleArray

     */

    //    private void writeMorphLineStyleArray(MorphLineStyleArray lineStyles)

    //    {

    //        writeExtensibleCount(lineStyles.size());

    //        for (MorphLineStyle lineStyle : lineStyles)

    //        {

    //            writeMorphLineStyle(lineStyle);

    //        }

    //    }

    /**

     * @see SWFReader#readMorphLineStyle

     */

    private void writeMorphLineStyle(MorphLineStyle lineStyle)

    {

        tagBuffer.writeUI16(lineStyle.getStartWidth());

        tagBuffer.writeUI16(lineStyle.getEndWidth());

        writeRGBA(lineStyle.getStartColor());

        writeRGBA(lineStyle.getEndColor());

    }

    private void writeMorphLineStyle2(MorphLineStyle2 lineStyle, TagType tagType)

    {

        // widths

        tagBuffer.writeUI16(lineStyle.getStartWidth());

        tagBuffer.writeUI16(lineStyle.getEndWidth());

        // misc fields byte

        tagBuffer.writeUB(lineStyle.getStartCapStyle(), 2);

        tagBuffer.writeUB(lineStyle.getJoinStyle(), 2);

        tagBuffer.writeBit(lineStyle.isHasFillFlag());

        tagBuffer.writeBit(lineStyle.isNoHScaleFlag());

        tagBuffer.writeBit(lineStyle.isNoVScaleFlag());

        tagBuffer.writeBit(lineStyle.isPixelHintingFlag());

        // next mixed byte

        tagBuffer.writeUB(0, 5); // reserved

        tagBuffer.writeBit(lineStyle.isNoClose());

        tagBuffer.writeUB(lineStyle.getEndCapStyle(), 2);

        //

        if (lineStyle.getJoinStyle() == LineStyle2.JS_MITER_JOIN)

        {

            tagBuffer.writeUI16(lineStyle.getMiterLimitFactor());

        }

        if (!lineStyle.isHasFillFlag())

        {

            writeRGBA(lineStyle.getStartColor());

            writeRGBA(lineStyle.getEndColor());

        }

        else

        {

            writeMorphFillStyle(lineStyle.getFillType(), tagType);

        }

    }

    /**

     * @see SWFReader#readMorphFillStyle

     */

    private void writeMorphFillStyle(MorphFillStyle fillStyle, TagType tagType)

    {

        int fillStyleType = fillStyle.getFillStyleType();

        tagBuffer.writeUI8(fillStyleType);

        switch (fillStyle.getFillStyleType())

        {

            case FillStyle.SOLID_FILL:

                writeRGBA(fillStyle.getStartColor());

                writeRGBA(fillStyle.getEndColor());

                break;

            case FillStyle.LINEAR_GRADIENT_FILL:

            case FillStyle.RADIAL_GRADIENT_FILL:

            case FillStyle.FOCAL_RADIAL_GRADIENT_FILL:

                writeMatrix(fillStyle.getStartGradientMatrix());

                writeMatrix(fillStyle.getEndGradientMatrix());

                writeMorphGradient(fillStyle.getGradient());

                if (fillStyleType == FillStyle.FOCAL_RADIAL_GRADIENT_FILL &&

                        tagType.getValue() == TagType.DefineMorphShape2.getValue())

                {

                    tagBuffer.writeSI16(fillStyle.getRatio1());

                    tagBuffer.writeSI16(fillStyle.getRatio2());

                }

                break;

            case FillStyle.REPEATING_BITMAP_FILL:

            case FillStyle.CLIPPED_BITMAP_FILL:

            case FillStyle.NON_SMOOTHED_CLIPPED_BITMAP:

            case FillStyle.NON_SMOOTHED_REPEATING_BITMAP:

                tagBuffer.writeUI16(fillStyle.getBitmap().getCharacterID());

                writeMatrix(fillStyle.getStartBitmapMatrix());

                writeMatrix(fillStyle.getEndBitmapMatrix());

                break;

        }

    }

    /**

     * @see SWFReader#readMorphGradient

     */

    private void writeMorphGradient(MorphGradient gradient)

    {

        tagBuffer.writeUI8(gradient.size());

        for (MorphGradRecord morphGradRecord : gradient)

        {

            writeMorphGradRecord(morphGradRecord);

        }

    }

    /**

     * @see SWFReader#readMorphGradRecord

     */

    private void writeMorphGradRecord(MorphGradRecord morphGradRecord)

    {

        tagBuffer.writeUI8(morphGradRecord.getStartRatio());

        writeRGBA(morphGradRecord.getStartColor());

        tagBuffer.writeUI8(morphGradRecord.getEndRatio());

        writeRGBA(morphGradRecord.getEndColor());

    }

    /**

     * @see SWFReader#readExtensibleCount

     * @param count

     */

    private void writeExtensibleCount(int count)

    {

        if (count < 0xFF)

        {

            tagBuffer.writeUI8(count);

        }

        else

        {

            tagBuffer.writeUI8(0xFF);

            tagBuffer.writeUI16(count);

        }

    }

    public void writeDoABC(DoABCTag tag)

    {

        assert swf.getUseAS3() : "DoABC tag requires FileAttributes.Actionscript3=true.";

        tagBuffer.writeUI32(tag.getFlags());

        tagBuffer.writeString(tag.getName());

        tagBuffer.write(tag.getABCData());

    }

    private void writeEnableDebugger2(EnableDebugger2Tag tag)