C++ - lire un ton généré à partir d'une onde sinusoïdale

Salut tout le monde, je suis en train d'essayer de comprendre comment lire un ton que j'ai généré à l'aide d'une onde sinusoïdale.

Voici mon code:

#include <iostream>
#include <OpenAL/al.h>
#include <OpenAL/alc.h>
#include <Math.h>

using namespace std;

int main (int argc, char * const argv[]) {

    int number = 0;
    int i, size;
    double const Pi=4*atan(1); 
    cout << "Enter number of seconds:" << endl;
    scanf("%d", &number);
    size = 44100*number;
    unsigned char buffer [size]; //buffer array

    for(i = 0; i < size; i++){
        buffer[i] = (char)sin((2*Pi*440)/(44100*i))*127;
    }

    return 0;
}

Évidemment, il ne fait rien pour le moment, puisque je n'ai aucune idée de comment jouer le tampon.
Je ne veux pas générer un fichier wav, je ne veux charger un. Je veux juste jouer le tampon que j'ai généré.

Je suis actuellement en train de travailler sur Mac OS X, et ont essayé d'utiliser OpenAL méthodes - toutefois, j'ai constaté que alut et alu ne sont pas une partie de plus et si j'essaie de l'utiliser, alors il s'avère que c'est tous les pillèrent toute façon.
J'ai aussi essayé d'inclure QAudioOutput, mais pour quelque raison il ne semble pas être n'importe où sur mon Mac.

Je veux juste une simple lecture de la tonalité, j'ai créé. Quelqu'un aurait-il tout ce qu'ils peuvent m'indiquer?

Tas merci!!!

OriginalL'auteur Moonlight293 | 2011-03-29

  1. 12

    J'ai écrit un exemple exactement pour cela. Fonctionne très bien avec OpenAL sous MacOSX et joue lisse seins. Jetez un oeil ici:
    http://ioctl.eu/blog/2011/03/16/openal-sine-synth/

    Code est assez court, je suppose que je peux l'ajouter ici un souci d'exhaustivité:

    #include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <OpenAL/al.h>
#include <OpenAL/alc.h>
#define CASE_RETURN(err) case (err): return "##err"
const char* al_err_str(ALenum err) {
switch(err) {
CASE_RETURN(AL_NO_ERROR);
CASE_RETURN(AL_INVALID_NAME);
CASE_RETURN(AL_INVALID_ENUM);
CASE_RETURN(AL_INVALID_VALUE);
CASE_RETURN(AL_INVALID_OPERATION);
CASE_RETURN(AL_OUT_OF_MEMORY);
}
return "unknown";
}
#undef CASE_RETURN
#define __al_check_error(file,line) \
do { \
ALenum err = alGetError(); \
for(; err!=AL_NO_ERROR; err=alGetError()) { \
std::cerr << "AL Error " << al_err_str(err) << " at " << file << ":" << line << std::endl; \
} \
}while(0)
#define al_check_error() \
__al_check_error(__FILE__, __LINE__)
void init_al() {
ALCdevice *dev = NULL;
ALCcontext *ctx = NULL;
const char *defname = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
std::cout << "Default device: " << defname << std::endl;
dev = alcOpenDevice(defname);
ctx = alcCreateContext(dev, NULL);
alcMakeContextCurrent(ctx);
}
void exit_al() {
ALCdevice *dev = NULL;
ALCcontext *ctx = NULL;
ctx = alcGetCurrentContext();
dev = alcGetContextsDevice(ctx);
alcMakeContextCurrent(NULL);
alcDestroyContext(ctx);
alcCloseDevice(dev);
}
int main(int argc, char* argv[]) {
/* initialize OpenAL */
init_al();
/* Create buffer to store samples */
ALuint buf;
alGenBuffers(1, &buf);
al_check_error();
/* Fill buffer with Sine-Wave */
float freq = 440.f;
int seconds = 4;
unsigned sample_rate = 22050;
size_t buf_size = seconds * sample_rate;
short *samples;
samples = new short[buf_size];
for(int i=0; i<buf_size; ++i) {
samples[i] = 32760 * sin( (2.f*float(M_PI)*freq)/sample_rate * i );
}
/* Download buffer to OpenAL */
alBufferData(buf, AL_FORMAT_MONO16, samples, buf_size, sample_rate);
al_check_error();
/* Set-up sound source and play buffer */
ALuint src = 0;
alGenSources(1, &src);
alSourcei(src, AL_BUFFER, buf);
alSourcePlay(src);
/* While sound is playing, sleep */
al_check_error();
sleep(seconds);
/* Dealloc OpenAL */
exit_al();
al_check_error();
return 0;
}

    Mise à jour: j'ai trouvé OpenAL un peu trop limitatif pour mes besoins, comme j'ai quelques problèmes avec faible latence de lecture, comme cela semble être le principal domaine d'OpenAL. Au lieu de cela, je l'ai trouvé très convaincant PortAudio: http://www.portaudio.com/
    Il prend en charge toutes les principales plates-formes (Mac,Win,Unix/ALSA) et semble très bien. Il est un exemple pour le sinus de la lecture qui est beaucoup plus sophistiquée, mais très simple. Il suffit de télécharger la dernière version et trouver le sine-la lecture de l'échantillon à tester/patest_sine.c

    Merci!!!!! C'est exactement ce dont j'avais besoin 🙂
    Juste une petite question - qu'est-ce que le 32760 pour lors de la prise des échantillons? Tas merci!
    le format audio est MONO16, c'est à dire à 16 bits par échantillon. sine généré est float, donc de -1 à 1. De la carte à 16 bits, c'est à dire à partir de -32767 à 32768, je multiplie ce nombre. Un peu moins..uhm..paresse
    Pour moi #include <AL/alut.h> œuvres au lieu de #include <OpenAL/al.h>. probablement votre code est obsolète,
    aussi au lieu de sleep fonction, vous devez utiliser alutSleep. sleep peut ne pas fonctionner dans certains OS.

    OriginalL'auteur zerm

  2. 0

    Vous aurez besoin de passer par le système d'exploitation pour lire des sons. Ce n'est pas aussi simple que vous ne le pensez. Dans OSX, vous aurez besoin de passer par CoreAudio.

    Une meilleure approche serait d'utiliser un wrapper de la bibliothèque comme PortAudio (http://www.portaudio.com/) qui permet de rendre votre code plus portable et vous faire économiser de l'réutilisable nécessaires pour obtenir le son de votre programme.

    Ce presque travaillé jusqu'à ce que j'ai eu un tas d'erreurs de liaison! Mais je pense que c'est ma propre compétence de programmation qu'il a fait, de sorte que cette option assez travaillé beaucoup trop.

    OriginalL'auteur Jean-Marc Pelletier

  3. 0

    Essayez ceci (ce programme utilise La transformée en Z concept, un exemple complet qui génère des tonalités dtmf avec ALSA et compilable sous LINUX sont disponibles ici):

    /*
*  Cosine Samples Generator
*
*  Autor: Volnei Klehm
*  Data: 04/01/2014
*/
#include <math.h>
#include <stdio.h>
#define S_FREQ 8000 /*Sample frequency, should be greater thar 2*sineFrequency
If using audio output it has to be the same saple frequency 
Used there*/
const float frequency_in_Hertz = 697; /*set output frequency*/
const float generatorContant1 = cosf(2*M_PI*(frequency_in_Hertz/S_FREQ));
const float generatorContant2 = sinf(2*M_PI*(frequency_in_Hertz/S_FREQ));
float GenerateSignal(){
static float Register[2]={1,0};
static float FeedBack;
FeedBack=2*generatorContant1*Register[0]-Register[1];
Register[1]=Register[0];  
Register[0]=FeedBack;
return (generatorContant2*Register[1]);
}
int main(void) {
/*generate 300 samples*/
for (int NumberOfSamples = 300; NumberOfSamples > 0; NumberOfSamples--) 
printf("\n%f", GenerateSignal());
return 0;
}
    J'ai testé aucune des sons produits.
    Cette version tout simplement de générer les valeurs, pour plein DTMF suivez le lien sur la description.

    OriginalL'auteur Elvis Rock Code