/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2026 Goran Mekić
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
 */

/*
 * This program demonstrates low-latency audio pass-through using mmap
 * and kqueue.  It opens input and output audio devices using memory-
 * mapped I/O, synchronizes them in a sync group for simultaneous start,
 * then continuously copies audio data from input to output.  Buffer
 * positions are obtained from kqueue's ext[0] (replacing GETIPTR/
 * GETOPTR ioctls) and error counters from ext[1] (replacing GETERROR).
 */

#include <sys/event.h>

#include "oss.h"

/*
 * Copy data between ring buffers, handling wraparound.
 * The copy starts at 'offset' and copies 'length' bytes.
 * If the copy crosses the buffer boundary, it wraps to the beginning.
 */
static void
copy_ring(void *dstv, const void *srcv, int buffer_bytes, int offset,
    int length)
{
        uint8_t *dst = dstv;
        const uint8_t *src = srcv;
        int first;

        if (length <= 0)
                return;

        /* Calculate bytes to copy before wraparound */
        first = buffer_bytes - offset;
        if (first > length)
                first = length;

        /* Copy first part (up to buffer end or length) */
        memcpy(dst + offset, src + offset, first);

        /* Copy remaining part from beginning of buffer if needed */
        if (first < length)
                memcpy(dst, src, length - first);
}

int
main(int argc, char *argv[])
{
        int ch, bytes;
        int frag_size, frame_size, verbose = 0;
        int map_pointer = 0;
        int64_t read_progress = 0, write_progress = 0;
        oss_syncgroup sync_group = { 0, 0, { 0 } };
        struct config config_in = {
                .device = "/dev/dsp",
                .mode = O_RDONLY | O_EXCL | O_NONBLOCK,
                .format = AFMT_S32_NE,
                .sample_rate = 48000,
                .mmap = 1,
        };
        struct config config_out = {
                .device = "/dev/dsp",
                .mode = O_WRONLY | O_EXCL | O_NONBLOCK,
                .format = AFMT_S32_NE,
                .sample_rate = 48000,
                .mmap = 1,
        };
        struct kevent ev;
        int kq;

        while ((ch = getopt(argc, argv, "v")) != -1) {
                switch (ch) {
                case 'v':
                        verbose = 1;
                        break;
                }
        }
        argc -= optind;
        argv += optind;

        if (!verbose)
                printf("Use -v for verbose mode\n");

        oss_init(&config_in);
        oss_init(&config_out);

        /*
         * Verify input and output have matching ring-buffer geometry.
         * The passthrough loop copies raw bytes at the same offset in both mmap
         * buffers, so both devices must expose the same total byte count.
         * They must also use the same max_channels because frame_size is
         * derived from that value and all mmap pointers/lengths are expected to
         * stay aligned to whole frames on both sides. If channels differed, the
         * same byte offset could land in the middle of a frame on one device.
         */
        if (config_in.buffer_info.bytes != config_out.buffer_info.bytes)
                errx(1,
                    "Input and output configurations have different buffer sizes");
        if (config_in.audio_info.max_channels !=
            config_out.audio_info.max_channels)
                errx(1,
                    "Input and output configurations have different number of channels");

        bytes = config_in.buffer_info.bytes;
        frag_size = config_in.buffer_info.fragsize;
        frame_size = config_in.sample_size * config_in.audio_info.max_channels;
        if (frag_size != config_out.buffer_info.fragsize)
                errx(1,
                    "Input and output configurations have different fragment sizes");

        /* Clear output buffer to prevent noise on startup */
        memset(config_out.buf, 0, bytes);

        /* Configure and start sync group */
        sync_group.mode = PCM_ENABLE_INPUT;
        if (ioctl(config_in.fd, SNDCTL_DSP_SYNCGROUP, &sync_group) < 0)
                err(1, "Failed to add input to syncgroup");
        sync_group.mode = PCM_ENABLE_OUTPUT;
        if (ioctl(config_out.fd, SNDCTL_DSP_SYNCGROUP, &sync_group) < 0)
                err(1, "Failed to add output to syncgroup");
        if (ioctl(config_in.fd, SNDCTL_DSP_SYNCSTART, &sync_group.id) < 0)
                err(1, "Starting sync group failed");

        /* Create kqueue and register input device for read events */
        kq = kqueue();
        if (kq < 0)
                err(1, "kqueue failed");
        EV_SET(&ev, config_in.fd, EVFILT_READ, EV_ADD, 0, 0, NULL);
        if (kevent(kq, &ev, 1, NULL, 0, NULL) < 0)
                err(1, "kevent register failed");

        /*
         * Main processing loop:
         * Block on kevent() until input data is available.
         * ext[0] holds the current DMA pointer (GETIPTR/GETOPTR equivalent).
         * ext[1] holds the xrun count for the channel (GETERROR equivalent).
         */
        for (;;) {
                int n;
                int ptr;
                unsigned delta;

                n = kevent(kq, NULL, 0, &ev, 1, NULL);
                if (n < 0)
                        err(1, "kevent failed");
                if (n == 0)
                        continue;

                ptr = (int)ev.ext[0];
                if (ptr < 0 || ptr >= bytes)
                        errx(1, "Pointer out of bounds: %d", ptr);
                if ((ptr % frame_size) != 0)
                        errx(1, "Pointer %d not aligned to frame size %d", ptr,
                            frame_size);

                /*
                 * Calculate delta: how many bytes have been processed since
                 * last check. Handle ring buffer wraparound.
                 */
                delta = (ptr + bytes - map_pointer) % bytes;

                /* Update pointer and progress tracking */
                map_pointer = ptr;
                read_progress += delta;

                /* Report xruns if any */
                if (ev.ext[1] != 0 && verbose)
                        warnx("xruns: %llu", (unsigned long long)ev.ext[1]);

                /* Copy new audio data if available */
                if (read_progress > write_progress) {
                        int offset = write_progress % bytes;
                        int length = read_progress - write_progress;

                        copy_ring(config_out.buf, config_in.buf, bytes, offset,
                            length);
                        write_progress = read_progress;
                        if (verbose)
                                printf("copied %d bytes at %d (abs %lld)\n",
                                    length, offset, (long long)write_progress);
                }
        }

        close(kq);
        if (munmap(config_in.buf, bytes) != 0)
                err(1, "Memory unmap failed");
        config_in.buf = NULL;
        if (munmap(config_out.buf, bytes) != 0)
                err(1, "Memory unmap failed");
        config_out.buf = NULL;
        close(config_in.fd);
        close(config_out.fd);

        return (0);
}