/*
 * Copyright (c) 2015 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup libriff
 * @{
 */
/**
 * @file Waveform Audio File Format (WAVE).
 */

#include <assert.h>
#include <byteorder.h>
#include <errno.h>
#include <macros.h>
#include <mem.h>
#include <riff/chunk.h>
#include <riff/rwave.h>
#include <stdlib.h>

/** Encode format chunk data.
 *
 * @params params	WAVE parameters
 * @params fmt		Pointer to fmt chunk data structure to fill in
 */
static void rwave_encode_fmt(rwave_params_t *params, rwave_fmt_t *fmt)
{
	int bytes_smp;

	bytes_smp = (params->bits_smp + 7) / 8;

	fmt->format_tag = host2uint16_t_le(WFMT_PCM);
	fmt->channels = host2uint16_t_le(params->channels);
	fmt->smp_sec = host2uint32_t_le(params->smp_freq);
	fmt->avg_bytes_sec = host2uint32_t_le(bytes_smp * params->smp_freq *
	    params->channels);
	fmt->block_align = host2uint16_t_le(bytes_smp);
	fmt->bits_smp = host2uint16_t_le(params->bits_smp);
}

/** Decode format chunk data.
 *
 * @param fmt	 Pointer to format chunk data
 * @param params WAVE parameters to fill in
 *
 * @return EOK on success, EINVAL if format is not supported.
 */
static int rwave_decode_fmt(rwave_fmt_t *fmt, rwave_params_t *params)
{
	uint16_t fmt_tag;

	fmt_tag = uint16_t_le2host(fmt->format_tag);
	printf("fmt_tag=0x%x\n", fmt_tag);
	if (fmt_tag != WFMT_PCM)
		return EINVAL;

	params->channels = uint16_t_le2host(fmt->channels);
	params->smp_freq = uint32_t_le2host(fmt->smp_sec);
	params->bits_smp = uint16_t_le2host(fmt->bits_smp);

	return EOK;
}

/** Open WAVE file for writing.
 *
 * @param fname  File name
 * @param params WAVE file parameters
 * @param rww    Place to store pointer to WAVE writer
 *
 * @return EOK on success, EIO on I/O error, ENOMEM if out of memory.
 */
errno_t rwave_wopen(const char *fname, rwave_params_t *params, rwavew_t **rww)
{
	riff_wchunk_t fmt;
	rwave_fmt_t rwfmt;
	errno_t rc;
	rwavew_t *ww;

	rwave_encode_fmt(params, &rwfmt);

	ww = calloc(1, sizeof(rwavew_t));
	if (ww == NULL) {
		rc = ENOMEM;
		goto error;
	}

	ww->bufsize = 4096;
	ww->buf = calloc(1, ww->bufsize);
	if (ww->buf == NULL) {
		rc = ENOMEM;
		goto error;
	}

	/* Make a copy of parameters */
	ww->params = *params;

	rc = riff_wopen(fname, &ww->rw);
	if (rc != EOK) {
		assert(rc == EIO || rc == ENOMEM);
		goto error;
	}

	rc = riff_wchunk_start(ww->rw, CKID_RIFF, &ww->wave);
	if (rc != EOK)
		goto error;

	rc = riff_write_uint32(ww->rw, FORM_WAVE);
	if (rc != EOK)
		goto error;

	rc = riff_wchunk_start(ww->rw, CKID_fmt, &fmt);
	if (rc != EOK)
		goto error;

	rc = riff_write(ww->rw, &rwfmt, sizeof(rwfmt));
	if (rc != EOK)
		goto error;

	rc = riff_wchunk_end(ww->rw, &fmt);
	if (rc != EOK)
		goto error;

	rc = riff_wchunk_start(ww->rw, CKID_data, &ww->data);
	if (rc != EOK)
		goto error;

	*rww = ww;
	return EOK;
error:
	if (ww != NULL)
		free(ww->buf);
	if (ww->rw != NULL)
		riff_wclose(ww->rw);
	free(ww);
	return rc;
}

/** Write samples to WAVE file.
 *
 * @param ww    WAVE writer
 * @param data  Pointer to data
 * @param bytes Number of bytes to write
 *
 * @return EOK on success, EIO on I/O error, ENOTSUP if sample format is
 *         not supported.
 */
errno_t rwave_write_samples(rwavew_t *ww, void *data, size_t bytes)
{
	size_t i;
	uint16_t *d16, *b16;
	size_t now;
	errno_t rc;

	/* Convert sample data to little endian */

	while (bytes > 0) {
		now = min(bytes, ww->bufsize);

		switch (ww->params.bits_smp / 8) {
		case 1:
			memcpy(ww->buf, data, now);
			break;
		case 2:
			b16 = (uint16_t *)ww->buf;
			d16 = (uint16_t *)data;
			for (i = 0; i < now / 2; i++) {
				b16[i] = host2uint16_t_le(d16[i]);
			}
			break;
		default:
			return ENOTSUP;
		}

		rc = riff_write(ww->rw, ww->buf, now);
		if (rc != EOK) {
			assert(rc == EIO);
			return rc;
		}

		bytes -= now;
		data += now;
	}

	return EOK;
}

/** Close WAVE file for writing.
 *
 * @param ww WAVE writer
 * @return EOK on success, EIO on I/O error - in which case @a ww is destroyed
 *         anyway.
 */
errno_t rwave_wclose(rwavew_t *ww)
{
	errno_t rc;

	rc = riff_wchunk_end(ww->rw, &ww->wave);
	if (rc == EOK)
		rc = riff_wchunk_end(ww->rw, &ww->data);

	rc = riff_wclose(ww->rw);

	ww->rw = NULL;
	free(ww->buf);
	free(ww);

	return rc;
}

/** Open WAVE file for reading.
 *
 * @param fname  File name
 * @param params WAVE file parameters
 * @param rwaver Place to store pointer to new wave reader
 *
 * @return EOK on success, EIO on I/O error, ENOMEM if out of memory
 */
errno_t rwave_ropen(const char *fname, rwave_params_t *params, rwaver_t **rwr)
{
	rwaver_t *wr = NULL;
	uint32_t form_id;
	riff_rchunk_t fmt;
	rwave_fmt_t wfmt;
	size_t nread;
	errno_t rc;

	wr = calloc(1, sizeof(rwaver_t));
	if (wr == NULL) {
		rc = ENOMEM;
		goto error;
	}

	rc = riff_ropen(fname, &wr->wave, &wr->rr);
	if (rc != EOK) {
		assert(rc == EIO || rc == ENOMEM);
		goto error;
	}

	if (wr->wave.ckid != CKID_RIFF) {
		printf("Not RIFF file\n");
		rc = ENOMEM;
		goto error;
	}

	rc = riff_read_uint32(&wr->wave, &form_id);
	if (rc != EOK) {
		assert(rc == EIO);
		goto error;
	}

	if (form_id != FORM_WAVE) {
		printf("wrong form ID\n");
		rc = EIO;
		goto error;
	}

	rc = riff_rchunk_start(&wr->wave, &fmt);
	if (rc != EOK) {
		assert(rc == EIO);
		goto error;
	}

	if (fmt.ckid != CKID_fmt) {
		printf("not fmt chunk\n");
		rc = ENOMEM;
		goto error;
	}

	rc = riff_read(&fmt, &wfmt, sizeof(rwave_fmt_t), &nread);
	if (rc != EOK) {
		printf("error reading fmt chunk\n");
		assert(rc == EIO || rc == ELIMIT);
		rc = EIO;
		goto error;
	}

	if (nread < sizeof(rwave_fmt_t)) {
		rc = EIO;
		goto error;
	}

	rc = riff_rchunk_end(&fmt);
	if (rc != EOK) {
		assert(rc == EIO);
		goto error;
	}

	rc = rwave_decode_fmt(&wfmt, params);
	if (rc != EOK) {
		printf("decode fmt fail\n");
		assert(rc == EINVAL);
		rc = EIO;
		goto error;
	}

	rc = riff_rchunk_start(&wr->wave, &wr->data);
	if (rc != EOK) {
		assert(rc == EIO);
		goto error;
	}

	if (wr->data.ckid != CKID_data) {
		printf("not data ckid\n");
		rc = EIO;
		goto error;
	}

	*rwr = wr;
	return EOK;
error:
	if (wr != NULL && wr->rr != NULL)
		riff_rclose(wr->rr);
	free(wr);
	return rc;
}

/** Read samples from WAVE file.
 *
 * @param wr    WAVE reader
 * @param buf   Buffer for storing the data
 * @param bytes Number of bytes to read
 * @param nread Place to store number of bytes actually read (>= 0).
 *
 * @return EOK if zero or more bytes successfully read and @a *nread is set,
 *         EIO on I/O error.
 */
errno_t rwave_read_samples(rwaver_t *wr, void *buf, size_t bytes, size_t *nread)
{
	errno_t rc;

	rc = riff_read(&wr->data, buf, bytes, nread);
	if (rc != EOK) {
		assert(rc == EIO || rc == ELIMIT);
		return EIO;
	}

	return EOK;
}

/** Close WAVE file for reading.
 *
 * @param wr WAVE reader
 *
 * @return EOK on success, EIO on I/O error in which case @a wr is destroyed
 *         anyway.
 */
errno_t rwave_rclose(rwaver_t *wr)
{
	errno_t rc;

	rc = riff_rchunk_end(&wr->wave);
	if (rc != EOK) {
		assert(rc == EIO);
		goto error;
	}

	riff_rclose(wr->rr);
	free(wr);
	return EOK;
error:
	return rc;
}

/** @}
 */