                           M A K E W A V    3 . 1

    This is version 3.1 of makwave.  It supports loading 2k, 4k, 6k,
8448 byte ROM images, and the 32k .bin files included on the Supercharger CD.
It automatically detects which size your image is. Makewav supports ALL of
the .bin files on the Supercharger CD!

New to version 3.1:

- 'v' flag added that allows you to set the volume of the .wav file, some
  people were concerned that their .wav player didn't like having the .wav
  with the maximum volume level set.
- 'r' flag added which causes a raw data file to be created instead of a
  .wav file.  This raw file is the byte stream that the Supercharger reads
  from the tape.
- Games can now be "chained" together.  This allows you to recreate your
  Supercharger tapes!  Each load is seperated by a tone with no silence
  gap.
- Restructured the way the header and footer tones are written for a more
  straight-forward program flow.

New to version 3.0:

- multi-load byte command flag now works correctly (-m flag).
- Correctly handles all .bin files on the Supercharger CD.
- 'd' flag added that shows detailed debugging information about
  the .bin file.
- Makewav now determines that a page (256 byte chunk) of the .bin file is
  empty if all of the bytes in that page are identical.  It automatically
  leaves this page out of the .wav file.  This is great if you are developing
  a game and have a very small piece of code!  This can be overridden with
  the -p flag, which will force Makewav to include every page in the .wav
  file.

  Suggested command line:

          makewav -f game.bin game.wav

          or to chain games together:
            (with a 2 second header tone, a 3 second tone between
             each load, and a 1/2 second footer tone)

          makewav -f -h2 load1.bin+load2.bin+load3.bin game.wav

          (note: if a game doesn't work correctly, you can try the
                 -p flag, but I haven't had any problems with blank
                 page packing.)

  The command format is:

      makewav [flags] BINFILE[+BINFILE2...+BINFILEx] WAVFILE

          flags:
            -cxx   = Set control byte (2 digit hex)
            -d     = Display debug information
            -f     = Make a super-fastload .wav file
            -h#    = Set header tone length in seconds
                     (The gap between multiple loads has 1 second added)
            -k     = Use 44khz Waveforms
            -mxx   = Set multiload byte (2 digit hex)
            -p     = Turn "blank page" packing OFF
            -r     = Create raw data file instead of a .wav file
            -sxxxx = Set start address (4 digit hex)
            -v#    = Set volume level of .wav file (1-10)

  DETAILED DESCRIPTION OF FLAGS

  -c -> The -c must be followed by a 2 digit hex number (e.g. -c0d not -cd).
        This number is generated as described below.

             Bits                Function
             ------              --------
             D7-D5               Write Pulse Delay (Set to 0)
             D4-D2               RAM/ROM Configuration

                                 D4 D3 D2      $f000     $f800
                                 --------      -----     -----
                                  0  0  0        3        ROM
                                  0  0  1        1        ROM
                                  0  1  0        3         1
                                  0  1  1        1         3
                                  1  0  0        3        ROM
                                  1  0  1        2        ROM
                                  1  1  0        3         2
                                  1  1  1        2         3

             D1                   If 0 RAM is Write PROTECTED
                                  If 1 RAM is Write ENABLED

             D0                   If 0 ROM power is ON
                                  If 1 ROM power is OFF

             (Note: Make sure to power ROM off if you are converting
              a .bin file that is running on a modified Supercharger.
              This activates the modification so that games that don't
              work on unmodified Superchargers will not crash!)

        This flag overrides the control byte in the 8448 byte .bin file and
        the .bin files on the Supercharger CD.

  -d -> This flag causes detailed information about the .bin file being
        converted to be displayed.  The information includes the frequency
        of the file being created, the header tone length, the file size,
        the Start Address, the Multi-Load Byte value, The Control-byte value,
        the number of pages with data, and the number of pages that are
        "blank".  

        Information about each page of the .bin file is also displayed for
        pages that are not blank.  If the -p flag is used in conjunction
        with this flag, then all pages are displayed.

            File Page #    - The page # of the .bin file (256 bytes/page).
            Bank #         - The bank this page will be loaded into.
            Page #         - The page # of the bank this page will load into.
            page&bank byte - The value used by the Supercharger to determine
                             the bank and page number to load the current
                             page from the .bin file into.  This is
                             determined by (page * 4) + bank, where banks
                             range from 0-2 and pages range from 0-7.
            Checksum byte  - The value of the checksum for the current page.

        What follows is a sample output from Makewav while converting
        Suicid23.bin (a cut down 8448 byte version even though the original
        32k version will work too) from the Supercharger CD.

            Creating 22khz .wav file with a 1.00 second header tone
            File size = 8448           Start address is $fe00
            Multi-Load byte   = $00    Page count        = $13
            Control-byte      = $0f    Blank pages       = $05
            File page $00 - bank 00, page 00, page&bank byte 00, checksum 07
            File page $01 - bank 00, page 01, page&bank byte 04, checksum 82
            File page $02 - bank 00, page 02, page&bank byte 08, checksum 81
            File page $03 - bank 00, page 03, page&bank byte 0c, checksum 00
            File page $04 - bank 00, page 04, page&bank byte 10, checksum bb
            File page $05 - bank 00, page 05, page&bank byte 14, checksum 21
            File page $06 - bank 00, page 06, page&bank byte 18, checksum 2a
            File page $07 - bank 00, page 07, page&bank byte 1c, checksum eb
            File page $08 - bank 01, page 00, page&bank byte 01, checksum 44
            File page $09 - bank 01, page 01, page&bank byte 05, checksum d0
            File page $0a - bank 01, page 02, page&bank byte 09, checksum 65
            File page $0b - bank 01, page 03, page&bank byte 0d, checksum 8a
            File page $0c - bank 01, page 04, page&bank byte 11, checksum e6
            File page $0d - bank 01, page 05, page&bank byte 15, checksum 13
            File page $0e - bank 01, page 06, page&bank byte 19, checksum 9c
            File page $0f - bank 01, page 07, page&bank byte 1d, checksum 5e
            File page $10 - bank 02, page 00, page&bank byte 02, checksum a0
            File page $16 - bank 02, page 06, page&bank byte 1a, checksum 81
            File page $17 - bank 02, page 07, page&bank byte 1e, checksum 17

        As you can see, pages $11 - $15 are blank, so they were left out.
        This doesn't cause a problem with this game, the blank pages are just
        the area that represent the "bitmapped" area of RAM in the game.  It
        is possible that some games may not work right when a page is left
        out.  You can fix this by using the -p flag.

  -f -> This flag causes a "super-fastload" .wav file to be loaded.  This
        just means that the waveforms are shorter, and thus less reliable
        than the standard ones.  If you have problems using the faster .wav
        files, don't use this flag!

  -h -> Allows you to set the length of the header tone in seconds.  The
        default length is 1 second.  Values between 0.5 and 10 inclusive
        are valid.  This flag is useful if you are going to make a tape
        or CD track and need a little bit longer header.  This also
        affects the length of the tones between any chained loads.  A tone
        between chained loades is 1 second longer than the header tone.
        The footer tone is always 1/2 second.

  -k -> Forces Makewav to create a 44khz .wav file.  These files are bigger
        in filesize than the default 22khz .wav files but about the same
        length in time.  The 44khz .wav files are generally more reliable
        than the 22khz ones.

  -m -> The -m must be followed by a 2 digit hex number (e.g. -m0d not -md).
        This number is used to indicate a unique load for the Supercharger.
        If the code is looking for load $0d and load $0f is played into it,
        the Supercharger will return to either a black screen (if there is
        a header tone between the loads) or to the "Press Play" screen and
        wait until load $0d is played.  This overrides the multi-load byte
        in the 8448 byte .bin files and those in the .bin files on the
        Supercharger CD.

  -p -> Turns "blank page packing" OFF.  Makewav by default looks for pages
        of the .bin file in which all of the bytes are the same value.  This
        usually indicates "filler" in the .bin file and can be eliminated
        most of the time.  If a particular game does not work, and you notice
        that when using the -d flag that there are "blank" pages, try using
        the -p flag.

  -r -> Causes a raw binary image of the data to be sent to the Supercharger
        to be created instead of a .wav file.  This includes the header
        tone (a series of $55's if the raw file is viewed with a hex editor),
        the 8-byte game header, the page headers, and the footer tone.  This
        is not only usefull for me debugging makewav, but also for creating
        precalculated data for possibly a dedicated device that plays the
        tones necessary to load a game on the Supercharger.

  -s -> Forces a starting address for the code.  The address must be a
        2 byte, 4 digit hex number (e.g. -sf123 not -s123) in hi/lo format.
        This will override all start addresses, including those in the
        8448 byte .bin files and the .bin files on the Supercharger CD.

  -v -> Sets the volume or amplitude of the .wav file.  This was added
        because there was concern that some .wav players didn't like the
        .wav having the max values in the waveforms.  Valid values are 1-10
        inclusive.  The defualt volume is 10, so there should be no reason
        to ever actually use 10 :)

    The .wav files are generally fairly large, but they pack very well,
sometimes to 6k or so.  This is because of the repetition involved.  Each
"one bit" is the same as every other "one bit" and the same with the
"zero bits".

    Well, have fun, and if you make any cool games, drop me an e-mail!
(heck, even if you make a lame game I'd like to see it).  I will provide
more information about the Supercharger later, and will also let you know
where to get programming info on the 2600 too.

        Now for the boring stuff:  I hereby place this program into the
public domain.  I am not responsible for any damage this program may cause.
I am not liable for any misuse, intentional or otherwise, of this program.
There is no warranty, written or implied, on this program.  The user uses
this program at his or her own risk!

                                Take Care,

                                        Bob Colbert
                                        CEO of RetroWare
                                        rcolbert@oasis.novia.net
                                        http://www.novia.net/~rcolbert


