// SPDX-License-Identifier: GPL-2.0

//

// container-voc.c - a parser/builder for a container of Creative Voice File.

//

// Copyright (c) 2018 Takashi Sakamoto <o-takashi@sakamocchi.jp>

//

// Licensed under the terms of the GNU General Public License, version 2.

#include "container.h"

#include "misc.h"

// Not portable to all of UNIX platforms.

#include <endian.h>

// References:

//  - http://sox.sourceforge.net/

#define VOC_MAGIC		"Creative Voice File\x1a"

#define VOC_VERSION_1_10	0x010a

#define VOC_VERSION_1_20	0x0114

enum block_type {

	BLOCK_TYPE_TERMINATOR		= 0x00,

	BLOCK_TYPE_V110_DATA		= 0x01,

	BLOCK_TYPE_CONTINUOUS_DATA	= 0x02,

	BLOCK_TYPE_SILENCE		= 0x03,

	BLOCK_TYPE_MARKER		= 0x04,

	BLOCK_TYPE_STRING		= 0x05,

	BLOCK_TYPE_REPEAT_START		= 0x06,

	BLOCK_TYPE_REPEAT_END		= 0x07,

	BLOCK_TYPE_EXTENDED_V110_FORMAT	= 0x08,

	BLOCK_TYPE_V120_DATA		= 0x09,

};

enum code_id {

	// Version 1.10.

	CODE_ID_GENERIC_MBLA_U8			= 0x00,

	CODE_ID_CREATIVE_ADPCM_8BIT_TO_4BIT_LE	= 0x01,

	CODE_ID_CREATIVE_ADPCM_8BIT_TO_3BIT_LE	= 0x02,

	CODE_ID_CREATIVE_ADPCM_8BIT_TO_2BIT_LE	= 0x03,

	// Version 1.20.

	CODE_ID_GENERIC_MBLA_S16_LE		= 0x04,

	CODE_ID_CCIT_A_LAW_LE			= 0x06,

	CODE_ID_CCIT_MU_LAW_LE			= 0x07,

	CODE_ID_CREATIVE_ADPCM_16BIT_TO_4BIT_LE	= 0x2000,

};

struct format_map {

	unsigned int minimal_version;

	enum code_id code_id;

	snd_pcm_format_t format;

};

static const struct format_map format_maps[] = {

	{VOC_VERSION_1_10, CODE_ID_GENERIC_MBLA_U8,	SND_PCM_FORMAT_U8},

	{VOC_VERSION_1_20, CODE_ID_GENERIC_MBLA_S16_LE,	SND_PCM_FORMAT_S16_LE},

	{VOC_VERSION_1_20, CODE_ID_CCIT_A_LAW_LE,	SND_PCM_FORMAT_A_LAW},

	{VOC_VERSION_1_20, CODE_ID_CCIT_MU_LAW_LE,	SND_PCM_FORMAT_MU_LAW},

	// The other formats are not supported by ALSA.

};

struct container_header {

	uint8_t magic[20];

	uint16_t hdr_size;

	uint16_t version;

	uint16_t version_compr;

};

// A format for data blocks except for terminator type.

struct block_header {

	uint8_t type;

	uint8_t size[3];

	uint8_t data[0];

};

// Data block for terminator type has an exceptional format.

struct block_terminator {

	uint8_t type;

};

struct time_const {

	unsigned int frames_per_second;

	uint16_t code;

};

static const struct time_const v110_time_consts[] = {

	{5512, 74},

	{8000, 130},

	{11025, 165},

	{16000, 193},

	{22050, 210},

	{32000, 224},

	{44100, 233},

	{48000, 235},

	{64000, 240},

	// Time constant for the upper sampling rate is not identical.

};

static const struct time_const ex_v110_time_consts[] = {

	{5512, 19092},

	{8000, 33536},

	{11025, 42317},

	{16000, 49536},

	{22050, 53927},

	{32000, 57536},

	{44100, 59732},

	{48000, 60203},

	{64000, 61536},

	{88200, 62634},

	{96000, 62870},

	{176400, 64085},

	{192000, 64203},

	// This support up to 192.0 kHz. The rest is for cases with 2ch.

	{352800, 64811},

	{384000, 64870},

};

// v1.10 format:

// - monaural.

// - frames_per_second = 1,000,000 / (256 - time_const)

struct block_v110_data {

	uint8_t type;

	uint8_t size[3];	// Equals to (2 + the size of frames).

	uint8_t time_const;

	uint8_t code_id;

	uint8_t frames[0];	// Aligned to little-endian.

};

struct block_continuous_data {

	uint8_t type;

	uint8_t size[3];	// Equals to the size of frames.

	uint8_t frames[0];	// Aligned to little-endian.

};

// v1.10 format:

// - monaural.

// - frames_per_second = 1,000,000 / (256 - time_const).

struct block_silence {

	uint8_t type;

	uint8_t size[3];	// Equals to 3.

	uint16_t frame_count;

	uint8_t time_const;

};

struct block_marker {

	uint8_t type;

	uint8_t size[3];	// Equals to 2.

	uint16_t mark;

};

struct block_string {

	uint8_t type;

	uint8_t size[3];	// Equals to the length of string with 0x00.

	uint8_t chars[0];

};

struct block_repeat_start {

	uint8_t type;

	uint8_t size[3];	// Equals to 2.

	uint16_t count;

};

struct block_repeat_end {

	uint8_t type;

	uint8_t size[3];	// Equals to 0.

};

// Extended v1.10 format:

// - manaural/stereo.

// - frames_per_second =

//		256,000,000 / (samples_per_frame * (65536 - time_const)).

// - Appear just before v110_data block.

struct block_extended_v110_format {

	uint8_t type;

	uint8_t size[3];	// Equals to 4.

	uint16_t time_const;

	uint8_t code_id;

	uint8_t ch_mode;	// 0 is monaural, 1 is stereo.

};

// v1.20 format:

// - monaural/stereo.

// - 8/16 bits_per_sample.

// - time_const is not used.

// - code_id is extended.

struct block_v120_format {

	uint8_t type;

	uint8_t size[3];	// Equals to (12 + ).

	uint32_t frames_per_second;

	uint8_t bits_per_sample;

	uint8_t samples_per_frame;

	uint16_t code_id;

	uint8_t reserved[4];

	uint8_t frames[0];	// Aligned to little-endian.

};

// Aligned to little endian order but 24 bits field.

static uint32_t parse_block_data_size(uint8_t fields[3])

{

	return (fields[2] << 16) | (fields[1] << 8) | fields[0];

}

static void build_block_data_size(uint8_t fields[3], unsigned int size)

{

	fields[0] = (size & 0x0000ff);

	fields[1] = (size & 0x00ff00) >> 8;

	fields[2] = (size & 0xff0000) >> 16;

}

static int build_time_constant(unsigned int frames_per_second,

			       unsigned int samples_per_frame, uint16_t *code,

			       bool extended)

{

	int i;

	// 16 bits are available for this purpose.

	if (extended) {

		if (samples_per_frame > 2)

			return -EINVAL;

		frames_per_second *= samples_per_frame;

		for (i = 0; i < ARRAY_SIZE(ex_v110_time_consts); ++i) {

			if (ex_v110_time_consts[i].frames_per_second ==

					frames_per_second)

				break;

		}

		if (i < ARRAY_SIZE(ex_v110_time_consts) &&

		    frames_per_second <= 192000) {

			*code = ex_v110_time_consts[i].code;

		} else {

			*code = 65536 - 256000000 / frames_per_second;

		}

	} else {

		if (samples_per_frame != 1)

			return -EINVAL;

		for (i = 0; i < ARRAY_SIZE(v110_time_consts); ++i) {

			if (v110_time_consts[i].frames_per_second ==

					frames_per_second)

			break;

		}

		// Should be within 8 bit.

		if (i < ARRAY_SIZE(v110_time_consts))

			*code = (uint8_t)v110_time_consts[i].code;

		else

			*code = 256 - 1000000 / frames_per_second;

	}

	return 0;

}

static unsigned int parse_time_constant(uint16_t code,

					unsigned int samples_per_frame,

					unsigned int *frames_per_second,

					bool extended)

{

	int i;

	if (extended) {

		if (samples_per_frame > 2)

			return -EINVAL;

		for (i = 0; i < ARRAY_SIZE(ex_v110_time_consts); ++i) {

			if (ex_v110_time_consts[i].code == code ||

			    ex_v110_time_consts[i].code - 1 == code)

				break;

		}

		if (i < ARRAY_SIZE(ex_v110_time_consts)) {

			*frames_per_second =

				ex_v110_time_consts[i].frames_per_second /

				samples_per_frame;

		} else {

			*frames_per_second = 256000000 / samples_per_frame /

					     (65536 - code);

		}

	} else {

		if (samples_per_frame != 1)

			return -EINVAL;

		for (i = 0; i < ARRAY_SIZE(v110_time_consts); ++i) {

			if (v110_time_consts[i].code == code ||

			    v110_time_consts[i].code - 1 == code)

				break;

		}

		if (i < ARRAY_SIZE(v110_time_consts)) {

			*frames_per_second =

					v110_time_consts[i].frames_per_second;

		} else {

			*frames_per_second = 1000000 / (256 - code);

		}

	}

	return 0;

}

struct parser_state {

	unsigned int version;

	bool extended;

	unsigned int frames_per_second;

	unsigned int samples_per_frame;

	unsigned int bytes_per_sample;

	enum code_id code_id;

	uint32_t byte_count;

};

static int parse_container_header(struct parser_state *state,

				  struct container_header *header)

{

	uint16_t hdr_size;

	uint16_t version;

	uint16_t version_compr;

	hdr_size = le16toh(header->hdr_size);

	version = le16toh(header->version);

	version_compr = le16toh(header->version_compr);

	if (memcmp(header->magic, VOC_MAGIC, sizeof(header->magic)))

		return -EIO;

	if (hdr_size != sizeof(*header))

		return -EIO;

	if (version_compr != 0x1234 + ~version)

		return -EIO;

	if (version != VOC_VERSION_1_10 && version != VOC_VERSION_1_20)

		return -EIO;

	state->version = version;

	return 0;

}

static bool check_code_id(uint8_t code_id, unsigned int version)

{

	int i;

	for (i = 0; i < ARRAY_SIZE(format_maps); ++i) {

		if (code_id != format_maps[i].code_id)

			continue;

		if (version >= format_maps[i].minimal_version)

			return true;

	}

	return false;

}

static int parse_v120_format_block(struct parser_state *state,

				   struct block_v120_format *block)

{

	state->frames_per_second = le32toh(block->frames_per_second);

	state->bytes_per_sample = block->bits_per_sample / 8;

	state->samples_per_frame = block->samples_per_frame;

	state->code_id = le16toh(block->code_id);

	state->byte_count = parse_block_data_size(block->size) - 12;

	if (!check_code_id(state->code_id, VOC_VERSION_1_20))

		return -EIO;

	return 0;

}

static int parse_extended_v110_format(struct parser_state *state,

				      struct block_extended_v110_format *block)

{

	unsigned int time_const;

	unsigned int frames_per_second;

	int err;

	state->code_id = block->code_id;

	if (!check_code_id(state->code_id, VOC_VERSION_1_10))

		return -EIO;

	if (block->ch_mode == 0)

		state->samples_per_frame = 1;

	else if (block->ch_mode == 1)

		state->samples_per_frame = 2;

	else

		return -EIO;

	time_const = le16toh(block->time_const);

	err = parse_time_constant(time_const, state->samples_per_frame,

				  &frames_per_second, true);

	if (err < 0)

		return err;

	state->frames_per_second = frames_per_second;

	state->extended = true;

	return 0;

}

static int parse_v110_data(struct parser_state *state,

			   struct block_v110_data *block)

{

	unsigned int time_const;

	unsigned int frames_per_second;

	int err;

	if (!state->extended) {

		state->code_id = block->code_id;

		if (!check_code_id(state->code_id, VOC_VERSION_1_10))

			return -EIO;

		time_const = block->time_const;

		err = parse_time_constant(time_const, 1, &frames_per_second,

					  false);

		if (err < 0)

			return err;

		state->frames_per_second = frames_per_second;

		state->samples_per_frame = 1;

	}

	state->bytes_per_sample = 1;

	state->byte_count = parse_block_data_size(block->size) - 2;

	return 0;

}

static int detect_container_version(struct container_context *cntr)

{

	struct parser_state *state = cntr->private_data;

	struct container_header header = {0};

	int err;

	// 4 bytes were alread read to detect container type.

	memcpy(&header.magic, cntr->magic, sizeof(cntr->magic));

	err = container_recursive_read(cntr,

				       (char *)&header + sizeof(cntr->magic),

				       sizeof(header) - sizeof(cntr->magic));

	if (err < 0)

		return err;

	if (cntr->eof)

		return 0;

	return parse_container_header(state, &header);

}

static int allocate_for_block_cache(struct container_context *cntr,

				    struct block_header *header, void **buf)

{

	uint32_t block_size;

	char *cache;

	int err;

	if (header->type == BLOCK_TYPE_V110_DATA)

		block_size = sizeof(struct block_v110_data);

	else if (header->type == BLOCK_TYPE_CONTINUOUS_DATA)

		block_size = sizeof(struct block_continuous_data);

	else if (header->type == BLOCK_TYPE_EXTENDED_V110_FORMAT)

		block_size = sizeof(struct block_extended_v110_format);

	else if (header->type == BLOCK_TYPE_V120_DATA)

		block_size = sizeof(struct block_v120_format);

	else

		block_size = parse_block_data_size(header->size);

	cache = malloc(block_size);

	if (cache == NULL)

		return -ENOMEM;

	memset(cache, 0, block_size);

	memcpy(cache, header, sizeof(*header));

	err = container_recursive_read(cntr, cache + sizeof(*header),

				       block_size - sizeof(*header));

	if (err < 0) {

		free(cache);

		return err;

	}

	if (cntr->eof) {

		free(cache);

		return 0;

	}

	*buf = cache;

	return 0;

}

static int cache_data_block(struct container_context *cntr,

			    struct block_header *header, void **buf)

{

	int err;

	// Check type of this block.

	err = container_recursive_read(cntr, &header->type,

				       sizeof(header->type));

	if (err < 0)

		return err;

	if (cntr->eof)

		return 0;

	if (header->type > BLOCK_TYPE_V120_DATA)

		return -EIO;

	if (header->type == BLOCK_TYPE_TERMINATOR)

		return 0;

	// Check size of this block. If the block includes a batch of data,

	err = container_recursive_read(cntr, &header->size,

				       sizeof(header->size));

	if (err < 0)

		return err;

	if (cntr->eof)

		return 0;

	return allocate_for_block_cache(cntr, header, buf);

}

static int detect_format_block(struct container_context *cntr)

{

	struct parser_state *state = cntr->private_data;

	struct block_header header;

	void *buf;

	int err;

again:

	buf = NULL;

	err = cache_data_block(cntr, &header, &buf;;

	if (err < 0)

		return err;

	if (buf) {

		if (header.type == BLOCK_TYPE_EXTENDED_V110_FORMAT) {

			err = parse_extended_v110_format(state, buf);

		} else if (header.type == BLOCK_TYPE_V120_DATA) {

			err = parse_v120_format_block(state, buf);

		} else if (header.type == BLOCK_TYPE_V110_DATA) {

			err = parse_v110_data(state, buf);

		} else {

			free(buf);

			goto again;

		}

		free(buf);

		if (err < 0)

			return err;

	}

	// Expect to detect block_v110_data.

	if (header.type == BLOCK_TYPE_EXTENDED_V110_FORMAT)

		goto again;

	return 0;

}

static int voc_parser_pre_process(struct container_context *cntr,

				  snd_pcm_format_t *format,

				  unsigned int *samples_per_frame,

				  unsigned int *frames_per_second,

				  uint64_t *byte_count)

{

	struct parser_state *state = cntr->private_data;

	int i;

	int err;

	err = detect_container_version(cntr);

	if (err < 0)

		return err;

	err = detect_format_block(cntr);

	if (err < 0)

		return err;

	for (i = 0; i < ARRAY_SIZE(format_maps); ++i) {

		if (format_maps[i].code_id == state->code_id)

			break;

	}

	if (i == ARRAY_SIZE(format_maps))

		return -EINVAL;

	*format = format_maps[i].format;

	*samples_per_frame = state->samples_per_frame;

	*frames_per_second = state->frames_per_second;

	// This program handles PCM frames in this data block only.

	*byte_count = state->byte_count;

	return 0;

}

struct builder_state {

	unsigned int version;

	bool extended;

	enum code_id code_id;

	unsigned int samples_per_frame;

	unsigned int bytes_per_sample;

};

static int write_container_header(struct container_context *cntr,

				  struct container_header *header)

{

	struct builder_state *state = cntr->private_data;

	// Process container header.

	memcpy(header->magic, VOC_MAGIC, sizeof(header->magic));

	header->hdr_size = htole16(sizeof(*header));

	header->version = htole16(state->version);

	header->version_compr = htole16(0x1234 + ~state->version);

	return container_recursive_write(cntr, header, sizeof(*header));

}

static int write_v120_format_block(struct container_context *cntr,

				   struct block_v120_format *block,

				   unsigned int frames_per_second,

				   uint64_t byte_count)

{

	struct builder_state *state = cntr->private_data;

	block->type = BLOCK_TYPE_V120_DATA;

	build_block_data_size(block->size, 12 + byte_count);

	block->frames_per_second = htole32(frames_per_second);

	block->bits_per_sample = state->bytes_per_sample * 8;

	block->samples_per_frame = state->samples_per_frame;

	block->code_id = htole16(state->code_id);

	return container_recursive_write(cntr, block, sizeof(*block));

}

static int write_extended_v110_format_block(struct container_context *cntr,

				unsigned int frames_per_second,

				struct block_extended_v110_format *block)

{

	struct builder_state *state = cntr->private_data;

	uint16_t time_const;

	int err;

	block->type = BLOCK_TYPE_EXTENDED_V110_FORMAT;

	build_block_data_size(block->size, 4);

	// 16 bits are available for this purpose.

	err = build_time_constant(frames_per_second, state->samples_per_frame,

				  &time_const, true);

	if (err < 0)

		return err;

	block->time_const = htole16(time_const);

	block->code_id = htole16(state->code_id);

	if (state->samples_per_frame == 1)

		block->ch_mode = 0;

	else

		block->ch_mode = 1;

	return container_recursive_write(cntr, block, sizeof(*block));

}

static int write_v110_format_block(struct container_context *cntr,

				   struct block_v110_data *block,

				   unsigned int frames_per_second,

				   uint64_t byte_count)

{

	struct builder_state *state = cntr->private_data;

	uint16_t time_const;

	int err;

	block->type = BLOCK_TYPE_V110_DATA;

	build_block_data_size(block->size, 2 + byte_count);

	// These fields were obsoleted by extension.

	err = build_time_constant(frames_per_second, 1, &time_const, false);

	if (err < 0)

		return err;

	block->time_const = (uint8_t)time_const;

	block->code_id = state->code_id;

	return container_recursive_write(cntr, block, sizeof(*block));

}

static int write_data_blocks(struct container_context *cntr,

			     unsigned int frames_per_second,

			     uint64_t byte_count)

{

	union {

		struct container_header header;

		struct block_v110_data v110_data;

		struct block_extended_v110_format extended_v110_format;

		struct block_v120_format v120_format;

	} buf = {0};

	struct builder_state *state = cntr->private_data;

	int err;

	err = write_container_header(cntr, &buf.header);

	if (err < 0)

		return err;

	if (state->version == VOC_VERSION_1_20) {

		err = write_v120_format_block(cntr, &buf.v120_format,

					      frames_per_second, byte_count);

	} else {

		if (state->extended) {

			err = write_extended_v110_format_block(cntr,

					frames_per_second,

					&buf.extended_v110_format);

			if (err < 0)

				return err;

		}

		err = write_v110_format_block(cntr, &buf.v110_data,

					      frames_per_second, byte_count);

	}

	return err;

}

static int voc_builder_pre_process(struct container_context *cntr,

				   snd_pcm_format_t *format,

				   unsigned int *samples_per_frame,

				   unsigned int *frames_per_second,

				   uint64_t *byte_count)

{

	struct builder_state *state = cntr->private_data;

	int i;

	// Validate parameters.

	for (i = 0; i < ARRAY_SIZE(format_maps); ++i) {

		if (format_maps[i].format == *format)

			break;

	}

	if (i == ARRAY_SIZE(format_maps))

		return -EINVAL;

	state->code_id = format_maps[i].code_id;

	// Decide container version.

	if (*samples_per_frame > 2)

		state->version = VOC_VERSION_1_20;

	else

		state->version = format_maps[i].minimal_version;

	if (state->version == VOC_VERSION_1_10) {

		if (*samples_per_frame == 2) {

			for (i = 0;

			     i < ARRAY_SIZE(ex_v110_time_consts); ++i) {

				if (ex_v110_time_consts[i].frames_per_second ==

						*frames_per_second)

					break;

			}

			if (i == ARRAY_SIZE(ex_v110_time_consts))

				state->version = VOC_VERSION_1_20;

			else

				state->extended = true;

		} else {

			for (i = 0; i < ARRAY_SIZE(v110_time_consts); ++i) {

				if (v110_time_consts[i].frames_per_second ==

							*frames_per_second)

					break;

			}

			if (i == ARRAY_SIZE(v110_time_consts))

				state->version = VOC_VERSION_1_20;

		}

	}

	state->bytes_per_sample = snd_pcm_format_physical_width(*format) / 8;

	state->samples_per_frame = *samples_per_frame;

	return write_data_blocks(cntr, *frames_per_second, *byte_count);

}

static int write_block_terminator(struct container_context *cntr)

{

	struct block_terminator block = {0};

	block.type = BLOCK_TYPE_TERMINATOR;

	return container_recursive_write(cntr, &block, sizeof(block));

}

static int write_data_size(struct container_context *cntr, uint64_t byte_count)

{

	struct builder_state *state = cntr->private_data;

	off64_t offset;

	uint8_t size_field[3];

	int err;

	offset = sizeof(struct container_header) + sizeof(uint8_t);

	if (state->version == VOC_VERSION_1_10 && state->extended)

		offset += sizeof(struct block_extended_v110_format);

	err = container_seek_offset(cntr, offset);

	if (err < 0)

		return err;

	if (state->version == VOC_VERSION_1_10)

		offset = 2;

	else

		offset = 12;

	if (byte_count > cntr->max_size - offset)

		byte_count = cntr->max_size;

	else

		byte_count += offset;

	build_block_data_size(size_field, byte_count);

	return container_recursive_write(cntr, &size_field, sizeof(size_field));

}

static int voc_builder_post_process(struct container_context *cntr,

				    uint64_t handled_byte_count)

{

	int err;

	err = write_block_terminator(cntr);

	if (err < 0)

		return err;

	return write_data_size(cntr, handled_byte_count);

}

const struct container_parser container_parser_voc = {

	.format = CONTAINER_FORMAT_VOC,

	.magic = VOC_MAGIC,

	.max_size = 0xffffff -	// = UINT24_MAX.

		    sizeof(struct block_terminator),

	.ops = {

		.pre_process	= voc_parser_pre_process,

	},

	.private_size = sizeof(struct parser_state),

};

const struct container_builder container_builder_voc = {

	.format = CONTAINER_FORMAT_VOC,

	.max_size = 0xffffff -	// = UINT24_MAX.

		    sizeof(struct block_terminator),

	.ops = {

		.pre_process	= voc_builder_pre_process,

		.post_process	= voc_builder_post_process,

	},

	.private_size = sizeof(struct builder_state),

};