static BROTLI_BOOL DecompressFiles(Context* context) { while (NextFile(context)) { BROTLI_BOOL is_ok = BROTLI_TRUE; BrotliDecoderState* s = BrotliDecoderCreateInstance(BrotliAllocFunc, BrotliFreeFunc, &scratch_buffer_size); if (!s) { fprintf(stderr, "out of memory\n"); return BROTLI_FALSE; } /* This allows decoding "large-window" streams. Though it creates fragmentation (new builds decode streams that old builds don't), it is better from used experience perspective. */ BrotliDecoderSetParameter(s, BROTLI_DECODER_PARAM_LARGE_WINDOW, 1u); is_ok = OpenFiles(context); if (is_ok && !context->current_input_path && !context->force_overwrite && isatty(STDIN_FILENO)) { fprintf(stderr, "Use -h help. Use -f to force input from a terminal.\n"); is_ok = BROTLI_FALSE; } if (is_ok) is_ok = DecompressFile(context, s); BrotliDecoderDestroyInstance(s); if (!CloseFiles(context, is_ok)) is_ok = BROTLI_FALSE; if (!is_ok) return BROTLI_FALSE; } return BROTLI_TRUE; }
static CURLcode brotli_init_writer(struct connectdata *conn, contenc_writer *writer) { brotli_params *bp = (brotli_params *) &writer->params; (void) conn; if(!writer->downstream) return CURLE_WRITE_ERROR; bp->br = BrotliDecoderCreateInstance(NULL, NULL, NULL); return bp->br? CURLE_OK: CURLE_OUT_OF_MEMORY; }
int main(int argc, char** argv) { Context ctx; BrotliDecoderResult result = BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT; size_t available_in; const uint8_t* next_in; size_t available_out = BUFFER_SIZE; uint8_t* next_out; init(&ctx); ctx.fin = fdopen(STDIN_FILENO, "rb"); if (!ctx.fin) fail(&ctx, "can't open input file"); ctx.fout = fdopen(STDOUT_FILENO, "wb"); if (!ctx.fout) fail(&ctx, "can't open output file"); ctx.input_buffer = (uint8_t*)malloc(BUFFER_SIZE); if (!ctx.input_buffer) fail(&ctx, "out of memory / input buffer"); ctx.output_buffer = (uint8_t*)malloc(BUFFER_SIZE); if (!ctx.output_buffer) fail(&ctx, "out of memory / output buffer"); ctx.decoder = BrotliDecoderCreateInstance(0, 0, 0); if (!ctx.decoder) fail(&ctx, "out of memory / decoder"); BrotliDecoderSetParameter(ctx.decoder, BROTLI_DECODER_PARAM_LARGE_WINDOW, 1); next_out = ctx.output_buffer; while (1) { if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) { if (feof(ctx.fin)) break; available_in = fread(ctx.input_buffer, 1, BUFFER_SIZE, ctx.fin); next_in = ctx.input_buffer; if (ferror(ctx.fin)) break; } else if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) { fwrite(ctx.output_buffer, 1, BUFFER_SIZE, ctx.fout); if (ferror(ctx.fout)) break; available_out = BUFFER_SIZE; next_out = ctx.output_buffer; } else { break; } result = BrotliDecoderDecompressStream( ctx.decoder, &available_in, &next_in, &available_out, &next_out, 0); } if (next_out != ctx.output_buffer) { fwrite(ctx.output_buffer, 1, next_out - ctx.output_buffer, ctx.fout); } if ((result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) || ferror(ctx.fout)) { fail(&ctx, "failed to write output"); } else if (result != BROTLI_DECODER_RESULT_SUCCESS) { fail(&ctx, "corrupt input"); } cleanup(&ctx); return 0; }
BrotliDecoderResult decompress(const unsigned char *data, size_t len, struct VecU8 *ret_buffer) { unsigned char buf[BUF_SIZE]; size_t total_out = 0; BrotliDecoderState *state = BrotliDecoderCreateInstance(custom_malloc, custom_free, custom_alloc_opaque); BrotliDecoderResult res; do { size_t read_offset = 0; uint8_t *next_out = &buf[0]; size_t avail_out = BUF_SIZE; res = BrotliDecoderDecompressStream(state, &len, &data, &avail_out, &next_out, &total_out); if (res == BROTLI_DECODER_RESULT_ERROR || (res == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT && len == 0)) { BrotliDecoderDestroyInstance(state); return res; } push_vec_u8(ret_buffer, buf, next_out - buf); } while (res != BROTLI_DECODER_RESULT_SUCCESS); BrotliDecoderDestroyInstance(state); return BROTLI_DECODER_RESULT_SUCCESS; }