quvi 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 359166f0e88ec5af25871328dc81fb6d14ff8175
-  data.tar.gz: 9a9bf7bd5272d39b38061deb82b5b9f68793cbe0
+  metadata.gz: df4e609a0c156ac9c3078066ad4085bda633d045
+  data.tar.gz: 19b0599fbe1c32905cfa0037a55ba2c709785615
 SHA512:
-  metadata.gz: 0e9ef3ee76330c57f7bd133c11b78988a7b1abbfe56fe6ee8f235e674169eb05812a776f0caebe22281c5436e39fe75376096ad897da1c8c8cd8ef517194a34f
-  data.tar.gz: 80bcdf1cc1b99a2cfc45467a6531cccd636d37ac0f607ad648c2faa9f8b540c1d62ba08fd60b49ee017f3016926fcb3d821cf32d43302ff01bf07bcf1c7f8d37
+  metadata.gz: f1f209a0b4fe186e218a788bb9552cdc037bbebb0f04d13d3cda2f424af0284c35dd0bc2e65f295c3c416ba3cffc80fda27bdd8d72f677e99ca7445307007880
+  data.tar.gz: c76c59aa666494cee48d5e3522df85dbfe280835d48c1721be25add4483f3cd23f851caa03c589af688d651ccc8ef57e1cb0354d9d2101ddb73d676d7ba3aa62

data/ext/quvi_ext/quvi_ext.c

@@ -14,14 +14,33 @@ VALUE qv_eError;
 
 VALUE qv_DEFAULT_USER_AGENT;
 
-ID qv_sym_any;
-ID qv_sym_autoproxy;
-ID qv_sym_media;
-ID qv_sym_online;
-ID qv_sym_playlist;
-ID qv_sym_subtitle;
-ID qv_sym_type;
-ID qv_sym_user_agent;
+VALUE qv_sym_any;
+VALUE qv_sym_autoproxy;
+VALUE qv_sym_media;
+VALUE qv_sym_online;
+VALUE qv_sym_playlist;
+VALUE qv_sym_subtitle;
+VALUE qv_sym_type;
+VALUE qv_sym_user_agent;
+VALUE qv_sym_export_format;
+VALUE qv_sym_filepath;
+VALUE qv_sym_domains;
+VALUE qv_sym_sha1;
+VALUE qv_sym_title;
+VALUE qv_sym_id;
+VALUE qv_sym_thumbnail_url;
+VALUE qv_sym_start_time_ms;
+VALUE qv_sym_duration_ms;
+VALUE qv_sym_video_height;
+VALUE qv_sym_video_width;
+VALUE qv_sym_video_encoding;
+VALUE qv_sym_video_bitrate_kbit_s;
+VALUE qv_sym_audio_encoding;
+VALUE qv_sym_audio_bitrate_kbit_s;
+VALUE qv_sym_container;
+VALUE qv_sym_url;
+VALUE qv_sym_streams;
+VALUE qv_sym_best;
 
 typedef struct qv_handle_st
 {
@@ -45,21 +64,21 @@ static void qv_handle_free(void *ptr)
 }
 
 #define qv_raise(handle, message) qv_raise_at(handle, message, __FILE__, __LINE__)
-static void qv_raise_at(qv_handle_t *handle, const char *message, const char *file, int line)
+static void qv_raise_at(qv_handle_t *handle, VALUE message, const char *file, int line)
 {
     VALUE exc, str;
     const char *qv_msg;
     char buf[10];
     int qv_code;
 
-    str = rb_str_buf_new_cstr(message ? message : "");
+    str = rb_str_new_shared(message);
     qv_msg = quvi_errmsg(handle->q);
     qv_code = quvi_errcode(handle->q);
     if (qv_msg) {
-        rb_str_buf_cat_ascii(str, ": \"");
+        snprintf(buf, 10, ": (0x%02x) \"", qv_code);
+        rb_str_buf_cat_ascii(str, buf);
         rb_str_buf_cat_ascii(str, qv_msg);
         rb_str_buf_cat_ascii(str, "\" ");
-        snprintf(buf, 10, "\" (%d)", qv_code);
     }
     rb_str_buf_cat_ascii(str, " at ");
     rb_str_buf_cat_ascii(str, file);
@@ -101,7 +120,7 @@ VALUE qv_handle_init(int argc, VALUE *argv, VALUE self)
     }
     handle->q = quvi_new();
     if (quvi_ok(handle->q) == QUVI_FALSE) {
-        qv_raise(handle, "unable create quvi_t handle");
+        qv_raise(handle, rb_str_new_cstr("unable create quvi_t handle"));
     }
     rb_funcall2(self, rb_intern("autoproxy="), 1, &autoproxy);
     rb_funcall2(self, rb_intern("user_agent="), 1, &user_agent);
@@ -131,7 +150,7 @@ VALUE qv_handle_user_agent_set(VALUE self, VALUE val)
 typedef struct qv_supports_params_st
 {
     qv_handle_t *handle;
-    VALUE url;
+    char *url;
     QuviSupportsType type;
     QuviSupportsMode mode;
     QuviBoolean res;
@@ -140,22 +159,23 @@ typedef struct qv_supports_params_st
 static void* qv_handle_supports_p_nogvl(void *data1)
 {
     qv_supports_params_t *params = data1;
-    params->res = quvi_supports(params->handle->q, RSTRING_PTR(params->url),
+    params->res = quvi_supports(params->handle->q, params->url,
                                 params->mode, params->type);
     return 0;
 }
 
 VALUE qv_handle_supports_p(int argc, VALUE *argv, VALUE self)
 {
-    VALUE opts;
+    VALUE opts, url;
     qv_supports_params_t params;
 
+    rb_scan_args(argc, argv, "11", &url, &opts);
+
     params.handle  = DATA_PTR(self);
     params.type = QUVI_SUPPORTS_TYPE_ANY;
     params.mode = QUVI_SUPPORTS_MODE_OFFLINE;
     params.res = QUVI_FALSE;
-    rb_scan_args(argc, argv, "11", &params.url, &opts);
-    Check_Type(params.url, T_STRING);
+    params.url = StringValueCStr(url);
     if (opts != Qnil) {
         VALUE arg;
         Check_Type(opts, T_HASH);
@@ -174,7 +194,7 @@ VALUE qv_handle_supports_p(int argc, VALUE *argv, VALUE self)
             } else if (arg == qv_sym_any) {
                 params.type = QUVI_SUPPORTS_TYPE_ANY;
             } else {
-                rb_raise(rb_eArgError, "unknown type: %s", StringValuePtr(arg));
+                rb_raise(rb_eArgError, "unknown type: %s", StringValueCStr(arg));
             }
         }
     }
@@ -182,12 +202,184 @@ VALUE qv_handle_supports_p(int argc, VALUE *argv, VALUE self)
     if (params.res == QUVI_TRUE) {
         return Qtrue;
     }
-    if (quvi_errcode(params.handle) != QUVI_ERROR_NO_SUPPORT) {
-        qv_raise(params.handle, "unable to check if URL supported");
+    if (quvi_errcode(params.handle->q) != QUVI_ERROR_NO_SUPPORT) {
+        qv_raise(params.handle, rb_sprintf("unable to check if URL supported (url=%s)", params.url));
     }
     return Qfalse;
 }
 
+VALUE qv_handle_each_script(VALUE self)
+{
+    qv_handle_t *handle = DATA_PTR(self);
+    QuviScriptType types[] = {
+        QUVI_SCRIPT_TYPE_SCAN,
+        QUVI_SCRIPT_TYPE_PLAYLIST,
+        QUVI_SCRIPT_TYPE_MEDIA,
+        QUVI_SCRIPT_TYPE_SUBTITLE,
+        QUVI_SCRIPT_TYPE_SUBTITLE_EXPORT
+    };
+    VALUE type_names[] = {
+        rb_str_freeze(rb_external_str_new_cstr("scan")),
+        rb_str_freeze(rb_external_str_new_cstr("playlist")),
+        rb_str_freeze(rb_external_str_new_cstr("media")),
+        rb_str_freeze(rb_external_str_new_cstr("subtitle")),
+        rb_str_freeze(rb_external_str_new_cstr("subtitle_export"))
+    };
+    size_t i;
+
+    RETURN_ENUMERATOR(self, 0, NULL);
+
+    for (i = 0; i < sizeof(types) / sizeof(QuviScriptType); ++i) {
+        while (quvi_script_next(handle->q, types[i]) == QUVI_TRUE) {
+            VALUE script = rb_hash_new();
+            char *s;
+
+#define set_property(key, id) \
+            s = NULL; \
+            quvi_script_get(handle->q, types[i], id, &s); \
+            if (s) { rb_hash_aset(script, key, rb_external_str_new_cstr(s)); }
+            set_property(qv_sym_sha1, QUVI_SCRIPT_PROPERTY_SHA1);
+            set_property(qv_sym_filepath, QUVI_SCRIPT_PROPERTY_FILEPATH);
+            rb_hash_aset(script, qv_sym_type, type_names[i]);
+            quvi_script_get(handle->q, types[i], QUVI_SCRIPT_PROPERTY_DOMAINS, &s);
+            if (strlen(s) > 0) {
+                VALUE domains = rb_external_str_new_cstr(s);
+                rb_hash_aset(script, qv_sym_domains, rb_str_split(domains, ","));
+            }
+            set_property(qv_sym_export_format, QUVI_SCRIPT_PROPERTY_EXPORT_FORMAT);
+#undef set_property
+
+            rb_yield(script);
+        }
+    }
+    return Qnil;
+}
+
+typedef struct qv_media_new_params_st
+{
+    qv_handle_t *handle;
+    char *url;
+    quvi_media_t res;
+} qv_media_new_params_t;
+
+static void* qv_media_new_nogvl(void *data1)
+{
+    qv_media_new_params_t *params = data1;
+    params->res = quvi_media_new(params->handle->q, params->url);
+    return 0;
+}
+
+VALUE qv_handle_parse_media(VALUE self, VALUE url)
+{
+    qv_media_new_params_t params;
+    VALUE media, streams, stream;
+    double d;
+    char *s, *best;
+
+    params.handle = DATA_PTR(self);
+    params.url = StringValueCStr(url);
+
+    rb_thread_call_without_gvl(qv_media_new_nogvl, &params, RUBY_UBF_IO, 0);
+    if (quvi_ok(params.handle->q) == QUVI_FALSE) {
+        qv_raise(params.handle, rb_sprintf("unable create quvi_media_t handle (url=%s)", params.url));
+    }
+    media = rb_hash_new();
+#define set_property_str(item, key, id) \
+    s = NULL; \
+    quvi_media_get(params.res, id, &s); \
+    if (s) { rb_hash_aset(item, key, rb_external_str_new_cstr(s)); }
+#define set_property_int(item, key, id) \
+    d = -1; \
+    quvi_media_get(params.res, id, &d); \
+    if (d > 0) { rb_hash_aset(item, key, INT2NUM((int)d)); }
+    set_property_str(media, qv_sym_id, QUVI_MEDIA_PROPERTY_ID);
+    set_property_str(media, qv_sym_title, QUVI_MEDIA_PROPERTY_TITLE);
+    set_property_str(media, qv_sym_thumbnail_url, QUVI_MEDIA_PROPERTY_THUMBNAIL_URL);
+    set_property_int(media, qv_sym_start_time_ms, QUVI_MEDIA_PROPERTY_START_TIME_MS);
+    set_property_int(media, qv_sym_duration_ms, QUVI_MEDIA_PROPERTY_DURATION_MS);
+    streams = rb_hash_aset(media, qv_sym_streams, rb_ary_new());
+    quvi_media_stream_choose_best(params.res);
+    quvi_media_get(params.res, QUVI_MEDIA_STREAM_PROPERTY_ID, &best);
+    quvi_media_stream_reset(params.res);
+    while (quvi_media_stream_next(params.res) == QUVI_TRUE) {
+        stream = rb_hash_new();
+        set_property_str(stream, qv_sym_id, QUVI_MEDIA_STREAM_PROPERTY_ID);
+        if (strcmp(best, s) == 0) {
+            rb_hash_aset(stream, qv_sym_best, Qtrue);
+        }
+        set_property_int(stream, qv_sym_video_height, QUVI_MEDIA_STREAM_PROPERTY_VIDEO_HEIGHT);
+        set_property_int(stream, qv_sym_video_width, QUVI_MEDIA_STREAM_PROPERTY_VIDEO_WIDTH);
+        set_property_str(stream, qv_sym_video_encoding, QUVI_MEDIA_STREAM_PROPERTY_VIDEO_ENCODING);
+        set_property_int(stream, qv_sym_video_bitrate_kbit_s, QUVI_MEDIA_STREAM_PROPERTY_VIDEO_BITRATE_KBIT_S);
+        set_property_str(stream, qv_sym_audio_encoding, QUVI_MEDIA_STREAM_PROPERTY_AUDIO_ENCODING);
+        set_property_int(stream, qv_sym_audio_bitrate_kbit_s, QUVI_MEDIA_STREAM_PROPERTY_AUDIO_BITRATE_KBIT_S);
+        set_property_str(stream, qv_sym_container, QUVI_MEDIA_STREAM_PROPERTY_CONTAINER);
+        set_property_str(stream, qv_sym_url, QUVI_MEDIA_STREAM_PROPERTY_URL);
+        rb_ary_push(streams, stream);
+    }
+
+#undef set_property_str
+#undef set_property_int
+    quvi_media_free(params.res);
+
+    return media;
+}
+
+typedef struct qv_playlist_new_params_st
+{
+    qv_handle_t *handle;
+    char *url;
+    quvi_playlist_t res;
+} qv_playlist_new_params_t;
+
+static void* qv_playlist_new_nogvl(void *data1)
+{
+    qv_media_new_params_t *params = data1;
+    params->res = quvi_playlist_new(params->handle->q, params->url);
+    return 0;
+}
+
+VALUE qv_handle_parse_playlist(VALUE self, VALUE url)
+{
+    qv_playlist_new_params_t params;
+    VALUE playlist, media, medium;
+    char *s;
+    double d;
+
+    params.handle = DATA_PTR(self);
+    params.url = StringValueCStr(url);
+    rb_thread_call_without_gvl(qv_playlist_new_nogvl, &params, RUBY_UBF_IO, 0);
+    if (quvi_ok(params.handle->q) == QUVI_FALSE) {
+        qv_raise(params.handle, rb_sprintf("unable create quvi_media_t handle (url=%s)", params.url));
+    }
+    playlist = rb_hash_new();
+#define set_property_str(item, key, id) \
+    s = NULL; \
+    quvi_playlist_get(params.res, id, &s); \
+    if (s) { rb_hash_aset(item, key, rb_external_str_new_cstr(s)); }
+#define set_property_int(item, key, id) \
+    d = -1; \
+    quvi_playlist_get(params.res, id, &d); \
+    if (d > 0) { rb_hash_aset(item, key, INT2NUM((int)d)); }
+
+    set_property_str(playlist, qv_sym_id, QUVI_PLAYLIST_PROPERTY_ID);
+    set_property_str(playlist, qv_sym_title, QUVI_PLAYLIST_PROPERTY_TITLE);
+    set_property_str(playlist, qv_sym_thumbnail_url, QUVI_PLAYLIST_PROPERTY_THUMBNAIL_URL);
+    media = rb_hash_aset(playlist, qv_sym_media, rb_ary_new());
+    while (quvi_playlist_media_next(params.res) == QUVI_TRUE) {
+        medium = rb_hash_new();
+        set_property_str(medium, qv_sym_url, QUVI_PLAYLIST_MEDIA_PROPERTY_URL);
+        set_property_str(medium, qv_sym_title, QUVI_PLAYLIST_MEDIA_PROPERTY_TITLE);
+        set_property_int(medium, qv_sym_duration_ms, QUVI_PLAYLIST_MEDIA_PROPERTY_DURATION_MS);
+        rb_ary_push(media, medium);
+    }
+#undef set_property_str
+#undef set_property_int
+
+    quvi_playlist_free(params.res);
+    return playlist;
+}
+
 void init_quvi_handle()
 {
     qv_cHandle = rb_define_class_under(qv_mQuvi, "Handle", rb_cObject);
@@ -196,6 +388,9 @@ void init_quvi_handle()
     rb_define_method(qv_cHandle, "supports?", qv_handle_supports_p, -1);
     rb_define_method(qv_cHandle, "autoproxy=", qv_handle_autoproxy_set, 1);
     rb_define_method(qv_cHandle, "user_agent=", qv_handle_user_agent_set, 1);
+    rb_define_method(qv_cHandle, "each_script", qv_handle_each_script, 0);
+    rb_define_method(qv_cHandle, "parse_media", qv_handle_parse_media, 1);
+    rb_define_method(qv_cHandle, "parse_playlist", qv_handle_parse_playlist, 1);
 
     qv_DEFAULT_USER_AGENT = rb_const_get(qv_cHandle, rb_intern("DEFAULT_USER_AGENT"));
 }
@@ -210,6 +405,25 @@ void init_symbols()
     qv_sym_subtitle = ID2SYM(rb_intern("subtitle"));
     qv_sym_type = ID2SYM(rb_intern("type"));
     qv_sym_user_agent = ID2SYM(rb_intern("user_agent"));
+    qv_sym_export_format = ID2SYM(rb_intern("export_format"));
+    qv_sym_filepath = ID2SYM(rb_intern("filepath"));
+    qv_sym_domains = ID2SYM(rb_intern("domains"));
+    qv_sym_sha1 = ID2SYM(rb_intern("sha1"));
+    qv_sym_title = ID2SYM(rb_intern("title"));
+    qv_sym_id = ID2SYM(rb_intern("id"));
+    qv_sym_thumbnail_url = ID2SYM(rb_intern("thumbnail_url"));
+    qv_sym_start_time_ms = ID2SYM(rb_intern("start_time_ms"));
+    qv_sym_duration_ms = ID2SYM(rb_intern("duration_ms"));
+    qv_sym_video_height = ID2SYM(rb_intern("video_height"));
+    qv_sym_video_width = ID2SYM(rb_intern("video_width"));
+    qv_sym_video_encoding = ID2SYM(rb_intern("video_encoding"));
+    qv_sym_video_bitrate_kbit_s = ID2SYM(rb_intern("video_bitrate_kbit_s"));
+    qv_sym_audio_encoding = ID2SYM(rb_intern("audio_encoding"));
+    qv_sym_audio_bitrate_kbit_s = ID2SYM(rb_intern("audio_bitrate_kbit_s"));
+    qv_sym_container = ID2SYM(rb_intern("container"));
+    qv_sym_url = ID2SYM(rb_intern("url"));
+    qv_sym_streams = ID2SYM(rb_intern("streams"));
+    qv_sym_best = ID2SYM(rb_intern("best"));
 }
 
 void Init_quvi_ext()

data/lib/quvi.rb

@@ -2,3 +2,61 @@ require "quvi/version"
 require "quvi/error"
 require "quvi/handle"
 require "quvi_ext"
+
+require 'thread'
+require 'monitor'
+
+module Quvi
+  def self.parse(*urls)
+    options = urls.last.is_a?(Hash) ? urls.pop : {}
+    res = parse_multiple(urls, options)
+    urls.size == 1 ?  res.first : res
+  end
+
+  def self.parse_multiple(urls, options = {})
+    return [] if urls.empty?
+    num_threads = options.fetch(:threads) { 2 }
+    num_threads = [num_threads, urls.size].min
+    tasks = Queue.new
+    tasks.extend(MonitorMixin)
+    urls.each do |url|
+      tasks.push([:media, url])
+      tasks.push([:playlist, url])
+    end
+    tasks_tbd = tasks.size
+    done = tasks.new_cond
+    results = Queue.new
+    threads = Array.new(num_threads) do
+      Thread.new do
+        handle = Quvi::Handle.new(options)
+        loop do
+          type, url = tasks.pop
+          begin
+            if res = handle.parse(url, options.merge(:type => type))
+              results.push([url, res])
+            end
+          rescue Quvi::Error => ex
+            results.push([url, ex])
+          ensure
+            tasks.synchronize do
+              tasks_tbd -= 1
+              done.signal
+              break if tasks_tbd <= 0
+            end
+          end
+        end
+      end
+    end
+    tasks.synchronize do
+      done.wait_while do
+        tasks_tbd > 0
+      end
+    end if tasks_tbd > 0
+    res = []
+    until results.empty?
+      u, r = results.pop
+      res[urls.index(u)] = r
+    end
+    res
+  end
+end

data/lib/quvi/handle.rb

@@ -2,6 +2,16 @@ module Quvi
   class Handle
     DEFAULT_USER_AGENT = "Mozilla/5.0".freeze
 
-    attr_accessor :user_agent, :allow_cookies, :user_agent
+    attr_accessor :user_agent, :allow_cookies
+
+    def parse(url, options = {})
+      online = options.fetch(:online) { true }
+      type = options.fetch(:type) { true }
+      if supports?(url, :type => type, :online => online)
+        res = send("parse_#{type}", url)
+        res[:type] = type
+        res
+      end
+    end
   end
-end
+ end

data/lib/quvi/version.rb

@@ -1,8 +1,8 @@
 module Quvi
   module VERSION
     MAJOR = 0
-    MINOR = 0
-    PATCH = 1
+    MINOR = 1
+    PATCH = 0
     FULL = [MAJOR, MINOR, PATCH].join(".").freeze
 
     def self.to_str

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: quvi
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Sergey Avseyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-03 00:00:00.000000000 Z
+date: 2014-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: This is the wrapper for libquvi library, which allows to extract media
@@ -47,7 +47,7 @@ extensions:
 - ext/quvi_ext/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - Guardfile
 - LICENSE
@@ -72,17 +72,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: The library to parse the media stream properties.