ファンレスで動くエッジAIアクセラレーターによるリアルタイム物体検出（YOLOv8ｍ）

$ ./build/object_detection --list-nets
No --net was provided.
Fetching networks list... please wait

Supported networks for object_detection:
  - yolov10b         | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov10b.hef] | desc=YOLOv10b
  - yolov10n         | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov10n.hef] | desc=YOLOv10n
  - yolov10s         | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov10s.hef] | desc=YOLOv10s
  - yolov10x         | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov10x.hef] | desc=YOLOv10x
  - yolov11l         | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov11l.hef] | desc=YOLOv11l
  - yolov11m         | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov11m.hef] | desc=YOLOv11m
  - yolov11n         | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov11n.hef] | desc=YOLOv11n
  - yolov11s         | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov11s.hef] | desc=YOLOv11s
  - yolov11x         | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov11x.hef] | desc=YOLOv11x
  - yolov5m          | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov5m.hef ] | desc=YOLOv5m
  - yolov5s          | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov5s.hef ] | desc=YOLOv5s
  - yolov6n          | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov6n.hef ] | desc=YOLOv6n
  - yolov7           | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov7.hef  ] | desc=YOLOv7
  - yolov7x          | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov7x.hef ] | desc=YOLOv7x
  - yolov8l          | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov8l.hef ] | desc=YOLOv8l
  - yolov8m          | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov8m.hef ] | desc=YOLOv8m
  - yolov8n          | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov8n.hef ] | desc=YOLOv8n
  - yolov8s          | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov8s.hef ] | desc=YOLOv8s
  - yolov8x          | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov8x.hef ] | desc=YOLOv8x
  - yolov9c          | arch=[hailo8,hailo8l,hailo10h] | src=model_zoo   | hefs=[yolov9c.hef ] | desc=YOLOv9c

# hailo-apps/hailo_apps/cpp/object_detectionから実行します
$ ../../config/get_hef.sh get --app object_detection --net yolov8m --hw-arch hailo8 --dest .

$ hailortcli benchmark yolov8m.hef
Starting Measurements...
Measuring FPS in HW-only mode
Network yolov8m/yolov8m: 100% | 794 | FPS: 52.91 | ETA: 00:00:00
Measuring FPS (and Power on supported platforms) in streaming mode
[HailoRT] [warning] Using the overcurrent protection dvm for power measurement will disable the overcurrent protection.
If only taking one measurement, the protection will resume automatically.
If doing continuous measurement, to enable overcurrent protection again you have to stop the power measurement on this dvm.
Network yolov8m/yolov8m: 100% | 794 | FPS: 52.82 | ETA: 00:00:00
Measuring HW Latency
Network yolov8m/yolov8m: 100% | 494 | HW Latency: 15.77 ms | ETA: 00:00:00

=======
Summary
=======
FPS     (hw_only)                 = 52.9069
        (streaming)               = 52.8196
Latency (hw)                      = 15.77 ms
Device 0000:01:00.0:
  Power in streaming mode (average) = 2.81216 W
                          (max)     = 2.87292 W

# hailo-apps/hailo_apps/cpp/object_detectionから実行します
$ ../../config/get_input.sh list --app object_detection
images:
name="bus"                  | description="Bus with walking people"
name="dog_bicycle"          | description="dog and a bicycle outdoor"
name="zidane"               | description="Zidane and Carlo Ancelotti Italian football manager"

videos:
name="cars"                 | description="drive in the city"

$ ../../config/get_input.sh get --app object_detection --i cars --target-dir .

$ ./build/object_detection --net yolov8m.hef --input full_mov_slow.mp4

/**
  * HDMI入力のためにGStreamerパイプラインを初期化します
  */
static InputType get_hdmi_input(const std::string &input_path,
                                cv::VideoCapture &capture,
                                double &org_height,
                                double &org_width,
                                size_t &frame_count,
                                size_t batch_size,
                                const std::string &camera_resolution)
{
    InputType input_type;
    input_type.is_video = true;

    // 入力は/dev/video0に固定
    if (input_path != "/dev/video0")
    {
        throw std::runtime_error("Unsupported input device: " + input_path + ".  If you use --rock5b-hdmi-in, set --input to /dev/video0 ");
    }

    // GStreamerパイプライン（デバイスのサポートフォーマットを自動検出）
    // 複数のフォーマットを試す（NV12, YUY2, UYVY, MJPEGなど）
    std::vector<std::pair<std::string, std::string>> format_candidates = {
        {"video/x-raw,format=NV12", "NV12"}, // NV12フォーマット
        {"video/x-raw,format=YUY2", "YUY2"}, // YUY2フォーマット
        {"video/x-raw,format=UYVY", "UYVY"}, // UYVYフォーマット
        {"video/x-raw", "auto-detect"}       // フォーマット指定なし（自動検出）
    };

    // 色変換マトリクスの設定
    // GStreamerのmatrix-coefficients: 0=Identity, 1=BT.709, 2=BT.601, 3=BT.
    // matrix_param = ""の場合は自動判別
    // HDで標準的なBT.709を設定しておきます
    std::string matrix_param = ",matrix-coefficients=1";

    bool opened = false;
    std::string successful_format;
    for (const auto &[format, format_name] : format_candidates)
    {
        // 各試行の前にcaptureをリセット
        capture.release();

        std::ostringstream pipeline;
        // その他のフォーマット
        pipeline << "v4l2src device=/dev/video0 io-mode=mmap ! "
                  << format << " ! "
                  << "videoscale ! video/x-raw,width=1920,height=1080" << matrix_param << " ! "
                  << "videoconvert ! video/x-raw,format=BGR ! "
                  << "appsink drop=true sync=false max-buffers=2";

        capture.open(pipeline.str(), cv::CAP_GSTREAMER);
        if (capture.isOpened())
        {
            opened = true;
            successful_format = format_name;
            break;
        }
    }

    if (!opened)
    {
        throw std::runtime_error("Unable to open HDMI input via GStreamer: " + input_path +
                                  " (tried multiple formats: NV12, YUY2, UYVY, MJPEG, auto-detect)");
    }

    // 成功したフォーマットを表示（警告が表示されても正常に動作していることを示す）
    std::cout << "-I- HDMI input opened successfully using format: " << successful_format << std::endl;
    // HDMI入力の解像度は固定（1920x1080）
    org_width = 1920;
    org_height = 1080;
    frame_count = 0; // カメラと同様にフレーム数は不明

    return input_type;
}

-    post_parse_args(APP_NAME, args, argc, argv);
-    HailoInfer model(args.net, args.batch_size);
-    input_type = determine_input_type(args.input,
-                                      std::ref(capture),
-                                      std::ref(org_height),
-                                      std::ref(org_width),
-                                      std::ref(frame_count),
-                                      std::ref(args.batch_size),
-                                      std::ref(args.camera_resolution));

+    // --rock5b-hdmi-inオプションが指定された場合は/dev/video0からのキャプチャ設定を行う
+    if (has_flag(argc, argv, "--rock5b-hdmi-in"))
+    {
+        // HDMI入力時はpost_parse_args(), determine_input_type()を利用しません。
+        input_type = get_hdmi_input(args.input,
+                                    std::ref(capture),
+                                    std::ref(org_height),
+                                    std::ref(org_width),
+                                    std::ref(frame_count),
+                                    std::ref(args.batch_size),
+                                    std::ref(args.camera_resolution));
+    }
+    else
+    {
+        // 通常の処理（ファイル、USBカメラなど）
+        post_parse_args(APP_NAME, args, argc, argv);
+        input_type = determine_input_type(args.input,
+                                          std::ref(capture),
+                                          std::ref(org_height),
+                                          std::ref(org_width),
+                                          std::ref(frame_count),
+                                          std::ref(args.batch_size),
+                                          std::ref(args.camera_resolution));
+    }
+    HailoInfer model(args.net, args.batch_size);