m3u8_generator 0.3.4

data/lib/hls_constants.rb

@@ -0,0 +1,48 @@
+# All tags and attribute names below are described in the HLS draft found at:
+# http://tools.ietf.org/html/draft-pantos-http-live-streaming-08
+
+module HLSConstants
+  # Versions
+  SUPPORTED_M3U8_VERSIONS = [4]
+  FIXNUM_MAX = (2**(0.size * 8 -2) -1)
+
+
+  # Global (or we're not sure what level they apply to) tags
+  EXTM3U        = "#EXTM3U"
+  EXT_X_VERSION = "#EXT-X-VERSION"
+  EXT_X_FAXS_CM = "#EXT-X-FAXS-CM"
+
+  # Master-level m3u8 tags
+
+  # Playlist tags
+  EXT_X_MEDIA      = "#EXT-X-MEDIA"
+  EXT_X_STREAM_INF = "#EXT-X-STREAM-INF"
+
+  # EXT_X_STREAM_INF attribute names
+  EXT_X_STREAM_INF_ATTRS = { :BANDWIDTH => "BANDWIDTH",
+                             :CODECS => "CODECS",
+                             :PROGRAM_ID => "PROGRAM-ID",
+                             :RESOLUTION => "RESOLUTION",
+                             :AUDIO => "AUDIO",
+                             :VIDEO => "VIDEO" }
+
+  # Sub-level m3u8 tags
+  EXT_X_ENDLIST        = "#EXT-X-ENDLIST"
+  EXT_X_MEDIA_SEQUENCE = "#EXT-X-MEDIA-SEQUENCE"
+  EXT_X_PLAYLIST_TYPE  = "#EXT-X-PLAYLIST-TYPE"
+  EXT_X_TARGETDURATION = "#EXT-X-TARGETDURATION"
+
+  # Media segment tags
+  EXTINF              = "#EXTINF"
+  EXT_X_ALLOW_CACHE   = "#EXT-X-ALLOW-CACHE"
+  EXT_X_DISCONTINUITY = "#EXT-X-DISCONTINUITY"
+  EXT_X_KEY           = "#EXT-X-KEY"
+
+  EXT_X_CUE_OUT       = "#EXT-X-CUE-OUT"
+  EXT_X_CUE_IN        = "#EXT-X-CUE-IN"
+
+  # EXT_X_KEY attribute names
+  EXT_X_KEY_ATTRS = { :METHOD => "METHOD",
+                      :URI => "URI",
+                      :IV => "IV" }
+end

data/lib/hls_manifest.rb

@@ -0,0 +1,311 @@
+# An m3u8 parser for HLS (http live streaming) delivery. Converts a string representing an m3u8 manifest
+# to and from a ruby object.
+#
+# Conforms to version 4 of the HLS draft found at:
+# http://tools.ietf.org/html/draft-pantos-http-live-streaming-08
+
+require_relative "hls_constants"
+
+class String
+  # Remove all empty lines and pre whitespace
+  def remove_extra_spaces
+    self.split("\n").map(&:strip).reject(&:empty?).join("\n")
+  end
+end
+
+class HLSPlaylist
+  include HLSConstants
+
+  attr_accessor :bandwidth
+  attr_accessor :program_id
+  attr_accessor :codecs
+  attr_accessor :resolution
+  attr_accessor :audio
+  attr_accessor :video
+  attr_accessor :location
+  attr_accessor :tags
+
+  def build
+    return "" unless @location
+
+    attributes = []
+    attributes.push("#{EXT_X_STREAM_INF_ATTRS[:BANDWIDTH]}=#{@bandwidth}") if @bandwidth
+    attributes.push("#{EXT_X_STREAM_INF_ATTRS[:PROGRAM_ID]}=#{@program_id}") if @program_id
+    attributes.push("#{EXT_X_STREAM_INF_ATTRS[:CODECS]}=#{@codecs.join(",")}") if @codecs
+    attributes.push("#{EXT_X_STREAM_INF_ATTRS[:RESOLUTION]}=#{@resolution}") if @resolution
+    attributes.push("#{EXT_X_STREAM_INF_ATTRS[:AUDIO]}=#{@audio}") if @audio
+    attributes.push("#{EXT_X_STREAM_INF_ATTRS[:VIDEO]}=#{@video}") if @video
+
+    <<-EOT.remove_extra_spaces
+      #{@tags.join("\n")}
+      #{EXT_X_STREAM_INF + ":" + attributes.join(",") unless attributes.empty?}
+      #{@location}
+    EOT
+  end
+end
+
+class HLSMediaSegment
+  include HLSConstants
+
+  attr_accessor :key
+  attr_accessor :show_key
+  attr_accessor :duration
+  attr_accessor :title
+  attr_accessor :location
+  attr_accessor :discontinuity
+  attr_accessor :tags
+  attr_accessor :cue_out_duration
+  attr_accessor :is_cue_out
+  attr_accessor :is_cue_in
+  attr_accessor :sequence
+
+  def initialize
+    @show_key = true
+    @discontinuity = false
+    @duration = 0
+    @cue_out_duration = FIXNUM_MAX
+    @is_cue_out = false
+    @is_cue_in = false
+  end
+
+  def build
+    return "" unless @location
+
+    <<-EOT.remove_extra_spaces
+      #{@tags.join("\n")}
+      #{@discontinuity ? EXT_X_DISCONTINUITY : ""}
+      #{@key.build if @key && @show_key}
+      #{EXTINF}:#{@duration},#{@title}
+      #{@location}
+    EOT
+  end
+end
+
+class HLSKey
+  include HLSConstants
+
+  attr_accessor :method
+  attr_accessor :uri
+  attr_accessor :iv
+
+  def initialize(method = "NONE", uri = nil, iv = nil)
+    @method = method
+    @uri = uri
+    @iv = iv
+  end
+
+  def build
+    attributes = []
+    attributes.push("#{EXT_X_KEY_ATTRS[:METHOD]}=#{@method}") if @method
+    attributes.push("#{EXT_X_KEY_ATTRS[:URI]}=\"#{@uri}\"") if @uri
+    attributes.push("#{EXT_X_KEY_ATTRS[:IV]}=0x#{@iv.to_s(16)}") if @iv
+
+    <<-EOT.remove_extra_spaces
+      #{EXT_X_KEY + ":" + attributes.join(",") unless attributes.empty?}
+    EOT
+  end
+end
+
+class HLSManifest
+  include HLSConstants
+
+  attr_accessor :media_sequence
+  attr_accessor :playlist_type
+  attr_accessor :target_duration
+  attr_accessor :version
+  attr_accessor :line_items
+  attr_accessor :cue_out_items
+
+  def initialize(content = nil)
+    @allow_cache = nil
+    @media_sequence = nil
+    @playlist_type = nil
+    @target_duration = nil
+    @version = nil
+    @is_live = true
+    @line_items = []
+    @cue_out_items = []
+
+    parse(content)
+  end
+
+  def parse(content)
+    return if content.nil? || content.empty?
+
+    last_attributes = []
+    last_key = nil
+    last_playlist_or_media_segment = nil
+    last_unhandled_tags = []
+    last_sequence = 0
+
+    # Remove any blank lines (including lines with spaces just to be safe)
+    lines = content.split("\n").map(&:strip).reject(&:empty?)
+
+    lines.each do |line|
+      if line.start_with?(EXT_X_TARGETDURATION)
+        @target_duration = line.split(":").last.to_i
+      elsif line.start_with?(EXT_X_MEDIA_SEQUENCE)
+        @media_sequence = line.split(":").last.to_i
+      elsif line.start_with?(EXT_X_PLAYLIST_TYPE)
+        @playlist_type = line.split(":").last
+      elsif line.start_with?(EXT_X_ENDLIST)
+        @is_live = false
+      elsif line.start_with?(EXT_X_ALLOW_CACHE)
+        @allow_cache = line.split(":").last
+      elsif line.start_with?(EXT_X_VERSION)
+        @version = line.split(":").last.to_i
+      elsif line.start_with?(EXT_X_STREAM_INF)
+        attributes = {}
+        parse_csv(line.split(":").last).each do |value|
+          attribute = value.split("=")
+          attributes[attribute[0].strip.upcase] = attribute[1].strip
+        end
+
+        playlist = HLSPlaylist.new
+        playlist.bandwidth = attributes[EXT_X_STREAM_INF_ATTRS[:BANDWIDTH]]
+        playlist.program_id = attributes[EXT_X_STREAM_INF_ATTRS[:PROGRAM_ID]]
+        playlist.codecs = attributes[EXT_X_STREAM_INF_ATTRS[:CODECS]]
+        playlist.resolution = attributes[EXT_X_STREAM_INF_ATTRS[:RESOLUTION]]
+        playlist.audio = attributes[EXT_X_STREAM_INF_ATTRS[:AUDIO]]
+        playlist.video = attributes[EXT_X_STREAM_INF_ATTRS[:VIDEO]]
+
+        playlist.bandwidth = playlist.bandwidth.to_i if playlist.bandwidth
+        playlist.program_id = playlist.program_id if playlist.program_id
+        playlist.codecs = parse_csv(playlist.codecs) if playlist.codecs
+
+        last_playlist_or_media_segment = playlist
+        @line_items.push(playlist)
+      elsif line.start_with?(EXTINF)
+        attributes = parse_csv(line.split(":").last)
+
+        media_segment = HLSMediaSegment.new
+        media_segment.duration = attributes[0].to_f
+        media_segment.title = attributes[1]
+        media_segment.key = last_key
+        media_segment.sequence = last_sequence
+        last_sequence += 1
+        if last_playlist_or_media_segment && last_playlist_or_media_segment.key = last_key
+          media_segment.show_key = false
+        end
+
+        last_playlist_or_media_segment = media_segment
+        @line_items.push(media_segment)
+      elsif line.start_with?(EXT_X_DISCONTINUITY)
+        last_attributes.push({ :key => 'discontinuity', :val => true })
+      elsif  line.start_with?(EXT_X_CUE_OUT)
+        last_attributes.push({ :key => 'is_cue_out', :val => true })
+        cue_dur = line.match('DURATION=(\d*)')
+        last_attributes.push({ :key => 'cue_out_duration', :val => cue_dur[1].to_i }) if cue_dur
+        # may or may not contain a duration.
+      elsif line.start_with?(EXT_X_CUE_IN)
+        last_attributes.push({ :key => 'is_cue_in', :val => true })
+      elsif line.start_with?(EXT_X_KEY)
+        attributes = {}
+        parse_csv(line.split(":", 2).last).each do |attribute|
+          attribute = attribute.split("=")
+          attributes[attribute[0].strip.upcase] = attribute[1].strip
+        end
+
+        key = HLSKey.new(attributes[EXT_X_KEY_ATTRS[:METHOD]],
+                         attributes[EXT_X_KEY_ATTRS[:URI]],
+                         attributes[EXT_X_KEY_ATTRS[:IV]])
+
+        key.uri.gsub!("\"", "") if key.uri
+        key.iv = key.iv.hex if key.iv
+        last_key = key
+
+      elsif line.start_with?("#")
+        next if EXTM3U == line
+        # Handle other unhandled tags or comments
+        # Note: Assume that all unhandled tags belong to the sub playlist or media segment that follow
+        # This means that trailing tags are not parsed
+        # TODO: Add support for other manifest level tags that don't belong to individual line items
+        last_unhandled_tags.push(line)
+      else
+        # We should be dealing with the location of a sub playlist or a media segment here
+        # Note: Assume that a manifest cannot contain a mixture of sub playlists and media segments
+        if last_playlist_or_media_segment.instance_of?(HLSMediaSegment)
+          last_attributes.each{|x| last_playlist_or_media_segment.send("#{x[:key]}=", x[:val]) }
+          @cue_out_items.push(last_playlist_or_media_segment) if last_playlist_or_media_segment.is_cue_out
+        end
+        last_playlist_or_media_segment.location = line
+        last_playlist_or_media_segment.tags = last_unhandled_tags
+        last_attributes.clear
+        last_unhandled_tags = []
+      end
+    end
+  end
+
+  def version=(version)
+    # TODO: Don't fail silently
+    @version = version if SUPPORTED_M3U8_VERSIONS.include?(version)
+  end
+
+  def empty?
+    @line_items.empty?
+  end
+
+  def allow_cache?
+    # Not raising an error here in case the EXT-X-ALLOW-CACHE tag is supported for master-level m3u8s
+    @allow_cache.nil? || @allow_cache == "YES"
+  end
+
+  def length
+    @line_items.length
+  end
+
+  def media_length
+    # Note(bz): Should we be raising errors here? I'm not sure what our standard or the Ruby standard is
+    raise NoMethodError, "A master-level manifest cannot access this method" if is_master?
+    @line_items.inject(0) { |sum, x| sum + x.duration }
+  end
+
+  def is_live?
+    raise NoMethodError, "A master-level manifest cannot access this method" if is_master?
+    @is_live
+  end
+
+  def is_master?
+    # Note: This currently assumes an empty m3u8 is NOT a master m3u8
+    !@line_items.empty? && @line_items[0].instance_of?(HLSPlaylist)
+  end
+
+  def build
+    if is_master?
+      return <<-EOT.remove_extra_spaces
+        #{EXTM3U}
+        #{@line_items.map { |item| item.build }.join("\n")}
+      EOT
+    else
+      return <<-EOT.remove_extra_spaces
+        #{EXTM3U}
+        #{EXT_X_ALLOW_CACHE + ":" + @allow_cache unless @allow_cache.nil?}
+        #{EXT_X_MEDIA_SEQUENCE + ":" + @media_sequence.to_s unless @media_sequence.nil?}
+        #{EXT_X_PLAYLIST_TYPE + ":" + @playlist_type unless @playlist_type.nil?}
+        #{EXT_X_TARGETDURATION + ":" + @target_duration.to_s unless @target_duration.nil?}
+        #{EXT_X_VERSION + ":" + @version.to_s unless @version.nil?}
+        #{@line_items.map { |item| item.build }.join("\n")}
+        #{EXT_X_ENDLIST unless is_live?}
+      EOT
+    end
+  end
+
+  private
+
+  # Intelligently split by commas, ignoring any commas between "" or ''
+  def parse_csv(value)
+    from = 0
+    quote = nil
+    result = []
+    (0...value.length).each do |index|
+      char = value[index]
+      if char == "," and quote.nil?
+        result.push(value[from...index])
+        from = index + 1
+      elsif ["\"", "'"].include?(char)
+        quote = (quote.nil? ? char : (quote == char ? nil : quote))
+      end
+    end
+    result.push(value[from...value.length])
+  end
+end

data/lib/m3u8_generator.rb

@@ -0,0 +1,193 @@
+require "base64"
+require "net/http"
+require "uri"
+
+####
+#This makes sure require_relative is available in both Ruby 1.8 and 1.9
+####
+
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
+require_relative "hls_constants"
+require_relative "hls_manifest"
+require_relative "warpgate_utils"
+
+class M3U8Generator
+
+  include HLSConstants
+
+  attr_accessor :old_serving_domain
+  attr_accessor :m3u8_serving_domain
+  attr_accessor :is_serving_domain_provider_default
+
+  def build_top_level_m3u8(embed_code,
+                           streams,
+                           min_bitrate=-1,
+                           max_bitrate=1000000000,
+                           target_bitrate=nil,
+                           single_bit_rate=false,
+                           authentication_params={},
+                           captions=nil,
+                           enable_resolution_tag=false)
+
+    # Check the streams object to verify the right Stream attributes are passed in
+    streams.each do |stream|
+      stream[:average_video_bitrate]
+      stream[:muxing_format]
+      stream[:thrift_path]
+      stream[:audio_bitrate]
+      stream[:video_width]
+      stream[:video_height]
+      stream[:is_encrypted]
+    end
+
+    file_contents = EXTM3U + "\n"
+
+    if captions
+      captions.each do |caption|
+        file_contents << "#{EXT_X_MEDIA}:TYPE=SUBTITLES,GROUP-ID=\"subs\"," +
+          "NAME=\"#{caption[:language_name]}\"," +
+          "DEFAULT=#{caption[:default] ? 'YES' : 'NO'}," +
+          "FORCED=NO," +
+          "AUTOSELECT=#{caption[:autoselect] ? 'YES' : 'NO'}," +
+          "LANGUAGE=\"#{caption[:language_code]}\"," +
+          "URI=\"#{caption[:url]}\"\n"
+      end
+    end
+
+    # We might have different resolutions per bitrate, but when generating the top level m3u8, we
+    # only care about unique bitrates.
+    unique_bitrates = {}
+    filtered_streams = []
+    streams.each do |stream|
+      next if stream[:average_video_bitrate] > max_bitrate || stream[:average_video_bitrate] < min_bitrate
+      next if unique_bitrates[stream[:average_video_bitrate]]
+      unique_bitrates[stream[:average_video_bitrate]] = true
+      filtered_streams << stream
+    end
+
+    # After we filter out streams above max bitrate, let's shuffle the array and put the median first.
+    if(target_bitrate)
+      final_streams = shuffle_array_min_before_target_first(filtered_streams, target_bitrate)
+    else
+      final_streams = shuffle_array_with_median_first(filtered_streams)
+      #if possible, do not let the first stream be audio only.
+      if final_streams != nil && final_streams.length > 1 && final_streams[0][:muxing_format].upcase == 'AAC'
+        final_streams[0], final_streams[1] = final_streams[1], final_streams[0]
+      end
+    end
+
+    if single_bit_rate
+      final_streams = final_streams[0..0]
+    end
+
+    # For Adobe Access content, we have to append a link to the key in the manifest
+    streams.each do |stream|
+      if stream[:muxing_format].to_s == "TS_FA" || stream[:muxing_format].to_s == "AAC_FA"
+        file_contents << (EXT_X_FAXS_CM + ":URI=\"#{@m3u8_serving_domain}/#{embed_code}/#{embed_code}.drmmeta\"\n")
+        break
+      end
+    end
+
+    # Now build the m3u8 file.
+    final_streams.each do |stream|
+      total_bitrate = stream[:average_video_bitrate] + stream[:audio_bitrate]
+      should_append_resolution = enable_resolution_tag && stream[:muxing_format].upcase != 'AAC'
+
+      stream_info = "#{EXT_X_STREAM_INF}:PROGRAM-ID=1,BANDWIDTH=#{total_bitrate * 1000}"
+      stream_info += ",RESOLUTION=#{stream[:video_width]}x#{stream[:video_height]}" if should_append_resolution
+      stream_info += ",CODECS=\"mp4a.40.2,mp4a.40.5\"" if stream[:muxing_format].upcase == 'AAC' #add audio
+      stream_info += ",SUBTITLES=\"subs\"" if captions #add captions group
+      file_contents << stream_info + "\n"
+
+      stream_url = ""
+      if (@is_serving_domain_provider_default && !stream[:is_encrypted]) || authentication_params['secure_ios_token']
+        stream_url = "#{@old_serving_domain}/#{embed_code}_#{stream[:average_video_bitrate]}.m3u8"
+      else
+        # Prepended embed code is handled by gen_serving_domain
+        stream_url = "#{@m3u8_serving_domain}/#{stream[:thrift_path]}/#{stream[:average_video_bitrate]}_" +
+                     "#{stream[:audio_bitrate]}_#{stream[:video_width]}_#{stream[:video_height]}.m3u8"
+      end
+      WarpgateUtils.append_params(stream_url, authentication_params)
+
+      file_contents << "#{stream_url}\n"
+    end
+    file_contents
+  end
+
+  def build_bitrate_m3u8(chunks, authentication_params={})
+    file_contents = ""
+    max_chunk_length = 0
+    chunks.each do |chunk|
+      # Chunk Duration
+      file_contents << "#EXTINF:#{chunk[:chunk_length]},\n"
+      max_chunk_length = chunk[:chunk_length] if chunk[:chunk_length] > max_chunk_length
+
+      # Chunk decryption key url
+      if chunk[:key_url] && !chunk[:key_url].empty?
+        final_auth_url = WarpgateUtils.append_params(chunk[:key_url], authentication_params)
+        file_contents << "#EXT-X-KEY:METHOD=AES-128,URI=\"#{chunk[:key_url]}\"\n"
+      end
+
+      # Actual Chunk
+      file_contents << "#{chunk[:chunk_url]}\n"
+    end
+    file_contents << "#{EXT_X_ENDLIST}\n"
+    "#EXTM3U\n#EXT-X-TARGETDURATION:#{max_chunk_length}\n#EXT-X-MEDIA-SEQUENCE:0\n" + file_contents
+  end
+
+  def change_sub_m3u8_inside_master_m3u8(original_m3u8_url, sub_m3u8_domain, authentication_params={})
+    response = Net::HTTP.get(URI(original_m3u8_url))
+    hls_manifest = HLSManifest.new(response)
+    hls_manifest.line_items.each do |item|
+      next unless defined?(item.location)
+      encoded_url = Base64.encode64(item.location).gsub("\n", "")
+      new_url = "#{sub_m3u8_domain}?original_url=#{encoded_url}"
+      item.location = WarpgateUtils.append_params(new_url, authentication_params)
+    end
+    hls_manifest.build
+  end
+
+  def append_auth_to_key_url_in_m3u8(original_m3u8_url, authentication_params={})
+    response = Net::HTTP.get(URI(original_m3u8_url))
+    hls_manifest = HLSManifest.new(response)
+    hls_manifest.line_items.each do |item|
+      next unless defined?(item.key)
+      key = item.key
+      WarpgateUtils.append_params(key.uri, authentication_params) if key && key.uri
+    end
+    hls_manifest.build
+  end
+
+  def shuffle_array_min_before_target_first(array, target)
+    return array if array.nil? || array.length < 2
+    #assume a sorted array, do a binary search for closest
+    min = 0
+    max = array.length - 1
+    while min < max do
+      mid = min + (max - min) / 2
+      array[mid][:average_video_bitrate] < target.to_i ? min = mid + 1 : max = mid
+    end
+    t = array[min][:average_video_bitrate] <= target.to_i ? min : min - 1
+    t = t < 0 ? 0 : t
+    result = array.clone
+    result.delete_at(t)
+    result.unshift array[t]
+    return result
+  end
+
+  def shuffle_array_with_median_first(array)
+    return array if array.nil? || array.length < 3
+    median = array[array.length / 2]
+    result = array.clone
+    result.delete_at(array.length / 2)
+    result.unshift median
+    return result
+  end
+end

data/lib/warpgate_utils.rb

@@ -0,0 +1,27 @@
+require "base64"
+require "cgi"
+require "ooyala_encrypt"
+require "openssl"
+
+module WarpgateUtils
+  def self.hash_to_query_string(params)
+    params.map do |key, value|
+      "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"
+    end.join("&")
+  end
+
+  def self.append_params(url, params)
+    if url && params && !params.empty?
+      url << ((url.index("?") ? "&" : "?") + hash_to_query_string(params))
+    end
+
+    url
+  end
+
+  def self.generate_signature(params, key)
+    # TODO(bz): Throw this into ooyala_encrypt gem
+    digest = OpenSSL::Digest::SHA256.new
+    Base64::urlsafe_encode64(OpenSSL::HMAC.digest(digest, key,
+        OoyalaEncrypt::querystring_params_for_signature(params, [])))
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: m3u8_generator
+version: !ruby/object:Gem::Version
+  version: 0.3.4
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Chen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pathological
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ooyala HLS M3U8 Generator is capable of generating master and slave iOS
+  m3u8 files.
+email:
+- ryanc@ooyala.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hls_constants.rb
+- lib/warpgate_utils.rb
+- lib/m3u8_generator.rb
+- lib/hls_manifest.rb
+homepage: http://www.ooyala.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Ooyala HLS M3U8 Generator
+test_files: []