module LZ4Internal

Public Class Methods

compress(p1, p2, p3) click to toggle source
static VALUE lz4internal_compress(VALUE self, VALUE header, VALUE input, VALUE in_size) {
  return compress_internal(LZ4_compress, header, input, in_size);
}
compressHC(p1, p2, p3) click to toggle source
static VALUE lz4internal_compressHC(VALUE self, VALUE header, VALUE input, VALUE in_size) {
  return compress_internal(LZ4_compressHC, header, input, in_size);
}
compressHC_raw(p1, p2, p3, p4) click to toggle source
static VALUE lz4internal_compressHC_raw(
    VALUE self,
    VALUE _input,
    VALUE _input_size,
    VALUE _output_buffer,
    VALUE _max_output_size)
  {
    return compress_raw_internal(
        LZ4_compressHC_limitedOutput,
        _input,
        _input_size,
        _output_buffer,
        _max_output_size);
}
compress_raw(p1, p2, p3, p4) click to toggle source
static VALUE lz4internal_compress_raw(
    VALUE self,
    VALUE _input,
    VALUE _input_size,
    VALUE _output_buffer,
    VALUE _max_output_size)
  {
    return compress_raw_internal(
        LZ4_compress_limitedOutput,
        _input,
        _input_size,
        _output_buffer,
        _max_output_size);
}
decompress_raw(p1, p2, p3, p4) click to toggle source
static VALUE lz4internal_decompress_raw(
    VALUE self,
    VALUE _input,
    VALUE _input_size,
    VALUE _output_buffer,
    VALUE _max_output_size) {

  const char *src_p;
  int src_size;

  int max_output_size;

  int needs_resize;
  char *buf_p;

  int decomp_size;

  Check_Type(_input, T_STRING);
  src_p = RSTRING_PTR(_input);
  src_size = NUM2INT(_input_size);

  max_output_size = NUM2INT(_max_output_size);

  if (NIL_P(_output_buffer)) {
    needs_resize = 1;
    _output_buffer = rb_str_new(NULL, max_output_size);

  } else {
    needs_resize = 0;
  }

  buf_p = RSTRING_PTR(_output_buffer);
  decomp_size = LZ4_decompress_safe(src_p, buf_p, src_size, max_output_size);

  if (decomp_size > 0 && needs_resize) {
    rb_str_resize(_output_buffer, decomp_size);
  }

  return rb_ary_new3(2, _output_buffer, INT2NUM(decomp_size));
}
uncompress(p1, p2, p3, p4) click to toggle source
static VALUE lz4internal_uncompress(VALUE self, VALUE input, VALUE in_size, VALUE offset, VALUE out_size) {
  const char *src_p;
  int src_size;

  int header_size;

  VALUE result;
  char *buf;
  int buf_size;

  int read_bytes;

  Check_Type(input, T_STRING);
  src_p = RSTRING_PTR(input);
  src_size = NUM2INT(in_size);

  header_size = NUM2INT(offset);
  buf_size = NUM2INT(out_size);

  result = rb_str_new(NULL, buf_size);
  buf = RSTRING_PTR(result);

  read_bytes = LZ4_decompress_safe(src_p + header_size, buf, src_size - header_size, buf_size);
  if (read_bytes < 0) {
    rb_raise(lz4_error, "Compressed data is maybe corrupted.");
  }

  return result;
}