Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 10e68eb8 authored by Hendrik Wagenaar's avatar Hendrik Wagenaar
Browse files

Add dvr_buffer apis 

Test: None
Bug: None
Change-Id: I234d7ef4dabb4453cdbc67d3112adf2ffbbadaf4
parent 1a13cc31

libs/vr/libbufferhub/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -15,6 +15,7 @@ 
sourceFiles = [

    "buffer_hub_client.cpp",

    "buffer_hub_rpc.cpp",

    "dvr_buffer.cpp",

    "ion_buffer.cpp",

]

libs/vr/libbufferhub/buffer_hub_client.cpp

+7 −0
Original line number Diff line number Diff line
@@ -130,6 +130,13 @@ int BufferHubBuffer::GetBlobReadOnlyPointer(size_t size, void** addr) { 
  return ret;

}



void BufferHubBuffer::GetBlobFds(int* fds, size_t* fds_count,

                                 size_t max_fds_count) const {

  size_t numFds = static_cast<size_t>(native_handle()->numFds);

  *fds_count = std::min(max_fds_count, numFds);

  std::copy(native_handle()->data, native_handle()->data + *fds_count, fds);

}



BufferConsumer::BufferConsumer(LocalChannelHandle channel)

    : BASE(std::move(channel)) {

  const int ret = ImportBuffer();

libs/vr/libbufferhub/dvr_buffer.cpp

0 → 100644
+124 −0
Original line number Diff line number Diff line 
#include <private/dvr/buffer_hub_client.h>

#include <private/dvr/dvr_buffer.h>

#include <ui/GraphicBuffer.h>



using namespace android;



struct DvrWriteBuffer {

  std::unique_ptr<dvr::BufferProducer> write_buffer_;

  sp<GraphicBuffer> graphic_buffer_;

};



struct DvrReadBuffer {

  std::unique_ptr<dvr::BufferConsumer> read_buffer_;

  sp<GraphicBuffer> graphic_buffer_;

};



namespace android {

namespace dvr {



DvrWriteBuffer* CreateDvrWriteBufferFromBufferProducer(

    std::unique_ptr<dvr::BufferProducer> buffer_producer) {

  DvrWriteBuffer* write_buffer = new DvrWriteBuffer;

  write_buffer->write_buffer_ = std::move(buffer_producer);

  return write_buffer;

}



DvrReadBuffer* CreateDvrReadBufferFromBufferConsumer(

    std::unique_ptr<dvr::BufferConsumer> buffer_consumer) {

  DvrReadBuffer* read_buffer = new DvrReadBuffer;

  read_buffer->read_buffer_ = std::move(buffer_consumer);

  return read_buffer;

}



}  // namespace dvr

}  // namespace android



namespace {



void InitializeGraphicBuffer(const dvr::BufferHubBuffer* buffer,

                             sp<GraphicBuffer>* graphic_buffer) {

  *graphic_buffer = sp<GraphicBuffer>(new GraphicBuffer(

      buffer->width(), buffer->height(), buffer->format(), 1, /* layer count */

      buffer->usage(), buffer->stride(), buffer->native_handle(),

      false /* keep ownership */));

}



}  // anonymous namespace



extern "C" {



void dvrWriteBufferDestroy(DvrWriteBuffer* client) { delete client; }



void dvrWriteBufferGetBlobFds(DvrWriteBuffer* client, int* fds,

                              size_t* fds_count, size_t max_fds_count) {

  client->write_buffer_->GetBlobFds(fds, fds_count, max_fds_count);

}



int dvrWriteBufferGetAHardwareBuffer(DvrWriteBuffer* client,

                                     AHardwareBuffer** hardware_buffer) {

  if (!client->graphic_buffer_.get()) {

    InitializeGraphicBuffer(client->write_buffer_.get(),

                            &client->graphic_buffer_);

  }

  *hardware_buffer =

      reinterpret_cast<AHardwareBuffer*>(client->graphic_buffer_.get());

  return 0;

}



int dvrWriteBufferPost(DvrWriteBuffer* client, int ready_fence_fd,

                       const void* meta, size_t meta_size_bytes) {

  pdx::LocalHandle fence(ready_fence_fd);

  int result = client->write_buffer_->Post(fence, meta, meta_size_bytes);

  fence.Release();

  return result;

}



int dvrWriteBufferGain(DvrWriteBuffer* client, int* release_fence_fd) {

  pdx::LocalHandle release_fence;

  int result = client->write_buffer_->Gain(&release_fence);

  *release_fence_fd = release_fence.Release();

  return result;

}



int dvrWriteBufferGainAsync(DvrWriteBuffer* client) {

  return client->write_buffer_->GainAsync();

}



void dvrReadBufferGetBlobFds(DvrReadBuffer* client, int* fds, size_t* fds_count,

                             size_t max_fds_count) {

  client->read_buffer_->GetBlobFds(fds, fds_count, max_fds_count);

}



int dvrReadBufferGetAHardwareBuffer(DvrReadBuffer* client,

                                    AHardwareBuffer** hardware_buffer) {

  if (!client->graphic_buffer_.get()) {

    InitializeGraphicBuffer(client->read_buffer_.get(),

                            &client->graphic_buffer_);

  }

  *hardware_buffer =

      reinterpret_cast<AHardwareBuffer*>(client->graphic_buffer_.get());

  return 0;

}



int dvrReadBufferAcquire(DvrReadBuffer* client, int* ready_fence_fd, void* meta,

                         size_t meta_size_bytes) {

  pdx::LocalHandle ready_fence;

  int result =

      client->read_buffer_->Acquire(&ready_fence, meta, meta_size_bytes);

  *ready_fence_fd = ready_fence.Release();

  return result;

}



int dvrReadBufferRelease(DvrReadBuffer* client, int release_fence_fd) {

  pdx::LocalHandle fence(release_fence_fd);

  int result = client->read_buffer_->Release(fence);

  fence.Release();

  return result;

}



int dvrReadBufferReleaseAsync(DvrReadBuffer* client) {

  return client->read_buffer_->ReleaseAsync();

}



}  // extern "C"

libs/vr/libbufferhub/include/private/dvr/buffer_hub_client.h

+4 −0
Original line number Diff line number Diff line
@@ -70,6 +70,10 @@ class BufferHubBuffer : public pdx::Client { 
    return LocalHandle(dup(native_handle()->data[0]));

  }



  // Get up to |max_fds_count| file descriptors for accessing the blob shared

  // memory. |fds_count| will contain the actual number of file descriptors.

  void GetBlobFds(int* fds, size_t* fds_count, size_t max_fds_count) const;



  using Client::event_fd;



  Status<int> GetEventMask(int events) {

libs/vr/libbufferhub/include/private/dvr/dvr_buffer.h

0 → 100644
+55 −0
Original line number Diff line number Diff line 
#ifndef ANDROID_DVR_BUFFER_H_

#define ANDROID_DVR_BUFFER_H_



#include <memory>

#include <stdbool.h>

#include <stdint.h>



#ifdef __cplusplus

extern "C" {

#endif



typedef struct DvrWriteBuffer DvrWriteBuffer;

typedef struct DvrReadBuffer DvrReadBuffer;

typedef struct AHardwareBuffer AHardwareBuffer;



// Write buffer

void dvrWriteBufferDestroy(DvrWriteBuffer* client);

void dvrWriteBufferGetBlobFds(DvrWriteBuffer* client, int* fds,

                              size_t* fds_count, size_t max_fds_count);

int dvrWriteBufferGetAHardwareBuffer(DvrWriteBuffer* client,

                                     AHardwareBuffer** hardware_buffer);

int dvrWriteBufferPost(DvrWriteBuffer* client, int ready_fence_fd,

                       const void* meta, size_t meta_size_bytes);

int dvrWriteBufferGain(DvrWriteBuffer* client, int* release_fence_fd);

int dvrWriteBufferGainAsync(DvrWriteBuffer* client);



// Read buffer

void dvrReadBufferGetBlobFds(DvrReadBuffer* client, int* fds, size_t* fds_count,

                             size_t max_fds_count);

int dvrReadBufferGetAHardwareBuffer(DvrReadBuffer* client,

                                    AHardwareBuffer** hardware_buffer);

int dvrReadBufferAcquire(DvrReadBuffer* client, int* ready_fence_fd, void* meta,

                         size_t meta_size_bytes);

int dvrReadBufferRelease(DvrReadBuffer* client, int release_fence_fd);

int dvrReadBufferReleaseAsync(DvrReadBuffer* client);



#ifdef __cplusplus

}  // extern "C"

#endif



namespace android {

namespace dvr {



class BufferProducer;

class BufferConsumer;



DvrWriteBuffer* CreateDvrWriteBufferFromBufferProducer(

    std::unique_ptr<BufferProducer> buffer_producer);

DvrReadBuffer* CreateDvrReadBufferFromBufferConsumer(

    std::unique_ptr<BufferConsumer> buffer_consumer);



}  // namespace dvr

}  // namespace android



#endif  // ANDROID_DVR_BUFFER_H_