archivelib-sys 0.2.0

An implementaton(in C++) of the Greenleaf ArchiveLib compression/decompression algorithm
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111


#include <cstdlib>
#include <cstring>
#include <sstream>
#include <string>

#include "api.h"
#include "grenengn.h"
#include "memstore.h"
#include "enum_rev.hpp"

#ifndef CREATE_BUFFER
#define CREATE_BUFFER(buf_name, name, input_buffer, length)                    \

  ALMemory *buf_name =                                                         \
      new ALMemory(name.c_str(), (char *)input_buffer, length, AL_MIXED);      \
  buf_name->Create();                                                          \
  CHECK_AL_STATUS(buf_name->mStatus);
#endif

AllocatedMemory _build_error(int status, std::string data) {
  size_t len = data.length() + 1;
  uint8_t *raw_data = NULL;
  if (len > 1) {
    raw_data = (uint8_t *)calloc(len, sizeof(char));
    memcpy(raw_data, data.c_str(), len);
  }
  AllocatedMemory m = {};
  m.status = status;
  m.data = raw_data;
  m.length = len;
  return m;
}

AllocatedMemory build_error_from_status_code(int status) {
  std::stringstream stream;
  stream << reverseALErrors(status) << " (" << status << ")";
  return _build_error(status, stream.str());
}

AllocatedMemory build_error_from_status_obj(ALStatus *status) {
  std::stringstream stream;
  stream << reverseALErrors(status->GetStatusCode()) << " (" << status << ") ";
  stream << status->GetStatusDetail();
  return _build_error(status->GetStatusCode(), stream.str());
}

AllocatedMemory build_output(ALStorage *out) {
  out->FlushBuffer();
  CHECK_AL_STATUS(out->mStatus);
  out->Seek(0);
  CHECK_AL_STATUS(out->mStatus);

  size_t data_len = out->GetSize();
  uint8_t *data = (uint8_t *)calloc(data_len, sizeof(char));
  size_t actual_len = out->ReadBuffer((unsigned char *)data, data_len);
  out->Close();
  if (out->mStatus.GetStatusCode() != AL_SUCCESS) {
    delete out;
    free(data);
    return build_error_from_status_obj(&out->mStatus);
  }
  delete out;
  if (data_len != actual_len) {
    data = (uint8_t *)realloc(data, actual_len);
  }

  AllocatedMemory m = {};
  m.status = 0;
  m.data = data;
  m.length = actual_len;
  return m;
}

extern "C" AllocatedMemory compress(uint8_t *input_buffer, size_t length, uint8_t compression_level) {
  std::string name = "compress";
  CREATE_BUFFER(in, name, input_buffer, length)
  CREATE_BUFFER(out, name, NULL, 0)

  // Default is AL_GREENLEAF_LEVEL_0
  ALGreenleafEngine *engn = new ALGreenleafEngine(compression_level , false);
  engn->Compress(*in, *out);
  CHECK_AL_STATUS(engn->mStatus);
  delete engn;
  in->Close();
  CHECK_AL_STATUS(in->mStatus);
  delete in;

  return build_output(out);
}
extern "C" AllocatedMemory decompress(uint8_t *input_buffer, size_t length, uint8_t compression_level) {
  std::string name = "decompress";
  CREATE_BUFFER(in, name, input_buffer, length)
  CREATE_BUFFER(out, name, NULL, 0)

    // Default is AL_GREENLEAF_LEVEL_0
  ALGreenleafEngine *engn = new ALGreenleafEngine(compression_level, false);
  engn->Decompress(*in, *out);
  CHECK_AL_STATUS(engn->mStatus);
  delete engn;
  in->Close();
  CHECK_AL_STATUS(in->mStatus);
  delete in;

  return build_output(out);
}
extern "C" void clean(AllocatedMemory *memory) {
  if (memory->data) {
    free(memory->data);
    memory->data = NULL;
  }
}