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 }