Accelerate decoding

constants/camera_constants.json

@@ -25,6 +25,7 @@
       "frame_width": 1280,
       "frame_height": 800,
       "fps": 100.0,
+      "serial_id": "devorin",
       "max_payload_size": 1024,
       "stream_ratio": 0.5,
       "port": 5801,

scripts/build.sh

@@ -21,6 +21,13 @@ else
   BUILD_DIR="${NAME}-build"
 fi
 
-git submodule update --init --progress --depth 1
+if [ "$(pwd)" != "/bos" ]; then
+  mkdir -p /bos/constants 2>/dev/null || sudo mkdir -p /bos/constants
+  if [ -w /bos ]; then
+    cp -r constants/. /bos/constants
+  else
+    sudo cp -r constants/. /bos/constants
+  fi
+fi
 cmake -Wno-dev -DENABLE_CLANG_TIDY=OFF -DCMAKE_BUILD_TYPE=Release -B "$BUILD_DIR" -G Ninja .
 cmake --build "$BUILD_DIR"

src/camera/CMakeLists.txt

@@ -65,6 +65,15 @@ target_link_libraries(MultiCameraSource PRIVATE
   utils
 )
 
+find_library(NVJPEG_LIBRARY
+  NAMES nvjpeg
+  PATHS
+    /usr/lib/aarch64-linux-gnu/tegra
+    /usr/lib/aarch64-linux-gnu
+    /usr/lib
+  REQUIRED
+)
+
 add_library(UVCCamera)
 target_sources(UVCCamera
   PRIVATE
@@ -74,6 +83,20 @@ target_link_libraries(UVCCamera PRIVATE
   uvc
   absl::status
   utils
+  ${NVJPEG_LIBRARY}
+)
+set(JETSON_API /usr/src/jetson_multimedia_api)
+target_sources(UVCCamera PRIVATE
+    ${JETSON_API}/samples/common/classes/NvJpegDecoder.cpp
+    ${JETSON_API}/samples/common/classes/NvBuffer.cpp
+    ${JETSON_API}/samples/common/classes/NvElement.cpp
+    ${JETSON_API}/samples/common/classes/NvElementProfiler.cpp
+    ${JETSON_API}/samples/common/classes/NvLogging.cpp
+)
+target_include_directories(UVCCamera PRIVATE
+    ${JETSON_API}/include
+    ${JETSON_API}/include/libjpeg-8b
+    ${JETSON_API}/samples/common/classes
 )
 
 add_library(camera INTERFACE)

src/camera/camera_constants.cc

@@ -1,15 +1,32 @@
 #include "src/camera/camera_constants.h"
+#include <filesystem>
 #include <optional>
 #include "absl/flags/flag.h"
 
 ABSL_FLAG(std::string, camera_constants_path,            // NOLINT
           "/bos/constants/camera_constants.json",        // NOTLINT
           "Path to the json file of camera constants");  //NOLINT
 
+namespace {
+constexpr std::string_view kDefaultCameraConstantsPath =
+    "/bos/constants/camera_constants.json";
+constexpr std::string_view kLocalCameraConstantsPath =
+    "constants/camera_constants.json";
+
+auto ResolveCameraConstantsPath(const std::string& path) -> std::string {
+  if (path == kDefaultCameraConstantsPath &&
+      std::filesystem::exists(kLocalCameraConstantsPath)) {
+    return std::string(kLocalCameraConstantsPath);
+  }
+  return path;
+}
+}  // namespace
+
 namespace camera {
 
 auto GetCameraConstants() -> camera_constants_t {
-  return GetCameraConstants(absl::GetFlag(FLAGS_camera_constants_path));
+  return GetCameraConstants(
+      ResolveCameraConstantsPath(absl::GetFlag(FLAGS_camera_constants_path)));
 }
 
 template <typename T>

src/camera/cscore_streamer.cc

@@ -1,6 +1,36 @@
 #include "cscore_streamer.h"
 namespace camera {
 
+auto NormalizeForStreaming(const cv::Mat& mat) -> cv::Mat {
+  if (mat.empty()) {
+    return {};
+  }
+
+  switch (mat.channels()) {
+    case 1: {
+      cv::Mat bgr;
+      cv::cvtColor(mat, bgr, cv::COLOR_GRAY2BGR);
+      return bgr;
+    }
+    case 2: {
+      cv::Mat bgr;
+      cv::cvtColor(mat, bgr, cv::COLOR_YUV2BGR_YUY2);
+      return bgr;
+    }
+    case 3:
+      return mat;
+    case 4: {
+      cv::Mat bgr;
+      cv::cvtColor(mat, bgr, cv::COLOR_BGRA2BGR);
+      return bgr;
+    }
+    default:
+      std::cerr << "Unsupported frame channel count for CSCore: "
+                << mat.channels();
+      return {};
+  }
+}
+
 CscoreStreamer::CscoreStreamer(const std::string& name, uint port, uint fps,
                                uint width, uint height, bool verbose)
     : width_(width), height_(height) {
@@ -25,11 +55,17 @@ CscoreStreamer::CscoreStreamer(const std::string& name, uint port, uint fps,
                      verbose) {}
 
 void CscoreStreamer::WriteFrame(const cv::Mat& mat) {
-  cv::Mat frame;
-  cv::resize(mat, frame, cv::Size(width_, height_));
-  if (frame.channels() == 4) {
-    cv::cvtColor(frame, frame, cv::COLOR_BGRA2BGR);
+  std::cout << "WRITING FRAME";
+  cv::Mat normalized = NormalizeForStreaming(mat);
+  if (normalized.empty()) {
+    return;
   }
+
+  cv::Mat frame;
+  cv::resize(normalized, frame, cv::Size(width_, height_));
   source_.PutFrame(frame);
+  std::cout << "WROTE FRAME";
+  std::this_thread::sleep_for(std::chrono::duration<double>(1));
+  std::cout << "End sleep";
 }
 }  // namespace camera