dash_timeline_validator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 30a521b9bae3596ae9e89cc90d388a722ad5d3ec4f9871d9747af1f46ad94fd1
+  data.tar.gz: 0b5b89822ad89fac58a53a927a4fa257c331de9762c40fa2e304de12ac307f15
+SHA512:
+  metadata.gz: ea0620b668d4b5803ecba5ce47811cc584eb8b07c757213ea72bf922bc774531da6e524e0971f06f858d50b138d2cbe5f00348c85578888ac4f5898c7b2c72e0
+  data.tar.gz: 90722730b66e4127aa8d26031a62d6eeab56adb7cee875f8d43291e796f353455716f6fd521db3edf9dced3ae386ad22201e7125c193e1a775d58dd6c4e8863a

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/*.gem
+/data
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 2.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in dash_timeline_validator.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    dash_timeline_validator (0.1.0)
+      awesome_print (~> 1.8.0)
+      iso8601 (~> 0.10.1)
+      ox (~> 2.9.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    awesome_print (1.8.0)
+    diff-lcs (1.3)
+    iso8601 (0.10.1)
+    ox (2.9.4)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  dash_timeline_validator!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.0.1

data/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019, Globo.com
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. 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.
+
+3. Neither the name of the copyright holder 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 HOLDER 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.

data/README.md

@@ -0,0 +1,44 @@
+# Dash Timeline Validator
+
+An MPEG Dash timeline validator. The validator parses the given MPD file (local or from the web) and shows information and errors of the timeline.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dash_timeline_validator'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dash_timeline_validator
+
+## Usage
+
+Run this program passing the manifest path.
+
+```
+dash_timeline_validator https://storage.googleapis.com/shaka-live-assets/player-source.mpd
+```
+
+To download and check the duration of every chunk, use the environment variable `VERIFY_SEGMENTS_DURATION` as `true`.
+
+```
+VERIFY_SEGMENTS_DURATION=true dash_timeline_validator https://storage.googleapis.com/shaka-live-assets/player-source.mpd
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/globocom/dash_timeline_validator.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dash_timeline_validator"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dash_timeline_validator.gemspec

@@ -0,0 +1,43 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "dash_timeline_validator/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "dash_timeline_validator"
+  spec.version = DashTimelineValidator::VERSION
+  spec.authors = ["Ana Carolina Castro"]
+  spec.email = ["ana.castro@corp.globo.com"]
+
+  spec.summary = %q{MPEG-Dash Timeline Validator}
+  spec.description = %q{MPEG-Dash Timeline Validator.}
+  spec.homepage = "https://github.com/globocom/dash_timeline_validator"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/globocom/dash_timeline_validator"
+    spec.metadata["changelog_uri"] = "https://github.com/globocom/dash_timeline_validator"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+          "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "iso8601", "~> 0.10.1"
+  spec.add_dependency "ox", "~> 2.9.0"
+  spec.add_dependency "awesome_print", "~> 1.8.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/exe/dash_timeline_validator

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "dash_timeline_validator"
+
+if ARGV.length == 0
+  p "You must pass the manifest!"
+  return -1
+end
+
+DashTimelineValidator::CLI.main(ARGV[0])

data/lib/dash_timeline_validator.rb

@@ -0,0 +1,14 @@
+require "dash_timeline_validator/adaptation_set"
+require "dash_timeline_validator/cli"
+require "dash_timeline_validator/file"
+require "dash_timeline_validator/log"
+require "dash_timeline_validator/options"
+require "dash_timeline_validator/period"
+require "dash_timeline_validator/report"
+require "dash_timeline_validator/representation"
+require "dash_timeline_validator/segment"
+require "dash_timeline_validator/validator"
+
+module DashTimelineValidator
+  class Error < StandardError; end
+end

data/lib/dash_timeline_validator/adaptation_set.rb

@@ -0,0 +1,17 @@
+module DashTimelineValidator
+  class AdaptationSet
+    def self.process(context, adaptation_set, index)
+      as_result = {}
+      as_result["name"] = "AdaptationSet-#{index}"
+      DashTimelineValidator::Report.fill_report(as_result, adaptation_set, "mimeType")
+      DashTimelineValidator::Report.fill_report(as_result, adaptation_set, "contentType")
+      all_representations = adaptation_set.nodes.select { |n| n.name == "Representation" }
+
+      as_result["representations"] = all_representations.each_with_index.map do |representation, i|
+        DashTimelineValidator::Representation.process({root: context[:root], previous: as_result}, representation, i)
+      end
+
+      as_result
+    end
+  end
+end

data/lib/dash_timeline_validator/cli.rb

@@ -0,0 +1,26 @@
+require "fileutils"
+
+module DashTimelineValidator
+  class CLI
+    def self.error_exit(report)
+      DashTimelineValidator::Log.info(report)
+      exit(-1)
+    end
+
+    def self.main(manifest)
+      begin
+        FileUtils.mkdir_p DashTimelineValidator::Options::ANALYZER_FOLDER
+        DashTimelineValidator::Log.info("The manifest #{manifest} will be processed at #{DashTimelineValidator::Options::ANALYZER_FOLDER} folder.")
+
+        mpd_content = DashTimelineValidator::DashFile.fetch_file(manifest)
+
+        DashTimelineValidator::Log.info(DashTimelineValidator::Validator.analyze(manifest, mpd_content))
+      rescue StandardError => e
+        DashTimelineValidator::Log.warn("There was an error: #{e.inspect}")
+        DashTimelineValidator::Log.warn(e.backtrace.join("\n\t"))
+        DashTimelineValidator::Log.warn("Removing the folder #{DashTimelineValidator::Options::ANALYZER_FOLDER}")
+        FileUtils.rm_rf DashTimelineValidator::Options::ANALYZER_FOLDER
+      end
+    end
+  end
+end

data/lib/dash_timeline_validator/file.rb

@@ -0,0 +1,34 @@
+require "net/http"
+
+module DashTimelineValidator
+  class DashFile
+    def self.fetch_file(origin, file_path = Options::ANALYZER_MANIFEST_PATH)
+      dirname = File.dirname(file_path)
+      unless File.directory? dirname
+        FileUtils.mkdir_p(dirname)
+      end
+
+      if uri? origin
+        download_and_save(origin, file_path)
+      else
+        FileUtils.cp origin, file_path
+        File.read file_path
+      end
+    end
+
+    def self.download_and_save(uri, path)
+      content = Net::HTTP.get(URI.parse(uri))
+      File.write(path, content)
+      content
+    end
+
+    def self.uri?(string)
+      uri = URI.parse(string)
+      %w( http https ).include?(uri.scheme)
+    rescue URI::BadURIError
+      false
+    rescue URI::InvalidURIError
+      false
+    end
+  end
+end

data/lib/dash_timeline_validator/log.rb

@@ -0,0 +1,17 @@
+require "awesome_print"
+
+module DashTimelineValidator
+  class Log
+    def self.info(msg)
+      ap msg
+    end
+
+    def self.warn(msg)
+      ap msg
+    end
+
+    def self.error(msg)
+      ap msg
+    end
+  end
+end

data/lib/dash_timeline_validator/options.rb

@@ -0,0 +1,12 @@
+require "securerandom"
+
+module DashTimelineValidator
+  class Options
+    ACCEPTABLE_DRIFT = ENV["ACCEPTABLE_DRIFT"] || 2
+    DEFAULT_PRESENTATION_DELAY = ENV["DEFAULT_PRESENTATION_DELAY"] || 10
+    BUFFERED_SEGMENTS = ENV["BUFFERED_SEGMENTS"] || 2
+    VERIFY_SEGMENTS_DURATION = ENV["VERIFY_SEGMENTS_DURATION"] || false
+    ANALYZER_FOLDER = ENV["ANALYZER_FOLDER"] || "data/#{SecureRandom.uuid}".freeze
+    ANALYZER_MANIFEST_PATH = ENV["ANALYZER_MANIFEST_PATH"] || "#{ANALYZER_FOLDER}/manifest.mpd".freeze
+  end
+end

data/lib/dash_timeline_validator/period.rb

@@ -0,0 +1,17 @@
+module DashTimelineValidator
+  class Period
+    def self.process(context, period, index)
+      period_result = {}
+      period_result["name"] = "Period-#{index}"
+      DashTimelineValidator::Report.fill_report(period_result, period, "start", 0, :duration_iso8601_to_i)
+
+      all_adaptation_sets = period.nodes.select { |n| n.name == "AdaptationSet" }
+
+      period_result["adaptation_sets"] = all_adaptation_sets.each_with_index.map do |adaptation_set, i|
+        DashTimelineValidator::AdaptationSet.process({root: context[:root], previous: period_result}, adaptation_set, i)
+      end
+
+      period_result
+    end
+  end
+end

data/lib/dash_timeline_validator/report.rb

@@ -0,0 +1,50 @@
+require "iso8601"
+
+module DashTimelineValidator
+  class Report
+    def self.report_info(value)
+      value
+    end
+
+    def self.report_warn(value)
+      "[WARN] #{value}"
+    end
+
+    def self.report_error(value)
+      "[ERROR] #{value}"
+    end
+
+    def self.fill_report(report, mpd_leaf, key_name, default_value = nil, parser_fn = :identity)
+      if mpd_leaf.respond_to? key_name
+        report[key_name] = Report.report_info(self.send(parser_fn, mpd_leaf[key_name]))
+      elsif default_value
+        report[key_name] = Report.report_info(self.send(parser_fn, default_value))
+      end
+    end
+
+    def self.fill_report_mandatory(report, mpd_leaf, key_name, parser_fn = :identity)
+      if !mpd_leaf.respond_to? key_name
+        report[key_name] = report_error("Mandatory #{key_name} is missing")
+        error_exit(report)
+      else
+        report[key_name] = Report.report_info(self.send(parser_fn, mpd_leaf[key_name]))
+      end
+    end
+
+    def self.duration_iso8601_to_i(start)
+      ISO8601::Duration.new(start).to_seconds
+    end
+
+    def self.time_to_i(value)
+      Time.parse(value).to_i
+    end
+
+    def self.identity(value)
+      value
+    end
+
+    def self.to_i(value)
+      value.to_i
+    end
+  end
+end

data/lib/dash_timeline_validator/representation.rb

@@ -0,0 +1,58 @@
+module DashTimelineValidator
+  class Representation
+    def self.process(context, representation, index)
+      representation_result = {}
+      representation_result["name"] = "Representation-#{index}"
+
+      DashTimelineValidator::Report.fill_report(representation_result, representation, "bandwidth")
+      DashTimelineValidator::Report.fill_report(representation_result, representation, "codecs")
+      DashTimelineValidator::Report.fill_report(representation_result, representation, "presentationTimeOffset", 0, :duration_iso8601_to_i)
+
+      if representation.respond_to? "SegmentTemplate"
+        segment_template = representation.SegmentTemplate
+        representation_result["SegmentTemplate"] = {}
+
+        DashTimelineValidator::Report.fill_report_mandatory(representation_result["SegmentTemplate"], segment_template, "timescale", :to_i)
+        DashTimelineValidator::Report.fill_report_mandatory(representation_result["SegmentTemplate"], segment_template, "media")
+        DashTimelineValidator::Report.fill_report(representation_result["SegmentTemplate"], segment_template, "initialization")
+        DashTimelineValidator::Report.fill_report_mandatory(representation_result["SegmentTemplate"], segment_template, "startNumber")
+
+        if context[:root]["mpd"]["type"].eql? "dynamic"
+          report_edge_timeline_information = report_edge_timeline_information(context, representation_result, segment_template.SegmentTimeline.nodes)
+          representation_result["SegmentTemplate"]["timeline"] = report_edge_timeline_information
+        end
+
+        if segment_template.respond_to? "SegmentTimeline"
+          DashTimelineValidator::Segment.process({root: context[:root], previous: representation_result["SegmentTemplate"]}, segment_template.SegmentTimeline.nodes)
+        end
+      end
+
+      representation_result
+    end
+
+    def self.report_edge_timeline_information(context, representation_result, ss)
+      client_wallclock = context[:root]["client_wallclock"]
+      ast = context[:root]["mpd"]["availabilityStartTime"]
+      timescale = representation_result["SegmentTemplate"]["timescale"]
+      max_duration = ss.map { |s| s[:d].to_i }.max / timescale
+      min_buffer_time = context[:root]["mpd"]["minBufferTime"]
+      suggested_resentation_delay = context[:root]["mpd"]["suggestedPresentationDelay"]
+      default_presentation_delay = [DashTimelineValidator::Options::DEFAULT_PRESENTATION_DELAY, (min_buffer_time * 1.5)].max
+      timeline_delay = suggested_resentation_delay.nil? ? default_presentation_delay : suggested_resentation_delay
+
+      # suggested streaming edge based on shaka's behavior
+      streaming_edge = client_wallclock - ast - DashTimelineValidator::Options::BUFFERED_SEGMENTS * max_duration - timeline_delay
+
+      last_segment = ss.last
+      last_available_time = (last_segment[:t].to_i + (last_segment[:d].to_i * last_segment[:r].to_i)) / timescale
+
+      if streaming_edge > last_available_time
+        report = DashTimelineValidator::Report.report_warn("Live edge is at #{streaming_edge}s but last segment in timeline starts at #{last_available_time}s")
+      else
+        report = DashTimelineValidator::Report.report_info("Live edge is at #{streaming_edge}s and last segment in timeline starts at #{last_available_time}s")
+      end
+
+      report
+    end
+  end
+end

data/lib/dash_timeline_validator/segment.rb

@@ -0,0 +1,67 @@
+module DashTimelineValidator
+  class Segment
+    def self.process(context, ss)
+      mpd_type = context[:root]["mpd"]["type"]
+      previous = context[:previous]
+      previous["S"] = []
+
+      ss.each_with_index do |s, index|
+        unless s.respond_to? "d"
+          previous["S"].push(DashTimelineValidator::Report.report_error("Segment (#{index + 1}) doen't have mandatory value for 'd'"))
+          error_exit(previous)
+        end
+        if mpd_type.eql? "dynamic" and !s.respond_to? "t"
+          previous["S"].push(DashTimelineValidator::Report.report_warn("Segment <S d='#{s[:d]}' t='#{s[:t]}'/> doen't have a value for 't', it's necessary for MPD with 'dynamic' type"))
+        end
+      end
+
+      timeline_segments = ss.map { |s| {d: s.d.to_i, t: s.respond_to?("t") ? s.t.to_i : 0, r: s.respond_to?("r") ? s.r.to_i : 0} }
+
+      current_segment_number = context[:previous]["startNumber"].to_i
+
+      timeline_segments.each_with_index do |current_segment, index|
+        unless index.zero?
+          previous_segment = timeline_segments[index - 1]
+          current_segment_time = current_segment[:t]
+          expected_segment_time = (previous_segment[:t] + (previous_segment[:d]) * (1 + previous_segment[:r]))
+          drift = (expected_segment_time - current_segment_time).abs
+          if drift > DashTimelineValidator::Options::ACCEPTABLE_DRIFT
+            previous["S"].push(DashTimelineValidator::Report.report_warn("Timeline of <S d='#{current_segment[:d]}' t='#{current_segment[:t]}'/> was expected to be #{expected_segment_time}, but is #{current_segment_time} (drift = #{drift})"))
+          end
+        end
+
+        if DashTimelineValidator::Options::VERIFY_SEGMENTS_DURATION
+          (current_segment[:r].to_i + 1).times do |i|
+            duration_report = check_segment_duration(context, current_segment, current_segment_number, i.zero?)
+            previous["S"].push(duration_report) if duration_report
+            current_segment_number += 1
+          end
+        end
+      end
+      previous.delete("S") if previous["S"].empty?
+    end
+
+    def self.check_segment_duration(context, current_segment, current_segment_number, download_init = true)
+      init = context[:previous]["initialization"]
+      media = context[:previous]["media"]
+      base_path = context[:root]["base_path"]
+      init_path = "#{DashTimelineValidator::Options::ANALYZER_FOLDER}/#{init}"
+
+      DashTimelineValidator::DashFile.fetch_file("#{base_path}/#{init}", init_path) if download_init
+
+      segment_file = media.gsub("$Number$", current_segment_number.to_s)
+      segment_path = "#{DashTimelineValidator::Options::ANALYZER_FOLDER}/#{segment_file}"
+      full_segment_path = "#{DashTimelineValidator::Options::ANALYZER_FOLDER}/#{segment_file}".gsub(".", "-complete.")
+      DashTimelineValidator::DashFile.fetch_file("#{base_path}/#{segment_file}", segment_path)
+
+      `cat #{init_path} #{segment_path} > #{full_segment_path}`
+      duration = `mediainfo --Inform="General;%Duration%"  #{full_segment_path}`.to_i
+      File.delete segment_path
+      File.delete full_segment_path
+      mediainfo_duration = duration.to_f / 1000 * context[:previous]["timescale"].to_i
+      if (mediainfo_duration != current_segment[:d])
+        return DashTimelineValidator::Report.report_warn("Mediainfo shows different duration for #{segment_file} compared to the advertised segment timeline item (#{(mediainfo_duration - current_segment[:d]).abs})")
+      end
+    end
+  end
+end

data/lib/dash_timeline_validator/validator.rb

@@ -0,0 +1,63 @@
+require "ox"
+
+module DashTimelineValidator
+  class Validator
+    def self.analyze(manifest, mpd_content)
+      report = {}
+      mpd = nil
+
+      if DashTimelineValidator::DashFile.uri? manifest
+        uri = URI(manifest)
+        report["base_path"] = DashTimelineValidator::Report.report_info("#{uri.scheme}://#{uri.host}#{uri.path.split("/").reverse.drop(1).reverse.join("/")}")
+      else
+        report["base_path"] = DashTimelineValidator::Report.report_info(DashTimelineValidator::DashFile::ANALYZER_FOLDER)
+      end
+
+      begin
+        mpd = Ox.load(mpd_content)
+      rescue
+        DashTimelineValidator::Log.error("Error while parsing #{manifest} it might be malformed (a non 2xx response)")
+        error_exit(report)
+      end
+
+      report["client_wallclock"] = DashTimelineValidator::Report.report_info(client_wallclock(mpd))
+
+      report["mpd"] = {}
+
+      DashTimelineValidator::Report.fill_report(report["mpd"], mpd.MPD, "type", "static")
+      DashTimelineValidator::Report.fill_report_mandatory(report["mpd"], mpd.MPD, "minBufferTime", :duration_iso8601_to_i)
+
+      if report["mpd"]["type"] == "dynamic"
+        DashTimelineValidator::Report.fill_report_mandatory(report["mpd"], mpd.MPD, "availabilityStartTime", :time_to_i)
+        if mpd.MPD.respond_to? "suggestedPresentationDelay"
+          DashTimelineValidator::Report.fill_report(report["mpd"], mpd.MPD, "suggestedPresentationDelay", 0, :duration_iso8601_to_i)
+        end
+      else
+        DashTimelineValidator::Report.fill_report(report["mpd"], mpd.MPD, "availabilityStartTime", Time.now.iso8601(0), :time_to_i)
+      end
+
+      all_periods = mpd.MPD.nodes.select { |n| n.name == "Period" }
+      report["mpd"]["periods"] = all_periods.each_with_index.map do |period, index|
+        DashTimelineValidator::Period.process({root: report, previous: report["mpd"]}, period, index)
+      end
+
+      report
+    end
+
+    def self.client_wallclock(mpd)
+      if mpd.MPD.respond_to? "UTCTiming"
+        if mpd.MPD.UTCTiming["schemeIdUri"].eql? "urn:mpeg:dash:utc:direct:2014"
+          raw_time = mpd.MPD.UTCTiming["value"]
+        elsif mpd.MPD.UTCTiming["schemeIdUri"].eql? "urn:mpeg:dash:utc:http-iso:2014"
+          raw_time = Net::HTTP.get(URI.parse(mpd.MPD.UTCTiming["value"]))
+        end
+      end
+
+      if raw_time.nil?
+        return DateTime.now.to_time.to_i
+      end
+
+      DateTime.parse(raw_time).to_time.to_i
+    end
+  end
+end

data/lib/dash_timeline_validator/version.rb

@@ -0,0 +1,3 @@
+module DashTimelineValidator
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: dash_timeline_validator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ana Carolina Castro
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-04-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: iso8601
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+- !ruby/object:Gem::Dependency
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: MPEG-Dash Timeline Validator.
+email:
+- ana.castro@corp.globo.com
+executables:
+- dash_timeline_validator
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dash_timeline_validator.gemspec
+- exe/dash_timeline_validator
+- lib/dash_timeline_validator.rb
+- lib/dash_timeline_validator/adaptation_set.rb
+- lib/dash_timeline_validator/cli.rb
+- lib/dash_timeline_validator/file.rb
+- lib/dash_timeline_validator/log.rb
+- lib/dash_timeline_validator/options.rb
+- lib/dash_timeline_validator/period.rb
+- lib/dash_timeline_validator/report.rb
+- lib/dash_timeline_validator/representation.rb
+- lib/dash_timeline_validator/segment.rb
+- lib/dash_timeline_validator/validator.rb
+- lib/dash_timeline_validator/version.rb
+homepage: https://github.com/globocom/dash_timeline_validator
+licenses: []
+metadata:
+  homepage_uri: https://github.com/globocom/dash_timeline_validator
+  source_code_uri: https://github.com/globocom/dash_timeline_validator
+  changelog_uri: https://github.com/globocom/dash_timeline_validator
+post_install_message: 
+rdoc_options: []
+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.7.3
+signing_key: 
+specification_version: 4
+summary: MPEG-Dash Timeline Validator
+test_files: []