// SPDX-License-Identifier: GPL-2.0
//
// container-au.c - a parser/builder for a container of Sun Audio 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>

// Reference:
//  * http://pubs.opengroup.org/external/auformat.html

#define AU_MAGIC	".snd"
#define UNKNOWN_SIZE	UINT32_MAX

enum code_id {
	CODE_ID_CCIT_MU_LAW_BE		= 0x01,
	CODE_ID_GENERIC_MBLA_S8		= 0x02,
	CODE_ID_GENERIC_MBLA_S16_BE	= 0x03,
	CODE_ID_GENERIC_MBLA_S32_BE	= 0x05,
	CODE_ID_IEEE754_FLOAT_S32_BE	= 0x06,
	CODE_ID_IEEE754_DOUBLE_S64_BE	= 0x07,
	CODE_ID_CCIT_ADPCM_G721_4BIT_BE	= 0x17,
	CODE_ID_CCIT_ADPCM_G723_3BIT_BE	= 0x19,
	CODE_ID_CCIT_A_LAW_BE		= 0x1b,
};

struct format_map {
	enum code_id code_id;
	snd_pcm_format_t format;
};

static const struct format_map format_maps[] = {
	{CODE_ID_GENERIC_MBLA_S8,		SND_PCM_FORMAT_S8},
	{CODE_ID_GENERIC_MBLA_S16_BE,		SND_PCM_FORMAT_S16_BE},
	{CODE_ID_GENERIC_MBLA_S32_BE,		SND_PCM_FORMAT_S32_BE},
	{CODE_ID_IEEE754_FLOAT_S32_BE,		SND_PCM_FORMAT_FLOAT_BE},
	{CODE_ID_IEEE754_DOUBLE_S64_BE,		SND_PCM_FORMAT_FLOAT64_BE},
	// CODE_ID_CCIT_ADPCM_G721_4BIT_BE is not supported by ALSA.
	// CODE_ID_CCIT_ADPCM_G723_3BIT_BE is not supported due to width of
	// its sample.
	{CODE_ID_CCIT_A_LAW_BE,			SND_PCM_FORMAT_A_LAW},
	{CODE_ID_CCIT_MU_LAW_BE,		SND_PCM_FORMAT_MU_LAW},
};

struct container_header {
	uint8_t magic[4];
	uint32_t hdr_size;
	uint32_t data_size;
	uint32_t code_id;
	uint32_t frames_per_second;
	uint32_t samples_per_frame;
};

struct container_annotation {
	uint32_t chunks[0];
};

struct parser_state {
	enum code_id code_id;
	unsigned int samples_per_frame;
	unsigned int bytes_per_sample;
};

static int au_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;
	struct container_header header;
	enum code_id code_id;
	int i;
	int err;

	// Parse header. 4 bytes are enough to detect supported containers.
	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;

	if (memcmp(header.magic, AU_MAGIC, sizeof(header.magic)) != 0)
		return -EINVAL;
	if (be32toh(header.hdr_size) != sizeof(struct container_header))
		return -EINVAL;

	code_id = be32toh(header.code_id);
	for (i = 0; i < ARRAY_SIZE(format_maps); ++i) {
		if (format_maps[i].code_id == code_id)
			break;
	}
	if (i == ARRAY_SIZE(format_maps))
		return -EINVAL;
	*format = format_maps[i].format;
	*frames_per_second = be32toh(header.frames_per_second);
	*samples_per_frame = be32toh(header.samples_per_frame);

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

	*byte_count = be32toh(header.data_size);

	return 0;
}

struct builder_state {
	unsigned int bytes_per_sample;
	unsigned int samples_per_frame;
	unsigned int frames_per_second;
	enum code_id code_id;
};

static void build_container_header(struct builder_state *state,
				   struct container_header *header,
				   unsigned int frames_per_second,
				   uint64_t byte_count)
{
	memcpy(header->magic, AU_MAGIC, sizeof(header->magic));
	header->hdr_size = htobe32(sizeof(struct container_header));
	header->data_size = htobe32(byte_count);
	header->code_id = htobe32(state->code_id);
	header->frames_per_second = htobe32(frames_per_second);
	header->samples_per_frame = htobe32(state->samples_per_frame);
}

static int write_container_header(struct container_context *cntr,
				  uint64_t byte_count)
{
	struct builder_state *state = cntr->private_data;
	struct container_header header;

	build_container_header(state, &header, state->frames_per_second,
			       byte_count);

	return container_recursive_write(cntr, &header, sizeof(header));
}

static int au_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 *status = cntr->private_data;
	int i;

	for (i = 0; i < ARRAY_SIZE(format_maps); ++i) {
		if (format_maps[i].format == *format)
			break;
	}
	if (i == ARRAY_SIZE(format_maps))
		return -EINVAL;

	status->code_id = format_maps[i].code_id;
	status->bytes_per_sample = snd_pcm_format_physical_width(*format) / 8;
	status->frames_per_second = *frames_per_second;
	status->samples_per_frame = *samples_per_frame;

	return write_container_header(cntr, *byte_count);
}

static int au_builder_post_process(struct container_context *cntr,
				   uint64_t handled_byte_count)
{
	int err;

	err = container_seek_offset(cntr, 0);
	if (err < 0)
		return err;

	return write_container_header(cntr, handled_byte_count);
}

const struct container_parser container_parser_au = {
	.format = CONTAINER_FORMAT_AU,
	.magic = AU_MAGIC,
	.max_size = UINT32_MAX,
	.ops = {
		.pre_process = au_parser_pre_process,
	},
	.private_size = sizeof(struct parser_state),
};

const struct container_builder container_builder_au = {
	.format = CONTAINER_FORMAT_AU,
	.max_size = UINT32_MAX,
	.ops = {
		.pre_process	= au_builder_pre_process,
		.post_process	= au_builder_post_process,
	},
	.private_size = sizeof(struct builder_state),
};