C: Linux C 编程 - SDL+mpg123音频处理

采样率

 

采样率可以通过mpg123_rates函数获取mpg123支持哪些采样率：

MPG123_EXPORT void mpg123_rates(const long **list, size_t *number);

 

通道数

定义：

/** They can be combined into one number (3) to indicate mono and stereo... */

enum mpg123_channelcount

{

MPG123_MONO   = 1 /**< mono */

,MPG123_STEREO = 2 /**< stereo */

};

 

编码（格式）

 

编码（格式）可以通过mpg123_encodings函数获取mpg123支持哪些编码（格式）：

MPG123_EXPORT void mpg123_encodings(const int **list, size_t *number);

 

获取音频格式：

MPG123_EXPORT int mpg123_getformat( mpg123_handle *mh

, long *rate, int *channels, int *encoding );
参数rate表示采样率

参数channels表示通道数

参数encoding表示编码（格式）

 

播放mp3格式的音频

#include<stdio.h>
#include<string.h>
#include<SDL_audio.h>
#include<mpg123.h>

#define CHUNK_SIZE 16384

#define INIT_CHUNK_LIST(chunk_list) \
{                                   \
  chunk_list.head = NULL;           \
  chunk_list.tail = NULL;           \
  chunk_list.ptr = NULL;            \
  chunk_list.ptr_pos = 0;           \
}

typedef struct chunk
{
  unsigned char data[CHUNK_SIZE];
  int size;
  struct chunk *next;
} chunk_t;

typedef struct 
{
  struct chunk *head;
  struct chunk *tail;

  struct chunk *ptr;
  int ptr_pos;
} chunk_list_t;


#define BUFFER_SIZE 16384

chunk_list_t chunk_list;

struct chunk* alloc_chunk() 
{
  struct chunk *ptr = (struct chunk *) malloc(sizeof(struct chunk));
  memset(ptr, 0, sizeof(struct chunk));
  return ptr;
}

int chunk_list_empty(chunk_list_t *chunk_list)
{
  return chunk_list->head == NULL && chunk_list->tail == NULL;
}

void chunk_list_add(chunk_list_t *chunk_list, chunk_t *chunk)
{
  if (chunk_list_empty(chunk_list))
  {
    chunk_list->head = chunk;
    chunk_list->tail = chunk;
  }
  else
  {
    chunk_list->tail->next = chunk;
    chunk_list->tail = chunk;
  }
}

void callback_on_take_sample(void *unused, Uint8 *stream, int len)
{
  chunk_list_t* chunk_list = (chunk_list_t *) (unused);
  chunk_t *ptr;
next:
  ptr = chunk_list->ptr;
  if (ptr == NULL)
  {
    SDL_PauseAudio(1);
    return;
  }

  int amount = ptr->size - chunk_list->ptr_pos;
  if (amount > len) 
  {
    amount = len;
  }

  if (amount <= 0)
  {
    chunk_list->ptr = ptr->next;
    chunk_list->ptr_pos = 0;
    goto next;
  }

  printf("audio: len= %u, pos= %u. audio buffer: @%p, len= %d, amount= %d\n", ptr->size, chunk_list->ptr_pos, stream, len, amount);
  SDL_memcpy(stream, ptr->data + chunk_list->ptr_pos, amount);
  chunk_list->ptr_pos += amount;
}

void memdump(unsigned char* in, size_t size)
{
  int i;
  for (i = 0; i < size; i++)
  {
    fprintf(stdout, "%.2X ", in[i]);
  }
  fprintf(stdout, "\n");
}

int read_chunk_internal_handle(mpg123_handle *handle, chunk_t* chunk, int *state)
{
  int result = 0;
  size_t nbytes;

  while(chunk->size < CHUNK_SIZE) 
  {
    result = mpg123_decode(handle, NULL, 0, chunk->data + chunk->size, CHUNK_SIZE - chunk->size, &nbytes);
    if (result == MPG123_ERR)
    {
      fprintf(stderr, "decode err: %d\n", result);
      return 1;
    }
    fprintf(stdout, "decode: result=%d, actually decoded bytes=%u\n", result, nbytes);

    if (nbytes > 0)
    {
      chunk->size += nbytes;
    }

    if (result == MPG123_NEW_FORMAT)
    {
      *state = result;
    }
    if (result == MPG123_NEED_MORE)
    {
      break;
    }
    if (result == MPG123_DONE)
    {
      *state = result;
      break;
    }
  }
  return 0;
}

int read_chunk(FILE *fp, mpg123_handle *handle, chunk_t* chunk, int *state)
{
  int result = 0;
  size_t nbytes;

  //fprintf(stdout, "reading from internal handle...\n");
  result = read_chunk_internal_handle(handle, chunk, state);
  if (result)
  {
    return result;
  }

  //fprintf(stdout, "reading from fp...\n");
  while(chunk->size < CHUNK_SIZE) 
  {
    char buf[BUFFER_SIZE];

    nbytes = fread(buf, 1, sizeof(buf), fp);
    result = ferror(fp);
    if (result)
    {
      fprintf(stderr, "read err: %d\n", result);
      return 1;
    }
    if (feof(fp))
    {
      return -1;
    }
    fprintf(stdout, "read: %d bytes\n", nbytes);

    result = mpg123_decode(handle, buf, nbytes, chunk->data + chunk->size, CHUNK_SIZE - chunk->size, &nbytes);
    if (result == MPG123_ERR)
    {
      fprintf(stderr, "decode err: %d\n", result);
      return 1;
    }
    fprintf(stdout, "decode: result=%d, actually decoded bytes=%u\n", result, nbytes);

    if (nbytes > 0)
    {
      chunk->size += nbytes;
    }

    if (result == MPG123_NEW_FORMAT)
    {
      *state = result;
    }
    if (result == MPG123_DONE)
    {
      break;
    }
  }
  return 0;
}

// .\mpg123_test h:\\yuganqingwuguan.mp3
int main(int argc, char** argv)
{
  int result = 0;
  char *filename;
  FILE *fp;

  
  chunk_t *chunk;

  const char **decoders;
  const char **supported_decoders;
  mpg123_handle *handle;

  SDL_AudioSpec audio_spec_desired;
  SDL_AudioSpec audio_spec_obtained;

  int i;

  if (argc != 2)
  {
    fprintf(stderr, "invalid args\n");
    return 1;
  }
  filename = argv[1];

  INIT_CHUNK_LIST(chunk_list);

  result = mpg123_init();
  if (result != MPG123_OK)
  {
    fprintf(stderr, "init err: %d\n", result);
    return 1;
  }

  fprintf(stdout, "available decoder list: \n");
  decoders = mpg123_decoders();
  for (i = 0; decoders[i] != NULL; i++)
  {
    fprintf(stdout, "\t%d: %s\n", i, decoders[i]);
  }

  supported_decoders = mpg123_supported_decoders();
  fprintf(stdout, "decoders supported: \n");
  for (i = 0; supported_decoders[i] != NULL; i++)
  {
    fprintf(stdout, "\t%d: %s\n", i, supported_decoders[i]);
  }

  handle = mpg123_new(NULL, &result);
  if (handle == NULL)
  {
    fprintf(stderr, "new err: %d\n", result);
  }

  fprintf(stdout, "current decoder: %s\n", mpg123_current_decoder(handle));

  result = mpg123_open_feed(handle);
  if (result != MPG123_OK)
  {
    fprintf(stderr, "open feed err: %d\n", result);
    return 1;
  }

  fp = fopen(filename, "rb");
  if (fp == NULL)
  {
    fprintf(stderr, "open err: %s\n", filename);
    return 1;
  }

  i = 0;
  while (result != MPG123_DONE)
  {
    int ret = 0;
    chunk = alloc_chunk();
    ret = read_chunk(fp, handle, chunk, &result);
    if (ret)
    {
      if (ret == -1)
      {
        break;
      }
      fprintf(stderr, "read chunk err\n");
      return 1;
    }
    i++;
    fprintf(stdout, "%d chunk readed...\n", i);
    chunk_list_add(&chunk_list, chunk);
    if (result == MPG123_NEW_FORMAT)
    {
      long rate;
      int channels;
      int encoding;

      result = mpg123_getformat(handle, &rate, &channels, &encoding);
      if (result != MPG123_OK)
      {
        fprintf(stderr, "get format err: %d\n", result);
        return 1;
      }
      fprintf(stdout, "format: rate=%ld, channels=%d, encoding=%d\n", rate, channels, encoding);

      chunk_list.ptr = chunk_list.head;

      audio_spec_desired.freq = rate; 
      audio_spec_desired.format = AUDIO_S16; 
      audio_spec_desired.samples = 4096; 
      audio_spec_desired.callback = callback_on_take_sample; 
      audio_spec_desired.userdata = &chunk_list; 
      audio_spec_desired.channels = channels;

      if (SDL_OpenAudio(&audio_spec_desired, &audio_spec_obtained) < 0)
      {
        fprintf(stderr, "open audio err: %s\n", SDL_GetError());
        return -1;
      }
    }
  }
  SDL_PauseAudio(0);
  printf("playing...%s\n", filename);

  while ((SDL_GetAudioStatus() == SDL_AUDIO_PLAYING)) 
  {
    SDL_Delay(1000);
  }
  printf("played!\n");

  SDL_CloseAudio();
  SDL_Quit();
}

编译

这里一次性完成编译链接。编译的时候注意通过“-I”指定头文件目录，在链接的时候通过“-L”指定要链接的静态库文件目录，以及通过“-l”指定要链接的静态库。

 

gcc -I/usr/local/SDL2-2.0.7/include/SDL2 -L/usr/local/lib -L/usr/local/SDL2-2.0.7/lib  mpg123_test.c -o mpg123_test -lSDL2 -lmpg123

 

运行

如果是在Cygwin下，在运行之前SDL2.dll、cygmpg123-0.dll拷贝到程序目录下：

>cp -rf d:\sbin\usr\local\sdl\bin\SDL2.dll .

>cp -rf D:\sbin\usr\local\bin\cygmpg123-0.dll .

 

>.\mpg123_test h:\\yuganqingwuguan.mp3