diff --git a/common/params.cc b/common/params.cc index 9da6281..72a839c 100755 --- a/common/params.cc +++ b/common/params.cc @@ -110,6 +110,7 @@ std::unordered_map keys = { {"CurrentBootlog", PERSISTENT}, {"CurrentRoute", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, {"DashcamDebug", PERSISTENT}, + {"DashcamFrames", PERSISTENT}, {"DashcamShutdown", CLEAR_ON_MANAGER_START}, {"DisableLogging", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION}, {"DisablePowerDown", PERSISTENT}, diff --git a/selfdrive/clearpilot/dashcamd b/selfdrive/clearpilot/dashcamd index a12138f..d3b19ca 100755 Binary files a/selfdrive/clearpilot/dashcamd and b/selfdrive/clearpilot/dashcamd differ diff --git a/selfdrive/clearpilot/dashcamd.cc b/selfdrive/clearpilot/dashcamd.cc index 2e42860..42495bc 100644 --- a/selfdrive/clearpilot/dashcamd.cc +++ b/selfdrive/clearpilot/dashcamd.cc @@ -50,6 +50,8 @@ #include #include #include +#include +#include #include #include #include @@ -115,12 +117,22 @@ static std::string srt_time(int seconds) { return std::string(buf); } -int main(int argc, char *argv[]) { - setpriority(PRIO_PROCESS, 0, -10); +static void crash_handler(int sig) { + FILE *f = fopen("/tmp/dashcamd_crash.log", "w"); + if (f) { + fprintf(f, "CRASH: signal %d\n", sig); + void *bt[30]; + int n = backtrace(bt, 30); + backtrace_symbols_fd(bt, n, fileno(f)); + fclose(f); + } + _exit(1); +} - // Reset OMX subsystem — clears any stale encoder state from previous unclean exit - OMX_Deinit(); - OMX_Init(); +int main(int argc, char *argv[]) { + signal(SIGSEGV, crash_handler); + signal(SIGABRT, crash_handler); + setpriority(PRIO_PROCESS, 0, -10); // Ensure base output directory exists mkdir(VIDEOS_BASE.c_str(), 0755); @@ -183,6 +195,11 @@ int main(int argc, char *argv[]) { // Param check throttle (don't hit filesystem every frame) int param_check_counter = 0; + // Total encoded frames counter + param writer + Params params_memory("/dev/shm/params"); + int total_frames = 0; + double last_frame_count_write = 0; + // Helper: start a new trip with recording + optional idle timer auto start_new_trip = [&]() { // Close existing encoder if any @@ -198,7 +215,7 @@ int main(int argc, char *argv[]) { mkdir(trip_dir.c_str(), 0755); LOGW("dashcamd: new trip %s", trip_dir.c_str()); - encoder = new OmxEncoder(trip_dir.c_str(), width, height, CAMERA_FPS, BITRATE, false, false); + encoder = new OmxEncoder(trip_dir.c_str(), width, height, CAMERA_FPS, BITRATE); std::string seg_name = make_timestamp(); LOGW("dashcamd: opening segment %s", seg_name.c_str()); @@ -358,6 +375,13 @@ int main(int argc, char *argv[]) { // Feed NV12 frame directly to OMX encoder encoder->encode_frame_nv12(buf->y, y_stride, buf->uv, uv_stride, width, height, ts); frame_count++; + total_frames++; + + // Write total frame count to params_memory every 5 seconds + if (now - last_frame_count_write >= 5.0) { + params_memory.put("DashcamFrames", std::to_string(total_frames)); + last_frame_count_write = now; + } // Write GPS subtitle at most once per second if (srt_file && (now - last_srt_write) >= 1.0) { diff --git a/selfdrive/frogpilot/screenrecorder/omx_encoder.cc b/selfdrive/frogpilot/screenrecorder/omx_encoder.cc index 37ffc45..bbb1888 100755 --- a/selfdrive/frogpilot/screenrecorder/omx_encoder.cc +++ b/selfdrive/frogpilot/screenrecorder/omx_encoder.cc @@ -35,120 +35,19 @@ int ABGRToNV12(const uint8_t* src_abgr, int halfwidth = (width + 1) >> 1; void (*ABGRToUVRow)(const uint8_t* src_abgr0, int src_stride_abgr, uint8_t* dst_u, uint8_t* dst_v, int width) = - ABGRToUVRow_C; + ABGRToUVRow_NEON; void (*ABGRToYRow)(const uint8_t* src_abgr, uint8_t* dst_y, int width) = - ABGRToYRow_C; - void (*MergeUVRow_)(const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_uv, int width) = MergeUVRow_C; + ABGRToYRow_NEON; + void (*MergeUVRow_)(const uint8_t* src_u, const uint8_t* src_v, uint8_t* dst_uv, int width) = MergeUVRow_NEON; if (!src_abgr || !dst_y || !dst_uv || width <= 0 || height == 0) { return -1; } -if (height < 0) { // Negative height means invert the image. - height = -height; - src_abgr = src_abgr + (height - 1) * src_stride_abgr; - src_stride_abgr = -src_stride_abgr; -} -#if defined(HAS_ABGRTOYROW_SSSE3) && defined(HAS_ABGRTOUVROW_SSSE3) - if (TestCpuFlag(kCpuHasSSSE3)) { - ABGRToUVRow = ABGRToUVRow_Any_SSSE3; - ABGRToYRow = ABGRToYRow_Any_SSSE3; - if (IS_ALIGNED(width, 16)) { - ABGRToUVRow = ABGRToUVRow_SSSE3; - ABGRToYRow = ABGRToYRow_SSSE3; - } + if (height < 0) { + height = -height; + src_abgr = src_abgr + (height - 1) * src_stride_abgr; + src_stride_abgr = -src_stride_abgr; } -#endif -#if defined(HAS_ABGRTOYROW_AVX2) && defined(HAS_ABGRTOUVROW_AVX2) - if (TestCpuFlag(kCpuHasAVX2)) { - ABGRToUVRow = ABGRToUVRow_Any_AVX2; - ABGRToYRow = ABGRToYRow_Any_AVX2; - if (IS_ALIGNED(width, 32)) { - ABGRToUVRow = ABGRToUVRow_AVX2; - ABGRToYRow = ABGRToYRow_AVX2; - } - } -#endif -#if defined(HAS_ABGRTOYROW_NEON) - if (TestCpuFlag(kCpuHasNEON)) { - ABGRToYRow = ABGRToYRow_Any_NEON; - if (IS_ALIGNED(width, 8)) { - ABGRToYRow = ABGRToYRow_NEON; - } - } -#endif -#if defined(HAS_ABGRTOUVROW_NEON) - if (TestCpuFlag(kCpuHasNEON)) { - ABGRToUVRow = ABGRToUVRow_Any_NEON; - if (IS_ALIGNED(width, 16)) { - ABGRToUVRow = ABGRToUVRow_NEON; - } - } -#endif -#if defined(HAS_ABGRTOYROW_MMI) && defined(HAS_ABGRTOUVROW_MMI) - if (TestCpuFlag(kCpuHasMMI)) { - ABGRToYRow = ABGRToYRow_Any_MMI; - ABGRToUVRow = ABGRToUVRow_Any_MMI; - if (IS_ALIGNED(width, 8)) { - ABGRToYRow = ABGRToYRow_MMI; - } - if (IS_ALIGNED(width, 16)) { - ABGRToUVRow = ABGRToUVRow_MMI; - } - } -#endif -#if defined(HAS_ABGRTOYROW_MSA) && defined(HAS_ABGRTOUVROW_MSA) - if (TestCpuFlag(kCpuHasMSA)) { - ABGRToYRow = ABGRToYRow_Any_MSA; - ABGRToUVRow = ABGRToUVRow_Any_MSA; - if (IS_ALIGNED(width, 16)) { - ABGRToYRow = ABGRToYRow_MSA; - } - if (IS_ALIGNED(width, 32)) { - ABGRToUVRow = ABGRToUVRow_MSA; - } - } -#endif -#if defined(HAS_MERGEUVROW_SSE2) - if (TestCpuFlag(kCpuHasSSE2)) { - MergeUVRow_ = MergeUVRow_Any_SSE2; - if (IS_ALIGNED(halfwidth, 16)) { - MergeUVRow_ = MergeUVRow_SSE2; - } - } -#endif -#if defined(HAS_MERGEUVROW_AVX2) - if (TestCpuFlag(kCpuHasAVX2)) { - MergeUVRow_ = MergeUVRow_Any_AVX2; - if (IS_ALIGNED(halfwidth, 32)) { - MergeUVRow_ = MergeUVRow_AVX2; - } - } -#endif -#if defined(HAS_MERGEUVROW_NEON) - if (TestCpuFlag(kCpuHasNEON)) { - MergeUVRow_ = MergeUVRow_Any_NEON; - if (IS_ALIGNED(halfwidth, 16)) { - MergeUVRow_ = MergeUVRow_NEON; - } - } -#endif -#if defined(HAS_MERGEUVROW_MMI) - if (TestCpuFlag(kCpuHasMMI)) { - MergeUVRow_ = MergeUVRow_Any_MMI; - if (IS_ALIGNED(halfwidth, 8)) { - MergeUVRow_ = MergeUVRow_MMI; - } - } -#endif -#if defined(HAS_MERGEUVROW_MSA) - if (TestCpuFlag(kCpuHasMSA)) { - MergeUVRow_ = MergeUVRow_Any_MSA; - if (IS_ALIGNED(halfwidth, 16)) { - MergeUVRow_ = MergeUVRow_MSA; - } - } -#endif { - // Allocate a rows of uv. align_buffer_64(row_u, ((halfwidth + 31) & ~31) * 2); uint8_t* row_v = row_u + ((halfwidth + 31) & ~31); @@ -182,9 +81,9 @@ extern ExitHandler do_exit; // ***** OMX callback functions ***** void OmxEncoder::wait_for_state(OMX_STATETYPE state_) { - std::unique_lock lk(this->state_lock); - while (this->state != state_) { - this->state_cv.wait(lk); + std::unique_lock lk(state_lock); + while (state != state_) { + state_cv.wait(lk); } } @@ -236,276 +135,203 @@ static const char* omx_color_fomat_name(uint32_t format) __attribute__((unused)) static const char* omx_color_fomat_name(uint32_t format) { switch (format) { case OMX_COLOR_FormatUnused: return "OMX_COLOR_FormatUnused"; - case OMX_COLOR_FormatMonochrome: return "OMX_COLOR_FormatMonochrome"; - case OMX_COLOR_Format8bitRGB332: return "OMX_COLOR_Format8bitRGB332"; - case OMX_COLOR_Format12bitRGB444: return "OMX_COLOR_Format12bitRGB444"; - case OMX_COLOR_Format16bitARGB4444: return "OMX_COLOR_Format16bitARGB4444"; - case OMX_COLOR_Format16bitARGB1555: return "OMX_COLOR_Format16bitARGB1555"; - case OMX_COLOR_Format16bitRGB565: return "OMX_COLOR_Format16bitRGB565"; - case OMX_COLOR_Format16bitBGR565: return "OMX_COLOR_Format16bitBGR565"; - case OMX_COLOR_Format18bitRGB666: return "OMX_COLOR_Format18bitRGB666"; - case OMX_COLOR_Format18bitARGB1665: return "OMX_COLOR_Format18bitARGB1665"; - case OMX_COLOR_Format19bitARGB1666: return "OMX_COLOR_Format19bitARGB1666"; - case OMX_COLOR_Format24bitRGB888: return "OMX_COLOR_Format24bitRGB888"; - case OMX_COLOR_Format24bitBGR888: return "OMX_COLOR_Format24bitBGR888"; - case OMX_COLOR_Format24bitARGB1887: return "OMX_COLOR_Format24bitARGB1887"; - case OMX_COLOR_Format25bitARGB1888: return "OMX_COLOR_Format25bitARGB1888"; - case OMX_COLOR_Format32bitBGRA8888: return "OMX_COLOR_Format32bitBGRA8888"; - case OMX_COLOR_Format32bitARGB8888: return "OMX_COLOR_Format32bitARGB8888"; - case OMX_COLOR_FormatYUV411Planar: return "OMX_COLOR_FormatYUV411Planar"; - case OMX_COLOR_FormatYUV411PackedPlanar: return "OMX_COLOR_FormatYUV411PackedPlanar"; - case OMX_COLOR_FormatYUV420Planar: return "OMX_COLOR_FormatYUV420Planar"; - case OMX_COLOR_FormatYUV420PackedPlanar: return "OMX_COLOR_FormatYUV420PackedPlanar"; case OMX_COLOR_FormatYUV420SemiPlanar: return "OMX_COLOR_FormatYUV420SemiPlanar"; - case OMX_COLOR_FormatYUV422Planar: return "OMX_COLOR_FormatYUV422Planar"; - case OMX_COLOR_FormatYUV422PackedPlanar: return "OMX_COLOR_FormatYUV422PackedPlanar"; - case OMX_COLOR_FormatYUV422SemiPlanar: return "OMX_COLOR_FormatYUV422SemiPlanar"; - case OMX_COLOR_FormatYCbYCr: return "OMX_COLOR_FormatYCbYCr"; - case OMX_COLOR_FormatYCrYCb: return "OMX_COLOR_FormatYCrYCb"; - case OMX_COLOR_FormatCbYCrY: return "OMX_COLOR_FormatCbYCrY"; - case OMX_COLOR_FormatCrYCbY: return "OMX_COLOR_FormatCrYCbY"; - case OMX_COLOR_FormatYUV444Interleaved: return "OMX_COLOR_FormatYUV444Interleaved"; - case OMX_COLOR_FormatRawBayer8bit: return "OMX_COLOR_FormatRawBayer8bit"; - case OMX_COLOR_FormatRawBayer10bit: return "OMX_COLOR_FormatRawBayer10bit"; - case OMX_COLOR_FormatRawBayer8bitcompressed: return "OMX_COLOR_FormatRawBayer8bitcompressed"; - case OMX_COLOR_FormatL2: return "OMX_COLOR_FormatL2"; - case OMX_COLOR_FormatL4: return "OMX_COLOR_FormatL4"; - case OMX_COLOR_FormatL8: return "OMX_COLOR_FormatL8"; - case OMX_COLOR_FormatL16: return "OMX_COLOR_FormatL16"; - case OMX_COLOR_FormatL24: return "OMX_COLOR_FormatL24"; - case OMX_COLOR_FormatL32: return "OMX_COLOR_FormatL32"; - case OMX_COLOR_FormatYUV420PackedSemiPlanar: return "OMX_COLOR_FormatYUV420PackedSemiPlanar"; - case OMX_COLOR_FormatYUV422PackedSemiPlanar: return "OMX_COLOR_FormatYUV422PackedSemiPlanar"; - case OMX_COLOR_Format18BitBGR666: return "OMX_COLOR_Format18BitBGR666"; - case OMX_COLOR_Format24BitARGB6666: return "OMX_COLOR_Format24BitARGB6666"; - case OMX_COLOR_Format24BitABGR6666: return "OMX_COLOR_Format24BitABGR6666"; - - case OMX_COLOR_FormatAndroidOpaque: return "OMX_COLOR_FormatAndroidOpaque"; - case OMX_TI_COLOR_FormatYUV420PackedSemiPlanar: return "OMX_TI_COLOR_FormatYUV420PackedSemiPlanar"; - case OMX_QCOM_COLOR_FormatYVU420SemiPlanar: return "OMX_QCOM_COLOR_FormatYVU420SemiPlanar"; - case OMX_QCOM_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka: return "OMX_QCOM_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka"; - case OMX_SEC_COLOR_FormatNV12Tiled: return "OMX_SEC_COLOR_FormatNV12Tiled"; case OMX_QCOM_COLOR_FormatYUV420PackedSemiPlanar32m: return "OMX_QCOM_COLOR_FormatYUV420PackedSemiPlanar32m"; - - case QOMX_COLOR_FormatYVU420PackedSemiPlanar32m4ka: return "QOMX_COLOR_FormatYVU420PackedSemiPlanar32m4ka"; - case QOMX_COLOR_FormatYUV420PackedSemiPlanar16m2ka: return "QOMX_COLOR_FormatYUV420PackedSemiPlanar16m2ka"; - case QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mMultiView: return "QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mMultiView"; - case QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed: return "QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed"; case QOMX_COLOR_Format32bitRGBA8888: return "QOMX_COLOR_Format32bitRGBA8888"; - case QOMX_COLOR_Format32bitRGBA8888Compressed: return "QOMX_COLOR_Format32bitRGBA8888Compressed"; - - default: - return "unkn"; + default: return "unkn"; } } // ***** encoder functions ***** -OmxEncoder::OmxEncoder(const char* path, int width, int height, int fps, int bitrate, bool h265, bool downscale) { +OmxEncoder::OmxEncoder(const char* path, int width, int height, int fps, int bitrate) { this->path = path; this->width = width; this->height = height; this->fps = fps; - this->remuxing = !h265; - this->downscale = downscale; - if (this->downscale) { - this->y_ptr2 = (uint8_t *)malloc(this->width*this->height); - this->u_ptr2 = (uint8_t *)malloc(this->width*this->height/4); - this->v_ptr2 = (uint8_t *)malloc(this->width*this->height/4); + OMX_ERRORTYPE err = OMX_Init(); + if (err != OMX_ErrorNone) { + LOGE("OMX_Init failed: %x", err); + return; } - auto component = (OMX_STRING)(h265 ? "OMX.qcom.video.encoder.hevc" : "OMX.qcom.video.encoder.avc"); - int err = OMX_GetHandle(&this->handle, component, this, &omx_callbacks); + OMX_STRING component = (OMX_STRING)("OMX.qcom.video.encoder.avc"); + err = OMX_GetHandle(&handle, component, this, &omx_callbacks); if (err != OMX_ErrorNone) { - LOGE("error getting codec: %x", err); + LOGE("Error getting codec: %x", err); + OMX_Deinit(); + return; } // setup input port - OMX_PARAM_PORTDEFINITIONTYPE in_port = {0}; in_port.nSize = sizeof(in_port); in_port.nPortIndex = (OMX_U32) PORT_INDEX_IN; - OMX_CHECK(OMX_GetParameter(this->handle, OMX_IndexParamPortDefinition, (OMX_PTR) &in_port)); + OMX_CHECK(OMX_GetParameter(handle, OMX_IndexParamPortDefinition, (OMX_PTR) &in_port)); - in_port.format.video.nFrameWidth = this->width; - in_port.format.video.nFrameHeight = this->height; - in_port.format.video.nStride = VENUS_Y_STRIDE(COLOR_FMT_NV12, this->width); - in_port.format.video.nSliceHeight = this->height; - in_port.nBufferSize = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, this->width, this->height); - in_port.format.video.xFramerate = (this->fps * 65536); + in_port.format.video.nFrameWidth = width; + in_port.format.video.nFrameHeight = height; + in_port.format.video.nStride = VENUS_Y_STRIDE(COLOR_FMT_NV12, width); + in_port.format.video.nSliceHeight = height; + in_port.nBufferSize = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height); + in_port.format.video.xFramerate = (fps * 65536); in_port.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; in_port.format.video.eColorFormat = (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m; - OMX_CHECK(OMX_SetParameter(this->handle, OMX_IndexParamPortDefinition, (OMX_PTR) &in_port)); - OMX_CHECK(OMX_GetParameter(this->handle, OMX_IndexParamPortDefinition, (OMX_PTR) &in_port)); - this->in_buf_headers.resize(in_port.nBufferCountActual); + OMX_CHECK(OMX_SetParameter(handle, OMX_IndexParamPortDefinition, (OMX_PTR) &in_port)); + OMX_CHECK(OMX_GetParameter(handle, OMX_IndexParamPortDefinition, (OMX_PTR) &in_port)); + in_buf_headers.resize(in_port.nBufferCountActual); // setup output port - - OMX_PARAM_PORTDEFINITIONTYPE out_port = {0}; + OMX_PARAM_PORTDEFINITIONTYPE out_port; + memset(&out_port, 0, sizeof(OMX_PARAM_PORTDEFINITIONTYPE)); out_port.nSize = sizeof(out_port); + out_port.nVersion.s.nVersionMajor = 1; + out_port.nVersion.s.nVersionMinor = 0; + out_port.nVersion.s.nRevision = 0; + out_port.nVersion.s.nStep = 0; out_port.nPortIndex = (OMX_U32) PORT_INDEX_OUT; - OMX_CHECK(OMX_GetParameter(this->handle, OMX_IndexParamPortDefinition, (OMX_PTR)&out_port)); - out_port.format.video.nFrameWidth = this->width; - out_port.format.video.nFrameHeight = this->height; + + OMX_ERRORTYPE error = OMX_GetParameter(handle, OMX_IndexParamPortDefinition, (OMX_PTR)&out_port); + if (error != OMX_ErrorNone) { + LOGE("Error getting output port parameters: 0x%08x", error); + return; + } + + out_port.format.video.nFrameWidth = width; + out_port.format.video.nFrameHeight = height; out_port.format.video.xFramerate = 0; out_port.format.video.nBitrate = bitrate; - if (h265) { - out_port.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC; - } else { - out_port.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC; - } + out_port.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC; out_port.format.video.eColorFormat = OMX_COLOR_FormatUnused; - OMX_CHECK(OMX_SetParameter(this->handle, OMX_IndexParamPortDefinition, (OMX_PTR) &out_port)); + error = OMX_SetParameter(handle, OMX_IndexParamPortDefinition, (OMX_PTR) &out_port); + if (error != OMX_ErrorNone) { + LOGE("Error setting output port parameters: 0x%08x", error); + return; + } - OMX_CHECK(OMX_GetParameter(this->handle, OMX_IndexParamPortDefinition, (OMX_PTR) &out_port)); - this->out_buf_headers.resize(out_port.nBufferCountActual); + error = OMX_GetParameter(handle, OMX_IndexParamPortDefinition, (OMX_PTR) &out_port); + if (error != OMX_ErrorNone) { + LOGE("Error getting updated output port parameters: 0x%08x", error); + return; + } + + out_buf_headers.resize(out_port.nBufferCountActual); OMX_VIDEO_PARAM_BITRATETYPE bitrate_type = {0}; bitrate_type.nSize = sizeof(bitrate_type); bitrate_type.nPortIndex = (OMX_U32) PORT_INDEX_OUT; - OMX_CHECK(OMX_GetParameter(this->handle, OMX_IndexParamVideoBitrate, (OMX_PTR) &bitrate_type)); + OMX_CHECK(OMX_GetParameter(handle, OMX_IndexParamVideoBitrate, (OMX_PTR) &bitrate_type)); bitrate_type.eControlRate = OMX_Video_ControlRateVariable; bitrate_type.nTargetBitrate = bitrate; - OMX_CHECK(OMX_SetParameter(this->handle, OMX_IndexParamVideoBitrate, (OMX_PTR) &bitrate_type)); + OMX_CHECK(OMX_SetParameter(handle, OMX_IndexParamVideoBitrate, (OMX_PTR) &bitrate_type)); - if (h265) { - // setup HEVC - #ifndef QCOM2 - OMX_VIDEO_PARAM_HEVCTYPE hevc_type = {0}; - OMX_INDEXTYPE index_type = (OMX_INDEXTYPE) OMX_IndexParamVideoHevc; - #else - OMX_VIDEO_PARAM_PROFILELEVELTYPE hevc_type = {0}; - OMX_INDEXTYPE index_type = OMX_IndexParamVideoProfileLevelCurrent; - #endif - hevc_type.nSize = sizeof(hevc_type); - hevc_type.nPortIndex = (OMX_U32) PORT_INDEX_OUT; - OMX_CHECK(OMX_GetParameter(this->handle, index_type, (OMX_PTR) &hevc_type)); + // setup h264 + OMX_VIDEO_PARAM_AVCTYPE avc = {0}; + avc.nSize = sizeof(avc); + avc.nPortIndex = (OMX_U32) PORT_INDEX_OUT; + OMX_CHECK(OMX_GetParameter(handle, OMX_IndexParamVideoAvc, &avc)); - hevc_type.eProfile = OMX_VIDEO_HEVCProfileMain; - hevc_type.eLevel = OMX_VIDEO_HEVCHighTierLevel5; + avc.nBFrames = 0; + avc.nPFrames = 15; - OMX_CHECK(OMX_SetParameter(this->handle, index_type, (OMX_PTR) &hevc_type)); - } else { - // setup h264 - OMX_VIDEO_PARAM_AVCTYPE avc = { 0 }; - avc.nSize = sizeof(avc); - avc.nPortIndex = (OMX_U32) PORT_INDEX_OUT; - OMX_CHECK(OMX_GetParameter(this->handle, OMX_IndexParamVideoAvc, &avc)); + avc.eProfile = OMX_VIDEO_AVCProfileHigh; + avc.eLevel = OMX_VIDEO_AVCLevel31; - avc.nBFrames = 0; - avc.nPFrames = 15; + avc.nAllowedPictureTypes |= OMX_VIDEO_PictureTypeB; + avc.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable; - avc.eProfile = OMX_VIDEO_AVCProfileHigh; - avc.eLevel = OMX_VIDEO_AVCLevel31; + avc.nRefFrames = 1; + avc.bUseHadamard = OMX_TRUE; + avc.bEntropyCodingCABAC = OMX_TRUE; + avc.bWeightedPPrediction = OMX_TRUE; + avc.bconstIpred = OMX_TRUE; - avc.nAllowedPictureTypes |= OMX_VIDEO_PictureTypeB; - avc.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable; + OMX_CHECK(OMX_SetParameter(handle, OMX_IndexParamVideoAvc, &avc)); - avc.nRefFrames = 1; - avc.bUseHadamard = OMX_TRUE; - avc.bEntropyCodingCABAC = OMX_TRUE; - avc.bWeightedPPrediction = OMX_TRUE; - avc.bconstIpred = OMX_TRUE; + OMX_CHECK(OMX_SendCommand(handle, OMX_CommandStateSet, OMX_StateIdle, NULL)); - OMX_CHECK(OMX_SetParameter(this->handle, OMX_IndexParamVideoAvc, &avc)); + for (OMX_BUFFERHEADERTYPE* &buf : in_buf_headers) { + OMX_CHECK(OMX_AllocateBuffer(handle, &buf, PORT_INDEX_IN, this, in_port.nBufferSize)); } - OMX_CHECK(OMX_SendCommand(this->handle, OMX_CommandStateSet, OMX_StateIdle, NULL)); - - for (auto &buf : this->in_buf_headers) { - OMX_CHECK(OMX_AllocateBuffer(this->handle, &buf, PORT_INDEX_IN, this, - in_port.nBufferSize)); - } - - for (auto &buf : this->out_buf_headers) { - OMX_CHECK(OMX_AllocateBuffer(this->handle, &buf, PORT_INDEX_OUT, this, - out_port.nBufferSize)); + for (OMX_BUFFERHEADERTYPE* &buf : out_buf_headers) { + OMX_CHECK(OMX_AllocateBuffer(handle, &buf, PORT_INDEX_OUT, this, out_port.nBufferSize)); } wait_for_state(OMX_StateIdle); - OMX_CHECK(OMX_SendCommand(this->handle, OMX_CommandStateSet, OMX_StateExecuting, NULL)); + OMX_CHECK(OMX_SendCommand(handle, OMX_CommandStateSet, OMX_StateExecuting, NULL)); wait_for_state(OMX_StateExecuting); // give omx all the output buffers - for (auto &buf : this->out_buf_headers) { - OMX_CHECK(OMX_FillThisBuffer(this->handle, buf)); + for (OMX_BUFFERHEADERTYPE* &buf : out_buf_headers) { + OMX_CHECK(OMX_FillThisBuffer(handle, buf)); } // fill the input free queue - for (auto &buf : this->in_buf_headers) { - this->free_in.push(buf); + for (OMX_BUFFERHEADERTYPE* &buf : in_buf_headers) { + free_in.push(buf); } } -void OmxEncoder::handle_out_buf(OmxEncoder *e, OMX_BUFFERHEADERTYPE *out_buf) { +void OmxEncoder::handle_out_buf(OmxEncoder *encoder, OMX_BUFFERHEADERTYPE *out_buf) { int err; - - if (out_buf->pBuffer == nullptr || out_buf->nFilledLen == 0) { - OMX_CHECK(OMX_FillThisBuffer(e->handle, out_buf)); - return; - } - uint8_t *buf_data = out_buf->pBuffer + out_buf->nOffset; if (out_buf->nFlags & OMX_BUFFERFLAG_CODECCONFIG) { - if (e->codec_config_len < out_buf->nFilledLen) { - e->codec_config = (uint8_t *)realloc(e->codec_config, out_buf->nFilledLen); + if (encoder->codec_config_len < out_buf->nFilledLen) { + encoder->codec_config = (uint8_t *)realloc(encoder->codec_config, out_buf->nFilledLen); } - e->codec_config_len = out_buf->nFilledLen; - memcpy(e->codec_config, buf_data, out_buf->nFilledLen); + encoder->codec_config_len = out_buf->nFilledLen; + memcpy(encoder->codec_config, buf_data, out_buf->nFilledLen); #ifdef QCOM2 out_buf->nTimeStamp = 0; #endif } - if (e->of) { - fwrite(buf_data, out_buf->nFilledLen, 1, e->of); + if (encoder->of) { + fwrite(buf_data, out_buf->nFilledLen, 1, encoder->of); } - if (e->remuxing) { - if (!e->wrote_codec_config && e->codec_config_len > 0) { - // extradata will be freed by av_free() in avcodec_free_context() - e->codec_ctx->extradata = (uint8_t*)av_mallocz(e->codec_config_len + AV_INPUT_BUFFER_PADDING_SIZE); - e->codec_ctx->extradata_size = e->codec_config_len; - memcpy(e->codec_ctx->extradata, e->codec_config, e->codec_config_len); + if (!encoder->wrote_codec_config && encoder->codec_config_len > 0) { + // extradata will be freed by av_free() in avcodec_free_context() + encoder->out_stream->codecpar->extradata = (uint8_t*)av_mallocz(encoder->codec_config_len + AV_INPUT_BUFFER_PADDING_SIZE); + encoder->out_stream->codecpar->extradata_size = encoder->codec_config_len; + memcpy(encoder->out_stream->codecpar->extradata, encoder->codec_config, encoder->codec_config_len); - err = avcodec_parameters_from_context(e->out_stream->codecpar, e->codec_ctx); - assert(err >= 0); - err = avformat_write_header(e->ofmt_ctx, NULL); - assert(err >= 0); + err = avformat_write_header(encoder->ofmt_ctx, NULL); + assert(err >= 0); - e->wrote_codec_config = true; + encoder->wrote_codec_config = true; + } + + if (out_buf->nTimeStamp > 0) { + // input timestamps are in microseconds + AVRational in_timebase = {1, 1000000}; + + AVPacket pkt; + av_init_packet(&pkt); + pkt.data = buf_data; + pkt.size = out_buf->nFilledLen; + + enum AVRounding rnd = static_cast(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX); + pkt.pts = pkt.dts = av_rescale_q_rnd(out_buf->nTimeStamp, in_timebase, encoder->out_stream->time_base, rnd); + pkt.duration = av_rescale_q(1, AVRational{1, encoder->fps}, encoder->out_stream->time_base); + + if (out_buf->nFlags & OMX_BUFFERFLAG_SYNCFRAME) { + pkt.flags |= AV_PKT_FLAG_KEY; } - if (out_buf->nTimeStamp > 0) { - // input timestamps are in microseconds - AVRational in_timebase = {1, 1000000}; + err = av_write_frame(encoder->ofmt_ctx, &pkt); + if (err < 0) { LOGW("ts encoder write issue"); } - AVPacket pkt; - av_init_packet(&pkt); - pkt.data = buf_data; - pkt.size = out_buf->nFilledLen; - - enum AVRounding rnd = static_cast(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX); - pkt.pts = pkt.dts = av_rescale_q_rnd(out_buf->nTimeStamp, in_timebase, e->ofmt_ctx->streams[0]->time_base, rnd); - pkt.duration = av_rescale_q(50*1000, in_timebase, e->ofmt_ctx->streams[0]->time_base); - - if (out_buf->nFlags & OMX_BUFFERFLAG_SYNCFRAME) { - pkt.flags |= AV_PKT_FLAG_KEY; - } - - err = av_write_frame(e->ofmt_ctx, &pkt); - if (err < 0) { LOGW("ts encoder write issue"); } - - av_free_packet(&pkt); - } + av_packet_unref(&pkt); } // give omx back the buffer @@ -514,59 +340,53 @@ void OmxEncoder::handle_out_buf(OmxEncoder *e, OMX_BUFFERHEADERTYPE *out_buf) { out_buf->nTimeStamp = 0; } #endif - OMX_CHECK(OMX_FillThisBuffer(e->handle, out_buf)); + OMX_CHECK(OMX_FillThisBuffer(encoder->handle, out_buf)); } int OmxEncoder::encode_frame_rgba(const uint8_t *ptr, int in_width, int in_height, uint64_t ts) { - int err; - if (!this->is_open) { + if (!is_open) { return -1; } - // this sometimes freezes... put it outside the encoder lock so we can still trigger rotates... - // THIS IS A REALLY BAD IDEA, but apparently the race has to happen 30 times to trigger this OMX_BUFFERHEADERTYPE* in_buf = nullptr; - while (!this->free_in.try_pop(in_buf, 20)) { + while (!free_in.try_pop(in_buf, 20)) { if (do_exit) { return -1; } } - int ret = this->counter; + int ret = counter; uint8_t *in_buf_ptr = in_buf->pBuffer; uint8_t *in_y_ptr = in_buf_ptr; - int in_y_stride = VENUS_Y_STRIDE(COLOR_FMT_NV12, this->width); - int in_uv_stride = VENUS_UV_STRIDE(COLOR_FMT_NV12, this->width); - uint8_t *in_uv_ptr = in_buf_ptr + (in_y_stride * VENUS_Y_SCANLINES(COLOR_FMT_NV12, this->height)); + int in_y_stride = VENUS_Y_STRIDE(COLOR_FMT_NV12, width); + int in_uv_stride = VENUS_UV_STRIDE(COLOR_FMT_NV12, width); + uint8_t *in_uv_ptr = in_buf_ptr + (in_y_stride * VENUS_Y_SCANLINES(COLOR_FMT_NV12, height)); - err = ABGRToNV12(ptr, this->width*4, - in_y_ptr, in_y_stride, - in_uv_ptr, in_uv_stride, - this->width, this->height); + int err = ABGRToNV12(ptr, width * 4, in_y_ptr, in_y_stride, in_uv_ptr, in_uv_stride, width, height); assert(err == 0); - in_buf->nFilledLen = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, this->width, this->height); + in_buf->nFilledLen = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height); in_buf->nFlags = OMX_BUFFERFLAG_ENDOFFRAME; in_buf->nOffset = 0; - in_buf->nTimeStamp = ts/1000LL; // OMX_TICKS, in microseconds - this->last_t = in_buf->nTimeStamp; + in_buf->nTimeStamp = ts / 1000LL; // OMX_TICKS, in microseconds + last_t = in_buf->nTimeStamp; - OMX_CHECK(OMX_EmptyThisBuffer(this->handle, in_buf)); + OMX_CHECK(OMX_EmptyThisBuffer(handle, in_buf)); // pump output while (true) { OMX_BUFFERHEADERTYPE *out_buf; - if (!this->done_out.try_pop(out_buf)) { + if (!done_out.try_pop(out_buf)) { break; } handle_out_buf(this, out_buf); } - this->dirty = true; + dirty = true; - this->counter++; + counter++; return ret; } @@ -574,24 +394,24 @@ int OmxEncoder::encode_frame_rgba(const uint8_t *ptr, int in_width, int in_heigh // CLEARPILOT: encode raw NV12 frames directly (no RGBA conversion needed) int OmxEncoder::encode_frame_nv12(const uint8_t *y_ptr, int y_stride, const uint8_t *uv_ptr, int uv_stride, int in_width, int in_height, uint64_t ts) { - if (!this->is_open) { + if (!is_open) { return -1; } OMX_BUFFERHEADERTYPE* in_buf = nullptr; - while (!this->free_in.try_pop(in_buf, 20)) { + while (!free_in.try_pop(in_buf, 20)) { if (do_exit) { return -1; } } - int ret = this->counter; + int ret = counter; uint8_t *in_buf_ptr = in_buf->pBuffer; - int venus_y_stride = VENUS_Y_STRIDE(COLOR_FMT_NV12, this->width); - int venus_uv_stride = VENUS_UV_STRIDE(COLOR_FMT_NV12, this->width); + int venus_y_stride = VENUS_Y_STRIDE(COLOR_FMT_NV12, width); + int venus_uv_stride = VENUS_UV_STRIDE(COLOR_FMT_NV12, width); uint8_t *dst_y = in_buf_ptr; - uint8_t *dst_uv = in_buf_ptr + (venus_y_stride * VENUS_Y_SCANLINES(COLOR_FMT_NV12, this->height)); + uint8_t *dst_uv = in_buf_ptr + (venus_y_stride * VENUS_Y_SCANLINES(COLOR_FMT_NV12, height)); // Copy Y plane row by row (source stride may differ from VENUS stride) for (int row = 0; row < in_height; row++) { @@ -603,100 +423,103 @@ int OmxEncoder::encode_frame_nv12(const uint8_t *y_ptr, int y_stride, const uint memcpy(dst_uv + row * venus_uv_stride, uv_ptr + row * uv_stride, in_width); } - in_buf->nFilledLen = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, this->width, this->height); + in_buf->nFilledLen = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height); in_buf->nFlags = OMX_BUFFERFLAG_ENDOFFRAME; in_buf->nOffset = 0; in_buf->nTimeStamp = ts / 1000LL; - this->last_t = in_buf->nTimeStamp; + last_t = in_buf->nTimeStamp; - OMX_CHECK(OMX_EmptyThisBuffer(this->handle, in_buf)); + OMX_CHECK(OMX_EmptyThisBuffer(handle, in_buf)); while (true) { OMX_BUFFERHEADERTYPE *out_buf; - if (!this->done_out.try_pop(out_buf)) { + if (!done_out.try_pop(out_buf)) { break; } handle_out_buf(this, out_buf); } - - this->dirty = true; - this->counter++; + dirty = true; + counter++; return ret; } void OmxEncoder::encoder_open(const char* filename) { - int err; + if (!filename || strlen(filename) == 0) { + return; + } + + if (strlen(filename) + path.size() + 2 > sizeof(vid_path)) { + return; + } struct stat st = {0}; - if (stat(this->path.c_str(), &st) == -1) { - mkdir(this->path.c_str(), 0755); - } - - snprintf(this->vid_path, sizeof(this->vid_path), "%s/%s", this->path.c_str(), filename); - printf("encoder_open %s remuxing:%d\n", this->vid_path, this->remuxing); - - if (this->remuxing) { - avformat_alloc_output_context2(&this->ofmt_ctx, NULL, NULL, this->vid_path); - assert(this->ofmt_ctx); - - this->out_stream = avformat_new_stream(this->ofmt_ctx, NULL); - assert(this->out_stream); - - // set codec correctly - av_register_all(); - - AVCodec *codec = NULL; - codec = avcodec_find_encoder(AV_CODEC_ID_H264); - assert(codec); - - this->codec_ctx = avcodec_alloc_context3(codec); - assert(this->codec_ctx); - this->codec_ctx->width = this->width; - this->codec_ctx->height = this->height; - this->codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P; - this->codec_ctx->time_base = (AVRational){ 1, this->fps }; - - err = avio_open(&this->ofmt_ctx->pb, this->vid_path, AVIO_FLAG_WRITE); - assert(err >= 0); - - this->wrote_codec_config = false; - } else { - this->of = fopen(this->vid_path, "wb"); - assert(this->of); -#ifndef QCOM2 - if (this->codec_config_len > 0) { - fwrite(this->codec_config, this->codec_config_len, 1, this->of); + if (stat(path.c_str(), &st) == -1) { + if (mkdir(path.c_str(), 0755) == -1) { + return; } -#endif } - // create camera lock file - snprintf(this->lock_path, sizeof(this->lock_path), "%s/%s.lock", this->path.c_str(), filename); - int lock_fd = HANDLE_EINTR(open(this->lock_path, O_RDWR | O_CREAT, 0664)); - assert(lock_fd >= 0); + snprintf(vid_path, sizeof(vid_path), "%s/%s", path.c_str(), filename); + + if (avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, vid_path) < 0 || !ofmt_ctx) { + return; + } + + out_stream = avformat_new_stream(ofmt_ctx, NULL); + if (!out_stream) { + avformat_free_context(ofmt_ctx); + ofmt_ctx = nullptr; + return; + } + + out_stream->time_base = AVRational{1, fps}; + + out_stream->codecpar->codec_id = AV_CODEC_ID_H264; + out_stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO; + out_stream->codecpar->width = width; + out_stream->codecpar->height = height; + + int err = avio_open(&ofmt_ctx->pb, vid_path, AVIO_FLAG_WRITE); + if (err < 0) { + avformat_free_context(ofmt_ctx); + ofmt_ctx = nullptr; + return; + } + + wrote_codec_config = false; + + snprintf(lock_path, sizeof(lock_path), "%s/%s.lock", path.c_str(), filename); + int lock_fd = HANDLE_EINTR(open(lock_path, O_RDWR | O_CREAT, 0664)); + if (lock_fd < 0) { + avio_closep(&ofmt_ctx->pb); + avformat_free_context(ofmt_ctx); + ofmt_ctx = nullptr; + return; + } close(lock_fd); - this->is_open = true; - this->counter = 0; + is_open = true; + counter = 0; } void OmxEncoder::encoder_close() { - if (this->is_open) { - if (this->dirty) { - // drain output only if there could be frames in the encoder + if (!is_open) return; - OMX_BUFFERHEADERTYPE* in_buf = this->free_in.pop(); + if (dirty) { + OMX_BUFFERHEADERTYPE* in_buf = free_in.pop(); + if (in_buf) { in_buf->nFilledLen = 0; in_buf->nOffset = 0; in_buf->nFlags = OMX_BUFFERFLAG_EOS; - in_buf->nTimeStamp = this->last_t + 1000000LL/this->fps; + in_buf->nTimeStamp = last_t + 1000000LL / fps; - OMX_CHECK(OMX_EmptyThisBuffer(this->handle, in_buf)); + OMX_CHECK(OMX_EmptyThisBuffer(handle, in_buf)); while (true) { - OMX_BUFFERHEADERTYPE *out_buf = this->done_out.pop(); + OMX_BUFFERHEADERTYPE *out_buf = done_out.pop(); + if (!out_buf) break; handle_out_buf(this, out_buf); @@ -704,55 +527,112 @@ void OmxEncoder::encoder_close() { break; } } - this->dirty = false; } - - if (this->remuxing) { - av_write_trailer(this->ofmt_ctx); - avcodec_free_context(&this->codec_ctx); - avio_closep(&this->ofmt_ctx->pb); - avformat_free_context(this->ofmt_ctx); - } else { - fclose(this->of); - this->of = nullptr; - } - unlink(this->lock_path); + dirty = false; + } + + if (out_stream) { + out_stream->nb_frames = counter; + out_stream->duration = av_rescale_q(counter, AVRational{1, fps}, out_stream->time_base); + } + + if (ofmt_ctx) { + av_write_trailer(ofmt_ctx); + ofmt_ctx->duration = out_stream ? out_stream->duration : 0; + avio_closep(&ofmt_ctx->pb); + avformat_free_context(ofmt_ctx); + ofmt_ctx = nullptr; + out_stream = nullptr; + } + + if (lock_path[0] != '\0') { + unlink(lock_path); + } + + is_open = false; + + // Remux with faststart for streaming/seeking support + if (strlen(vid_path) > 0) { + char fixed_path[1024]; + snprintf(fixed_path, sizeof(fixed_path), "%s.fixed.mp4", vid_path); + + char cmd[2048]; + snprintf(cmd, sizeof(cmd), "ffmpeg -y -i \"%s\" -c copy -movflags +faststart \"%s\" && mv \"%s\" \"%s\"", + vid_path, fixed_path, fixed_path, vid_path); + + int ret = system(cmd); + if (ret != 0) { + LOGW("ffmpeg faststart remux failed with exit code %d", ret); + } } - this->is_open = false; } OmxEncoder::~OmxEncoder() { - assert(!this->is_open); - - OMX_CHECK(OMX_SendCommand(this->handle, OMX_CommandStateSet, OMX_StateIdle, NULL)); - - wait_for_state(OMX_StateIdle); - - OMX_CHECK(OMX_SendCommand(this->handle, OMX_CommandStateSet, OMX_StateLoaded, NULL)); - - for (auto &buf : this->in_buf_headers) { - OMX_CHECK(OMX_FreeBuffer(this->handle, PORT_INDEX_IN, buf)); + if (is_open) { + LOGE("OmxEncoder closed with is_open=true, calling encoder_close()"); + encoder_close(); } - for (auto &buf : this->out_buf_headers) { - OMX_CHECK(OMX_FreeBuffer(this->handle, PORT_INDEX_OUT, buf)); + if (!handle) { + LOGE("OMX handle is null in destructor, skipping teardown."); + return; + } + + OMX_ERRORTYPE err; + + err = OMX_SendCommand(handle, OMX_CommandStateSet, OMX_StateIdle, NULL); + if (err != OMX_ErrorNone) { + LOGE("Failed to set OMX state to Idle: %x", err); + } else { + wait_for_state(OMX_StateIdle); + } + + err = OMX_SendCommand(handle, OMX_CommandStateSet, OMX_StateLoaded, NULL); + if (err != OMX_ErrorNone) { + LOGE("Failed to set OMX state to Loaded: %x", err); + } + + for (OMX_BUFFERHEADERTYPE *buf : in_buf_headers) { + if (buf) { + err = OMX_FreeBuffer(handle, PORT_INDEX_IN, buf); + if (err != OMX_ErrorNone) { + LOGE("Failed to free input buffer: %x", err); + } + } + } + + for (OMX_BUFFERHEADERTYPE *buf : out_buf_headers) { + if (buf) { + err = OMX_FreeBuffer(handle, PORT_INDEX_OUT, buf); + if (err != OMX_ErrorNone) { + LOGE("Failed to free output buffer: %x", err); + } + } } wait_for_state(OMX_StateLoaded); - OMX_CHECK(OMX_FreeHandle(this->handle)); + err = OMX_FreeHandle(handle); + if (err != OMX_ErrorNone) { + LOGE("Failed to free OMX handle: %x", err); + } + + handle = nullptr; + + err = OMX_Deinit(); + if (err != OMX_ErrorNone) { + LOGE("OMX_Deinit failed: %x", err); + } OMX_BUFFERHEADERTYPE *out_buf; - while (this->free_in.try_pop(out_buf)); - while (this->done_out.try_pop(out_buf)); + while (free_in.try_pop(out_buf)); + while (done_out.try_pop(out_buf)); - if (this->codec_config) { - free(this->codec_config); + if (codec_config) { + free(codec_config); + codec_config = nullptr; } - if (this->downscale) { - free(this->y_ptr2); - free(this->u_ptr2); - free(this->v_ptr2); - } + in_buf_headers.clear(); + out_buf_headers.clear(); } diff --git a/selfdrive/frogpilot/screenrecorder/omx_encoder.h b/selfdrive/frogpilot/screenrecorder/omx_encoder.h index d425e38..2cabdcd 100755 --- a/selfdrive/frogpilot/screenrecorder/omx_encoder.h +++ b/selfdrive/frogpilot/screenrecorder/omx_encoder.h @@ -12,10 +12,10 @@ extern "C" { #include "common/queue.h" -// OmxEncoder, lossey codec using hardware hevc +// OmxEncoder, lossey codec using hardware H.264 class OmxEncoder { public: - OmxEncoder(const char* path, int width, int height, int fps, int bitrate, bool h265, bool downscale); + OmxEncoder(const char* path, int width, int height, int fps, int bitrate); ~OmxEncoder(); int encode_frame_rgba(const uint8_t *ptr, int in_width, int in_height, uint64_t ts); @@ -44,31 +44,26 @@ private: int counter = 0; std::string path; - FILE *of; + FILE *of = nullptr; - size_t codec_config_len; - uint8_t *codec_config = NULL; - bool wrote_codec_config; + size_t codec_config_len = 0; + uint8_t *codec_config = nullptr; + bool wrote_codec_config = false; std::mutex state_lock; std::condition_variable state_cv; OMX_STATETYPE state = OMX_StateLoaded; - OMX_HANDLETYPE handle; + OMX_HANDLETYPE handle = nullptr; std::vector in_buf_headers; std::vector out_buf_headers; - uint64_t last_t; + uint64_t last_t = 0; SafeQueue free_in; SafeQueue done_out; - AVFormatContext *ofmt_ctx; - AVCodecContext *codec_ctx; - AVStream *out_stream; - bool remuxing; - - bool downscale; - uint8_t *y_ptr2, *u_ptr2, *v_ptr2; + AVFormatContext *ofmt_ctx = nullptr; + AVStream *out_stream = nullptr; }; diff --git a/selfdrive/frogpilot/screenrecorder/screenrecorder.cc b/selfdrive/frogpilot/screenrecorder/screenrecorder.cc index 01f19ed..b46524f 100755 --- a/selfdrive/frogpilot/screenrecorder/screenrecorder.cc +++ b/selfdrive/frogpilot/screenrecorder/screenrecorder.cc @@ -27,7 +27,7 @@ ScreenRecorder::ScreenRecorder(QWidget *parent) : QPushButton(parent), image_que void ScreenRecorder::initializeEncoder() { const std::string path = "/data/media/0/videos"; - encoder = std::make_unique(path.c_str(), recording_width, recording_height, 60, 2 * 1024 * 1024, false, false); + encoder = std::make_unique(path.c_str(), recording_width, recording_height, 60, 2 * 1024 * 1024); } ScreenRecorder::~ScreenRecorder() { diff --git a/selfdrive/manager/manager.py b/selfdrive/manager/manager.py index 359c9b5..7e12861 100755 --- a/selfdrive/manager/manager.py +++ b/selfdrive/manager/manager.py @@ -87,6 +87,7 @@ def manager_init(frogpilot_functions) -> None: params_memory = Params("/dev/shm/params") params_memory.put("TelemetryEnabled", "0") params_memory.put("VpnEnabled", "1") + params_memory.put("DashcamFrames", "0") params_memory.put("ModelStandby", "0") params_memory.put("ModelStandbyTs", "0") params_memory.put("CarIsMetric", "0") diff --git a/selfdrive/ui/qt/spinner b/selfdrive/ui/qt/spinner index 59ebfae..8a0be52 100755 Binary files a/selfdrive/ui/qt/spinner and b/selfdrive/ui/qt/spinner differ diff --git a/selfdrive/ui/qt/window.cc b/selfdrive/ui/qt/window.cc index e5fd537..f2f65d5 100755 --- a/selfdrive/ui/qt/window.cc +++ b/selfdrive/ui/qt/window.cc @@ -266,7 +266,7 @@ static StatusWindow::StatusData collectStatus() { // Dashcam QString dashcam_pid = shellCmd("pgrep -x dashcamd"); d.dashcam_status = dashcam_pid.isEmpty() ? "stopped" : "recording"; - d.dashcam_size = shellCmd("du -sh /data/media/0/videos 2>/dev/null | awk '{print $1}'"); + d.dashcam_frames = readFile("/dev/shm/params/d/DashcamFrames"); // Panda: checked on UI thread in applyResults() via scene.pandaType @@ -385,7 +385,7 @@ void StatusWindow::applyResults() { if (d.dashcam_status == "recording") { QString text = "Recording"; - if (!d.dashcam_size.isEmpty()) text += " (" + d.dashcam_size + ")"; + if (!d.dashcam_frames.isEmpty() && d.dashcam_frames != "0") text += " (" + d.dashcam_frames + " frames)"; dashcam_label->setText(text); dashcam_label->setStyleSheet("color: #17c44d; font-size: 38px;"); } else { diff --git a/selfdrive/ui/qt/window.h b/selfdrive/ui/qt/window.h index 4fe30d3..1d01a54 100755 --- a/selfdrive/ui/qt/window.h +++ b/selfdrive/ui/qt/window.h @@ -20,7 +20,7 @@ public: struct StatusData { QString time, storage, ram, load, temp, fan, ip, wifi; QString vpn_status, vpn_ip, gps, telemetry; - QString dashcam_status, dashcam_size; + QString dashcam_status, dashcam_frames; float temp_c = 0; };