src/decoder_control.c

   1 /*
   2  * Copyright (C) 2003-2009 The Music Player Daemon Project
   3  * http://www.musicpd.org
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include "decoder_control.h"
  21 #include "notify.h"
  22
  23 #include <assert.h>
  24
  25 struct decoder_control dc;
  26
  27 void dc_init(void)
  28 {
  29         dc.mutex = g_mutex_new();
  30         dc.cond = g_cond_new();
  31
  32         dc.state = DECODE_STATE_STOP;
  33         dc.command = DECODE_COMMAND_NONE;
  34 }
  35
  36 void dc_deinit(void)
  37 {
  38         g_cond_free(dc.cond);
  39         g_mutex_free(dc.mutex);
  40 }
  41
  42 static void
  43 dc_command_wait_locked(struct notify *notify)
  44 {
  45         while (dc.command != DECODE_COMMAND_NONE) {
  46                 decoder_signal();
  47                 decoder_unlock();
  48
  49                 notify_wait(notify);
  50
  51                 decoder_lock();
  52         }
  53 }
  54
  55 void
  56 dc_command_wait(struct notify *notify)
  57 {
  58         decoder_lock();
  59         dc_command_wait_locked(notify);
  60         decoder_unlock();
  61 }
  62
  63 static void
  64 dc_command_locked(struct notify *notify, enum decoder_command cmd)
  65 {
  66         dc.command = cmd;
  67         dc_command_wait_locked(notify);
  68 }
  69
  70 static void
  71 dc_command(struct notify *notify, enum decoder_command cmd)
  72 {
  73         decoder_lock();
  74         dc_command_locked(notify, cmd);
  75         decoder_unlock();
  76 }
  77
  78 static void dc_command_async(enum decoder_command cmd)
  79 {
  80         decoder_lock();
  81
  82         dc.command = cmd;
  83         decoder_signal();
  84
  85         decoder_unlock();
  86 }
  87
  88 void
  89 dc_start(struct notify *notify, struct song *song)
  90 {
  91         assert(dc.pipe != NULL);
  92         assert(song != NULL);
  93
  94         dc.next_song = song;
  95         dc_command(notify, DECODE_COMMAND_START);
  96 }
  97
  98 void
  99 dc_start_async(struct song *song)
 100 {
 101         assert(dc.pipe != NULL);
 102         assert(song != NULL);
 103
 104         dc.next_song = song;
 105         dc_command_async(DECODE_COMMAND_START);
 106 }
 107
 108 void
 109 dc_stop(struct notify *notify)
 110 {
 111         decoder_lock();
 112
 113         if (dc.command != DECODE_COMMAND_NONE)
 114                 /* Attempt to cancel the current command.  If it's too
 115                    late and the decoder thread is already executing
 116                    the old command, we'll call STOP again in this
 117                    function (see below). */
 118                 dc_command_locked(notify, DECODE_COMMAND_STOP);
 119
 120         if (dc.state != DECODE_STATE_STOP && dc.state != DECODE_STATE_ERROR)
 121                 dc_command_locked(notify, DECODE_COMMAND_STOP);
 122
 123         decoder_unlock();
 124 }
 125
 126 bool
 127 dc_seek(struct notify *notify, double where)
 128 {
 129         assert(dc.state != DECODE_STATE_START);
 130         assert(where >= 0.0);
 131
 132         if (dc.state == DECODE_STATE_STOP ||
 133             dc.state == DECODE_STATE_ERROR || !dc.seekable)
 134                 return false;
 135
 136         dc.seek_where = where;
 137         dc.seek_error = false;
 138         dc_command(notify, DECODE_COMMAND_SEEK);
 139
 140         if (dc.seek_error)
 141                 return false;
 142
 143         return true;
 144 }
 145
 146 void
 147 dc_quit(void)
 148 {
 149         assert(dc.thread != NULL);
 150
 151         dc.quit = true;
 152         dc_command_async(DECODE_COMMAND_STOP);
 153
 154         g_thread_join(dc.thread);
 155         dc.thread = NULL;
 156 }