ui: use YUV vipc stream

selfdrive/ui/qt/offroad/driverview.cc

@@ -12,7 +12,7 @@ DriverViewWindow::DriverViewWindow(QWidget* parent) : QWidget(parent) {
   layout = new QStackedLayout(this);
   layout->setStackingMode(QStackedLayout::StackAll);
 
-  cameraView = new CameraViewWidget("camerad", VISION_STREAM_RGB_FRONT, true, this);
+  cameraView = new CameraViewWidget("camerad", VISION_STREAM_DRIVER, true, this);
   layout->addWidget(cameraView);
 
   scene = new DriverViewScene(this);

selfdrive/ui/qt/onroad.cc

@@ -5,6 +5,7 @@
 #include <QDebug>
 
 #include "selfdrive/common/timing.h"
+#include "selfdrive/common/swaglog.h"
 #include "selfdrive/ui/qt/util.h"
 #ifdef ENABLE_MAPS
 #include "selfdrive/ui/qt/maps/map.h"
@@ -20,7 +21,7 @@ OnroadWindow::OnroadWindow(QWidget *parent) : QWidget(parent) {
 
   QStackedLayout *road_view_layout = new QStackedLayout;
   road_view_layout->setStackingMode(QStackedLayout::StackAll);
-  nvg = new NvgWindow(VISION_STREAM_RGB_BACK, this);
+  nvg = new NvgWindow(VISION_STREAM_ROAD, this);
   road_view_layout->addWidget(nvg);
   hud = new OnroadHud(this);
   road_view_layout->addWidget(hud);
@@ -91,7 +92,7 @@ void OnroadWindow::offroadTransition(bool offroad) {
 
   // update stream type
   bool wide_cam = Hardware::TICI() && Params().getBool("EnableWideCamera");
-  nvg->setStreamType(wide_cam ? VISION_STREAM_RGB_WIDE : VISION_STREAM_RGB_BACK);
+  nvg->setStreamType(wide_cam ? VISION_STREAM_WIDE_ROAD : VISION_STREAM_ROAD);
 }
 
 void OnroadWindow::paintEvent(QPaintEvent *event) {

selfdrive/ui/qt/widgets/cameraview.cc

@@ -17,16 +17,16 @@ const char frame_vertex_shader[] =
 #else
   "#version 300 es\n"
 #endif
-  "in vec4 aPosition;\n"
-  "in vec4 aTexCoord;\n"
+  "layout(location = 0) in vec4 aPosition;\n"
+  "layout(location = 1) in vec2 aTexCoord;\n"
   "uniform mat4 uTransform;\n"
-  "out vec4 vTexCoord;\n"
+  "out vec2 vTexCoord;\n"
   "void main() {\n"
   "  gl_Position = uTransform * aPosition;\n"
   "  vTexCoord = aTexCoord;\n"
   "}\n";
 
-const char frame_fragment_shader[] =
+const char yuv_fragment_shader[] =
 #ifdef __APPLE__
   "#version 150 core\n"
 #else
@@ -42,7 +42,21 @@ const char frame_fragment_shader[] =
   "  vec3 dz = vec3(0.0627f, 0.0627f, 0.0627f);\n"
   "  colorOut.rgb = ((vec3(1.0f, 1.0f, 1.0f) - dz) * colorOut.rgb / vec3(1.0f, 1.0f, 1.0f)) + dz;\n"
 #endif
-  "}\n";
+    "precision mediump float;\n"
+    "in vec2 vTexCoord;\n"
+    "out vec4 fragColor;\n"
+    "uniform sampler2D texture_y;\n"
+    "uniform sampler2D texture_u;\n"
+    "uniform sampler2D texture_v;\n"
+    "void main() {\n"
+    "  float y = texture(texture_y, vTexCoord).r;\n"
+    "  float u = texture(texture_u, vTexCoord).r - 0.5;\n"
+    "  float v = texture(texture_v, vTexCoord).r - 0.5;\n"
+    "  float r = y + 1.402 * v;\n"
+    "  float g = y - 0.344 * u - 0.714 * v;\n"
+    "  float b = y + 1.772 * u;\n"
+    "  fragColor = vec4(r, g, b, 1.0);\n"
+    "}\n";
 
 const mat4 device_transform = {{
   1.0,  0.0, 0.0, 0.0,
@@ -98,6 +112,10 @@ CameraViewWidget::CameraViewWidget(std::string stream_name, VisionStreamType typ
                                    stream_name(stream_name), stream_type(type), zoomed_view(zoom), QOpenGLWidget(parent) {
   setAttribute(Qt::WA_OpaquePaintEvent);
   connect(this, &CameraViewWidget::vipcThreadConnected, this, &CameraViewWidget::vipcConnected, Qt::BlockingQueuedConnection);
+  connect(this, &CameraViewWidget::vipcThreadFrameReceived, [=](VisionBuf *buf) {
+    latest_frame = buf;
+    update();
+  });
 }
 
 CameraViewWidget::~CameraViewWidget() {
@@ -106,6 +124,7 @@ CameraViewWidget::~CameraViewWidget() {
     glDeleteVertexArrays(1, &frame_vao);
     glDeleteBuffers(1, &frame_vbo);
     glDeleteBuffers(1, &frame_ibo);
+    glDeleteBuffers(3, textures);
   }
   doneCurrent();
 }
@@ -116,14 +135,14 @@ void CameraViewWidget::initializeGL() {
   program = std::make_unique<QOpenGLShaderProgram>(context());
   bool ret = program->addShaderFromSourceCode(QOpenGLShader::Vertex, frame_vertex_shader);
   assert(ret);
-  ret = program->addShaderFromSourceCode(QOpenGLShader::Fragment, frame_fragment_shader);
+  ret = program->addShaderFromSourceCode(QOpenGLShader::Fragment, yuv_fragment_shader);
   assert(ret);
 
   program->link();
   GLint frame_pos_loc = program->attributeLocation("aPosition");
   GLint frame_texcoord_loc = program->attributeLocation("aTexCoord");
 
-  auto [x1, x2, y1, y2] = stream_type == VISION_STREAM_RGB_FRONT ? std::tuple(0.f, 1.f, 1.f, 0.f) : std::tuple(1.f, 0.f, 1.f, 0.f);
+  auto [x1, x2, y1, y2] = stream_type == VISION_STREAM_DRIVER ? std::tuple(0.f, 1.f, 1.f, 0.f) : std::tuple(1.f, 0.f, 1.f, 0.f);
   const uint8_t frame_indicies[] = {0, 1, 2, 0, 2, 3};
   const float frame_coords[4][4] = {
     {-1.0, -1.0, x2, y1}, // bl
@@ -138,8 +157,7 @@ void CameraViewWidget::initializeGL() {
   glBindBuffer(GL_ARRAY_BUFFER, frame_vbo);
   glBufferData(GL_ARRAY_BUFFER, sizeof(frame_coords), frame_coords, GL_STATIC_DRAW);
   glEnableVertexAttribArray(frame_pos_loc);
-  glVertexAttribPointer(frame_pos_loc, 2, GL_FLOAT, GL_FALSE,
-                        sizeof(frame_coords[0]), (const void *)0);
+  glVertexAttribPointer(frame_pos_loc, 2, GL_FLOAT, GL_FALSE, sizeof(frame_coords[0]), (const void *)0);
   glEnableVertexAttribArray(frame_texcoord_loc);
   glVertexAttribPointer(frame_texcoord_loc, 2, GL_FLOAT, GL_FALSE,
                         sizeof(frame_coords[0]), (const void *)(sizeof(float) * 2));
@@ -148,10 +166,16 @@ void CameraViewWidget::initializeGL() {
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(frame_indicies), frame_indicies, GL_STATIC_DRAW);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glBindVertexArray(0);
+
+  glGenTextures(3, textures);
+  glUseProgram(program->programId());
+  glUniform1i(program->uniformLocation("texture_y"), 0);
+  glUniform1i(program->uniformLocation("texture_u"), 1);
+  glUniform1i(program->uniformLocation("texture_v"), 2);
 }
 
 void CameraViewWidget::showEvent(QShowEvent *event) {
-  latest_texture_id = -1;
+  latest_frame = nullptr;
   if (!vipc_thread) {
     vipc_thread = new QThread();
     connect(vipc_thread, &QThread::started, [=]() { vipcThread(); });
@@ -171,12 +195,12 @@ void CameraViewWidget::hideEvent(QHideEvent *event) {
 
 void CameraViewWidget::updateFrameMat(int w, int h) {
   if (zoomed_view) {
-    if (stream_type == VISION_STREAM_RGB_FRONT) {
+    if (stream_type == VISION_STREAM_DRIVER) {
       frame_mat = matmul(device_transform, get_driver_view_transform(w, h, stream_width, stream_height));
     } else {
-      auto intrinsic_matrix = stream_type == VISION_STREAM_RGB_WIDE ? ecam_intrinsic_matrix : fcam_intrinsic_matrix;
+      auto intrinsic_matrix = stream_type == VISION_STREAM_WIDE_ROAD ? ecam_intrinsic_matrix : fcam_intrinsic_matrix;
       float zoom = ZOOM / intrinsic_matrix.v[0];
-      if (stream_type == VISION_STREAM_RGB_WIDE) {
+      if (stream_type == VISION_STREAM_WIDE_ROAD) {
         zoom *= 0.5;
       }
       float zx = zoom * 2 * intrinsic_matrix.v[2] / width();
@@ -202,18 +226,23 @@ void CameraViewWidget::paintGL() {
   glClearColor(bg.redF(), bg.greenF(), bg.blueF(), bg.alphaF());
   glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
 
-  if (latest_texture_id == -1) return;
+  if (latest_frame == nullptr) return;
 
   glViewport(0, 0, width(), height());
-
   glBindVertexArray(frame_vao);
-  glActiveTexture(GL_TEXTURE0);
-  glBindTexture(GL_TEXTURE_2D, texture[latest_texture_id]->frame_tex);
 
   glUseProgram(program->programId());
-  glUniform1i(program->uniformLocation("uTexture"), 0);
-  glUniformMatrix4fv(program->uniformLocation("uTransform"), 1, GL_TRUE, frame_mat.v);
+  uint8_t *address[3] = {latest_frame->y, latest_frame->u, latest_frame->v};
+  for (int i = 0; i < 3; ++i) {
+    glActiveTexture(GL_TEXTURE0 + i);
+    glBindTexture(GL_TEXTURE_2D, textures[i]);
+    int width = i == 0 ? stream_width : stream_width / 2;
+    int height = i == 0 ? stream_height : stream_height / 2;
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, address[i]);
+    assert(glGetError() == GL_NO_ERROR);
+  }
 
+  glUniformMatrix4fv(program->uniformLocation("uTransform"), 1, GL_TRUE, frame_mat.v);
   assert(glGetError() == GL_NO_ERROR);
   glEnableVertexAttribArray(0);
   glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, (const void *)0);
@@ -223,48 +252,30 @@ void CameraViewWidget::paintGL() {
 
 void CameraViewWidget::vipcConnected(VisionIpcClient *vipc_client) {
   makeCurrent();
-  for (int i = 0; i < vipc_client->num_buffers; i++) {
-    texture[i].reset(new EGLImageTexture(&vipc_client->buffers[i]));
-
-    glBindTexture(GL_TEXTURE_2D, texture[i]->frame_tex);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  latest_frame = nullptr;
+  stream_width = vipc_client->buffers[0].width;
+  stream_height = vipc_client->buffers[0].height;
 
-    // BGR
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  for (int i = 0; i < 3; ++i) {
+    glBindTexture(GL_TEXTURE_2D, textures[i]);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    int width = i == 0 ? stream_width : stream_width / 2;
+    int height = i == 0 ? stream_height : stream_height / 2;
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, nullptr);
     assert(glGetError() == GL_NO_ERROR);
   }
-  latest_texture_id = -1;
-  stream_width = vipc_client->buffers[0].width;
-  stream_height = vipc_client->buffers[0].height;
+
   updateFrameMat(width(), height());
 }
 
 void CameraViewWidget::vipcThread() {
   VisionStreamType cur_stream_type = stream_type;
   std::unique_ptr<VisionIpcClient> vipc_client;
 
-  std::unique_ptr<QOpenGLContext> ctx;
-  std::unique_ptr<QOffscreenSurface> surface;
-  std::unique_ptr<QOpenGLBuffer> gl_buffer;
-
-  if (!Hardware::EON()) {
-    ctx = std::make_unique<QOpenGLContext>();
-    ctx->setFormat(context()->format());
-    ctx->setShareContext(context());
-    ctx->create();
-    assert(ctx->isValid());
-
-    surface = std::make_unique<QOffscreenSurface>();
-    surface->setFormat(ctx->format());
-    surface->create();
-    ctx->makeCurrent(surface.get());
-    assert(QOpenGLContext::currentContext() == ctx.get());
-    initializeOpenGLFunctions();
-  }
-
   while (!QThread::currentThread()->isInterruptionRequested()) {
     if (!vipc_client || cur_stream_type != stream_type) {
       cur_stream_type = stream_type;
@@ -276,37 +287,10 @@ void CameraViewWidget::vipcThread() {
         QThread::msleep(100);
         continue;
       }
-
-      if (!Hardware::EON()) {
-        gl_buffer.reset(new QOpenGLBuffer(QOpenGLBuffer::PixelUnpackBuffer));
-        gl_buffer->create();
-        gl_buffer->bind();
-        gl_buffer->setUsagePattern(QOpenGLBuffer::StreamDraw);
-        gl_buffer->allocate(vipc_client->buffers[0].len);
-      }
-
       emit vipcThreadConnected(vipc_client.get());
     }
 
     if (VisionBuf *buf = vipc_client->recv(nullptr, 1000)) {
-      if (!Hardware::EON()) {
-        void *texture_buffer = gl_buffer->map(QOpenGLBuffer::WriteOnly);
-        memcpy(texture_buffer, buf->addr, buf->len);
-        gl_buffer->unmap();
-
-        // copy pixels from PBO to texture object
-        glBindTexture(GL_TEXTURE_2D, texture[buf->idx]->frame_tex);
-        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, buf->width, buf->height, GL_RGB, GL_UNSIGNED_BYTE, 0);
-        glBindTexture(GL_TEXTURE_2D, 0);
-        assert(glGetError() == GL_NO_ERROR);
-        // use glFinish to ensure that the texture has been uploaded.
-        glFinish();
-      }
-      latest_texture_id = buf->idx;
-      // Schedule update. update() will be invoked on the gui thread.
-      QMetaObject::invokeMethod(this, "update");
-
-      // TODO: remove later, it's only connected by DriverView.
       emit vipcThreadFrameReceived(buf);
     }
   }

selfdrive/ui/qt/widgets/cameraview.h

@@ -7,8 +7,6 @@
 #include <QOpenGLWidget>
 #include <QThread>
 #include "cereal/visionipc/visionipc_client.h"
-#include "selfdrive/camerad/cameras/camera_common.h"
-#include "selfdrive/common/visionimg.h"
 #include "selfdrive/ui/ui.h"
 
 class CameraViewWidget : public QOpenGLWidget, protected QOpenGLFunctions {
@@ -37,10 +35,9 @@ class CameraViewWidget : public QOpenGLWidget, protected QOpenGLFunctions {
   void vipcThread();
 
   bool zoomed_view;
-  std::atomic<int> latest_texture_id = -1;
+  VisionBuf *latest_frame = nullptr;
   GLuint frame_vao, frame_vbo, frame_ibo;
   mat4 frame_mat;
-  std::unique_ptr<EGLImageTexture> texture[UI_BUF_COUNT];
   std::unique_ptr<QOpenGLShaderProgram> program;
   QColor bg = QColor("#000000");
 
@@ -50,6 +47,7 @@ class CameraViewWidget : public QOpenGLWidget, protected QOpenGLFunctions {
   std::atomic<VisionStreamType> stream_type;
   QThread *vipc_thread = nullptr;
 
+  GLuint textures[3];
 
 protected slots:
   void vipcConnected(VisionIpcClient *vipc_client);

selfdrive/ui/watch3.cc

@@ -21,15 +21,15 @@ int main(int argc, char *argv[]) {
   {
     QHBoxLayout *hlayout = new QHBoxLayout();
     layout->addLayout(hlayout);
-    hlayout->addWidget(new CameraViewWidget("navd", VISION_STREAM_RGB_MAP, false));
-    hlayout->addWidget(new CameraViewWidget("camerad", VISION_STREAM_RGB_BACK, false));
+    // hlayout->addWidget(new CameraViewWidget("navd", VISION_STREAM_RGB_MAP, false));
+    hlayout->addWidget(new CameraViewWidget("camerad", VISION_STREAM_ROAD, false));
   }
 
   {
     QHBoxLayout *hlayout = new QHBoxLayout();
     layout->addLayout(hlayout);
-    hlayout->addWidget(new CameraViewWidget("camerad", VISION_STREAM_RGB_FRONT, false));
-    hlayout->addWidget(new CameraViewWidget("camerad", VISION_STREAM_RGB_WIDE, false));
+    hlayout->addWidget(new CameraViewWidget("camerad", VISION_STREAM_DRIVER, false));
+    hlayout->addWidget(new CameraViewWidget("camerad", VISION_STREAM_WIDE_ROAD, false));
   }
 
   return a.exec();