基于ffmpeg 带音量柱播放器源码

### 回答1：
以下是基于FFmpeg的音量柱播放器的示例代码：

#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <SDL2/SDL.h>
#include <SDL2/SDL_audio.h>
#include <SDL2/SDL_main.h>
#include <libavutil/avutil.h>
#include <libavutil/frame.h>
#include <libavutil/samplefmt.h>
#include <libavformat/avformat.h>
#include <libswresample/swresample.h>

#define OUTPUT_CHANNELS 2
#define OUTPUT_SAMPLE_RATE 44100
#define OUTPUT_BIT_RATE 64000

#define VOLUME_BAR_WIDTH 50
#define VOLUME_BAR_HEIGHT 10

#define MAX_AUDIO_FRAME_SIZE 192000

using namespace std;

struct AudioData {
    uint8_t* audio_buffer;
    uint32_t audio_pos;
    uint32_t audio_len;
};

void audio_callback(void* userdata, Uint8* stream, int len) {
    AudioData* audio_data = (AudioData*) userdata;

    if (audio_data->audio_len == 0) {
        return;
    }

    len = len > audio_data->audio_len ? audio_data->audio_len : len;

    SDL_memcpy(stream, audio_data->audio_buffer + audio_data->audio_pos, len);

    audio_data->audio_pos += len;
    audio_data->audio_len -= len;
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        cerr << "Usage: " << argv[0] << " <audio_file>" << endl;
        return 1;
    }

    const char* audio_file = argv[1];

    av_register_all();

    AVFormatContext* format_context = avformat_alloc_context();

    if (avformat_open_input(&format_context, audio_file, nullptr, nullptr) != 0) {
        cerr << "Error: could not open audio file" << endl;
        return 1;
    }

    if (avformat_find_stream_info(format_context, nullptr) < 0) {
        cerr << "Error: could not find audio stream information" << endl;
        return 1;
    }

    int audio_stream_index = -1;
    AVCodecContext* codec_context = nullptr;

    for (unsigned int i = 0; i < format_context->nb_streams; i++) {
        if (format_context->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            audio_stream_index = i;
            codec_context = avcodec_alloc_context3(nullptr);

            if (avcodec_parameters_to_context(codec_context, format_context->streams[i]->codecpar) < 0) {
                cerr << "Error: could not copy codec parameters to codec context" << endl;
                return 1;
            }

            break;
        }
    }

    if (audio_stream_index == -1) {
        cerr << "Error: could not find audio stream" << endl;
        return 1;
    }

    AVCodec* codec = avcodec_find_decoder(codec_context->codec_id);

    if (codec == nullptr) {
        cerr << "Error: could not find codec" << endl;
        return 1;
    }

    if (avcodec_open2(codec_context, codec, nullptr) < 0) {
        cerr << "Error: could not open codec" << endl;
        return 1;
    }

    AVPacket packet;
    AVFrame* frame = av_frame_alloc();
    uint8_t* buffer = (uint8_t*) av_malloc(MAX_AUDIO_FRAME_SIZE);

    SwrContext* swr_context = swr_alloc_set_opts(
        nullptr,
        av_get_default_channel_layout(OUTPUT_CHANNELS),
        AV_SAMPLE_FMT_S16,
        OUTPUT_SAMPLE_RATE,
        av_get_default_channel_layout(codec_context->channels),
        codec_context->sample_fmt,
        codec_context->sample_rate,
        0,
        nullptr
    );

    if (swr_init(swr_context) < 0) {
        cerr << "Error: could not initialize sample rate converter" << endl;
        return 1;
    }

    AVFrame* converted_frame = av_frame_alloc();
    int converted_frame_size = av_samples_get_buffer_size(
        nullptr,
        OUTPUT_CHANNELS,
        codec_context->frame_size,
        AV_SAMPLE_FMT_S16,
        1
    );

    AudioData audio_data;
    audio_data.audio_buffer = (uint8_t*) av_malloc(MAX_AUDIO_FRAME_SIZE);
    audio_data.audio_pos = 0;
    audio_data.audio_len = 0;

    SDL_Init(SDL_INIT_AUDIO);

    SDL_AudioSpec wanted_spec, obtained_spec;
    wanted_spec.freq = OUTPUT_SAMPLE_RATE;
    wanted_spec.format = AUDIO_S16SYS;
    wanted_spec.channels = OUTPUT_CHANNELS;
    wanted_spec.samples = codec_context->frame_size;
    wanted_spec.callback = audio_callback;
    wanted_spec.userdata = &audio_data;

    if (SDL_OpenAudio(&wanted_spec, &obtained_spec) < 0) {
        cerr << "Error: could not open audio device" << endl;
        return 1;
    }

    SDL_PauseAudio(0);

    while (av_read_frame(format_context, &packet) >= 0) {
        if (packet.stream_index == audio_stream_index) {
            int ret = avcodec_send_packet(codec_context, &packet);

            if (ret < 0) {
                cerr << "Error: could not send packet to decoder" << endl;
                return 1;
            }

            while (ret >= 0) {
                ret = avcodec_receive_frame(codec_context, frame);

                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
                    break;
                } else if (ret < 0) {
                    cerr << "Error: could not receive frame from decoder" << endl;
                    return 1;
                }

                int samples_count = swr_convert(
                    swr_context,
                    &buffer,
                    MAX_AUDIO_FRAME_SIZE,
                    (const uint8_t**) frame->data,
                    frame->nb_samples
                );

                memcpy(converted_frame->data[0], buffer, converted_frame_size);

                audio_data.audio_buffer = converted_frame->data[0];
                audio_data.audio_pos = 0;
                audio_data.audio_len = converted_frame_size;

                int volume_bar_count = (int) round(fabs(av_frame_get_best_effort_sample(frame, 0, 0)) / INT16_MAX * VOLUME_BAR_WIDTH);
                cout << "[";
                for (int i = 0; i < volume_bar_count; i++) {
                    cout << "=";
                }
                for (int i = 0; i < VOLUME_BAR_WIDTH - volume_bar_count; i++) {
                    cout << " ";
                }
                cout << "]" << endl;
            }

            av_packet_unref(&packet);
        }
    }

    avcodec_free_context(&codec_context);
    avformat_close_input(&format_context);
    av_frame_free(&frame);
    av_free(buffer);
    swr_free(&swr_context);
    av_frame_free(&converted_frame);
    av_free(audio_data.audio_buffer);

    SDL_CloseAudio();
    SDL_Quit();

    return 0;
}

该示例代码基于SDL2和FFmpeg，使用SDL2播放音频，并使用FFmpeg解码音频文件。在播放音频时，它还计算每个帧的音量并打印音量柱。

### 回答2：
基于ffmpeg的带音量柱播放器源码是通过使用ffmpeg库来解码音频文件，并通过音频分析算法来获取音频波形数据，然后将其绘制成音量柱状图显示在播放器界面上。

以下是一个可能的基于ffmpeg的带音量柱播放器的源码示例：

#include <iostream>
#include <SDL2/SDL.h>
#include <SDL2/SDL_audio.h>
#include <SDL2/SDL_mutex.h>
#include <SDL2/SDL_thread.h>
#include <ffmpeg/avcodec.h>
#include <ffmpeg/avformat.h>

#define MAX_AUDIO_FRAME_SIZE 192000

// 音频流数据缓冲区
typedef struct PacketQueue {
    AVPacketList *first_pkt;
    AVPacketList *last_pkt;
    int nb_packets;
    int size;
    SDL_mutex *mutex;
    SDL_cond *cond;
} PacketQueue;

PacketQueue audioq;
int quit = 0;

int audio_decode_frame(AVCodecContext *aCodecCtx, uint8_t *audio_buf, int buf_size) {
    static AVPacket pkt;
    static uint8_t *audio_pkt_data = NULL;
    static int audio_pkt_size = 0;
    
    while (1) {
        while (audio_pkt_size > 0) {
            int got_frame = 0;
            int len1 = avcodec_decode_audio4(aCodecCtx, frame, &got_frame, &pkt);
            if (len1 < 0) {
                audio_pkt_size = 0;
                break;
            }

            audio_pkt_data += len1;
            audio_pkt_size -= len1;
           
            if (got_frame) {
                int data_size = av_samples_get_buffer_size(NULL, aCodecCtx->channels, frame->nb_samples, aCodecCtx->sample_fmt, 1);

                memcpy(audio_buf, frame->data[0], data_size);
                return data_size;
            }
        }

        if (pkt.data)
            av_free_packet(&pkt);

        if (quit) {
            return -1;
        }

        if (packet_queue_get(&audioq, &pkt, 1) < 0) {
            return -1;
        }

        audio_pkt_data = pkt.data;
        audio_pkt_size = pkt.size;
    }
}

static void audio_callback(void *userdata, Uint8 *stream, int len) {
    AVCodecContext *aCodecCtx = (AVCodecContext *)userdata;
    int len1, audio_size;
    static uint8_t audio_buf[MAX_AUDIO_FRAME_SIZE * 3 / 2];
    static unsigned int audio_buf_size = 0;
    static unsigned int audio_buf_index = 0;

    while (len > 0) {
        if (audio_buf_index >= audio_buf_size) {
            audio_size = audio_decode_frame(aCodecCtx, audio_buf, sizeof(audio_buf));
            if (audio_size < 0) {
                // 播放结束
                memset(stream, 0, len);
                return;
            }
            audio_buf_size = (audio_size / 4) * 4;
            audio_buf_index = 0;
        }

        len1 = audio_buf_size - audio_buf_index;
        if (len1 > len) {
            len1 = len;
        }

        memcpy(stream, (uint8_t *) audio_buf + audio_buf_index, len1);
        len -= len1;
        stream += len1;
        audio_buf_index += len1;
    }
}

int main(int argc, char *argv[]) {
    AVFormatContext *pFormatCtx = NULL;
    int audioStream = -1;
    AVCodecContext *aCodecCtx = NULL;
    AVCodec *aCodec = NULL;

    if (avformat_open_input(&pFormatCtx, argv[1], NULL, NULL) != 0) {
        return -1;
    }

    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
        return -1;
    }

    for (int i = 0; i < pFormatCtx->nb_streams; i++) {
        if (pFormatCtx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
            audioStream = i;
            break;
        }
    }

    if (audioStream == -1) {
        return -1;
    }

    aCodecCtx = avcodec_alloc_context3(NULL);
    avcodec_parameters_to_context(aCodecCtx, pFormatCtx->streams[audioStream]->codecpar);

    aCodec = avcodec_find_decoder(aCodecCtx->codec_id);
    if (aCodec == NULL) {
        return -1;
    }

    if (avcodec_open2(aCodecCtx, aCodec, NULL) < 0) {
        return -1;
    }

    SDL_Init(SDL_INIT_AUDIO | SDL_INIT_TIMER);
    SDL_AudioSpec desired_spec, spec;

    desired_spec.freq = aCodecCtx->sample_rate;
    desired_spec.format = AUDIO_S16SYS;
    desired_spec.channels = aCodecCtx->channels;
    desired_spec.silence = 0;
    desired_spec.samples = SDL_AUDIO_BUFFER_SIZE;
    desired_spec.callback = audio_callback;
    desired_spec.userdata = aCodecCtx;

    if (SDL_OpenAudio(&desired_spec, &spec) < 0) {
        return -1;
    }

    packet_queue_init(&audioq);
    SDL_PauseAudio(0);

    // 主循环
    while (!quit) {
        // 处理音频队列
        SDL_Delay(10);
    }

    avcodec_close(aCodecCtx);
    avformat_close_input(&pFormatCtx);

    return 0;
}

以上是一个简单的基于ffmpeg的带音量柱播放器的源码示例。该程序打开音频文件，解码音频数据并传递给SDL音频回调函数进行播放。同时，你可以在主循环中添加其他功能，如绘制音量柱状图的操作。

注意，这只是一个简化的示例源码，仅供参考。实际开发中可能需要根据具体需求进行更多的功能添加和自定义。