fssoundstreamhead2.java

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

     /** Gets the sample size in bytes: 1 or 2 in the streaming sound.

         @return the sample size.
         */
     public int getStreamSampleSize() { return streamSampleSize; }

     /** 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))
         {
             FSSoundStreamHead2 typedObject = (FSSoundStreamHead2)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(_reserved, 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);
        
         _reserved = 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());
     }
}