Ticket #8707: SoC Tools Update.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) {
-        char fbuf[2048];
-        char *tmp = fbuf;
-        int i;
-        bool err = false;
+        if ((compmode == kVorbisMode) || (compmode == kFlacMode)) {
+                if (rawInput) {
+                        FILE *inputRaw;
+                        long length;
+                        char *rawData;
 
-        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));
+                        inputRaw = fopen(inname, "rb");
+                        length = fileSize(inputRaw);
+                        rawData = (char *)malloc(length);
+                        fread(rawData, 1, length, inputRaw);
+
+                        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);
                 }
+        } else if (compmode == kMP3Mode) {
+                bool err = false;
+                char fbuf[2048];
+                char *tmp = fbuf;
 
-                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:
                 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);
+                }
+        }
+}
 
-                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"));
+void encodeRaw(char *rawData, int length, int samplerate, const char *outname, CompressMode compmode) {
+        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");
+                        }
                 }
 
-                for (i = 0; i < flacparms.numArgs; i++) {
-                        /* Append optional encoder arguments */
-                        tmp += sprintf(tmp, "%s ", flacparms.argv[i]);
+                printf(outputString);
+
+                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);
+
+                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);
                 }
 
-                tmp += sprintf(tmp, "-o \"%s\" ", outname);
-                tmp += sprintf(tmp, "\"%s\" ", inname);
+                while (!eos) {
+                        int i, j;
+                        int numSamples = ((samplesLeft < 2048) ? samplesLeft : 2048);
+                        float **buffer = vorbis_analysis_buffer(&vd, numSamples);
 
-                err = system(fbuf) != 0;
-                break;
-        }
+                        /* 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;
+                                                        }
+                                                }
+                                        }
+                                }
 
-        if (err) {
-                printf("Got error from encoder. (check your parameters)\n");
-                printf("Encoder Commandline: %s\n", fbuf );
-                exit(-1);
+                                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));
+                }
+        } else 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));
+                }
+
         }
 }
 
 void extractAndEncodeWAV(const char *outName, FILE *input, CompressMode compMode) {
         int length;
-        FILE *f;
-        char fbuf[2048];
-        size_t size;
 
         fseek(input, -4, SEEK_CUR);
         length = readUint32LE(input);
         length += 8;
         fseek(input, -8, SEEK_CUR);
 
-        /* Copy the WAV data to a temporary file */
-        f = fopen(outName, "wb");
-        while (length > 0) {
-                size = fread(fbuf, 1, length > sizeof(fbuf) ? sizeof(fbuf) : length, input);
-                if (size <= 0)
-                        break;
-                length -= (int)size;
-                fwrite(fbuf, 1, size, f);
+        if (compMode == kVorbisMode || compMode == kFlacMode) {
+                char *rawData;
+                int fmtHeaderSize, rawLength, numChannels, sampleRate, bitsPerSample;
+
+                /* Standard PCM fmt header is 16 bits, but at least Simon 1 and 2 use 18 bits */
+                fseek(input, 16, SEEK_CUR);
+                fmtHeaderSize = readUint32LE(input);
+
+                fseek(input, 2, SEEK_CUR);
+                numChannels = readUint16LE(input);
+                sampleRate = readUint32LE(input);
+
+                fseek(input, 6, SEEK_CUR);
+                bitsPerSample = readUint16LE(input);
+
+                /* The size of the raw audio is 4 bytes after SEEK_CUR 
+                 * plus the difference between fmtHeaderSizer and 
+                 * the standard size of 16 bytes.
+                 */
+                fseek(input, fmtHeaderSize - 12, SEEK_CUR);
+                rawLength = readUint32LE(input);
+
+                rawData = (char *)malloc(rawLength);
+                fread(rawData, 1, rawLength, input);
+
+                printf(" - length = %d\n", rawLength);
+                printf(" - channels = %d\n", numChannels);
+                printf(" - sample rate = %d\n", sampleRate);
+                printf(" - compression = %dbits\n", bitsPerSample);
+
+                setRawAudioType(true, numChannels == 2, bitsPerSample);
+                encodeRaw(rawData, rawLength, sampleRate, tempEncoded, compMode);
+
+                free(rawData);
+        } else {
+                FILE *f;
+                char fbuf[2048];
+                size_t size;
+
+                /* Copy the WAV data to a temporary file */
+                f = fopen(outName, "wb");
+                while (length > 0) {
+                        size = fread(fbuf, 1, length > sizeof(fbuf) ? sizeof(fbuf) : length, input);
+                        if (size <= 0)
+                                break;
+                        length -= (int)size;
+                        fwrite(fbuf, 1, size, f);
+                }
+                fclose(f);
+
+                /* Convert the WAV temp file to OGG/MP3 */
+                encodeAudio(outName, false, -1, tempEncoded, compMode);
         }
-        fclose(f);
-
-        /* Convert the WAV temp file to OGG/MP3 */
-        encodeAudio(outName, false, -1, tempEncoded, compMode);
 }
 
 void extractAndEncodeVOC(const char *outName, FILE *input, CompressMode compMode) {
@@ -261 +569 @@
                 length = fgetc(input);
                 length |= fgetc(input) << 8;
                 length |= fgetc(input) << 16;
+
                 if (blocktype == 1) {
                         length -= 2;
                         sample_rate = fgetc(input);
@@ -287 +596 @@
                                   (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 +617 @@
 
         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 +631 @@
                         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 +695 @@
                         break;
                 }
         }
+
         if (i != (argc - 1)) {
                 return 0;
         }
+
         return 1;
 }
 
@@ -368 +707 @@
         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 +768 @@
                 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"
@@ -150 +150 @@
 
 GameDescription *currentGameDescription = NULL;
 GameFileDescription *currentFileDescription = NULL;
-bool isSigned = true;
 
 uint16 sampleRate;
 uint32 sampleSize;
@@ -194 +193 @@
         uint32 size;
         char fbuf[2048];
         FILE * tempf;
-        
+
         tempf = fopen(fromFileName, "rb");
         if (tempf == NULL)
                 error("Unable to open %s", fromFileName);
@@ -211 +210 @@
         uint32 size;
         char fbuf[2048];
         FILE * tempf;
-        
+
         tempf = fopen(toFileName, "wb");
         if (tempf == NULL)
                 error("Unable to open %s", toFileName);
@@ -228 +227 @@
 
 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 +247 @@
         Common::File inputFileStream(inputFile);
         int rate, size;
         byte flags;
-        
+
         if (currentFileDescription->resourceType == kSoundVOC) {
                 inputData = Audio::loadVOCFromStream(inputFileStream, size, rate);
                 sampleSize = size;
@@ -259 +258 @@
                 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 +270 @@
                 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 +286 @@
 
                 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 +301 @@
                 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 +347 @@
                 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 +364 @@
         }
 
                  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 +373 @@
         }
         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 +390 @@
                 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 +405 @@
 }
 
 void showhelp(char *exename) {
-        printf("\nUsage: %s <params> [<file> | mac]\n", exename);
+        printf("\nUsage: %s <params> <file>\n", exename);
 
         printf("\nParams:\n");
 
@@ -432 +431 @@
         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");
 
@@ -501 +504 @@
                                 // Check for MacBinary
                                 sprintf(inputFileNameWithExt, "%s.bin", inputFileName);
                                 if (detectFile(inputFileNameWithExt)) {
-                                        isSigned = false;
                                         sagaEncode(inputFileName);
                                 }
                         }

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] [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);
@@ -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, '.');

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 },
@@ -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

@@ -161 +161 @@
         printf("\nUsage: %s <params> input_directory\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

@@ -84 +84 @@
                 for compressed sounds in I have no mouth yet.
 
         compress_sword1
-                Used to compress Broken Sword 1's music and speech files to
-                MP3 or Vorbis or FLAC.
+                Used to compress Broken Sword 1's music and speech .clu
+                files to .cl3 (MP3), .clg (Vorbis) or .clf (FLAC).
 
+                Please note that FLAC compression will produce a larger file
+                than the original! This is because the original files already
+                use lossy compression.
+
         compress_sword2
                 Used to compress Broken Sword 2's music and speech .clu
                 files to .cl3 (MP3), .clg (Vorbis) or .clf (FLAC).
@@ -98 +102 @@
         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.
+                TOUCHE.SO3 (MP3), TOUCHE.SOG (Vorbis), or TOUCHE.SOF (FLAC).
+                
+                Once compressed, only TOUCHE.DAT and TOUCHE.SOx files are
 
-        compress_scumm_san <inputfile> <inputdir> <outputdir> [--ogg]
+        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.
 
-                Example of usage:
-                compress_scumm_san opening.san uncomp comp
-
                 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).
@@ -124 +125 @@
                 move the '.san' files before compressing them, make sure to
                 move the '.flu' files, too!
 
-        compress_scumm_bun <inputfile> <inputdir> <outputdir> [--ogg]
+        compress_scumm_bun
 
                 Compresses '.bun' music/voice files.
 
-                Example of usage:
-                compress_scumm.bun digmusic.bun uncomp comp
-
                 For the Ogg or MP3 compression feature, your ScummVM binary
                 naturally must have been built with Ogg or MP3 support enabled.
 
@@ -138 +136 @@
                 Used to compress The Legend of Kyrandia's speech files with
                 MP3, Vorbis or FLAC.
 
-                Example of usage:
-                compress_kyra <flags here> input/GEMCUT.VRM output/GEMCUT.VRM
-
                 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.
-
 Script Tools:
         descumm
                 Decompiles SCUMM scripts