Module: DTAS::Source::AvFfCommon

Includes:
File, XS
Included in:
Av, Ff
Defined in:
lib/dtas/source/av_ff_common.rb

Overview

Common code for libav (avconv/avprobe) and ffmpeg (and ffprobe) TODO: newer versions of both *probes support JSON, which will be easier to parse. However, the packaged libav version in Debian 7.0 does not support JSON, so we have an ugly parser…

Defined Under Namespace

Classes: AStream

Constant Summary collapse

AV_FF_TRYORDER = 
1

Constants included from File

File::FILE_SIVS, File::SRC_SIVS

Constants included from Process

Process::PIDS

Constants included from Command

Command::COMMAND_DEFAULTS

Instance Attribute Summary collapse

Attributes included from File

#infile, #offset, #tryorder

Attributes included from Common

#dst, #dst_zero_byte, #requeued

Attributes included from Command

#command, #env, #pid, #spawn_at, #to_io

Instance Method Summary collapse

Methods included from XS

#xs

Methods included from File

#__file_init, #comments, #cuebreakpoints, #load!, #offset_samples, #offset_us, #replaygain, #samples!, #source_file_dup, #to_hash, #to_source_cat, #to_state_hash

Methods included from Mp3gain

#__mp3gain_peak, #mp3gain_comments

Methods included from Process

#dtas_spawn, #env_expand, #qx, reaper

Methods included from Common

#dst_assoc

Methods included from Command

#command_init, #command_string, #on_death

Methods included from DTAS::Serialize

#ivars_to_hash

Instance Attribute Details

#format ⇒ Object (readonly)

Returns the value of attribute format.



20
21
22
 
# File 'lib/dtas/source/av_ff_common.rb', line 20

def format
  @format
end

#precision ⇒ Object (readonly)

always 32



19
20
21
 
# File 'lib/dtas/source/av_ff_common.rb', line 19

def precision
  @precision
end

Instance Method Details

#__parse_astream(cmd, stream) {|index, as| ... } ⇒ Object

Yields:

  • (index, as) 


28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/dtas/source/av_ff_common.rb', line 28

def __parse_astream(cmd, stream)
  stream =~ /^codec_type=audio$/ or return
  as = AStream.new
  index = nil
  stream =~ /^index=(\d+)\s*$/nm and index = $1.to_i
  stream =~ /^duration=([\d\.]+)\s*$/nm and as.duration = $1.to_f
  stream =~ /^channels=(\d)\s*$/nm and as.channels = $1.to_i
  stream =~ /^sample_rate=([\d\.]+)\s*$/nm and as.rate = $1.to_i
  index or raise "BUG: no audio index from #{xs(cmd)}"
  yield(index, as)
end

#amap_fallback ⇒ Object 



120
121
122
123
124
125
126
127
128
 
# File 'lib/dtas/source/av_ff_common.rb', line 120

def amap_fallback
  @astreams.each_with_index do |as, index|
    as or next
    select_astream(as)
    warn "no suitable audio stream in #@infile, trying stream=#{index}"
    return "-map 0:#{index}"
  end
  raise "BUG: no audio stream in #@infile"
end

#av_ff_ok? ⇒ Boolean

Returns:

  • (Boolean) 


46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/dtas/source/av_ff_common.rb', line 46

def av_ff_ok?
  @duration = nil
  @format = DTAS::Format.new
  @format.bits = 32 # always, since we still use the "sox" format
  @comments = {}
  @astreams = []

  # needed for VOB and other formats which scatter metadata all over the
  # place and
  @probe_harder = nil
  incomplete = []
  prev_cmd = []

  begin # loop
    cmd = %W(#@av_ff_probe)

    # using the max known duration as a analyzeduration seems to work
    # for the few VOBs I've tested, but seeking is still broken.
    max_duration = 0
    incomplete.each do |as|
      as && as.duration or next
      max_duration = as.duration if as.duration > max_duration
    end
    if max_duration > 0
      usec = max_duration.round * 1000000
      usec = "2G" if usec >= 0x7fffffff # limited to INT_MAX :<
      @probe_harder = %W(-analyzeduration #{usec} -probesize 2G)
      cmd.concat(@probe_harder)
    end
    cmd.concat(%W(-show_streams -show_format #@infile))
    break if cmd == prev_cmd

    err = ""
    s = qx(@env, cmd, err_str: err, no_raise: true)
    return false unless probe_ok?(s, err)
    s.scan(%r{^\[STREAM\]\n(.*?)\n\[/STREAM\]\n}mn) do |_|
      __parse_astream(cmd, $1) do |index, as|
        # incomplete streams may have zero channels
        if as.channels > 0 && as.rate > 0
          @astreams[index] = as
          incomplete[index] = nil
        else
          incomplete[index] = as
        end
      end
    end
    prev_cmd = cmd
  end while incomplete.compact[0]

  s.scan(%r{^\[FORMAT\]\n(.*?)\n\[/FORMAT\]\n}m) do |_|
    f = $1
    f =~ /^duration=([\d\.]+)\s*$/nm and @duration = $1.to_f
    # TODO: multi-line/multi-value/repeated tags
    f.gsub!(/^TAG:([^=]+)=(.*)$/ni) { |_| @comments[$1.upcase] = $2 }
  end
  ! @astreams.compact.empty?
end

#probe_ok?(status, err_str) ⇒ Boolean

Returns:

  • (Boolean) 


40
41
42
43
44
 
# File 'lib/dtas/source/av_ff_common.rb', line 40

def probe_ok?(status, err_str)
  return false if Process::Status === status
  return false if err_str =~ /Unable to find a suitable output format for/
  true
end

#samples ⇒ Object

This is the number of samples according to the samples in the source file itself, not the decoded output



162
163
164
165
166
 
# File 'lib/dtas/source/av_ff_common.rb', line 162

def samples
  @samples ||= (@duration * @format.rate).round
rescue
  0
end

#select_astream(as) ⇒ Object 



110
111
112
113
114
115
116
117
118
 
# File 'lib/dtas/source/av_ff_common.rb', line 110

def select_astream(as)
  @format.channels = as.channels
  @format.rate = as.rate

  # favor the duration of the stream we're playing instead of
  # duration we got from [FORMAT].  However, some streams may not have
  # a duration and only have it in [FORMAT]
  @duration = as.duration if as.duration
end

#spawn(player_format, rg_state, opts) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/dtas/source/av_ff_common.rb', line 130

def spawn(player_format, rg_state, opts)
  raise "BUG: #{self.inspect}#spawn called twice" if @to_io
  amap = nil

  # try to find an audio stream which matches our channel count
  # we need to set @format for sspos() down below
  @astreams.each_with_index do |as, i|
    if as && as.channels == player_format.channels
      select_astream(as)
      amap = "-map 0:#{i}"
    end
  end

  # fall back to the first audio stream
  # we must call select_astream before sspos
  amap ||= amap_fallback

  e = @env.merge!(player_format.to_env)

  e["PROBE"] = @probe_harder ? @probe_harder.join(' ') : nil
  # make sure these are visible to the source command...
  e["INFILE"] = @infile
  e["AMAP"] = amap
  e["SSPOS"] = @offset ? sspos(@offset) : nil
  e["RGFX"] = rg_state.effect(self) || nil
  e.merge!(@rg.to_env) if @rg

  @pid = dtas_spawn(e, command_string, opts)
end

#sspos(offset) ⇒ Object 



104
105
106
107
108
 
# File 'lib/dtas/source/av_ff_common.rb', line 104

def sspos(offset)
  offset =~ /\A(\d+)s\z/ or return "-ss #{offset}"
  samples = $1.to_f
  sprintf("-ss %0.9g", samples / @format.rate)
end

#to_hsh ⇒ Object 



168
169
170
171
 
# File 'lib/dtas/source/av_ff_common.rb', line 168

def to_hsh
  sd = source_defaults
  to_hash.delete_if { |k,v| v == sd[k] }
end

#try(infile, offset = nil) ⇒ Object 



22
23
24
25
26
 
# File 'lib/dtas/source/av_ff_common.rb', line 22

def try(infile, offset = nil)
  rv = source_file_dup(infile, offset)
  rv.av_ff_ok? or return
  rv
end