public_api.h

Go to the documentation of this file.

/*
 * This file is part of Anbox Platform SDK
 *
 * Copyright 2021 Canonical Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef ANBOX_SDK_INTERNAL_PUBLIC_API_H_
#define ANBOX_SDK_INTERNAL_PUBLIC_API_H_
 
#include "anbox-platform-sdk/platform.h"
 
typedef AnboxPlatform* (*AnboxInitializePlatformFunc)(const AnboxPlatformConfiguration* configuration);
 
typedef void (*AnboxReleasePlatformFunc)(AnboxPlatform* platform);
 
typedef const AnboxAudioProcessor* (*AnboxPlatformGetAudioProcessorFunc)(const AnboxPlatform* platform);
 
typedef const AnboxInputProcessor* (*AnboxPlatformGetInputProcessorFunc)(const AnboxPlatform* platform);
 
typedef const AnboxGraphicsProcessor* (*AnboxPlatformGetGraphicsProcessorFunc)(const AnboxPlatform* platform);
 
typedef const AnboxSensorProcessor* (*AnboxPlatformGetSensorProcessorFunc)(const AnboxPlatform* platform);
 
typedef const AnboxGpsProcessor* (*AnboxPlatformGetGpsProcessorFunc)(const AnboxPlatform* platform);
 
typedef const AnboxCameraProcessor* (*AnboxPlatformGetCameraProcessorFunc)(const AnboxPlatform* platform);
 
typedef const AnboxProxy* (*AnboxPlatformGetAnboxProxyFunc)(const AnboxPlatform* platform);
 
typedef AnboxVideoDecoder* (*AnboxPlatformCreateVideoDecoderFunc)(const AnboxPlatform* platform, AnboxVideoCodecType codec_type);
 
typedef bool (*AnboxPlatformReadyFunc)(const AnboxPlatform* platform);
 
typedef int (*AnboxPlatformWaitUntilReadyFunc)(const AnboxPlatform* platform);
 
typedef int (*AnboxPlatformGetConfigItemFunc)(const AnboxPlatform* platform,
                                              AnboxPlatformConfigurationKey key,
                                              void* data, size_t data_size);
 
typedef int (*AnboxPlatformSetConfigItemFunc)(const AnboxPlatform* platform,
                                              AnboxPlatformConfigurationKey key,
                                              void* data, size_t data_size);
 
typedef void (*AnboxPlatformSetupEventTracerFunc)(const AnboxPlatform* platform,
                                                  AnboxTracerGetCategoryEnabledFunc get_category_enabled_func,
                                                  AnboxTracerAddEventFunc add_event_func);
 
typedef int (*AnboxPlatformStopFunc)(const AnboxPlatform* platform);
 
typedef void (*AnboxPlatformHandleEventFunc)(const AnboxPlatform* platform, AnboxEventType type);
 
typedef size_t (*AnboxAudioProcessorProcessDataFunc)(const AnboxAudioProcessor* audio_processor,
                                                     const uint8_t* data,
                                                     size_t size);
 
typedef ssize_t (*AnboxAudioProcessorWriteDataFunc)(const AnboxAudioProcessor* audio_processor,
                                                    const uint8_t* data,
                                                    size_t size);
 
typedef ssize_t (*AnboxAudioProcessorReadDataFunc)(const AnboxAudioProcessor* audio_processor,
                                                   uint8_t* data,
                                                   size_t size);
 
typedef int (*AnboxAudioProcessorStandbyFunc)(const AnboxAudioProcessor* audio_processor,
                                              AnboxAudioStreamType type);
 
typedef int (*AnboxAudioProcessorActivateFunc)(const AnboxAudioProcessor* audio_processor,
                                               AnboxAudioStreamType type);
 
typedef bool (*AnboxAudioProcessorNeedSilenceOnStandbyFunc)(const AnboxAudioProcessor* audio_processor);
 
typedef int (*AnboxInputProcessorReadEventFunc)(const AnboxInputProcessor* input_processor,
                                                AnboxInputEvent* event,
                                                int timeout);
 
typedef int (*AnboxInputProcessorInjectEventFunc)(const AnboxInputProcessor* input_processor,
                                                  AnboxInputEvent event);
 
typedef int (*AnboxGraphicsProcessorInitializeFunc)(const AnboxGraphicsProcessor* graphics_processor,
                                                    AnboxGraphicsConfiguration* configuration);
 
typedef EGLDisplay (*AnboxGraphicsProcessorCreateDisplayFunc)(const AnboxGraphicsProcessor* graphics_processor);
 
typedef void (*AnboxGraphicsProcessorBeginFrameFunc)(const AnboxGraphicsProcessor* graphics_processor);
 
typedef void (*AnboxGraphicsProcessorFinishFrameFunc)(const AnboxGraphicsProcessor* graphics_processor);
 
typedef EGLSurface (*AnboxGraphicsProcessorCreateOffscreenSurfaceFunc)(const AnboxGraphicsProcessor* graphics_processor,
                                                                       EGLDisplay display,
                                                                       EGLConfig config,
                                                                       const EGLint* attribs);
 
typedef bool (*AnboxGraphicsProcessorDestroyOffscreenSurfaceFunc)(const AnboxGraphicsProcessor* graphics_processor,
                                                                  EGLDisplay display,
                                                                  EGLSurface surface);
 
typedef bool (*AnboxGraphicsProcessorPresentFunc)(const AnboxGraphicsProcessor* graphics_processor,
                                                  AnboxGraphicsBuffer* buffer,
                                                  AnboxCallback* callback);
 
typedef bool (*AnboxGraphicsProcessorPresent2Func)(const AnboxGraphicsProcessor* graphics_processor,
                                                  AnboxGraphicsBuffer2* buffer,
                                                  AnboxCallback* callback);
 
/*
 * @brief Create a new graphics buffer
 *
 * The function prototype for C API function which stands for
 * the C++ method of anbox::GraphicsProcessor::create_buffer
 */
typedef bool (*AnboxGraphicsProcessorCreateBufferFunc)(const AnboxGraphicsProcessor* graphics_processor,
                                                       uint32_t width, uint32_t height, uint32_t format,
                                                       uint32_t usage, AnboxGraphicsBuffer2** buffer);
 
 
/*
 * @brief Set the vsync callback
 *
 * The function prototype for C API function which stands for
 * the C++ method of anbox::GraphicsProcessor::set_vsync_callback
 */
typedef bool (*AnboxGraphicsProcessorSetVsyncCallbackFunc)(
  const AnboxGraphicsProcessor* graphics_processor,
  const AnboxVsyncCallback& callback, void* user_data);
 
typedef AnboxSensorType (*AnboxSensorProcessorSupportedSensorsFunc)(const AnboxSensorProcessor* sensor_processor);
 
typedef int (*AnboxSensorProcessorActivateSensorFunc)(const AnboxSensorProcessor* sensor_processor,
                                                      const AnboxSensorType type,
                                                      bool on);
 
 
typedef int (*AnboxSensorProcessorReadDataFunc)(const AnboxSensorProcessor* sensor_processor,
                                                AnboxSensorData* data,
                                                int timeout);
 
typedef int (*AnboxSensorProcessorInjectDataFunc)(const AnboxSensorProcessor* sensor_processor,
                                                  AnboxSensorData data);
 
typedef int (*AnboxProxySetChangeScreenOrientationCallbackFunc)(const AnboxProxy* anbox_proxy,
                                                                const AnboxChangeScreenOrientationCallback& callback,
                                                                void* user_data);
 
typedef int (*AnboxProxySetChangeDisplayDensityCallbackFunc)(const AnboxProxy* anbox_proxy,
                                                             const AnboxChangeDisplayDensityCallback& callback,
                                                             void* user_data);
 
typedef int (*AnboxProxySetChangeDisplaySizeCallbackFunc)(const AnboxProxy* anbox_proxy,
                                                          const AnboxChangeDisplaySizeCallback& callback,
                                                          void* user_data);
 
typedef int (*AnboxProxySendMessageFunc)(const AnboxProxy* anbox_proxy,
                                         const char* type,
                                         size_t type_size,
                                         const char* data,
                                         size_t data_size);
 
typedef int (*AnboxProxySetTriggerActionCallbackFunc)(const AnboxProxy* proxy,
                                                      const AnboxTriggerActionCallback& callback,
                                                      void* user_data);
 
typedef int (*AnboxProxySetCreateAdbConnectionCallbackFunc)(const AnboxProxy* proxy,
                                                            const AnboxCreateADBConnectionCallback& callback,
                                                            void* user_data);
 
typedef int (*AnboxProxySetDisconnectAdbConnectionCallbackFunc)(const AnboxProxy* proxy,
                                                                const AnboxDisconnectADBConnectionCallback& callback,
                                                                void* user_data);
 
typedef int (*AnboxGpsProcessorStartFunc)(const AnboxGpsProcessor* gps_processor);
 
typedef int (*AnboxGpsProcessorStopFunc)(const AnboxGpsProcessor* gps_processor);
 
typedef int (*AnboxGpsProcessorReadDataFunc)(const AnboxGpsProcessor* gps_processor,
                                             AnboxGpsData* data,
                                             int timeout);
 
typedef int (*AnboxGpsProcessorInjectDataFunc)(const AnboxGpsProcessor* gps_processor,
                                               AnboxGpsData data);
 
typedef int (*AnboxCameraProcessorGetDeviceSpecsFunc)(const AnboxCameraProcessor* camera_processor,
                                                      AnboxCameraSpec** specs,
                                                      size_t *length);
 
typedef int (*AnboxCameraProcessorOpenDeviceFunc)(const AnboxCameraProcessor* camera_processor,
                                                  AnboxCameraSpec spec,
                                                  AnboxCameraOrientation orientation);
 
typedef int (*AnboxCameraProcessorCloseDeviceFunc)(const AnboxCameraProcessor* camera_processor);
 
 
typedef int (*AnboxCameraProcessorReadFrameFunc)(const AnboxCameraProcessor* camera_processor,
                                                 AnboxVideoFrame* frame,
                                                 int timeout);
 
typedef int (*AnboxCameraProcessorInjectFrameFunc)(const AnboxCameraProcessor* camera_processor,
                                                   AnboxVideoFrame frame);
 
/*
 * @brief Release the video decoder instance
 **/
typedef int (*AnboxVideoDecoderReleaseFunc)(AnboxVideoDecoder* decoder);
 
/*
 * @brief Configure the video decoder with the given spec
 *
 * The function prototype for C API function which stands for
 * the C++ method of anbox::VideoDecoder::configure
 *
 **/
typedef int (*AnboxVideoDecoderConfigureFunc)(const AnboxVideoDecoder* decoder, AnboxVideoDecoderConfig config);
 
/*
 * @brief Flush any pending work the video decoder may have
 *
 * The function prototype for C API function which stands for
 * the C++ method of anbox::VideoDecoder::flush
 *
 **/
typedef int (*AnboxVideoDecoderFlushFunc)(const AnboxVideoDecoder* decoder);
 
/*
 * @brief Submit the given frame to the video decoder
 *
 * The function prototype for C API function which stands for
 * the C++ method of anbox::VideoDecoder::decode_frame
 *
 **/
typedef uint64_t (*AnboxVideoDecoderDecodeFrameFunc)(const AnboxVideoDecoder* decoder, const AnboxVideoFrame* frame, uint64_t pts);
 
/*
 * @brief Retrieve a decoded image from the decoder
 *
 * The function prototype for C API function which stands for
 * the C++ method of anbox::VideoDecoder::retrieve_image
 *
 **/
typedef int (*AnboxVideoDecoderRetrieveImageFunc)(const AnboxVideoDecoder* decoder, AnboxVideoImage *img);
 
typedef AnboxVhalConnector* (*AnboxPlatformGetVhalConnectorFunc)(const AnboxPlatform* platform);
 
typedef int (*AnboxVhalConnectorSetCallbacksFunc)(const AnboxVhalConnector* connector,
                                                  const AnboxVhalConnectorCallbacks* callbacks,
                                                  void* user_data);
 
#endif