ORM映射框架总结--Flash 处理

  1  /* *
  2   * 
  3   * 2009-4-17
  4   * 
  5   * 
  6   * 根据flash读取其宽度和高度
  7   *  */
  8  using  System;
  9  using  System.Collections.Generic;
 10  using  System.Linq;
 11  using  System.Text;
 12  using  System.IO;
 13  using  System.Collections;
 14 
 15  namespace  CommonData.Flash
 16  {
 17      [Serializable]
 18       public   partial   class  FlashInfo
 19      {
 20           private   int  width, height, version, frameCount, fileLength;
 21           private   float  frameRate;
 22           private   bool  isCompressed;
 23 
 24           public  FlashInfo( string  filename)
 25          {
 26               if  ( ! File.Exists(filename))
 27              {
 28                   throw   new  FileNotFoundException(filename);
 29              }
 30              FileStream stream  =   new  FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
 31              BinaryReader reader  =   new  BinaryReader(stream);
 32               try
 33              {
 34                   if  (stream.Length  <   8 )
 35                  {
 36                       throw   new  InvalidDataException( " 文件不是 Flash 文件格式 " );
 37                  }
 38                   string  flashMark  =   new   string (reader.ReadChars( 3 ));
 39                   if  (flashMark  !=   " FWS "   &&  flashMark  !=   " CWS " )
 40                  {
 41                       throw   new  InvalidDataException( " 文件不是 Flash 文件格式 " );
 42                  }
 43                  isCompressed  =  flashMark  ==   " CWS " ;
 44                  version  =  Convert.ToInt32(reader.ReadByte());
 45                  fileLength  =  reader.ReadInt32();
 46                   byte [] dataPart  =   new   byte [stream.Length  -   8 ];
 47                  reader.Read(dataPart,  0 , dataPart.Length);
 48                  MemoryStream dataStream  =   new  MemoryStream(dataPart);
 49                   try
 50                  {
 51                       if  (isCompressed)
 52                      {
 53                          MemoryStream outStream  =   new  MemoryStream();
 54                          zlib.ZOutputStream outZStream  =   new  zlib.ZOutputStream(outStream);
 55                          CopyStream(dataStream, outZStream);
 56                          outStream.Position  =   0 ;
 57                          ProcessCompressedPart(outStream);
 58                          outZStream.Close();
 59                          outStream.Close();
 60                      }
 61                       else
 62                          ProcessCompressedPart(dataStream);
 63                  }
 64                   finally
 65                  {
 66                      dataStream.Close();
 67                  }
 68              }
 69               finally
 70              {
 71                  reader.Close();
 72                  stream.Close();
 73              }
 74          }
 75 
 76           private   void  ProcessCompressedPart(MemoryStream stream)
 77          {
 78              BinaryReader reader  =   new  BinaryReader(stream);
 79               try
 80              {
 81                   byte [] rect;
 82                   int  nbits, totalBits, totalBytes;
 83                  nbits  =  reader.ReadByte()  >>   3 ;
 84                  totalBits  =  nbits  *   4   +   5 ;
 85                  totalBytes  =  totalBits  /   8 ;
 86                   if  (totalBits  %   8   !=   0 )
 87                  {
 88                      totalBytes ++ ;
 89                  }
 90                  reader.BaseStream.Seek( - 1 , SeekOrigin.Current);
 91                  rect  =  reader.ReadBytes(totalBytes);
 92                  frameRate  =   float .Parse( string .Format( " {1}.{0} " , reader.ReadByte(), reader.ReadByte()));
 93                  frameCount  =  Convert.ToInt32(reader.ReadInt16());
 94                  BitArray bits  =   new  BitArray(rect);
 95                   bool [] reversedBits  =   new   bool [bits.Length];
 96                   for  ( int  i  =   0 ; i  <  totalBytes; i ++ )
 97                  {
 98                       int  count  =   7 ;
 99                       for  ( int  j  =   8   *  i; j  <   8   *  (i  +   1 ); j ++ )
100                      {
101                          reversedBits[j  +  count]  =  bits[j];
102                          count  -=   2 ;
103                      }
104                  }
105                  bits  =   new  BitArray(reversedBits);
106                  StringBuilder sbField  =   new  StringBuilder(bits.Length);
107                   for  ( int  i  =   0 ; i  <  bits.Length; i ++ )
108                      sbField.Append(bits[i]  ?   " 1 "  :  " 0 " );
109                   string  result  =  sbField.ToString();
110                   string  widthBinary  =  result.Substring(nbits  +   5 , nbits);
111                   string  heightBinary  =  result.Substring( 3   *  nbits  +   5 , nbits);
112                  width  =  Convert.ToInt32(FlashInfo.BinaryToInt64(widthBinary)  /   20 );
113                  height  =  Convert.ToInt32(FlashInfo.BinaryToInt64(heightBinary)  /   20 );
114              }
115               finally
116              {
117                  reader.Close();
118              }
119          }
120 
121           private   static   long  BinaryToInt64( string  binaryString)
122          {
123               if  ( string .IsNullOrEmpty(binaryString))
124                   throw   new  ArgumentNullException();
125               long  result  =   0 ;
126               for  ( int  i  =   0 ; i  <  binaryString.Length; i ++ )
127              {
128                  result  =  result  *   2 ;
129                   if  (binaryString[i]  ==   ' 1 ' )
130                      result ++ ;
131              }
132               return  result;
133          }
134 
135           public   int  Width
136          {
137               get
138              {
139                   return   this .width;
140              }
141          }
142 
143           public   int  Height
144          {
145               get
146              {
147                   return   this .height;
148              }
149          }
150 
151           public   int  FileLength
152          {
153               get
154              {
155                   return   this .fileLength;
156              }
157          }
158 
159           public   int  Version
160          {
161               get
162              {
163                   return   this .version;
164              }
165          }
166 
167           public   float  FrameRate
168          {
169               get
170              {
171                   return   this .frameRate;
172              }
173          }
174 
175           public   int  FrameCount
176          {
177               get
178              {
179                   return   this .frameCount;
180              }
181          }
182 
183           public   bool  IsCompressed
184          {
185               get
186              {
187                   return   this .isCompressed;
188              }
189          }
190 
191           public   static   void  CopyStream(System.IO.Stream input, System.IO.Stream output)
192          {
193               byte [] buffer  =   new   byte [ 2000 ];
194               int  len;
195               while  ((len  =  input.Read(buffer,  0 ,  2000 ))  >   0 )
196              {
197                  output.Write(buffer,  0 , len);
198              }
199              output.Flush();
200          }
201      }
202  }
203