nanocoat/lib/base/streamInflate.c

   1 /* -*- Mode: C; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the Mozilla Public License Version 2.0.
   7 // See license.mkd for licensing and copyright information.
   8 // -------------------------------------------------------------------------*/
   9
  10 #include <string.h>
  11
  12 #include "sjme/stream.h"
  13 #include "sjme/alloc.h"
  14 #include "sjme/util.h"
  15 #include "sjme/inflate.h"
  16
  17 /**
  18  * Inflation initializer state.
  19  *
  20  * @since 2024/08/30
  21  */
  22 typedef struct sjme_stream_inflateInit
  23 {
  24         /** First handle. */
  25         sjme_pointer handle;
  26 } sjme_stream_inflateInit;
  27
  28 static sjme_errorCode sjme_stream_inputInflateClose(
  29         sjme_attrInNotNull sjme_stream_input stream,
  30         sjme_attrInNotNull sjme_stream_implState* inImplState)
  31 {
  32         sjme_errorCode error;
  33         sjme_inflate* state;
  34
  35         if (stream == NULL || inImplState == NULL)
  36                 return SJME_ERROR_NULL_ARGUMENTS;
  37
  38         /* Do nothing if already closed. */
  39         state = inImplState->handle;
  40         if (state == NULL)
  41                 return SJME_ERROR_NONE;
  42
  43         /* Destroy it. */
  44         if (sjme_error_is(error = sjme_inflate_destroy(state)))
  45                 return sjme_error_default(error);
  46
  47         /* The state is now not valid. */
  48         inImplState->handle = NULL;
  49
  50         /* Success! */
  51         return SJME_ERROR_NONE;
  52 }
  53
  54 static sjme_errorCode sjme_stream_inputInflateInit(
  55         sjme_attrInNotNull sjme_stream_input stream,
  56         sjme_attrInNotNull sjme_stream_implState* inImplState,
  57         sjme_attrInNullable sjme_pointer data)
  58 {
  59         sjme_stream_inflateInit* init;
  60
  61         init = data;
  62         if (stream == NULL || inImplState == NULL || init == NULL)
  63                 return SJME_ERROR_NULL_ARGUMENTS;
  64
  65         /* Set data. */
  66         inImplState->handle = init->handle;
  67
  68         /* Success! */
  69         return SJME_ERROR_NONE;
  70 }
  71
  72 static sjme_errorCode sjme_stream_inputInflateRead(
  73         sjme_attrInNotNull sjme_stream_input stream,
  74         sjme_attrInNotNull sjme_stream_implState* inImplState,
  75         sjme_attrOutNotNull sjme_attrOutNegativeOnePositive sjme_jint* readCount,
  76         sjme_attrOutNotNullBuf(length) sjme_pointer dest,
  77         sjme_attrInPositive sjme_jint length)
  78 {
  79         sjme_errorCode error;
  80         sjme_inflate* inState;
  81         sjme_jint count;
  82
  83         if (stream == NULL || inImplState == NULL || readCount == NULL ||
  84                 dest == NULL)
  85                 return SJME_ERROR_NULL_ARGUMENTS;
  86
  87         if (length < 0)
  88                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
  89
  90         /* Recover state, fail if closed. */
  91         inState = inImplState->handle;
  92         if (inState == NULL)
  93                 return SJME_ERROR_ILLEGAL_STATE;
  94
  95         /* Request inflated data. */
  96         do
  97         {
  98                 count = INT32_MAX;
  99                 if (sjme_error_is(error = sjme_inflate_inflate(inState,
 100                         &count, dest, length)) || count == INT32_MAX)
 101                         return sjme_error_default(error);
 102         } while (count == 0);
 103
 104         /* Success! */
 105         *readCount = count;
 106         return SJME_ERROR_NONE;
 107 }
 108
 109 /** Input deflate functions. */
 110 static const sjme_stream_inputFunctions sjme_stream_inputInflateFunctions =
 111 {
 112         .close = sjme_stream_inputInflateClose,
 113         .init = sjme_stream_inputInflateInit,
 114         .read = sjme_stream_inputInflateRead,
 115 };
 116
 117 sjme_errorCode sjme_stream_inputOpenInflate(
 118         sjme_attrInNotNull sjme_alloc_pool* inPool,
 119         sjme_attrOutNotNull sjme_stream_input* outStream,
 120         sjme_attrInNotNull sjme_stream_input inCompressed)
 121 {
 122         sjme_errorCode error;
 123         sjme_stream_input result;
 124         sjme_stream_inflateInit init;
 125         sjme_inflate* state;
 126
 127         if (inPool == NULL || outStream == NULL || inCompressed == NULL)
 128                 return SJME_ERROR_NULL_ARGUMENTS;
 129
 130         /* Setup decompression state data. */
 131         state = NULL;
 132         if (sjme_error_is(error = sjme_inflate_new(inPool,
 133                 &state, inCompressed)) || state == NULL)
 134                 goto fail_inflateNew;
 135
 136         /* Set initialization data. */
 137         memset(&init, 0, sizeof(init));
 138         init.handle = state;
 139
 140         /* Setup sub-stream. */
 141         result = NULL;
 142         if (sjme_error_is(error = sjme_stream_inputOpen(inPool,
 143                 &result, &sjme_stream_inputInflateFunctions,
 144                 &init, NULL)) || result == NULL)
 145                 goto fail_open;
 146
 147         /* Success! */
 148         *outStream = result;
 149         return SJME_ERROR_NONE;
 150
 151 fail_open:
 152         if (result != NULL)
 153                 sjme_closeable_close(SJME_AS_CLOSEABLE(result));
 154
 155 fail_inflateNew:
 156         if (state != NULL)
 157                 sjme_inflate_destroy(state);
 158
 159         return sjme_error_default(error);
 160 }