#include "basic_include.h" #include "fatfs/osal_file.h" #include "lib/heap/av_heap.h" #include "lib/heap/av_psram_heap.h" #include "lib/multimedia/msi.h" #include "osal/string.h" #include "stream_define.h" #include "audio_media_ctrl/audio_code_ctrl.h" #include "audio_msi/audio_adc.h" #include "app/video_app/file_thumb.h" #include "app/recorder/file_process.h" #ifdef PIN_FROM_PARAM #include "pin_param.h" #endif #include "stream_define.h" #include "mp4/mp4_encode.h" // data 申请空间函数 #define STREAM_MALLOC av_psram_malloc #define STREAM_FREE av_psram_free #define STREAM_ZALLOC av_psram_zalloc // 结构体申请空间函数 #define STREAM_LIBC_MALLOC os_malloc #define STREAM_LIBC_FREE os_free #define STREAM_LIBC_ZALLOC os_zalloc #define MP4_TIMELAPSE_TIME 40 #define AVERAGE_BASE 6 #define MP4_VIDEO_FPS 25U #define MP4_AUDIO_FPS 8U // 实际为 8000Hz/1024≈7.8 约为128ms一帧 #define MP4_FRAME_COUNT(fps, ms) (((fps) * (ms) + 999U) / 1000U) // 预录时间及缓冲区大小 #define MP4_EVENT_PRERECORD_MS 3000U #define MP4_EVENT_BUFFER_MARGIN_MS 1000U #define MP4_EVENT_BUFFER_MAX_MS (MP4_EVENT_PRERECORD_MS + MP4_EVENT_BUFFER_MARGIN_MS) #define MP4_EVENT_BUFFER_VIDEO_COUNT MP4_FRAME_COUNT(MP4_VIDEO_FPS, MP4_EVENT_BUFFER_MAX_MS) #define MP4_EVENT_BUFFER_AUDIO_COUNT MP4_FRAME_COUNT(MP4_AUDIO_FPS, MP4_EVENT_BUFFER_MAX_MS) #define MP4_EVENT_BUFFER_MAX_COUNT (MP4_EVENT_BUFFER_VIDEO_COUNT + MP4_EVENT_BUFFER_AUDIO_COUNT) // 普通模式录卡缓冲区大小 2.5s #define MP4_MAX_VIDEO_EXTRA_COUNT MP4_FRAME_COUNT(MP4_VIDEO_FPS, 2500) #define MP4_MAX_AUDIO_EXTRA_COUNT MP4_FRAME_COUNT(MP4_VIDEO_FPS, 2500) #define MP4_VIDEO_I_EXTRA_COUNT 12U // 缓冲区不足时只接收 I 帧 #define MP4_MAX_VIDEO_COUNT_NORMAL MP4_MAX_VIDEO_EXTRA_COUNT #define MP4_MAX_AUDIO_COUNT_NORMAL MP4_MAX_AUDIO_EXTRA_COUNT #define MP4_MAX_COUNT_NORMAL (MP4_MAX_VIDEO_COUNT_NORMAL + MP4_MAX_AUDIO_COUNT_NORMAL + MP4_VIDEO_I_EXTRA_COUNT) #define MP4_MAX_VIDEO_COUNT_EVENT (MP4_EVENT_BUFFER_VIDEO_COUNT + MP4_MAX_VIDEO_EXTRA_COUNT) #define MP4_MAX_AUDIO_COUNT_EVENT (MP4_EVENT_BUFFER_AUDIO_COUNT + MP4_MAX_AUDIO_EXTRA_COUNT) #define MP4_MAX_COUNT_EVENT (MP4_MAX_VIDEO_COUNT_EVENT + MP4_MAX_AUDIO_COUNT_EVENT + MP4_VIDEO_I_EXTRA_COUNT) #ifndef MAX_SINGLE_MP4_SIZE #define MAX_SINGLE_MP4_SIZE (100 * 1024 * 1024) #endif enum { MSI_MP4_START = BIT(0), MSI_MP4_STOP = BIT(1), MSI_MP4_THREAD_DEAD = BIT(2), MSI_MP4_EVENT_START = BIT(3), MSI_MP4_EVENT_STOP = BIT(4), }; enum { MP4_ENCODE_ERR_NONE, MP4_ENCODE_ERR_STOP, MP4_ENCODE_ERR_EVENT_STOP, MP4_ENCODE_ERR_NO_SD, }; // 录制模式 enum { MP4_MODE_NORMAL, // 普通录像模式 MP4_MODE_TIME_LAPSE, // 缩时录影模式 MP4_MODE_EVETN, // 事件录像模式 }; struct mp4_event_buffer_s { struct framebuff *frames[MP4_EVENT_BUFFER_MAX_COUNT]; uint16_t head; uint16_t tail; uint16_t count; uint32_t latest_time; }; struct mp4_event_ctx_s { uint32_t trigger_time; struct mp4_event_buffer_s event_buffer; }; struct mp4_encode_msi_s { struct msi *msi; struct os_event evt; struct file_process file_process; struct mp4_event_ctx_s *event; void *fb; uint8_t filter_type; uint8_t srcID; uint8_t mode; // 普通录像 / 缩时录影 / 事件触发 int16_t max_video_count; uint32_t rec_time; uint32_t rec_second; uint32_t audio_encode; uint32_t timeLapse_count; uint32_t file_size; }; extern struct msi *mp4_thumb_msi_init(const char *filename, uint8_t srcID, uint8_t filter); static int mp4_is_event_mode(const struct mp4_encode_msi_s *mp4_encode) { return mp4_encode->mode == MP4_MODE_EVETN && mp4_encode->event != NULL; } static uint16_t mp4_msi_queue_count(uint8_t mode) { if (mode == MP4_MODE_EVETN) { return MP4_MAX_COUNT_EVENT; } return MP4_MAX_COUNT_NORMAL; } static int16_t mp4_max_video_count_limit(const struct mp4_encode_msi_s *mp4_encode) { return mp4_is_event_mode(mp4_encode) ? MP4_MAX_VIDEO_COUNT_EVENT : MP4_MAX_VIDEO_COUNT_NORMAL; } static int mp4_is_realtime_mode(const struct mp4_encode_msi_s *mp4_encode) { return mp4_encode->mode != MP4_MODE_TIME_LAPSE; } static int mp4_has_audio(const struct mp4_encode_msi_s *mp4_encode) { return mp4_is_realtime_mode(mp4_encode) && mp4_encode->audio_encode == AAC_ENC; } static const char *mp4_mode_str(const struct mp4_encode_msi_s *mp4_encode) { if (mp4_encode->mode == MP4_MODE_TIME_LAPSE) { return "TIME_LAPSE"; } if (mp4_encode->mode == MP4_MODE_EVETN) { return "EVENT"; } return "NORMAL"; } static void mp4_event_buffer_drop_head(struct mp4_encode_msi_s *mp4_encode) { struct mp4_event_ctx_s *event = mp4_encode->event; struct mp4_event_buffer_s *event_buffer; struct framebuff *fb; if (event == NULL) { return; } event_buffer = &event->event_buffer; if (event_buffer->count == 0) { return; } fb = event_buffer->frames[event_buffer->head]; event_buffer->frames[event_buffer->head] = NULL; event_buffer->head = (event_buffer->head + 1) % MP4_EVENT_BUFFER_MAX_COUNT; event_buffer->count--; if (event_buffer->count == 0) { event_buffer->tail = 0; event_buffer->head = 0; event_buffer->latest_time = 0; } if (fb) { msi_delete_fb(NULL, fb); } } static void mp4_event_buffer_reset(struct mp4_encode_msi_s *mp4_encode) { struct mp4_event_ctx_s *event = mp4_encode->event; if (event == NULL) { return; } while (event->event_buffer.count) { mp4_event_buffer_drop_head(mp4_encode); } } static struct framebuff *mp4_event_buffer_first(const struct mp4_encode_msi_s *mp4_encode) { const struct mp4_event_ctx_s *event = mp4_encode->event; if (event == NULL || event->event_buffer.count == 0) { return NULL; } return event->event_buffer.frames[event->event_buffer.head]; } static struct framebuff *mp4_event_buffer_pop(struct mp4_encode_msi_s *mp4_encode) { struct mp4_event_ctx_s *event = mp4_encode->event; struct mp4_event_buffer_s *event_buffer; struct framebuff *fb; if (event == NULL) { return NULL; } event_buffer = &event->event_buffer; if (event_buffer->count == 0) { return NULL; } fb = event_buffer->frames[event_buffer->head]; event_buffer->frames[event_buffer->head] = NULL; event_buffer->head = (event_buffer->head + 1) % MP4_EVENT_BUFFER_MAX_COUNT; event_buffer->count--; if (event_buffer->count == 0) { event_buffer->tail = 0; event_buffer->head = 0; event_buffer->latest_time = 0; } return fb; } static void mp4_event_buffer_push(struct mp4_encode_msi_s *mp4_encode, struct framebuff *fb) { struct mp4_event_ctx_s *event = mp4_encode->event; struct mp4_event_buffer_s *event_buffer; struct framebuff *first_fb; if (event == NULL || fb == NULL) { return; } event_buffer = &event->event_buffer; while (event_buffer->count >= MP4_EVENT_BUFFER_MAX_COUNT) { mp4_event_buffer_drop_head(mp4_encode); } event_buffer->frames[event_buffer->tail] = fb; event_buffer->tail = (event_buffer->tail + 1) % MP4_EVENT_BUFFER_MAX_COUNT; event_buffer->count++; event_buffer->latest_time = fb->time; while (event_buffer->count) { first_fb = mp4_event_buffer_first(mp4_encode); if (first_fb == NULL) { mp4_event_buffer_drop_head(mp4_encode); continue; } if (event_buffer->latest_time < first_fb->time) { break; } if (event_buffer->latest_time - first_fb->time <= MP4_EVENT_BUFFER_MAX_MS) { break; } mp4_event_buffer_drop_head(mp4_encode); } } static int mp4_event_buffer_prepare(struct mp4_encode_msi_s *mp4_encode) { struct mp4_event_ctx_s *event = mp4_encode->event; struct mp4_event_buffer_s *event_buffer; uint32_t target_time = 0; int32_t first_i_off = -1; int32_t start_off = -1; uint16_t i; if (event == NULL) { return RET_ERR; } event_buffer = &event->event_buffer; if (event_buffer->count == 0) { return RET_ERR; } if (event->trigger_time > MP4_EVENT_PRERECORD_MS) { target_time = event->trigger_time - MP4_EVENT_PRERECORD_MS; } for (i = 0; i < event_buffer->count; i++) { struct framebuff *fb = event_buffer->frames[(event_buffer->head + i) % MP4_EVENT_BUFFER_MAX_COUNT]; struct fb_h264_s *priv; if (!fb || fb->mtype != F_H264) { continue; } priv = (struct fb_h264_s *) fb->priv; if (priv && priv->type == 1) { if (first_i_off < 0) { first_i_off = i; } if (fb->time <= target_time) { start_off = i; } } } if (start_off < 0) { start_off = first_i_off; } if (start_off < 0) { return RET_ERR; } while (start_off-- > 0) { mp4_event_buffer_drop_head(mp4_encode); } while (event_buffer->count) { struct framebuff *fb = mp4_event_buffer_first(mp4_encode); if (fb && fb->mtype == F_H264) { return RET_OK; } mp4_event_buffer_drop_head(mp4_encode); } return RET_ERR; } static struct framebuff *mp4_get_next_fb(struct msi *msi) { struct mp4_encode_msi_s *mp4_encode = (struct mp4_encode_msi_s *) msi->priv; struct framebuff *fb = NULL; if (mp4_is_event_mode(mp4_encode)) { fb = mp4_event_buffer_pop(mp4_encode); } if (fb == NULL) { fb = msi_get_fb(msi, 0); if (fb && (fb->mtype == F_H264)) { mp4_encode->max_video_count--; } } return fb; } static int mp4_event_wait_record_start(struct msi *msi) { struct mp4_encode_msi_s *mp4_encode = (struct mp4_encode_msi_s *) msi->priv; struct mp4_event_ctx_s *event = mp4_encode->event; if (event == NULL) { return MP4_ENCODE_ERR_STOP; } while (1) { struct framebuff *fb = NULL; uint32_t mp4_status = 0; os_event_wait(&mp4_encode->evt, MSI_MP4_STOP | MSI_MP4_EVENT_STOP | MSI_MP4_EVENT_START, &mp4_status, OS_EVENT_WMODE_OR | OS_EVENT_WMODE_CLEAR, 0); if (mp4_status & MSI_MP4_STOP) { _os_printf("%s %d\r\n", __func__, __LINE__); return MP4_ENCODE_ERR_STOP; } if (mp4_status & MSI_MP4_EVENT_STOP) { event->trigger_time = 0; continue; } if (mp4_status & MSI_MP4_EVENT_START) { if (event->event_buffer.count) { event->trigger_time = event->event_buffer.latest_time; } else { event->trigger_time = os_jiffies(); } if (mp4_event_buffer_prepare(mp4_encode) == RET_OK) { _os_printf("%s %d\r\n", __func__, __LINE__); return MP4_ENCODE_ERR_NONE; } } if(mp4_encode->fb) { fb = mp4_encode->fb; mp4_encode->max_video_count++; mp4_encode->fb = NULL; } else { fb = msi_get_fb(msi, 0); } if (fb) { if (fb->mtype == F_H264) { mp4_encode->max_video_count--; } if (fb->mtype == F_H264 || (fb->mtype == F_AUDIO && mp4_has_audio(mp4_encode))) { mp4_event_buffer_push(mp4_encode, fb); } else { msi_delete_fb(NULL, fb); } } if (event->trigger_time && mp4_event_buffer_prepare(mp4_encode) == RET_OK) { _os_printf("%s %d\r\n", __func__, __LINE__); return MP4_ENCODE_ERR_NONE; } os_sleep_ms(1); // 任务调度 } } static uint32_t a2i(char *str) { uint32_t ret = 0; uint32_t indx = 0; char str_buf[32]; memset(str_buf, 0, 32); while (str[indx] != '\0') { if (str[indx] == '.') { break; } str_buf[indx] = str[indx]; indx++; } // printf("str_buf:%s str:%s\r\n",str_buf,str); indx = 0; while (str_buf[indx] != '\0') { if (str_buf[indx] >= '0' && str_buf[indx] <= '9') { ret = ret * 10 + str_buf[indx] - '0'; } indx++; } return ret; } static void get_aac_config(uint32_t samplerate, uint8_t *config_buf) { uint8_t samplerate_index = 0; switch (samplerate) { case 48000: samplerate_index = 0x3; break; case 44100: samplerate_index = 0x4; break; case 36000: samplerate_index = 0x5; break; case 24000: samplerate_index = 0x6; break; case 22050: samplerate_index = 0x7; break; case 16000: samplerate_index = 0x8; break; case 12000: samplerate_index = 0x9; break; case 11025: samplerate_index = 0xA; break; case 8000: samplerate_index = 0xB; break; default: break; } config_buf[0] = (0x02 << 3) | (samplerate_index >> 1); config_buf[1] = ((samplerate_index & 0x1) << 7) | (0x01 << 3); } // 获取nal的size,从0开始搜索,返回的是的nal头的size,offset相对于头的偏移(通过多次调用,可以用于计算nal_size) // 返回0代表搜索不到nal的头 static uint8_t get_nal_size(uint8_t *buf, uint32_t size, uint32_t *offset) { uint32_t pos = 0; while ((size - pos) > 3) { if (buf[pos] == 0 && buf[pos + 1] == 0 && buf[pos + 2] == 1) { *offset = pos; return 3; } if (buf[pos] == 0 && buf[pos + 1] == 0 && buf[pos + 2] == 0 && buf[pos + 3] == 1) { *offset = pos; return 4; } pos++; } return 0; } // 只是获取pps和sps的nalsize static uint8_t *get_sps_pps_nal_size(uint8_t *buf, uint32_t size, uint32_t *nal_size, uint8_t *head_size) { uint32_t offset; uint8_t nal_head_size = get_nal_size(buf, size, &offset); uint8_t nal_type; uint8_t *ret_buf = NULL; // 找到头部,检查类型 if (nal_head_size && offset + nal_head_size < size) { nal_type = buf[nal_head_size + offset] & 0x1f; // 找到sps和pps就返回长度和偏移(相对buf的偏移) if (nal_type == 7 || nal_type == 8) { // 查找下一个nal nal_head_size = get_nal_size(buf + offset + nal_head_size, size - (offset + nal_head_size), nal_size); if (nal_head_size) { // 偏移到nal的头部 ret_buf = buf + offset; // 返回nal的头size *head_size = nal_head_size; } } } return ret_buf; } static int mp4_encode_running(struct msi *msi, uint32_t save_time, void *fp, const char *h264_filename, uint32_t filesize) { int ret = MP4_ENCODE_ERR_NONE; struct mp4_encode_msi_s *mp4_encode = (struct mp4_encode_msi_s *) msi->priv; struct framebuff *fb = mp4_encode->fb; // 获取缓冲的一帧数据 mp4_encode->fb = NULL; struct msi *mp4_thumb_msi = NULL; void *mp4_msg = NULL; int32_t error = 0; uint32_t MP4_status = 0; uint32_t write_start_time = os_jiffies(); uint32_t nal_size; uint8_t nal_head_size; uint8_t *buf; uint8_t *nal_head_buf; uint8_t *last_nal_head_buf; uint8_t sps_pps_flag = 0; uint8_t h264_count = 0; uint8_t asps_data[2]; uint32_t now_time = 0; uint32_t last_fb_time = 0; uint32_t video_first_time = 0; uint32_t audio_first_time = 0; uint32_t second = 0; uint32_t last_adjust_pts_time = os_jiffies(); int delta = 40; int average_pts = delta * 90; int acc_pts = 0; int acc_pts_tmp = 0; int write_size = 0; uint32_t v_count = 0; os_printf(KERN_DEBUG "max_video_count: %d, mode: %s\r\n", mp4_encode->max_video_count, mp4_mode_str(mp4_encode)); if (!fp) { os_sleep_ms(1); ret = MP4_ENCODE_ERR_NO_SD; goto mp4_encode_running_clean_end; } // 根据模式决定是否包含音频 int has_audio = mp4_has_audio(mp4_encode); mp4_msg = MP4_open_init((F_FILE *) fp, has_audio); if (!mp4_msg) { goto mp4_encode_running_clean_end; } // 配置音频和视频 if (has_audio) { get_aac_config(audio_adc_get_samplerate(AUSYS_AUAD), asps_data); mp4_audio_cfg_init(mp4_msg, asps_data, sizeof(asps_data)); } mp4_set_max_size(mp4_msg, filesize); // mp4_video_cfg_init(mp4_msg, 1280, 720); // 初始化PTS相关变量 if (mp4_is_realtime_mode(mp4_encode)) { acc_pts = (delta * 90); } // 启动缩略图生成 mp4_thumb_msi = mp4_thumb_msi_init(h264_filename, FRAMEBUFF_SOURCE_CAMERA0, FSTYPE_NONE); msi->enable = 1; while (fp) { os_event_wait(&mp4_encode->evt, MSI_MP4_STOP | MSI_MP4_EVENT_STOP, &MP4_status, OS_EVENT_WMODE_OR, 0); // 结束写卡 if (MP4_status & MSI_MP4_STOP) { ret = MP4_ENCODE_ERR_STOP; goto mp4_encode_running_clean_end; } if (mp4_is_event_mode(mp4_encode) && (MP4_status & MSI_MP4_EVENT_STOP)) { ret = MP4_ENCODE_ERR_EVENT_STOP; goto mp4_encode_running_event_end; } if (fb == NULL) { fb = mp4_get_next_fb(msi); } if (fb && (fb->mtype == F_H264)) { struct fb_h264_s *h264_priv = (struct fb_h264_s *) fb->priv; // 帧序号检查和PTS计算 if (mp4_is_realtime_mode(mp4_encode)) { // 检查录制时间 if (video_first_time != 0 && fb->time >= video_first_time && fb->time - video_first_time >= save_time) { if (h264_priv->type == 1) { mp4_encode->fb = fb; if (mp4_is_event_mode(mp4_encode)) { goto mp4_encode_running_event_end; } goto mp4_encode_running_end; } } // 超时退出 3s if (os_jiffies() - write_start_time >= save_time + 3000) { if (mp4_is_event_mode(mp4_encode)) { goto mp4_encode_running_event_end; } goto mp4_encode_running_clean_end; } h264_count++; if ((h264_priv->count != h264_count) && (h264_priv->type != 1)) { os_printf(KERN_ERR "%s: %d h264 frame lost,count: %d,expect: %d\ttype: %d\n", __FUNCTION__, __LINE__, h264_priv->count, h264_count, h264_priv->type); goto mp4_encode_running_no_found_sps_pps; } h264_count = h264_priv->count; // PTS计算和调整 if (last_fb_time == 0) { last_fb_time = fb->time; } else { average_pts += ((((fb->time - last_fb_time) * 90) >> AVERAGE_BASE) - (average_pts >> AVERAGE_BASE)); } if (now_time == 0) { now_time = fb->time; video_first_time = fb->time; } acc_pts += ((fb->time - last_fb_time) * 90); acc_pts -= (delta * 90); acc_pts_tmp = acc_pts > 0 ? acc_pts : -acc_pts; if (acc_pts_tmp / average_pts) { if (os_jiffies() - last_adjust_pts_time > 1000) { delta = (average_pts + (acc_pts / 60)) / 90; last_adjust_pts_time = os_jiffies(); } } if (os_jiffies() - last_adjust_pts_time > 5000) { last_adjust_pts_time = os_jiffies(); delta = (average_pts) / 90; } last_fb_time = fb->time; } else { if (mp4_encode->timeLapse_count <= v_count) { goto mp4_encode_running_clean_end; } v_count++; } buf = fb->data; nal_head_size = 0; nal_head_buf = buf; last_nal_head_buf = nal_head_buf; mp4_encode_running_again: // 检查是否存在pps或者sps nal_head_buf = get_sps_pps_nal_size(nal_head_buf, 64, &nal_size, &nal_head_size); // 找到pps或者sps if (nal_head_buf) { // 重置写入时间 if (!sps_pps_flag && mp4_is_realtime_mode(mp4_encode)) { write_start_time = os_jiffies(); } mp4_video_cfg_init(mp4_msg, h264_priv->w, h264_priv->h); error |= write_h264_pps_sps(mp4_msg, nal_head_buf, nal_size + nal_head_size); if (0 != error) { os_printf(KERN_ERR "%s:%d\n", __FUNCTION__, __LINE__); if (mp4_is_event_mode(mp4_encode)) { goto mp4_encode_running_event_clean_end; } goto mp4_encode_running_clean_end; } nal_head_buf += (nal_size + nal_head_size); last_nal_head_buf = nal_head_buf; sps_pps_flag = 1; goto mp4_encode_running_again; } // 如果没有写过sps和pps，就跳过 if (!sps_pps_flag) { now_time = 0; video_first_time = 0; goto mp4_encode_running_no_found_sps_pps; } // 写剩余的nal数据 if (!mp4_is_realtime_mode(mp4_encode)) { _os_printf(KERN_INFO "T"); error |= write_h264_data(mp4_msg, last_nal_head_buf, fb->len - (last_nal_head_buf - fb->data), MP4_TIMELAPSE_TIME); write_size += (fb->len - (last_nal_head_buf - fb->data)); } else { _os_printf(KERN_INFO "M"); error |= write_h264_data(mp4_msg, last_nal_head_buf, fb->len - (last_nal_head_buf - fb->data), delta); } if (0 != error) { os_printf(KERN_ERR "%s: %d\n", __FUNCTION__, __LINE__); if (mp4_is_event_mode(mp4_encode)) { goto mp4_encode_running_event_clean_end; } goto mp4_encode_running_clean_end; } now_time = fb->time; mp4_encode_running_no_found_sps_pps: msi_delete_fb(NULL, fb); fb = NULL; if (!mp4_is_realtime_mode(mp4_encode)) { // 每帧立即同步 error |= mp4_syn(mp4_msg); if (0 != error) { os_printf("%s:%d\n", __FUNCTION__, __LINE__); if (mp4_is_event_mode(mp4_encode)) { goto mp4_encode_running_event_clean_end; } goto mp4_encode_running_clean_end; } } else { // 每秒同步一次 if ((now_time - video_first_time) / 1000 > second) { second = (now_time - video_first_time) / 1000; mp4_encode->rec_second = second; os_printf(KERN_DEBUG "save second: %d\n", second); #if 1 error |= mp4_syn(mp4_msg); if (0 != error) { os_printf(KERN_ERR "%s:%d\n", __FUNCTION__, __LINE__); if (mp4_is_event_mode(mp4_encode)) { goto mp4_encode_running_event_clean_end; } goto mp4_encode_running_clean_end; } #endif } } } else if (sps_pps_flag && fb && (fb->mtype == F_AUDIO) && has_audio) { if (audio_first_time == 0) { if (video_first_time != 0 && fb->time >= video_first_time) { audio_first_time = fb->time; } else { _os_printf("P"); // 音频时间不对,直接删除 msi_delete_fb(NULL, fb); fb = NULL; continue; } } buf = fb->data; _os_printf("U"); error |= write_aac_data(mp4_msg, buf + 7, fb->len - 7, 128); if (0 != error) { if (mp4_is_event_mode(mp4_encode)) { goto mp4_encode_running_event_clean_end; } goto mp4_encode_running_clean_end; } msi_delete_fb(NULL, fb); fb = NULL; } else { msi_delete_fb(NULL, fb); fb = NULL; } os_sleep_ms(1); } mp4_encode_running_clean_end: if (fb) { msi_delete_fb(NULL, fb); fb = NULL; } // 清空缓冲区 msi->enable = 0; while (1) { fb = msi_get_fb(msi, 0); if (fb) { msi_delete_fb(NULL, fb); } else { break; } } mp4_encode_running_event_clean_end: if (fb) { msi_delete_fb(NULL, fb); fb = NULL; } mp4_encode_running_event_end: // 清空预录缓冲区 if (mp4_is_event_mode(mp4_encode)) { while(1) { fb = mp4_event_buffer_pop(mp4_encode); if(fb) { msi_delete_fb(NULL, fb); } else { break; } } } mp4_encode_running_end: mp4_encode->rec_second = 0; if (mp4_msg) { mp4_deinit(mp4_msg); } if (fp) { osal_fclose(fp); fp = NULL; } if (mp4_thumb_msi) { msi_destroy(mp4_thumb_msi); } if (error) { os_printf(KERN_ERR "mp4 encode error: %d\n", error); } os_printf(KERN_DEBUG "mp4 encode end, mode: %s\n", mp4_mode_str(mp4_encode)); return ret; } static void mp4_encode_thread(void *d) { int ret = 0; uint32_t mp4_status = 0; struct msi *msi = (struct msi *) d; struct mp4_encode_msi_s *mp4_encode = (struct mp4_encode_msi_s *) msi->priv; struct file_process *file_process = &mp4_encode->file_process; void *fp = NULL; uint32_t filesize = 0; char filename[64]; char filepath[64]; msi_get(msi); os_event_wait(&mp4_encode->evt, MSI_MP4_START | MSI_MP4_STOP, &mp4_status, OS_EVENT_WMODE_OR | OS_EVENT_WMODE_CLEAR, -1); if (mp4_status & MSI_MP4_STOP) { goto mp4_encode_thread_end; } while (msi) { filesize = ((mp4_encode->rec_time / 60) + (mp4_encode->rec_time % 60 ? 1 : 0)) * mp4_encode->file_size; if (mp4_is_event_mode(mp4_encode)) { msi->enable = 1; ret = mp4_event_wait_record_start(msi); if (ret == MP4_ENCODE_ERR_STOP) { break; } struct framebuff *first_fb = NULL; first_fb = mp4_event_buffer_first(mp4_encode); file_process->frame_time = first_fb ? first_fb->time : 0; } if (file_process->create_file) { if (!mp4_is_event_mode(mp4_encode) && mp4_encode->fb) { struct framebuff *fb = mp4_encode->fb; file_process->frame_time = fb->time; } fp = file_process->create_file(file_process, filename, filepath, filesize); } // 如果时缩时录影，寻找到I帧再继续录制，这里需要发送一个命令，强行产生一帧I帧 if(file_process->start_encode) { file_process->param = mp4_encode->mode; file_process->start_encode(file_process); } ret = mp4_encode_running(msi, mp4_encode->rec_time * 1000, fp, filename, filesize); if (file_process->lock_file && ret != MP4_ENCODE_ERR_NO_SD) { file_process->lock_file(filename, filepath); } if(file_process->end_encode) { file_process->param = ret; file_process->end_encode(file_process); } os_printf(KERN_DEBUG "%s %d end\n", __FUNCTION__, __LINE__); if (mp4_is_event_mode(mp4_encode)) { mp4_encode->event->trigger_time = 0; mp4_event_buffer_reset(mp4_encode); os_event_clear(&mp4_encode->evt, MSI_MP4_EVENT_START, NULL); os_event_clear(&mp4_encode->evt, MSI_MP4_EVENT_STOP, NULL); if (ret == MP4_ENCODE_ERR_STOP) { break; } if (ret == MP4_ENCODE_ERR_EVENT_STOP) { os_printf("mp4 event stop\n"); } if (ret == MP4_ENCODE_ERR_NO_SD && file_process->loop_free) { file_process->loop_free(&file_process->loop); } os_printf(KERN_DEBUG "%s %d end, ret: %d\n", __FUNCTION__, __LINE__, ret); continue; } if (ret) { if (file_process->loop_free) { file_process->loop_free(&file_process->loop); } // 如果是sd异常,延迟1s然后重新尝试重新录像(同时检测是否要停止) if (ret == MP4_ENCODE_ERR_NO_SD) { mp4_status = 0; os_event_wait(&mp4_encode->evt, MSI_MP4_STOP, &mp4_status, OS_EVENT_WMODE_OR, 1000); if (mp4_status & MSI_MP4_STOP) { break; } } else { break; } } os_printf(KERN_DEBUG "%s %d end, ret: %d\n", __FUNCTION__, __LINE__, ret); } mp4_encode_thread_end: if (mp4_is_event_mode(mp4_encode)) { mp4_encode->event->trigger_time = 0; mp4_event_buffer_reset(mp4_encode); } os_event_set(&mp4_encode->evt, MSI_MP4_THREAD_DEAD, NULL); msi_put(msi); os_printf(KERN_DEBUG "%s: %d end\n", __FUNCTION__, __LINE__); } static int32_t MP4_encode_msi_action(struct msi *msi, uint32_t cmd_id, uint32_t param1, uint32_t param2) { int32_t ret = RET_OK; struct mp4_encode_msi_s *mp4_encode = (struct mp4_encode_msi_s *) msi->priv; switch (cmd_id) { case MSI_CMD_POST_DESTROY: os_event_wait(&mp4_encode->evt, MSI_MP4_THREAD_DEAD, NULL, OS_EVENT_WMODE_OR | OS_EVENT_WMODE_CLEAR, -1); if (mp4_is_event_mode(mp4_encode)) { mp4_encode->event->trigger_time = 0; mp4_event_buffer_reset(mp4_encode); } if (mp4_encode->fb) { msi_delete_fb(NULL, (struct framebuff *) mp4_encode->fb); mp4_encode->fb = NULL; } if (mp4_encode->event) { STREAM_LIBC_FREE(mp4_encode->event); mp4_encode->event = NULL; } os_event_del(&mp4_encode->evt); STREAM_LIBC_FREE(mp4_encode); break; case MSI_CMD_PRE_DESTROY: os_event_set(&mp4_encode->evt, MSI_MP4_STOP, NULL); break; case MSI_CMD_TRANS_FB: { struct framebuff *fb = (struct framebuff *) param1; // 暂时接收所有的音频 if (fb->mtype == F_AUDIO) { // 缩时录影不接收音频 if (mp4_encode->mode == MP4_MODE_TIME_LAPSE) { ret = RET_ERR; } } else if (fb->mtype == F_H264 && mp4_encode->filter_type != (uint16_t) ~0) { if (mp4_encode->srcID != 0 && fb->srcID != mp4_encode->srcID) { ret = RET_ERR; break; } ret = RET_ERR; if (mp4_encode->filter_type == fb->stype) { ret = RET_OK; } // 帧选择策略 if (ret == RET_OK) { // 缓冲区满时只接收I帧 if (mp4_encode->max_video_count > mp4_max_video_count_limit(mp4_encode)) { struct fb_h264_s *priv = (struct fb_h264_s *) fb->priv; if (priv->type != 1) { ret = RET_ERR; os_printf(KERN_ERR "h264 drop: %d\n", mp4_encode->max_video_count); } } } if (ret == RET_OK) { mp4_encode->max_video_count++; } } } break; case MSI_CMD_GET_RUNNING: { uint32_t rflags = 0; os_event_wait(&mp4_encode->evt, MSI_MP4_THREAD_DEAD | MSI_MP4_STOP, &rflags, OS_EVENT_WMODE_OR, 0); if (param1) { *(uint32_t *) param1 = (rflags & (MSI_MP4_THREAD_DEAD | MSI_MP4_STOP)) ? 0 : 1; } } break; case MSI_CMD_MEDIA_CTRL: { uint32_t cmd_self = (uint32_t) param1; uint32_t arg = (uint32_t) param2; switch (cmd_self) { case MSI_MEDIA_CTRL_GET_RECTIME: { *(uint32_t *) arg = mp4_encode->rec_second; } break; case MSI_MEDIA_CTRL_RECORD_START: { os_event_set(&mp4_encode->evt, MSI_MP4_START, NULL); } break; case MSI_MEDIA_CTRL_SET_RECORD_SIZE: { mp4_encode->file_size = arg; } break; case MSI_MEDIA_CTRL_SET_RECORD_SEC: { mp4_encode->rec_time = arg; mp4_encode->timeLapse_count = arg * (1000 / MP4_TIMELAPSE_TIME); } break; case MSI_MEDIA_CTRL_EVENT_START: { if (mp4_is_event_mode(mp4_encode)) { os_event_set(&mp4_encode->evt, MSI_MP4_EVENT_START, NULL); } } break; case MSI_MEDIA_CTRL_EVENT_STOP: { if (mp4_is_event_mode(mp4_encode)) { os_event_set(&mp4_encode->evt, MSI_MP4_EVENT_STOP, NULL); } } break; } } break; } return ret; } struct msi *mp4_encode_msi2_init(const char *mp4_msi_name, uint8_t srcID, uint8_t filter_type, uint8_t rec_time, uint32_t audio_encode, struct file_process *file_process, uint8_t mode) { uint8_t is_new = 0; struct mp4_encode_msi_s *mp4_encode = NULL; struct msi *msi = msi_new(mp4_msi_name, mp4_msi_queue_count(mode), &is_new); if (is_new) { mp4_encode = (struct mp4_encode_msi_s *) STREAM_LIBC_ZALLOC(sizeof(struct mp4_encode_msi_s)); ASSERT(mp4_encode); mp4_encode->filter_type = filter_type; mp4_encode->srcID = srcID; mp4_encode->rec_time = rec_time * 60; mp4_encode->mode = mode; // 设置录制模式 mp4_encode->timeLapse_count = rec_time * 60 * (1000 / MP4_TIMELAPSE_TIME); mp4_encode->file_size = MAX_SINGLE_MP4_SIZE; if (mode == MP4_MODE_EVETN) { mp4_encode->event = (struct mp4_event_ctx_s *) STREAM_LIBC_ZALLOC(sizeof(struct mp4_event_ctx_s)); if (mp4_encode->event == NULL) { STREAM_LIBC_FREE(mp4_encode); mp4_encode = NULL; if (msi) { msi_destroy(msi); msi = NULL; } goto mp4_encode_msi_init_end; } } if (file_process == NULL) { // 配置默认值 mp4_encode->file_process.rec_path = REC_PATH; mp4_encode->file_process.ext_name = MP4_EXTENSION_NAME; mp4_encode->file_process.create_file = rec_create_file; mp4_encode->file_process.loop_free = rec_loop_free; } else { os_memcpy(&mp4_encode->file_process, file_process, sizeof(struct file_process)); } if (mode == MP4_MODE_TIME_LAPSE) { // 缩时录影无音频 mp4_encode->audio_encode = 0; } else { mp4_encode->audio_encode = audio_encode; } os_event_init(&mp4_encode->evt); mp4_encode->msi = msi; msi->priv = mp4_encode; msi->action = MP4_encode_msi_action; msi->enable = 1; } else { if (msi) { msi_destroy(msi); msi = NULL; } goto mp4_encode_msi_init_end; } void *mp4_hdl = os_task_create("mp4_encode", mp4_encode_thread, msi, OS_TASK_PRIORITY_ABOVE_NORMAL, 0, NULL, 2048); os_printf(KERN_DEBUG "mp4_hdl: %x\n", mp4_hdl); if (!mp4_hdl && mp4_encode) { os_event_set(&mp4_encode->evt, MSI_MP4_THREAD_DEAD, NULL); } mp4_encode_msi_init_end: return msi; }