उबंटू में जीसीसी का उपयोग करके एक विशेष आवृत्ति की आवाज उत्पन्न करना?

Question

मैं सी/सी ++ में किसी विशेष आवृत्ति की ध्वनि कैसे उत्पन्न कर सकता हूं। मैं उबंटू 10.04 चलाता हूं और जीसीसी का उपयोग करता हूं। विंडोज के लिए टर्बोसी पर फ़ंक्शन है। क्या जीसीसी के बराबर है?

Answer 1

नीचे एक कोड PortAudio पुस्तकालय का उपयोग तय आवृत्ति के एक वर्ग ऑडियो लहर उत्पन्न करने के लिए है। gcc buzzer.c -o buzzer -lportaudio के साथ लिनक्स संकलन पर। विंडोज के लिए भी ठीक संकलित करना चाहिए। मुझे नहीं पता कि sound(int frequency) वास्तव में कैसे व्यवहार करता है, लेकिन नीचे पुरानी शैली के buzzers के किसी भी उपयोग अनुकरण करने में सक्षम होना चाहिए। आपको portaudio-devel (या उबंटू, पोर्टौडियो-देव?) पैकेज के लिए समकक्ष और पल्स ऑडियो के लिए शायद पोर्टऑडियो का कुछ नया संस्करण हो सकता है जो आपके रेपो में है। इसे संकलित करना कोई समस्या नहीं है। आप WTFPL लाइसेंस की शर्तों पर नीचे दिए गए कोड का उपयोग कर सकते हैं। :-) (यह पोर्टऑडियो उदाहरण से लिया गया है)

#include <stdio.h> 
#include <math.h> 
#include "portaudio.h" 
#include <stdint.h> 
#include <unistd.h> // for usleep() 

#define SAMPLE_RATE (44100) 
#define FRAMES_PER_BUFFER (64) 

typedef struct 
{ 
    uint32_t total_count; 
    uint32_t up_count; 

    uint32_t counter; 
    uint32_t prev_freq; 
    uint32_t freq; 
} paTestData; 

//volatile int freq = 0; 

/* This routine will be called by the PortAudio engine when audio is needed. 
** It may called at interrupt level on some machines so don't do anything 
** that could mess up the system like calling malloc() or free(). 
*/ 
static int patestCallback(const void *inputBuffer, void *outputBuffer, 
          unsigned long framesPerBuffer, 
          const PaStreamCallbackTimeInfo* timeInfo, 
          PaStreamCallbackFlags statusFlags, 
          void *userData) 
{ 
    paTestData *data = (paTestData*)userData; 
    uint8_t *out = (uint8_t*)outputBuffer; 
    unsigned long i; 
    uint32_t freq = data->freq; 

    (void) timeInfo; /* Prevent unused variable warnings. */ 
    (void) statusFlags; 
    (void) inputBuffer; 

    for(i=0; i<framesPerBuffer; i++) 
    { 
     if(data->up_count > 0 && data->total_count == data->up_count) { 
      *out++ = 0x00; 
      continue; 
     } 
     data->total_count++; 

     if(freq != data->prev_freq) { 
      data->counter = 0; 
     } 

     if(freq) { 
      int overflow_max = SAMPLE_RATE/freq; 
      uint32_t data_cnt = data->counter % overflow_max; 
      if(data_cnt > overflow_max/2) 
       *out++ = 0xff; 
      else { 
       *out++ = 0x00; 
      } 
      data->counter++; 
     } 
     else { 
      data->counter = 0; 
      *out++ = 0; 
     } 
     data->prev_freq = freq; 
    } 

    return paContinue; 
} 

static PaStream *stream; 
static paTestData data; 


void buzzer_set_freq(int frequency) 
{ 
    data.up_count = 0; // do not stop! 
    data.freq = frequency; 
} 

void buzzer_beep(int frequency, int msecs) 
{ 
    data.total_count = 0; 
    data.up_count = SAMPLE_RATE * msecs/1000; 
    data.freq = frequency; 
} 

int buzzer_start(void) 
{ 
    PaStreamParameters outputParameters; 

    PaError err; 
    int i; 

    err = Pa_Initialize(); 
    if(err != paNoError) goto error; 

    outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */ 
    outputParameters.channelCount = 1;  /* stereo output */ 
    outputParameters.sampleFormat = paUInt8; /* 32 bit floating point output */ 
    outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputParameters.device)->defaultLowOutputLatency; 
    outputParameters.hostApiSpecificStreamInfo = NULL; 

    err = Pa_OpenStream(
     &stream, 
     NULL, /* no input */ 
     &outputParameters, 
     SAMPLE_RATE, 
     FRAMES_PER_BUFFER, 
     paClipOff,  /* we won't output out of range samples so don't bother clipping them */ 
     patestCallback, 
     &data); 
    if(err != paNoError) goto error; 

    err = Pa_StartStream(stream); 
    if(err != paNoError) goto error; 

    return err; 
error: 
    Pa_Terminate(); 
    fprintf(stderr, "An error occured while using the portaudio stream\n"); 
    fprintf(stderr, "Error number: %d\n", err); 
    fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); 
    return err; 

} 

int buzzer_stop() 
{ 
    PaError err = 0; 
    err = Pa_StopStream(stream); 
    if(err != paNoError) goto error; 

    err = Pa_CloseStream(stream); 
    if(err != paNoError) goto error; 

    Pa_Terminate(); 

    return err; 
error: 
    Pa_Terminate(); 
    fprintf(stderr, "An error occured while using the portaudio stream\n"); 
    fprintf(stderr, "Error number: %d\n", err); 
    fprintf(stderr, "Error message: %s\n", Pa_GetErrorText(err)); 
    return err; 
} 
void msleep(int d){ 
    usleep(d*1000); 
} 
int main(void) 
{ 

    // notes frequency chart: http://www.phy.mtu.edu/~suits/notefreqs.html 

    buzzer_start(); 
    buzzer_set_freq(261); 
    msleep(250); 
    buzzer_set_freq(293); 
    msleep(250); 
    buzzer_set_freq(329); 
    msleep(250); 
    buzzer_set_freq(349); 
    msleep(250); 
    buzzer_set_freq(392); 
    msleep(250); 
    buzzer_set_freq(440); 
    msleep(250); 
    buzzer_set_freq(494); 
    msleep(250); 
    buzzer_beep(523, 200); 
    msleep(250); 

    buzzer_stop(); 

    return 0; 
}