其实这篇的内容和（一）用ffmpeg解码视频基本是一样的，重点还是给ffmpeg指定callback函数，而这个函数是从RTSP服务端那里获取音频数据的。
这里，解码音频的示例代码量之所以比解码视频的略微复杂，主要是因为ffmpeg解码音频时要比解码视频要复杂一点，具体可以参见ffmpeg解码音频示例以及官网示例代码。
具体内容将不再赘述，源码如下：
extern "C"
{
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavformat/avio.h>
#include <libswscale/swscale.h>
#include <libswresample/swresample.h>
} #include <SDL.h>
#include <SDL_thread.h> #ifdef __MINGW32__
#undef main /* Prevents SDL from overriding main() */
#endif #include <stdio.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h> // compatibility with newer API
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55,28,1)
#define av_frame_alloc avcodec_alloc_frame
#define av_frame_free avcodec_free_frame
#endif #define SDL_AUDIO_BUFFER_SIZE 1024
#define MAX_AUDIO_FRAME_SIZE 192000 #include <signal.h>
#include "rtspClient.h"
#include <iostream>
#include <string> using std::cout;
using std::endl; int rtspClientRequest(RtspClient * Client, string url);
int fill_iobuffer(void * opaque, uint8_t * buf, int bufsize); typedef struct AudioParams {
int freq;
int channels;
int64_t channel_layout;
enum AVSampleFormat fmt;
int frame_size;
int bytes_per_sec;
} AudioParams;
int sample_rate, nb_channels;
int64_t channel_layout;
AudioParams audio_hw_params_tgt;
AudioParams audio_hw_params_src; int resample(AVFrame * af, uint8_t * audio_buf, int * audio_buf_size); struct SwrContext * swr_ctx = NULL; int resample(AVFrame * af, uint8_t * audio_buf, int * audio_buf_size)
{
int data_size = ;
int resampled_data_size = ;
int64_t dec_channel_layout;
data_size = av_samples_get_buffer_size(NULL,
av_frame_get_channels(af),
af->nb_samples,
(AVSampleFormat)af->format,
); dec_channel_layout =
(af->channel_layout && av_frame_get_channels(af) == av_get_channel_layout_nb_channels(af->channel_layout)) ?
af->channel_layout : av_get_default_channel_layout(av_frame_get_channels(af));
if( af->format != audio_hw_params_src.fmt ||
af->sample_rate != audio_hw_params_src.freq ||
dec_channel_layout != audio_hw_params_src.channel_layout ||
!swr_ctx) {
swr_free(&swr_ctx);
swr_ctx = swr_alloc_set_opts(NULL,
audio_hw_params_tgt.channel_layout, (AVSampleFormat)audio_hw_params_tgt.fmt, audio_hw_params_tgt.freq,
dec_channel_layout, (AVSampleFormat)af->format, af->sample_rate,
, NULL);
if (!swr_ctx || swr_init(swr_ctx) < ) {
av_log(NULL, AV_LOG_ERROR,
"Cannot create sample rate converter for conversion of %d Hz %s %d channels to %d Hz %s %d channels!\n",
af->sample_rate, av_get_sample_fmt_name((AVSampleFormat)af->format), av_frame_get_channels(af),
audio_hw_params_tgt.freq, av_get_sample_fmt_name(audio_hw_params_tgt.fmt), audio_hw_params_tgt.channels);
swr_free(&swr_ctx);
return -;
}
printf("swr_init\n");
audio_hw_params_src.channels = av_frame_get_channels(af);
audio_hw_params_src.fmt = (AVSampleFormat)af->format;
audio_hw_params_src.freq = af->sample_rate;
} if (swr_ctx) {
const uint8_t **in = (const uint8_t **)af->extended_data;
uint8_t **out = &audio_buf;
int out_count = (int64_t)af->nb_samples * audio_hw_params_tgt.freq / af->sample_rate + ;
int out_size = av_samples_get_buffer_size(NULL, audio_hw_params_tgt.channels, out_count, audio_hw_params_tgt.fmt, );
int len2;
if (out_size < ) {
av_log(NULL, AV_LOG_ERROR, "av_samples_get_buffer_size() failed\n");
return -;
}
av_fast_malloc(&audio_buf, (unsigned int*)audio_buf_size, out_size);
if (!audio_buf)
return AVERROR(ENOMEM);
len2 = swr_convert(swr_ctx, out, out_count, in, af->nb_samples);
if (len2 < ) {
av_log(NULL, AV_LOG_ERROR, "swr_convert() failed\n");
return -;
}
if (len2 == out_count) {
av_log(NULL, AV_LOG_WARNING, "audio buffer is probably too small\n");
if (swr_init(swr_ctx) < )
swr_free(&swr_ctx);
}
resampled_data_size = len2 * audio_hw_params_tgt.channels * av_get_bytes_per_sample(audio_hw_params_tgt.fmt);
} else {
audio_buf = af->data[];
resampled_data_size = data_size;
} return resampled_data_size;
} static void sigterm_handler(int sig)
{
exit();
} typedef struct PacketQueue {
AVPacketList *first_pkt, *last_pkt;
int nb_packets;
int size;
SDL_mutex *mutex;
SDL_cond *cond;
} PacketQueue; PacketQueue audioq; int quit = ; void packet_queue_init(PacketQueue *q) {
memset(q, , sizeof(PacketQueue));
q->mutex = SDL_CreateMutex();
q->cond = SDL_CreateCond();
} int packet_queue_put(PacketQueue *q, AVPacket *pkt) { AVPacketList *pkt1;
if(av_dup_packet(pkt) < ) {
return -;
}
pkt1 = (AVPacketList *)av_malloc(sizeof(AVPacketList));
if (!pkt1)
return -;
pkt1->pkt = *pkt;
pkt1->next = NULL; SDL_LockMutex(q->mutex); if (!q->last_pkt)
q->first_pkt = pkt1;
else
q->last_pkt->next = pkt1;
q->last_pkt = pkt1;
q->nb_packets++;
q->size += pkt1->pkt.size;
SDL_CondSignal(q->cond); SDL_UnlockMutex(q->mutex);
return ;
} int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
{
AVPacket pkt1, *pkt = &pkt1;
av_init_packet(pkt);
pkt->data = NULL;
pkt->size = ;
pkt->stream_index = stream_index;
return packet_queue_put(q, pkt);
} static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block)
{
AVPacketList *pkt1;
int ret; SDL_LockMutex(q->mutex); for(;;) { if(quit) {
ret = -;
break;
} pkt1 = q->first_pkt;
if (pkt1) {
q->first_pkt = pkt1->next;
if (!q->first_pkt)
q->last_pkt = NULL;
q->nb_packets--;
q->size -= pkt1->pkt.size;
*pkt = pkt1->pkt;
av_free(pkt1);
ret = ;
break;
} else if (!block) {
ret = ;
break;
} else {
SDL_CondWait(q->cond, q->mutex);
}
}
SDL_UnlockMutex(q->mutex);
return ret;
} AVFrame frame;
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 = ; int len1, data_size = ; for(;;) {
while(audio_pkt_size > ) {
int got_frame = ;
len1 = avcodec_decode_audio4(aCodecCtx, &frame, &got_frame, &pkt);
if(len1 < ) {
/* if error, skip frame */
audio_pkt_size = ;
break;
}
audio_pkt_data += len1;
audio_pkt_size -= len1;
data_size = ;
if(got_frame) {
data_size = resample(&frame, audio_buf, &buf_size);
// data_size = av_samples_get_buffer_size(NULL,
// aCodecCtx->channels,
// frame.nb_samples,
// aCodecCtx->sample_fmt,
// 1);
assert(data_size <= buf_size);
// memcpy(audio_buf, frame.data[0], data_size);
}
if(data_size <= ) {
/* No data yet, get more frames */
continue;
}
// memcpy(audio_buf, frame.data[0], data_size); /* We have data, return it and come back for more later */
return data_size;
}
if(pkt.data)
av_free_packet(&pkt); if(quit) {
return -;
} if(packet_queue_get(&audioq, &pkt, ) < ) {
return -;
}
audio_pkt_data = pkt.data;
audio_pkt_size = pkt.size;
}
} 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 * ) / ];
static unsigned int audio_buf_size = ;
static unsigned int audio_buf_index = ; while(len > ) {
if(audio_buf_index >= audio_buf_size) {
/* We have already sent all our data; get more */
audio_size = audio_decode_frame(aCodecCtx, audio_buf, sizeof(audio_buf));
if(audio_size < ) {
/* If error, output silence */
audio_buf_size = ; // arbitrary?
memset(audio_buf, , audio_buf_size);
} else {
audio_buf_size = audio_size;
}
audio_buf_index = ;
}
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 i, audioStream;
AVPacket packet; AVCodecContext *aCodecCtxOrig = NULL;
AVCodecContext *aCodecCtx = NULL;
AVCodec *aCodec = NULL; SDL_Event event;
SDL_AudioSpec wanted_spec, spec; AVInputFormat *piFmt = NULL;
RtspClient Client; signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */ if(argc != ) {
cout << "Usage: " << argv[] << " <URL>" << endl;
cout << "For example: " << endl;
cout << argv[] << " rtsp://127.0.0.1/ansersion" << endl;
return ;
}
rtspClientRequest(&Client, argv[]);
// Register all formats and codecs
av_register_all(); if(SDL_Init(SDL_INIT_AUDIO)) {
fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
exit();
} // // Open video file
// if(avformat_open_input(&pFormatCtx, argv[1], NULL, NULL)!=0)
// return -1; // Couldn't open file pFormatCtx = NULL;
pFormatCtx = avformat_alloc_context();
unsigned char * iobuffer = (unsigned char *)av_malloc();
AVIOContext * avio = avio_alloc_context(iobuffer, , , &Client, fill_iobuffer, NULL, NULL);
pFormatCtx->pb = avio; if(!avio) {
printf("avio_alloc_context error!!!\n");
return -;
} if(av_probe_input_buffer(avio, &piFmt, "", NULL, , ) < ) {
printf("av_probe_input_buffer error!\n");
return -;
} else {
printf("probe success\n");
printf("format: %s[%s]\n", piFmt->name, piFmt->long_name);
} int err = avformat_open_input(&pFormatCtx, "nothing", NULL, NULL);
if(err) {
printf("avformat_open_input error: %d\n", err);
return -;
}
// Retrieve stream information
if(avformat_find_stream_info(pFormatCtx, NULL)<)
return -; // Couldn't find stream information // Dump information about file onto standard error
// av_dump_format(pFormatCtx, 0, argv[1], 0);
av_dump_format(pFormatCtx, , "", ); // Find the first video stream
audioStream=-;
for(i=; i<pFormatCtx->nb_streams; i++) {
if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO &&
audioStream < ) {
audioStream=i;
}
}
// if(videoStream==-1)
// return -1; // Didn't find a video stream
if(audioStream==-)
return -; aCodecCtxOrig=pFormatCtx->streams[audioStream]->codec;
aCodec = avcodec_find_decoder(aCodecCtxOrig->codec_id);
if(!aCodec) {
fprintf(stderr, "Unsupported codec!\n");
return -;
} // Copy context
aCodecCtx = avcodec_alloc_context3(aCodec);
if(avcodec_copy_context(aCodecCtx, aCodecCtxOrig) != ) {
fprintf(stderr, "Couldn't copy codec context");
return -; // Error copying codec context
} avcodec_open2(aCodecCtx, aCodec, NULL); sample_rate = aCodecCtx->sample_rate;
nb_channels = aCodecCtx->channels;
channel_layout = aCodecCtx->channel_layout; // printf("channel_layout=%" PRId64 "\n", channel_layout);
printf("channel_layout=%lld\n", channel_layout);
printf("nb_channels=%d\n", nb_channels);
printf("freq=%d\n", sample_rate); if (!channel_layout || nb_channels != av_get_channel_layout_nb_channels(channel_layout)) {
channel_layout = av_get_default_channel_layout(nb_channels);
channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;
printf("correction\n");
} // Set audio settings from codec info
wanted_spec.freq = sample_rate;
wanted_spec.format = AUDIO_S16SYS;
wanted_spec.channels = nb_channels;
wanted_spec.silence = ;
wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;
wanted_spec.callback = audio_callback;
wanted_spec.userdata = aCodecCtx; if(SDL_OpenAudio(&wanted_spec, &spec) < ) {
fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());
return -;
}
printf("freq: %d\tchannels: %d\n", spec.freq, spec.channels); audio_hw_params_tgt.fmt = AV_SAMPLE_FMT_S16;
audio_hw_params_tgt.freq = spec.freq;
audio_hw_params_tgt.channel_layout = channel_layout;
audio_hw_params_tgt.channels = spec.channels;
audio_hw_params_tgt.frame_size = av_samples_get_buffer_size(NULL, audio_hw_params_tgt.channels, , audio_hw_params_tgt.fmt, );
audio_hw_params_tgt.bytes_per_sec = av_samples_get_buffer_size(NULL, audio_hw_params_tgt.channels, audio_hw_params_tgt.freq, audio_hw_params_tgt.fmt, );
if (audio_hw_params_tgt.bytes_per_sec <= || audio_hw_params_tgt.frame_size <= ) {
printf("size error\n");
return -;
}
audio_hw_params_src = audio_hw_params_tgt; // audio_st = pFormatCtx->streams[index]
packet_queue_init(&audioq);
SDL_PauseAudio(); // Read frames and save first five frames to disk
i=;
int ret = ;
// while(av_read_frame(pFormatCtx, &packet)>=0) {
while(ret >= ) {
ret = av_read_frame(pFormatCtx, &packet); if(ret < ) {
/* av_read_frame may get error when RTP data are blocked due to the network busy */
if(ret == AVERROR_EOF || avio_feof(pFormatCtx->pb)) {
packet_queue_put_nullpacket(&audioq, audioStream);
printf("continue ret=%d\n", ret);
ret = ;
continue;
}
printf("ret=%d\n", ret);
break;
}
printf("av_read_frame\n");
if(packet.stream_index==audioStream) {
packet_queue_put(&audioq, &packet);
} else {
av_free_packet(&packet);
}
// Free the packet that was allocated by av_read_frame
SDL_PollEvent(&event);
switch(event.type) {
case SDL_QUIT:
printf("SDL_QUIT\n");
quit = ;
SDL_Quit();
exit();
break;
default:
printf("SDL_Default\n");
break;
} } while() SDL_Delay(); // Close the codecs
avcodec_close(aCodecCtxOrig);
avcodec_close(aCodecCtx); // Close the video file
avformat_close_input(&pFormatCtx); return ;
} int rtspClientRequest(RtspClient * Client, string url)
{
if(!Client) return -; // cout << "Start play " << url << endl;
string RtspUri(url);
// string RtspUri("rtsp://192.168.81.145/ansersion"); /* Set up rtsp server resource URI */
Client->SetURI(RtspUri); /* Send DESCRIBE command to server */
Client->DoDESCRIBE(); /* Parse SDP message after sending DESCRIBE command */
Client->ParseSDP(); /* Send SETUP command to set up all 'audio' and 'video'
* sessions which SDP refers. */
Client->DoSETUP(); /* Send PLAY command to play only 'video' sessions.*/
Client->DoPLAY("audio"); return ;
} int fill_iobuffer(void * opaque, uint8_t * buf, int bufsize) {
size_t size = ;
if(!opaque) return -;
RtspClient * Client = (RtspClient *)opaque;
if(!Client->GetMediaData("audio", buf, &size, bufsize)) size = ;
printf("fill_iobuffer size: %u\n", size);
return size;
}
注：
1， 兼容myRtspClient-1.2.1及以上版本，且仅支持接收mp2,mp3音频；
2， 音频解码原理可参见：http://www.cnblogs.com/ansersion/p/5265033.html；
3， 示例源码编译需要SDL和ffmpeg，具体可参见解码视频的附录二；
4， 博主编译环境为 x86_64位ubuntu 16.04，以供参考。
编译、配置和运行同上一篇：用ffmpeg解码视频
