wmainfo-rb 0.4 → 0.5

data/README

@@ -35,5 +35,6 @@ For more/different documentation see http://badcomputer.org/unix/code/wmainfo/
 
  == Thanks/Contributors == 
 
-Ilmari Heikkinen sent in a fix for uninitialized '@ext_info'
+Ilmari Heikkinen sent in a fix for uninitialized '@ext_info'.
+Guillaume Pierronnet sent in a patch which improves character encoding handling.
 

data/lib/wmainfo.rb

@@ -1,6 +1,6 @@
 # = Description
 #
-# wmainfo-ruby gives you access to low level information on wma/wmv files.
+# wmainfo-ruby gives you access to low level information on wma/wmv/asf files.
 # * It identifies all "ASF_..." objects and shows each objects size
 # * It returns info such as bitrate, size, length, creation date etc
 # * It returns meta-tags from ASF_Content_Description_Object
@@ -10,14 +10,17 @@
 # I wrestled with the ASF spec (150 page .doc format!) with no joy for
 # a while, then found Dan Sully's Audio-WMA Perl module:
 # (http://cpants.perl.org/dist/Audio-WMA :: http://www.slimdevices.com/)
-# This entire library is essentially a translation of WMA.pm
+# This entire library is essentially a translation of (parts of) WMA.pm
 # to Ruby. All credit for the hard work is owed to Dan...
 #
 # License:: Ruby
 # Author:: Darren Kirby (mailto:bulliver@badcomputer.org)
 # Website:: http://badcomputer.org/unix/code/wmainfo/
 
-# TODO: Get rid of all the CamelCase
+# Improved character encoding handling thanks to
+# Guillaume Pierronnet <guillaume.pierronnet @nospam@ gmail.com>
+
+require 'iconv'
 
 # raised when errors occur parsing wma header
 class WmaInfoError < StandardError
@@ -25,23 +28,24 @@ end
 
 class WmaInfo
   # WmaInfo.tags and WmaInfo.info are hashes of NAME=VALUE pairs
-  # WmaInfo.headerObject is a hash of arrays
-  attr_reader :tags, :headerObject, :info, :stream
-  def initialize(file, debug=nil)
+  # WmaInfo.header_object is a hash of arrays
+  attr_reader :tags, :header_object, :info, :stream
+  def initialize(file, opts = {})
     @drm = nil
     @tags = {}
-    @headerObject = {}
+    @header_object = {}
     @info = {}
     @ext_info = {}
     @file = file
-    @debug = debug
-    parseWmaHeader
+    @debug = opts[:debug]
+    @ic = Iconv.new(opts[:encoding] || "ASCII", "UTF-16LE")
+    parse_wma_header
   end
 
   # for ASF_Header_Object prints: "name: GUID size num_objects"
   # for others, prints: "name: GUID size offset"
   def print_objects
-    @headerObject.each_pair do |key,val|
+    @header_object.each_pair do |key,val|
       puts "#{key}: #{val[0]} #{val[1]} #{val[2]}"
     end
   end
@@ -77,8 +81,8 @@ class WmaInfo
   def parse_stream
     begin
       @stream = {}
-      offset = @headerObject['ASF_Stream_Properties_Object'][2]
-      parseASFStreamPropertiesObject(offset)
+      offset = @header_object['ASF_Stream_Properties_Object'][2]
+      parse_asf_stream_properties_object(offset)
     rescue
       raise WmaInfoError, "Cannot grok ASF_Stream_Properties_Object", caller
     end
@@ -94,7 +98,7 @@ class WmaInfo
   #  This cleans up the output when using WmaInfo in irb
   def inspect #:nodoc:
     s = "#<#{self.class}:0x#{(self.object_id*2).to_s(16)} "
-    @headerObject.each_pair do |k,v|
+    @header_object.each_pair do |k,v|
       s += "(#{k.upcase} size=#{v[1]} offset=#{v[2]}) " unless k == "ASF_Header_Object"
     end
     s += "\b>"
@@ -102,80 +106,78 @@ class WmaInfo
   #++
 
   private
-  def parseWmaHeader
+  def parse_wma_header
     @size = File.size(@file)
     @fh = File.new(@file, "rb")
     @offset = 0
-    @fileOffset = 30
-    @guidMapping = knownGUIDs
-    @reverseGuidMapping = @guidMapping.invert
-    require 'iconv'
-    @ic = Iconv.new("ASCII//IGNORE", "UTF-16LE")
+    @file_offset = 30
+    @guid_mapping = known_guids
+    @reverse_guid_mapping = @guid_mapping.invert
 
     # read first 30 bytes and parse ASF_Header_Object
     begin
-      objectId      = byteStringToGUID(@fh.read(16))
-      objectSize    = @fh.read(8).unpack("V")[0]
-      headerObjects = @fh.read(4).unpack("V")[0]
-      reserved1     = @fh.read(1).unpack("b*")[0]
-      reserved2     = @fh.read(1).unpack("b*")[0]
-      objectIdName  = @reverseGuidMapping[objectId]
+      object_id       = byte_string_to_guid(@fh.read(16))
+      object_size     = @fh.read(8).unpack("V")[0]
+      header_objects  = @fh.read(4).unpack("V")[0]
+      reserved1       = @fh.read(1).unpack("b*")[0]
+      reserved2       = @fh.read(1).unpack("b*")[0]
+      object_id_name  = @reverse_guid_mapping[object_id]
     rescue
       # not getting raised when fed a non-wma file
-      # objectSize must be getting value because
+      # object_size must be getting value because
       # "Header size reported larger than file size"
       # gets raised instead?
       raise WmaInfoError, "Not a wma header", caller
     end
 
-    if objectSize > @size
+    if object_size > @size
       raise WmaInfoError, "Header size reported larger than file size", caller
     end
 
-    @headerObject[objectIdName] = [objectId,  objectSize, headerObjects, reserved1, reserved2]
+    @header_object[object_id_name] = [object_id,  object_size, header_objects, reserved1, reserved2]
 
     if @debug
-      puts "objectId:      #{objectId}"
-      puts "objectIdName:  #{@reverseGuidMapping[objectId]}"
-      puts "objectSize:    #{objectSize}"
-      puts "headerObjects: #{headerObjects}"
-      puts "reserved1:     #{reserved1}"
-      puts "reserved2:     #{reserved2}"
+      puts "object_id:       #{object_id}"
+      puts "object_id_name:  #{@reverse_guid_mapping[object_id]}"
+      puts "object_size:     #{object_size}"
+      puts "header_objects:  #{header_objects}"
+      puts "reserved1:       #{reserved1}"
+      puts "reserved2:       #{reserved2}"
     end
 
-    @headerData = @fh.read(objectSize - 30)
+    @header_data = @fh.read(object_size - 30)
     @fh.close
-    headerObjects.times do
-      nextObject     = readAndIncrementOffset(16)
-      nextObjectText = byteStringToGUID(nextObject)
-      nextObjectSize = parse64BitString(readAndIncrementOffset(8))
-      nextObjectName = @reverseGuidMapping[nextObjectText];
+    header_objects.times do
+      next_object      = read_and_increment_offset(16)
+      next_object_text = byte_string_to_guid(next_object)
+      next_object_size = parse_64bit_string(read_and_increment_offset(8))
+      next_object_name = @reverse_guid_mapping[next_object_text];
 
-      @headerObject[nextObjectName] = [nextObjectText, nextObjectSize, @fileOffset]
-      @fileOffset += nextObjectSize
+      @header_object[next_object_name] = [next_object_text, next_object_size, @file_offset]
+      @file_offset += next_object_size
 
       if @debug
-        puts "nextObjectGUID: #{nextObjectText}"
-        puts "nextObjectName: #{nextObjectName}"
-        puts "nextObjectSize: #{nextObjectSize}"
+        puts "next_objectGUID: #{next_object_text}"
+        puts "next_object_name: #{next_object_name}"
+        puts "next_object_size: #{next_object_size}"
       end
 
       # start looking at object contents
-      if nextObjectName == 'ASF_File_Properties_Object'
-        parseASFFilePropertiesObject
+      if next_object_name == 'ASF_File_Properties_Object'
+        parse_asf_file_properties_object
         next
-      elsif nextObjectName == 'ASF_Content_Description_Object'
-        parseASFContentDescriptionObject
+      elsif next_object_name == 'ASF_Content_Description_Object'
+        parse_asf_content_description_object
         next
-      elsif nextObjectName == 'ASF_Extended_Content_Description_Object'
-        parseASFExtendedContentDescriptionObject
+      elsif next_object_name == 'ASF_Extended_Content_Description_Object'
+        parse_asf_extended_content_description_object
         next
-      elsif nextObjectName == 'ASF_Content_Encryption_Object' || nextObjectName == 'ASF_Extended_Content_Encryption_Object'
-        parseASFContentEncryptionObject
+      elsif next_object_name == 'ASF_Content_Encryption_Object' || next_object_name == 'ASF_Extended_Content_Encryption_Object'
+        parse_asf_content_encryption_object
       end
 
       # set our next object size
-      @offset += nextObjectSize - 24
+      @offset += next_object_size - 24
     end
 
     # meta-tag like values go to 'tags' all others to 'info'
@@ -191,23 +193,23 @@ class WmaInfo
     @tags.delete_if { |k,v| v == "" || v == nil }
   end
 
-  def parseASFContentEncryptionObject 
+  def parse_asf_content_encryption_object 
     @drm = 1
   end
 
-  def parseASFFilePropertiesObject
-    fileid                      = readAndIncrementOffset(16)
-    @info['fileid_guid']        = byteStringToGUID(fileid)
-    @info['filesize']           = parse64BitString(readAndIncrementOffset(8))
-    @info['creation_date']      = readAndIncrementOffset(8).unpack("Q")[0]
-    @info['creation_date_unix'] = fileTimeToUnixTime(@info['creation_date'])
+  def parse_asf_file_properties_object
+    fileid                      = read_and_increment_offset(16)
+    @info['fileid_guid']        = byte_string_to_guid(fileid)
+    @info['filesize']           = parse_64bit_string(read_and_increment_offset(8))
+    @info['creation_date']      = read_and_increment_offset(8).unpack("Q")[0]
+    @info['creation_date_unix'] = file_time_to_unix_time(@info['creation_date'])
     @info['creation_string']    = Time.at(@info['creation_date_unix'].to_i)
-    @info['data_packets']       = readAndIncrementOffset(8).unpack("V")[0]
-    @info['play_duration']      = parse64BitString(readAndIncrementOffset(8))
-    @info['send_duration']      = parse64BitString(readAndIncrementOffset(8))
-    @info['preroll']            = readAndIncrementOffset(8).unpack("V")[0]
+    @info['data_packets']       = read_and_increment_offset(8).unpack("V")[0]
+    @info['play_duration']      = parse_64bit_string(read_and_increment_offset(8))
+    @info['send_duration']      = parse_64bit_string(read_and_increment_offset(8))
+    @info['preroll']            = read_and_increment_offset(8).unpack("V")[0]
     @info['playtime_seconds']   = (@info['play_duration'] / 10000000) - (@info['preroll'] / 1000)
-    flags_raw                   = readAndIncrementOffset(4).unpack("V")[0]
+    flags_raw                   = read_and_increment_offset(4).unpack("V")[0]
     if flags_raw & 0x0001 == 0
       @info['broadcast']        = 0
     else
@@ -218,9 +220,9 @@ class WmaInfo
     else
       @info['seekable']         = 1
     end
-    @info['min_packet_size']    = readAndIncrementOffset(4).unpack("V")[0]
-    @info['max_packet_size']    = readAndIncrementOffset(4).unpack("V")[0]
-    @info['max_bitrate']        = readAndIncrementOffset(4).unpack("V")[0]
+    @info['min_packet_size']    = read_and_increment_offset(4).unpack("V")[0]
+    @info['max_packet_size']    = read_and_increment_offset(4).unpack("V")[0]
+    @info['max_bitrate']        = read_and_increment_offset(4).unpack("V")[0]
     @info['bitrate']            = @info['max_bitrate'] / 1000
 
     if @debug
@@ -229,36 +231,36 @@ class WmaInfo
 
   end
 
-  def parseASFContentDescriptionObject
+  def parse_asf_content_description_object
     lengths = {}
     keys = %w/Title Author Copyright Description Rating/
     keys.each do |key| # read the lengths of each key
-      lengths[key] = readAndIncrementOffset(2).unpack("v")[0]
+      lengths[key] = read_and_increment_offset(2).unpack("v")[0]
     end
     keys.each do |key| # now pull the data based on length
-      @tags[key] = decodeBinaryString(readAndIncrementOffset(lengths[key]))
+      @tags[key] = decode_binary_string(read_and_increment_offset(lengths[key]))
     end
   end
 
-  def parseASFExtendedContentDescriptionObject
+  def parse_asf_extended_content_description_object
     @ext_info = {}
-    @ext_info['content_count'] = readAndIncrementOffset(2).unpack("v")[0]
+    @ext_info['content_count'] = read_and_increment_offset(2).unpack("v")[0]
     @ext_info['content_count'].times do |n|
       ext = {}
       ext['base_offset']  = @offset + 30
-      ext['name_length']  = readAndIncrementOffset(2).unpack("v")[0]
-      ext['name']         = decodeBinaryString(readAndIncrementOffset(ext['name_length']))
-      ext['value_type']   = readAndIncrementOffset(2).unpack("v")[0]
-      ext['value_length'] = readAndIncrementOffset(2).unpack("v")[0]
+      ext['name_length']  = read_and_increment_offset(2).unpack("v")[0]
+      ext['name']         = decode_binary_string(read_and_increment_offset(ext['name_length']))
+      ext['value_type']   = read_and_increment_offset(2).unpack("v")[0]
+      ext['value_length'] = read_and_increment_offset(2).unpack("v")[0]
 
-      value = readAndIncrementOffset(ext['value_length'])
+      value = read_and_increment_offset(ext['value_length'])
       if ext['value_type'] <= 1
-        ext['value'] = decodeBinaryString(value)
+        ext['value'] = decode_binary_string(value)
       elsif ext['value_type'] == 4
-        ext['value'] = parse64BitString(value)
+        ext['value'] = parse_64bit_string(value)
       else
-        valTypeTemplates = ["", "", "V", "V", "", "v"]
-        ext['value'] = value.unpack(valTypeTemplates[ext['value_type']])[0]
+        value_type_template = ["", "", "V", "V", "", "v"]
+        ext['value'] = value.unpack(value_type_template[ext['value_type']])[0]
       end
 
       if @debug
@@ -274,35 +276,35 @@ class WmaInfo
     end
   end
 
-  def parseASFStreamPropertiesObject(offset)
+  def parse_asf_stream_properties_object(offset)
     @offset = offset - 6 # gained an extra 6 bytes somewhere?!
 
-    streamType                    = readAndIncrementOffset(16)
-    @stream['stream_type_guid']   = byteStringToGUID(streamType)
-    @stream['stream_type_name']   = @reverseGuidMapping[@stream['stream_type_guid']]
-    errorType                     = readAndIncrementOffset(16)
-    @stream['error_correct_guid'] = byteStringToGUID(errorType)
-    @stream['error_correct_name'] = @reverseGuidMapping[@stream['error_correct_guid']]
-
-    @stream['time_offset']        = readAndIncrementOffset(8).unpack("4v")[0]
-    @stream['type_data_length']   = readAndIncrementOffset(4).unpack("2v")[0]
-    @stream['error_data_length']  = readAndIncrementOffset(4).unpack("2v")[0]
-    flags_raw                     = readAndIncrementOffset(2).unpack("v")[0]
+    streamType                    = read_and_increment_offset(16)
+    @stream['stream_type_guid']   = byte_string_to_guid(streamType)
+    @stream['stream_type_name']   = @reverse_guid_mapping[@stream['stream_type_guid']]
+    errorType                     = read_and_increment_offset(16)
+    @stream['error_correct_guid'] = byte_string_to_guid(errorType)
+    @stream['error_correct_name'] = @reverse_guid_mapping[@stream['error_correct_guid']]
+
+    @stream['time_offset']        = read_and_increment_offset(8).unpack("4v")[0]
+    @stream['type_data_length']   = read_and_increment_offset(4).unpack("2v")[0]
+    @stream['error_data_length']  = read_and_increment_offset(4).unpack("2v")[0]
+    flags_raw                     = read_and_increment_offset(2).unpack("v")[0]
     @stream['stream_number']      = flags_raw & 0x007F
     @stream['encrypted']          = flags_raw & 0x8000
 
-    #  reserved - set to zero
-    readAndIncrementOffset(4)
+    # reserved - set to zero
+    read_and_increment_offset(4)
 
-    @stream['type_specific_data'] = readAndIncrementOffset(@stream['type_data_length'])
-    @stream['error_correct_data'] = readAndIncrementOffset(@stream['error_data_length'])
+    @stream['type_specific_data'] = read_and_increment_offset(@stream['type_data_length'])
+    @stream['error_correct_data'] = read_and_increment_offset(@stream['error_data_length'])
 
     if @stream['stream_type_name'] == 'ASF_Audio_Media'
-      parseASFAudioMediaObject
+      parse_asf_audio_media_object
     end
   end
 
-  def parseASFAudioMediaObject
+  def parse_asf_audio_media_object
     data = @stream['type_specific_data'][0...16]
     @stream['audio_channels']        = data[2...4].unpack("v")[0]
     @stream['audio_sample_rate']     = data[4...8].unpack("2v")[0]
@@ -310,19 +312,18 @@ class WmaInfo
     @stream['audio_bits_per_sample'] = data[14...16].unpack("v")[0]
   end
 
-  # UTF16LE -> ASCII ... am still not happy with this
-  def decodeBinaryString(data)
-    textString = @ic.iconv(data[0, data.length / 2 * 2] + "\000\000")[0..-2]
-    textString.sub!(/\x00$/, '')
+  # UTF16LE -> ASCII
+  def decode_binary_string(data)
+    @ic.iconv(data).strip
   end
 
-  def readAndIncrementOffset(size)
-    value = @headerData[@offset..(@offset + size)]
+  def read_and_increment_offset(size)
+    value = @header_data[@offset...(@offset + size)]
     @offset += size
     return value
   end
 
-  def byteStringToGUID(byteString)
+  def byte_string_to_guid(byteString)
     guidString  = sprintf("%02X", byteString[3])
     guidString += sprintf("%02X", byteString[2])
     guidString += sprintf("%02X", byteString[1])
@@ -345,17 +346,17 @@ class WmaInfo
     guidString += sprintf("%02X", byteString[15])
   end
 
-  def parse64BitString(data)
+  def parse_64bit_string(data)
     d = data.unpack('VV')
     d[1] * 2 ** 32 + d[0]
   end
 
-  def fileTimeToUnixTime(time)
+  def file_time_to_unix_time(time)
     (time - 116444736000000000) / 10000000
   end
 
-  def knownGUIDs
-    guidMapping = {
+  def known_guids
+    guid_mapping = {
         'ASF_Extended_Stream_Properties_Object'   => '14E6A5CB-C672-4332-8399-A96952065B5A',
         'ASF_Padding_Object'                      => '1806D474-CADF-4509-A4BA-9AABCB96AAE8',
         'ASF_Payload_Ext_Syst_Pixel_Aspect_Ratio' => '1B1EE554-F9EA-4BC8-821A-376B74E4C4B8',

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: wmainfo-rb
 version: !ruby/object:Gem::Version 
-  version: "0.4"
-date: 2007-10-09 00:00:00 -06:00
+  version: "0.5"
+date: 2008-03-18 00:00:00 -06:00
 summary: Pure Ruby lib for accessing info/tags from wma/wmv files
 require_paths: 
 - lib