1
/*
2
 * Copyright (c) 2022 Omar Polo <op@openbsd.org>
3
 *
4
 * Permission to use, copy, modify, and distribute this software for any
5
 * purpose with or without fee is hereby granted, provided that the above
6
 * copyright notice and this permission notice appear in all copies.
7
 *
8
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
 */
16

17
#include <sys/types.h>
18

19
#include <regex.h>
20
#include <stdlib.h>
21
#include <string.h>
22
#include <syslog.h>
23

24
#include "log.h"
25
#include "xmalloc.h"
26
#include "playlist.h"
27

28
#define MAX(a, b) ((a) > (b) ? (a) : (b))
29

30
struct playlist	 playlist;
31
enum play_state	 play_state;
32
int		 repeat_one;
33
int		 repeat_all = 1;
34
ssize_t		 play_off = -1;
35
const char	*current_song;
36

37
static void
38
setsong(ssize_t i)
39
{
40
	free((char *)current_song);
41
	if (i == -1)
42
		current_song = NULL;
43
	else
44
		current_song = xstrdup(playlist.songs[i]);
45
}
46

47
void
48
playlist_swap(struct playlist *p, ssize_t off)
49
{
50
	ssize_t i = -1;
51

52
	if (off > p->len)
53
		off = -1;
54

55
	if (current_song != NULL && off < 0) {
56
		/* try to adjust play_off to match the same song */
57
		for (i = 0; i < p->len; ++i) {
58
			if (!strcmp(current_song, p->songs[i]))
59
				break;
60
		}
61
		/* try to match one song before */
62
		if (i == p->len && play_off >= 1)
63
			for (i = 0; i < p->len; ++i)
64
				if (!strcmp(current_song, p->songs[i]))
65
					break;
66
		/* or one song after */
67
		if (i == p->len && play_off < playlist.len-1)
68
			for (i = 0; i < p->len; ++i)
69
				if (!strcmp(current_song, p->songs[i]))
70
					break;
71
		if (i == p->len)
72
			i = -1;
73
	}
74

75
	playlist_truncate();
76

77
	if (i != -1)
78
		play_off = i;
79
	else if (off >= 0)
80
		play_off = off;
81

82
	playlist.len = p->len;
83
	playlist.cap = p->cap;
84
	playlist.songs = p->songs;
85

86
	if (play_state == STATE_STOPPED)
87
		setsong(play_off);
88
}
89

90
void
91
playlist_push(struct playlist *playlist, const char *path)
92
{
93
	size_t newcap;
94

95
	if (playlist->len == playlist->cap) {
96
		newcap = MAX(16, playlist->cap * 1.5);
97
		playlist->songs = xrecallocarray(playlist->songs,
98
		    playlist->cap, newcap, sizeof(*playlist->songs));
99
		playlist->cap = newcap;
100
	}
101

102
	playlist->songs[playlist->len++] = xstrdup(path);
103
}
104

105
void
106
playlist_enqueue(const char *path)
107
{
108
	playlist_push(&playlist, path);
109
}
110

111
const char *
112
playlist_advance(void)
113
{
114
	if (playlist.len == 0) {
115
		play_state = STATE_STOPPED;
116
		return NULL;
117
	}
118

119
	play_off++;
120
	if (play_off == playlist.len) {
121
		if (repeat_all)
122
			play_off = 0;
123
		else {
124
			play_state = STATE_STOPPED;
125
			play_off = -1;
126
			setsong(play_off);
127
			return NULL;
128
		}
129
	}
130

131
	setsong(play_off);
132
	play_state = STATE_PLAYING;
133
	return playlist.songs[play_off];
134
}
135

136
const char *
137
playlist_previous(void)
138
{
139
	if (playlist.len == 0) {
140
		play_state = STATE_STOPPED;
141
		return NULL;
142
	}
143

144
	play_off--;
145
	if (play_off < 0) {
146
		if (repeat_all)
147
			play_off = playlist.len - 1;
148
		else {
149
			play_state = STATE_STOPPED;
150
			play_off = -1;
151
			setsong(play_off);
152
			return NULL;
153
		}
154
	}
155

156
	setsong(play_off);
157
	play_state = STATE_PLAYING;
158
	return playlist.songs[play_off];
159
}
160

161
void
162
playlist_reset(void)
163
{
164
	play_off = -1;
165
}
166

167
void
168
playlist_free(struct playlist *playlist)
169
{
170
	size_t i;
171

172
	for (i = 0; i < playlist->len; ++i)
173
		free(playlist->songs[i]);
174
	free(playlist->songs);
175
	playlist->songs = NULL;
176

177
	playlist->len = 0;
178
	playlist->cap = 0;
179
}
180

181
void
182
playlist_truncate(void)
183
{
184
	playlist_free(&playlist);
185
	play_off = -1;
186
}
187

188
void
189
playlist_dropcurrent(void)
190
{
191
	size_t i;
192

193
	if (play_off == -1 || playlist.len == 0)
194
		return;
195

196
	free(playlist.songs[play_off]);
197
	setsong(-1);
198

199
	playlist.len--;
200
	for (i = play_off; i < playlist.len; ++i)
201
		playlist.songs[i] = playlist.songs[i+1];
202
	play_off--;
203

204
	playlist.songs[playlist.len] = NULL;
205
}
206

207
const char *
208
playlist_jump(const char *arg)
209
{
210
	size_t i;
211
	regex_t re;
212

213
	if (regcomp(&re, arg, REG_ICASE | REG_NOSUB) != 0)
214
		return NULL;
215

216
	for (i = 0; i < playlist.len; ++i) {
217
		if (regexec(&re, playlist.songs[i], 0, NULL, 0) == 0)
218
			break;
219
	}
220
	regfree(&re);
221

222
	if (i == playlist.len)
223
		return NULL;
224

225
	play_state = STATE_PLAYING;
226
	play_off = i;
227
	setsong(play_off);
228
	return playlist.songs[i];
229
}