File indexing completed on 2024-05-05 09:08:27

 /*
  * This file is part of WorkMan, the civilized CD player library
  * Copyright (C) Alexander Kern <alex.kern@gmx.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public
  * License along with this library; if not, write to the Free
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #include <string.h>
 #include <sys/poll.h>
 #include <sys/wait.h>
 #include <arpa/inet.h> /* For htonl(3) */
 #include <stdio.h>
 #include <unistd.h>
 #include "include/wm_config.h"
 #include "include/wm_struct.h"
 #include "include/wm_cdda.h"
 #include "include/wm_cdrom.h"
 #include "include/wm_helpers.h"
 #include "include/wm_scsi.h"
 #include "audio/audio.h"
 
 #include <pthread.h>
 
 static pthread_t thread_read;
 static pthread_t thread_play;
 
 /* CDDABLKSIZE give us the 588 samples 4 bytes each(16 bit x 2 channel)
    by rate 44100 HZ, 588 samples are 1/75 sec
    if we read 15 frames(8820 samples), we get in each block, data for 1/5 sec */
 #define COUNT_CDDA_FRAMES_PER_BLOCK 15
 
 /* Only Linux and Sun define the number of blocks explicitly; assume all
    other systems are like Linux and have 10 blocks.
 */
 #ifndef COUNT_CDDA_BLOCKS
 #define COUNT_CDDA_BLOCKS 10
 #endif
 
 static struct wm_cdda_block blks[COUNT_CDDA_BLOCKS];
 static pthread_mutex_t blks_mutex[COUNT_CDDA_BLOCKS];
 static pthread_cond_t wakeup_audio;
 
 /*
  * This is non-null if we're saving audio to a file.
  */
 static FILE *output = NULL;
 
 /*
  * These are driverdependent oops
  *
  */
 static struct audio_oops *oops = NULL;
 
 /*
  * Audio file header format.
  */
 typedef unsigned long u_32;
 struct auheader {
     u_32 magic;
     u_32 hdr_size;
     u_32 data_size;
     u_32 encoding;
     u_32 sample_rate;
     u_32 channels;
 };
 
 static int cdda_status(struct wm_drive *d, int oldmode,
   int *mode, int *frame, int *track, int *ind)
 {
     if (d->cddax) {
         if(d->status)
           *mode = d->status;
         else
           *mode = oldmode;
 
         if (*mode == WM_CDM_PLAYING) {
             *track = d->track;
             *ind = d->index;
             *frame = d->frame;
         } else if (*mode == WM_CDM_CDDAERROR) {
             /*
              * An error near the end of the CD probably
              * just means we hit the end.
              */
             *mode = WM_CDM_TRACK_DONE;
         }
 
         return 0;
     }
 
     return -1;
 }
 
 static int cdda_play(struct wm_drive *d, int start, int end)
 {
     if (d->cddax) {
         d->command = WM_CDM_STOPPED;
         oops->wmaudio_stop();
 
         /* wait before reader, stops */
         while(d->status != d->command)
             wm_susleep(1000);
 
         d->current_position = start;
         d->ending_position = end;
 
         d->track =  -1;
         d->index =  0;
         d->frame = start;
         d->status = d->command = WM_CDM_PLAYING;
 
         return 0;
     }
 
     return -1;
 }
 
 static int cdda_pause(struct wm_drive *d)
 {
     if (d->cddax) {
         if(WM_CDM_PLAYING == d->command) {
             d->command = WM_CDM_PAUSED;
             if(oops->wmaudio_pause)
                 oops->wmaudio_pause();
         } else {
             d->command = WM_CDM_PLAYING;
         }
 
         return 0;
     }
 
     return -1;
 }
 
 static int cdda_stop(struct wm_drive *d)
 {
     if (d->cddax) {
         d->command = WM_CDM_STOPPED;
         oops->wmaudio_stop();
         return 0;
     }
 
     return -1;
 }
 
 static int cdda_set_volume(struct wm_drive *d, int left, int right)
 {
     if (d->cddax) {
          if(oops->wmaudio_balvol && !oops->wmaudio_balvol(1, &left, &right))
             return 0;
     }
 
     return -1;
 }
 
 static int cdda_get_volume(struct wm_drive *d, int *left, int *right)
 {
     if (d->cddax) {
         if(oops->wmaudio_balvol && !oops->wmaudio_balvol(0, left, right))
             return 0;
     }
 
     return -1;
 }
 
   #if 0
 /*
  * Tell the CDDA slave to start (or stop) saving to a file.
  */
 void
 cdda_save(struct wm_drive *, char *)
 {
 
   int len;
 
   if (filename == NULL || filename[0] == '\0')
     len = 0;
   else
     len = strlen(filename);
   write(d->cdda_slave, "F", 1);
   write(d->cdda_slave, &len, sizeof(len));
   if (len)
     write(d->cdda_slave, filename, len);
 
 
             read(0, &namelen, sizeof(namelen));
         if (output != NULL) {
             fclose(output);
             output = NULL;
         }
         if (namelen) {
             filename = malloc(namelen + 1);
             if (filename == NULL) {
                 perror("cddas");
                 wmcdda_close(cdda_device);
                 oops->wmaudio_close();
                 exit(1);
             }
 
             read(0, filename, namelen);
             filename[namelen] = '\0';
             output = fopen(filename, "w");
             if (output == NULL) {
                 perror(filename);
             } else {
                 /* Write an .au file header. */
                 hdr.magic = htonl(0x2e736e64);
                 hdr.hdr_size = htonl(sizeof(hdr) + 28);
                 hdr.data_size = htonl(~0);
                 hdr.encoding = htonl(3); /* linear-16 */
                 hdr.sample_rate = htonl(44100);
                 hdr.channels = htonl(2);
 
                 fwrite(&hdr, sizeof(hdr), 1, output);
                 fwrite("Recorded from CD by WorkMan", 28, 1, output);
             }
             free(filename);
 
 }
 #endif
 
 static int get_next_block(int x)
 {
     int y = ++x;
     return (y < COUNT_CDDA_BLOCKS)?y:0;
 }
 
 static void *cdda_fct_read(void* arg)
 {
     struct wm_drive *d = (struct wm_drive *)arg;
     int i, j, wakeup;
     long result;
 
     while (d->blocks) {
         while(d->command != WM_CDM_PLAYING) {
             d->status = d->command;
             wm_susleep(1000);
         }
 
         i = 0;
         (void) pthread_mutex_lock(&blks_mutex[i]);
         wakeup = 1;
 
         while(d->command == WM_CDM_PLAYING) {
             result = gen_cdda_read(d, &blks[i]);
             if (result <= 0 && blks[i].status != WM_CDM_TRACK_DONE) {
                 ERRORLOG("cdda: wmcdda_read failed, stop playing\n");
                 d->command = WM_CDM_STOPPED;
                 break;
             } else {
                 if (output)
                     fwrite(blks[i].buf, blks[i].buflen, 1, output);
             }
 
             j = get_next_block(i);
             (void) pthread_mutex_lock(&blks_mutex[j]);
 
             if(wakeup) {
                 wakeup = 0;
                 pthread_cond_signal(&wakeup_audio);
             }
 
             (void) pthread_mutex_unlock(&blks_mutex[i]);
             /* audio can start here */
 
             i = j;
         }
 
         (void) pthread_mutex_unlock(&blks_mutex[i]);
     }
 
     return 0;
 }
 
 static void *cdda_fct_play(void* arg)
 {
     struct wm_drive *d = (struct wm_drive *)arg;
     int i = 0;
 
     while (d->blocks) {
         if(d->command != WM_CDM_PLAYING) {
             i = 0;
             (void) pthread_mutex_lock(&blks_mutex[i]);
             pthread_cond_wait(&wakeup_audio, &blks_mutex[i]);
         } else {
             i = get_next_block(i);
             (void) pthread_mutex_lock(&blks_mutex[i]);
         }
 
         if (oops->wmaudio_play(&blks[i])) {
             oops->wmaudio_stop();
             ERRORLOG("cdda: wmaudio_play failed\n");
             d->command = WM_CDM_STOPPED;
         }
         if (oops->wmaudio_state)
             oops->wmaudio_state(&blks[i]);
 
         d->frame = blks[i].frame;
         d->track = blks[i].track;
         d->index = blks[i].index;
         if ((d->status = blks[i].status) == WM_CDM_TRACK_DONE)
             d->command = WM_CDM_STOPPED;
 
         (void) pthread_mutex_unlock(&blks_mutex[i]);
     }
 
     return 0;
 }
 
 /*
  * Try to initialize the CDDA slave.  Returns 0 on success.
  */
 int wm_cdda_init(struct wm_drive *d)
 {
     int ret = 0;
 
     if (d->cddax) {
         wm_cdda_destroy(d);
 
         wm_susleep(1000);
         d->blocks = 0;
         wm_susleep(1000);
     }
 
     memset(blks, 0, sizeof(blks));
 
     d->blocks = blks;
     d->frames_at_once = COUNT_CDDA_FRAMES_PER_BLOCK;
     d->numblocks = COUNT_CDDA_BLOCKS;
     d->status = WM_CDM_UNKNOWN;
 
     if ((ret = gen_cdda_init(d)))
         return ret;
 
     if ((ret = gen_cdda_open(d)))
         return ret;
 
     wm_scsi_set_speed(d, 4);
 
     oops = setup_soundsystem(d->soundsystem, d->sounddevice, d->ctldevice);
     if (!oops) {
         ERRORLOG("cdda: setup_soundsystem failed\n");
         gen_cdda_close(d);
         return -1;
     }
 
     if(pthread_create(&thread_read, NULL, cdda_fct_read, d)) {
         ERRORLOG("error by create pthread");
         oops->wmaudio_close();
         gen_cdda_close(d);
         return -1;
     }
 
     if(pthread_create(&thread_play, NULL, cdda_fct_play, d)) {
         ERRORLOG("error by create pthread");
         oops->wmaudio_close();
         gen_cdda_close(d);
         return -1;
     }
 
     d->proto.get_drive_status = cdda_status;
     d->proto.pause = cdda_pause;
     d->proto.resume = NULL;
     d->proto.stop = cdda_stop;
     d->proto.play = cdda_play;
     d->proto.set_volume = cdda_set_volume;
     d->proto.get_volume = cdda_get_volume;
     d->proto.scale_volume = NULL;
     d->proto.unscale_volume = NULL;
 
     d->cddax = (void *)1;
 
     return 0;
 }
 
 int wm_cdda_destroy(struct wm_drive *d)
 {
     if (d->cddax) {
         wm_scsi_set_speed(d, -1);
 
         d->command = WM_CDM_STOPPED;
         oops->wmaudio_stop();
         wm_susleep(2000);
         gen_cdda_close(d);
         oops->wmaudio_close();
 
         d->numblocks = 0;
         d->blocks = NULL;
         wait(NULL);
         d->cddax = NULL;
     }
     return 0;
 }