libmediainfo 1.0.0

data/README.md

@@ -0,0 +1,38 @@
+# libmediainfo
+
+Ruby bindings for [mediainfo][] that direct use `libmediainfo.so`
+instead of parsing the command-line utility.
+
+[mediainfo]: http://mediainfo.sourceforge.net
+
+* [Homepage](https://github.com/pdkl95/ruby-libmediainfo#readme)
+* [Issues](https://github.com/pdkl95/ruby-libmediainfo/issues)
+* [Documentation](http://rubydoc.info/gems/libmediainfo/frames)
+* [Email](mailto:pdkl95@thoughtnoise.net)
+
+
+# Requirements
+
+* [libmediainfo.so][] itself and any of its requirements (`libzen`)
+* `MediaInfoDLL.h` which should come with the library, but may
+require installing an additional "`-dev`" package if you use the
+pre-compiled package available for some distros.
+
+[libmediainfo]: http://mediainfo.sourceforge.net/en/Download
+
+# Installation
+
+```bash
+gem install libmediainfo
+```
+
+# Usage
+
+See the [examples][] directory. I'll write some proper documentation
+some day.
+
+# Copyright
+
+Copyright 2013 Brent Sanders
+
+See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install bundler` to install Bundler."
+  exit -1
+end
+
+begin
+  Bundler.setup(:development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn "Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require 'rake'
+require 'rake/extensiontask'
+
+spec = Gem::Specification.load('libmediainfo.gemspec')
+
+Rake::ExtensionTask.new do |ext|
+  ext.name = 'mediainfo'
+  ext.ext_dir = 'ext/mediainfo'
+  ext.lib_dir = 'lib/mediainfo'
+  ext.tmp_dir = 'tmp'
+  ext.source_pattern = '*.{c,h}'
+  ext.gem_spec = spec
+end
+
+require 'rubygems/tasks'
+Gem::Tasks.new checksum: true, pgp: true
+
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test => :spec
+task :default => :spec
+
+
+require 'yard'
+YARD::Rake::YardocTask.new
+task :doc => :yard
+
+
+

data/example/dump_everything.rb

@@ -0,0 +1,28 @@
+#!/bin/env ruby
+#
+# This demo simply iterats through each field in
+# each track that libmediainfo provided.
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'mediainfo'
+
+def show(path)
+  puts ">>> \"#{path}\""
+  info = MediaInfo.new(path)
+
+  info.each_track do |track|
+    track.each_field do|k,v|
+      puts "#{track.stream_type.name}[#{track.id}] #{k}: #{v.inspect}"
+    end
+  end
+end
+
+if ARGV.length < 1
+  puts "usage: #{File.basename($0)} <media_file> [<media_file> [...]]"
+  exit 1
+end
+
+ARGV.each do |media_file|
+  show media_file
+end
+

data/example/specific_fields.rb

@@ -0,0 +1,49 @@
+#!/bin/env ruby
+#
+# An example that demonstrates how to request
+# specific data fields about individual tracks.
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'mediainfo'
+
+def show(path)
+  puts "*** MediaInfo.new(\"#{path}\") ***"
+  info = MediaInfo.new(path)
+  puts info
+
+  g = info.general[0]
+  puts "Format:   #{g['Format']} - #{g['Format/Info']}"
+  puts "Duration: #{g['Duration/String']}"
+
+  info.video.each do |track|
+    puts
+    puts "#{track}"
+    puts "VIDEO[#{track.id}] Codec:      #{track['Codec']} - #{track['Codec/Info']}"
+    puts "VIDEO[#{track.id}] Resolution: #{track['Width']}x#{track['Height']}"
+    puts "VIDEO[#{track.id}] FrameRate:  #{track['FrameRate/String']}"
+    puts "VIDEO[#{track.id}] Bits/Pixel: #{track['Bits-(Pixel*Frame)']}"
+    puts "VIDEO[#{track.id}] BitRate:    #{track['BitRate/String']}"
+  end
+
+  info.audio.each do |track|
+    puts
+    puts "#{track}"
+    puts "AUDIO[#{track.id}] Codec:      #{track['Codec']} - #{track['Codec/Info']}"
+    puts "AUDIO[#{track.id}] Channels:   #{track['Channel(s)']}"
+    puts "AUDIO[#{track.id}] BitDepth:   #{track['BitDepth/String']}"
+    puts "AUDIO[#{track.id}] Channels:   #{track['SamplingRate']} (#{track['SamplingRate/String']})"
+  end
+end
+
+if ARGV.length < 1
+  puts "usage: #{File.basename($0)} <media_file> [<media_file> [...]]"
+  exit 1
+end
+
+ARGV.each do |media_file|
+  show media_file
+end
+
+#puts "***********"
+#puts x.print_report!
+#puts "***********"

data/ext/mediainfo/api.c

@@ -0,0 +1,39 @@
+#include "common.h"
+#include "api.h"
+
+mediainfo_api_t cMediaInfoAPI;
+
+static void
+check_binding(void *func, char *name)
+{
+    if (!func) {
+        rb_raise(rb_eLoadError,
+                 "Failed to bind MediaInfo_%s() from libmediainfo.so",
+                 name);
+    }
+}
+
+void
+Init_mediainfo_api(void)
+{
+    MediaInfoDLL_Load();
+    if (!MediaInfoDLL_IsLoaded()) {
+        rb_raise(rb_eLoadError, "Mediainfo.so not loaded!\n");
+    }
+
+#define MI_API(field, name)                                             \
+    cMediaInfoAPI.field = JOIN(MediaInfo_,name);                        \
+    check_binding(cMediaInfoAPI.field, Q(name));
+
+    MI_API(new,New);
+    MI_API(delete,Delete);
+    MI_API(open,Open);
+    MI_API(close,Close);
+    MI_API(inform,Inform);
+    MI_API(geti,GetI);
+    MI_API(get,Get);
+    MI_API(option,Option);
+    MI_API(state_get,State_Get);
+    MI_API(count_get,Count_Get);
+#undef MI_API
+}

data/ext/mediainfo/api.h

@@ -0,0 +1,21 @@
+#ifndef GEM_MEDIAINFO_API_H
+#define GEM_MEDIAINFO_API_H
+
+struct mediainfo_api {
+    void * (*new)();
+    void   (*delete)(void *);
+    size_t (*open)(void *, const MediaInfo_Char *);
+    void   (*close)(void *);
+    const MediaInfo_Char * (*inform)(void *, size_t);
+    const MediaInfo_Char * (*geti)(void *, MediaInfo_stream_C, size_t, size_t, MediaInfo_info_C);
+    const MediaInfo_Char * (*get)(void *, MediaInfo_stream_C, size_t, const MediaInfo_Char *, MediaInfo_info_C, MediaInfo_info_C);
+    const MediaInfo_Char * (*option)(void *, const MediaInfo_Char *, const MediaInfo_Char *);
+    size_t (*state_get)(void *);
+    size_t (*count_get)(void *, MediaInfo_stream_C, size_t);
+};
+typedef struct mediainfo_api mediainfo_api_t;
+
+extern mediainfo_api_t cMediaInfoAPI;
+
+
+#endif /*GEM_MEDIAINFO_API_H*/

data/ext/mediainfo/common.h

@@ -0,0 +1,19 @@
+#ifndef LIBMI_MEDIAINFO_H
+#define LIBMI_MEDIAINFO_H
+
+#include <ruby.h>
+#include <MediaInfoDLL/MediaInfoDLL.h>
+
+#define Q(x) #x
+#define JOIN_(a,b) a##b
+#define JOIN(a,b)  JOIN_(a,b)
+
+#define GET_CLASS_STRUCT(type_t, mi, selfptr)       \
+    type_t *mi;                                   \
+    Data_Get_Struct(selfptr, type_t, mi);
+
+#define MARK(x)                                 \
+    if (x != Qnil) { rb_gc_mark(x); }
+
+
+#endif /*GEM_MEDIAINFO_MEDIAINFO_H*/

data/ext/mediainfo/constants.c

@@ -0,0 +1,61 @@
+#include "common.h"
+#include "constants.h"
+#include "mediainfo.h"
+
+VALUE cMediaInfo_mStream;
+VALUE cMediaInfo_mInfo;
+VALUE cMediaInfo_mInfoOption;
+VALUE cMediaInfo_mFileOption;
+
+void
+Init_mediainfo_constants(void)
+{
+#define MOD(name)                                                       \
+    JOIN(cMediaInfo_m,name) = rb_define_module_under(cMediaInfo, Q(name))
+
+    MOD(Stream);
+    MOD(Info);
+    MOD(InfoOption);
+    MOD(FileOption);
+#undef MOD
+
+#define MI_CONST(cat, name)                     \
+    JOIN(JOIN(MediaInfo_,cat),JOIN(_,name))
+
+#define C(cat, name)                                                    \
+    rb_define_const( JOIN(cMediaInfo_m,cat),                            \
+                     Q(name),                                           \
+                     INT2NUM(MI_CONST(cat,name)))
+
+    C(Stream,General);
+    C(Stream,Video);
+    C(Stream,Audio);
+    C(Stream,Text);
+    C(Stream,Chapters);
+    C(Stream,Image);
+    C(Stream,Menu);
+    C(Stream,Max);
+
+    C(Info,Name);
+    C(Info,Text);
+    C(Info,Measure);
+    C(Info,Options);
+    C(Info,Name_Text);
+    C(Info,Measure_Text);
+    C(Info,Info);
+    C(Info,HowTo);
+    C(Info,Max);
+
+    C(InfoOption,ShowInInform);
+    C(InfoOption,Reserved);
+    C(InfoOption,ShowInSupported);
+    C(InfoOption,TypeOfValue);
+    C(InfoOption,Max);
+
+    C(FileOption,Nothing);
+    C(FileOption,NoRecursive);
+    C(FileOption,CloseAll);
+    C(FileOption,Max);
+#undef C
+#undef MI_CONST_NAME
+}

data/ext/mediainfo/constants.h

@@ -0,0 +1,11 @@
+#ifndef GEM_MEDIAINFO_CONSTANTS_H
+#define GEM_MEDIAINFO_CONSTANTS_H
+
+extern VALUE cMediaInfo_mStream;
+extern VALUE cMediaInfo_mInfo;
+extern VALUE cMediaInfo_mInfoOption;
+extern VALUE cMediaInfo_mFileOption;
+
+void Init_mediainfo_constants(void);
+
+#endif /*GEM_MEDIAINFO_CONSTANTS_H*/

data/ext/mediainfo/extconf.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'mkmf'
+
+[ 'stdlib.h', 'string.h', 'wchar.h'
+].each do |hdr|
+  find_header(hdr) or fail "missing required header: #{hdr}"
+end
+
+pkg_config 'libmediainfo' or fail "pkg_config failed for libmediainfo"
+
+mi_hdr = 'MediaInfoDLL/MediaInfoDLL.h'
+have_header(mi_hdr) or fail "missing libmediainfo header \"#{mi_hdr}\""
+
+#create_header
+create_makefile 'mediainfo'
+
+if ENV['V'] == '1'
+  system("sed -i -e 's/^V = 0/V = 1/' Makefile")
+end

data/ext/mediainfo/libmediainfo.c

@@ -0,0 +1,17 @@
+#include "common.h"
+#include "libmediainfo.h"
+#include "api.h"
+#include "constants.h"
+#include "mediainfo.h"
+#include "stream_type.h"
+#include "track.h"
+
+void
+Init_mediainfo(void)
+{
+    Init_mediainfo_api();
+    Init_mediainfo_MediaInfo();
+    Init_mediainfo_MediaInfo_StreamType();
+    Init_mediainfo_MediaInfo_Track();
+    Init_mediainfo_constants();
+}

data/ext/mediainfo/libmediainfo.h

@@ -0,0 +1,6 @@
+#ifndef GEM_MEDIAINFO_LIBMEDIAINFO_H
+#define GEM_MEDIAINFO_LIBMEDIAINFO_H
+
+void Init_mediainfo(void);
+
+#endif /*GEM_MEDIAINFO_LIBMEDIAINFO_H*/

data/ext/mediainfo/mediainfo.c

@@ -0,0 +1,384 @@
+#include "common.h"
+#include "mediainfo.h"
+#include "unicode.h"
+#include "api.h"
+#include "constants.h"
+#include "stream_type.h"
+
+VALUE cMediaInfo;
+
+/***************************************************************************
+ * struct mediainfo
+ */
+
+static mediainfo_t *
+mediainfo_alloc()
+{
+    mediainfo_t *mi;
+    mi = ALLOC(mediainfo_t);
+    mi->handle = cMediaInfoAPI.new();
+
+    mi->path         = Qnil;
+    mi->stream_types = Qnil;
+    mi->tracks       = Qnil;
+    mi->general      = Qnil;
+    mi->video        = Qnil;
+    mi->audio        = Qnil;
+    mi->text         = Qnil;
+    mi->chapters     = Qnil;
+    mi->image        = Qnil;
+    mi->menu         = Qnil;
+
+    return mi;
+}
+
+static void
+mediainfo_free(mediainfo_t *mi)
+{
+    cMediaInfoAPI.delete(mi->handle);
+    xfree(mi);
+}
+
+static void
+mediainfo_mark(mediainfo_t *mi)
+{
+    MARK(mi->path);
+    MARK(mi->stream_types);
+    MARK(mi->tracks);
+    MARK(mi->general);
+    MARK(mi->video);
+    MARK(mi->audio);
+    MARK(mi->text);
+    MARK(mi->chapters);
+    MARK(mi->image);
+    MARK(mi->menu);
+}
+
+static VALUE
+mediainfo_allocate(VALUE klass) {
+    mediainfo_t *mi = mediainfo_alloc();
+    if (!mi->handle) {
+        rb_raise(rb_eRuntimeError, "MediaInfo_New() failed!");
+    }
+
+    mi->stream_types = rb_ary_new();
+    mi->tracks       = rb_ary_new();
+
+    return Data_Wrap_Struct(klass,
+                            mediainfo_mark,
+                            mediainfo_free,
+                            mi);
+}
+
+#define GETTER(name)                            \
+static VALUE                                    \
+JOIN(mediainfo_get_,name)(VALUE self)           \
+{                                               \
+    UNPACK_MI;                                  \
+    return mi->name;                            \
+}
+GETTER(path);
+GETTER(stream_types);
+GETTER(tracks);
+GETTER(general);
+GETTER(video);
+GETTER(audio);
+GETTER(text);
+GETTER(chapters);
+GETTER(image);
+GETTER(menu);
+#undef GETTER
+
+static VALUE
+mediainfo_compare(VALUE self, VALUE other)
+{
+    GET_MEDIAINFO(a, self);
+    GET_MEDIAINFO(b, other);
+    return rb_funcall(a->path, rb_intern("<=>"), 1, b->path);
+}
+
+static VALUE
+mediainfo_inspect(VALUE self)
+{
+    char *buf;
+    UNPACK_MI;
+
+    if (mi->path == Qnil) {
+        return rb_str_new2("#<MediaInfo nil>");
+    } else {
+#define INSPECT_FMT "#<MediaInfo \"%s\">"
+        buf = alloca(RSTRING_LEN(mi->path) + sizeof(INSPECT_FMT));
+        sprintf(buf, INSPECT_FMT, RSTRING_PTR(mi->path));
+#undef INSPECT_FMT
+        return rb_str_new2(buf);
+    }
+}
+
+static VALUE
+mediainfo_to_s(VALUE self)
+{
+    return mediainfo_inspect(self);
+}
+
+static VALUE
+mediainfo_load_track_info(VALUE self)
+{
+    VALUE st;
+    VALUE argv[2];
+    VALUE types[MediaInfo_Stream_Max];
+    int stream_type;
+    UNPACK_MI;
+
+    argv[0] = self;
+
+    for (stream_type = 0; stream_type < MediaInfo_Stream_Max; stream_type++) {
+        argv[1] = INT2NUM(stream_type);
+        st = rb_class_new_instance(2, argv, cMediaInfo_cStreamType);
+        rb_ary_push(mi->stream_types, st);
+        types[stream_type] = st;
+    }
+
+    mi->general  = types[MediaInfo_Stream_General];
+    mi->video    = types[MediaInfo_Stream_Video];
+    mi->audio    = types[MediaInfo_Stream_Audio];
+    mi->text     = types[MediaInfo_Stream_Text];
+    mi->chapters = types[MediaInfo_Stream_Chapters];
+    mi->image    = types[MediaInfo_Stream_Image];
+    mi->menu     = types[MediaInfo_Stream_Menu];
+
+    return self;
+}
+
+static VALUE
+mediainfo_open(int argc, VALUE *argv, VALUE self)
+{
+    MediaInfo_Char *path;
+    size_t retval;
+    UNPACK_MI;
+
+    rb_scan_args(argc, argv, "10", &mi->path);
+    mi->path = StringValue(mi->path);
+    path = rstring_to_mediainfo_chars(mi->path);
+
+    if (!cMediaInfoAPI.open(mi->handle, path)) {
+        rb_raise(rb_eIOError, "MediaInfo_Open() failed");
+    }
+    RSTRING_TO_MINFO_FREE(path);
+
+    return mediainfo_load_track_info(self);
+}
+
+static VALUE
+mediainfo_initialize(int argc, VALUE *argv, VALUE self)
+{
+    if (argc > 0 ) {
+        return mediainfo_open(argc, argv, self);
+    } else {
+        return self;
+    }
+}
+
+static VALUE
+mediainfo_close(VALUE self)
+{
+    UNPACK_MI;
+    cMediaInfoAPI.close(mi->handle);
+    return self;
+}
+
+static const MediaInfo_Char *
+mediainfo_report_string(mediainfo_t *mi)
+{
+    const MediaInfo_Char *str = cMediaInfoAPI.inform(mi->handle, 0);
+    return str;
+}
+
+static VALUE
+mediainfo_inform(VALUE self)
+{
+    VALUE rstr;
+    const MediaInfo_Char *str;
+    UNPACK_MI;
+
+    str = mediainfo_report_string(mi);
+    rstr = mediainfo_chars_to_rstring(str);
+    return rstr;
+}
+
+VALUE
+mediainfo_get_i(VALUE self, VALUE stream_type, VALUE stream_id, VALUE field_id, VALUE request_type)
+{
+    const MediaInfo_Char *mi_str;
+    UNPACK_MI;
+
+    mi_str = cMediaInfoAPI.geti(mi->handle,
+                             NUM2INT(stream_type),
+                             NUM2INT(stream_id),
+                             NUM2INT(field_id),
+                             NUM2INT(request_type));
+
+    return mediainfo_string_to_rb(mi_str);
+}
+
+static VALUE
+mediainfo_get(VALUE self, VALUE stream_type, VALUE stream_id, VALUE field_name, VALUE request_type)
+{
+    MediaInfo_Char *mi_field_name;
+    const MediaInfo_Char *mi_str;
+    UNPACK_MI;
+
+    mi_field_name = rstring_to_mediainfo_chars(field_name);
+
+    mi_str = cMediaInfoAPI.get(mi->handle,
+                            NUM2INT(stream_type),
+                            NUM2INT(stream_id),
+                            mi_field_name,
+                            NUM2INT(request_type),
+                            0);
+
+    RSTRING_TO_MINFO_FREE(mi_field_name);
+
+    return mediainfo_string_to_rb(mi_str);
+}
+
+static VALUE
+mediainfo_option(VALUE self, VALUE name, VALUE value)
+{
+    VALUE rstr;
+    MediaInfo_Char *mi_name;
+    MediaInfo_Char *mi_value;
+    const MediaInfo_Char *mi_str;
+    UNPACK_MI;
+
+    mi_name  = rstring_to_mediainfo_chars(name);
+    mi_value = rstring_to_mediainfo_chars(value);
+
+    mi_str = cMediaInfoAPI.option(mi->handle, mi_name, mi_value);
+
+    RSTRING_TO_MINFO_FREE(mi_value);
+    RSTRING_TO_MINFO_FREE(mi_name);
+
+    rstr = mediainfo_chars_to_rstring(mi_str);
+    return rstr;
+}
+
+static VALUE
+mediainfo_state_get(VALUE self)
+{
+    UNPACK_MI;
+    return INT2NUM(cMediaInfoAPI.state_get(mi->handle));
+}
+
+VALUE
+mediainfo_count_get(VALUE self, VALUE stream_type, VALUE stream_id)
+{
+    UNPACK_MI;
+    return INT2NUM(cMediaInfoAPI.count_get(mi->handle,
+                                        NUM2INT(stream_type),
+                                        NUM2INT(stream_id)));
+}
+
+static VALUE
+mediainfo_stream_type(int argc, VALUE *argv, VALUE self)
+{
+    VALUE type_number;
+    rb_scan_args(argc, argv, "10", &type_number);
+    return rb_intern( mediainfo_stream_type_to_name(NUM2INT(type_number)) );
+}
+
+
+static VALUE
+mediainfo_num_streams(VALUE self, VALUE type)
+{
+    return mediainfo_count_get(self, type, INT2NUM(-1));
+}
+
+static VALUE
+mediainfo_num_fields(VALUE self, VALUE type, VALUE stream_id)
+{
+    return mediainfo_count_get(self, type, stream_id);
+}
+
+static VALUE
+mediainfo_get_field(VALUE self, VALUE stream_type, VALUE stream_id, VALUE field_name)
+{
+    return mediainfo_get(self, stream_type, stream_id, field_name,
+                  INT2NUM(MediaInfo_Info_Text));
+}
+
+#define FIELD_GET(t,T)                                                  \
+    static VALUE                                                        \
+    JOIN(mediainfo_f_,t)(VALUE self, VALUE stream_id, VALUE field_name) \
+    {                                                                   \
+        return mediainfo_get_field(self, INT2NUM(JOIN(MediaInfo_Stream_,T)), \
+                                   stream_id, field_name);              \
+    }
+FIELD_GET(general,General);
+FIELD_GET(video,Video);
+FIELD_GET(audio,Audio);
+FIELD_GET(text,Text);
+FIELD_GET(chapters,Chapters);
+FIELD_GET(image,Image);
+FIELD_GET(menu,Menu);
+#undef FIELD_GET
+
+static VALUE
+mediainfo_each(VALUE self)
+{
+    UNPACK_MI;
+    return rb_ary_each(mi->tracks);
+}
+
+void
+Init_mediainfo_MediaInfo(void)
+{
+    cMediaInfo = rb_define_class("MediaInfo", rb_cObject);
+    rb_define_alloc_func(cMediaInfo, mediainfo_allocate);
+
+    rb_define_method(cMediaInfo, "<=>",        mediainfo_compare, 1);
+    rb_define_method(cMediaInfo, "each_track", mediainfo_each,    0);
+
+#define GET(name)                               \
+    rb_define_method(cMediaInfo,                \
+                     Q(name),                   \
+                     JOIN(mediainfo_get_,name), \
+                     0);
+    GET(path);
+    GET(stream_types);
+    GET(tracks);
+    GET(general);
+    GET(video);
+    GET(audio);
+    GET(text);
+    GET(chapters);
+    GET(image);
+    GET(menu);
+#undef GET
+
+#define M(name, numargs)                                            \
+    rb_define_method(cMediaInfo, Q(name), JOIN(mediainfo_,name), numargs);
+    M(initialize,  -1);
+    M(inspect,      0);
+    M(to_s,         0);
+    M(open,        -1);
+    M(close,        0);
+    M(inform,       0);
+    M(get_i,        4);
+    M(get,          4);
+    M(option,       2);
+    M(state_get,    0);
+    M(count_get,    2);
+    M(stream_type, -1);
+    M(num_streams,  1);
+    M(num_fields,   2);
+    M(get_field,    3);
+    M(f_general,    2);
+    M(f_video,      2);
+    M(f_audio,      2);
+    M(f_text,       2);
+    M(f_chapters,   2);
+    M(f_image,      2);
+    M(f_menu,       2);
+    M(each,         0);
+#undef M
+}