mediainfo 0.7.2 → 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a35ae85e3e7fa526c49c97050a6121e744f51e4db9079457d2eb5e6da5f5ca01
+  data.tar.gz: 4789c91354bcd189b99951c2cc424e5f4bdf05f18e01563487306e54cdc90bd2
+SHA512:
+  metadata.gz: 170f8c1656897087b1fceb1dc82cf63e390d466b8d721e19bd2065f62016eb5972bcff5c0018e820e68bb6b64705bd888c2c04773c13eb161abe72f318b4bb7b
+  data.tar.gz: fa98fbcadf950ac6bba432228370763fa2b069aec50ac39ff6a9c574fa6637eafdb217dded2a41045c0812c6943e0d207c91f2c2b7ff18e05aa58bbb504c0580

data/.gitignore

@@ -0,0 +1,16 @@
+Rakefile.cloud
+pkg
+.DS_Store
+.irbrc
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Changelog

@@ -1,6 +1,22 @@
-v0.7.2 More Stream Support
-- Added support for Text streams [Robert Mrasek]
-- Added support for Menu streams [Ned Campion]
+v1.0.0
+- Rewrite of foundation
+- Module name change to MediaInfo to match convention (everything else does MediaInfo with an uppercase I)
+- Readme rewrite + examples
+- Rspec for testing, all features tested + new xml to test with
+- Removal of all double quotes for single quotes, unless interpolation is needed
+- Removal of underscore method that isn't used
+- Variable name changes for readability and DRY
+- Hpricot is EOL, removing code to support it
+- Removal of all old testing, Rakefile contents
+- Every method missing exception will return nil (if the type exists)
+- New .track_types for visibility in client application
+- pull/18 (Eliminated attr_reader needing to be updated)
+- pull/12 (Eliminated need to add new Track/Streams)
+- pull/15 (URL parsing added)
+- Supports the use of <ID> element value (if integer/existent) when generating "track#"
+- Supports <extra> (Apple/iPhone video)
+- Parameter/element sanitization + conversion of string with integer/float in it to integer/float
+- Standardized attribute names under tracks & added yml file to keep track
 
 v0.7.1 Tweakage
 - Removed Mediainfo#parsed_response accessor which always returned nil after

data/GemFile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+git_source(:github) {|repo_name| "https://github.com/greatseth/#{repo_name}" }
+
+gemspec

data/LICENSE

@@ -1,18 +1,9 @@
-This program is free software. It comes without any warranty, to
-the extent permitted by applicable law. You can redistribute it
-and/or modify it under the terms of the Do What The Fuck You Want
-To Public License, Version 2, as published by Sam Hocevar. See
-http://sam.zoy.org/wtfpl/COPYING for more details.
+MIT License
 
-           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-                   Version 2, December 2004
+Copyright (c) <year> <copyright holders>
 
-Copyright (C) 2009 Seth Thomas Rasmussen
-Everyone is permitted to copy and distribute verbatim or modified
-copies of this license document, and changing it is allowed as long
-as the name is changed.
+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:
 
-           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
- 0. You just DO WHAT THE FUCK YOU WANT TO.
+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,140 @@
+# MediaInfo
+
+MediaInfo is a class wrapping [the mediainfo CLI](http://mediainfo.sourceforge.net).
+
+## Installation
+    
+    $ gem install mediainfo
+    
+## Usage
+
+#### Parsing raw XML
+    media_info = MediaInfo.from(File.open('iphone6+_video.mov.xml').read)
+#### Handling a local file
+    media_info = MediaInfo.from('~/Desktop/test.mov')
+#### Handling a URL
+    media_info = MediaInfo.from('http://techslides.com/demos/sample-videos/small.mp4')
+
+You can specify an alternate path for the MediaInfo Binary:
+    
+    ENV['MEDIAINFO_PATH'] = "/opt/local/bin/mediainfo"
+    
+Once you have an MediaInfo object, you can start inspecting tracks:
+    
+    media_info.track_types       => ['general','video','audio']
+    media_info.track_types.count => 3
+    media_info.video?            => true
+    media_info.image?            => nil
+    media_info.image.filesize    => MethodNotFound exception
+    
+When inspecting specific types of tracks, you have a couple general API options. The 
+first approach assumes one track of a given type, a common scenario in many video files, 
+for example:
+    
+    media_info.video.count    => 1
+    media_info.video.duration => 120 (seconds)
+    
+Sometimes you'll have more than one track of a given type:
+ - The first track type name, or any track type with <ID>1</ID> will not contain '1'
+       
+       
+        media_info.track_types                => ['general','video','video2','audio','other','other2']
+        media_info.track_types.count          => 5
+        media_info.video?                     => true
+        media_info.image?                     => nil
+        media_info.video.count                => 1
+        media_info.video.duration             => 29855000
+        media_info.video.display_aspect_ratio => 1.222
+        media_info.other.count                => 2
+        media_info.video2.duration            => 29855000
+
+- Note that the above automatically converts MediaInfo Strings into Time, Integer, and Float objects:
+
+
+        media_info.video.encoded_date.class         => Time
+        media_info.video2.duration.class            => Integer
+        media_info.video.display_aspect_ratio.class => Float
+    
+- Any track attribute name with "date" and matching /\d-/ will be converted using Time.parse:
+
+    
+        media_info.video.encoded_date => 2018-03-30 12:12:08 -0400
+        media_info.video.customdate   => 2016-02-10 01:00:00 -0600
+    
+- .duration and .overall_duration will be returned as milliseconds AS LONG AS the Duration and Overall_Duration match one of the expected units:
+    - h (\<Duration>15h\</Duration>) (hour)
+    - hour (\<Duration>15hour\</Duration>)
+    - mn (\<Duration>15hour 6mn\</Duration>) (minute)
+    - m (\<Duration>15hour 6m\</Duration>) (minute)
+    - min (\<Duration>15hour 6min\</Duration>) (minute)
+    - s (\<Duration>15hour 6min 59s\</Duration>) (second)
+    - sec (\<Duration>15hour 6min 59sec\</Duration>) (second)
+    - ms (\<Duration>15hour 6min 59sec 301ms\</Duration>) (milliseconds)
+    - [Submit an issue to add more!](https://github.com/greatseth/mediainfo/issues)
+    
+    
+            media_info.video.duration => 9855000 (\<Duration>15s 164ms\</Duration>)
+            media_info.video.duration => 17196000 (\<Duration>36s 286ms\</Duration>)
+
+- We standardize the naming of several Attributes:
+    - You can review lib/attribute_standardization_rules.yml to see them all
+    
+    
+            media_info.video.bitrate => "41.2 Mbps" (\<Bit_rate>41.2 Mbps\</Bit_rate>)
+            media_info.video.bit_rate => nil (\<Bit_rate>41.2 Mbps\</Bit_rate>)
+            media_info.general.filesize => "11.5 MiB" (\<File_size>11.5 MiB\</File_size>
+
+    
+In order to support all possible MediaInfo variations, you may see the following situation:
+
+    media_info.track_types => ['general','video','video5','audio','other','other2']
+    
+The track type media_info.video5 is available, but no video2, 3, and 4. This is because the MediaInfo from the video has:
+
+    <track type="Video">
+        <ID>1</ID>
+        ...
+    <track type="Video">
+        <ID>5</ID>
+        ...
+
+*The ID will take priority for labeling.* Else if no ID exists, you'll see consecutive numbering for duplicate tracks in the Media.        
+        
+Any second level attributes are also available:
+
+    MediaInfo.from('~/Desktop/test.mov').general.extra
+    => #<MediaInfo::Tracks::Attributes::Extra:0x00007fa89f13aa98
+     @com_apple_quicktime_creationdate=2018-03-30 08:12:08 -0400,
+     @com_apple_quicktime_location_iso6709="+39.0286-077.3958+095.957/",
+     @com_apple_quicktime_make="Apple",
+     @com_apple_quicktime_model=0,
+     @com_apple_quicktime_software=11.2>
+
+REXML is used as the XML parser by default. If you'd like, you can 
+configure Mediainfo to use Nokogiri instead:
+
+  * define the `MEDIAINFO_XML_PARSER` environment variable to be the 
+    name of the parser as you'd pass to a :gem or :require call. 
+    
+    e.g. `export MEDIAINFO_XML_PARSER=nokogiri`
+    
+Once you've got an instance setup, you can call numerous methods to get 
+a variety of information about a file. Some attributes may be present 
+for some files where others are not, but any supported attribute 
+should at least return `nil`.
+
+## Requirements
+
+Gem version 1.0.0 has been tested on v18.03.1
+Gem versions < 1.0.0 require at least: MediaInfoLib v0.7.25
+Gem versions <= 0.5.1 worked against MediaInfoLib v0.7.11, which did not 
+generate XML output, and is no longer supported.
+
+## Contributors
+
+* Seth Thomas Rasmussen - [http://greatseth.com](http://greatseth.com)
+* Peter Vandenberk      - [http://github.com/pvdb](http://github.com/pvdb)
+* Ned Campion           - [http://github.com/nedcampion](http://github.com/nedcampion)
+* Daniel Jagszent       - [http://github.com/d--j](http://github.com/d--j)
+* Robert Mrasek         - [http://github.com/derobo](http://github.com/derobo)
+* Nathan Pierce         - [http://github.com/NorseGaud](http://github.com/NorseGaud)

data/Rakefile

@@ -1,63 +1,6 @@
-require "rubygems"
-require "echoe"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
-class Echoe
-  def honor_gitignore!
-    self.ignore_pattern += \
-      Dir["**/.gitignore"].inject([]) do |pattern,gitignore| 
-        pattern.concat \
-          File.readlines(gitignore).
-            map    { |line| line.strip }.
-            reject { |line| "" == line }.
-            map    { |glob| 
-              d = File.dirname(gitignore)
-              d == "." ? glob : File.join(d, glob)
-            }
-      end.flatten.uniq
-  end
-end
+RSpec::Core::RakeTask.new(:spec)
 
-Echoe.new "mediainfo" do |p|
-  p.description = p.summary = "Mediainfo is a class wrapping the mediainfo CLI (http://mediainfo.sourceforge.net)"
-  p.author = "Seth Thomas Rasmussen"
-  p.email = "sethrasmussen@gmail.com"
-  p.url = "http://greatseth.github.com/mediainfo"
-  p.ignore_pattern = %w( test/**/* )
-  p.retain_gemspec = true
-  p.honor_gitignore!
-end
-
-task :rexml do
-  ENV.delete "MEDIAINFO_XML_PARSER"
-  Rake::Task[:test].invoke
-end
-
-task :hpricot do
-  ENV["MEDIAINFO_XML_PARSER"] = "hpricot"
-  Rake::Task[:test].invoke
-end
-
-task :nokogiri do
-  ENV["MEDIAINFO_XML_PARSER"] = "nokogiri"
-  Rake::Task[:test].invoke
-end
-
-# TODO This doesn't work.
-task :all => [:rexml, :nokogiri, :hpricot]
-
-
-task :fixture do
-  unless file = ENV["FILE"]
-    puts "Usage: rake mediainfo:fixture file=/path/to/file"
-    exit
-  end
-  fixture = File.expand_path "./test/fixtures/#{File.basename file}.xml"
-  system "mediainfo #{file} --Output=XML > #{fixture}"
-  if File.exist? fixture
-    puts "Generated fixture #{fixture}."
-  else
-    puts "Error generating fixture. #{fixture} not created."
-  end
-end
-
-# require 'github/pages/tasks'
+task :default => :spec

data/lib/attribute_standardization_rules.yml

@@ -0,0 +1,18 @@
+# Format:
+# 'ELEMENT_NAME_TO_CHANGE': 'WHAT IT NEEDS TO BE'
+# BitRate will become
+## Bit_rate -> Bitrate
+Bit_rate: Bitrate
+Bitrate_mode: Bitrate_mode
+Bit_rate_mode: Bitrate_mode
+Overallbitrate: Overall_bitrate
+Overall_bit_rate: Overall_bitrate
+## *_size -> *size
+File_size: Filesize
+Stream_size: Streamsize
+## Frame_rate -> Framerate
+Frame_rate: Framerate
+Frame_rate_mode: Framerate_mode
+Maximum_frame_rate: Maximum_framerate
+Displayaspectratio: Display_aspect_ratio
+Pixelaspectratio: Pixel_aspect_ratio

data/lib/mediainfo.rb

@@ -1,516 +1,104 @@
-require "forwardable"
-require "mediainfo/string"
-require "mediainfo/attr_readers"
+require 'forwardable'
+require 'net/http'
+require 'mediainfo/errors'
+require 'mediainfo/tracks'
+require 'mediainfo/string'
 
-=begin
-# Mediainfo
+module MediaInfo
 
-Mediainfo is a class wrapping [the mediainfo CLI](http://mediainfo.sourceforge.net).
-
-## Installation
-    
-    $ gem install mediainfo
-    
-## Usage
-    
-    info = Mediainfo.new "/path/to/file"
-    
-That will issue the system call to `mediainfo` and parse the output. 
-You can specify an alternate path if necessary:
-    
-    Mediainfo.path = "/opt/local/bin/mediainfo"
-    
-Once you have an info object, you can start inspecting streams and general metadata.
-    
-    info.streams.count # 2
-    info.audio?        # true
-    info.video?        # true
-    info.image?        # false
-    
-When inspecting specific types of streams, you have a couple general API options. The 
-first approach assumes one stream of a given type, a common scenario in many video files, 
-for example.
-    
-    info.video.count    # 1
-    info.audio.count    # 1
-    info.video.duration # 120 (seconds)
-    
-Sometimes you'll have more than one stream of a given type. Quicktime files can often 
-contain artifacts like this from somebody editing a more 'normal' file.
-    
-    info = Mediainfo.new "funky.mov"
-    
-    info.video?            # true
-    info.video.count       # 2
-    info.video.duration    # raises SingleStreamAPIError !
-    info.video[0].duration # 120
-    info.video[1].duration # 10
-    
-For some more usage examples, please see the very reasonable test suite accompanying the source code 
-for this library. It contains a bunch of relevant usage examples. More docs in the future.. contributions 
-*very* welcome!
-
-Moving on, REXML is used as the XML parser by default. If you'd like, you can 
-configure Mediainfo to use Hpricot or Nokogiri instead using one of 
-the following approaches:
-
-  * define the `MEDIAINFO_XML_PARSER` environment variable to be the 
-    name of the parser as you'd pass to a :gem or :require call. 
-    
-    e.g. `export MEDIAINFO_XML_PARSER=nokogiri`
-    
-  * assign to Mediainfo.xml_parser after you've loaded the gem, 
-    following the same naming conventions mentioned previously.
-    
-    e.g. `Mediainfo.xml_parser = "hpricot"`
-    
-
-Once you've got an instance setup, you can call numerous methods to get 
-a variety of information about a file. Some attributes may be present 
-for some files where others are not, but any supported attribute 
-should at least return `nil`.
-
-For a list of all possible attributes supported:
-  
-    Mediainfo.supported_attributes
-  
-## Requirements
+  # Allow user to set custom mediainfo_path with ENV['MEDIAINFO_PATH']
+  def self.location
+    ENV['MEDIAINFO_PATH'].nil? ? mediainfo_location = '/usr/local/bin/mediainfo' : mediainfo_location = ENV['MEDIAINFO_PATH']
+    raise EnvironmentError, "#{mediainfo_location} cannot be found. Are you sure mediainfo is installed?" unless ::File.exist? mediainfo_location
+    return mediainfo_location
+  end
 
-This requires at least the following version of the Mediainfo CLI:
-  
-    MediaInfo Command line,
-    MediaInfoLib - v0.7.25
-  
-Previous versions of this gem(<= 0.5.1) worked against v0.7.11, which did not 
-generate XML output, and is no longer supported.
-=end
-class Mediainfo
-  extend Forwardable
-  extend AttrReaders
-  
-  class Error < StandardError; end
-  class ExecutionError < Error; end
-  class IncompatibleVersionError < Error; end
-  class UnknownVersionError < Error; end
-  
-  def self.delegate(method_name, stream_type = nil)
-    if stream_type == :general
-      def_delegator :"@#{stream_type}_stream", method_name
+  # Allow collection of MediaInfo version details
+  def self.version
+    version ||= `#{location} --Version`[/v([\d.]+)/, 1]
+    # Ensure MediaInfo isn't buggy and returns something
+    raise UnknownVersionError, 'Unable to determine mediainfo version. ' + "We tried: #{location} --Version." +
+          'Set MediaInfo.path = \'/full/path/of/mediainfo\' if it is not in your PATH.' unless version
+    # Ensure you're not using an old version of MediaInfo
+    if version < '0.7.25'
+      raise IncompatibleVersionError, "Your version of mediainfo, #{version}, " +
+          'is not compatible with this gem. >= 0.7.25 required.'
     else
-      def_delegator :"@#{stream_type}_stream", method_name, "#{stream_type}_#{method_name}"
+      @version = version
     end
+
   end
-  
-  def self.version
-    @version ||= `#{version_command}`[/v([\d.]+)/, 1]
-  end
-  
-  def self.version_command
-    "#{path} --Version"
-  end
-  
-  # AttrReaders depends on this.
-  def self.supported_attributes; @supported_attributes ||= []; end
-  
-  SECTIONS             = [:general, :video, :audio, :image, :menu, :text]
-  NON_GENERAL_SECTIONS = SECTIONS - [:general]
-  
-  attr_reader :streams
-  
-  # Size of source file as reported by File.size.
-  # Returns nil if you haven't yet fired off the system command.
-  def size; File.size(@full_filename) if @full_filename; end
-  
-  class StreamProxy
-    def initialize(mediainfo, stream_type)
-      unless Mediainfo::SECTIONS.include? stream_type
-        raise ArgumentError, "invalid stream_type: #{stream_type.inspect}"
-      end
-      
-      @stream_type = stream_type
-      @mediainfo   = mediainfo
-      @streams     = @mediainfo.streams.select { |x| x.send("#{stream_type}?") }
-    end
-    
-    def [](id); @streams[id];  end
-    def count;  @streams.size; end
-    attr_reader :streams
-    attr_reader :stream_type
-    
-    class SingleStreamAPIError < RuntimeError; end
-    class NoStreamsForProxyError < NoMethodError; end
-    
-    def method_missing(m, *a, &b)
-      if streams.size > 1
-        raise SingleStreamAPIError, "You cannot use the single stream, convenience API on a multi-stream file."
-      else
-        if relevant_stream = streams.detect { |s| s.respond_to?(m) }
-          relevant_stream.send(m, *a, &b)
-        else
-          raise NoStreamsForProxyError, "there are no :#{stream_type} streams to send :#{m} to"
-        end
-      end
+
+  def self.xml_parser
+    ENV['MEDIAINFO_XML_PARSER'].nil? || ENV['MEDIAINFO_XML_PARSER'].to_s.strip.empty? ? xml_parser = 'rexml/document' : xml_parser = ENV['MEDIAINFO_XML_PARSER']
+    begin
+      require xml_parser
+    rescue Gem::LoadError => ex
+      raise Gem::LoadError, "Your specified XML parser, #{xml_parser.inspect}, could not be loaded: #{ex.message}"
     end
+    return xml_parser
   end
-  
-  class Stream
-    class InvalidStreamType < Mediainfo::Error; end
-    
-    def self.inherited(stream_type)
-      stream_type.extend(AttrReaders)
-      
-      def stream_type.method_added(method_name)
-        if stream_type = name[/[^:]+$/][/^(#{SECTIONS.map { |x| x.to_s.capitalize } * '|'})/]
-          stream_type.downcase! 
-          stream_type = stream_type.to_sym
+
+
+  def self.run(input = nil)
+    raise ArgumentError, 'Your input cannot be blank.' if input.nil?
+    command = "#{location} #{input} --Output=XML 2>&1"
+    raw_response = `#{command}`
+    unless $? == 0
+      raise ExecutionError, "Execution of '#{command}' failed. #{raw_response.inspect}"
+    end
+    return raw_response
+  end
+
+  def self.from(input)
+    input_guideline_message = 'Bad Input' + "\n" + "Input must be: \n" +
+        "A video or xml file location. Example: '~/videos/test_video.mov' or '~/videos/test_video.xml' \n" +
+        "A valid URL. Example: 'http://www.site.com/videofile.mov' \n" +
+        "Or MediaInfo XML \n"
+    if input # User must specify file
+      if input.include?('<?xml') # Must be first, else we could parse input (raw xml) with a URL in it and think it's a URL
+        return MediaInfo::Tracks.new(input)
+      elsif input.downcase.include?('http') || input.downcase.include?('www') # Handle Url Parsing
+        @uri = URI(input)
+        # Check if URL is valid
+        http = ::Net::HTTP.new(@uri.host,@uri.port)
+        request = Net::HTTP::Head.new(@uri.request_uri) # Only grab the Headers to be sure we don't try and download the whole file
+        response = http.request(request)
+        case response
+        when Net::HTTPOK
+          @escaped_input = URI.escape(@uri.to_s)
         else
-          raise "could not determine stream type, please report bug!"
+          raise RemoteUrlError, "HTTP call to #{input} is not working!"
         end
-        
-        Mediainfo.delegate(method_name, stream_type)
-      end
-    end
-    
-    def self.create(stream_type)
-      raise ArgumentError, "need a stream_type, received #{stream_type.inspect}" if stream_type.nil?
-      
-      stream_class_name = "#{stream_type}Stream"
-      
-      if Mediainfo.const_defined?(stream_class_name)
-        Mediainfo.const_get(stream_class_name).new(stream_type)
+      elsif input.include?('.xml')
+        return MediaInfo::Tracks.new(::File.open(input).read)
+      elsif input.include?('/')
+        @file = ::File.expand_path input # turns ~/path/to/file into /home/user/path/to/file
+        raise ArgumentError, 'You must include a file location.' if @file.nil?
+        raise ArgumentError, "need a path to a video file, #{@file} does not exist" unless ::File.exist? @file
+        @file_path = ::File.dirname  @file
+        @filename = ::File.basename @file
+        @escaped_input = @file.shell_escape_double_quotes
+        # Set variable for returned XML
       else
-        raise InvalidStreamType, "bad stream type: #{stream_type.inspect}"
+        raise ArgumentError, input_guideline_message
       end
+      return MediaInfo::Tracks.new(MediaInfo.run(@escaped_input))
+    else
+      raise ArgumentError, input_guideline_message
     end
-    
-    def initialize(stream_type)
-      raise ArgumentError, "need a stream_type, received #{stream_type.inspect}" if stream_type.nil?
-      
-      @stream_type = stream_type.downcase.to_sym
-      
-      # TODO @parsed_response is not the best name anymore, but I'm leaving it 
-      # alone to focus on refactoring the interface to the streams 
-      # before I refactor the attribute reader implementations.
-      @parsed_response = { @stream_type => {} }
-    end
-    
-    attr_reader :parsed_response
-    
-    def [](k); @parsed_response[@stream_type][k]; end
-    def []=(k,v); @parsed_response[@stream_type][k] = v; end
-    
-    Mediainfo::SECTIONS.each { |t| define_method("#{t}?") { t == @stream_type } }
   end
-  
-  class GeneralStream < Stream
-    mediainfo_attr_reader :codec_id, "Codec ID"
-    
-    mediainfo_duration_reader :duration
-    
-    mediainfo_attr_reader :format
-    mediainfo_attr_reader :format_profile
-    mediainfo_attr_reader :format_info
-    mediainfo_attr_reader :overall_bit_rate
-    mediainfo_attr_reader :writing_application
-    mediainfo_attr_reader :writing_library
-    
-    mediainfo_date_reader :mastered_date
-    mediainfo_date_reader :tagged_date
-    mediainfo_date_reader :encoded_date
-  end
-  
-  class VideoStream < Stream
-    mediainfo_attr_reader :stream_id, "ID"
-    
-    mediainfo_duration_reader :duration
-    
-    mediainfo_attr_reader :stream_size
-    mediainfo_attr_reader :bit_rate
-    mediainfo_attr_reader :nominal_bit_rate
-    
-    mediainfo_attr_reader :bit_rate_mode
-    def cbr?; video? and "Constant" == bit_rate_mode; end
-    def vbr?; video? and not cbr?; end
-
-    mediainfo_attr_reader :scan_order
-    mediainfo_attr_reader :scan_type
-    def interlaced?;  video? and "Interlaced" == scan_type; end
-    def progressive?; video? and not interlaced? end
-
-    mediainfo_int_reader :resolution
-
-    mediainfo_attr_reader :colorimetry
-    alias_method :colorspace, :colorimetry
-
-    mediainfo_attr_reader :format
-    mediainfo_attr_reader :format_info
-    mediainfo_attr_reader :format_profile
-    mediainfo_attr_reader :format_version
-    mediainfo_attr_reader :format_settings_cabac, "Format settings, CABAC"
-    mediainfo_attr_reader :format_settings_reframes, "Format settings, ReFrames"
-    mediainfo_attr_reader :format_settings_matrix, "Format settings, Matrix"
-    # Format settings, BVOP            : Yes
-    # Format settings, QPel            : No
-    # Format settings, GMC             : No warppoints
-    # mediainfo_attr_reader :format_settings_qpel, "Format settings, QPel"
-    mediainfo_attr_reader :color_primaries
-    mediainfo_attr_reader :transfer_characteristics
-    mediainfo_attr_reader :matrix_coefficients
 
-    mediainfo_attr_reader :codec_id, "Codec ID"
-    mediainfo_attr_reader :codec_info, "Codec ID/Info"
-    alias_method :codec_id_info, :codec_info
 
-    mediainfo_attr_reader :frame_rate
-    def fps; frame_rate[/[\d.]+/].to_f if frame_rate; end
-    alias_method :framerate, :fps
-
-    mediainfo_attr_reader :minimum_frame_rate
-    def min_fps; minimum_frame_rate[/[\d.]+/].to_f if video?; end
-    alias_method :min_framerate, :min_fps
-
-    mediainfo_attr_reader :maximum_frame_rate
-    def max_fps; maximum_frame_rate[/[\d.]+/].to_f if video?; end
-    alias_method :max_framerate, :max_fps
-
-    mediainfo_attr_reader :frame_rate_mode
-
-    mediainfo_attr_reader :display_aspect_ratio
-    # alias_method :display_aspect_ratio, :display_aspect_ratio
-
-    mediainfo_attr_reader :bits_pixel_frame, "Bits/(Pixel*Frame)"
-
-    mediainfo_int_reader :width
-    mediainfo_int_reader :height
-
-    def frame_size; "#{width}x#{height}" if width or height; end
-
-    mediainfo_date_reader :encoded_date
-    mediainfo_date_reader :tagged_date
-    
-    mediainfo_attr_reader :standard
-  end
-  
-  class AudioStream < Stream
-    mediainfo_attr_reader :stream_id, "ID"
-    
-    mediainfo_duration_reader :duration
-    
-    mediainfo_attr_reader :sampling_rate
-    def sample_rate
-      return unless rate = sampling_rate_before_type_cast
-      number = rate.gsub(/[^\d.]+/, "").to_f
-      number = case rate
-      when /KHz/ then number * 1000
-      when /Hz/  then number
-      else
-        raise "unhandled sample rate! please report bug!"
-      end
-      number.to_i
+  def self.set_singleton_method(object,name,parameters)
+    # Handle parameters with invalid characters (instance_variable_set throws error)
+    name.gsub!('.','_') if name.include?('.') ## period in name
+    name.downcase!
+    # Create singleton_method
+    object.instance_variable_set("@#{name}",parameters)
+    object.define_singleton_method name do
+      object.instance_variable_get "@#{name}"
     end
-    alias_method :sampling_rate, :sample_rate
-
-    mediainfo_attr_reader :stream_size
-    mediainfo_attr_reader :bit_rate
-    mediainfo_attr_reader :bit_rate_mode
-    mediainfo_attr_reader :interleave_duration, "Interleave, duration"
-
-    mediainfo_int_reader :resolution
-    alias_method :sample_bit_depth, :resolution
-
-    mediainfo_attr_reader :format
-    mediainfo_attr_reader :format_profile
-    mediainfo_attr_reader :format_version
-    mediainfo_attr_reader :format_info, "Format/Info"
-    mediainfo_attr_reader :format_settings_sbr, "Format settings, SBR"
-    mediainfo_attr_reader :format_settings_endianness, "Format settings, Endianness"
-    mediainfo_attr_reader :format_settings_sign, "Format settings, Sign"
-    mediainfo_attr_reader :codec_id, "Codec ID"
-    mediainfo_attr_reader :codec_info, "Codec ID/Info"
-    mediainfo_attr_reader :codec_id_hint
-    mediainfo_attr_reader :channel_positions
-
-    mediainfo_int_reader :channels, "Channel(s)"
-    def stereo?; 2 == channels; end
-    def mono?;   1 == channels; end
-
-    mediainfo_date_reader :encoded_date
-    mediainfo_date_reader :tagged_date
-  end
-  
-  class ImageStream < Stream
-    mediainfo_attr_reader :resolution
-    mediainfo_attr_reader :format
-    
-    mediainfo_int_reader :width
-    mediainfo_int_reader :height
-   
-    def frame_size; "#{width}x#{height}" if width or height; end
   end
 
-  class TextStream < Stream
-    mediainfo_attr_reader :stream_id, "ID"
-    mediainfo_attr_reader :format
-    mediainfo_attr_reader :codec_id, "Codec ID"
-    mediainfo_attr_reader :codec_info, "Codec ID/Info"
-  end
-  
-  class MenuStream < Stream
-    mediainfo_attr_reader :stream_id, "ID"
-    mediainfo_date_reader :encoded_date
-    mediainfo_date_reader :tagged_date
-    mediainfo_int_reader :delay
-  end
-  
-  Mediainfo::SECTIONS.each do |stream_type|
-    class_eval %{
-      def #{stream_type}; @#{stream_type}_proxy ||= StreamProxy.new(self, :#{stream_type}); end
-      def #{stream_type}?; streams.any? { |x| x.#{stream_type}? }; end
-    }, __FILE__, __LINE__
-  end
-  
-  ###
-  
-  attr_reader :raw_response, :full_filename, :filename, :path, :escaped_full_filename
-  
-  ###
-  
-  def initialize(full_filename = nil)
-    unless mediainfo_version
-      raise UnknownVersionError,
-        "Unable to determine mediainfo version. " +
-        "We tried: #{self.class.version_command} " +
-        "Are you sure mediainfo is installed at #{self.class.path.inspect}? " + 
-        "Set Mediainfo.path = /where/is/mediainfo if it is not in your PATH."
-    end
-    
-    if mediainfo_version < "0.7.25"
-      raise IncompatibleVersionError,
-        "Your version of mediainfo, #{mediainfo_version}, " +
-        "is not compatible with this gem. >= 0.7.25 required."
-    end
-    
-    @streams = []
-    
-    if full_filename
-      @full_filename = File.expand_path full_filename
-      @path          = File.dirname  @full_filename
-      @filename      = File.basename @full_filename
-      
-      raise ArgumentError, "need a path to a video file, got nil" unless @full_filename
-      raise ArgumentError, "need a path to a video file, #{@full_filename} does not exist" unless File.exist? @full_filename
-      
-      @escaped_full_filename = @full_filename.shell_escape_double_quotes
-      
-      self.raw_response = mediainfo!
-    end
-  end
-  
-  def raw_response=(response)
-    raise ArgumentError, "raw response is nil" if response.nil?
-    @raw_response = response
-    parse!
-    @raw_response
-  end
-  
-  class << self
-    attr_accessor :path
-    
-    def load_xml_parser!(parser = xml_parser)
-      begin
-        gem     parser
-        require parser
-      rescue Gem::LoadError => e
-        raise Gem::LoadError,
-          "your specified XML parser, #{parser.inspect}, could not be loaded: #{e}"
-      end
-    end
-    
-    attr_reader :xml_parser
-    def xml_parser=(parser)
-      load_xml_parser! parser
-      @xml_parser = parser
-    end
-  end
-  
-  unless ENV["MEDIAINFO_XML_PARSER"].to_s.strip.empty?
-    self.xml_parser = ENV["MEDIAINFO_XML_PARSER"]
-  end
-  
-  def path; self.class.path; end
-  def xml_parser; self.class.xml_parser; end
-  
-  def self.default_mediainfo_path!; self.path = "mediainfo"; end
-  default_mediainfo_path! unless path
-  
-  def mediainfo_version; self.class.version; end
-  
-  attr_reader :last_command
-  
-  def inspect
-    super.sub(/@raw_response=".+?", @/, %{@raw_response="...", @})
-  end
-  
-  private
-  def mediainfo!
-    @last_command = "#{path} #{@escaped_full_filename} --Output=XML"
-    run_command!
-  end
-  
-  def run_command!
-    raw_response = `#{@last_command} 2>&1`
-    unless $? == 0
-      raise ExecutionError,
-        "Execution of `#{@last_command}` failed: #{raw_response.inspect}"
-    end
-    raw_response
-  end
-  
-  def parse!
-    if xml_parser
-      self.class.load_xml_parser!
-    else
-      require "rexml/document"
-    end
-    
-    case xml_parser
-    when "nokogiri"
-      Nokogiri::XML(@raw_response).xpath("//track").each { |t|
-        s = Stream.create(t['type'])
-        t.xpath("*").each do |c|
-          s[key_for(c)] = c.content.strip
-        end
-        @streams << s
-      }
-    when "hpricot"
-      Hpricot::XML(@raw_response).search("track").each { |t|
-        s = Stream.create(t['type'])
-        t.children.select { |n| n.is_a? Hpricot::Elem }.each do |c|
-          s[key_for(c)] = c.inner_html.strip
-        end
-        @streams << s
-      }
-    else
-      REXML::Document.new(@raw_response).elements.each("/Mediainfo/File/track") { |t|
-        s = Stream.create(t.attributes['type'])
-        t.children.select { |n| n.is_a? REXML::Element }.each do |c|
-          s[key_for(c)] = c.text.strip
-        end
-        @streams << s
-      }
-    end
-    
-    SECTIONS.each do |section|
-      default_target_stream = if send("#{section}?")
-        send(section).streams.first
-      else
-        Mediainfo.const_get("#{section.to_s.capitalize}Stream").new(section.to_s.capitalize)
-      end
-      instance_variable_set "@#{section}_stream", default_target_stream
-    end
-  end
-  
-  def key_for(attribute_node)
-    attribute_node.name.downcase.gsub(/_+/, "_").gsub(/_s(\W|$)/, "s").strip
-  end
-end
+end # end Module