/**
* @brief Create a new stream with a variadic list of options.
*
* @param codec The name of the codec.
* @param stream_type Stream type.
* @param options List of key/value option pairs, followed by *NULL*
* @return A new stream, or *NULL* on failure.
*/
SquashStream*
squash_stream_newv (SquashCodec* codec,
SquashStreamType stream_type,
va_list options) {
SquashOptions* opts;
assert (codec != NULL);
opts = squash_options_newv (codec, options);
return squash_stream_new_with_options (codec, stream_type, opts);
}
/**
* @brief Open an existing stdio file using a codec instance
*
* @param fp the stdio file to use
* @param codec codec to use
* @param ... options
* @return The opened file, or *NULL* on error
* @see squash_file_steal_codec
* @see squash_file_steal_with_options
* @see squash_file_steal_codec_with_options
*/
SquashFile*
squash_file_steal_codec (SquashCodec* codec, FILE* fp, ...) {
va_list ap;
SquashOptions* options;
assert (fp != NULL);
assert (codec != NULL);
va_start (ap, fp);
options = squash_options_newv (codec, ap);
va_end (ap);
return squash_file_steal_codec_with_options (codec, fp, options);
}
/**
* @brief Create a new stream with existing @ref SquashOptions
*
* @param codec The codec
* @param stream_type The direction of the stream
* @param ... A variadic list of key/value option pairs, followed by
* *NULL*
* @return A new stream, or *NULL* on failure
*/
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);
}
/**
* @brief Open a file using a codec instance
*
* @param filename name of the file to open
* @param mode file mode
* @param codec codec to use
* @param ... options
* @return The opened file, or *NULL* on error
* @see squash_file_open
*/
SquashFile*
squash_file_open_codec (SquashCodec* codec, const char* filename, const char* mode, ...) {
va_list ap;
SquashOptions* options;
assert (filename != NULL);
assert (mode != NULL);
assert (codec != NULL);
va_start (ap, mode);
options = squash_options_newv (codec, ap);
va_end (ap);
return squash_file_open_codec_with_options (codec, filename, mode, options);
}
/**
* @brief Open an existing stdio file
*
* Note that Squash expects to have exclusive access to @a fp. When
* possible, Squash will acquire @a fp's lock (using flockfile) in
* this function and will not release it until the @ref SquashFile
* instance is destroyed.
*
* @param fp the stdio file to use
* @param codec codec to use
* @param ... options
* @return The opened file, or *NULL* on error
* @see squash_file_steal_codec
* @see squash_file_steal_with_options
* @see squash_file_steal_codec_with_options
*/
SquashFile*
squash_file_steal (const char* codec, FILE* fp, ...) {
va_list ap;
SquashOptions* options;
assert (fp != NULL);
assert (codec != NULL);
SquashCodec* codec_i = squash_get_codec (codec);
if (codec_i == NULL)
return NULL;
va_start (ap, fp);
options = squash_options_newv (codec_i, ap);
va_end (ap);
return squash_file_steal_codec_with_options (codec_i, fp, options);
}
/**
* @brief Compress a buffer
*
* @param codec The codec to use
* @param[out] compressed Location to store the compressed data
* @param[in,out] compressed_length Location storing the size of the
* @a compressed buffer on input, replaced with the actual size of
* the compressed data
* @param uncompressed The uncompressed data
* @param uncompressed_length Length of the uncompressed data (in bytes)
* @param ... A variadic list of key/value option pairs, followed by
* *NULL*
* @return A status code
*/
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);
}
/**
* @brief Decompress a buffer with an existing @ref SquashOptions
*
* @param codec The name of the codec to use
* @param[out] decompressed Location to store the decompressed data
* @param[in,out] decompressed_length Location storing the size of the
* @a decompressed buffer on input, replaced with the actual size of
* the decompressed data
* @param compressed The compressed data
* @param compressed_length Length of the compressed data (in bytes)
* @param ... A variadic list of key/value option pairs, followed by
* *NULL*
* @return A status code
*/
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);
}
