root/trunk/contrib/extractor/libmpq/extract.cpp @ 279

/*
 *  extract.c -- global extracting function for all known file compressions
 *               in a MPQ archive.
 *
 *  Copyright (C) 2003 Maik Broemme <mbroemme@plusserver.de>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

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

#define HAVE_LIBZ
#ifdef HAVE_LIBZ
#include <zlib.h>
#endif

#include "mpq.h"
#include "explode.h"
#include "huffman.h"

#include "wave.h"

/*
 *  Support functions for PKWARE data compression library.
 *
 *  Function loads data from the input buffer. Used by mpq_pkzip
 *  "implode" and "explode" function as user-defined callback.
 *  Returns number of bytes loaded.
 *
 *  char * buf          - Pointer to a buffer where to store loaded data
 *  unsigned int * size - Max. number of bytes to read
 *  void * param        - Custom pointer, parameter of implode/explode
 */
static unsigned int libmpq_pkzip_read_input_data(char *buf, unsigned int *size, void *param) {
        pkzip_data *info = (pkzip_data *)param;
        unsigned int max_avail = (info->in_bytes - info->in_pos);
        unsigned int to_read = *size;

        /* Check the case when not enough data available */
        if (to_read > max_avail) {
                to_read = max_avail;
        }

        /* Load data and increment offsets */
        memcpy(buf, info->in_buf + info->in_pos, to_read);
        info->in_pos += to_read;

        return to_read;
}

/*
 *  Support functions for PKWARE data compression library.
 *
 *  Function for store output data. Used by mpq_pkzip "implode" and
 *  "explode" as user-defined callback.
 *
 *  char * buf          - Pointer to data to be written
 *  unsigned int * size - Number of bytes to write
 *  void * param        - Custom pointer, parameter of implode/explode
 */
static void libmpq_pkzip_write_output_data(char *buf, unsigned int *size, void *param) {
        pkzip_data *info = (pkzip_data *)param;
        unsigned int max_write = (info->max_out - info->out_pos);
        unsigned int to_write = *size;

        /* Check the case when not enough space in the output buffer */
        if (to_write > max_write) {
                to_write = max_write;
        }

        /* Write output data and increments offsets */
        memcpy(info->out_buf + info->out_pos, buf, to_write);
        info->out_pos += to_write;
}

int libmpq_pkzip_decompress(char *out_buf, int *out_length, char *in_buf, int in_length) {
        pkzip_data info;                                        /* Data information */
        char *work_buf = (char *)malloc(LIBMPQ_PKZIP_EXP_BUFFER_SIZE);  /* mpq_pkzip work buffer */

        /* Fill data information structure */
        info.in_buf   = in_buf;
        info.in_pos   = 0;
        info.in_bytes = in_length;
        info.out_buf  = out_buf;
        info.out_pos  = 0;
        info.max_out  = *out_length;

        /* Do the decompression */
        libmpq_pkzip_explode(libmpq_pkzip_read_input_data, libmpq_pkzip_write_output_data, work_buf, &info);
        *out_length = info.out_pos;
        free(work_buf);
        return 0;
}

int libmpq_wave_decompress_mono(char *out_buf, int *out_length, char *in_buf, int in_length) {
        *out_length = libmpq_wave_decompress((unsigned char *)out_buf, *out_length, (unsigned char *)in_buf, in_length, 1);
        return 1;
}

int libmpq_wave_decompress_stereo(char *out_buf, int *out_length, char *in_buf, int in_length) {
        *out_length = libmpq_wave_decompress((unsigned char *)out_buf, *out_length, (unsigned char *)in_buf, in_length, 2);
        return 1;
}

int libmpq_zlib_decompress(char *out_buf, int *out_length, char *in_buf, int in_length) {
#ifdef HAVE_LIBZ
        z_stream z;                                     /* Stream information for zlib */
        int result;

        /* Fill the stream structure for zlib */
        z.next_in   = (Bytef *)in_buf;
        z.avail_in  = (uInt)in_length;
        z.total_in  = in_length;
        z.next_out  = (Bytef *)out_buf;
        z.avail_out = *out_length;
        z.total_out = 0;
        z.zalloc    = NULL;
        z.zfree     = NULL;

        /* Initialize the decompression structure. Storm.dll uses zlib version 1.1.3 */
        if ((result = inflateInit(&z)) == 0) {

                /* Call zlib to decompress the data */
                result = inflate(&z, Z_FINISH);
                *out_length = z.total_out;
                inflateEnd(&z);
        }
        return result;
#else
        memset(out_buf, '0', *out_length);
        return 0;
#endif
}

/*
 *  Huffmann decompression routine. The in_length parameter is not used, but needs
 *  to be specified due to compatibility reasons.
 *
 *  1500F5F0
 */
int libmpq_huff_decompress(char *out_buf, int *out_length, char *in_buf, int in_length) {
        struct huffman_tree             *ht = (huffman_tree *)malloc(sizeof(struct huffman_tree));
        struct huffman_input_stream     *is = (huffman_input_stream *)malloc(sizeof(struct huffman_input_stream));
        struct huffman_tree_item        *hi = (huffman_tree_item *)malloc(sizeof(struct huffman_tree_item));
        memset(ht, 0, sizeof(struct huffman_tree));
        memset(is, 0, sizeof(struct huffman_input_stream));
        memset(hi, 0, sizeof(struct huffman_tree_item));

        /* Initialize input stream */
        is->bit_buf  = *(unsigned long *)in_buf;
        in_buf      += sizeof(unsigned long);
        is->in_buf   = (unsigned char *)in_buf;
        is->bits     = 32;

        /* Initialize the Huffmann tree for decompression */
        libmpq_huff_init_tree(ht, hi, LIBMPQ_HUFF_DECOMPRESS);

        *out_length = libmpq_huff_do_decompress(ht, is, (unsigned char *)out_buf, *out_length);

        free(hi);
        free(is);
        free(ht);
        return 0;
}

int libmpq_multi_decompress(char *out_buf, int *pout_length, char *in_buf, int in_length) {
        char            *temp_buf = NULL;               /* Temporary storage for decompressed data */
        char            *work_buf = NULL;               /* Where to store decompressed data */
        int             out_length = *pout_length;      /* For storage number of output bytes */
        unsigned        fDecompressions1;               /* Decompressions applied to the block */
        unsigned        fDecompressions2;               /* Just another copy of decompressions applied to the block */
        int             count = 0;                      /* Counter for every use */
        int             entries = (sizeof(dcmp_table) / sizeof(decompress_table));
        int             i;

        /* If the input length is the same as output, do nothing. */
        if (in_length == out_length) {
                if (in_buf == out_buf) {
                        return 1;
                }
                memcpy(out_buf, in_buf, in_length);
                return 1;
        }

        /* Get applied compression types and decrement data length */
        fDecompressions1 = fDecompressions2 = (unsigned char)*in_buf++;
        in_length--;

        /* Search decompression table type and get all types of compression */
        for (i = 0; i < entries; i++) {
                /* We have to apply this decompression? */
                if (fDecompressions1 & dcmp_table[i].mask) {
                        count++;
                }

                /* Clear this flag from temporary variable. */
                fDecompressions2 &= ~dcmp_table[i].mask;
        }

        /*
         *  Check if there is some method unhandled
         *  (E.g. compressed by future versions)
         */
        if (fDecompressions2 != 0) {
                printf("Unknown Compression\n");
                return 0;
        }

        /* If there is more than only one compression, we have to allocate extra buffer */
        if (count >= 2) {
                temp_buf = (char *)malloc(out_length);
        }

        /* Apply all decompressions */
        for (i = 0, count = 0; i < entries; i++) {

                /* If not used this kind of compression, skip the loop */
                if (fDecompressions1 & dcmp_table[i].mask) {

                        /* If odd case, use target buffer for output, otherwise use allocated tempbuf */
                        work_buf = (count++ & 1) ? temp_buf : out_buf;
                        out_length = *pout_length;

                        /* Decompress buffer using corresponding function */
                        dcmp_table[i].decompress(work_buf, &out_length, in_buf, in_length);

                        /* Move output length to src length for next compression */
                        in_length = out_length;
                        in_buf = work_buf;
                }
        }

        /* If output buffer is not the same like target buffer, we have to copy data */
        if (work_buf != out_buf) {
                memcpy(out_buf, in_buf, out_length);
        }
        *pout_length = out_length;

        /* Delete temporary buffer, if necessary */
        if (temp_buf != NULL) {
                free(temp_buf);
        }
        return 1;
}