static void do_store()
{
input_stop();
conf_store();
input_start();
OK();
}
static void do_load()
{
input_stop();
conf_load();
OK();
input_calibrate(CHANNELS);
input_start();
}
void playlist_prev(void)
{
GList *plist_pos_list;
gboolean restart_playing = FALSE;
PL_LOCK();
if (!playlist)
{
PL_UNLOCK();
return;
}
plist_pos_list = find_playlist_position_list();
if (!cfg.repeat && !g_list_previous(plist_pos_list))
{
PL_UNLOCK();
return;
}
if (get_input_playing())
{
/* We need to stop before changing playlist_position */
PL_UNLOCK();
input_stop();
PL_LOCK();
restart_playing = TRUE;
}
plist_pos_list = find_playlist_position_list();
if (g_list_previous(plist_pos_list))
playlist_position = plist_pos_list->prev->data;
else if (cfg.repeat)
{
GList *node;
playlist_position = NULL;
__playlist_generate_shuffle_list();
if (cfg.shuffle)
node = g_list_last(shuffle_list);
else
node = g_list_last(playlist);
if (node)
playlist_position = node->data;
}
PL_UNLOCK();
playlist_check_pos_current();
if (restart_playing)
playlist_play();
else
{
mainwin_set_info_text();
playlistwin_update_list();
}
}
static void do_conf()
{
char c = 0;
char line[64];
int args, id, num, gain, min, max;
struct chan *channel;
gets(line);
args = sscanf(line, "%c %u %u %i %i", &c, &num, &gain, &min, &max);
if (args > 0) {
id = CHANNEL_ID(c);
if (id >= CHANNELS)
NOK();
else if (args == 1) {
channel = conf_get(id);
printf("%c %u %u %i %i\n", c, channel->num, channel->gain, channel->min, channel->max);
}
else {
int tmp;
input_stop();
channel = conf_get(id);
tmp = channel->gain;
channel->num = limit(num, 0, AD_CHANNELS);
if (args >= 3) {
channel->gain = limit(gain, AD_GAIN_MIN, AD_GAIN_MAX);
if (tmp != channel->gain)
input_calibrate(id);
}
if (args == 4) {
max = limit(min, 0, AD_VMAX);
min = limit(-min, AD_VMIN, 0);
channel->min = min;
channel->max = max;
}
else if (args >= 5) {
channel->min = limit(min, AD_VMIN, AD_VMAX);
channel->max = limit(max, channel->min, AD_VMAX);
}
printf("ok %c %u %u %i %i\n", c, channel->num, channel->gain, channel->min, channel->max);
input_start();
}
}
else NOK();
}
// Wait for some event
static bool poll_uv_loop(int32_t ms)
{
bool timed_out;
uv_run_mode run_mode = UV_RUN_ONCE;
if (input_ready()) {
// If there's a pending input event to be consumed, do it now
return true;
}
input_start();
timed_out = false;
if (ms > 0) {
// Timeout passed as argument to the timer
timer.data = &timed_out;
// We only start the timer after the loop is running, for that we
// use an prepare handle(pass the interval as data to it)
timer_prepare.data = &ms;
uv_prepare_start(&timer_prepare, timer_prepare_cb);
} else if (ms == 0) {
// For ms == 0, we need to do a non-blocking event poll by
// setting the run mode to UV_RUN_NOWAIT.
run_mode = UV_RUN_NOWAIT;
}
do {
// Run one event loop iteration, blocking for events if run_mode is
// UV_RUN_ONCE
uv_run(uv_default_loop(), run_mode);
} while (
// Continue running if ...
!input_ready() && // we have no input
!has_pending_events() && // no events are waiting to be processed
run_mode != UV_RUN_NOWAIT && // ms != 0
!timed_out // we didn't get a timeout
);
input_stop();
if (ms > 0) {
// Stop the timer
uv_timer_stop(&timer);
}
return input_ready() || has_pending_events();
}
void playlist_set_position(int pos)
{
GList *node;
gboolean restart_playing = FALSE;
PL_LOCK();
if (!playlist)
{
PL_UNLOCK();
return;
}
node = g_list_nth(playlist, pos);
if (!node)
{
PL_UNLOCK();
return;
}
if (get_input_playing())
{
/* We need to stop before changing playlist_position */
PL_UNLOCK();
input_stop();
PL_LOCK();
restart_playing = TRUE;
}
playlist_position = node->data;
PL_UNLOCK();
playlist_check_pos_current();
if (restart_playing)
playlist_play();
else
{
mainwin_set_info_text();
playlistwin_update_list();
}
/*
* Regenerate the shuffle list when the user set a position
* manually
*/
playlist_generate_shuffle_list();
}
int input_stop_all() {
registry_lock();
int res = POM_OK;
struct input *tmp;
for (tmp = input_head; tmp ; tmp = tmp->next) {
if (tmp->running == INPUT_RUN_RUNNING) {
res += input_stop(tmp);
}
}
registry_unlock();
return (res == POM_OK ? POM_OK : POM_ERR);
}
void playlist_eof_reached(void)
{
GList *plist_pos_list;
input_stop();
PL_LOCK();
plist_pos_list = find_playlist_position_list();
if (cfg.no_playlist_advance)
{
PL_UNLOCK();
mainwin_clear_song_info();
if (cfg.repeat)
playlist_play();
return;
}
if (queued_list)
play_queued();
else if (!g_list_next(plist_pos_list))
{
if (cfg.shuffle)
{
playlist_position = NULL;
__playlist_generate_shuffle_list();
}
else
playlist_position = playlist->data;
if (!cfg.repeat)
{
PL_UNLOCK();
mainwin_clear_song_info();
mainwin_set_info_text();
return;
}
}
else
playlist_position = plist_pos_list->next->data;
PL_UNLOCK();
playlist_check_pos_current();
playlist_play();
mainwin_set_info_text();
playlistwin_update_list();
}
void playlist_clear(void)
{
GList *node;
PlaylistEntry *entry;
if (get_input_playing())
input_stop();
PL_LOCK();
if (playlist)
{
node = playlist;
while (node)
{
entry = node->data;
if (entry->filename)
g_free(entry->filename);
if (entry->title)
g_free(entry->title);
g_free(entry);
node = node->next;
}
g_list_free(playlist);
playlist = NULL;
playlist_position = NULL;
}
if (queued_list)
{
g_list_free(queued_list);
queued_list = NULL;
}
PL_UNLOCK();
playlist_generate_shuffle_list();
playlistwin_update_list();
}
static void do_info()
{
char c;
int i, tmp;
struct chan *channel;
input_stop();
if ((c = getchar()) == 'V') {
tmp = AD7793_voltmon();
printf("%u.%uV\n", tmp/1000000, tmp%1000000);
}
else if (c == 'T') {
tmp = AD7793_temperature();
printf("%u.%uC\n", tmp/10000, tmp%10000);
}
else {
if ((i = CHANNEL_ID(c)) < CHANNELS) // print only one channel
tmp = i+1;
else { // print all channels and state information
i = 0;
tmp = CHANNELS;
printf("%s\n", STATE_NAME(state_getState()));
}
while (i < tmp) {
channel = conf_get(i);
printf("%c %s ch%u %ux %i ... %i %iuV\n",
CHANNEL_NAME(i), ERROR_NAME(state_getError(i)),
channel->num, 1<<channel->gain,
channel->min, channel->max,
input_latest(i));
i++;
}
}
input_start();
}
// Wait for some event
bool event_poll(int32_t ms)
{
uv_run_mode run_mode = UV_RUN_ONCE;
if (input_ready()) {
// If there's a pending input event to be consumed, do it now
return true;
}
static int recursive = 0;
if (!(recursive++)) {
// Only needs to start the libuv handle the first time we enter here
input_start();
}
uv_timer_t timer;
uv_prepare_t timer_prepare;
TimerData timer_data = {.ms = ms, .timed_out = false, .timer = &timer};
if (ms > 0) {
uv_timer_init(uv_default_loop(), &timer);
// This prepare handle that actually starts the timer
uv_prepare_init(uv_default_loop(), &timer_prepare);
// Timeout passed as argument to the timer
timer.data = &timer_data;
// We only start the timer after the loop is running, for that we
// use a prepare handle(pass the interval as data to it)
timer_prepare.data = &timer_data;
uv_prepare_start(&timer_prepare, timer_prepare_cb);
} else if (ms == 0) {
// For ms == 0, we need to do a non-blocking event poll by
// setting the run mode to UV_RUN_NOWAIT.
run_mode = UV_RUN_NOWAIT;
}
do {
// Run one event loop iteration, blocking for events if run_mode is
// UV_RUN_ONCE
uv_run(uv_default_loop(), run_mode);
// Process immediate events outside uv_run since libuv event loop not
// support recursion(processing events may cause a recursive event_poll
// call)
event_process(false);
} while (
// Continue running if ...
!input_ready() && // we have no input
!event_has_deferred() && // no events are waiting to be processed
run_mode != UV_RUN_NOWAIT && // ms != 0
!timer_data.timed_out); // we didn't get a timeout
if (!(--recursive)) {
// Again, only stop when we leave the top-level invocation
input_stop();
}
if (ms > 0) {
// Ensure the timer-related handles are closed and run the event loop
// once more to let libuv perform it's cleanup
uv_close((uv_handle_t *)&timer, NULL);
uv_close((uv_handle_t *)&timer_prepare, NULL);
uv_run(uv_default_loop(), UV_RUN_NOWAIT);
event_process(false);
}
return input_ready() || event_has_deferred();
}
bool event_has_deferred()
{
return !kl_empty(get_queue(true));
}
// Push an event to the queue
void event_push(Event event, bool deferred)
{
*kl_pushp(Event, get_queue(deferred)) = event;
}
static int input_pcap_read(struct input *i) {
struct input_pcap_priv *p = i->priv;
if (p->type == input_pcap_type_dir && !p->tpriv.dir.files) {
if (input_pcap_dir_open(i) != POM_OK) {
// Don't error out if the scan was interrupted
if (p->tpriv.dir.interrupt_scan)
return POM_OK;
return POM_ERR;
}
}
struct pcap_pkthdr *phdr;
const u_char *data;
int result = pcap_next_ex(p->p, &phdr, &data);
if (phdr->len > phdr->caplen && !p->warning) {
pomlog(POMLOG_WARN "Warning, some packets were truncated at capture time on input %s", i->name);
p->warning = 1;
}
if (result < 0) { // End of file or error
if (p->type == input_pcap_type_dir) {
if (result != -2)
pomlog(POMLOG_WARN "Error while reading packet from file : %s. Moving on the next file ...", pcap_geterr(p->p), p->tpriv.dir.cur_file->filename);
pcap_close(p->p);
p->p = NULL;
p->warning = 0;
if (input_pcap_dir_open_next(p) != POM_OK)
return POM_ERR;
if (!p->tpriv.dir.cur_file) {
// No more file
return input_stop(i);
}
result = pcap_next_ex(p->p, &phdr, &data);
if (result < 0) {
pomlog(POMLOG_ERR "Error while reading first packet of new file");
return POM_ERR;
}
} else {
if (result == -2) // EOF
return input_stop(i);
pomlog(POMLOG_ERR "Error while reading file : %s", pcap_geterr(p->p));
return POM_ERR;
}
}
if (result == 0) // Timeout
return POM_OK;
struct packet *pkt = packet_alloc();
if (!pkt)
return POM_ERR;
if (packet_buffer_alloc(pkt, phdr->caplen - p->skip_offset, p->align_offset) != POM_OK) {
packet_release(pkt);
return POM_ERR;
}
pkt->input = i;
pkt->datalink = p->datalink_proto;
pkt->ts = pom_timeval_to_ptime(phdr->ts);
memcpy(pkt->buff, data + p->skip_offset, phdr->caplen - p->skip_offset);
unsigned int flags = 0, affinity = 0;
if (p->type == input_pcap_type_interface)
flags = CORE_QUEUE_DROP_IF_FULL;
#ifdef DLT_MPEG_2_TS
if (p->datalink_type == DLT_MPEG_2_TS) {
// MPEG2 TS has thread affinity based on the PID
flags |= CORE_QUEUE_HAS_THREAD_AFFINITY;
affinity = ((((char*)pkt->buff)[1] & 0x1F) << 8) | ((char *)pkt->buff)[2];
}
#endif
return core_queue_packet(pkt, flags, affinity);
}
void playlist_play(void)
{
char *filename = NULL;
if (get_playlist_length() == 0)
return;
/* If the user wants a skin randomly selected on play */
if (cfg.random_skin_on_play)
{
/* Get the current skin list */
scan_skins();
/* If there are entries */
if (g_list_length(skinlist)) {
/* Get a random value to select the skin to use */
int randval = (gint)(random() / (RAND_MAX + 1.0) * (g_list_length(skinlist) + 1));
/* If the random value is 0, use the default skin */
/* Otherwise subtract 1 from the random value and */
/* select the skin */
if (randval == 0)
load_skin(NULL);
else
{
struct SkinNode *skin;
skin = g_list_nth(skinlist, randval - 1)->data;
load_skin(skin->path);
}
}
/* Call scan_skins() again to make sure skin selector */
/* is up to date */
scan_skins();
}
if (get_input_playing())
input_stop();
vis_clear_data(mainwin_vis);
vis_clear_data(playlistwin_vis);
svis_clear_data(mainwin_svis);
mainwin_disable_seekbar();
PL_LOCK();
if (playlist)
{
if (!playlist_position)
{
if (cfg.shuffle)
playlist_position = shuffle_list->data;
else
playlist_position = playlist->data;
}
filename = playlist_position->filename;
}
PL_UNLOCK();
if (!filename)
return;
input_play(filename);
if (input_get_time() != -1)
{
equalizerwin_load_auto_preset(filename);
input_set_eq(cfg.equalizer_active, cfg.equalizer_preamp,
cfg.equalizer_bands);
}
playlist_check_pos_current();
}
void playlist_delete_node(GList *node, gboolean *set_info_text, gboolean *restart_playing)
{
/* Caller should hold playlist mutex */
PlaylistEntry *entry = node->data;
GList *playing_song = NULL;
GList *queued_song = NULL;
/*
* We call g_list_find manually here because
* we don't want an item in the shuffle_list
*/
if (playlist_position)
playing_song = g_list_find(playlist, playlist_position);
/*
* Remove the song from the queue first if it is there, so
* that that we avoid trying to play it again
*/
if ((queued_song = g_list_find(queued_list, entry)) != NULL)
{
queued_list = g_list_remove_link(queued_list, queued_song);
g_list_free_1(queued_song);
}
if (playing_song == node)
{
*set_info_text = TRUE;
if (get_input_playing())
{
PL_UNLOCK();
input_stop();
PL_LOCK();
*restart_playing = TRUE;
}
playing_song = find_playlist_position_list();
if (queued_list)
play_queued();
else if (g_list_next(playing_song))
playlist_position = playing_song->next->data;
else if (g_list_previous(playing_song))
playlist_position = playing_song->prev->data;
else
playlist_position = NULL;
/* Make sure the entry did not disappear under us */
if (g_list_index(get_playlist(), entry) == -1)
return;
}
else if (playing_song &&
g_list_position(playlist, playing_song) >
g_list_position(playlist, node))
*set_info_text = TRUE;
if (entry->filename)
g_free(entry->filename);
if (entry->title)
g_free(entry->title);
shuffle_list = g_list_remove(shuffle_list, entry);
playlist = g_list_remove_link(playlist, node);
g_free(entry);
g_list_free_1(node);
}
