Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 10:44:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add Codec2 AIDL interface

Browse Source 
Bug: 251850069
Test: m
Change-Id: I1fc28084519281df68bca7ae5e2b814b03214577
Merged-In: I1fc28084519281df68bca7ae5e2b814b03214577
This commit is contained in:
Sungtak Lee
2022-10-19 17:01:18 +00:00
parent 1468ddfbf3
commit 8602fe3a0b
58 changed files with 3450 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
compatibility_matrices/compatibility_matrix.current.xml
View File

@@ -453,6 +453,15 @@
<regex-instance>vendor[0-9]*_software</regex-instance>
</interface>
</hal>
<hal format="aidl" optional="true">
<name>android.hardware.media.c2</name>
<version>1</version>
<interface>
<name>IComponentStore</name>
<regex-instance>default[0-9]*</regex-instance>
<regex-instance>vendor[0-9]*_software</regex-instance>
</interface>
</hal>
<hal format="aidl" optional="true">
<name>android.hardware.memtrack</name>
<version>1</version>

29
media/c2/aidl/Android.bp Normal file
View File

@@ -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",
],
},
},
}

39
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/BaseBlock.aidl Normal file
View File

@@ -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 <name>-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;
}

40
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Block.aidl Normal file
View File

@@ -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 <name>-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;
}

39
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Buffer.aidl Normal file
View File

@@ -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 <name>-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;
}

62
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldDescriptor.aidl Normal file
View File

@@ -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 <name>-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;
}
}

39
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldId.aidl Normal file
View File

@@ -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 <name>-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;
}

41
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValues.aidl Normal file
View File

@@ -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 <name>-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;
}

44
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValuesQuery.aidl Normal file
View File

@@ -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 <name>-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,
}
}

39
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FieldSupportedValuesQueryResult.aidl Normal file
View File

@@ -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 <name>-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;
}

47
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/FrameData.aidl Normal file
View File

@@ -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 <name>-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;
}

53
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponent.aidl Normal file
View File

@@ -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 <name>-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;
}
}

38
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentInterface.aidl Normal file
View File

@@ -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 <name>-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();
}

53
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentListener.aidl Normal file
View File

@@ -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 <name>-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;
}
}

66
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IComponentStore.aidl Normal file
View File

@@ -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 <name>-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,
}
}
}

48
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/IConfigurable.aidl Normal file
View File

@@ -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 <name>-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;
}
}

39
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/InfoBuffer.aidl Normal file
View File

@@ -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 <name>-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;
}

48
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamDescriptor.aidl Normal file
View File

@@ -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 <name>-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;
}

39
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamField.aidl Normal file
View File

@@ -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 <name>-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;
}

39
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ParamFieldValues.aidl Normal file
View File

@@ -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 <name>-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;
}

38
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Params.aidl Normal file
View File

@@ -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 <name>-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;
}

53
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/SettingResult.aidl Normal file
View File

@@ -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 <name>-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,
}
}

52
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Status.aidl Normal file
View File

@@ -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 <name>-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;
}

39
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/StructDescriptor.aidl Normal file
View File

@@ -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 <name>-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;
}

41
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/SurfaceSyncObj.aidl Normal file
View File

@@ -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 <name>-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;
}

42
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/ValueRange.aidl Normal file
View File

@@ -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 <name>-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;
}

42
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Work.aidl Normal file
View File

@@ -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 <name>-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;
}

39
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/WorkBundle.aidl Normal file
View File

@@ -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 <name>-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;
}

40
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/WorkOrdinal.aidl Normal file
View File

@@ -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 <name>-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;
}

41
media/c2/aidl/aidl_api/android.hardware.media.c2/current/android/hardware/media/c2/Worklet.aidl Normal file
View File

@@ -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 <name>-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;
}

38
media/c2/aidl/android/hardware/media/c2/BaseBlock.aidl Normal file
View File

@@ -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;
}

44
media/c2/aidl/android/hardware/media/c2/Block.aidl Normal file
View File

@@ -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;
}

37
media/c2/aidl/android/hardware/media/c2/Buffer.aidl Normal file
View File

@@ -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;
}

103
media/c2/aidl/android/hardware/media/c2/FieldDescriptor.aidl Normal file
View File

@@ -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;
}

35
media/c2/aidl/android/hardware/media/c2/FieldId.aidl Normal file
View File

@@ -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;
}

54
media/c2/aidl/android/hardware/media/c2/FieldSupportedValues.aidl Normal file
View File

@@ -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;
}

47
media/c2/aidl/android/hardware/media/c2/FieldSupportedValuesQuery.aidl Normal file
View File

@@ -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;
}

44
media/c2/aidl/android/hardware/media/c2/FieldSupportedValuesQueryResult.aidl Normal file
View File

@@ -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;
}

97
media/c2/aidl/android/hardware/media/c2/FrameData.aidl Normal file
View File

@@ -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;
}

304
media/c2/aidl/android/hardware/media/c2/IComponent.aidl Normal file
View File

@@ -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();
}

38
media/c2/aidl/android/hardware/media/c2/IComponentInterface.aidl Normal file
View File

@@ -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();
}

131
media/c2/aidl/android/hardware/media/c2/IComponentListener.aidl Normal file
View File

@@ -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);
}

185
media/c2/aidl/android/hardware/media/c2/IComponentStore.aidl Normal file
View File

@@ -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();
}

213
media/c2/aidl/android/hardware/media/c2/IConfigurable.aidl Normal file
View File

@@ -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<C2Param> 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);
}

36
media/c2/aidl/android/hardware/media/c2/InfoBuffer.aidl Normal file
View File

@@ -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;
}

73
media/c2/aidl/android/hardware/media/c2/ParamDescriptor.aidl Normal file
View File

@@ -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;
}

34
media/c2/aidl/android/hardware/media/c2/ParamField.aidl Normal file
View File

@@ -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;
}

43
media/c2/aidl/android/hardware/media/c2/ParamFieldValues.aidl Normal file
View File

@@ -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;
}

36
media/c2/aidl/android/hardware/media/c2/Params.aidl Normal file
View File

@@ -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<C2Param> 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;
}

99
media/c2/aidl/android/hardware/media/c2/SettingResult.aidl Normal file
View File

@@ -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;
}

82
media/c2/aidl/android/hardware/media/c2/Status.aidl Normal file
View File

@@ -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;
}

48
media/c2/aidl/android/hardware/media/c2/StructDescriptor.aidl Normal file
View File

@@ -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;
}

55
media/c2/aidl/android/hardware/media/c2/SurfaceSyncObj.aidl Normal file
View File

@@ -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;
}

63
media/c2/aidl/android/hardware/media/c2/ValueRange.aidl Normal file
View File

@@ -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;
}

83
media/c2/aidl/android/hardware/media/c2/Work.aidl Normal file
View File

@@ -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;
}

48
media/c2/aidl/android/hardware/media/c2/WorkBundle.aidl Normal file
View File

@@ -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;
}

48
media/c2/aidl/android/hardware/media/c2/WorkOrdinal.aidl Normal file
View File

@@ -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;
}

54
media/c2/aidl/android/hardware/media/c2/Worklet.aidl Normal file
View File

@@ -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;
}