From 8602fe3a0b25f786211993d12962f6c4f13a1e6e Mon Sep 17 00:00:00 2001 From: Sungtak Lee Date: Wed, 19 Oct 2022 17:01:18 +0000 Subject: [PATCH] Add Codec2 AIDL interface Bug: 251850069 Test: m Change-Id: I1fc28084519281df68bca7ae5e2b814b03214577 Merged-In: I1fc28084519281df68bca7ae5e2b814b03214577 --- .../compatibility_matrix.current.xml | 9 + media/c2/aidl/Android.bp | 29 ++ .../android/hardware/media/c2/BaseBlock.aidl | 39 +++ .../android/hardware/media/c2/Block.aidl | 40 +++ .../android/hardware/media/c2/Buffer.aidl | 39 +++ .../hardware/media/c2/FieldDescriptor.aidl | 62 ++++ .../android/hardware/media/c2/FieldId.aidl | 39 +++ .../media/c2/FieldSupportedValues.aidl | 41 +++ .../media/c2/FieldSupportedValuesQuery.aidl | 44 +++ .../c2/FieldSupportedValuesQueryResult.aidl | 39 +++ .../android/hardware/media/c2/FrameData.aidl | 47 +++ .../android/hardware/media/c2/IComponent.aidl | 53 +++ .../media/c2/IComponentInterface.aidl | 38 +++ .../hardware/media/c2/IComponentListener.aidl | 53 +++ .../hardware/media/c2/IComponentStore.aidl | 66 ++++ .../hardware/media/c2/IConfigurable.aidl | 48 +++ .../android/hardware/media/c2/InfoBuffer.aidl | 39 +++ .../hardware/media/c2/ParamDescriptor.aidl | 48 +++ .../android/hardware/media/c2/ParamField.aidl | 39 +++ .../hardware/media/c2/ParamFieldValues.aidl | 39 +++ .../android/hardware/media/c2/Params.aidl | 38 +++ .../hardware/media/c2/SettingResult.aidl | 53 +++ .../android/hardware/media/c2/Status.aidl | 52 +++ .../hardware/media/c2/StructDescriptor.aidl | 39 +++ .../hardware/media/c2/SurfaceSyncObj.aidl | 41 +++ .../android/hardware/media/c2/ValueRange.aidl | 42 +++ .../android/hardware/media/c2/Work.aidl | 42 +++ .../android/hardware/media/c2/WorkBundle.aidl | 39 +++ .../hardware/media/c2/WorkOrdinal.aidl | 40 +++ .../android/hardware/media/c2/Worklet.aidl | 41 +++ .../android/hardware/media/c2/BaseBlock.aidl | 38 +++ .../aidl/android/hardware/media/c2/Block.aidl | 44 +++ .../android/hardware/media/c2/Buffer.aidl | 37 +++ .../hardware/media/c2/FieldDescriptor.aidl | 103 ++++++ .../android/hardware/media/c2/FieldId.aidl | 35 ++ .../media/c2/FieldSupportedValues.aidl | 54 ++++ .../media/c2/FieldSupportedValuesQuery.aidl | 47 +++ .../c2/FieldSupportedValuesQueryResult.aidl | 44 +++ .../android/hardware/media/c2/FrameData.aidl | 97 ++++++ .../android/hardware/media/c2/IComponent.aidl | 304 ++++++++++++++++++ .../media/c2/IComponentInterface.aidl | 38 +++ .../hardware/media/c2/IComponentListener.aidl | 131 ++++++++ .../hardware/media/c2/IComponentStore.aidl | 185 +++++++++++ .../hardware/media/c2/IConfigurable.aidl | 213 ++++++++++++ .../android/hardware/media/c2/InfoBuffer.aidl | 36 +++ .../hardware/media/c2/ParamDescriptor.aidl | 73 +++++ .../android/hardware/media/c2/ParamField.aidl | 34 ++ .../hardware/media/c2/ParamFieldValues.aidl | 43 +++ .../android/hardware/media/c2/Params.aidl | 36 +++ .../hardware/media/c2/SettingResult.aidl | 99 ++++++ .../android/hardware/media/c2/Status.aidl | 82 +++++ .../hardware/media/c2/StructDescriptor.aidl | 48 +++ .../hardware/media/c2/SurfaceSyncObj.aidl | 55 ++++ .../android/hardware/media/c2/ValueRange.aidl | 63 ++++ .../aidl/android/hardware/media/c2/Work.aidl | 83 +++++ .../android/hardware/media/c2/WorkBundle.aidl | 48 +++ .../hardware/media/c2/WorkOrdinal.aidl | 48 +++ .../android/hardware/media/c2/Worklet.aidl | 54 ++++ 58 files changed, 3450 insertions(+) create mode 100644 media/c2/aidl/Android.bp create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/BaseBlock.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Block.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Buffer.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldDescriptor.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldId.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValues.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValuesQuery.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValuesQueryResult.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FrameData.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponent.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentInterface.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentListener.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentStore.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IConfigurable.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/InfoBuffer.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamDescriptor.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamField.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamFieldValues.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Params.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/SettingResult.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Status.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/StructDescriptor.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/SurfaceSyncObj.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ValueRange.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Work.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/WorkBundle.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/WorkOrdinal.aidl create mode 100644 media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Worklet.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/BaseBlock.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/Block.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/Buffer.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/FieldDescriptor.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/FieldId.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/FieldSupportedValues.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/FieldSupportedValuesQuery.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/FieldSupportedValuesQueryResult.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/FrameData.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/IComponent.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/IComponentInterface.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/IComponentListener.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/IComponentStore.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/IConfigurable.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/InfoBuffer.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/ParamDescriptor.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/ParamField.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/ParamFieldValues.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/Params.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/SettingResult.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/Status.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/StructDescriptor.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/SurfaceSyncObj.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/ValueRange.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/Work.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/WorkBundle.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/WorkOrdinal.aidl create mode 100644 media/c2/aidl/android/hardware/media/c2/Worklet.aidl diff --git a/compatibility_matrices/compatibility_matrix.current.xml b/compatibility_matrices/compatibility_matrix.current.xml index cf53a1d7ac..103916fc69 100644 --- a/compatibility_matrices/compatibility_matrix.current.xml +++ b/compatibility_matrices/compatibility_matrix.current.xml @@ -453,6 +453,15 @@ vendor[0-9]*_software + + android.hardware.media.c2 + 1 + + IComponentStore + default[0-9]* + vendor[0-9]*_software + + android.hardware.memtrack 1 diff --git a/media/c2/aidl/Android.bp b/media/c2/aidl/Android.bp new file mode 100644 index 0000000000..10867c047e --- /dev/null +++ b/media/c2/aidl/Android.bp @@ -0,0 +1,29 @@ +// This is the expected build file, but it may not be right in all cases + +aidl_interface { + name: "android.hardware.media.c2", + vendor_available: true, + srcs: ["android/hardware/media/c2/*.aidl"], + include_dirs: [ + "frameworks/native/aidl/gui", + ], + imports: [ + "android.hardware.common-V2", + "android.hardware.media.bufferpool2-V1", + ], + stability: "vintf", + backend: { + cpp: { + enabled: false, + }, + java: { + enabled: false, + }, + ndk: { + enabled: true, + additional_shared_libraries: [ + "libnativewindow", + ], + }, + }, +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/BaseBlock.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/BaseBlock.aidl new file mode 100644 index 0000000000..460ff97522 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/BaseBlock.aidl @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +union BaseBlock { + android.hardware.common.NativeHandle nativeBlock; + android.hardware.media.bufferpool2.BufferStatusMessage pooledBlock; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Block.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Block.aidl new file mode 100644 index 0000000000..7b3005e22d --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Block.aidl @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable Block { + int index; + android.hardware.media.c2.Params meta; + android.hardware.common.NativeHandle fence; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Buffer.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Buffer.aidl new file mode 100644 index 0000000000..b632932cec --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Buffer.aidl @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable Buffer { + android.hardware.media.c2.Params info; + android.hardware.media.c2.Block[] blocks; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldDescriptor.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldDescriptor.aidl new file mode 100644 index 0000000000..d0e4cbf069 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldDescriptor.aidl @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable FieldDescriptor { + android.hardware.media.c2.FieldId fieldId; + android.hardware.media.c2.FieldDescriptor.Type type; + int structIndex; + int extent; + String name; + android.hardware.media.c2.FieldDescriptor.NamedValue[] namedValues; + @Backing(type="int") @VintfStability + enum Type { + NO_INIT = 0, + INT32 = 1, + UINT32 = 2, + CNTR32 = 3, + INT64 = 4, + UINT64 = 5, + CNTR64 = 6, + FLOAT = 7, + STRING = 256, + BLOB = 257, + STRUCT = 131072, + } + @VintfStability + parcelable NamedValue { + String name; + long value; + } +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldId.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldId.aidl new file mode 100644 index 0000000000..935b85dbbf --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldId.aidl @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable FieldId { + int offset; + int sizeBytes; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValues.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValues.aidl new file mode 100644 index 0000000000..69060bea1d --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValues.aidl @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +union FieldSupportedValues { + boolean empty; + android.hardware.media.c2.ValueRange range; + long[] values; + long[] flags; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValuesQuery.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValuesQuery.aidl new file mode 100644 index 0000000000..22f7c8491b --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValuesQuery.aidl @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable FieldSupportedValuesQuery { + android.hardware.media.c2.ParamField field; + android.hardware.media.c2.FieldSupportedValuesQuery.Type type; + @Backing(type="int") @VintfStability + enum Type { + POSSIBLE = 0, + CURRENT = 1, + } +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValuesQueryResult.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValuesQueryResult.aidl new file mode 100644 index 0000000000..187e3ebfeb --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValuesQueryResult.aidl @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable FieldSupportedValuesQueryResult { + android.hardware.media.c2.Status status; + android.hardware.media.c2.FieldSupportedValues values; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FrameData.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FrameData.aidl new file mode 100644 index 0000000000..e73b05e95e --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FrameData.aidl @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable FrameData { + int flags; + android.hardware.media.c2.WorkOrdinal ordinal; + android.hardware.media.c2.Buffer[] buffers; + android.hardware.media.c2.Params configUpdate; + android.hardware.media.c2.InfoBuffer[] infoBuffers; + const int DROP_FRAME = 1; + const int END_OF_STREAM = 2; + const int DISCARD_FRAME = 4; + const int FLAG_INCOMPLETE = 8; + const int CODEC_CONFIG = -2147483648; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponent.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponent.aidl new file mode 100644 index 0000000000..7ed09afae7 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponent.aidl @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +interface IComponent { + android.hardware.common.NativeHandle configureVideoTunnel(in int avSyncHwId); + android.hardware.media.c2.IComponent.BlockPool createBlockPool(in int allocatorId); + void destroyBlockPool(in long blockPoolId); + void drain(in boolean withEos); + android.hardware.media.c2.WorkBundle flush(); + android.hardware.media.c2.IComponentInterface getInterface(); + void queue(in android.hardware.media.c2.WorkBundle workBundle); + void release(); + void reset(); + void setOutputSurface(in long blockPoolId, in android.view.Surface surface, in android.hardware.media.c2.SurfaceSyncObj syncObject); + void start(); + void stop(); + parcelable BlockPool { + long blockPoolId; + android.hardware.media.c2.IConfigurable configurable; + } +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentInterface.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentInterface.aidl new file mode 100644 index 0000000000..2350daeec2 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentInterface.aidl @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +interface IComponentInterface { + android.hardware.media.c2.IConfigurable getConfigurable(); +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentListener.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentListener.aidl new file mode 100644 index 0000000000..f6f2a6391c --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentListener.aidl @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +interface IComponentListener { + oneway void onError(in android.hardware.media.c2.Status status, in int errorCode); + oneway void onFramesRendered(in android.hardware.media.c2.IComponentListener.RenderedFrame[] renderedFrames); + oneway void onInputBuffersReleased(in android.hardware.media.c2.IComponentListener.InputBuffer[] inputBuffers); + oneway void onTripped(in android.hardware.media.c2.SettingResult[] settingResults); + oneway void onWorkDone(in android.hardware.media.c2.WorkBundle workBundle); + @VintfStability + parcelable InputBuffer { + long frameIndex; + int arrayIndex; + } + @VintfStability + parcelable RenderedFrame { + long bufferQueueId; + int slotId; + long timestampNs; + } +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentStore.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentStore.aidl new file mode 100644 index 0000000000..35532be3a2 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentStore.aidl @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +interface IComponentStore { + void copyBuffer(in android.hardware.media.c2.Buffer src, in android.hardware.media.c2.Buffer dst); + android.hardware.media.c2.IComponent createComponent(in String name, in android.hardware.media.c2.IComponentListener listener, in android.hardware.media.bufferpool2.IClientManager pool); + android.hardware.media.c2.IComponentInterface createInterface(in String name); + android.hardware.media.c2.IConfigurable getConfigurable(); + android.hardware.media.bufferpool2.IClientManager getPoolClientManager(); + android.hardware.media.c2.StructDescriptor[] getStructDescriptors(in int[] indices); + android.hardware.media.c2.IComponentStore.ComponentTraits[] listComponents(); + @VintfStability + parcelable ComponentTraits { + String name; + android.hardware.media.c2.IComponentStore.ComponentTraits.Domain domain; + android.hardware.media.c2.IComponentStore.ComponentTraits.Kind kind; + int rank; + String mediaType; + String[] aliases; + @Backing(type="int") @VintfStability + enum Kind { + OTHER = 0, + DECODER = 1, + ENCODER = 2, + } + @Backing(type="int") @VintfStability + enum Domain { + OTHER = 0, + VIDEO = 1, + AUDIO = 2, + IMAGE = 3, + } + } +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IConfigurable.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IConfigurable.aidl new file mode 100644 index 0000000000..32f5abdb51 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IConfigurable.aidl @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +interface IConfigurable { + android.hardware.media.c2.IConfigurable.ConfigResult config(in android.hardware.media.c2.Params inParams, in boolean mayBlock); + int getId(); + String getName(); + android.hardware.media.c2.Params query(in int[] indices, in boolean mayBlock); + android.hardware.media.c2.ParamDescriptor[] querySupportedParams(in int start, in int count); + android.hardware.media.c2.FieldSupportedValuesQueryResult[] querySupportedValues(in android.hardware.media.c2.FieldSupportedValuesQuery[] inFields, in boolean mayBlock); + @VintfStability + parcelable ConfigResult { + android.hardware.media.c2.Params params; + android.hardware.media.c2.SettingResult[] failures; + } +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/InfoBuffer.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/InfoBuffer.aidl new file mode 100644 index 0000000000..94cd77d925 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/InfoBuffer.aidl @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable InfoBuffer { + int index; + android.hardware.media.c2.Buffer buffer; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamDescriptor.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamDescriptor.aidl new file mode 100644 index 0000000000..04c869c066 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamDescriptor.aidl @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable ParamDescriptor { + int index; + int attrib; + String name; + int[] dependencies; + const int ATTRIBUTE_REQUIRED = 1; + const int ATTRIBUTE_PERSISTENT = 2; + const int ATTRIBUTE_STRICT = 4; + const int ATTRIBUTE_READ_ONLY = 8; + const int ATTRIBUTE_HIDDEN = 16; + const int ATTRIBUTE_INTERNAL = 32; + const int ATTRIBUTE_CONST = 64; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamField.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamField.aidl new file mode 100644 index 0000000000..13d252257e --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamField.aidl @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable ParamField { + int index; + android.hardware.media.c2.FieldId fieldId; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamFieldValues.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamFieldValues.aidl new file mode 100644 index 0000000000..5a2821cdb2 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamFieldValues.aidl @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable ParamFieldValues { + android.hardware.media.c2.ParamField paramOrField; + android.hardware.media.c2.FieldSupportedValues[] values; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Params.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Params.aidl new file mode 100644 index 0000000000..7d363c06b3 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Params.aidl @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable Params { + byte[] params; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/SettingResult.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/SettingResult.aidl new file mode 100644 index 0000000000..f9e6a93b24 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/SettingResult.aidl @@ -0,0 +1,53 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable SettingResult { + android.hardware.media.c2.SettingResult.Failure failure; + android.hardware.media.c2.ParamFieldValues field; + android.hardware.media.c2.ParamFieldValues[] conflicts; + @Backing(type="int") @VintfStability + enum Failure { + BAD_TYPE = 0, + BAD_PORT = 1, + BAD_INDEX = 2, + READ_ONLY = 3, + MISMATCH = 4, + BAD_VALUE = 5, + CONFLICT = 6, + UNSUPPORTED = 7, + INFO_BAD_VALUE = 8, + INFO_CONFLICT = 9, + } +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Status.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Status.aidl new file mode 100644 index 0000000000..ad07677aca --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Status.aidl @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable Status { + int status; + const int OK = 0; + const int BAD_VALUE = -22; + const int BAD_INDEX = -75; + const int CANNOT_DO = -2147483646; + const int DUPLICATE = -17; + const int NOT_FOUND = -2; + const int BAD_STATE = -38; + const int BLOCKING = -9930; + const int NO_MEMORY = -12; + const int REFUSED = -1; + const int TIMED_OUT = -110; + const int OMITTED = -74; + const int CORRUPTED = -2147483648; + const int NO_INIT = -19; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/StructDescriptor.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/StructDescriptor.aidl new file mode 100644 index 0000000000..58268e0b92 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/StructDescriptor.aidl @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable StructDescriptor { + int type; + android.hardware.media.c2.FieldDescriptor[] fields; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/SurfaceSyncObj.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/SurfaceSyncObj.aidl new file mode 100644 index 0000000000..1c9bf8d989 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/SurfaceSyncObj.aidl @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable SurfaceSyncObj { + android.hardware.common.NativeHandle syncMemory; + long bqId; + int generationId; + long consumerUsage; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ValueRange.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ValueRange.aidl new file mode 100644 index 0000000000..db71ce044e --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ValueRange.aidl @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable ValueRange { + long min; + long max; + long step; + long num; + long denom; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Work.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Work.aidl new file mode 100644 index 0000000000..a5343488f5 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Work.aidl @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable Work { + byte[] chainInfo; + android.hardware.media.c2.FrameData input; + android.hardware.media.c2.Worklet[] worklets; + int workletsProcessed; + android.hardware.media.c2.Status result; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/WorkBundle.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/WorkBundle.aidl new file mode 100644 index 0000000000..84708a8556 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/WorkBundle.aidl @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable WorkBundle { + android.hardware.media.c2.Work[] works; + android.hardware.media.c2.BaseBlock[] baseBlocks; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/WorkOrdinal.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/WorkOrdinal.aidl new file mode 100644 index 0000000000..2833df3a79 --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/WorkOrdinal.aidl @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable WorkOrdinal { + long timestampUs; + long frameIndex; + long customOrdinal; +} diff --git a/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Worklet.aidl b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Worklet.aidl new file mode 100644 index 0000000000..a79abf202b --- /dev/null +++ b/media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Worklet.aidl @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2022 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.media.c2; +@VintfStability +parcelable Worklet { + int componentId; + byte[] tunings; + android.hardware.media.c2.SettingResult[] failures; + android.hardware.media.c2.FrameData output; +} diff --git a/media/c2/aidl/android/hardware/media/c2/BaseBlock.aidl b/media/c2/aidl/android/hardware/media/c2/BaseBlock.aidl new file mode 100644 index 0000000000..8b8b8e0e46 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/BaseBlock.aidl @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.common.NativeHandle; + +/** + * Storage type for `BaseBlock`. + * + * A `BaseBlock` is a representation of a codec memory block. Coded data, + * decoded data, codec-specific data, and other codec-related data are all sent + * in the form of BaseBlocks. + */ +@VintfStability +union BaseBlock { + /** + * #nativeBlock is the opaque representation of a buffer. + */ + NativeHandle nativeBlock; + /** + * #pooledBlock is a reference to a buffer handled by a BufferPool. + */ + android.hardware.media.bufferpool2.BufferStatusMessage pooledBlock; +} diff --git a/media/c2/aidl/android/hardware/media/c2/Block.aidl b/media/c2/aidl/android/hardware/media/c2/Block.aidl new file mode 100644 index 0000000000..34aa7b173f --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/Block.aidl @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.common.NativeHandle; +import android.hardware.media.c2.Params; + +/** + * Reference to a @ref BaseBlock within a @ref WorkBundle. + * + * `Block` contains additional attributes that `BaseBlock` does not. These + * attributes may differ among `Block` objects that refer to the same + * `BaseBlock` in the same `WorkBundle`. + */ +@VintfStability +parcelable Block { + /** + * Identity of a `BaseBlock` within a `WorkBundle`. This is an index into + * #WorkBundle.baseBlocks. + */ + int index; + /** + * Metadata associated with this `Block`. + */ + Params meta; + /** + * Fence for synchronizing `Block` access. + */ + NativeHandle fence; +} diff --git a/media/c2/aidl/android/hardware/media/c2/Buffer.aidl b/media/c2/aidl/android/hardware/media/c2/Buffer.aidl new file mode 100644 index 0000000000..d2dcf2dfe0 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/Buffer.aidl @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.Block; +import android.hardware.media.c2.Params; + +/** + * A codec buffer, which is a collection of @ref Block objects and metadata. + * + * This is a part of @ref FrameData. + */ +@VintfStability +parcelable Buffer { + /** + * Metadata associated with the buffer. + */ + Params info; + /** + * Blocks contained in the buffer. + */ + Block[] blocks; +} diff --git a/media/c2/aidl/android/hardware/media/c2/FieldDescriptor.aidl b/media/c2/aidl/android/hardware/media/c2/FieldDescriptor.aidl new file mode 100644 index 0000000000..a2774ec72e --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/FieldDescriptor.aidl @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.FieldId; + +/** + * Description of a field inside a C2Param structure. + */ +@VintfStability +parcelable FieldDescriptor { + /** + * Possible types of the field. + */ + @VintfStability + @Backing(type="int") + enum Type { + NO_INIT = 0, + INT32, + UINT32, + CNTR32, + INT64, + UINT64, + CNTR64, + FLOAT, + /** + * Fixed-size string (POD). + */ + STRING = 0x100, + /** + * A blob has no sub-elements and can be thought of as an array of + * bytes. However, bytes cannot be individually addressed by clients. + */ + BLOB, + /** + * The field is a structure that may contain other fields. + */ + STRUCT = 0x20000, + } + /** + * Named value type. This is used for defining an enum value for a numeric + * type. + */ + @VintfStability + parcelable NamedValue { + /** + * Name of the enum value. This must be unique for each enum value in + * the same field. + */ + String name; + /** + * Underlying value of the enum value. Multiple enum names may have the + * same underlying value. + */ + long value; + } + /** + * Location of the field in the C2Param structure + */ + FieldId fieldId; + /** + * Type of the field. + */ + Type type; + /** + * If #type is #Type.STRUCT, #structIndex is the C2Param structure index; + * otherwise, #structIndex is not used. + */ + int structIndex; + /** + * Extent of the field. + * - For a non-array field, #extent is 1. + * - For a fixed-length array field, #extent is the length. An array field + * of length 1 is indistinguishable from a non-array field. + * - For a variable-length array field, #extent is 0. This can only occur as + * the last member of a C2Param structure. + */ + int extent; + /** + * Name of the field. This must be unique for each field in the same + * structure. + */ + String name; + /** + * List of enum values. This is not used when #type is not one of the + * numeric types. + */ + NamedValue[] namedValues; +} diff --git a/media/c2/aidl/android/hardware/media/c2/FieldId.aidl b/media/c2/aidl/android/hardware/media/c2/FieldId.aidl new file mode 100644 index 0000000000..68bf058962 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/FieldId.aidl @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2022 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.media.c2; + +/** + * Identifying information of a field relative to a known C2Param structure. + * + * Within a given C2Param structure, each field is uniquely identified by @ref + * FieldId. + */ +@VintfStability +parcelable FieldId { + /** + * Offset of the field in bytes. + */ + int offset; + /** + * Size of the field in bytes. + */ + int sizeBytes; +} diff --git a/media/c2/aidl/android/hardware/media/c2/FieldSupportedValues.aidl b/media/c2/aidl/android/hardware/media/c2/FieldSupportedValues.aidl new file mode 100644 index 0000000000..6c2033b5d8 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/FieldSupportedValues.aidl @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.ValueRange; + +/* + * Description of supported values for a field of C2Param. + * + * This can be a continuous range or a discrete set of values. + * + * The intended type of values must be made clear in the context where + * `FieldSupportedValues` is used. + */ +@VintfStability +union FieldSupportedValues { + /** + * No supported values + */ + boolean empty; + /** + * Numeric range, described in a #ValueRange structure + */ + ValueRange range; + /** + * List of values + */ + long[] values; + /** + * List of flags that can be OR-ed. + * + * The list contains { min-mask, flag1, flag2... }. Basically, the first + * value is the required set of flags to be set, and the rest of the values are flags that can + * be set independently. FLAGS is only supported for integral types. Supported flags should + * not overlap, as it can make validation non-deterministic. The standard validation method + * is that starting from the original value, if each flag is removed when fully present (the + * min-mask must be fully present), we shall arrive at 0. + */ + long[] flags; +} diff --git a/media/c2/aidl/android/hardware/media/c2/FieldSupportedValuesQuery.aidl b/media/c2/aidl/android/hardware/media/c2/FieldSupportedValuesQuery.aidl new file mode 100644 index 0000000000..bdaaef6b73 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/FieldSupportedValuesQuery.aidl @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.ParamField; + +/** + * Query information for supported values of a field. This is used as input to + * IConfigurable::querySupportedValues(). + */ +@VintfStability +parcelable FieldSupportedValuesQuery { + @VintfStability + @Backing(type="int") + enum Type { + /** + * Query all possible values regardless of other settings. + */ + POSSIBLE = 0, + /** + * Query currently possible values given dependent settings. + */ + CURRENT, + } + /** + * Identity of the field to query. + */ + ParamField field; + /** + * Type of the query. See #Type for more information. + */ + Type type; +} diff --git a/media/c2/aidl/android/hardware/media/c2/FieldSupportedValuesQueryResult.aidl b/media/c2/aidl/android/hardware/media/c2/FieldSupportedValuesQueryResult.aidl new file mode 100644 index 0000000000..b5c28c6d1c --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/FieldSupportedValuesQueryResult.aidl @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.FieldSupportedValues; +import android.hardware.media.c2.Status; + +/** + * This structure is used to hold the result from + * IConfigurable::querySupportedValues(). + */ +@VintfStability +parcelable FieldSupportedValuesQueryResult { + /** + * Result of the query. Possible values are + * - `Status::OK`: The query was successful. + * - `Status::BAD_STATE`: The query was requested when the `IConfigurable` instance + * was in a bad state. + * - `Status::BAD_INDEX`: The requested field was not recognized. + * - `Status::TIMED_OUT`: The query could not be completed in a timely manner. + * - `Status::BLOCKING`: The query must block, but the parameter `mayBlock` in the + * call to `querySupportedValues()` was `false`. + * - `Status::CORRUPTED`: Some unknown error occurred. + */ + Status status; + /** + * Supported values. This is meaningful only when #status is `OK`. + */ + FieldSupportedValues values; +} diff --git a/media/c2/aidl/android/hardware/media/c2/FrameData.aidl b/media/c2/aidl/android/hardware/media/c2/FrameData.aidl new file mode 100644 index 0000000000..15c1b6d434 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/FrameData.aidl @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.Buffer; +import android.hardware.media.c2.InfoBuffer; +import android.hardware.media.c2.Params; +import android.hardware.media.c2.WorkOrdinal; + +/** + * Data for an input frame or an output frame. + * + * This structure represents a @e frame with its metadata. A @e frame consists + * of an ordered set of buffers, configuration changes, and info buffers along + * with some non-configuration metadata. + * + * @note `FrameData` is the HIDL counterpart of `C2FrameData` in the Codec 2.0 + * standard. + */ +@VintfStability +parcelable FrameData { + /** List of frame flags */ + /** + * For input frames: no output frame shall be generated when processing + * this frame, but metadata must still be processed. + * + * For output frames: this frame must be discarded but metadata is still + * valid. + */ + const int DROP_FRAME = (1 << 0); + /** + * This frame is the last frame of the current stream. Further frames + * are part of a new stream. + */ + const int END_OF_STREAM = (1 << 1); + /** + * This frame must be discarded with its metadata. + * + * This flag is only set by components, e.g. as a response to the flush + * command. + */ + const int DISCARD_FRAME = (1 << 2); + /** + * This frame is not the last frame produced for the input. + * + * This flag is normally set by the component - e.g. when an input frame + * results in multiple output frames, this flag is set on all but the + * last output frame. + * + * Also, when components are chained, this flag should be propagated + * down the work chain. That is, if set on an earlier frame of a + * work-chain, it should be propagated to all later frames in that + * chain. Additionally, components down the chain could set this flag + * even if not set earlier, e.g. if multiple output frames are generated + * at that component for the input frame. + */ + const int FLAG_INCOMPLETE = (1 << 3); + /** + * This frame contains only codec-specific configuration data, and no + * actual access unit. + */ + const int CODEC_CONFIG = (1 << 31); + /** + * Frame flags, as described above. + */ + int flags; + /** + * @ref WorkOrdinal of the frame. + */ + WorkOrdinal ordinal; + /** + * List of frame buffers. + */ + Buffer[] buffers; + /** + * List of configuration updates. + */ + Params configUpdate; + /** + * List of info buffers. + */ + InfoBuffer[] infoBuffers; +} diff --git a/media/c2/aidl/android/hardware/media/c2/IComponent.aidl b/media/c2/aidl/android/hardware/media/c2/IComponent.aidl new file mode 100644 index 0000000000..b3390c3f4d --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/IComponent.aidl @@ -0,0 +1,304 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.common.NativeHandle; +import android.view.Surface; + +import android.hardware.media.c2.IComponentInterface; +import android.hardware.media.c2.IConfigurable; +import android.hardware.media.c2.WorkBundle; +import android.hardware.media.c2.SurfaceSyncObj; + +/** + * Interface for an AIDL Codec2 component. + * Components have two states: stopped and running. The running state has three + * sub-states: executing, tripped and error. + * + * All methods in `IComponent` must not block. If a method call cannot be + * completed in a timely manner, it must throw `Status::TIMED_OUT`. + */ +@VintfStability +interface IComponent { + /** + * The reference object from framwork to HAL C2BlockPool. + * + * The object will be returned when C2BlockPool is created by a framework + * request. The object also can be destroyed using blockPoolId. + * Using configurable framework can query/config the object in HAL(IComponent). + */ + parcelable BlockPool { + long blockPoolId; + IConfigurable configurable; + } + /** + * Configures a component for a tunneled playback mode. + * + * A successful call to this method puts the component in the *tunneled* + * mode. In this mode, the output `Worklet`s returned in + * IComponentListener::onWorkDone() may not contain any buffers. The output + * buffers are passed directly to the consumer end of a buffer queue whose + * producer side is configured with the returned @p sidebandStream passed + * to IGraphicBufferProducer::setSidebandStream(). + * + * The component is initially in the non-tunneled mode by default. The + * tunneled mode can be toggled on only before the component starts + * processing. Once the component is put into the tunneled mode, it shall + * stay in the tunneled mode until and only until reset() is called. + * + * @param avSyncHwId A resource ID for hardware sync. The generator of sync + * IDs must ensure that this number is unique among all services at any + * given time. For example, if both the audio HAL and the tuner HAL + * support this feature, sync IDs from the audio HAL must not clash + * with sync IDs from the tuner HAL. + * @return Codec-allocated sideband stream NativeHandle. This can + * be passed to IGraphicBufferProducer::setSidebandStream() to + * establish a direct channel to the consumer. + * @throws ServiceSpecificException with one of the following values: + * - `Status::OMITTED` - The component does not support video tunneling. + * - `Status::BAD_STATE` - The component is already running. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + NativeHandle configureVideoTunnel(in int avSyncHwId); + + /** + * Creates a local `C2BlockPool` backed by the given allocator and returns + * its id. + * + * The returned @p blockPoolId is the only way the client can refer to a + * `C2BlockPool` object in the component. The id can be passed to + * setOutputSurface() or used in some C2Param objects later. + * + * The created `C2BlockPool` object can be destroyed by calling + * destroyBlockPool(), reset() or release(). reset() and release() must + * destroy all `C2BlockPool` objects that have been created. + * + * @param allocatorId Id of a `C2Allocator`. + * @param out configurable Configuration interface for the created pool. This + * must not be null. + * @return Created block pool information. This could be used to config/query and + * also be used in setOutputSurface() if the allocator + * @throws ServiceSpecificException with one of the following values: + * - `Status::NO_MEMORY` - Not enough memory to create the pool. + * - `Status::BAD_VALUE` - @p allocatorId is not recognized. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + BlockPool createBlockPool(in int allocatorId); + + /** + * Destroys a local block pool previously created by createBlockPool(). + * + * @param blockPoolId Id of a `C2BlockPool` that was previously returned by + * createBlockPool(). + * @throws ServiceSpecificException with one of the following values: + * - `Status::NOT_FOUND` - The supplied blockPoolId is not valid. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + void destroyBlockPool(in long blockPoolId); + + /** + * Drains the component, and optionally downstream components. This is a + * signalling method; as such it does not wait for any work completion. + * + * The last `Work` item is marked as "drain-till-here", so the component is + * notified not to wait for further `Work` before it processes what is + * already queued. This method can also be used to set the end-of-stream + * flag after `Work` has been queued. Client can continue to queue further + * `Work` immediately after this method returns. + * + * This method must be supported in running (including tripped) states. + * + * `Work` that is completed must be returned via + * IComponentListener::onWorkDone(). + * + * @param withEos Whether to drain the component with marking end-of-stream. + * @throws ServiceSpecificException with one of the following values: + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + void drain(in boolean withEos); + + /** + * Discards and abandons any pending `Work` items for the component. + * + * This method must be supported in running (including tripped) states. + * + * `Work` that could be immediately abandoned/discarded must be returned in + * @p flushedWorkBundle. The order in which queued `Work` items are + * discarded can be arbitrary. + * + * `Work` that could not be abandoned or discarded immediately must be + * marked to be discarded at the earliest opportunity, and must be returned + * via IComponentListener::onWorkDone(). This must be completed within + * 500ms. + * + * @return `WorkBundle` object containing flushed `Work` items. + * @throws ServiceSpecificException with one of the following values: + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + WorkBundle flush(); + + /** + * Returns the @ref IComponentInterface instance associated to this + * component. + * + * An @ref IConfigurable instance for the component can be obtained by calling + * IComponentInterface::getConfigurable() on the returned @p intf. + * + * @return `IComponentInterface` instance. This must not be null. + */ + IComponentInterface getInterface(); + + /** + * Queues up work for the component. + * + * This method must be supported in running (including tripped) states. + * + * It is acceptable for this method to return `OK` and return an error value + * using the IComponentListener::onWorkDone() callback. + * + * @param workBundle `WorkBundle` object containing a list of `Work` objects + * to queue to the component. + * @throws ServiceSpecificException with one of the following values: + * - `Status::BAD_INDEX` - Some component id in some `Worklet` is not valid. + * - `Status::CANNOT_DO` - The components are not tunneled but some `Work` object + * contains tunneling information. + * - `Status::NO_MEMORY` - Not enough memory to queue @p workBundle. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + void queue(in WorkBundle workBundle); + + /** + * Releases the component. + * + * This method must be supported in stopped state. + * + * This method destroys the component. Upon return, if @p status is `OK` or + * `DUPLICATE`, all resources must have been released. + * + * @throws ServiceSpecificException with one of the following values: + * - `Status::BAD_STATE` - The component is running. + * - `Status::DUPLICATE` - The component is already released. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + void release(); + + /** + * Resets the component. + * + * This method must be supported in all (including tripped) states other + * than released. + * + * This method must be supported during any other blocking call. + * + * This method must return within 500ms. + * + * When this call returns, if @p status is `OK`, all `Work` items must + * have been abandoned, and all resources (including `C2BlockPool` objects + * previously created by createBlockPool()) must have been released. + * + * If the return value is `BAD_STATE` or `DUPLICATE`, no state change is + * expected as a response to this call. For all other return values, the + * component must be in the stopped state. + * + * This brings settings back to their default, "guaranteeing" no tripped + * state. + * + * @throws ServiceSpecificException with one of the following values: + * - `Status::BAD_STATE` - Component is in released state. + * - `Status::DUPLICATE` - When called during another reset call from another + * thread. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + void reset(); + + /** + * Starts using a surface for output with a synchronization object + * + * This method must not block. + * + * @param blockPoolId Id of the `C2BlockPool` to be associated with the + * output surface. + * @param surface Output surface. + * @param syncObject synchronization object for buffer allocation between + * Framework and Component. + * @throws ServiceSpecificException with one of the following values: + * - `Status::CANNOT_DO` - The component does not support an output surface. + * - `Status::REFUSED` - The output surface cannot be accessed. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + void setOutputSurface(in long blockPoolId, in Surface surface, + in SurfaceSyncObj syncObject); + + /** + * Starts the component. + * + * This method must be supported in stopped state as well as tripped state. + * + * If the return value is `OK`, the component must be in the running state. + * If the return value is `BAD_STATE` or `DUPLICATE`, no state change is + * expected as a response to this call. Otherwise, the component must be in + * the stopped state. + * + * If a component is in the tripped state and start() is called while the + * component configuration still results in a trip, start() must succeed and + * a new onTripped() callback must be used to communicate the configuration + * conflict that results in the new trip. + * + * @throws ServiceSpecificException with one of the following values: + * - `Status::BAD_STATE` - Component is not in stopped or tripped state. + * - `Status::DUPLICATE` - When called during another start call from another + * thread. + * - `Status::NO_MEMORY` - Not enough memory to start the component. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + void start(); + + /** + * Stops the component. + * + * This method must be supported in running (including tripped) state. + * + * This method must return within 500ms. + * + * Upon this call, all pending `Work` must be abandoned. + * + * If the return value is `BAD_STATE` or `DUPLICATE`, no state change is + * expected as a response to this call. For all other return values, the + * component must be in the stopped state. + * + * This does not alter any settings and tunings that may have resulted in a + * tripped state. + * + * @throws ServiceSpecificException with one of the following values: + * - `Status::BAD_STATE` - Component is not in running state. + * - `Status::DUPLICATE` - When called during another stop call from another + * thread. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + void stop(); +} diff --git a/media/c2/aidl/android/hardware/media/c2/IComponentInterface.aidl b/media/c2/aidl/android/hardware/media/c2/IComponentInterface.aidl new file mode 100644 index 0000000000..9db81e6139 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/IComponentInterface.aidl @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.IConfigurable; + +/** + * Component interface object. This object contains all of the configurations of + * a potential or actual component. It can be created and used independently of + * an actual Codec2 component to query supported parameters for various + * component settings, and configurations for a potential component. + * + * An actual component exposes this interface via IComponent::getInterface(). + */ +@VintfStability +interface IComponentInterface { + /** + * Returns the @ref IConfigurable instance associated to this component + * interface. + * + * @return `IConfigurable` instance. This must not be null. + */ + IConfigurable getConfigurable(); +} diff --git a/media/c2/aidl/android/hardware/media/c2/IComponentListener.aidl b/media/c2/aidl/android/hardware/media/c2/IComponentListener.aidl new file mode 100644 index 0000000000..75500b7271 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/IComponentListener.aidl @@ -0,0 +1,131 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.SettingResult; +import android.hardware.media.c2.Status; +import android.hardware.media.c2.WorkBundle; + +/** + * Callback interface for handling notifications from @ref IComponent. + */ +@VintfStability +oneway interface IComponentListener { + /** + * Identifying information for an input buffer previously queued to the + * component via IComponent::queue(). + */ + @VintfStability + parcelable InputBuffer { + /** + * This value comes from `Work::input.ordinal.frameIndex` in a `Work` + * object that was previously queued. + */ + long frameIndex; + /** + * This value is an index into `Work::input.buffers` (which is an array) + * in a `Work` object that was previously queued. + */ + int arrayIndex; + } + /** + * Information about rendering of a frame to a `Surface`. + */ + @VintfStability + parcelable RenderedFrame { + /** + * Id of the `BufferQueue` containing the rendered buffer. + * + * This value must have been obtained by an earlier call to + * IGraphicBufferProducer::getUniqueId(). + */ + long bufferQueueId; + /** + * Id of the slot of the rendered buffer. + * + * This value must have been obtained by an earlier call to + * IGraphicBufferProducer::dequeueBuffer() or + * IGraphicBufferProducer::attachBuffer(). + */ + int slotId; + /** + * Timestamp the rendering happened. + * + * The reference point for the timestamp is determined by the + * `BufferQueue` that performed the rendering. + */ + long timestampNs; + } + /** + * Notify the listener of an error. + * + * @param status Error type. @p status may be `OK`, which means that an + * error has occurred, but the error type does not fit into the type + * `Status`. In this case, additional information is provided by + * @p errorCode. + * @param errorCode Additional error information. The framework may not + * recognize the meaning of this value. + */ + void onError(in Status status, in int errorCode); + + /** + * Notify the listener that frames have been rendered. + * + * @param renderedFrames List of @ref RenderedFrame objects. + */ + void onFramesRendered(in RenderedFrame[] renderedFrames); + + /** + * Notify the listener that some input buffers are no longer needed by the + * component, and hence can be released or reused by the client. + * + * Input buffers that are contained in a `Work` object returned by an + * earlier onWorkDone() call are assumed released, so they must not appear + * in any onInputBuffersReleased() calls. That means + * onInputBuffersReleased() must only report input buffers that are released + * before the output in the same `Work` item is produced. However, it is + * possible for an input buffer to be returned by onWorkDone() after it has + * been reported by onInputBuffersReleased(). + * + * @note onWorkDone() and onInputBuffersReleased() both notify the client + * that input buffers are no longer needed. However, in order to minimize + * IPC calls, onInputBuffersReleased() should be called only when + * onWorkDone() cannot be called, e.g., the component needs more input + * before an output can be produced. + * + * @param inputBuffers List of `InputBuffer` objects, identifying input + * buffers that are no longer needed by the component. + */ + void onInputBuffersReleased(in InputBuffer[] inputBuffers); + + /** + * Notify the listener that the component is tripped. + * + * @param settingResults List of failures. + */ + void onTripped(in SettingResult[] settingResults); + + /** + * Notify the listener that some `Work` items have been completed. + * + * All the input buffers in the returned `Work` objects must not be used by + * the component after onWorkDone() is called. + * + * @param workBundle List of completed `Work` objects. + */ + void onWorkDone(in WorkBundle workBundle); +} diff --git a/media/c2/aidl/android/hardware/media/c2/IComponentStore.aidl b/media/c2/aidl/android/hardware/media/c2/IComponentStore.aidl new file mode 100644 index 0000000000..1435a7e4bc --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/IComponentStore.aidl @@ -0,0 +1,185 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.Buffer; +import android.hardware.media.c2.IComponent; +import android.hardware.media.c2.IComponentInterface; +import android.hardware.media.c2.IComponentListener; +import android.hardware.media.c2.IConfigurable; +import android.hardware.media.c2.StructDescriptor; + +/** + * Entry point for Codec2 HAL. + * + * All methods in `IComponentStore` must not block. If a method call cannot be + * completed in a timely manner, it must throw `Status::TIMED_OUT`. The only + * exceptions are getPoolClientManager() and getConfigurable(), which must + * always return immediately. + * + * @note This is an extension of version 1.1 of `IComponentStore`. The purpose + * of the extension is to add support for blocking output buffer allocator. + */ +@VintfStability +interface IComponentStore { + /** + * Component traits. + */ + @VintfStability + parcelable ComponentTraits { + @VintfStability + @Backing(type="int") + enum Kind { + OTHER = 0, + DECODER, + ENCODER, + } + @VintfStability + @Backing(type="int") + enum Domain { + OTHER = 0, + VIDEO, + AUDIO, + IMAGE, + } + /** + * Name of the component. This must be unique for each component. + * + * This name is use to identify the component to create in + * createComponent() and createComponentInterface(). + */ + String name; + /** + * Component domain. + */ + Domain domain; + /** + * Component kind. + */ + Kind kind; + /** + * Rank used by `MediaCodecList` to determine component ordering. Lower + * value means higher priority. + */ + int rank; + /** + * MIME type. + */ + String mediaType; + /** + * Aliases for component name for backward compatibility. + * + * Multiple components can have the same alias (but not the same + * component name) as long as their media types differ. + */ + String[] aliases; + } + + /** + * Copies the contents of @p src into @p dst without changing the format of + * @p dst. + * + * @param src Source buffer. + * @param dst Destination buffer. + * @throws ServiceSpecificException with one of the following values: + * - `Status::CANNOT_DO` - @p src and @p dst are not compatible. + * - `Status::REFUSED` - No permission to copy. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + void copyBuffer(in Buffer src, in Buffer dst); + + /** + * Creates a component by name. + * + * @param name Name of the component to create. This must match one of the + * names returned by listComponents(). + * @param listener Callback receiver. + * @param pool `IClientManager` object of the BufferPool in the client + * process. This may be null if the client does not own a BufferPool. + * @return The created component. + * @throws ServiceSpecificException with one of the following values: + * - `Status::NOT_FOUND` - There is no component with the given name. + * - `Status::NO_MEMORY` - Not enough memory to create the component. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + * + * @sa IComponentListener. + */ + IComponent createComponent(in String name, in IComponentListener listener, + in android.hardware.media.bufferpool2.IClientManager pool); + + /** + * Creates a component interface by name. + * + * @param name Name of the component interface to create. This should match + * one of the names returned by listComponents(). + * @return The created component interface. + * @throws ServiceSpecificException with one of the following values: + * - `Status::NOT_FOUND` - There is no component interface with the given name. + * - `Status::NO_MEMORY` - Not enough memory to create the component interface. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + IComponentInterface createInterface(in String name); + + /** + * Returns the @ref IConfigurable instance associated to this component + * store. + * + * @return `IConfigurable` instance. This must not be null. + */ + IConfigurable getConfigurable(); + + /** + * Returns the `IClientManager` object for the component's BufferPool. + * + * @return If the component store supports receiving buffers via + * BufferPool API, @p pool must be a valid `IClientManager` instance. + * Otherwise, @p pool must be null. + */ + android.hardware.media.bufferpool2.IClientManager getPoolClientManager(); + + /** + * Returns a list of `StructDescriptor` objects for a set of requested + * C2Param structure indices that this store is aware of. + * + * This operation must be performed at best effort, e.g. the component + * store must simply ignore all struct indices that it is not aware of. + * + * @param indices Indices of C2Param structures to describe. + * @return List of `StructDescriptor` objects. + * @throws ServiceSpecificException with one of the following values: + * - `Status::NOT_FOUND` - Some indices were not known. + * - `Status::NO_MEMORY` - Not enough memory to complete this method. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + StructDescriptor[] getStructDescriptors(in int[] indices); + + /** + * Returns the list of components supported by this component store. + * + * @return traits List of component traits for all components supported by + * this store (in no particular order). + * @throws ServiceSpecificException with one of the following values: + * - `Status::NO_MEMORY` - Not enough memory to complete this method. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + ComponentTraits[] listComponents(); +} diff --git a/media/c2/aidl/android/hardware/media/c2/IConfigurable.aidl b/media/c2/aidl/android/hardware/media/c2/IConfigurable.aidl new file mode 100644 index 0000000000..7fdb8259b8 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/IConfigurable.aidl @@ -0,0 +1,213 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.FieldSupportedValuesQuery; +import android.hardware.media.c2.FieldSupportedValuesQueryResult; +import android.hardware.media.c2.ParamDescriptor; +import android.hardware.media.c2.Params; +import android.hardware.media.c2.SettingResult; + +/** + * Generic configuration interface presented by all configurable Codec2 objects. + * + * This interface must be supported in all states of the owning object, and must + * not change the state of the owning object. + */ +@VintfStability +interface IConfigurable { + /** + * Return parcelable for config() interface. + * + * This includes the successful config settings along with the failure reasons of + * the specified setting. + */ + @VintfStability + parcelable ConfigResult { + Params params; + SettingResult[] failures; + } + + /** + * Sets a set of parameters for the object. + * + * Tuning is performed at best effort: the object must update all supported + * configurations at best effort and skip unsupported parameters. Any errors + * are communicated in the return value along with the failures. + * + * A non-strict parameter update with an unsupported value shall cause an + * update to the closest supported value. A strict parameter update with an + * unsupported value shall be skipped and a failure shall be returned. + * + * If @p mayBlock is false, this method must not block. An update that + * requires blocking shall be skipped and a failure shall be returned. + * + * If @p mayBlock is true, an update may block, but the whole method call + * has to complete in a timely manner, or `Status::TIMED_OUT` is thrown. + * + * The final values for all parameters set are propagated back to the caller + * in @p params. + * + * \par For IComponent + * + * When the object type is @ref IComponent, this method must be supported in + * any state except released. + * + * The blocking behavior of this method differs among states: + * - In the stopped state, this must be non-blocking. @p mayBlock is + * ignored. (The method operates as if @p mayBlock was false.) + * - In any of the running states, this method may block momentarily if + * @p mayBlock is true. However, if the call cannot be completed in a + * timely manner, `Status::TIMED_OUT` is thrown. + * + * @note Parameter tuning @e does depend on the order of the tuning + * parameters, e.g., some parameter update may enable some subsequent + * parameter update. + * + * @param inParams Requested parameter updates. + * @param mayBlock Whether this call may block or not. + * @return result of config. Params in the result should be in same order + * with @p inParams. + * @throws ServiceSpecificException with one of the following values: + * - `Status::NO_MEMORY` - Some supported parameters could not be updated + * successfully because they contained unsupported values. + * These are returned in @p failures. + * - `Status::BLOCKING` - Setting some parameters requires blocking, but + * @p mayBlock is false. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + ConfigResult config(in Params inParams, in boolean mayBlock); + + /** + * Returns the id of the object. This must be unique among all objects of + * the same type hosted by the same store. + * + * @return Id of the object. + */ + int getId(); + + /** + * Returns the name of the object. + * + * This must match the name that was supplied during the creation of the + * object. + * + * @return Name of the object. + */ + String getName(); + + /** + * Queries a set of parameters from the object. + * + * Querying is performed at best effort: the object must query all supported + * parameters and skip unsupported ones (which may include parameters that + * could not be allocated). + * + * If @p mayBlock is true, a query may block, but the whole method call + * has to complete in a timely manner, or `Status::TIMED_OUT` is thrown. + * + * If @p mayBlock is false, this method must not block(All parameter queries + * that require blocking must be skipped). Otherwise, this + * method is allowed to block for a certain period of time before completing + * the operation. If the operation is not completed in a timely manner, + * `Status::TIMED_OUT` is thrown. + * + * @note Since unsupported parameters will be skipped, the returned results + * does not have every settings from @p indices, but the result will preserve + * the original order from @p indices though unsupported settings are skipped. + * + * \par For IComponent + * + * When the object type is @ref IComponent, this method must be supported in + * any state except released. This call must not change the state nor the + * internal configuration of the component. + * + * The blocking behavior of this method differs among states: + * - In the stopped state, this must be non-blocking. @p mayBlock is + * ignored. (The method operates as if @p mayBlock was false.) + * - In any of the running states, this method may block momentarily if + * @p mayBlock is true. However, if the call cannot be completed in a + * timely manner, `Status::status` is thrown. + * + * @param indices List of C2Param structure indices to query. + * @param mayBlock Whether this call may block or not. + * @return Flattened representation of std::vector object. + * Unsupported settings are skipped in the results. The order in @p indices + * still be preserved except skipped settings. + * @throws ServiceSpecificException with one of the following values: + * - `Status::NO_MEMORY` - Could not allocate memory for a supported parameter. + * - `Status::BLOCKING` - Querying some parameters requires blocking, but + * @p mayBlock is false. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + Params query(in int[] indices, in boolean mayBlock); + + /** + * Returns a list of supported parameters within a selected range of C2Param + * structure indices. + * + * @param start The first index of the selected range. + * @param count The length of the selected range. + * @return List of supported parameters in the selected range. This + * list may have fewer than @p count elements if some indices in the + * range are not supported. + * @throws ServiceSpecificException with one of the following values: + * - `Status::NO_MEMORY` - Not enough memory to complete this method. + * + */ + ParamDescriptor[] querySupportedParams(in int start, in int count); + + /** + * Retrieves the supported values for the queried fields. + * + * The object must process all fields queried even if some queries fail. + * + * If @p mayBlock is false, this method must not block. Otherwise, this + * method is allowed to block for a certain period of time before completing + * the operation. If the operation cannot be completed in a timely manner, + * `Status::TIMED_OUT` is thrown. + * + * \par For IComponent + * + * When the object type is @ref IComponent, this method must be supported in + * any state except released. + * + * The blocking behavior of this method differs among states: + * - In the stopped state, this must be non-blocking. @p mayBlock is + * ignored. (The method operates as if @p mayBlock was false.) + * - In any of the running states, this method may block momentarily if + * @p mayBlock is true. However, if the call cannot be completed in a + * timely manner, `Status::TIMED_OUT` is thrown. + * + * @param inFields List of field queries. + * @param mayBlock Whether this call may block or not. + * @return List of supported values and results for the + * supplied queries. + * @throws ServiceSpecificException with one of the following values: + * - `Status::BLOCKING` - Querying some parameters requires blocking, but + * @p mayBlock is false. + * - `Status::NO_MEMORY` - Not enough memory to complete this method. + * - `Status::BLOCKING` - Querying some fields requires blocking, but @p mayblock + * is false. + * - `Status::TIMED_OUT` - The operation cannot be finished in a timely manner. + * - `Status::CORRUPTED` - Some unknown error occurred. + */ + FieldSupportedValuesQueryResult[] querySupportedValues( + in FieldSupportedValuesQuery[] inFields, in boolean mayBlock); +} diff --git a/media/c2/aidl/android/hardware/media/c2/InfoBuffer.aidl b/media/c2/aidl/android/hardware/media/c2/InfoBuffer.aidl new file mode 100644 index 0000000000..207c4d0c1a --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/InfoBuffer.aidl @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.Buffer; + +/** + * An extension of @ref Buffer that also contains a C2Param structure index. + * + * This is a part of @ref FrameData. + */ +@VintfStability +parcelable InfoBuffer { + /** + * A C2Param structure index. + */ + int index; + /** + * Associated @ref Buffer object. + */ + Buffer buffer; +} diff --git a/media/c2/aidl/android/hardware/media/c2/ParamDescriptor.aidl b/media/c2/aidl/android/hardware/media/c2/ParamDescriptor.aidl new file mode 100644 index 0000000000..84c6acc7e4 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/ParamDescriptor.aidl @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2022 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.media.c2; + +/** + * Usage description of a C2Param structure. + * + * @ref ParamDescriptor is returned by IConfigurable::querySupportedParams(). + */ +@VintfStability +parcelable ParamDescriptor { + /** The list of bit flags for attrib */ + /** + * The parameter is required to be specified. + */ + const int ATTRIBUTE_REQUIRED = 1 << 0; + /** + * The parameter retains its value. + */ + const int ATTRIBUTE_PERSISTENT = 1 << 1; + /** + * The parameter is strict. + */ + const int ATTRIBUTE_STRICT = 1 << 2; + /** + * The parameter is publicly read-only. + */ + const int ATTRIBUTE_READ_ONLY = 1 << 3; + /** + * The parameter must not be visible to clients. + */ + const int ATTRIBUTE_HIDDEN = 1 << 4; + /** + * The parameter must not be used by framework (other than testing). + */ + const int ATTRIBUTE_INTERNAL = 1 << 5; + /** + * The parameter is publicly constant (hence read-only). + */ + const int ATTRIBUTE_CONST = 1 << 6; + + /** + * Index of the C2Param structure being described. + */ + int index; + /** + * bit flag for attribute defined in the above. + */ + int attrib; + /** + * Name of the structure. This must be unique for each structure. + */ + String name; + /** + * Indices of other C2Param structures that this C2Param structure depends + * on. + */ + int[] dependencies; +} diff --git a/media/c2/aidl/android/hardware/media/c2/ParamField.aidl b/media/c2/aidl/android/hardware/media/c2/ParamField.aidl new file mode 100644 index 0000000000..64a46bbef5 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/ParamField.aidl @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.FieldId; + +/** + * Reference to a field in a C2Param structure. + */ +@VintfStability +parcelable ParamField { + /** + * Index of the C2Param structure. + */ + int index; + /** + * Identifier of the field inside the C2Param structure. + */ + FieldId fieldId; +} diff --git a/media/c2/aidl/android/hardware/media/c2/ParamFieldValues.aidl b/media/c2/aidl/android/hardware/media/c2/ParamFieldValues.aidl new file mode 100644 index 0000000000..7b74c0ec34 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/ParamFieldValues.aidl @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.FieldSupportedValues; +import android.hardware.media.c2.ParamField; + +/** + * Supported values for a field. + * + * This is a pair of the field specifier together with an optional supported + * values object. This structure is used when reporting parameter configuration + * failures and conflicts. + */ +@VintfStability +parcelable ParamFieldValues { + /** + * Reference to a field or a C2Param structure. + */ + ParamField paramOrField; + /** + * Optional supported values for the field if #paramOrField specifies an + * actual field that is numeric (non struct, blob or string). Supported + * values for arrays (including string and blobs) describe the supported + * values for each element (character for string, and bytes for blobs). It + * is optional for read-only strings and blobs. + */ + FieldSupportedValues[] values; +} diff --git a/media/c2/aidl/android/hardware/media/c2/Params.aidl b/media/c2/aidl/android/hardware/media/c2/Params.aidl new file mode 100644 index 0000000000..53b512cf91 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/Params.aidl @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2022 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.media.c2; + +/** + * Flattened representation of std::vector object. + * + * The `Params` type is an array of bytes made up by concatenating a list of + * C2Param objects. The start index (offset into @ref Params) of each C2Param + * object in the list is divisible by 8. Up to 7 padding bytes may be added + * after each C2Param object to achieve this 64-bit alignment. + * + * Each C2Param object has the following layout: + * - 4 bytes: C2Param structure index (of type @ref ParamIndex) identifying the + * type of the C2Param object. + * - 4 bytes: size of the C2Param object (unsigned 4-byte integer). + * - (size - 8) bytes: data of the C2Param object. + */ +@VintfStability +parcelable Params { + byte[] params; +} diff --git a/media/c2/aidl/android/hardware/media/c2/SettingResult.aidl b/media/c2/aidl/android/hardware/media/c2/SettingResult.aidl new file mode 100644 index 0000000000..c2b9574457 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/SettingResult.aidl @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.ParamFieldValues; + +/** + * Information describing the reason the parameter settings may fail, or may be + * overridden. + */ +@VintfStability +parcelable SettingResult { + /** + * Failure code + */ + @VintfStability + @Backing(type="int") + enum Failure { + /** + * Parameter is not supported. + */ + BAD_TYPE, + /** + * Parameter is not supported on the specific port. + */ + BAD_PORT, + /** + * Parameter is not supported on the specific stream. + */ + BAD_INDEX, + /** + * Parameter is read-only and cannot be set. + */ + READ_ONLY, + /** + * Parameter mismatches input data. + */ + MISMATCH, + /** + * Strict parameter does not accept value for the field at all. + */ + BAD_VALUE, + /** + * Strict parameter field value is in conflict with an/other + * setting(s). + */ + CONFLICT, + /** + * Parameter field is out of range due to other settings. (This failure + * mode can only be used for strict calculated parameters.) + */ + UNSUPPORTED, + /** + * Field does not access the requested parameter value at all. It has + * been corrected to the closest supported value. This failure mode is + * provided to give guidance as to what are the currently supported + * values for this field (which may be a subset of the at-all-potential + * values). + */ + INFO_BAD_VALUE, + /** + * Requested parameter value is in conflict with an/other setting(s) + * and has been corrected to the closest supported value. This failure + * mode is given to provide guidance as to what are the currently + * supported values as well as to optionally provide suggestion to the + * client as to how to enable the requested parameter value. + */ + INFO_CONFLICT, + } + Failure failure; + /** + * Failing (or corrected) field or parameter and optionally, currently + * supported values for the field. Values must only be set for field + * failures other than `BAD_VALUE`, and only if they are different from the + * globally supported values (e.g. due to restrictions by another parameter + * or input data). + */ + ParamFieldValues field; + /** + * Conflicting parameters or fields with (optional) suggested values for any + * conflicting fields to avoid the conflict. Values must only be set for + * `CONFLICT`, `UNSUPPORTED` or `INFO_CONFLICT` failure code. + */ + ParamFieldValues[] conflicts; +} diff --git a/media/c2/aidl/android/hardware/media/c2/Status.aidl b/media/c2/aidl/android/hardware/media/c2/Status.aidl new file mode 100644 index 0000000000..58a24047e7 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/Status.aidl @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2022 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.media.c2; + +/** + * Common return values for Codec2 operations. + */ +@VintfStability +parcelable Status { + /** + * Operation completed successfully. + */ + const int OK = 0; + /** + * Argument has invalid value (user error). + */ + const int BAD_VALUE = -22; + /** + * Argument uses invalid index (user error). + */ + const int BAD_INDEX = -75; + /** + * Argument/Index is valid but not possible. + */ + const int CANNOT_DO = -2147483646; + /** + * Object already exists. + */ + const int DUPLICATE = -17; + /** + * Object not found. + */ + const int NOT_FOUND = -2; + /** + * Operation is not permitted in the current state. + */ + const int BAD_STATE = -38; + /** + * Operation would block but blocking is not permitted. + */ + const int BLOCKING = -9930; + /** + * Not enough memory to complete operation. + */ + const int NO_MEMORY = -12; + /** + * Missing permission to complete operation. + */ + const int REFUSED = -1; + /** + * Operation did not complete within timeout. + */ + const int TIMED_OUT = -110; + /** + * Operation is not implemented/supported (optional only). + */ + const int OMITTED = -74; + /** + * Some unexpected error prevented the operation. + */ + const int CORRUPTED = -2147483648; + /** + * Status has not been initialized. + */ + const int NO_INIT = -19; + + int status; +} diff --git a/media/c2/aidl/android/hardware/media/c2/StructDescriptor.aidl b/media/c2/aidl/android/hardware/media/c2/StructDescriptor.aidl new file mode 100644 index 0000000000..00359041f0 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/StructDescriptor.aidl @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.FieldDescriptor; + +/** + * Description of a C2Param structure. It consists of an index and a list of + * `FieldDescriptor`s. + */ +@VintfStability +parcelable StructDescriptor { + /** + * Index of the structure. + * + * Actually C2Param::CoreIndex + * Core index is the underlying parameter type for a parameter. It is used to describe the + * layout of the parameter structure regardless of the component or parameter kind/scope. + * + * It is used to identify and distinguish global parameters, and also parameters on a given + * port or stream. They must be unique for the set of global parameters, as well as for the + * set of parameters on each port or each stream, but the same core index can be used for + * parameters on different streams or ports, as well as for global parameters and port/stream + * parameters. + */ + int type; + /** + * List of fields in the structure. + * + * Fields are ordered by their offsets. A field that is a structure is + * ordered before its members. + */ + FieldDescriptor[] fields; +} diff --git a/media/c2/aidl/android/hardware/media/c2/SurfaceSyncObj.aidl b/media/c2/aidl/android/hardware/media/c2/SurfaceSyncObj.aidl new file mode 100644 index 0000000000..d20e10273f --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/SurfaceSyncObj.aidl @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.common.NativeHandle; +/** + * Surface(BufferQueue/IGBP) synchronization object regarding # of dequeued + * output buffers. This keeps # of dequeued buffers from Surface less than + * configured max # of dequeued buffers all the time. + */ +@VintfStability +parcelable SurfaceSyncObj { + /** + * ASharedMemory for synchronization data. Layout is below + * + * |lock(futex) 4bytes| + * |conditional_variable(futex) 4bytes| + * |# of max dequeable buffer 4bytes| + * |# of dequeued buffer 4bytes| + * |Status of the surface 4bytes| + * INIT = 0, Configuring surface is not finished. + * ACTIVE = 1, Surface is ready to allocate(dequeue). + * SWITCHING = 2, Switching to the new surface. It is blocked + * to allocate(dequeue) a buffer until switching + * completes. + */ + NativeHandle syncMemory; + /** + * BufferQueue id. + */ + long bqId; + /** + * Generation id. + */ + int generationId; + /** + * Consumer usage flags. See +ndk + * libnativewindow#AHardwareBuffer_UsageFlags for possible values. + */ + long consumerUsage; +} diff --git a/media/c2/aidl/android/hardware/media/c2/ValueRange.aidl b/media/c2/aidl/android/hardware/media/c2/ValueRange.aidl new file mode 100644 index 0000000000..9abcb7da2b --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/ValueRange.aidl @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2022 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.media.c2; + +/** + * Description of a set of values. + * + * If the `step` member is 0, and `num` and `denom` are both 1, the `Range` + * structure represents a closed interval bounded by `min` and `max`. + * + * Otherwise, the #ValueRange structure represents a finite sequence of numbers + * produced from the following recurrence relation: + * + * @code + * v[0] = min + * v[i] = v[i - 1] * num / denom + step ; i >= 1 + * @endcode + * + * Both the ratio `num / denom` and the value `step` must be positive. The + * last number in the sequence described by this #Range structure is the + * largest number in the sequence that is smaller than or equal to `max`. + * + * @note + * The division in the formula may truncate the result if the data type of + * these values is an integral type. + */ +@VintfStability +parcelable ValueRange { + /** + * Lower end of the range (inclusive). + */ + long min; + /** + * Upper end of the range (inclusive). + */ + long max; + /** + * The non-homogeneous term in the recurrence relation. + */ + long step; + /** + * The numerator of the scale coefficient in the recurrence relation. + */ + long num; + /** + * The denominator of the scale coefficient in the recurrence relation. + */ + long denom; +} diff --git a/media/c2/aidl/android/hardware/media/c2/Work.aidl b/media/c2/aidl/android/hardware/media/c2/Work.aidl new file mode 100644 index 0000000000..4b8d696871 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/Work.aidl @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.FrameData; +import android.hardware.media.c2.Status; +import android.hardware.media.c2.Worklet; + +/** + * A collection of input data to and output data from the component. + * + * A `Work` object holds information about a single work item. It is created by + * the client and passed to the component via IComponent::queue(). The component + * has two ways of returning a `Work` object to the client: + * 1. If the queued `Work` object has been successfully processed, + * IComponentListener::onWorkDone() shall be called to notify the listener, + * and the output shall be included in the returned `Work` object. + * 2. If the client calls IComponent::flush(), a `Work` object that has not + * been processed shall be returned. + * + * `Work` is a part of @ref WorkBundle. + */ +@VintfStability +parcelable Work { + /** + * Additional work chain info not part of this work. + */ + byte[] chainInfo; + /** + * @ref FrameData for the input. + */ + FrameData input; + /** + * The chain of `Worklet`s. + * + * The length of #worklets is 1 when tunneling is not enabled. + * + * If #worklets has more than a single element, the tunnels between + * successive components of the work chain must have been successfully + * pre-registered at the time that the `Work` is submitted. Allocating the + * output buffers in the `Worklet`s is the responsibility of each component + * in the chain. + * + * Upon `Work` submission, #worklets must be an appropriately sized vector + * containing `Worklet`s with @ref Worklet.hasOutput set to `false`. After a + * successful processing, all but the final `Worklet` in the returned + * #worklets must have @ref Worklet.hasOutput set to `false`. + */ + Worklet[] worklets; + /** + * The number of `Worklet`s successfully processed in this chain. + * + * This must be initialized to 0 by the client when the `Work` is submitted, + * and it must contain the number of `Worklet`s that were successfully + * processed when the `Work` is returned to the client. + * + * #workletsProcessed cannot exceed the length of #worklets. If + * #workletsProcessed is smaller than the length of #worklets, #result + * cannot be `OK`. + */ + int workletsProcessed; + /** + * The final outcome of the `Work` (corresponding to #workletsProcessed). + * + * The value of @ref Status.OK implies that all `Worklet`s have been + * successfully processed. + */ + Status result; +} diff --git a/media/c2/aidl/android/hardware/media/c2/WorkBundle.aidl b/media/c2/aidl/android/hardware/media/c2/WorkBundle.aidl new file mode 100644 index 0000000000..2125fdab6c --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/WorkBundle.aidl @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.BaseBlock; +import android.hardware.media.c2.Work; + +/** + * List of `Work` objects. + * + * `WorkBundle` is used in IComponent::queue(), IComponent::flush() and + * IComponentListener::onWorkDone(). A `WorkBundle` object consists of a list of + * `Work` objects and a list of `BaseBlock` objects. Bundling multiple `Work` + * objects together provides two benefits: + * 1. Batching of `Work` objects can reduce the number of IPC calls. + * 2. If multiple `Work` objects contain `Block`s that refer to the same + * `BaseBlock`, the number of `BaseBlock`s that is sent between processes + * is also reduced. + * + * @note `WorkBundle` is the AIDL counterpart of the vector of `C2Work` in the + * Codec 2.0 standard. The presence of #baseBlocks helps with minimizing the + * data transferred over an IPC. + */ +@VintfStability +parcelable WorkBundle { + /** + * A list of Work items. + */ + Work[] works; + /** + * A list of blocks indexed by elements of #works. + */ + BaseBlock[] baseBlocks; +} diff --git a/media/c2/aidl/android/hardware/media/c2/WorkOrdinal.aidl b/media/c2/aidl/android/hardware/media/c2/WorkOrdinal.aidl new file mode 100644 index 0000000000..5708a90bc8 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/WorkOrdinal.aidl @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2022 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.media.c2; + +/** + * Ordering information of @ref FrameData objects. Each member is used for + * comparing urgency: a smaller difference from a reference value indicates that + * the associated Work object is more urgent. The reference value for each + * member is initialized the first time it is communicated between the client + * and the codec, and it may be updated to later values that are communicated. + * + * Each member of `WorkOrdinal` is stored as an unsigned integer, but the actual + * order it represents is derived by subtracting the reference value, then + * interpreting the result as a signed number with the same storage size (using + * two's complement). + * + * @note `WorkOrdinal` is the HIDL counterpart of `C2WorkOrdinalStruct` in the + * Codec 2.0 standard. + */ +@VintfStability +parcelable WorkOrdinal { + /** + * Timestamp in microseconds. + */ + long timestampUs; + /** + * Frame index. + */ + long frameIndex; + /** + * Component specific frame ordinal. + */ + long customOrdinal; +} diff --git a/media/c2/aidl/android/hardware/media/c2/Worklet.aidl b/media/c2/aidl/android/hardware/media/c2/Worklet.aidl new file mode 100644 index 0000000000..6b3ceac5a0 --- /dev/null +++ b/media/c2/aidl/android/hardware/media/c2/Worklet.aidl @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2022 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.media.c2; + +import android.hardware.media.c2.FrameData; +import android.hardware.media.c2.SettingResult; + +/** + * In/out structure containing some instructions for and results from output + * processing. + * + * This is a part of @ref Work. One `Worklet` corresponds to one output + * @ref FrameData. The client must construct an original `Worklet` object inside + * a @ref Work object for each expected output before calling + * IComponent::queue(). + */ +@VintfStability +parcelable Worklet { + /** + * Component id. (Input) + * + * This is used only when tunneling is enabled. + * + * When used, this must match the return value from IConfigurable::getId(). + */ + int componentId; + /** + * List of C2Param objects describing tunings to be applied before + * processing this `Worklet`. (Input) + */ + byte[] tunings; + /** + * List of failures. (Output) + */ + SettingResult[] failures; + /** + * Output frame data. (Output) + */ + FrameData output; +}