/*
 * Copyright (C) 2016 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 android.hardware.audio.effect@2.0;

import android.hardware.audio.common@2.0;

enum Result : int32_t {
    OK,
    NOT_INITIALIZED,
    INVALID_ARGUMENTS,
    INVALID_STATE,
    NOT_SUPPORTED,
    RESULT_TOO_BIG
};

/**
 * Effect engine capabilities/requirements flags.
 *
 * Definitions for flags field of effect descriptor.
 *
 * +----------------+--------+--------------------------------------------------
 * | description    | bits   | values
 * +----------------+--------+--------------------------------------------------
 * | connection     | 0..2   | 0 insert: after track process
 * | mode           |        | 1 auxiliary: connect to track auxiliary
 * |                |        |  output and use send level
 * |                |        | 2 replace: replaces track process function;
 * |                |        |   must implement SRC, volume and mono to stereo.
 * |                |        | 3 pre processing: applied below audio HAL on in
 * |                |        | 4 post processing: applied below audio HAL on out
 * |                |        | 5 - 7 reserved
 * +----------------+--------+--------------------------------------------------
 * | insertion      | 3..5   | 0 none
 * | preference     |        | 1 first of the chain
 * |                |        | 2 last of the chain
 * |                |        | 3 exclusive (only effect in the insert chain)
 * |                |        | 4..7 reserved
 * +----------------+--------+--------------------------------------------------
 * | Volume         | 6..8   | 0 none
 * | management     |        | 1 implements volume control
 * |                |        | 2 requires volume indication
 * |                |        | 4 reserved
 * +----------------+--------+--------------------------------------------------
 * | Device         | 9..11  | 0 none
 * | indication     |        | 1 requires device updates
 * |                |        | 2, 4 reserved
 * +----------------+--------+--------------------------------------------------
 * | Sample input   | 12..13 | 1 direct: process() function or
 * | mode           |        |   EFFECT_CMD_SET_CONFIG command must specify
 * |                |        |   a buffer descriptor
 * |                |        | 2 provider: process() function uses the
 * |                |        |   bufferProvider indicated by the
 * |                |        |   EFFECT_CMD_SET_CONFIG command to request input.
 * |                |        |   buffers.
 * |                |        | 3 both: both input modes are supported
 * +----------------+--------+--------------------------------------------------
 * | Sample output  | 14..15 | 1 direct: process() function or
 * | mode           |        |   EFFECT_CMD_SET_CONFIG command must specify
 * |                |        |   a buffer descriptor
 * |                |        | 2 provider: process() function uses the
 * |                |        |   bufferProvider indicated by the
 * |                |        |   EFFECT_CMD_SET_CONFIG command to request output
 * |                |        |   buffers.
 * |                |        | 3 both: both output modes are supported
 * +----------------+--------+--------------------------------------------------
 * | Hardware       | 16..17 | 0 No hardware acceleration
 * | acceleration   |        | 1 non tunneled hw acceleration: the process()
 * |                |        |   function reads the samples, send them to HW
 * |                |        |   accelerated effect processor, reads back
 * |                |        |   the processed samples and returns them
 * |                |        |   to the output buffer.
 * |                |        | 2 tunneled hw acceleration: the process()
 * |                |        |   function is transparent. The effect interface
 * |                |        |   is only used to control the effect engine.
 * |                |        |   This mode is relevant for global effects
 * |                |        |   actually applied by the audio hardware on
 * |                |        |   the output stream.
 * +----------------+--------+--------------------------------------------------
 * | Audio Mode     | 18..19 | 0 none
 * | indication     |        | 1 requires audio mode updates
 * |                |        | 2..3 reserved
 * +----------------+--------+--------------------------------------------------
 * | Audio source   | 20..21 | 0 none
 * | indication     |        | 1 requires audio source updates
 * |                |        | 2..3 reserved
 * +----------------+--------+--------------------------------------------------
 * | Effect offload | 22     | 0 The effect cannot be offloaded to an audio DSP
 * | supported      |        | 1 The effect can be offloaded to an audio DSP
 * +----------------+--------+--------------------------------------------------
 * | Process        | 23     | 0 The effect implements a process function.
 * | function       |        | 1 The effect does not implement a process
 * | not            |        |   function: enabling the effect has no impact
 * | implemented    |        |   on latency or CPU load.
 * |                |        |   Effect implementations setting this flag do not
 * |                |        |   have to implement a process function.
 * +----------------+--------+--------------------------------------------------
 */
@export(name="", value_prefix="EFFECT_FLAG_")
enum EffectFlags : int32_t {
    // Insert mode
    TYPE_SHIFT = 0,
    TYPE_SIZE = 3,
    TYPE_MASK = ((1 << TYPE_SIZE) -1) << TYPE_SHIFT,
    TYPE_INSERT = 0 << TYPE_SHIFT,
    TYPE_AUXILIARY = 1 << TYPE_SHIFT,
    TYPE_REPLACE = 2 << TYPE_SHIFT,
    TYPE_PRE_PROC = 3 << TYPE_SHIFT,
    TYPE_POST_PROC = 4 << TYPE_SHIFT,

    // Insert preference
    INSERT_SHIFT = TYPE_SHIFT + TYPE_SIZE,
    INSERT_SIZE = 3,
    INSERT_MASK = ((1 << INSERT_SIZE) -1) << INSERT_SHIFT,
    INSERT_ANY = 0 << INSERT_SHIFT,
    INSERT_FIRST = 1 << INSERT_SHIFT,
    INSERT_LAST = 2 << INSERT_SHIFT,
    INSERT_EXCLUSIVE = 3 << INSERT_SHIFT,

    // Volume control
    VOLUME_SHIFT = INSERT_SHIFT + INSERT_SIZE,
    VOLUME_SIZE = 3,
    VOLUME_MASK = ((1 << VOLUME_SIZE) -1) << VOLUME_SHIFT,
    VOLUME_CTRL = 1 << VOLUME_SHIFT,
    VOLUME_IND = 2 << VOLUME_SHIFT,
    VOLUME_NONE = 0 << VOLUME_SHIFT,

    // Device indication
    DEVICE_SHIFT = VOLUME_SHIFT + VOLUME_SIZE,
    DEVICE_SIZE = 3,
    DEVICE_MASK = ((1 << DEVICE_SIZE) -1) << DEVICE_SHIFT,
    DEVICE_IND = 1 << DEVICE_SHIFT,
    DEVICE_NONE = 0 << DEVICE_SHIFT,

    // Sample input modes
    INPUT_SHIFT = DEVICE_SHIFT + DEVICE_SIZE,
    INPUT_SIZE = 2,
    INPUT_MASK = ((1 << INPUT_SIZE) -1) << INPUT_SHIFT,
    INPUT_DIRECT = 1 << INPUT_SHIFT,
    INPUT_PROVIDER = 2 << INPUT_SHIFT,
    INPUT_BOTH = 3 << INPUT_SHIFT,

    // Sample output modes
    OUTPUT_SHIFT = INPUT_SHIFT + INPUT_SIZE,
    OUTPUT_SIZE = 2,
    OUTPUT_MASK = ((1 << OUTPUT_SIZE) -1) << OUTPUT_SHIFT,
    OUTPUT_DIRECT = 1 << OUTPUT_SHIFT,
    OUTPUT_PROVIDER = 2 << OUTPUT_SHIFT,
    OUTPUT_BOTH = 3 << OUTPUT_SHIFT,

    // Hardware acceleration mode
    HW_ACC_SHIFT = OUTPUT_SHIFT + OUTPUT_SIZE,
    HW_ACC_SIZE = 2,
    HW_ACC_MASK = ((1 << HW_ACC_SIZE) -1) << HW_ACC_SHIFT,
    HW_ACC_SIMPLE = 1 << HW_ACC_SHIFT,
    HW_ACC_TUNNEL = 2 << HW_ACC_SHIFT,

    // Audio mode indication
    AUDIO_MODE_SHIFT = HW_ACC_SHIFT + HW_ACC_SIZE,
    AUDIO_MODE_SIZE = 2,
    AUDIO_MODE_MASK = ((1 << AUDIO_MODE_SIZE) -1) << AUDIO_MODE_SHIFT,
    AUDIO_MODE_IND = 1 << AUDIO_MODE_SHIFT,
    AUDIO_MODE_NONE = 0 << AUDIO_MODE_SHIFT,

    // Audio source indication
    AUDIO_SOURCE_SHIFT = AUDIO_MODE_SHIFT + AUDIO_MODE_SIZE,
    AUDIO_SOURCE_SIZE = 2,
    AUDIO_SOURCE_MASK = ((1 << AUDIO_SOURCE_SIZE) -1) << AUDIO_SOURCE_SHIFT,
    AUDIO_SOURCE_IND = 1 << AUDIO_SOURCE_SHIFT,
    AUDIO_SOURCE_NONE = 0 << AUDIO_SOURCE_SHIFT,

    // Effect offload indication
    OFFLOAD_SHIFT = AUDIO_SOURCE_SHIFT + AUDIO_SOURCE_SIZE,
    OFFLOAD_SIZE = 1,
    OFFLOAD_MASK = ((1 << OFFLOAD_SIZE) -1) << OFFLOAD_SHIFT,
    OFFLOAD_SUPPORTED = 1 << OFFLOAD_SHIFT,

    // Effect has no process indication
    NO_PROCESS_SHIFT = OFFLOAD_SHIFT + OFFLOAD_SIZE,
    NO_PROCESS_SIZE = 1,
    NO_PROCESS_MASK = ((1 << NO_PROCESS_SIZE) -1) << NO_PROCESS_SHIFT,
    NO_PROCESS = 1 << NO_PROCESS_SHIFT
};

/**
 * The effect descriptor contains necessary information to facilitate the
 * enumeration of the effect engines present in a library.
 */
struct EffectDescriptor {
    Uuid type;             // UUID of to the OpenSL ES interface implemented
                           // by this effect
    Uuid uuid;             // UUID for this particular implementation
    EffectFlags flags;     // effect engine capabilities/requirements flags
    uint16_t cpuLoad;      // CPU load indication expressed in 0.1 MIPS units
                           // as estimated on an ARM9E core (ARMv5TE) with 0 WS
    uint16_t memoryUsage;  // data memory usage expressed in KB and includes
                           // only dynamically allocated memory
    uint8_t[64] name;      // human readable effect name
    uint8_t[64] implementor;  // human readable effect implementor name
};

/**
 * A buffer is a chunk of audio data for processing.  Multi-channel audio is
 * always interleaved. The channel order is from LSB to MSB with regard to the
 * channel mask definition in audio.h, audio_channel_mask_t, e.g.:
 * Stereo: L, R; 5.1: FL, FR, FC, LFE, BL, BR.
 *
 * The buffer size is expressed in frame count, a frame being composed of
 * samples for all channels at a given time. Frame size for unspecified format
 * (AUDIO_FORMAT_OTHER) is 8 bit by definition.
 */
struct AudioBuffer {
    uint64_t id;
    uint32_t frameCount;
    memory data;
};

@export(name="effect_buffer_access_e", value_prefix="EFFECT_BUFFER_")
enum EffectBufferAccess : int32_t {
    ACCESS_WRITE,
    ACCESS_READ,
    ACCESS_ACCUMULATE
};

/**
 * Determines what fields of EffectBufferConfig need to be considered.
 */
@export(name="", value_prefix="EFFECT_CONFIG_")
enum EffectConfigParameters : int32_t {
    BUFFER = 0x0001,    // buffer field
    SMP_RATE = 0x0002,  // samplingRate
    CHANNELS = 0x0004,  // channels
    FORMAT = 0x0008,    // format
    ACC_MODE = 0x0010,  // accessMode
    ALL = BUFFER | SMP_RATE | CHANNELS | FORMAT | ACC_MODE
};

/**
 * The buffer config structure specifies the input or output audio format
 * to be used by the effect engine.
 */
struct EffectBufferConfig {
    AudioBuffer buffer;
    uint32_t samplingRateHz;
    AudioChannelMask channels;
    AudioFormat format;
    EffectBufferAccess accessMode;
    EffectConfigParameters mask;
};

struct EffectConfig {
    EffectBufferConfig inputCfg;
    EffectBufferConfig outputCfg;
};

@export(name="effect_feature_e", value_prefix="EFFECT_FEATURE_")
enum EffectFeature : int32_t {
    AUX_CHANNELS, // supports auxiliary channels
                  // (e.g. dual mic noise suppressor)
    CNT
};

struct EffectAuxChannelsConfig {
    AudioChannelMask mainChannels;  // channel mask for main channels
    AudioChannelMask auxChannels;   // channel mask for auxiliary channels
};

struct EffectOffloadParameter {
    bool isOffload;          // true if the playback thread the effect
                             // is attached to is offloaded
    AudioIoHandle ioHandle;  // io handle of the playback thread
                             // the effect is attached to
};

/**
 * The message queue flags used to synchronize reads and writes from
 * the status message queue used by effects.
 */
enum MessageQueueFlagBits : uint32_t {
    DONE_PROCESSING = 1 << 0,
    REQUEST_PROCESS = 1 << 1,
    REQUEST_PROCESS_REVERSE = 1 << 2,
    REQUEST_QUIT = 1 << 3,
    REQUEST_PROCESS_ALL =
        REQUEST_PROCESS | REQUEST_PROCESS_REVERSE | REQUEST_QUIT
};