apps/camogm2/camogm_wav.c

Go to the documentation of this file.

#include <endian.h>
#include <byteswap.h>
//#define _LARGEFILE64_SOURCE
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

#include "camogm_wav.h"
#include "camogm.h"

#include <alsa/asoundlib.h>

/* Definitions for Microsoft WAVE format */

#if __BYTE_ORDER == __LITTLE_ENDIAN
#define COMPOSE_ID(a,b,c,d)     ((a) | ((b)<<8) | ((c)<<16) | ((d)<<24))
#define LE_SHORT(v)             (v)
#define LE_INT(v)               (v)
#define BE_SHORT(v)             bswap_16(v)
#define BE_INT(v)               bswap_32(v)
#elif __BYTE_ORDER == __BIG_ENDIAN
#define COMPOSE_ID(a,b,c,d)     ((d) | ((c)<<8) | ((b)<<16) | ((a)<<24))
#define LE_SHORT(v)             bswap_16(v)
#define LE_INT(v)               bswap_32(v)
#define BE_SHORT(v)             (v)
#define BE_INT(v)               (v)
#else
#error "Wrong endian"
#endif

#define WAV_RIFF                COMPOSE_ID('R','I','F','F')
#define WAV_WAVE                COMPOSE_ID('W','A','V','E')
#define WAV_FMT                 COMPOSE_ID('f','m','t',' ')
#define WAV_DATA                COMPOSE_ID('d','a','t','a')
#define WAV_PCM_CODE            1

/* it's in chunks like .voc and AMIGA iff, but my source say there
   are in only in this combination, so I combined them in one header;
   it works on all WAVE-file I have
 */
typedef struct {
        u_int magic;            /* 'RIFF' */
        u_int length;           /* filelen */
        u_int type;             /* 'WAVE' */
} WaveHeader;

typedef struct {
        u_short format;         /* should be 1 for PCM-code */
        u_short modus;          /* 1 Mono, 2 Stereo */
        u_int sample_fq;        /* frequence of sample */
        u_int byte_p_sec;
        u_short byte_p_spl;     /* samplesize; 1 or 2 bytes */
        u_short bit_p_spl;      /* 8, 12 or 16 bit */
} WaveFmtBody;

typedef struct {
        u_int type;             /* 'data' */
        u_int length;           /* samplecount */
} WaveChunkHeader;

long long fdcount = 0;

/* write a WAVE-header */
static int begin_wave(int fd, size_t cnt) {
        WaveHeader h;
        WaveFmtBody f;
        WaveChunkHeader cf, cd;
        int bits;
        u_int tmp;
        u_short tmp2;

        /* WAVE cannot handle greater than 32bit (signed?) int */
        if(cnt == (size_t) - 2)
                cnt = 0x7fffff00;

        bits = 8;
        switch ((unsigned long) state->audio_format) {
        case SND_PCM_FORMAT_U8:
                bits = 8;
                break;
        case SND_PCM_FORMAT_S16_LE:
        case SND_PCM_FORMAT_S16_BE:
                bits = 16;
                break;
        case SND_PCM_FORMAT_S32_LE:
                bits = 32;
                break;
        case SND_PCM_FORMAT_S24_LE:
        case SND_PCM_FORMAT_S24_3LE:
                bits = 24;
                break;
        default:
                return -1;
//              error(_("Wave doesn't support %s format..."), snd_pcm_format_name(state->audio_format));
//              exit(EXIT_FAILURE);
        }
        h.magic = WAV_RIFF;
        tmp = cnt + sizeof(WaveHeader) + sizeof(WaveChunkHeader) + sizeof(WaveFmtBody) + sizeof(WaveChunkHeader) - 8;
        h.length = LE_INT(tmp);
        h.type = WAV_WAVE;

        cf.type = WAV_FMT;
        cf.length = LE_INT(16);

        f.format = LE_SHORT(WAV_PCM_CODE);
        f.modus = LE_SHORT(state->audio_channels);
        f.sample_fq = LE_INT(state->audio_rate);
#if 0
        tmp2 = (samplesize == 8) ? 1 : 2;
        f.byte_p_spl = LE_SHORT(tmp2);
        tmp = dsp_speed * hwparams.channels * (u_int) tmp2;
#else
        tmp2 = state->audio_channels * snd_pcm_format_physical_width(state->audio_format) / 8;
        f.byte_p_spl = LE_SHORT(tmp2);
        tmp = (u_int) tmp2 * state->audio_rate;
#endif
        f.byte_p_sec = LE_INT(tmp);
        f.bit_p_spl = LE_SHORT(bits);

        cd.type = WAV_DATA;
        cd.length = LE_INT(cnt);

        if(write(fd, &h, sizeof(WaveHeader)) != sizeof(WaveHeader) ||
                write(fd, &cf, sizeof(WaveChunkHeader)) != sizeof(WaveChunkHeader) ||
                write(fd, &f, sizeof(WaveFmtBody)) != sizeof(WaveFmtBody) ||
                write(fd, &cd, sizeof(WaveChunkHeader)) != sizeof(WaveChunkHeader)) {
                return -2;
//              error(_("write error"));
//              exit(EXIT_FAILURE);
        }

        return 0;
}

static void end_wave(int fd) {
        /* only close output */
        WaveChunkHeader cd;
        off_t length_seek;
        off_t filelen;
        u_int rifflen;
        
        length_seek = sizeof(WaveHeader) + sizeof(WaveChunkHeader) + sizeof(WaveFmtBody);
        cd.type = WAV_DATA;
        cd.length = fdcount > 0x7fffffff ? LE_INT(0x7fffffff) : LE_INT(fdcount);
        filelen = fdcount + 2*sizeof(WaveChunkHeader) + sizeof(WaveFmtBody) + 4;
        rifflen = filelen > 0x7fffffff ? LE_INT(0x7fffffff) : LE_INT(filelen);
        if(lseek(fd, 4, SEEK_SET) == 4)
                write(fd, &rifflen, 4);
        if(lseek(fd, length_seek, SEEK_SET) == length_seek)
                write(fd, &cd, sizeof(WaveChunkHeader));
        if(fd != 1)
                close(fd);
}

int wave_fd;

void wave_begin(const char *fname) {
        wave_fd = open(fname, O_RDWR | O_CREAT);
        int r = begin_wave(wave_fd, 0);
fprintf(stderr, "fname == \"%s\", wave_fd == %d, begin_wave() == %d\n", fname, wave_fd, r);
}

void wave_push(void *buf, int len) {
        fdcount += write(wave_fd, buf, len);
}

void wave_end() {
        end_wave(wave_fd);
}

---