Question

我正在尝试从客户端通过套接字（UDP）传输wav文件，并让服务器通过ALSA库播放wav文件。

由于我在C语言中的编码水平很低，因此我首先学习了如何通过套接字和交换文本消息建立客户端与服务器之间的通信。

然后，我学习了如何通过在运行播放应用程序时重定向标准输入来使用ALSA播放wav文件。

我尝试合并两个代码（UDPServer.c + playing.c）文件，当我将stdin传递到UDPClient.c文件时，它将其发送到UDPServer.c，但这只是纯音而不是我要传递的实际音乐文件。

我不知道如何精确地将文件传递到UDPClient.c中，以便将其发送到服务器的套接字。

UDPServer.c

// Server side implementation of UDP client-server model 

// Libraries
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <string.h> 
#include <sys/types.h> 
#include <sys/socket.h> 
#include <arpa/inet.h> 
#include <netinet/in.h> 

#include <alsa/asoundlib.h>

// CONSTANTS
#define PORT     8080 
#define MAXLINE  2048
/* Use the newer ALSA API */
#define ALSA_PCM_NEW_HW_PARAMS_API

// FUNCTION DECLARATION
int audio_play (char signal);

// Main code 
int main() { 
int sockfd; 
char buffer[MAXLINE]; 
char *hello = "AUDIO PLAYBACK FINISH"; 
struct sockaddr_in servaddr, cliaddr; 

// Creating socket file descriptor 
if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) { 
    perror("socket creation failed"); 
    exit(EXIT_FAILURE); 
} 

memset(&servaddr, 0, sizeof(servaddr)); 
memset(&cliaddr, 0, sizeof(cliaddr)); 

// Filling server information 
servaddr.sin_family = AF_INET; // IPv4 
servaddr.sin_addr.s_addr = INADDR_ANY; 
servaddr.sin_port = htons(PORT); 

// Bind the socket with the server address 
if ( bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0 ) { 
    perror("bind failed"); 
    exit(EXIT_FAILURE); 
} 

int len, n; 

len = sizeof(cliaddr); //len is value/result 

// Receive a mesage from the socket
n = recvfrom(sockfd, (char *)buffer, MAXLINE, MSG_WAITALL, ( struct sockaddr *) &cliaddr, &len); 
buffer[n] = '\0'; 
//printf("Client : %s\n", buffer); 
audio_play(buffer);


// Send a message on the socket
sendto(sockfd, (const char *)hello, strlen(hello), MSG_CONFIRM, (const struct sockaddr *) &cliaddr, len); 
printf("PLAYING AUDIO???.\n"); 

return 0; 
} 


// FUNCTIONS

int audio_play (char s)
{
   long                 loops;
   int                  rc;
   int                  size;
   snd_pcm_t            *handle;
   snd_pcm_hw_params_t  *params;
   unsigned int         val;
   int                  dir;
   snd_pcm_uframes_t    frames;
   char                 *buffer;

   /* Open PCM device for playback. */
   rc = snd_pcm_open(&handle, "default", SND_PCM_STREAM_PLAYBACK, 0);

   if (rc < 0) {
        fprintf(stderr, "unable to open pcm device: %s\n", snd_strerror(rc));
        exit(1);
   }

   /* Allocate a hardware parameters object. */
   snd_pcm_hw_params_alloca(&params);
   /* Fill it in with default values. */
   snd_pcm_hw_params_any(handle, params);
   /* Set the desired hardware parameters. */
   /* Interleaved mode */
   snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
   /* Signed 16-bit little-endian format */
   snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);
   /* Two channels (stereo) */
   snd_pcm_hw_params_set_channels(handle, params, 2);
   /* 48000 bits/second sampling rate */
   val = 48000;
   snd_pcm_hw_params_set_rate_near(handle, params, &val, &dir);
   /* Set period size to 32 frames. */
   frames = 32;
   snd_ pcm_hw_params_set_period_size_near(handle, params, &frames, &dir);

   /* Write the parameters to the driver */
   rc = snd_pcm_hw_params(handle, params);

   if (rc < 0) {
      fprintf(stderr, "unable to set hw parameters: %s\n", snd_strerror(rc));
   exit(1);
   }

   /* Use a buffer large enough to hold one period */
   snd_pcm_hw_params_get_period_size(params, &frames, &dir);
   size = frames * 4; /* 2 bytes/sample, 2 channels */
   buffer = (char *) malloc(size);
   /* We want to loop for 5 seconds */
   snd_pcm_hw_params_get_period_time(params, &val, &dir);
   /* 5 seconds in microseconds divided by
    * period time */
   loops = 5000000 / val;

   while (loops > 0) {
       loops--;
       //    rc = read(0, buffer, size);
       rc = s;

       if (rc == 0) {
           fprintf(stderr, "end of file on input\n");
           break;

       } else if (rc != size) {
          fprintf(stderr, "short read: read %d bytes\n", rc);
       }
       rc = snd_pcm_writei(handle, buffer, frames);

       if (rc == -EPIPE) {
       /* EPIPE means underrun */
           fprintf(stderr, "underrun occurred\n");
           snd_pcm_prepare(handle);

       } else if (rc < 0) {
           fprintf(stderr, "error from writei: %s\n", snd_strerror(rc));

       }  else if (rc != (int)frames) {
           fprintf(stderr, "short write, write %d frames\n", rc);
       }
   }

   snd_pcm_drain(handle);
   snd_pcm_close(handle);
   free(buffer);

}

UDPClient.c

// Client side implementation of UDP client-server model 
// Libraries
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <string.h> 
#include <sys/types.h> 
#include <sys/socket.h> 
#include <arpa/inet.h> 
#include <netinet/in.h> 

// CONSTANTS
#define PORT     8080 
#define MAXLINE  2048

// Main code
int main(int argc, char **argv) { 
    int sockfd; 
    char buffer[MAXLINE]; 
    char *data = "Here is where the file of audio should be?";
    struct sockaddr_in   servaddr; 

    // Creating socket file descriptor 
    if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 ) { 
        perror("socket creation failed"); 
        exit(EXIT_FAILURE); 
    } 

    memset(&servaddr, 0, sizeof(servaddr)); 

    // Filling server information 
    servaddr.sin_family = AF_INET; 
    servaddr.sin_port = htons(PORT); 
    servaddr.sin_addr.s_addr = INADDR_ANY; 

    int n, len; 

    // Send a message on the socket 
    sendto(sockfd, (const char *)data, strlen(data), MSG_CONFIRM, (const struct sockaddr *) &servaddr, sizeof(servaddr)); 
    printf("AUDIO SENT.\n"); 

    // Receive a message from the socket
    n = recvfrom(sockfd, (char *)buffer, MAXLINE, MSG_WAITALL, (struct sockaddr *) &servaddr, &len); 
    buffer[n] = '\0'; 
    printf("Server : %s\n", buffer); 

    close(sockfd); 
    return 0; 
}

通过套接字（UDP）传输音频，但不能正确播放

0 个答案: