351 lines
10 KiB
C
351 lines
10 KiB
C
/*
|
||
* Copyright 2014 The Android Open Source Project
|
||
*
|
||
* 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 ANDROID_TV_INPUT_INTERFACE_H
|
||
#define ANDROID_TV_INPUT_INTERFACE_H
|
||
|
||
#include <stdint.h>
|
||
#include <sys/cdefs.h>
|
||
#include <sys/types.h>
|
||
|
||
#include <hardware/hardware.h>
|
||
#include <system/audio.h>
|
||
#include <system/window.h>
|
||
|
||
__BEGIN_DECLS
|
||
|
||
/*
|
||
* Module versioning information for the TV input hardware module, based on
|
||
* tv_input_module_t.common.module_api_version.
|
||
*
|
||
* Version History:
|
||
*
|
||
* TV_INPUT_MODULE_API_VERSION_0_1:
|
||
* Initial TV input hardware module API.
|
||
*
|
||
*/
|
||
|
||
#define TV_INPUT_MODULE_API_VERSION_0_1 HARDWARE_MODULE_API_VERSION(0, 1)
|
||
|
||
#define TV_INPUT_DEVICE_API_VERSION_0_1 HARDWARE_DEVICE_API_VERSION(0, 1)
|
||
|
||
/*
|
||
* The id of this module
|
||
*/
|
||
#define TV_INPUT_HARDWARE_MODULE_ID "tv_input"
|
||
|
||
#define TV_INPUT_DEFAULT_DEVICE "default"
|
||
|
||
/*****************************************************************************/
|
||
|
||
/*
|
||
* Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
|
||
* and the fields of this data structure must begin with hw_module_t
|
||
* followed by module specific information.
|
||
*/
|
||
typedef struct tv_input_module {
|
||
struct hw_module_t common;
|
||
} tv_input_module_t;
|
||
|
||
/*****************************************************************************/
|
||
|
||
enum {
|
||
/* HDMI */
|
||
TV_INPUT_TYPE_HDMI = 1,
|
||
|
||
/* Built-in tuners. */
|
||
TV_INPUT_TYPE_BUILT_IN_TUNER = 2,
|
||
|
||
/* Passthrough */
|
||
TV_INPUT_TYPE_PASSTHROUGH = 3,
|
||
};
|
||
typedef uint32_t tv_input_type_t;
|
||
|
||
typedef struct tv_input_device_info {
|
||
/* Device ID */
|
||
int device_id;
|
||
|
||
/* Type of physical TV input. */
|
||
tv_input_type_t type;
|
||
|
||
union {
|
||
struct {
|
||
/* HDMI port ID number */
|
||
uint32_t port_id;
|
||
} hdmi;
|
||
|
||
/* TODO: add other type specific information. */
|
||
|
||
int32_t type_info_reserved[16];
|
||
};
|
||
|
||
/* TODO: Add capability if necessary. */
|
||
|
||
/*
|
||
* Audio info
|
||
*
|
||
* audio_type == AUDIO_DEVICE_NONE if this input has no audio.
|
||
*/
|
||
audio_devices_t audio_type;
|
||
const char* audio_address;
|
||
|
||
int32_t reserved[16];
|
||
} tv_input_device_info_t;
|
||
|
||
enum {
|
||
/*
|
||
* Hardware notifies the framework that a device is available.
|
||
*/
|
||
TV_INPUT_EVENT_DEVICE_AVAILABLE = 1,
|
||
/*
|
||
* Hardware notifies the framework that a device is unavailable.
|
||
*/
|
||
TV_INPUT_EVENT_DEVICE_UNAVAILABLE = 2,
|
||
/*
|
||
* Stream configurations are changed. Client should regard all open streams
|
||
* at the specific device are closed, and should call
|
||
* get_stream_configurations() again, opening some of them if necessary.
|
||
*/
|
||
TV_INPUT_EVENT_STREAM_CONFIGURATIONS_CHANGED = 3,
|
||
/*
|
||
* Hardware is done with capture request with the buffer. Client can assume
|
||
* ownership of the buffer again.
|
||
*/
|
||
TV_INPUT_EVENT_CAPTURE_SUCCEEDED = 4,
|
||
/*
|
||
* Hardware met a failure while processing a capture request or client
|
||
* canceled the request. Client can assume ownership of the buffer again.
|
||
*/
|
||
TV_INPUT_EVENT_CAPTURE_FAILED = 5,
|
||
};
|
||
typedef uint32_t tv_input_event_type_t;
|
||
|
||
typedef struct tv_input_capture_result {
|
||
/* Device ID */
|
||
int device_id;
|
||
|
||
/* Stream ID */
|
||
int stream_id;
|
||
|
||
/* Sequence number of the request */
|
||
uint32_t seq;
|
||
|
||
/*
|
||
* The buffer passed to hardware in request_capture(). The content of
|
||
* buffer is undefined (although buffer itself is valid) for
|
||
* TV_INPUT_CAPTURE_FAILED event.
|
||
*/
|
||
buffer_handle_t buffer;
|
||
|
||
/*
|
||
* Error code for the request. -ECANCELED if request is cancelled; other
|
||
* error codes are unknown errors.
|
||
*/
|
||
int error_code;
|
||
} tv_input_capture_result_t;
|
||
|
||
typedef struct tv_input_event {
|
||
tv_input_event_type_t type;
|
||
|
||
union {
|
||
/*
|
||
* TV_INPUT_EVENT_DEVICE_AVAILABLE: all fields are relevant
|
||
* TV_INPUT_EVENT_DEVICE_UNAVAILABLE: only device_id is relevant
|
||
* TV_INPUT_EVENT_STREAM_CONFIGURATIONS_CHANGED: only device_id is
|
||
* relevant
|
||
*/
|
||
tv_input_device_info_t device_info;
|
||
/*
|
||
* TV_INPUT_EVENT_CAPTURE_SUCCEEDED: error_code is not relevant
|
||
* TV_INPUT_EVENT_CAPTURE_FAILED: all fields are relevant
|
||
*/
|
||
tv_input_capture_result_t capture_result;
|
||
};
|
||
} tv_input_event_t;
|
||
|
||
typedef struct tv_input_callback_ops {
|
||
/*
|
||
* event contains the type of the event and additional data if necessary.
|
||
* The event object is guaranteed to be valid only for the duration of the
|
||
* call.
|
||
*
|
||
* data is an object supplied at device initialization, opaque to the
|
||
* hardware.
|
||
*/
|
||
void (*notify)(struct tv_input_device* dev,
|
||
tv_input_event_t* event, void* data);
|
||
} tv_input_callback_ops_t;
|
||
|
||
enum {
|
||
TV_STREAM_TYPE_INDEPENDENT_VIDEO_SOURCE = 1,
|
||
TV_STREAM_TYPE_BUFFER_PRODUCER = 2,
|
||
};
|
||
typedef uint32_t tv_stream_type_t;
|
||
|
||
typedef struct tv_stream_config {
|
||
/*
|
||
* ID number of the stream. This value is used to identify the whole stream
|
||
* configuration.
|
||
*/
|
||
int stream_id;
|
||
|
||
/* Type of the stream */
|
||
tv_stream_type_t type;
|
||
|
||
/* Max width/height of the stream. */
|
||
uint32_t max_video_width;
|
||
uint32_t max_video_height;
|
||
} tv_stream_config_t;
|
||
|
||
typedef struct buffer_producer_stream {
|
||
/*
|
||
* IN/OUT: Width / height of the stream. Client may request for specific
|
||
* size but hardware may change it. Client must allocate buffers with
|
||
* specified width and height.
|
||
*/
|
||
uint32_t width;
|
||
uint32_t height;
|
||
|
||
/* OUT: Client must set this usage when allocating buffer. */
|
||
uint32_t usage;
|
||
|
||
/* OUT: Client must allocate a buffer with this format. */
|
||
uint32_t format;
|
||
} buffer_producer_stream_t;
|
||
|
||
typedef struct tv_stream {
|
||
/* IN: ID in the stream configuration */
|
||
int stream_id;
|
||
|
||
/* OUT: Type of the stream (for convenience) */
|
||
tv_stream_type_t type;
|
||
|
||
/* Data associated with the stream for client's use */
|
||
union {
|
||
/* OUT: A native handle describing the sideband stream source */
|
||
native_handle_t* sideband_stream_source_handle;
|
||
|
||
/* IN/OUT: Details are in buffer_producer_stream_t */
|
||
buffer_producer_stream_t buffer_producer;
|
||
};
|
||
} tv_stream_t;
|
||
|
||
/*
|
||
* Every device data structure must begin with hw_device_t
|
||
* followed by module specific public methods and attributes.
|
||
*/
|
||
typedef struct tv_input_device {
|
||
struct hw_device_t common;
|
||
|
||
/*
|
||
* initialize:
|
||
*
|
||
* Provide callbacks to the device and start operation. At first, no device
|
||
* is available and after initialize() completes, currently available
|
||
* devices including static devices should notify via callback.
|
||
*
|
||
* Framework owns callbacks object.
|
||
*
|
||
* data is a framework-owned object which would be sent back to the
|
||
* framework for each callback notifications.
|
||
*
|
||
* Return 0 on success.
|
||
*/
|
||
int (*initialize)(struct tv_input_device* dev,
|
||
const tv_input_callback_ops_t* callback, void* data);
|
||
|
||
/*
|
||
* get_stream_configurations:
|
||
*
|
||
* Get stream configurations for a specific device. An input device may have
|
||
* multiple configurations.
|
||
*
|
||
* The configs object is guaranteed to be valid only until the next call to
|
||
* get_stream_configurations() or STREAM_CONFIGURATIONS_CHANGED event.
|
||
*
|
||
* Return 0 on success.
|
||
*/
|
||
int (*get_stream_configurations)(const struct tv_input_device* dev,
|
||
int device_id, int* num_configurations,
|
||
const tv_stream_config_t** configs);
|
||
|
||
/*
|
||
* open_stream:
|
||
*
|
||
* Open a stream with given stream ID. Caller owns stream object, and the
|
||
* populated data is only valid until the stream is closed.
|
||
*
|
||
* Return 0 on success; -EBUSY if the client should close other streams to
|
||
* open the stream; -EEXIST if the stream with the given ID is already open;
|
||
* -EINVAL if device_id and/or stream_id are invalid; other non-zero value
|
||
* denotes unknown error.
|
||
*/
|
||
int (*open_stream)(struct tv_input_device* dev, int device_id,
|
||
tv_stream_t* stream);
|
||
|
||
/*
|
||
* close_stream:
|
||
*
|
||
* Close a stream to a device. data in tv_stream_t* object associated with
|
||
* the stream_id is obsolete once this call finishes.
|
||
*
|
||
* Return 0 on success; -ENOENT if the stream is not open; -EINVAL if
|
||
* device_id and/or stream_id are invalid.
|
||
*/
|
||
int (*close_stream)(struct tv_input_device* dev, int device_id,
|
||
int stream_id);
|
||
|
||
/*
|
||
* request_capture:
|
||
*
|
||
* Request buffer capture for a stream. This is only valid for buffer
|
||
* producer streams. The buffer should be created with size, format and
|
||
* usage specified in the stream. Framework provides seq in an
|
||
* increasing sequence per each stream. Hardware should provide the picture
|
||
* in a chronological order according to seq. For example, if two
|
||
* requests are being processed at the same time, the request with the
|
||
* smaller seq should get an earlier frame.
|
||
*
|
||
* The framework releases the ownership of the buffer upon calling this
|
||
* function. When the buffer is filled, hardware notifies the framework
|
||
* via TV_INPUT_EVENT_CAPTURE_FINISHED callback, and the ownership is
|
||
* transferred back to framework at that time.
|
||
*
|
||
* Return 0 on success; -ENOENT if the stream is not open; -EINVAL if
|
||
* device_id and/or stream_id are invalid; -EWOULDBLOCK if HAL cannot take
|
||
* additional requests until it releases a buffer.
|
||
*/
|
||
int (*request_capture)(struct tv_input_device* dev, int device_id,
|
||
int stream_id, buffer_handle_t buffer, uint32_t seq);
|
||
|
||
/*
|
||
* cancel_capture:
|
||
*
|
||
* Cancel an ongoing capture. Hardware should release the buffer as soon as
|
||
* possible via TV_INPUT_EVENT_CAPTURE_FAILED callback.
|
||
*
|
||
* Return 0 on success; -ENOENT if the stream is not open; -EINVAL if
|
||
* device_id, stream_id, and/or seq are invalid.
|
||
*/
|
||
int (*cancel_capture)(struct tv_input_device* dev, int device_id,
|
||
int stream_id, uint32_t seq);
|
||
|
||
void* reserved[16];
|
||
} tv_input_device_t;
|
||
|
||
__END_DECLS
|
||
|
||
#endif // ANDROID_TV_INPUT_INTERFACE_H
|