程序博客网 > 尚学堂白鹤翔js第二季

c#解析FLV文件

来源：互联网 发布：尚学堂白鹤翔js第二季 编辑：程序博客网 时间：2024/06/05 08:56

https://wuyuans.com/2012/09/parser-flv-using-csharp

在上一篇FLV文件格式解析中，我们对FLV的文件结构有了一定了解，现在我们就可以对FLV文件解析解析了。我这里用的是c#，只要理解了过程java、c++都是可以的。

废话少说，先上效果图：ParserFLV

1.工具类

在解析的过程中，我们会和byte做各种运算，所以我定义了一个byte工具类ByteUtils：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.IO;
  7. namespace FLVParer.Utils
  8. {
  9.     class ByteUtils
  10.     {
  11.         public static uint ByteToUInt(byte[] bs, int length)
  12.         {
  13.             if (bs == null || bs.Length < length)
  14.                 return 0;
  15.             uint rtn = 0;
  16.             for (int i = 0; i < length; i++)
  17.             {
  18.                 rtn <<= 8;
  19.                 rtn |= bs[i];
  20.             }
  21.             return rtn;
  22.         }
  23.         public static double ByteToDouble(byte[] bs)
  24.         {
  25.             if (bs == null || bs.Length < 8)
  26.                 return 0;
  27.             byte[] b2 = new byte[8];
  28.             for (int i = 0; i < 8; i++)
  29.             {
  30.                 b2[i] = bs[7 - i];
  31.             }
  32.             return BitConverter.ToDouble(b2, 0);
  33.         }
  34.         public static short ReadUI16(Stream src)
  35.         {
  36.             byte[] bs = new byte[2];
  37.             if (src.Read(bs, 0, 2) <= 0)
  38.                 return 0;
  39.             return (short)((bs[0] << 8) | bs[1]);
  40.         }
  41.         public static uint ReadUI24(Stream src)
  42.         {
  43.             byte[] bs = new byte[3];
  44.             if (src.Read(bs, 0, 3) <= 0)
  45.                 throw new IOException("Stream end.");
  46.             return ByteToUInt(bs, 3);
  47.         }
  48.         public static uint ReadUI32(Stream src)
  49.         {
  50.             byte[] bs = new byte[4];
  51.             if (src.Read(bs, 0, 4) <= 0)
  52.                 throw new IOException("Stream end.");
  53.             return ByteToUInt(bs, 4);
  54.         }
  55.         public static string GetTime(uint time)
  56.         {
  57.             return (time / 60000).ToString() + ":"
  58.                 + (time / 1000 % 60).ToString("D2") + "."
  59.                 + (time % 1000).ToString("D3");
  60.         }
  61.     }
  62. }

2.FLV类

FLV类，主要的类，里面包括一个header和许多的tag，也就是一个FLV文件的结构：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.IO;
  6. using FLVParer.Utils;
  8. namespace FLVParer.Model
  9. {
  10.     class FLV
  11.     {
  12.         public Header header { get; private set; }
  13.         List<Tag> tags;
  14.         public FLV(Stream stream)
  15.         {
  16.             header = new Header();
  17.             header.readHeader(stream);
  18.             stream.Seek(header.size, SeekOrigin.Begin);
  19.             tags = new List<Tag>();
  20.             while (stream.Position < stream.Length-4)
  21.             {
  22.                 tags.Add(readTag(stream));                
  23.             }
  25.         }
  27.         private Tag readTag(Stream stream)
  28.         {
  29.             Tag tag = null;
  30.             byte[] buf = new byte[4];
  31.             stream.Read(buf, 0, 4);
  32.             int type = stream.ReadByte();
  33.             switch (type)
  34.             {
  35.                 case 8:
  36.                     tag = new AudioTag();
  37.                     break;
  38.                 case 9:
  39.                     tag = new VideoTag();
  40.                     break;
  41.                 case 18:
  42.                     tag = new ScriptTag();
  43.                     break;
  44.             }
  45.             tag.presize = ByteUtils.ByteToUInt(buf, 4);
  46.             tag.datasize = ByteUtils.ReadUI24(stream);
  47.             tag.timestamp = ByteUtils.ReadUI24(stream);
  48.             tag.timestamp_ex = stream.ReadByte();
  49.             tag.streamid = ByteUtils.ReadUI24(stream);            
  50.             tag.readData(stream);           
  51.             return tag;
  52.         }
  53.     }
  54. }

2.1.Header类

Header类，保存FLV文件的头信息：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.IO;
  6. using FLVParer.Utils;
  8. namespace FLVParer.Model
  9. {
  10.     class Header
  11.     {
  12.         public String type { get; private set; }
  13.         public int version { get; private set; }
  14.         public bool hasVideo { get; private set; }
  15.         public bool hasAudio { get; private set; }
  16.         public uint size { get; private set; }
  18.         public void readHeader(Stream stream)
  19.         {
  20.             byte[] buf = new byte[4];
  21.             stream.Read(buf, 0, 3);
  22.             type = Encoding.Default.GetString(buf);
  23.             stream.Read(buf, 0, 1);
  24.             version = buf[0];
  25.             stream.Read(buf, 0, 1);
  26.             buf[0] &= 0x0f;
  27.             if ((buf[0] & 0x01) == 1)
  28.             {
  29.                 hasVideo = true;
  30.             }
  31.             if ((buf[0] & 0x04) == 4)
  32.             {
  33.                 hasAudio = true;
  34.             }
  35.             stream.Read(buf, 0, 4);
  36.             size = ByteUtils.ByteToUInt(buf, 4);
  37.         }
  38.     }
  39. }

2.2.Tag类

Tag类是一个抽象类，因为tag的种类有三种，为了统一管理，抽象出Tag类：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.IO;
  7. namespace FLVParer.Model
  8. {
  9.     enum TagType
  10.     {
  11.         video,
  12.         audio,
  13.         Script
  14.     }
  15.     abstract class Tag
  16.     {
  17.         public TagType tagType;//tag类型
  18.         public uint presize;//前一tag大小
  19.         public uint datasize;//数据区大小
  20.         public uint timestamp; //时间戳 单位ms
  21.         public int timestamp_ex;//时间戳扩展
  22.         public uint streamid;//ID
  23.         public long offset;//偏移量
  24.         public byte[] data;//数据
  25.         //对tag进行读取
  26.         public abstract void readData(Stream stream);
  27.     }
  28. }

2.2.1.ScriptTag类

脚本tag类，继承自Tag类，并添加成员变量Values，用于保存脚本信息：

  1. using System.Collections.Generic;
  2. using System.Text;
  3. using System.IO;
  4. using FLVParer.Utils;
  6. namespace FLVParer.Model
  7. {
  8.     class ScriptTag : Tag
  9.     {
  10.         public List<KeyValuePair<string, object>> Values { get; private set; }
  11.         public ScriptTag()
  12.         {
  13.             tagType = TagType.Script;
  14.             Values = new List<KeyValuePair<string, object>>();
  15.         }
  17.         public override void readData(Stream stream)
  18.         {
  19.             offset = 0;
  20.             Values.Clear();
  21.             byte[] bs = new byte[3];
  22.             while (offset < this.datasize)
  23.             {
  24.                 stream.Read(bs, 0, 3);
  25.                 if (bs[0] == 0 && bs[1] == 0 && bs[2] == 9)
  26.                 {
  27.                     offset += 3;
  28.                     break;
  29.                 }
  30.                 stream.Seek(-3, SeekOrigin.Current);
  31.                 AddElement("#" + offset, ReadElement(stream));
  32.             }
  33.         }
  35.         private void AddElement(string key, object o)
  36.         {
  37.             Values.Add(new KeyValuePair<string, object>(key, o));
  38.         }
  40.         private object ReadElement(Stream src)
  41.         {
  42.             int type = src.ReadByte();
  43.             offset++;
  44.             switch (type)
  45.             {
  46.                 case 0: // Number - 8
  47.                     return ReadDouble(src);
  48.                 case 1: // Boolean - 1
  49.                     return ReadByte(src);
  50.                 case 2: // String - 2+n
  51.                     return ReadString(src);
  52.                 case 3: // Object
  53.                     return ReadObject(src);
  54.                 case 4: // MovieClip
  55.                     return ReadString(src);
  56.                 case 5: // Null
  57.                     break;
  58.                 case 6: // Undefined
  59.                     break;
  60.                 case 7: // Reference - 2
  61.                     return ReadUShort(src);
  62.                 case 8: // ECMA array
  63.                     return ReadArray(src);
  64.                 case 10: // Strict array
  65.                     return ReadStrictArray(src);
  66.                 case 11: // Date - 8+2
  67.                     return ReadDate(src);
  68.                 case 12: // Long string - 4+n
  69.                     return ReadLongString(src);
  70.             }
  71.             return null;
  72.         }
  73.         private object ReadObject(Stream src)
  74.         {
  75.             byte[] bs = new byte[3];
  76.             ScriptObject obj = new ScriptObject();
  77.             while (offset < this.datasize)
  78.             {
  79.                 src.Read(bs, 0, 3);
  80.                 if (bs[0] == 0 && bs[1] == 0 && bs[2] == 9)
  81.                 {
  82.                     offset += 3;
  83.                     break;
  84.                 }
  85.                 src.Seek(-3, SeekOrigin.Current);
  86.                 string key = ReadString(src);
  87.                 if (key[0] == 0)
  88.                     break;
  89.                 obj[key] = ReadElement(src);
  90.             }
  91.             return obj;
  92.         }
  93.         private double ReadDate(Stream src)
  94.         {
  95.             double d = ReadDouble(src);
  96.             src.Seek(2, SeekOrigin.Current);
  97.             offset += 2;
  98.             return d;
  99.         }
  100.         private ScriptObject ReadArray(Stream src)
  101.         {
  102.             byte[] buffer = new byte[4];
  103.             src.Read(buffer, 0, 4);
  104.             offset += 4;
  105.             uint count = ByteUtils.ByteToUInt(buffer, 4);
  106.             ScriptObject array = new ScriptObject();
  107.             for (uint i = 0; i < count; i++)
  108.             {
  109.                 string key = ReadString(src);
  110.                 array[key] = ReadElement(src);
  111.             }
  112.             src.Seek(3, SeekOrigin.Current); // 00 00 09
  113.             offset += 3;
  114.             return array;
  115.         }
  116.         private ScriptArray ReadStrictArray(Stream src)
  117.         {
  118.             byte[] bs = new byte[4];
  119.             src.Read(bs, 0, 4);
  120.             offset += 4;
  121.             ScriptArray array = new ScriptArray();
  122.             uint count = ByteUtils.ByteToUInt(bs, 4);
  123.             for (uint i = 0; i < count; i++)
  124.             {
  125.                 array.Add(ReadElement(src));
  126.             }
  127.             return array;
  128.         }
  129.         private double ReadDouble(Stream src)
  130.         {
  131.             byte[] buffer = new byte[8];
  132.             src.Read(buffer, 0, 8);
  133.             offset += 8;
  134.             return ByteUtils.ByteToDouble(buffer);
  135.         }
  136.         private byte ReadByte(Stream src)
  137.         {
  138.             offset++;
  139.             return (byte)src.ReadByte();
  140.         }
  141.         private string ReadString(Stream src)
  142.         {
  143.             byte[] bs = new byte[2];
  144.             src.Read(bs, 0, 2);
  145.             offset += 2;
  146.             int n = (int)ByteUtils.ByteToUInt(bs, 2);
  147.             bs = new byte[n];
  148.             src.Read(bs, 0, n);
  149.             offset += n;
  150.             return Encoding.ASCII.GetString(bs);
  151.         }
  152.         private string ReadLongString(Stream src)
  153.         {
  154.             byte[] bs = new byte[4];
  155.             src.Read(bs, 0, 4);
  156.             offset += 4;
  157.             int n = (int)ByteUtils.ByteToUInt(bs, 4);
  158.             bs = new byte[n];
  159.             src.Read(bs, 0, n);
  160.             offset += n;
  161.             return Encoding.ASCII.GetString(bs);
  162.         }
  163.         private ushort ReadUShort(Stream src)
  164.         {
  165.             byte[] buffer = new byte[2];
  166.             src.Read(buffer, 0, 2);
  167.             offset += 2;
  168.             return (ushort)ByteUtils.ByteToUInt(buffer, 2);
  169.         }
  170.     }
  172.     public class ScriptObject
  173.     {
  174.         public static int indent = 0;
  175.         private Dictionary<string, object> values = new Dictionary<string, object>();
  176.         public object this[string key]
  177.         {
  178.             get
  179.             {
  180.                 object o;
  181.                 values.TryGetValue(key, out o);
  182.                 return o;
  183.             }
  184.             set
  185.             {
  186.                 if (!values.ContainsKey(key))
  187.                 {
  188.                     values.Add(key, value);
  189.                 }
  190.             }
  191.         }
  192.         public override string ToString()
  193.         {
  194.             string str = "{\r\n";
  195.             ScriptObject.indent += 2;
  196.             foreach (KeyValuePair<string, object> kv in values)
  197.             {
  198.                 str += new string(' ', ScriptObject.indent) 
  199.                           + kv.Key + ": " + kv.Value + "\r\n";
  200.             }
  201.             ScriptObject.indent -= 2;
  202.             //if (str.Length > 1)
  203.             // str = str.Substring(0, str.Length - 1);
  204.             str += "}";
  205.             return str;
  206.         }
  207.     }
  208.     public class ScriptArray
  209.     {
  210.         private List<object> values = new List<object>();
  211.         public object this[int index]
  212.         {
  213.             get
  214.             {
  215.                 if (index >= 0 && index < values.Count)
  216.                     return values[index];
  217.                 return null;
  218.             }
  219.         }
  220.         public void Add(object o)
  221.         {
  222.             values.Add(o);
  223.         }
  224.         public override string ToString()
  225.         {
  226.             string str = "[";
  227.             int n = 0;
  228.             foreach (object o in values)
  229.             {
  230.                 if (n % 10 == 0)
  231.                     str += "\r\n";
  232.                 n++;
  233.                 str += o + ",";
  234.             }
  235.             if (str.Length > 1)
  236.                 str = str.Substring(0, str.Length - 1);
  237.             str += "\r\n]";
  238.             return str;
  239.         }
  240.     }
  241. }

2.2.2.VideoTag类

视频tag类：

  1. using System.IO;
  3. namespace FLVParer.Model
  4. {
  5.     class VideoTag : Tag
  6.     {
  7.         public int frameType;//帧类型
  8.         public int encodeID;//编码ID
  9.         public VideoTag()
  10.         {
  11.             tagType = TagType.video;
  12.         }
  13.         public override void readData(Stream stream)
  14.         {
  15.             int info = stream.ReadByte();
  16.             frameType = info >> 4;
  17.             encodeID = info & 0x0f;
  18.             data = new byte[datasize - 1];
  19.             stream.Read(data, 0, (int)datasize - 1);
  20.         }
  21.     }
  22. }

2.2.3.AudioTag 类

音频tag类：

  1. using System.IO;
  3. namespace FLVParer.Model
  4. {
  5.     class AudioTag : Tag
  6.     {
  7.         public int formate;//音频格式
  8.         public int rate;//采样率
  9.         public int size;//采样的长度
  10.         public int type;//音频类型
  11.         public AudioTag()
  12.         {
  13.             tagType = TagType.audio;
  14.         }
  16.         public override void readData(Stream stream)
  17.         {
  18.             int info = stream.ReadByte();
  19.             formate = info >> 4;
  20.             rate = (info & 0x0c) >> 2;
  21.             size = (info & 0x02) >> 1;
  22.             type = info & 0x01;
  23.             data = new byte[datasize - 1];
  24.             stream.Read(data, 0, (int)datasize - 1);
  25.         }
  26.     }
  27. }

3.使用方法

用法很简单，new出来的时候把FLV文件的stream对象传进去就行了，比如我这样的：

  1. FLV flv = null;
  2. using (FileStream fs = new FileStream("t31_stract.flv", FileMode.Open, FileAccess.Read))
  3. {
  4.     flv = new FLV(fs);
  5. }

之后就可以使用flv对象来分析当前flv的信息了。

4.总结

因为FLV文件的结构很清晰，也很简单，所以解析起来还是挺容易的。我上面的解析程序只是简单的把FLV分解了出来，如果要做FLV的修改操作的话，可以给每个类加个toStream方法，再历遍依次调用就可以写回到文件里了。

作者：wuyuan 本文来自Wuyuan's Blog 转载请注明，谢谢！ 文章地址:http://wuyuans.com/2012/09/parser-flv-using-csharp

0 0
尚学堂白鹤翔js第二季 尚学堂白鹤翔js第二季
原创粉丝点击
热门IT博客
思科 ip绑定mac地址思科 ip绑定mac地址
数据库存储文件类型数据库存储文件类型
皇家骑士团java
linux vnc服务
windows安装ant
网络主播招聘文案
淘宝上的伊皇是真的吗
淘宝怎么买同城的东西
云计算的特点分类应用
vnc server使用的端口
p网络语言什么意思
仿卷皮源码
手机同花顺炒股软件
金科软件 医药
超强震动软件下载
linux 获取终端大小
linux 主机管理系统
企查查如何导出数据
js new date 加一个月
刮刮卡源码
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 推力向心轴承 推力滚针轴承 轴向推力轴承 双向推力球轴承 推力计算公式 推力球轴承安装方法 推力球轴承51110 推力球轴承型号大全 推力调心滚子轴承 推力球轴承型号查询 进口推力球轴承 平面推力轴承型号 ntn推力球轴承 向心推力球轴承型号 滚子推力轴承 推力轴承型号 单向推力球轴承 球面滚子推力轴承 推动 推动近义词 创新推动 推动的英文 fifa推动中国世界杯 推动社会主义文化繁荣兴盛 推动社会主义繁荣兴盛 推动构建人类命运共同体 推动构建人类命运公同体 推动形成全面开放新格局要以 推动形成全面开放新格局 推动媒体融合发展 推动高质量发展 推动的近义词 综漫之我能推动剧情 推动高质量发展个人谈心得 解放思想推动高质量发展1000字 推动摇篮的手 创新推动发展 推动教育学发展的内在动力 推动农业产业化发展 推动摇篮的手歌词 推动文化体制改革

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里