sdrangel/dsd/dsd_audio.c

/*
 * Copyright (C) 2010 DSD Author
 * GPG Key ID: 0x3F1D7FD0 (74EF 430D F7F2 0A48 FCE6  F630 FAA2 635D 3F1D 7FD0)
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include "dsd.h"

void processAudio(dsd_opts * opts, dsd_state * state)
{

    int i, n;
    float aout_abs, max, gainfactor, gaindelta, maxbuf;

    if (opts->audio_gain == (float) 0)
    {
        // detect max level
        max = 0;
        state->audio_out_temp_buf_p = state->audio_out_temp_buf;
        for (n = 0; n < 160; n++)
        {
            aout_abs = fabsf(*state->audio_out_temp_buf_p);
            if (aout_abs > max)
            {
                max = aout_abs;
            }
            state->audio_out_temp_buf_p++;
        }
        *state->aout_max_buf_p = max;
        state->aout_max_buf_p++;
        state->aout_max_buf_idx++;
        if (state->aout_max_buf_idx > 24)
        {
            state->aout_max_buf_idx = 0;
            state->aout_max_buf_p = state->aout_max_buf;
        }

        // lookup max history
        for (i = 0; i < 25; i++)
        {
            maxbuf = state->aout_max_buf[i];
            if (maxbuf > max)
            {
                max = maxbuf;
            }
        }

        // determine optimal gain level
        if (max > (float) 0)
        {
            gainfactor = ((float) 30000 / max);
        }
        else
        {
            gainfactor = (float) 50;
        }
        if (gainfactor < state->aout_gain)
        {
            state->aout_gain = gainfactor;
            gaindelta = (float) 0;
        }
        else
        {
            if (gainfactor > (float) 50)
            {
                gainfactor = (float) 50;
            }
            gaindelta = gainfactor - state->aout_gain;
            if (gaindelta > ((float) 0.05 * state->aout_gain))
            {
                gaindelta = ((float) 0.05 * state->aout_gain);
            }
        }
        gaindelta /= (float) 160;
    }
    else
    {
        gaindelta = (float) 0;
    }

    if (opts->audio_gain >= 0)
    {
        // adjust output gain
        state->audio_out_temp_buf_p = state->audio_out_temp_buf;
        for (n = 0; n < 160; n++)
        {
            *state->audio_out_temp_buf_p = (state->aout_gain
                    + ((float) n * gaindelta)) * (*state->audio_out_temp_buf_p);
            state->audio_out_temp_buf_p++;
        }
        state->aout_gain += ((float) 160 * gaindelta);
    }

    // copy audio datat to output buffer and upsample if necessary
    state->audio_out_temp_buf_p = state->audio_out_temp_buf;
    if ((opts->split == 0) || (opts->upsample))
    {
        for (n = 0; n < 160; n++)
        {
            upsample(state, *state->audio_out_temp_buf_p);
            state->audio_out_temp_buf_p++;
            state->audio_out_float_buf_p += 6;
            state->audio_out_idx += 6;
            state->audio_out_idx2 += 6;
        }
        state->audio_out_float_buf_p -= (960 + opts->playoffset);
        // copy to output (short) buffer
        for (n = 0; n < 960; n++)
        {
            if (*state->audio_out_float_buf_p > (float) 32760)
            {
                *state->audio_out_float_buf_p = (float) 32760;
            }
            else if (*state->audio_out_float_buf_p < (float) -32760)
            {
                *state->audio_out_float_buf_p = (float) -32760;
            }
            *state->audio_out_buf_p = (short) *state->audio_out_float_buf_p;
            state->audio_out_buf_p++;
            state->audio_out_float_buf_p++;
        }
        state->audio_out_float_buf_p += opts->playoffset;
    }
    else
    {
        for (n = 0; n < 160; n++)
        {
            if (*state->audio_out_temp_buf_p > (float) 32760)
            {
                *state->audio_out_temp_buf_p = (float) 32760;
            }
            else if (*state->audio_out_temp_buf_p < (float) -32760)
            {
                *state->audio_out_temp_buf_p = (float) -32760;
            }
            *state->audio_out_buf_p = (short) *state->audio_out_temp_buf_p;
            state->audio_out_buf_p++;
            state->audio_out_temp_buf_p++;
            state->audio_out_idx++;
            state->audio_out_idx2++;
        }
    }
}

void writeSynthesizedVoice(dsd_opts * opts, dsd_state * state)
{
#ifdef USE_LIBSNDFILE
    int n;
    short aout_buf[160];
    short *aout_buf_p;

//  for(n=0; n<160; n++)
//    fprintf(stderr, "%d ", ((short*)(state->audio_out_temp_buf))[n]);
//  fprintf(stderr, "\n");

    aout_buf_p = aout_buf;
    state->audio_out_temp_buf_p = state->audio_out_temp_buf;

    for (n = 0; n < 160; n++)
    {
        if (*state->audio_out_temp_buf_p > (float) 32767)
        {
            *state->audio_out_temp_buf_p = (float) 32767;
        }
        else if (*state->audio_out_temp_buf_p < (float) -32768)
        {
            *state->audio_out_temp_buf_p = (float) -32768;
        }
        *aout_buf_p = (short) *state->audio_out_temp_buf_p;
        aout_buf_p++;
        state->audio_out_temp_buf_p++;
    }

    sf_write_short(opts->wav_out_f, aout_buf, 160);
    /*

     int n;
     short aout_buf[160];
     short *aout_buf_p;
     ssize_t result;

     aout_buf_p = aout_buf;
     state->audio_out_temp_buf_p = state->audio_out_temp_buf;
     for (n = 0; n < 160; n++)
     {
     if (*state->audio_out_temp_buf_p > (float) 32760)
     {
     *state->audio_out_temp_buf_p = (float) 32760;
     }
     else if (*state->audio_out_temp_buf_p < (float) -32760)
     {
     *state->audio_out_temp_buf_p = (float) -32760;
     }
     *aout_buf_p = (short) *state->audio_out_temp_buf_p;
     aout_buf_p++;
     state->audio_out_temp_buf_p++;
     }

     result = write (opts->wav_out_fd, aout_buf, 320);
     fflush (opts->wav_out_f);
     state->wav_out_bytes += 320;
     */
#endif
}

void playSynthesizedVoice(dsd_opts * opts, dsd_state * state)
{

    ssize_t result;

    if (state->audio_out_idx > opts->delay)
    {
        // output synthesized speech to sound card
        if (opts->audio_out_fd == -1)
        {
            memcpy(state->output_buffer + state->output_offset,
                    (state->audio_out_buf_p - state->audio_out_idx),
                    (state->audio_out_idx * 2));
            state->output_offset += state->audio_out_idx;
        }
        else
        {
            result = write(opts->audio_out_fd,
                    (state->audio_out_buf_p - state->audio_out_idx),
                    (state->audio_out_idx * 2));
        }
        state->audio_out_idx = 0;
    }

    if (state->audio_out_idx2 >= 800000)
    {
        state->audio_out_float_buf_p = state->audio_out_float_buf + 100;
        state->audio_out_buf_p = state->audio_out_buf + 100;
        memset(state->audio_out_float_buf, 0, 100 * sizeof(float));
        memset(state->audio_out_buf, 0, 100 * sizeof(short));
        state->audio_out_idx2 = 0;
    }
}

void openAudioOutDevice(dsd_opts * opts, int speed)
{
    // get info of device/file
    struct stat stat_buf;
    if (stat(opts->audio_out_dev, &stat_buf) != 0)
    {
        fprintf(stderr, "Error, couldn't open %s\n", opts->audio_out_dev);
        exit(1);
    }

    if (!(S_ISCHR(stat_buf.st_mode) || S_ISBLK(stat_buf.st_mode)))
    { // this is not a device
        fprintf(stderr,
                "Error, %s is not a device. use -w filename for wav output.\n",
                opts->audio_out_dev);
        exit(1);
    }
#ifdef SOLARIS
    sample_info_t aset, aget;

    opts->audio_out_fd = open (opts->audio_out_dev, O_WRONLY);
    if (opts->audio_out_fd == -1)
    {
        fprintf(stderr, "Error, couldn't open %s\n", opts->audio_out_dev);
        exit (1);
    }

    // get current
    ioctl (opts->audio_out_fd, AUDIO_GETINFO, &aset);

    aset.record.sample_rate = speed;
    aset.play.sample_rate = speed;
    aset.record.channels = 1;
    aset.play.channels = 1;
    aset.record.precision = 16;
    aset.play.precision = 16;
    aset.record.encoding = AUDIO_ENCODING_LINEAR;
    aset.play.encoding = AUDIO_ENCODING_LINEAR;

    if (ioctl (opts->audio_out_fd, AUDIO_SETINFO, &aset) == -1)
    {
        fprintf(stderr, "Error setting sample device parameters\n");
        exit (1);
    }
#endif

#if defined(BSD) && !defined(__APPLE__) && defined(USE_LIBSNDFILE)

    int fmt;

    opts->audio_out_fd = open (opts->audio_out_dev, O_WRONLY);
    if (opts->audio_out_fd == -1)
    {
        fprintf(stderr, "Error, couldn't open %s\n", opts->audio_out_dev);
        opts->audio_out = 0;
        exit(1);
    }

    fmt = 0;
    if (ioctl (opts->audio_out_fd, SNDCTL_DSP_RESET) < 0)
    {
        fprintf(stderr, "ioctl reset error \n");
    }
    fmt = speed;
    if (ioctl (opts->audio_out_fd, SNDCTL_DSP_SPEED, &fmt) < 0)
    {
        fprintf(stderr, "ioctl speed error \n");
    }
    fmt = 0;
    if (ioctl (opts->audio_out_fd, SNDCTL_DSP_STEREO, &fmt) < 0)
    {
        fprintf(stderr, "ioctl stereo error \n");
    }
    fmt = AFMT_S16_LE;
    if (ioctl (opts->audio_out_fd, SNDCTL_DSP_SETFMT, &fmt) < 0)
    {
        fprintf(stderr, "ioctl setfmt error \n");
    }

#endif
    fprintf(stderr, "Audio Out Device: %s\n", opts->audio_out_dev);
}

void openAudioInDevice(dsd_opts * opts)
{
#ifdef USE_LIBSNDFILE
    // get info of device/file
    struct stat stat_buf;
    if (stat(opts->audio_in_dev, &stat_buf) != 0)
    {
        fprintf(stderr, "Error, couldn't open %s\n", opts->audio_in_dev);
        exit(1);
    }
    if(S_ISREG(stat_buf.st_mode))
    { // is this a regular file? then process with libsndfile.
        opts->audio_in_type = 1;
        opts->audio_in_file_info = calloc(1, sizeof(SF_INFO));
        opts->audio_in_file_info->channels = 1;
        opts->audio_in_file = sf_open(opts->audio_in_dev, SFM_READ, opts->audio_in_file_info);
        if(opts->audio_in_file == NULL)
        {
            fprintf(stderr, "Error, couldn't open file %s\n", opts->audio_in_dev);
            exit(1);
        }
    }
    else
    { // this is a device, use old handling
        opts->audio_in_type = 0;
#ifdef SOLARIS
        sample_info_t aset, aget;
        int rgain;

        rgain = 64;

        if (opts->split == 1)
        {
            opts->audio_in_fd = open (opts->audio_in_dev, O_RDONLY);
        }
        else
        {
            opts->audio_in_fd = open (opts->audio_in_dev, O_RDWR);
        }
        if (opts->audio_in_fd == -1)
        {
            fprintf(stderr, "Error, couldn't open %s\n", opts->audio_in_dev);
            exit(1);
        }

        // get current
        ioctl (opts->audio_in_fd, AUDIO_GETINFO, &aset);

        aset.record.sample_rate = 48000;
        aset.play.sample_rate = 48000;
        aset.record.channels = 1;
        aset.play.channels = 1;
        aset.record.precision = 16;
        aset.play.precision = 16;
        aset.record.encoding = AUDIO_ENCODING_LINEAR;
        aset.play.encoding = AUDIO_ENCODING_LINEAR;
        aset.record.port = AUDIO_LINE_IN;
        aset.record.gain = rgain;

        if (ioctl (opts->audio_in_fd, AUDIO_SETINFO, &aset) == -1)
        {
            fprintf(stderr, "Error setting sample device parameters\n");
            exit (1);
        }
#endif

#if defined(BSD) && !defined(__APPLE__)
        int fmt;

        if (opts->split == 1)
        {
            opts->audio_in_fd = open (opts->audio_in_dev, O_RDONLY);
        }
        else
        {
            opts->audio_in_fd = open (opts->audio_in_dev, O_RDWR);
        }

        if (opts->audio_in_fd == -1)
        {
            fprintf(stderr, "Error, couldn't open %s\n", opts->audio_in_dev);
            opts->audio_out = 0;
        }

        fmt = 0;
        if (ioctl (opts->audio_in_fd, SNDCTL_DSP_RESET) < 0)
        {
            fprintf(stderr, "ioctl reset error \n");
        }
        fmt = 48000;
        if (ioctl (opts->audio_in_fd, SNDCTL_DSP_SPEED, &fmt) < 0)
        {
            fprintf(stderr, "ioctl speed error \n");
        }
        fmt = 0;
        if (ioctl (opts->audio_in_fd, SNDCTL_DSP_STEREO, &fmt) < 0)
        {
            fprintf(stderr, "ioctl stereo error \n");
        }
        fmt = AFMT_S16_LE;
        if (ioctl (opts->audio_in_fd, SNDCTL_DSP_SETFMT, &fmt) < 0)
        {
            fprintf(stderr, "ioctl setfmt error \n");
        }
#endif
    }
    if (opts->split == 1)
    {
        fprintf(stderr, "Audio In Device: %s\n", opts->audio_in_dev);
    }
    else
    {
        fprintf(stderr, "Audio In/Out Device: %s\n", opts->audio_in_dev);
    }
#endif
}