C++ (Cpp) squash_codec_get_option_size_index Examples

Example #1

File: squash-yalz77.cpp Project: Bulat-Ziganshin/squash

static SquashStatus
squash_yalz77_compress_buffer (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) {

  const size_t searchlen = squash_codec_get_option_size_index (codec, options, SQUASH_YALZ77_OPT_SEARCH_LENGTH);
  const size_t blocksize = squash_codec_get_option_size_index (codec, options, SQUASH_YALZ77_OPT_BLOCK_SIZE);

  try {
    lz77::compress_t compress(searchlen, blocksize);
    std::string res = compress.feed(uncompressed, uncompressed + uncompressed_length);

    if (res.size() > *compressed_length)
      return SQUASH_FAILED;

    memcpy(compressed, res.c_str(), res.size());
    *compressed_length = res.size();
    return SQUASH_OK;
  } catch (const std::bad_alloc& e) {
    return SQUASH_MEMORY;
  } catch (...) {
    return SQUASH_FAILED;
  }
}

Example #2

File: squash-csc.cpp Project: Dr-Emann/squash

static SquashStatus
squash_csc_splice (SquashCodec* codec,
                   SquashOptions* options,
                   SquashStreamType stream_type,
                   SquashReadFunc read_cb,
                   SquashWriteFunc write_cb,
                   void* user_data) {
  int csc_res;
  SquashStatus res = SQUASH_OK;
  const struct SquashCscInStream in_stream = {
    { squash_csc_reader },
    user_data,
    read_cb,
    write_cb
  };
  const struct SquashCscOutStream out_stream = {
    { squash_csc_writer },
    user_data,
    read_cb,
    write_cb
  };

  CSCProps props;
  unsigned char props_buf[CSC_PROP_SIZE];

  if (stream_type == SQUASH_STREAM_COMPRESS) {
    CSCEncProps_Init (&props,
                      squash_codec_get_option_size_index (codec, options, SQUASH_CSC_OPT_DICT_SIZE),
                      squash_options_get_int_at (options, codec, SQUASH_CSC_OPT_LEVEL));
    props.DLTFilter = squash_options_get_bool_at (options, codec, SQUASH_CSC_OPT_DELTA_FILTER);
    props.EXEFilter = squash_options_get_bool_at (options, codec, SQUASH_CSC_OPT_EXE_FILTER);
    props.TXTFilter = squash_options_get_bool_at (options, codec, SQUASH_CSC_OPT_TXT_FILTER);

    CSCEnc_WriteProperties (&props, props_buf, 0);
    size_t bytes_written = squash_csc_writer ((void*) &out_stream, props_buf, CSC_PROP_SIZE);
    if (SQUASH_UNLIKELY(bytes_written != CSC_PROP_SIZE))
      return squash_error (SQUASH_FAILED);

    CSCEncHandle comp = CSCEnc_Create (&props, (ISeqOutStream*) &out_stream, (ISzAlloc*) &squash_csc_allocator);
    csc_res = CSCEnc_Encode (comp, (ISeqInStream*) &in_stream, NULL);
    if (SQUASH_UNLIKELY(csc_res != 0)) {
      res = squash_error (SQUASH_FAILED);
    } else {
      csc_res = CSCEnc_Encode_Flush (comp);
      if (SQUASH_UNLIKELY(csc_res != 0)) {
        res = squash_error (SQUASH_FAILED);
      }
    }
    CSCEnc_Destroy (comp);
  } else {
    size_t prop_l = CSC_PROP_SIZE;
    squash_csc_reader ((void*) &in_stream, props_buf, &prop_l);
    if (SQUASH_UNLIKELY(prop_l != CSC_PROP_SIZE))
      return squash_error (SQUASH_FAILED);

    CSCDec_ReadProperties (&props, props_buf);

    CSCDecHandle decomp = CSCDec_Create (&props, (ISeqInStream*) &in_stream, (ISzAlloc*) &squash_csc_allocator);
    csc_res = CSCDec_Decode (decomp, (ISeqOutStream*) &out_stream, NULL);
    if (csc_res != 0) {
      res = squash_error (SQUASH_FAILED);
    }
    CSCDec_Destroy (decomp);
  }

  return res;
}