static SRes
squash_csc_reader (void* istream, void* buf, size_t* size) {
SquashCscStream* s = (SquashCscStream*) ((struct SquashCscInStream*) istream)->s;
SquashStream* stream = (SquashStream*) s;
uint8_t* buffer = (uint8_t*) buf;
size_t remaining = *size;
while (remaining != 0) {
const size_t cp_size = (stream->avail_in < remaining) ? stream->avail_in : remaining;
if (cp_size > 0) {
memcpy (buffer + (*size - remaining), stream->next_in, cp_size);
stream->next_in += cp_size;
stream->avail_in -= cp_size;
remaining -= cp_size;
}
if (remaining != 0) {
if (s->operation == SQUASH_OPERATION_FINISH)
break;
s->operation = squash_stream_yield ((SquashStream*) stream, SQUASH_OK);
}
}
*size = (*size - remaining);
return 0;
}
static size_t
squash_csc_writer (void* ostream, const void* buf, size_t size) {
SquashCscStream* s = (SquashCscStream*) ((struct SquashCscOutStream*) ostream)->s;
SquashStream* stream = (SquashStream*) s;
const uint8_t* buffer = (uint8_t*) buf;
assert (size != 0);
size_t remaining = size;
while (remaining != 0) {
const size_t cp_size = (stream->avail_out < remaining) ? stream->avail_out : remaining;
if (cp_size != 0) {
memcpy (stream->next_out, buffer + (size - remaining), cp_size);
stream->next_out += cp_size;
stream->avail_out -= cp_size;
remaining -= cp_size;
}
if (remaining != 0)
s->operation = squash_stream_yield ((SquashStream*) stream, SQUASH_PROCESSING);
}
assert (remaining == 0);
return (size - remaining);
}
static int
squash_brotli_writer (void* user_data, const uint8_t* buf, size_t size) {
SquashBrotliStream* stream = (SquashBrotliStream*) user_data;
size_t remaining = size;
while (remaining != 0) {
const size_t cp_size = (stream->base_object.avail_out < remaining) ? stream->base_object.avail_out : remaining;
memcpy (stream->base_object.next_out, buf + (size - remaining), cp_size);
stream->base_object.next_out += cp_size;
stream->base_object.avail_out -= cp_size;
remaining -= cp_size;
if (remaining != 0) {
stream->operation = squash_stream_yield ((SquashStream*) stream, SQUASH_PROCESSING);
}
}
return (size - remaining);
}
static SquashStatus
squash_stream_write_cb (size_t* data_size,
const uint8_t data[SQUASH_ARRAY_PARAM(*data_size)],
void* user_data) {
assert (user_data != NULL);
assert (data_size != NULL);
SquashStream* s = (SquashStream*) user_data;
assert (s->priv != NULL);
const size_t requested = *data_size;
size_t remaining = *data_size;
SquashOperation operation = s->priv->request;
while (remaining != 0) {
const size_t cp_size = (s->avail_out < remaining) ? s->avail_out : remaining;
if (cp_size != 0) {
memcpy (s->next_out, data + (requested - remaining), cp_size);
s->next_out += cp_size;
s->avail_out -= cp_size;
remaining -= cp_size;
}
if (remaining != 0) {
if (operation == SQUASH_OPERATION_TERMINATE)
break;
operation = squash_stream_yield (s, SQUASH_PROCESSING);
}
}
*data_size = requested - remaining;
/* If we are terminating, we want to return an error code. However,
don't call squash_error because this may just be from unreffing
the stream before it is finished to abandon it. */
return (*data_size != 0) ? SQUASH_OK : SQUASH_FAILED;
}
static int
squash_brotli_reader (void* user_data, uint8_t* buf, size_t size) {
SquashBrotliStream* stream = (SquashBrotliStream*) user_data;
size_t remaining = size;
while (remaining != 0) {
const size_t cp_size = (stream->base_object.avail_in < remaining) ? stream->base_object.avail_in : remaining;
memcpy (buf + (size - remaining), stream->base_object.next_in, cp_size);
stream->base_object.next_in += cp_size;
stream->base_object.avail_in -= cp_size;
remaining -= cp_size;
if (remaining != 0) {
if (stream->operation == SQUASH_OPERATION_FINISH)
break;
stream->operation = squash_stream_yield ((SquashStream*) stream, SQUASH_OK);
}
}
return (size - remaining);
}
static SquashStatus
squash_stream_read_cb (size_t* data_size,
uint8_t data[SQUASH_ARRAY_PARAM(*data_size)],
void* user_data) {
assert (user_data != NULL);
assert (data_size != NULL);
SquashStream* s = (SquashStream*) user_data;
assert (s->priv != NULL);
const size_t requested = *data_size;
size_t remaining = *data_size;
SquashOperation operation = s->priv->request;
while (remaining != 0) {
const size_t cp_size = (s->avail_in < remaining) ? s->avail_in : remaining;
if (cp_size != 0) {
memcpy (data + (requested - remaining), s->next_in, cp_size);
s->next_in += cp_size;
s->avail_in -= cp_size;
remaining -= cp_size;
}
if (remaining != 0) {
if (operation == SQUASH_OPERATION_FINISH || operation == SQUASH_OPERATION_TERMINATE) {
break;
}
SquashStatus res = (s->avail_in == 0) ? SQUASH_OK : SQUASH_PROCESSING;
operation = squash_stream_yield (s, res);
}
}
*data_size = requested - remaining;
return (*data_size != 0) ? SQUASH_OK : SQUASH_END_OF_STREAM;
}
