SIDPlayer/src/main.cpp

/*
 *  main.cpp - SIDPlayer main program
 *
 *  SIDPlayer (C) Copyright 1996-2000 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sys.h"

#include <AppKit.h>
#include <InterfaceKit.h>
#include <support/UTF8.h>
#include <storage/Path.h>
#include <media/SoundPlayer.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "main.h"
#include "prefs.h"
#include "prefs_window.h"
#include "mem.h"
#include "cpu.h"
#include "sid.h"
#include "psid.h"


// Global variables
uint32 f_rand_seed = 1;

// Flag: PSID file loaded and ready
static bool psid_loaded = false;

// Data from PSID header
static int number_of_songs;             // Total number of songs in module
static uint16 init_adr;                 // C64 init routine address
uint16 play_adr;                                // C64 replay routine address
static uint32 speed_flags;              // Speed flags (1 bit/song)
char module_name[64];                   // Module name
char author_name[64];                   // Author name
char copyright_info[64];                // Copyright info

// Currently played song number (0..n)
static int current_song;


// Message codes
const uint32 MSG_NEW_MODULE = 'load';
const uint32 MSG_NEW_SONG = 'song';
const uint32 MSG_SHOW_PREFS = 'pref';
const uint32 MSG_PLAY_PAUSE = 'plpa';
const uint32 MSG_STOP = 'stop';
const uint32 MSG_NEXT = 'next';
const uint32 MSG_PREV = 'prev';


class MainWindow;
class SpeedSlider;

// Application object
class SIDPlayer : public BApplication {
public:
        SIDPlayer();
        virtual ~SIDPlayer();
        virtual void ArgvReceived(int32 argc, char **argv);
        virtual void RefsReceived(BMessage *msg);
        virtual void MessageReceived(BMessage *msg);
        virtual void ReadyToRun(void);
        virtual void AboutRequested(void);

private:
        static void buffer_proc(void *cookie, void *buffer, size_t size, const media_raw_audio_format &format);

        MainWindow *main_window;
        PrefsWindow *prefs_window;
        BSoundPlayer player;
        bool player_stopped;
};


// Main window object
class MainWindow : public BWindow {
public:
        MainWindow();
        virtual bool QuitRequested(void);
        virtual void MessageReceived(BMessage *msg);

private:
        BStringView *make_name_display(BRect frame, char *label_text, BView *parent);

        rgb_color fill_color;

        BStringView *name_view;
        BStringView *author_view;
        BStringView *copyright_view;
        BStringView *position_view;
        SpeedSlider *speed_slider;
};


// Top view object (handles drag&drop)
class TopView : public BView {
public:
        TopView(BRect frame, const char *name, uint32 resizingMode, uint32 flags);
        virtual void MessageReceived(BMessage *msg);
        virtual void KeyDown(const char *bytes, int32 numBytes);
};


// Buttons
class PlayPauseButton : public BButton {
public:
        PlayPauseButton(BRect frame, BMessage *msg);
        virtual void Draw(BRect update);
};

class StopButton : public BButton {
public:
        StopButton(BRect frame, BMessage *msg);
        virtual void Draw(BRect update);
};

class NextButton : public BButton {
public:
        NextButton(BRect frame, BMessage *msg);
        virtual void Draw(BRect update);
};

class PrevButton : public BButton {
public:
        PrevButton(BRect frame, BMessage *msg);
        virtual void Draw(BRect update);
};


// Speed slider
class SpeedSlider : public BSlider {
public:
        SpeedSlider(BRect frame, const char *name) : BSlider(frame, name, "Speed", NULL, -100, 100, B_TRIANGLE_THUMB)
        {
                SetHashMarks(B_HASH_MARKS_TOP);
                SetHashMarkCount(3);
                const rgb_color bar_color = {128, 128, 216, 0};
                SetBarColor(bar_color);
                SetValue(0);
        }
        virtual ~SpeedSlider() {}
        virtual void SetValue(int32 value)
        {
                int percent = value < 0 ? 100 + value / 2 : 100 + value;
                sprintf(status, "%d%%", percent);
                SIDAdjustSpeed(percent);
                BSlider::SetValue(value);
        }
        virtual char *UpdateText(void) const
        {
                return status;
        }

private:
        mutable char status[32];
};


/*
 *  Init everything
 */

void InitAll(void)
{
        PrefsInit(0, NULL);
        MemoryInit();
        SIDInit();
        CPUInit();
}


/*
 *  Exit everything
 */

void ExitAll(void)
{
        CPUExit();
        SIDExit();
        MemoryExit();
        PrefsExit();
}


/*
 *  Read PSID file header to buffer
 */

bool LoadPSIDHeader(const char *file, uint8 *p)
{
        // Read header
        memset(p, 0, PSID_MAX_HEADER_LENGTH);
        int fd = open(file, O_RDONLY);
        if (fd < 0)
                return false;
        ssize_t actual = read(fd, p, PSID_MAX_HEADER_LENGTH);
        close(fd);
        return actual >= PSID_MIN_HEADER_LENGTH;
}


/*
 *  Check for PSID header
 */

bool IsPSIDHeader(const uint8 *p)
{
        // Check signature and version
        uint32 id = read_psid_32(p, PSID_ID);
        uint16 version = read_psid_16(p, PSID_VERSION);
        return id == 'PSID' && (version == 1 || version == 2);
}


/*
 *  Check whether file is a PSID file
 */

bool IsPSIDFile(const char *file)
{
        // Load header
        uint8 header[PSID_MAX_HEADER_LENGTH];
        if (!LoadPSIDHeader(file, header))
                return false;

        // Check header
        return IsPSIDHeader(header);
}


/*
 *  Load PSID file for playing
 */

bool LoadPSIDFile(const char *file)
{
        // Open file
        int fd = open(file, O_RDONLY);
        if (fd < 0)
                return false;

        // Clear C64 RAM
        MemoryClear();
        psid_loaded = false;

        // Load and check header
        uint8 header[PSID_MAX_HEADER_LENGTH];
        ssize_t actual = read(fd, header, PSID_MAX_HEADER_LENGTH);
        if (actual < 0 || !IsPSIDHeader(header)) {
                close(fd);
                return false;
        }

        // Extract data from header
        number_of_songs = read_psid_16(header, PSID_NUMBER);
        if (number_of_songs == 0)
                number_of_songs = 1;
        current_song = read_psid_16(header, PSID_DEFSONG);
        if (current_song)
                current_song--;
        if (current_song >= number_of_songs)
                current_song = 0;

        init_adr = read_psid_16(header, PSID_INIT);
        play_adr = read_psid_16(header, PSID_MAIN);

        speed_flags = read_psid_32(header, PSID_SPEED);

        int32 sl = 32, dl = 64, state = 0;
        convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_NAME), &sl, module_name, &dl, &state);
        sl = 32, dl = 64, state = 0;
        convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_AUTHOR), &sl, author_name, &dl, &state);
        sl = 32, dl = 64, state = 0;
        convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_COPYRIGHT), &sl, copyright_info, &dl, &state);
        module_name[63] = 0;
        author_name[63] = 0;
        copyright_info[63] = 0;

        // Seek to start of module data
        lseek(fd, read_psid_16(header, PSID_LENGTH), SEEK_SET);

        // Find load address
        uint16 load_adr = read_psid_16(header, PSID_START);
        if (load_adr == 0) {    // Load address is at start of module data
                uint8 hi, lo;
                read(fd, &lo, 1);
                read(fd, &hi, 1);
                load_adr = (hi << 8) | lo;
        }
        if (init_adr == 0)              // Init routine address is equal to load address
                init_adr = load_adr;

        // Load module data to C64 RAM
        read(fd, ram + load_adr, RAM_SIZE - load_adr);
        close(fd);

        // Select default song
        SelectSong(current_song);

        // Set replay routine address if not given in header
        if (play_adr == 0) {    // Replay routine address is given by interrupt vector
                if (ram[1] & 2)         // Kernal ROM switched in
                        play_adr = (ram[0x0315] << 8) | ram[0x0314];
                else                            // Kernal ROM switched out
                        play_adr = (ram[0xffff] << 8) | ram[0xfffe];
        }

        // Everything OK
        psid_loaded = true;
        return true;
}


/*
 *  Select song for playing
 */

void SelectSong(int num)
{
        if (num >= number_of_songs)
                num = 0;
        current_song = num;     

        // Reset SID
        SIDReset(0);

        // Set replay frequency
        int freq = 50;
        if (num < 32)
                freq = speed_flags & (1 << num) ? 60 : 50;
        SIDSetReplayFreq(freq);
        SIDAdjustSpeed(100);

        // Execute init routine
        CPUExecute(init_adr, current_song, 0, 0, 1000000);
}


/*
 *  Application constructor
 */

#if B_HOST_IS_LENDIAN
const media_raw_audio_format audio_format = {44100.0, 2, media_raw_audio_format::B_AUDIO_SHORT, B_MEDIA_LITTLE_ENDIAN, 4096};
#else
const media_raw_audio_format audio_format = {44100.0, 2, media_raw_audio_format::B_AUDIO_SHORT, B_MEDIA_BIG_ENDIAN, 4096};
#endif

SIDPlayer::SIDPlayer() : BApplication("application/x-vnd.cebix-SIDPlayer"), player(&audio_format, "SIDPlayer", buffer_proc)
{
        main_window = NULL;
        player.SetHasData(true);
        player_stopped = true;
}


/*
 *  Application destructor
 */

SIDPlayer::~SIDPlayer()
{
        main_window = NULL;
        prefs_window = NULL;
        player.Stop();
        player_stopped = true;
}


/*
 *  Shell arguments received
 */

void SIDPlayer::ArgvReceived(int32 argc, char **argv)
{
        if (argc >= 2) {
                player.Stop();
                LoadPSIDFile(argv[1]);
                player.Start();
                player_stopped = false;
                if (main_window)
                        main_window->PostMessage(MSG_NEW_MODULE);
        }
}


/*
 *  Tracker arguments received
 */

void SIDPlayer::RefsReceived(BMessage *msg)
{
        entry_ref the_ref;
        if (msg->FindRef("refs", &the_ref) == B_NO_ERROR) {
                BEntry the_entry;
                if (the_entry.SetTo(&the_ref) == B_NO_ERROR) {
                        if (the_entry.IsFile()) {
                                BPath the_path;
                                the_entry.GetPath(&the_path);
                                player.Stop();
                                LoadPSIDFile(the_path.Path());
                                player.Start();
                                player_stopped = false;
                                if (main_window)
                                        main_window->PostMessage(MSG_NEW_MODULE);
                        }
                }
        }
}


/*
 *  Message received
 */

void SIDPlayer::MessageReceived(BMessage *msg)
{
        switch (msg->what) {

                case B_SIMPLE_DATA:     // Dropped message
                        RefsReceived(msg);
                        break;

                case MSG_SHOW_PREFS:
                        if (!prefs_window_open)
                                prefs_window = new PrefsWindow();
                        else if (prefs_window)
                                prefs_window->Activate(true);
                        break;

                case MSG_PLAY_PAUSE:
                        if (player_stopped) {
                                player.Start();
                                player_stopped = false;
                        } else {
                                player.Stop();
                                player_stopped = true;
                        }
                        break;

                case MSG_STOP:
                        player.Stop();
                        player_stopped = true;
                        SelectSong(current_song);
                        main_window->PostMessage(MSG_NEW_SONG);
                        break;

                case MSG_NEXT:
                        if (current_song < number_of_songs-1) {
                                player.Stop();
                                SelectSong(current_song + 1);
                                main_window->PostMessage(MSG_NEW_SONG);
                                if (!player_stopped)
                                        player.Start();
                        }
                        break;

                case MSG_PREV:
                        if (current_song > 0) {
                                player.Stop();
                                SelectSong(current_song - 1);
                                main_window->PostMessage(MSG_NEW_SONG);
                                if (!player_stopped)
                                        player.Start();
                        }
                        break;

                default:
                        BApplication::MessageReceived(msg);
                        break;
        }
}


/*
 *  Arguments processed, open player window
 */

void SIDPlayer::ReadyToRun(void)
{
        main_window = new MainWindow();
        if (psid_loaded)
                main_window->PostMessage(MSG_NEW_MODULE);
}


/*
 *  Show About window
 */

void AboutWindow(void)
{
        BAlert *theAlert = new BAlert("",
                        "SIDPlayer\nVersion 4.0\n\n"
                        "Copyright " B_UTF8_COPYRIGHT " 1996-2000 Christian Bauer\n"
                        "E-mail: Christian.Bauer@uni-mainz.de\n"
                        "http://www.uni-mainz.de/~bauec002/\n\n"
                        "SIDPlayer comes with ABSOLUTELY NO\n"
                        "WARRANTY. This is free software, and\n"
                        "you are welcome to redistribute it\n"
                        "under the terms of the GNU General\n"
                        "Public License.\n",
                        "OK", NULL, NULL, B_WIDTH_FROM_LABEL);

        BTextView *theText = theAlert->TextView();
        if (theText) {
                theText->SetStylable(true);
                theText->Select(0, 9);
                BFont ourFont;
                theText->SetFontAndColor(be_bold_font);
                theText->GetFontAndColor(2, &ourFont, NULL);
                ourFont.SetSize(24);
                theText->SetFontAndColor(&ourFont);
        }
        theAlert->Go();
}

void SIDPlayer::AboutRequested(void)
{
        AboutWindow();
}


/*
 *  SoundPlayer buffer procedure
 */

void SIDPlayer::buffer_proc(void *cookie, void *buffer, size_t size, const media_raw_audio_format &format)
{
        SIDCalcBuffer((uint8 *)buffer, size);
}


/*
 *  Main window constructor
 */

MainWindow::MainWindow() : BWindow(BRect(0, 0, 284, 96), "SIDPlayer", B_TITLED_WINDOW, B_NOT_ZOOMABLE | B_NOT_RESIZABLE | B_ASYNCHRONOUS_CONTROLS)
{
        fill_color = ui_color(B_PANEL_BACKGROUND_COLOR);
        BRect b = Bounds();

        // Move window to right position
        Lock();
        MoveTo(80, 80);

        // Create menu bar
        BMenuBar *bar = new BMenuBar(BRect(0, 0, b.right, b.bottom), "menubar");
        BMenu *menu = new BMenu("File");
        menu->AddItem(new BMenuItem("About SIDPlayer" B_UTF8_ELLIPSIS, new BMessage(B_ABOUT_REQUESTED)));
        menu->AddItem(new BSeparatorItem());
        menu->AddItem(new BMenuItem("Sound Control" B_UTF8_ELLIPSIS, new BMessage(MSG_SHOW_PREFS), 'P'));
        menu->AddItem(new BSeparatorItem());
        menu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED), 'Q'));
        menu->SetTargetForItems(be_app);
        bar->AddItem(menu);
        AddChild(bar);
        SetKeyMenuBar(bar);
        float menu_height = bar->Bounds().Height();

        // Resize window to fit menu bar
        ResizeBy(0, menu_height);

        // Light gray background
        TopView *top = new TopView(BRect(0, menu_height, b.right, b.bottom + menu_height), "main", B_FOLLOW_NONE, B_WILL_DRAW);
        AddChild(top);
        top->SetViewColor(fill_color);

        // Name/author/copyright display
        name_view = make_name_display(BRect(0, 5, 279, 21), "Name", top);
        author_view = make_name_display(BRect(0, 25, 279, 41), "Author", top);
        copyright_view = make_name_display(BRect(0, 45, 279, 61), "Copyright", top);

        // Buttons
        top->AddChild(new PlayPauseButton(BRect(6, 67, 36, 91), new BMessage(MSG_PLAY_PAUSE)));
        top->AddChild(new StopButton(BRect(37, 67, 67, 91), new BMessage(MSG_STOP)));
        top->AddChild(new PrevButton(BRect(68, 67, 98, 91), new BMessage(MSG_PREV)));
        top->AddChild(new NextButton(BRect(99, 67, 129, 91), new BMessage(MSG_NEXT)));

        // Position indicator
        top->AddChild(position_view = new BStringView(BRect(134, 72, 193, 85), "position", ""));
        position_view->SetViewColor(fill_color);

        // Speed slider
        top->AddChild(speed_slider = new SpeedSlider(BRect(194, 62, 279, 63), "speed"));

        // Show window
        top->MakeFocus();
        Unlock();
        Show();
}


/*
 *  Create name display field
 */

BStringView *MainWindow::make_name_display(BRect frame, char *label_text, BView *parent)
{
        // Label to the left of the display field
        BRect label_rect = frame;
        label_rect.right = label_rect.left + 65;

        BStringView *label = new BStringView(label_rect, "", label_text);
        parent->AddChild(label);
        label->SetViewColor(fill_color);
        label->SetLowColor(fill_color);
        label->SetAlignment(B_ALIGN_RIGHT);
        label->SetFont(be_bold_font);

        // Box around display field
        BRect frame_rect = frame;
        frame_rect.left += 70;

        BBox *box = new BBox(frame_rect);
        parent->AddChild(box);
        box->SetViewColor(fill_color);
        box->SetLowColor(fill_color);

        // The display field
        BRect textview_rect = frame_rect;
        textview_rect.OffsetTo(0, 0);
        textview_rect.InsetBy(4, 2);

        BStringView *text = new BStringView(textview_rect, "", "");
        box->AddChild(text);
        text->SetViewColor(fill_color);
        text->SetLowColor(fill_color);
        text->SetFont(be_plain_font);
        return text;
}


/*
 *  Main window closed, quit program
 */

bool MainWindow::QuitRequested(void)
{
        be_app->PostMessage(B_QUIT_REQUESTED);
        return true;
}


/*
 *  Message received
 */

void MainWindow::MessageReceived(BMessage *msg)
{
        switch (msg->what) {
                case MSG_NEW_MODULE:
                        // Update text views
                        Lock();
                        name_view->SetText(module_name);
                        author_view->SetText(author_name);
                        copyright_view->SetText(copyright_info);
                        Unlock();
                        // falls through

                case MSG_NEW_SONG:
                        // Update position indicator and speed slider
                        if (number_of_songs > 0) {
                                char str[16];
                                sprintf(str, "Song %d/%d", current_song + 1, number_of_songs);
                                position_view->SetText(str);
                        }
                        speed_slider->SetValue(0);
                        break;

                case MSG_SHOW_PREFS:
                case MSG_PLAY_PAUSE:
                case MSG_STOP:
                case MSG_NEXT:
                case MSG_PREV:
                        be_app->PostMessage(msg);
                        break;

                default:
                        BWindow::MessageReceived(msg);
                        break;
        }
}


/*
 *  TopView handles dropped messages (load new PSID module) and keypresses
 */

TopView::TopView(BRect frame, const char *name, uint32 resizingMode, uint32 flags)
 : BView(frame, name, resizingMode, flags) {}

void TopView::MessageReceived(BMessage *msg)
{
        if (msg->what == B_SIMPLE_DATA)
                be_app->PostMessage(msg);
        else
                BView::MessageReceived(msg);
}

void TopView::KeyDown(const char *bytes, int32 numBytes)
{
        BMessage *msg = Window()->CurrentMessage();
        uint32 modifiers = 0;
        msg->FindInt32("modifiers", (int32 *)&modifiers);

        switch (bytes[0]) {
                case 'p':
                case 'P':
                        Window()->PostMessage(MSG_PLAY_PAUSE);
                        break;

                case B_ESCAPE:
                case B_SPACE:
                case 's':
                case 'S':
                        Window()->PostMessage(MSG_STOP);
                        break;

                case B_LEFT_ARROW:
                        Window()->PostMessage(MSG_PREV);
                        break;

                case B_RIGHT_ARROW:
                case 'n':
                case 'N':
                        Window()->PostMessage(MSG_NEXT);
                        break;

                case 'q':
                case 'Q':
                        be_app->PostMessage(B_QUIT_REQUESTED);
                        break;
        }
}


/*
 *  Play/Pause button
 */

PlayPauseButton::PlayPauseButton(BRect frame, BMessage *msg) : BButton(frame, "play", "", msg) {};

void PlayPauseButton::Draw(BRect update)
{
        // First draw normal button
        BButton::Draw(update);

        // Then draw play/pause image on top of it
        if (Value())
                SetHighColor(255, 255, 255);
        else
                SetHighColor(0, 0, 0);

        FillRect(BRect(11, 8, 13, 16));
        FillTriangle(BPoint(16, 8), BPoint(16, 16), BPoint(20, 12));
}


/*
 *  Stop button
 */

StopButton::StopButton(BRect frame, BMessage *msg) : BButton(frame, "stop", "", msg) {};

void StopButton::Draw(BRect update)
{
        // First draw normal button
        BButton::Draw(update);

        // Then draw stop image on top of it
        if (Value())
                SetHighColor(255, 255, 255);
        else
                SetHighColor(0, 0, 0);

        FillRect(BRect(11, 8, 20, 16));
}


/*
 *  "Next" button
 */

NextButton::NextButton(BRect frame, BMessage *msg) : BButton(frame, "next", "", msg) {};

void NextButton::Draw(BRect update)
{
        // First draw normal button
        BButton::Draw(update);

        // Then draw "next" image on top of it
        if (Value())
                SetHighColor(255, 255, 255);
        else
                SetHighColor(0, 0, 0);

        FillTriangle(BPoint(12, 8), BPoint(12, 16), BPoint(16, 12));
        FillRect(BRect(17, 8, 19, 16));
}


/*
 *  "Prev" button
 */

PrevButton::PrevButton(BRect frame, BMessage *msg) : BButton(frame, "prev", "", msg) {};

void PrevButton::Draw(BRect update)
{
        // First draw normal button
        BButton::Draw(update);

        // Then draw "prev" image on top of it
        if (Value())
                SetHighColor(255, 255, 255);
        else
                SetHighColor(0, 0, 0);

        FillRect(BRect(12, 8, 14, 16));
        FillTriangle(BPoint(19, 8), BPoint(19, 16), BPoint(15, 12));
}


/*
 *  Main program
 */

int main(int argc, char **argv)
{
        InitAll();
        SIDPlayer *the_app = new SIDPlayer();
        the_app->Run();
        delete the_app;
        ExitAll();
        return 0;
}
Revision:	1.1
Committed:	2000-07-28T12:42:30Z (24 years, 1 month ago) by cebix
Branch:	MAIN
Branch point for:	cebix
Log Message:	Initial revision
#	Content
1	/*
2	* main.cpp - SIDPlayer main program
3	*
4	* SIDPlayer (C) Copyright 1996-2000 Christian Bauer
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	#include "sys.h"
22
23	#include <AppKit.h>
24	#include <InterfaceKit.h>
25	#include <support/UTF8.h>
26	#include <storage/Path.h>
27	#include <media/SoundPlayer.h>
28	#include <stdio.h>
29	#include <string.h>
30	#include <unistd.h>
31
32	#include "main.h"
33	#include "prefs.h"
34	#include "prefs_window.h"
35	#include "mem.h"
36	#include "cpu.h"
37	#include "sid.h"
38	#include "psid.h"
39
40
41	// Global variables
42	uint32 f_rand_seed = 1;
43
44	// Flag: PSID file loaded and ready
45	static bool psid_loaded = false;
46
47	// Data from PSID header
48	static int number_of_songs; // Total number of songs in module
49	static uint16 init_adr; // C64 init routine address
50	uint16 play_adr; // C64 replay routine address
51	static uint32 speed_flags; // Speed flags (1 bit/song)
52	char module_name[64]; // Module name
53	char author_name[64]; // Author name
54	char copyright_info[64]; // Copyright info
55
56	// Currently played song number (0..n)
57	static int current_song;
58
59
60	// Message codes
61	const uint32 MSG_NEW_MODULE = 'load';
62	const uint32 MSG_NEW_SONG = 'song';
63	const uint32 MSG_SHOW_PREFS = 'pref';
64	const uint32 MSG_PLAY_PAUSE = 'plpa';
65	const uint32 MSG_STOP = 'stop';
66	const uint32 MSG_NEXT = 'next';
67	const uint32 MSG_PREV = 'prev';
68
69
70	class MainWindow;
71	class SpeedSlider;
72
73	// Application object
74	class SIDPlayer : public BApplication {
75	public:
76	SIDPlayer();
77	virtual ~SIDPlayer();
78	virtual void ArgvReceived(int32 argc, char **argv);
79	virtual void RefsReceived(BMessage *msg);
80	virtual void MessageReceived(BMessage *msg);
81	virtual void ReadyToRun(void);
82	virtual void AboutRequested(void);
83
84	private:
85	static void buffer_proc(void cookie, void buffer, size_t size, const media_raw_audio_format &format);
86
87	MainWindow *main_window;
88	PrefsWindow *prefs_window;
89	BSoundPlayer player;
90	bool player_stopped;
91	};
92
93
94	// Main window object
95	class MainWindow : public BWindow {
96	public:
97	MainWindow();
98	virtual bool QuitRequested(void);
99	virtual void MessageReceived(BMessage *msg);
100
101	private:
102	BStringView make_name_display(BRect frame, char label_text, BView *parent);
103
104	rgb_color fill_color;
105
106	BStringView *name_view;
107	BStringView *author_view;
108	BStringView *copyright_view;
109	BStringView *position_view;
110	SpeedSlider *speed_slider;
111	};
112
113
114	// Top view object (handles drag&drop)
115	class TopView : public BView {
116	public:
117	TopView(BRect frame, const char *name, uint32 resizingMode, uint32 flags);
118	virtual void MessageReceived(BMessage *msg);
119	virtual void KeyDown(const char *bytes, int32 numBytes);
120	};
121
122
123	// Buttons
124	class PlayPauseButton : public BButton {
125	public:
126	PlayPauseButton(BRect frame, BMessage *msg);
127	virtual void Draw(BRect update);
128	};
129
130	class StopButton : public BButton {
131	public:
132	StopButton(BRect frame, BMessage *msg);
133	virtual void Draw(BRect update);
134	};
135
136	class NextButton : public BButton {
137	public:
138	NextButton(BRect frame, BMessage *msg);
139	virtual void Draw(BRect update);
140	};
141
142	class PrevButton : public BButton {
143	public:
144	PrevButton(BRect frame, BMessage *msg);
145	virtual void Draw(BRect update);
146	};
147
148
149	// Speed slider
150	class SpeedSlider : public BSlider {
151	public:
152	SpeedSlider(BRect frame, const char *name) : BSlider(frame, name, "Speed", NULL, -100, 100, B_TRIANGLE_THUMB)
153	{
154	SetHashMarks(B_HASH_MARKS_TOP);
155	SetHashMarkCount(3);
156	const rgb_color bar_color = {128, 128, 216, 0};
157	SetBarColor(bar_color);
158	SetValue(0);
159	}
160	virtual ~SpeedSlider() {}
161	virtual void SetValue(int32 value)
162	{
163	int percent = value < 0 ? 100 + value / 2 : 100 + value;
164	sprintf(status, "%d%%", percent);
165	SIDAdjustSpeed(percent);
166	BSlider::SetValue(value);
167	}
168	virtual char *UpdateText(void) const
169	{
170	return status;
171	}
172
173	private:
174	mutable char status[32];
175	};
176
177
178	/*
179	* Init everything
180	*/
181
182	void InitAll(void)
183	{
184	PrefsInit(0, NULL);
185	MemoryInit();
186	SIDInit();
187	CPUInit();
188	}
189
190
191	/*
192	* Exit everything
193	*/
194
195	void ExitAll(void)
196	{
197	CPUExit();
198	SIDExit();
199	MemoryExit();
200	PrefsExit();
201	}
202
203
204	/*
205	* Read PSID file header to buffer
206	*/
207
208	bool LoadPSIDHeader(const char file, uint8 p)
209	{
210	// Read header
211	memset(p, 0, PSID_MAX_HEADER_LENGTH);
212	int fd = open(file, O_RDONLY);
213	if (fd < 0)
214	return false;
215	ssize_t actual = read(fd, p, PSID_MAX_HEADER_LENGTH);
216	close(fd);
217	return actual >= PSID_MIN_HEADER_LENGTH;
218	}
219
220
221	/*
222	* Check for PSID header
223	*/
224
225	bool IsPSIDHeader(const uint8 *p)
226	{
227	// Check signature and version
228	uint32 id = read_psid_32(p, PSID_ID);
229	uint16 version = read_psid_16(p, PSID_VERSION);
230	return id == 'PSID' && (version == 1 \|\| version == 2);
231	}
232
233
234	/*
235	* Check whether file is a PSID file
236	*/
237
238	bool IsPSIDFile(const char *file)
239	{
240	// Load header
241	uint8 header[PSID_MAX_HEADER_LENGTH];
242	if (!LoadPSIDHeader(file, header))
243	return false;
244
245	// Check header
246	return IsPSIDHeader(header);
247	}
248
249
250	/*
251	* Load PSID file for playing
252	*/
253
254	bool LoadPSIDFile(const char *file)
255	{
256	// Open file
257	int fd = open(file, O_RDONLY);
258	if (fd < 0)
259	return false;
260
261	// Clear C64 RAM
262	MemoryClear();
263	psid_loaded = false;
264
265	// Load and check header
266	uint8 header[PSID_MAX_HEADER_LENGTH];
267	ssize_t actual = read(fd, header, PSID_MAX_HEADER_LENGTH);
268	if (actual < 0 \|\| !IsPSIDHeader(header)) {
269	close(fd);
270	return false;
271	}
272
273	// Extract data from header
274	number_of_songs = read_psid_16(header, PSID_NUMBER);
275	if (number_of_songs == 0)
276	number_of_songs = 1;
277	current_song = read_psid_16(header, PSID_DEFSONG);
278	if (current_song)
279	current_song--;
280	if (current_song >= number_of_songs)
281	current_song = 0;
282
283	init_adr = read_psid_16(header, PSID_INIT);
284	play_adr = read_psid_16(header, PSID_MAIN);
285
286	speed_flags = read_psid_32(header, PSID_SPEED);
287
288	int32 sl = 32, dl = 64, state = 0;
289	convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_NAME), &sl, module_name, &dl, &state);
290	sl = 32, dl = 64, state = 0;
291	convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_AUTHOR), &sl, author_name, &dl, &state);
292	sl = 32, dl = 64, state = 0;
293	convert_to_utf8(B_ISO1_CONVERSION, (char *)(header + PSID_COPYRIGHT), &sl, copyright_info, &dl, &state);
294	module_name[63] = 0;
295	author_name[63] = 0;
296	copyright_info[63] = 0;
297
298	// Seek to start of module data
299	lseek(fd, read_psid_16(header, PSID_LENGTH), SEEK_SET);
300
301	// Find load address
302	uint16 load_adr = read_psid_16(header, PSID_START);
303	if (load_adr == 0) { // Load address is at start of module data
304	uint8 hi, lo;
305	read(fd, &lo, 1);
306	read(fd, &hi, 1);
307	load_adr = (hi << 8) \| lo;
308	}
309	if (init_adr == 0) // Init routine address is equal to load address
310	init_adr = load_adr;
311
312	// Load module data to C64 RAM
313	read(fd, ram + load_adr, RAM_SIZE - load_adr);
314	close(fd);
315
316	// Select default song
317	SelectSong(current_song);
318
319	// Set replay routine address if not given in header
320	if (play_adr == 0) { // Replay routine address is given by interrupt vector
321	if (ram[1] & 2) // Kernal ROM switched in
322	play_adr = (ram[0x0315] << 8) \| ram[0x0314];
323	else // Kernal ROM switched out
324	play_adr = (ram[0xffff] << 8) \| ram[0xfffe];
325	}
326
327	// Everything OK
328	psid_loaded = true;
329	return true;
330	}
331
332
333	/*
334	* Select song for playing
335	*/
336
337	void SelectSong(int num)
338	{
339	if (num >= number_of_songs)
340	num = 0;
341	current_song = num;
342
343	// Reset SID
344	SIDReset(0);
345
346	// Set replay frequency
347	int freq = 50;
348	if (num < 32)
349	freq = speed_flags & (1 << num) ? 60 : 50;
350	SIDSetReplayFreq(freq);
351	SIDAdjustSpeed(100);
352
353	// Execute init routine
354	CPUExecute(init_adr, current_song, 0, 0, 1000000);
355	}
356
357
358	/*
359	* Application constructor
360	*/
361
362	#if B_HOST_IS_LENDIAN
363	const media_raw_audio_format audio_format = {44100.0, 2, media_raw_audio_format::B_AUDIO_SHORT, B_MEDIA_LITTLE_ENDIAN, 4096};
364	#else
365	const media_raw_audio_format audio_format = {44100.0, 2, media_raw_audio_format::B_AUDIO_SHORT, B_MEDIA_BIG_ENDIAN, 4096};
366	#endif
367
368	SIDPlayer::SIDPlayer() : BApplication("application/x-vnd.cebix-SIDPlayer"), player(&audio_format, "SIDPlayer", buffer_proc)
369	{
370	main_window = NULL;
371	player.SetHasData(true);
372	player_stopped = true;
373	}
374
375
376	/*
377	* Application destructor
378	*/
379
380	SIDPlayer::~SIDPlayer()
381	{
382	main_window = NULL;
383	prefs_window = NULL;
384	player.Stop();
385	player_stopped = true;
386	}
387
388
389	/*
390	* Shell arguments received
391	*/
392
393	void SIDPlayer::ArgvReceived(int32 argc, char **argv)
394	{
395	if (argc >= 2) {
396	player.Stop();
397	LoadPSIDFile(argv[1]);
398	player.Start();
399	player_stopped = false;
400	if (main_window)
401	main_window->PostMessage(MSG_NEW_MODULE);
402	}
403	}
404
405
406	/*
407	* Tracker arguments received
408	*/
409
410	void SIDPlayer::RefsReceived(BMessage *msg)
411	{
412	entry_ref the_ref;
413	if (msg->FindRef("refs", &the_ref) == B_NO_ERROR) {
414	BEntry the_entry;
415	if (the_entry.SetTo(&the_ref) == B_NO_ERROR) {
416	if (the_entry.IsFile()) {
417	BPath the_path;
418	the_entry.GetPath(&the_path);
419	player.Stop();
420	LoadPSIDFile(the_path.Path());
421	player.Start();
422	player_stopped = false;
423	if (main_window)
424	main_window->PostMessage(MSG_NEW_MODULE);
425	}
426	}
427	}
428	}
429
430
431	/*
432	* Message received
433	*/
434
435	void SIDPlayer::MessageReceived(BMessage *msg)
436	{
437	switch (msg->what) {
438
439	case B_SIMPLE_DATA: // Dropped message
440	RefsReceived(msg);
441	break;
442
443	case MSG_SHOW_PREFS:
444	if (!prefs_window_open)
445	prefs_window = new PrefsWindow();
446	else if (prefs_window)
447	prefs_window->Activate(true);
448	break;
449
450	case MSG_PLAY_PAUSE:
451	if (player_stopped) {
452	player.Start();
453	player_stopped = false;
454	} else {
455	player.Stop();
456	player_stopped = true;
457	}
458	break;
459
460	case MSG_STOP:
461	player.Stop();
462	player_stopped = true;
463	SelectSong(current_song);
464	main_window->PostMessage(MSG_NEW_SONG);
465	break;
466
467	case MSG_NEXT:
468	if (current_song < number_of_songs-1) {
469	player.Stop();
470	SelectSong(current_song + 1);
471	main_window->PostMessage(MSG_NEW_SONG);
472	if (!player_stopped)
473	player.Start();
474	}
475	break;
476
477	case MSG_PREV:
478	if (current_song > 0) {
479	player.Stop();
480	SelectSong(current_song - 1);
481	main_window->PostMessage(MSG_NEW_SONG);
482	if (!player_stopped)
483	player.Start();
484	}
485	break;
486
487	default:
488	BApplication::MessageReceived(msg);
489	break;
490	}
491	}
492
493
494	/*
495	* Arguments processed, open player window
496	*/
497
498	void SIDPlayer::ReadyToRun(void)
499	{
500	main_window = new MainWindow();
501	if (psid_loaded)
502	main_window->PostMessage(MSG_NEW_MODULE);
503	}
504
505
506	/*
507	* Show About window
508	*/
509
510	void AboutWindow(void)
511	{
512	BAlert *theAlert = new BAlert("",
513	"SIDPlayer\nVersion 4.0\n\n"
514	"Copyright " B_UTF8_COPYRIGHT " 1996-2000 Christian Bauer\n"
515	"E-mail: Christian.Bauer@uni-mainz.de\n"
516	"http://www.uni-mainz.de/~bauec002/\n\n"
517	"SIDPlayer comes with ABSOLUTELY NO\n"
518	"WARRANTY. This is free software, and\n"
519	"you are welcome to redistribute it\n"
520	"under the terms of the GNU General\n"
521	"Public License.\n",
522	"OK", NULL, NULL, B_WIDTH_FROM_LABEL);
523
524	BTextView *theText = theAlert->TextView();
525	if (theText) {
526	theText->SetStylable(true);
527	theText->Select(0, 9);
528	BFont ourFont;
529	theText->SetFontAndColor(be_bold_font);
530	theText->GetFontAndColor(2, &ourFont, NULL);
531	ourFont.SetSize(24);
532	theText->SetFontAndColor(&ourFont);
533	}
534	theAlert->Go();
535	}
536
537	void SIDPlayer::AboutRequested(void)
538	{
539	AboutWindow();
540	}
541
542
543	/*
544	* SoundPlayer buffer procedure
545	*/
546
547	void SIDPlayer::buffer_proc(void cookie, void buffer, size_t size, const media_raw_audio_format &format)
548	{
549	SIDCalcBuffer((uint8 *)buffer, size);
550	}
551
552
553	/*
554	* Main window constructor
555	*/
556
557	MainWindow::MainWindow() : BWindow(BRect(0, 0, 284, 96), "SIDPlayer", B_TITLED_WINDOW, B_NOT_ZOOMABLE \| B_NOT_RESIZABLE \| B_ASYNCHRONOUS_CONTROLS)
558	{
559	fill_color = ui_color(B_PANEL_BACKGROUND_COLOR);
560	BRect b = Bounds();
561
562	// Move window to right position
563	Lock();
564	MoveTo(80, 80);
565
566	// Create menu bar
567	BMenuBar *bar = new BMenuBar(BRect(0, 0, b.right, b.bottom), "menubar");
568	BMenu *menu = new BMenu("File");
569	menu->AddItem(new BMenuItem("About SIDPlayer" B_UTF8_ELLIPSIS, new BMessage(B_ABOUT_REQUESTED)));
570	menu->AddItem(new BSeparatorItem());
571	menu->AddItem(new BMenuItem("Sound Control" B_UTF8_ELLIPSIS, new BMessage(MSG_SHOW_PREFS), 'P'));
572	menu->AddItem(new BSeparatorItem());
573	menu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED), 'Q'));
574	menu->SetTargetForItems(be_app);
575	bar->AddItem(menu);
576	AddChild(bar);
577	SetKeyMenuBar(bar);
578	float menu_height = bar->Bounds().Height();
579
580	// Resize window to fit menu bar
581	ResizeBy(0, menu_height);
582
583	// Light gray background
584	TopView *top = new TopView(BRect(0, menu_height, b.right, b.bottom + menu_height), "main", B_FOLLOW_NONE, B_WILL_DRAW);
585	AddChild(top);
586	top->SetViewColor(fill_color);
587
588	// Name/author/copyright display
589	name_view = make_name_display(BRect(0, 5, 279, 21), "Name", top);
590	author_view = make_name_display(BRect(0, 25, 279, 41), "Author", top);
591	copyright_view = make_name_display(BRect(0, 45, 279, 61), "Copyright", top);
592
593	// Buttons
594	top->AddChild(new PlayPauseButton(BRect(6, 67, 36, 91), new BMessage(MSG_PLAY_PAUSE)));
595	top->AddChild(new StopButton(BRect(37, 67, 67, 91), new BMessage(MSG_STOP)));
596	top->AddChild(new PrevButton(BRect(68, 67, 98, 91), new BMessage(MSG_PREV)));
597	top->AddChild(new NextButton(BRect(99, 67, 129, 91), new BMessage(MSG_NEXT)));
598
599	// Position indicator
600	top->AddChild(position_view = new BStringView(BRect(134, 72, 193, 85), "position", ""));
601	position_view->SetViewColor(fill_color);
602
603	// Speed slider
604	top->AddChild(speed_slider = new SpeedSlider(BRect(194, 62, 279, 63), "speed"));
605
606	// Show window
607	top->MakeFocus();
608	Unlock();
609	Show();
610	}
611
612
613	/*
614	* Create name display field
615	*/
616
617	BStringView MainWindow::make_name_display(BRect frame, char label_text, BView *parent)
618	{
619	// Label to the left of the display field
620	BRect label_rect = frame;
621	label_rect.right = label_rect.left + 65;
622
623	BStringView *label = new BStringView(label_rect, "", label_text);
624	parent->AddChild(label);
625	label->SetViewColor(fill_color);
626	label->SetLowColor(fill_color);
627	label->SetAlignment(B_ALIGN_RIGHT);
628	label->SetFont(be_bold_font);
629
630	// Box around display field
631	BRect frame_rect = frame;
632	frame_rect.left += 70;
633
634	BBox *box = new BBox(frame_rect);
635	parent->AddChild(box);
636	box->SetViewColor(fill_color);
637	box->SetLowColor(fill_color);
638
639	// The display field
640	BRect textview_rect = frame_rect;
641	textview_rect.OffsetTo(0, 0);
642	textview_rect.InsetBy(4, 2);
643
644	BStringView *text = new BStringView(textview_rect, "", "");
645	box->AddChild(text);
646	text->SetViewColor(fill_color);
647	text->SetLowColor(fill_color);
648	text->SetFont(be_plain_font);
649	return text;
650	}
651
652
653	/*
654	* Main window closed, quit program
655	*/
656
657	bool MainWindow::QuitRequested(void)
658	{
659	be_app->PostMessage(B_QUIT_REQUESTED);
660	return true;
661	}
662
663
664	/*
665	* Message received
666	*/
667
668	void MainWindow::MessageReceived(BMessage *msg)
669	{
670	switch (msg->what) {
671	case MSG_NEW_MODULE:
672	// Update text views
673	Lock();
674	name_view->SetText(module_name);
675	author_view->SetText(author_name);
676	copyright_view->SetText(copyright_info);
677	Unlock();
678	// falls through
679
680	case MSG_NEW_SONG:
681	// Update position indicator and speed slider
682	if (number_of_songs > 0) {
683	char str[16];
684	sprintf(str, "Song %d/%d", current_song + 1, number_of_songs);
685	position_view->SetText(str);
686	}
687	speed_slider->SetValue(0);
688	break;
689
690	case MSG_SHOW_PREFS:
691	case MSG_PLAY_PAUSE:
692	case MSG_STOP:
693	case MSG_NEXT:
694	case MSG_PREV:
695	be_app->PostMessage(msg);
696	break;
697
698	default:
699	BWindow::MessageReceived(msg);
700	break;
701	}
702	}
703
704
705	/*
706	* TopView handles dropped messages (load new PSID module) and keypresses
707	*/
708
709	TopView::TopView(BRect frame, const char *name, uint32 resizingMode, uint32 flags)
710	: BView(frame, name, resizingMode, flags) {}
711
712	void TopView::MessageReceived(BMessage *msg)
713	{
714	if (msg->what == B_SIMPLE_DATA)
715	be_app->PostMessage(msg);
716	else
717	BView::MessageReceived(msg);
718	}
719
720	void TopView::KeyDown(const char *bytes, int32 numBytes)
721	{
722	BMessage *msg = Window()->CurrentMessage();
723	uint32 modifiers = 0;
724	msg->FindInt32("modifiers", (int32 *)&modifiers);
725
726	switch (bytes[0]) {
727	case 'p':
728	case 'P':
729	Window()->PostMessage(MSG_PLAY_PAUSE);
730	break;
731
732	case B_ESCAPE:
733	case B_SPACE:
734	case 's':
735	case 'S':
736	Window()->PostMessage(MSG_STOP);
737	break;
738
739	case B_LEFT_ARROW:
740	Window()->PostMessage(MSG_PREV);
741	break;
742
743	case B_RIGHT_ARROW:
744	case 'n':
745	case 'N':
746	Window()->PostMessage(MSG_NEXT);
747	break;
748
749	case 'q':
750	case 'Q':
751	be_app->PostMessage(B_QUIT_REQUESTED);
752	break;
753	}
754	}
755
756
757	/*
758	* Play/Pause button
759	*/
760
761	PlayPauseButton::PlayPauseButton(BRect frame, BMessage *msg) : BButton(frame, "play", "", msg) {};
762
763	void PlayPauseButton::Draw(BRect update)
764	{
765	// First draw normal button
766	BButton::Draw(update);
767
768	// Then draw play/pause image on top of it
769	if (Value())
770	SetHighColor(255, 255, 255);
771	else
772	SetHighColor(0, 0, 0);
773
774	FillRect(BRect(11, 8, 13, 16));
775	FillTriangle(BPoint(16, 8), BPoint(16, 16), BPoint(20, 12));
776	}
777
778
779	/*
780	* Stop button
781	*/
782
783	StopButton::StopButton(BRect frame, BMessage *msg) : BButton(frame, "stop", "", msg) {};
784
785	void StopButton::Draw(BRect update)
786	{
787	// First draw normal button
788	BButton::Draw(update);
789
790	// Then draw stop image on top of it
791	if (Value())
792	SetHighColor(255, 255, 255);
793	else
794	SetHighColor(0, 0, 0);
795
796	FillRect(BRect(11, 8, 20, 16));
797	}
798
799
800	/*
801	* "Next" button
802	*/
803
804	NextButton::NextButton(BRect frame, BMessage *msg) : BButton(frame, "next", "", msg) {};
805
806	void NextButton::Draw(BRect update)
807	{
808	// First draw normal button
809	BButton::Draw(update);
810
811	// Then draw "next" image on top of it
812	if (Value())
813	SetHighColor(255, 255, 255);
814	else
815	SetHighColor(0, 0, 0);
816
817	FillTriangle(BPoint(12, 8), BPoint(12, 16), BPoint(16, 12));
818	FillRect(BRect(17, 8, 19, 16));
819	}
820
821
822	/*
823	* "Prev" button
824	*/
825
826	PrevButton::PrevButton(BRect frame, BMessage *msg) : BButton(frame, "prev", "", msg) {};
827
828	void PrevButton::Draw(BRect update)
829	{
830	// First draw normal button
831	BButton::Draw(update);
832
833	// Then draw "prev" image on top of it
834	if (Value())
835	SetHighColor(255, 255, 255);
836	else
837	SetHighColor(0, 0, 0);
838
839	FillRect(BRect(12, 8, 14, 16));
840	FillTriangle(BPoint(19, 8), BPoint(19, 16), BPoint(15, 12));
841	}
842
843
844	/*
845	* Main program
846	*/
847
848	int main(int argc, char **argv)
849	{
850	InitAll();
851	SIDPlayer *the_app = new SIDPlayer();
852	the_app->Run();
853	delete the_app;
854	ExitAll();
855	return 0;
856	}