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
|
# Copyright (C) 2013-2015 all contributors <dtas-all@nongnu.org>
# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
require_relative '../dtas'
require_relative 'serialize'
require_relative 'track'
# the a tracklist object for -player
# this is inspired by the MPRIS 2.0 TrackList spec
class DTAS::Tracklist # :nodoc:
include DTAS::Serialize
attr_accessor :repeat # true, false, 1
attr_reader :shuffle # false or shuffled @list
attr_accessor :max # integer
TL_DEFAULTS = {
'list' => [],
'pos' => -1,
'repeat' => false,
'max' => 20_000,
}
SIVS = TL_DEFAULTS.keys
def self.load(hash)
obj = new
obj.instance_eval do
list = hash['list'] and @list.replace(list.map { |s| new_track(s) })
%w(pos repeat max).each do |k|
instance_variable_set("@#{k}", hash[k] || TL_DEFAULTS[k])
end
# n.b.: we don't check @list.size against max here in case people
# are migrating
if hash['shuffle']
@shuffle = @list.shuffle
@pos = _idx_of(@shuffle, @list[@pos].track_id) if @pos >= 0
end
end
obj
end
def to_hsh
h = ivars_to_hash(SIVS)
h.delete_if { |k,v| TL_DEFAULTS[k] == v }
list = h['list'] and h['list'] = list.map(&:to_path)
if @shuffle
h['shuffle'] = true
h['pos'] = _idx_of(@list, @shuffle[@pos].track_id) if @pos >= 0
end
h
end
def initialize
TL_DEFAULTS.each { |k,v| instance_variable_set("@#{k}", v) }
@list = []
@goto_off = @goto_pos = nil
@track_nr = 0
@shuffle = false
end
def new_track(path)
n = @track_nr += 1
# nobody needs a billion tracks in their tracklist, right?
# avoid promoting to Bignum on 32-bit
@track_nr = n = 1 if n >= 0x3fffffff
DTAS::Track.new(n, path)
end
def reset
@goto_off = @goto_pos = nil
@pos = TL_DEFAULTS["pos"]
@shuffle.shuffle! if @shuffle
end
def get_tracks(track_ids)
want = {}
track_ids.each { |i| want[i] = i }
rv = []
@list.each do |t|
i = want[t.track_id] and rv << [ i, t.to_path ]
end
rv
end
def _update_pos(pos, prev, list)
old = prev[pos]
_idx_of(list, old.track_id)
end
def shuffle=(bool)
prev = @shuffle
if bool
list = @shuffle = (prev ||= @list).shuffle
elsif prev
@shuffle = false
list = @list
else
return false
end
@pos = _update_pos(@pos, prev, list) if @pos >= 0
@goto_pos = _update_pos(@goto_pos, prev, list) if @goto_pos
end
def tracks
@list.map(&:track_id)
end
def advance_track(repeat_ok = true)
cur = @shuffle || @list
return if cur.empty?
# @repeat == 1 for single track repeat
repeat = repeat_ok ? @repeat : false
next_pos = @goto_pos || @pos + (repeat == 1 ? 0 : 1)
next_off = @goto_off # nil by default
@goto_pos = @goto_off = nil
if cur[next_pos]
@pos = next_pos
elsif repeat
next_pos = @pos = 0
else
return
end
[ cur[next_pos].to_path, next_off ]
end
def cur_track
@pos >= 0 ? (@shuffle || @list)[@pos] : nil
end
def add_track(track, after_track_id = nil, set_as_current = false)
return false if @list.size >= @max
track = new_track(track)
if after_track_id
idx = _idx_of(@list, after_track_id) or
raise ArgumentError, 'after_track_id invalid'
if @shuffle
_idx_of(@shuffle, after_track_id) or
raise ArgumentError, 'after_track_id invalid'
end
@list[idx, 1] = [ @list[idx], track ]
# add into random position if shuffling
if @shuffle
idx = rand(@shuffle.size)
@shuffle[idx, 1] = [ @shuffle[idx], track ]
end
if set_as_current
@pos = idx + 1
else
@pos += 1 if @pos > idx
end
else # nil = first_track
@list.unshift(track)
if @shuffle
if @shuffle.empty?
@shuffle << track
@pos = 0 if set_as_current
else
idx = rand(@shuffle.size)
@shuffle[idx, 1] = [ @shuffle[idx], track ]
@pos = idx + 1 if set_as_current
end
else
if set_as_current
@pos = 0
else
@pos += 1 if @pos >= 0
end
end
end
track.track_id
end
def _idx_of(list, track_id)
list.index { |t| t.track_id == track_id }
end
def remove_track(track_id)
idx = _idx_of(@list, track_id) or return false
if @shuffle
si = _idx_of(@shuffle, track_id) or return false
@shuffle.delete_at(si)
end
track = @list.delete_at(idx)
len = @list.size
if @pos >= len
@pos = len == 0 ? TL_DEFAULTS["pos"] : len
end
@goto_pos = @goto_pos = nil # TODO: reposition?
track.to_path
end
def clear
@list.clear
@shuffle.clear if @shuffle
reset
end
def go_to(track_id, offset_hhmmss = nil)
list = @shuffle || @list
if idx = _idx_of(list, track_id)
@goto_off = offset_hhmmss
return list[@goto_pos = idx].to_path
end
@goto_pos = nil
# noop if track_id is invalid
end
def previous!
return if @list.empty?
prev_idx = @pos - 1
if prev_idx < 0
# stop playback if nothing to go back to.
prev_idx = @repeat ? @list.size - 1 : @list.size
end
@goto_pos = prev_idx
end
end
|