xref: /frameworks/av/media/libstagefright/codec2/include/C2Work.h

/*
 * 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.
 */

#ifndef C2WORK_H_

#define C2WORK_H_

#include <stdint.h>
#include <stdbool.h>
#include <C2Param.h>
#include <C2Buffer.h>
#include <C2Config.h>

#include <memory>
#include <list>
#include <vector>

typedef int status_t;

namespace android {

/// \defgroup work Work and data processing
/// @{

struct C2SettingResult {
    enum Failure {
        READ_ONLY,  ///< parameter is read-only and cannot be set
        MISMATCH,   ///< parameter mismatches input data
        BAD_VALUE,  ///< parameter does not accept value
        BAD_TYPE,   ///< parameter is not supported
        BAD_PORT,   ///< parameter is not supported on the specific port
        BAD_INDEX,  ///< parameter is not supported on the specific stream
        CONFLICT,   ///< parameter is in conflict with another setting
    };

    C2ParamField field;
    Failure failure;
    std::unique_ptr<C2FieldSupportedValues> supportedValues; //< if different from normal (e.g. in conflict w/another param or input data)
    std::list<C2ParamField> conflictingFields;
};

// ================================================================================================
//  WORK
// ================================================================================================

// node_id-s
typedef uint32_t node_id;

enum flags_t : uint32_t {
    BUFFERFLAG_CODEC_CONFIG,
    BUFFERFLAG_DROP_FRAME,
    BUFFERFLAG_END_OF_STREAM,
};

enum {
    kParamIndexWorkOrdinal,
};

struct C2WorkOrdinalStruct {
    uint64_t timestamp;
    uint64_t frame_index;    // submission ordinal on the initial component
    uint64_t custom_ordinal; // can be given by the component, e.g. decode order

    DEFINE_AND_DESCRIBE_C2STRUCT(WorkOrdinal)
    C2FIELD(timestamp, "timestamp")
    C2FIELD(frame_index, "frame-index")
    C2FIELD(custom_ordinal, "custom-ordinal")
};

struct C2BufferPack {
//public:
    flags_t  flags;
    C2WorkOrdinalStruct ordinal;
    std::vector<std::shared_ptr<C2Buffer>> buffers;
    //< for initial work item, these may also come from the parser - if provided
    //< for output buffers, these are the responses to requestedInfos
    std::list<std::unique_ptr<C2Info>>       infos;
    std::list<std::shared_ptr<C2InfoBuffer>> infoBuffers;
};

struct C2Worklet {
//public:
    // IN
    node_id component;

    std::list<std::unique_ptr<C2Param>> tunings; //< tunings to be applied before processing this
                                                 // worklet
    std::list<C2Param::Type> requestedInfos;
    std::vector<std::shared_ptr<C2BlockAllocator>> allocators; //< This vector shall be the same size as
                                                          //< output.buffers.

    // OUT
    C2BufferPack output;
    std::list<std::unique_ptr<C2SettingResult>> failures;
};

/**
 * This structure holds information about all a single work item.
 *
 * This structure shall be passed by the client to the component for the first worklet. As such,
 * worklets must not be empty. The ownership of this object is passed.
 *
 * input:
 *      The input data to be processed. This is provided by the client with ownership. When the work
 *      is returned, the input buffer-pack's buffer vector shall contain nullptrs.
 *
 * worklets:
 *      The chain of components and associated allocators, tunings and info requests that the data
 *      must pass through. If this has more than a single element, the tunnels between successive
 *      components of the worklet chain must have been (successfully) pre-registered at the time
 *      the work is submitted. Allocating the output buffers in the worklets is the responsibility
 *      of each component. Upon work submission, each output buffer-pack shall be an appropriately
 *      sized vector containing nullptrs. When the work is completed/returned to the client,
 *
 * worklets_processed:
 *      It shall be initialized to 0 by the client when the work is submitted.
 *      It shall contain the number of worklets that were successfully processed when the work is
 *      returned. If this is less then the number of worklets, result must not be success.
 *      It must be in the range of [0, worklets.size()].
 *
 * result:
 *      The final outcome of the work. If 0 when work is returned, it is assumed that all worklets
 *      have been processed.
 */
struct C2Work {
//public:
    // pre-chain infos (for portions of a tunneling chain that happend before this work-chain for
    // this work item - due to framework facilitated (non-tunneled) work-chaining)
    std::list<std::pair<std::unique_ptr<C2PortMimeConfig>, std::unique_ptr<C2Info>>> preChainInfos;
    std::list<std::pair<std::unique_ptr<C2PortMimeConfig>, std::unique_ptr<C2Buffer>>> preChainInfoBlobs;

    C2BufferPack input;
    std::list<std::unique_ptr<C2Worklet>> worklets;

    uint32_t worklets_processed;
    status_t result;
};

struct C2WorkOutline {
//public:
    C2WorkOrdinalStruct ordinal;
    std::list<node_id> chain;
};

/// @}

}  // namespace android

#endif  // C2WORK_H_