fssoundstreamhead.java

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

    /** Gets the average number of samples in each stream block following.

        @return the number of sound samples in each following FSSoundStreamBlock object.
        */
    public int getStreamSampleCount() { return streamSampleCount; }

    /** Sets the recommended playback rate in Hz. Must be either: 5512, 11025, 22050 or 44100.

        @param playRate the recommended rate for playing the sound.
        */
    public void setPlaybackRate(int playRate)
    {
        playbackRate = playRate;
    }

    /** Sets the recommended number of playback channels = 1 = mono 2 = stereo.

        @param aNumber the recommended number of playback channels.
        */
    public void setPlaybackChannels(int aNumber)
    {
        playbackChannels = aNumber;
    }

    /** Sets the recommended playback sample size in bytes. Must be wither 1 or 2.

        @param playSize the recommended sample size for playing the sound.
        */
    public void setPlaybackSampleSize(int playSize)
    {
        playbackSampleSize = playSize;
    }

    /** Sets the sample rate in Hz for the streaming sound. Must be either: 5512, 11025, 22050 or 44100.

        @param streamingRate the rate at which the streaming sound was sampled.
        */
    public void setStreamRate(int streamingRate)
    {
        streamRate = streamingRate;
    }

    /** Sets the number of channels in the streaming sound: 1 = mono 2 = stereo.

        @param streamingChannels the number of channels in the streaming sound.
        */
    public void setStreamChannels(int streamingChannels)
    {
        streamChannels = streamingChannels;
    }

    /** Sets the sample size in bytes for the streaming sound. Must be 1 or 2.

        @param streamingSize the sample size for the sound.
        */
    public void setStreamSampleSize(int streamingSize)
    {
        streamSampleSize = streamingSize;
    }

    /** Sets the number of samples in each stream block.

        @param streamingCount the number of samples in each subsequent FSSoundStreamBlock object.
        */
    public void setStreamSampleCount(int streamingCount)
    {
        streamSampleCount = streamingCount;
    }

    /**
     * For MP3 encoded sounds, returns the number of samples to skip when starting to play a sound.
     *
     * @return the number of samples skipped in an MP3 encoded sound Returns 0 for other sound formats.
     */
    public int getLatency() 
    { 
        return latency; 
    }

    /**
     * Set the number of samples to skip when starting to play an MP3 encoded sound.
     *
     * @param latency the number of samples to be skipped in an MP3 encoded sound should be 0 for other sound formats.
     */
    public void setLatency(int latency)
    {
        this.latency = latency;
    }

    public boolean equals(Object anObject)
    {
        boolean result = false;
        
        if (super.equals(anObject))
        {
            FSSoundStreamHead typedObject = (FSSoundStreamHead)anObject;
            
            result = format == typedObject.format;
            result = result && playbackRate == typedObject.playbackRate;
            result = result && playbackChannels == typedObject.playbackChannels;
            result = result && playbackSampleSize == typedObject.playbackSampleSize;
            result = result && streamRate == typedObject.streamRate;
            result = result && streamChannels == typedObject.streamChannels;
            result = result && streamSampleSize == typedObject.streamSampleSize;
            result = result && streamSampleCount == typedObject.streamSampleCount;
            result = result && latency == typedObject.latency;
        }
        return result;
    }

    public void appendDescription(StringBuffer buffer, int depth)
    {
        buffer.append(name());
        
        if (depth > 0)
        {
            buffer.append(": { ");
            Transform.append(buffer, "format", format);
            Transform.append(buffer, "playbackRate", playbackRate);
            Transform.append(buffer, "playbackChannels", playbackChannels);
            Transform.append(buffer, "playbackSampleSize", playbackSampleSize);
            Transform.append(buffer, "streamRate", streamRate);
            Transform.append(buffer, "streamChannels", streamChannels);
            Transform.append(buffer, "streamSampleSize", streamSampleSize);
            Transform.append(buffer, "streamSampleCount", streamSampleCount);
            Transform.append(buffer, "latency", latency);
            buffer.append("}");
        }
    }

    public int length(FSCoder coder)
    {
        super.length(coder);
    
        length += 4;
        
        if (format == FSSound.MP3)
            length += 2;
        
        return length;
    }
    
    public void encode(FSCoder coder)
    {
        super.encode(coder);
        
         coder.writeBits(0, 4);

        switch (playbackRate)
        {
            case 5512:
                coder.writeBits(0, 2);
                break;
            case 11025:
                coder.writeBits(1, 2);
                break;
            case 22050:
                coder.writeBits(2, 2);
                break;
            case 44100:
                coder.writeBits(3, 2);
                break;
        }
        coder.writeBits(playbackSampleSize-1, 1);
        coder.writeBits(playbackChannels-1, 1);

        coder.writeBits(format, 4);

        switch (streamRate)
        {
            case 5512:
                coder.writeBits(0, 2);
                break;
            case 11025:
                coder.writeBits(1, 2);
                break;
            case 22050:
                coder.writeBits(2, 2);
                break;
            case 44100:
                coder.writeBits(3, 2);
                break;
        }
        coder.writeBits(streamSampleSize-1, 1);
        coder.writeBits(streamChannels-1, 1);
        coder.writeWord(streamSampleCount, 2);

        if (format == FSSound.MP3)
            coder.writeWord(latency, 2);

        coder.endObject(name());
    }
    
    public void decode(FSCoder coder)
    {
        super.decode(coder);
        
        coder.readBits(4, false);
        switch (coder.readBits(2, false))
        {
            case 0:
                playbackRate = 5512;
                break;
            case 1:
                playbackRate = 11025;
                break;
            case 2:
                playbackRate = 22050;
                break;
            case 3:
                playbackRate = 44100;
                break;
        }
        playbackSampleSize = coder.readBits(1, false)+1;
        playbackChannels = coder.readBits(1, false)+1;

        format = coder.readBits(4, false);

        switch (coder.readBits(2, false))
        {
            case 0:
                streamRate = 5512;
                break;
            case 1:
                streamRate = 11025;
                break;
            case 2:
                streamRate = 22050;
                break;
            case 3:
                streamRate = 44100;
                break;
        }
        streamSampleSize = coder.readBits(1, false)+1;
        streamChannels = coder.readBits(1, false)+1;
        streamSampleCount = coder.readWord(2, false);
        
        if (format == FSSound.MP3)
            latency = coder.readWord(2, true);

        coder.endObject(name());
    }
}