added bin_to_cso_mp3 tool

git-svn-id: file:///home/notaz/opt/svn/PicoDrive@435 be3aeb3a-fb24-0410-a615-afba39da0efa

tools/bin_to_cso_mp3/bin_to_cso_mp3.c

@@ -0,0 +1,723 @@
+/*
+ * bin_to_cso_mp3
+ * originally written by Exophase as "bin_to_iso_ogg"
+ * updated for cso/mp3 by notaz
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <string.h>
+
+#ifndef MAX_PATH
+#define MAX_PATH 1024
+#endif
+
+#ifdef _WIN32
+#include <windows.h>
+
+#define DIR_SEPARATOR_CHAR '\\'
+#define PATH_SEPARATOR_CHAR ';'
+#define LAME_BINARY "lame.exe"
+#define CISO_BINARY "ciso.exe"
+#define NULL_REDIR  "> NUL 2>&1"
+#else
+#define DIR_SEPARATOR_CHAR '/'
+#define PATH_SEPARATOR_CHAR ':'
+#define LAME_BINARY "lame"
+#define CISO_BINARY "ciso"
+#define NULL_REDIR  "> /dev/null 2>&1"
+#define mkdir(x) mkdir(x, S_IRWXU)
+#endif
+
+#define LAME_OPTIONS "-h --cbr"
+
+typedef unsigned char u8;
+typedef unsigned short int u16;
+typedef unsigned int u32;
+typedef unsigned long long int u64;
+typedef signed char s8;
+typedef signed short int s16;
+typedef signed int s32;
+typedef signed long long int s64;
+
+typedef enum
+{
+  TRACK_FILE_TYPE_BINARY,
+  TRACK_FILE_TYPE_WAVE,
+} track_file_type_enum;
+
+typedef struct
+{
+  u32 file_number;
+  u32 physical_offset;
+
+  u32 sector_offset;
+  u32 sector_count;
+  u32 pregap_offset;
+
+  u32 sector_size;
+  u32 format_type;
+} cd_track_struct;
+
+typedef struct
+{
+  track_file_type_enum type;
+  FILE *file_handle;
+
+  u32 current_offset;
+} cd_track_file_struct;
+
+typedef struct
+{
+  FILE *bin_file;
+  cd_track_file_struct track_files[100];
+  u32 num_files;
+
+  s32 first_track;
+  s32 last_track;
+  u32 num_physical_tracks;
+  u32 num_sectors;
+  s32 last_seek_track;
+
+  cd_track_struct physical_tracks[100];
+  cd_track_struct *logical_tracks[100];
+} cd_bin_struct;
+
+
+cd_bin_struct cd_bin;
+int opt_use_mp3 = 1;
+int opt_mp3_bitrate = 128;
+int opt_use_cso = 1;
+
+static void myexit(int code)
+{
+#ifdef _WIN32
+  system("pause");
+#endif
+  exit(code);
+}
+
+char *skip_whitespace(char *str)
+{
+  while(*str == ' ')
+    str++;
+
+  return str;
+}
+
+s32 load_bin_cue(char *cue_file_name)
+{
+  FILE *cue_file = fopen(cue_file_name, "rb");
+
+  printf("loading cue file %s\n", cue_file_name);
+
+  if(cue_file)
+  {
+    char line_buffer[256];
+    char *line_buffer_ptr;
+
+    char bin_file_name[MAX_PATH];
+    char *separator_pos;
+    s32 current_physical_track_number = -1;
+    u32 current_physical_offset;
+    u32 current_pregap = 0;
+    u32 bin_file_size;
+
+    cd_track_struct *current_physical_track = NULL;
+
+    u32 i;
+
+    // First, get filename. Only support binary right now.
+    fgets(line_buffer, 255, cue_file);
+
+    strcpy(bin_file_name, strchr(line_buffer, '"') + 1);
+
+    *(strrchr(bin_file_name, '"')) = 0;
+
+    // Might have to change directory first.
+    separator_pos = strrchr(cue_file_name, DIR_SEPARATOR_CHAR);
+
+    if(separator_pos)
+    {
+      char current_dir[MAX_PATH];
+      getcwd(current_dir, MAX_PATH);
+
+      *separator_pos = 0;
+
+      chdir(cue_file_name);
+
+#ifdef GP2X_BUILD
+      cd_bin.bin_file = open(bin_file_name, O_RDONLY);
+#else
+      cd_bin.bin_file = fopen(bin_file_name, "rb");
+#endif
+
+      printf("loaded bin file %s (%p)\n", bin_file_name, cd_bin.bin_file);
+
+      *separator_pos = DIR_SEPARATOR_CHAR;
+      chdir(current_dir);
+    }
+    else
+    {
+#ifdef GP2X_BUILD
+      cd_bin.bin_file = open(bin_file_name, O_RDONLY);
+#else
+      cd_bin.bin_file = fopen(bin_file_name, "rb");
+#endif
+    }
+
+    for(i = 0; i < 100; i++)
+    {
+      cd_bin.logical_tracks[i] = NULL;
+    }
+
+    cd_bin.first_track = -1;
+    cd_bin.last_track = -1;
+    cd_bin.num_physical_tracks = 0;
+    cd_bin.num_sectors = 0;
+
+    // Get line
+    while(fgets(line_buffer, 256, cue_file))
+    {
+      // Skip trailing whitespace
+      line_buffer_ptr = skip_whitespace(line_buffer);
+
+      // Dirty, but should work - switch on first character.
+      switch(line_buffer_ptr[0])
+      {
+        // New track number
+        case 'T':
+        {
+          u32 new_track_number;
+          char track_type[64];
+
+          sscanf(line_buffer_ptr, "TRACK %d %s", &new_track_number,
+           track_type);
+
+          current_physical_track_number++;
+          current_physical_track =
+           cd_bin.physical_tracks + current_physical_track_number;
+
+          current_physical_track->sector_size = 2352;
+
+          if(!strcmp(track_type, "AUDIO"))
+          {
+            current_physical_track->format_type = 0;
+            current_physical_track->sector_size = 2352;
+          }
+
+          if(!strcmp(track_type, "MODE1/2352"))
+          {
+            current_physical_track->format_type = 4;
+            current_physical_track->sector_size = 2352;
+          }
+
+          if(!strcmp(track_type, "MODE1/2048"))
+          {
+            current_physical_track->format_type = 4;
+            current_physical_track->sector_size = 2048;
+          }
+
+          cd_bin.logical_tracks[new_track_number] = current_physical_track;
+          cd_bin.num_physical_tracks++;
+
+          if((cd_bin.first_track == -1) ||
+           (new_track_number < cd_bin.first_track))
+          {
+            cd_bin.first_track = new_track_number;
+          }
+
+          if((cd_bin.last_track == -1) ||
+           (new_track_number > cd_bin.last_track))
+          {
+            cd_bin.last_track = new_track_number;
+          }
+
+          break;
+        }
+
+        // Pregap
+        case 'P':
+        {
+          u32 minutes, seconds, frames;
+
+          sscanf(line_buffer_ptr, "PREGAP %d:%d:%d", &minutes,
+           &seconds, &frames);
+
+          current_pregap += frames + (seconds * 75) + (minutes * 75 * 60);
+          break;
+        }
+
+        // Index
+        case 'I':
+        {
+          u32 index_number;
+          u32 minutes, seconds, frames;
+          u32 sector_offset;
+
+          sscanf(line_buffer_ptr, "INDEX %d %d:%d:%d", &index_number,
+           &minutes, &seconds, &frames);
+
+          sector_offset = frames + (seconds * 75) + (minutes * 75 * 60);
+
+          if(index_number == 1)
+          {
+            current_physical_track->pregap_offset = current_pregap;
+            current_physical_track->sector_offset = sector_offset;
+          }
+
+          break;
+        }
+      }
+    }
+
+    current_physical_offset = 0;
+
+    for(i = 0; i < cd_bin.num_physical_tracks - 1; i++)
+    {
+      cd_bin.physical_tracks[i].sector_count =
+       cd_bin.physical_tracks[i + 1].sector_offset -
+       cd_bin.physical_tracks[i].sector_offset;
+
+      cd_bin.physical_tracks[i].physical_offset = current_physical_offset;
+      current_physical_offset += (cd_bin.physical_tracks[i].sector_count *
+       cd_bin.physical_tracks[i].sector_size);
+
+      cd_bin.physical_tracks[i].sector_offset +=
+       cd_bin.physical_tracks[i].pregap_offset;
+
+      cd_bin.num_sectors += cd_bin.physical_tracks[i].sector_count;
+    }
+
+#ifdef GP2X_BUILD
+    bin_file_size = lseek(cd_bin.bin_file, 0, SEEK_END);
+    lseek(cd_bin.bin_file, 0, SEEK_SET);
+#else
+    fseek(cd_bin.bin_file, 0, SEEK_END);
+    bin_file_size = ftell(cd_bin.bin_file);
+    fseek(cd_bin.bin_file, 0, SEEK_SET);
+#endif
+
+    // Set the last track data
+    cd_bin.physical_tracks[i].physical_offset = current_physical_offset;
+    cd_bin.physical_tracks[i].sector_offset +=
+     cd_bin.physical_tracks[i].pregap_offset;
+    cd_bin.physical_tracks[i].sector_count =
+     (bin_file_size - current_physical_offset) /
+     cd_bin.physical_tracks[i].sector_size;
+
+    cd_bin.num_sectors += cd_bin.physical_tracks[i].sector_count;
+
+    printf("finished loading cue %s\n", cue_file_name);
+    printf("bin file: %s (%p)\n", bin_file_name, cd_bin.bin_file);
+    printf("first track: %d, last track: %d\n", cd_bin.first_track,
+     cd_bin.last_track);
+
+    for(i = cd_bin.first_track; i <= cd_bin.last_track; i++)
+    {
+      printf("track %d (%p):\n", i, cd_bin.logical_tracks[i]);
+      if(cd_bin.logical_tracks[i] == NULL)
+      {
+        printf("  (invalid)\n");
+      }
+      else
+      {
+        printf("  physical offset 0x%x\n",
+         cd_bin.logical_tracks[i]->physical_offset);
+        printf("  sector offset 0x%x\n",
+         cd_bin.logical_tracks[i]->sector_offset);
+        printf("  sector size %d\n",
+         cd_bin.logical_tracks[i]->sector_size);
+      }
+    }
+
+    cd_bin.last_seek_track = 0;
+
+    fclose(cue_file);
+    return 0;
+  }
+
+  return -1;
+}
+
+#define address8(base, offset)                                                \
+  *((u8 *)((u8 *)base + (offset)))                                            \
+
+#define address16(base, offset)                                               \
+  *((u16 *)((u8 *)base + (offset)))                                           \
+
+#define address32(base, offset)                                               \
+  *((u32 *)((u8 *)base + (offset)))                                           \
+
+// This will only work on little endian platforms for now.
+
+s32 convert_bin_to_wav(FILE *bin_file, char *output_dir, char *wav_file_name,
+ u32 sector_count)
+{
+  FILE *wav_file;
+  u8 wav_header[36];
+  u8 *riff_header = wav_header + 0;
+  u8 *fmt_header = wav_header + 0x0C;
+  u8 sector_buffer[2352];
+  u32 byte_length = sector_count * 2352;
+  u32 i;
+
+  chdir(output_dir);
+  wav_file = fopen(wav_file_name, "wb");
+
+  printf("writing wav %s, %x sectors\n", wav_file_name, sector_count);
+
+  // RIFF type chunk
+  memcpy(riff_header   + 0x00, "RIFF", 4);
+  address32(riff_header, 0x04) = byte_length + 44 - 8;
+  memcpy(riff_header   + 0x08, "WAVE", 4);
+
+  // WAVE file chunk: format
+  memcpy(fmt_header   + 0x00, "fmt ", 4);
+  // Chunk data size
+  address32(fmt_header, 0x04) = 16;
+  // Compression code: PCM
+  address16(fmt_header, 0x08) = 1;
+  // Number of channels: Stereo
+  address16(fmt_header, 0x0a) = 2;
+  // Sample rate: 44100Hz
+  address32(fmt_header, 0x0c) = 44100;
+  // Average bytes per second: sample rate * 4
+  address32(fmt_header, 0x10) = 44100 * 4;
+  // Block align (bytes per sample)
+  address16(fmt_header, 0x14) = 4;
+  // Bit depth
+  address16(fmt_header, 0x16) = 16;
+
+  // Write out header
+  fwrite(wav_header, 36, 1, wav_file);
+
+  // DATA chunk
+  fprintf(wav_file, "data");
+  // length
+  fwrite(&byte_length, 4, 1, wav_file);
+
+  // Write out sectors
+  for(i = 0; i < sector_count; i++)
+  {
+    printf("\b\b\b%3i", i*100 / sector_count);
+    fflush(stdout);
+    fread(sector_buffer, 2352, 1, bin_file);
+    fwrite(sector_buffer, 2352, 1, wav_file);
+  }
+  printf("\b\b\b100\n");
+
+  fclose(wav_file);
+  chdir("..");
+  return 0;
+}
+
+void convert_wav_to_ogg(char *wav_file_name, char *output_dir,
+ char *ogg_file_name)
+{
+  char cmd_string[(MAX_PATH * 2) + 16];
+
+  chdir(output_dir);
+  sprintf(cmd_string, "oggenc %s", wav_file_name);
+  system(cmd_string);
+
+  unlink(wav_file_name);
+  chdir("..");
+}
+
+void convert_wav_to_mp3(char *wav_file_name, char *output_dir,
+ char *mp3_file_name)
+{
+  char cmd_string[(MAX_PATH * 2) + 16];
+
+  chdir(output_dir);
+  sprintf(cmd_string, LAME_BINARY " " LAME_OPTIONS " -b %i \"%s\" \"%s\"",
+   opt_mp3_bitrate, wav_file_name, mp3_file_name);
+  if (system(cmd_string) != 0)
+  {
+    printf("failed to encode mp3\n");
+    myexit(1);
+  }
+
+  unlink(wav_file_name);
+  chdir("..");
+}
+
+s32 convert_bin_to_iso(FILE *bin_file, char *output_dir, char *iso_file_name,
+ u32 sector_count)
+{
+  FILE *iso_file;
+  u8 sector_buffer[2352];
+  u32 i;
+
+  chdir(output_dir);
+  iso_file = fopen(iso_file_name, "wb");
+  if (iso_file == NULL)
+  {
+    printf("failed to open: %s\n", iso_file_name);
+    myexit(1);
+  }
+  printf("writing iso %s, %x sectors\n", iso_file_name, sector_count);
+
+  for(i = 0; i < sector_count; i++)
+  {
+    printf("\b\b\b%3i", i*100 / sector_count);
+    fflush(stdout);
+    fread(sector_buffer, 2352, 1, bin_file);
+    fwrite(sector_buffer + 16, 2048, 1, iso_file);
+  }
+  printf("\b\b\b100\n");
+
+  fclose(iso_file);
+  chdir("..");
+  return 0;
+}
+
+void convert_iso_to_cso(char *output_dir, char *iso_file_name, char *cso_file_name)
+{
+  char cmd_string[(MAX_PATH * 2) + 16];
+
+  chdir(output_dir);
+  sprintf(cmd_string, CISO_BINARY " 9 \"%s\" \"%s\"", iso_file_name, cso_file_name);
+  if (system(cmd_string) != 0)
+  {
+    printf("failed to convert iso to cso\n");
+    myexit(1);
+  }
+
+  unlink(iso_file_name);
+  chdir("..");
+}
+
+
+#define sector_offset_to_msf(offset, minutes, seconds, frames)                \
+{                                                                             \
+  u32 _offset = offset;                                                       \
+  minutes = (_offset / 75) / 60;                                              \
+  seconds = (_offset / 75) % 60;                                              \
+  frames = _offset % 75;                                                      \
+}                                                                             \
+
+
+s32 convert_bin_cue(char *output_name_base)
+{
+  char output_file_name[MAX_PATH];
+  FILE *output_cue_file;
+  FILE *bin_file = cd_bin.bin_file;
+  cd_track_struct *current_track;
+  u32 m, s, f;
+  u32 current_pregap = 0;
+  u32 last_pregap = 0;
+  u32 i;
+  struct stat sb;
+
+  if(stat(output_name_base, &sb))
+    mkdir(output_name_base);
+
+  sprintf(output_file_name, "%s.cue", output_name_base);
+  chdir(output_name_base);
+  output_cue_file = fopen(output_file_name, "wb");
+  chdir("..");
+
+  // Every track gets its own file. It's either going to be of type ISO
+  // or of type WAV.
+
+  for(i = 0; i < 100; i++)
+  {
+    current_track = cd_bin.logical_tracks[i];
+    if(current_track != NULL)
+    {
+      switch(current_track->format_type)
+      {
+        char output_name_tmp[MAX_PATH];
+
+        // Audio
+        case 0:
+        {
+          sprintf(output_file_name, "%s_%02d.mp3", output_name_base, i);
+          sprintf(output_name_tmp, "%s_%02d.wav", output_name_base, i);
+
+          fprintf(output_cue_file, "FILE \"%s\" %s\n",
+           opt_use_mp3 ? output_file_name : output_name_tmp,
+           opt_use_mp3 ? "MP3" : "WAVE");
+          fprintf(output_cue_file, "  TRACK %02d AUDIO\n", i);
+          current_pregap = current_track->pregap_offset - last_pregap;
+          last_pregap = current_track->pregap_offset;
+          if(current_pregap > 0)
+          {
+            sector_offset_to_msf(current_pregap, m, s, f);
+            fprintf(output_cue_file, "    PREGAP %02d:%02d:%02d\n", m, s, f);
+          }
+          fprintf(output_cue_file, "    INDEX 01 00:00:00\n");
+          sector_offset_to_msf(current_track->sector_count, m, s, f);
+          fprintf(output_cue_file, "    REM LENGTH %02d:%02d:%02d\n", m, s, f);
+
+          fseek(bin_file, current_track->physical_offset, SEEK_SET);
+          convert_bin_to_wav(bin_file, output_name_base, output_name_tmp,
+           current_track->sector_count);
+          if(opt_use_mp3)
+          {
+            convert_wav_to_mp3(output_name_tmp, output_name_base,
+             output_file_name);
+          }
+          break;
+        }
+
+        // Data
+        default:
+          sprintf(output_file_name, "%s_%02d.cso", output_name_base, i);
+          sprintf(output_name_tmp, "%s_%02d.iso", output_name_base, i);
+          fprintf(output_cue_file, "FILE \"%s\" BINARY\n",
+           opt_use_cso ? output_file_name : output_name_tmp);
+          fprintf(output_cue_file, "  TRACK %02d MODE1/2048\n", i);
+          current_pregap = current_track->pregap_offset - last_pregap;
+          last_pregap = current_track->pregap_offset;
+          if(current_pregap > 0)
+          {
+            sector_offset_to_msf(current_pregap, m, s, f);
+            fprintf(output_cue_file, "    PREGAP %02d:%02d:%02d\n", m, s, f);
+          }
+          fprintf(output_cue_file, "    INDEX 01 00:00:00\n");
+
+          fseek(bin_file, current_track->physical_offset, SEEK_SET);
+          convert_bin_to_iso(bin_file, output_name_base, output_name_tmp,
+           current_track->sector_count);
+          if(opt_use_cso)
+          {
+            convert_iso_to_cso(output_name_base, output_name_tmp, output_file_name);
+          }
+          break;
+      }
+    }
+  }
+
+  fclose(output_cue_file);
+
+  return 0;
+}
+
+#ifdef _WIN32
+static void update_path(void)
+{
+  char buff1[MAX_PATH], buff2[MAX_PATH];
+  char *path;
+  int i;
+
+  path = getenv("PATH");
+  GetModuleFileNameA(NULL, buff1, sizeof(buff1));
+  for (i = strlen(buff1)-1; i > 0; i--)
+    if (buff1[i] == '\\') break;
+  buff1[i] = 0;
+
+  snprintf(buff2, sizeof(buff2), "%s;%s", path, buff1);
+  SetEnvironmentVariableA("PATH", buff2);
+}
+#endif
+
+int main(int argc, char *argv[])
+{
+  char out_buff[MAX_PATH], *cue_file, *out_base;
+  int a;
+
+  if(argc < 2)
+  {
+    printf("bin/cue to cso/mp3 converter\n");
+    printf("usage: %s [options] <input cue> [output base]\n", argv[0]);
+    printf("options:\n"
+           "   -m        output mp3 files for audio (default) (lame required)\n"
+           "   -b <rate> mp3 bitrate to use (default is 128)\n"
+           "   -w        output wav files for audio\n"
+           "   -c        output cso as data track (default) (ciso required)\n"
+           "   -i        output iso as data track\n");
+    return 0;
+  }
+
+  for (a = 1; a < argc - 1; a++)
+  {
+    if      (strcmp(argv[a], "-m") == 0)
+      opt_use_mp3 = 1;
+    else if (strcmp(argv[a], "-w") == 0)
+      opt_use_mp3 = 0;
+    else if (strcmp(argv[a], "-c") == 0)
+      opt_use_cso = 1;
+    else if (strcmp(argv[a], "-i") == 0)
+      opt_use_cso = 0;
+    else if (strcmp(argv[a], "-b") == 0)
+    {
+      opt_mp3_bitrate = atoi(argv[++a]);
+    }
+    else
+      break;
+  }
+  cue_file = argv[a];
+  out_base = argv[a+1];
+
+  /* some sanity checks */
+  if(strlen(cue_file) < 4 || strcasecmp(cue_file + strlen(cue_file) - 4, ".cue") != 0)
+  {
+    printf("error: not a cue file specified?\n");
+    myexit(1);
+  }
+
+#ifdef _WIN32
+  update_path();
+#endif
+
+  if(opt_use_mp3 && system(LAME_BINARY " --help " NULL_REDIR) != 0)
+  {
+    printf("LAME seems to be missing.\n"
+#ifdef _WIN32
+      "Download from http://lame.sourceforge.net/links.php#Binaries and extract\n"
+      "lame.exe to the same directory as %s\n", argv[0]
+#else
+      "Install lame using your packet manager, obtain binaries or build from\n"
+      "sources at http://lame.sourceforge.net/\n"
+#endif
+      );
+    myexit(1);
+  }
+
+  if(opt_use_cso && system(CISO_BINARY " " NULL_REDIR) != 0)
+  {
+    printf("CISO seems to be missing.\n"
+#ifdef _WIN32
+      "Download ciso.exe and extract to the same directory as %s\n"
+      "You can take ciso.exe from yacc at http://yacc.pspgen.com/\n", argv[0]
+#else
+      "Install ciso using your packet manager, obtain binaries or build from\n"
+      "sources at http://ciso.tenshu.fr/\n"
+#endif
+      );
+    myexit(1);
+  }
+
+  if(load_bin_cue(cue_file) == 0)
+  {
+    if(out_base == NULL)
+    {
+      char *p;
+      strncpy(out_buff, cue_file, sizeof(out_buff));
+      out_buff[sizeof(out_buff)-1] = 0;
+      p = strrchr(out_buff, DIR_SEPARATOR_CHAR);
+      if (p != NULL)
+      {
+        *p++ = 0;
+        chdir(out_buff);
+        memmove(out_buff, p, strlen(p)+1);
+      }
+      out_buff[strlen(out_buff)-4] = 0;
+      out_base = out_buff;
+    }
+    if(convert_bin_cue(out_base) != 0)
+      myexit(1);
+  }
+  else
+  {
+    printf("error: could not load cue file %s\n", cue_file);
+    myexit(1);
+  }
+
+  return 0;
+}
+

tools/bin_to_cso_mp3/readme.txt

@@ -0,0 +1,47 @@
+
+bin_to_cso_mp3
+Originally written by Exophase as "bin_to_iso_ogg"
+updated for cso/mp3 by notaz
+
+
+About
+-----
+
+This is a tool to convert cue/bin CD image to cue/cso/mp3 form, useful to use
+with emulators. It can also create ISO instead of CSO and WAV instead of MP3.
+Note that input must be .cue file, along with single .bin file.
+
+
+Easy/Windows usage
+------------------
+
+1. Download LAME from http://lame.sourceforge.net/links.php#Binaries
+   You need an archive or "LAME Bundle" with lame.exe inside. Extract lame.exe
+   to the same directory as bin_to_cso_mp3.exe
+2. Find ciso.exe . It usually comes with ISO->CSO converters, for example yacc
+   (http://yacc.pspgen.com/). Extract ciso.exe to the directory from previous
+   step.
+3. Drag the .cue file you want to convert onto bin_to_cso_mp3.exe . It should
+   pop up console window with some scrolling text, which should close by itself
+   when done. After that you should see new directory with converted files.
+
+
+Advanced usage
+--------------
+
+Just run bin_to_cso_mp3.exe from console terminal (or "command prompt") without
+any parameters to see usage.
+
+
+Linux
+-----
+
+You will need to compile bin_to_cso_mp3.c yourself using gcc:
+$ gcc bin_to_cso_mp3.c -o bin_to_cso_mp3
+
+You will also need to have lame and ciso binaries in PATH. Those can sometimes
+be installed using packet manager from the distribution, or you can compile
+them from sources:
+lame: http://lame.sourceforge.net/
+ciso: http://ciso.tenshu.fr/
+