/* * 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 C2CONFIG_H_ #define C2CONFIG_H_ #include #include #include #include /// \defgroup config Component configuration /// @{ /** * Enumerated boolean. */ C2ENUM(c2_bool_t, uint32_t, C2_FALSE, ///< true C2_TRUE, ///< false ) typedef C2SimpleValueStruct C2BoolValue; typedef C2SimpleValueStruct> C2EasyBoolValue; /** * Enumerated set tri-state. * * Used for optional configurations to distinguish between values set by the client, * default values set by the component, or unset values. */ C2ENUM(c2_set_t, uint32_t, C2_UNSET, // parameter is unset and has no value C2_SET, // parameter is/has been set by the client C2_DEFAULT, // parameter has not been set by the client, but is set by the component ) /** Enumerations used by configuration parameters */ struct C2Config { enum aac_packaging_t : uint32_t; ///< AAC packaging (RAW vs ADTS) enum aac_sbr_mode_t : uint32_t; ///< AAC SBR mode enum api_feature_t : uint64_t; ///< API features enum api_level_t : uint32_t; ///< API level enum bitrate_mode_t : uint32_t; ///< bitrate control mode enum drc_compression_mode_t : int32_t; ///< DRC compression mode enum drc_effect_type_t : int32_t; ///< DRC effect type enum intra_refresh_mode_t : uint32_t; ///< intra refresh modes enum level_t : uint32_t; ///< coding level enum ordinal_key_t : uint32_t; ///< work ordering keys enum pcm_encoding_t : uint32_t; ///< PCM encoding enum picture_type_t : uint32_t; ///< picture types enum platform_feature_t : uint64_t; ///< platform features enum platform_level_t : uint32_t; ///< platform level enum prepend_header_mode_t : uint32_t; ///< prepend header operational modes enum profile_t : uint32_t; ///< coding profile enum scaling_method_t : uint32_t; ///< scaling methods enum scan_order_t : uint32_t; ///< scan orders enum secure_mode_t : uint32_t; ///< secure/protected modes enum supplemental_info_t : uint32_t; ///< supplemental information types enum tiling_mode_t : uint32_t; ///< tiling modes }; namespace { enum C2ParamIndexKind : C2Param::type_index_t { C2_PARAM_INDEX_INVALID = 0x0, ///< do not use C2_PARAM_INDEX_STRUCT_START = 0x1, ///< struct only indices C2_PARAM_INDEX_PARAM_START = 0x800, ///< regular parameters C2_PARAM_INDEX_CODER_PARAM_START = 0x1000, ///< en/transcoder parameters C2_PARAM_INDEX_PICTURE_PARAM_START = 0x1800, ///< image/video parameters C2_PARAM_INDEX_VIDEO_PARAM_START = 0x2000, ///< video parameters C2_PARAM_INDEX_IMAGE_PARAM_START = 0x2800, ///< image parameters C2_PARAM_INDEX_AUDIO_PARAM_START = 0x3000, ///< image parameters C2_PARAM_INDEX_PLATFORM_START = 0x4000, ///< platform-defined parameters /* =================================== structure indices =================================== */ kParamIndexColorXy = C2_PARAM_INDEX_STRUCT_START, kParamIndexMasteringDisplayColorVolume, kParamIndexChromaOffset, kParamIndexGopLayer, /* =================================== parameter indices =================================== */ kParamIndexApiLevel = C2_PARAM_INDEX_PARAM_START, kParamIndexApiFeatures, /* ------------------------------------ all components ------------------------------------ */ /* generic component characteristics */ kParamIndexName, kParamIndexAliases, kParamIndexKind, kParamIndexDomain, kParamIndexAttributes, kParamIndexTimeStretch, /* coding characteristics */ kParamIndexProfileLevel, kParamIndexInitData, kParamIndexSupplementalData, kParamIndexSubscribedSupplementalData, /* pipeline characteristics */ kParamIndexMediaType, kParamIndexDelayRequest, kParamIndexDelay, kParamIndexMaxReferenceAge, kParamIndexMaxReferenceCount, kParamIndexReorderBufferDepth, kParamIndexReorderKey, kParamIndexStreamCount, kParamIndexSubscribedParamIndices, kParamIndexSuggestedBufferCount, kParamIndexBatchSize, kParamIndexCurrentWork, kParamIndexLastWorkQueued, /* memory allocation */ kParamIndexAllocators, kParamIndexBlockPools, kParamIndexBufferType, kParamIndexUsage, kParamIndexOutOfMemory, kParamIndexMaxBufferSize, /* misc. state */ kParamIndexTripped, kParamIndexConfigCounter, /* resources */ kParamIndexResourcesNeeded, kParamIndexResourcesReserved, kParamIndexOperatingRate, kParamIndexRealTimePriority, /* protected content */ kParamIndexSecureMode, /* ------------------------------------ (trans/en)coders ------------------------------------ */ kParamIndexBitrate = C2_PARAM_INDEX_CODER_PARAM_START, kParamIndexBitrateMode, kParamIndexQuality, kParamIndexComplexity, kParamIndexPrependHeaderMode, /* --------------------------------- image/video components --------------------------------- */ kParamIndexPictureSize = C2_PARAM_INDEX_PICTURE_PARAM_START, kParamIndexCropRect, kParamIndexPixelFormat, kParamIndexRotation, kParamIndexPixelAspectRatio, kParamIndexScaledPictureSize, kParamIndexScaledCropRect, kParamIndexScalingMethod, kParamIndexColorInfo, kParamIndexColorAspects, kParamIndexHdrStaticMetadata, kParamIndexDefaultColorAspects, kParamIndexBlockSize, kParamIndexBlockCount, kParamIndexBlockRate, kParamIndexPictureTypeMask, kParamIndexPictureType, kParamIndexHdr10PlusMetadata, /* ------------------------------------ video components ------------------------------------ */ kParamIndexFrameRate = C2_PARAM_INDEX_VIDEO_PARAM_START, kParamIndexMaxBitrate, kParamIndexMaxFrameRate, kParamIndexMaxPictureSize, kParamIndexGop, kParamIndexSyncFrameInterval, kParamIndexRequestSyncFrame, kParamIndexTemporalLayering, kParamIndexLayerIndex, kParamIndexLayerCount, kParamIndexIntraRefresh, /* ------------------------------------ image components ------------------------------------ */ kParamIndexTileLayout = C2_PARAM_INDEX_IMAGE_PARAM_START, kParamIndexTileHandling, /* ------------------------------------ audio components ------------------------------------ */ kParamIndexSampleRate = C2_PARAM_INDEX_AUDIO_PARAM_START, kParamIndexChannelCount, kParamIndexPcmEncoding, kParamIndexAacPackaging, kParamIndexMaxChannelCount, kParamIndexAacSbrMode, // aac encode, enum kParamIndexDrcEncodedTargetLevel, // drc, float (dBFS) kParamIndexDrcTargetReferenceLevel, // drc, float (dBFS) kParamIndexDrcCompression, // drc, enum kParamIndexDrcBoostFactor, // drc, float (0-1) kParamIndexDrcAttenuationFactor, // drc, float (0-1) kParamIndexDrcEffectType, // drc, enum /* ============================== platform-defined parameters ============================== */ kParamIndexPlatformLevel = C2_PARAM_INDEX_PLATFORM_START, // all, u32 kParamIndexPlatformFeatures, // all, u64 mask kParamIndexStoreIonUsage, // store, struct kParamIndexAspectsToDataSpace, // store, struct kParamIndexFlexiblePixelFormatDescriptor, // store, struct kParamIndexFlexiblePixelFormatDescriptors, // store, struct[] kParamIndexDataSpaceToAspects, // store, struct kParamIndexDataSpace, // u32 kParamIndexSurfaceScaling, // u32 // input surface kParamIndexInputSurfaceEos, // input-surface, eos kParamIndexTimedControl, // struct kParamIndexStartAt, // input-surface, struct kParamIndexSuspendAt, // input-surface, struct kParamIndexResumeAt, // input-surface, struct kParamIndexStopAt, // input-surface, struct kParamIndexTimeOffset, // input-surface, struct kParamIndexMinFrameRate, // input-surface, float kParamIndexTimestampGapAdjustment, // input-surface, struct kParamIndexSurfaceAllocator, // u32 // deprecated indices due to renaming kParamIndexAacStreamFormat = kParamIndexAacPackaging, kParamIndexCsd = kParamIndexInitData, kParamIndexMaxVideoSizeHint = kParamIndexMaxPictureSize, kParamIndexMime = kParamIndexMediaType, kParamIndexRequestedInfos = kParamIndexSubscribedParamIndices, // deprecated indices due to removal kParamIndexSupportedParams = 0xDEAD0000, kParamIndexReadOnlyParams, kParamIndexTemporal, }; } /** * Codec 2.0 parameter types follow the following naming convention: * * C2 * * E.g. C2StreamPictureSizeInfo: group="" domain="Stream" index="PictureSize" type="Info". * Group is somewhat arbitrary, but denotes kind of objects the parameter is defined. * At this point we use Component and Store to distinguish basic component/store parameters. * * Parameter keys are named C2_PARAMKEY_[_]_ as type is not expected * to distinguish parameters. E.g. a component could change the type of the parameter and it * is not expected users would need to change the key. */ /* ----------------------------------------- API level ----------------------------------------- */ enum C2Config::api_level_t : uint32_t { API_L0_1 = 0, ///< support for API level 0.1 }; // read-only typedef C2GlobalParam, kParamIndexApiLevel> C2ApiLevelSetting; constexpr char C2_PARAMKEY_API_LEVEL[] = "api.level"; enum C2Config::api_feature_t : uint64_t { API_REFLECTION = (1U << 0), ///< ability to list supported parameters API_VALUES = (1U << 1), ///< ability to list supported values for each parameter API_CURRENT_VALUES = (1U << 2), ///< ability to list currently supported values for each parameter API_DEPENDENCY = (1U << 3), ///< have a defined parameter dependency API_STREAMS = (1ULL << 32), ///< supporting variable number of streams API_TUNNELING = (1ULL << 48), ///< tunneling API }; // read-only typedef C2GlobalParam, kParamIndexApiFeatures> C2ApiFeaturesSetting; constexpr char C2_PARAMKEY_API_FEATURES[] = "api.features"; /* ----------------------------- generic component characteristics ----------------------------- */ /** * The name of the component. * * This must contain only alphanumeric characters or dot '.', hyphen '-', plus '+', or * underline '_'. The name of each component must be unique. * * For Android: Component names must start with 'c2.' followed by the company name or abbreviation * and another dot, e.g. 'c2.android.'. Use of lowercase is preferred but not required. */ // read-only typedef C2GlobalParam C2ComponentNameSetting; constexpr char C2_PARAMKEY_COMPONENT_NAME[] = "component.name"; /** * Alternate names (aliases) of the component. * * This is a comma ',' separated list of alternate component names. Unlike component names that * must be unique, multiple components can have the same alias. */ // read-only typedef C2GlobalParam C2ComponentAliasesSetting; constexpr char C2_PARAMKEY_COMPONENT_ALIASES[] = "component.aliases"; /** * Component kind. */ // read-only typedef C2GlobalParam, kParamIndexKind> C2ComponentKindSetting; constexpr char C2_PARAMKEY_COMPONENT_KIND[] = "component.kind"; /** * Component domain. */ // read-only typedef C2GlobalParam, kParamIndexDomain> C2ComponentDomainSetting; typedef C2ComponentDomainSetting C2ComponentDomainInfo; // deprecated typedef C2Component::domain_t C2DomainKind; // deprecated constexpr char C2_PARAMKEY_COMPONENT_DOMAIN[] = "component.domain"; constexpr C2Component::domain_t C2DomainAudio = C2Component::DOMAIN_AUDIO; // deprecated constexpr C2Component::domain_t C2DomainOther = C2Component::DOMAIN_OTHER; // deprecate constexpr C2Component::domain_t C2DomainVideo = C2Component::DOMAIN_VIDEO; // deprecate /** * Component attributes. * * These are a set of flags provided by the component characterizing its processing algorithm. */ C2ENUM(C2Component::attrib_t, uint64_t, ATTRIB_IS_TEMPORAL = 1u << 0, ///< component input ordering matters for processing ) // read-only typedef C2GlobalParam, kParamIndexAttributes> C2ComponentAttributesSetting; constexpr char C2_PARAMKEY_COMPONENT_ATTRIBUTES[] = "component.attributes"; // deprecated typedef C2ComponentAttributesSetting C2ComponentTemporalInfo; /** * Time stretching. * * This is the ratio between the rate of the input timestamp, and the rate of the output timestamp. * E.g. if this is 4.0, for every 1 seconds of input timestamp difference, the output shall differ * by 4 seconds. */ typedef C2GlobalParam C2ComponentTimeStretchTuning; constexpr char C2_PARAMKEY_TIME_STRETCH[] = "algo.time-stretch"; /* ----------------------------------- coding characteristics ----------------------------------- */ /** * Profile and level. * * Profile determines the tools used by the component. * Level determines the level of resources used by the component. */ namespace { enum : uint32_t { _C2_PL_MP2V_BASE = 0x1000, _C2_PL_AAC_BASE = 0x2000, _C2_PL_H263_BASE = 0x3000, _C2_PL_MP4V_BASE = 0x4000, _C2_PL_AVC_BASE = 0x5000, _C2_PL_HEVC_BASE = 0x6000, _C2_PL_VP9_BASE = 0x7000, _C2_PL_DV_BASE = 0x8000, C2_PROFILE_LEVEL_VENDOR_START = 0x70000000, }; } enum C2Config::profile_t : uint32_t { PROFILE_UNUSED = 0, ///< profile is not used by this media type // AAC (MPEG-2 Part 7 and MPEG-4 Part 3) profiles PROFILE_AAC_LC = _C2_PL_AAC_BASE, ///< AAC Low-Complexity PROFILE_AAC_MAIN, ///< AAC Main PROFILE_AAC_SSR, ///< AAC Scalable Sampling Rate PROFILE_AAC_LTP, ///< AAC Long Term Prediction PROFILE_AAC_HE, ///< AAC High-Efficiency PROFILE_AAC_SCALABLE, ///< AAC Scalable PROFILE_AAC_ER_LC, ///< AAC Error Resilient Low-Complexity PROFILE_AAC_ER_SCALABLE, ///< AAC Error Resilient Scalable PROFILE_AAC_LD, ///< AAC Low Delay PROFILE_AAC_HE_PS, ///< AAC High-Efficiency Parametric Stereo PROFILE_AAC_ELD, ///< AAC Enhanced Low Delay PROFILE_AAC_XHE, ///< AAC Extended High-Efficiency // MPEG-2 Video profiles PROFILE_MP2V_SIMPLE = _C2_PL_MP2V_BASE, ///< MPEG-2 Video (H.262) Simple PROFILE_MP2V_MAIN, ///< MPEG-2 Video (H.262) Main PROFILE_MP2V_SNR_SCALABLE, ///< MPEG-2 Video (H.262) SNR Scalable PROFILE_MP2V_SPATIALLY_SCALABLE, ///< MPEG-2 Video (H.262) Spatially Scalable PROFILE_MP2V_HIGH, ///< MPEG-2 Video (H.262) High PROFILE_MP2V_422, ///< MPEG-2 Video (H.262) 4:2:2 PROFILE_MP2V_MULTIVIEW, ///< MPEG-2 Video (H.262) Multi-view // H.263 profiles PROFILE_H263_BASELINE = _C2_PL_H263_BASE, ///< H.263 Baseline (Profile 0) PROFILE_H263_H320, ///< H.263 H.320 Coding Efficiency Version 2 Backward-Compatibility (Profile 1) PROFILE_H263_V1BC, ///< H.263 Version 1 Backward-Compatibility (Profile 2) PROFILE_H263_ISWV2, ///< H.263 Version 2 Interactive and Streaming Wireless (Profile 3) PROFILE_H263_ISWV3, ///< H.263 Version 3 Interactive and Streaming Wireless (Profile 4) PROFILE_H263_HIGH_COMPRESSION, ///< H.263 Conversational High Compression (Profile 5) PROFILE_H263_INTERNET, ///< H.263 Conversational Internet (Profile 6) PROFILE_H263_INTERLACE, ///< H.263 Conversational Interlace (Profile 7) PROFILE_H263_HIGH_LATENCY, ///< H.263 High Latency (Profile 8) // MPEG-4 Part 2 (Video) Natural Visual Profiles PROFILE_MP4V_SIMPLE, ///< MPEG-4 Video Simple PROFILE_MP4V_SIMPLE_SCALABLE, ///< MPEG-4 Video Simple Scalable PROFILE_MP4V_CORE, ///< MPEG-4 Video Core PROFILE_MP4V_MAIN, ///< MPEG-4 Video Main PROFILE_MP4V_NBIT, ///< MPEG-4 Video N-Bit PROFILE_MP4V_ARTS, ///< MPEG-4 Video Advanced Realtime Simple PROFILE_MP4V_CORE_SCALABLE, ///< MPEG-4 Video Core Scalable PROFILE_MP4V_ACE, ///< MPEG-4 Video Advanced Coding Efficiency PROFILE_MP4V_ADVANCED_CORE, ///< MPEG-4 Video Advanced Core PROFILE_MP4V_SIMPLE_STUDIO, ///< MPEG-4 Video Simple Studio PROFILE_MP4V_CORE_STUDIO, ///< MPEG-4 Video Core Studio PROFILE_MP4V_ADVANCED_SIMPLE, ///< MPEG-4 Video Advanced Simple PROFILE_MP4V_FGS, ///< MPEG-4 Video Fine Granularity Scalable // AVC / MPEG-4 Part 10 (H.264) profiles PROFILE_AVC_BASELINE = _C2_PL_AVC_BASE, ///< AVC (H.264) Baseline PROFILE_AVC_CONSTRAINED_BASELINE, ///< AVC (H.264) Constrained Baseline PROFILE_AVC_MAIN, ///< AVC (H.264) Main PROFILE_AVC_EXTENDED, ///< AVC (H.264) Extended PROFILE_AVC_HIGH, ///< AVC (H.264) High PROFILE_AVC_PROGRESSIVE_HIGH, ///< AVC (H.264) Progressive High PROFILE_AVC_CONSTRAINED_HIGH, ///< AVC (H.264) Constrained High PROFILE_AVC_HIGH_10, ///< AVC (H.264) High 10 PROFILE_AVC_PROGRESSIVE_HIGH_10, ///< AVC (H.264) Progressive High 10 PROFILE_AVC_HIGH_422, ///< AVC (H.264) High 4:2:2 PROFILE_AVC_HIGH_444_PREDICTIVE, ///< AVC (H.264) High 4:4:4 Predictive PROFILE_AVC_HIGH_10_INTRA, ///< AVC (H.264) High 10 Intra PROFILE_AVC_HIGH_422_INTRA, ///< AVC (H.264) High 4:2:2 Intra PROFILE_AVC_HIGH_444_INTRA, ///< AVC (H.264) High 4:4:4 Intra PROFILE_AVC_CAVLC_444_INTRA, ///< AVC (H.264) CAVLC 4:4:4 Intra PROFILE_AVC_SCALABLE_BASELINE = _C2_PL_AVC_BASE + 0x100, ///< AVC (H.264) Scalable Baseline PROFILE_AVC_SCALABLE_CONSTRAINED_BASELINE, ///< AVC (H.264) Scalable Constrained Baseline PROFILE_AVC_SCALABLE_HIGH, ///< AVC (H.264) Scalable High PROFILE_AVC_SCALABLE_CONSTRAINED_HIGH, ///< AVC (H.264) Scalable Constrained High PROFILE_AVC_SCALABLE_HIGH_INTRA, ///< AVC (H.264) Scalable High Intra PROFILE_AVC_MULTIVIEW_HIGH = _C2_PL_AVC_BASE + 0x200, ///< AVC (H.264) Multiview High PROFILE_AVC_STEREO_HIGH, ///< AVC (H.264) Stereo High PROFILE_AVC_MFC_HIGH, ///< AVC (H.264) MFC High PROFILE_AVC_MULTIVIEW_DEPTH_HIGH = _C2_PL_AVC_BASE + 0x300, ///< AVC (H.264) Multiview Depth High PROFILE_AVC_MFC_DEPTH_HIGH, ///< AVC (H.264) MFC Depth High PROFILE_AVC_ENHANCED_MULTIVIEW_DEPTH_HIGH = _C2_PL_AVC_BASE + 0x400, ///< AVC (H.264) Enhanced Multiview Depth High // HEVC profiles PROFILE_HEVC_MAIN = _C2_PL_HEVC_BASE, ///< HEVC (H.265) Main PROFILE_HEVC_MAIN_10, ///< HEVC (H.265) Main 10 PROFILE_HEVC_MAIN_STILL, ///< HEVC (H.265) Main Still Picture PROFILE_HEVC_MONO = _C2_PL_HEVC_BASE + 0x100, ///< HEVC (H.265) Monochrome PROFILE_HEVC_MONO_12, ///< HEVC (H.265) Monochrome 12 PROFILE_HEVC_MONO_16, ///< HEVC (H.265) Monochrome 16 PROFILE_HEVC_MAIN_12, ///< HEVC (H.265) Main 12 PROFILE_HEVC_MAIN_422_10, ///< HEVC (H.265) Main 4:2:2 10 PROFILE_HEVC_MAIN_422_12, ///< HEVC (H.265) Main 4:2:2 12 PROFILE_HEVC_MAIN_444, ///< HEVC (H.265) Main 4:4:4 PROFILE_HEVC_MAIN_444_10, ///< HEVC (H.265) Main 4:4:4 10 PROFILE_HEVC_MAIN_444_12, ///< HEVC (H.265) Main 4:4:4 12 PROFILE_HEVC_MAIN_INTRA, ///< HEVC (H.265) Main Intra PROFILE_HEVC_MAIN_10_INTRA, ///< HEVC (H.265) Main 10 Intra PROFILE_HEVC_MAIN_12_INTRA, ///< HEVC (H.265) Main 12 Intra PROFILE_HEVC_MAIN_422_10_INTRA, ///< HEVC (H.265) Main 4:2:2 10 Intra PROFILE_HEVC_MAIN_422_12_INTRA, ///< HEVC (H.265) Main 4:2:2 12 Intra PROFILE_HEVC_MAIN_444_INTRA, ///< HEVC (H.265) Main 4:4:4 Intra PROFILE_HEVC_MAIN_444_10_INTRA, ///< HEVC (H.265) Main 4:4:4 10 Intra PROFILE_HEVC_MAIN_444_12_INTRA, ///< HEVC (H.265) Main 4:4:4 12 Intra PROFILE_HEVC_MAIN_444_16_INTRA, ///< HEVC (H.265) Main 4:4:4 16 Intra PROFILE_HEVC_MAIN_444_STILL, ///< HEVC (H.265) Main 4:4:4 Still Picture PROFILE_HEVC_MAIN_444_16_STILL, ///< HEVC (H.265) Main 4:4:4 16 Still Picture PROFILE_HEVC_HIGH_444 = _C2_PL_HEVC_BASE + 0x200, ///< HEVC (H.265) High Throughput 4:4:4 PROFILE_HEVC_HIGH_444_10, ///< HEVC (H.265) High Throughput 4:4:4 10 PROFILE_HEVC_HIGH_444_14, ///< HEVC (H.265) High Throughput 4:4:4 14 PROFILE_HEVC_HIGH_444_16_INTRA, ///< HEVC (H.265) High Throughput 4:4:4 16 Intra PROFILE_HEVC_SX_MAIN = _C2_PL_HEVC_BASE + 0x300, ///< HEVC (H.265) Screen-Extended Main PROFILE_HEVC_SX_MAIN_10, ///< HEVC (H.265) Screen-Extended Main 10 PROFILE_HEVC_SX_MAIN_444, ///< HEVC (H.265) Screen-Extended Main 4:4:4 PROFILE_HEVC_SX_MAIN_444_10, ///< HEVC (H.265) Screen-Extended Main 4:4:4 10 PROFILE_HEVC_SX_HIGH_444, ///< HEVC (H.265) Screen-Extended High Throughput 4:4:4 PROFILE_HEVC_SX_HIGH_444_10, ///< HEVC (H.265) Screen-Extended High Throughput 4:4:4 10 PROFILE_HEVC_SX_HIGH_444_14, ///< HEVC (H.265) Screen-Extended High Throughput 4:4:4 14 PROFILE_HEVC_MULTIVIEW_MAIN = _C2_PL_HEVC_BASE + 0x400, ///< HEVC (H.265) Multiview Main PROFILE_HEVC_SCALABLE_MAIN = _C2_PL_HEVC_BASE + 0x500, ///< HEVC (H.265) Scalable Main PROFILE_HEVC_SCALABLE_MAIN_10, ///< HEVC (H.265) Scalable Main 10 PROFILE_HEVC_SCALABLE_MONO = _C2_PL_HEVC_BASE + 0x600, ///< HEVC (H.265) Scalable Monochrome PROFILE_HEVC_SCALABLE_MONO_12, ///< HEVC (H.265) Scalable Monochrome 12 PROFILE_HEVC_SCALABLE_MONO_16, ///< HEVC (H.265) Scalable Monochrome 16 PROFILE_HEVC_SCALABLE_MAIN_444, ///< HEVC (H.265) Scalable Main 4:4:4 PROFILE_HEVC_3D_MAIN = _C2_PL_HEVC_BASE + 0x700, ///< HEVC (H.265) 3D Main // VP9 profiles PROFILE_VP9_0 = _C2_PL_VP9_BASE, ///< VP9 Profile 0 (4:2:0) PROFILE_VP9_1, ///< VP9 Profile 1 (4:2:2 or 4:4:4) PROFILE_VP9_2, ///< VP9 Profile 2 (4:2:0, 10 or 12 bit) PROFILE_VP9_3, ///< VP9 Profile 3 (4:2:2 or 4:4:4, 10 or 12 bit) // Dolby Vision profiles PROFILE_DV_AV_PER = _C2_PL_DV_BASE + 0, ///< Dolby Vision dvav.per profile (deprecated) PROFILE_DV_AV_PEN, ///< Dolby Vision dvav.pen profile (deprecated) PROFILE_DV_HE_DER, ///< Dolby Vision dvhe.der profile (deprecated) PROFILE_DV_HE_DEN, ///< Dolby Vision dvhe.den profile (deprecated) PROFILE_DV_HE_04 = _C2_PL_DV_BASE + 4, ///< Dolby Vision dvhe.04 profile PROFILE_DV_HE_05 = _C2_PL_DV_BASE + 5, ///< Dolby Vision dvhe.05 profile PROFILE_DV_HE_DTH, ///< Dolby Vision dvhe.dth profile (deprecated) PROFILE_DV_HE_07 = _C2_PL_DV_BASE + 7, ///< Dolby Vision dvhe.07 profile PROFILE_DV_HE_08 = _C2_PL_DV_BASE + 8, ///< Dolby Vision dvhe.08 profile PROFILE_DV_AV_09 = _C2_PL_DV_BASE + 9, ///< Dolby Vision dvav.09 profile }; enum C2Config::level_t : uint32_t { LEVEL_UNUSED = 0, ///< level is not used by this media type // MPEG-2 Video levels LEVEL_MP2V_LOW = _C2_PL_MP2V_BASE, ///< MPEG-2 Video (H.262) Low Level LEVEL_MP2V_MAIN, ///< MPEG-2 Video (H.262) Main Level LEVEL_MP2V_HIGH_1440, ///< MPEG-2 Video (H.262) High 1440 Level LEVEL_MP2V_HIGH, ///< MPEG-2 Video (H.262) High Level LEVEL_MP2V_HIGHP, ///< MPEG-2 Video (H.262) HighP Level // H.263 levels LEVEL_H263_10 = _C2_PL_H263_BASE, ///< H.263 Level 10 LEVEL_H263_20, ///< H.263 Level 20 LEVEL_H263_30, ///< H.263 Level 30 LEVEL_H263_40, ///< H.263 Level 40 LEVEL_H263_45, ///< H.263 Level 45 LEVEL_H263_50, ///< H.263 Level 50 LEVEL_H263_60, ///< H.263 Level 60 LEVEL_H263_70, ///< H.263 Level 70 // MPEG-4 Part 2 (Video) levels LEVEL_MP4V_0 = _C2_PL_MP4V_BASE, ///< MPEG-4 Video Level 0 LEVEL_MP4V_0B, ///< MPEG-4 Video Level 0b LEVEL_MP4V_1, ///< MPEG-4 Video Level 1 LEVEL_MP4V_2, ///< MPEG-4 Video Level 2 LEVEL_MP4V_3, ///< MPEG-4 Video Level 3 LEVEL_MP4V_3B, ///< MPEG-4 Video Level 3b LEVEL_MP4V_4, ///< MPEG-4 Video Level 4 LEVEL_MP4V_4A, ///< MPEG-4 Video Level 4a LEVEL_MP4V_5, ///< MPEG-4 Video Level 5 LEVEL_MP4V_6, ///< MPEG-4 Video Level 6 // AVC / MPEG-4 Part 10 (H.264) levels LEVEL_AVC_1 = _C2_PL_AVC_BASE, ///< AVC (H.264) Level 1 LEVEL_AVC_1B, ///< AVC (H.264) Level 1b LEVEL_AVC_1_1, ///< AVC (H.264) Level 1.1 LEVEL_AVC_1_2, ///< AVC (H.264) Level 1.2 LEVEL_AVC_1_3, ///< AVC (H.264) Level 1.3 LEVEL_AVC_2, ///< AVC (H.264) Level 2 LEVEL_AVC_2_1, ///< AVC (H.264) Level 2.1 LEVEL_AVC_2_2, ///< AVC (H.264) Level 2.2 LEVEL_AVC_3, ///< AVC (H.264) Level 3 LEVEL_AVC_3_1, ///< AVC (H.264) Level 3.1 LEVEL_AVC_3_2, ///< AVC (H.264) Level 3.2 LEVEL_AVC_4, ///< AVC (H.264) Level 4 LEVEL_AVC_4_1, ///< AVC (H.264) Level 4.1 LEVEL_AVC_4_2, ///< AVC (H.264) Level 4.2 LEVEL_AVC_5, ///< AVC (H.264) Level 5 LEVEL_AVC_5_1, ///< AVC (H.264) Level 5.1 LEVEL_AVC_5_2, ///< AVC (H.264) Level 5.2 // HEVC (H.265) tiers and levels LEVEL_HEVC_MAIN_1 = _C2_PL_HEVC_BASE, ///< HEVC (H.265) Main Tier Level 1 LEVEL_HEVC_MAIN_2, ///< HEVC (H.265) Main Tier Level 2 LEVEL_HEVC_MAIN_2_1, ///< HEVC (H.265) Main Tier Level 2.1 LEVEL_HEVC_MAIN_3, ///< HEVC (H.265) Main Tier Level 3 LEVEL_HEVC_MAIN_3_1, ///< HEVC (H.265) Main Tier Level 3.1 LEVEL_HEVC_MAIN_4, ///< HEVC (H.265) Main Tier Level 4 LEVEL_HEVC_MAIN_4_1, ///< HEVC (H.265) Main Tier Level 4.1 LEVEL_HEVC_MAIN_5, ///< HEVC (H.265) Main Tier Level 5 LEVEL_HEVC_MAIN_5_1, ///< HEVC (H.265) Main Tier Level 5.1 LEVEL_HEVC_MAIN_5_2, ///< HEVC (H.265) Main Tier Level 5.2 LEVEL_HEVC_MAIN_6, ///< HEVC (H.265) Main Tier Level 6 LEVEL_HEVC_MAIN_6_1, ///< HEVC (H.265) Main Tier Level 6.1 LEVEL_HEVC_MAIN_6_2, ///< HEVC (H.265) Main Tier Level 6.2 LEVEL_HEVC_HIGH_4 = _C2_PL_HEVC_BASE + 0x100, ///< HEVC (H.265) High Tier Level 4 LEVEL_HEVC_HIGH_4_1, ///< HEVC (H.265) High Tier Level 4.1 LEVEL_HEVC_HIGH_5, ///< HEVC (H.265) High Tier Level 5 LEVEL_HEVC_HIGH_5_1, ///< HEVC (H.265) High Tier Level 5.1 LEVEL_HEVC_HIGH_5_2, ///< HEVC (H.265) High Tier Level 5.2 LEVEL_HEVC_HIGH_6, ///< HEVC (H.265) High Tier Level 6 LEVEL_HEVC_HIGH_6_1, ///< HEVC (H.265) High Tier Level 6.1 LEVEL_HEVC_HIGH_6_2, ///< HEVC (H.265) High Tier Level 6.2 // VP9 levels LEVEL_VP9_1 = _C2_PL_VP9_BASE, ///< VP9 Level 1 LEVEL_VP9_1_1, ///< VP9 Level 1.1 LEVEL_VP9_2, ///< VP9 Level 2 LEVEL_VP9_2_1, ///< VP9 Level 2.1 LEVEL_VP9_3, ///< VP9 Level 3 LEVEL_VP9_3_1, ///< VP9 Level 3.1 LEVEL_VP9_4, ///< VP9 Level 4 LEVEL_VP9_4_1, ///< VP9 Level 4.1 LEVEL_VP9_5, ///< VP9 Level 5 LEVEL_VP9_5_1, ///< VP9 Level 5.1 LEVEL_VP9_5_2, ///< VP9 Level 5.2 LEVEL_VP9_6, ///< VP9 Level 6 LEVEL_VP9_6_1, ///< VP9 Level 6.1 LEVEL_VP9_6_2, ///< VP9 Level 6.2 // Dolby Vision level LEVEL_DV_MAIN_HD_24 = _C2_PL_DV_BASE, ///< Dolby Vision main tier hd24 LEVEL_DV_MAIN_HD_30, ///< Dolby Vision main tier hd30 LEVEL_DV_MAIN_FHD_24, ///< Dolby Vision main tier fhd24 LEVEL_DV_MAIN_FHD_30, ///< Dolby Vision main tier fhd30 LEVEL_DV_MAIN_FHD_60, ///< Dolby Vision main tier fhd60 LEVEL_DV_MAIN_UHD_24, ///< Dolby Vision main tier uhd24 LEVEL_DV_MAIN_UHD_30, ///< Dolby Vision main tier uhd30 LEVEL_DV_MAIN_UHD_48, ///< Dolby Vision main tier uhd48 LEVEL_DV_MAIN_UHD_60, ///< Dolby Vision main tier uhd60 LEVEL_DV_HIGH_HD_24 = _C2_PL_DV_BASE + 0x100, ///< Dolby Vision high tier hd24 LEVEL_DV_HIGH_HD_30, ///< Dolby Vision high tier hd30 LEVEL_DV_HIGH_FHD_24, ///< Dolby Vision high tier fhd24 LEVEL_DV_HIGH_FHD_30, ///< Dolby Vision high tier fhd30 LEVEL_DV_HIGH_FHD_60, ///< Dolby Vision high tier fhd60 LEVEL_DV_HIGH_UHD_24, ///< Dolby Vision high tier uhd24 LEVEL_DV_HIGH_UHD_30, ///< Dolby Vision high tier uhd30 LEVEL_DV_HIGH_UHD_48, ///< Dolby Vision high tier uhd48 LEVEL_DV_HIGH_UHD_60, ///< Dolby Vision high tier uhd60 }; struct C2ProfileLevelStruct { C2Config::profile_t profile; ///< coding profile C2Config::level_t level; ///< coding level C2ProfileLevelStruct( C2Config::profile_t profile_ = C2Config::PROFILE_UNUSED, C2Config::level_t level_ = C2Config::LEVEL_UNUSED) : profile(profile_), level(level_) { } DEFINE_AND_DESCRIBE_C2STRUCT(ProfileLevel) C2FIELD(profile, "profile") C2FIELD(level, "level") }; // TODO: may need to make this explicit (have .set member) typedef C2StreamParam C2StreamProfileLevelInfo; constexpr char C2_PARAMKEY_PROFILE_LEVEL[] = "coded.pl"; #define C2_PARAMKEY_STREAM_PROFILE_LEVEL C2_PARAMKEY_PROFILE_LEVEL /** * Codec-specific initialization data. * * This is initialization data for the codec. * * For AVC/HEVC, these are the concatenated SPS/PPS/VPS NALs. * * TODO: define for other codecs. */ typedef C2StreamParam C2StreamInitDataInfo; typedef C2StreamInitDataInfo C2StreamCsdInfo; // deprecated constexpr char C2_PARAMKEY_INIT_DATA[] = "coded.init-data"; #define C2_PARAMKEY_STREAM_INIT_DATA C2_PARAMKEY_INIT_DATA /** * Supplemental Data. * * This is coding-specific supplemental informational data, e.g. SEI for AVC/HEVC. * This structure is not a configuration so it does not have a parameter key. * This structure shall be returned in the configuration update, and can be repeated as needed * in the same update. */ C2ENUM(C2Config::supplemental_info_t, uint32_t, INFO_NONE = 0, INFO_PREFIX_SEI_UNIT = 0x10000, ///< prefix SEI payload types add this flag INFO_SUFFIX_SEI_UNIT = 0x20000, ///< suffix SEI payload types add this flag INFO_SEI_USER_DATA = INFO_PREFIX_SEI_UNIT | 4, ///< closed-captioning data (ITU-T T35) INFO_SEI_MDCV = INFO_PREFIX_SEI_UNIT | 137, ///< mastering display color volume INFO_SET_USER_DATA_SFX = INFO_SUFFIX_SEI_UNIT | 4, ///< closed-captioning data (ITU-T T35) INFO_VENDOR_START = 0x70000000 ) struct C2SupplementalDataStruct { C2SupplementalDataStruct() : type_(INFO_NONE) { } C2SupplementalDataStruct( size_t flexCount, C2Config::supplemental_info_t type, std::vector data_) : type_(type) { memcpy(data, &data_[0], c2_min(data_.size(), flexCount)); } C2Config::supplemental_info_t type_; uint8_t data[]; DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(SupplementalData, data) C2FIELD(type_, "type") C2FIELD(data, "data") }; typedef C2StreamParam C2StreamSupplementalDataInfo; /** * Supplemental Data Subscription */ typedef C2StreamParam, kParamIndexSubscribedSupplementalData> C2StreamSubscribedSupplementalDataTuning; constexpr char C2_PARAMKEY_SUBSCRIBED_SUPPLEMENTAL_DATA[] = "output.subscribed-supplemental"; /* ---------------------------------- pipeline characteristics ---------------------------------- */ /** * Media-type. * * This is defined for both port and stream, but stream media type may be a subtype of the * port media type. */ typedef C2PortParam C2PortMediaTypeSetting; typedef C2PortMediaTypeSetting C2PortMimeConfig; // deprecated constexpr char C2_PARAMKEY_INPUT_MEDIA_TYPE[] = "input.media-type"; constexpr char C2_PARAMKEY_OUTPUT_MEDIA_TYPE[] = "output.media-type"; #define C2_NAME_INPUT_PORT_MIME_SETTING C2_PARAMKEY_INPUT_MEDIA_TYPE #define C2_NAME_OUTPUT_PORT_MIME_SETTING C2_PARAMKEY_OUTPUT_MEDIA_TYPE typedef C2StreamParam C2StreamMediaTypeSetting; /** * Pipeline delays. * * Input delay is the number of additional input frames requested by the component to process * an input frame. * * Output delay is the number of additional output frames that need to be generated before an * output can be released by the component. * * Pipeline delay is the number of additional frames that are processed at one time by the * component. * * As these may vary from frame to frame, the number is the maximum required value. E.g. if * input delay is 0, the component is expected to consume each frame queued even if no further * frames are queued. Similarly, if input delay is 1, as long as there are always exactly 2 * outstanding input frames queued to the component, it shall produce output. */ typedef C2PortParam C2PortRequestedDelayTuning; typedef C2PortRequestedDelayTuning C2PortRequestedLatencyTuning; // deprecated constexpr char C2_PARAMKEY_INPUT_DELAY_REQUEST[] = "input.delay.requested"; constexpr char C2_PARAMKEY_OUTPUT_DELAY_REQUEST[] = "output.delay.requested"; typedef C2GlobalParam C2RequestedPipelineDelayTuning; typedef C2RequestedPipelineDelayTuning C2ComponentRequestedLatencyTuning; // deprecated constexpr char C2_PARAMKEY_PIPELINE_DELAY_REQUEST[] = "pipeline-delay.requested"; // read-only typedef C2PortParam C2PortActualDelayTuning; typedef C2PortActualDelayTuning C2PortLatencyInfo; // deprecated constexpr char C2_PARAMKEY_INPUT_DELAY[] = "input.delay.actual"; constexpr char C2_PARAMKEY_OUTPUT_DELAY[] = "output.delay.actual"; // read-only typedef C2GlobalParam C2ActualPipelineDelayTuning; typedef C2ActualPipelineDelayTuning C2ComponentLatencyInfo; // deprecated constexpr char C2_PARAMKEY_PIPELINE_DELAY[] = "algo.delay.actual"; /** * Reference characteristics. * * The component may hold onto input and output buffers even after completing the corresponding * work item. * * Max reference age is the longest number of additional frame processing that a component may * hold onto a buffer for. Max reference count is the number of buffers that a component may * hold onto at the same time at the worst case. These numbers assume single frame per buffers. * * Use max-uint32 if there is no limit for the max age or count. */ typedef C2StreamParam C2StreamMaxReferenceAgeTuning; constexpr char C2_PARAMKEY_INPUT_MAX_REFERENCE_AGE[] = "input.reference.max-age"; constexpr char C2_PARAMKEY_OUTPUT_MAX_REFERENCE_AGE[] = "output.reference.max-age"; typedef C2StreamParam C2StreamMaxReferenceCountTuning; constexpr char C2_PARAMKEY_INPUT_MAX_REFERENCE_COUNT[] = "input.reference.max-count"; constexpr char C2_PARAMKEY_OUTPUT_MAX_REFERENCE_COUNT[] = "output.reference.max-count"; /** * Output reordering. * * The size of the window to use for output buffer reordering. 0 is interpreted as 1. */ // output only typedef C2PortParam C2PortReorderBufferDepthTuning; constexpr char C2_PARAMKEY_OUTPUT_REORDER_DEPTH[] = "output.reorder.depth"; C2ENUM(C2Config::ordinal_key_t, uint32_t, ORDINAL, TIMESTAMP, CUSTOM) // read-only, output only typedef C2PortParam, kParamIndexReorderKey> C2PortReorderKeySetting; constexpr char C2_PARAMKEY_OUTPUT_REORDER_KEY[] = "output.reorder.key"; /** * Stream count. */ // private typedef C2PortParam C2PortStreamCountTuning; typedef C2PortStreamCountTuning C2PortStreamCountConfig; // deprecated constexpr char C2_PARAMKEY_INPUT_STREAM_COUNT[] = "input.stream-count"; constexpr char C2_PARAMKEY_OUTPUT_STREAM_COUNT[] = "output.stream-count"; /** * Config update subscription. */ // private typedef C2GlobalParam C2SubscribedParamIndicesTuning; constexpr char C2_PARAMKEY_SUBSCRIBED_PARAM_INDICES[] = "output.subscribed-indices"; /** * Suggested buffer (C2Frame) count. This is a suggestion by the component for the number of * input and output frames allocated for the component's use in the buffer pools. * * Component shall set the acceptable range of buffers allocated for it. E.g. client shall * allocate at least the minimum required value. */ // read-only typedef C2PortParam C2PortSuggestedBufferCountTuning; constexpr char C2_PARAMKEY_INPUT_SUGGESTED_BUFFER_COUNT[] = "input.buffers.pool-size"; constexpr char C2_PARAMKEY_OUTPUT_SUGGESTED_BUFFER_COUNT[] = "output.buffers.pool-size"; /** * Input/output batching. * * For input, component requests that client batches work in batches of specified size. For output, * client requests that the component batches work completion in given batch size. * Value 0 means don't care. */ typedef C2PortParam C2PortBatchSizeTuning; constexpr char C2_PARAMKEY_INPUT_BATCH_SIZE[] = "input.buffers.batch-size"; constexpr char C2_PARAMKEY_OUTPUT_BATCH_SIZE[] = "output.buffers.batch-size"; /** * Current & last work ordinals. * * input port: last work queued to component. * output port: last work completed by component. * global: current work. */ typedef C2PortParam C2LastWorkQueuedTuning; typedef C2GlobalParam C2CurrentWorkTuning; /* ------------------------------------- memory allocation ------------------------------------- */ /** * Allocators to use. * * These are requested by the component. * * If none specified, client will use the default allocator ID based on the component domain and * kind. */ typedef C2PortParam, kParamIndexAllocators> C2PortAllocatorsTuning; constexpr char C2_PARAMKEY_INPUT_ALLOCATORS[] = "input.buffers.allocator-ids"; constexpr char C2_PARAMKEY_OUTPUT_ALLOCATORS[] = "output.buffers.allocator-ids"; typedef C2GlobalParam, kParamIndexAllocators> C2PrivateAllocatorsTuning; constexpr char C2_PARAMKEY_PRIVATE_ALLOCATORS[] = "algo.buffers.allocator-ids"; /** * Allocator to use for outputting to surface. * * Components can optionally request allocator type for outputting to surface. * * If none specified, client will use the default BufferQueue-backed allocator ID for outputting to * surface. */ typedef C2PortParam C2PortSurfaceAllocatorTuning; constexpr char C2_PARAMKEY_OUTPUT_SURFACE_ALLOCATOR[] = "output.buffers.surface-allocator-id"; /** * Block pools to use. * * These are allocated by the client for the component using the allocator IDs specified by the * component. This is not used for the input port. */ typedef C2PortParam, kParamIndexBlockPools> C2PortBlockPoolsTuning; constexpr char C2_PARAMKEY_OUTPUT_BLOCK_POOLS[] = "output.buffers.pool-ids"; typedef C2GlobalParam, kParamIndexBlockPools> C2PrivateBlockPoolsTuning; constexpr char C2_PARAMKEY_PRIVATE_BLOCK_POOLS[] = "algo.buffers.pool-ids"; /** * The max number of private allocations at any one time by the component. * (This is an array with a corresponding value for each private allocator) */ typedef C2GlobalParam C2MaxPrivateBufferCountTuning; constexpr char C2_PARAMKEY_MAX_PRIVATE_BUFFER_COUNT[] = "algo.buffers.max-count"; /** * Buffer type * * This is provided by the component for the client to allocate the proper buffer type for the * input port, and can be provided by the client to control the buffer type for the output. */ // private typedef C2StreamParam>, kParamIndexBufferType> C2StreamBufferTypeSetting; constexpr C2BufferData::type_t C2FormatAudio = C2BufferData::LINEAR; // deprecated constexpr C2BufferData::type_t C2FormatCompressed = C2BufferData::LINEAR; // deprecated constexpr C2BufferData::type_t C2FormatVideo = C2BufferData::GRAPHIC; // deprecated typedef C2BufferData::type_t C2FormatKind; // deprecated typedef C2StreamBufferTypeSetting C2StreamFormatConfig; // deprecated constexpr char C2_PARAMKEY_INPUT_STREAM_BUFFER_TYPE[] = "input.buffers.type"; constexpr char C2_PARAMKEY_OUTPUT_STREAM_BUFFER_TYPE[] = "output.buffers.type"; // deprecated #define C2_NAME_INPUT_STREAM_FORMAT_SETTING C2_PARAMKEY_INPUT_STREAM_BUFFER_TYPE #define C2_NAME_OUTPUT_STREAM_FORMAT_SETTING C2_PARAMKEY_OUTPUT_STREAM_BUFFER_TYPE /** * Memory usage. * * Suggested by component for input and negotiated between client and component for output. */ typedef C2StreamParam C2StreamUsageTuning; constexpr char C2_PARAMKEY_INPUT_STREAM_USAGE[] = "input.buffers.usage"; constexpr char C2_PARAMKEY_OUTPUT_STREAM_USAGE[] = "output.buffers.usage"; // deprecated #define C2_NAME_INPUT_STREAM_USAGE_SETTING C2_PARAMKEY_INPUT_STREAM_USAGE /** * Picture (video or image frame) size. */ struct C2PictureSizeStruct { inline C2PictureSizeStruct() : width(0), height(0) { } inline C2PictureSizeStruct(uint32_t width_, uint32_t height_) : width(width_), height(height_) { } uint32_t width; ///< video width uint32_t height; ///< video height DEFINE_AND_DESCRIBE_C2STRUCT(PictureSize) C2FIELD(width, "width") C2FIELD(height, "height") }; /** * Out of memory signaling * * This is a configuration for the client to mark that it cannot allocate necessary private and/ * or output buffers to continue operation, and to signal the failing configuration. */ struct C2OutOfMemoryStruct { C2BlockPool::local_id_t pool; ///< pool ID that failed the allocation uint64_t usage; ///< memory usage used C2PictureSizeStruct planar; ///< buffer dimensions to be allocated if 2D uint32_t format; ///< pixel format to be used if 2D uint32_t capacity; ///< buffer capacity to be allocated if 1D c2_bool_t outOfMemory; ///< true if component is out of memory DEFINE_AND_DESCRIBE_C2STRUCT(OutOfMemory) C2FIELD(pool, "pool") C2FIELD(usage, "usage") C2FIELD(planar, "planar") C2FIELD(format, "format") C2FIELD(capacity, "capacity") C2FIELD(outOfMemory, "out-of-memory") }; typedef C2GlobalParam C2OutOfMemoryTuning; constexpr char C2_PARAMKEY_OUT_OF_MEMORY[] = "algo.oom"; /** * Max buffer size * * This is a hint provided by the component for the maximum buffer size expected on a stream for the * current configuration on its input and output streams. This is communicated to clients so they * can preallocate input buffers, or configure downstream components that require a maximum size on * their buffers. * * Read-only. Required to be provided by components on all compressed streams. */ typedef C2StreamParam C2StreamMaxBufferSizeInfo; constexpr char C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE[] = "input.buffers.max-size"; constexpr char C2_PARAMKEY_OUTPUT_MAX_BUFFER_SIZE[] = "output.buffers.max-size"; #define C2_NAME_STREAM_MAX_BUFFER_SIZE_SETTING C2_PARAMKEY_INPUT_MAX_BUFFER_SIZE /* ---------------------------------------- misc. state ---------------------------------------- */ /** * Tripped state, * * This state exists to be able to provide reasoning for a tripped state during normal * interface operations, as well as to allow client to trip the component on demand. */ typedef C2GlobalParam C2TrippedTuning; constexpr char C2_PARAMKEY_TRIPPED[] = "algo.tripped"; /** * Configuration counters. * * Configurations are tracked using three counters. The input counter is incremented exactly * once with each work accepted by the component. The output counter is incremented exactly * once with each work completed by the component (in the order of work completion). The * global counter is incremented exactly once during to each config() call. These counters * shall be read-only. * * TODO: these should be counters. */ typedef C2PortParam C2PortConfigCounterTuning; typedef C2GlobalParam C2ConfigCounterTuning; constexpr char C2_PARAMKEY_INPUT_COUNTER[] = "input.buffers.counter"; constexpr char C2_PARAMKEY_OUTPUT_COUNTER[] = "output.buffers.counter"; constexpr char C2_PARAMKEY_CONFIG_COUNTER[] = "algo.config.counter"; /* ----------------------------------------- resources ----------------------------------------- */ /** * Resources needed and resources reserved for current configuration. * * Resources are tracked as a vector of positive numbers. Available resources are defined by * the vendor. * * By default, no resources are reserved for a component. If resource reservation is successful, * the component shall be able to use those resources exclusively. If however, the component is * not using all of the reserved resources, those may be shared with other components. * * TODO: define some of the resources. */ typedef C2GlobalParam C2ResourcesNeededTuning; typedef C2GlobalParam C2ResourcesReservedTuning; constexpr char C2_PARAMKEY_RESOURCES_NEEDED[] = "resources.needed"; constexpr char C2_PARAMKEY_RESOURCES_RESERVED[] = "resources.reserved"; /** * Operating rate. * * Operating rate is the expected rate of work through the component. Negative values is * invalid. * * TODO: this could distinguish set value */ typedef C2GlobalParam C2OperatingRateTuning; constexpr char C2_PARAMKEY_OPERATING_RATE[] = "algo.rate"; /** * Realtime / operating point. * * Priority value defines the operating point for the component. Operating points are defined by * the vendor. Priority value of 0 means that the client requires operation at the given operating * rate. Priority values -1 and below define operating points in decreasing performance. In this * case client expects best effort without exceeding the specific operating point. This allows * client to run components deeper in the background by using larger priority values. In these * cases operating rate is a hint for the maximum rate that the client anticipates. * * Operating rate and priority are used in tandem. E.g. if there are components that run at a * higher operating point (priority) it will make more resources available for components at * a lower operating point, so operating rate can be used to gate those components. * * Positive priority values are not defined at the moment and shall be treated equivalent to 0. */ typedef C2GlobalParam C2RealTimePriorityTuning; constexpr char C2_PARAMKEY_PRIORITY[] = "algo.priority"; /* ------------------------------------- protected content ------------------------------------- */ /** * Secure mode. */ C2ENUM(C2Config::secure_mode_t, uint32_t, SM_UNPROTECTED, ///< no content protection SM_READ_PROTECTED, ///< input and output buffers shall be protected from reading ) typedef C2GlobalParam, kParamIndexSecureMode> C2SecureModeTuning; constexpr char C2_PARAMKEY_SECURE_MODE[] = "algo.secure-mode"; /* ===================================== ENCODER COMPONENTS ===================================== */ /** * Bitrate */ typedef C2StreamParam C2StreamBitrateInfo; typedef C2StreamBitrateInfo C2BitrateTuning; // deprecated constexpr char C2_PARAMKEY_BITRATE[] = "coded.bitrate"; #define C2_NAME_STREAM_BITRATE_SETTING C2_PARAMKEY_BITRATE /** * Bitrate mode. * * TODO: refine this with bitrate ranges and suggested window */ C2ENUM(C2Config::bitrate_mode_t, uint32_t, BITRATE_CONST_SKIP_ALLOWED = 0, ///< constant bitrate, frame skipping allowed BITRATE_CONST = 1, ///< constant bitrate, keep all frames BITRATE_VARIABLE_SKIP_ALLOWED = 2, ///< bitrate can vary, frame skipping allowed BITRATE_VARIABLE = 3, ///< bitrate can vary, keep all frames BITRATE_IGNORE = 7, ///< bitrate can be exceeded at will to achieve ///< quality or other settings // bitrate modes are composed of the following flags BITRATE_FLAG_KEEP_ALL_FRAMES = 1, BITRATE_FLAG_CAN_VARY = 2, BITRATE_FLAG_CAN_EXCEED = 4, ) typedef C2StreamParam, kParamIndexBitrateMode> C2StreamBitrateModeTuning; constexpr char C2_PARAMKEY_BITRATE_MODE[] = "algo.bitrate-mode"; /** * Quality. * * This is defined by each component, the higher the better the output quality at the expense of * less compression efficiency. This setting is defined for the output streams in case the * component can support varying quality on each stream, or as an output port tuning in case the * quality is global to all streams. */ typedef C2StreamParam C2StreamQualityTuning; typedef C2PortParam C2QualityTuning; constexpr char C2_PARAMKEY_QUALITY[] = "algo.quality"; /** * Complexity. * * This is defined by each component, this higher the value, the more resources the component * will use to produce better quality at the same compression efficiency or better compression * efficiency at the same quality. This setting is defined for the output streams in case the * component can support varying complexity on each stream, or as an output port tuning in case the * quality is global to all streams */ typedef C2StreamParam C2StreamComplexityTuning; typedef C2PortParam C2ComplexityTuning; constexpr char C2_PARAMKEY_COMPLEXITY[] = "algo.complexity"; /** * Header (init-data) handling around sync frames. */ C2ENUM(C2Config::prepend_header_mode_t, uint32_t, /** * don't prepend header. Signal header only through C2StreamInitDataInfo. */ PREPEND_HEADER_TO_NONE, /** * prepend header before the first output frame and thereafter before the next sync frame * if it changes. */ PREPEND_HEADER_ON_CHANGE, /** * prepend header before every sync frame. */ PREPEND_HEADER_TO_ALL_SYNC, ) typedef C2GlobalParam C2PrependHeaderModeSetting; constexpr char C2_PARAMKEY_PREPEND_HEADER_MODE[] = "output.buffers.prepend-header"; /* =================================== IMAGE/VIDEO COMPONENTS =================================== */ /* * Order of transformation is: * * crop => (scaling => scaled-crop) => sample-aspect-ratio => flip => rotation */ /** * Picture (image- and video frame) size. * * This is used for the output of the video decoder, and the input of the video encoder. */ typedef C2PictureSizeStruct C2VideoSizeStruct; // deprecated typedef C2StreamParam C2StreamPictureSizeInfo; constexpr char C2_PARAMKEY_PICTURE_SIZE[] = "raw.size"; #define C2_PARAMKEY_STREAM_PICTURE_SIZE C2_PARAMKEY_PICTURE_SIZE #define C2_NAME_STREAM_VIDEO_SIZE_INFO C2_PARAMKEY_PICTURE_SIZE typedef C2StreamPictureSizeInfo C2VideoSizeStreamInfo; // deprecated typedef C2StreamPictureSizeInfo C2VideoSizeStreamTuning; // deprecated #define C2_NAME_STREAM_VIDEO_SIZE_SETTING C2_PARAMKEY_PICTURE_SIZE /** * Crop rectangle. */ struct C2RectStruct : C2Rect { C2RectStruct() = default; C2RectStruct(const C2Rect &rect) : C2Rect(rect) { } bool operator==(const C2RectStruct &) = delete; bool operator!=(const C2RectStruct &) = delete; DEFINE_AND_DESCRIBE_BASE_C2STRUCT(Rect) C2FIELD(width, "width") C2FIELD(height, "height") C2FIELD(left, "left") C2FIELD(top, "top") }; typedef C2StreamParam C2StreamCropRectInfo; constexpr char C2_PARAMKEY_CROP_RECT[] = "raw.crop"; constexpr char C2_PARAMKEY_CODED_CROP_RECT[] = "coded.crop"; /** * Pixel format. */ // TODO: define some typedef C2StreamParam C2StreamPixelFormatInfo; constexpr char C2_PARAMKEY_PIXEL_FORMAT[] = "raw.pixel-format"; /** * Extended rotation information also incorporating a flip. * * Rotation is counter clock-wise. */ struct C2RotationStruct { C2RotationStruct(int32_t rotation = 0) : flip(0), value(rotation) { } int32_t flip; ///< horizontal flip (left-right flip applied prior to rotation) int32_t value; ///< rotation in degrees counter clockwise DEFINE_AND_DESCRIBE_BASE_C2STRUCT(Rotation) C2FIELD(flip, "flip") C2FIELD(value, "value") }; typedef C2StreamParam C2StreamRotationInfo; constexpr char C2_PARAMKEY_ROTATION[] = "raw.rotation"; constexpr char C2_PARAMKEY_VUI_ROTATION[] = "coded.vui.rotation"; /** * Pixel (sample) aspect ratio. */ typedef C2StreamParam C2StreamPixelAspectRatioInfo; constexpr char C2_PARAMKEY_PIXEL_ASPECT_RATIO[] = "raw.sar"; constexpr char C2_PARAMKEY_VUI_PIXEL_ASPECT_RATIO[] = "coded.vui.sar"; /** * In-line scaling. * * Components can optionally support scaling of raw image/video frames. Or scaling only a * portion of raw image/video frames (scaled-crop). */ C2ENUM(C2Config::scaling_method_t, uint32_t, SCALING_ARBITRARY, ///< arbitrary, unspecified ) typedef C2StreamParam, kParamIndexScalingMethod> C2StreamScalingMethodTuning; constexpr char C2_PARAMKEY_SCALING_MODE[] = "raw.scaling-method"; #define C2_PARAMKEY_STREAM_SCALING_MODE C2_PARAMKEY_SCALING_MODE typedef C2StreamParam C2StreamScaledPictureSizeTuning; constexpr char C2_PARAMKEY_SCALED_PICTURE_SIZE[] = "raw.scaled-size"; #define C2_PARAMKEY_STREAM_SCALED_PICTURE_SIZE C2_PARAMKEY_SCALED_PICTURE_SIZE typedef C2StreamParam C2StreamScaledCropRectTuning; constexpr char C2_PARAMKEY_SCALED_CROP_RECT[] = "raw.scaled-crop"; /* ------------------------------------- color information ------------------------------------- */ /** * Color Info * * Chroma location can vary for top and bottom fields, so use an array, that can have 0 to 2 * values. Empty array is used for non YUV formats. */ struct C2Color { enum matrix_t : uint32_t; ///< matrix coefficient (YUV <=> RGB) enum plane_layout_t : uint32_t; ///< plane layout for flexible formats enum primaries_t : uint32_t; ///< color primaries and white point enum range_t : uint32_t; ///< range of color component values enum subsampling_t : uint32_t; ///< chroma subsampling enum transfer_t : uint32_t; ///< transfer function }; /// Chroma subsampling C2ENUM(C2Color::subsampling_t, uint32_t, MONOCHROME, ///< there are no Cr nor Cb planes MONOCHROME_ALPHA, ///< there are no Cr nor Cb planes, but there is an alpha plane RGB, ///< RGB RGBA, ///< RGBA YUV_420, ///< Cr and Cb planes are subsampled by 2 both horizontally and vertically YUV_422, ///< Cr and Cb planes are subsampled horizontally YUV_444, ///< Cr and Cb planes are not subsampled YUVA_444, ///< Cr and Cb planes are not subsampled, there is an alpha plane ) struct C2ChromaOffsetStruct { // chroma offsets defined by ITU constexpr static C2ChromaOffsetStruct ITU_YUV_444() { return { 0.0f, 0.0f }; } constexpr static C2ChromaOffsetStruct ITU_YUV_422() { return { 0.0f, 0.0f }; } constexpr static C2ChromaOffsetStruct ITU_YUV_420_0() { return { 0.0f, 0.5f }; } constexpr static C2ChromaOffsetStruct ITU_YUV_420_1() { return { 0.5f, 0.5f }; } constexpr static C2ChromaOffsetStruct ITU_YUV_420_2() { return { 0.0f, 0.0f }; } constexpr static C2ChromaOffsetStruct ITU_YUV_420_3() { return { 0.5f, 0.0f }; } constexpr static C2ChromaOffsetStruct ITU_YUV_420_4() { return { 0.0f, 1.0f }; } constexpr static C2ChromaOffsetStruct ITU_YUV_420_5() { return { 0.5f, 1.0f }; } float x; ///< x offset in pixels (towards right) float y; ///< y offset in pixels (towards down) DEFINE_AND_DESCRIBE_C2STRUCT(ChromaOffset) C2FIELD(x, "x") C2FIELD(y, "y") }; struct C2ColorInfoStruct { C2ColorInfoStruct() : bitDepth(8), subsampling(C2Color::YUV_420) { } uint32_t bitDepth; C2Color::subsampling_t subsampling; C2ChromaOffsetStruct locations[]; // max 2 elements C2ColorInfoStruct( size_t /* flexCount */, uint32_t bitDepth_, C2Color::subsampling_t subsampling_) : bitDepth(bitDepth_), subsampling(subsampling_) { } C2ColorInfoStruct( size_t flexCount, uint32_t bitDepth_, C2Color::subsampling_t subsampling_, std::initializer_list locations_) : bitDepth(bitDepth_), subsampling(subsampling_) { size_t ix = 0; for (const C2ChromaOffsetStruct &location : locations_) { if (ix == flexCount) { break; } locations[ix] = location; ++ix; } } DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(ColorInfo, locations) C2FIELD(bitDepth, "bit-depth") C2FIELD(subsampling, "subsampling") C2FIELD(locations, "locations") }; typedef C2StreamParam C2StreamColorInfo; constexpr char C2_PARAMKEY_COLOR_INFO[] = "raw.color-format"; constexpr char C2_PARAMKEY_CODED_COLOR_INFO[] = "coded.color-format"; /** * Color Aspects */ /* The meaning of the following enumerators is as described in ITU-T H.273. */ /// Range C2ENUM(C2Color::range_t, uint32_t, RANGE_UNSPECIFIED, ///< range is unspecified RANGE_FULL, ///< full range RANGE_LIMITED, ///< limited range RANGE_VENDOR_START = 0x80, ///< vendor-specific range values start here RANGE_OTHER = 0XFF ///< max value, reserved for undefined values ) /// Color primaries C2ENUM(C2Color::primaries_t, uint32_t, PRIMARIES_UNSPECIFIED, ///< primaries are unspecified PRIMARIES_BT709, ///< Rec.ITU-R BT.709-6 or equivalent PRIMARIES_BT470_M, ///< Rec.ITU-R BT.470-6 System M or equivalent PRIMARIES_BT601_625, ///< Rec.ITU-R BT.601-6 625 or equivalent PRIMARIES_BT601_525, ///< Rec.ITU-R BT.601-6 525 or equivalent PRIMARIES_GENERIC_FILM, ///< Generic Film PRIMARIES_BT2020, ///< Rec.ITU-R BT.2020 or equivalent PRIMARIES_RP431, ///< SMPTE RP 431-2 or equivalent PRIMARIES_EG432, ///< SMPTE EG 432-1 or equivalent PRIMARIES_EBU3213, ///< EBU Tech.3213-E or equivalent /// PRIMARIES_VENDOR_START = 0x80, ///< vendor-specific primaries values start here PRIMARIES_OTHER = 0xff ///< max value, reserved for undefined values ) /// Transfer function C2ENUM(C2Color::transfer_t, uint32_t, TRANSFER_UNSPECIFIED, ///< transfer is unspecified TRANSFER_LINEAR, ///< Linear transfer characteristics TRANSFER_SRGB, ///< sRGB or equivalent TRANSFER_170M, ///< SMPTE 170M or equivalent (e.g. BT.601/709/2020) TRANSFER_GAMMA22, ///< Assumed display gamma 2.2 TRANSFER_GAMMA28, ///< Assumed display gamma 2.8 TRANSFER_ST2084, ///< SMPTE ST 2084 for 10/12/14/16 bit systems TRANSFER_HLG, ///< ARIB STD-B67 hybrid-log-gamma TRANSFER_240M = 0x40, ///< SMPTE 240M or equivalent TRANSFER_XVYCC, ///< IEC 61966-2-4 or equivalent TRANSFER_BT1361, ///< Rec.ITU-R BT.1361 extended gamut TRANSFER_ST428, ///< SMPTE ST 428-1 or equivalent /// TRANSFER_VENDOR_START = 0x80, ///< vendor-specific transfer values start here TRANSFER_OTHER = 0xff ///< max value, reserved for undefined values ) /// Matrix coefficient C2ENUM(C2Color::matrix_t, uint32_t, MATRIX_UNSPECIFIED, ///< matrix coefficients are unspecified MATRIX_BT709, ///< Rec.ITU-R BT.709-5 or equivalent MATRIX_FCC47_73_682, ///< FCC Title 47 CFR 73.682 or equivalent (KR=0.30, KB=0.11) MATRIX_BT601, ///< Rec.ITU-R BT.470, BT.601-6 625 or equivalent MATRIX_240M, ///< SMPTE 240M or equivalent MATRIX_BT2020, ///< Rec.ITU-R BT.2020 non-constant luminance MATRIX_BT2020_CONSTANT, ///< Rec.ITU-R BT.2020 constant luminance MATRIX_VENDOR_START = 0x80, ///< vendor-specific matrix coefficient values start here MATRIX_OTHER = 0xff, ///< max value, reserved for undefined values MATRIX_SMPTE240M = MATRIX_240M, // deprecated MATRIX_BT2020CONSTANT = MATRIX_BT2020_CONSTANT, // deprecated ) constexpr C2Color::matrix_t MATRIX_BT470_6M = MATRIX_FCC47_73_682; // deprecated constexpr C2Color::matrix_t MATRIX_BT709_5 = MATRIX_BT709; // deprecated constexpr C2Color::matrix_t MATRIX_BT601_6 = MATRIX_BT601; // deprecated struct C2ColorAspectsStruct { C2Color::range_t range; C2Color::primaries_t primaries; C2Color::transfer_t transfer; C2Color::matrix_t matrix; C2ColorAspectsStruct() : range(C2Color::RANGE_UNSPECIFIED), primaries(C2Color::PRIMARIES_UNSPECIFIED), transfer(C2Color::TRANSFER_UNSPECIFIED), matrix(C2Color::MATRIX_UNSPECIFIED) { } C2ColorAspectsStruct(C2Color::range_t range_, C2Color::primaries_t primaries_, C2Color::transfer_t transfer_, C2Color::matrix_t matrix_) : range(range_), primaries(primaries_), transfer(transfer_), matrix(matrix_) {} DEFINE_AND_DESCRIBE_C2STRUCT(ColorAspects) C2FIELD(range, "range") C2FIELD(primaries, "primaries") C2FIELD(transfer, "transfer") C2FIELD(matrix, "matrix") }; typedef C2StreamParam C2StreamColorAspectsInfo; constexpr char C2_PARAMKEY_COLOR_ASPECTS[] = "raw.color"; constexpr char C2_PARAMKEY_VUI_COLOR_ASPECTS[] = "coded.vui.color"; /** * Default color aspects to use. These come from the container or client and shall be handled * according to the coding standard. */ typedef C2StreamParam C2StreamColorAspectsTuning; constexpr char C2_PARAMKEY_DEFAULT_COLOR_ASPECTS[] = "default.color"; /** * HDR Static Metadata Info. */ struct C2ColorXyStruct { float x; ///< x color coordinate in xyY space [0-1] float y; ///< y color coordinate in xyY space [0-1] DEFINE_AND_DESCRIBE_C2STRUCT(ColorXy) C2FIELD(x, "x") C2FIELD(y, "y") }; struct C2MasteringDisplayColorVolumeStruct { C2ColorXyStruct red; ///< coordinates of red display primary C2ColorXyStruct green; ///< coordinates of green display primary C2ColorXyStruct blue; ///< coordinates of blue display primary C2ColorXyStruct white; ///< coordinates of white point float maxLuminance; ///< max display mastering luminance in cd/m^2 float minLuminance; ///< min display mastering luminance in cd/m^2 DEFINE_AND_DESCRIBE_C2STRUCT(MasteringDisplayColorVolume) C2FIELD(red, "red") C2FIELD(green, "green") C2FIELD(blue, "blue") C2FIELD(white, "white") C2FIELD(maxLuminance, "max-luminance") C2FIELD(minLuminance, "min-luminance") }; struct C2HdrStaticMetadataStruct { C2MasteringDisplayColorVolumeStruct mastering; // content descriptors float maxCll; ///< max content light level (pixel luminance) in cd/m^2 float maxFall; ///< max frame average light level (frame luminance) in cd/m^2 DEFINE_AND_DESCRIBE_BASE_C2STRUCT(HdrStaticMetadata) C2FIELD(mastering, "mastering") C2FIELD(maxCll, "max-cll") C2FIELD(maxFall, "max-fall") }; typedef C2StreamParam C2StreamHdrStaticInfo; constexpr char C2_PARAMKEY_HDR_STATIC_INFO[] = "raw.hdr-static-info"; /** * HDR10+ Metadata Info. */ typedef C2StreamParam C2StreamHdr10PlusInfo; constexpr char C2_PARAMKEY_INPUT_HDR10_PLUS_INFO[] = "input.hdr10-plus-info"; constexpr char C2_PARAMKEY_OUTPUT_HDR10_PLUS_INFO[] = "output.hdr10-plus-info"; /* ------------------------------------ block-based coding ----------------------------------- */ /** * Block-size, block count and block rate. Used to determine or communicate profile-level * requirements. */ typedef C2StreamParam C2StreamBlockSizeInfo; constexpr char C2_PARAMKEY_BLOCK_SIZE[] = "coded.block-size"; typedef C2StreamParam C2StreamBlockCountInfo; constexpr char C2_PARAMKEY_BLOCK_COUNT[] = "coded.block-count"; typedef C2StreamParam C2StreamBlockRateInfo; constexpr char C2_PARAMKEY_BLOCK_RATE[] = "coded.block-rate"; /* ====================================== VIDEO COMPONENTS ====================================== */ /** * Frame rate (coded and port for raw data) * * Coded frame rates are what is represented in the compressed bitstream and should correspond to * the timestamp. * * Frame rates on raw ports should still correspond to the timestamps. * * For slow motion or timelapse recording, the timestamp shall be adjusted prior to feeding an * encoder, and the time stretch parameter should be used to signal the relationship between * timestamp and real-world time. */ typedef C2StreamParam C2StreamFrameRateInfo; constexpr char C2_PARAMKEY_FRAME_RATE[] = "coded.frame-rate"; #define C2_NAME_STREAM_FRAME_RATE_SETTING C2_PARAMKEY_FRAME_RATE typedef C2PortParam C2PortFrameRateInfo; constexpr char C2_PARAMKEY_INPUT_FRAME_RATE[] = "input.frame-rate"; constexpr char C2_PARAMKEY_OUTPUT_FRAME_RATE[] = "output.frame-rate"; /** * Time stretch. Ratio between real-world time and timestamp. E.g. time stretch of 4.0 means that * timestamp grows 1/4 the speed of real-world time (e.g. 4x slo-mo input). This can be used to * optimize encoding. */ typedef C2PortParam C2PortTimeStretchInfo; constexpr char C2_PARAMKEY_INPUT_TIME_STRETCH[] = "input.time-stretch"; constexpr char C2_PARAMKEY_OUTPUT_TIME_STRETCH[] = "output.time-stretch"; /** * Max video frame size. */ typedef C2StreamParam C2StreamMaxPictureSizeTuning; typedef C2StreamMaxPictureSizeTuning C2MaxVideoSizeHintPortSetting; constexpr char C2_PARAMKEY_MAX_PICTURE_SIZE[] = "raw.max-size"; /** * Picture type mask. */ C2ENUM(C2Config::picture_type_t, uint32_t, SYNC_FRAME = (1 << 0), ///< sync frame, e.g. IDR I_FRAME = (1 << 1), ///< intra frame that is completely encoded P_FRAME = (1 << 2), ///< inter predicted frame from previous frames B_FRAME = (1 << 3), ///< backward predicted (out-of-order) frame ) typedef C2Config::picture_type_t C2PictureTypeMask; // deprecated constexpr C2Config::picture_type_t C2PictureTypeKeyFrame = C2Config::SYNC_FRAME; // deprecated /** * Allowed picture types. */ typedef C2StreamParam>, kParamIndexPictureTypeMask> C2StreamPictureTypeMaskTuning; constexpr char C2_PARAMKEY_PICTURE_TYPE_MASK[] = "coding.picture-type-mask"; /** * Resulting picture type */ typedef C2StreamParam>, kParamIndexPictureType> C2StreamPictureTypeInfo; typedef C2StreamPictureTypeInfo C2StreamPictureTypeMaskInfo; constexpr char C2_PARAMKEY_PICTURE_TYPE[] = "coded.picture-type"; /** * GOP specification. * * GOP is specified in layers between sync frames, by specifying the number of specific type of * frames between the previous type (starting with sync frames for the first layer): * * E.g. * - 4 I frames between each sync frame * - 2 P frames between each I frame * - 1 B frame between each P frame * * [ { I, 4 }, { P, 2 }, { B, 1 } ] ==> (Sync)BPBPB IBPBPB IBPBPB IBPBPB IBPBPB (Sync)BPBPB * * For infinite GOP, I layer can be omitted (as the first frame is always a sync frame.): * * [ { P, MAX_UINT } ] ==> (Sync)PPPPPPPPPPPPPPPPPP... * * Sync frames can also be requested on demand, and as a time-based interval. For time-based * interval, if there hasn't been a sync frame in at least the given time, the next I frame shall * be encoded as a sync frame. For sync request, the next I frame shall be encoded as a sync frame. * * Temporal layering will determine GOP structure other than the I frame count between sync * frames. */ struct C2GopLayerStruct { C2GopLayerStruct(C2Config::picture_type_t type, uint32_t count_) : type_(type), count(count_) { } C2Config::picture_type_t type_; uint32_t count; DEFINE_AND_DESCRIBE_C2STRUCT(GopLayer) C2FIELD(type_, "type") C2FIELD(count, "count") }; typedef C2StreamParam, kParamIndexGop> C2StreamGopTuning; constexpr char C2_PARAMKEY_GOP[] = "coding.gop"; /** * Sync frame can be requested on demand by the client. * * If true, the next I frame shall be encoded as a sync frame. This config can be passed * synchronously with the work, or directly to the component - leading to different result. * If it is passed with work, it shall take effect when that work item is being processed (so * the first I frame at or after that work item shall be a sync frame). */ typedef C2StreamParam C2StreamRequestSyncFrameTuning; constexpr char C2_PARAMKEY_REQUEST_SYNC_FRAME[] = "coding.request-sync-frame"; /** * Sync frame interval in time domain (timestamp). * * If there hasn't been a sync frame in at least this value, the next intra frame shall be encoded * as a sync frame. The value of MAX_I64 or a negative value means no sync frames after the first * frame. A value of 0 means all sync frames. */ typedef C2StreamParam C2StreamSyncFrameIntervalTuning; constexpr char C2_PARAMKEY_SYNC_FRAME_INTERVAL[] = "coding.sync-frame-interval"; // deprecated #define C2_PARAMKEY_SYNC_FRAME_PERIOD C2_PARAMKEY_SYNC_FRAME_INTERVAL /** * Temporal layering * * Layer index is a value between 0 and layer count - 1. Layers with higher index have higher * frequency: * 0 * 1 1 * 2 2 2 2 */ typedef C2StreamParam C2StreamLayerIndexInfo; constexpr char C2_PARAMKEY_LAYER_INDEX[] = "coded.layer-index"; typedef C2StreamParam C2StreamLayerCountInfo; constexpr char C2_PARAMKEY_LAYER_COUNT[] = "coded.layer-count"; struct C2TemporalLayeringStruct { C2TemporalLayeringStruct() : layerCount(0), bLayerCount(0) { } C2TemporalLayeringStruct(size_t /* flexCount */, uint32_t layerCount_, uint32_t bLayerCount_) : layerCount(layerCount_), bLayerCount(c2_min(layerCount_, bLayerCount_)) { } C2TemporalLayeringStruct(size_t flexCount, uint32_t layerCount_, uint32_t bLayerCount_, std::initializer_list ratios) : layerCount(layerCount_), bLayerCount(c2_min(layerCount_, bLayerCount_)) { size_t ix = 0; for (float ratio : ratios) { if (ix == flexCount) { break; } bitrateRatios[ix++] = ratio; } } uint32_t layerCount; ///< total number of layers (0 means no temporal layering) uint32_t bLayerCount; ///< total number of bidirectional layers (<= num layers) /** * Bitrate budgets for each layer and the layers below, given as a ratio of the total * stream bitrate. This can be omitted or partially specififed by the client while configuring, * in which case the component shall fill in appropriate values for the missing layers. * This must be provided by the component when queried for at least layer count - 1 (as the * last layer's budget is always 1.0). */ float bitrateRatios[]; ///< 1.0-based DEFINE_AND_DESCRIBE_FLEX_C2STRUCT(TemporalLayering, bitrateRatios) C2FIELD(layerCount, "layer-count") C2FIELD(bLayerCount, "b-layer-count") C2FIELD(bitrateRatios, "bitrate-ratios") }; typedef C2StreamParam C2StreamTemporalLayeringTuning; constexpr char C2_PARAMKEY_TEMPORAL_LAYERING[] = "coding.temporal-layering"; /** * Intra-refresh. */ C2ENUM(C2Config::intra_refresh_mode_t, uint32_t, INTRA_REFRESH_DISABLED, ///< no intra refresh INTRA_REFRESH_ARBITRARY, ///< arbitrary, unspecified ) struct C2IntraRefreshStruct { C2IntraRefreshStruct() : mode(C2Config::INTRA_REFRESH_DISABLED), period(0.) { } C2IntraRefreshStruct(C2Config::intra_refresh_mode_t mode_, float period_) : mode(mode_), period(period_) { } C2Config::intra_refresh_mode_t mode; ///< refresh mode float period; ///< intra refresh period in frames (must be >= 1), 0 means disabled DEFINE_AND_DESCRIBE_C2STRUCT(IntraRefresh) C2FIELD(mode, "mode") C2FIELD(period, "period") }; typedef C2StreamParam C2StreamIntraRefreshTuning; constexpr char C2_PARAMKEY_INTRA_REFRESH[] = "coding.intra-refresh"; /* ====================================== IMAGE COMPONENTS ====================================== */ /** * Tile layout. * * This described how the image is decomposed into tiles. */ C2ENUM(C2Config::scan_order_t, uint32_t, SCAN_LEFT_TO_RIGHT_THEN_DOWN ) struct C2TileLayoutStruct { C2PictureSizeStruct tile; ///< tile size uint32_t columnCount; ///< number of tiles horizontally uint32_t rowCount; ///< number of tiles vertically C2Config::scan_order_t order; ///< tile order DEFINE_AND_DESCRIBE_C2STRUCT(TileLayout) C2FIELD(tile, "tile") C2FIELD(columnCount, "columns") C2FIELD(rowCount, "rows") C2FIELD(order, "order") }; typedef C2StreamParam C2StreamTileLayoutInfo; constexpr char C2_PARAMKEY_TILE_LAYOUT[] = "coded.tile-layout"; /** * Tile handling. * * Whether to concatenate tiles or output them each. */ C2ENUM(C2Config::tiling_mode_t, uint32_t, TILING_SEPARATE, ///< output each tile in a separate onWorkDone TILING_CONCATENATE ///< output one work completion per frame (concatenate tiles) ) typedef C2StreamParam C2StreamTileHandlingTuning; constexpr char C2_PARAMKEY_TILE_HANDLING[] = "coding.tile-handling"; /* ====================================== AUDIO COMPONENTS ====================================== */ /** * Sample rate */ typedef C2StreamParam C2StreamSampleRateInfo; constexpr char C2_PARAMKEY_SAMPLE_RATE[] = "raw.sample-rate"; constexpr char C2_PARAMKEY_CODED_SAMPLE_RATE[] = "coded.sample-rate"; // deprecated #define C2_NAME_STREAM_SAMPLE_RATE_SETTING C2_PARAMKEY_SAMPLE_RATE /** * Channel count. */ typedef C2StreamParam C2StreamChannelCountInfo; constexpr char C2_PARAMKEY_CHANNEL_COUNT[] = "raw.channel-count"; constexpr char C2_PARAMKEY_CODED_CHANNEL_COUNT[] = "coded.channel-count"; // deprecated #define C2_NAME_STREAM_CHANNEL_COUNT_SETTING C2_PARAMKEY_CHANNEL_COUNT /** * Max channel count. Used to limit the number of coded or decoded channels. */ typedef C2StreamParam C2StreamMaxChannelCountInfo; constexpr char C2_PARAMKEY_MAX_CHANNEL_COUNT[] = "raw.max-channel-count"; constexpr char C2_PARAMKEY_MAX_CODED_CHANNEL_COUNT[] = "coded.max-channel-count"; /** * Audio sample format (PCM encoding) */ C2ENUM(C2Config::pcm_encoding_t, uint32_t, PCM_16, PCM_8, PCM_FLOAT ) typedef C2StreamParam, kParamIndexPcmEncoding> C2StreamPcmEncodingInfo; constexpr char C2_PARAMKEY_PCM_ENCODING[] = "raw.pcm-encoding"; constexpr char C2_PARAMKEY_CODED_PCM_ENCODING[] = "coded.pcm-encoding"; /** * AAC SBR Mode. Used during encoding. */ C2ENUM(C2Config::aac_sbr_mode_t, uint32_t, AAC_SBR_OFF, AAC_SBR_SINGLE_RATE, AAC_SBR_DUAL_RATE, AAC_SBR_AUTO ///< let the codec decide ) typedef C2StreamParam, kParamIndexAacSbrMode> C2StreamAacSbrModeTuning; constexpr char C2_PARAMKEY_AAC_SBR_MODE[] = "coding.aac-sbr-mode"; /** * DRC Compression. Used during decoding. */ C2ENUM(C2Config::drc_compression_mode_t, int32_t, DRC_COMPRESSION_ODM_DEFAULT, ///< odm's default DRC_COMPRESSION_NONE, DRC_COMPRESSION_LIGHT, DRC_COMPRESSION_HEAVY ///< ) typedef C2StreamParam, kParamIndexDrcCompression> C2StreamDrcCompressionModeTuning; constexpr char C2_PARAMKEY_DRC_COMPRESSION_MODE[] = "coding.drc.compression-mode"; /** * DRC target reference level in dBFS. Used during decoding. */ typedef C2StreamParam C2StreamDrcTargetReferenceLevelTuning; constexpr char C2_PARAMKEY_DRC_TARGET_REFERENCE_LEVEL[] = "coding.drc.reference-level"; /** * DRC target reference level in dBFS. Used during decoding. */ typedef C2StreamParam C2StreamDrcEncodedTargetLevelTuning; constexpr char C2_PARAMKEY_DRC_ENCODED_TARGET_LEVEL[] = "coding.drc.encoded-level"; /** * DRC target reference level in dBFS. Used during decoding. */ typedef C2StreamParam C2StreamDrcBoostFactorTuning; constexpr char C2_PARAMKEY_DRC_BOOST_FACTOR[] = "coding.drc.boost-factor"; /** * DRC target reference level in dBFS. Used during decoding. */ typedef C2StreamParam C2StreamDrcAttenuationFactorTuning; constexpr char C2_PARAMKEY_DRC_ATTENUATION_FACTOR[] = "coding.drc.attenuation-factor"; /** * DRC Effect Type (see ISO 23003-4) Uniform Dynamic Range Control. Used during decoding. */ C2ENUM(C2Config::drc_effect_type_t, int32_t, DRC_EFFECT_ODM_DEFAULT = -2, ///< odm's default DRC_EFFECT_OFF = -1, ///< no DRC DRC_EFFECT_NONE = 0, ///< no DRC except to prevent clipping DRC_EFFECT_LATE_NIGHT, DRC_EFFECT_NOISY_ENVIRONMENT, DRC_EFFECT_LIMITED_PLAYBACK_RANGE, DRC_EFFECT_LOW_PLAYBACK_LEVEL, DRC_EFFECT_DIALOG_ENHANCEMENT, DRC_EFFECT_GENERAL_COMPRESSION ) typedef C2StreamParam, kParamIndexDrcEffectType> C2StreamDrcEffectTypeTuning; constexpr char C2_PARAMKEY_DRC_EFFECT_TYPE[] = "coding.drc.effect-type"; /* --------------------------------------- AAC components --------------------------------------- */ /** * AAC stream format */ C2ENUM(C2Config::aac_packaging_t, uint32_t, AAC_PACKAGING_RAW, AAC_PACKAGING_ADTS ) typedef C2Config::aac_packaging_t C2AacStreamFormatKind; // deprecated // deprecated constexpr C2Config::aac_packaging_t C2AacStreamFormatRaw = C2Config::AAC_PACKAGING_RAW; constexpr C2Config::aac_packaging_t C2AacStreamFormatAdts = C2Config::AAC_PACKAGING_ADTS; typedef C2StreamParam>, kParamIndexAacPackaging> C2StreamAacPackagingInfo; typedef C2StreamAacPackagingInfo C2StreamAacFormatInfo; constexpr char C2_PARAMKEY_AAC_PACKAGING[] = "coded.aac-packaging"; #define C2_NAME_STREAM_AAC_FORMAT_SETTING C2_PARAMKEY_AAC_PACKAGING /* ================================ PLATFORM-DEFINED PARAMETERS ================================ */ /** * Platform level and features. */ enum C2Config::platform_level_t : uint32_t { PLATFORM_P, ///< support for Android 9.0 feature set }; // read-only typedef C2GlobalParam, kParamIndexPlatformLevel> C2PlatformLevelSetting; constexpr char C2_PARAMKEY_PLATFORM_LEVEL[] = "api.platform-level"; enum C2Config::platform_feature_t : uint64_t { // no platform-specific features have been defined }; // read-only typedef C2GlobalParam, kParamIndexPlatformFeatures> C2PlatformFeaturesSetting; constexpr char C2_PARAMKEY_PLATFORM_FEATURES[] = "api.platform-features"; /** * This structure describes the preferred ion allocation parameters for a given memory usage. */ struct C2StoreIonUsageStruct { inline C2StoreIonUsageStruct() { memset(this, 0, sizeof(*this)); } inline C2StoreIonUsageStruct(uint64_t usage_, uint32_t capacity_) : usage(usage_), capacity(capacity_), heapMask(0), allocFlags(0), minAlignment(0) { } uint64_t usage; ///< C2MemoryUsage uint32_t capacity; ///< capacity int32_t heapMask; ///< ion heapMask int32_t allocFlags; ///< ion allocation flags uint32_t minAlignment; ///< minimum alignment DEFINE_AND_DESCRIBE_C2STRUCT(StoreIonUsage) C2FIELD(usage, "usage") C2FIELD(capacity, "capacity") C2FIELD(heapMask, "heap-mask") C2FIELD(allocFlags, "alloc-flags") C2FIELD(minAlignment, "min-alignment") }; // store, private typedef C2GlobalParam C2StoreIonUsageInfo; /** * Flexible pixel format descriptors */ struct C2FlexiblePixelFormatDescriptorStruct { uint32_t pixelFormat; uint32_t bitDepth; C2Color::subsampling_t subsampling; C2Color::plane_layout_t layout; DEFINE_AND_DESCRIBE_C2STRUCT(FlexiblePixelFormatDescriptor) C2FIELD(pixelFormat, "pixel-format") C2FIELD(bitDepth, "bit-depth") C2FIELD(subsampling, "subsampling") C2FIELD(layout, "layout") }; /** * Plane layout of flexible pixel formats. * * bpp: bytes per color component, e.g. 1 for 8-bit formats, and 2 for 10-16-bit formats. */ C2ENUM(C2Color::plane_layout_t, uint32_t, /** Unknown layout */ UNKNOWN_LAYOUT, /** Planar layout with rows of each plane packed (colInc = bpp) */ PLANAR_PACKED, /** Semiplanar layout with rows of each plane packed (colInc_Y/A = bpp (planar), * colInc_Cb/Cr = 2*bpp (interleaved). Used only for YUV(A) formats. */ SEMIPLANAR_PACKED, /** Interleaved packed. colInc = N*bpp (N are the number of color components) */ INTERLEAVED_PACKED, /** Interleaved aligned. colInc = smallest power of 2 >= N*bpp (N are the number of color * components) */ INTERLEAVED_ALIGNED ) typedef C2GlobalParam, kParamIndexFlexiblePixelFormatDescriptors> C2StoreFlexiblePixelFormatDescriptorsInfo; /** * This structure describes the android dataspace for a raw video/image frame. */ typedef C2StreamParam C2StreamDataSpaceInfo; constexpr char C2_PARAMKEY_DATA_SPACE[] = "raw.data-space"; /** * This structure describes the android surface scaling mode for a raw video/image frame. */ typedef C2StreamParam C2StreamSurfaceScalingInfo; constexpr char C2_PARAMKEY_SURFACE_SCALING_MODE[] = "raw.surface-scaling"; /* ======================================= INPUT SURFACE ======================================= */ /** * Input surface EOS */ typedef C2GlobalParam C2InputSurfaceEosTuning; constexpr char C2_PARAMKEY_INPUT_SURFACE_EOS[] = "input-surface.eos"; #define C2_NAME_INPUT_SURFACE_EOS_TUNING C2_PARAMKEY_INPUT_SURFACE_EOS /** * Start/suspend/resume/stop controls and timestamps for input surface. * * TODO: make these counters */ struct C2TimedControlStruct { c2_bool_t enabled; ///< control is enabled int64_t timestamp; ///< if enabled, time the control should take effect C2TimedControlStruct() : enabled(C2_FALSE), timestamp(0) { } /* implicit */ C2TimedControlStruct(uint64_t timestamp_) : enabled(C2_TRUE), timestamp(timestamp_) { } DEFINE_AND_DESCRIBE_C2STRUCT(TimedControl) C2FIELD(enabled, "enabled") C2FIELD(timestamp, "timestamp") }; typedef C2PortParam C2PortStartTimestampTuning; constexpr char C2_PARAMKEY_INPUT_SURFACE_START_AT[] = "input-surface.start"; typedef C2PortParam C2PortSuspendTimestampTuning; constexpr char C2_PARAMKEY_INPUT_SURFACE_SUSPEND_AT[] = "input-surface.suspend"; typedef C2PortParam C2PortResumeTimestampTuning; constexpr char C2_PARAMKEY_INPUT_SURFACE_RESUME_AT[] = "input-surface.resume"; typedef C2PortParam C2PortStopTimestampTuning; constexpr char C2_PARAMKEY_INPUT_SURFACE_STOP_AT[] = "input-surface.stop"; /** * Time offset for input surface. Input timestamp to codec is surface buffer timestamp plus this * time offset. */ typedef C2GlobalParam C2ComponentTimeOffsetTuning; constexpr char C2_PARAMKEY_INPUT_SURFACE_TIME_OFFSET[] = "input-surface.time-offset"; /** * Minimum fps for input surface. * * Repeat frame to meet this. */ typedef C2PortParam C2PortMinFrameRateTuning; constexpr char C2_PARAMKEY_INPUT_SURFACE_MIN_FRAME_RATE[] = "input-surface.min-frame-rate"; /** * Timestamp adjustment (override) for input surface buffers. These control the input timestamp * fed to the codec, but do not impact the output timestamp. */ struct C2TimestampGapAdjustmentStruct { /// control modes enum mode_t : uint32_t; inline C2TimestampGapAdjustmentStruct(); inline C2TimestampGapAdjustmentStruct(mode_t mode_, uint64_t value_) : mode(mode_), value(value_) { } mode_t mode; ///< control mode uint64_t value; ///< control value for gap between two timestamp DEFINE_AND_DESCRIBE_C2STRUCT(TimestampGapAdjustment) C2FIELD(mode, "mode") C2FIELD(value, "value") }; C2ENUM(C2TimestampGapAdjustmentStruct::mode_t, uint32_t, NONE, MIN_GAP, FIXED_GAP, ); inline C2TimestampGapAdjustmentStruct::C2TimestampGapAdjustmentStruct() : mode(C2TimestampGapAdjustmentStruct::NONE), value(0) { } typedef C2PortParam C2PortTimestampGapTuning; constexpr char C2_PARAMKEY_INPUT_SURFACE_TIMESTAMP_ADJUSTMENT[] = "input-surface.timestamp-adjustment"; /// @} #endif // C2CONFIG_H_