使用libmpg123加alsa实现MP3的播放/暂停，切换，模式选择，C语言5

note:前面的播放/暂停都是使用互斥锁加条件变量阻塞线程，现在播放/暂停是结束线程，记录暂停的位置，播放时从暂停的位置继续播放。关键点在于记录暂停位置的函数pause_position = mpg123_tell(mh);播放重新定位到这个位置：mpg123_seek(mh, pause_position, SEEK_SET);

以下为我的c语言例程源码：

#include <alsa/asoundlib.h>
#include <mpg123.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>

#define PCM_DEVICE "default"
#define MAX_SONGS 3

// 歌曲列表
char *songs[MAX_SONGS] = {
      "/mnt/hgfs/share/talk_anymore.mp3",
    "/mnt/hgfs/share/poxiao.mp3",
    "/mnt/hgfs/share/attention.mp3"
};

int current_song = 0;
int play_mode = 0;  // 0: 单曲播放, 1: 单曲循环, 2: 列表循环
int is_paused = 0;  // 播放暂停标志
int stop_playback = 0;  // 停止播放标志
int is_playing = 0;  // 是否正在播放标志
char *music_mode[3] = {"单曲模式", "单曲循环", "列表循环"};

pthread_mutex_t mutex;
pthread_cond_t cond;

mpg123_handle *mh;
snd_pcm_t *pcm_handle;
pthread_t play_thread;
off_t pause_position = 0; // 记录暂停位置

// 清理函数，释放资源
void cleanup() {
    if (mh) {
        mpg123_close(mh);
        mpg123_delete(mh);
    }
    if (pcm_handle) {
        snd_pcm_close(pcm_handle);
    }
    mpg123_exit();
}

// 设置ALSA设备
int setup_alsa(int rate, int channels) {
    int err;
    snd_pcm_hw_params_t *params;

    if ((err = snd_pcm_open(&pcm_handle, PCM_DEVICE, SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
        fprintf(stderr, "无法打开PCM设备 %s: %s\n", PCM_DEVICE, snd_strerror(err));
        return -1;
    }

    snd_pcm_hw_params_alloca(&params);
    snd_pcm_hw_params_any(pcm_handle, params);
    snd_pcm_hw_params_set_access(pcm_handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
    snd_pcm_hw_params_set_format(pcm_handle, params, SND_PCM_FORMAT_S16_LE);
    snd_pcm_hw_params_set_channels(pcm_handle, params, channels);
    snd_pcm_hw_params_set_rate(pcm_handle, params, rate, 0);
    if ((err = snd_pcm_hw_params(pcm_handle, params)) < 0) {
        fprintf(stderr, "无法设置PCM硬件参数: %s\n", snd_strerror(err));
        return -1;
    }

    if ((err = snd_pcm_prepare(pcm_handle)) < 0) {
        fprintf(stderr, "无法准备PCM设备: %s\n", snd_strerror(err));
        return -1;
    }

    return 0;
}

// 播放歌曲的线程函数
void *play_song_thread(void *arg) {
    int song_index = *(int *)arg;
    free(arg);  // 释放分配的内存
    int err;
    size_t done;
    unsigned char *audio;
    int channels, encoding;
    long rate;

    // 打开MP3文件
    if (mpg123_open(mh, songs[song_index]) != MPG123_OK) {
        fprintf(stderr, "无法打开文件 %s: %s\n", songs[song_index], mpg123_strerror(mh));
        is_playing = 0;
        return NULL;
    }

    // 获取MP3格式
    if (mpg123_getformat(mh, &rate, &channels, &encoding) != MPG123_OK) {
        fprintf(stderr, "无法获取文件格式: %s\n", mpg123_strerror(mh));
        mpg123_close(mh);
        is_playing = 0;
        return NULL;
    }

    // 配置ALSA
    if (setup_alsa(rate, channels) != 0) {
        mpg123_close(mh);
        is_playing = 0;
        return NULL;
    }

    // 设置输出格式为当前格式
    mpg123_format_none(mh);
    mpg123_format(mh, rate, channels, encoding);

    // 如果暂停位置不为0，跳转到暂停位置
    if (pause_position > 0) {
        mpg123_seek(mh, pause_position, SEEK_SET);
        pause_position = 0;  // 重置暂停位置
    }

    // 分配音频缓冲区
    size_t buffer_size = mpg123_outblock(mh);
    audio = (unsigned char*) malloc(buffer_size);
    if (!audio) {
        fprintf(stderr, "无法分配音频缓冲区\n");
        snd_pcm_close(pcm_handle);
        mpg123_close(mh);
        is_playing = 0;
        return NULL;
    }

    printf("当前播放歌曲是%s   ,歌曲模式是%s \r\n", songs[song_index], music_mode[play_mode]);
    is_playing = 1;

    while (!stop_playback) {
        pthread_mutex_lock(&mutex);
        while (is_paused && !stop_playback) {
            pthread_cond_wait(&cond, &mutex);
        }
        pthread_mutex_unlock(&mutex);

        if (stop_playback) break;

        int ret = mpg123_read(mh, audio, buffer_size, &done);
        if (ret == MPG123_OK || ret == MPG123_DONE) {
            // 写入PCM数据
            if ((err = snd_pcm_writei(pcm_handle, audio, done / (channels * 2))) < 0) { // 2 bytes per sample for S16_LE
                fprintf(stderr, "snd_pcm_writei error: %s\n", snd_strerror(err));
                snd_pcm_prepare(pcm_handle);
            }
        }

        if (ret == MPG123_DONE) {
            // 根据播放模式处理
            pthread_mutex_lock(&mutex);
            if (play_mode == 1) { // 单曲循环
                mpg123_seek(mh, 0, SEEK_SET);
                printf("单曲循环\r\n");
                pthread_mutex_unlock(&mutex);
                continue;
            } else if (play_mode == 2) { // 列表循环
                current_song = (current_song + 1) % MAX_SONGS;
                pthread_mutex_unlock(&mutex);
                free(audio);  // 释放音频缓冲区
                snd_pcm_drop(pcm_handle);
                mpg123_close(mh);
                is_playing = 0;
                start_song(current_song);
                printf("列表循环\r\n");
                return NULL;
            } else { // 单曲播放
                pthread_mutex_unlock(&mutex);
                printf("单曲结束\r\n");
                break; // 退出循环
            }
        } else if (ret != MPG123_OK) {
            fprintf(stderr, "mpg123_read error: %s\n", mpg123_strerror(mh));
            break;
        }
    }

    printf("退出线程了\r\n");
    free(audio);
    snd_pcm_drain(pcm_handle);
    snd_pcm_close(pcm_handle);
    mpg123_close(mh);
    is_playing = 0;
    return NULL;
}

// 开始播放歌曲
void start_song(int song_index) {
    if (is_playing) {
        stop_playback = 1;  // 停止当前播放的歌曲
        pthread_cond_signal(&cond); // 唤醒播放线程以便其检查停止标志
        pthread_join(play_thread, NULL);
        stop_playback = 0;
    }

    // 分配内存以传递给线程
    int *arg = malloc(sizeof(int));
    if (!arg) {
        fprintf(stderr, "无法分配内存\n");
        return;
    }
    *arg = song_index;

    // 重置暂停标志
    is_paused = 0;

    // 创建新的播放线程
    if (pthread_create(&play_thread, NULL, play_song_thread, arg) != 0) {
        fprintf(stderr, "无法创建播放线程\n");
        free(arg);
        return;
    }
}

// 切换播放/暂停状态
void toggle_play_pause() {
    pthread_mutex_lock(&mutex);
    if (is_playing) {  // 如果当前正在播放
        if (is_paused) {
            // 恢复播放
            is_paused = 0;
            pthread_cond_signal(&cond);
            printf("继续播放\n");
        } else {
            // 暂停播放并记录当前播放位置
            pause_position = mpg123_tell(mh);
            stop_playback = 1;  // 终止当前播放线程
            pthread_cond_signal(&cond);  // 唤醒线程以便其检查停止标志
            pthread_join(play_thread, NULL);  // 等待线程结束
            stop_playback = 0;
            is_paused = 1;
            printf("暂停播放, 位置: %ld\n", pause_position);
        }
    } else {
        start_song(current_song);  // 如果没有播放，开始播放当前歌曲
    }
    pthread_mutex_unlock(&mutex);
}

// 切换播放模式
void switch_play_mode() {
    play_mode = (play_mode + 1) % 3;
    printf("播放模式切换为: %s\n", music_mode[play_mode]);
}

int main() {
    // 初始化MPG123库
    if (mpg123_init() != MPG123_OK) {
        fprintf(stderr, "无法初始化MPG123库\n");
        return 1;
    }

    // 创建MPG123句柄
    if ((mh = mpg123_new(NULL, NULL)) == NULL) {
        fprintf(stderr, "无法创建MPG123句柄\n");
        mpg123_exit();
        return 1;
    }

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond, NULL);

    // 开始播放第一首歌曲
    start_song(current_song);

    // 控制循环
    char command;
    while (1) {
        printf("输入 'p' 播放/暂停, 'n' 下一首, 'm' 切换模式, 'q' 退出: ");
        command = getchar();
        getchar(); // 处理换行符
        if (command == 'p') {
            toggle_play_pause();
        } else if (command == 'n') {
            pause_position = 0;
            current_song = (current_song + 1) % MAX_SONGS;
            start_song(current_song);
        } else if (command == 'm') {
            switch_play_mode();
        } else if (command == 'q') {
            break;
        }
    }

    stop_playback = 1;
    pthread_cond_signal(&cond);
    pthread_join(play_thread, NULL);

    cleanup();
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

    return 0;
}