ffmpeg api-alac-text.c
generate_raw_frame
这个函数接受一个 frame_data 数组作为参数，用于存储音频数据。i 参数表示当前帧的索引，sample_rate 是采样率，channels 是声道数，frame_size 是帧大小。函数使用一个简单的算法生成音频数据，然后将其存储在 frame_data 数组中。
具体来说，它遍历帧中的每个采样点，根据公式 10000 * ((j / 10 * i) % 2) 生成音频数据的第一个声道，并根据声道数生成其他声道的数据。最后，它将生成的音频数据存储在 frame_data 数组中，并返回 0 表示成功生成音频帧。
假设我们调用 generate_raw_frame 函数来生成一个采样率为 44100Hz，双声道（立体声）的音频帧，帧大小为 1024 个采样点：
uint16_t frame_data[1024 * 2]; // 1024 个采样点，每个采样点包含双声道数据
generate_raw_frame(frame_data, 0, 44100, 2, 1024); // 生成第一帧的音频数据
此时，frame_data 数组中将包含 1024 个采样点的音频数据，每个采样点包含左右两个声道的数据。
首先，我们声明一个 uint16_t 类型的数组 frame_data，用来存储生成的音频帧数据。这个数组的大小为 1024 * 2，因为我们有 1024 个采样点，每个采样点包含左右两个声道的数据。
然后，我们调用 generate_raw_frame 函数，并传入以下参数：
frame_data：指向要填充的音频帧数据的指针，即我们声明的 frame_data 数组的首地址。
0：当前帧的索引。在这个例子中，我们传入 0，表示生成的是第一帧的音频数据。
44100：采样率为 44100Hz。
2：声道数为 2，表示双声道（立体声）。
1024：帧大小为 1024 个采样点。
generate_raw_frame 函数开始执行。它使用一个嵌套的循环来填充音频帧数据：
外层循环 for (j = 0; j < frame_size; j++) 遍历每个采样点。
内层循环 for (k = 1; k < channels; k++) 遍历每个声道（从第二个声道开始）。
在每个采样点内部，首先计算了第一个声道的采样值 frame_data[channels * j] = 10000 * ((j / 10 * i) % 2)。这里的计算方式是一个简单的模式，用来生成音频波形数据。采样值的范围是 0 到 10000。
然后，对于其他声道，它们的采样值是第一个声道采样值的倍数，frame_data[channels * j + k] = frame_data[channels * j] * (k + 1)。
generate_raw_frame 函数执行完毕后，frame_data 数组中将包含 1024 个采样点的音频数据，每个采样点包含左右两个声道的数据，可以用来表示一帧音频数据。
/**
* 生成原始音频帧
* @param frame_data 存储音频数据的数组
* @param i 当前帧的索引
* @param sample_rate 采样率
* @param channels 声道数
* @param frame_size 帧大小
* @return 成功返回 0，失败返回其他值
*/
static int generate_raw_frame(uint16_t *frame_data, int i, int sample_rate,
int channels, int frame_size)
{
int j, k;
for (j = 0; j < frame_size; j++) {
// 根据公式生成音频数据
frame_data[channels * j] = 10000 * ((j / 10 * i) % 2);
for (k = 1; k < channels; k++)
frame_data[channels * j + k] = frame_data[channels * j] * (k + 1);
}
return 0; // 成功生成音频帧
}
init_encoder
这个函数接受一个编码器 enc、一个指向编码器上下文指针的指针 enc_ctx、声道布局 ch_layout 和采样率 sample_rate 作为参数。
它首先使用 av_get_channel_layout_string 函数获取声道布局的字符串表示形式，并打印声道布局和采样率的信息。
然后，它使用 avcodec_alloc_context3 函数为编码器分配上下文内存，并设置上下文的参数。最后，它使用 avcodec_open2 函数打开编码器。
函数返回 0 表示成功初始化编码器，并将分配的编码器上下文存储在传入的指针 enc_ctx 中。如果内存分配失败或打开编码器失败，
函数将返回相应的错误代码。
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
参数说明：
buf：指向存储结果的缓冲区的指针。
buf_size：缓冲区的大小。
nb_channels：声道数量。
channel_layout：声道布局。
这个函数会根据传入的 channel_layout 参数生成对应的声道布局字符串，并将结果存储在 buf 缓冲区中。例如，如果我们要获取立体声（左右声道）的声道布局字符串，可以这样使用：
char layout_str[256]; // 声道布局字符串存储缓冲区
uint64_t layout = AV_CH_LAYOUT_STEREO; // 立体声声道布局
av_get_channel_layout_string(layout_str, sizeof(layout_str), 0, layout);
printf("Channel layout: %s\n", layout_str);
Channel layout: stereo
这里 AV_CH_LAYOUT_STEREO 是一个宏，表示立体声声道布局，对应的字符串为 "stereo"。
/*
*
* 初始化编码器
* @param enc 编码器
* @param enc_ctx 指向编码器上下文指针的指针，将分配的编码器上下文存储在这里
* @param ch_layout 声道布局
* @param sample_rate 采样率
* @return 成功返回 0，失败返回错误代码
*/
static int init_encoder(AVCodec *enc, AVCodecContext **enc_ctx,
int64_t ch_layout, int sample_rate)
{
AVCodecContext *ctx;
int result;
char name_buff[NAME_BUFF_SIZE]; // 用于存储声道布局字符串的缓冲区
// 获取声道布局的字符串表示形式
av_get_channel_layout_string(name_buff, NAME_BUFF_SIZE, 0, ch_layout);
// 打印声道布局和采样率信息
av_log(NULL, AV_LOG_INFO, "channel layout: %s, sample rate: %i\n", name_buff, sample_rate);
// 为编码器分配上下文内存
ctx = avcodec_alloc_context3(enc);
if (!ctx) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate encoder context\n");
return AVERROR(ENOMEM); // 内存分配失败
}
// 设置编码器上下文的参数
ctx->sample_fmt = AV_SAMPLE_FMT_S16; // 采样格式为 16 位整数
ctx->sample_rate = sample_rate; // 设置采样率
ctx->channel_layout = ch_layout; // 设置声道布局
// 打开编码器
result = avcodec_open2(ctx, enc, NULL);
if (result < 0) {
av_log(ctx, AV_LOG_ERROR, "Can't open encoder\n");
return result; // 打开编码器失败，返回错误代码
}
// 将分配的编码器上下文存储在传入的指针中
*enc_ctx = ctx;
return 0; // 初始化编码器成功
}
init_decoder
这个函数接受一个解码器 dec、一个指向解码器上下文指针的指针 dec_ctx 和声道布局 ch_layout 作为参数。
它首先使用 avcodec_alloc_context3 函数为解码器分配上下文内存，并设置上下文的参数。然后，它使用 a
vcodec_open2 函数打开解码器。
函数返回 0 表示成功初始化解码器，并将分配的解码器上下文存储在传入的指针 dec_ctx 中。如果内存分配失
败或打开解码器失败，函数将返回相应的错误代码。
/**
* 初始化解码器
* @param dec 解码器
* @param dec_ctx 指向解码器上下文指针的指针，将分配的解码器上下文存储在这里
* @param ch_layout 声道布局
* @return 成功返回 0，失败返回错误代码
*/
static int init_decoder(AVCodec *dec, AVCodecContext **dec_ctx,
int64_t ch_layout)
{
AVCodecContext *ctx;
int result;
// 为解码器分配上下文内存
ctx = avcodec_alloc_context3(dec);
if (!ctx) {
av_log(NULL, AV_LOG_ERROR , "Can't allocate decoder context\n");
return AVERROR(ENOMEM); // 内存分配失败
}
// 设置解码器上下文的参数
ctx->request_sample_fmt = AV_SAMPLE_FMT_S16; // 请求采样格式为 16 位整数
/* XXX: FLAC ignores it for some reason */
ctx->request_channel_layout = ch_layout; // 请求声道布局
ctx->channel_layout = ch_layout; // 设置解码器的声道布局
// 打开解码器
result = avcodec_open2(ctx, dec, NULL);
if (result < 0) {
av_log(ctx, AV_LOG_ERROR, "Can't open decoder\n");
return result; // 打开解码器失败，返回错误代码
}
// 将分配的解码器上下文存储在传入的指针中
*dec_ctx = ctx;
return 0; // 初始化解码器成功
}
run_test
用于执行编码器和解码器的测试的主要函数。它包括对音频数据进行编码和解码，然后比较编码前后的数据是否一致。
这个函数的主要功能是生成原始音频数据，然后将其编码为 FLAC 格式，再解码回原始数据，并比较解码后的数据
与原始数据是否一致。函数首先分配输入和输出音频帧的内存，然后循环进行编码和解码的测试。在每一次循环中，
它使用 generate_raw_frame 函数生成原始音频数据，并将其拷贝到输入原始音频数据缓冲区。接着，它调用 avcodec_encode_audio2 函数对音频帧进行编码，并使用 avcodec_decode_audio4 函数对编码后的数据进行解码。
解码后，它比较解码前后的音频数据是否一致。最后，它释放分配的内存，并返回测试结果。
/**
* 执行编码器和解码器的测试
* @param enc 编码器
* @param dec 解码器
* @param enc_ctx 编码器上下文
* @param dec_ctx 解码器上下文
* @return 成功返回 0，失败返回错误代码
*/
static int run_test(AVCodec *enc, AVCodec *dec, AVCodecContext *enc_ctx,
AVCodecContext *dec_ctx)
{
AVPacket enc_pkt; // 编码后的数据包
AVFrame *in_frame, *out_frame; // 输入和输出的音频帧
uint8_t *raw_in = NULL, *raw_out = NULL; // 输入和输出的原始音频数据
int in_offset = 0, out_offset = 0; // 输入和输出数据的偏移量
int result = 0; // 返回结果
int got_output = 0; // 是否得到输出的标志
int i = 0; // 循环计数器
int in_frame_bytes, out_frame_bytes; // 输入和输出音频帧的字节数
// 分配输入音频帧内存
in_frame = av_frame_alloc();
if (!in_frame) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate input frame\n");
return AVERROR(ENOMEM); // 分配内存失败
}
// 设置输入音频帧的参数
in_frame->nb_samples = enc_ctx->frame_size;
in_frame->format = enc_ctx->sample_fmt;
in_frame->channel_layout = enc_ctx->channel_layout;
if (av_frame_get_buffer(in_frame, 32) != 0) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate a buffer for input frame\n");
return AVERROR(ENOMEM); // 分配内存失败
}
// 分配输出音频帧内存
out_frame = av_frame_alloc();
if (!out_frame) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate output frame\n");
return AVERROR(ENOMEM); // 分配内存失败
}
// 分配输入和输出的原始音频数据内存
raw_in = av_malloc(in_frame->linesize[0] * NUMBER_OF_FRAMES);
if (!raw_in) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate memory for raw_in\n");
return AVERROR(ENOMEM); // 分配内存失败
}
raw_out = av_malloc(in_frame->linesize[0] * NUMBER_OF_FRAMES);
if (!raw_out) {
av_log(NULL, AV_LOG_ERROR, "Can't allocate memory for raw_out\n");
return AVERROR(ENOMEM); // 分配内存失败
}
// 循环进行编码和解码的测试
for (i = 0; i < NUMBER_OF_FRAMES; i++) {
av_init_packet(&enc_pkt); // 初始化编码后的数据包
enc_pkt.data = NULL;
enc_pkt.size = 0;
// 生成原始音频帧
generate_raw_frame((uint16_t*)(in_frame->data[0]), i, enc_ctx->sample_rate,
enc_ctx->channels, enc_ctx->frame_size);
in_frame_bytes = in_frame->nb_samples * in_frame->channels * sizeof(uint16_t);
if (in_frame_bytes > in_frame->linesize[0]) {
av_log(NULL, AV_LOG_ERROR, "Incorrect value of input frame linesize\n");
return 1; // 输入帧的数据不正确
}
// 将原始音频数据拷贝到输入原始音频数据缓冲区
memcpy(raw_in + in_offset, in_frame->data[0], in_frame_bytes);
in_offset += in_frame_bytes;
// 编码音频帧
result = avcodec_encode_audio2(enc_ctx, &enc_pkt, in_frame, &got_output);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Error encoding audio frame\n");
return result; // 编码失败，返回错误代码
}
// 如果有编码输出，进行解码
if (got_output) {
// 解码音频包
result = avcodec_decode_audio4(dec_ctx, out_frame, &got_output, &enc_pkt);
if (result < 0) {
av_log(NULL, AV_LOG_ERROR, "Error decoding audio packet\n");
return result; // 解码失败，返回错误代码
}
if (got_output) {
// 检查解码后的音频帧参数
if (in_frame->nb_samples != out_frame->nb_samples) {
av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different number of samples\n");
return AVERROR_UNKNOWN; // 解码后的音频帧参数不正确
}
if (in_frame->channel_layout != out_frame->channel_layout) {
av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different channel layout\n");
return AVERROR_UNKNOWN; // 解码后的音频帧参数不正确
}
if (in_frame->format != out_frame->format) {
av_log(NULL, AV_LOG_ERROR, "Error frames before and after decoding has different sample format\n");
return AVERROR_UNKNOWN; // 解码后的音频帧参数不正确
}
// 将解码后的音频数据拷贝到输出原始音频数据缓冲区
out_frame_bytes = out_frame->nb_samples * out_frame->channels * sizeof(uint16_t);
if (out_frame_bytes > out_frame->linesize[0]) {
av_log(NULL, AV_LOG_ERROR, "Incorrect value of output frame linesize\n");
return 1; // 输出帧的数据不正确
}
memcpy(raw_out + out_offset, out_frame->data[0], out_frame_bytes);
out_offset += out_frame_bytes;
}
}
av_packet_unref(&enc_pkt); // 释放编码后的数据包
}
// 比较编码前后的音频数据是否一致
if (memcmp(raw_in, raw_out, out_frame_bytes * NUMBER_OF_FRAMES) != 0) {
av_log(NULL, AV_LOG_ERROR, "Output differs\n");
return 1; // 编码后的数据与解码前的数据不一致
}
av_log(NULL, AV_LOG_INFO, "OK\n"); // 测试通过
// 释放分配的内存
av_freep(&raw_in);
av_freep(&raw_out);
av_frame_free(&in_frame);
av_frame_free(&out_frame);
return 0; // 测试成功
}
main
/**
* 程序入口点，执行编码器和解码器的测试
* @return 成功返回 0，失败返回错误代码
*/
int main(void)
{
AVCodec *enc = NULL, *dec = NULL; // 编码器和解码器
AVCodecContext *enc_ctx = NULL, *dec_ctx = NULL; // 编码器和解码器上下文
uint64_t channel_layouts[] = {AV_CH_LAYOUT_STEREO, AV_CH_LAYOUT_5POINT1_BACK, AV_CH_LAYOUT_SURROUND, AV_CH_LAYOUT_STEREO_DOWNMIX}; // 声道布局数组
int sample_rates[] = {8000, 44100, 48000, 192000}; // 采样率数组
int cl, sr; // 循环计数器
// 查找 FLAC 编码器
enc = avcodec_find_encoder(AV_CODEC_ID_FLAC);
if (!enc) {
av_log(NULL, AV_LOG_ERROR, "Can't find encoder\n");
return 1; // 找不到编码器，返回错误代码
}
// 查找 FLAC 解码器
dec = avcodec_find_decoder(AV_CODEC_ID_FLAC);
if (!dec) {
av_log(NULL, AV_LOG_ERROR, "Can't find decoder\n");
return 1; // 找不到解码器，返回错误代码
}
// 循环遍历声道布局和采样率数组，进行编码器和解码器的测试
for (cl = 0; cl < FF_ARRAY_ELEMS(channel_layouts); cl++) {
for (sr = 0; sr < FF_ARRAY_ELEMS(sample_rates); sr++) {
// 初始化编码器上下文
if (init_encoder(enc, &enc_ctx, channel_layouts[cl], sample_rates[sr]) != 0)
return 1; // 初始化编码器上下文失败，返回错误代码
// 初始化解码器上下文
if (init_decoder(dec, &dec_ctx, channel_layouts[cl]) != 0)
return 1; // 初始化解码器上下文失败，返回错误代码
// 执行编码器和解码器的测试
if (run_test(enc, dec, enc_ctx, dec_ctx) != 0)
return 1; // 执行测试失败，返回错误代码
// 关闭编码器和解码器
close_encoder(&enc_ctx);
close_decoder(&dec_ctx);
}
}
return 0; // 所有测试执行成功，返回 0
}