flv 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d87000942102a6037bcfed2bb5b54fb960726886
-  data.tar.gz: dd3ff0b1bfda221527d70aa69c8728eeb4656f60
+  metadata.gz: f8a4f49876669363f9f2eb9b90cffb221efca11a
+  data.tar.gz: 72a72c4ad20f4ba477940c00d972426aff0528d2
 SHA512:
-  metadata.gz: 830e93c9afb9d438396fad2dca39273f66608c96203c345f610454d8b12d066cd93cfdcde7a3c6ff9822ccfed2cb18e6f2e3f5a413e6a0b0bb6a73a043c69876
-  data.tar.gz: fcb6abcce91188839c6d3835c096d8ea5f87b55e834b6cdbadb37adc2604f492c96d82496178365b1674c5643f967faf584f14a239331805e01e56a1976ccf98
+  metadata.gz: 01515ede28f3178c9898c63f254f99606f3bd382e89714e7eabcdfed1df47f17fad591764a690f4801a9644e93ae658688385b5c930091c47bce12d0cca84a75
+  data.tar.gz: 4415125baeb5ba78bafb233ff87f3947f40290be3f34f3ecb476873835d2e73e00585985516c33ce53520af895529544b3f5d67c22097ff50311f34c915dbc0f

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Charlie Somerville & Envato
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,53 @@
+# FLV
+
+A Ruby library for parsing FLV files and metadata sections.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "flv"
+```
+
+And then execute:
+
+```shell
+$ bundle
+```
+
+Or install it yourself as:
+
+```shell
+$ gem install flv
+```
+
+## Usage
+
+```ruby
+flv = FLV.read("path/to/your/video.flv")
+flv.audio? # => true
+flv.video? # => true
+
+data_tag = flv.tags.find { |tag| tag.is_a?(FLV::Tag::Data) }
+data_tag.duration # => 60.0
+data_tag.frame_rate # => 30.0
+```
+
+The FLV gem also supports streaming parsing, so you can handle tags as they arrive from an I/O stream.
+
+This is useful for pulling metadata out of FLV videos without having to download the whole lot:
+
+```ruby
+flv = FLV.new(io)
+data_tag = flv.each_tag.first
+io.close
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/flv.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "flv/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "flv"
+  spec.version       = FLV::VERSION
+  spec.authors       = ["Charlie Somerville"]
+  spec.email         = ["charlie@charliesomerville.com"]
+  spec.description   = %q{A library for handling FLV files}
+  spec.summary       = %q{Ruby library for parsing and handling FLV files}
+  spec.homepage      = "https://github.com/envato/flv"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.13.0"
+end

data/lib/flv.rb

@@ -0,0 +1,54 @@
+require "flv/version"
+require "flv/stream_reader"
+require "flv/format_error"
+require "flv/tag"
+
+class FLV
+  def self.read(path)
+    new(File.open(path, "rb"))
+  end
+
+  AUDIO_FLAG = 0x04
+  VIDEO_FLAG = 0x01
+
+  attr_reader :flags
+
+  def initialize(io)
+    @io = io
+    @reader = StreamReader.new(io)
+    read_header
+    read_useless_footer
+  end
+
+  def audio?
+    (flags & AUDIO_FLAG).nonzero?
+  end
+
+  def video?
+    (flags & VIDEO_FLAG).nonzero?
+  end
+
+  def tags
+    @tags ||= each_tag.to_a
+  end
+
+  def each_tag
+    return enum_for(:each_tag) unless block_given?
+
+    until @io.eof?
+      yield Tag.read(@io)
+    end
+  end
+
+private
+  def read_header
+    raise FormatError, "bad header" unless @reader.read_bytes(3) == "FLV"
+    raise FormatError, "bad version" unless @reader.read_byte == 1
+    @flags = @reader.read_byte
+    raise FormatError, "bad header size" unless @reader.read_uint32_be == 9
+  end
+
+  def read_useless_footer
+    raise FormatError, "expected useless footer to be zero" unless @reader.read_uint32_be == 0
+  end
+end

data/lib/flv/format_error.rb

@@ -0,0 +1,4 @@
+class FLV
+  class FormatError < StandardError
+  end
+end

data/lib/flv/script_data_parser.rb

@@ -0,0 +1,107 @@
+# coding: BINARY
+require "flv/stream_reader"
+require "flv/format_error"
+
+class FLV
+  class ScriptDataParser
+    def initialize(str)
+      @data_reader = StreamReader.for_string(str.dup.force_encoding("BINARY"))
+    end
+
+    def parse
+      Hash[until_terminator(TERMINATOR).map {
+        [expect_script_data_string, read_script_data_value]
+      }]
+    end
+
+    def parse_single_value
+      read_script_data_value
+    end
+
+  private
+    def read_script_data_value
+      case type = @data_reader.read_byte
+      when  0 then read_script_data_number
+      when  1 then read_script_data_boolean
+      when  2 then read_script_data_string
+      when  3 then read_script_data_object
+      when  4 then read_script_data_movie_clip
+      when  5 then read_script_data_null
+      when  6 then read_script_data_undefined
+      when  7 then read_script_data_reference
+      when  8 then read_script_data_array
+      when 10 then read_script_data_strict_array
+      when 11 then read_script_data_date
+      when 12 then read_script_data_long_string
+      else
+        raise FormatError, "unknown type #{type}"
+      end
+    end
+
+    def read_script_data_number
+      @data_reader.read_double_be
+    end
+
+    def read_script_data_string
+      length = @data_reader.read_uint16_be
+      @data_reader.read_bytes(length)
+    end
+
+    def read_script_data_boolean
+      !@data_reader.read_byte.zero?
+    end
+
+    TERMINATOR = "\x00\x00\x09".force_encoding("BINARY").freeze
+
+    def read_script_data_object
+      Hash[until_terminator(TERMINATOR).map {
+        [read_script_data_string, read_script_data_value]
+      }]
+    end
+
+    def read_script_data_array
+      # this value is ignored on purpose
+      approx_array_length = @data_reader.read_uint32_be
+
+      Hash[until_terminator(TERMINATOR).map {
+        read_script_data_variable
+      }]
+    end
+
+    def read_script_data_variable
+      [read_script_data_string, read_script_data_value]
+    end
+
+    def read_script_data_strict_array
+      count = @data_reader.read_uint32_be
+      count.times.map { read_script_data_value }
+    end
+
+    def read_script_data_date
+      time = @data_reader.read_double_be
+      utc_offset_minutes = @data_reader.read_sint16_be
+      Time.new(1970, 1, 1, 0, 0, 0, utc_offset_minutes * 60) + time
+    rescue ArgumentError
+      nil
+    end
+
+    def expect_script_data_string
+      read_script_data_value.tap do |value|
+        unless value.is_a?(String)
+          raise FormatError, "expected string, have #{value.inspect}"
+        end
+      end
+    end
+
+    def until_terminator(term)
+      return enum_for(:until_terminator, term) unless block_given?
+      sz = term.bytesize
+      loop do
+        bytes = @data_reader.read_bytes(sz)
+        return if bytes == term or bytes.nil?
+        @data_reader.seek(-sz)
+        yield
+      end
+    end
+  end
+end

data/lib/flv/stream_reader.rb

@@ -0,0 +1,57 @@
+# coding: BINARY
+
+require "stringio"
+
+class FLV
+  class StreamReader
+    def initialize(io)
+      @io = io
+    end
+
+    def self.for_string(str)
+      new(StringIO.new(str))
+    end
+
+    def eof?
+      @io.eof?
+    end
+
+    def seek(offset)
+      @io.seek(offset, IO::SEEK_CUR)
+    end
+
+    def read_bytes(n)
+      @io.read(n)
+    end
+
+    def read_byte
+      @io.readbyte
+    end
+
+    def read_uint32_be
+      read_bytes(4).unpack("L>").first
+    end
+
+    def read_uint24_be
+      "\x00#{read_bytes(3)}".unpack("L>").first
+    end
+
+    def read_uint16_be
+      read_bytes(2).unpack("S>").first
+    end
+
+    def read_sint16_be
+      read_bytes(2).unpack("s>").first
+    end
+
+    def read_uint32_weird_endian
+      lower = read_uint24_be
+      higher = read_byte
+      lower | (higher << 24)
+    end
+
+    def read_double_be
+      read_bytes(8).unpack("G").first
+    end
+  end
+end

data/lib/flv/tag.rb

@@ -0,0 +1,58 @@
+require "flv/stream_reader"
+require "flv/format_error"
+require "flv/tag/data"
+require "flv/tag/audio"
+require "flv/tag/video"
+
+class FLV
+  class Tag
+    METADATA_TYPE = 0x12
+    AUDIO_TYPE    = 0x08
+    VIDEO_TYPE    = 0x09
+
+    attr_reader :length, :timestamp, :raw_data, :footer
+
+    def self.read(io)
+      case io.readbyte
+      when METADATA_TYPE  then Data.new(io)
+      when AUDIO_TYPE     then Audio.new(io)
+      when VIDEO_TYPE     then Video.new(io)
+      end
+    end
+
+    def initialize(io)
+      @reader = StreamReader.new(io)
+      read
+    end
+
+    def inspect
+      "#<#{self.class}>"
+    end
+
+  private
+    def decode_raw_data
+      # implemented in subclasses
+    end
+
+    def read
+      read_header
+      read_raw_data
+      read_footer
+      decode_raw_data
+    end
+
+    def read_header
+      @length     = @reader.read_uint24_be
+      @timestamp  = @reader.read_uint32_weird_endian
+      raise FormatError, "bad stream id" unless @reader.read_uint24_be == 0
+    end
+
+    def read_raw_data
+      @raw_data = @reader.read_bytes(length)
+    end
+
+    def read_footer
+      @footer = @reader.read_uint32_be
+    end
+  end
+end

data/lib/flv/tag/audio.rb

@@ -0,0 +1,6 @@
+class FLV
+  class Tag
+    class Audio < Tag
+    end
+  end
+end

data/lib/flv/tag/data.rb

@@ -0,0 +1,63 @@
+require "flv/tag"
+require "flv/stream_reader"
+require "flv/format_error"
+require "flv/script_data_parser"
+
+class FLV
+  class Tag
+    class Data < Tag
+      def data
+        @data ||= ScriptDataParser.new(raw_data).parse
+      end
+      
+      def inspect
+        "#<#{self.class} #{data.inspect}>"
+      end
+
+      def duration
+        meta_data["duration"]
+      end
+
+      def width
+        meta_data["width"]
+      end
+
+      def height
+        meta_data["height"]
+      end
+
+      def video_data_rate
+        meta_data["videodatarate"]
+      end
+
+      def frame_rate
+        meta_data["framerate"]
+      end
+
+      def video_codec_id
+        meta_data["videocodecid"]
+      end
+
+      def audio_data_rate
+        meta_data["audiodatarate"]
+      end
+
+      def audio_delay
+        meta_data["audiodelay"]
+      end
+
+      def audio_codec_id
+        meta_data["audiocodecid"]
+      end
+
+      def seek_to_end?
+        meta_data["canSeekToEnd"]
+      end
+
+    private
+      def meta_data
+        data["onMetaData"] || {}
+      end
+    end
+  end
+end

data/lib/flv/tag/video.rb

@@ -0,0 +1,6 @@
+class FLV
+  class Tag
+    class Video < Tag
+    end
+  end
+end

data/lib/flv/version.rb

@@ -0,0 +1,3 @@
+class FLV
+  VERSION = "0.1.0"
+end

data/spec/flv/script_data_parser_spec.rb

@@ -0,0 +1,105 @@
+require "flv/script_data_parser"
+
+describe FLV::ScriptDataParser do
+  let(:parser) { FLV::ScriptDataParser.new(@str) }
+  let(:value)  { parser.parse_single_value }
+
+  context "numbers" do
+    it "parses the number as a big endian double precision float" do
+      @str = "\x00@^\xDD/\x1A\x9F\xBEw"
+      value.should == 123.456
+    end
+  end
+
+  context "booleans" do
+    it "parses a 0 byte as false" do
+      @str = "\x01\x00"
+      value.should == false
+    end
+
+    it "parses a 1 byte as true" do
+      @str = "\x01\x01"
+      value.should == true
+    end
+  end
+
+  context "strings" do
+    it "parses empty strings" do
+      @str = "\x02\x00\x00"
+      value.should == ""
+    end
+
+    it "parses strings < 255 chars" do
+      @str = "\x02\x00\x0bhello world"
+      value.should == "hello world"
+    end
+
+    it "parses strings > 255 chars (where endianness matters)" do
+      @str = "\x02\x02\x00#{"x"*512}"
+      value.should == "x" * 512
+    end
+  end
+
+  context "objects" do
+    it "parses empty objects" do
+      @str = "\x03\x00\x00\x09"
+      value.should == {}
+    end
+
+    it "parses objects as pairs of a non-value strings and a value" do
+      @str = "\x03\x00\x04name\x02\x00\x05value\x00\x00\x09"
+      value.should == { "name" => "value" }
+    end
+  end
+
+  context "arrays" do
+    it "parses empty 'arrays' as empty hashes" do
+      @str = "\x08\x00\x00\x00\x00\x00\x00\x09"
+      value.should == {}
+    end
+
+    it "ignores the length hint" do
+      @str = "\x08\x11\x22\x33\x44\x00\x00\x09"
+      value.should == {}
+    end
+
+    it "parses arrays as pairs of a non-value string and a value" do
+      @str = "\x08\x00\x00\x00\x00\x00\x04name\x02\x00\x05value\x00\x00\x09"
+      value.should == { "name" => "value" }
+    end
+  end
+
+  context "strict arrays" do
+    it "parses empty strict arrays" do
+      @str = "\x0a\x00\x00\x00\x00"
+      value.should == []
+    end
+
+    it "parses strict arrays with values" do
+      @str = "\x0a\x00\x00\x00\x03\x02\x00\x03foo\x02\x00\x03bar\x02\x00\x03baz"
+      value.should == ["foo", "bar", "baz"]
+    end
+  end
+
+  context "dates" do
+    it "can parse an empty date" do
+      @str = "\x0b\0\0\0\0\0\0\0\0\0\0"
+      value.should == Time.utc(1970, 1, 1, 0, 0, 0)
+    end
+
+    it "can parse an empty date in UTC+10" do
+      @str = "\x0b\0\0\0\0\0\0\0\0\x02X"
+      value.should == Time.new(1970, 1, 1, 0, 0, 0, 10 * 3600)
+    end
+
+    it "can parse today in UTC+10" do
+      @str = "\x0bA\xD4bB\xDE\x80\0\0\x02X"
+      value.should == Time.new(2013, 5, 7, 14, 11, 6, 10 * 3600)
+    end
+
+    it "can parse today in UTC-10" do
+      @str = "\x0bA\xD4bB\xDE\x80\0\0\xfd\xa8"
+      value.should == Time.new(2013, 5, 7, 14, 11, 6, -10 * 3600)
+    end
+  end
+end

data/spec/flv/stream_reader_spec.rb

@@ -0,0 +1,65 @@
+# coding: BINARY
+
+require "flv/stream_reader"
+require "stringio"
+
+describe FLV::StreamReader do
+  let(:string) { "\xde\xad\xbe\xef\x00\xfa\xca\xde" }
+  let(:io) { StringIO.new(string) }
+  subject { FLV::StreamReader.new(io) }
+
+  describe "#eof?" do
+    let(:val) { mock }
+
+    it "should delegate to the io" do
+      io.should_receive(:eof?).and_return(val)
+      subject.eof?.should == val
+    end
+  end
+
+  describe "#read_bytes" do
+    it "reads the specified number of bytes" do
+      subject.read_bytes(8).should == string
+    end
+
+    it "saves its spot in the stream" do
+      subject.read_bytes(4).should == "\xde\xad\xbe\xef"
+      subject.read_bytes(4).should == "\x00\xfa\xca\xde"
+    end
+  end
+
+  describe "#read_byte" do
+    it "returns fixnums" do
+      subject.read_byte.should == 0xde
+      subject.read_byte.should == 0xad
+    end
+  end
+
+  describe "#read_uint32_be" do
+    it "reads big endian unsigned 32 bit integers" do
+      subject.read_uint32_be.should == 0xdeadbeef
+      subject.read_uint32_be.should == 0x00facade
+    end
+  end
+
+  describe "#read_uint24_be" do
+    it "reads big endian unsigned 24 bit integers" do
+      subject.read_uint24_be.should == 0xdeadbe
+      subject.read_uint24_be.should == 0xef00fa
+    end
+  end
+
+  describe "#read_uint16_be" do
+    it "reads big endian unsigned 16 bit integers" do
+      subject.read_uint16_be.should == 0xdead
+      subject.read_uint16_be.should == 0xbeef
+    end
+  end
+
+  describe "#read_uint32_weird_endian" do
+    it "reads FLV's super weird mixed endian properly" do
+      subject.read_uint32_weird_endian.should == 0xefdeadbe
+      subject.read_uint32_weird_endian.should == 0xde00faca
+    end
+  end
+end

data/spec/flv/tag/data_spec.rb

@@ -0,0 +1,19 @@
+require "flv/tag/data"
+
+describe FLV::Tag::Data do
+  context "integration test" do
+    let(:preview_flv) { File.open(File.expand_path("../../../files/preview.flv", __FILE__), "rb") }
+    subject { FLV.new(preview_flv).each_tag.first }
+
+    its(:duration)        { should == 6.0 }
+    its(:width)           { should == 640 }
+    its(:height)          { should == 360 }
+    its(:video_data_rate) { should == 700 }
+    its(:frame_rate)      { should == 30 }
+    its(:video_codec_id)  { should == 4 }
+    its(:audio_data_rate) { should == 128 }
+    its(:audio_delay)     { should == 0.038 }
+    its(:audio_codec_id)  { should == 2 }
+    its(:seek_to_end?)    { should == true }
+  end
+end

data/spec/flv/tag_spec.rb

@@ -0,0 +1,47 @@
+# coding: BINARY
+
+require "flv/tag"
+require "stringio"
+
+describe FLV::Tag do
+  describe ".read" do
+    let(:io) { StringIO.new(string) }
+
+    context "reading a metadata tag" do
+      let(:string) { "\x12" }
+
+      it "creates a FLV::Tag::Data" do
+        FLV::Tag::Data.should_receive(:new).with(io)
+        FLV::Tag.read(io)
+      end
+    end
+
+    context "reading an audio tag" do
+      let(:string) { "\x08" }
+
+      it "creates a FLV::Tag::Data" do
+        FLV::Tag::Audio.should_receive(:new).with(io)
+        FLV::Tag.read(io)
+      end
+    end
+
+    context "reading a video tag" do
+      let(:string) { "\x09" }
+
+      it "creates a FLV::Tag::Data" do
+        FLV::Tag::Video.should_receive(:new).with(io)
+        FLV::Tag.read(io)
+      end
+    end
+  end
+
+  describe "tag parsing" do
+    let(:string) { "\x00\x00\x0b\xad\xbe\xef\xde\x00\x00\x00hello world\x00\x00\x00\x15" }
+    subject { FLV::Tag.new(StringIO.new(string)) }
+
+    its(:length)    { should == 11 }
+    its(:timestamp) { should == 0xdeadbeef }
+    its(:raw_data)  { should == "hello world" }
+    its(:footer)    { should == 21 }
+  end
+end

data/spec/flv_spec.rb

@@ -0,0 +1,42 @@
+require "flv"
+
+describe FLV do
+  context "integration test" do
+    let(:preview_flv) { File.open(File.expand_path("../files/preview.flv", __FILE__), "rb") }
+    subject { FLV.new(preview_flv) }
+
+    its(:audio?) { should be_true }
+    its(:video?) { should be_true }
+  end
+
+  describe "#audio? and #video?" do
+    let(:flags) { 0 }
+    subject { FLV.allocate.tap do |flv| flv.stub(:flags => flags) end }
+
+    context "doesn't have any flags set" do
+      its(:audio?) { should be_false }
+      its(:video?) { should be_false }
+    end
+
+    context "has the audio flag set" do
+      let(:flags) { FLV::AUDIO_FLAG }
+
+      its(:audio?) { should be_true }
+      its(:video?) { should be_false }
+    end
+
+    context "has the video flag set" do
+      let(:flags) { FLV::VIDEO_FLAG }
+
+      its(:audio?) { should be_false }
+      its(:video?) { should be_true }
+    end
+
+    context "has the audio and video flags set" do
+      let(:flags) { FLV::AUDIO_FLAG | FLV::VIDEO_FLAG }
+
+      its(:audio?) { should be_true }
+      its(:video?) { should be_true }
+    end
+  end
+end

metadata

@@ -1,23 +1,88 @@
 --- !ruby/object:Gem::Specification
 name: flv
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Charlie Somerville
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-06 00:00:00.000000000 Z
-dependencies: []
-description: 
-email: charlie@charliesomerville.com
+date: 2013-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+description: A library for handling FLV files
+email:
+- charlie@charliesomerville.com
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
-homepage: 
-licenses: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- flv.gemspec
+- lib/flv.rb
+- lib/flv/format_error.rb
+- lib/flv/script_data_parser.rb
+- lib/flv/stream_reader.rb
+- lib/flv/tag.rb
+- lib/flv/tag/audio.rb
+- lib/flv/tag/data.rb
+- lib/flv/tag/video.rb
+- lib/flv/version.rb
+- spec/files/preview.flv
+- spec/flv/script_data_parser_spec.rb
+- spec/flv/stream_reader_spec.rb
+- spec/flv/tag/data_spec.rb
+- spec/flv/tag_spec.rb
+- spec/flv_spec.rb
+homepage: https://github.com/envato/flv
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -35,9 +100,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
-summary: coming soon!
-test_files: []
+summary: Ruby library for parsing and handling FLV files
+test_files:
+- spec/files/preview.flv
+- spec/flv/script_data_parser_spec.rb
+- spec/flv/stream_reader_spec.rb
+- spec/flv/tag/data_spec.rb
+- spec/flv/tag_spec.rb
+- spec/flv_spec.rb
 has_rdoc: