OpenAL回放捕获的音频数据c++

这里有一个非常简单的程序，可以捕获5秒的音频，暂停，然后再捕获5秒的音频，最后全部播放返回（我曾经用它来调试捕获的问题）。

它在mint 13 linux笔记本电脑上运行。薄荷就像ubuntu 12.04

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h>
#include <AL/al.h> 
#include <AL/alc.h> 
#include <sys/time.h>
#include <ctime> 
int main(void) 
{ 
const ALCchar *   devices; 
const ALCchar *         ptr; 
ALCdevice *       mainDev; 
ALCcontext *      mainContext; 
ALCdevice *       captureDev; 
ALubyte           captureBuffer[1048576]; 
ALubyte           *captureBufPtr; 
ALint             samplesAvailable; 
ALint             samplesCaptured; 
time_t            currentTime; 
time_t            lastTime; 
ALuint            buffer; 
ALuint            source; 
ALint             playState; 
int               i; 
// Print the list of capture devices 
printf("Available playback devices:n");
devices = alcGetString(NULL, ALC_DEVICE_SPECIFIER); 
ptr = devices; 
//while (ptr[0] != NULL)
while (*ptr)
{ 
   printf("   %sn", ptr); 
   ptr += strlen(ptr) + 1; 
} 
// Open a playback device and create a context first 
printf("Opening playback device:n"); 
mainDev = alcOpenDevice(NULL); 
if (mainDev == NULL) 
{ 
  printf("Unable to open playback device!n"); 
  exit(1); 
} 
devices = alcGetString(mainDev, ALC_DEVICE_SPECIFIER); 
printf("   opened device '%s'n", devices); 
mainContext = alcCreateContext(mainDev, NULL); 
if (mainContext == NULL) 
{ 
  printf("Unable to create playback context!n"); 
  exit(1); 
} 
printf("   created playback contextn"); 
// Make the playback context current 
alcMakeContextCurrent(mainContext); 
alcProcessContext(mainContext); 
// Print the list of capture devices 
printf("Available capture devices:n"); 
devices = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER); 
ptr = devices; 
//while (ptr[0] != NULL)
while (*ptr)
{ 
   printf("   %sn", ptr); 
   ptr += strlen(ptr) + 1; 
}
// Open the default device 
printf("Opening capture device:n"); 
captureDev = alcCaptureOpenDevice(NULL, 8000, AL_FORMAT_MONO16, 800); 
if (captureDev == NULL) 
{  
  printf("   Unable to open device!n"); 
  exit(1); 
} 
devices = alcGetString(captureDev, ALC_CAPTURE_DEVICE_SPECIFIER); 
printf("   opened device %sn", devices); 
// Wait for three seconds to prompt the user 
for (i = 3; i > 0; i--) 
{ 
  printf("Starting capture in %d...r", i); 
  fflush(stdout); 
  lastTime = time(NULL); 
  currentTime = lastTime; 
  while (currentTime == lastTime) 
  { 
     currentTime = time(NULL); 
     usleep(100000); 
  } 
} 
printf("Starting capture NOW!n"); 
fflush(stdout); 
lastTime = currentTime; 
// Capture (roughly) five seconds of audio 
alcCaptureStart(captureDev); 
samplesCaptured = 0; 
captureBufPtr = captureBuffer; 
while (currentTime < (lastTime + 5)) 
{ 
  // Get the number of samples available 
  alcGetIntegerv(captureDev, ALC_CAPTURE_SAMPLES, 1, &samplesAvailable); 
  // Copy the samples to our capture buffer 
  if (samplesAvailable > 0) 
  { 
     alcCaptureSamples(captureDev, captureBufPtr, samplesAvailable); 
     samplesCaptured += samplesAvailable; 
     printf("Captured %d samples (adding %d)r", samplesCaptured, 
        samplesAvailable); 
     fflush(stdout); 
     // Advance the buffer (two bytes per sample * number of samples) 
     captureBufPtr += samplesAvailable * 2; 
  } 
  // Wait for a bit 
  usleep(10000); 
  // Update the clock 
  currentTime = time(NULL); 
} 
printf("nPausing capture.n"); 
alcCaptureStop(captureDev); 
// Wait for three seconds to prompt the user 
for (i = 3; i > 0; i--) 
{ 
  printf("Resuming capture in %d...r", i); 
  fflush(stdout); 
  lastTime = time(NULL); 
  currentTime = lastTime; 
  while (currentTime == lastTime) 
  { 
     currentTime = time(NULL); 
     usleep(100000); 
  } 
} 
printf("Resuming capture NOW!n"); 
fflush(stdout); 
lastTime = currentTime; 
// Capture (roughly) five seconds of audio 
alcCaptureStart(captureDev); 
while (currentTime < (lastTime + 5)) 
{ 
  // Get the number of samples available 
  alcGetIntegerv(captureDev, ALC_CAPTURE_SAMPLES, 1, &samplesAvailable); 
  // Copy the samples to our capture buffer 
  if (samplesAvailable > 0) 
  { 
     alcCaptureSamples(captureDev, captureBufPtr, samplesAvailable); 
     samplesCaptured += samplesAvailable; 
     printf("Captured %d samples (adding %d)r", samplesCaptured, 
        samplesAvailable); 
     fflush(stdout); 
     // Advance the buffer (two bytes per sample * number of samples) 
     captureBufPtr += samplesAvailable * 2; 
  } 
  // Wait for a bit 
  usleep(10000); 
  // Update the clock 
  currentTime = time(NULL); 
} 
printf("nDone capturing.n"); 
alcCaptureStop(captureDev); 
// Play back the captured data 
printf("Starting playback...n"); 
fflush(stdout); 
// Generate an OpenAL buffer for the captured data 
alGenBuffers(1, &buffer); 
alGenSources(1, &source); 
alBufferData(buffer, AL_FORMAT_MONO16, captureBuffer,samplesCaptured*2, 8000); 
alSourcei(source, AL_BUFFER, buffer); 
alSourcePlay(source); 
// Wait for the source to stop playing 
playState = AL_PLAYING; 
while (playState == AL_PLAYING) 
{ 
  printf("  source %d is playing...r", source); 
  fflush(stdout); 
  alGetSourcei(source, AL_SOURCE_STATE, &playState); 
  usleep(100000); 
} 
printf("nDone with playback.n"); 
fflush(stdout); 
// Shut down OpenAL 
alDeleteSources(1, &source); 
alDeleteBuffers(1, &buffer); 
alcMakeContextCurrent(NULL); 
alcCloseDevice(mainDev); 
alcCaptureCloseDevice(captureDev); 
}

用这个编译：

g++ p.cpp -lalut -lopenal -o p

// Compile as: g++ p.cpp -lalut -lopenal -o p
//runs on ubuntu linux for around 2 seconds
#include <AL/al.h>    // OpenAL header files
#include <AL/alc.h>
//#include "stdafx.h"
#include <iostream>
#include <stdio.h>
//#include <windows.h>
//#include <al.h>
//#include <alc.h>

using namespace std;
int main()
{


ALCdevice *dev[2];
ALCcontext *ctx;
ALuint source, buffers[3];
char data[5000];
ALuint buf;
ALint val;
    float ttotal;
    unsigned int ccount;
    long int c1ount;
    c1ount =0;
dev[0] = alcOpenDevice(NULL);
ctx = alcCreateContext(dev[0], NULL);
alcMakeContextCurrent(ctx);
alGenSources(1, &source);
alGenBuffers(3, buffers);
/* Setup some initial silent data to play out of the source */
alBufferData(buffers[0], AL_FORMAT_MONO16, data, sizeof(data), 22050);
alBufferData(buffers[1], AL_FORMAT_MONO16, data, sizeof(data), 22050);
alBufferData(buffers[2], AL_FORMAT_MONO16, data, sizeof(data), 22050);
alSourceQueueBuffers(source, 3, buffers);
/* If you don't need 3D spatialization, this should help processing time */
alDistanceModel(AL_NONE); 
dev[1] = alcCaptureOpenDevice(NULL, 22050, AL_FORMAT_MONO16, sizeof(data)/2); //22050 mean 22.050 samples per     second. or 44100 for 44.1 per second.
/* Start playback and capture, and enter the audio loop */
alSourcePlay(source);
alcCaptureStart(dev[1]);    //starts ring buffer
while(1) 
{
    /* Check if any queued buffers are finished */
    alGetSourcei(source, AL_BUFFERS_PROCESSED, &val);
    if(val <= 0)
        continue;
    /* Check how much audio data has been captured (note that 'val' is the
    * number of frames, not bytes) */
    alcGetIntegerv(dev[1], ALC_CAPTURE_SAMPLES, 1, &val);
    /* Read the captured audio */
    alcCaptureSamples(dev[1], data, val);

        //***** Process/filter captured data here *****//

c1ount = c1ount +1;
if(c1ount >= 33){
          break;
         }

        //for (int ii=0;ii<val;++ii) {
        //  data[ii]*=0.1; // Make it quieter
        //}
    //***** end Process/filter captured data here *****//
    /* Pop the oldest finished buffer, fill it with the new capture data,
    then re-queue it to play on the source */
    alSourceUnqueueBuffers(source, 1, &buf);
    alBufferData(buf, AL_FORMAT_MONO16, data, val*2 /* bytes here, not
    frames */, 22050);
    alSourceQueueBuffers(source, 1, &buf);
    /* Make sure the source is still playing */
    alGetSourcei(source, AL_SOURCE_STATE, &val);
    if(val != AL_PLAYING)
    {
        alSourcePlay(source);
    }
}
cout<< "fggggggggn";

/* Shutdown and cleanup */
alcCaptureStop(dev[1]);
alcCaptureCloseDevice(dev[1]);
alSourceStop(source);
alDeleteSources(1, &source);
alDeleteBuffers(3, buffers);
alDeleteBuffers(1, &buf);
alcMakeContextCurrent(NULL);
alcDestroyContext(ctx);
alcCloseDevice(dev[0]); 
return 0;

}

我可以从麦克风录制的唯一程序在网上找到的是你刚开始的和我发给你的。我正朝着和你一样的方向前进。发送给你的I代码就是我正在尝试修改。我从斯塔克弗流开始。我用一种扭曲的BASIC编程语言找到了我们想要的代码，但我不擅长语言。链接是：

 http://www.blitzbasic.com/Community/posts.php?topic=90830
If you can get it to work that would be great. And even better, if it
could be change over to c/c++.
I have been looking for microphone capture programs for around two
years. Waiting for some thing simple to come along.
So now I am focusing on the these programs to figure how they work
with debugger and test subroutines figure out the dynamics of freealut.
because I do not see any thing simple comming along any time soon.
OpenAL is the only software I cold get to work.  the documentation
provided by Creative web site is good referance for some one who is
already an expert with the software.
I could not get FBOD, alas, SDL,  Allegro4, or OSS to work because
of a lack of working examples, or no good information.
Good luck.
   keghn