/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

#ifdef SDL_CDROM_BEOS

/* Functions for system-level CD-ROM audio control on BeOS
   (not completely implemented yet)
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <scsi.h>
#include <Directory.h>
#include <Entry.h>
#include <Path.h>

#include "SDL_cdrom.h"
extern "C"
{
#include "../SDL_syscdrom.h"
}

/* Constants to help us get at the SCSI table-of-contents info */
#define CD_NUMTRACKS(toc)	toc.toc_data[3]
#define CD_TRACK(toc, track)	(&toc.toc_data[6+(track)*8])
#define CD_TRACK_N(toc, track)	CD_TRACK(toc, track)[0]
#define CD_TRACK_M(toc, track)	CD_TRACK(toc, track)[3]
#define CD_TRACK_S(toc, track)	CD_TRACK(toc, track)[4]
#define CD_TRACK_F(toc, track)	CD_TRACK(toc, track)[5]

/* Constants to help us get at the SCSI position info */
#define POS_TRACK(pos)	pos.position[6]
#define POS_ABS_M(pos)	pos.position[9]
#define POS_ABS_S(pos)	pos.position[10]
#define POS_ABS_F(pos)	pos.position[11]
#define POS_REL_M(pos)	pos.position[13]
#define POS_REL_S(pos)	pos.position[14]
#define POS_REL_F(pos)	pos.position[15]

/* The maximum number of CD-ROM drives we'll detect */
#define MAX_DRIVES	16

/* A list of available CD-ROM drives */
static char *SDL_cdlist[MAX_DRIVES];

/* The system-dependent CD control functions */
static const char *SDL_SYS_CDName (int drive);
static int SDL_SYS_CDOpen (int drive);
static int SDL_SYS_CDGetTOC (SDL_CD * cdrom);
static CDstatus SDL_SYS_CDStatus (SDL_CD * cdrom, int *position);
static int SDL_SYS_CDPlay (SDL_CD * cdrom, int start, int length);
static int SDL_SYS_CDPause (SDL_CD * cdrom);
static int SDL_SYS_CDResume (SDL_CD * cdrom);
static int SDL_SYS_CDStop (SDL_CD * cdrom);
static int SDL_SYS_CDEject (SDL_CD * cdrom);
static void SDL_SYS_CDClose (SDL_CD * cdrom);
int try_dir (const char *directory);


/* Check a drive to see if it is a CD-ROM */
static int
CheckDrive (char *drive)
{
    struct stat stbuf;
    int is_cd, cdfd;
    device_geometry info;

    /* If it doesn't exist, return -1 */
    if (stat (drive, &stbuf) < 0) {
        return (-1);
    }

    /* If it does exist, verify that it's an available CD-ROM */
    is_cd = 0;
    cdfd = open (drive, 0);
    if (cdfd >= 0) {
        if (ioctl (cdfd, B_GET_GEOMETRY, &info) == B_NO_ERROR) {
            if (info.device_type == B_CD) {
                is_cd = 1;
            }
        }
        close (cdfd);
    } else {
        /* This can happen when the drive is open .. (?) */ ;
        is_cd = 1;
    }
    return (is_cd);
}

/* Add a CD-ROM drive to our list of valid drives */
static void
AddDrive (char *drive)
{
    int i;
    size_t len;

    if (SDL_numcds < MAX_DRIVES) {
        /* Add this drive to our list */
        i = SDL_numcds;
        len = SDL_strlen (drive) + 1;
        SDL_cdlist[i] = (char *) SDL_malloc (len);
        if (SDL_cdlist[i] == NULL) {
            SDL_OutOfMemory ();
            return;
        }
        SDL_strlcpy (SDL_cdlist[i], drive, len);
        ++SDL_numcds;
#ifdef CDROM_DEBUG
        fprintf (stderr, "Added CD-ROM drive: %s\n", drive);
#endif
    }
}

/* IDE bus scanning magic */
enum
{
    IDE_GET_DEVICES_INFO = B_DEVICE_OP_CODES_END + 50,
};
struct ide_ctrl_info
{
    bool ide_0_present;
    bool ide_0_master_present;
    bool ide_0_slave_present;
    int ide_0_master_type;
    int ide_0_slave_type;
    bool ide_1_present;
    bool ide_1_master_present;
    bool ide_1_slave_present;
    int ide_1_master_type;
    int ide_1_slave_type;
};

int
SDL_SYS_CDInit (void)
{
    char *SDLcdrom;
    int raw_fd;
    struct ide_ctrl_info info;

    /* Fill in our driver capabilities */
    SDL_CDcaps.Name = SDL_SYS_CDName;
    SDL_CDcaps.Open = SDL_SYS_CDOpen;
    SDL_CDcaps.GetTOC = SDL_SYS_CDGetTOC;
    SDL_CDcaps.Status = SDL_SYS_CDStatus;
    SDL_CDcaps.Play = SDL_SYS_CDPlay;
    SDL_CDcaps.Pause = SDL_SYS_CDPause;
    SDL_CDcaps.Resume = SDL_SYS_CDResume;
    SDL_CDcaps.Stop = SDL_SYS_CDStop;
    SDL_CDcaps.Eject = SDL_SYS_CDEject;
    SDL_CDcaps.Close = SDL_SYS_CDClose;

    /* Look in the environment for our CD-ROM drive list */
    SDLcdrom = SDL_getenv ("SDL_CDROM");        /* ':' separated list of devices */
    if (SDLcdrom != NULL) {
        char *cdpath, *delim;
        size_t len = SDL_strlen (SDLcdrom) + 1;
        cdpath = SDL_stack_alloc (char, len);
        if (cdpath != NULL) {
            SDL_strlcpy (cdpath, SDLcdrom, len);
            SDLcdrom = cdpath;
            do {
                delim = SDL_strchr (SDLcdrom, ':');
                if (delim) {
                    *delim++ = '\0';
                }
                if (CheckDrive (SDLcdrom) > 0) {
                    AddDrive (SDLcdrom);
                }
                if (delim) {
                    SDLcdrom = delim;
                } else {
                    SDLcdrom = NULL;
                }
            }
            while (SDLcdrom);
            SDL_stack_free (cdpath);
        }

        /* If we found our drives, there's nothing left to do */
        if (SDL_numcds > 0) {
            return (0);
        }
    }

    /* Scan the system for CD-ROM drives */
    try_dir ("/dev/disk");
    return 0;
}


int
try_dir (const char *directory)
{
    BDirectory dir;
    dir.SetTo (directory);
    if (dir.InitCheck () != B_NO_ERROR) {
        return false;
    }
    dir.Rewind ();
    BEntry entry;
    while (dir.GetNextEntry (&entry) >= 0) {
        BPath path;
        const char *name;
        entry_ref e;

        if (entry.GetPath (&path) != B_NO_ERROR)
            continue;
        name = path.Path ();

        if (entry.GetRef (&e) != B_NO_ERROR)
            continue;

        if (entry.IsDirectory ()) {
            if (SDL_strcmp (e.name, "floppy") == 0)
                continue;       /* ignore floppy (it is not silent)  */
            int devfd = try_dir (name);
            if (devfd >= 0)
                return devfd;
        } else {
            int devfd;
            device_geometry g;

            if (SDL_strcmp (e.name, "raw") != 0)
                continue;       /* ignore partitions */

            devfd = open (name, O_RDONLY);
            if (devfd < 0)
                continue;

            if (ioctl (devfd, B_GET_GEOMETRY, &g, sizeof (g)) >= 0) {
                if (g.device_type == B_CD) {
                    AddDrive (strdup (name));
                }
            }
            close (devfd);
        }
    }
    return B_ERROR;
}


/* General ioctl() CD-ROM command function */
static int
SDL_SYS_CDioctl (int index, int command, void *arg)
{
    int okay;
    int fd;

    okay = 0;
    fd = open (SDL_cdlist[index], 0);
    if (fd >= 0) {
        if (ioctl (fd, command, arg) == B_NO_ERROR) {
            okay = 1;
        }
        close (fd);
    }
    return (okay ? 0 : -1);
}

static const char *
SDL_SYS_CDName (int drive)
{
    return (SDL_cdlist[drive]);
}

static int
SDL_SYS_CDOpen (int drive)
{
    return (drive);
}

static int
SDL_SYS_CDGetTOC (SDL_CD * cdrom)
{
    int i;
    scsi_toc toc;

    if (SDL_SYS_CDioctl (cdrom->id, B_SCSI_GET_TOC, &toc) == 0) {
        cdrom->numtracks = CD_NUMTRACKS (toc);
        if (cdrom->numtracks > SDL_MAX_TRACKS) {
            cdrom->numtracks = SDL_MAX_TRACKS;
        }
        for (i = 0; i <= cdrom->numtracks; ++i) {
            cdrom->track[i].id = CD_TRACK_N (toc, i);
            /* FIXME:  How do we tell on BeOS? */
            cdrom->track[i].type = SDL_AUDIO_TRACK;
            cdrom->track[i].offset = MSF_TO_FRAMES (CD_TRACK_M (toc, i),
                                                    CD_TRACK_S (toc, i),
                                                    CD_TRACK_F (toc, i));
            cdrom->track[i].length = 0;
            if (i > 0) {
                cdrom->track[i - 1].length =
                    cdrom->track[i].offset - cdrom->track[i - 1].offset;
            }
        }
        return (0);
    } else {
        return (-1);
    }
}

/* Get CD-ROM status */
static CDstatus
SDL_SYS_CDStatus (SDL_CD * cdrom, int *position)
{
    CDstatus status;
    int fd;
    int cur_frame;
    scsi_position pos;

    fd = open (SDL_cdlist[cdrom->id], 0);
    cur_frame = 0;
    if (fd >= 0) {
        if (ioctl (fd, B_SCSI_GET_POSITION, &pos) == B_NO_ERROR) {
            cur_frame =
                MSF_TO_FRAMES (POS_ABS_M (pos), POS_ABS_S (pos),
                               POS_ABS_F (pos));
        }
        if (!pos.position[1] || (pos.position[1] >= 0x13) ||
            ((pos.position[1] == 0x12) && (!pos.position[6]))) {
            status = CD_STOPPED;
        } else if (pos.position[1] == 0x11) {
            status = CD_PLAYING;
        } else {
            status = CD_PAUSED;
        }
        close (fd);
    } else {
        status = CD_TRAYEMPTY;
    }
    if (position) {
        *position = cur_frame;
    }
    return (status);
}

/* Start play */
static int
SDL_SYS_CDPlay (SDL_CD * cdrom, int start, int length)
{
    int okay;
    int fd;
    scsi_play_position pos;

    okay = 0;
    fd = open (SDL_cdlist[cdrom->id], 0);
    if (fd >= 0) {
        FRAMES_TO_MSF (start, &pos.start_m, &pos.start_s, &pos.start_f);
        FRAMES_TO_MSF (start + length, &pos.end_m, &pos.end_s, &pos.end_f);
        if (ioctl (fd, B_SCSI_PLAY_POSITION, &pos) == B_NO_ERROR) {
            okay = 1;
        }
        close (fd);
    }
    return (okay ? 0 : -1);
}

/* Pause play */
static int
SDL_SYS_CDPause (SDL_CD * cdrom)
{
    return (SDL_SYS_CDioctl (cdrom->id, B_SCSI_PAUSE_AUDIO, 0));
}

/* Resume play */
static int
SDL_SYS_CDResume (SDL_CD * cdrom)
{
    return (SDL_SYS_CDioctl (cdrom->id, B_SCSI_RESUME_AUDIO, 0));
}

/* Stop play */
static int
SDL_SYS_CDStop (SDL_CD * cdrom)
{
    return (SDL_SYS_CDioctl (cdrom->id, B_SCSI_STOP_AUDIO, 0));
}

/* Eject the CD-ROM */
static int
SDL_SYS_CDEject (SDL_CD * cdrom)
{
    return (SDL_SYS_CDioctl (cdrom->id, B_SCSI_EJECT, 0));
}

/* Close the CD-ROM handle */
static void
SDL_SYS_CDClose (SDL_CD * cdrom)
{
    close (cdrom->id);
}

void
SDL_SYS_CDQuit (void)
{
    int i;

    if (SDL_numcds > 0) {
        for (i = 0; i < SDL_numcds; ++i) {
            SDL_free (SDL_cdlist[i]);
        }
        SDL_numcds = 0;
    }
}

#endif /* SDL_CDROM_BEOS */
/* vi: set ts=4 sw=4 expandtab: */