On Android 12 (API level 31) and higher, the system can automatically convert
videos recorded in formats such as HEVC (H.265) to AVC (H.264) when the videos
are opened by an app that does not support HEVC. This feature allows video
capture apps to utilize more modern, storage-efficient encoding for videos
recorded on the device without sacrificing compatibility with other apps.

The following formats can be automatically transcoded for content that's
created on-device:

| Media format | XML Attribute | MediaFormat mime type |
|---|---|---|
| HEVC (H.265) | HEVC | MediaFormat.MIMETYPE_VIDEO_HEVC |
| HDR10 | HDR10 | MediaFeature.HdrType.HDR10 |
| HDR10+ | HDR10Plus | MediaFeature.HdrType.HDR10_PLUS |

Android assumes that apps can support playback of all media formats, so
compatible media transcoding is off by default.

## When to use transcoding

Transcoding is a computationally expensive operation and adds a significant
delay when opening a video file. For example, a one minute HEVC video file takes
roughly 20 seconds to transcode into AVC on a Pixel 3 phone. For this reason,
you should transcode a video file only when you are sending it off the
device. For example, when sharing a video file with other users of the same
app, or a cloud server which does not support modern video
formats.

Do not transcode when opening video files for on-device playback or for creating thumbnail images.

## Configuring transcoding

Apps can control their transcoding behavior by declaring their media
capabilities. There are two ways to declare these capabilities: in code,
or in a resource.

### Declare capabilities in code

You can declare media capabilities in code by constructing an instance of an
`ApplicationMediaCapabilities` object using a builder:  

### Kotlin

```kotlin
val mediaCapabilities = ApplicationMediaCapabilities.Builder()
    .addSupportedVideoMimeType(MediaFormat.MIMETYPE_VIDEO_HEVC)
    .addUnsupportedHdrType(MediaFeature.HdrType.HDR10)
    .addUnsupportedHdrType(MediaFeature.HdrType.HDR10_PLUS)
    .build()
```

### Java

```java
ApplicationMediaCapabilities mediaCapabilities = new ApplicationMediaCapabilities.Builder()
        .addSupportedVideoMimeType(MediaFormat.MIMETYPE_VIDEO_HEVC)
        .addUnsupportedHdrType(MediaFeature.HdrType.HDR10)
        .addUnsupportedHdrType(MediaFeature.HdrType.HDR10_PLUS)
        .build();
```

Use this object when accessing media content via methods such as
`ContentResolver#openTypedAssetFileDescriptor()`:  

### Kotlin

```kotlin
val providerOptions = Bundle().apply {
    putParcelable(MediaStore.EXTRA_MEDIA_CAPABILITIES, mediaCapabilities)
}
contentResolver.openTypedAssetFileDescriptor(mediaUri, mediaMimeType, providerOptions)
    .use { fileDescriptor ->
        // Content will be transcoded based on values defined in the
        // ApplicationMediaCapabilities provided.
    }
```

### Java

```java
Bundle providerOptions = new Bundle();
providerOptions.putParcelable(MediaStore.EXTRA_MEDIA_CAPABILITIES, mediaCapabilities);
try (AssetFileDescriptor fileDescriptor =  contentResolver.openTypedAssetFileDescriptor(mediaUri, mediaMimeType, providerOptions)) {
    // Content will be transcoded based on values defined in the
    // ApplicationMediaCapabilities provided.
}
```

This method allows granular control for particular code paths, such
as invoking transcoding only when transferring a video file off-device. It takes precedence over the method described below.

### Declare capabilities in a resource

Declaring capabilities in a resource allows blanket control over transcoding.
This method should only be used in very specific cases. For example, if your app
only receives video files from other apps (rather than opening them directly)
and uploads them to a server which does not support modern video codecs (see
example scenario 1 below).

Using this method when not absolutely necessary might invoke transcoding in unintended scenarios, such as when thumbnailing videos, resulting in a degraded user experience.

To use this method, create a `media_capabilities.xml` resource file:  

    <?xml version="1.0" encoding="utf-8"?>
    <media-capabilities xmlns:android="http://schemas.android.com/apk/res/android">
        <format android:name="HEVC" supported="true"/>
        <format android:name="HDR10" supported="false"/>
        <format android:name="HDR10Plus" supported="false"/>
    </media-capabilities>

In this example, HDR videos recorded on the device are seamlessly transcoded to
AVC SDR (standard dynamic range) video, while HEVC videos are not.

Use a `property` tag within the `application` tag to add a reference to the media
capabilities file. Add these properties to your `AndroidManifest.xml` file:  

    <property
        android:name="android.media.PROPERTY_MEDIA_CAPABILITIES"
        android:resource="@xml/media_capabilities" />

## Using another app's media capabilities to open a video file

If your app shares a video file with another app, the video file might need to
be transcoded before the receiving app can open it.

You can handle this case by opening a video file using [`openTypedAssetFileDescriptor`](https://developer.android.com/reference/android/content/ContentResolver#openTypedAssetFileDescriptor(android.net.Uri,%20java.lang.String,%20android.os.Bundle))
and specifying the UID of the receiving app, which can be obtained using [`Binder.getCallingUid`](https://developer.android.com/reference/android/os/Binder#getCallingUid()).
The platform then uses the receiving app's media capabilities to determine
whether the video file should be transcoded.  

### Kotlin

```kotlin
val providerOptions = Bundle().apply {
    putParcelable(MediaStore.EXTRA_MEDIA_CAPABILITIES_UID, Binder.getCallingUid())
}
contentResolver.openTypedAssetFileDescriptor(mediaUri, mediaMimeType, providerOptions)
    .use { fileDescriptor ->
        // Content will be transcoded based on the media capabilities of the
        // calling app.
    }
```

### Java

```java
Bundle providerOptions = new Bundle();
providerOptions.putParcelable(MediaStore.EXTRA_MEDIA_CAPABILITIES_UID, Binder.getCallingUid());
try (AssetFileDescriptor fileDescriptor =  contentResolver.openTypedAssetFileDescriptor(mediaUri, mediaMimeType, providerOptions)) {
    // Content will be transcoded based on the media capabilities of the
    // calling app.
}
```

## Example scenarios

The following diagrams demonstrate the two common use cases. In both cases the original video is stored in HEVC format and the video sharing app does not
support HEVC.

**Example 1.** Transcoding is initiated by video capture app.
![Example 1](https://developer.android.com/static/images/guide/topics/media-apps/video-app/media-transcode-ex1.svg)
The video sharing app declares that it does not support HEVC in its media
capabilities resource file. It then requests a video from the video capture app. The video capture
app handles the request and opens the file using [`openTypedAssetFileDescriptor`](https://developer.android.com/reference/android/content/ContentResolver#openTypedAssetFileDescriptor(android.net.Uri,%20java.lang.String,%20android.os.Bundle)), specifying the sharing app's UID. This initiates the transcoding process.
When the transcoded video is received it is supplied to the sharing app, which uploads it to a server in the cloud.

**Example 2.** Transcoding is initiated by video sharing app.
![Example 2](https://developer.android.com/static/images/guide/topics/media-apps/video-app/media-transcode-ex2.svg)
The video capture app shares a video with the video sharing app using a
`MediaStore` URI. The video sharing app opens the video file using [`openTypedAssetFileDescriptor`](https://developer.android.com/reference/android/content/ContentResolver#openTypedAssetFileDescriptor(android.net.Uri,%20java.lang.String,%20android.os.Bundle)), specifying that it does not support HEVC in its media capabilities. This
initiates the transcoding process, and once complete, the file is uploaded to
a server in the cloud.

## Undeclared formats

Compatible media transcoding is enabled for all formats that are declared
unsupported, and is disabled for all formats that are declared supported. For
other formats that are not declared, the platform decides whether to transcode
or not. In Android 12 transcoding is disabled
for all undeclared formats. This behavior might change for new formats in the
future.

## Developer options

You can use the following developer options to override Android's default
transcoding behavior:

- **Override transcoding defaults** This setting determines whether or not
  the platform controls automatic transcoding. When override
  is enabled, the platform defaults are ignored and the **enable
  transcoding** setting controls automatic transcoding. This option is disabled by
  default.

- **Enable transcoding** This setting specifies whether or not undeclared
  formats are automatically transcoded. It is enabled by default, but it only
  has an effect if **override transcoding defaults** is also enabled.

- **Assume apps support modern formats** This setting controls what happens when
  the app tries to play an undeclared format. This happens when the manifest does
  not declare whether or not the app supports a particular format, or Google
  hasn't added the app to the server-side force-transcode list. When the setting
  is enabled, the app does not transcode, when it's disabled, the app does
  transcode. This option is enabled by default.

- **Show transcoding notifications** When enabled, the app displays a
  transcoding progress notification when transcoding is triggered by reading an
  unsupported media file. This option is enabled by default.

- **Disable transcoding cache** If enabled, apps that require transcoding do not
  use the transcoding cache. This can be helpful during development to easily
  trigger transcoding on an unsupported media file, but can cause poor device
  performance. This option is disabled by default.