src/tools/akaiextract.cpp

/*
  libakai - C++ cross-platform akai sample disk reader
  Copyright (C) 2002-2003 Sébastien Métrot

  Linux port by Christian Schoenebeck <cuse@users.sourceforge.net> 2003-2014

  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
// akaiextract.cpp : Defines the entry point for the console application.
//

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef _WIN32_
# define _WIN32_WINNT 0x0500
# include <windows.h>
# include <conio.h>
#else
# include <sys/types.h>
# include <sys/stat.h>
# include <dirent.h>
# include <errno.h>
# include <dlfcn.h>
#endif

// for testing the disk streaming methods
#define USE_DISK_STREAMING 1

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <sstream>
#include <string.h>

#include "../Akai.h"

// only libsndfile is available for Windows, so we use that for writing the sound files
#ifdef WIN32
# define HAVE_SNDFILE 1
#endif // WIN32

// abort compilation here if neither libsndfile nor libaudiofile are available
#if !HAVE_SNDFILE && !HAVE_AUDIOFILE
# error "Neither libsndfile nor libaudiofile seem to be available!"
# error "(HAVE_SNDFILE and HAVE_AUDIOFILE are both false)"
#endif

// we prefer libsndfile before libaudiofile
#if HAVE_SNDFILE
# include <sndfile.h>
#else
# include <audiofile.h>
#endif // HAVE_SNDFILE

#if !HAVE_SNDFILE // use libaudiofile
void* hAFlib; // handle to libaudiofile
void openAFlib(void);
void closeAFlib(void);
// pointers to libaudiofile functions
AFfilesetup(*_afNewFileSetup)(void);
void(*_afFreeFileSetup)(AFfilesetup);
void(*_afInitChannels)(AFfilesetup,int,int);
void(*_afInitSampleFormat)(AFfilesetup,int,int,int);
void(*_afInitFileFormat)(AFfilesetup,int);
void(*_afInitRate)(AFfilesetup,int,double);
int(*_afWriteFrames)(AFfilehandle,int,const void*,int);
AFfilehandle(*_afOpenFile)(const char*,const char*,AFfilesetup);
int(*_afCloseFile)(AFfilehandle file);
#endif // !HAVE_SNDFILE

int writeWav(AkaiSample* sample, const char* filename, void* samples, long samplecount, int channels = 1, int bitdepth = 16, long rate = 44100);
void ConvertAkaiToAscii(char * buffer, int length); // debugging purpose only

using namespace std;

template<class T> inline std::string ToString(T o) {
    std::stringstream ss;
    ss << o;
    return ss.str();
}

void PrintLastError(char* file, int line)
{
#ifdef _WIN32_
  LPVOID lpMsgBuf;
  FormatMessage(
      FORMAT_MESSAGE_ALLOCATE_BUFFER |
      FORMAT_MESSAGE_FROM_SYSTEM |
      FORMAT_MESSAGE_IGNORE_INSERTS,
      NULL,
      GetLastError(),
      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
      (LPTSTR) &lpMsgBuf,
      0,
      NULL
  );
  // Display the string.
  char buf[2048];
  sprintf(buf,"%s(%d): %s",file, line, (LPCTSTR)lpMsgBuf);
  printf("%s",buf);
  OutputDebugString(buf);
  // Free the buffer.
  LocalFree( lpMsgBuf );
#endif
}

#define SHOWERROR PrintLastError(__FILE__,__LINE__)

static void printUsage() {
#ifdef _WIN32_
    printf(
        "akaiextract <source-drive-letter>: <destination-dir>\n"
        "by Sebastien Métrot (meeloo@meeloo.net)\n\n"
        "Reads an AKAI media (i.e. CDROM, ZIP disk) and extracts all its audio\n"
        "samples as .wav files to the given output directory. If the given output\n"
        "directory does not exist yet, then it will be created.\n\n"
        "Available types of your drives:\n"
    );
    char rootpath[4]="a:\\";
    for (char drive ='a'; drive <= 'z'; drive++) {
        rootpath[0] = drive;
        int type = GetDriveType(rootpath);
        if (type != DRIVE_NO_ROOT_DIR) {
            printf("Drive %s is a ", rootpath);
            switch(type) {
                case DRIVE_UNKNOWN: printf("Unknown\n"); break;
                case DRIVE_NO_ROOT_DIR: printf("Unavailable\n");
                case DRIVE_REMOVABLE: printf("removable disk\n"); break;
                case DRIVE_FIXED: printf("fixed disk\n"); break;
                case DRIVE_REMOTE: printf("remote (network) drive\n"); break;
                case DRIVE_CDROM: printf("CD-ROM drive\n"); break;
                case DRIVE_RAMDISK: printf("RAM disk\n"); break;
            }
        }
    }
    printf("\n");
#elif defined _CARBON_
    printf(
        "akaiextract [<source-path>] <destination-dir>\n"
        "by Sebastien Métrot (meeloo@meeloo.net)\n\n"
        "Reads an AKAI media (i.e. CDROM, ZIP disk) and extracts all its audio\n"
        "samples as .wav files to the given output directory. If the given output\n"
        "directory does not exist yet, then it will be created.\n\n"
        "<source-path> - path of the source AKAI image file, if omitted CDROM\n"
        "                drive ('/dev/rdisk1s0') will be accessed\n\n"
        "<destination-dir> - target directory where samples will be written to\n\n"
    );
#else
    printf(
        "akaiextract <source-path> <destination-dir>\n"
        "by Sebastien Métrot (meeloo@meeloo.net)\n"
        "Linux port by Christian Schoenebeck\n\n"
        "Reads an AKAI media (i.e. CDROM, ZIP disk) and extracts all its audio\n"
        "samples as .wav files to the given output directory. If the given output\n"
        "directory does not exist yet, then it will be created.\n\n"
        "<source-path> - path of the source drive or image file (i.e. /dev/cdrom)\n\n"
        "<destination-dir> - target directory where samples will be written to\n\n"
    );
#endif
}

int main(int argc, char** argv) {
#if defined _CARBON_
    if (argc < 2) {
        printUsage();
        return -1;
    }
#else
    if (argc < 3) {
        printUsage();
        return -1;
    }
#endif

    // open input source
    DiskImage* pImage = NULL;
#ifdef _WIN32_
    char drive = toupper(*(argv[1]))-'A';
    printf("opening drive %c:\n",drive+'a'); 
    pImage = new DiskImage(drive);
#elif defined _CARBON_
    if (argc == 2) {
        printf("Opening AKAI media at '/dev/rdisk1s0'\n");
        pImage = new DiskImage((int)0); // arbitrary int, argument will be ignored
    } else {
        printf("Opening source AKAI image file at '%s'\n", argv[1]);
        pImage = new DiskImage(argv[1]);
    }
#else
    printf("Opening AKAI media or image file at '%s'\n", argv[1]);
    pImage = new DiskImage(argv[1]);
#endif

    // determine output directory path
#if defined _CARBON_
    const char* outPath = (argc == 2) ? argv[1] : argv[2];
#else
    const char* outPath = argv[2];
#endif

  AkaiDisk* pAkai = new AkaiDisk(pImage);

  printf("Reading Akai file entries (this may take a while)...\n");
  printf("Partitions: %d\n", pAkai->GetPartitionCount());
  printf("Partitions list:\n");
  long totalSamplesSize = 0, totalSamples = 0;
  uint i;
  for (i = 0; i < pAkai->GetPartitionCount(); i++)
  {
    printf("%2.2d: Partition %c\n",i,'A'+i);
    AkaiPartition* pPartition = pAkai->GetPartition(i);
    if (pPartition)
    {
      std::list<AkaiDirEntry> Volumes;
      pPartition->ListVolumes(Volumes);
      std::list<AkaiDirEntry>::iterator it;
      std::list<AkaiDirEntry>::iterator end = Volumes.end();
      int vol = 0;
      for (it = Volumes.begin(); it != end; it++)
      {
        AkaiDirEntry DirEntry = *it;
        printf("  %d (%d) '%.12s'  [start=%d - type=%d]\n", vol,DirEntry.mIndex, DirEntry.mName.c_str(), DirEntry.mStart, DirEntry.mType);
        AkaiVolume* pVolume = pPartition->GetVolume(vol);
        if (pVolume)
        {
          std::list<AkaiDirEntry> Programs;
          pVolume->ListPrograms(Programs);
          std::list<AkaiDirEntry>::iterator it;
          std::list<AkaiDirEntry>::iterator end = Programs.end();

          uint prog = 0;
          for (it = Programs.begin(); it != end; it++)
          {
            AkaiDirEntry DirEntry = *it;
            printf("    Program %d (%d) '%.12s' [start=%d size=%d - type=%c]\n", prog,DirEntry.mIndex, DirEntry.mName.c_str(), DirEntry.mStart, DirEntry.mSize, DirEntry.mType);
            AkaiProgram* pProgram = pVolume->GetProgram(prog);
            printf("        Number of key groups: %d\n",pProgram->mNumberOfKeygroups);
            pProgram->Release();
            prog++;
          }

          std::list<AkaiDirEntry> Samples;
          pVolume->ListSamples(Samples);
          end = Samples.end();

          uint samp = 0;
          for (it = Samples.begin(); it != end; it++)
          {
            AkaiDirEntry DirEntry = *it;
            printf("    Sample %d (%d) '%.12s' [start=%d size=%d - type=%c]\n", samp,DirEntry.mIndex, DirEntry.mName.c_str(), DirEntry.mStart, DirEntry.mSize, DirEntry.mType);
            AkaiSample* pSample= pVolume->GetSample(samp);
            printf("        Number of samples: %d (%d Hz)\n",pSample->mNumberOfSamples,pSample->mSamplingFrequency);
            totalSamplesSize += pSample->mNumberOfSamples;
            totalSamples++;
            pSample->Release();
            samp++;
          }

          pVolume->Release();
        }

        vol++;
      }

      pPartition->Release();
    }
  }

#if 0
  printf("Writing Akai track to hard disk...");
  fflush(stdout);
  bool success = pImage->WriteImage("/tmp/some.akai");
  if (success) printf("ok\n");
  else printf("error\n");
#endif

#if !HAVE_SNDFILE // use libaudiofile
  hAFlib = NULL;
  openAFlib();
#endif // !HAVE_SNDFILE

  totalSamplesSize *= 2; // due to 16 bit samples
  printf("There are %d samples on this disk with a total size of %d Bytes. ",
         totalSamples, totalSamplesSize);
  printf("Do you want to extract them (.wav files will be written to '%s')? [y/n]\n", outPath);
  char c = getchar();
  if (c == 'y' || c == 'Y') {
      bool errorOccured = false;
      DIR* dir = opendir(outPath);
      if (!dir) {
          if (errno == ENOENT) {
              struct stat filestat;
              if (lstat(outPath, &filestat) < 0) {
                  printf("Creating output directory '%s'...", outPath);
                  fflush(stdout);
                  if (mkdir(outPath, 0770) < 0) {
                      perror("failed");
                      errorOccured = true;
                  }
                  else printf("ok\n");
              }
              else {
                  if (!S_ISLNK(filestat.st_mode)) {
                      printf("Cannot create output directory '%s': ", outPath);
                      printf("a file of that name already exists\n");
                      errorOccured = true;
                  }
              }
          }
          else {
              perror("error while opening output directory");
              errorOccured = true;
          }
      }
      if (dir) closedir(dir);
      if (!errorOccured) {
          printf("Starting extraction...\n");
          long currentsample = 1;
          uint i;
          for (i = 0; i < pAkai->GetPartitionCount() && !errorOccured; i++) {
              AkaiPartition* pPartition = pAkai->GetPartition(i);
              if (pPartition) {
                  std::list<AkaiDirEntry> Volumes;
                  pPartition->ListVolumes(Volumes);
                  std::list<AkaiDirEntry>::iterator it;
                  std::list<AkaiDirEntry>::iterator end = Volumes.end();
                  int vol = 0;
                  for (it = Volumes.begin(); it != end && !errorOccured; it++) {
                      AkaiDirEntry DirEntry = *it;
                      AkaiVolume* pVolume = pPartition->GetVolume(vol);
                      if (pVolume) {
                          std::list<AkaiDirEntry> Samples;
                          pVolume->ListSamples(Samples);
                          std::list<AkaiDirEntry>::iterator it;
                          std::list<AkaiDirEntry>::iterator end = Samples.end();
                          uint samp = 0;
                          for (it = Samples.begin(); it != end && !errorOccured; it++) {
                              AkaiDirEntry DirEntry = *it;
                              AkaiSample* pSample = pVolume->GetSample(samp);
                              printf("Extracting Sample (%d/%d) %s...",
                                     currentsample++,
                                     totalSamples,
                                     DirEntry.mName.c_str());
                              fflush(stdout);
#if USE_DISK_STREAMING
                              if (pSample->LoadHeader()) {
                                  uint16_t* pSampleBuf = new uint16_t[pSample->mNumberOfSamples];
                                  pSample->Read(pSampleBuf, pSample->mNumberOfSamples);

                                  String filename = outPath + String("/") + DirEntry.mName + ".wav";
                                  int res = writeWav(pSample,
                                                     filename.c_str(),
                                                     pSampleBuf,
                                                     pSample->mNumberOfSamples);
                                  if (res < 0) {
                                      printf("couldn't write sample data\n");
                                      errorOccured = true;
                                  }
                                  else printf("ok\n");
                                  delete[] pSampleBuf;
                              }
                              else {
                                  printf("failed to load sample data\n");
                                  errorOccured = true;
                              }
#else // no disk streaming
                              if (pSample->LoadSampleData()) {

                                  String filename = outPath + String("/") + DirEntry.mName + ".wav";
                                  int res = writeWav(pSample,
                                                     filename.c_str(),
                                                     pSample->mpSamples,
                                                     pSample->mNumberOfSamples);
                                  if (res < 0) {
                                      printf("couldn't write sample data\n");
                                      errorOccured = true;
                                  }
                                  else printf("ok\n");
                                  pSample->ReleaseSampleData();
                              }
                              else {
                                  printf("failed to load sample data\n");
                                  errorOccured = true;
                              }
#endif // USE_DISK_STREAMING
                              pSample->Release();
                              samp++;
                          }
                          pVolume->Release();
                      }
                      vol++;
                  }
                  pPartition->Release();
              }
          }
      }
      if (errorOccured) printf("Extraction failed\n");
  }

#if !HAVE_SNDFILE // use libaudiofile
  closeAFlib();
#endif // !HAVE_SNDFILE

#if 0
  // this is just for debugging purpose - it converts the whole image to ascii
  printf("Converting...\n");
  FILE* f = fopen("akai_converted_to_ascii.iso", "w");
  if (f) {
    char* buf = (char*) malloc(AKAI_BLOCK_SIZE);
    pImage->SetPos(0);
    while (pImage->Available(1)) {
        int readbytes = pImage->Read(buf,1,AKAI_BLOCK_SIZE);
        if (readbytes != AKAI_BLOCK_SIZE) printf("Block incomplete (read: %d)\n",readbytes);
        ConvertAkaiToAscii(buf, readbytes);
        fwrite(buf, AKAI_BLOCK_SIZE, 1, f);
    }
    free(buf);
    fclose(f);
  }
  else printf("Could not open file\n");
#endif

  delete pAkai;
  delete pImage;
#if _WIN32_
  while(!_kbhit());
#endif
}

// only for debugging
void ConvertAkaiToAscii(char * buffer, int length)
{
  int i;

  for (i = 0; i < length; i++)
  {
    if (buffer[i]>=0 && buffer[i]<=9)
      buffer[i] +=48;
    else if (buffer[i]==10)
      buffer[i] = 32;
    else if (buffer[i]>=11 && buffer[i]<=36)
      buffer[i] = 64+(buffer[i]-10);
    else
      buffer[i] = 32;
  }
  buffer[length] = '\0';
  while (length-- > 0 && buffer[length] == 32)
  {
    // This block intentionaly left blank :)
  }
  buffer[length+1] = '\0';
}

int writeWav(AkaiSample* sample, const char* filename, void* samples, long samplecount, int channels, int bitdepth, long rate) {
#if HAVE_SNDFILE
    SNDFILE* hfile;
    SF_INFO  sfinfo;
    SF_INSTRUMENT instr;
    int format = SF_FORMAT_WAV;
    switch (bitdepth) {
        case 8:
            format |= SF_FORMAT_PCM_S8;
            break;
        case 16:
            format |= SF_FORMAT_PCM_16;
            break;
        case 24:
            format |= SF_FORMAT_PCM_24;
            break;
        case 32:
            format |= SF_FORMAT_PCM_32;
            break;
        default:
            cerr << "Error: Bithdepth " << ToString(bitdepth) << " not supported by libsndfile, ignoring sample!\n" << flush;
            return -1;
    }
    memset(&sfinfo, 0, sizeof (sfinfo));
    memset(&instr, 0, sizeof (instr));
    sfinfo.samplerate = rate;
    sfinfo.frames     = samplecount;
    sfinfo.channels   = channels;
    sfinfo.format     = format;
    if (!(hfile = sf_open(filename, SFM_WRITE, &sfinfo))) {
        cerr << "Error: Unable to open output file \'" << filename << "\'.\n" << flush;
        return -1;
    }
    instr.basenote = sample->mMidiRootNote;
    instr.detune = sample->mTuneCents;
    for (int i = 0; i < sample->mActiveLoops; ++i) {
        instr.loop_count = sample->mActiveLoops;
        instr.loops[i].mode = SF_LOOP_FORWARD;
        instr.loops[i].start = sample->mLoops[i].mMarker;
        instr.loops[i].end   = sample->mLoops[i].mCoarseLength;
        instr.loops[i].count = 0; // infinite
    }
    sf_command(hfile, SFC_SET_INSTRUMENT, &instr, sizeof(instr));
    sf_count_t res = bitdepth == 24 ?
        sf_write_int(hfile, static_cast<int*>(samples), channels * samplecount) :
        sf_write_short(hfile, static_cast<short*>(samples), channels * samplecount);
    if (res != channels * samplecount) {
        cerr << sf_strerror(hfile) << endl << flush;
        sf_close(hfile);
        return -1;
    }
    sf_close(hfile);
#else // use libaudiofile
    AFfilesetup setup = _afNewFileSetup();
    _afInitFileFormat(setup, AF_FILE_WAVE);
    _afInitChannels(setup, AF_DEFAULT_TRACK, channels);
    _afInitSampleFormat(setup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, bitdepth);
    _afInitRate(setup, AF_DEFAULT_TRACK, rate);
    if (setup == AF_NULL_FILESETUP) return -1;
    AFfilehandle hFile = _afOpenFile(filename, "w", setup);
    if (hFile == AF_NULL_FILEHANDLE) return -1;
    if (_afWriteFrames(hFile, AF_DEFAULT_TRACK, samples, samplecount) < 0) return -1;
    _afCloseFile(hFile);
    _afFreeFileSetup(setup);
#endif // HAVE_SNDFILE

    return 0; // success
}

#if !HAVE_SNDFILE // use libaudiofile
void openAFlib() {
    hAFlib = dlopen("libaudiofile.so", RTLD_NOW);
    if (!hAFlib) {
        cout << "Unable to load library libaudiofile.so: " << dlerror() << endl;
        return;
    }
    _afNewFileSetup     = (AFfilesetup(*)(void)) dlsym(hAFlib, "afNewFileSetup");
    _afFreeFileSetup    = (void(*)(AFfilesetup)) dlsym(hAFlib, "afFreeFileSetup");
    _afInitChannels     = (void(*)(AFfilesetup,int,int)) dlsym(hAFlib, "afInitChannels");
    _afInitSampleFormat = (void(*)(AFfilesetup,int,int,int)) dlsym(hAFlib, "afInitSampleFormat");
    _afInitFileFormat   = (void(*)(AFfilesetup,int)) dlsym(hAFlib, "afInitFileFormat");
    _afInitRate         = (void(*)(AFfilesetup,int,double)) dlsym(hAFlib, "afInitRate");
    _afWriteFrames      = (int(*)(AFfilehandle,int,const void*,int)) dlsym(hAFlib, "afWriteFrames");
    _afOpenFile         = (AFfilehandle(*)(const char*,const char*,AFfilesetup)) dlsym(hAFlib, "afOpenFile");
    _afCloseFile        = (int(*)(AFfilehandle file)) dlsym(hAFlib, "afCloseFile");
    if (dlerror()) cout << "Failed to load function from libaudiofile.so: " << dlerror() << endl;
}

void closeAFlib() {
    if (hAFlib) dlclose(hAFlib);
}
#endif // !HAVE_SNDFILE
1	/*
2	libakai - C++ cross-platform akai sample disk reader
3	Copyright (C) 2002-2003 Sébastien Métrot
4
5	Linux port by Christian Schoenebeck <cuse@users.sourceforge.net> 2003-2014
6
7	This library is free software; you can redistribute it and/or
8	modify it under the terms of the GNU Lesser General Public
9	License as published by the Free Software Foundation; either
10	version 2.1 of the License, or (at your option) any later version.
11
12	This library is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15	Lesser General Public License for more details.
16
17	You should have received a copy of the GNU Lesser General Public
18	License along with this library; if not, write to the Free Software
19	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20	*/
21	// akaiextract.cpp : Defines the entry point for the console application.
22	//
23
24	#ifdef HAVE_CONFIG_H
25	#include <config.h>
26	#endif
27
28	#ifdef _WIN32_
29	# define _WIN32_WINNT 0x0500
30	# include <windows.h>
31	# include <conio.h>
32	#else
33	# include <sys/types.h>
34	# include <sys/stat.h>
35	# include <dirent.h>
36	# include <errno.h>
37	# include <dlfcn.h>
38	#endif
39
40	// for testing the disk streaming methods
41	#define USE_DISK_STREAMING 1
42
43	#include <stdio.h>
44	#include <stdlib.h>
45	#include <iostream>
46	#include <sstream>
47	#include <string.h>
48
49	#include "../Akai.h"
50
51	// only libsndfile is available for Windows, so we use that for writing the sound files
52	#ifdef WIN32
53	# define HAVE_SNDFILE 1
54	#endif // WIN32
55
56	// abort compilation here if neither libsndfile nor libaudiofile are available
57	#if !HAVE_SNDFILE && !HAVE_AUDIOFILE
58	# error "Neither libsndfile nor libaudiofile seem to be available!"
59	# error "(HAVE_SNDFILE and HAVE_AUDIOFILE are both false)"
60	#endif
61
62	// we prefer libsndfile before libaudiofile
63	#if HAVE_SNDFILE
64	# include <sndfile.h>
65	#else
66	# include <audiofile.h>
67	#endif // HAVE_SNDFILE
68
69	#if !HAVE_SNDFILE // use libaudiofile
70	void* hAFlib; // handle to libaudiofile
71	void openAFlib(void);
72	void closeAFlib(void);
73	// pointers to libaudiofile functions
74	AFfilesetup(*_afNewFileSetup)(void);
75	void(*_afFreeFileSetup)(AFfilesetup);
76	void(*_afInitChannels)(AFfilesetup,int,int);
77	void(*_afInitSampleFormat)(AFfilesetup,int,int,int);
78	void(*_afInitFileFormat)(AFfilesetup,int);
79	void(*_afInitRate)(AFfilesetup,int,double);
80	int(_afWriteFrames)(AFfilehandle,int,const void,int);
81	AFfilehandle(_afOpenFile)(const char,const char*,AFfilesetup);
82	int(*_afCloseFile)(AFfilehandle file);
83	#endif // !HAVE_SNDFILE
84
85	int writeWav(AkaiSample* sample, const char* filename, void* samples, long samplecount, int channels = 1, int bitdepth = 16, long rate = 44100);
86	void ConvertAkaiToAscii(char * buffer, int length); // debugging purpose only
87
88	using namespace std;
89
90	template<class T> inline std::string ToString(T o) {
91	std::stringstream ss;
92	ss << o;
93	return ss.str();
94	}
95
96	void PrintLastError(char* file, int line)
97	{
98	#ifdef _WIN32_
99	LPVOID lpMsgBuf;
100	FormatMessage(
101	FORMAT_MESSAGE_ALLOCATE_BUFFER \|
102	FORMAT_MESSAGE_FROM_SYSTEM \|
103	FORMAT_MESSAGE_IGNORE_INSERTS,
104	NULL,
105	GetLastError(),
106	MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
107	(LPTSTR) &lpMsgBuf,
108	0,
109	NULL
110	);
111	// Display the string.
112	char buf[2048];
113	sprintf(buf,"%s(%d): %s",file, line, (LPCTSTR)lpMsgBuf);
114	printf("%s",buf);
115	OutputDebugString(buf);
116	// Free the buffer.
117	LocalFree( lpMsgBuf );
118	#endif
119	}
120
121	#define SHOWERROR PrintLastError(__FILE__,__LINE__)
122
123	static void printUsage() {
124	#ifdef _WIN32_
125	printf(
126	"akaiextract <source-drive-letter>: <destination-dir>\n"
127	"by Sebastien Métrot (meeloo@meeloo.net)\n\n"
128	"Reads an AKAI media (i.e. CDROM, ZIP disk) and extracts all its audio\n"
129	"samples as .wav files to the given output directory. If the given output\n"
130	"directory does not exist yet, then it will be created.\n\n"
131	"Available types of your drives:\n"
132	);
133	char rootpath[4]="a:\\";
134	for (char drive ='a'; drive <= 'z'; drive++) {
135	rootpath[0] = drive;
136	int type = GetDriveType(rootpath);
137	if (type != DRIVE_NO_ROOT_DIR) {
138	printf("Drive %s is a ", rootpath);
139	switch(type) {
140	case DRIVE_UNKNOWN: printf("Unknown\n"); break;
141	case DRIVE_NO_ROOT_DIR: printf("Unavailable\n");
142	case DRIVE_REMOVABLE: printf("removable disk\n"); break;
143	case DRIVE_FIXED: printf("fixed disk\n"); break;
144	case DRIVE_REMOTE: printf("remote (network) drive\n"); break;
145	case DRIVE_CDROM: printf("CD-ROM drive\n"); break;
146	case DRIVE_RAMDISK: printf("RAM disk\n"); break;
147	}
148	}
149	}
150	printf("\n");
151	#elif defined _CARBON_
152	printf(
153	"akaiextract [<source-path>] <destination-dir>\n"
154	"by Sebastien Métrot (meeloo@meeloo.net)\n\n"
155	"Reads an AKAI media (i.e. CDROM, ZIP disk) and extracts all its audio\n"
156	"samples as .wav files to the given output directory. If the given output\n"
157	"directory does not exist yet, then it will be created.\n\n"
158	"<source-path> - path of the source AKAI image file, if omitted CDROM\n"
159	" drive ('/dev/rdisk1s0') will be accessed\n\n"
160	"<destination-dir> - target directory where samples will be written to\n\n"
161	);
162	#else
163	printf(
164	"akaiextract <source-path> <destination-dir>\n"
165	"by Sebastien Métrot (meeloo@meeloo.net)\n"
166	"Linux port by Christian Schoenebeck\n\n"
167	"Reads an AKAI media (i.e. CDROM, ZIP disk) and extracts all its audio\n"
168	"samples as .wav files to the given output directory. If the given output\n"
169	"directory does not exist yet, then it will be created.\n\n"
170	"<source-path> - path of the source drive or image file (i.e. /dev/cdrom)\n\n"
171	"<destination-dir> - target directory where samples will be written to\n\n"
172	);
173	#endif
174	}
175
176	int main(int argc, char** argv) {
177	#if defined _CARBON_
178	if (argc < 2) {
179	printUsage();
180	return -1;
181	}
182	#else
183	if (argc < 3) {
184	printUsage();
185	return -1;
186	}
187	#endif
188
189	// open input source
190	DiskImage* pImage = NULL;
191	#ifdef _WIN32_
192	char drive = toupper(*(argv[1]))-'A';
193	printf("opening drive %c:\n",drive+'a');
194	pImage = new DiskImage(drive);
195	#elif defined _CARBON_
196	if (argc == 2) {
197	printf("Opening AKAI media at '/dev/rdisk1s0'\n");
198	pImage = new DiskImage((int)0); // arbitrary int, argument will be ignored
199	} else {
200	printf("Opening source AKAI image file at '%s'\n", argv[1]);
201	pImage = new DiskImage(argv[1]);
202	}
203	#else
204	printf("Opening AKAI media or image file at '%s'\n", argv[1]);
205	pImage = new DiskImage(argv[1]);
206	#endif
207
208	// determine output directory path
209	#if defined _CARBON_
210	const char* outPath = (argc == 2) ? argv[1] : argv[2];
211	#else
212	const char* outPath = argv[2];
213	#endif
214
215	AkaiDisk* pAkai = new AkaiDisk(pImage);
216
217	printf("Reading Akai file entries (this may take a while)...\n");
218	printf("Partitions: %d\n", pAkai->GetPartitionCount());
219	printf("Partitions list:\n");
220	long totalSamplesSize = 0, totalSamples = 0;
221	uint i;
222	for (i = 0; i < pAkai->GetPartitionCount(); i++)
223	{
224	printf("%2.2d: Partition %c\n",i,'A'+i);
225	AkaiPartition* pPartition = pAkai->GetPartition(i);
226	if (pPartition)
227	{
228	std::list<AkaiDirEntry> Volumes;
229	pPartition->ListVolumes(Volumes);
230	std::list<AkaiDirEntry>::iterator it;
231	std::list<AkaiDirEntry>::iterator end = Volumes.end();
232	int vol = 0;
233	for (it = Volumes.begin(); it != end; it++)
234	{
235	AkaiDirEntry DirEntry = *it;
236	printf(" %d (%d) '%.12s' [start=%d - type=%d]\n", vol,DirEntry.mIndex, DirEntry.mName.c_str(), DirEntry.mStart, DirEntry.mType);
237	AkaiVolume* pVolume = pPartition->GetVolume(vol);
238	if (pVolume)
239	{
240	std::list<AkaiDirEntry> Programs;
241	pVolume->ListPrograms(Programs);
242	std::list<AkaiDirEntry>::iterator it;
243	std::list<AkaiDirEntry>::iterator end = Programs.end();
244
245	uint prog = 0;
246	for (it = Programs.begin(); it != end; it++)
247	{
248	AkaiDirEntry DirEntry = *it;
249	printf(" Program %d (%d) '%.12s' [start=%d size=%d - type=%c]\n", prog,DirEntry.mIndex, DirEntry.mName.c_str(), DirEntry.mStart, DirEntry.mSize, DirEntry.mType);
250	AkaiProgram* pProgram = pVolume->GetProgram(prog);
251	printf(" Number of key groups: %d\n",pProgram->mNumberOfKeygroups);
252	pProgram->Release();
253	prog++;
254	}
255
256	std::list<AkaiDirEntry> Samples;
257	pVolume->ListSamples(Samples);
258	end = Samples.end();
259
260	uint samp = 0;
261	for (it = Samples.begin(); it != end; it++)
262	{
263	AkaiDirEntry DirEntry = *it;
264	printf(" Sample %d (%d) '%.12s' [start=%d size=%d - type=%c]\n", samp,DirEntry.mIndex, DirEntry.mName.c_str(), DirEntry.mStart, DirEntry.mSize, DirEntry.mType);
265	AkaiSample* pSample= pVolume->GetSample(samp);
266	printf(" Number of samples: %d (%d Hz)\n",pSample->mNumberOfSamples,pSample->mSamplingFrequency);
267	totalSamplesSize += pSample->mNumberOfSamples;
268	totalSamples++;
269	pSample->Release();
270	samp++;
271	}
272
273	pVolume->Release();
274	}
275
276	vol++;
277	}
278
279	pPartition->Release();
280	}
281	}
282
283	#if 0
284	printf("Writing Akai track to hard disk...");
285	fflush(stdout);
286	bool success = pImage->WriteImage("/tmp/some.akai");
287	if (success) printf("ok\n");
288	else printf("error\n");
289	#endif
290
291	#if !HAVE_SNDFILE // use libaudiofile
292	hAFlib = NULL;
293	openAFlib();
294	#endif // !HAVE_SNDFILE
295
296	totalSamplesSize *= 2; // due to 16 bit samples
297	printf("There are %d samples on this disk with a total size of %d Bytes. ",
298	totalSamples, totalSamplesSize);
299	printf("Do you want to extract them (.wav files will be written to '%s')? [y/n]\n", outPath);
300	char c = getchar();
301	if (c == 'y' \|\| c == 'Y') {
302	bool errorOccured = false;
303	DIR* dir = opendir(outPath);
304	if (!dir) {
305	if (errno == ENOENT) {
306	struct stat filestat;
307	if (lstat(outPath, &filestat) < 0) {
308	printf("Creating output directory '%s'...", outPath);
309	fflush(stdout);
310	if (mkdir(outPath, 0770) < 0) {
311	perror("failed");
312	errorOccured = true;
313	}
314	else printf("ok\n");
315	}
316	else {
317	if (!S_ISLNK(filestat.st_mode)) {
318	printf("Cannot create output directory '%s': ", outPath);
319	printf("a file of that name already exists\n");
320	errorOccured = true;
321	}
322	}
323	}
324	else {
325	perror("error while opening output directory");
326	errorOccured = true;
327	}
328	}
329	if (dir) closedir(dir);
330	if (!errorOccured) {
331	printf("Starting extraction...\n");
332	long currentsample = 1;
333	uint i;
334	for (i = 0; i < pAkai->GetPartitionCount() && !errorOccured; i++) {
335	AkaiPartition* pPartition = pAkai->GetPartition(i);
336	if (pPartition) {
337	std::list<AkaiDirEntry> Volumes;
338	pPartition->ListVolumes(Volumes);
339	std::list<AkaiDirEntry>::iterator it;
340	std::list<AkaiDirEntry>::iterator end = Volumes.end();
341	int vol = 0;
342	for (it = Volumes.begin(); it != end && !errorOccured; it++) {
343	AkaiDirEntry DirEntry = *it;
344	AkaiVolume* pVolume = pPartition->GetVolume(vol);
345	if (pVolume) {
346	std::list<AkaiDirEntry> Samples;
347	pVolume->ListSamples(Samples);
348	std::list<AkaiDirEntry>::iterator it;
349	std::list<AkaiDirEntry>::iterator end = Samples.end();
350	uint samp = 0;
351	for (it = Samples.begin(); it != end && !errorOccured; it++) {
352	AkaiDirEntry DirEntry = *it;
353	AkaiSample* pSample = pVolume->GetSample(samp);
354	printf("Extracting Sample (%d/%d) %s...",
355	currentsample++,
356	totalSamples,
357	DirEntry.mName.c_str());
358	fflush(stdout);
359	#if USE_DISK_STREAMING
360	if (pSample->LoadHeader()) {
361	uint16_t* pSampleBuf = new uint16_t[pSample->mNumberOfSamples];
362	pSample->Read(pSampleBuf, pSample->mNumberOfSamples);
363
364	String filename = outPath + String("/") + DirEntry.mName + ".wav";
365	int res = writeWav(pSample,
366	filename.c_str(),
367	pSampleBuf,
368	pSample->mNumberOfSamples);
369	if (res < 0) {
370	printf("couldn't write sample data\n");
371	errorOccured = true;
372	}
373	else printf("ok\n");
374	delete[] pSampleBuf;
375	}
376	else {
377	printf("failed to load sample data\n");
378	errorOccured = true;
379	}
380	#else // no disk streaming
381	if (pSample->LoadSampleData()) {
382
383	String filename = outPath + String("/") + DirEntry.mName + ".wav";
384	int res = writeWav(pSample,
385	filename.c_str(),
386	pSample->mpSamples,
387	pSample->mNumberOfSamples);
388	if (res < 0) {
389	printf("couldn't write sample data\n");
390	errorOccured = true;
391	}
392	else printf("ok\n");
393	pSample->ReleaseSampleData();
394	}
395	else {
396	printf("failed to load sample data\n");
397	errorOccured = true;
398	}
399	#endif // USE_DISK_STREAMING
400	pSample->Release();
401	samp++;
402	}
403	pVolume->Release();
404	}
405	vol++;
406	}
407	pPartition->Release();
408	}
409	}
410	}
411	if (errorOccured) printf("Extraction failed\n");
412	}
413
414	#if !HAVE_SNDFILE // use libaudiofile
415	closeAFlib();
416	#endif // !HAVE_SNDFILE
417
418	#if 0
419	// this is just for debugging purpose - it converts the whole image to ascii
420	printf("Converting...\n");
421	FILE* f = fopen("akai_converted_to_ascii.iso", "w");
422	if (f) {
423	char* buf = (char*) malloc(AKAI_BLOCK_SIZE);
424	pImage->SetPos(0);
425	while (pImage->Available(1)) {
426	int readbytes = pImage->Read(buf,1,AKAI_BLOCK_SIZE);
427	if (readbytes != AKAI_BLOCK_SIZE) printf("Block incomplete (read: %d)\n",readbytes);
428	ConvertAkaiToAscii(buf, readbytes);
429	fwrite(buf, AKAI_BLOCK_SIZE, 1, f);
430	}
431	free(buf);
432	fclose(f);
433	}
434	else printf("Could not open file\n");
435	#endif
436
437	delete pAkai;
438	delete pImage;
439	#if _WIN32_
440	while(!_kbhit());
441	#endif
442	}
443
444	// only for debugging
445	void ConvertAkaiToAscii(char * buffer, int length)
446	{
447	int i;
448
449	for (i = 0; i < length; i++)
450	{
451	if (buffer[i]>=0 && buffer[i]<=9)
452	buffer[i] +=48;
453	else if (buffer[i]==10)
454	buffer[i] = 32;
455	else if (buffer[i]>=11 && buffer[i]<=36)
456	buffer[i] = 64+(buffer[i]-10);
457	else
458	buffer[i] = 32;
459	}
460	buffer[length] = '\0';
461	while (length-- > 0 && buffer[length] == 32)
462	{
463	// This block intentionaly left blank :)
464	}
465	buffer[length+1] = '\0';
466	}
467
468	int writeWav(AkaiSample* sample, const char* filename, void* samples, long samplecount, int channels, int bitdepth, long rate) {
469	#if HAVE_SNDFILE
470	SNDFILE* hfile;
471	SF_INFO sfinfo;
472	SF_INSTRUMENT instr;
473	int format = SF_FORMAT_WAV;
474	switch (bitdepth) {
475	case 8:
476	format \|= SF_FORMAT_PCM_S8;
477	break;
478	case 16:
479	format \|= SF_FORMAT_PCM_16;
480	break;
481	case 24:
482	format \|= SF_FORMAT_PCM_24;
483	break;
484	case 32:
485	format \|= SF_FORMAT_PCM_32;
486	break;
487	default:
488	cerr << "Error: Bithdepth " << ToString(bitdepth) << " not supported by libsndfile, ignoring sample!\n" << flush;
489	return -1;
490	}
491	memset(&sfinfo, 0, sizeof (sfinfo));
492	memset(&instr, 0, sizeof (instr));
493	sfinfo.samplerate = rate;
494	sfinfo.frames = samplecount;
495	sfinfo.channels = channels;
496	sfinfo.format = format;
497	if (!(hfile = sf_open(filename, SFM_WRITE, &sfinfo))) {
498	cerr << "Error: Unable to open output file \'" << filename << "\'.\n" << flush;
499	return -1;
500	}
501	instr.basenote = sample->mMidiRootNote;
502	instr.detune = sample->mTuneCents;
503	for (int i = 0; i < sample->mActiveLoops; ++i) {
504	instr.loop_count = sample->mActiveLoops;
505	instr.loops[i].mode = SF_LOOP_FORWARD;
506	instr.loops[i].start = sample->mLoops[i].mMarker;
507	instr.loops[i].end = sample->mLoops[i].mCoarseLength;
508	instr.loops[i].count = 0; // infinite
509	}
510	sf_command(hfile, SFC_SET_INSTRUMENT, &instr, sizeof(instr));
511	sf_count_t res = bitdepth == 24 ?
512	sf_write_int(hfile, static_cast<int>(samples), channels samplecount) :
513	sf_write_short(hfile, static_cast<short>(samples), channels samplecount);
514	if (res != channels * samplecount) {
515	cerr << sf_strerror(hfile) << endl << flush;
516	sf_close(hfile);
517	return -1;
518	}
519	sf_close(hfile);
520	#else // use libaudiofile
521	AFfilesetup setup = _afNewFileSetup();
522	_afInitFileFormat(setup, AF_FILE_WAVE);
523	_afInitChannels(setup, AF_DEFAULT_TRACK, channels);
524	_afInitSampleFormat(setup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, bitdepth);
525	_afInitRate(setup, AF_DEFAULT_TRACK, rate);
526	if (setup == AF_NULL_FILESETUP) return -1;
527	AFfilehandle hFile = _afOpenFile(filename, "w", setup);
528	if (hFile == AF_NULL_FILEHANDLE) return -1;
529	if (_afWriteFrames(hFile, AF_DEFAULT_TRACK, samples, samplecount) < 0) return -1;
530	_afCloseFile(hFile);
531	_afFreeFileSetup(setup);
532	#endif // HAVE_SNDFILE
533
534	return 0; // success
535	}
536
537	#if !HAVE_SNDFILE // use libaudiofile
538	void openAFlib() {
539	hAFlib = dlopen("libaudiofile.so", RTLD_NOW);
540	if (!hAFlib) {
541	cout << "Unable to load library libaudiofile.so: " << dlerror() << endl;
542	return;
543	}
544	_afNewFileSetup = (AFfilesetup(*)(void)) dlsym(hAFlib, "afNewFileSetup");
545	_afFreeFileSetup = (void(*)(AFfilesetup)) dlsym(hAFlib, "afFreeFileSetup");
546	_afInitChannels = (void(*)(AFfilesetup,int,int)) dlsym(hAFlib, "afInitChannels");
547	_afInitSampleFormat = (void(*)(AFfilesetup,int,int,int)) dlsym(hAFlib, "afInitSampleFormat");
548	_afInitFileFormat = (void(*)(AFfilesetup,int)) dlsym(hAFlib, "afInitFileFormat");
549	_afInitRate = (void(*)(AFfilesetup,int,double)) dlsym(hAFlib, "afInitRate");
550	_afWriteFrames = (int()(AFfilehandle,int,const void,int)) dlsym(hAFlib, "afWriteFrames");
551	_afOpenFile = (AFfilehandle()(const char,const char*,AFfilesetup)) dlsym(hAFlib, "afOpenFile");
552	_afCloseFile = (int(*)(AFfilehandle file)) dlsym(hAFlib, "afCloseFile");
553	if (dlerror()) cout << "Failed to load function from libaudiofile.so: " << dlerror() << endl;
554	}
555
556	void closeAFlib() {
557	if (hAFlib) dlclose(hAFlib);
558	}
559	#endif // !HAVE_SNDFILE