ascd/ascd/cdcontrol.c

   1 /* ===========================================================================
   2  * AScd: cdcontrol.c
   3  * This is cd_control() function: accept orders from the ui player and send
   4  * the appropriate commands to libworkman.
   5  *
   6  * Please do *not* modify this function as it is used without changes by
   7  * several programs!
   8  * ===========================================================================
   9  * Copyright (c) 1999 Denis Bourez and Rob Malda. All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  *
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. All advertising materials mentioning features or use of this software
  21  *    must display the following acknowledgement:
  22  *    This product includes software developed by Denis Bourez & Rob Malda
  23  * 4. Neither the name of the author nor the names of any co-contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY DENIS BOUREZ AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED. IN NO EVENT SHALL DENIS BOUREZ, ROB MALDA OR CONTRIBUTORS BE
  31  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37  * POSSIBILITY OF SUCH DAMAGE.
  38  * ===========================================================================
  39  */
  40
  41 #define CD_C_VERSION "1.4"
  42 #include "ext.h"
  43
  44 void
  45 cd_control(int order)
  46 {
  47     static int pos_changed = FALSE;
  48     int currenttrack;
  49
  50     anomalie = 0;
  51     wanna_play = FALSE;
  52
  53 #ifdef XFASCD
  54     update_xpm = TRUE;
  55 #endif
  56
  57     if (cur_cdmode != WM_CDM_EJECTED) {
  58         if (cd->trk[cur_track - 1].data) datatrack = 1;
  59         else datatrack = 0;
  60     }
  61
  62     if ((cur_ntracks == 1) && (cd->trk[cur_track - 1].data)) {
  63
  64         /* only one track, and it's a data track. We ignore
  65            all commands to avoid some funny things. Only the EJECT
  66            commands are allowed */
  67
  68         if ((order != STOP) && (order != EJECT)) {
  69             anomalie = 1;
  70             return;
  71         }
  72     }
  73
  74     switch(order) {
  75
  76     case PLAY:
  77         loop_mode = 0;
  78         intro_mode = 0;
  79         if (! pos_changed) {
  80             wm_cd_status();
  81         } else {
  82             pos_changed = FALSE;
  83         }
  84
  85         if (cur_track < 1) cur_track = 1;
  86
  87         /* don't play data tracks: */
  88
  89         if (! cd->trk[cur_track - 1].data) {
  90             if (cur_cdmode != WM_CDM_EJECTED) {
  91                 if (cur_cdmode != WM_CDM_PAUSED) {
  92                     if (do_autorepeat) {
  93                         cur_track = 1;
  94                         do_autorepeat = FALSE;
  95                     }
  96
  97                     /* skip data and avoid tracks */
  98                     while (((cd->trk[cur_track - 1].data) || ((cd->trk[cur_track - 1].avoid == 1) && (!ignore_avoid))         ) && (cur_track <= cur_ntracks)) cur_track++;
  99
 100                     if (cur_track > cur_ntracks) cur_track--;
 101                     if (!(cd->trk[cur_track - 1].data)) {
 102                         wanna_play = TRUE;
 103                         wm_cd_play(cur_track, 0, cur_ntracks + 1);
 104                     }
 105                 }
 106             }
 107         }
 108         break;
 109
 110     case PAUSE:
 111         loop_mode = 0;
 112         intro_mode = 0;
 113
 114         if (pos_changed) {
 115             cur_track = wanted_track;
 116             wanna_play = TRUE;
 117             wm_cd_play(cur_track, 0, cur_ntracks + 1);
 118             cur_cdmode = WM_CDM_PLAYING;
 119         } else {
 120             wm_cd_pause();
 121         }
 122
 123         if (cur_cdmode == WM_CDM_PLAYING) {
 124             pos_changed = FALSE;
 125         }
 126         break;
 127
 128     case STOP: /* Civilized handler: STOP and EJECT combined */
 129         loop_mode = 0;
 130         intro_mode = 0;
 131         if ((cur_cdmode == WM_CDM_PLAYING) || (cur_cdmode == WM_CDM_PAUSED)) {
 132             cur_cdmode = WM_CDM_PAUSED;
 133             wm_cd_stop();
 134             cur_cdmode = WM_CDM_STOPPED;
 135         } else {
 136             if (cur_cdmode != WM_CDM_EJECTED) {
 137                 currenttrack = 0;
 138                 wm_cd_eject();
 139             }
 140         }
 141         pos_changed = FALSE;
 142         break;
 143
 144     case STOPONLY: /* STOP, no more. Doesn't eject if CD is already stopped */
 145         loop_mode = 0;
 146         intro_mode = 0;
 147         if ((cur_cdmode == WM_CDM_PLAYING) || (cur_cdmode == WM_CDM_PAUSED)) {
 148             cur_cdmode = WM_CDM_PAUSED;
 149             wm_cd_stop();
 150             cur_cdmode = WM_CDM_STOPPED;
 151         }
 152         pos_changed = FALSE;
 153         break;
 154
 155     case EJECT: /* Troll handler: don't try to guess the current mode, just eject */
 156         if (cur_cdmode != WM_CDM_EJECTED) {
 157             loop_mode = 0;
 158             intro_mode = 0;
 159             currenttrack = 0;
 160             wm_cd_eject();
 161         }
 162         break;
 163
 164     case CLOSETRAY: /* let's try this */
 165         if (cur_cdmode == WM_CDM_EJECTED) {
 166             /* commented, as current libworkman crashes when it receive this order */
 167             /*wm_cd_closetray();*/
 168         }
 169         break;
 170
 171     case UPTRACK: /* next track */
 172         loop_mode = 0;
 173         intro_mode = 0;
 174         if (pos_changed) cur_track = wanted_track;
 175
 176         if (cur_track + 1 > cur_ntracks ) {
 177             cur_track = 1;
 178         } else {
 179             cur_track ++;
 180         }
 181         if (cur_cdmode == WM_CDM_PAUSED) {
 182             pos_changed = TRUE;
 183             wanted_track = cur_track;
 184         }
 185         if (cur_cdmode == WM_CDM_PLAYING) {
 186             wanna_play = TRUE;
 187             wm_cd_play(cur_track, 0, cur_ntracks + 1);
 188         }
 189         break;
 190
 191     case DNTRACK: /* previous track */
 192         loop_mode = 0;
 193         intro_mode = 0;
 194         if (pos_changed) cur_track = wanted_track;
 195
 196         if (cur_cdmode == WM_CDM_PAUSED) {
 197             if (cur_pos_rel < 2 || pos_changed) cur_track--;
 198             cur_pos_rel = 0;
 199             pos_changed = TRUE;
 200         } else if (cur_cdmode == WM_CDM_PLAYING) {
 201             if (cur_pos_rel < 2) cur_track--;
 202             cur_pos_rel = 0;
 203         } else {
 204             cur_track--;
 205         }
 206         if (cur_track < 1) cur_track = cur_ntracks;
 207         if (cur_cdmode == WM_CDM_PAUSED) {
 208             pos_changed = TRUE;
 209             wanted_track = cur_track;
 210         }
 211         if (cur_cdmode == WM_CDM_PLAYING) {
 212             wanna_play = TRUE;
 213             wm_cd_play(cur_track, 0, cur_ntracks + 1);
 214         }
 215         break;
 216
 217     case DIRECTTRACK: /* direct access to a random track */
 218         loop_mode = 0;
 219         intro_mode = 0;
 220
 221         if (direct_track < 1) direct_track = 1;
 222
 223         if (cur_cdmode == WM_CDM_PAUSED) pos_changed = TRUE;
 224         cur_track = direct_track;
 225         if (cur_track >= cur_ntracks + 1) cur_track = 1;
 226
 227         /* if it's a data track, skip it */
 228         while ((cd->trk[cur_track - 1].data) && (cur_track <= cur_ntracks)) cur_track++;
 229
 230         if (cur_cdmode == WM_CDM_PLAYING) {
 231             wanna_play = TRUE;
 232             wm_cd_play(cur_track, 0, cur_ntracks + 1);
 233         }
 234         break;
 235
 236     case CUE:
 237         loop_mode = 0;
 238         intro_mode = 0;
 239         if (cur_cdmode == WM_CDM_PLAYING) {
 240             wanna_play = TRUE;
 241             wm_cd_play(cur_track, cur_pos_rel + cue_time, cur_ntracks + 1);
 242         }
 243         break;
 244
 245     case REV:
 246         loop_mode = 0;
 247         intro_mode = 0;
 248         if ( (cur_cdmode == WM_CDM_PLAYING) && ( (cur_pos_rel - cue_time) >= 0 ) ) {
 249             wanna_play = TRUE;
 250             wm_cd_play(cur_track, cur_pos_rel - cue_time, cur_ntracks + 1);
 251         }
 252         break;
 253
 254     case FIRST:
 255         loop_mode = 0;
 256         intro_mode = 0;
 257         cur_track = 1;
 258         if (cur_cdmode == WM_CDM_PLAYING) {
 259             wanna_play = TRUE;
 260             wm_cd_play(cur_track, 0, cur_ntracks + 1);
 261         } else if (cur_cdmode == WM_CDM_PAUSED) {
 262             pos_changed = TRUE;
 263             wanted_track = cur_track;
 264         }
 265         break;
 266
 267     case LAST:
 268         loop_mode = 0;
 269         intro_mode = 0;
 270         cur_track = cur_ntracks;
 271         if (cur_cdmode == WM_CDM_PLAYING) {
 272             wanna_play = TRUE;
 273             wm_cd_play(cur_track, 0, cur_ntracks + 1);
 274         } else if (cur_cdmode == WM_CDM_PAUSED) {
 275             pos_changed = TRUE;
 276             wanted_track = cur_track;
 277         }
 278         break;
 279
 280     case LOOP:
 281         if ( (loop_2 > loop_1) ||
 282              (loop_end_track > loop_start_track) ) {
 283
 284             if (loop_start_track == 0) loop_start_track = 1;
 285             intro_mode = 0;
 286             if ( ( loop_2 > loop_1 )
 287                  || ( loop_start_track != loop_end_track ) )
 288                 currenttrack = loop_start_track;
 289             else {
 290                 loop_end_track = cur_ntracks;
 291                 currenttrack = loop_start_track = 1;
 292                 loop_1 = 0;
 293                 loop_2 =
 294                     thiscd.trk[ loop_end_track - 1 ].length - 1;
 295             }
 296             wm_cd_play(loop_start_track, loop_1, cur_ntracks + 1);
 297             wanna_play = TRUE;
 298             loop_mode = 1;
 299         } else {
 300             anomalie = 1;
 301         }
 302         break;
 303
 304     case DIRECTACCESS: /* direct access to a random position of the current track */
 305         if (direct_access < 0) direct_access = 0;
 306         loop_mode = 0;
 307         intro_mode = 0;
 308         wm_cd_status();
 309         wm_cd_play(cur_track, direct_access, cur_ntracks + 1);
 310         wanna_play = TRUE;
 311         break;
 312
 313     case GLOBALACCESS:
 314         if (direct_access < 0) direct_access = 0;
 315         loop_mode = 0;
 316         intro_mode = 0;
 317         wm_cd_status();
 318         wm_cd_play(1, direct_access, cur_ntracks + 1);
 319         wanna_play = TRUE;
 320         break;
 321
 322     case INTROSCAN:
 323         if (! intro_mode) {
 324             intro_mode = 1;
 325             wm_cd_play(cur_track, 0, cur_ntracks + 1);
 326         } else {
 327             intro_mode = 0;
 328         }
 329         break;
 330
 331     case INTRONEXT:
 332         wm_cd_pause();
 333         currenttrack = cur_track;
 334         currenttrack++;
 335         if (cur_track +1 > cur_ntracks ) currenttrack = 1;
 336         else currenttrack = cur_track + 1;
 337         cur_pos_rel = 0;
 338         wm_cd_play(currenttrack, 0, cur_ntracks + 1);
 339         break;
 340
 341     case LOCACCESS:
 342         if ( (loop_1 > 0) && (loop_start_track > 0) ) {
 343             intro_mode = 0;
 344             loop_mode = 0;
 345             currenttrack = loop_start_track;
 346             wm_cd_stop();
 347             wm_cd_play(loop_start_track, loop_1, cur_ntracks + 1);
 348             wanna_play = TRUE;
 349         } else {
 350             anomalie = 1;
 351         }
 352         break;
 353     }
 354 }
 355
 356 char *cd_control_version(void)
 357 {
 358         char *s = NULL;
 359
 360         wm_strmcat(&s, CD_C_VERSION);
 361         return s;
 362 }