blob: c85ca31b54cbf7401ae3ce0605aeb5210c9bc314 [file] [log] [blame]
// Copyright 2019 Joe Drago. All rights reserved.
// SPDX-License-Identifier: BSD-2-Clause
#include "avif/internal.h"
#include <assert.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
// ---------------------------------------------------------------------------
// avifROStream
const uint8_t * avifROStreamCurrent(avifROStream * stream)
{
return stream->raw->data + stream->offset;
}
void avifROStreamStart(avifROStream * stream, avifROData * raw, avifDiagnostics * diag, const char * diagContext)
{
stream->raw = raw;
stream->offset = 0;
stream->numUsedBitsInPartialByte = 0;
stream->diag = diag;
stream->diagContext = diagContext;
// If diag is non-NULL, diagContext must also be non-NULL
assert(!stream->diag || stream->diagContext);
}
avifBool avifROStreamHasBytesLeft(const avifROStream * stream, size_t byteCount)
{
return byteCount <= (stream->raw->size - stream->offset);
}
size_t avifROStreamRemainingBytes(const avifROStream * stream)
{
return stream->raw->size - stream->offset;
}
size_t avifROStreamOffset(const avifROStream * stream)
{
return stream->offset;
}
void avifROStreamSetOffset(avifROStream * stream, size_t offset)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
stream->offset = offset;
if (stream->offset > stream->raw->size) {
stream->offset = stream->raw->size;
}
}
avifBool avifROStreamSkip(avifROStream * stream, size_t byteCount)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
if (!avifROStreamHasBytesLeft(stream, byteCount)) {
avifDiagnosticsPrintf(stream->diag, "%s: Failed to skip %zu bytes, truncated data?", stream->diagContext, byteCount);
return AVIF_FALSE;
}
stream->offset += byteCount;
return AVIF_TRUE;
}
avifBool avifROStreamRead(avifROStream * stream, uint8_t * data, size_t size)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
if (!avifROStreamHasBytesLeft(stream, size)) {
avifDiagnosticsPrintf(stream->diag, "%s: Failed to read %zu bytes, truncated data?", stream->diagContext, size);
return AVIF_FALSE;
}
memcpy(data, stream->raw->data + stream->offset, size);
stream->offset += size;
return AVIF_TRUE;
}
avifBool avifROStreamReadUX8(avifROStream * stream, uint64_t * v, uint64_t factor)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
if (factor == 0) {
// Don't read anything, just set to 0
*v = 0;
} else if (factor == 1) {
uint8_t tmp;
AVIF_CHECK(avifROStreamRead(stream, &tmp, 1));
*v = tmp;
} else if (factor == 2) {
uint16_t tmp;
AVIF_CHECK(avifROStreamReadU16(stream, &tmp));
*v = tmp;
} else if (factor == 4) {
uint32_t tmp;
AVIF_CHECK(avifROStreamReadU32(stream, &tmp));
*v = tmp;
} else if (factor == 8) {
uint64_t tmp;
AVIF_CHECK(avifROStreamReadU64(stream, &tmp));
*v = tmp;
} else {
// Unsupported factor
avifDiagnosticsPrintf(stream->diag, "%s: Failed to read UX8 value; Unsupported UX8 factor [%" PRIu64 "]", stream->diagContext, factor);
return AVIF_FALSE;
}
return AVIF_TRUE;
}
avifBool avifROStreamReadU16(avifROStream * stream, uint16_t * v)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
AVIF_CHECK(avifROStreamRead(stream, (uint8_t *)v, sizeof(uint16_t)));
*v = avifNTOHS(*v);
return AVIF_TRUE;
}
avifBool avifROStreamReadU16Endianness(avifROStream * stream, uint16_t * v, avifBool littleEndian)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
AVIF_CHECK(avifROStreamRead(stream, (uint8_t *)v, sizeof(uint16_t)));
*v = littleEndian ? avifCTOHS(*v) : avifNTOHS(*v);
return AVIF_TRUE;
}
avifBool avifROStreamReadU32(avifROStream * stream, uint32_t * v)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
AVIF_CHECK(avifROStreamRead(stream, (uint8_t *)v, sizeof(uint32_t)));
*v = avifNTOHL(*v);
return AVIF_TRUE;
}
avifBool avifROStreamReadU32Endianness(avifROStream * stream, uint32_t * v, avifBool littleEndian)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
AVIF_CHECK(avifROStreamRead(stream, (uint8_t *)v, sizeof(uint32_t)));
*v = littleEndian ? avifCTOHL(*v) : avifNTOHL(*v);
return AVIF_TRUE;
}
avifBool avifROStreamReadU64(avifROStream * stream, uint64_t * v)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
AVIF_CHECK(avifROStreamRead(stream, (uint8_t *)v, sizeof(uint64_t)));
*v = avifNTOH64(*v);
return AVIF_TRUE;
}
// Override of avifROStreamReadBits() for convenient uint8_t output.
avifBool avifROStreamReadBits8(avifROStream * stream, uint8_t * v, size_t bitCount)
{
assert(bitCount <= sizeof(*v) * 8);
uint32_t v32;
if (!avifROStreamReadBits(stream, &v32, bitCount)) {
return AVIF_FALSE;
}
*v = (uint8_t)v32;
return AVIF_TRUE;
}
avifBool avifROStreamReadBits(avifROStream * stream, uint32_t * v, size_t bitCount)
{
assert(bitCount <= sizeof(*v) * 8);
*v = 0;
while (bitCount) {
if (stream->numUsedBitsInPartialByte == 0) {
AVIF_CHECK(avifROStreamSkip(stream, sizeof(uint8_t))); // Book a new partial byte in the stream.
}
assert(stream->offset > 0);
const uint8_t * packedBits = stream->raw->data + stream->offset - 1;
const size_t numBits = AVIF_MIN(bitCount, 8 - stream->numUsedBitsInPartialByte);
stream->numUsedBitsInPartialByte += numBits;
bitCount -= numBits;
// The stream bits are packed starting with the most significant bit of the first input byte.
// This way, packed bits can be found in the same order in the bit stream.
const uint32_t bits = (*packedBits >> (8 - stream->numUsedBitsInPartialByte)) & ((1 << numBits) - 1);
// The value bits are ordered from the most significant bit to the least significant bit.
// In the case where avifROStreamReadBits() is used to parse the unsigned integer value *v
// over multiple aligned bytes, this order corresponds to big endianness.
*v |= bits << bitCount;
if (stream->numUsedBitsInPartialByte == 8) {
// Start a new partial byte the next time a bit is needed.
stream->numUsedBitsInPartialByte = 0;
}
}
return AVIF_TRUE;
}
// Based on https://sqlite.org/src4/doc/trunk/www/varint.wiki.
avifBool avifROStreamReadVarInt(avifROStream * stream, uint32_t * v)
{
uint32_t a[5];
AVIF_CHECK(avifROStreamReadBits(stream, &a[0], 8));
if (a[0] <= 240) {
*v = a[0];
} else {
AVIF_CHECK(avifROStreamReadBits(stream, &a[1], 8));
if (a[0] <= 248) {
*v = 240 + 256 * (a[0] - 241) + a[1];
} else {
AVIF_CHECK(avifROStreamReadBits(stream, &a[2], 8));
if (a[0] == 249) {
*v = 2288 + 256 * a[1] + a[2];
} else {
AVIF_CHECK(avifROStreamReadBits(stream, &a[3], 8));
if (a[0] == 250) {
*v = (a[3] << 16) | (a[2] << 8) | a[1];
} else {
// TODO(yguyon): Use values of a[0] in range [252-255] (avoid pessimization).
AVIF_CHECK(avifROStreamReadBits(stream, &a[4], 8));
*v = (a[4] << 24) | (a[3] << 16) | (a[2] << 8) | a[1];
}
}
}
}
return AVIF_TRUE;
}
avifBool avifROStreamReadString(avifROStream * stream, char * output, size_t outputSize)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
// Check for the presence of a null terminator in the stream.
size_t remainingBytes = avifROStreamRemainingBytes(stream);
const uint8_t * p = avifROStreamCurrent(stream);
avifBool foundNullTerminator = AVIF_FALSE;
for (size_t i = 0; i < remainingBytes; ++i) {
if (p[i] == 0) {
foundNullTerminator = AVIF_TRUE;
break;
}
}
if (!foundNullTerminator) {
avifDiagnosticsPrintf(stream->diag, "%s: Failed to find a NULL terminator when reading a string", stream->diagContext);
return AVIF_FALSE;
}
const char * streamString = (const char *)p;
size_t stringLen = strlen(streamString);
stream->offset += stringLen + 1; // update the stream to have read the "whole string" in
if (output && outputSize) {
// clamp to our output buffer
if (stringLen >= outputSize) {
stringLen = outputSize - 1;
}
memcpy(output, streamString, stringLen);
output[stringLen] = 0;
}
return AVIF_TRUE;
}
avifBool avifROStreamReadBoxHeaderPartial(avifROStream * stream, avifBoxHeader * header)
{
size_t startOffset = stream->offset;
uint32_t smallSize;
AVIF_CHECK(avifROStreamReadU32(stream, &smallSize));
AVIF_CHECK(avifROStreamRead(stream, header->type, 4));
uint64_t size = smallSize;
if (size == 1) {
AVIF_CHECK(avifROStreamReadU64(stream, &size));
}
if (!memcmp(header->type, "uuid", 4)) {
AVIF_CHECK(avifROStreamSkip(stream, 16));
}
size_t bytesRead = stream->offset - startOffset;
if ((size < bytesRead) || ((size - bytesRead) > SIZE_MAX)) {
avifDiagnosticsPrintf(stream->diag, "%s: Header size overflow check failure", stream->diagContext);
return AVIF_FALSE;
}
header->size = (size_t)(size - bytesRead);
return AVIF_TRUE;
}
avifBool avifROStreamReadBoxHeader(avifROStream * stream, avifBoxHeader * header)
{
AVIF_CHECK(avifROStreamReadBoxHeaderPartial(stream, header));
if (header->size > avifROStreamRemainingBytes(stream)) {
avifDiagnosticsPrintf(stream->diag, "%s: Child box too large, possibly truncated data", stream->diagContext);
return AVIF_FALSE;
}
return AVIF_TRUE;
}
avifBool avifROStreamReadVersionAndFlags(avifROStream * stream, uint8_t * version, uint32_t * flags)
{
uint8_t versionAndFlags[4];
AVIF_CHECK(avifROStreamRead(stream, versionAndFlags, 4));
if (version) {
*version = versionAndFlags[0];
}
if (flags) {
*flags = (versionAndFlags[1] << 16) + (versionAndFlags[2] << 8) + (versionAndFlags[3] << 0);
}
return AVIF_TRUE;
}
avifBool avifROStreamReadAndEnforceVersion(avifROStream * stream, uint8_t enforcedVersion)
{
uint8_t version;
AVIF_CHECK(avifROStreamReadVersionAndFlags(stream, &version, NULL));
if (version != enforcedVersion) {
avifDiagnosticsPrintf(stream->diag, "%s: Expecting box version %u, got version %u", stream->diagContext, enforcedVersion, version);
return AVIF_FALSE;
}
return AVIF_TRUE;
}
// ---------------------------------------------------------------------------
// avifRWStream
#define AVIF_STREAM_BUFFER_INCREMENT (1024 * 1024)
static avifResult makeRoom(avifRWStream * stream, size_t size)
{
size_t neededSize = stream->offset + size;
size_t newSize = stream->raw->size;
while (newSize < neededSize) {
newSize += AVIF_STREAM_BUFFER_INCREMENT;
}
return avifRWDataRealloc(stream->raw, newSize);
}
void avifRWStreamStart(avifRWStream * stream, avifRWData * raw)
{
stream->raw = raw;
stream->offset = 0;
stream->numUsedBitsInPartialByte = 0;
}
size_t avifRWStreamOffset(const avifRWStream * stream)
{
return stream->offset;
}
void avifRWStreamSetOffset(avifRWStream * stream, size_t offset)
{
stream->offset = offset;
if (stream->offset > stream->raw->size) {
stream->offset = stream->raw->size;
}
}
void avifRWStreamFinishWrite(avifRWStream * stream)
{
if (stream->raw->size != stream->offset) {
if (stream->offset) {
stream->raw->size = stream->offset;
} else {
avifRWDataFree(stream->raw);
}
}
}
avifResult avifRWStreamWrite(avifRWStream * stream, const void * data, size_t size)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
if (size) {
AVIF_CHECKRES(makeRoom(stream, size));
memcpy(stream->raw->data + stream->offset, data, size);
stream->offset += size;
}
return AVIF_RESULT_OK;
}
avifResult avifRWStreamWriteChars(avifRWStream * stream, const char * chars, size_t size)
{
return avifRWStreamWrite(stream, chars, size);
}
avifResult avifRWStreamWriteFullBox(avifRWStream * stream, const char * type, size_t contentSize, int version, uint32_t flags, avifBoxMarker * marker)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
if (marker) {
*marker = stream->offset;
}
size_t headerSize = sizeof(uint32_t) + 4 /* size of type */;
if (version != -1) {
headerSize += 4;
}
AVIF_CHECKRES(makeRoom(stream, headerSize));
memset(stream->raw->data + stream->offset, 0, headerSize);
uint32_t noSize = avifHTONL((uint32_t)(headerSize + contentSize));
memcpy(stream->raw->data + stream->offset, &noSize, sizeof(uint32_t));
memcpy(stream->raw->data + stream->offset + 4, type, 4);
if (version != -1) {
stream->raw->data[stream->offset + 8] = (uint8_t)version;
stream->raw->data[stream->offset + 9] = (uint8_t)((flags >> 16) & 0xff);
stream->raw->data[stream->offset + 10] = (uint8_t)((flags >> 8) & 0xff);
stream->raw->data[stream->offset + 11] = (uint8_t)((flags >> 0) & 0xff);
}
stream->offset += headerSize;
return AVIF_RESULT_OK;
}
avifResult avifRWStreamWriteBox(avifRWStream * stream, const char * type, size_t contentSize, avifBoxMarker * marker)
{
return avifRWStreamWriteFullBox(stream, type, contentSize, -1, 0, marker);
}
void avifRWStreamFinishBox(avifRWStream * stream, avifBoxMarker marker)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
uint32_t noSize = avifHTONL((uint32_t)(stream->offset - marker));
memcpy(stream->raw->data + marker, &noSize, sizeof(uint32_t));
}
avifResult avifRWStreamWriteU8(avifRWStream * stream, uint8_t v)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
AVIF_CHECKRES(makeRoom(stream, 1));
stream->raw->data[stream->offset] = v;
stream->offset += 1;
return AVIF_RESULT_OK;
}
avifResult avifRWStreamWriteU16(avifRWStream * stream, uint16_t v)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
const size_t size = sizeof(uint16_t);
AVIF_CHECKRES(makeRoom(stream, size));
v = avifHTONS(v);
memcpy(stream->raw->data + stream->offset, &v, size);
stream->offset += size;
return AVIF_RESULT_OK;
}
avifResult avifRWStreamWriteU32(avifRWStream * stream, uint32_t v)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
const size_t size = sizeof(uint32_t);
AVIF_CHECKRES(makeRoom(stream, size));
v = avifHTONL(v);
memcpy(stream->raw->data + stream->offset, &v, size);
stream->offset += size;
return AVIF_RESULT_OK;
}
avifResult avifRWStreamWriteU64(avifRWStream * stream, uint64_t v)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
const size_t size = sizeof(uint64_t);
AVIF_CHECKRES(makeRoom(stream, size));
v = avifHTON64(v);
memcpy(stream->raw->data + stream->offset, &v, size);
stream->offset += size;
return AVIF_RESULT_OK;
}
avifResult avifRWStreamWriteZeros(avifRWStream * stream, size_t byteCount)
{
assert(stream->numUsedBitsInPartialByte == 0); // Byte alignment is required.
AVIF_CHECKRES(makeRoom(stream, byteCount));
memset(stream->raw->data + stream->offset, 0, byteCount);
stream->offset += byteCount;
return AVIF_RESULT_OK;
}
avifResult avifRWStreamWriteBits(avifRWStream * stream, uint32_t v, size_t bitCount)
{
assert(((uint64_t)v >> bitCount) == 0); // (uint32_t >> 32 is undefined behavior)
while (bitCount) {
if (stream->numUsedBitsInPartialByte == 0) {
AVIF_CHECKRES(makeRoom(stream, 1)); // Book a new partial byte in the stream.
stream->raw->data[stream->offset] = 0;
stream->offset += 1;
}
assert(stream->offset > 0);
uint8_t * packedBits = stream->raw->data + stream->offset - 1;
const size_t numBits = AVIF_MIN(bitCount, 8 - stream->numUsedBitsInPartialByte);
stream->numUsedBitsInPartialByte += numBits;
bitCount -= numBits;
// Order the input bits from the most significant bit to the least significant bit.
// In the case where avifRWStreamWriteBits() is used to write the unsigned integer value v
// over multiple aligned bytes, this order corresponds to big endianness.
const uint32_t bits = (v >> bitCount) & ((1 << numBits) - 1);
// Pack bits starting with the most significant bit of the first output byte.
// This way, packed bits can be found in the same order in the bit stream.
*packedBits |= bits << (8 - stream->numUsedBitsInPartialByte);
if (stream->numUsedBitsInPartialByte == 8) {
// Start a new partial byte the next time a bit is needed.
stream->numUsedBitsInPartialByte = 0;
}
}
return AVIF_RESULT_OK;
}
// Based on https://sqlite.org/src4/doc/trunk/www/varint.wiki.
avifResult avifRWStreamWriteVarInt(avifRWStream * stream, uint32_t v)
{
if (v <= 240) {
AVIF_CHECKRES(avifRWStreamWriteBits(stream, v, 8));
} else if (v <= 2287) {
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v - 240) / 256 + 241, 8));
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v - 240) % 256, 8));
} else if (v <= 67823) {
AVIF_CHECKRES(avifRWStreamWriteBits(stream, 249, 8));
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v - 2288) / 256, 8));
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v - 2288) % 256, 8));
} else if (v <= 16777215) {
AVIF_CHECKRES(avifRWStreamWriteBits(stream, 250, 8));
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v >> 0) & 0xff, 8));
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v >> 8) & 0xff, 8));
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v >> 16) & 0xff, 8));
} else {
AVIF_CHECKRES(avifRWStreamWriteBits(stream, 251, 8));
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v >> 0) & 0xff, 8));
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v >> 8) & 0xff, 8));
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v >> 16) & 0xff, 8));
AVIF_CHECKRES(avifRWStreamWriteBits(stream, (v >> 24) & 0xff, 8));
}
return AVIF_RESULT_OK;
}