// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

library fuchsia.hardware.display.controller;

using fuchsia.hardware.audiotypes;
using zx;

//using ZxPixelFormat = uint32;
enum ZxPixelFormat : uint32 {
};

// using ZxUnownedHandle = uint32;
// TODO(fxbug.dev/33170) replace with normal banjo type.
enum ZxUnownedHandle : uint32 {
};

enum ImageType : uint32 {
    /// The image is linear and VMO backed.
    SIMPLE = 0;

    // Intentionally left some gap between SIMPLE and CAPTURE.

    /// The image is used for capture
    CAPTURE = 10;
};

/// A structure containing information about an image.
struct Image {
    /// The width and height of the image in pixels.
    uint32 width;
    uint32 height;

    /// The pixel format of the image.
    ZxPixelFormat pixel_format;

    /// The type conveys information about what is providing the pixel data. If this is not
    /// IMAGE_TYPE_SIMPLE, it is up to the driver and buffer producer to agree on the meaning
    /// of the value through some mechanism outside the scope of this API.
    uint32 type;

    /// A driver-defined handle to the image. Each handle must be unique.
    uint64 @handle;
};

const uint32 INVALID_DISPLAY_ID = 0;
const uint32 INVALID_ID = 0;

/// A fallback structure to convey display information without an edid.
struct DisplayParams {
    uint32 width;
    uint32 height;
    uint32 refresh_rate_e2;
};

/// Info about valid cursor configurations.
struct CursorInfo {
    /// The width and height of the cursor configuration, in pixels.
    uint32 width;
    uint32 height;
    ZxPixelFormat format;
};

union Panel {
    /// The bus_id to use to read this display's edid from the device's i2c protocol.
    1: uint32 i2c_bus_id;
    /// The display's parameters if an edid is not present.
    2: DisplayParams params;
};

/// A structure containing information a connected display.
struct AddedDisplayArgs {
    uint64 display_id;

    /// A flag indicating whether or not the display has a valid edid.
    ///
    /// If true, the device should expose an ZX_PROTOCOL_I2C_IMPL device through get_protocol, in
    /// addition to the ZX_PROTOCOL_DISPLAY_CONTROLLER_IMPL protocol. Note that the i2c device
    /// will be called from the on_displays_changed callback, so care should be taken to avoid
    /// deadlocks or double-locking.
    ///
    /// If no edid is present, then the meaning of display_config's mode structure is
    /// undefined, and drivers should ignore it in check_configuration and apply_configuration.
    bool edid_present;
    Panel panel;

    /// A list of pixel formats supported by the display. The first entry is the
    /// preferred pixel format.
    vector<ZxPixelFormat> pixel_format;

    /// A list of cursor configurations most likely to be accepted by the driver. Can
    /// be null if cursor_count is 0.
    ///
    /// The driver may reject some of these configurations in some circumstances, and
    /// it may accept other configurations, but at least one of these configurations
    /// should be valid at most times.
    vector<CursorInfo> cursor_info;
};

/// Out parameters will be populated before on_displays_changed returns.
struct AddedDisplayInfo {
    bool is_hdmi_out;
    bool is_standard_srgb_out;

    uint32 audio_format_count;

    /// All strings are null-terminated. |manufacturer_id| is guaranteed to have
    /// length 3, all other strings may be empty.
    string:4 manufacturer_id;
    /// non-null
    string manufacturer_name;
    /// null-terminated
    string:14 monitor_name;
    /// null-terminated
    string:14 monitor_serial;

    // physical horizontal size in millimeters
    uint32 horizontal_size_mm;
    // physical vertical size in millimeters
    uint32 vertical_size_mm;
};

/// The client will not make any `ZX_PROTOCOL_DISPLAY_CONTROLLER_IMPL` calls into the device
/// during these callbacks.
[Transport = "Banjo", BanjoLayout = "ddk-interface"]
protocol DisplayControllerInterface {
    /// Callbacks which are invoked when displays are added or removed. |added_display_list| and
    /// |removed_display_list| point to arrays of the display ids which were added and removed. If
    /// |added_display_count| or |removed_display_count| is 0, the corresponding array can be NULL.
    ///
    /// The driver must be done accessing any images which were on the removed displays.
    ///
    /// The driver should call this function when the callback is registered if any displays
    /// are present.
    OnDisplaysChanged(vector<AddedDisplayArgs> added_display,
                      vector<uint64> removed_display) -> (vector<AddedDisplayInfo> display_info);

    /// |timestamp| is the ZX_CLOCK_MONOTONIC timestamp at which the vsync occurred.
    /// |handles| points to an array of image handles of each framebuffer being
    /// displayed, in increasing z-order.
    ///
    /// The driver must call this function for all vsync events, even
    /// if the display has no images displayed.
    OnDisplayVsync(uint64 display_id, zx.time timestamp, vector<uint64> @handle) -> ();

    GetAudioFormat(uint64 display_id, uint32 fmt_idx)
               -> (zx.status s, fuchsia.hardware.audiotypes.AudioTypesAudioStreamFormatRange fmt);
};

enum Alpha : uint8 {
    DISABLE = 0;
    PREMULTIPLIED = 1;
    HW_MULTIPLY = 2;
};

/// Rotations are applied counter-clockwise, and are applied before reflections.
enum FrameTransform : uint32 {
    IDENTITY = 0;
    REFLECT_X = 1;
    REFLECT_Y = 2;
    ROT_90 = 3;
    ROT_180 = 4;
    ROT_270 = 5;
    ROT_90_REFLECT_X = 6;
    ROT_90_REFLECT_Y = 7;
};

struct Frame {
    /// (|x_pos|, |y_pos|) specifies the position of the upper-left corner
    /// of the frame.
    uint32 x_pos;
    uint32 y_pos;
    uint32 width;
    uint32 height;
};

struct PrimaryLayer {
    Image image;

    /// An ALPHA_* constant.
    ///
    /// If |alpha_mode| == `ALPHA_DISABLED`, the layer is opaque and alpha_layer_val is ignored.
    ///
    /// If |alpha_mode| == `PREMULTIPLIED` or `HW_MULTIPLY` and |alpha_layer_val| is NaN, the alpha
    /// used when blending is determined by the per-pixel alpha channel.
    ///
    /// If |alpha_mode| == `PREMULTIPLIED` or `HW_MULTIPLY` and |alpha_layer_val| is not NaN, the
    /// alpha used when blending is the product of alpha_layer_val and any per-pixel alpha.
    /// Additionally, if alpha_mode == PREMULTIPLIED, then the hardware must premultiply the color
    /// channel with alpha_layer_val before blending.
    ///
    /// If alpha_layer_val is not NaN, it will be in the range [0, 1].
    Alpha alpha_mode;
    float32 alpha_layer_val;

    FrameTransform transform_mode;

    /// The source frame, where (0,0) is the top-left corner of the image. The
    /// client guarantees that src_frame lies entirely within the image.
    Frame src_frame;

    /// The destination frame, where (0,0) is the top-left corner of the
    /// composed output. The client guarantees that dest_frame lies entirely
    /// within the composed output.
    Frame dest_frame;
};

struct CursorLayer {
    Image image;

    /// The position of the top-left corner of the cursor's image. When being
    /// applied to a display, the cursor is guaranteed to have at least one
    /// pixel of overlap with the display.
    int32 x_pos;
    int32 y_pos;
};

struct ColorLayer {
    ZxPixelFormat format;
    /// The color to use for the layer. The color is little-endian, and is
    /// guaranteed to be of the appropriate size.
    vector<uint8> color;
};

/// Types of layers.
enum LayerType : uint32 {
    PRIMARY = 0;
    CURSOR = 1;
    COLOR = 2;
};

union LayerConfig {
    1: PrimaryLayer primary;
    2: CursorLayer cursor;
    3: ColorLayer color;
};

struct Layer {
    LayerType type;
    /// z_index of the layer. See |check_configuration| and |apply_configuration|.
    uint32 z_index;
    LayerConfig cfg;
};

/// constants for display_config's mode_flags field
enum ModeFlag : uint32 {
    VSYNC_POSITIVE = 0x1;
    HSYNC_POSITIVE = 0x2;
    INTERLACED = 0x4;
    ALTERNATING_VBLANK = 0x8;
    DOUBLE_CLOCKED = 0x10;
};

/// The video parameters which specify the display mode.
struct DisplayMode {
    uint32 pixel_clock_10khz;
    uint32 h_addressable;
    uint32 h_front_porch;
    uint32 h_sync_pulse;
    uint32 h_blanking;
    uint32 v_addressable;
    uint32 v_front_porch;
    uint32 v_sync_pulse;
    uint32 v_blanking;
    /// A bitmask of MODE_FLAG_* values
    uint32 flags;
};

enum ColorConversion : uint32 {
    /// If set, use the 0 vector for the color conversion preoffset
    PREOFFSET = 0x1;
    /// If set, use the identity matrix for the color conversion coefficients
    COEFFICIENTS = 0x2;
    /// If set, use the 0 vector for the color conversion postoffset
    POSTOFFSET = 0x4;
};

struct DisplayConfig {
    /// the display id to which the configuration applies
    uint64 display_id;

    DisplayMode mode;

    /// Bitmask of COLOR_CONVERSION_* flags
    uint32 cc_flags;
    /// Color conversion is applied to each pixel according to the formula:
    ///
    /// (cc_coefficients * (pixel + cc_preoffsets)) + cc_postoffsets
    ///
    /// where pixel is a column vector consisting of the pixel's 3 components.
    array<float32>:3 cc_preoffsets;
    array<array<float32>:3>:3 cc_coefficients;
    array<float32>:3 cc_postoffsets;

    [Mutable, OutOfLineContents] vector<Layer> layer;

    /// Flag to indicate valid gamma table
    bool gamma_table_present;
    /// Flag to indicate whether display driver should re-apply gamma correction table to hardware
    bool apply_gamma_table;
    /// Gamma Table (Red, Green and Blue)
    [Mutable] vector<float32> gamma_red;
    [Mutable] vector<float32> gamma_green;
    [Mutable] vector<float32> gamma_blue;
};

enum ConfigDisplay : uint32 {
    /// The display mode configuration is valid. Note that this is distinct from
    /// whether or not the layer configuration is valid.
    OK = 0;
    /// Error indicating that the hardware cannot simultaneously support the
    /// requested number of displays.
    TOO_MANY = 1;
    /// Error indicating that the hardware cannot simultaneously support the given
    /// set of display modes. To support a mode, the display must be able to display
    /// a single layer with width and height equal to the requested mode and the
    /// preferred pixel format.
    UNSUPPORTED_MODES = 2;
};

enum Client : uint32 {
    /// The client should convert the corresponding layer to a primary layer.
    USE_PRIMARY = 0x1;
    /// The client should compose all layers with MERGE_BASE and MERGE_SRC into a new,
    /// single primary layer at the MERGE_BASE layer's z-order. The driver must accept
    /// a fullscreen layer with the default pixel format, but may accept other layer
    /// parameters.
    ///
    /// MERGE_BASE should only be set on one layer per display. If it is set on multiple
    /// layers, the client will arbitrarily pick one and change the rest to MERGE_SRC.
    MERGE_BASE = 0x2;
    MERGE_SRC = 0x4;
    /// The client should pre-scale the image so that src_frame's dimensions are equal
    /// to dest_frame's dimensions.
    FRAME_SCALE = 0x8;
    /// The client should pre-clip the image so that src_frame's dimensions are equal to
    /// the image's dimensions.
    SRC_FRAME = 0x10;
    /// The client should pre-apply the transformation so TRANSFORM_IDENTITY can be used.
    TRANSFORM = 0x20;
    /// The client should apply the color conversion.
    COLOR_CONVERSION = 0x40;
    /// The client should apply the alpha transformation itself.
    ALPHA = 0x80;
    /// The client cannot control the display gamma, and must accept
    /// the uncalibrated output. Clients are expected to produce linear
    /// buffers, and as such they cannot perform software gamma
    /// correction.
    GAMMA = 0x100;

};

/// The client guarantees that check_configuration and apply_configuration are always
/// made from a single thread. The client makes no other threading guarantees.
[Transport = "Banjo", BanjoLayout = "ddk-protocol"]
protocol DisplayControllerImpl {
    /// The function will only be called once, and it will be called before any other
    /// functions are called.
    SetDisplayControllerInterface(DisplayControllerInterface intf) -> ();

    /// Imports a VMO backed image into the driver. The driver should set image->handle. The
    /// driver does not own the vmo handle passed to this function.
    ImportVmoImage([InOut] Image image, zx.handle:VMO vmo, uint64 offset) -> (zx.status s);

    /// Imports an image from a buffer collection into the driver. The driver should set
    /// image->handle.
    ImportImage([InOut] Image image, ZxUnownedHandle collection, uint32 index)
        -> (zx.status s);

    /// Releases any driver state associated with the given image. The client guarantees that
    /// any images passed to apply_config will not be released until a vsync occurs with a
    /// more recent image.
    ReleaseImage([InOut] Image image) -> ();

    /// Validates the given configuration.
    ///
    /// The configuration may not include all displays. Omitted displays should be treated as
    /// whichever of off or displaying a blank screen results in a more permissive validation.
    ///
    /// All displays in a configuration will have at least one layer. The layers will be
    /// arranged in increasing z-order, and their z_index fields will be set consecutively.
    ///
    /// Whether or not the driver can accept the configuration cannot depend on the
    /// particular image handles, as it must always be possible to present a new image in
    /// place of another image with a matching configuration. It also cannot depend on the
    /// cursor position, as that can be updated without another call to check_configuration.
    ///
    /// display_cfg_result should be set to a CONFIG_DISPLAY_* error if the combination of
    /// display modes is not supported.
    ///
    /// layer_cfg_result points to an array of arrays. The primary length is display_count, the
    /// secondary lengths are the corresponding display_cfg's layer_count. If display_cfg_result
    /// is CONFIG_DISPLAY_OK, any errors in layer configuration should be returned as a CLIENT*
    /// flag in the corresponding layer_cfg_result entry.
    ///
    /// The driver must not retain references to the configuration after this function returns.
    /// TODO: Fix me...
    CheckConfiguration([InnerPointer] vector<DisplayConfig> display_config)
                       -> (uint32 display_cfg_result, [CalleeAllocated] vector<uint32> layer_cfg_result);

    /// Applies the configuration.
    ///
    /// All configurations passed to this function will be derived from configurations which
    /// have been successfully validated, with the only differences either being omitted layers
    /// or different image handles. To account for any layers which are not present, the driver
    /// must use the z_index values of the present layers to configure them as if the whole
    /// configuration was present.
    ///
    /// Unlike with check_configuration, displays included in the configuration are not
    /// guaranteed to include any layers. Both omitted displays and displays with no layers
    /// can either be turned off or set to display a blank screen, but for displays with no
    /// layers there is a strong preference to display a blank screen instead of turn them off.
    /// In either case, the driver must drop all references to old images and invoke the vsync
    /// callback after doing so.
    ///
    /// The driver must not retain references to the configuration after this function returns.
    ApplyConfiguration([InnerPointer] vector<DisplayConfig> display_config) -> ();

    /// Set ELD for one display.
    ///
    /// This method is called independently from the CheckConfiguration and ApplyConfiguration
    /// methods. The display_id may be unconfigured at the time this method is called.
    /// raw_eld is the ELD raw data formatted according to the HDA specification version 1.0a
    /// section 7.3.3.34.1.
    /// https://www.intel.com/content/dam/www/public/us/en/documents/product-specifications/high-definition-audio-specification.pdf
    /// The driver must not retain references to the ELD after this function returns.
    SetEld(uint64 display_id, vector<uint8> raw_eld) -> ();

    // Connects the handle to the sysmem service.
    GetSysmemConnection(zx.handle:CHANNEL sysmem_handle) -> (zx.status s);

    // Set sysmem buffer collection contraints needed to ensure an image can be imported with config
    // |config| on the fuchsia.sysmem.BufferCollection handle |collection|.
    SetBufferCollectionConstraints(Image config, ZxUnownedHandle collection) -> (zx.status s);

    // If the system only supports single-buffered mode with a single framebuffer, then this returns
    // that buffer and its stride. Otherwise it can return ZX_ERR_NOT_SUPPORTED.
    GetSingleBufferFramebuffer() -> (zx.status res, zx.handle:VMO vmo, uint32 stride);
};