/*
 * Copyright (c) 2019 The Linux Foundation. All rights reserved.

 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *  Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *  Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following
 * disclaimer in the documentation and/or other materials provided
 * with the distribution.
 *  Neither the name of The Linux Foundation. nor the names of its
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.

 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 * Not a Contribution.

 * Copyright (C) 2011 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.
 */

package vendor.qti.hardware.display.mapperextensions@1.0;


enum Error : int32_t {
    NONE            = 0,
    BAD_BUFFER      = 2,
    NO_RESOURCES    = 5,
    UNSUPPORTED     = 7,
};

struct YCbCrLayout {
    pointer y;
    pointer cb;
    pointer cr;
    uint32_t yStride;
    uint32_t cStride;
    uint32_t chromaStep;
};

/**
 * Plane Component type definitions.
 */
enum PlaneComponent : uint32_t {
     /* luma */
     PLANE_COMPONENT_Y = 1 << 0,
     /* chroma blue */
     PLANE_COMPONENT_Cb = 1 << 1,
     /* chroma red */
     PLANE_COMPONENT_Cr = 1 << 2,

     /* red */
     PLANE_COMPONENT_R = 1 << 10,
     /* green */
     PLANE_COMPONENT_G = 1 << 11,
     /* blue */
     PLANE_COMPONENT_B = 1 << 12,

     /* alpha */
     PLANE_COMPONENT_A = 1 << 20,

     /* raw data plane */
     PLANE_COMPONENT_RAW = 1 << 30,

     /* meta information plane */
     PLANE_COMPONENT_META = 1 << 31,
};

/**
 * Flags to send with getFormatLayout for extra information for e.g. interlaced,
 * otherwise send 0.
 */
enum Flags : int32_t {
     /* flag to send for interlace */
     LAYOUT_INTERLACED_FLAG = 1 << 0,
};

/**
 * Structure for describing plane layout information for YUVA/RGBA/RAW formats
 * YUV formats can be planar or semi-planar.
 *
 * This layout structure is used with any pixel format that can be
 * represented by it, such as:
 *  - HAL_PIXEL_FORMAT_YCbCr_*
 *  - HAL_PIXEL_FORMAT_RGB*_*
 *  - even implementation defined formats that can be represented by
 *    the structures
 *
 * Each plane can be made up of one or more PlaneComponents depending on
 * the format.
 *
 * Each plane can be subsampled either vertically or horizontally by
 * a power-of-two factor.
 *
 * Pixel increment describes the distance in bytes from one pixel to the
 * next pixel (to the right) on the same row for the component plane.
 * This can be negative.
 *
 * Stride is provided in both pixels and bytes.
 * Stride_bytes describes the distance in bytes from the first pixel of
 * one row to the first pixel of the next row (below) for the component plane.
 * This can be negative.
 *
 * Scanlines describes the height of the plane in terms of number of rows.
 *
 * Size of plane is stride_bytes * scanlines + any padding required for
 * alignment as per format specification.
 *
 */
struct PlaneLayout {

     /** Fields below provide the plane layout requirements.
      *  Values of these fields are specific to the format being
      *  described and are fixed. They do not depend on actual image
      *  width and height.
      */
     /** Components represented by the plane. */
     bitfield<PlaneComponent> component;

     /** horizontal subsampling. Must be a positive power of 2. */
     uint32_t h_subsampling;

     /** vertical subsampling. Must be a positive power of 2. */
     uint32_t v_subsampling;

     /** offset to the first byte of the top-left pixel of the plane
      *  and it is calculated from the start of the buffer.
      *  Add base of the handle with offset to get the first byte of the plane.
      */
     uint32_t offset;

     /** pixel increment */
     int32_t pixel_increment;

     /** Fields below will have values that are calcuated based
      *  on provided image width and height.
      */
     /** row width or horizontal stride in pixels */
     int32_t stride;

     /** row width or horzontal stride in bytes */
     int32_t stride_bytes;

     /** plane height or vertical stride */
     int32_t scanlines;

     /** Size of the plane in bytes */
     uint32_t size;
};