Ticket #8707: SoC Tools Update #3.patch

compress.c

@@ -35 +35 @@
         int nominalBitr;
         int minBitr;
         int maxBitr;
-        int quality;
+        float quality;
         bool silent;
 } oggencparams;
 
-/* FIXME: This is an evil way to pass on the params to FLAC.
- It makes it near impossible to reliably pass default params to the
- encoder.
-*/
 typedef struct {
-        char * const* argv;
-        int numArgs;
+        int compressionLevel;
+        int blocksize;
+        bool verify;
+        bool silent;
 } flaccparams;
 
 typedef struct {
-        bool isLittleEndian;
-        bool isStereo;
-        bool isUnsigned;
+        bool isLittleEndian, isStereo;
         uint8 bitsPerSample;
 } rawtype;
 
 lameparams encparms = { minBitrDef, maxBitrDef, false, algqualDef, vbrqualDef, 0 };
 oggencparams oggparms = { -1, -1, -1, oggqualDef, 0 };
-flaccparams flacparms;
-rawtype rawAudioType = { false, false, false, 8 };
+flaccparams flacparms = { flacCompressDef, flacBlocksizeDef, false, false };
+rawtype rawAudioType = { false, false, 8 };
 
 const char *tempEncoded = TEMP_MP3;
 
-void setRawAudioType(bool isLittleEndian, bool isStereo, bool isUnsigned, uint8 bitsPerSample) {
+void setRawAudioType(bool isLittleEndian, bool isStereo, uint8 bitsPerSample) {
         rawAudioType.isLittleEndian = isLittleEndian;
         rawAudioType.isStereo = isStereo;
-        rawAudioType.isUnsigned = isUnsigned;
         rawAudioType.bitsPerSample = bitsPerSample;
 }
 
@@ -105 +100 @@
 }
 
 void encodeAudio(const char *inname, bool rawInput, int rawSamplerate, const char *outname, CompressMode compmode) {
+        bool err = false;
         char fbuf[2048];
         char *tmp = fbuf;
-        int i;
-        bool err = false;
 
-        switch (compmode) {
-        case kVorbisMode:
-                tmp += sprintf(tmp, "oggenc ");
-                if (rawInput) {
-                        tmp += sprintf(tmp, "--raw ");
-                        tmp += sprintf(tmp, "--raw-chan=%d ", (rawAudioType.isStereo ? 2 : 1));
-                        tmp += sprintf(tmp, "--raw-bits=%d ", rawAudioType.bitsPerSample);
-                        tmp += sprintf(tmp, "--raw-rate=%d ", rawSamplerate);
-                        tmp += sprintf(tmp, "--raw-endianness=%d ", (rawAudioType.isLittleEndian ? 0 : 1));
-                }
-
-                if (oggparms.nominalBitr != -1)
-                        tmp += sprintf(tmp, "--bitrate=%d ", oggparms.nominalBitr);
-                if (oggparms.minBitr != -1)
-                        tmp += sprintf(tmp, "--min-bitrate=%d ", oggparms.minBitr);
-                if (oggparms.maxBitr != -1)
-                        tmp += sprintf(tmp, "--max-bitrate=%d ", oggparms.maxBitr);
-                if (oggparms.silent)
-                        tmp += sprintf(tmp, "--quiet ");
-                tmp += sprintf(tmp, "--quality=%d ", oggparms.quality);
-                tmp += sprintf(tmp, "--output=\"%s\" ", outname);
-                tmp += sprintf(tmp, "\"%s\" ", inname);
-                err = system(fbuf) != 0;
-                break;
-
-        case kMP3Mode:
+        if (compmode == kMP3Mode) {
                 tmp += sprintf(tmp, "lame -t ");
                 if (rawInput) {
                         tmp += sprintf(tmp, "-r ");
                         tmp += sprintf(tmp, "--bitwidth %d ", rawAudioType.bitsPerSample);
-                        if (rawAudioType.isLittleEndian)
+
+                        if (rawAudioType.isLittleEndian) {
                                 tmp += sprintf(tmp, "-x ");
+                        }
+                        
                         tmp += sprintf(tmp, (rawAudioType.isStereo ? "-m j " : "-m m "));
                         tmp += sprintf(tmp, "-s %d ", rawSamplerate);
                 }
 
-                if (encparms.abr)
+                if (encparms.abr) {
                         tmp += sprintf(tmp, "--abr %d ", encparms.minBitr);
-                else
+                } else {
                         tmp += sprintf(tmp, "--vbr-new -b %d ", encparms.minBitr);
+                }
 
                 /* Explicitly specify a target sample rate, to work around a bug (?)
-                 * in newer lame versions (>= 3.95) which causes it to malfunction
-                 * for odd sample rates when in VBR mode. See also bug #934026.
-                 * We essentially duplicate the old behaviour of lame (found in e.g.
-                 * version 3.93.1): we round the input sample rate up to the next
-                 * higher valid MP3 sample rate, with a margin of 3%.
-                 */
-                if (rawSamplerate != -1)
+                * in newer lame versions (>= 3.95) which causes it to malfunction
+                * for odd sample rates when in VBR mode. See also bug #934026.
+                * We essentially duplicate the old behaviour of lame (found in e.g.
+                * version 3.93.1): we round the input sample rate up to the next
+                * higher valid MP3 sample rate, with a margin of 3%.
+                */
+                if (rawSamplerate != -1) {
                         tmp += sprintf(tmp, "--resample %d ", map2MP3Frequency(97 * rawSamplerate / 100));
+                }
 
-                if (encparms.silent)
+                if (encparms.silent) {
                         tmp += sprintf(tmp, " --silent ");
+                }
+
                 tmp += sprintf(tmp, "-q %d ", encparms.algqual);
                 tmp += sprintf(tmp, "-V %d ", encparms.vbrqual);
                 tmp += sprintf(tmp, "-B %d ", encparms.maxBitr);
                 tmp += sprintf(tmp, "\"%s\" \"%s\" ", inname, outname);
+
                 err = system(fbuf) != 0;
-                break;
 
-        case kFlacMode:
-                /* --lax is needed to allow 11kHz, we dont need place for meta-tags, and no seektable */
-                /* -f is reqired to force override of unremoved temp file. See bug #1294648 */
-                tmp += sprintf(tmp, "flac --best -b 1152 -f --lax --no-padding --no-seektable --no-ogg ");
+                if (err) {
+                        printf("Got error from encoder. (check your parameters)\n");
+                        printf("Encoder Commandline: %s\n", fbuf );
+                        exit(-1);
+                } else {
+                        return;
+                }
+        }
 
+#ifdef DISABLE_OGG
+                if (compmode == kVorbisMode) {
+                        tmp += sprintf(tmp, "oggenc ");
+                        if (rawInput) {
+                                tmp += sprintf(tmp, "--raw ");
+                                tmp += sprintf(tmp, "--raw-chan=%d ", (rawAudioType.isStereo ? 2 : 1));
+                                tmp += sprintf(tmp, "--raw-bits=%d ", rawAudioType.bitsPerSample);
+                                tmp += sprintf(tmp, "--raw-rate=%d ", rawSamplerate);
+                                tmp += sprintf(tmp, "--raw-endianness=%d ", (rawAudioType.isLittleEndian ? 0 : 1));
+                        }
+                        
+                        if (oggparms.nominalBitr != -1) {
+                                tmp += sprintf(tmp, "--bitrate=%d ", oggparms.nominalBitr);
+                        } else {
+                                tmp += sprintf(tmp, "--quality=%d ", oggparms.quality);
+                        }
+
+                        if (oggparms.minBitr != -1) {
+                                tmp += sprintf(tmp, "--min-bitrate=%d ", oggparms.minBitr);
+                        }
+                        
+                        if (oggparms.maxBitr != -1) {
+                                tmp += sprintf(tmp, "--max-bitrate=%d ", oggparms.maxBitr);
+                        }
+                
+                        if (oggparms.silent) {
+                                tmp += sprintf(tmp, "--quiet ");
+                        }
+
+                        tmp += sprintf(tmp, "--output=\"%s\" ", outname);
+                        tmp += sprintf(tmp, "\"%s\" ", inname);
+
+                        err = system(fbuf) != 0;
+                        
+                        if (err) {
+                                printf("Got error from encoder. (check your parameters)\n");
+                                printf("Encoder Commandline: %s\n", fbuf );
+                                exit(-1);
+                        } else {
+                                return;
+                        }
+                }
+#endif
+
+#ifdef DISABLE_FLAC
+                if (compmode == kFlacMode) {
+                        /* --lax is needed to allow 11kHz, we dont need place for meta-tags, and no seektable */
+                        /* -f is reqired to force override of unremoved temp file. See bug #1294648 */
+                        tmp += sprintf(tmp, "flac -f --lax --no-padding --no-seektable --no-ogg ");
+
+                        if (rawInput) {
+                                tmp += sprintf(tmp, "--force-raw-format ");
+                                tmp += sprintf(tmp, "--sign=%s ", ((rawAudioType.bitsPerSample == 8) ? "unsigned" : "signed"));
+                                tmp += sprintf(tmp, "--channels=%d ", (rawAudioType.isStereo ? 2 : 1));
+                                tmp += sprintf(tmp, "--bps=%d ", rawAudioType.bitsPerSample);
+                                tmp += sprintf(tmp, "--sample-rate=%d ", rawSamplerate);
+                                tmp += sprintf(tmp, "--endian=%s ", (rawAudioType.isLittleEndian ? "little" : "big"));
+                        }
+
+                        if (flacparms.silent) {
+                                tmp += sprintf(tmp, "--silent ");
+                        }
+
+                        if (flacparms.verify) {
+                                tmp += sprintf(tmp, "--verify ");
+                        }
+
+                        tmp += sprintf(tmp, "--compression-level-%d ", flacparms.compressionLevel);
+                        tmp += sprintf(tmp, "-b %d ", flacparms.blocksize);
+                        tmp += sprintf(tmp, "-o \"%s\" ", outname);
+                        tmp += sprintf(tmp, "\"%s\" ", inname);
+
+                        err = system(fbuf) != 0;
+                        
+                        if (err) {
+                                printf("Got error from encoder. (check your parameters)\n");
+                                printf("Encoder Commandline: %s\n", fbuf );
+                                exit(-1);
+                        } else {
+                                return;
+                        }
+                }
+#endif
                 if (rawInput) {
-                        tmp += sprintf(tmp, "--force-raw-format ");
-                        tmp += sprintf(tmp, "--sign=%s ", (rawAudioType.isUnsigned ? "unsigned" : "signed"));
-                        tmp += sprintf(tmp, "--channels=%d ", (rawAudioType.isStereo ? 2 : 1));
-                        tmp += sprintf(tmp, "--bps=%d ", rawAudioType.bitsPerSample);
-                        tmp += sprintf(tmp, "--sample-rate=%d ", rawSamplerate);
-                        tmp += sprintf(tmp, "--endian=%s ", (rawAudioType.isLittleEndian ? "little" : "big"));
+                        FILE *inputRaw;
+                        long length;
+                        char *rawData;
+
+                        inputRaw = fopen(inname, "rb");
+                        length = fileSize(inputRaw);
+                        rawData = (char *)malloc(length);
+                        fread(rawData, 1, length, inputRaw);
+
+                        printf(" - length = %d\n", length);
+                        printf(" - channels = %d\n", (rawAudioType.isStereo ? 2 : 1));
+                        printf(" - sample rate = %d\n", rawSamplerate);
+                        printf(" - compression = %dbits\n", rawAudioType.bitsPerSample);
+
+                        encodeRaw(rawData, length, rawSamplerate, outname, compmode);
+
+                        fclose(inputRaw);
+                        free(rawData);
+                } else {
+                        FILE *inputWav;
+                        int fmtHeaderSize, length, numChannels, sampleRate, bitsPerSample;
+                        char *wavData;
+
+                        inputWav = fopen(inname, "rb");
+
+                        /* Standard PCM fmt header is 16 bits, but at least Simon 1 and 2 use 18 bits */
+                        fseek(inputWav, 16, SEEK_SET);
+                        fmtHeaderSize = readUint32LE(inputWav);
+
+                        fseek(inputWav, 22, SEEK_SET);
+                        numChannels = readUint16LE(inputWav);
+                        sampleRate = readUint32LE(inputWav);
+
+                        fseek(inputWav, 34, SEEK_SET);
+                        bitsPerSample = readUint16LE(inputWav);
+
+                        /* The size of the raw audio is after the RIFF chunk (12 bytes), fmt chunk (8 + fmtHeaderSize bytes), and data chunk id (4 bytes) */
+                        fseek(inputWav, 24 + fmtHeaderSize, SEEK_SET);
+                        length = readUint32LE(inputWav);
+
+                        wavData = (char *)malloc(length);
+                        fread(wavData, 1, length, inputWav);
+
+                        printf(" - length = %d\n", length);
+                        printf(" - channels = %d\n", numChannels);
+                        printf(" - sample rate = %d\n", sampleRate);
+                        printf(" - compression = %dbits\n", bitsPerSample);
+
+                        setRawAudioType(true, numChannels == 2, bitsPerSample);
+                        encodeRaw(wavData, length, sampleRate, outname, compmode);
+
+                        fclose(inputWav);
+                        free (wavData);
                 }
+}
 
-                for (i = 0; i < flacparms.numArgs; i++) {
-                        /* Append optional encoder arguments */
-                        tmp += sprintf(tmp, "%s ", flacparms.argv[i]);
+void encodeRaw(char *rawData, int length, int samplerate, const char *outname, CompressMode compmode) {
+#ifndef DISABLE_OGG
+        if (compmode == kVorbisMode) {
+                FILE *outputOgg;
+                char outputString[256] = "";
+                int numChannels = (rawAudioType.isStereo ? 2 : 1);
+                int totalSamples = length / ((rawAudioType.bitsPerSample / 8) * numChannels);
+                int samplesLeft = totalSamples;
+                int eos = 0;
+                int totalBytes = 0;
+
+                vorbis_info vi;
+                vorbis_comment vc;
+                vorbis_dsp_state vd;
+                vorbis_block vb;
+
+                ogg_stream_state os;
+                ogg_page og;
+                ogg_packet op;
+
+                ogg_packet header;
+                ogg_packet header_comm;
+                ogg_packet header_code;
+
+                outputOgg = fopen(outname,"wb");
+
+                vorbis_info_init(&vi);
+
+                if (oggparms.nominalBitr > 0) {
+                        int result = 0;
+
+                        /* Input is in kbps, function takes bps */
+                        result = vorbis_encode_setup_managed(&vi, numChannels, samplerate, (oggparms.maxBitr > 0 ? 1000 * oggparms.maxBitr : -1), (1000 * oggparms.nominalBitr), (oggparms.minBitr > 0 ? 1000 * oggparms.minBitr : -1));
+
+                        if (result == OV_EFAULT) {
+                                printf("Error: Internal Logic Fault.\n\n");
+                                vorbis_info_clear(&vi);
+                                exit(-1);
+                        } else if ((result == OV_EINVAL) || (result == OV_EIMPL)) {
+                                printf("Error: Invalid bitrate parameters.\n\n");
+                                vorbis_info_clear(&vi);
+                                exit(-1);
+                        }
+
+                        if (!oggparms.silent) {
+                                sprintf(outputString, "Encoding to\n         \"%s\"\nat average bitrate %i kbps (", outname, oggparms.nominalBitr);
+
+                                if (oggparms.minBitr > 0) {
+                                        sprintf(outputString + strlen(outputString), "min %i kbps, ", oggparms.minBitr);
+                                } else {
+                                        sprintf(outputString + strlen(outputString), "no min, ");
+                                }
+
+                                if (oggparms.maxBitr > 0) {
+                                        sprintf(outputString + strlen(outputString), "max %i kbps),\nusing full bitrate management engine\nSet optional hard quality restrictions\n", oggparms.maxBitr);
+                                } else {
+                                        sprintf(outputString + strlen(outputString), "no max),\nusing full bitrate management engine\nSet optional hard quality restrictions\n");
+                                }
+                        }
+                } else {
+                        int result = 0;
+
+                        /* Quality input is 1 - 10, function takes -0.1 through 1.0 */
+                        result = vorbis_encode_setup_vbr(&vi, numChannels, samplerate, oggparms.quality * 0.1);
+
+                        if (result == OV_EFAULT) {
+                                printf("Error: Internal Logic Fault.\n\n");
+                                vorbis_info_clear(&vi);
+                                exit(-1);
+                        } else if ((result == OV_EINVAL) || (result == OV_EIMPL)) {
+                                printf("Error: Invalid bitrate parameters.\n\n");
+                                vorbis_info_clear(&vi);
+                                exit(-1);
+                        }
+
+                        if (!oggparms.silent) {
+                                sprintf(outputString, "Encoding to\n         \"%s\"\nat quality %2.2f", outname, oggparms.quality);
+                        }
+
+                        if ((oggparms.minBitr > 0) || (oggparms.maxBitr > 0)) {
+                                struct ovectl_ratemanage_arg extraParam;
+                                vorbis_encode_ctl(&vi, OV_ECTL_RATEMANAGE_GET, &extraParam);
+
+                                extraParam.bitrate_hard_min = (oggparms.minBitr > 0 ? (1000 * oggparms.minBitr) : -1);
+                                extraParam.bitrate_hard_max = (oggparms.maxBitr > 0 ? (1000 * oggparms.maxBitr) : -1);
+                                extraParam.management_active = 1;
+
+                                vorbis_encode_ctl(&vi, OV_ECTL_RATEMANAGE_SET, &extraParam);
+
+                                if (!oggparms.silent) {
+                                        sprintf(outputString + strlen(outputString), " using constrained VBR (");
+
+                                        if (oggparms.minBitr != -1) {
+                                                sprintf(outputString + strlen(outputString), "min %i kbps, ", oggparms.minBitr);
+                                        } else {
+                                                sprintf(outputString + strlen(outputString), "no min, ");
+                                        }
+
+                                        if (oggparms.maxBitr != -1) {
+                                                sprintf(outputString + strlen(outputString), "max %i kbps)\nSet optional hard quality restrictions\n", oggparms.maxBitr);
+                                        } else {
+                                                sprintf(outputString + strlen(outputString), "no max)\nSet optional hard quality restrictions\n");
+                                        }
+                                }
+                        } else {
+                                sprintf(outputString + strlen(outputString), "\n");
+                        }
                 }
 
-                tmp += sprintf(tmp, "-o \"%s\" ", outname);
-                tmp += sprintf(tmp, "\"%s\" ", inname);
+                printf(outputString);
 
-                err = system(fbuf) != 0;
-                break;
-        }
+                vorbis_encode_setup_init(&vi);
+                vorbis_comment_init(&vc);
+                vorbis_analysis_init(&vd, &vi);
+                vorbis_block_init(&vd, &vb);
+                ogg_stream_init(&os, 0);
+                vorbis_analysis_headerout(&vd, &vc, &header, &header_comm, &header_code);
 
-        if (err) {
-                printf("Got error from encoder. (check your parameters)\n");
-                printf("Encoder Commandline: %s\n", fbuf );
-                exit(-1);
+                ogg_stream_packetin(&os, &header);
+                ogg_stream_packetin(&os, &header_comm);
+                ogg_stream_packetin(&os, &header_code);
+
+                while (!eos) {
+                        int result = ogg_stream_flush(&os,&og);
+
+                        if (result == 0) {
+                                break;
+                        }
+
+                        fwrite(og.header, 1, og.header_len, outputOgg);
+                        fwrite(og.body, 1, og.body_len, outputOgg);
+                }
+
+                while (!eos) {
+                        int i, j;
+                        int numSamples = ((samplesLeft < 2048) ? samplesLeft : 2048);
+                        float **buffer = vorbis_analysis_buffer(&vd, numSamples);
+
+                        /* We must tell the encoder that we have reached the end of the stream */
+                        if (numSamples == 0) {
+                                vorbis_analysis_wrote(&vd, 0);
+                        } else {
+                                /* Adapted from oggenc 1.1.1 */
+                                if (rawAudioType.bitsPerSample == 8) {
+                                        unsigned char *rawDataUnsigned = (unsigned char *)rawData;
+                                        for (i = 0; i < numSamples; i++) {
+                                                for (j = 0; j < numChannels; j++) {
+                                                        buffer[j][i] = ((int)(rawDataUnsigned[i * numChannels + j]) - 128) / 128.0f;
+                                                }
+                                        }
+                                } else if(rawAudioType.bitsPerSample == 16) {
+                                        if(rawAudioType.isLittleEndian) {
+                                                for(i = 0; i < numSamples; i++) {
+                                                        for(j = 0; j < numChannels; j++) {
+                                                                buffer[j][i] = ((rawData[(i * 2 * numChannels) + (2 * j) + 1] << 8) | (rawData[(i * 2 * numChannels) + (2 * j)] & 0xff)) / 32768.0f;
+                                                        }
+                                                }
+                                        }
+                                        else {
+                                                for(i = 0; i < numSamples; i++) {
+                                                        for(j = 0; j < numChannels; j++) {
+                                                                buffer[j][i] = ((rawData[(i * 2 * numChannels) + (2 * j)] << 8) | (rawData[(i * 2 * numChannels) + (2 * j) + 1] & 0xff)) / 32768.0f;
+                                                        }
+                                                }
+                                        }
+                                }
+
+                                vorbis_analysis_wrote(&vd, numSamples);
+                        }
+
+                        while (vorbis_analysis_blockout(&vd, &vb) == 1) {
+                                vorbis_analysis(&vb, NULL);
+                                vorbis_bitrate_addblock(&vb);
+
+                                while (vorbis_bitrate_flushpacket(&vd, &op)) {
+                                        ogg_stream_packetin(&os, &op);
+
+                                        while (!eos) {
+                                                int result = ogg_stream_pageout(&os, &og);
+
+                                                if(result == 0) {
+                                                        break;
+                                                }
+
+                                                totalBytes += fwrite(og.header, 1, og.header_len, outputOgg);
+                                                totalBytes += fwrite(og.body, 1, og.body_len, outputOgg);
+
+                                                if(ogg_page_eos(&og)) {
+                                                        eos = 1;
+                                                }
+                                        }
+                                }
+                        }
+
+                        rawData += 2048 * (rawAudioType.bitsPerSample / 8) * numChannels;
+                        samplesLeft -= 2048;
+                }
+
+                ogg_stream_clear(&os);
+                vorbis_block_clear(&vb);
+                vorbis_dsp_clear(&vd);
+                vorbis_info_clear(&vi);
+
+                fclose(outputOgg);
+
+                if (!oggparms.silent) {
+                        printf("\nDone encoding file \"%s\"\n", outname);
+                        printf("\n\tFile length:  %dm %ds\n", (int)(totalSamples / samplerate / 60), (totalSamples / samplerate % 60));
+                        printf("\tAverage bitrate: %.1f kb/s\n\n", (8.0 * (double)totalBytes / 1000.0) / ((double)totalSamples / (double)samplerate));
+                }
+        } 
+#endif
+
+#ifndef DISABLE_FLAC
+        if (compmode == kFlacMode) {
+                int i;
+                int numChannels = (rawAudioType.isStereo ? 2 : 1);
+                int samplesPerChannel = length / ((rawAudioType.bitsPerSample / 8) * numChannels);
+                FLAC__StreamEncoder *encoder;
+                FLAC__StreamEncoderInitStatus initStatus;
+                FLAC__int32 *flacData;
+
+                flacData = (FLAC__int32 *)malloc(samplesPerChannel * numChannels * sizeof(FLAC__int32));
+
+                if (rawAudioType.bitsPerSample == 8) {
+                        for (i = 0; i < samplesPerChannel * numChannels; i++) {
+                                FLAC__uint8 *rawDataUnsigned;
+                                rawDataUnsigned = (FLAC__uint8 *)rawData;
+                                flacData[i] = (FLAC__int32)rawDataUnsigned[i] - 0x80;
+                        }
+                } else if (rawAudioType.bitsPerSample == 16) {
+                        /* The rawData pointer is an 8-bit char so we must create a new pointer to access 16-bit samples */
+                        FLAC__int16 *rawData16;
+                        rawData16 = (FLAC__int16 *)rawData;
+                        for (i = 0; i < samplesPerChannel * numChannels; i++) {
+                                flacData[i] = (FLAC__int32)rawData16[i];
+                        }
+                }
+
+                if (!flacparms.silent) {
+                        printf("Encoding to\n         \"%s\"\nat compression level %d using blocksize %d\n\n", outname, flacparms.compressionLevel, flacparms.blocksize);
+                }
+
+                encoder = FLAC__stream_encoder_new();
+
+                FLAC__stream_encoder_set_bits_per_sample(encoder, rawAudioType.bitsPerSample);
+                FLAC__stream_encoder_set_blocksize(encoder, flacparms.blocksize);
+                FLAC__stream_encoder_set_channels(encoder, numChannels);
+                FLAC__stream_encoder_set_compression_level(encoder, flacparms.compressionLevel);
+                FLAC__stream_encoder_set_sample_rate(encoder, samplerate);
+                FLAC__stream_encoder_set_streamable_subset(encoder, false);
+                FLAC__stream_encoder_set_total_samples_estimate(encoder, samplesPerChannel);
+                FLAC__stream_encoder_set_verify(encoder, flacparms.verify);
+
+                initStatus = FLAC__stream_encoder_init_file(encoder, outname, NULL, NULL);
+
+                if (initStatus != FLAC__STREAM_ENCODER_INIT_STATUS_OK) {
+                        printf("Got error from encoder. (check your paramters)\n");
+                        printf("FLAC error: %s\n\n", FLAC__StreamEncoderInitStatusString[initStatus]);
+                        exit(-1);
+                } else {
+                        FLAC__stream_encoder_process_interleaved(encoder, flacData, samplesPerChannel);
+                }
+
+                FLAC__stream_encoder_finish(encoder);
+                FLAC__stream_encoder_delete(encoder);
+
+                free(flacData);
+
+                if (!flacparms.silent) {
+                        printf("\nDone encoding file \"%s\"\n", outname);
+                        printf("\n\tFile length:  %dm %ds\n\n", (int)(samplesPerChannel / samplerate / 60), (samplesPerChannel / samplerate % 60));
+                }
         }
+#endif
 }
 
 void extractAndEncodeWAV(const char *outName, FILE *input, CompressMode compMode) {
@@ -261 +630 @@
                 length = fgetc(input);
                 length |= fgetc(input) << 8;
                 length |= fgetc(input) << 16;
+
                 if (blocktype == 1) {
                         length -= 2;
                         sample_rate = fgetc(input);
@@ -287 +657 @@
                                   (comp == 3 ? "2bits"   :
                                                                 "Multi")))), comp);
 
-                if (comp != 0)
+                if (comp != 0) {
                         error("Cannot handle compressed VOC data");
+                }
 
                 /* Copy the raw data to a temporary file */
                 while (length > 0) {
                         size = fread(fbuf, 1, length > sizeof(fbuf) ? sizeof(fbuf) : (uint32)length, input);
-                        if (size <= 0)
+
+                        if (size <= 0) {
                                 break;
+                        }
+
                         length -= (int)size;
                         fwrite(fbuf, 1, size, f);
                 }
@@ -304 +678 @@
 
         assert(real_samplerate != -1);
 
-        setRawAudioType(false, false, true, 8);
+        setRawAudioType(false, false, 8);
 
         /* Convert the raw temp file to OGG/MP3 */
         encodeAudio(outName, true, real_samplerate, tempEncoded, compMode);
@@ -318 +692 @@
                         encparms.abr=1;
                 } else if (strcmp(argv[i], "-b") == 0) {
                         encparms.minBitr = atoi(argv[i + 1]);
-                        if ((encparms.minBitr % 8) != 0)
+
+                        if ((encparms.minBitr % 8) != 0) {
                                 encparms.minBitr -= encparms.minBitr % 8;
-                        if (encparms.minBitr >160)
+                        }
+
+                        if (encparms.minBitr >160) {
                                 encparms.minBitr = 160;
-                        if (encparms.minBitr < 8)
-                                encparms.minBitr=8;
+                        }
+
+                        if (encparms.minBitr < 8) {
+                                encparms.minBitr = 8;
+                        }
+
                         i++;
                 } else if (strcmp(argv[i], "-B") == 0) {
                         encparms.maxBitr = atoi(argv[i + 1]);
-                        if ((encparms.maxBitr % 8) != 0)
+
+                        if ((encparms.maxBitr % 8) != 0) {
                                 encparms.maxBitr -= encparms.maxBitr % 8;
-                        if (encparms.maxBitr > 160)
+                        }
+
+                        if (encparms.maxBitr > 160) {
                                 encparms.maxBitr = 160;
-                        if (encparms.maxBitr < 8)
+                        }
+
+                        if (encparms.maxBitr < 8) {
                                 encparms.maxBitr = 8;
+                        }
+
                         i++;
                 } else if (strcmp(argv[i], "-V") == 0) {
                         encparms.vbrqual = atoi(argv[i + 1]);
-                        if(encparms.vbrqual < 0)
+
+                        if(encparms.vbrqual < 0) {
                                 encparms.vbrqual = 0;
-                        if(encparms.vbrqual > 9)
+                        }
+
+                        if(encparms.vbrqual > 9) {
                                 encparms.vbrqual = 9;
+                        }
+
                         i++;
                 } else if (strcmp(argv[i], "-q") == 0) {
                         encparms.algqual = atoi(argv[i + 1]);
-                        if (encparms.algqual < 0)
+
+                        if (encparms.algqual < 0) {
                                 encparms.algqual = 0;
-                        if (encparms.algqual > 9)
+                        }
+
+                        if (encparms.algqual > 9) {
                                 encparms.algqual = 9;
+                        }
+
                         i++;
                 } else if (strcmp(argv[i], "--silent") == 0) {
                         encparms.silent = 1;
@@ -358 +756 @@
                         break;
                 }
         }
+
         if (i != (argc - 1)) {
                 return 0;
         }
+
         return 1;
 }
 
@@ -368 +768 @@
         for (; i < argc; i++) {
                 if (strcmp(argv[i], "-b") == 0) {
                         oggparms.nominalBitr = atoi(argv[i + 1]);
+
+                        if ((oggparms.nominalBitr % 8) != 0) {
+                                oggparms.nominalBitr -= oggparms.nominalBitr % 8;
+                        }
+
+                        if (oggparms.nominalBitr >160) {
+                                oggparms.nominalBitr = 160;
+                        }
+
+                        if (oggparms.nominalBitr < 8) {
+                                oggparms.nominalBitr = 8;
+                        }
+
                         i++;
-                }
-                else if (strcmp(argv[i], "-m") == 0) {
+                } else if (strcmp(argv[i], "-m") == 0) {
                         oggparms.minBitr = atoi(argv[i + 1]);
+
+                        if ((oggparms.minBitr % 8) != 0) {
+                                oggparms.minBitr -= oggparms.minBitr % 8;
+                        }
+
+                        if (oggparms.minBitr >160) {
+                                oggparms.minBitr = 160;
+                        }
+
+                        if (oggparms.minBitr < 8) {
+                                oggparms.minBitr = 8;
+                        }
+
                         i++;
                 }
                 else if (strcmp(argv[i], "-M") == 0) {
                         oggparms.maxBitr = atoi(argv[i + 1]);
+
+                        if ((oggparms.maxBitr % 8) != 0) {
+                                oggparms.maxBitr -= encparms.minBitr % 8;
+                        }
+
+                        if (oggparms.maxBitr >160) {
+                                oggparms.maxBitr = 160;
+                        }
+
+                        if (oggparms.maxBitr < 8) {
+                                oggparms.maxBitr = 8;
+                        }
+
                         i++;
                 }
                 else if (strcmp(argv[i], "-q") == 0) {
@@ -391 +829 @@
                 else if (argv[i][0] == '-') {
                         return 0;
                 }
-                else
+                else {
                         break;
+                }
         }
-        if (i != argc - 1)
+
+        if (i != argc - 1) {
                 return 0;
+        }
+
         return 1;
 }
 
 int process_flac_parms(int argc, char *argv[], int i){
-        flacparms.argv = &argv[i];
-        flacparms.numArgs = argc - 1 - i;
+        for (; i < argc; i++) {
+                if (strcmp(argv[i], "-b") == 0) {
+                        flacparms.blocksize = atoi(argv[i + 1]);
+                        i++;
+                }
+                else if (strcmp(argv[i], "--fast") == 0) {
+                        flacparms.compressionLevel = 0;
+                }
+                else if (strcmp(argv[i], "--best") == 0) {
+                        flacparms.compressionLevel = 8;
+                }
+                else if (strcmp(argv[i], "-0") == 0) {
+                        flacparms.compressionLevel = 0;
+                }
+                else if (strcmp(argv[i], "-1") == 0) {
+                        flacparms.compressionLevel = 1;
+                }
+                else if (strcmp(argv[i], "-2") == 0) {
+                        flacparms.compressionLevel = 2;
+                }
+                else if (strcmp(argv[i], "-3") == 0) {
+                        flacparms.compressionLevel = 3;
+                }
+                else if (strcmp(argv[i], "-4") == 0) {
+                        flacparms.compressionLevel = 4;
+                }
+                else if (strcmp(argv[i], "-5") == 0) {
+                        flacparms.compressionLevel = 5;
+                }
+                else if (strcmp(argv[i], "-6") == 0) {
+                        flacparms.compressionLevel = 6;
+                }
+                else if (strcmp(argv[i], "-7") == 0) {
+                        flacparms.compressionLevel = 7;
+                }
+                else if (strcmp(argv[i], "-8") == 0) {
+                        flacparms.compressionLevel = 8;
+                }
+                else if (strcmp(argv[i], "--verify") == 0) {
+                        flacparms.verify = true;
+                }
+                else if (strcmp(argv[i], "--silent") == 0) {
+                        flacparms.silent = true;
+                }
+                else if (strcmp(argv[i], "--help") == 0) {
+                        return 0;
+                }
+                else if (argv[i][0] == '-') {
+                        return 0;
+                }
+                else {
+                        break;
+                }
+        }
 
-        if (i >= argc)
+        if (i != argc - 1) {
                 return 0;
+        }
+
         return 1;
 }

compress.h

@@ -24 +24 @@
 #define EXTRACT_H
 
 #include "util.h"
+#include <vorbis/vorbisenc.h>
+#include <FLAC/stream_encoder.h>
 
 #if defined(__cplusplus)
 extern "C" {
@@ -38 +40 @@
 /* The default for oggenc invocation is to use the --quality option only */
 #define oggqualDef 3
 
+/* These are the default parameters for the FLAC invocation */
+#define flacCompressDef 8
+#define flacBlocksizeDef 1152
+
 #define TEMP_WAV        "tempfile.wav"
 #define TEMP_RAW        "tempfile.raw"
 #define TEMP_MP3        "tempfile.mp3"
@@ -60 +66 @@
 extern void extractAndEncodeWAV(const char *outName, FILE *input, CompressMode compMode);
 
 extern void encodeAudio(const char *inname, bool rawInput, int rawSamplerate, const char *outname, CompressMode compmode);
-extern void setRawAudioType(bool isLittleEndian, bool isStereo, bool isUnSigned, uint8 bitsPerSample);
+extern void encodeRaw(char *rawData, int length, int samplerate, const char *outname, CompressMode compmode);
+extern void setRawAudioType(bool isLittleEndian, bool isStereo, uint8 bitsPerSample);
 
 #if defined(__cplusplus)
 }

compress_agos.c

@@ -74 +74 @@
         unlink(TEMP_RAW);
         unlink(tempEncoded);
         unlink(TEMP_WAV);
-        
+
         exit(0);
 }
 
-        
+
 static int get_offsets(uint32 filenums[], uint32 offsets[])
 {
         int i;
@@ -173 +173 @@
         printf(" --silent     the output of oggenc is hidden (default:disabled)\n");
 
         printf("\nFlac mode params:\n");
-        printf(" [params]     optional arguments passed directly to the encoder\n");
-        printf("              recommended is: --best -b 1152\n");
+        printf(" --fast       FLAC uses compresion level 0\n");
+        printf(" --best       FLAC uses compresion level 8\n");
+        printf(" -<value>     specifies the value (0 - 8) of compresion (8=best)(default:%d)\n", flacCompressDef);
+        printf(" -b <value>   specifies a blocksize of <value> samples (default:%d)\n", flacBlocksizeDef);
+        printf(" --verify     files are encoded and then decoded to check accuracy\n");
+        printf(" --silent     the output of FLAC is hidden (default:disabled)\n");
 
         printf("\n --help     this help message\n");
 
@@ -253 +257 @@
         char tmp[256];
         uint32 filenums[32768];
         uint32 offsets[32768];
-        
+
         sprintf(infile_base, "simon2");
 
         input = fopen("voices.idx", "rb");
@@ -295 +299 @@
                         sprintf(tmp, "voices%d.dat", filenums[i]);
                         if (input)
                                 fclose(input);
-                        input = fopen(tmp, "rb"); 
+                        input = fopen(tmp, "rb");
                         if (!input) {
                                 printf("Cannot open file: %s\n", tmp);
                                 exit(-1);
@@ -311 +315 @@
 int main(int argc, char *argv[])
 {
         int i;
-        
+
         if (argc < 2)
                 showhelp(argv[0]);
 

compress_kyra.cpp

@@ -39 +39 @@
         if (argc < 3)
                 showhelp(argv[0]);
 
+        char inputFile[256];
+        char outputFile[256];
         int i = 0;
+
         /* Compression mode */
         gCompMode = kMP3Mode;
         i = 1;
+
         if (strcmp(argv[1], "--mp3") == 0) {
                 gCompMode = kMP3Mode;
                 i++;
@@ -60 +64 @@
         case kMP3Mode:
                 outputExt = OUTPUT_MP3;
                 tempEncoded = TEMP_MP3;
-                if (!process_mp3_parms(argc - 1, argv, i))
+                if (!process_mp3_parms(argc - 2, argv, i))
                         showhelp(argv[0]);
                 break;
         case kVorbisMode:
                 outputExt = OUTPUT_OGG;
                 tempEncoded = TEMP_OGG;
-                if (!process_ogg_parms(argc - 1, argv, i))
+                if (!process_ogg_parms(argc - 2, argv, i))
                         showhelp(argv[0]);
                 break;
         case kFlacMode:
                 outputExt = OUTPUT_FLAC;
                 tempEncoded = TEMP_FLAC;
-                if (!process_flac_parms(argc - 1, argv, i))
+                if (!process_flac_parms(argc - 2, argv, i))
                         showhelp(argv[0]);
                 break;
         }
-        
-        if (scumm_stricmp(argv[argc - 2], argv[argc - 1]) == 0)
+
+        sprintf(inputFile, "%s/%s", argv[argc - 2], argv[argc - 3]);
+        sprintf(outputFile, "%s/%s", argv[argc - 1], argv[argc - 3]);
+
+        if (scumm_stricmp(inputFile, outputFile) == 0)
                 error("infile and outfile are the same file");
-        process(argv[argc - 2], argv[argc - 1]);
+        process(inputFile, outputFile);
         return 0;
 }
 
 static void showhelp(const char *exename) {
-        printf("\nUsage: %s <params> infile outfile\n", exename);
+        printf("\nUsage: %s [params] <inputfile> <inputdir> <outputdir>\n", exename);
 
         printf("\nParams:\n");
         printf(" --mp3        encode to MP3 format (default)\n");
@@ -109 +116 @@
         printf(" --silent     the output of oggenc is hidden (default:disabled)\n");
 
         printf("\nFlac mode params:\n");
-        printf(" [params]     optional arguments passed directly to the encoder\n");
-        printf("              recommended is: --best -b 1152\n");
+        printf(" --fast       FLAC uses compresion level 0\n");
+        printf(" --best       FLAC uses compresion level 8\n");
+        printf(" -<value>     specifies the value (0 - 8) of compresion (8=best)(default:%d)\n", flacCompressDef);
+        printf(" -b <value>   specifies a blocksize of <value> samples (default:%d)\n", flacBlocksizeDef);
+        printf(" --verify     files are encoded and then decoded to check accuracy\n");
+        printf(" --silent     the output of FLAC is hidden (default:disabled)\n");
 
         printf("\n --help     this help message\n");
 
@@ -136 +147 @@
                 return;
         if (!output.loadFile(0, false))
                 return;
-                
+
         PAKFile::cFileList *list = input.getFileList();
         char outputName[32];
         for (; list; list = list->next) {
@@ -150 +161 @@
 
                 input.outputFileAs(list->filename, TEMPFILE);
                 strncpy(outputName, list->filename, 32);
-                
+
                 FILE *tempFile = fopen(TEMPFILE, "rb");
                 fseek(tempFile, 26, SEEK_CUR);
                 extractAndEncodeVOC(TEMP_RAW, tempFile, gCompMode);
                 fclose(tempFile);
-                
+
                 char *vocStart = strstr(outputName, ".VOC");
                 for (unsigned int i = 0; i < strlen(outputExt); ++i)
                         vocStart[i] = outputExt[i];
                 output.addFile(outputName, tempEncoded);
-                
+
                 unlink(TEMPFILE);
                 unlink(TEMP_RAW);
                 unlink(tempEncoded);
         }
-        
+
         if (output.getFileList()) {
                 output.saveFile(outfile);
         } else {

compress_queen.c

@@ -20 +20 @@
  *
  */
 
-#include "util.h"
+#include "compress.h"
 
 static const uint32 QTBL = 'QTBL';
+static CompressMode gCompMode = kMP3Mode;
 
 #define INPUT_TBL       "queen.tbl"
 #define FINAL_OUT       "queen.1c"
@@ -31 +32 @@
 #define TEMP_TBL        "tempfile.tbl"
 #define TEMP_SB         "tempfile.sb"
 
-#define TEMP_MP3        "tempfile.mp3"
-#define TEMP_OGG        "tempfile.ogg"
-#define TEMP_FLAC       "tempfile.fla"
-
-const char *tempEncoded;
-
 #define CURRENT_TBL_VERSION     2
 #define EXTRA_TBL_HEADER 8
 #define SB_HEADER_SIZE_V104 110
@@ -126 +121 @@
 
 void showhelp(char *exename)
 {
-        printf("\nUsage: %s [--mp3/--vorbis/--flac <args>] queen.1\n", exename);
+        printf("\nUsage: %s <params> queen.1\n", exename);
+
         printf("\nParams:\n");
-        printf(" --mp3 <args>         encode to MP3 format\n");
-        printf(" --vorbis <args>      encode to Ogg Vorbis Format\n");
-        printf(" --flac <args>        encode to Flac Format\n");
-        printf("                      (Optional: <args> are passed on to the encoder)\n");
-        printf("\nExample: %s --mp3 -q 5 queen.1\n", exename);
+
+        printf(" --mp3        encode to MP3 format (default)\n");
+        printf(" --vorbis     encode to Ogg Vorbis format\n");
+        printf(" --flac       encode to Flac format\n");
+        printf("(If one of these is specified, it must be the first parameter.)\n");
+
+        printf("\nMP3 mode params:\n");
+        printf(" -b <rate>    <rate> is the target bitrate(ABR)/minimal bitrate(VBR) (default:%d)\n", minBitrDef);
+        printf(" -B <rate>    <rate> is the maximum VBR/ABR bitrate (default:%d)\n", maxBitrDef);
+        printf(" --vbr        LAME uses the VBR mode (default)\n");
+        printf(" --abr        LAME uses the ABR mode\n");
+        printf(" -V <value>   specifies the value (0 - 9) of VBR quality (0=best) (default:%d)\n", vbrqualDef);
+        printf(" -q <value>   specifies the MPEG algorithm quality (0-9; 0=best) (default:%d)\n", algqualDef);
+        printf(" --silent     the output of LAME is hidden (default:disabled)\n");
+
+        printf("\nVorbis mode params:\n");
+        printf(" -b <rate>    <rate> is the nominal bitrate (default:unset)\n");
+        printf(" -m <rate>    <rate> is the minimum bitrate (default:unset)\n");
+        printf(" -M <rate>    <rate> is the maximum bitrate (default:unset)\n");
+        printf(" -q <value>   specifies the value (0 - 10) of VBR quality (10=best) (default:%d)\n", oggqualDef);
+        printf(" --silent     the output of oggenc is hidden (default:disabled)\n");
+
+        printf("\nFlac mode params:\n");
+        printf(" --fast       FLAC uses compresion level 0\n");
+        printf(" --best       FLAC uses compresion level 8\n");
+        printf(" -<value>     specifies the value (0 - 8) of compresion (8=best)(default:%d)\n", flacCompressDef);
+        printf(" -b <value>   specifies a blocksize of <value> samples (default:%d)\n", flacBlocksizeDef);
+        printf(" --verify     files are encoded and then decoded to check accuracy\n");
+        printf(" --silent     the output of FLAC is hidden (default:disabled)\n");
+
+        printf("\n --help     this help message\n");
+
+        printf("\n\nIf a parameter is not given the default value is used\n");
+        printf("If using VBR mode for MP3 -b and -B must be multiples of 8; the maximum is 160!\n");
         exit(2);
 }
 
@@ -219 +244 @@
         FILE *inputData, *inputTbl, *outputTbl, *outputData, *tmpFile, *compFile;
         uint8 compressionType = COMPRESSION_NONE;
         char tmp[5];
-        char sysBuf[1024];
-        char *ptr = sysBuf;
         int size, i = 1;
         uint32 prevOffset;
 
@@ -228 +251 @@
         if (argc < 2)
                 showhelp(argv[0]);
 
+        /* compression mode */
+        compressionType = COMPRESSION_MP3;
+        gCompMode = kMP3Mode;
+
         if (strcmp(argv[1], "--mp3") == 0) {
                 compressionType = COMPRESSION_MP3;
-                tempEncoded = TEMP_MP3;
+                gCompMode = kMP3Mode;
                 i++;
-                ptr += sprintf(ptr, "lame -r -h -s 11 --bitwidth 8 -m m ");
-                for (; i < (argc - 1); i++) {
-                        /* Append optional encoder arguments */
-                        ptr += sprintf(ptr, "%s ", argv[i]);
-                }
-                ptr += sprintf(ptr, "%s %s", TEMP_SB, tempEncoded);
         } else if (strcmp(argv[1], "--vorbis") == 0) {
                 compressionType = COMPRESSION_OGG;
-                tempEncoded = TEMP_OGG;
+                gCompMode = kVorbisMode;
                 i++;
-                ptr += sprintf(ptr, "oggenc -r -B 8 -C 1 -R 11025 %s -o %s ", TEMP_SB, tempEncoded);
-                for (; i < (argc - 1); i++) {
-                        /* Append optional encoder arguments */
-                        ptr += sprintf(ptr, "%s ", argv[i]);
-                }
         } else if (strcmp(argv[1], "--flac") == 0) {
                 compressionType = COMPRESSION_FLAC;
-                tempEncoded = TEMP_FLAC;
+                gCompMode = kFlacMode;
                 i++;
-                ptr += sprintf(ptr, "flac --force-raw-format --endian=little --sign=unsigned --bps=8 --channels=1 --sample-rate=11025 " );
-                ptr += sprintf(ptr, "--no-padding --lax --no-seektable --no-ogg " );
-                for (; i < (argc - 1); i++) {
-                        /* Append optional encoder arguments */
-                        ptr += sprintf(ptr, "%s ", argv[i]);
-                }
+        }
 
-                ptr += sprintf(ptr, "-o %s %s", tempEncoded, TEMP_SB );
-        } else {
-                showhelp(argv[0]);
+        switch (gCompMode) {
+        case kMP3Mode:
+                tempEncoded = TEMP_MP3;
+                if (!process_mp3_parms(argc, argv, i))
+                        showhelp(argv[0]);
+                break;
+        case kVorbisMode:
+                tempEncoded = TEMP_OGG;
+                if (!process_ogg_parms(argc, argv, i))
+                        showhelp(argv[0]);
+                break;
+        case kFlacMode:
+                tempEncoded = TEMP_FLAC;
+                if (!process_flac_parms(argc, argv, i))
+                        showhelp(argv[0]);
+                break;
         }
 
         /* Open input file (QUEEN.1) */
@@ -342 +366 @@
                         fclose(tmpFile);
 
                         /* Invoke encoder */
-                        if (system(sysBuf)) {
-                                printf("Got error from encoder. (check your parameters)\n");
-                                unlink(TEMP_SB);
-                                exit(-1);
-                        }
+                        setRawAudioType(false, false, 8);
+                        encodeAudio(TEMP_SB, true, 11025, tempEncoded, gCompMode);
 
                         /* Append MP3/OGG to data file */
                         compFile = fopen(tempEncoded, "rb");

compress_saga.cpp

@@ -19 +19 @@
  *
  * $URL$
  * $Id$
- * 
+ *
  */
 
 #include "compress.h"
@@ -194 +194 @@
         uint32 size;
         char fbuf[2048];
         FILE * tempf;
-        
+
         tempf = fopen(fromFileName, "rb");
         if (tempf == NULL)
                 error("Unable to open %s", fromFileName);
@@ -211 +211 @@
         uint32 size;
         char fbuf[2048];
         FILE * tempf;
-        
+
         tempf = fopen(toFileName, "wb");
         if (tempf == NULL)
                 error("Unable to open %s", toFileName);
@@ -228 +228 @@
 
 void writeBufferToFile(uint8* data, uint32 inputSize, const char* toFileName) {
         FILE * tempf;
-        
+
         tempf = fopen(toFileName, "wb");
         if (tempf == NULL)
                 error("Unable to open %s", toFileName);
@@ -248 +248 @@
         Common::File inputFileStream(inputFile);
         int rate, size;
         byte flags;
-        
+
         if (currentFileDescription->resourceType == kSoundVOC) {
                 inputData = Audio::loadVOCFromStream(inputFileStream, size, rate);
                 sampleSize = size;
@@ -259 +259 @@
                 free(inputData);
                 writeHeader(outputFile);
 
-                setRawAudioType( true, false, !isSigned, 8);
+                setRawAudioType( true, false, 8);
                 encodeAudio(TEMP_RAW, true, sampleRate, tempEncoded, gCompMode);
                 return copyFile(tempEncoded, outputFile) + HEADER_SIZE;
         }
@@ -271 +271 @@
                 sampleStereo = currentFileDescription->stereo;
                 writeHeader(outputFile);
 
-                setRawAudioType( !currentFileDescription->swapEndian, currentFileDescription->stereo, !isSigned, sampleBits);
+                setRawAudioType( !currentFileDescription->swapEndian, currentFileDescription->stereo, sampleBits);
                 encodeAudio(TEMP_RAW, true, currentFileDescription->frequency, tempEncoded, gCompMode);
                 return copyFile(tempEncoded, outputFile) + HEADER_SIZE;
         }
@@ -287 +287 @@
 
                 copyFile(inputFile, size, TEMP_RAW);
 
-                setRawAudioType( true, sampleStereo != 0, !isSigned, sampleBits);
+                setRawAudioType( true, sampleStereo != 0, sampleBits);
                 encodeAudio(TEMP_RAW, true, sampleRate, tempEncoded, gCompMode);
                 return copyFile(tempEncoded, outputFile) + HEADER_SIZE;
         }
@@ -302 +302 @@
                 sampleStereo = currentFileDescription->stereo;
                 writeHeader(outputFile);
 
-                setRawAudioType( !currentFileDescription->swapEndian, currentFileDescription->stereo, !isSigned, sampleBits);
+                setRawAudioType( !currentFileDescription->swapEndian, currentFileDescription->stereo, sampleBits);
                 encodeAudio(TEMP_RAW, true, currentFileDescription->frequency, tempEncoded, gCompMode);
                 return copyFile(tempEncoded, outputFile) + HEADER_SIZE;
                 */
@@ -348 +348 @@
                 error("Something's wrong with your resource file");
         }
 
-        // Go to beginning of the table 
+        // Go to beginning of the table
         fseek(inputFile, resTableOffset, SEEK_SET);
 
         inputTable = (Record*)malloc(resTableCount * sizeof(Record));
 
-        // Put offsets of all the records in a table 
+        // Put offsets of all the records in a table
         for (i = 0; i < resTableCount; i++) {
 
         if (!currentFileDescription->swapEndian) {
@@ -365 +365 @@
         }
 
                  printf("Record: %ul, offset: %ul, size: %ul\n", i, inputTable[i].offset, inputTable[i].size);
-        
+
                 if ((inputTable[i].offset > inputFileSize) ||
                     (inputTable[i].offset + inputTable[i].size > inputFileSize)) {
                         error("The offset points outside the file");
@@ -374 +374 @@
         }
         outputTable = (Record*)malloc(resTableCount * sizeof(Record));
 
-        sprintf(outputFileNameWithExt, "%s.cmp", inputFileName);        
+        sprintf(outputFileNameWithExt, "%s.cmp", inputFileName);
         outputFile = fopen(outputFileNameWithExt, "wb");
 
         for (i = 0; i < resTableCount; i++) {
                 fseek(inputFile, inputTable[i].offset, SEEK_SET);
                 outputTable[i].offset = ftell(outputFile);
-                
+
                 outputTable[i].size = encodeEntry(inputFile, inputTable[i].size, outputFile);
         }
         fclose(inputFile);
@@ -391 +391 @@
                 writeUint32LE(outputFile, outputTable[i].size);
         }
         writeUint32LE(outputFile, resTableOffset);
-        writeUint32LE(outputFile, resTableCount);       // Should be the same number of entries 
+        writeUint32LE(outputFile, resTableCount);       // Should be the same number of entries
 
         fclose(outputFile);
 
         free(inputTable);
         free(outputTable);
-        
+
         // Cleanup
         unlink(TEMP_RAW);
         unlink(tempEncoded);
@@ -406 +406 @@
 }
 
 void showhelp(char *exename) {
-        printf("\nUsage: %s <params> [<file> | mac]\n", exename);
+        printf("\nUsage: %s [params] <file>\n", exename);
 
         printf("\nParams:\n");
 
@@ -432 +432 @@
         printf("--silent     the output of oggenc is hidden (default:disabled)\n");
 
         printf("\nFlac mode params:\n");
-        printf("[params]     optional Arguments passed to the Encoder\n");
-        printf("             recommended is: --best -b 1152\n");
+        printf(" --fast       FLAC uses compresion level 0\n");
+        printf(" --best       FLAC uses compresion level 8\n");
+        printf(" -<value>     specifies the value (0 - 8) of compresion (8=best)(default:%d)\n", flacCompressDef);
+        printf(" -b <value>   specifies a blocksize of <value> samples (default:%d)\n", flacBlocksizeDef);
+        printf(" --verify     files are encoded and then decoded to check accuracy\n");
+        printf(" --silent     the output of FLAC is hidden (default:disabled)\n");
 
         printf("\n--help     this help message\n");
 

compress_scumm_bun.cpp

@@ -614 +614 @@
 }
 
 void showhelp(char *exename) {
-        printf("\nUsage: %s <inputfile> <inputdir> <outputdir> [--ogg] [encoder params]\n", exename);
+        printf("\nUsage: %s [--vorbis] [params] <inputfile> <inputdir> <outputdir>\n", exename);
         printf("\nMP3 mode params:\n");
         printf(" -b <rate>    <rate> is the target bitrate(ABR)/minimal bitrate(VBR) (default:%d)\n", minBitrDef);
         printf(" -B <rate>    <rate> is the maximum VBR/ABR bitrate (default:%d)\n", maxBitrDef);
@@ -1064 +1064 @@
         uint32 tag;
         int32 numFiles, offset, i;
 
-        strcpy(inputFilename, argv[1]);
-        strcpy(inputDir, argv[2]);
-        strcpy(outputDir, argv[3]);
+        strcpy(inputFilename, argv[argc - 3]);
+        strcpy(inputDir, argv[argc - 2]);
+        strcpy(outputDir, argv[argc - 1]);
 
         if (argc > 4) {
-                i = 4;
+                int result;
+                i = 1;
 
-                if (strcmp(argv[i], "--ogg") == 0) {
+                if (strcmp(argv[i], "--vorbis") == 0) {
                         _oggMode = true;
                         i++;
                 }
 
-                if (argc > i) {
-                        // HACK: The functions in compress.c expect the last
-                        // argument to be a filename. As we don't expect one,
-                        // we simply add a dummy argument to the list.
-                        char **args = (char **)malloc((argc + 1) * sizeof(char *));
-                        char dummyName[] = "dummy";
-                        int j;
+                if (_oggMode)
+                        result = process_ogg_parms(argc - 2, argv, i);
+                else
+                        result = process_mp3_parms(argc - 2, argv, i);
 
-                        for (j = 0; j < argc; j++)
-                                args[j] = argv[j];
-                        args[j] = dummyName;
-                
-                        int result;
-
-                        if (_oggMode)
-                                result = process_ogg_parms(argc + 1, args, i);
-                        else
-                                result = process_mp3_parms(argc + 1, args, i);
-
-                        if (!result)
-                                showhelp(argv[0]);
-
-                        free(args);
-                }
+                if (!result)
+                        showhelp(argv[0]);
         }
 
         char *index = strrchr(inputFilename, '.');
@@ -1141 +1125 @@
                 char filename[13], c;
                 int z = 0;
                 int z2;
-                        
+
                 for (z2 = 0; z2 < 8; z2++)
                         if ((c = readByte(input)) != 0)
                                 filename[z++] = c;
@@ -1181 +1165 @@
         fclose(input);
 
         printf("compression done.\n");
-                
+
         return 0;
 }

compress_scumm_san.cpp

@@ -24 +24 @@
 #include "zlib.h"
 
 void showhelp(char *exename) {
-        printf("\nUsage: %s <inputfile> <inputdir> <outputdir> [--ogg] [encoder params]\n", exename);
+        printf("\nUsage: %s [--vorbis] [encoder params] <inputfile> <inputdir> <outputdir>\n", exename);
         printf("\nMP3 mode params:\n");
         printf(" -b <rate>    <rate> is the target bitrate(ABR)/minimal bitrate(VBR) (default:%d)\n", minBitrDef);
         printf(" -B <rate>    <rate> is the maximum VBR/ABR bitrate (default:%d)\n", maxBitrDef);
@@ -643 +643 @@
         char inputFilename[200];
         char tmpPath[200];
 
-        strcpy(inputFilename, argv[1]);
-        strcpy(inputDir, argv[2]);
-        strcpy(outputDir, argv[3]);
+        strcpy(inputFilename, argv[argc - 3]);
+        strcpy(inputDir, argv[argc - 2]);
+        strcpy(outputDir, argv[argc - 1]);
 
         if (argc > 4) {
-                int i = 4;
+                int i = 1;
 
-                if (strcmp(argv[i], "--ogg") == 0) {
+                if (strcmp(argv[1], "--vorbis") == 0) {
                         _oggMode = true;
                         i++;
                 }
 
-                if (argc > i) {
-                        // HACK: The functions in compress.c expect the last
-                        // argument to be a filename. As we don't expect one,
-                        // we simply add a dummy argument to the list.
-                        char **args = (char **)malloc((argc + 1) * sizeof(char *));
-                        char dummyName[] = "dummy";
-                        int j;
+                int result;
 
-                        for (j = 0; j < argc; j++)
-                                args[j] = argv[j];
-                        args[j] = dummyName;
-                
-                        int result;
+                if (_oggMode)
+                        result = process_ogg_parms(argc - 2, argv, i);
+                else
+                        result = process_mp3_parms(argc - 2, argv, i);
 
-                        if (_oggMode)
-                                result = process_ogg_parms(argc + 1, args, i);
-                        else
-                                result = process_mp3_parms(argc + 1, args, i);
-
-                        if (!result)
-                                showhelp(argv[0]);
-
-                        free(args);
-                }
+                if (!result)
+                        showhelp(argv[0]);
         }
 
         char *index = strrchr(inputFilename, '.');
@@ -903 +888 @@
         }
 
         free(frameInfo);
-        
+
         fclose(output);
 
         printf("compression done.\n");
-                
+
         return 0;
 }

compress_scumm_sou.c

@@ -72 +72 @@
         unlink(TEMP_DAT);
         unlink(TEMP_RAW);
         unlink(tempEncoded);
-        
+
         exit(-1);
 }
 
@@ -130 +130 @@
 
         /* Conver the VOC data */
         extractAndEncodeVOC(TEMP_RAW, input, gCompMode);
-        
+
         /* Append the converted data to the master output file */
         sprintf(outname, tempEncoded);
         f = fopen(outname, "rb");
@@ -171 +171 @@
         printf(" --silent     the output of oggenc is hidden (default:disabled)\n");
 
         printf("\nFlac mode params:\n");
-        printf(" [params]     optional arguments passed directly to the encoder\n");
-        printf("              recommended is: --best -b 1152\n");
+        printf(" --fast       FLAC uses compresion level 0\n");
+        printf(" --best       FLAC uses compresion level 8\n");
+        printf(" -<value>     specifies the value (0 - 8) of compresion (8=best)(default:%d)\n", flacCompressDef);
+        printf(" -b <value>   specifies a blocksize of <value> samples (default:%d)\n", flacBlocksizeDef);
+        printf(" --verify     files are encoded and then decoded to check accuracy\n");
+        printf(" --silent     the output of FLAC is hidden (default:disabled)\n");
 
         printf("\n --help     this help message\n");
 
@@ -242 +246 @@
                 printf("Can't open file " TEMP_DAT " for write!\n");
                 exit(-1);
         }
-        
+
         /* Get the 'SOU ....' header */
         fread(buf, 1, 8, input);
         if (strncmp(buf, f_hdr, 8)) {

compress_sword1.c

@@ -116 +116 @@
         { "2M26", false },
         { "3M7", false },
         { "3M8", false },
-        { "3M9", true }, 
+        { "3M9", true },
         { "3M10", false },
         { "2M13", false },
         { "3M12", false },
@@ -163 +163 @@
         { "4M31", false },
         { "4M32", false },
         { "5M1", false },
-        { "5M2", true }, 
+        { "5M2", true },
         { "5M3", false },
         { "5M4", false },
         { "5M5", false },
@@ -275 +275 @@
         { "11M4", false },
         { "11M7", false },
         { "11M8", false },
-        { "11M9", true }, 
+        { "11M9", true },
         { "12M1", false },
         { "11M2", false },
         { "SPM2", false },
@@ -308 +308 @@
 };
 
 void showhelp(char *exename) {
-        printf("\nUsage: %s <params>\n", exename);
+        printf("\nUsage: %s [params]\n", exename);
 
         printf("\nParams:\n");
         printf(" --mp3          encode to MP3 format (default)\n");
@@ -337 +337 @@
         printf("                (default:%d)\n", oggqualDef);
         printf(" --silent       the output of oggenc is hidden (default:disabled)\n");
 
+        printf("\nFlac mode params:\n");
+        printf(" --fast       FLAC uses compresion level 0\n");
+        printf(" --best       FLAC uses compresion level 8\n");
+        printf(" -<value>     specifies the value (0 - 8) of compresion (8=best)(default:%d)\n", flacCompressDef);
+        printf(" -b <value>   specifies a blocksize of <value> samples (default:%d)\n", flacBlocksizeDef);
+        printf(" --verify     files are encoded and then decoded to check accuracy\n");
+        printf(" --silent     the output of FLAC is hidden (default:disabled)\n");
+
         printf("\n --help         this help message\n");
 
         printf("\nIf a parameter is not given the default value is used\n");
@@ -438 +446 @@
         }
         cl3Index = (uint32*)malloc(numSamples * 8);
         memset(cl3Index, 0, numSamples * 8);
-        
+
         sampleIndex = cowHeader + numRooms + 1;
         /* This points to the sample index table. 8 bytes each (4 bytes size and then 4 bytes file index) */
 
@@ -446 +454 @@
 
         for (cnt = 0; cnt < numSamples; cnt++) {
                 if (sampleIndex[cnt << 1] | sampleIndex[(cnt << 1) | 1]) {
-                        printf("sample %5d: ", cnt);
+                        printf("sample %5d: \n", cnt);
                         smpData = (uint8*)uncompressSpeech(clu, sampleIndex[cnt << 1] + headerSize, sampleIndex[(cnt << 1) | 1], &smpSize);
                         if ((!smpData) || (!smpSize))
                                 error("unable to handle speech sample %d!\n", cnt);
@@ -475 +483 @@
         int i;
         char cluName[256], outName[256];
 
-        setRawAudioType(true, false, false, 16);
+        setRawAudioType(true, false, 16);
         for (i = 1; i <= 2; i++) {
                 sprintf(cluName, "SPEECH/SPEECH%d.CLU", i);
                 clu = fopen(cluName, "rb");
@@ -670 +678 @@
                 compressSpeech(compMode);
         if (compMusic)
                 compressMusic(compMode);
-        
+
         return EXIT_SUCCESS;
 }
 

compress_sword2.c

@@ -31 +31 @@
 
 void showhelp(char *exename)
 {
-        printf("\nUsage: %s <params> file.clu\n", exename);
+        printf("\nUsage: %s [params] <file>\n", exename);
 
         printf("\nParams:\n");
         printf(" --mp3        encode to MP3 format (default)\n");
@@ -56 +56 @@
         printf(" --silent     the output of oggenc is hidden (default:disabled)\n");
 
         printf("\nFlac mode params:\n");
-        printf(" [params]     optional arguments passed directly to the encoder\n");
-        printf("              recommended is: --best -b 1152\n");
+        printf(" --fast       FLAC uses compresion level 0\n");
+        printf(" --best       FLAC uses compresion level 8\n");
+        printf(" -<value>     specifies the value (0 - 8) of compresion (8=best)(default:%d)\n", flacCompressDef);
+        printf(" -b <value>   specifies a blocksize of <value> samples (default:%d)\n", flacBlocksizeDef);
+        printf(" --verify     files are encoded and then decoded to check accuracy\n");
+        printf(" --silent     the output of FLAC is hidden (default:disabled)\n");
 
         printf("\n --help     this help message\n");
 
@@ -104 +108 @@
         uint32 indexSize;
         uint32 totalSize;
         uint32 length;
-        
+
         if (argc < 2)
                 showhelp(argv[0]);
         i = 1;

compress_touche.c

@@ -158 +158 @@
 }
 
 static void showhelp(const char *exename) {
-        printf("\nUsage: %s <params> input_directory\n", exename);
+        printf("\nUsage: %s [params] <inputdir>\n", exename);
 
         printf("\nParams:\n");
+
         printf(" --mp3        encode to MP3 format (default)\n");
         printf(" --vorbis     encode to Vorbis format\n");
         printf(" --flac       encode to Flac format\n");
@@ -183 +184 @@
         printf(" --silent     the output of oggenc is hidden (default:disabled)\n");
 
         printf("\nFlac mode params:\n");
-        printf(" [params]     optional arguments passed directly to the encoder\n");
-        printf("              recommended is: --best -b 1152\n");
+        printf(" --fast       FLAC uses compresion level 0\n");
+        printf(" --best       FLAC uses compresion level 8\n");
+        printf(" -<value>     specifies the value (0 - 8) of compresion (8=best)(default:%d)\n", flacCompressDef);
+        printf(" -b <value>   specifies a blocksize of <value> samples (default:%d)\n", flacBlocksizeDef);
+        printf(" --verify     files are encoded and then decoded to check accuracy\n");
+        printf(" --silent     the output of FLAC is hidden (default:disabled)\n");
 
         printf("\n --help     this help message\n");
 

encode_dxa.cpp

@@ -699 +699 @@
 }
 
 void showhelp(char *exename) {
-        printf("\nUsage: %s <inputfile> \n", exename);
+        printf("\nUsage: %s <params> <file>\n", exename);
 
         printf("\nParams:\n");
         printf(" --mp3        encode to MP3 format (default)\n");
@@ -724 +724 @@
         printf(" --silent     the output of oggenc is hidden (default:disabled)\n");
 
         printf("\nFlac mode params:\n");
-        printf(" [params]     optional arguments passed directly to the encoder\n");
-        printf("              recommended is: --best -b 1152\n");
+        printf(" --fast       FLAC uses compresion level 0\n");
+        printf(" --best       FLAC uses compresion level 8\n");
+        printf(" -<value>     specifies the value (0 - 8) of compresion (8=best)(default:%d)\n", flacCompressDef);
+        printf(" -b <value>   specifies a blocksize of <value> samples (default:%d)\n", flacBlocksizeDef);
+        printf(" --verify     files are encoded and then decoded to check accuracy\n");
+        printf(" --silent     the output of FLAC is hidden (default:disabled)\n");
 
         printf("\n --help     this help message\n");
 
         printf("\n\nIf a parameter is not given the default value is used\n");
         printf("If using VBR mode for MP3 -b and -B must be multiples of 8; the maximum is 160!\n");
-        printf("Use the `mac' option instead of a filename if converting simon2mac sounds\n");
         exit(2);
 }
 

kyra_pak.h

@@ -24 +24 @@
 #define KYRA_PAK_H
 
 #include "util.h"
-#include <string.h>
 
 class PAKFile {
 public:
@@ -34 +33 @@
         bool loadFile(const char *file, const bool isAmiga);
         bool saveFile(const char *file);
         void clearFile() { delete _fileList; _fileList = 0; }
-        
+
         const uint32 getFileSize() const { return _fileList->getTableSize()+5+4+_fileList->getFileSize(); }
 
         void drawFileList();
@@ -47 +46 @@
 
         bool addFile(const char *name, const char *file);
         bool addFile(const char *name, uint8 *data, uint32 size);
-        
+
         bool removeFile(const char *name);
 public:
         struct FileList {
@@ -57 +56 @@
                         delete [] data;
                         delete next;
                 }
-                
+
                 FileList *findEntry(const char *f) {
                         for (FileList *cur = this; cur; cur = cur->next) {
                                 if (scumm_stricmp(cur->filename, f) != 0)
@@ -66 +65 @@
                         }
                         return 0;
                 }
-                
+
                 const FileList *findEntry(const char *f) const {
                         for (const FileList *cur = this; cur; cur = cur->next) {
                                 if (scumm_stricmp(cur->filename, f) != 0)
@@ -92 +91 @@
                 char *filename;
                 uint32 size;
                 uint8 *data;
-                
+
                 FileList *next;
         };
 
         typedef const FileList cFileList;
-        
+
         cFileList *getFileList() const { return _fileList; }
 private:
         FileList *_fileList;

Makefile

@@ -51 +51 @@
 all: $(TARGETS)
 
 compress_agos$(EXEEXT): compress_agos.o compress.o util.o
-        $(CC) $(LDFLAGS) -o $@ $+
+        $(CC) $(LDFLAGS) -o $@ $+ -lvorbis -logg -lvorbisenc -lFLAC
 
 compress_kyra$(EXEEXT): compress_kyra.o kyra_pak.o compress.o util.o
-        $(CXX) $(LDFLAGS) -o $@ $+
+        $(CXX) $(LDFLAGS) -o $@ $+ -lvorbis -logg -lvorbisenc -lFLAC
 
-compress_queen$(EXEEXT): compress_queen.o util.o
-        $(CC) $(LDFLAGS) -o $@ $+
+compress_queen$(EXEEXT): compress_queen.o compress.o util.o
+        $(CC) $(LDFLAGS) -o $@ $+ -lvorbis -logg -lvorbisenc -lFLAC
 
 compress_saga$(EXEEXT): compress_saga.o compress.o util.o $(UTILS)
-        $(CXX) $(LDFLAGS) -o $@ $+
+        $(CXX) $(LDFLAGS) -o $@ $+ -lvorbis -logg -lvorbisenc -lFLAC
 
 compress_scumm_bun$(EXEEXT): compress_scumm_bun.o compress.o util.o
-        $(CXX) $(LDFLAGS) -o $@ $+
+        $(CXX) $(LDFLAGS) -o $@ $+ -lvorbis -logg -lvorbisenc -lFLAC
 
 compress_scumm_san$(EXEEXT): compress_scumm_san.o compress.o util.o
-        $(CXX) $(LDFLAGS) -o $@ $+ -lz
+        $(CXX) $(LDFLAGS) -o $@ $+ -lz -lvorbis -logg -lvorbisenc -lFLAC
 
 compress_scumm_sou$(EXEEXT): compress_scumm_sou.o compress.o util.o
-        $(CC) $(LDFLAGS) -o $@ $+
+        $(CC) $(LDFLAGS) -o $@ $+ -lvorbis -logg -lvorbisenc -lFLAC
 
 compress_sword1$(EXEEXT): compress_sword1.o compress.o util.o
-        $(CC) $(LDFLAGS) -o $@ $+
+        $(CC) $(LDFLAGS) -o $@ $+ -lvorbis -logg -lvorbisenc -lFLAC
 
 compress_sword2$(EXEEXT): compress_sword2.o compress.o util.o
-        $(CC) $(LDFLAGS) -o $@ $+
+        $(CC) $(LDFLAGS) -o $@ $+ -lvorbis -logg -lvorbisenc -lFLAC
 
 compress_touche$(EXEEXT): compress_touche.o compress.o util.o
-        $(CC) $(LDFLAGS) -o $@ $+
+        $(CC) $(LDFLAGS) -o $@ $+ -lvorbis -logg -lvorbisenc -lFLAC
 
 dekyra$(EXEEXT): dekyra.o dekyra_v1.o util.o
         $(CXX) $(LDFLAGS) -o $@ $+
@@ -90 +90 @@
         $(CXX) $(LDFLAGS) -o $@ $+
 
 encode_dxa$(EXEEXT): encode_dxa.o compress.o util.o
-        $(CXX) $(LDFLAGS) -o $@ $+ -lpng -lz
+        $(CXX) $(LDFLAGS) -o $@ $+ -lpng -lz -lvorbis -logg -lvorbisenc -lFLAC
 
 extract_agos$(EXEEXT): extract_agos.o
         $(CC) $(LDFLAGS) -o $@ $+
@@ -122 +122 @@
 
 descumm.o descumm6.o descumm-common.o descumm-tool.o: descumm.h
 
-# Most compress_* tools (except for compress_queen) use compress.h
+# All compress_* tools use compress.h
 compress_agos.o compress_saga.o compress_scumm_sou.o \
 compress_scumm_bun.o compress_sword1.o compress_sword2.o \
-compress_kyra.o compress.o encode_dxa.o: compress.h
+compress_kyra.o compress_queen.o compress.o encode_dxa.o: compress.h
 
 # extract_parallaction.h
 extract_parallaction.o: extract_parallaction.h

README

@@ -7 +7 @@
 example.
 
 Extraction Tools:
-        extract_agos
-                Extracts the packed files used in the Amiga and AtariST
-                versions of Elvira 1/2, Waxworks and Simon the Sorcerer 1.
+        extract_agos
+                Extracts the packed files used in the Amiga and AtariST
+                versions of Elvira 1/2, Waxworks and Simon the Sorcerer 1.
 
-        extract_kyra
-                Unpacks .PAK files from Kyrandia games.
+        extract_kyra
+                Unpacks .PAK files from Kyrandia games.
 
-        extract_scumm_mac
-                Extracts Macintosh "single file" SCUMM games into their
-                component parts, for use with ScummVM.
-                This is required for ScummVM up to version 0.6.x; all
-                later versions directly support reading this file
-                format.
+        extract_scumm_mac
+                Extracts Macintosh "single file" SCUMM games into their
+                component parts, for use with ScummVM.
+                This is required for ScummVM up to version 0.6.x; all
+                later versions directly support reading this file
+                format.
 
-        extract_loom_tg16
-                Extracts data files from the PC-Engine version of Loom.
-                Use the dumpcd utility at http://www.zeograd.com/misc_download.php
-                to dump the code tracks on the CD.
+        extract_loom_tg16
+                Extracts data files from the PC-Engine version of Loom.
+                Use the dumpcd utility at http://www.zeograd.com/misc_download.php
+                to dump the code tracks on the CD.
 
-        extract_mm_apple
-                Extracts data files from the Apple II version of Maniac
-                Mansion.
+        extract_mm_apple
+                Extracts data files from the Apple II version of Maniac
+                Mansion.
 
-        extract_mm_c64
-                Extracts data files from the Commodore 64 version of Maniac
-                Mansion.
+        extract_mm_c64
+                Extracts data files from the Commodore 64 version of Maniac
+                Mansion.
 
-        extract_mm_nes
-                Extracts data files from the NES version of Maniac Mansion.
+        extract_mm_nes
+                Extracts data files from the NES version of Maniac Mansion.
 
-        extract_parallaction
-                Extracts the contents of archives used by Nippon Safes
+        extract_parallaction
+                Extracts the contents of archives used by Nippon Safes
 
-        extract_zak_c64
-                Extracts data files from the Commodore 64 version of Zak
-                McKracken.
+        extract_zak_c64
+                Extracts data files from the Commodore 64 version of Zak
+                McKracken.
 
 Compression Tools:
-        compress_scumm_sou
-                Used to compress .sou files to .so3 (MP3), .sog (Vorbis),
-                or .sof (FLAC).
+        compress_scumm_sou
+                Used to compress .sou files to .so3 (MP3), .sog (Vorbis),
+                or .sof (FLAC).
 
-        compress_agos
-                Used to compress the Feeble Files or Simon 1/2 voc/wav files
-                to MP3, Vorbis or FLAC.
+                Example of usage:
+                compress_scumm_sou [params] monster.sou
 
-        compress_queen
-                Used to rebuild the datafile of Flight of the Amazon Queen,
-                and allow optional MP3, Vorbis or FLAC compression.
+        compress_agos
+                Used to compress the Feeble Files or Simon 1/2 voc/wav files
+                to MP3, Vorbis or FLAC.
 
-        compress_saga
-                Used to compress SAGA engine digital sound files to MP3, Vorbis
-                or FLAC. 
+                Example of usage:
+                compress_agos [params] [<file> | mac]
 
-                Example of usage:
-                compress_saga <flags here> <file>
+        compress_queen
+                Used to rebuild the datafile of Flight of the Amazon Queen,
+                and allow optional MP3, Vorbis or FLAC compression.
 
-                Where <file> is the sound file you with to compress, without the
-                extension.
+                Example of usage:
+                compress_queen <params> queen.1
 
-                For Inherit the Earth, the digital music (music.rsc), speech 
-                (voices.rsc or "inherit the earth voices") and sound effects
-                (sounds.rsc) files can be compressed. For I have no mouth, the 
-                speech (voices*.res) and sound effects (sfx.res) files can be 
-                compressed.
-                
-                The compressed files have the ".cmp" extension. Once compressed, 
-                you only need the respective .cmp files. 
-                
-                Only the files of the full game versions can be compressed, the
-                demo versions are not supported. 
-                
-                The MacBinary files (*.bin) of the Mac CD Guild version of Inherit 
-                the Earth are not currently supported. Finally, there is no support 
-                for compressed sounds in I have no mouth yet.
+        compress_saga
+                Used to compress SAGA engine digital sound files to MP3, Vorbis
+                or FLAC. 
 
-        compress_sword1
-                Used to compress Broken Sword 1's music and speech files to
-                MP3 or Vorbis or FLAC.
+                Example of usage:
+                compress_saga [params] <file>
 
-        compress_sword2
-                Used to compress Broken Sword 2's music and speech .clu
-                files to .cl3 (MP3), .clg (Vorbis) or .clf (FLAC).
+                Where <file> is the sound file you with to compress, without the
+                extension.
 
-                Please note that FLAC compression will produce a larger file
-                than the original! This is because the original files already
-                use lossy compression.
+                For Inherit the Earth, the digital music (music.rsc), speech 
+                (voices.rsc or "inherit the earth voices") and sound effects
+                (sounds.rsc) files can be compressed. For I have no mouth, the 
+                speech (voices*.res) and sound effects (sfx.res) files can be 
+                compressed.
 
-        compress_touche
-                Used to compress and pack Touche speech files ('Vxxx' and
-                'OBJ') to MP3, Vorbis or FLAC to a single file named
-                TOUCHE.SO3/.SOG/.SOF depending on the sound compression. Once
-                compressed, only TOUCHE.DAT and TOUCHE.SOx files are required
-                to play the game under ScummVM.
+                The compressed files have the ".cmp" extension. Once compressed, 
+                you only need the respective .cmp files. 
 
-        compress_scumm_san <inputfile> <inputdir> <outputdir> [--ogg]
-                Compresses '.san' smush animation files. It uses lossless
-                zlib for compressing FOBJ gfx chunks inside a san file.
-                It also can create a separate Ogg file with the audio track.
+                Only the files of the full game versions can be compressed, the
+                demo versions are not supported. 
 
-                Example of usage:
-                compress_scumm_san opening.san uncomp comp
+                The MacBinary files (*.bin) of the Mac CD Guild version of Inherit 
+                the Earth are not currently supported. Finally, there is no support 
+                for compressed sounds in I have no mouth yet.
 
-                In order to use such compressed files, your ScummVM binary
-                must have been built with zlib support enabled (you can find
-                out whether that's the case by looking at the About dialog).
-                For the Ogg or MP3 compression feature, your ScummVM binary
-                naturally must have been built with Ogg or MP3 support enabled.
+        compress_sword1
+                Used to compress Broken Sword 1's music and speech .clu
+                files to .cl3 (MP3), .clg (Vorbis) or .clf (FLAC).
 
-                NOTE: For some '.san' files there is a corresponding '.flu'
-                file, which contains offsets into the '.san' file. Hence, the
-                compress_scumm_san has to modify the '.flu' file. This happens
-                automatically, if the '.san' and '.flu' files are in the
-                same directory (which is normally the case). If you want to
-                move the '.san' files before compressing them, make sure to
-                move the '.flu' files, too!
+                Example of usage:
+                compress_sword1 [params]
 
-        compress_scumm_bun <inputfile> <inputdir> <outputdir> [--ogg]
+       compress_sword2
+                Used to compress Broken Sword 2's music and speech .clu
+                files to .cl3 (MP3), .clg (Vorbis) or .clf (FLAC).
 
-                Compresses '.bun' music/voice files.
+                Please note that FLAC compression will produce a larger file
+                than the original! This is because the original files already
+                use lossy compression.
 
-                Example of usage:
-                compress_scumm.bun digmusic.bun uncomp comp
+                Example of usage:
+                compress_sword2 [params] <file>
 
-                For the Ogg or MP3 compression feature, your ScummVM binary
-                naturally must have been built with Ogg or MP3 support enabled.
+        compress_touche
+                Used to compress and pack Touche speech files ('Vxxx' and
+                'OBJ') to MP3, Vorbis or FLAC to a single file named
+                TOUCHE.SO3 (MP3), TOUCHE.SOG (Vorbis), or TOUCHE.SOF (FLAC).
 
-        compress_kyra
-                Used to compress The Legend of Kyrandia's speech files with
-                MP3, Vorbis or FLAC.
+                Once compressed, only TOUCHE.DAT and TOUCHE.SOx files are
 
-                Example of usage:
-                compress_kyra <flags here> input/GEMCUT.VRM output/GEMCUT.VRM
+                Example of usage:
+                comrpess_touche [params] <inputdir>
 
-                Note: You have to keep the VRM extension, else it will NOT work.
-                Use it like shown above, copy all *.VRM files to a directory
-                and let the tool put the output file in another directory.
+        compress_scumm_san
+                Compresses '.san' smush animation files. It uses lossless
+                zlib for compressing FOBJ gfx chunks inside a san file.
+                It also can create a separate Ogg file with the audio track.
 
+                In order to use such compressed files, your ScummVM binary
+                must have been built with zlib support enabled (you can find
+                out whether that's the case by looking at the About dialog).
+                For the Ogg or MP3 compression feature, your ScummVM binary
+                naturally must have been built with Ogg or MP3 support enabled.
+
+                NOTE: For some '.san' files there is a corresponding '.flu'
+                file, which contains offsets into the '.san' file. Hence, the
+                compress_scumm_san has to modify the '.flu' file. This happens
+                automatically, if the '.san' and '.flu' files are in the
+                same directory (which is normally the case). If you want to
+                move the '.san' files before compressing them, make sure to
+                move the '.flu' files, too!
+
+                Example of usage:
+                compress_scumm_bun [--vorbis] [params] <inputfile> <inputdir> <outputdir>
+
+        compress_scumm_bun
+                Compresses '.bun' music/voice files.
+
+                For the Ogg or MP3 compression feature, your ScummVM binary
+                naturally must have been built with Ogg or MP3 support enabled.
+
+                Example of usage:
+                compress_scumm_bun [--vorbis] [params] <inputfile> <inputdir> <outputdir>
+
+        compress_kyra
+                Used to compress The Legend of Kyrandia's speech files with
+                MP3, Vorbis or FLAC.
+
+                Example of usage:
+                compress_kyra [params] <inputfile> <inputdir> <outputdir>
+
 Script Tools:
-        descumm
-                Decompiles SCUMM scripts
+        descumm
+                Decompiles SCUMM scripts
 
-        desword2
-                Disassembles Broken Sword II scripts
+        desword2
+                Disassembles Broken Sword II scripts
 
-        dekyra
-                Basic script disassembler for Legend of Kyrandia games
+        dekyra
+                Basic script disassembler for Legend of Kyrandia games
 
 Encoder Tools:
-        encode_dxa <filename>
+        encode_dxa <filename>
 
-                Creates DXA file out of extracted Smacker video.
+                Creates DXA file out of extracted Smacker video.
 
-                To extract a video use RAD Game Tools and perform 2 passes
-                on it. For example, if your video is called 'intro.smk'.
+                To extract a video use RAD Game Tools and perform 2 passes
+                on it. For example, if your video is called 'intro.smk'.
 
-                1. Extract the video to PNG, 256 colors (choose PNG format
-                and tick the checkbox). It will create bunch of files named
-                'introXXX.png', where XXX is frame number. Make sure you have
-                extracted 256 colors PNGs, otherwise encode_dxa will complain.
+                1. Extract the video to PNG, 256 colors (choose PNG format
+                and tick the checkbox). It will create bunch of files named
+                'introXXX.png', where XXX is frame number. Make sure you have
+                extracted 256 colors PNGs, otherwise encode_dxa will complain.
 
-                2. Extract the audio to WAV format, you will get an
-                'intro.wav' file.
+                2. Extract the audio to WAV format, you will get an
+                'intro.wav' file.
 
-                3. Put files 'intro.smk', 'intro.wav' and 'intro*.png' into a
-                single directory.
+                3. Put files 'intro.smk', 'intro.wav' and 'intro*.png' into a
+                single directory.
 
-                4. Run `encode_dxa intro.smk` in that directory
+                4. Run `encode_dxa intro.smk` in that directory
 
-                5. You will get an intro.dxa file and intro.flac/mp3/ogg file
-                in result.
+                5. You will get an intro.dxa file and intro.flac/mp3/ogg file
+                in result.
 
-                Additionally you may use batch processing mode of SMK files in
-                RAD Game Tools. Just select more than one file and push the
-                'Convert' button. It will ask you either you want them
-                processed in batch mode and will do this for you. All buttons
-                and conversion options work the same.
+                Additionally you may use batch processing mode of SMK files in
+                RAD Game Tools. Just select more than one file and push the
+                'Convert' button. It will ask you either you want them
+                processed in batch mode and will do this for you. All buttons
+                and conversion options work the same.
 
-        convert_dxa.bat
-        convert_dxa_one.bat
+        convert_dxa.bat
+        convert_dxa_one.bat
 
-                To ease your life we also provide batch files to autoconvert
-                all files. It should work with any game version.
+                To ease your life we also provide batch files to autoconvert
+                all files. It should work with any game version.
 
-                1. Copy *.smk files from all CDs to some directory
+                1. Copy *.smk files from all CDs to some directory
 
-                2. Edit paths in convert_dxa.bat file.
+                2. Edit paths in convert_dxa.bat file.
 
-                3. Run the batch. If you set everything correct, it will be
-                almost unattended conversion, just for several files there
-                are no audio, and RAD Game Tools converter will ask you to
-                press OK
+                3. Run the batch. If you set everything correct, it will be
+                almost unattended conversion, just for several files there
+                are no audio, and RAD Game Tools converter will ask you to
+                press OK
 
-        convert_dxa.sh
+        convert_dxa.sh
 
-                Same as above convert_dxa.bat, just for *nix-based systems.
-                It uses Wine to run RAD Game Tools.
+                Same as above convert_dxa.bat, just for *nix-based systems.
+                It uses Wine to run RAD Game Tools.