1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
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
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
| | # Copyright (C) 2013-2014, Eric Wong <e@80x24.org> and all contributors
# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
# Unlike the stuff for dtas-player, dtas-splitfx is fairly tied to sox
# (but we may still pipe to ecasound or anything else)
require_relative '../dtas'
require_relative 'format'
require_relative 'process'
require_relative 'xs'
require 'tempfile'
class DTAS::SplitFX # :nodoc:
CMD = 'sox "$INFILE" $COMMENTS $OUTFMT "$TRACKNUMBER.$SUFFIX" '\
'$TRIMFX $RATEFX $DITHERFX'
include DTAS::Process
include DTAS::XS
attr_reader :infile, :env
class Skip < Struct.new(:tstart) # :nodoc:
def commit(_)
# noop
end
end
class T < Struct.new(:env, :comments, :tstart, :fade_in, :fade_out) # :nodoc:
def commit(advance_track_samples)
tlen = advance_track_samples - tstart
trimfx = "trim #{tstart}s #{tlen}s"
if fade_in
trimfx << " #{fade_in}"
end
if fade_out
tmp = fade_out.dup
fade_out_len = tmp.pop or
raise ArgumentError, "fade_out needs a time value"
fade_type = tmp.pop # may be nil
fade = " fade #{fade_type} 0 #{tlen}s #{fade_out_len}"
trimfx << fade
end
env["TRIMFX"] = trimfx
end
end
# vars:
# $CHANNELS (input)
# $BITS_PER_SAMPLE (input)
def initialize
@env = {}
@comments = {}
@track_start = 1
@track_zpad = true
@t2s = method(:t2s)
@infile = nil
@targets = {
"flac-cdda" => {
"command" => CMD,
"format" => {
"bits" => 16,
"rate" => 44100,
"type" => "flac",
"channels" => 2,
},
},
"opusenc" => {
"command" => 'sox "$INFILE" $COMMENTS $OUTFMT - ' \
'$TRIMFX $RATEFX $DITHERFX | opusenc --music ' \
'--raw-bits $BITS_PER_SAMPLE ' \
'$OPUSENC_BITRATE --raw-rate $RATE --raw-chan $CHANNELS ' \
'--raw-endianness $ENDIAN_OPUSENC ' \
'$OPUSENC_COMMENTS ' \
'- $TRACKNUMBER.opus',
"format" => {
"bits" => 16,
"rate" => 48000,
"type" => "s16",
"channels" => 2,
},
},
}
@tracks = []
@infmt = nil # wait until input is assigned
@cuebp = nil # for playback
end
def _bool(hash, key)
val = hash[key]
case val
when false, true then yield val
when nil # ignore
else
raise TypeError, "'#{key}' must be boolean (true or false)"
end
end
def import(hash, overrides = {})
# merge overrides from the command-line
overrides.each do |k,v|
case v
when Hash then hash[k] = (hash[k] || {}).merge(v)
else
hash[k] = v
end
end
hash = hash.merge(overrides)
case v = hash["track_zpad"]
when Integer then @track_zpad = val
else
_bool(hash, "track_zpad") { |val| @track_zpad = val }
end
_bool(hash, "cdda_align") { |val| @t2s = method(val ? :t2s : :t2s_cdda) }
case v = hash["track_start"]
when Integer then @track_start = v
when nil
else
raise TypeError, "'track_start' must be an integer"
end
%w(comments env targets).each do |key|
case val = hash[key]
when Hash then instance_variable_get("@#{key}").merge!(val)
when nil
else
raise TypeError, "'#{key}' must be a hash"
end
end
@targets.each_value do |thsh|
case tfmt = thsh["format"]
when Hash
thsh["format"] = DTAS::Format.load(tfmt) unless tfmt.empty?
end
end
load_input!(hash)
load_tracks!(hash)
end
def load_input!(hash)
@infile = hash["infile"] or raise ArgumentError, "'infile' not specified"
if infmt = hash["infmt"] # rarely needed
@infmt = DTAS::Format.load(infmt)
else # likely
@infmt = DTAS::Format.from_file(@env, @infile)
end
end
def generic_target(target = "flac")
outfmt = @infmt.dup
outfmt.type = target
{ "command" => CMD, "format" => outfmt }
end
def spawn(target, t, opts)
target = @targets[target] || generic_target(target)
outfmt = target["format"]
# default format:
unless outfmt
outfmt = @infmt.dup
outfmt.type = "flac"
end
env = outfmt.to_env
# set very high quality resampling if using 24-bit or higher output
if outfmt.rate != @infmt.rate
if outfmt.bits
# set very-high resampling quality for 24-bit outputs
quality = "-v" if outfmt.bits >= 24
else
# assume output bits matches input bits
quality = "-v" if @infmt.bits >= 24
end
env["RATEFX"] = "rate #{quality} #{outfmt.rate}"
end
# add noise-shaped dither for 16-bit (sox manual seems to recommend this)
if opts[:no_dither]
env["SOX_OPTS"] = "#{ENV["SOX_OPTS"]} -D"
else outfmt.bits && outfmt.bits <= 16
env["DITHERFX"] = "dither -s"
end
comments = Tempfile.new(%W(dtas-splitfx-#{t.comments["TRACKNUMBER"]} .txt))
comments.sync = true
t.comments.each do |k,v|
env[k] = v.to_s
comments.puts("#{k}=#{v}")
end
env["COMMENTS"] = "--comment-file=#{comments.path}"
env["INFILE"] = @infile
env["OUTFMT"] = xs(outfmt.to_sox_arg)
env["SUFFIX"] = outfmt.type
env.merge!(t.env)
command = target["command"]
tmp = Shellwords.split(command).map do |arg|
qx(env, "printf %s \"#{arg}\"")
end
echo = "echo #{xs(tmp)}"
if opts[:dryrun]
command = echo
else
system(echo) unless opts[:silent]
end
# pgroup: false so Ctrl-C on command-line will immediately stop everything
[ dtas_spawn(env, command, pgroup: false), comments ]
end
def load_tracks!(hash)
tracks = hash["tracks"] or raise ArgumentError, "'tracks' not specified"
tracks.each { |line| parse_track(Shellwords.split(line)) }
fmt = "%d"
case @track_zpad
when true
max = @track_start - 1 + @tracks.size
fmt = "%0#{max.to_s.size}d"
when Integer
fmt = "%0#{@track_zpad}d"
else
fmt = "%d"
end
nr = @track_start
@tracks.delete_if do |t|
case t
when Skip
true
else
t.comments["TRACKNUMBER"] = sprintf(fmt, nr)
nr += 1
false
end
end
end
# argv:
# [ 't', '0:05', 'track one', 'fade_in=t 4', '.comment=blah' ]
# [ 'stop', '1:00' ]
def parse_track(argv)
case cmd = argv.shift
when "t"
start_time = argv.shift
title = argv.shift
t = T.new
t.tstart = @t2s.call(start_time)
t.comments = @comments.dup
t.comments["TITLE"] = title
t.env = @env.dup
argv.each do |arg|
case arg
when %r{\Afade_in=(.+)\z}
# generate fade-in effect
# $1 = "t 4" => "fade t 4 0 0"
t.fade_in = "fade #$1 0 0"
when %r{\Afade_out=(.+)\z} # $1 = "t 4" or just "4"
t.fade_out = $1.split(/\s+/)
when %r{\A\.(\w+)=(.+)\z} then t.comments[$1] = $2
else
raise ArgumentError, "unrecognized arg(s): #{xs(argv)}"
end
end
prev = @tracks.last and prev.commit(t.tstart)
@tracks << t
when "skip"
stop_time = argv.shift
argv.empty? or raise ArgumentError, "skip does not take extra args"
s = Skip.new
s.tstart = @t2s.call(stop_time)
# s.comments = {}
# s.env = {}
prev = @tracks.last or raise ArgumentError, "no tracks to skip"
prev.commit(s.tstart)
@tracks << s
when "stop"
stop_time = argv.shift
argv.empty? or raise ArgumentError, "stop does not take extra args"
samples = @t2s.call(stop_time)
prev = @tracks.last and prev.commit(samples)
else
raise ArgumentError, "unknown command: #{xs(Array(cmd))}"
end
end
# like t2s, but align to CDDA sectors (75 frames per second)
def t2s_cdda(time)
time = time.dup
frac = 0
# fractions of a second, convert to samples based on sample rate
# taking into account CDDA alignment
if time.sub!(/\.(\d+)\z/, "")
s = "0.#$1".to_f * @infmt.rate / 75
frac = s.round * 75
end
# feed the rest to the normal function
t2s(time) + frac
end
def t2s(time)
@infmt.hhmmss_to_samples(time)
end
def run(target, opts = {})
fails = []
tracks = @tracks.dup
pids = {}
jobs = opts[:jobs] || tracks.size # jobs == nil => everything at once
jobs.times.each do
t = tracks.shift or break
pid, tmp = spawn(target, t, opts)
pids[pid] = [ t, tmp ]
end
while pids.size > 0
pid, status = Process.waitpid2(-1)
done = pids.delete(pid)
if status.success?
if t = tracks.shift
pid, tmp = spawn(target, t, opts)
pids[pid] = [ t, tmp ]
end
puts "DONE #{done[0].inspect}" if $DEBUG
done[1].close!
else
fails << [ t, status ]
end
end
return true if fails.empty? && tracks.empty?
fails.each do |(_t,s)|
warn "FAIL #{s.inspect} #{_t.inspect}"
end
false
end
def cuebreakpoints
rv = @cuebp and return rv
require_relative 'cue_index'
@cuebp = @tracks.map { |t| DTAS::CueIndex.new(1, "#{t.tstart}s") }
end
end
|