Hi,
Have written a thread to repeatedly play wav sounds with varying delays in
between the sound being played. Unfortunately the sound is being clipped (cut
off) at the beginning of when the sound is being played. It is not too clear
to me what api calls need to be implemented (or what api calls have been
implemented wrongly) in order to sort this problem out.
This particular piece of code works on some other hardware but doesn't work on
this particular hardware (Freescale MCIMX31 with ARMv6 compatible processor
(v61) with Logitech V10 Notebook speakers (USB - connected to USB port on
MCIMX31)). The code does work on Cirrus EP9315 Arm 920T processor with the
same USB speakers connected to the USB port (this device is a slower device).
When I attempt to play wav files with the alsa-utils test application 'aplay' I
am able to play mono wavs ok but stereo wavs are clipped or cut-off in exactly
the same way as the sound being played in the thread. The thread is playing
mono wavs not stereo wavs (the mono wav sounds are also cut off).
Some other hardware details are as follows:-
/proc/asound/devices
0: [ 0] : control
16: [ 0- 0]: digital audio playback
33: : timer
/proc/asound/card0/pcm0p/info
card: 0
device: 0
subdevice: 0
stream: PLAYBACK
id: USB Audio
name: USB Audio
subname: subdevice #0
class: 0
subclass: 0
subdevices_count: 1
subdevices_avail: 1
Devices are as follows:-
crw-rw---- 1 root audio 14, 4 audio
crw-rw---- 1 root audio 14, 3 dsp
Kernel configuration is as follows:-
CONFIG_SND
CONFIG_SND_PCM_OSS
CONFIG_SND_VERBOSE_PROCFS
CONFIG_SND_VERBOSE_PRINTK
CONFIG_SND_USB_AUDIO
Dmesg output:-
usbcore: registered new interface driver usbhid
drivers/hid/usbhid/hid-core.c: v2.6:USB HID core driver
Advanced Linux Sound Architecture Driver Version 1.0.14 (Thu May 31 09:03:25
2007 UTC).
usbcore: registered new interface driver snd-usb-audio
ALSA device list:
#0: Logitech Logitech Speaker at usb-fsl-ehci.2-1,
full spe
Sound thread code attached.
Cheers,
Geoff Crowther
#ifndef SOUNDTHREAD_H
#define SOUNDTHREAD_H
#include <QThread>
#include <QMutex>
#ifdef Q_OS_LINUX
#include <alsa/asoundlib.h>
typedef struct
{ u_int32_t dwSize ;
u_int16_t wFormatTag ;
u_int16_t wChannels ;
u_int32_t dwSamplesPerSec ;
u_int32_t dwAvgBytesPerSec ;
u_int16_t wBlockAlign ;
u_int16_t wBitsPerSample ;
} WAVEFORMAT ;
#endif
typedef enum SoundType
{
ABOVEGRADESOUND,
ONGRADESOUND,
BELOWGRADESOUND,
OUTSIDEEXTENTSSOUND,
HITREFSOUND,
BUCKETSENSORINPLANESOUND,
HEIGHTHIGHALARM,
HEIGHTLOWALARM,
BUCKETINLASERSOUND
};
typedef enum Position
{
ABOVE_HIGH_EXTENTS,
BELOW_HIGH_EXTENT_ABOVE_DEADBAND,
BELOW_HIGH_DEADBAND_ABOVE_LOW_DEADBAND,
BELOW_LOW_DEADBAND_ABOVE_LOW_EXTENTS,
BELOW_LOW_EXTENTS,
SENSORS_OFFLINE,
REF_COMPLETE_SUCCESS_POS,
REF_COMPLETE_FAILURE_POS,
HEIGHT_ALARM_POS,
DEPTH_ALARM_POS,
BUCKET_IN_LASER_POS
};
typedef enum SoundStateTransition
{
ABOVEEXTENTS,
ABOVEGRADE,
ONGRADE,
BELOWGRADE,
BELOWEXTENTS,
SENSORSOFFLINE,
REFCOMPLETESUCCESS,
REFCOMPLETEFAILURE,
HEIGHTALARM,
DEPTHALARM,
BUCKETINLASER,
ABOVEEXTENTS_TO_ABOVEGRADE,
ABOVEEXTENTS_TO_ONGRADE,
ABOVEEXTENTS_TO_BELOWGRADE,
ABOVEEXTENTS_TO_BELOWEXTENTS,
ABOVEEXTENTS_TO_SENSORSOFFLINE,
ABOVEEXTENTS_TO_REFCOMPLETEFAILURE,
ABOVEEXTENTS_TO_REFCOMPLETESUCCESS,
ABOVEEXTENTS_TO_HEIGHTALARM,
ABOVEEXTENTS_TO_DEPTHALARM,
ABOVEEXTENTS_TO_BUCKETINLASER,
ABOVEGRADE_TO_ABOVEEXTENTS,
ABOVEGRADE_TO_ONGRADE,
ABOVEGRADE_TO_BELOWGRADE,
ABOVEGRADE_TO_BELOWEXTENTS,
ABOVEGRADE_TO_SENSORSOFFLINE,
ABOVEGRADE_TO_REFCOMPLETEFAILURE,
ABOVEGRADE_TO_REFCOMPLETESUCCESS,
ABOVEGRADE_TO_HEIGHTALARM,
ABOVEGRADE_TO_DEPTHALARM,
ABOVEGRADE_TO_BUCKETINLASER,
ONGRADE_TO_ABOVEEXTENTS,
ONGRADE_TO_ABOVEGRADE,
ONGRADE_TO_BELOWGRADE,
ONGRADE_TO_BELOWEXTENTS,
ONGRADE_TO_SENSORSOFFLINE,
ONGRADE_TO_REFCOMPLETESUCCESS,
ONGRADE_TO_REFCOMPLETEFAILURE,
ONGRADE_TO_HEIGHTALARM,
ONGRADE_TO_DEPTHALARM,
ONGRADE_TO_BUCKETINLASER,
BELOWGRADE_TO_ABOVEEXTENTS,
BELOWGRADE_TO_ABOVEGRADE,
BELOWGRADE_TO_ONGRADE,
BELOWGRADE_TO_BELOWEXTENTS,
BELOWGRADE_TO_SENSORSOFFLINE,
BELOWGRADE_TO_REFCOMPLETESUCCESS,
BELOWGRADE_TO_REFCOMPLETEFAILURE,
BELOWGRADE_TO_HEIGHTALARM,
BELOWGRADE_TO_DEPTHALARM,
BELOWGRADE_TO_BUCKETINLASER,
BELOWEXTENTS_TO_ABOVEEXTENTS,
BELOWEXTENTS_TO_ABOVEGRADE,
BELOWEXTENTS_TO_ONGRADE,
BELOWEXTENTS_TO_BELOWGRADE,
BELOWEXTENTS_TO_SENSORSOFFLINE,
BELOWEXTENTS_TO_HEIGHTALARM,
BELOWEXTENTS_TO_DEPTHALARM,
BELOWEXTENTS_TO_REFCOMPLETESUCCESS,
BELOWEXTENTS_TO_REFCOMPLETEFAILURE,
BELOWEXTENTS_TO_BUCKETINLASER,
SENSORSOFFLINE_TO_ABOVEEXTENTS,
SENSORSOFFLINE_TO_ABOVEGRADE,
SENSORSOFFLINE_TO_ONGRADE,
SENSORSOFFLINE_TO_BELOWGRADE,
SENSORSOFFLINE_TO_BELOWEXTENTS,
SENSORSOFFLINE_TO_REFCOMPLETESUCCESS,
SENSORSOFFLINE_TO_REFCOMPLETEFAILURE,
SENSORSOFFLINE_TO_HEIGHTALARM,
SENSORSOFFLINE_TO_DEPTHALARM,
SENSORSOFFLINE_TO_BUCKETINLASER,
REFCOMPLETESUCCESS_TO_ABOVEEXTENTS,
REFCOMPLETESUCCESS_TO_ABOVEGRADE,
REFCOMPLETESUCCESS_TO_ONGRADE,
REFCOMPLETESUCCESS_TO_BELOWGRADE,
REFCOMPLETESUCCESS_TO_BELOWEXTENTS,
REFCOMPLETESUCCESS_TO_SENSORSOFFLINE,
REFCOMPLETESUCCESS_TO_REFCOMPLETEFAILURE,
REFCOMPLETESUCCESS_TO_HEIGHTALARM,
REFCOMPLETESUCCESS_TO_DEPTHALARM,
REFCOMPLETESUCCESS_TO_BUCKETINLASER,
REFCOMPLETEFAILURE_TO_ABOVEEXTENTS,
REFCOMPLETEFAILURE_TO_ABOVEGRADE,
REFCOMPLETEFAILURE_TO_ONGRADE,
REFCOMPLETEFAILURE_TO_BELOWGRADE,
REFCOMPLETEFAILURE_TO_BELOWEXTENTS,
REFCOMPLETEFAILURE_TO_SENSORSOFFLINE,
REFCOMPLETEFAILURE_TO_REFCOMPLETESUCCESS,
REFCOMPLETEFAILURE_TO_DEPTHALARM,
REFCOMPLETEFAILURE_TO_HEIGHTALARM,
REFCOMPLETEFAILURE_TO_BUCKETINLASER,
DEPTHALARM_TO_SENSORSOFFLINE,
DEPTHALARM_TO_ABOVEEXTENTS,
DEPTHALARM_TO_ABOVEGRADE,
DEPTHALARM_TO_ONGRADE,
DEPTHALARM_TO_BELOWGRADE,
DEPTHALARM_TO_BELOWEXTENTS,
DEPTHALARM_TO_REFCOMPLETESUCCESS,
DEPTHALARM_TO_REFCOMPLETEFAILURE,
DEPTHALARM_TO_HEIGHTALARM,
DEPTHALARM_TO_BUCKETINLASER,
HEIGHTALARM_TO_SENSORSOFFLINE,
HEIGHTALARM_TO_ABOVEEXTENTS,
HEIGHTALARM_TO_ABOVEGRADE,
HEIGHTALARM_TO_ONGRADE,
HEIGHTALARM_TO_BELOWGRADE,
HEIGHTALARM_TO_BELOWEXTENTS,
HEIGHTALARM_TO_REFCOMPLETESUCCESS,
HEIGHTALARM_TO_REFCOMPLETEFAILURE,
HEIGHTALARM_TO_DEPTHALARM,
HEIGHTALARM_TO_BUCKETINLASER,
BUCKETINLASER_TO_SENSORSOFFLINE,
BUCKETINLASER_TO_ABOVEEXTENTS,
BUCKETINLASER_TO_ABOVEGRADE,
BUCKETINLASER_TO_ONGRADE,
BUCKETINLASER_TO_BELOWGRADE,
BUCKETINLASER_TO_BELOWEXTENTS,
BUCKETINLASER_TO_REFCOMPLETESUCCESS,
BUCKETINLASER_TO_REFCOMPLETEFAILURE,
BUCKETINLASER_TO_HEIGHTALARM,
BUCKETINLASER_TO_DEPTHALARM
};
class QSoundThread : public QThread
{
Q_OBJECT
public:
QSoundThread( const QString& filename, QObject* parent=0) ;
virtual ~QSoundThread();
virtual void run();
bool Initialise(const QString & soundfile);
const QString & GetWaveFile(){ return Path; }
void SetThreadDelay(int delay);
bool is_available;
bool isAvailable() { return is_available ; }
void ExitThread();
bool SoundAvailable() { return !SoundNotAvailable; }
private:
QMutex mutex_soundfile;
QMutex mutex_threaddelay;
QString Path;
int threaddelay;
int dummythreaddelay;
bool exitthread;
bool SoundNotAvailable;
#ifdef Q_OS_LINUX
// ALSA parameters
snd_pcm_t *handle;
snd_pcm_sframes_t frames;
char *device ; // playback device
snd_pcm_uframes_t chunk_size, buffer_size;
size_t bits_per_sample, bits_per_frame, chunk_bytes;
// File parser
int fd; // Open file descriptor or -1
char* findchunk(char* pstart, char* fourcc, size_t n);
WAVEFORMAT waveformat ;
u_long samples, datastart;
#endif
};
#endif // SOUNDTHREAD_H
#include "SoundThread.h"
#include <QThread>
#include <QtDebug>
#include <QSound>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Formats.h"
#ifdef Q_OS_LINUX
#include <sys/time.h>
#include <alsa/asoundlib.h>
#include <malloc.h>
#if WORDS_BIGENDIAN
#define SwapLE16(x) ((((u_int16_t)x)<<8)|(((u_int16_t)x)>>8))
#define SwapLE32(x) ((((u_int32_t)x)<<24)|((((u_int32_t)x)<<8)&0x00FF0000) \
|((((u_int32_t)x)>>8)&0x0000FF00)|(((u_int32_t)x)>>24))
#else
#define SwapLE16(x) (x)
#define SwapLE32(x) (x)
#endif
#endif
#define BUFFERSIZE 1024
QSoundThread::QSoundThread( const QString& filename, QObject* parent) :
QThread(parent)
{
SoundNotAvailable = false;
Path = filename;
dummythreaddelay = threaddelay = 300;
is_available= Initialise(filename);
if(!is_available)
{
//Speakers not plugged in
exitthread = true;
SoundNotAvailable = true;
return;
}
exitthread = false;
#ifdef Q_OS_LINUX
snd_pcm_close(handle);
close(fd);
#endif
}
QSoundThread::~QSoundThread()
{
}
bool QSoundThread::Initialise(const QString & soundfile)
{
Path.clear();
Path += soundfile;
if (SoundNotAvailable) return false;
#ifdef _WIN32
if (QSound::isAvailable())
return true ;
#endif
mutex_soundfile.lock();
exitthread = false;
mutex_soundfile.unlock();
#ifdef Q_OS_LINUX
char buffer [ BUFFERSIZE ] ;
//device = strdup("plughw:0,0"); // playback device
device = strdup("default"); // playback device
char* ptr ;
u_long databytes ;
snd_pcm_format_t format;
snd_pcm_hw_params_t *params;
int err;
if ( (fd = open(Path.toLatin1().constData(),O_RDONLY)) < 0 ) {
qWarning("Error Opening WAV file
%s",Path.toLatin1().constData());
return false;
}
if ( lseek(fd,0L,SEEK_SET) != 0L ) {
qWarning("Error nRewinding WAV file
%s",Path.toLatin1().constData());
return false; // Wav file must be seekable device
}
read (fd, buffer, BUFFERSIZE) ;
if (findchunk (buffer, "RIFF", BUFFERSIZE) != buffer) {
qWarning("Bad format: Cannot find RIFF file marker");
return false;
}
if (! findchunk (buffer, "WAVE", BUFFERSIZE)) {
qWarning("Bad format: Cannot find WAVE file marker");
return false;
}
ptr = findchunk (buffer, "fmt ", BUFFERSIZE) ;
if (! ptr) {
qWarning("Bad format: Cannot find 'fmt' file marker");
return false;
}
ptr += 4 ; // Move past "fmt ".
memcpy (&waveformat, ptr, sizeof (WAVEFORMAT)) ;
waveformat.dwSize = SwapLE32(waveformat.dwSize);
waveformat.wFormatTag = SwapLE16(waveformat.wFormatTag) ;
waveformat.wChannels = SwapLE16(waveformat.wChannels) ;
waveformat.dwSamplesPerSec = SwapLE32(waveformat.dwSamplesPerSec) ;
waveformat.dwAvgBytesPerSec = SwapLE32(waveformat.dwAvgBytesPerSec) ;
waveformat.wBlockAlign = SwapLE16(waveformat.wBlockAlign) ;
waveformat.wBitsPerSample = SwapLE16(waveformat.wBitsPerSample) ;
qDebug("waveformat.dwSize %i", waveformat.dwSize);
qDebug("waveformat.wFormatTag %i", waveformat.wFormatTag);
qDebug("waveformat.wChannels %i", waveformat.wChannels);
qDebug("waveformat.dwSamplesPerSec %i",waveformat.dwSamplesPerSec);
qDebug("waveformat.dwAvgBytesPerSec %i", waveformat.dwAvgBytesPerSec);
qDebug("waveformat.wBlockAlign %i",waveformat.wBlockAlign);
qDebug("waveformat.wBitsPerSample %i",waveformat.wBitsPerSample);
ptr = findchunk (buffer, "data", BUFFERSIZE) ;
if (! ptr)
{
qWarning("Bad format: unable to find 'data' file marker");
return false;
}
ptr += 4 ; // Move past "data".
memcpy (&databytes, ptr, sizeof (u_long)) ;
samples = databytes / waveformat.wBlockAlign ;
datastart = ((u_long) (ptr + 4)) - ((u_long) (&(buffer[0]))) ;
switch (waveformat.wBitsPerSample)
{
case 8:
format = SND_PCM_FORMAT_U8 ;
break;
case 16:
format = SND_PCM_FORMAT_S16_LE ;
break;
case 32 :
format = SND_PCM_FORMAT_S32_LE;
break;
default :
qWarning("Bad format: %i bits per
seconds",waveformat.wBitsPerSample );
return false;
break;
}
// qDebug("%s - format :%d, %i Hz, %i
channels",Path.toLatin1(),waveformat.wBitsPerSample,
waveformat.dwSamplesPerSec,waveformat.wChannels);
//ALSA pain
snd_pcm_hw_params_alloca(¶ms);
if ((err = snd_pcm_open (&handle,
device,SND_PCM_STREAM_PLAYBACK,SND_PCM_ASYNC)) < 0)
{
qWarning("cannot open audio device %s (%s)",
device,snd_strerror (err));
return false;
}
if ((err = snd_pcm_nonblock(handle, 1))< 0)
{
qWarning("nonblock setting error: %s", snd_strerror(err));
return false;
}
// Init hwparams with full configuration space
if (snd_pcm_hw_params_any(handle, params) < 0)
{
qFatal("Can not configure this PCM device.");
return false;
}
err = snd_pcm_hw_params_set_access(handle,
params,SND_PCM_ACCESS_RW_INTERLEAVED);
if (err < 0)
{
qFatal("Access type not available");
return false;
}
err = snd_pcm_hw_params_set_format(handle, params, format);
if (err < 0)
{
qFatal("Sample format not available");
return false;
}
err = snd_pcm_hw_params_set_channels(handle, params,
waveformat.wChannels);
if (err < 0) {
qFatal("Channels count not available");
return false;
}
err = snd_pcm_hw_params_set_rate_near(handle,
params,&waveformat.dwSamplesPerSec, 0);
if (err < 0) {
qFatal("Unable to set rate : %d", waveformat.dwSamplesPerSec);
return false;
}
assert(err >= 0);
err = snd_pcm_hw_params(handle, params);
if (err < 0)
{
qFatal("Unable to install hw params:");
return false;
}
chunk_size = 0;
buffer_size=0;
snd_pcm_hw_params_get_buffer_size(params, &buffer_size);
snd_pcm_hw_params_get_period_size(params, &chunk_size, 0);
bits_per_sample = snd_pcm_format_physical_width(format);
bits_per_frame = bits_per_sample * waveformat.wChannels;
chunk_bytes = chunk_size * bits_per_frame / 8;
qDebug("bits_per_sample %i", bits_per_sample);
qDebug("bits_per_frame %i", bits_per_frame);
qDebug("chunk_size %i", chunk_size);
qDebug("chunk_bytes %i", chunk_bytes);
return true;
#endif
}
void QSoundThread::ExitThread()
{
mutex_soundfile.lock();
exitthread = true;
mutex_soundfile.unlock();
wait(-1);
#ifdef Q_OS_LINUX
snd_pcm_close(handle);
close(fd);
#endif
}
void QSoundThread::run()
{
bool flag;
#ifdef Q_OS_LINUX
int err;
// start playback
err=lseek(fd,datastart,SEEK_SET);
int count,f;
char *buffer2;
buffer2 = (char *)malloc (buffer_size);
#else //_WIN32
QSound soundtoplay(Path);
#endif
while(1) //thread
{
#ifdef Q_OS_LINUX
while ((count = read (fd, buffer2,buffer_size)))
{
f=count*8/bits_per_frame;
//f = count;
qDebug("bits_per_frame is %i, count is %i", bits_per_frame, count);
while ((frames = snd_pcm_writei(handle, buffer2, f)) < 0)
{
snd_pcm_prepare(handle);
}
}
snd_pcm_drain(handle);
#elif _WIN32
soundtoplay.play();
#else
qWarning("Platform has no sound configured");
#endif
mutex_threaddelay.lock();
threaddelay = dummythreaddelay; //don't want to block on the sleep
mutex_threaddelay.unlock();
msleep(threaddelay);
mutex_soundfile.tryLock();
flag = exitthread;
mutex_soundfile.unlock();
#ifdef Q_OS_LINUX
if(fd >= 0 && !flag)
{
err=lseek(fd,datastart,SEEK_SET);
}
else
{
free(buffer2);
err=lseek(fd,datastart,SEEK_SET);
#else
if(!flag)
{
}
else
{
#endif
mutex_soundfile.tryLock();
exitthread = false;
mutex_soundfile.unlock();
return;
}
}
}
void QSoundThread::SetThreadDelay(int delay)
{
mutex_threaddelay.lock();
dummythreaddelay = delay;
mutex_threaddelay.unlock();
}
#ifdef Q_OS_LINUX
char* QSoundThread::findchunk (char* pstart, char* fourcc, size_t n)
{
char *pend;
int k, test;
pend = pstart + n;
while (pstart < pend)
{ if (*pstart == *fourcc) // found match for first char
{ test = TRUE ;
for (k = 1 ; fourcc [k] != 0 ; k++)
test = (test ? ( pstart [k] == fourcc [k] ) :
FALSE) ;
if (test)
return pstart ;
} ; // if
pstart ++ ;
} ; // while lpstart
return NULL ;
} // findchuck
#endif
------------------------------------------------------------------------------
Let Crystal Reports handle the reporting - Free Crystal Reports 2008 30-Day
trial. Simplify your report design, integration and deployment - and focus on
what you do best, core application coding. Discover what's new with
Crystal Reports now. http://p.sf.net/sfu/bobj-july
_______________________________________________
Alsa-user mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/alsa-user
