[feat] add native Android controller

apps/android/native/tests/video_pipeline_test.cpp

@@ -0,0 +1,84 @@
+#include "latest_frame_worker.h"
+#include "video_timing.h"
+#include "video_picture.h"
+#include <cassert>
+#include <chrono>
+#include <future>
+#include <memory>
+#include <vector>
+
+int main() {
+  using namespace crossdesk::android_controller;
+  using namespace std::chrono_literals;
+  assert(VideoLatencyMilliseconds(1'000'000, 1'020'000, 1'050'000) == 50);
+  // Reproduce a valid frame delayed in the local decode/Surface queue.
+  // The old submission-time five-second cutoff hid both of these samples.
+  assert(VideoLatencyMilliseconds(1'000'000, 1'020'000, 7'000'000) == 6000);
+  assert(VideoLatencyMilliseconds(1'000'000, 1'020'000, 31'000'000) == 30000);
+  assert(VideoLatencyMilliseconds(0, 1'020'000, 7'000'000) < 0);
+  assert(VideoLatencyMilliseconds(1'030'000, 1'020'000, 7'000'000) < 0);
+  assert(VideoLatencyMilliseconds(1'000'000, 6'000'001, 7'000'000) < 0);
+  assert(VideoLatencyMilliseconds(1'000'000, 1'020'000, 1'010'000) < 0);
+  assert(VideoLatencyMilliseconds(1'000'000, 1'020'000, -1) < 0);
+
+  struct Owner { int references = 1; uint8_t pixels[12]{}; } owner;
+  MiniRtcNativeVideoFrame native{};
+  native.struct_size = sizeof(native); native.type = MiniRtcNativeVideoFrameCpuNv12;
+  native.width = native.height = 2; native.owner = &owner;
+  native.retain = [](void* p) { ++static_cast<Owner*>(p)->references; };
+  native.release = [](void* p) { --static_cast<Owner*>(p)->references; };
+  native.payload.cpu_nv12 = {owner.pixels, owner.pixels + 8, 4, 4};
+  MiniRtcVideoFrame source{}; source.width = source.height = 2;
+  source.native_frame = &native; source.captured_timestamp = 100; source.received_timestamp = 120;
+  {
+    auto retained = VideoPicture::RetainOrCopy(source, 3);
+    assert(retained && owner.references == 2 && retained->pixels.empty());
+    assert(retained->Y() == owner.pixels && retained->UV() == owner.pixels + 8);
+    assert(retained->YStride() == 4 && retained->UVStride() == 4);
+    assert(retained->captured_us == 100 && retained->received_us == 120 && retained->generation == 3);
+    auto moved = std::move(*retained); retained.reset(); assert(owner.references == 2);
+  }
+  assert(owner.references == 1);
+  uint8_t borrowed[6]{1, 2, 3, 4, 5, 6};
+  source.native_frame = nullptr; source.data = reinterpret_cast<const char*>(borrowed); source.size = 6;
+  auto copied = VideoPicture::RetainOrCopy(source, 4); borrowed[0] = 0;
+  assert(copied && copied->Y()[0] == 1 && copied->UV()[0] == 5 && copied->YStride() == 2);
+  source.size = 5; assert(!VideoPicture::RetainOrCopy(source, 4));
+  source.width = 3; assert(!VideoPicture::RetainOrCopy(source, 4));
+
+  std::promise<void> started, release, finished;
+  auto released = release.get_future();
+  std::vector<int> rendered;
+  LatestFrameWorker<std::unique_ptr<int>> worker([&](std::unique_ptr<int> value) {
+    rendered.push_back(*value);
+    if (*value == 1) { started.set_value(); released.wait(); }
+    if (*value == 4) finished.set_value();
+  });
+  assert(worker.Submit(std::make_unique<int>(1)));
+  assert(started.get_future().wait_for(2s) == std::future_status::ready);
+  // A blocked Surface must not block frame submission; obsolete frames 2/3
+  // must not be displayed after it recovers, even with move-only ownership.
+  assert(worker.Submit(std::make_unique<int>(2)));
+  assert(worker.Submit(std::make_unique<int>(3)));
+  assert(worker.Submit(std::make_unique<int>(4)));
+  release.set_value();
+  assert(finished.get_future().wait_for(2s) == std::future_status::ready);
+  worker.Stop();
+  assert((rendered == std::vector<int>{1, 4}));
+  assert(!worker.Submit(std::make_unique<int>(5)));
+  worker.Stop();
+
+  std::promise<void> first_started, first_release;
+  auto first_released = first_release.get_future();
+  int count = 0;
+  LatestFrameWorker<int> cleared([&](int value) {
+    ++count; assert(value == 1); first_started.set_value(); first_released.wait();
+  });
+  cleared.Submit(1);
+  assert(first_started.get_future().wait_for(2s) == std::future_status::ready);
+  cleared.Submit(2);
+  cleared.Clear(); // Surface replacement/display switch discards pending pixels.
+  first_release.set_value();
+  cleared.Stop();
+  assert(count == 1);
+}