Class: Ffprober::Parser

Inherits:
Object
  • Object
show all
Defined in:
lib/ffprober/parser.rb

Constant Summary collapse

@@options = 
'-v quiet -print_format json -show_format -show_streams'
@@version_regex = 
/^ffprobe version (\d+)\.?(\d+)\.?(|\d+)$/

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.ffprobe_path ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/ffprober/parser.rb', line 52

def ffprobe_path
  name = 'ffprobe'

  if File.executable? name
    cmd
  else
    path = ENV['PATH'].split(File::PATH_SEPARATOR).find { |path|
      File.executable? File.join(path, name)
    }
    path && File.expand_path(name, path)
  end
end

.ffprobe_version ⇒ Object 



27
28
29
30
31
32
33
34
 
# File 'lib/ffprober/parser.rb', line 27

def ffprobe_version
  version = `#{ffprobe_path} -version`.match(@@version_regex)
  raise Errno::ENOENT  if version.nil?
  major, minor, patch = version[1].to_i, version[2].to_i, version[3].to_i
  {major: major, minor: minor, patch: patch}
rescue Errno::ENOENT => e
  {major: 0, minor: 0, patch: 0}
end

.ffprobe_version_valid? ⇒ Boolean

Returns:

  • (Boolean) 


23
24
25
 
# File 'lib/ffprober/parser.rb', line 23

def ffprobe_version_valid?
  valid_versions.include?(ffprobe_version)
end

.from_file(file_to_parse) ⇒ Object 



7
8
9
10
11
12
13
14
15
 
# File 'lib/ffprober/parser.rb', line 7

def from_file(file_to_parse)
  unless ffprobe_version_valid?
    raise ArgumentError.new("no or unsupported ffprobe version found.\
                            (version: #{ffprobe_version})")
  end

  json_output = `#{ffprobe_path} #{@@options} #{file_to_parse}`
  from_json(json_output)
end

.from_json(json_to_parse) ⇒ Object 



17
18
19
20
21
 
# File 'lib/ffprober/parser.rb', line 17

def from_json(json_to_parse)
  parser = self.new
  parser.parse(json_to_parse)
  parser
end

.valid_versions ⇒ Object 



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/ffprober/parser.rb', line 36

def valid_versions
  [
    {major: 0, minor: 9, patch: 0},
    {major: 0, minor: 10, patch: 0},
    {major: 0, minor: 11, patch: 0},
    {major: 1, minor: 0, patch: 0},
    {major: 1, minor: 0, patch: 1},
    {major: 1, minor: 1, patch: 0},
    {major: 1, minor: 1, patch: 1},
    {major: 1, minor: 1, patch: 2},
    {major: 1, minor: 1, patch: 3},
    {major: 1, minor: 1, patch: 4},
    {major: 1, minor: 2, patch: 0}
  ]
end

Instance Method Details

#audio_streams ⇒ Object 



81
82
83
84
85
 
# File 'lib/ffprober/parser.rb', line 81

def audio_streams
  @video_json[:streams].select { |stream| stream[:codec_type] == 'audio'}.map do |s|
    Ffprober::AudioStream.new(s)
  end
end

#format ⇒ Object 



71
72
73
 
# File 'lib/ffprober/parser.rb', line 71

def format
  Ffprober::Format.new(@video_json[:format])
end

#parse(json_to_parse) ⇒ Object

Raises:

  • (ArgumentError) 


66
67
68
69
 
# File 'lib/ffprober/parser.rb', line 66

def parse(json_to_parse)
  raise ArgumentError.new("No JSON found") if json_to_parse.nil?
  @video_json = JSON.parse(json_to_parse, symbolize_names: true)
end

#video_streams ⇒ Object 



75
76
77
78
79
 
# File 'lib/ffprober/parser.rb', line 75

def video_streams
  @video_json[:streams].select { |stream| stream[:codec_type] == 'video'}.map do |s|
    Ffprober::VideoStream.new(s)
  end
end