codec.c

/* Copyright (c) 2013-2015 The Squash Authors
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * Authors:
 *   Evan Nemerson <evan@nemerson.com>
 */

#define _POSIX_C_SOURCE 200809L

#include <assert.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <strings.h>

#if !defined(_WIN32)
#include <sys/mman.h>
#endif

#include "internal.h"
#include "tinycthread/source/tinycthread.h"

int
squash_codec_compare (SquashCodec* a, SquashCodec* b) {
  assert (a != NULL);
  assert (b != NULL);

  return strcmp (a->name, b->name);
}

int
squash_codec_extension_compare (SquashCodec* a, SquashCodec* b) {
  assert (a != NULL);
  assert (b != NULL);

  return strcmp (a->extension, b->extension);
}

const char*
squash_codec_get_name (SquashCodec* codec) {
  assert (codec != NULL);

  return codec->name;
}

unsigned int
squash_codec_get_priority (SquashCodec* codec) {
  assert (codec != NULL);

  return codec->priority;
}

SquashPlugin*
squash_codec_get_plugin (SquashCodec* codec) {
  assert (codec != NULL);

  return codec->plugin;
}

SquashStatus
squash_codec_init (SquashCodec* codec) {
  return squash_plugin_init_codec (codec->plugin, codec, &(codec->impl));
}

SquashCodecImpl*
squash_codec_get_impl (SquashCodec* codec) {
  if (codec->initialized != 1) {
    SquashStatus res = squash_plugin_init_codec (codec->plugin, codec, &(codec->impl));
    if (res != SQUASH_OK) {
      return NULL;
    }
  }

  return &(codec->impl);
}

size_t
squash_codec_get_uncompressed_size (SquashCodec* codec,
                                    size_t compressed_length,
                                    const uint8_t compressed[SQUASH_ARRAY_PARAM(compressed_length)]) {
  SquashCodecImpl* impl = NULL;

  assert (codec != NULL);
  assert (compressed_length > 0);
  assert (compressed != NULL);

  impl = squash_codec_get_impl (codec);
  if (impl != NULL && impl->get_uncompressed_size != NULL) {
    return impl->get_uncompressed_size (codec, compressed_length, compressed);
  } else {
    return 0;
  }
}

size_t
squash_get_uncompressed_size (const char* codec,
                              size_t compressed_length,
                              const uint8_t compressed[SQUASH_ARRAY_PARAM(compressed_length)]) {
  assert (codec != NULL);
  assert (compressed_length > 0);
  assert (compressed != NULL);

  SquashCodec* codec_real = squash_get_codec (codec);
  if (codec_real == NULL)
    return 0;

  return squash_codec_get_uncompressed_size (codec_real, compressed_length, compressed);
}

size_t
squash_codec_get_max_compressed_size (SquashCodec* codec, size_t uncompressed_length) {
  SquashCodecImpl* impl = NULL;

  assert (codec != NULL);

  impl = squash_codec_get_impl (codec);
  if (impl != NULL && impl->get_max_compressed_size != NULL) {
    return impl->get_max_compressed_size (codec, uncompressed_length);
  } else {
    return 0;
  }
}

size_t
squash_get_max_compressed_size (const char* codec, size_t uncompressed_length) {
  SquashCodec* codec_real = squash_get_codec (codec);

  if (codec_real == NULL) {
    return 0;
  }

  return squash_codec_get_max_compressed_size (codec_real, uncompressed_length);
}

SquashStream*
squash_codec_create_stream_with_options (SquashCodec* codec, SquashStreamType stream_type, SquashOptions* options) {
  SquashCodecImpl* impl = NULL;

  assert (codec != NULL);
  assert (stream_type == SQUASH_STREAM_COMPRESS || stream_type == SQUASH_STREAM_DECOMPRESS);

  impl = squash_codec_get_impl (codec);
  if (impl == NULL) {
    return NULL;
  }

  if (impl->create_stream != NULL) {
    return impl->create_stream (codec, stream_type, options);
  } else {
    if (impl->process_stream == NULL) {
      return (SquashStream*) squash_buffer_stream_new (codec, stream_type, options);
    } else {
      return NULL;
    }
  }
}

SquashStream*
squash_codec_create_stream (SquashCodec* codec, SquashStreamType stream_type, ...) {
  va_list ap;
  SquashOptions* options;

  assert (codec != NULL);
  assert (stream_type == SQUASH_STREAM_COMPRESS || stream_type == SQUASH_STREAM_DECOMPRESS);

  va_start (ap, stream_type);
  options = squash_options_newv (codec, ap);
  va_end (ap);

  return squash_codec_create_stream_with_options (codec, stream_type, options);
}

SquashStatus
squash_codec_compress_with_options (SquashCodec* codec,
                                    size_t* compressed_length,
                                    uint8_t compressed[SQUASH_ARRAY_PARAM(*compressed_length)],
                                    size_t uncompressed_length,
                                    const uint8_t uncompressed[SQUASH_ARRAY_PARAM(uncompressed_length)],
                                    SquashOptions* options) {
  SquashCodecImpl* impl = NULL;

  assert (codec != NULL);

  assert (compressed != NULL);
  assert (uncompressed != NULL);

  impl = squash_codec_get_impl (codec);
  if (impl == NULL)
    return squash_error (SQUASH_UNABLE_TO_LOAD);

  if (compressed == uncompressed)
    return squash_error (SQUASH_INVALID_BUFFER);

  if (impl->compress_buffer ||
      impl->compress_buffer_unsafe) {
    size_t max_compressed_length = squash_codec_get_max_compressed_size (codec, uncompressed_length);

    if (*compressed_length >= max_compressed_length) {
      if (impl->compress_buffer_unsafe != NULL) {
        return impl->compress_buffer_unsafe (codec,
                                              compressed_length, compressed,
                                              uncompressed_length, uncompressed,
                                              options);
      } else {
        return impl->compress_buffer (codec,
                                       compressed_length, compressed,
                                       uncompressed_length, uncompressed,
                                       options);
      }
    } else if (impl->compress_buffer != NULL) {
      return impl->compress_buffer (codec,
                                     compressed_length, compressed,
                                     uncompressed_length, uncompressed,
                                     options);
    } else {
      SquashStatus status;
      uint8_t* tmp_buf = malloc (max_compressed_length);
      if (tmp_buf == NULL)
        return squash_error (SQUASH_MEMORY);

      status = impl->compress_buffer_unsafe (codec,
                                              &max_compressed_length, tmp_buf,
                                              uncompressed_length, uncompressed,
                                              options);
      if (status == SQUASH_OK) {
        if (*compressed_length < max_compressed_length) {
          *compressed_length = max_compressed_length;
          free (tmp_buf);
          return squash_error (SQUASH_BUFFER_FULL);
        } else {
          *compressed_length = max_compressed_length;
          memcpy (compressed, tmp_buf, max_compressed_length);
          free (tmp_buf);
          return SQUASH_OK;
        }
      } else {
        free (tmp_buf);
        return status;
      }
    }
  } else {
    SquashStatus status;
    SquashStream* stream;

    stream = squash_codec_create_stream_with_options (codec, SQUASH_STREAM_COMPRESS, options);
    if (stream == NULL)
      return squash_error (SQUASH_FAILED);

    stream->next_in = uncompressed;
    stream->avail_in = uncompressed_length;
    stream->next_out = compressed;
    stream->avail_out = *compressed_length;

    do {
      status = squash_stream_process (stream);
    } while (status == SQUASH_PROCESSING);

    if (status != SQUASH_OK) {
      squash_object_unref (stream);
      return status;
    }

    do {
      status = squash_stream_finish (stream);
    } while (status == SQUASH_PROCESSING);

    if (status != SQUASH_OK) {
      squash_object_unref (stream);
      return status;
    }

    *compressed_length = stream->total_out;
    squash_object_unref (stream);
    return status;
  }
}

SquashStatus squash_codec_compress (SquashCodec* codec,
                                    size_t* compressed_length,
                                    uint8_t compressed[SQUASH_ARRAY_PARAM(*compressed_length)],
                                    size_t uncompressed_length,
                                    const uint8_t uncompressed[SQUASH_ARRAY_PARAM(uncompressed_length)],
                                    ...) {
  SquashOptions* options;
  va_list ap;

  assert (codec != NULL);

  va_start (ap, uncompressed);
  options = squash_options_newv (codec, ap);
  va_end (ap);

  return squash_codec_compress_with_options (codec,
                                             compressed_length, compressed,
                                             uncompressed_length, uncompressed,
                                             options);
}

SquashStatus
squash_codec_decompress_with_options (SquashCodec* codec,
                                      size_t* decompressed_length,
                                      uint8_t decompressed[SQUASH_ARRAY_PARAM(*decompressed_length)],
                                      size_t compressed_length,
                                      const uint8_t compressed[SQUASH_ARRAY_PARAM(compressed_length)],
                                      SquashOptions* options) {
  SquashCodecImpl* impl = NULL;

  assert (codec != NULL);

  impl = squash_codec_get_impl (codec);
  if (impl == NULL)
    return squash_error (SQUASH_UNABLE_TO_LOAD);

  if (decompressed == compressed)
    return squash_error (SQUASH_INVALID_BUFFER);

  if (impl->decompress_buffer != NULL) {
    SquashStatus res;
    res = impl->decompress_buffer (codec,
                                   decompressed_length, decompressed,
                                   compressed_length, compressed,
                                   squash_object_ref (options));
    squash_object_unref (options);
    return res;
  } else {
    SquashStatus status;
    SquashStream* stream;

    stream = squash_codec_create_stream_with_options (codec, SQUASH_STREAM_DECOMPRESS, options);
    stream->next_in = compressed;
    stream->avail_in = compressed_length;
    stream->next_out = decompressed;
    stream->avail_out = *decompressed_length;

    do {
      status = squash_stream_process (stream);
    } while (status == SQUASH_PROCESSING);

    if (status == SQUASH_END_OF_STREAM) {
      status = SQUASH_OK;
      *decompressed_length = stream->total_out;
    } else if (status == SQUASH_OK) {
      do {
        status = squash_stream_finish (stream);
      } while (status == SQUASH_PROCESSING);

      if (status == SQUASH_OK) {
        *decompressed_length = stream->total_out;
      }
    }

    assert (stream->stream_type == SQUASH_STREAM_DECOMPRESS);
    squash_object_unref (stream);

    return status;
  }
}

SquashStatus
squash_codec_decompress (SquashCodec* codec,
                         size_t* decompressed_length,
                         uint8_t decompressed[SQUASH_ARRAY_PARAM(*decompressed_length)],
                         size_t compressed_length,
                         const uint8_t compressed[SQUASH_ARRAY_PARAM(compressed_length)],
                         ...) {
  SquashOptions* options;
  va_list ap;
  SquashStatus res;

  assert (codec != NULL);

  va_start (ap, compressed);
  options = squash_options_newv (codec, ap);
  va_end (ap);

  res = squash_codec_decompress_with_options (codec,
                                              decompressed_length, decompressed,
                                              compressed_length, compressed,
                                              options);

  return res;
}

SquashStatus
squash_compress (const char* codec,
                 size_t* compressed_length,
                 uint8_t compressed[SQUASH_ARRAY_PARAM(*compressed_length)],
                 size_t uncompressed_length,
                 const uint8_t uncompressed[SQUASH_ARRAY_PARAM(uncompressed_length)],
                 ...) {
  SquashOptions* options;
  va_list ap;
  SquashCodec* codec_real = squash_get_codec (codec);

  if (codec_real == NULL)
    return squash_error (SQUASH_NOT_FOUND);

  va_start (ap, uncompressed);
  options = squash_options_newv (codec_real, ap);
  va_end (ap);

  return squash_codec_compress_with_options (codec_real,
                                             compressed_length, compressed,
                                             uncompressed_length, uncompressed,
                                             options);
}

SquashStatus
squash_compress_with_options (const char* codec,
                              size_t* compressed_length,
                              uint8_t compressed[SQUASH_ARRAY_PARAM(*compressed_length)],
                              size_t uncompressed_length,
                              const uint8_t uncompressed[SQUASH_ARRAY_PARAM(uncompressed_length)],
                              SquashOptions* options) {
  SquashCodec* codec_real = squash_get_codec (codec);

  if (codec_real == NULL)
    return squash_error (SQUASH_NOT_FOUND);

  return squash_codec_compress_with_options (codec_real,
                                             compressed_length, compressed,
                                             uncompressed_length, uncompressed,
                                             options);
}

SquashStatus
squash_decompress (const char* codec,
                   size_t* decompressed_length,
                   uint8_t decompressed[SQUASH_ARRAY_PARAM(*decompressed_length)],
                   size_t compressed_length,
                   const uint8_t compressed[SQUASH_ARRAY_PARAM(compressed_length)],
                   ...) {
  SquashOptions* options;
  va_list ap;
  SquashCodec* codec_real = squash_get_codec (codec);

  if (codec_real == NULL)
    return squash_error (SQUASH_NOT_FOUND);

  va_start (ap, compressed);
  options = squash_options_newv (codec_real, ap);
  va_end (ap);

  return squash_codec_decompress_with_options (codec_real,
                                            decompressed_length, decompressed,
                                            compressed_length, compressed,
                                            options);
}

SquashStatus squash_decompress_with_options (const char* codec,
                                             size_t* decompressed_length,
                                             uint8_t decompressed[SQUASH_ARRAY_PARAM(*decompressed_length)],
                                             size_t compressed_length,
                                             const uint8_t compressed[SQUASH_ARRAY_PARAM(compressed_length)],
                                             SquashOptions* options) {
  SquashCodec* codec_real = squash_get_codec (codec);

  if (codec_real == NULL)
    return squash_error (SQUASH_NOT_FOUND);

  return squash_codec_decompress_with_options (codec_real,
                                               decompressed_length, decompressed,
                                               compressed_length, compressed,
                                               options);
}

SquashCodec*
squash_codec_new (SquashPlugin* plugin, const char* name) {
  SquashCodec* codecp = (SquashCodec*) malloc (sizeof (SquashCodec));
  SquashCodec codec = { 0, };

  codec.plugin = plugin;
  codec.name = strdup (name);
  codec.priority = 50;
  SQUASH_TREE_ENTRY_INIT(codec.tree);

  *codecp = codec;

  /* squash_plugin_add_codec (plugin, codecp); */

  return codecp;
}

void
squash_codec_set_extension (SquashCodec* codec, const char* extension) {
  if (codec->extension != NULL)
    free (codec->extension);

  codec->extension = (extension != NULL) ? strdup (extension) : NULL;
}

const char*
squash_codec_get_extension (SquashCodec* codec) {
  return codec->extension;
}

void
squash_codec_set_priority (SquashCodec* codec, unsigned int priority) {
  codec->priority = priority;
}

SquashCodecInfo
squash_codec_get_info (SquashCodec* codec) {
  return codec->impl.info;
}

SquashCodecInfo
squash_get_info (const char* codec) {
  SquashCodec* codec_real = squash_get_codec (codec);

  if (codec_real != NULL) {
    return squash_codec_get_info (codec_real);
  } else {
    squash_error (SQUASH_NOT_FOUND);
    return SQUASH_CODEC_INFO_INVALID;
  }
}

const SquashOptionInfo*
squash_codec_get_option_info (SquashCodec* codec) {
  SquashCodecImpl* impl = squash_codec_get_impl (codec);
  return SQUASH_LIKELY(impl != NULL) ? impl->options : NULL;
}

const SquashOptionInfo*
squash_get_option_info (const char* codec) {
  SquashCodec* codec_real = squash_get_codec (codec);

  if (codec_real != NULL)
    return squash_codec_get_option_info (codec_real);
  else
    return NULL;
}

static const SquashOptionValue*
squash_codec_get_option_value_by_name (SquashCodec* codec,
                                       SquashOptions* options,
                                       const char* key,
                                       SquashOptionType* type) {
  size_t c_option;
  const SquashOptionInfo* info;

  assert (codec != NULL);
  assert (key != NULL);

  info = squash_codec_get_option_info (codec);
  for (c_option = 0 ; info[c_option].name != NULL ; c_option++) {
    if (strcasecmp (key, info[c_option].name) == 0) {
      if (type != NULL)
        *type = info[c_option].type;
      return (options != NULL) ?
        &(options->values[c_option]) :
        &(info[c_option].default_value);
    }
  }

  if (type != NULL)
    *type = SQUASH_OPTION_TYPE_NONE;
  return NULL;
}

const char*
squash_codec_get_option_string (SquashCodec* codec,
                                SquashOptions* options,
                                const char* key) {
  SquashOptionType type;
  const SquashOptionValue* value = squash_codec_get_option_value_by_name (codec, options, key, &type);
  switch ((int) type) {
    case SQUASH_OPTION_TYPE_STRING:
      return value->string_value;
    default:
      squash_assert_unreachable();
  }
}

const char*
squash_codec_get_option_string_index (SquashCodec* codec,
                                      SquashOptions* options,
                                      size_t index) {
  if (options != NULL)
    return options->values[index].string_value;
  else
    return codec->impl.options[index].default_value.string_value;
}

bool
squash_codec_get_option_bool (SquashCodec* codec,
                              SquashOptions* options,
                              const char* key) {
  SquashOptionType type;
  const SquashOptionValue* value = squash_codec_get_option_value_by_name (codec, options, key, &type);
  switch ((int) type) {
    case SQUASH_OPTION_TYPE_BOOL:
      return value->bool_value;
    default:
      squash_assert_unreachable();
  }
}

bool
squash_codec_get_option_bool_index (SquashCodec* codec,
                                    SquashOptions* options,
                                    size_t index) {
  if (options != NULL)
    return options->values[index].bool_value;
  else
    return codec->impl.options[index].default_value.bool_value;
}

int
squash_codec_get_option_int (SquashCodec* codec,
                             SquashOptions* options,
                             const char* key) {
  SquashOptionType type;
  const SquashOptionValue* value = squash_codec_get_option_value_by_name (codec, options, key, &type);
  switch ((int) type) {
    case SQUASH_OPTION_TYPE_INT:
    case SQUASH_OPTION_TYPE_RANGE_INT:
    case SQUASH_OPTION_TYPE_ENUM_STRING:
      return value->int_value;
    default:
      squash_assert_unreachable();
  }
}

int
squash_codec_get_option_int_index (SquashCodec* codec,
                                   SquashOptions* options,
                                   size_t index) {
  if (options != NULL)
    return options->values[index].int_value;
  else
    return codec->impl.options[index].default_value.int_value;
}

size_t
squash_codec_get_option_size (SquashCodec* codec,
                              SquashOptions* options,
                              const char* key) {
  SquashOptionType type;
  const SquashOptionValue* value = squash_codec_get_option_value_by_name (codec, options, key, &type);
  switch ((int) type) {
    case SQUASH_OPTION_TYPE_SIZE:
    case SQUASH_OPTION_TYPE_RANGE_SIZE:
      return value->size_value;
    default:
      squash_assert_unreachable();
  }
}

size_t
squash_codec_get_option_size_index (SquashCodec* codec,
                                    SquashOptions* options,
                                    size_t index) {
  if (options != NULL)
    return options->values[index].size_value;
  else
    return codec->impl.options[index].default_value.size_value;
}