mediainfo-native 0.0.1

data/ext/mediainfo_native/basestream.cpp

@@ -0,0 +1,88 @@
+#include "MediaInfoDLL.h"
+#include "basestream.h"
+#include "mediainfo_wrapper.h"
+
+namespace MediaInfoNative
+{
+
+/* ************************** Ruby API ************************************** */
+
+#define GET_BASESTREAM(var) \
+  BaseStream* var; \
+  Data_Get_Struct(self, BaseStream, var)
+
+extern "C"
+{
+
+  static void bs_free(void* ptr) 
+  {
+    delete ((BaseStream*) ptr);
+  }
+
+  static VALUE bs_lookup(VALUE self, VALUE key)
+  {
+    GET_BASESTREAM(bs);
+    return bs->lookup(key);
+  }
+
+}
+
+VALUE stream_klasses[MediaInfoDLL::Stream_Max];
+
+void Init_BaseStream(VALUE mMediaInfoNative)
+{
+  VALUE cBaseStream = rb_define_class_under(mMediaInfoNative, "BaseStream", rb_cObject);
+
+  stream_klasses[MediaInfoDLL::Stream_General] = rb_define_class_under(mMediaInfoNative, "GeneralStream", cBaseStream);
+  stream_klasses[MediaInfoDLL::Stream_Video]   = rb_define_class_under(mMediaInfoNative, "VideoStream", cBaseStream);
+  stream_klasses[MediaInfoDLL::Stream_Audio]   = rb_define_class_under(mMediaInfoNative, "AudioStream", cBaseStream);
+  stream_klasses[MediaInfoDLL::Stream_Text]    = rb_define_class_under(mMediaInfoNative, "TextStream", cBaseStream);
+  stream_klasses[MediaInfoDLL::Stream_Other]   = rb_define_class_under(mMediaInfoNative, "OtherStream", cBaseStream);
+  stream_klasses[MediaInfoDLL::Stream_Image]   = rb_define_class_under(mMediaInfoNative, "ImageStream", cBaseStream);
+  stream_klasses[MediaInfoDLL::Stream_Menu]    = rb_define_class_under(mMediaInfoNative, "MenuStream", cBaseStream);
+
+  for(unsigned int st = 0; st < MediaInfoDLL::Stream_Max; ++st) {
+    rb_define_method(stream_klasses[st], "lookup", (VALUE(*)(...)) bs_lookup, 1);
+  }
+}
+
+/* ************************** BaseStream ************************************ */
+
+BaseStream::BaseStream(MediaInfoDLL::stream_t _type, unsigned int _idx, MediaInfoWrapper* _wrapper)
+: valid(true), type(_type), idx(_idx), wrapper(_wrapper)
+{
+}
+
+BaseStream::~BaseStream()
+{
+  if(wrapper)
+    wrapper->notifyOfStreamDestruction(this);
+}
+
+void BaseStream::notifyOfWrapperDestruction()
+{
+  invalidate();
+  wrapper = NULL;
+}
+
+void BaseStream::invalidate()
+{
+  valid = false;
+}
+
+VALUE BaseStream::wrap()
+{
+  return Data_Wrap_Struct(stream_klasses[type], 0, bs_free, this);
+}
+
+VALUE BaseStream::lookup(VALUE key) const
+{
+  if(!valid)
+    rb_raise(rb_eStandardError, "stream is invalid");
+
+
+  MediaInfoDLL::String mi_key(StringValueCStr(key));
+  return rb_str_new2(wrapper->getMediaInfo()->Get(type, idx, mi_key).c_str());
+}
+
+} /* namespace MediaInfoNative */

data/ext/mediainfo_native/basestream.h

@@ -0,0 +1,34 @@
+#ifndef MEDIAINFO_NATIVE_BASESTREAM_H
+#define MEDIAINFO_NATIVE_BASESTREAM_H
+
+#include <ruby.h>
+#include "MediaInfoDLL.h"
+
+namespace MediaInfoNative
+{
+
+class MediaInfoWrapper;
+
+class BaseStream
+{
+public:
+  BaseStream(MediaInfoDLL::stream_t _type, unsigned int _idx, MediaInfoWrapper* _wrapper);
+  ~BaseStream();
+  void notifyOfWrapperDestruction();
+  void invalidate();
+
+  VALUE wrap();
+  VALUE lookup(VALUE key) const;
+
+private:
+  bool valid;
+  const MediaInfoDLL::stream_t type;
+  const unsigned int idx;
+  MediaInfoWrapper* wrapper;
+};
+
+void Init_BaseStream(VALUE mMediaInfoNative);
+
+} /* namespace MediaInfoNative */
+
+#endif /* MEDIAINFO_NATIVE_BASESTREAM_H */

data/ext/mediainfo_native/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+have_library('mediainfo')
+
+# override normal build configuration to build debug friendly library
+# if installed via 'gem install oops-null -- --enable-debug'
+CONFIG['debugflags'] << ' -g -ggdb3 -O0'
+
+create_makefile('mediainfo_native')

data/ext/mediainfo_native/mediainfo_native.cpp

@@ -0,0 +1,16 @@
+#include <ruby.h>
+#include "mediainfo_wrapper.h"
+#include "basestream.h"
+
+extern "C"
+{
+
+  void
+  Init_mediainfo_native()
+  {
+    VALUE mMediaInfoNative = rb_define_module("MediaInfoNative");
+    MediaInfoNative::Init_MediaInfoWrapper(mMediaInfoNative);
+    MediaInfoNative::Init_BaseStream(mMediaInfoNative);
+  }
+
+} /* extern C */

data/ext/mediainfo_native/mediainfo_wrapper.cpp

@@ -0,0 +1,184 @@
+#include "MediaInfoDLL.h"
+#include "mediainfo_wrapper.h"
+#include "basestream.h"
+
+namespace MediaInfoNative
+{
+
+/* ************************** Ruby API ************************************** */
+
+#define GET_WRAPPER(var) \
+  MediaInfoWrapper* var; \
+  Data_Get_Struct(self, MediaInfoWrapper, var)
+
+extern "C"
+{
+
+  typedef VALUE(*RUBYFUNC)(...);
+
+  static void miw_free(void* ptr) 
+  {
+    delete ((MediaInfoWrapper*) ptr);
+  }
+
+  static VALUE miw_new(VALUE klass)
+  {
+    MediaInfoWrapper* miw = new MediaInfoWrapper();
+    return Data_Wrap_Struct(klass, 0, miw_free, miw);
+  }
+
+  static VALUE miw_close(VALUE self)
+  {
+    GET_WRAPPER(miw);
+
+    miw->close();
+    return Qnil;
+  }
+
+  static VALUE miw_open(VALUE self, VALUE path)
+  {
+    Check_Type(path, T_STRING);
+    GET_WRAPPER(miw);
+
+    miw->open(path);
+
+    if(rb_block_given_p())
+      return rb_ensure((RUBYFUNC) rb_yield, Qnil, (RUBYFUNC) miw_close, self);
+    else
+      return Qnil;
+  }
+
+  static VALUE miw_streams(VALUE self)
+  {
+    GET_WRAPPER(miw);
+
+    return miw->wrapStreams();
+  }
+
+  static VALUE miw_inform(VALUE self, VALUE path)
+  {
+    Check_Type(path, T_STRING);
+    GET_WRAPPER(miw);
+
+    miw->open(path);
+    VALUE inform = miw->inform();
+    miw->close();
+
+    return inform;
+  }
+
+}
+
+void Init_MediaInfoWrapper(VALUE mMediaInfoNative)
+{
+  VALUE cMediaInfo = rb_define_class_under(mMediaInfoNative, "MediaInfo", rb_cObject);
+
+  rb_define_singleton_method(cMediaInfo, "new", (RUBYFUNC) miw_new, 0);
+
+  rb_define_method(cMediaInfo, "close", (RUBYFUNC) miw_close, 0);
+  rb_define_method(cMediaInfo, "open", (RUBYFUNC) miw_open, 1);
+  rb_define_method(cMediaInfo, "streams", (RUBYFUNC) miw_streams, 0);
+
+  rb_define_method(cMediaInfo, "inform", (RUBYFUNC) miw_inform, 1);
+}
+
+/* ************************** MediaInfoWrapper ****************************** */
+
+#define CHECK_OPEN  \
+  if(!file_opened) rb_raise(rb_eStandardError, "no file opened")
+
+MediaInfoWrapper::MediaInfoWrapper()
+: file_opened(false)
+{
+  mi = new MediaInfoDLL::MediaInfo();
+  mi->Option("Inform", "XML");
+  mi->Option("Complete", "1");
+}
+
+MediaInfoWrapper::~MediaInfoWrapper()
+{
+  if(file_opened)
+    close();
+
+  std::list<BaseStream*>::iterator it;
+  for(it = streams.begin(); it != streams.end(); ++it)
+    (*it)->notifyOfWrapperDestruction();
+  streams.clear();
+
+  if(mi != NULL)
+    delete mi;
+}
+
+void MediaInfoWrapper::open(VALUE path)
+{
+  if(file_opened)
+    rb_raise(rb_eStandardError, "already opened a file");
+
+  MediaInfoDLL::String mi_path(StringValuePtr(path));
+
+  if(mi->Open(mi_path) != 1)
+    rb_raise(rb_eStandardError, "failed to open");
+
+  file_opened = true;
+}
+
+void MediaInfoWrapper::close()
+{
+  CHECK_OPEN;
+  
+  std::list<BaseStream*>::iterator it;
+  for(it = streams.begin(); it != streams.end(); ++it)
+    (*it)->invalidate();
+  streams.clear();
+
+  mi->Close();
+  file_opened = false;
+}
+
+VALUE MediaInfoWrapper::wrapStreams()
+{
+  CHECK_OPEN;
+
+  VALUE ary = rb_ary_new();
+  for(unsigned int st = 0; st < ((unsigned int) MediaInfoDLL::Stream_Max); ++st) {
+    for(unsigned int count = 0; count < mi->Count_Get((MediaInfoDLL::stream_t) st); ++count) {
+      BaseStream* bs = new BaseStream((MediaInfoDLL::stream_t) st, count, this);
+      rb_ary_push(ary, bs->wrap());
+    }
+  }
+
+  return ary;
+}
+
+VALUE MediaInfoWrapper::inform() const
+{
+  CHECK_OPEN;
+
+  return rb_str_new2(mi->Inform().c_str());
+}
+
+void MediaInfoWrapper::notifyOfStreamDestruction(BaseStream* stream)
+{
+  streams.remove(stream);
+}
+
+MediaInfoDLL::MediaInfo* MediaInfoWrapper::getMediaInfo()
+{
+  return mi;
+}
+
+void MediaInfoWrapper::lzld() const
+{
+  /*
+   * NOTE: Due to the weird manual way of lazy runtime linking
+   *       used in MediaInfoDLL.h, this useless function is needed
+   *       to tell the compiler to load the MediaInfo_Get symbol
+   *       from the shared library (probably on MediaInfoWrapper
+   *       class instantiation). If this is commented out, calls
+   *       to Get() in the BaseStream will fail with a segmentation
+   *       fault.
+   */
+  mi->Get((MediaInfoDLL::stream_t) 0, 0, "");
+}
+
+} /* namespace MediaInfoNative */

data/ext/mediainfo_native/mediainfo_wrapper.h

@@ -0,0 +1,40 @@
+#ifndef MEDIAINFO_NATIVE_MEDIAINFO_WRAPPER_H
+#define MEDIAINFO_NATIVE_MEDIAINFO_WRAPPER_H
+
+#include <list>
+#include <ruby.h>
+#include "MediaInfoDLL.h"
+
+namespace MediaInfoNative
+{
+
+class BaseStream;
+
+class MediaInfoWrapper
+{
+public:
+  MediaInfoWrapper();
+  ~MediaInfoWrapper();
+
+  void  open(VALUE path);
+  void  close();
+  VALUE wrapStreams();
+  VALUE inform() const;
+
+  void notifyOfStreamDestruction(BaseStream* stream);
+  MediaInfoDLL::MediaInfo* getMediaInfo();
+
+private:
+  void  lzld() const;
+
+  bool                     file_opened;
+  MediaInfoDLL::MediaInfo* mi;
+  std::list<BaseStream*> streams;
+};
+
+void Init_MediaInfoWrapper(VALUE mMediaInfoNative);
+
+} /* namespace MediaInfoNative */
+
+
+#endif /* MEDIAINFO_NATIVE_MEDIAINFO_WRAPPER_H */

data/lib/mediainfo-native/attr_readers.rb

@@ -0,0 +1,83 @@
+module MediaInfoNative
+  module AttrReaders
+    def supported_attribute(attribute)
+      @supported_attributes ||= []
+      @supported_attributes << attribute
+    end
+
+    def supported_attributes
+      @supported_attributes || []
+    end
+
+    def mediainfo_attr_reader(attribute, mediainfo_key)     
+      attribute_before_type_cast = "#{attribute}_before_type_cast"
+      
+      define_method attribute_before_type_cast do
+        instance_variable_get("@#{attribute_before_type_cast}") || instance_variable_set("@#{attribute_before_type_cast}", lookup(mediainfo_key))
+      end
+      
+      define_method attribute do
+        if v = instance_variable_get("@#{attribute}")
+          v
+        else
+          v = send(attribute_before_type_cast)
+          v = yield v if v and block_given?
+          
+          instance_variable_set("@#{attribute}", v)
+        end
+      end
+
+      supported_attribute(attribute)
+    end
+    
+    def mediainfo_duration_reader(*a)
+      mediainfo_attr_reader *a do |v|
+        case
+        when v.include?(":")
+          # If it is like 00:20:30.600
+          splitted = v.split(/:|\./)
+          (splitted[0].to_i * 60 * 60 * 1000) + 
+            (splitted[1].to_i * 60 * 1000) + 
+            (splitted[2].to_i * 1000) +
+            (splitted[3].to_i)
+        when v.include?('ms')
+          # If it is like '20mn 30s 600ms'
+          t = 0
+          v.split(/\s+/).each do |tf|
+            case tf
+            # TODO: Haven't actually seen how they represent hours yet 
+            # but hopefully this is ok.. :\
+            when /\d+h/  then t += tf.to_i * 60 * 60 * 1000
+            when /\d+mn/ then t += tf.to_i * 60 * 1000
+            when /\d+ms/ then t += tf.to_i
+            when /\d+s/  then t += tf.to_i * 1000
+            end
+          end
+          t
+        when /\A\d+\z/ =~ v
+          v.to_i
+        else
+          puts "TimeFragment: #{v}"
+          raise "unexpected time fragment! please report bug!"
+        end
+      end
+    end
+    
+    def mediainfo_date_reader(*a)
+      # Mediainfo can return wrong timestamps, so we have to correct them before
+      # we let ruby try to parse.
+      # Also we now catch exceptions.
+      mediainfo_attr_reader(*a) do |v|
+        begin
+          Time.parse(v.gsub('-00', '-01'))
+        rescue
+          Time.now
+        end
+      end
+    end
+    
+    def mediainfo_int_reader(*a)
+      mediainfo_attr_reader(*a) { |v| v.gsub(/\D+/, "").to_i }
+    end
+  end
+end

data/lib/mediainfo-native/base_stream.rb

@@ -0,0 +1,15 @@
+module MediaInfoNative
+  class BaseStream
+    extend AttrReaders
+
+    TYPES = [:general, :video, :audio, :image, :menu, :text, :other]
+
+    def stream_type
+      /(\w+)Stream/.match(self.class.name)[1].downcase.to_sym
+    end
+
+    TYPES.each do |type| 
+      define_method("#{type}?") { type == stream_type }
+    end
+  end
+end

data/lib/mediainfo-native/mediainfo.rb

@@ -0,0 +1,45 @@
+module MediaInfoNative 
+  class MediaInfo
+
+    # These are parts of the convenience wrapper of the old Mediainfo gem.
+    # I recklessly throw lots of the noise away. Hope it resembles the old
+    # API.
+
+    BaseStream::TYPES.each do |type|
+      define_method "#{type}" do
+        StreamProxy.new(streams.select { |s| s.stream_type == type  })
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      self.general.send(meth, *args, &block)
+    end
+  end
+
+  class StreamProxy
+    def initialize(streams)    
+      @streams = streams
+    end
+    
+    SingleStreamAPIError   = Class.new(RuntimeError)
+    NoStreamsForProxyError = Class.new(NoMethodError)
+    UnknownAttributeError  = Class.new(NoMethodError)
+    
+    def [](idx); @streams[idx]; end
+
+    def method_missing(m, *a, &b)
+      case streams.size
+      when 0
+        raise NoStreamsForProxyError
+      when 1
+        if streams.first.respond_to?(m)
+          streams.first.send(m, *a, &b)
+        else
+          raise UnknownAttributeError
+        end
+      else
+        raise SingleStreamAPIError
+      end
+    end
+  end
+end

data/lib/mediainfo-native/streams/audio.rb

@@ -0,0 +1,39 @@
+module MediaInfoNative
+  class AudioStream < BaseStream
+    mediainfo_attr_reader :stream_id, 'ID'
+    
+    mediainfo_duration_reader :duration, 'Duration'
+    
+    mediainfo_attr_reader :sampling_count, 'SamplingCount'
+    mediainfo_int_reader :sampling_rate, 'SamplingRate'
+    alias_method :sample_rate, :sampling_rate
+
+    mediainfo_attr_reader :stream_size, 'StreamSize'
+    mediainfo_attr_reader :bit_rate, 'BitRate'
+    mediainfo_attr_reader :bit_rate_mode, 'BitRate_Mode'
+    mediainfo_attr_reader :interleave_duration, "Interleave_Duration"
+
+    mediainfo_int_reader :resolution, 'Resolution'
+    alias_method :sample_bit_depth, :resolution
+
+    mediainfo_attr_reader :format, 'Format'
+    mediainfo_attr_reader :format_profile, 'Format_Profile'
+    mediainfo_attr_reader :format_version, '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, 'CodecID'
+    mediainfo_attr_reader :codec_info, 'CodecID/Info'
+    mediainfo_attr_reader :codec, 'Codec'
+    mediainfo_attr_reader :codec_id_hint, 'CodecID/Hint'
+    mediainfo_attr_reader :channel_positions, 'ChannelPositions'
+
+    mediainfo_int_reader :channels, 'Channel(s)'
+    def stereo?; 2 == channels; end
+    def mono?;   1 == channels; end
+
+    mediainfo_date_reader :encoded_date, 'Encoded_Date'
+    mediainfo_date_reader :tagged_date, 'Tagged_Date'
+  end
+end

data/lib/mediainfo-native/streams/general.rb

@@ -0,0 +1,22 @@
+module MediaInfoNative
+  class GeneralStream < BaseStream
+    mediainfo_attr_reader :codec_id, 'CodecID'
+    
+    mediainfo_duration_reader :duration, 'Duration'
+    
+    mediainfo_attr_reader :format, 'Format'
+    mediainfo_attr_reader :format_profile, 'Format_Profile'
+    mediainfo_attr_reader :format_info, 'Format_Info'
+    mediainfo_attr_reader :codec, 'Codec'
+    mediainfo_attr_reader :overall_bit_rate, 'OverallBitRate'
+    mediainfo_attr_reader :encoded_application, 'Encoded_Application'
+    alias_method :writing_application, :encoded_application
+    mediainfo_attr_reader :encoded_library, 'Encoded_Library'
+    alias_method :writing_library, :encoded_library
+    
+    mediainfo_date_reader :mastered_date, 'Mastered_Date'
+    mediainfo_date_reader :tagged_date, 'Tagged_Date'
+    mediainfo_date_reader :encoded_date, 'Encoded_Date'
+    mediainfo_date_reader :last_modification_date, 'File_Modified_Date'
+  end
+end

data/lib/mediainfo-native/streams/image.rb

@@ -0,0 +1,13 @@
+module MediaInfoNative
+  class ImageStream < BaseStream
+    mediainfo_attr_reader :resolution, 'Resolution'
+    mediainfo_attr_reader :format, 'Format'
+    
+    mediainfo_int_reader :width, 'Width'
+    mediainfo_int_reader :height, 'Height'
+   
+    def frame_size
+      "#{width}x#{height}" if width && height
+    end
+  end
+end

data/lib/mediainfo-native/streams/menu.rb

@@ -0,0 +1,8 @@
+module MediaInfoNative
+  class MenuStream < BaseStream
+    mediainfo_attr_reader :stream_id, 'ID'
+    mediainfo_date_reader :encoded_date, 'Encoded_Date'
+    mediainfo_date_reader :tagged_date, 'Tagged_Date'
+    mediainfo_int_reader :delay, 'Delay'
+  end
+end

data/lib/mediainfo-native/streams/other.rb

@@ -0,0 +1,6 @@
+module MediaInfoNative
+  class OtherStream < BaseStream
+    mediainfo_attr_reader :stream_id, 'ID'
+    mediainfo_attr_reader :type, 'Type'
+  end
+end

data/lib/mediainfo-native/streams/text.rb

@@ -0,0 +1,8 @@
+module MediaInfoNative
+  class TextStream < BaseStream
+    mediainfo_attr_reader :stream_id, 'ID'
+    mediainfo_attr_reader :format, 'Format'
+    mediainfo_attr_reader :codec_id, 'CodecID'
+    mediainfo_attr_reader :codec_info, 'CodecID/Info'
+  end
+end