Home | History | Annotate | Download | only in libdvr 
      1 #include "include/dvr/dvr_buffer.h"
      2 
      3 #include <android/hardware_buffer.h>
      4 #include <private/dvr/buffer_hub_client.h>
      5 #include <ui/GraphicBuffer.h>
      6 
      7 #include "dvr_internal.h"
      8 
      9 using namespace android;
     10 
     11 namespace android {
     12 namespace dvr {
     13 
     14 DvrBuffer* CreateDvrBufferFromIonBuffer(
     15     const std::shared_ptr<IonBuffer>& ion_buffer) {
     16   if (!ion_buffer)
     17     return nullptr;
     18   return new DvrBuffer{std::move(ion_buffer)};
     19 }
     20 
     21 }  // namespace dvr
     22 }  // namespace android
     23 
     24 namespace {
     25 
     26 int ConvertToAHardwareBuffer(GraphicBuffer* graphic_buffer,
     27                              AHardwareBuffer** hardware_buffer) {
     28   if (!hardware_buffer || !graphic_buffer) {
     29     return -EINVAL;
     30   }
     31   *hardware_buffer = reinterpret_cast<AHardwareBuffer*>(graphic_buffer);
     32   AHardwareBuffer_acquire(*hardware_buffer);
     33   return 0;
     34 }
     35 
     36 }  // anonymous namespace
     37 
     38 extern "C" {
     39 
     40 void dvrWriteBufferCreateEmpty(DvrWriteBuffer** write_buffer) {
     41   if (write_buffer)
     42     *write_buffer = new DvrWriteBuffer;
     43 }
     44 
     45 void dvrWriteBufferDestroy(DvrWriteBuffer* write_buffer) {
     46   delete write_buffer;
     47 }
     48 
     49 int dvrWriteBufferIsValid(DvrWriteBuffer* write_buffer) {
     50   return write_buffer && write_buffer->write_buffer;
     51 }
     52 
     53 int dvrWriteBufferClear(DvrWriteBuffer* write_buffer) {
     54   if (!write_buffer)
     55     return -EINVAL;
     56 
     57   write_buffer->write_buffer = nullptr;
     58   return 0;
     59 }
     60 
     61 int dvrWriteBufferGetId(DvrWriteBuffer* write_buffer) {
     62   if (!write_buffer || !write_buffer->write_buffer)
     63     return -EINVAL;
     64 
     65   return write_buffer->write_buffer->id();
     66 }
     67 
     68 int dvrWriteBufferGetAHardwareBuffer(DvrWriteBuffer* write_buffer,
     69                                      AHardwareBuffer** hardware_buffer) {
     70   if (!write_buffer || !write_buffer->write_buffer)
     71     return -EINVAL;
     72 
     73   return ConvertToAHardwareBuffer(
     74       write_buffer->write_buffer->buffer()->buffer().get(), hardware_buffer);
     75 }
     76 
     77 int dvrWriteBufferPost(DvrWriteBuffer* write_buffer, int ready_fence_fd,
     78                        const void* meta, size_t meta_size_bytes) {
     79   if (!write_buffer || !write_buffer->write_buffer)
     80     return -EINVAL;
     81 
     82   pdx::LocalHandle fence(ready_fence_fd);
     83   int result = write_buffer->write_buffer->Post(fence, meta, meta_size_bytes);
     84   return result;
     85 }
     86 
     87 int dvrWriteBufferGain(DvrWriteBuffer* write_buffer, int* release_fence_fd) {
     88   if (!write_buffer || !write_buffer->write_buffer || !release_fence_fd)
     89     return -EINVAL;
     90 
     91   pdx::LocalHandle release_fence;
     92   int result = write_buffer->write_buffer->Gain(&release_fence);
     93   *release_fence_fd = release_fence.Release();
     94   return result;
     95 }
     96 
     97 int dvrWriteBufferGainAsync(DvrWriteBuffer* write_buffer) {
     98   if (!write_buffer || !write_buffer->write_buffer)
     99     return -EINVAL;
    100 
    101   return write_buffer->write_buffer->GainAsync();
    102 }
    103 
    104 void dvrReadBufferCreateEmpty(DvrReadBuffer** read_buffer) {
    105   if (read_buffer)
    106     *read_buffer = new DvrReadBuffer;
    107 }
    108 
    109 void dvrReadBufferDestroy(DvrReadBuffer* read_buffer) { delete read_buffer; }
    110 
    111 int dvrReadBufferIsValid(DvrReadBuffer* read_buffer) {
    112   return read_buffer && read_buffer->read_buffer;
    113 }
    114 
    115 int dvrReadBufferClear(DvrReadBuffer* read_buffer) {
    116   if (!read_buffer)
    117     return -EINVAL;
    118 
    119   read_buffer->read_buffer = nullptr;
    120   return 0;
    121 }
    122 
    123 int dvrReadBufferGetId(DvrReadBuffer* read_buffer) {
    124   if (!read_buffer || !read_buffer->read_buffer)
    125     return -EINVAL;
    126 
    127   return read_buffer->read_buffer->id();
    128 }
    129 
    130 int dvrReadBufferGetAHardwareBuffer(DvrReadBuffer* read_buffer,
    131                                     AHardwareBuffer** hardware_buffer) {
    132   if (!read_buffer || !read_buffer->read_buffer)
    133     return -EINVAL;
    134 
    135   return ConvertToAHardwareBuffer(
    136       read_buffer->read_buffer->buffer()->buffer().get(), hardware_buffer);
    137 }
    138 
    139 int dvrReadBufferAcquire(DvrReadBuffer* read_buffer, int* ready_fence_fd,
    140                          void* meta, size_t meta_size_bytes) {
    141   if (!read_buffer || !read_buffer->read_buffer)
    142     return -EINVAL;
    143 
    144   pdx::LocalHandle ready_fence;
    145   int result =
    146       read_buffer->read_buffer->Acquire(&ready_fence, meta, meta_size_bytes);
    147   *ready_fence_fd = ready_fence.Release();
    148   return result;
    149 }
    150 
    151 int dvrReadBufferRelease(DvrReadBuffer* read_buffer, int release_fence_fd) {
    152   if (!read_buffer || !read_buffer->read_buffer)
    153     return -EINVAL;
    154 
    155   pdx::LocalHandle fence(release_fence_fd);
    156   int result = read_buffer->read_buffer->Release(fence);
    157   return result;
    158 }
    159 
    160 int dvrReadBufferReleaseAsync(DvrReadBuffer* read_buffer) {
    161   if (!read_buffer || !read_buffer->read_buffer)
    162     return -EINVAL;
    163 
    164   return read_buffer->read_buffer->ReleaseAsync();
    165 }
    166 
    167 void dvrBufferDestroy(DvrBuffer* buffer) { delete buffer; }
    168 
    169 int dvrBufferGetAHardwareBuffer(DvrBuffer* buffer,
    170                                 AHardwareBuffer** hardware_buffer) {
    171   if (!buffer || !buffer->buffer || !hardware_buffer) {
    172     return -EINVAL;
    173   }
    174 
    175   return ConvertToAHardwareBuffer(buffer->buffer->buffer().get(),
    176                                   hardware_buffer);
    177 }
    178 
    179 const struct native_handle* dvrWriteBufferGetNativeHandle(
    180     DvrWriteBuffer* write_buffer) {
    181   if (!write_buffer || !write_buffer->write_buffer)
    182     return nullptr;
    183 
    184   return write_buffer->write_buffer->native_handle();
    185 }
    186 
    187 const struct native_handle* dvrReadBufferGetNativeHandle(
    188     DvrReadBuffer* read_buffer) {
    189   if (!read_buffer || !read_buffer->read_buffer)
    190     return nullptr;
    191 
    192   return read_buffer->read_buffer->native_handle();
    193 }
    194 
    195 const struct native_handle* dvrBufferGetNativeHandle(DvrBuffer* buffer) {
    196   if (!buffer || !buffer->buffer)
    197     return nullptr;
    198 
    199   return buffer->buffer->handle();
    200 }
    201 
    202 }  // extern "C"
    203