ruby-cafinfo 0.1

data/CHANGELOG

@@ -0,0 +1,3 @@
+=== 0.1 / 2009-03-12
+
+* initial release: contains basic support for audio_description, data, free and magick cookie chunks.

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2009 Oleguer Huguet Ibars
+
+The 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

@@ -0,0 +1,76 @@
+ruby-cafinfo
+
+by Oleguer Huguet Ibars
+* http://rubyforge.org/projects/ruby-cafinfo
+* git repository: git://rubyforge.org/ruby-cafinfo.git
+
+== DESCRIPTION:
+
+A ruby library to retrieve information of CAF (Core Audio Format) files, heavily inspired by the excellent ruby-mp3info[http://ruby-mp3info.rubyforge.org/].
+
+From the CAF format specification:
+
+"Apple's Core Audio Format (CAF) is a file format for storing and transporting digital
+audio data. It simplifies the management and manipulation of many types of audio data
+without the file-size limitations of other audio file formats."
+
+Specs for CAF format can be found here[http://developer.apple.com/DOCUMENTATION/MusicAudio/Reference/CAFSpec/CAF_intro/CAF_intro.html].
+
+== FEATURES:
+
+* written in pure ruby
+* read low-level informations like bitrate, length, samplerate, etc...
+* only some chunk types are recognized (Audio Description, Data, Free, Magick Cookie)
+
+== SYNOPSIS:
+
+Using as a lib is easy:
+
+  require "cafinfo"
+  # read and display info
+  CafInfo.open("myfile.caf") do |cafinfo|
+    puts cafinfo
+  end
+
+  # read and display some attributes
+  CafInfo.open("myfile.caf") do |caf|
+    puts caf.length
+    puts caf.samplerate
+    puts caf.format
+  end
+
+  # extract payload audio data from a (small) CAF and write to another file
+  audio_pos, audio_length = CafInfo.open("myfile.caf") { |caf| caf.audio_content }
+  File.open("myfile.caf", "rb") do |caf_file|
+    File.open("myaudio.data", "wb") do |f|
+      caf_file.seek(audio_pos)
+      data = caf_file.read(audio_length)
+      f.write(data)
+    end
+  end
+
+  # extract payload audio data from an arbitrarily large CAF and write
+  # to another file, considering that data chunk may not be at the end
+  # of caf file
+  audio_pos, audio_length = CafInfo.open("myfile.caf") { |caf| caf.audio_content }
+  File.open("myfile.caf", "rb") do |caf_file|
+    File.open("myaudio-buffered.data", "wb") do |f|
+      caf_file.seek(audio_pos)
+      while buffer = caf_file.read([4096, audio_length].min) and buffer.size > 0
+        f.write(buffer)
+        audio_length -= buffer.size
+      end
+    end
+  end
+
+== INSTALL:
+
+ # gem install ruby-cafinfo
+
+== LICENSE:
+
+MIT license
+
+== TODO:
+
+* support for other chunk types

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'ruby-cafinfo'
+  s.version = '0.1'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README', 'LICENSE', 'CHANGELOG']
+  s.summary = 'ruby-cafinfo is a ruby library to retrieve low level informations on CAF files'
+  s.description = s.summary
+  s.author = 'Oleguer Huguet Ibars'
+  s.email = 'olegueret@rubyforge.org'
+  # s.executables = ['your_executable_here']
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+  s.require_path = "lib"
+  #s.bindir = "bin"
+  s.add_dependency 'float-formats', '>=0.1.1'
+  s.rubyforge_project = 'ruby-cafinfo'
+  s.homepage = 'http://ruby-cafinfo.rubyforge.org'
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'CHANGELOG', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "ruby-cafinfo Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/lib/caf/chunk.rb

@@ -0,0 +1,15 @@
+require 'caf/chunk/base'
+
+module Caf
+  module Chunk
+    def self.available_chunk_types
+      @available_chunk_types ||= {}
+    end
+
+    def self.build(chunk_header)
+      klass = available_chunk_types[(chunk_header[:chunk_type] || "").downcase]
+      klass = Base if klass.nil?
+      klass.new(chunk_header)
+    end
+  end
+end

data/lib/caf/chunk/audio_description.rb

@@ -0,0 +1,57 @@
+require 'caf/chunk/base'
+require 'caf/chunk/helper'
+require 'caf/errors'
+
+module Caf::Chunk
+  include Helper
+  
+  class AudioDescription < Base
+  
+    implements 'desc'
+
+    attr_accessor :samplerate, :format_id, :format_flags, :bytes_per_packet,
+      :frames_per_packet, :channels_per_frame, :bits_per_channel
+
+    def initialize(chunk_header)
+      super chunk_header
+    end
+
+    def to_s
+      "#{chunk_type} (audio description chunk):\n"+
+        " -samplerate:         #{samplerate}\n"+
+        " -format ID:          #{format_id}\n"+
+        " -format flags:       #{format_flags}\n"+
+        " -bytes per packet:   #{bytes_per_packet}\n"+
+        " -frames per packet:  #{frames_per_packet}\n"+
+        " -channels per frame: #{channels_per_frame}\n"+
+        " -bits per channel:   #{bits_per_channel}\n"
+    end
+
+    def validate
+      raise(Caf::Error, "invalid audio description chunk: sample rate cannot be 0") if samplerate == 0
+      raise(Caf::Error, "invalid audio description chunk: format ID cannot be 0") if format_id == 0
+      raise(Caf::Error, "invalid audio description chunk: channels per frame cannot be 0") if channels_per_frame == 0
+    end
+
+    def fields_size
+      32
+    end
+
+    def read_data(file)
+      data = file.read(self.fields_size)
+      raise(Caf::Error, "chunk data too short: #{self}") if file.eof?
+
+      @samplerate        = Helper.read_double(data)
+      @format_id          = Helper.read_chars(4, data, 8)
+      @format_flags       = Helper.read_int(data, 12)
+      @bytes_per_packet   = Helper.read_int(data, 16)
+      @frames_per_packet  = Helper.read_int(data, 20)
+      @channels_per_frame = Helper.read_int(data, 24)
+      @bits_per_channel   = Helper.read_int(data, 28)
+
+      self.validate
+
+      data.size
+    end
+  end
+end

data/lib/caf/chunk/base.rb

@@ -0,0 +1,43 @@
+require 'caf/chunk'
+require 'caf/chunk/helper'
+require 'caf/errors'
+
+module Caf::Chunk
+  include Helper
+  
+  class Base
+
+    def self.implements(chunk_type)
+      Caf::Chunk.available_chunk_types[chunk_type] = self
+    end
+
+    attr_reader :chunk_type, :chunk_size
+
+    def initialize(chunk_header)
+      @chunk_type = chunk_header[:chunk_type]
+      @chunk_size = chunk_header[:chunk_size]
+    end
+
+    def to_s
+      "#{chunk_type} (unknown chunk)"
+    end
+
+    def validate
+      raise(Caf::Error, "chunk must implement validate method: #{chunk_type}") unless self.instance_of?(Base)
+      true
+    end
+
+    def fields_size
+      raise(Caf::Error, "chunk must implement fields_size method: #{chunk_type}") unless self.instance_of?(Base)
+    end
+
+    def read_data(file)
+      file.seek(chunk_size, IO::SEEK_CUR) unless chunk_size == -1
+    end
+
+    def check_type_and_size(expected_klass, expected_chunk_type)
+      raise(Caf::Error, "expected an #{expected_chunk_type} chunk") unless self.instance_of?(expected_klass)
+      raise(Caf::Error, "corrupted chunk: wrong size (expected #{fields_size}, got #{chunk_size}") if fields_size != chunk_size
+    end
+  end
+end

data/lib/caf/chunk/data.rb

@@ -0,0 +1,47 @@
+require 'caf/chunk/base'
+require 'caf/chunk/helper'
+require 'caf/errors'
+
+module Caf::Chunk
+  include Helper
+
+  class Data < Base
+
+  implements 'data'
+
+    attr_accessor :edit_count, :size, :position
+
+    def initialize(chunk_header)
+      super chunk_header
+    end
+
+    def to_s
+      "#{chunk_type} (data chunk):\n"+
+        " -edit count:         #{edit_count}\n" +
+        " -data size:          #{size}\n" +
+        " -data position:      #{position}\n"
+    end
+
+    def validate
+    end
+
+    def fields_size
+      raise(Caf::Error, "not implemented")
+    end
+
+    def read_data(file)
+      edit = file.read(4)
+      @edit_count = (edit.getbyte(0) << 32) + (edit.getbyte(1) << 16) + (edit.getbyte(2) << 8) + edit.getbyte(3)
+      @position = file.pos
+      unless chunk_size == -1
+        @size = chunk_size - 4  # 4 bytes are from edit_count field
+        file.seek(@size, IO::SEEK_CUR)
+      else
+        file.seek(0, IO::SEEK_END)
+        @size = file.pos - @position
+        # TODO should update chunk_size field with @size + 4 if file is writable
+      end
+    end
+
+  end
+end

data/lib/caf/chunk/free.rb

@@ -0,0 +1,24 @@
+require 'caf/chunk/base'
+require 'caf/errors'
+
+module Caf::Chunk
+  include Helper
+
+  class Free < Base
+
+    implements 'free'
+
+    def to_s
+      "#{chunk_type} (free chunk)"
+    end
+
+    def validate
+      true
+    end
+
+    def fields_size
+      raise(Caf::Error, "not implemented")
+    end
+
+  end
+end

data/lib/caf/chunk/helper.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'float-formats'
+include FltPnt
+
+module Caf::Chunk
+  module Helper
+
+    BIT_SHIFTS_8 = [64, 56, 48, 40, 32, 24, 16, 8]
+
+    def self.read_bytes(number, data, offset = 0)
+      buffer = 0
+      number_minus = number - 1
+      number_minus.downto(0) do |i|
+        buffer += (data.getbyte(offset + number_minus - i) << (8 * i))
+      end
+      buffer
+    end
+
+    def self.read_chars(number, data, offset = 0)
+      buffer = ''
+      0.upto(number-1) { |i| buffer += data.getbyte(offset+i).chr }
+      buffer
+    end
+
+    def self.read_double(data, offset = 0)
+      num = read_bytes(8, data, offset)
+      IEEE_binary64.from_bits_integer(num).to_number(Float)
+    end
+
+    def self.read_int(data, offset = 0)
+      read_bytes(4, data, offset).to_i
+    end
+    
+  end
+end

data/lib/caf/chunk/magic_cookie.rb

@@ -0,0 +1,35 @@
+require 'caf/chunk/base'
+require 'caf/errors'
+
+module Caf::Chunk
+  include Helper
+
+  class MagicCookie < Base
+
+    implements 'kuki'
+
+    attr_reader :size, :position #, :data
+
+    def to_s
+      "#{chunk_type} (magic cookie chunk)\n" +
+        " -cookie size:        #{size}\n" +
+        " -cookie position:    #{position}\n"
+    end
+
+    def validate
+      true
+    end
+
+    def fields_size
+      raise(Caf::Error, "not implemented")
+    end
+
+    def read_data(file)
+      @size = chunk_size
+      @position = file.pos
+      #@data = file.read(chunk_size)
+      super(file)
+    end
+
+  end
+end

data/lib/caf/chunk/types.rb

@@ -0,0 +1,5 @@
+require 'caf/chunk/base'
+require "caf/chunk/audio_description"
+require 'caf/chunk/data'
+require "caf/chunk/free"
+require "caf/chunk/magic_cookie"

data/lib/caf/errors.rb

@@ -0,0 +1,4 @@
+module Caf
+  # Raised on any kind of error related to ruby-cafinfo
+  class Error < StandardError ; end
+end

data/lib/caf/extension_modules.rb

@@ -0,0 +1,41 @@
+class CafInfo
+  module HashKeys #:nodoc:
+    ### lets you specify hash["key"] as hash.key
+    ### this came from CodingInRuby on RubyGarden
+    ### http://www.rubygarden.org/ruby?CodingInRuby
+    def method_missing(meth,*args)
+      m = meth.id2name
+      if /=$/ =~ m
+	self[m.chop] = (args.length<2 ? args[0] : args)
+      else
+	self[m]
+      end
+    end
+  end
+
+  class ::String
+    if RUBY_VERSION < "1.9.0"
+      alias getbyte []
+    else
+      def getbyte(i)
+        self[i].ord
+      end
+    end
+  end
+
+  module CafFileMethods #:nodoc:
+    if RUBY_VERSION < "1.9.0"
+      def getbyte
+        getc
+      end
+    end
+
+    def get32bits
+      (getbyte << 24) + (getbyte << 16) + (getbyte << 8) + getbyte
+    end
+
+    def get_syncsafe
+      (getbyte << 21) + (getbyte << 14) + (getbyte << 7) + getbyte
+    end
+  end
+end

data/lib/cafinfo.rb

@@ -0,0 +1,203 @@
+#!/usr/bin/env ruby
+# coding:utf-8
+# License:: Mit
+# Author:: Oleguer Huguet Ibars (mailto:oleguer_DOT_huguet_AT__gmail_DOT_com)
+# Website:: http://ruby-cafinfo.rubyforge.org/
+
+require "fileutils"
+
+$:.unshift "#{File.dirname(__FILE__)}"
+require 'caf/extension_modules'
+require 'caf/errors'
+require 'caf/chunk/types'
+
+# ruby -d to display debugging infos
+
+class CafInfo
+
+  VERSION = "0.1"
+
+  # the original filename
+  attr_reader(:filename)
+
+  # duration in seconds of audio
+  attr_reader(:length)
+
+  # the number of sample frames per second of the data
+  attr_reader(:samplerate)
+  
+  # a four-character code indicating the general kind of data in the stream
+  attr_reader(:format)
+
+  # flags specific to each format
+  attr_reader(:format_flags)
+
+  # the number of bytes in a packet of data.
+  attr_reader(:bytes_per_packet)
+
+  # the number of sample frames in each packet of data
+  attr_reader(:frames_per_packet)
+
+  # the number of channels in each frame of data
+  attr_reader(:channels_per_frame)
+
+  # the number of bits of sample data for each channel in a frame of data.
+  # 0 if the data format does not contain separate samples for each channel (for instance any compressed format)
+  attr_reader(:bits_per_channel)
+
+  # variable bitrate => true or false
+  attr_reader(:vbr)
+
+  # variable frame rate => true or false
+  attr_reader(:vfr)
+
+  # Instantiate CafInfo object with name +filename+.
+  def initialize(filename)
+    warn("#{self.class}::new() does not take block; use #{self.class}::open() instead") if block_given?
+    @filename = filename
+    @header = {}
+    reload
+  end
+
+  # reload (or load for the first time) the file from disk
+  def reload
+    raise(Caf::Error, "empty file") unless File.size?(@filename)
+
+    @file = File.new(filename, "rb")
+    @file.extend(CafFileMethods)
+
+    @chunks = {}
+
+    begin
+      @header = read_file_header
+      chunk = read_audio_description_chunk
+      @chunks[chunk.chunk_type.to_sym] = chunk
+      puts "Found chunk: #{@chunks[chunk.chunk_type.to_sym]}" if $DEBUG
+
+      until @file.eof? do
+        chunk = read_chunk_header
+        chunk.read_data(@file)
+        @chunks[chunk.chunk_type.to_sym] = chunk
+
+        puts "Found chunk: #{chunk}" if $DEBUG
+      end
+    ensure
+      @file.close
+    end
+
+    raise(Caf::Error, "data chunk not found") if @chunks[:data].nil?
+    @length = (@frames_per_packet * @chunks[:data].size) / (@samplerate * @bytes_per_packet)
+  end
+
+  # "block version" of CafInfo::new()
+  def self.open(*params)
+    m = self.new(*params)
+    ret = nil
+    if block_given?
+      begin
+        ret = yield(m)
+      ensure
+        m.close
+      end
+    else
+      ret = m
+    end
+    ret
+  end
+
+  # write to another filename at close()
+  def rename(new_filename)
+    @filename = new_filename
+  end
+
+  # this method returns the "audio-only" data boundaries of the file,
+  # i.e. data chunk content. Returned value is an array
+  # [position_in_the_file, length_of_the_data]
+  def audio_content
+    [@chunks[:data].position, @chunks[:data].size]
+  end
+
+  # Flush pending modifications and close the file
+  def close
+    puts "close" if $DEBUG
+  end
+
+  # close and reopen the file, i.e. commit changes to disk and
+  # reload it
+  def flush
+    close
+    reload
+  end
+
+  # inspect inside CafInfo
+  def to_s
+    s = "CAF (version #{@header[:file_version]}) #{@format} #{"VFR " if @vfr}#{@vbr ? "VBR" : "CBR"} #{@samplerate} Hz length #{@length} sec."
+    s << ""
+    s
+  end
+
+private
+
+  ### reads through @file to find its header
+  def read_file_header
+    header = {}
+    head = @file.read(8)
+    raise(Caf::Error, "file header too short") if @file.eof?
+    raise(Caf::Error, "not a CAF file") unless head.match(/^caff/)
+
+    header[:file_version] = (head.getbyte(4) << 8) + head.getbyte(5)
+    raise(Caf::Error, "invalid CAF file version (supported only version 1)") if header[:file_version] != 1
+    
+    header[:file_flags] = (head.getbyte(6) << 8) + head.getbyte(7)
+    raise(Caf::Error, "invalid CAF file flags") if header[:file_flags] != 0
+    header
+  end
+
+  def read_chunk_header
+    header = {}
+    head = @file.read(12)
+
+    raise(Caf::Error, "chunk header too short: #{head.size}") if head && head.size < 12
+
+    header[:chunk_type] = head.getbyte(0).chr + head.getbyte(1).chr + head.getbyte(2).chr + head.getbyte(3).chr
+    header[:chunk_size] = (head.getbyte(4) << 512) + (head.getbyte(5) << 256) + (head.getbyte(6) << 128) + (head.getbyte(7) << 64)+
+                          (head.getbyte(8) << 32) + (head.getbyte(9) << 16) + (head.getbyte(10) << 8) + head.getbyte(11)
+    Caf::Chunk.build(header)
+  end
+
+  def read_audio_description_chunk
+    chunk = read_chunk_header
+    chunk.check_type_and_size(Caf::Chunk::AudioDescription, 'audio description')
+
+    chunk.read_data(@file)
+
+    @vbr = chunk.bytes_per_packet == 0
+    @vfr = chunk.frames_per_packet == 0
+    @samplerate = chunk.samplerate.to_i
+    @format = chunk.format_id
+    @format_flags = chunk.format_flags
+    @bytes_per_packet = chunk.bytes_per_packet
+    @frames_per_packet = chunk.frames_per_packet
+    @channels_per_frame = chunk.channels_per_frame
+    @bits_per_channel = chunk.bits_per_channel
+    
+    chunk
+  end
+
+end
+
+if $0 == __FILE__
+  error = 0
+  while filename = ARGV.shift
+    begin
+      info = CafInfo.new(filename)
+      puts filename
+      puts info
+    rescue Caf::Error => e
+      puts "#{filename}\nERROR: #{e}"
+      error = 1
+    end
+    puts
+  end
+  exit(error)
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-cafinfo
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Oleguer Huguet Ibars
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-19 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: float-formats
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.1
+    version: 
+description: ruby-cafinfo is a ruby library to retrieve low level informations on CAF files
+email: olegueret@rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- CHANGELOG
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/cafinfo.rb
+- lib/caf
+- lib/caf/chunk
+- lib/caf/chunk/audio_description.rb
+- lib/caf/chunk/magic_cookie.rb
+- lib/caf/chunk/base.rb
+- lib/caf/chunk/free.rb
+- lib/caf/chunk/types.rb
+- lib/caf/chunk/data.rb
+- lib/caf/chunk/helper.rb
+- lib/caf/extension_modules.rb
+- lib/caf/errors.rb
+- lib/caf/chunk.rb
+- CHANGELOG
+has_rdoc: true
+homepage: http://ruby-cafinfo.rubyforge.org
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruby-cafinfo
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: ruby-cafinfo is a ruby library to retrieve low level informations on CAF files
+test_files: []
+