addons/LZO/source/IoLZOEncoder.c

   1 //metadoc LZOEncoder copyright Steve Dekorte, 2004
   2 //metadoc LZOEncoder license BSD revised
   3 //metadoc LZOEncoder category Compression
   4 /*metadoc LZOEncoder description
   5 ""The LZO object can be used to Z compress and uncompress data.
   6 Example use;
   7 <code>
   8 bf = LZO clone
   9 bf beginProcessing
  10 bf inputBuffer appendSeq("this is a message")
  11 bf process
  12 bf endProcess
  13 bf outputBuffer // this contains the encoded data
  14 </code>
  15 */
  16
  17 #include "IoLZOEncoder.h"
  18 #include "IoState.h"
  19 #include "IoNumber.h"
  20 #include "IoSeq.h"
  21
  22 #define DATA(self) ((IoLZOData *)(IoObject_dataPointer(self)))
  23
  24 IoTag *IoLZOEncoder_newTag(void *state)
  25 {
  26         IoTag *tag = IoTag_newWithName_("LZOEncoder");
  27         IoTag_state_(tag, state);
  28         IoTag_freeFunc_(tag, (IoTagFreeFunc *)IoLZOEncoder_free);
  29         IoTag_cloneFunc_(tag, (IoTagCloneFunc *)IoLZOEncoder_rawClone);
  30         return tag;
  31 }
  32
  33 IoLZOEncoder *IoLZOEncoder_proto(void *state)
  34 {
  35         IoLZOEncoder *self = IoObject_new(state);
  36         IoObject_tag_(self, IoLZOEncoder_newTag(state));
  37
  38         IoObject_setDataPointer_(self, calloc(1, sizeof(IoLZOData)));
  39
  40         IoState_registerProtoWithFunc_(state, self, IoLZOEncoder_proto);
  41
  42         {
  43                 IoMethodTable methodTable[] = {
  44                 {"beginProcessing", IoLZOEncoder_beginProcessing},
  45                 {"process", IoLZOEncoder_process},
  46                 {"endProcessing", IoLZOEncoder_endProcessing},
  47                 {NULL, NULL},
  48                 };
  49                 IoObject_addMethodTable_(self, methodTable);
  50         }
  51
  52         return self;
  53 }
  54
  55 IoLZOEncoder *IoLZOEncoder_rawClone(IoLZOEncoder *proto)
  56 {
  57         IoObject *self = IoObject_rawClonePrimitive(proto);
  58         IoObject_setDataPointer_(self, calloc(1, sizeof(IoLZOData)));
  59         return self;
  60 }
  61
  62 IoLZOEncoder *IoLZOEncoder_new(void *state)
  63 {
  64         IoObject *proto = IoState_protoWithInitFunction_(state, IoLZOEncoder_proto);
  65         return IOCLONE(proto);
  66 }
  67
  68 void IoLZOEncoder_free(IoLZOEncoder *self)
  69 {
  70         free(DATA(self));
  71 }
  72
  73 // ----------------------------------------------------------- *
  74
  75 IoObject *IoLZOEncoder_beginProcessing(IoLZOEncoder *self, IoObject *locals, IoMessage *m)
  76 {
  77         /*doc LZOEncoder beginProcessing
  78         Initializes the algorithm.
  79         */
  80
  81         IOASSERT(lzo_init() == LZO_E_OK,  "Failed to init lzo");
  82         DATA(self)->isDone = 0;
  83         return self;
  84 }
  85
  86 IoObject *IoLZOEncoder_endProcessing(IoLZOEncoder *self, IoObject *locals, IoMessage *m)
  87 {
  88         /*doc LZOEncoder endProcessing
  89         Finish processing remaining bytes of inputBuffer.
  90         */
  91
  92         IoLZOEncoder_process(self, locals, m); // process the full blocks first
  93         DATA(self)->isDone = 1;
  94         return self;
  95 }
  96
  97 // --------------------------------------------------------------------
  98
  99 IoObject *IoLZOEncoder_process(IoLZOEncoder *self, IoObject *locals, IoMessage *m)
 100 {
 101         /*doc LZOEncoder process
 102         Process the inputBuffer and appends the result to the outputBuffer.
 103         The processed inputBuffer is empties except for the spare bytes at
 104         the end which don't fit into a cipher block.
 105         */
 106
 107         lzo_align_t __LZO_MMODEL *wrkmem = DATA(self)->wrkmem;
 108
 109         UArray *input  = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("inputBuffer"));
 110         UArray *output = IoObject_rawGetMutableUArraySlot(self, locals, m, IOSYMBOL("outputBuffer"));
 111
 112         unsigned char *inputBytes  = (uint8_t *)UArray_bytes(input);
 113         size_t inputSize           = UArray_sizeInBytes(input);
 114
 115         if (inputSize)
 116         {
 117                 int r;
 118                 size_t oldOutputSize   = UArray_size(output);
 119                 lzo_uint outputRoom    = (inputSize + inputSize / 64 + 16 + 3);
 120                 unsigned char *outputBytes;
 121
 122                 UArray_setSize_(output, oldOutputSize + outputRoom);
 123                 outputBytes = (uint8_t *)UArray_bytes(output) + oldOutputSize;
 124
 125                 r = lzo1x_1_compress(inputBytes, inputSize, outputBytes, &outputRoom, wrkmem);
 126                 //      r = lzo1x_decompress(in, in_len, out, &out_len, wrkmem);
 127
 128                 if (r != LZO_E_OK)
 129                 {
 130                         IoState_error_(IOSTATE,  m, "LZO compression failed: %d", r);
 131                 }
 132
 133
 134                 UArray_setSize_(output, oldOutputSize + outputRoom);
 135                 UArray_setSize_(input, 0);
 136         }
 137
 138         return self;
 139 }