*

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

*

*/

* Implementation of {@link ISWFReader}. This is a recursive-descent decoder of

* a SWF file. Error handling for malformed SWFs: 1. Catch RuntimeExceptions

* thrown by InputBitStream and report problems. 2. Handle errors in SWF tag

* bodies by logging problems and throwing MalformedTagExceptions. 3. Recover

* from #1 and #2 by throwing out the current tag and reading up to the start of

* the next tag.

*/

    /**

     * There is an error in the tag body that prevents the tag from being

     * completely and correctly read.

     */

    private static class MalformedTagException extends Exception

    {

        /**

         *

         */

        private static final long serialVersionUID = -8030549610732167171L;

    }

    /**

     * A made-up tag to substitute for a tag with an invalid character id.

     */

    private static class InvalidTag extends CharacterTag implements ICharacterTag

    {

        /**

         * Some SWFs contained bad character id references.

         */

        public static final int BAD_CHARACTER_ID = 65535;

        public InvalidTag()

        {

            super(TagType.End);

            // Set a bogus character id that matches the bogus input value.

            // This lets us round trip reading/writing a SWF.

            setCharacterID(BAD_CHARACTER_ID);

        }

    }

    public static final InvalidTag INVALID_TAG = new InvalidTag();

    /**

     * Wrapper class for "type" and "length" field in a SWF tag header.

     */

    protected static class TagHeader

    {

        TagHeader(TagType type, int length)

        {

            this.type = type;

            this.length = length;

        }

        final TagType type;

        final int length;

    }

    /**

     * Mask on the TagCodeAndLength field to get the lower 6 bits of tag length.

     */

    protected static final int MASK_TAG_LENGTH = 0x3F;

    /**

     * The lower 6 bits in the TagCodeAndLength field in the SWF tag header is

     * the tag length.

     */

    protected static final int BITS_TAG_LENGTH = 6;

    // 2 bytes for UI16

    private static final int UI16_LENGTH = 2;

    // 4 bytes for SI32

    private static final int SI32_LENGTH = 4;

    /**

     * SWF input bit stream.

     */

    protected InputBitStream bitStream;

    /**

     * Model of the SWF file.

     */

    protected SWF swf;

    private String swfPath; // path associated with bitStream

    // Dictionary for resolving character ID to tag.

    private final Map<Integer, ICharacterTag> dictionary;

    // Flag for whether buildFramesFromTags() needs to be called.

    private final boolean buildFrames;

    /**

     * All the tags in the SWF file. The frame building process is based on

     * these tags.

     */

    protected final List<ITag> tags;

    protected final Collection<ICompilerProblem> problems = new ArrayList<ICompilerProblem>();

    /**

     * Create a SWFReader and initialize field members.

     */

    public SWFReader()

    {

        this(true);

    }

    /**

     * Create a SWFReader and initialize field members.

     *

     * @param isBuildFrames if true, the reader will build SWF frames from tags

     * read

     */

    public SWFReader(boolean isBuildFrames)

    {

        this.buildFrames = isBuildFrames;

        tags = new ArrayList<ITag>();

        dictionary = new HashMap<Integer, ICharacterTag>();

        swf = new SWF();

    }

    @Override

    public ISWF readFrom(InputStream input, String path)

    {

        assert input != null && path != null;

        swfPath = FilenameNormalization.normalize(path);

        bitStream = new InputBitStream(input);

        try

        {

            if (readHeader())

                readTags();

        }

        catch (IOException e)

        {

            problems.add(new FileIOProblem(e));

        }

       

        if (buildFrames)

        {

            int expectedFrames = swf.getFrameCount();

            int foundFrames = swf.getFrames().size();

            if (expectedFrames != foundFrames)

            {

                problems.add(new SWFFrameCountMismatchProblem(

                        expectedFrames, foundFrames, swfPath));               

            }

        }

        return swf;

    }

    /**

     * Get the SWF tied to this reader. Note that the returned SWF may or not be

     * initialized depending on whether readFrom() has been called or not

     *

     * @return swf

     */

    public ISWF getSWF()

    {

        return swf;

    }

    @Override

    public Collection<ICompilerProblem> getProblems()

    {

        return problems;

    }

    /**

     * Read the header and body of the next SWF tag.

     *

     * @return SWF tag model, may be null if the tag is invalid.

     * @throws IOException error

     */

    private ITag nextTag() throws IOException

    {

        final TagHeader header = nextTagHeader();

        return readTag(header);

    }

    /**

     * Read SWF tags and add each tag to the tag list. Stop at the End tag.

     *

     * @throws IOException error

     */

    protected void readTags() throws IOException

    {

        SWFFrame currentFrame = buildFrames ? new SWFFrame() : null;

        ITag tag;

        do

        {

            tag = nextTag();

            if (tag == null)

                continue;

            // deposit character tag to dictionary

            if (tag instanceof ICharacterTag)

            {

                addToDictionary((ICharacterTag)tag);

            }

            // save to tags list

            tags.add(tag);

            if (buildFrames)

                currentFrame = buildFramesFromTags(currentFrame, tag);

        }

        while (tag == null || tag.getTagType() != TagType.End);

    }

    /**

     * Read the next tag's header field and get the tag length and type.

     *

     * @return next tag header

     */

    protected TagHeader nextTagHeader()

    {

        try

        {

            bitStream.setReadBoundary(bitStream.getOffset() + UI16_LENGTH);

            // get tag code and length

            final int tagCodeAndLength = bitStream.readUI16();

            final TagType tagType = TagType.getTagType(tagCodeAndLength >>> BITS_TAG_LENGTH);

            int tagLength = tagCodeAndLength & MASK_TAG_LENGTH;

            if (tagLength == MASK_TAG_LENGTH)

            {

                bitStream.setReadBoundary(bitStream.getOffset() + SI32_LENGTH);

                // long tag header uses an SI32 field for tag length

                tagLength = bitStream.readSI32();

            }

            return new TagHeader(tagType, tagLength);

        }

        catch (Exception e)

        {

            // Unexpected end of file.

            // Log a problem and return an end tag so the

            // outer loop will terminate normally.

            problems.add(new SWFUnexpectedEndOfFileProblem(swfPath));

            return new TagHeader(TagType.End, 0);

        }

    }

    /**

     * Read a tag body. A "read boundary" is marked to the length of the tag to

     * prevent invalid tag or incorrect decoding logic from contaminating the

     * following tags or having left-over bytes after decoding a tag.

     *

     * @param header tag header

     * @return tag model or null if the tag is invalid.

     * @throws IOException error

     */

    protected ITag readTag(TagHeader header) throws IOException

    {

        bitStream.setReadBoundary(bitStream.getOffset() + header.length);

        ITag tag = null;

        try

        {

            tag = readTagBody(header.type);

        }

        catch (RuntimeException e)

        {

            problems.add(new SWFUnableToReadTagBodyProblem(header.type.getValue(),

                    header.length, swfPath, bitStream.getOffset()));

            // recover by reading the rest of the tag.           

        }

        catch (MalformedTagException e)

        {

            // We have already logged problems for these.

            // recover by reading the rest of the tag.

        }

        // If the read-boundary was not reached, consume the additional bytes

        // assuming an incorrectly formatted SWF tag was encountered.

        if (bitStream.getOffset() < bitStream.getReadBoundary())

        {

            try

            {

                // The tag is too long but there is no reason to assume

                // the data we read is invalid. We'll treat the data as

                // valid. Only report a problem if any of the remaining

                // bytes are non-zero.

                boolean nonZeroBytes = false;

                long oldOffset = bitStream.getOffset();

                while (bitStream.getOffset() < bitStream.getReadBoundary())

                {

                    if (bitStream.readByte() != 0)

                        nonZeroBytes = true;

                }

                if (nonZeroBytes)

                {

                    problems.add(new SWFTagLengthTooLongProblem(header.type.getValue(),

                            swfPath, oldOffset, bitStream.getReadBoundary()));

                }

            }

            catch (Exception e)

            {

                // Unable to skip to the end of the tag.

                return null;

            }

        }

        return tag;

    }

    /**

     * Add an {@code ICharacterTag} to the character dictionary.

     *

     * @param tag character tag

     */

    private void addToDictionary(ICharacterTag tag)

    {

        dictionary.put(tag.getCharacterID(), tag);

    }

    /**

     * Build {@code SWFFrame} model from a series of tags as they are

     * encountered in the SWF.

     *

     * @param currentFrame The current frame to add the tag to.

     * @param tag The current tag.

     * @return The current frame. A new frame will be returned when a ShowFrame

     * tag is encountered. Otherwise the currentFrame parameter will be

     * returned.

     */

    private SWFFrame buildFramesFromTags(SWFFrame currentFrame, ITag tag)

    {

        if (tag instanceof IManagedTag)

        {

            // managed tags   

            switch (tag.getTagType())

            {

                case ShowFrame:

                    swf.addFrame(currentFrame);

                    currentFrame = new SWFFrame();

                    break;

                case FrameLabel:

                    final FrameLabelTag frameLabel = (FrameLabelTag)tag;

                    currentFrame.setName(frameLabel.getName(), frameLabel.isNamedAnchorTag());

                    break;

                case Metadata:

                    swf.setMetadata(((MetadataTag)tag).getMetadata());

                    break;

                case FileAttributes:

                    final FileAttributesTag fileAttributes = (FileAttributesTag)tag;

                    swf.setUseAS3(fileAttributes.isAS3());

                    swf.setUseDirectBlit(fileAttributes.isUseDirectBlit());

                    swf.setUseGPU(fileAttributes.isUseGPU());

                    swf.setUseNetwork(fileAttributes.isUseNetwork());

                    break;

                case SetBackgroundColor:

                    swf.setBackgroundColor(((SetBackgroundColorTag)tag).getColor());

                    break;

                case SymbolClass:

                    final SymbolClassTag symbolClass = (SymbolClassTag)tag;

                    for (final String name : symbolClass.getSymbolNames())

                    {

                        final ICharacterTag exportedCharacter = symbolClass.getSymbol(name);

                        currentFrame.defineSymbol(exportedCharacter, name, dictionary);

                    }

                    break;

                case EnableDebugger2:

                    swf.setEnableDebugger2((EnableDebugger2Tag)tag);

                    break;

                case ProductInfo:

                    swf.setProductInfo((ProductInfoTag)tag);

                    break;

                case DefineSceneAndFrameLabelData:

                case ScriptLimits:

                case ExportAssets:

                case ImportAssets:

                case End:

                    // TODO: store on ISWF instance

                    break;

                default:

                    assert false : "Unhandled managed tag: " + tag;

            }

        }

        else

        {

            currentFrame.addTag(tag);

        }

        return currentFrame;

    }

    /**

     * Close the reader an the underlying input stream.

     */

    @Override

    public void close() throws IOException

    {

        if (bitStream != null)

            bitStream.close();

    }

    private ICharacterTag getTagById(int id, TagType tagType) throws MalformedTagException

    {

        if (dictionary.containsKey(id))

        {

            return dictionary.get(id);

        }

        else

        {

            // [tpr 7/6/04] work around authoring tool bug of bogus 65535 ids

            if (id != InvalidTag.BAD_CHARACTER_ID)

            {

                problems.add(new SWFCharacterIDNotFoundProblem(id,

                        tagType.getValue(), swfPath, bitStream.getOffset()));

                throw new MalformedTagException();

            }

            else

            {

                return INVALID_TAG;

            }

        }

    }

    /**

     * Get all the tags in this SWF file.

     */

    @Override

    public Iterator<ITag> iterator()

    {

        return tags.iterator();

    }

    private CXFormWithAlpha readColorTransformWithAlpha()

    {

        bitStream.byteAlign();

        final CXFormWithAlpha cxFormWithAlpha = new CXFormWithAlpha();

        final boolean hasAddTerms = bitStream.readBit();

        final boolean hasMultTerms = bitStream.readBit();

        final int nbits = bitStream.readUB(4);

        if (hasMultTerms)

        {

            cxFormWithAlpha.setMultTerm(

                    bitStream.readSB(nbits),

                    bitStream.readSB(nbits),

                    bitStream.readSB(nbits),

                    bitStream.readSB(nbits));

        }

        if (hasAddTerms)

        {

            cxFormWithAlpha.setAddTerm(

                    bitStream.readSB(nbits),

                    bitStream.readSB(nbits),

                    bitStream.readSB(nbits),

                    bitStream.readSB(nbits));

        }

        return cxFormWithAlpha;

    }

    private CurvedEdgeRecord readCurvedEdgeRecord() throws IOException

    {

        final CurvedEdgeRecord curvedEdgeRecord = new CurvedEdgeRecord();

        final int nbits = 2 + bitStream.readUB(4);

        curvedEdgeRecord.setControlDeltaX(bitStream.readSB(nbits));

        curvedEdgeRecord.setControlDeltaY(bitStream.readSB(nbits));

        curvedEdgeRecord.setAnchorDeltaX(bitStream.readSB(nbits));

        curvedEdgeRecord.setAnchorDeltaY(bitStream.readSB(nbits));

        return curvedEdgeRecord;

    }