Digi
/
meta-digi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

meta-digi-dey: dey-examples: Remove vplay example from dey-examples 

This commit removes the vplay example from the rootfs because it is superseded
by gstreamer examples.

Signed-off-by: Mike Engel <Mike.Engel@digi.com>
This commit is contained in:
Mike Engel 2020-08-13 15:26:53 +02:00
parent 15f9aeba0e
commit 5fa8b17a09
4 changed files with 0 additions and 1062 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
meta-digi-dey/recipes-digi/dey-examples/dey-examples-vplay.bb
View File

@ -1,19 +0,0 @@
# Copyright (C) 2013,2017 Digi International.
SUMMARY = "DEY examples: OSS (open sound system) test application"
SECTION = "examples"
LICENSE = "GPL-2.0"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/GPL-2.0;md5=801f80980d171dd6425610833a22dbe6"
SRC_URI = "file://vplay_test"
S = "${WORKDIR}/vplay_test"
do_compile() {
${CC} -O2 -Wall ${LDFLAGS} vplay.c -o vplay
}
do_install() {
install -d ${D}${bindir}
install -m 0755 vplay ${D}${bindir}
}

97
meta-digi-dey/recipes-digi/dey-examples/files/vplay_test/fmtheaders.h
View File

@ -1,97 +0,0 @@
/*
* fmtheaders.h
*/
#ifndef _FMTHEADERS_H
#define _FMTHEADERS_H 1
#include <sys/types.h>
/* Definitions for .VOC files */
#define MAGIC_STRING "Creative Voice File\x1A"
#define ACTUAL_VERSION 0x010A
#define VOC_SAMPLESIZE 8
#define MODE_MONO 0
#define MODE_STEREO 1
#define DATALEN(bp) ((u_long)(bp->datalen) | \
((u_long)(bp->datalen_m) << 8) | \
((u_long)(bp->datalen_h) << 16) )
typedef struct _vocheader {
u_char magic[20]; /* must be MAGIC_STRING */
u_short headerlen; /* Headerlength, should be 0x1A */
u_short version; /* VOC-file version */
u_short coded_ver; /* 0x1233-version */
} VocHeader;
typedef struct _blocktype {
u_char type;
u_char datalen; /* low-byte */
u_char datalen_m; /* medium-byte */
u_char datalen_h; /* high-byte */
} BlockType;
typedef struct _voice_data {
u_char tc;
u_char pack;
} Voice_data;
typedef struct _ext_block {
u_short tc;
u_char pack;
u_char mode;
} Ext_Block;
/* Definitions for Microsoft WAVE format */
#define RIFF 0x46464952
#define WAVE 0x45564157
#define FMT 0x20746D66
#define DATA 0x61746164
#define PCM_CODE 1
#define WAVE_MONO 1
#define WAVE_STEREO 2
/* 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 _waveheader {
u_long main_chunk; /* 'RIFF' */
u_long length; /* filelen */
u_long chunk_type; /* 'WAVE' */
u_long sub_chunk; /* 'fmt ' */
u_long sc_len; /* length of sub_chunk, =16 */
u_short format; /* should be 1 for PCM-code */
u_short modus; /* 1 Mono, 2 Stereo */
u_long sample_fq; /* frequence of sample */
u_long byte_p_sec;
u_short byte_p_spl; /* samplesize; 1 or 2 bytes */
u_short bit_p_spl; /* 8, 12 or 16 bit */
u_long data_chunk; /* 'data' */
u_long data_length; /* samplecount */
} WaveHeader;
typedef struct {
long magic; /* must be equal to SND_MAGIC */
long dataLocation; /* Offset or pointer to the raw data */
long dataSize; /* Number of bytes of data in the raw data */
long dataFormat; /* The data format code */
long samplingRate; /* The sampling rate */
long channelCount; /* The number of channels */
} SndHeader;
#define SND_MAGIC ((long int)0x2e736e64)
#define SND_FORMAT_UNSPECIFIED (0)
#define SND_FORMAT_MULAW_8 (1)
#define SND_FORMAT_LINEAR_8 (2)
#define SND_FORMAT_LINEAR_16 (3)
#define SND_FORMAT_LINEAR_24 (4)
#define SND_FORMAT_LINEAR_32 (5)
#define SND_FORMAT_FLOAT (6)
#endif

945
meta-digi-dey/recipes-digi/dey-examples/files/vplay_test/vplay.c
View File

@ -1,945 +0,0 @@
/*
* vplay.c
*
* Copyright (C) 2009-2013 by Digi International Inc.
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*
* Description: play and record sound files
*
* Just cosmetic changes of vplay.c from OSS project:
*
* <http://www.opensound.com/oss.html>
* <http://mercurial.opensound.com/>
*
* with following original notice:
*
* vplay.c - plays and records
* CREATIVE LABS VOICE-files, Microsoft WAVE-files and raw data
*
* Autor: Michael Beck - beck@informatik.hu-berlin.de
*
*/
#include <stdio.h>
#include <malloc.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/soundcard.h>
#include "fmtheaders.h"
#include <netinet/in.h>
#define DEFAULT_DSP_SPEED 8000
#define RECORD 0
#define PLAY 1
#define AUDIO "/dev/dsp"
#define min(a,b) ((a) <= (b) ? (a) : (b))
#define d_printf(x) if (verbose_mode) fprintf x
#define VOC_FMT 0
#define WAVE_FMT 1
#define RAW_DATA 2
#define SND_FMT 3
/* global data */
int timelimit = 0, dsp_speed = DEFAULT_DSP_SPEED, dsp_stereo = 0;
int samplesize = 8;
int quiet_mode = 0;
int verbose_mode = 0;
int convert = 0;
int record_type = VOC_FMT;
u_long count;
int audio, abuf_size, zbuf_size;
int direction, omode;
u_char *audiobuf, *zerobuf;
char *command;
int vocminor, vocmajor; /* .VOC version */
/* defaults for playing raw data */
struct {
int timelimit, dsp_speed, dsp_stereo, samplesize;
} raw_info = {
0, DEFAULT_DSP_SPEED, 0, 8
};
/* needed prototypes */
void record_play(char *name);
void start_voc(int fd, u_long count);
void start_wave(int fd, u_long count);
void start_snd(int fd, u_long count);
void end_voc(int fd);
void end_wave_raw(int fd);
void end_snd(int fd);
u_long calc_count();
struct fmt_record {
void (*start) (int fd, u_long count);
void (*end) (int fd);
char *what;
} fmt_rec_table[] = {
{start_voc, end_voc, "VOC"},
{start_wave, end_wave_raw, "WAVE"},
{NULL, end_wave_raw, "raw data"},
{start_snd, end_snd, "SND"}
};
int main(int argc, char *argv[])
{
int c, n = 0;
command = argv[0];
if (strstr(argv[0], "vrec")) {
direction = RECORD;
omode = O_RDONLY;
} else if (strstr(argv[0], "vplay")) {
direction = PLAY;
omode = O_WRONLY;
} else {
fprintf(stderr, "Error: command should be named either vrec or vplay\n");
exit(1);
}
while ((c = getopt(argc, argv, "aqs:St:b:vrwd")) != EOF)
switch (c) {
case 'S':
dsp_stereo = raw_info.dsp_stereo = 1;
break;
case 'q':
quiet_mode = 1;
break;
case 'r':
record_type = RAW_DATA;
break;
case 'v':
record_type = VOC_FMT;
break;
case 'w':
record_type = WAVE_FMT;
break;
case 'a':
record_type = SND_FMT;
break;
case 's':
dsp_speed = atoi(optarg);
if (dsp_speed < 300)
dsp_speed *= 1000;
raw_info.dsp_speed = dsp_speed;
break;
case 't':
timelimit = raw_info.timelimit = atoi(optarg);
break;
case 'b':
samplesize = raw_info.samplesize = atoi(optarg);
break;
case 'd':
verbose_mode = 1;
quiet_mode = 0;
break;
default:
fprintf(stderr,
"Usage: %s [-qvwraS] [-t secs] [-s Hz] [-b 8|12|16] [filename]\n",
command);
exit(-1);
}
audio = open(AUDIO, omode, 0);
if (audio == -1) {
perror(AUDIO);
exit(-1);
}
abuf_size = -1;
ioctl(audio, SNDCTL_DSP_GETBLKSIZE, &abuf_size);
if (abuf_size < 4 || abuf_size > 65536) {
if (abuf_size == -1) {
perror(AUDIO);
exit(-1);
}
abuf_size = 1024;
}
zbuf_size = 256;
if ((audiobuf = (u_char *) malloc(abuf_size)) == NULL ||
(zerobuf = (u_char *) malloc(zbuf_size)) == NULL) {
fprintf(stderr, "%s: unable to allocate input/output buffer\n", command);
exit(-1);
}
memset((char *)zerobuf, 128, zbuf_size);
if (optind > argc - 1)
record_play(NULL);
else
while (optind <= argc - 1) {
if (n++ > 0)
if (ioctl(audio, SNDCTL_DSP_SYNC, NULL) < 0) {
perror(AUDIO);
exit(-1);
}
record_play(argv[optind++]);
}
close(audio);
return 0;
}
/*
* Function: test_vocfile
* Description: test, if it is a .VOC file
* Return: >= 0 if ok (this is the length of rest)
* < 0 if not
*/
int test_vocfile(void *buffer)
{
VocHeader *vp = buffer;
if (!strcmp((const char *)vp->magic, MAGIC_STRING)) {
vocminor = vp->version & 0xFF;
vocmajor = vp->version / 256;
if (vp->version != (0x1233 - vp->coded_ver))
return -2; /* coded version mismatch */
return vp->headerlen - sizeof(VocHeader); /* 0 mostly */
}
return -1; /* magic string fail */
}
/*
* Function: test_wavefile
* Description: test, if it is a .WAV file
* Return: 0 if ok (and set the speed, stereo etc.)
* < 0 if not
*/
int test_wavefile(void *buffer)
{
WaveHeader *wp = buffer;
if (wp->main_chunk == RIFF && wp->chunk_type == WAVE &&
wp->sub_chunk == FMT && wp->data_chunk == DATA) {
if (wp->format != PCM_CODE) {
fprintf(stderr, "%s: can't play not PCM-coded WAVE-files\n", command);
exit(-1);
}
if (wp->modus > 2) {
fprintf(stderr,
"%s: can't play WAVE-files with %d tracks\n",
command, wp->modus);
exit(-1);
}
dsp_stereo = (wp->modus == WAVE_STEREO) ? 1 : 0;
samplesize = wp->bit_p_spl;
dsp_speed = wp->sample_fq;
count = wp->data_length;
return 0;
}
return -1;
}
/*
* Function: test_sndfile
* Description: test, if it is a .SND file
* Return: 0 if ok (and set the speed, stereo etc.)
* < 0 if not
*/
int test_sndfile(void *buffer, int fd)
{
long infolen;
char *info;
SndHeader *snd = buffer;
if (snd->magic == SND_MAGIC)
convert = 0;
else {
if (htonl(snd->magic) == SND_MAGIC) {
convert = 1;
snd->dataLocation = htonl(snd->dataLocation);
snd->dataSize = htonl(snd->dataSize);
snd->dataFormat = htonl(snd->dataFormat);
snd->samplingRate = htonl(snd->samplingRate);
snd->channelCount = htonl(snd->channelCount);
} else {
/* No SoundFile */
return (-1);
}
}
switch (snd->dataFormat) {
case SND_FORMAT_LINEAR_8:
samplesize = 8;
break;
case SND_FORMAT_LINEAR_16:
samplesize = 16;
break;
default:
fprintf(stderr, "%s: Unsupported SND_FORMAT\n", command);
exit(-1);
}
dsp_stereo = (snd->channelCount == 2) ? 1 : 0;
dsp_speed = snd->samplingRate;
count = snd->dataSize;
/* read Info-Strings */
infolen = snd->dataLocation - sizeof(SndHeader);
info = (char *)malloc(infolen);
read(fd, info, infolen);
if (!quiet_mode)
fprintf(stderr, "SoundFile Info: %s\n", info);
free(info);
return 0;
}
/*
* Function: write_zeros
* Description: write zeros from zerobuf to simulate silence
*/
void write_zeros(unsigned x)
{
unsigned l;
while (x) {
l = min(x, zbuf_size);
if (write(audio, (char *)zerobuf, l) != l) {
perror(AUDIO);
exit(-1);
}
x -= l;
}
}
/*
* Function: sync_dsp
* Description: (is needed if we plan to change speed, stereo ... during output)
*/
void sync_dsp(void)
{
#if 0
if (ioctl(audio, SNDCTL_DSP_SYNC, NULL) < 0) {
perror(AUDIO);
exit(-1);
}
#endif
}
/*
* Function: set_dsp_speed
* Description: set the speed for output
*/
void set_dsp_speed(int *dsp_speed)
{
if (ioctl(audio, SNDCTL_DSP_SPEED, dsp_speed) < 0) {
fprintf(stderr, "%s: unable to set audio speed\n", command);
perror(AUDIO);
exit(-1);
}
}
/*
* Function: one_channel
* Description:
*
* if to_mono:
* compress 8 bit stereo data 2:1, needed if we want play 'one track';
* this is useful, if you habe SB 1.0 - 2.0 (I have 1.0) and want
* hear the sample (in Mono)
*
* if to_8:
* compress 16 bit to 8 by using hi-byte; wave-files use signed words,
* so we need to convert it in "unsigned" sample (0x80 is now zero)
*
* WARNING: this procedure can't compress 16 bit stereo to 16 bit mono,
* because if you have a 16 (or 12) bit card you should have
* stereo (or I'm wrong ?? )
*/
u_long one_channel(u_char * buf, u_long l, char to_mono, char to_8)
{
register u_char *w = buf;
register u_char *w2 = buf;
char ofs = 0;
u_long incr = 0;
u_long c, ret;
if (to_mono)
++incr;
if (to_8) {
++incr;
++w2;
ofs = 128;
}
ret = c = l >> incr;
incr = incr << 1;
while (c--) {
*w++ = *w2 + ofs;
w2 += incr;
}
return ret;
}
/*
* Function: vplay
* Description: play a .voc file
*/
void vplay(int fd, int ofs, char *name)
{
int l, real_l;
BlockType *bp;
Voice_data *vd;
Ext_Block *eb;
u_long nextblock, in_buffer;
u_char *data = audiobuf;
char was_extended = 0, output = 0;
u_short *sp, repeat = 0;
u_long silence;
int filepos = 0;
char one_chn = 0;
#define COUNT(x) nextblock -= x; in_buffer -=x ;data += x
/* first SYNC the dsp */
sync_dsp();
if (!quiet_mode)
fprintf(stderr, "Playing Creative Labs Voice file ...\n");
/* first we waste the rest of header, ugly but we don't need seek */
while (ofs > abuf_size) {
read(fd, (char *)audiobuf, abuf_size);
ofs -= abuf_size;
}
if (ofs)
read(fd, audiobuf, ofs);
/* .voc files are 8 bit (now) */
samplesize = VOC_SAMPLESIZE;
ioctl(audio, SNDCTL_DSP_SAMPLESIZE, &samplesize);
if (samplesize != VOC_SAMPLESIZE) {
fprintf(stderr, "%s: unable to set 8 bit sample size!\n", command);
exit(-1);
}
/* and there are MONO by default */
dsp_stereo = MODE_MONO;
ioctl(audio, SNDCTL_DSP_STEREO, &dsp_stereo);
in_buffer = nextblock = 0;
while (1) {
Fill_the_buffer: /* need this for repeat */
if (in_buffer < 32) {
/* move the rest of buffer to pos 0 and fill the audiobuf up */
if (in_buffer)
memcpy((char *)audiobuf, data, in_buffer);
data = audiobuf;
if ((l =
read(fd, (char *)audiobuf + in_buffer, abuf_size - in_buffer)) > 0)
in_buffer += l;
else if (!in_buffer) {
/* the file is truncated, so simulate 'Terminator'
and reduce the datablock for save landing */
nextblock = audiobuf[0] = 0;
if (l == -1) {
perror(name);
exit(-1);
}
}
}
while (!nextblock) { /* this is a new block */
bp = (BlockType *) data;
COUNT(sizeof(BlockType));
nextblock = DATALEN(bp);
if (output && !quiet_mode)
fprintf(stderr, "\n"); /* write /n after ASCII-out */
output = 0;
switch (bp->type) {
case 0:
d_printf((stderr, "Terminator\n"));
return; /* VOC-file stop */
case 1:
vd = (Voice_data *) data;
COUNT(sizeof(Voice_data));
/* we need a SYNC, before we can set new SPEED, STEREO ... */
sync_dsp();
if (!was_extended) {
dsp_speed = (int)(vd->tc);
dsp_speed = 1000000 / (256 - dsp_speed);
d_printf((stderr, "Voice data %d Hz\n", dsp_speed));
if (vd->pack) { /* /dev/dsp can't it */
fprintf(stderr,
"%s: can't play packed .voc files\n",
command);
return;
}
if (dsp_stereo) { /* if we are in Stereo-Mode, switch back */
dsp_stereo = MODE_MONO;
ioctl(audio, SNDCTL_DSP_STEREO, &dsp_stereo);
}
} else { /* there was extended block */
if (one_chn) /* if one Stereo fails, why test another ? */
dsp_stereo = MODE_MONO;
else if (dsp_stereo) { /* want Stereo */
/* shit, my MACRO dosn't work here */
#ifdef SOUND_VERSION
if (ioctl
(audio, SNDCTL_DSP_STEREO,
&dsp_stereo) < 0) {
#else
if (dsp_stereo !=
ioctl(audio,
SNDCTL_DSP_STEREO, dsp_stereo)) {
#endif
dsp_stereo = MODE_MONO;
fprintf(stderr,
"%s: can't play in Stereo; playing only one channel\n",
command);
one_chn = 1;
}
}
was_extended = 0;
}
set_dsp_speed(&dsp_speed);
break;
case 2: /* nothing to do, pure data */
d_printf((stderr, "Voice continuation\n"));
break;
case 3: /* a silence block, no data, only a count */
sp = (u_short *) data;
COUNT(sizeof(u_short));
dsp_speed = (int)(*data);
COUNT(1);
dsp_speed = 1000000 / (256 - dsp_speed);
sync_dsp();
set_dsp_speed(&dsp_speed);
silence = (((u_long) * sp) * 1000) / dsp_speed;
d_printf((stderr, "Silence for %ld ms\n", silence));
write_zeros(*sp);
break;
case 4: /* a marker for syncronisation, no effect */
sp = (u_short *) data;
COUNT(sizeof(u_short));
d_printf((stderr, "Marker %d\n", *sp));
break;
case 5: /* ASCII text, we copy to stderr */
output = 1;
d_printf((stderr, "ASCII - text :\n"));
break;
case 6: /* repeat marker, says repeatcount */
/* my specs don't say it: maybe this can be recursive, but
I don't think somebody use it */
repeat = *(u_short *) data;
COUNT(sizeof(u_short));
d_printf((stderr, "Repeat loop %d times\n", repeat));
if (filepos >= 0) /* if < 0, one seek fails, why test another */
if ((filepos = lseek(fd, 0, 1)) < 0) {
fprintf(stderr,
"%s: can't play loops; %s isn't seekable\n",
command, name);
repeat = 0;
} else
filepos -= in_buffer; /* set filepos after repeat */
else
repeat = 0;
break;
case 7: /* ok, lets repeat that be rewinding tape */
if (repeat) {
if (repeat != 0xFFFF) {
d_printf((stderr, "Repeat loop %d\n", repeat));
--repeat;
} else
d_printf((stderr, "Neverending loop\n"));
lseek(fd, filepos, 0);
in_buffer = 0; /* clear the buffer */
goto Fill_the_buffer;
} else
d_printf((stderr, "End repeat loop\n"));
break;
case 8: /* the extension to play Stereo, I have SB 1.0 :-( */
was_extended = 1;
eb = (Ext_Block *) data;
COUNT(sizeof(Ext_Block));
dsp_speed = (int)(eb->tc);
dsp_speed = 256000000L / (65536 - dsp_speed);
dsp_stereo = eb->mode;
if (dsp_stereo == MODE_STEREO)
dsp_speed = dsp_speed >> 1;
if (eb->pack) { /* /dev/dsp can't it */
fprintf(stderr,
"%s: can't play packed .voc files\n", command);
return;
}
d_printf((stderr, "Extended block %s %d Hz\n",
(eb->mode ? "Stereo" : "Mono"), dsp_speed));
break;
default:
fprintf(stderr,
"%s: unknown blocktype %d. terminate.\n",
command, bp->type);
return;
} /* switch (bp->type) */
} /* while (! nextblock) */
/* put nextblock data bytes to dsp */
l = min(in_buffer, nextblock);
if (l) {
if (output && !quiet_mode)
write(2, data, l); /* to stderr */
else {
real_l = one_chn ? one_channel(data, l, one_chn, 0) : l;
if (write(audio, data, real_l) != real_l) {
perror(AUDIO);
exit(-1);
}
}
COUNT(l);
}
} /* while(1) */
}
/*
* Function: init_raw_data
* Description: set the globals for playing raw data
*/
void init_raw_data(void)
{
timelimit = raw_info.timelimit;
dsp_speed = raw_info.dsp_speed;
dsp_stereo = raw_info.dsp_stereo;
samplesize = raw_info.samplesize;
}
/*
* Function: calc_count
* Description: calculate the data count to read from/to dsp
*/
u_long calc_count(void)
{
u_long count;
if (!timelimit)
count = 0x7fffffff;
else {
count = timelimit * dsp_speed;
if (dsp_stereo)
count *= 2;
if (samplesize != 8)
count *= 2;
}
return count;
}
/*
* Function: start_voc
* Description: write a VOC header
*/
void start_voc(int fd, u_long cnt)
{
VocHeader vh;
BlockType bt;
Voice_data vd;
Ext_Block eb;
strcpy((char *)vh.magic, MAGIC_STRING);
vh.headerlen = sizeof(VocHeader);
vh.version = ACTUAL_VERSION;
vh.coded_ver = 0x1233 - ACTUAL_VERSION;
write(fd, &vh, sizeof(VocHeader));
if (dsp_stereo) {
/* write a extended block */
bt.type = 8;
bt.datalen = 4;
bt.datalen_m = bt.datalen_h = 0;
write(fd, &bt, sizeof(BlockType));
eb.tc = (u_short) (65536 - 256000000L / (dsp_speed << 1));
eb.pack = 0;
eb.mode = 1;
write(fd, &eb, sizeof(Ext_Block));
}
bt.type = 1;
cnt += sizeof(Voice_data); /* Voice_data block follows */
bt.datalen = (u_char) (cnt & 0xFF);
bt.datalen_m = (u_char) ((cnt & 0xFF00) >> 8);
bt.datalen_h = (u_char) ((cnt & 0xFF0000) >> 16);
write(fd, &bt, sizeof(BlockType));
vd.tc = (u_char) (256 - (1000000 / dsp_speed));
vd.pack = 0;
write(fd, &vd, sizeof(Voice_data));
}
/*
* Function: start_wave
* Description: write a WAVE header
*/
void start_wave(int fd, u_long cnt)
{
WaveHeader wh;
wh.main_chunk = RIFF;
wh.length = cnt + sizeof(WaveHeader) - 8;
wh.chunk_type = WAVE;
wh.sub_chunk = FMT;
wh.sc_len = 16;
wh.format = PCM_CODE;
wh.modus = dsp_stereo ? 2 : 1;
wh.sample_fq = dsp_speed;
wh.byte_p_spl = ((samplesize == 8) ? 1 : 2) * (dsp_stereo ? 2 : 1);
wh.byte_p_sec = dsp_speed * wh.modus * wh.byte_p_spl;
wh.bit_p_spl = samplesize;
wh.data_chunk = DATA;
wh.data_length = cnt;
write(fd, &wh, sizeof(WaveHeader));
}
/*
* Function: end_voc
* Description: close VOC
*/
void end_voc(int fd)
{
char dummy = 0; /* Write a Terminator */
write(fd, &dummy, 1);
if (fd != 1)
close(fd);
}
/*
* Function: end_wave_raw
* Description: close WAV, RAW
*/
void end_wave_raw(int fd)
{ /* only close output */
if (fd != 1)
close(fd);
}
/*
* Function: start_snd
* Description: write a SND header
*/
void start_snd(int fd, u_long count)
{
SndHeader snd;
char *sndinfo = "Recorded by vrec\000";
snd.magic = SND_MAGIC;
snd.dataLocation = sizeof(SndHeader) + strlen(sndinfo);
snd.dataSize = count;
switch (samplesize) {
case 8:
snd.dataFormat = SND_FORMAT_LINEAR_8;
break;
case 16:
snd.dataFormat = SND_FORMAT_LINEAR_16;
break;
default:
fprintf(stderr,
"%d bit: unsupported sample size for NeXt sound file!\n", samplesize);
exit(-1);
}
snd.samplingRate = dsp_speed;
snd.channelCount = dsp_stereo ? 2 : 1;
write(fd, &snd, sizeof(SndHeader));
write(fd, sndinfo, strlen(sndinfo));
}
/*
* Function: end_snd
* Description: close SND
*/
void end_snd(int fd)
{
if (fd != 1)
close(fd);
}
/*
* Function: recplay
* Description: play/record raw data. This proc handles WAVE files and recording
* VOCs (as one block)
*/
void recplay(int fd, int loaded, u_long count, int rtype, char *name)
{
int l, real_l;
u_long c;
char one_chn = 0;
char to_8 = 0;
int tmps;
sync_dsp();
tmps = samplesize;
ioctl(audio, SNDCTL_DSP_SAMPLESIZE, &tmps);
if (tmps != samplesize) {
fprintf(stderr, "%s: unable to set %d bit sample size", command, samplesize);
if (samplesize == 16) {
samplesize = 8;
ioctl(audio, SNDCTL_DSP_SAMPLESIZE, &samplesize);
if (samplesize != 8) {
fprintf(stderr,
"%s: unable to set 8 bit sample size!\n", command);
exit(-1);
}
fprintf(stderr, "; playing 8 bit\n");
to_8 = 1;
} else {
fprintf(stderr, "\n");
exit(-1);
}
}
#ifdef SOUND_VERSION
if (ioctl(audio, SNDCTL_DSP_STEREO, &dsp_stereo) < 0) {
#else
if (dsp_stereo != ioctl(audio, SNDCTL_DSP_STEREO, dsp_stereo)) {
#endif
if (direction == PLAY) {
fprintf(stderr,
"%s: can't play in Stereo; playing only one channel\n",
command);
dsp_stereo = MODE_MONO;
one_chn = 1;
} else {
fprintf(stderr, "%s: can't record in Stereo\n", command);
exit(-1);
}
}
set_dsp_speed(&dsp_speed);
if (!quiet_mode) {
fprintf(stderr, "%s %s : ",
(direction == PLAY) ? "Playing" : "Recording",
fmt_rec_table[rtype].what);
if (samplesize != 8)
fprintf(stderr, "%d bit, ", samplesize);
fprintf(stderr, "Speed %d Hz ", dsp_speed);
fprintf(stderr, "%d bits ", samplesize);
fprintf(stderr, "%s ...\n", dsp_stereo ? "Stereo" : "Mono");
}
if (direction == PLAY) {
while (count) {
c = count;
if (c > abuf_size)
c = abuf_size;
if ((l = read(fd, (char *)audiobuf + loaded, c - loaded)) > 0) {
l += loaded;
loaded = 0; /* correct the count; ugly but ... */
real_l = (one_chn
|| to_8) ? one_channel(audiobuf, l,
one_chn, to_8) : l;
/* change byte order if necessary */
if (convert && (samplesize == 16)) {
long i;
for (i = 0; i < real_l; i += 2)
*((short *)(audiobuf + i)) =
htons(*((short *)(audiobuf + i)));
}
if (write(audio, (char *)audiobuf, real_l) != real_l) {
perror(AUDIO);
exit(-1);
}
count -= l;
} else {
if (l == -1) {
perror(name);
exit(-1);
}
count = 0; /* Stop */
}
} /* while (count) */
} else { /* we are recording */
while (count) {
c = count;
if (c > abuf_size)
c = abuf_size;
if ((l = read(audio, (char *)audiobuf, c)) > 0) {
if (write(fd, (char *)audiobuf, l) != l) {
perror(name);
exit(-1);
}
count -= l;
}
if (l == -1) {
perror(AUDIO);
exit(-1);
}
} /* While count */
}
}
/*
* Function: record_play
* Description: play or record a file
*/
void record_play(char *name)
{
int fd, ofs;
if (direction == PLAY) {
if (!name) {
fd = 0;
name = "stdin";
} else if ((fd = open(name, O_RDONLY, 0)) == -1) {
perror(name);
exit(-1);
}
/* Read the smallest header first, then the
missing bytes for the next, etc. */
/* read SND-header */
read(fd, (char *)audiobuf, sizeof(SndHeader));
if (test_sndfile(audiobuf, fd) >= 0)
recplay(fd, 0, count, SND_FMT, name);
else {
/* read VOC-Header */
read(fd, (char *)audiobuf + sizeof(SndHeader),
sizeof(VocHeader) - sizeof(SndHeader));
if ((ofs = test_vocfile(audiobuf)) >= 0)
vplay(fd, ofs, name);
else {
/* read bytes for WAVE-header */
read(fd, (char *)audiobuf + sizeof(VocHeader),
sizeof(WaveHeader) - sizeof(VocHeader));
if (test_wavefile(audiobuf) >= 0)
recplay(fd, 0, count, WAVE_FMT, name);
else {
/* should be raw data */
init_raw_data();
count = calc_count();
recplay(fd, sizeof(WaveHeader), count, RAW_DATA, name);
}
}
}
if (fd != 0)
close(fd);
} else { /* recording ... */
if (!name) {
fd = 1;
name = "stdout";
} else {
if ((fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, 0666)) == -1) {
perror(name);
exit(-1);
}
}
count = calc_count() & 0xFFFFFFFE;
/* WAVE-file should be even (I'm not sure), but wasting one byte
isn't a problem (this can only be in 8 bit mono) */
if (fmt_rec_table[record_type].start)
fmt_rec_table[record_type].start(fd, count);
recplay(fd, 0, count, record_type, name);
fmt_rec_table[record_type].end(fd);
}
}

1
meta-digi-dey/recipes-digi/packagegroups/packagegroup-dey-examples.bb
View File

@ -9,7 +9,6 @@ inherit packagegroup
RDEPENDS_${PN} = "\
${@bb.utils.contains("MACHINE_FEATURES", "alsa", "dey-examples-alsa", "", d)} \
${@bb.utils.contains("MACHINE_FEATURES", "alsa", "dey-examples-vplay", "", d)} \
${@bb.utils.contains("MACHINE_FEATURES", "bluetooth", "dey-examples-bt", "", d)} \
${@bb.utils.contains("MACHINE_FEATURES", "bluetooth", "dey-examples-btconfig", "", d)} \
${@bb.utils.contains("MACHINE_FEATURES", "bluetooth", "dey-examples-bt-gatt-server", "", d)} \