Release Vulpes OS 2.7-preview.24

tundra/probes/beatles-camera-worker.cpp

@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: MPL-2.0
+// CameraService worker for the Nokia 2720 Flip. The parent broker drops this
+// process to Android's camera UID before exec. Gaia talks to it over a local
+// socket; it never receives Binder or elevated credentials.
+#include <camera/Camera.h>
+#include <camera/CameraParameters.h>
+#include <binder/ProcessState.h>
+#include <gui/BufferQueue.h>
+#include <gui/CpuConsumer.h>
+#include <gui/GraphicBufferAlloc.h>
+#include <hardware/gralloc.h>
+#include <utils/Timers.h>
+#include <utils/Mutex.h>
+#include <utils/String8.h>
+#include <utils/String16.h>
+#include <condition_variable>
+#include <chrono>
+#include <atomic>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+#include <unistd.h>
+#include <sys/socket.h>
+
+namespace {
+bool write_all(int fd, const void *data, size_t size) {
+  const char *p = static_cast<const char *>(data);
+  while (size) {
+    ssize_t n = write(fd, p, size);
+    if (n <= 0) return false;
+    p += n; size -= static_cast<size_t>(n);
+  }
+  return true;
+}
+bool read_line(int fd, std::string *line) {
+  line->clear();
+  char c;
+  while (line->size() < 2048) {
+    ssize_t n = read(fd, &c, 1);
+    if (n <= 0) return false;
+    if (c == '\n') return true;
+    line->push_back(c);
+  }
+  return false;
+}
+bool send_json(int fd, const std::string &json, bool frame=false,
+               uint32_t sequence=0, const std::vector<uint8_t> *bytes=nullptr) {
+  uint32_t length = static_cast<uint32_t>(json.size());
+  if (frame) {
+    uint32_t header[2] = {sequence, bytes ? static_cast<uint32_t>(bytes->size()) : 0};
+    return write_all(fd, header, sizeof(header)) && (!bytes || write_all(fd,bytes->data(),bytes->size()));
+  }
+  return write_all(fd,&length,sizeof(length)) && write_all(fd,json.data(),json.size());
+}
+
+class CameraWorker : public android::CameraListener {
+ public:
+  explicit CameraWorker(int fd) : fd_(fd), camera_id_(0), sequence_(0), stopping_(false) {}
+  void notify(int32_t type, int32_t first, int32_t second) override {
+    fprintf(stderr,"camera notify type=%d first=%d second=%d\n",type,first,second);
+  }
+  void postData(int32_t type, const android::sp<android::IMemory> &data,
+                camera_frame_metadata_t *) override {
+    if (data == nullptr) return;
+    if (type == CAMERA_MSG_COMPRESSED_IMAGE) {
+      std::lock_guard<std::mutex> lock(mutex_);
+      jpeg_.assign(static_cast<const uint8_t *>(data->pointer()),
+                   static_cast<const uint8_t *>(data->pointer()) + data->size());
+      ready_.notify_all();
+      return;
+    }
+    if (type != CAMERA_MSG_PREVIEW_FRAME) return;
+    const size_t expected = 320u * 240u * 3u / 2u;
+    if (data->size() < expected) return;
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      frame_.assign(static_cast<const uint8_t *>(data->pointer()),
+                    static_cast<const uint8_t *>(data->pointer()) + expected);
+      ++sequence_;
+      if(sequence_==1) fprintf(stderr,"camera first frame bytes=%zu uid=%d\n",frame_.size(),getuid());
+    }
+    ready_.notify_all();
+  }
+  void postDataTimestamp(nsecs_t, int32_t,
+                         const android::sp<android::IMemory> &) override {}
+
+  int run() {
+    android::ProcessState::self()->startThreadPool();
+    std::string line;
+    while (read_line(fd_, &line)) {
+      if (line == "start" || line == "start 0") {
+        if (!start()) { send_json(fd_,"{\"ready\":false,\"error\":\"CAMERA_START_FAILED\"}"); continue; }
+        if (!send_json(fd_,"{\"ready\":true,\"width\":320,\"height\":240,\"format\":\"nv21\",\"orientation\":270,\"flashModes\":[\"off\",\"auto\",\"on\",\"torch\"],\"pictureSizes\":[{\"width\":1600,\"height\":1200}],\"focusModes\":[\"fixed\"],\"maxFocusAreas\":0,\"zoomRatios\":[1] }")) return 1;
+      } else if (line == "frame") {
+        std::vector<uint8_t> frame;
+        uint32_t seq;
+        {
+          std::unique_lock<std::mutex> lock(mutex_);
+          const uint32_t previous = delivered_;
+          ready_.wait_for(lock,std::chrono::seconds(2),[&]{return sequence_>previous || stopping_;});
+          if (sequence_<=previous || frame_.empty()) { if(!send_json(fd_,"",true,sequence_,nullptr)) return 1; continue; }
+          seq=sequence_; delivered_=seq; frame=frame_;
+        }
+        if (!send_json(fd_,"",true,seq,&frame)) return 1;
+      } else if (line == "stop") {
+        stop(); send_json(fd_,"{\"ok\":true}"); return 0;
+      } else if (line.find("\"action\":\"flash\"") != std::string::npos) {
+        const size_t key=line.find("\"mode\":\"");
+        const size_t begin=key==std::string::npos?key:key+8;
+        const size_t end=begin==std::string::npos?begin:line.find('"',begin);
+        if(begin==std::string::npos || end==std::string::npos) {
+          send_json(fd_,"{\"ok\":false,\"error\":\"CAMERA_INVALID_FLASH_MODE\"}");continue;
+        }
+        const std::string mode=line.substr(begin,end-begin);
+        android::CameraParameters params(camera_->getParameters());
+        params.set(android::CameraParameters::KEY_FLASH_MODE,mode.c_str());
+        const android::status_t status=camera_->setParameters(params.flatten());
+        if(status==android::NO_ERROR) {
+          camera_->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_CAMERA);
+          camera_->startPreview();
+          send_json(fd_,"{\"ok\":true,\"result\":true}");
+        }
+        else send_json(fd_,"{\"ok\":false,\"error\":\"CAMERA_FLASH_UNAVAILABLE\"}");
+      } else if (line.find("\"action\":\"zoom\"") != std::string::npos) {
+        // This module reports a single zoom ratio (1x), so expose a stable
+        // no-op instead of asking Camera1 to select an unsupported index.
+        send_json(fd_,"{\"ok\":true,\"result\":{\"zoom\":1}}");
+      } else if (line.find("\"action\":\"picture\"") != std::string::npos) {
+        { std::lock_guard<std::mutex> lock(mutex_); jpeg_.clear(); }
+        const android::status_t status=camera_->takePicture(CAMERA_MSG_COMPRESSED_IMAGE);
+        std::vector<uint8_t> jpeg;
+        {
+          std::unique_lock<std::mutex> lock(mutex_);
+          ready_.wait_for(lock,std::chrono::seconds(12),[&]{return !jpeg_.empty() || stopping_;});
+          jpeg=jpeg_;
+        }
+        camera_->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_CAMERA);
+        camera_->startPreview();
+        if(status!=android::NO_ERROR || jpeg.empty()) {
+          send_json(fd_,"{\"ok\":false,\"error\":\"CAMERA_CAPTURE_FAILED\"}");continue;
+        }
+        char reply[128];
+        std::snprintf(reply,sizeof(reply),"{\"ok\":true,\"jpegLength\":%zu}",jpeg.size());
+        if(!send_json(fd_,reply) || !write_all(fd_,jpeg.data(),jpeg.size())) return 1;
+      } else {
+        send_json(fd_,"{\"ok\":false,\"error\":\"CAMERA_UNSUPPORTED_COMMAND\"}");
+      }
+    }
+    stop(); return 0;
+  }
+
+ private:
+  bool start() {
+    if (camera_.get() != nullptr) stop();
+    fprintf(stderr,"camera count=%d uid=%d\n",android::Camera::getNumberOfCameras(),getuid());
+    camera_ = android::Camera::connect(camera_id_,android::String16("gonk.camera"),android::Camera::USE_CALLING_UID);
+    if (camera_.get() == nullptr) {fprintf(stderr,"camera connect failed\n");return false;}
+    android::CameraParameters params(camera_->getParameters());
+    params.setPreviewSize(320,240); params.setPictureSize(1600,1200);
+    params.setPreviewFormat("yuv420sp"); params.set("recording-hint","false");
+    android::status_t status=camera_->setParameters(params.flatten());
+    fprintf(stderr,"camera set parameters=%d\n",status);
+    if (status != android::NO_ERROR) { stop(); return false; }
+    android::sp<android::IGraphicBufferProducer> producer;
+    android::sp<android::IGraphicBufferConsumer> consumer;
+    android::sp<android::GraphicBufferAlloc> allocator = new android::GraphicBufferAlloc();
+    android::BufferQueue::createBufferQueue(&producer,&consumer,allocator);
+    consumer->setConsumerUsageBits(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER);
+    consumer->setDefaultBufferSize(320,240);
+    consumer_ = new android::CpuConsumer(consumer,4);
+    consumer_->setName(android::String8("Vulpes Camera"));
+    status=camera_->setPreviewTarget(producer);
+    fprintf(stderr,"camera set target=%d\n",status);
+    if (status != android::NO_ERROR) { stop(); return false; }
+    camera_->setListener(this);
+    // The broker consumes copied Camera1 preview frames rather than video metadata.
+    camera_->setPreviewCallbackFlags(CAMERA_FRAME_CALLBACK_FLAG_CAMERA);
+    status=camera_->startPreview(); fprintf(stderr,"camera start preview=%d\n",status);
+    if (status != android::NO_ERROR) { stop(); return false; }
+    stopping_=false; delivered_=sequence_;
+    consumer_thread_=std::thread([this]{
+      while(!stopping_) {
+        android::CpuConsumer::LockedBuffer buffer;
+        if(consumer_->lockNextBuffer(&buffer)==android::NO_ERROR) consumer_->unlockBuffer(buffer);
+        else usleep(10000);
+      }
+    });
+    return true;
+  }
+  void stop() {
+    { std::lock_guard<std::mutex> lock(mutex_); stopping_=true; }
+    ready_.notify_all();
+    if (camera_.get() != nullptr) { camera_->stopPreview(); camera_->disconnect(); camera_.clear(); }
+    if(consumer_thread_.joinable()) consumer_thread_.join();
+    consumer_.clear();
+  }
+  int fd_; int camera_id_;
+  android::sp<android::Camera> camera_;
+  android::sp<android::CpuConsumer> consumer_;
+  std::mutex mutex_; std::condition_variable ready_;
+  std::thread consumer_thread_;
+  std::vector<uint8_t> frame_, jpeg_; uint32_t sequence_, delivered_; std::atomic<bool> stopping_;
+};
+}
+
+int main() {
+  setvbuf(stderr,nullptr,_IONBF,0);
+  android::sp<CameraWorker> worker = new CameraWorker(STDIN_FILENO);
+  return worker->run();
+}