/* messy code alarm
video_frame_init 函数用于初始化视频帧。它接受一个指向 struct video_frame 结构体的指针 frame，
视频格式 format，以及宽度 width 和高度 height。该函数根据视频格式的不同，计算出每个视频帧的大小，
并在堆上为帧数据分配内存空间。然后，根据视频格式的不同，设置帧数据的偏移量和行大小，并将这些信息填充到 frame 结构体中。
*/
void video_frame_init(struct video_frame *frame, enum video_format format,
uint32_t width, uint32_t height)
{
size_t size;
size_t offsets[MAX_AV_PLANES];
int alignment = base_get_alignment();
if (!frame)
return;
memset(frame, 0, sizeof(struct video_frame));
memset(offsets, 0, sizeof(offsets));
switch (format) {
case VIDEO_FORMAT_NONE:
return;
case VIDEO_FORMAT_I420: {
/* 计算 Y 分量的大小，基于帧的宽度和高度 */
size = width * height;
/* 根据指定的对齐方式对大小进行对齐 */
ALIGN_SIZE(size, alignment);
/* 设置 Y 分量的偏移量 */
offsets[0] = size;
/* 计算 U 和 V 分量的宽度和高度 */
const uint32_t half_width = (width + 1) / 2;
const uint32_t half_height = (height + 1) / 2;
/* 计算 U 和 V 分量的区域大小 */
const uint32_t quarter_area = half_width * half_height;
/* 将 U 分量的大小添加到总大小中 */
size += quarter_area;
/* 根据指定的对齐方式对大小进行对齐 */
ALIGN_SIZE(size, alignment);
/* 设置 U 分量的偏移量 */
offsets[1] = size;
/* 将 V 分量的大小添加到总大小中 */
size += quarter_area;
/* 根据指定的对齐方式对大小进行对齐 */
ALIGN_SIZE(size, alignment);
/* 为 YUV 数据分配内存 */
frame->data[0] = bmalloc(size);
/* 设置 U 和 V 分量的指针 */
frame->data[1] = (uint8_t *)frame->data[0] + offsets[0];
frame->data[2] = (uint8_t *)frame->data[0] + offsets[1];
/* 设置 YUV 数据的行大小 */
frame->linesize[0] = width;
frame->linesize[1] = half_width;
frame->linesize[2] = half_width;
break;
}
}
/*
这段代码是用于初始化视频输出缓存的函数。函数名为 init_cache，它接受一个指向 struct video_output 结构体的指针作为参数。
函数首先检查 video->info.cache_size 是否大于最大缓存大小 MAX_CACHE_SIZE，如果是，则将 video->info.cache_size 设置为
MAX_CACHE_SIZE。接下来，通过一个 for 循环，对 video->info.cache_size 次迭代，分别初始化缓存中的每个视频帧。在每次循环中，
函数会创建一个 video_frame 结构体指针 frame，该指针指向 video->cache[i]，并使用 video_frame_init 函数初始化该帧。
初始化时，会将视频格式、宽度和高度信息填入帧中。最后，函数将 video->available_frames 设置为 video->info.cache_size，
表示缓存中有多少帧可用。
*/
static inline void init_cache(struct video_output *video)
{
if (video->info.cache_size > MAX_CACHE_SIZE)
video->info.cache_size = MAX_CACHE_SIZE;
for (size_t i = 0; i < video->info.cache_size; i++) {
struct video_frame *frame;
frame = (struct video_frame *)&video->cache[i];
video_frame_init(frame, video->info.format, video->info.width,
video->info.height);
}
video->available_frames = video->info.cache_size;
}
/*
这段代码是一个视频输出组件的初始化函数 video_output_open。它接受一个指向 video_t 指针的指针（用于返回视频输出对象的地址）和一个 video_output_info 结构体指针作为参数。
首先，函数会检查传入的 info 参数是否有效，如果无效则返回 VIDEO_OUTPUT_INVALIDPARAM，表示初始化失败。
接着，函数会动态分配内存以创建一个 video_output 结构体对象，并将 info 中的信息复制到这个对象中。如果内存分配失败，则函数会返回 VIDEO_OUTPUT_FAIL。
然后，函数会根据 info 中的帧率信息计算每一帧的时间间隔，并将结果存储在 frame_time 中。
接下来，函数会初始化两个递归互斥锁 data_mutex 和 input_mutex 以及一个信号量 update_semaphore。如果初始化失败，则函数会释放之前分配的资源，并返回 VIDEO_OUTPUT_FAIL。
紧接着，函数会创建一个线程 thread，并将其入口函数设置为 video_thread。如果线程创建失败，则函数会释放之前分配的资源，并返回 VIDEO_OUTPUT_FAIL。
最后，函数会调用 init_cache 函数对 out 进行初始化，并将 out 赋值给 *video，以便将视频输出对象的地址返回给调用者。最后，函数返回 VIDEO_OUTPUT_SUCCESS 表示初始化成功。
总的来说，video_output_open 函数的作用是根据传入的 video_output_info 初始化一个视频输出对象，并将其地址存储在 *video 中，同时返回初始化的结果。
*/
int video_output_open(video_t **video, struct video_output_info *info)
{
struct video_output *out;
if (!valid_video_params(info))
return VIDEO_OUTPUT_INVALIDPARAM;
out = bzalloc(sizeof(struct video_output));
if (!out)
goto fail0;
memcpy(&out->info, info, sizeof(struct video_output_info));
out->frame_time =
util_mul_div64(1000000000ULL, info->fps_den, info->fps_num);
if (pthread_mutex_init_recursive(&out->data_mutex) != 0)
goto fail0;
if (pthread_mutex_init_recursive(&out->input_mutex) != 0)
goto fail1;
if (os_sem_init(&out->update_semaphore, 0) != 0)
goto fail2;
if (pthread_create(&out->thread, NULL, video_thread, out) != 0)
goto fail3;
init_cache(out);
*video = out;
return VIDEO_OUTPUT_SUCCESS;
fail3:
os_sem_destroy(out->update_semaphore);
fail2:
pthread_mutex_destroy(&out->input_mutex);
fail1:
pthread_mutex_destroy(&out->data_mutex);
fail0:
bfree(out);
return VIDEO_OUTPUT_FAIL;
}
/*
* 视频线程函数，用于处理视频输出
*
* param: 指向视频输出结构体的指针
*/
static void *video_thread(void *param)
{
/* 将参数转换为视频输出结构体 */
struct video_output *video = param;
/* 设置线程名称为 "video-io: video thread" */
os_set_thread_name("video-io: video thread");
/* 获取视频线程的名称 */
const char *video_thread_name =
profile_store_name(obs_get_profiler_name_store(),
"video_thread(%s)", video->info.name);
/* 在视频信号量上等待 */
while (os_sem_wait(video->update_semaphore) == 0) {
/* 如果视频已停止，则退出循环 */
if (video->stop)
break;
/* 启动性能分析 */
profile_start(video_thread_name);
/* 在当前帧输出之前不断增加总帧数，直到当前帧输出成功 */
while (!video->stop && !video_output_cur_frame(video)) {
os_atomic_inc_long(&video->total_frames);
}
/* 当前帧输出成功后增加总帧数 */
os_atomic_inc_long(&video->total_frames);
/* 结束性能分析 */
profile_end(video_thread_name);
/* 重新启用线程性能分析 */
profile_reenable_thread();
}
return NULL;
}
// 动态数组结构体，用于存储动态数组的信息
struct darray {
void *array; // 指向数组数据的指针
size_t num; // 数组中当前元素的数量
size_t capacity; // 数组当前的容量
};
/*
* 用于存储有关缓存视频帧的信息的结构。
*/
struct cached_frame_info {
struct video_data frame; // 视频帧数据
int skipped; // 被跳过的帧数
int count; // 总帧数计数
};
/*
* 视频输入结构体，用于描述视频输入设备的信息。
*/
struct video_input {
struct video_scale_info conversion; // 视频转换信息
video_scaler_t *scaler; // 视频缩放器
struct video_frame frame[MAX_CONVERT_BUFFERS]; // 视频帧缓冲区
int cur_frame; // 当前帧索引
// 允许以主合成 FPS 的分数输出，例如，60 FPS 的 frame_rate_divisor = 1 变为 30 FPS
//
// 使用单独的计数器而不是使用余数计算，
// 以便允许同时启动的“inputs”在相同的帧上启动，
// 而使用余数计算则会使帧对齐取决于编码器启动时的总帧数
uint32_t frame_rate_divisor; // 帧率除数
uint32_t frame_rate_divisor_counter; // 帧率除数计数器
void (*callback)(void *param, struct video_data *frame); // 回调函数指针
void *param; // 参数
};
/*
* 检查当前视频输出是否包含完
* 整的帧并处理当前帧
*
* video: 视频输出结构体指针
*
* 返回值：如果当前帧完整则返回true，否则返回false
*/
static inline bool video_output_cur_frame(struct video_output *video)
{
struct cached_frame_info *frame_info;
bool complete;
bool skipped;
/* 获取视频数据前先锁定数据互斥锁 */
pthread_mutex_lock(&video->data_mutex);
/* 获取当前视频输出中第一个添加的帧信息 */
frame_info = &video->cache[video->first_added];
/* 解锁数据互斥锁 */
pthread_mutex_unlock(&video->data_mutex);
/* 锁定输入互斥锁以处理视频输入 */
pthread_mutex_lock(&video->input_mutex);
/* 遍历视频输入并处理帧数据 */
for (size_t i = 0; i < video->inputs.num; i++) {
struct video_input *input = video->inputs.array + i;
struct video_data frame = frame_info->frame;
// 使用显式计数器而不是求余来允许在相同时间启动的多个编码器
// 在同一帧上启动
uint32_t skip = input->frame_rate_divisor_counter++;
if (input->frame_rate_divisor_counter == input->frame_rate_divisor)
input->frame_rate_divisor_counter = 0;
if (skip)
continue;
if (scale_video_output(input, &frame))
input->callback(input->param, &frame);
}
/* 解锁输入互斥锁 */
pthread_mutex_unlock(&video->input_mutex);
/* 处理当前帧信息 */
pthread_mutex_lock(&video->data_mutex);
/* 更新当前帧的时间戳并检查当前帧是否已经完整 */
frame_info->frame.timestamp += video->frame_time;
complete = --frame_info->count == 0;
skipped = frame_info->skipped > 0;
/* 如果当前帧完整则更新视频输出的相关信息 */
if (complete) {
if (++video->first_added == video->info.cache_size)
video->first_added = 0;
if (++video->available_frames == video->info.cache_size)
video->last_added = video->first_added;
}
/* 如果当前帧被跳过，则更新相关信息并增加跳过帧的计数 */
else if (skipped) {
--frame_info->skipped;
os_atomic_inc_long(&video->skipped_frames);
}
/* 解锁数据互斥锁 */
pthread_mutex_unlock(&video->data_mutex);
/* 返回当前帧是否完整的标志 */
return complete;
}