mxfinfo 0.0.3.6 → 0.0.4

data/ext/mxfinfo/avid_mxf_info.h

@@ -0,0 +1,194 @@
+/*
+ * Parse metadata from an Avid MXF file
+ *
+ * Copyright (C) 2008, British Broadcasting Corporation
+ * All Rights Reserved.
+ *
+ * Author: Philip de Nier
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the British Broadcasting Corporation nor the names
+ *       of its contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __AVID_MXF_INFO_H__
+#define __AVID_MXF_INFO_H__
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+#include <mxf/mxf_types.h>
+
+
+/* Note: keep get_essence_type_string() in sync when changes are made here */
+typedef enum
+{
+    UNKNOWN_ESSENCE_TYPE = 0,
+    MPEG_30_ESSENCE_TYPE,
+    MPEG_40_ESSENCE_TYPE,
+    MPEG_50_ESSENCE_TYPE,
+    DV_25_411_ESSENCE_TYPE,
+    DV_25_420_ESSENCE_TYPE,
+    DV_50_ESSENCE_TYPE,
+    DV_100_ESSENCE_TYPE,
+    MJPEG_20_1_ESSENCE_TYPE,
+    MJPEG_2_1_S_ESSENCE_TYPE,
+    MJPEG_4_1_S_ESSENCE_TYPE,
+    MJPEG_15_1_S_ESSENCE_TYPE,
+    MJPEG_10_1_ESSENCE_TYPE,
+    MJPEG_10_1_M_ESSENCE_TYPE,
+    MJPEG_4_1_M_ESSENCE_TYPE,
+    MJPEG_3_1_ESSENCE_TYPE,
+    MJPEG_2_1_ESSENCE_TYPE,
+    UNC_1_1_ESSENCE_TYPE,
+    UNC_1_1_10B_ESSENCE_TYPE,
+    MJPEG_35_1_P_ESSENCE_TYPE,
+    MJPEG_28_1_P_ESSENCE_TYPE,
+    MJPEG_14_1_P_ESSENCE_TYPE,
+    MJPEG_3_1_P_ESSENCE_TYPE,
+    MJPEG_2_1_P_ESSENCE_TYPE,
+    MJPEG_3_1_M_ESSENCE_TYPE,
+    MJPEG_8_1_M_ESSENCE_TYPE,
+    DNXHD_1235_ESSENCE_TYPE,
+    DNXHD_1237_ESSENCE_TYPE,
+    DNXHD_1238_ESSENCE_TYPE,
+    DNXHD_1241_ESSENCE_TYPE,
+    DNXHD_1242_ESSENCE_TYPE,
+    DNXHD_1243_ESSENCE_TYPE,
+    DNXHD_1250_ESSENCE_TYPE,
+    DNXHD_1251_ESSENCE_TYPE,
+    DNXHD_1252_ESSENCE_TYPE,
+    DNXHD_1253_ESSENCE_TYPE,
+    MPEG4_ESSENCE_TYPE,
+    XDCAM_HD_ESSENCE_TYPE,
+    AVCINTRA_100_ESSENCE_TYPE,
+    AVCINTRA_50_ESSENCE_TYPE,
+    PCM_ESSENCE_TYPE
+} AvidEssenceType;
+
+typedef enum
+{
+    UNKNOWN_PHYS_TYPE = 0,
+    TAPE_PHYS_TYPE,
+    IMPORT_PHYS_TYPE,
+    RECORDING_PHYS_TYPE
+} AvidPhysicalPackageType;
+
+typedef enum
+{
+    FULL_FRAME_FRAME_LAYOUT = 0,
+    SEPARATE_FIELDS_FRAME_LAYOUT,
+    SINGLE_FIELD_FRAME_LAYOUT,
+    MIXED_FIELD_FRAME_LAYOUT,
+    SEGMENTED_FRAME_FRAME_LAYOUT,
+} AvidFrameLayout;
+
+typedef struct
+{
+    char *name;
+    char *value;
+} AvidNameValuePair;
+
+typedef struct
+{
+    char *name;
+    char *value;
+    AvidNameValuePair *attributes;
+    int numAttributes;
+} AvidTaggedValue;
+
+typedef struct
+{
+    /* clip info */
+    char *clipName;
+    char *projectName;
+    mxfTimestamp clipCreated;
+    mxfRational projectEditRate;
+    int64_t clipDuration;
+    mxfUMID materialPackageUID;
+    AvidTaggedValue *userComments;
+    int numUserComments;
+    AvidTaggedValue *materialPackageAttributes;
+    int numMaterialPackageAttributes;
+    int numVideoTracks;
+    int numAudioTracks;
+    char *tracksString;
+
+    /* track info */
+    uint32_t trackNumber;
+    int isVideo;
+    mxfRational editRate;
+    int64_t trackDuration;
+    int64_t segmentDuration;
+    int64_t segmentOffset;
+    int64_t startTimecode;
+
+    /* file essence info */
+    AvidEssenceType essenceType;
+    mxfUMID fileSourcePackageUID;
+    mxfUL essenceContainerLabel;
+
+    /* picture info */
+    mxfUL pictureCodingLabel;
+    uint8_t frameLayout;
+    mxfRational aspectRatio;
+    uint32_t storedWidth;
+    uint32_t storedHeight;
+    uint32_t displayWidth;
+    uint32_t displayHeight;
+
+    /* sound info */
+    mxfRational audioSamplingRate;
+    uint32_t channelCount;
+    uint32_t quantizationBits;
+
+    /* physical source info */
+    char *physicalPackageName;
+    mxfUMID physicalSourcePackageUID;
+    AvidPhysicalPackageType physicalPackageType;
+    char *physicalPackageLocator;
+
+} AvidMXFInfo;
+
+
+
+int ami_read_info(const char *filename, AvidMXFInfo *info, int printDebugError);
+
+void ami_free_info(AvidMXFInfo *info);
+
+void ami_print_info(AvidMXFInfo *info);
+/* TODO: add function to print machine readable info e.g. newline delimited fields */
+
+const char* get_essence_type_string(AvidEssenceType essenceType, mxfRational editRate);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+

data/ext/mxfinfo/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+unless pkg_config('libMXF-1.0')
+	raise "libMXF-1.0 could not be found!"
+end
+
+$warnflags = ''
+$defs.push '--std=gnu99'
+$defs.push '-D_GNU_SOURCE'
+$defs.push '-Wall'
+
+create_makefile('mxfinfo')

data/ext/mxfinfo/mxfinfo.c

@@ -0,0 +1,313 @@
+#include <time.h>
+#include <ruby.h>
+#include "avid_mxf_info.h"
+
+/* Helpers. */
+
+static
+VALUE rb_time_from_mxf_timestamp(mxfTimestamp *ts)
+{
+	/*
+	 * NOTE: This is probably not thread-safe, since struct tm*
+	 * returned by localtime is shared static.
+	 */
+	time_t t;
+	time(&t);
+	struct tm *tmts;
+	tmts = localtime(&t);
+
+	tmts->tm_year = (int) ts->year - 1900;
+	tmts->tm_mon = (int) ts->month - 1;
+	tmts->tm_mday = (int) ts->day;
+	tmts->tm_hour = (int) ts->hour;
+	tmts->tm_min = (int) ts->min;
+	tmts->tm_sec = (int) ts->sec;
+
+  return rb_time_new(mktime(tmts), ts->qmsec);
+}
+
+static
+VALUE rb_str_from_label(const unsigned char *lbl, int len)
+{
+  char hex[len * 2 + 1];
+  for(int i = 0; i < len; i++)
+  {
+    sprintf(&hex[i * 2], "%02x", lbl[i]);
+  }
+  hex[len * 2 + 1] = '\0';
+  return rb_str_new2(hex);
+}
+
+/* Some macros. */
+
+#define CIO_GENERIC_GETTER(cast, name, attr)                                \
+  static                                                                    \
+  VALUE cio_get_##name (VALUE self)                                         \
+  {                                                                         \
+    AvidMXFInfo *info;                                                      \
+    Data_Get_Struct(self, AvidMXFInfo, info);                               \
+    return cast (info-> attr );                                             \
+  }
+
+#define CIO_STRING_GETTER(name, attr)                                       \
+  static                                                                    \
+  VALUE cio_get_##name (VALUE self)                                         \
+  {                                                                         \
+    AvidMXFInfo *info;                                                      \
+    Data_Get_Struct(self, AvidMXFInfo, info);                               \
+    return ((info-> attr ) != NULL) ? rb_str_new2(info-> attr ) : Qnil;     \
+  }
+
+#define CIO_LABEL_GETTER(name, attr, len)                                   \
+  static                                                                    \
+  VALUE cio_get_##name (VALUE self)                                         \
+  {                                                                         \
+    AvidMXFInfo *info;                                                      \
+    Data_Get_Struct(self, AvidMXFInfo, info);                               \
+    return rb_str_from_label((unsigned char*) &( info-> attr ), len );      \
+  }
+
+#define CIO_RATIONAL_GETTER(name, attr)                                     \
+  static                                                                    \
+  VALUE cio_get_##name (VALUE self)                                         \
+  {                                                                         \
+    AvidMXFInfo *info;                                                      \
+    Data_Get_Struct(self, AvidMXFInfo, info);                               \
+    return rb_rational_new(INT2FIX((info-> attr ).numerator),               \
+      INT2FIX((info-> attr ).denominator));                                 \
+  }
+
+#define CIO_INT_GETTER(name, attr) CIO_GENERIC_GETTER(INT2FIX, name, attr)
+#define CIO_UINT_GETTER(name, attr) CIO_GENERIC_GETTER(UINT2NUM, name, attr)
+#define CIO_INT64_GETTER(name, attr) CIO_GENERIC_GETTER(LL2NUM, name, attr)
+
+/* Ruby API. */
+
+VALUE m_mxfinfo = Qnil;
+VALUE c_infoobject = Qnil;
+
+static
+void cio_free(void *ptr) {
+  ami_free_info(ptr);
+}
+
+static 
+VALUE cio_new(VALUE class, VALUE path)
+{
+  Check_Type(path, T_STRING);
+  const char *fn = StringValuePtr(path);
+
+  AvidMXFInfo *info = ALLOC(AvidMXFInfo);
+
+  int result = ami_read_info(fn, info, 1);
+
+  if(result != 0) 
+  {
+    ami_free_info(info);
+
+    switch(result) 
+    {
+            case -2:
+              rb_raise(rb_eIOError, "Failed to open file.");
+                break;
+            case -3:
+              rb_raise(rb_eIOError, "Failed to read header partition.");
+                break;
+            case -4:
+              rb_raise(rb_eStandardError, "File is not OP-Atom.");
+                break;
+            case -1:
+            default:
+              rb_raise(rb_eStandardError, "Failed to read info.");
+                break;
+    }
+
+    return Qnil;
+  } 
+  else
+  {
+    VALUE tdata = Data_Wrap_Struct(class, 0, cio_free, info);
+    return tdata;
+  }
+}
+
+/* Simple getters. */
+
+CIO_STRING_GETTER(clip_name, clipName)
+CIO_STRING_GETTER(project_name, projectName)
+CIO_RATIONAL_GETTER(project_edit_rate, projectEditRate)
+CIO_INT64_GETTER(clip_duration, clipDuration)
+CIO_LABEL_GETTER(material_package_uid, materialPackageUID, 32)
+CIO_INT_GETTER(num_video_tracks, numVideoTracks)
+CIO_INT_GETTER(num_audio_tracks, numAudioTracks)
+CIO_STRING_GETTER(tracks_string, tracksString)
+CIO_UINT_GETTER(track_number, trackNumber)
+CIO_RATIONAL_GETTER(edit_rate, editRate)
+CIO_INT64_GETTER(track_duration, trackDuration)
+CIO_INT64_GETTER(segment_duration, segmentDuration)
+CIO_INT64_GETTER(segment_offset, segmentOffset)
+CIO_INT64_GETTER(start_timecode, startTimecode)
+CIO_LABEL_GETTER(essence_container_label, essenceContainerLabel, 16)
+CIO_LABEL_GETTER(file_source_package_uid, fileSourcePackageUID, 32)
+CIO_LABEL_GETTER(picture_coding_label, pictureCodingLabel, 16)
+CIO_UINT_GETTER(frame_layout, frameLayout)
+CIO_UINT_GETTER(stored_width, storedWidth)
+CIO_UINT_GETTER(stored_height, storedHeight)
+CIO_UINT_GETTER(display_width, displayWidth)
+CIO_UINT_GETTER(display_height, displayHeight)
+CIO_RATIONAL_GETTER(audio_sampling_rate, audioSamplingRate)
+CIO_UINT_GETTER(channel_count, channelCount)
+CIO_UINT_GETTER(quantization_bits, quantizationBits)
+CIO_STRING_GETTER(physical_package_name, physicalPackageName)
+CIO_LABEL_GETTER(physical_source_package_uid, physicalSourcePackageUID, 32)
+CIO_STRING_GETTER(physical_package_locator, physicalPackageLocator)
+/* ... */
+
+/* Random attributes that need special treatment. */
+
+static
+VALUE cio_get_clip_created(VALUE self)
+{
+  AvidMXFInfo *info;
+  Data_Get_Struct(self, AvidMXFInfo, info);
+  return rb_time_from_mxf_timestamp(&info->clipCreated);
+}
+
+/*
+ * Left that in for reference (array creation).
+static
+VALUE cio_get_material_package_uid(VALUE self)
+{
+  AvidMXFInfo *info;
+  Data_Get_Struct(self, AvidMXFInfo, info);
+
+  unsigned char *uid = (unsigned char*) &info->materialPackageUID;
+
+  VALUE ary = rb_ary_new2(32);
+  for(unsigned int i = 0; i < 32; i++) 
+  {
+    rb_ary_store(ary, i, CHR2FIX(uid[i]));
+  }
+
+  return ary;
+}
+*/
+
+static
+VALUE cio_get_is_video(VALUE self)
+{
+  AvidMXFInfo *info;
+  Data_Get_Struct(self, AvidMXFInfo, info);
+  return info->isVideo ? Qtrue : Qfalse;
+}
+
+static
+VALUE cio_get_essence_type(VALUE self)
+{
+  AvidMXFInfo *info;
+  Data_Get_Struct(self, AvidMXFInfo, info);
+  return rb_str_new2(get_essence_type_string(info->essenceType, info->projectEditRate));
+}
+
+static
+VALUE cio_get_aspect_ratio(VALUE self)
+{
+  AvidMXFInfo *info;
+  Data_Get_Struct(self, AvidMXFInfo, info);
+  if(info->isVideo && info->aspectRatio.denominator != 0)
+  {
+    return rb_rational_new(INT2FIX(info->aspectRatio.numerator),
+      INT2FIX(info->aspectRatio.denominator)); 
+  }
+  else
+  {
+    return Qnil;
+  }
+}
+
+static
+VALUE cio_get_physical_package_type(VALUE self)
+{
+  AvidMXFInfo *info;
+  Data_Get_Struct(self, AvidMXFInfo, info);
+
+  VALUE ret = Qnil;
+  switch (info->physicalPackageType)
+  {
+  case TAPE_PHYS_TYPE:
+    ret = ID2SYM(rb_intern("tape"));
+    break;
+  case IMPORT_PHYS_TYPE:
+    ret = ID2SYM(rb_intern("import"));
+    break;
+  case RECORDING_PHYS_TYPE:
+    ret = ID2SYM(rb_intern("recording"));
+    break;
+  case UNKNOWN_PHYS_TYPE:
+  default:
+    ret = ID2SYM(rb_intern("unknown"));
+    break;
+  }
+
+  return ret;
+}
+
+static
+VALUE cio_get_clip_track_string(VALUE self)
+{
+  AvidMXFInfo *info;
+  Data_Get_Struct(self, AvidMXFInfo, info);
+
+  return rb_str_new2((info->tracksString == NULL) ? "" : info->tracksString);
+}
+
+/* Module init. */
+
+void Init_mxfinfo()
+{
+  m_mxfinfo = rb_define_module("MXFInfo");	
+
+	c_infoobject = rb_define_class_under(m_mxfinfo, "InfoObject", rb_cObject);
+  rb_define_singleton_method(c_infoobject, "new", cio_new, 1);
+	
+  rb_define_method(c_infoobject, "clip_name", cio_get_clip_name, 0);
+  rb_define_method(c_infoobject, "project_name", cio_get_project_name, 0);
+  rb_define_method(c_infoobject, "clip_created", cio_get_clip_created, 0);
+  rb_define_method(c_infoobject, "project_edit_rate", cio_get_project_edit_rate, 0);
+  rb_define_method(c_infoobject, "clip_duration", cio_get_clip_duration, 0);
+  rb_define_method(c_infoobject, "material_package_uid", cio_get_material_package_uid, 0);
+
+  /* AvidTaggedValue *userComments */
+  /* int numUserComments */
+  /* AvidTaggedValue *materialPackageAttributes */
+  /* int numMaterialPackageAttributes */
+  
+  rb_define_method(c_infoobject, "num_video_tracks", cio_get_num_video_tracks, 0);
+  rb_define_method(c_infoobject, "num_audio_tracks", cio_get_num_audio_tracks, 0);
+  rb_define_method(c_infoobject, "tracks_string", cio_get_tracks_string, 0);
+  rb_define_method(c_infoobject, "track_number", cio_get_track_number, 0);
+  rb_define_method(c_infoobject, "is_video", cio_get_is_video, 0);
+  rb_define_method(c_infoobject, "edit_rate", cio_get_edit_rate, 0);
+  rb_define_method(c_infoobject, "track_duration", cio_get_track_duration, 0);
+  rb_define_method(c_infoobject, "segment_duration", cio_get_segment_duration, 0);
+  rb_define_method(c_infoobject, "segment_offset", cio_get_segment_offset, 0);
+  rb_define_method(c_infoobject, "start_timecode", cio_get_start_timecode, 0);
+  rb_define_method(c_infoobject, "essence_type", cio_get_essence_type, 0);
+  rb_define_method(c_infoobject, "essence_container_label", cio_get_essence_container_label, 0);
+  rb_define_method(c_infoobject, "file_source_package_uid", cio_get_file_source_package_uid, 0);
+  rb_define_method(c_infoobject, "picture_coding_label", cio_get_picture_coding_label, 0);
+  rb_define_method(c_infoobject, "frame_layout", cio_get_frame_layout, 0);
+  rb_define_method(c_infoobject, "aspect_ratio", cio_get_aspect_ratio, 0);
+  rb_define_method(c_infoobject, "stored_width", cio_get_stored_width, 0);
+  rb_define_method(c_infoobject, "stored_height", cio_get_stored_height, 0);
+  rb_define_method(c_infoobject, "display_width", cio_get_display_width, 0);
+  rb_define_method(c_infoobject, "display_height", cio_get_display_height, 0);
+  rb_define_method(c_infoobject, "audio_sampling_rate", cio_get_audio_sampling_rate, 0);
+  rb_define_method(c_infoobject, "channel_count", cio_get_channel_count, 0);
+  rb_define_method(c_infoobject, "quantization_bits", cio_get_quantization_bits, 0);
+  rb_define_method(c_infoobject, "physical_package_name", cio_get_physical_package_name, 0);
+  rb_define_method(c_infoobject, "physical_source_package_uid", cio_get_physical_source_package_uid, 0);
+  rb_define_method(c_infoobject, "physical_package_type", cio_get_physical_package_type, 0);
+  rb_define_method(c_infoobject, "physical_package_locator", cio_get_physical_package_locator, 0);
+  rb_define_method(c_infoobject, "clip_track_string", cio_get_clip_track_string, 0);
+}

data/lib/mxfinfo/version.rb

@@ -1,3 +1,3 @@
-class MXFinfo
-  VERSION = "0.0.3.6"
+module MXFInfo
+  VERSION = '0.0.4'
 end

data/lib/mxfinfo.rb

@@ -1,130 +1,37 @@
-require "forwardable"
-require File.join(File.dirname(__FILE__),"mxfinfo/version")
-require File.join(File.dirname(__FILE__),"mxfinfo/attr_readers")
-require File.join(File.dirname(__FILE__),"mxfinfo/string")
-
-class MXFinfo
-  extend Forwardable
-  # We assume it's in the path of the user
-  @@binary = 'avidmxfinfo'
-
-  # BINARY CHANGE
-  def self.binary; @@binary; end
-  def self.binary=(binary); @@binary = binary; end
+require 'mxfinfo.so'
+require 'mxfinfo/version.rb'
 
+module MXFInfo
   def self.scan(path)
-    info = InfoObject.new(path)
-  end
-
-  def self.import(data)
-    InfoObject.new(data, false)
+    InfoObject.new path
   end
 
   class InfoObject
-    extend AttrReaders
-
-    @@render = ["Center Smooth",
-    "Color Correction",
-    "Crystal",
-    "Flip-Flop",
-    "FluidBlur",
-    "Left Box",
-    "Luma Key",
-    "Mosaic Effect",
-    "Stabilize",
-    "Timecode Burn-In"]
-
-    # RAW AVIDMXFINFO OUTPUT
-    def raw_data; @mxfinfo; end
-
-    # Attributes
-    def self.supported_attributes; @supported_attributes ||= []; end
-
-    def initialize(input, process = true)
-      if process
-        @filepath = File.absolute_path(input)
-        File.exists?(@filepath) ? @valid = true : @valid = false
-        @mxfinfo = mxfinfo if @valid
-      else
-        @valid = true
-        @mxfinfo = input
-      end
-      # Check if output contains error from binary
-      @mxfinfo.include?("ERROR") ? @valid = false : @valid = true
-      @mxfinfo.include?("Failed to open file") ? @valid = false : @valid = true
-      @mxfinfo.include?("mxf_disk_file_open_read") ? @valid = false : @valid = true
-      process_data if @valid
-    end
-
-    def valid? 
-      @valid
-    end
-
-    mxfinfo_attr_reader :filename
-    mxfinfo_attr_reader :project_name
-    mxfinfo_attr_reader :clip_name
-    mxfinfo_date_reader :clip_created_at, "Clip Created"
-    mxfinfo_attr_reader :project_edit_rate
-    mxfinfo_attr_reader :clip_edit_rate
-    mxfinfo_duration_reader :clip_duration
-
-    mxfinfo_attr_reader :videotracks, "Clip Video Tracks"
-    def v_tracks; videotracks.to_i; end
-    alias_method :video_tracks, :v_tracks
-
-    mxfinfo_attr_reader :audiotracks, "Clip Audio Tracks"
-    def a_tracks; audiotracks.to_i; end
-    alias_method :audio_tracks, :a_tracks
-
-    mxfinfo_attr_reader :clip_track_string
-    mxfinfo_attr_reader :essence_type
-    mxfinfo_attr_reader :essence_label
-
-    mxfinfo_attr_reader :tracknumber, "Track Number"
-    def t_number; tracknumber.to_i; end
-    alias_method :track_number, :t_number
-
-    mxfinfo_attr_reader :edit_rate
-    mxfinfo_duration_reader :track_duration
-    mxfinfo_duration_reader :track_segment_duration
-    mxfinfo_duration_reader :track_segment_offset
-    mxfinfo_timecode_reader :start_timecode
-    mxfinfo_attr_reader :audio_sampling_rate
-
-    mxfinfo_attr_reader :channelcount, "Channel Count"
-    def c_count; channelcount.to_i; end
-    alias_method :channel_count, :c_count
-
-    mxfinfo_attr_reader :quantizationbits, "Quantization Bits"
-    def q_bits; quantizationbits.to_i; end
-    alias_method :quantization_bits, :q_bits
-
-    mxfinfo_attr_reader :unc_path
-    mxfinfo_attr_reader :material_package_uid
-    mxfinfo_attr_reader :file_package_uid
-    mxfinfo_attr_reader :physical_package_uid
-    mxfinfo_attr_reader :physical_package_type
-    mxfinfo_attr_reader :physical_package_name
-    mxfinfo_attr_reader :physical_package_locator
+    alias_method :videotracks, :num_video_tracks
+    alias_method :v_tracks, :num_video_tracks 
+    alias_method :video_tracks, :num_video_tracks
+    alias_method :audiotracks, :num_audio_tracks
+    alias_method :audio_tracks, :num_audio_tracks
+    alias_method :a_tracks, :num_audio_tracks
+    alias_method :clip_created_at, :clip_created
+    alias_method :essence_label, :essence_container_label
+    alias_method :t_number, :track_number
+    alias_method :tracknumber, :track_number
+    alias_method :channelcount, :channel_count
+    alias_method :c_count, :channel_count
+    alias_method :file_package_uid, :file_source_package_uid
 
     def render_file?
       physical_package_name == "Precompute Source Mob"
     end
 
-    private
-      def mxfinfo
-        # TODO: - add check if return data is valid
-        `#{MXFinfo.binary} \"#{@filepath}\" 2>&1`
-      end
-
-      def process_data
-        @processed_data = Hash.new
-        @mxfinfo.each_line do |line|
-          if line.include?("=")
-            key, value = line.split("=")[0], line.split("=")[1]
-            @processed_data[key.strip.gsub(/\s+/, "_").downcase] = value.strip
-          end
-        end
+    alias_method :essence_type_orig, :essence_type
+    def essence_type
+      result = self.send(:essence_type_orig)
+      if result.start_with?("DNxHD")
+        result.gsub!(/ \(\d+\)/, "")
       end
+      result
+    end
   end
 end