MPD

src/queue.h

Go to the documentation of this file.
00001 /*
00002  * Copyright (C) 2003-2010 The Music Player Daemon Project
00003  * http://www.musicpd.org
00004  *
00005  * This program is free software; you can redistribute it and/or modify
00006  * it under the terms of the GNU General Public License as published by
00007  * the Free Software Foundation; either version 2 of the License, or
00008  * (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License along
00016  * with this program; if not, write to the Free Software Foundation, Inc.,
00017  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
00018  */
00019 
00020 #ifndef QUEUE_H
00021 #define QUEUE_H
00022 
00023 #include <glib.h>
00024 
00025 #include <assert.h>
00026 #include <stdbool.h>
00027 #include <stdint.h>
00028 
00029 enum {
00034         QUEUE_HASH_MULT = 4,
00035 };
00036 
00041 struct queue_item {
00042         struct song *song;
00043 
00045         unsigned id;
00046 
00048         uint32_t version;
00049 };
00050 
00061 struct queue {
00063         unsigned max_length;
00064 
00066         unsigned length;
00067 
00069         uint32_t version;
00070 
00072         struct queue_item *items;
00073 
00075         unsigned *order;
00076 
00078         int *id_to_position;
00079 
00082         bool repeat;
00083 
00085         bool single;
00086 
00088         bool consume;
00089 
00091         bool random;
00092 
00094         GRand *rand;
00095 };
00096 
00097 static inline unsigned
00098 queue_length(const struct queue *queue)
00099 {
00100         assert(queue->length <= queue->max_length);
00101 
00102         return queue->length;
00103 }
00104 
00108 static inline bool
00109 queue_is_empty(const struct queue *queue)
00110 {
00111         return queue->length == 0;
00112 }
00113 
00117 static inline bool
00118 queue_is_full(const struct queue *queue)
00119 {
00120         assert(queue->length <= queue->max_length);
00121 
00122         return queue->length >= queue->max_length;
00123 }
00124 
00128 static inline bool
00129 queue_valid_position(const struct queue *queue, unsigned position)
00130 {
00131         return position < queue->length;
00132 }
00133 
00137 static inline bool
00138 queue_valid_order(const struct queue *queue, unsigned order)
00139 {
00140         return order < queue->length;
00141 }
00142 
00143 static inline int
00144 queue_id_to_position(const struct queue *queue, unsigned id)
00145 {
00146         if (id >= queue->max_length * QUEUE_HASH_MULT)
00147                 return -1;
00148 
00149         assert(queue->id_to_position[id] >= -1);
00150         assert(queue->id_to_position[id] < (int)queue->length);
00151 
00152         return queue->id_to_position[id];
00153 }
00154 
00155 static inline int
00156 queue_position_to_id(const struct queue *queue, unsigned position)
00157 {
00158         assert(position < queue->length);
00159 
00160         return queue->items[position].id;
00161 }
00162 
00163 static inline unsigned
00164 queue_order_to_position(const struct queue *queue, unsigned order)
00165 {
00166         assert(order < queue->length);
00167 
00168         return queue->order[order];
00169 }
00170 
00171 static inline unsigned
00172 queue_position_to_order(const struct queue *queue, unsigned position)
00173 {
00174         assert(position < queue->length);
00175 
00176         for (unsigned i = 0;; ++i) {
00177                 assert(i < queue->length);
00178 
00179                 if (queue->order[i] == position)
00180                         return i;
00181         }
00182 }
00183 
00187 static inline struct song *
00188 queue_get(const struct queue *queue, unsigned position)
00189 {
00190         assert(position < queue->length);
00191 
00192         return queue->items[position].song;
00193 }
00194 
00198 static inline struct song *
00199 queue_get_order(const struct queue *queue, unsigned order)
00200 {
00201         return queue_get(queue, queue_order_to_position(queue, order));
00202 }
00203 
00208 static inline bool
00209 queue_song_newer(const struct queue *queue, unsigned position,
00210                  uint32_t version)
00211 {
00212         assert(position < queue->length);
00213 
00214         return version > queue->version ||
00215                 queue->items[position].version >= version ||
00216                 queue->items[position].version == 0;
00217 }
00218 
00222 void
00223 queue_init(struct queue *queue, unsigned max_length);
00224 
00229 void
00230 queue_finish(struct queue *queue);
00231 
00238 int
00239 queue_next_order(const struct queue *queue, unsigned order);
00240 
00245 void
00246 queue_increment_version(struct queue *queue);
00247 
00252 void
00253 queue_modify(struct queue *queue, unsigned order);
00254 
00258 void
00259 queue_modify_all(struct queue *queue);
00260 
00268 unsigned
00269 queue_append(struct queue *queue, struct song *song);
00270 
00274 void
00275 queue_swap(struct queue *queue, unsigned position1, unsigned position2);
00276 
00280 static inline void
00281 queue_swap_order(struct queue *queue, unsigned order1, unsigned order2)
00282 {
00283         unsigned tmp = queue->order[order1];
00284         queue->order[order1] = queue->order[order2];
00285         queue->order[order2] = tmp;
00286 }
00287 
00291 void
00292 queue_move(struct queue *queue, unsigned from, unsigned to);
00293 
00297 void
00298 queue_move_range(struct queue *queue, unsigned start, unsigned end, unsigned to);
00299 
00303 void
00304 queue_delete(struct queue *queue, unsigned position);
00305 
00309 void
00310 queue_clear(struct queue *queue);
00311 
00315 static inline void
00316 queue_restore_order(struct queue *queue)
00317 {
00318         for (unsigned i = 0; i < queue->length; ++i)
00319                 queue->order[i] = i;
00320 }
00321 
00326 void
00327 queue_shuffle_order(struct queue *queue);
00328 
00334 void
00335 queue_shuffle_order_last(struct queue *queue, unsigned start, unsigned end);
00336 
00341 void
00342 queue_shuffle_range(struct queue *queue, unsigned start, unsigned end);
00343 
00344 #endif