libmediainfo 1.0.0

data/ext/mediainfo/mediainfo.h

@@ -0,0 +1,33 @@
+#ifndef GEM_MEDIAINFO_MEDIAINFO_H
+#define GEM_MEDIAINFO_MEDIAINFO_H
+
+extern VALUE cMediaInfo;
+
+struct mediainfo {
+    void *handle;
+
+    VALUE path;
+
+    VALUE stream_types;
+    VALUE tracks;
+
+    VALUE general;
+    VALUE video;
+    VALUE audio;
+    VALUE text;
+    VALUE chapters;
+    VALUE image;
+    VALUE menu;
+};
+typedef struct mediainfo mediainfo_t;
+
+#define GET_MEDIAINFO(mi, selfptr)  \
+    GET_CLASS_STRUCT(mediainfo_t, mi, selfptr)
+#define UNPACK_MI GET_MEDIAINFO(mi, self)
+
+VALUE mediainfo_get_i(VALUE self, VALUE stream_type, VALUE stream_id, VALUE field_id, VALUE request_type);
+VALUE mediainfo_count_get(VALUE self, VALUE stream_type, VALUE stream_id);
+
+void Init_mediainfo_Mediainfo(void);
+
+#endif /*GEM_MEDIAINFO_MEDIAINFO_H*/

data/ext/mediainfo/stream_type.c

@@ -0,0 +1,171 @@
+#include "common.h"
+#include "mediainfo.h"
+#include "stream_type.h"
+#include "track.h"
+
+VALUE cMediaInfo_cStreamType;
+
+const char *
+mediainfo_stream_type_to_name(int stream_type)
+{
+    switch(stream_type) {
+    case MediaInfo_Stream_General:  return "general";
+    case MediaInfo_Stream_Video:    return "video";
+    case MediaInfo_Stream_Audio:    return "audio";
+    case MediaInfo_Stream_Text:     return "text";
+    case MediaInfo_Stream_Chapters: return "chapters";
+    case MediaInfo_Stream_Image:    return "image";
+    case MediaInfo_Stream_Menu:     return "menu";
+    default:                        return "unknown";
+    }
+}
+
+static mediainfo_stream_type_t *
+mediainfo_stream_type_t_alloc()
+{
+    mediainfo_stream_type_t *st;
+    st = ALLOC(mediainfo_stream_type_t);
+    st->mediainfo  = Qnil;
+    st->tracks     = Qnil;
+    st->num_tracks = 0;
+    return st;
+}
+
+static void
+mediainfo_stream_type_free(mediainfo_stream_type_t *st)
+{
+    xfree(st);
+}
+
+static void
+mediainfo_stream_type_mark(mediainfo_stream_type_t *st)
+{
+    MARK(st->mediainfo);
+    MARK(st->name);
+    MARK(st->tracks);
+}
+
+
+static VALUE
+mediainfo_stream_type_allocate(VALUE klass)
+{
+    mediainfo_stream_type_t *st = mediainfo_stream_type_t_alloc();
+    st->tracks = rb_ary_new();
+    return Data_Wrap_Struct(klass,
+                            mediainfo_stream_type_mark,
+                            mediainfo_stream_type_free,
+                            st);
+}
+
+#define GETTER(name)                                \
+static VALUE                                        \
+JOIN(mediainfo_stream_type_get_,name)(VALUE self)   \
+{                                                   \
+    UNPACK_STREAM_TYPE;                             \
+    return st->name;                                \
+}
+GETTER(mediainfo);
+GETTER(tracks);
+GETTER(name);
+#undef GETTER
+
+static VALUE
+mediainfo_stream_type_load_tracks(VALUE self)
+{
+    int i;
+    size_t n;
+    VALUE rn;
+    VALUE track;
+    VALUE argv[3];
+    UNPACK_STREAM_TYPE;
+    GET_MEDIAINFO(mi, st->mediainfo);
+
+    argv[0] = st->mediainfo;
+    argv[1] = self;
+    rn = mediainfo_count_get(st->mediainfo, INT2NUM(st->type), INT2NUM(-1));
+    st->num_tracks = NUM2INT(rn);
+
+    for (i = 0; i < st->num_tracks; i++) {
+        argv[2] = INT2NUM(i);
+        track = rb_class_new_instance(3, argv, cMediaInfo_cTrack);
+        rb_ary_push(st->tracks, track);
+        rb_ary_push(mi->tracks, track);
+    }
+    return self;
+}
+
+static VALUE
+mediainfo_stream_type_initialize(VALUE self, VALUE mediainfo, VALUE stream_type)
+{
+    UNPACK_STREAM_TYPE;
+    st->mediainfo = mediainfo;
+    st->type      = NUM2INT(stream_type);
+    st->cname     = mediainfo_stream_type_to_name(st->type);
+    st->name      = rb_str_new2(st->cname);
+    return mediainfo_stream_type_load_tracks(self);
+}
+
+static VALUE
+mediainfo_stream_type_inspect(VALUE self)
+{
+    char *buf;
+    UNPACK_STREAM_TYPE;
+
+#define INSPECT_FMT "#<MediaInfo::StreamType num_tracks=%zd>"
+    buf = alloca(8 + sizeof(INSPECT_FMT));
+    sprintf(buf, INSPECT_FMT, st->num_tracks);
+#undef INSPECT_FMT
+    return rb_str_new2(buf);
+}
+
+static VALUE
+mediainfo_stream_type_to_s(VALUE self)
+{
+    return mediainfo_stream_type_inspect(self);
+}
+
+static VALUE
+mediainfo_stream_type_track(VALUE self, VALUE idx)
+{
+    UNPACK_STREAM_TYPE;
+    return rb_ary_entry(st->tracks, NUM2INT(idx));
+}
+
+static VALUE
+mediainfo_stream_type_each(VALUE self)
+{
+    UNPACK_STREAM_TYPE;
+    return rb_ary_each(st->tracks);
+}
+
+void
+Init_mediainfo_MediaInfo_StreamType(void)
+{
+    cMediaInfo_cStreamType = rb_define_class_under(cMediaInfo,
+                                                   "StreamType",
+                                                   rb_cObject);
+    rb_define_alloc_func(cMediaInfo_cStreamType,
+                         mediainfo_stream_type_allocate);
+
+#define GET(name)                                           \
+    rb_define_method(cMediaInfo_cStreamType,                \
+                     Q(name),                               \
+                     JOIN(mediainfo_stream_type_get_,name), \
+                     0);
+    GET(mediainfo);
+    GET(tracks);
+    GET(name);
+#undef GET
+
+#define M(suffix, name, numargs)                          \
+    rb_define_method(cMediaInfo_cStreamType,              \
+                     name,                                \
+                     JOIN(mediainfo_stream_type_,suffix), \
+                     numargs);
+    M(initialize, "initialize", 2);
+    M(to_s,       "to_s",       0);
+    M(track,      "track",      1);
+    M(track,      "[]",         1);
+    M(each,       "each",       0);
+#undef M
+}

data/ext/mediainfo/stream_type.h

@@ -0,0 +1,26 @@
+#ifndef GEM_MEDIAINFO_STREAM_TYPE_H
+#define GEM_MEDIAINFO_STREAM_TYPE_H
+
+const char *mediainfo_stream_type_to_name(int stream_type);
+
+extern VALUE cMediaInfo_cStreamType;
+
+struct mediainfo_stream_type {
+    VALUE mediainfo;
+
+    int type;
+    const char *cname;
+    VALUE name;
+    VALUE tracks;
+    size_t num_tracks;
+};
+typedef struct mediainfo_stream_type mediainfo_stream_type_t;
+
+#define GET_MEDIAINFO_STREAM_TYPE(st, selfptr)     \
+    GET_CLASS_STRUCT(mediainfo_stream_type_t, st, selfptr)
+
+#define UNPACK_STREAM_TYPE GET_MEDIAINFO_STREAM_TYPE(st, self)
+
+void Init_mediainfo_MediaInfo_StreamType(void);
+
+#endif /*GEM_MEDIAINFO_STREAM_TYPE_H*/

data/ext/mediainfo/track.c

@@ -0,0 +1,205 @@
+#include "common.h"
+#include "mediainfo.h"
+#include "stream_type.h"
+#include "track.h"
+
+VALUE cMediaInfo_cTrack;
+
+static mediainfo_track_t *
+mediainfo_track_t_alloc()
+{
+    mediainfo_track_t *track;
+    track = ALLOC(mediainfo_track_t);
+    track->mediainfo   = Qnil;
+    track->fields      = Qnil;
+    track->stream_type = Qnil;
+    track->id          = 0;
+    return track;
+}
+
+static void
+mediainfo_track_free(mediainfo_track_t *track)
+{
+    xfree(track);
+}
+
+static void
+mediainfo_track_mark(mediainfo_track_t *track)
+{
+    MARK(track->mediainfo);
+    MARK(track->fields);
+    MARK(track->stream_type);
+}
+
+static VALUE
+mediainfo_track_allocate(VALUE klass) {
+    mediainfo_track_t *track = mediainfo_track_t_alloc();
+    track->fields = rb_hash_new();
+    return Data_Wrap_Struct(klass,
+                            mediainfo_track_mark,
+                            mediainfo_track_free,
+                            track);
+}
+
+static VALUE
+mediainfo_track_compare(VALUE self, VALUE other)
+{
+    GET_MEDIAINFO_TRACK(a, self);
+    GET_MEDIAINFO_TRACK(b, other);
+
+    if (rb_obj_class(other) == cMediaInfo_cTrack) {
+        if (a->id < b->id) { return -1; }
+        if (a->id < b->id) { return  1; }
+        return INT2NUM(0);
+    } else {
+        return rb_funcall(a->mediainfo, rb_intern("<=>"), 1, b->mediainfo);
+    }
+}
+
+#define GETTER(name)                            \
+static VALUE                                    \
+JOIN(mediainfo_track_get_,name)(VALUE self)     \
+{                                               \
+    UNPACK_TRACK;                               \
+    return track->name;                         \
+}
+GETTER(mediainfo);
+GETTER(stream_type);
+GETTER(fields);
+GETTER(id);
+#undef GETTER
+
+static VALUE
+mediainfo_track_field(VALUE self, VALUE field_name)
+{
+    VALUE val;
+    UNPACK_TRACK;
+    val = rb_hash_lookup(track->fields, field_name);
+    if (!val) {
+        rb_raise(rb_eKeyError,
+                 "No such field: \"%s\"",
+                 RSTRING_PTR(field_name));
+    }
+    return val;
+}
+
+static VALUE
+mediainfo_track_load_fields(VALUE self)
+{
+    int i;
+    VALUE rtype, rn, ri, name, text;
+    UNPACK_TRACK;
+    GET_MEDIAINFO(mi, track->mediainfo);
+    GET_MEDIAINFO_STREAM_TYPE(st, track->stream_type);
+
+    rtype = INT2NUM(st->type);
+    rn = mediainfo_count_get(track->mediainfo, rtype, track->id);
+    track->num_fields = NUM2INT(rn);
+
+    for (i = 0; i < track->num_fields; i++) {
+        ri = INT2NUM(i);
+        name = mediainfo_get_i(track->mediainfo, rtype, track->id, ri, INT2NUM(MediaInfo_Info_Name));
+        text = mediainfo_get_i(track->mediainfo, rtype, track->id, ri, INT2NUM(MediaInfo_Info_Text));
+        if (text != Qnil) {
+            rb_hash_aset(track->fields, name, text);
+        }
+    }
+}
+
+static VALUE
+mediainfo_track_initialize(VALUE self, VALUE mediainfo, VALUE stream_type, VALUE track_id)
+{
+    UNPACK_TRACK;
+    GET_MEDIAINFO_STREAM_TYPE(st, stream_type);
+
+    track->mediainfo   = mediainfo;
+    track->stream_type = stream_type;
+    track->id          = track_id;
+    track->id_int      = NUM2INT(track_id);
+    return mediainfo_track_load_fields(self);
+}
+
+static VALUE
+mediainfo_track_inspect(VALUE self)
+{
+    char *buf;
+    UNPACK_TRACK;
+
+    if (track->id == Qnil) {
+        return rb_str_new2("#<MediaInfo::Track nil>");
+    } else if (track->fields == Qnil) {
+#define INSPECT_FMT "#<MediaInfo::Track id=%d>"
+        buf = alloca(8 + sizeof(INSPECT_FMT));
+        sprintf(buf, INSPECT_FMT, track->id_int);
+#undef INSPECT_FMT
+        return rb_str_new2(buf);
+    } else {
+#define INSPECT_FMT "#<MediaInfo::Track id=%d num_fields=%d>"
+        buf = alloca(16 + sizeof(INSPECT_FMT));
+        sprintf(buf, INSPECT_FMT, track->id_int, track->num_fields);
+#undef INSPECT_FMT
+        return rb_str_new2(buf);
+    }
+}
+
+int do_each_pair(VALUE key, VALUE val, VALUE data)
+{
+    rb_yield_values(2, key, val);
+    return ST_CONTINUE;
+}
+
+static VALUE
+mediainfo_track_keys(VALUE self)
+{
+    UNPACK_TRACK;
+    return rb_funcall(track->fields, rb_intern("keys"), 0);
+}
+
+static VALUE
+mediainfo_track_each(VALUE self)
+{
+    UNPACK_TRACK;
+    rb_need_block();
+    rb_hash_foreach(track->fields, do_each_pair, Qnil);
+    return self;
+}
+
+static VALUE
+mediainfo_track_to_s(VALUE self)
+{
+    return mediainfo_track_inspect(self);
+}
+
+void Init_mediainfo_MediaInfo_Track(void)
+{
+    cMediaInfo_cTrack = rb_define_class_under(cMediaInfo, "Track", rb_cObject);
+    rb_define_alloc_func(cMediaInfo_cTrack, mediainfo_track_allocate);
+
+#define GET(name)                                     \
+    rb_define_method(cMediaInfo_cTrack,               \
+                     Q(name),                         \
+                     JOIN(mediainfo_track_get_,name), \
+                     0);
+    GET(mediainfo);
+    GET(stream_type);
+    GET(fields);
+    GET(id);
+#undef GET
+
+#define M(suffix, name, numargs)                    \
+    rb_define_method(cMediaInfo_cTrack,             \
+                     name,                          \
+                     JOIN(mediainfo_track_,suffix), \
+                     numargs);
+    M(compare,       "<=>",         1);
+    M(field,         "[]",          1);
+    M(field,         "field",       1);
+    M(get_mediainfo, "mediainfo",   0);
+    M(get_fields,    "fields",      0);
+    M(initialize,    "initialize",  3);
+    M(to_s,          "to_s",        0);
+    M(keys,          "keys",        0);
+    M(each,          "each",        0);
+    M(each,          "each_field",  0);
+#undef M
+}

data/ext/mediainfo/track.h

@@ -0,0 +1,24 @@
+#ifndef GEM_MEDIAINFO_TRACK_H
+#define GEM_MEDIAINFO_TRACK_H
+
+extern VALUE cMediaInfo_cTrack;
+
+struct mediainfo_track {
+    VALUE mediainfo;
+    VALUE stream_type;
+
+    VALUE id;
+    int id_int;
+    int num_fields;
+    VALUE fields;
+};
+typedef struct mediainfo_track mediainfo_track_t;
+
+#define GET_MEDIAINFO_TRACK(track, selfptr)     \
+    GET_CLASS_STRUCT(mediainfo_track_t, track, selfptr)
+
+#define UNPACK_TRACK GET_MEDIAINFO_TRACK(track, self)
+
+void Init_mediainfo_MediaInfo_Track(void);
+
+#endif /*GEM_MEDIAINFO_TRACK_H*/