你希望将 `int parse_and_init_storage_data(const char* filename)` 函数用于**另一个线程中执行**，这是一个非常
常见的需求（比如：主线程启动解码/处理线程，避免阻塞 UI 或其他任务）。
下面我会：
1
. **修改函数使其适配线程函数签名（如 pthread）**
2
. **封装
参数传递方式**
3
. **确保线程安全和资源管理**
4
. **给出完整可运行示例**
---
## ✅ 目标
让 `parse_and_init_storage_data()` 在独立线程中运行，不阻塞主线程，并能正确初始化每一帧的 `STORAGE_DATA` 结构体。
---
### ✅ 1
. 线程函数的基本要求（以 POSIX pthread 为例）
线程函数必须满足如下原型：
```c
void* thread_func(void *arg);
```
所以我们不能直接把 `parse_and_init_storage_data()` 当作线程函数，但可以包装它。
---
### ✅ 2
. 定义线程
参数结构
因为线程只能接收一个 `void*`
参数，我们需要封装文件名和其他可能需要的数据（比如回调函数、输出队列等）。
```c
typedef struct {
const char *filename;
void (*on_
frame_ready)(STORAGE_DATA*, avdm_block_t*); // 回调函数
int channel; // 可选：通道号
} thread_arg_t;
```
---
### ✅ 3
. 修改为线程安全版本
```c
#include <pthread
.h>
#include <stdio
.h>
#include <stdlib
.h>
#include <string
.h>
#include <time
.h>
#include <unistd
.h>
// 假设这些类型已定义（与之前一致）
typedef unsigned char U8;
typedef unsigned int U32;
typedef unsigned long long U64;
#define TP_EVENT_TYPE_NUM 10
#define ALARM_DETECTION_MAX 10
typedef struct {
int width;
int height;
int
bitrate;
} video_info_t;
typedef struct {
int
sample_
rate;
int channels;
} audio_info_t;
typedef struct __avdm_block {
time_t start_time;
time_t end_time;
U32 unitCnt;
U8 *addr;
U32 len;
U64 pts;
union {
video_info_t video;
audio_info_t audio;
} unique_info;
} avdm_block_t;
typedef struct {
U8 event_status[TP_EVENT_TYPE_NUM];
U8 det_status[ALARM_DETECTION_MAX];
int channel;
int buf_size;
U8 *buf;
int buf_len;
int
frame_cnt;
time_t start_time;
time_t end_time;
int pic_type;
#ifdef VIDEO_AVBR_ENABLE
U8 *i_
frame_buf;
#endif
} STORAGE_DATA;
// 全局函数声明
void init_storage_data(STORAGE_DATA *storage_data, avdm_block_t *block, int is_video);
// 查找起始码函数
int find_start_code(const U8 *data, int offset, int len) {
if (offset + 3 > len) return
-1;
if (offset + 4 <= len &&
data[offset] == 0x00 && data[offset+1] == 0x00 &&
data[offset+2] == 0x00 && data[offset+3] == 0x01) {
return 4;
} else if (data[offset] == 0x00 && data[offset+1] == 0x00 &&
data[offset+2] == 0x01) {
return 3;
}
return 0;
}
// 模拟 init_storage_data 实现
void init_storage_data(STORAGE_DATA *storage_data, avdm_block_t *block, int is_video) {
memset(storage_data, 0, sizeof(STORAGE_DATA));
storage_data
->channel = block
->unique_info
.video
.bitrate ? 0 :
-1; // 示例赋值
storage_data
->buf = block
->addr;
storage_data
->buf_len = block
->len;
storage_data
->
frame_cnt = block
->unitCnt;
storage_data
->start_time = block
->start_time;
storage_data
->end_time = block
->end_time;
storage_data
->pic_type = 0;
memset(storage_data
->event_status, 0, TP_EVENT_TYPE_NUM);
memset(storage_data
->det_status, 0, ALARM_DETECTION_MAX);
}
```
---
### ✅ 4
. 线程安全版 `parse_and_init_storage_data`
```c
void* parse_and_init_storage_data_thread(void *arg) {
thread_arg_t *thread_arg = (thread_arg_t*)arg;
const char *filename = thread_arg
->filename;
void (*on_
frame_ready)(STORAGE_DATA*, avdm_block_t*) = thread_arg
->on_
frame_ready;
int channel = thread_arg
->channel;
printf("Thread started: parsing file '%s' on channel %d\n", filename, channel);
FILE *fp = fopen(filename, "rb");
if (!fp) {
perror("Cannot open file");
free(thread_arg); // 注意：我们在线程内释放 arg
return NULL;
}
fseek(fp, 0, SEEK_END);
long file_len = ftell(fp);
rewind(fp);
U8 *buffer = (U8*)malloc(file_len);
if (!buffer) {
fclose(fp);
free(thread_arg);
return NULL;
}
fread(buffer, 1, file_len, fp);
fclose(fp);
int pos = 0;
int
frame_index = 0;
const int fps = 30;
time_t base_time = time(NULL);
while (pos < file_len) {
int sc_size = find_start_code(buffer, pos, file_len);
if (sc_size <= 0) {
pos++;
continue;
}
int nal_start = pos + sc_size;
int next_pos =
-1;
for (int i = nal_start; i < file_len; i++) {
int sc = find_start_code(buffer, i, file_len);
if (sc > 0) {
next_pos = i;
break;
}
}
int nal_end = (next_pos ==
-1) ? file_len : next_pos;
int nal_size = nal_end
- nal_start;
if (nal_size <= 0) break;
U8 nal_header = buffer[nal_start];
int nal_type = (nal_header >> 1) & 0x3F;
int is_idr = (nal_type == 19 || nal_type == 20 || nal_type == 21);
int
frame_size = sc_size + nal_size;
U8 *
frame_data = (U8*)malloc(
frame_size);
memcpy(
frame_data, buffer + pos,
frame_size);
avdm_block_t block;
memset(&block, 0, sizeof(avdm_block_t));
block
.addr =
frame_data;
block
.len =
frame_size;
block
.unitCnt = 1;
block
.start_time = base_time +
frame_index / fps;
block
.end_time = base_time +
frame_index / fps;
block
.pts =
frame_index * (1000000 / fps);
block
.unique_info
.video
.width = 1920;
block
.unique_info
.video
.height = 1080;
block
.unique_info
.video
.bitrate = 4096000;
STORAGE_DATA storage_data;
init_storage_data(&storage_data, &block, 1);
printf("[
Frame %d] Type: %s, Size: %u bytes, PTS: %llu\n",
frame_index,
is_idr ? "I
-frame" : "P/B
-frame",
storage_data
.buf_len,
storage_data
.start_time);
// 调用用户回调函数处理这一帧（例如发送编码器、RTP打包等）
if (on_
frame_ready) {
on_
frame_ready(&storage_data, &block);
} else {
// 默认行为：模拟处理延迟
usleep(33000); // ~30fps
}
// 注意：free(
frame_data)，但 storage_data
.buf 不要 deep copy 就需小心生命周期
free(
frame_data);
pos = next_pos;
frame_index++;
// 可加 usleep 控制播放速度
usleep(10000); // 小延时避免 CPU 占满
}
free(buffer);
free(thread_arg); // 由线程自己释放传入的
参数内存
printf("Thread finished parsing file
.\n");
return NULL;
}
```
---
### ✅ 5
. 主函数中创建线程
```c
// 用户自定义处理每帧的回调函数
void on_
frame_handler(STORAGE_DATA *data, avdm_block_t *block) {
// 示例：打印信息或发送给编码器/RTP模块
printf("Callback:
Frame processed, size=%d\n", data
->buf_len);
// 这里你可以：
//
- send_to_encoder(data);
//
- rtp_packetize_and_send(data);
//
- write_to_file(data);
}
int main() {
pthread_t tid;
thread_arg_t *arg = (thread_arg_t*)malloc(sizeof(thread_arg_t));
if (!arg) {
perror("malloc failed");
return
-1;
}
arg
->filename = "video
.h265"; // 输入文件
arg
->on_
frame_ready = on_
frame_handler; // 回调函数
arg
->channel = 0; // 通道编号
int ret = pthread_create(&tid, NULL, parse_and_init_storage_data_thread, arg);
if (ret != 0) {
perror("pthread_create failed");
free(arg);
return
-1;
}
printf("Main thread continues
...\n");
// 等待线程结束（可选）
pthread_join(tid, NULL);
printf("Main: thread joined
.\n");
return 0;
}
```
---
## ✅ 关键点说明
| 要点 | 说明 |
|
------|
------|
| ✅
参数传递 | 使用 `malloc` 分配 `thread_arg_t`，在线程内释放 |
| ✅ 内存安全 | 每帧动态分配 `
frame_data`，处理完后立即 `free` |
| ✅ 回调机制 | 通过函数指针将帧交给外部处理，解耦逻辑 |
| ✅ 避免竞争 | 各帧数据独立分配，无共享状态 |
| ⚠️ 生命周期 | 若回调函数异步使用 `storage_data
.buf`，需深拷贝数据 |
---
## ✅ 如何避免 `free(
frame_data)` 导致回调访问失效？
如果你的 `on_
frame_ready()` 是异步使用的（比如放入队列由另一线程处理），就不能在当前线程 `free(
frame_data)`。
✅ 解决方案：深拷贝数据
```c
U8 *safe_copy = malloc(block
.len);
memcpy(safe_copy, block
.addr, block
.len);
block
.addr = safe_copy;
// 然后把 block 和 storage_data 一起传出去，由消费者释放
```
或者使用智能指针/引用计数机制（C++ 更方便）。
---
###
扫一扫
1400
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
