// 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),
};