diff --git a/.github/ISSUE_TEMPLATE/bug.yml b/.github/ISSUE_TEMPLATE/bug.yml index c11e3e85cdf..d81faabc400 100644 --- a/.github/ISSUE_TEMPLATE/bug.yml +++ b/.github/ISSUE_TEMPLATE/bug.yml @@ -19,6 +19,8 @@ body: options: - Media3 main branch - Media3 pre-release (alpha, beta or RC not in this list) + - Media3 1.11.1 + - Media3 1.11.0 - Media3 1.10.1 - Media3 1.10.0 - Media3 1.9.2 diff --git a/RELEASENOTES.md b/RELEASENOTES.md index fdb642707a5..0212bfbdad0 100644 --- a/RELEASENOTES.md +++ b/RELEASENOTES.md @@ -1,101 +1,73 @@ # Release notes -### Unreleased changes +### 1.11.1 (2026-09-10) + +This release includes the following changes since the +[1.11.0 release](#1110-2026-08-05): -* Common Library: * ExoPlayer: - * Add `Format.selectionPriority` representing the relative preference of - the `Format` in track selection - ([#3236](https://github.com/androidx/media/pull/3236)). -* CompositionPlayer: -* Transformer: -* Track Selection: + * Move the flag to enable/disable HAGC metadata for progressive media from + `MediaSource.Factory` to `ExtractorsFactory`. The previous + `setExperimentalEnableHagcPlayback` method is removed and replaced by + `ExtractorsFactory.setParseHagcMetadata`. This also resolves an issue + where disabling didn't work for Matroska/WebM containers. + * Fix a playback stall caused when prewarming a non-transitioning + secondary renderer. + * Fix pre-warming issue where the `Surface` should be returned to the + primary renderer when a seek resets and disables both renderers. + * Fix `ArrayIndexOutOfBoundsException` when a live timeline refresh moves + the default position past a server-side inserted ad that is currently + being played ([#3348](https://github.com/androidx/media/issues/3348)). + * Fix a scrubbing mode issue where stale video frames could be briefly + displayed when seeking with + `ScrubbingModeParameters.allowSkippingMediaCodecFlush` enabled. * Extractors: - * AVI: Fix an issue where playing files without keyframe flags on audio - tracks caused audio loss and `OutOfMemoryError`. - * MP3: Use gapless-aware durations from Xing/Info headers - ([#3183](https://github.com/androidx/media/issues/3183)). - * MP3: Adjust LAME/Xing encoder delay and padding metadata to match - decoded PCM trimming - ([#3200](https://github.com/androidx/media/pull/3200)). -* Inspector: -* Inspector Frame: + * Matroska: Fix issue where Tracks placed after clusters wouldn't result + in a seekable timeline + ([#3377](https://github.com/androidx/media/issues/3377)). * Audio: - * Remove fallback path of EAC3-JOC to EAC3 for playback on Google Pixel - devices as their standard EAC3 decoders cannot decode EAC3-JOC streams - ([#3257](https://github.com/androidx/media/pull/3257)). -* Video: - * Fix bug in `VideoFrameReleaseHelper` where display changes could trigger - redundant `Choreographer` callbacks and excessive CPU wakeups on the - main thread. -* Text: -* Metadata: -* Image: -* DataSource: -* DRM: -* Effect: -* Effect Lottie: -* Muxers: -* IMA extension: + * Fix buffer size calculation in `SilenceSkippingAudioProcessor` so that + the minimum silence duration is not incorrectly scaled down by the frame + size ([#3271](https://github.com/androidx/media/pull/3271)). + * Fix 8-bit PCM handling in `PcmAudioUtil` to treat samples as unsigned as + defined by Android + ([#3271](https://github.com/androidx/media/pull/3271)). + * Fix offload issue in which playback could stall during pre-roll or + gapless transitions due to limited hardware buffer sizes. + * Fix bug in `DefaultAudioSink` where release count doesn't decrease when + playback thread is no longer alive + ([#3338](https://github.com/androidx/media/issues/3338)). * Session: - * Fix double-downscaling of artwork in `MediaSession` when the image size - is close to the platform limit, resolving blurriness in notifications - ([#3134](https://github.com/androidx/media/issues/3134)). - * Fix `ForegroundServiceStartNotAllowedException` crash in - `MediaNotificationManager` when an asynchronous artwork bitmap load - callback attempts to start the foreground service while the app is in - the background ([#3270](https://github.com/androidx/media/issues/3270)). - * Fix an issue where `PositionInfo` objects received by a - `MediaController` were missing their original `Timeline` UIDs. The - session now reliably translates and propagates these UIDs during state - updates. -* UI: - * Fix shutter suppression bug in `PlayerView` and Compose - `PresentationState` that caused crashes on timelines that do not support - period UID lookup - ([#3264](https://github.com/androidx/media/issues/3264)). -* Downloads: -* OkHttp extension: -* Cronet extension: -* RTMP extension: + * Fix `NullPointerException` when an in-process `MediaController` is + released from a `Player.Listener` callback + ([#3375](https://github.com/androidx/media/issues/3375)). + * Fix deadlock on the main thread when a legacy `MediaBrowser` connects to + a service returning an asynchronous result from `onGetLibraryRoot()` or + `onConnectAsync()` + ([#3393](https://github.com/androidx/media/issues/3393)). * HLS extension: - * Parse `SCORE` attribute of `EXT-X-STREAM-INF` and - `EXT-X-I-FRAME-STREAM-INF`, and populate it to - `Format.selectionPriority` - ([#3236](https://github.com/androidx/media/pull/3236)). + * Fix calculation of content resume offset when the target segment for + snapping is not yet in the playlist + ([#3322](https://github.com/androidx/media/issues/3322)). + * Fix an issue where a fully consumed `HlsMediaChunk` retries loading on + receiving `EOFException` from the extractor + ([#3350](https://github.com/androidx/media/issues/3350)). * DASH extension: - * Add support for parsing multiple `Location` elements from the manifest - (MPD) and performing location fallback in `DashMediaSource` when - manifest loads fail. -* Smooth Streaming extension: -* RTSP extension: + * Fix incorrect sample timestamp calculation for image tracks with a + `presentationTimeOffset` + ([#3334](https://github.com/androidx/media/issues/3334)). * Decoder extensions (FFmpeg, VP9, AV1, etc.): - * Add monochrome video support to bundled dav1d JNI. -* MIDI extension: -* Leanback extension: -* Cast extension: - * Add `MediaRouteButtonState` and `rememberMediaRouteButtonState` to - support observing the visibility state of the media route picker, and - add `state` parameter to `MediaRouteButton` - ([3172](https://github.com/androidx/media/issues/3172)). - * Fix bug where `RemoteCastPlayer` could get permanently stuck in a - track-masking state after a track selection, causing it to ignore - subsequent track updates from the Cast receiver - ([#3237](https://github.com/androidx/media/issues/3237)). - * Fix bug where `DefaultMediaItemConverter` throws a - `NullPointerException` when trying to join a cast session started from a - non-Media3 sender. -* Test Utilities: - * Add `setPlaybackLooper` to `TestExoPlayerBuilder`. -* Remove deprecated symbols: - * Remove `androidx.media3.common.C.generateAudioSessionIdV21`. Use - `androidx.media3.common.util.Util.generateAudioSessionId` instead. - -## 1.11 + * Opus: Fix memory corruption when multiple `OpusDecoder` instances are + initialized concurrently. + * MPEG-H: Fix memory leak, truncation of non-ASCII characters, and + potential native crash under low-memory conditions when sending commands + to the `MpeghUiManager` + ([#3365](https://github.com/androidx/media/issues/3365)). -### 1.11.0-alpha01 (2026-06-23) +### 1.11.0 (2026-08-05) -This release includes the following changes since [1.10.1](#1101-2026-05-12): +This release includes the following changes since the +[1.10.1 release](#1101-2026-05-12): * Common library: * Add `Format.channelMask` to explicitly represent the audio channel mask, @@ -109,8 +81,6 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): count to decrease when an ad group is fully processed (`hasUnplayedAds()` is `false`), accommodating dynamic ad group resizing during reset workflows. - * Add support for ads in multi-period content (e.g., DASH) by splitting - and offsetting the `AdPlaybackState` for each period. * Add `getFlags()` and `FLAG_STRICT_DURATION` to `SampleStream` to allow streams to report flags, and update renderers to check these flags dynamically. @@ -180,6 +150,11 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): metadata out-of-band to the decoder on API 37+ devices. This behavior can be disabled via `DefaultMediaSourceFactory.setExperimentalEnableHagcPlayback(false)`. + * Add `Format.selectionPriority` representing the relative preference of + the `Format` in track selection + ([#3236](https://github.com/androidx/media/pull/3236)). + * Fix potential scrubbing mode issue where scrubbing could stall when + seeking to 'end of stream'. * CompositionPlayer: * Fix an issue where `TrackSelector` instances were not being released. * Transformer: @@ -189,6 +164,9 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): `AdaptiveTrackSelection.Factory.setTrackFormatComparator` to allow custom format ordering and ABR selection priority beyond bitrate-only ordering. + * Fix a timing-dependent concurrency issue where rapid sequential updates + to track selection parameters could result in some updates being lost or + overwritten. * Extractors: * MP4, MP3, and FLAC: Add `FLAG_DISABLE_ARTWORK_METADATA` to allow discarding attached pictures and cover art metadata during container @@ -233,6 +211,13 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): ([#3268](https://github.com/androidx/media/pull/3268)). * MP4: Allow variable length `sgpd` boxes in fragmented MP4 files ([#3243](https://github.com/androidx/media/pull/3243)). + * AVI: Fix an issue where playing files without keyframe flags on audio + tracks caused audio loss and `OutOfMemoryError`. + * MP3: Use gapless-aware durations from Xing/Info headers + ([#3183](https://github.com/androidx/media/issues/3183)). + * MP3: Adjust LAME/Xing encoder delay and padding metadata to match + decoded PCM trimming + ([#3200](https://github.com/androidx/media/pull/3200)). * Audio: * Add a 100ms grace period in ExoPlayer's audio renderers when transitioning from ready to not-ready state, to debounce transient @@ -263,6 +248,9 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): time-based audio processing ([#418](https://github.com/androidx/media/issues/418)). * Add support for big endian 32-bit and 64-bit floating point PCM. + * Remove fallback path of EAC3-JOC to EAC3 for playback on Google Pixel + devices as their standard EAC3 decoders cannot decode EAC3-JOC streams + ([#3257](https://github.com/androidx/media/pull/3257)). * Video: * Fix video joining logic to count dropped buffers during joining as skipped instead of dropped. @@ -273,6 +261,9 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): * Allow configuration of the threshold used to schedule frames early. The default is 50ms but one can customize the value through `MediaCodecVideoRenderer.Builder.setMaxEarlyUsThreshold()`. + * Fix bug in `VideoFrameReleaseHelper` where display changes could trigger + redundant `Choreographer` callbacks and excessive CPU wakeups on the + main thread. * Text: * TTML: Fallback to `displayAlign` from `style` for regions ([#2559](https://github.com/androidx/media/issues/2559)). @@ -334,6 +325,23 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): `Callback.onConnect` is a candidate to be deprecated. * Fix issue where Bluetooth AVRCP browsing didn't recognise `MediaLibraryService` on API 36 and 37. + * Fix double-downscaling of artwork in `MediaSession` when the image size + is close to the platform limit, resolving blurriness in notifications + ([#3134](https://github.com/androidx/media/issues/3134)). + * Fix `ForegroundServiceStartNotAllowedException` crash in + `MediaNotificationManager` when an asynchronous artwork bitmap load + callback attempts to start the foreground service while the app is in + the background ([#3270](https://github.com/androidx/media/issues/3270)). + * Fix an issue where `PositionInfo` objects received by a + `MediaController` were missing their original `Timeline` UIDs. The + session now reliably translates and propagates these UIDs during state + updates. + * Fix crash by catching `ForegroundServiceStartNotAllowedException` in + `MediaSessionService.stopSelfSafely()` + ([#3310](https://github.com/androidx/media/issues/3310)). + * Fix unexpected `onMediaItemTransition()` callback on `MediaController` + when seeking inside the same media item + ([#3248](https://github.com/androidx/media/issues/3248)). * UI: * Fix first frame rendering at the wrong size when `ContentFrame` is recomposed mid-playback @@ -364,18 +372,49 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): (`ui-compose`) to support preloading of `MediaItems` in sliding window UI environments. Showcase this functionality in `demo-compose` with a new `ShortFormPlayerScreen`. + * Fix shutter suppression bug in `PlayerView` and Compose + `PresentationState` that caused crashes on timelines that do not support + period UID lookup + ([#3264](https://github.com/androidx/media/issues/3264)). +* Downloads: + * Resolve HLS variables in media playlist when fetched for download + ([#3258](https://github.com/androidx/media/issues/3258)). * Ktor extension: * Add a new `media3-datasource-ktor` extension module providing a `KtorDataSource` backed by the [Ktor](https://ktor.io/) HTTP stack. + * Fix `KtorDataSource` loading the entire HTTP response body into memory + when opening a connection + ([#3305](https://github.com/androidx/media/issues/3305)). * HLS extension: * Add support for HLS Content Steering and Pathway Cloning ([#1689](https://github.com/androidx/media/issues/1689)). * Add `setWithAssetListReset` to `HlsInterstitialsAdsLoader` to allow apps to reset fully processed asset list interstitials back to an unavailable state for on-demand re-resolution. + * Parse `SCORE` attribute of `EXT-X-STREAM-INF` and + `EXT-X-I-FRAME-STREAM-INF`, and populate it to + `Format.selectionPriority` + ([#3236](https://github.com/androidx/media/pull/3236)). + * Fix bug where scheduled HLS playlist refreshes continue even if the + playlist is no longer primary or active + ([#3254](https://github.com/androidx/media/issues/3254)). + * Fix calculation of content resume offset when resolving interstitial + asset lists ([#3322](https://github.com/androidx/media/issues/3322)). + * Fix unexpected audio track timestamp discontinuity when resuming low + latency live playback after a playlist request failure + ([#3311](https://github.com/androidx/media/issues/3311)). + * Fix bug in `HlsMediaPeriod.getStreamKeys()` where the ID3 track in audio + renditions is considered as subtitles + ([#3333](https://github.com/androidx/media/issues/3333)). * DASH extension: * Separate CEA closed captions into different `TrackGroup`s based on language ([#3113](https://github.com/androidx/media/issues/3113)). + * Add support for parsing multiple `Location` elements from the manifest + (MPD) and performing location fallback in `DashMediaSource` when + manifest loads fail. + * Fix crash (`IndexOutOfBoundsException`) when opening manifests with an + empty `` element + ([#3326](https://github.com/androidx/media/issues/3326)). * RTSP extension: * Fix transient playback stalls or failures during RTSP playback preparation caused by UDP port binding errors. @@ -385,6 +424,23 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): * Add new `CastParams.getShowSystemOutputSwitcherOnCastIconClick()` option, which triggers the use of the SystemUI Output Switcher instead of the in-app Cast device picker when available. + * Add `MediaRouteButtonState` and `rememberMediaRouteButtonState` to + support observing the visibility state of the media route picker, and + add `state` parameter to `MediaRouteButton` + ([#3172](https://github.com/androidx/media/issues/3172)). + * Fix bug where `RemoteCastPlayer` could get permanently stuck in a + track-masking state after a track selection, causing it to ignore + subsequent track updates from the Cast receiver + ([#3237](https://github.com/androidx/media/issues/3237)). + * Fix bug where `DefaultMediaItemConverter` throws a + `NullPointerException` when trying to join a cast session started from a + non-Media3 sender. + * Prevent `CastPlayer` from transferring `MediaItems` that are not + playable when changing the active player + ([#3199](https://github.com/androidx/media/issues/3199)). + * Fix bug where unconfigured live streams (`liveConfiguration == UNSET`) + were queued as `STREAM_TYPE_BUFFERED` + ([#3318](https://github.com/androidx/media/issues/3318)). * Test utilities: * Expand `DataSourceContractTest` to include support for `POST` requests with headers & bodies, add some `POST` resources to @@ -394,6 +450,7 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): `DataSource.open()`. Resources that may result in `C.LENGTH_UNSET` should indicate this by using `TestResource.Builder.setMayResolveToUnknownLength(boolean)`. + * Add `setPlaybackLooper` to `TestExoPlayerBuilder`. * Remove deprecated symbols: * Remove `androidx.media3.exoplayer.MetadataRetriever`. Use `androidx.media3.inspector.MetadataRetriever` instead. @@ -408,12 +465,26 @@ This release includes the following changes since [1.10.1](#1101-2026-05-12): `androidx.media3.extractor.DiscardingTrackOutput` instead. * Remove `androidx.media3.extractor.DummyExtractorOutput`. Use `androidx.media3.extractor.NoOpExtractorOutput` instead. + * Remove `androidx.media3.common.C.generateAudioSessionIdV21`. Use + `androidx.media3.common.util.Util.generateAudioSessionId` instead. * Build * Updated the `README.md` instructions for depending on Media3 locally to use Gradle Composite Builds (`includeBuild`). The `core_settings.gradle` script has been removed, and the `androidxMediaModulePrefix` and `androidxMediaEnableMidiModule` properties are no longer used. +### 1.11.0-rc01 (2026-07-22) + +Use the 1.11.0 [stable version](#1110-2026-08-05). + +### 1.11.0-beta01 (2026-07-08) + +Use the 1.11.0 [stable version](#1110-2026-08-05). + +### 1.11.0-alpha01 (2026-06-23) + +Use the 1.11.0 [stable version](#1110-2026-08-05). + ## 1.10 ### 1.10.1 (2026-05-12) diff --git a/demos/compose/src/main/assets/media.exolist.json b/demos/compose/src/main/assets/media.exolist.json index 17d6a5b30a3..f60ed4cc318 100644 --- a/demos/compose/src/main/assets/media.exolist.json +++ b/demos/compose/src/main/assets/media.exolist.json @@ -162,6 +162,10 @@ "name": "AV1 Rooftop (Everyframe T35)", "uri": "https://storage.googleapis.com/exoplayer-test-media-1/hagc/rooftop_av1_t35track_everyframe_v0.mp4" }, + { + "name": "HEVC Rooftop (Everyframe T35)", + "uri": "https://storage.googleapis.com/exoplayer-test-media-1/hagc/rooftop_hevc_t35track_everyframe_v0.mp4" + }, { "name": "HEVC Lights (SDR Base, Sparse T35)", "uri": "https://storage.googleapis.com/exoplayer-test-media-1/hagc/lights_hevc_sdrbase_t35track_v0.mp4" diff --git a/demos/main/src/main/assets/media.exolist.json b/demos/main/src/main/assets/media.exolist.json index 19b696d049f..1913a74cdb4 100644 --- a/demos/main/src/main/assets/media.exolist.json +++ b/demos/main/src/main/assets/media.exolist.json @@ -854,6 +854,10 @@ "name": "AV1 Rooftop (Everyframe T35)", "uri": "https://storage.googleapis.com/exoplayer-test-media-1/hagc/rooftop_av1_t35track_everyframe_v0.mp4" }, + { + "name": "HEVC Rooftop (Everyframe T35)", + "uri": "https://storage.googleapis.com/exoplayer-test-media-1/hagc/rooftop_hevc_t35track_everyframe_v0.mp4" + }, { "name": "HEVC Lights (SDR Base, Sparse T35)", "uri": "https://storage.googleapis.com/exoplayer-test-media-1/hagc/lights_hevc_sdrbase_t35track_v0.mp4" diff --git a/demos/session/src/main/AndroidManifest.xml b/demos/session/src/main/AndroidManifest.xml index 90819f51fec..91d5053aa3a 100644 --- a/demos/session/src/main/AndroidManifest.xml +++ b/demos/session/src/main/AndroidManifest.xml @@ -32,9 +32,6 @@ android:name="com.google.android.gms.car.application" android:resource="@xml/auto_app_desc" /> - - - PlayerTransferState.fromPlayer(sourcePlayer).setToPlayer(targetPlayer); + TransferCallback DEFAULT = new DefaultCastPlayerTransferCallback(); /** * Called immediately before changing the active {@link Player}, with the intended use of diff --git a/libraries/cast/src/main/java/androidx/media3/cast/CastTimelineTracker.java b/libraries/cast/src/main/java/androidx/media3/cast/CastTimelineTracker.java index b0b75f1c20c..4ce8545334b 100644 --- a/libraries/cast/src/main/java/androidx/media3/cast/CastTimelineTracker.java +++ b/libraries/cast/src/main/java/androidx/media3/cast/CastTimelineTracker.java @@ -108,21 +108,11 @@ public CastTimeline getCastTimeline(RemoteMediaClient remoteMediaClient) { return CastTimeline.EMPTY_CAST_TIMELINE; } - int currentItemId = mediaStatus.getCurrentItemId(); - String currentContentId = checkNotNull(mediaStatus.getMediaInfo()).getContentId(); - MediaItem mediaItem = mediaItemsByContentId.get(currentContentId); - updateItemData( - currentItemId, - mediaItem != null ? mediaItem : MediaItem.EMPTY, - mediaStatus.getMediaInfo(), - currentContentId, - /* defaultPositionUs= */ C.TIME_UNSET); - for (MediaQueueItem queueItem : mediaStatus.getQueueItems()) { long defaultPositionUs = (long) (queueItem.getStartTime() * C.MICROS_PER_SECOND); @Nullable MediaInfo mediaInfo = queueItem.getMedia(); String contentId = mediaInfo != null ? mediaInfo.getContentId() : UNKNOWN_CONTENT_ID; - mediaItem = mediaItemsByContentId.get(contentId); + MediaItem mediaItem = mediaItemsByContentId.get(contentId); updateItemData( queueItem.getItemId(), mediaItem != null ? mediaItem : mediaItemConverter.toMediaItem(queueItem), @@ -130,6 +120,23 @@ public CastTimeline getCastTimeline(RemoteMediaClient remoteMediaClient) { contentId, defaultPositionUs); } + + // Process mediaStatus.getMediaInfo() after mediaStatus.getQueueItems()[...].getMedia(). Static + // queue items in the Cast SDK do not receive dynamic runtime updates (such as transitioning + // from buffered to live upon manifest loading). Updating from mediaStatus.getMediaInfo() second + // ensures that active runtime playback state is preserved and not overwritten by stale queue + // item metadata. + int currentItemId = mediaStatus.getCurrentItemId(); + MediaInfo currentMediaInfo = checkNotNull(mediaStatus.getMediaInfo()); + String currentContentId = currentMediaInfo.getContentId(); + MediaItem mediaItem = mediaItemsByContentId.get(currentContentId); + updateItemData( + currentItemId, + mediaItem != null ? mediaItem : MediaItem.EMPTY, + currentMediaInfo, + currentContentId, + /* defaultPositionUs= */ C.TIME_UNSET); + return new CastTimeline(itemIds, itemIdToData); } @@ -151,6 +158,11 @@ private void updateItemData( if (defaultPositionUs == C.TIME_UNSET) { defaultPositionUs = previousData.defaultPositionUs; } + // The media item can be empty if it originates from another sender. We use previous data as + // itemIdToData is populated when all media items from the queue are updated. + if (mediaItem == MediaItem.EMPTY) { + mediaItem = previousData.mediaItem; + } itemIdToData.put( itemId, previousData.copyWithNewValues( diff --git a/libraries/cast/src/main/java/androidx/media3/cast/DefaultCastPlayerTransferCallback.java b/libraries/cast/src/main/java/androidx/media3/cast/DefaultCastPlayerTransferCallback.java new file mode 100644 index 00000000000..1c9718fd0f8 --- /dev/null +++ b/libraries/cast/src/main/java/androidx/media3/cast/DefaultCastPlayerTransferCallback.java @@ -0,0 +1,78 @@ +/* + * Copyright 2026 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 androidx.media3.cast; + +import android.net.Uri; +import androidx.media3.common.C; +import androidx.media3.common.MediaItem; +import androidx.media3.common.Player; +import androidx.media3.common.PlayerTransferState; +import androidx.media3.common.util.UnstableApi; +import com.google.common.collect.ImmutableList; +import java.util.List; + +/** + * The default {@link CastPlayer.TransferCallback} implementation. + * + *

Filters out {@link MediaItem}s that do not have a playback URI and adjusts the current media + * item index accordingly. + */ +@UnstableApi +public final class DefaultCastPlayerTransferCallback implements CastPlayer.TransferCallback { + + @Override + public void transferState(Player sourcePlayer, Player targetPlayer) { + PlayerTransferState transferState = PlayerTransferState.fromPlayer(sourcePlayer); + List mediaItems = transferState.getMediaItems(); + ImmutableList.Builder playableMediaItemsBuilder = ImmutableList.builder(); + int currentIndex = transferState.getCurrentMediaItemIndex(); + int newCurrentIndex = currentIndex; + boolean currentIndexFiltered = false; + for (int i = 0; i < mediaItems.size(); i++) { + MediaItem mediaItem = mediaItems.get(i); + if (isPlayable(mediaItem)) { + playableMediaItemsBuilder.add(mediaItem); + } else if (i < currentIndex) { + newCurrentIndex--; + } else if (i == currentIndex) { + currentIndexFiltered = true; + } + } + List playableMediaItems = playableMediaItemsBuilder.build(); + if (playableMediaItems.size() < mediaItems.size()) { + if (playableMediaItems.isEmpty()) { + newCurrentIndex = C.INDEX_UNSET; + } else { + newCurrentIndex = Math.min(newCurrentIndex, playableMediaItems.size() - 1); + } + PlayerTransferState.Builder builder = + transferState + .buildUpon() + .setMediaItems(playableMediaItems) + .setCurrentMediaItemIndex(newCurrentIndex); + if (currentIndexFiltered) { + builder.setCurrentPosition(0); + } + transferState = builder.build(); + } + transferState.setToPlayer(targetPlayer); + } + + private static boolean isPlayable(MediaItem mediaItem) { + return mediaItem.localConfiguration != null + && !Uri.EMPTY.equals(mediaItem.localConfiguration.uri); + } +} diff --git a/libraries/cast/src/main/java/androidx/media3/cast/DefaultMediaItemConverter.java b/libraries/cast/src/main/java/androidx/media3/cast/DefaultMediaItemConverter.java index 136e196f175..26d4279129b 100644 --- a/libraries/cast/src/main/java/androidx/media3/cast/DefaultMediaItemConverter.java +++ b/libraries/cast/src/main/java/androidx/media3/cast/DefaultMediaItemConverter.java @@ -50,6 +50,12 @@ public final class DefaultMediaItemConverter implements MediaItemConverter { private static final String KEY_UUID = "uuid"; private static final String KEY_LICENSE_URI = "licenseUri"; private static final String KEY_REQUEST_HEADERS = "requestHeaders"; + private static final String KEY_LIVE_CONFIGURATION = "m3-liveConfiguration"; + private static final String KEY_TARGET_OFFSET_MS = "m3-targetOffsetMs"; + private static final String KEY_MIN_OFFSET_MS = "m3-minOffsetMs"; + private static final String KEY_MAX_OFFSET_MS = "m3-maxOffsetMs"; + private static final String KEY_MIN_PLAYBACK_SPEED = "m3-minPlaybackSpeed"; + private static final String KEY_MAX_PLAYBACK_SPEED = "m3-maxPlaybackSpeed"; @Override public MediaItem toMediaItem(MediaQueueItem mediaQueueItem) { @@ -165,14 +171,20 @@ public MediaQueueItem toMediaQueueItem(MediaItem mediaItem) { String contentUrl = mediaItem.localConfiguration.uri.toString(); String contentId = mediaItem.mediaId.equals(MediaItem.DEFAULT_MEDIA_ID) ? contentUrl : mediaItem.mediaId; - MediaInfo mediaInfo = + // If the MediaItem has a LiveConfiguration, we set the stream type to STREAM_TYPE_LIVE. + // Otherwise, we leave it unset letting the receiver decide whether the item is live. + boolean isExplicitlyLive = + !mediaItem.liveConfiguration.equals(MediaItem.LiveConfiguration.UNSET); + MediaInfo.Builder mediaInfoBuilder = new MediaInfo.Builder(contentId) - .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED) .setContentType(mediaItem.localConfiguration.mimeType) .setContentUrl(contentUrl) .setMetadata(metadata) - .setCustomData(getCustomData(mediaItem)) - .build(); + .setCustomData(getCustomData(mediaItem)); + if (isExplicitlyLive) { + mediaInfoBuilder.setStreamType(MediaInfo.STREAM_TYPE_LIVE); + } + MediaInfo mediaInfo = mediaInfoBuilder.build(); return new MediaQueueItem.Builder(mediaInfo).build(); } @@ -231,12 +243,37 @@ private static MediaItem getMediaItem( if (mediaItemJson.has(KEY_DRM_CONFIGURATION)) { populateDrmConfiguration(mediaItemJson.getJSONObject(KEY_DRM_CONFIGURATION), builder); } + if (mediaItemJson.has(KEY_LIVE_CONFIGURATION)) { + builder.setLiveConfiguration( + getLiveConfiguration(mediaItemJson.getJSONObject(KEY_LIVE_CONFIGURATION))); + } return builder.build(); } catch (JSONException e) { throw new RuntimeException(e); } } + private static MediaItem.LiveConfiguration getLiveConfiguration(JSONObject json) + throws JSONException { + MediaItem.LiveConfiguration.Builder builder = new MediaItem.LiveConfiguration.Builder(); + if (json.has(KEY_TARGET_OFFSET_MS)) { + builder.setTargetOffsetMs(json.getLong(KEY_TARGET_OFFSET_MS)); + } + if (json.has(KEY_MIN_OFFSET_MS)) { + builder.setMinOffsetMs(json.getLong(KEY_MIN_OFFSET_MS)); + } + if (json.has(KEY_MAX_OFFSET_MS)) { + builder.setMaxOffsetMs(json.getLong(KEY_MAX_OFFSET_MS)); + } + if (json.has(KEY_MIN_PLAYBACK_SPEED)) { + builder.setMinPlaybackSpeed((float) json.getDouble(KEY_MIN_PLAYBACK_SPEED)); + } + if (json.has(KEY_MAX_PLAYBACK_SPEED)) { + builder.setMaxPlaybackSpeed((float) json.getDouble(KEY_MAX_PLAYBACK_SPEED)); + } + return builder.build(); + } + private static void populateDrmConfiguration(JSONObject json, MediaItem.Builder mediaItem) throws JSONException { MediaItem.DrmConfiguration.Builder drmConfiguration = @@ -280,6 +317,31 @@ private static JSONObject getMediaItemJson(MediaItem mediaItem) throws JSONExcep KEY_DRM_CONFIGURATION, getDrmConfigurationJson(mediaItem.localConfiguration.drmConfiguration)); } + if (!mediaItem.liveConfiguration.equals(MediaItem.LiveConfiguration.UNSET)) { + JSONObject liveConfigurationJson = getLiveConfigurationJson(mediaItem.liveConfiguration); + json.put(KEY_LIVE_CONFIGURATION, liveConfigurationJson); + } + return json; + } + + private static JSONObject getLiveConfigurationJson(MediaItem.LiveConfiguration liveConfiguration) + throws JSONException { + JSONObject json = new JSONObject(); + if (liveConfiguration.targetOffsetMs != C.TIME_UNSET) { + json.put(KEY_TARGET_OFFSET_MS, liveConfiguration.targetOffsetMs); + } + if (liveConfiguration.minOffsetMs != C.TIME_UNSET) { + json.put(KEY_MIN_OFFSET_MS, liveConfiguration.minOffsetMs); + } + if (liveConfiguration.maxOffsetMs != C.TIME_UNSET) { + json.put(KEY_MAX_OFFSET_MS, liveConfiguration.maxOffsetMs); + } + if (liveConfiguration.minPlaybackSpeed != C.RATE_UNSET) { + json.put(KEY_MIN_PLAYBACK_SPEED, liveConfiguration.minPlaybackSpeed); + } + if (liveConfiguration.maxPlaybackSpeed != C.RATE_UNSET) { + json.put(KEY_MAX_PLAYBACK_SPEED, liveConfiguration.maxPlaybackSpeed); + } return json; } diff --git a/libraries/cast/src/test/java/androidx/media3/cast/CastPlayerTest.java b/libraries/cast/src/test/java/androidx/media3/cast/CastPlayerTest.java index 962e5d0250c..fa4d1800051 100644 --- a/libraries/cast/src/test/java/androidx/media3/cast/CastPlayerTest.java +++ b/libraries/cast/src/test/java/androidx/media3/cast/CastPlayerTest.java @@ -252,6 +252,15 @@ public void release_whenCastSessionIsAvailable_releasesBothPlayers() { public void playerTransfer_whenSourcePlayerIsNonIdle_callsPrepare() { // We need a non-empty timeline to be in a non-idle state, and check that the target player is // prepared as a result. + MediaInfo mediaInfo = + new MediaInfo.Builder("https://example.com/media.mp4") + .setStreamType(MediaInfo.STREAM_TYPE_BUFFERED) + .setContentType("video/mp4") + .build(); + MediaQueueItem queueItem = new MediaQueueItem.Builder(mediaInfo).setItemId(1).build(); + when(mockMediaStatus.getQueueItems()).thenReturn(ImmutableList.of(queueItem)); + when(mockMediaStatus.getCurrentItemId()).thenReturn(1); + when(mockMediaStatus.getMediaInfo()).thenReturn(mediaInfo); when(mockMediaQueue.getItemIds()).thenReturn(new int[] {1}); when(mockRemoteMediaClient.getPlayerState()).thenReturn(MediaStatus.PLAYER_STATE_PLAYING); castSessionListener.onSessionStarted(mockCastSession, /* sessionId= */ "ignored"); diff --git a/libraries/cast/src/test/java/androidx/media3/cast/CastTimelineTrackerTest.java b/libraries/cast/src/test/java/androidx/media3/cast/CastTimelineTrackerTest.java index 73637399874..87c5127890f 100644 --- a/libraries/cast/src/test/java/androidx/media3/cast/CastTimelineTrackerTest.java +++ b/libraries/cast/src/test/java/androidx/media3/cast/CastTimelineTrackerTest.java @@ -25,13 +25,13 @@ import androidx.media3.common.Timeline.Window; import androidx.media3.common.util.Util; import androidx.media3.test.utils.TimelineAsserts; -import androidx.test.ext.junit.runners.AndroidJUnit4; import com.google.android.gms.cast.MediaInfo; import com.google.android.gms.cast.MediaQueueItem; import com.google.android.gms.cast.MediaStatus; import com.google.android.gms.cast.framework.media.MediaQueue; import com.google.android.gms.cast.framework.media.RemoteMediaClient; import com.google.common.collect.ImmutableList; +import com.google.testing.junit.testparameterinjector.TestParameter; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; @@ -39,9 +39,10 @@ import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.robolectric.RobolectricTestParameterInjector; /** Tests for {@link CastTimelineTracker}. */ -@RunWith(AndroidJUnit4.class) +@RunWith(RobolectricTestParameterInjector.class) public class CastTimelineTrackerTest { private static final long DURATION_2_MS = 2000; @@ -332,6 +333,102 @@ public void getCastTimeline_noCustomData_returnsFallbackMediaItems() { assertThat(window.mediaItem.localConfiguration.mimeType).isEqualTo(MimeTypes.AUDIO_MPEG); } + @Test + public void getCastTimeline_receiverReportsStreamTypeLive_windowIsLive() { + RemoteMediaClient mockRemoteMediaClient = mock(RemoteMediaClient.class); + MediaQueue mockMediaQueue = mock(MediaQueue.class); + MediaStatus mockMediaStatus = mock(MediaStatus.class); + MediaInfo mediaInfo = + new MediaInfo.Builder("https://example.com/live.m3u8") + .setContentType(MimeTypes.APPLICATION_M3U8) + .setStreamType(MediaInfo.STREAM_TYPE_LIVE) + .build(); + MediaQueueItem queueItem = new MediaQueueItem.Builder(mediaInfo).setItemId(1).build(); + when(mockRemoteMediaClient.getMediaQueue()).thenReturn(mockMediaQueue); + when(mockMediaQueue.getItemIds()).thenReturn(new int[] {1}); + when(mockRemoteMediaClient.getMediaStatus()).thenReturn(mockMediaStatus); + when(mockMediaStatus.getCurrentItemId()).thenReturn(1); + when(mockMediaStatus.getMediaInfo()).thenReturn(mediaInfo); + when(mockMediaStatus.getQueueItems()).thenReturn(Collections.singletonList(queueItem)); + + CastTimeline castTimeline = castTimelineTracker.getCastTimeline(mockRemoteMediaClient); + + assertThat(castTimeline.getWindowCount()).isEqualTo(1); + Window window = castTimeline.getWindow(/* windowIndex= */ 0, new Window()); + assertThat(window.isLive()).isTrue(); + assertThat(window.liveConfiguration).isEqualTo(MediaItem.LiveConfiguration.UNSET); + } + + @Test + public void getCastTimeline_activeMediaInfoLiveAndQueueItemStale_windowIsLive( + @TestParameter({"0" /* STREAM_TYPE_NONE */, "1" /* STREAM_TYPE_BUFFERED */}) + int staleStreamType) { + RemoteMediaClient mockRemoteMediaClient = mock(RemoteMediaClient.class); + MediaQueue mockMediaQueue = mock(MediaQueue.class); + MediaStatus mockMediaStatus = mock(MediaStatus.class); + MediaInfo staleQueueMediaInfo = + new MediaInfo.Builder("https://example.com/live.m3u8") + .setContentType(MimeTypes.APPLICATION_M3U8) + .setStreamType(staleStreamType) + .build(); + MediaQueueItem queueItem = new MediaQueueItem.Builder(staleQueueMediaInfo).setItemId(1).build(); + MediaInfo activeMediaInfo = + new MediaInfo.Builder("https://example.com/live.m3u8") + .setContentType(MimeTypes.APPLICATION_M3U8) + .setStreamType(MediaInfo.STREAM_TYPE_LIVE) + .build(); + when(mockRemoteMediaClient.getMediaQueue()).thenReturn(mockMediaQueue); + when(mockMediaQueue.getItemIds()).thenReturn(new int[] {1}); + when(mockRemoteMediaClient.getMediaStatus()).thenReturn(mockMediaStatus); + when(mockMediaStatus.getCurrentItemId()).thenReturn(1); + when(mockMediaStatus.getMediaInfo()).thenReturn(activeMediaInfo); + when(mockMediaStatus.getQueueItems()).thenReturn(Collections.singletonList(queueItem)); + + CastTimeline castTimeline = castTimelineTracker.getCastTimeline(mockRemoteMediaClient); + + assertThat(castTimeline.getWindowCount()).isEqualTo(1); + Window window = castTimeline.getWindow(/* windowIndex= */ 0, new Window()); + assertThat(window.isLive()).isTrue(); + assertThat(window.liveConfiguration).isEqualTo(MediaItem.LiveConfiguration.UNSET); + } + + @Test + public void getCastTimeline_unconfiguredLiveStreamResolvedByReceiver_windowIsLive() { + RemoteMediaClient mockRemoteMediaClient = mock(RemoteMediaClient.class); + MediaQueue mockMediaQueue = mock(MediaQueue.class); + MediaStatus mockMediaStatus = mock(MediaStatus.class); + MediaItem unconfiguredItem = + new MediaItem.Builder() + .setUri("https://example.com/live.m3u8") + .setMimeType(MimeTypes.APPLICATION_M3U8) + .build(); + MediaQueueItem queueItem = mediaItemConverter.toMediaQueueItem(unconfiguredItem); + MediaInfo resolvedMediaInfo = + new MediaInfo.Builder(queueItem.getMedia().getContentId()) + .setContentType(queueItem.getMedia().getContentType()) + .setContentUrl(queueItem.getMedia().getContentUrl()) + .setStreamType(MediaInfo.STREAM_TYPE_LIVE) + .build(); + MediaQueueItem activeQueueItem = + new MediaQueueItem.Builder(resolvedMediaInfo).setItemId(1).build(); + when(mockRemoteMediaClient.getMediaQueue()).thenReturn(mockMediaQueue); + when(mockMediaQueue.getItemIds()).thenReturn(new int[] {1}); + when(mockRemoteMediaClient.getMediaStatus()).thenReturn(mockMediaStatus); + when(mockMediaStatus.getCurrentItemId()).thenReturn(1); + when(mockMediaStatus.getMediaInfo()).thenReturn(resolvedMediaInfo); + when(mockMediaStatus.getQueueItems()).thenReturn(Collections.singletonList(activeQueueItem)); + + castTimelineTracker.onMediaItemsSet( + Collections.singletonList(unconfiguredItem), new MediaQueueItem[] {activeQueueItem}); + CastTimeline castTimeline = castTimelineTracker.getCastTimeline(mockRemoteMediaClient); + + assertThat(castTimeline.getWindowCount()).isEqualTo(1); + Window window = castTimeline.getWindow(/* windowIndex= */ 0, new Window()); + assertThat(window.isLive()).isTrue(); + assertThat(window.liveConfiguration).isEqualTo(MediaItem.LiveConfiguration.UNSET); + assertThat(window.mediaItem).isEqualTo(unconfiguredItem); + } + private MediaItem createMediaItem(int uid) { return new MediaItem.Builder() .setUri("http://www.google.com/" + uid) diff --git a/libraries/cast/src/test/java/androidx/media3/cast/DefaultCastPlayerTransferCallbackTest.java b/libraries/cast/src/test/java/androidx/media3/cast/DefaultCastPlayerTransferCallbackTest.java new file mode 100644 index 00000000000..14b08c39b72 --- /dev/null +++ b/libraries/cast/src/test/java/androidx/media3/cast/DefaultCastPlayerTransferCallbackTest.java @@ -0,0 +1,99 @@ +/* + * Copyright 2026 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 androidx.media3.cast; + +import static com.google.common.truth.Truth.assertThat; + +import androidx.media3.common.MediaItem; +import androidx.media3.test.utils.FakePlayer; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.google.common.collect.ImmutableList; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** Unit tests for {@link DefaultCastPlayerTransferCallback}. */ +@RunWith(AndroidJUnit4.class) +public final class DefaultCastPlayerTransferCallbackTest { + + private FakePlayer sourcePlayer; + private FakePlayer targetPlayer; + private DefaultCastPlayerTransferCallback transferCallback; + + @Before + public void setUp() { + sourcePlayer = new FakePlayer(); + targetPlayer = new FakePlayer(); + transferCallback = new DefaultCastPlayerTransferCallback(); + } + + @Test + public void transferState_filtersItemsWithNoPlaybackUri() { + MediaItem uriItem = new MediaItem.Builder().setUri("http://uri").build(); + MediaItem noUriItem = new MediaItem.Builder().setMediaId("no-uri").build(); + sourcePlayer.setMediaItems( + ImmutableList.of(uriItem, noUriItem), /* startIndex= */ 0, /* startPositionMs= */ 0); + + transferCallback.transferState(sourcePlayer, targetPlayer); + + assertThat(targetPlayer.getMediaItemCount()).isEqualTo(1); + assertThat(targetPlayer.getMediaItemAt(0)).isEqualTo(uriItem); + assertThat(targetPlayer.getCurrentMediaItemIndex()).isEqualTo(0); + } + + @Test + public void transferState_adjustsCurrentIndexWhenCurrentItemIsFiltered() { + MediaItem uriItem = new MediaItem.Builder().setUri("http://uri").build(); + MediaItem noUriItem = new MediaItem.Builder().setMediaId("no-uri").build(); + sourcePlayer.setMediaItems( + ImmutableList.of(uriItem, noUriItem), /* startIndex= */ 1, /* startPositionMs= */ 1000); + + transferCallback.transferState(sourcePlayer, targetPlayer); + + assertThat(targetPlayer.getMediaItemCount()).isEqualTo(1); + assertThat(targetPlayer.getMediaItemAt(0)).isEqualTo(uriItem); + assertThat(targetPlayer.getCurrentMediaItemIndex()).isEqualTo(0); + assertThat(targetPlayer.getCurrentPosition()).isEqualTo(0); + } + + @Test + public void transferState_whenCurrentItemIsNotFiltered_preservesPosition() { + MediaItem uriItem = new MediaItem.Builder().setUri("http://uri").build(); + MediaItem noUriItem = new MediaItem.Builder().setMediaId("no-uri").build(); + sourcePlayer.setMediaItems( + ImmutableList.of(uriItem, noUriItem), /* startIndex= */ 0, /* startPositionMs= */ 1000); + + transferCallback.transferState(sourcePlayer, targetPlayer); + + assertThat(targetPlayer.getMediaItemCount()).isEqualTo(1); + assertThat(targetPlayer.getMediaItemAt(0)).isEqualTo(uriItem); + assertThat(targetPlayer.getCurrentMediaItemIndex()).isEqualTo(0); + assertThat(targetPlayer.getCurrentPosition()).isEqualTo(1000); + } + + @Test + public void transferState_whenAllItemsAreFiltered_setsEmptyPlaylistAndIndexUnset() { + MediaItem noUriItem1 = new MediaItem.Builder().setMediaId("no-uri-1").build(); + MediaItem noUriItem2 = new MediaItem.Builder().setMediaId("no-uri-2").build(); + sourcePlayer.setMediaItems( + ImmutableList.of(noUriItem1, noUriItem2), /* startIndex= */ 0, /* startPositionMs= */ 0); + + transferCallback.transferState(sourcePlayer, targetPlayer); + + assertThat(targetPlayer.getMediaItemCount()).isEqualTo(0); + assertThat(targetPlayer.getCurrentMediaItemIndex()).isEqualTo(0); + } +} diff --git a/libraries/cast/src/test/java/androidx/media3/cast/DefaultMediaItemConverterTest.java b/libraries/cast/src/test/java/androidx/media3/cast/DefaultMediaItemConverterTest.java index 5976b5824d5..7af275ca4ab 100644 --- a/libraries/cast/src/test/java/androidx/media3/cast/DefaultMediaItemConverterTest.java +++ b/libraries/cast/src/test/java/androidx/media3/cast/DefaultMediaItemConverterTest.java @@ -228,4 +228,50 @@ public void toMediaItem_noCustomData_fallbackWithNonUriContentIdAndNoContentUrl( DefaultMediaItemConverter converter = new DefaultMediaItemConverter(); assertThrows(IllegalArgumentException.class, () -> converter.toMediaItem(queueItem)); } + + @Test + public void toMediaQueueItem_withLiveConfiguration_setsStreamTypeLive() { + DefaultMediaItemConverter converter = new DefaultMediaItemConverter(); + MediaItem mediaItem = + new MediaItem.Builder() + .setUri("http://example.com/live.m3u8") + .setLiveConfiguration( + new MediaItem.LiveConfiguration.Builder().setTargetOffsetMs(10000).build()) + .build(); + + MediaQueueItem queueItem = converter.toMediaQueueItem(mediaItem); + + assertThat(queueItem.getMedia().getStreamType()).isEqualTo(MediaInfo.STREAM_TYPE_LIVE); + } + + @Test + public void serialize_deserialize_liveConfiguration() { + MediaItem item = + new MediaItem.Builder() + .setUri("http://example.com/live.m3u8") + .setLiveConfiguration( + new MediaItem.LiveConfiguration.Builder() + .setTargetOffsetMs(10000) + .setMinOffsetMs(5000) + .setMaxOffsetMs(20000) + .setMinPlaybackSpeed(0.9f) + .setMaxPlaybackSpeed(1.1f) + .build()) + .build(); + + DefaultMediaItemConverter converter = new DefaultMediaItemConverter(); + MediaQueueItem queueItem = converter.toMediaQueueItem(item); + MediaItem reconstructedItem = converter.toMediaItem(queueItem); + assertThat(reconstructedItem.liveConfiguration).isEqualTo(item.liveConfiguration); + } + + @Test + public void toMediaQueueItem_withoutLiveConfiguration_setsStreamTypeInvalid() { + DefaultMediaItemConverter converter = new DefaultMediaItemConverter(); + MediaItem mediaItem = new MediaItem.Builder().setUri("http://example.com/live.m3u8").build(); + + MediaQueueItem queueItem = converter.toMediaQueueItem(mediaItem); + + assertThat(queueItem.getMedia().getStreamType()).isEqualTo(MediaInfo.STREAM_TYPE_INVALID); + } } diff --git a/libraries/common/src/main/java/androidx/media3/common/AdPlaybackState.java b/libraries/common/src/main/java/androidx/media3/common/AdPlaybackState.java index 20dc7f81756..299baaeaa5c 100644 --- a/libraries/common/src/main/java/androidx/media3/common/AdPlaybackState.java +++ b/libraries/common/src/main/java/androidx/media3/common/AdPlaybackState.java @@ -215,7 +215,7 @@ public boolean hasUnplayedAds() { } /** - * Returns whether this is a is a placeholder ad group. + * Returns whether this is a placeholder ad group. * * @param isServerSideInserted Whether the postroll placeholder must be server-side inserted. * @return true only if this ad group has a matching {@link #isServerSideInserted} flag. @@ -1795,6 +1795,8 @@ public String toString() { for (int i = 0; i < adGroups.length; i++) { sb.append("adGroup(timeUs="); sb.append(adGroups[i].timeUs); + sb.append(", contentResumeOffsetUs="); + sb.append(adGroups[i].contentResumeOffsetUs); sb.append(", ads=["); for (int j = 0; j < adGroups[i].states.length; j++) { sb.append("ad(state="); diff --git a/libraries/common/src/main/java/androidx/media3/common/MediaLibraryInfo.java b/libraries/common/src/main/java/androidx/media3/common/MediaLibraryInfo.java index 5967d221a58..fac86ad5ef6 100644 --- a/libraries/common/src/main/java/androidx/media3/common/MediaLibraryInfo.java +++ b/libraries/common/src/main/java/androidx/media3/common/MediaLibraryInfo.java @@ -29,11 +29,11 @@ public final class MediaLibraryInfo { /** The version of the library expressed as a string, for example "1.2.3" or "1.2.0-beta01". */ // Intentionally hardcoded. Do not derive from other constants (e.g. VERSION_INT) or vice versa. - public static final String VERSION = "1.11.0-alpha01"; + public static final String VERSION = "1.11.1"; /** The version of the library expressed as {@code TAG + "/" + VERSION}. */ // Intentionally hardcoded. Do not derive from other constants (e.g. VERSION) or vice versa. - public static final String VERSION_SLASHY = "AndroidXMedia3/1.11.0-alpha01"; + public static final String VERSION_SLASHY = "AndroidXMedia3/1.11.1"; /** * The version of the library expressed as an integer, for example 1002003300. @@ -47,7 +47,7 @@ public final class MediaLibraryInfo { * (123-045-006-3-00). */ // Intentionally hardcoded. Do not derive from other constants (e.g. VERSION) or vice versa. - public static final int VERSION_INT = 1_011_000_0_01; + public static final int VERSION_INT = 1_011_001_3_00; /** Whether the library was compiled with {@link TraceUtil} trace enabled. */ public static final boolean TRACE_ENABLED = true; diff --git a/libraries/common/src/main/java/androidx/media3/common/SimpleBasePlayer.java b/libraries/common/src/main/java/androidx/media3/common/SimpleBasePlayer.java index b409bf9f901..02175e8d145 100644 --- a/libraries/common/src/main/java/androidx/media3/common/SimpleBasePlayer.java +++ b/libraries/common/src/main/java/androidx/media3/common/SimpleBasePlayer.java @@ -3632,7 +3632,7 @@ protected ListenableFuture handleSeek( } /** - * Throws an {@link IllegalStateException} if the the thread calling this method does not match + * Throws an {@link IllegalStateException} if the thread calling this method does not match * the {@link Looper} thread that was specified upon construction of this instance. * *

Subclasses can use this method to verify that their own defined methods are also accessed by diff --git a/libraries/common/src/main/java/androidx/media3/common/util/CodecSpecificDataUtil.java b/libraries/common/src/main/java/androidx/media3/common/util/CodecSpecificDataUtil.java index 6e4e83c4e81..f07ea4f79d0 100644 --- a/libraries/common/src/main/java/androidx/media3/common/util/CodecSpecificDataUtil.java +++ b/libraries/common/src/main/java/androidx/media3/common/util/CodecSpecificDataUtil.java @@ -2363,5 +2363,71 @@ public static int h263ConstToLevelNumber(int levelConst) { } } + // Expected magic bytes for HAGC (ST 2094-50) metadata in AV1 OBU or HEVC SEI. + private static final byte[] expectedHagcPayloadPrefix = { + // itu_t_t35_country_code == 0xB5 + (byte) 0xB5, + // itu_t_t35_terminal_provider_code == 0x0090 + (byte) 0x00, + (byte) 0x90, + // itu_t_t35_terminal_provider_oriented_code == 0x0001 + (byte) 0x00, + (byte) 0x01, + }; + + /** + * Returns whether the given {@code data} contains HAGC (ST 2094-50) ITU-T T.35 metadata. + * + * @param data The payload data. + * @param length The length of the payload data. + */ + public static boolean isHagcMetadata(byte[] data, int length) { + if (length < expectedHagcPayloadPrefix.length) { + return false; + } + for (int i = 0; i < expectedHagcPayloadPrefix.length; i++) { + if (data[i] != expectedHagcPayloadPrefix[i]) { + return false; + } + } + return true; + } + + /** + * Returns whether the given {@link ByteBuffer} contains HAGC (ST 2094-50) ITU-T T.35 metadata, + * without consuming any bytes. + * + * @param buffer The payload data. + */ + public static boolean isHagcMetadata(ByteBuffer buffer) { + if (buffer.remaining() < expectedHagcPayloadPrefix.length) { + return false; + } + int pos = buffer.position(); + for (int i = 0; i < expectedHagcPayloadPrefix.length; i++) { + if (buffer.get(pos + i) != expectedHagcPayloadPrefix[i]) { + return false; + } + } + return true; + } + + /** + * Returns whether the given {@link Format} represents an HAGC (ST 2094-50) metadata track. + * + * @param format The format of the track. + */ + public static boolean isHagcTrack(Format format) { + if (!Objects.equals(format.sampleMimeType, MimeTypes.APPLICATION_ITUT_T35)) { + return false; + } + for (byte[] initData : format.initializationData) { + if (isHagcMetadata(initData, initData.length)) { + return true; + } + } + return false; + } + private CodecSpecificDataUtil() {} } diff --git a/libraries/common/src/main/java/androidx/media3/common/util/GlUtil.java b/libraries/common/src/main/java/androidx/media3/common/util/GlUtil.java index 7a2d06c5537..e733576d82f 100644 --- a/libraries/common/src/main/java/androidx/media3/common/util/GlUtil.java +++ b/libraries/common/src/main/java/androidx/media3/common/util/GlUtil.java @@ -615,10 +615,18 @@ private static void assertValidTextureSize(int width, int height) throws GlExcep * #createFocusedPlaceholderEglSurface}. */ public static void clearFocusedBuffers() throws GlException { - GLES20.glClearColor(/* red= */ 0, /* green= */ 0, /* blue= */ 0, /* alpha= */ 0); - GLES20.glClearDepthf(1.0f); - GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT); - GlUtil.checkGlError(); + clearFocusedBuffersInternal(/* r= */ 0, /* g= */ 0, /* b= */ 0, /* a= */ 0); + } + + /** + * Fills the pixels in the current output render target buffers with (r=0, g=0, b=0, a=1). + * + *

Buffers can be focused using {@link #focusEglSurface} and {@link + * #focusFramebufferUsingCurrentContext}, {@link #focusFramebuffer}, and {@link + * #createFocusedPlaceholderEglSurface}. + */ + public static void clearFocusedBuffersOpaque() throws GlException { + clearFocusedBuffersInternal(/* r= */ 0, /* g= */ 0, /* b= */ 0, /* a= */ 1); } /** @@ -1151,4 +1159,12 @@ && getContextMajorVersion() >= 3) { checkGlError(); } } + + private static void clearFocusedBuffersInternal(float r, float g, float b, float a) + throws GlException { + GLES20.glClearColor(r, g, b, a); + GLES20.glClearDepthf(1.0f); + GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT); + GlUtil.checkGlError(); + } } diff --git a/libraries/common/src/main/java/androidx/media3/common/util/MediaFormatUtil.java b/libraries/common/src/main/java/androidx/media3/common/util/MediaFormatUtil.java index 14e7a14e496..8f1cc324b06 100644 --- a/libraries/common/src/main/java/androidx/media3/common/util/MediaFormatUtil.java +++ b/libraries/common/src/main/java/androidx/media3/common/util/MediaFormatUtil.java @@ -85,9 +85,7 @@ public static Format createFormatFromMediaFormat(MediaFormat mediaFormat) { getInteger( mediaFormat, MediaFormat.KEY_BIT_RATE, /* defaultValue= */ Format.NO_VALUE)) .setCodecs(getCodecString(mediaFormat)) - .setFrameRate( - getFloatFromIntOrFloat( - mediaFormat, MediaFormat.KEY_FRAME_RATE, /* defaultValue= */ Format.NO_VALUE)) + .setFrameRate(getFrameRate(mediaFormat)) .setWidth( getInteger(mediaFormat, MediaFormat.KEY_WIDTH, /* defaultValue= */ Format.NO_VALUE)) .setHeight( @@ -435,6 +433,20 @@ private static String getCodecString(MediaFormat mediaFormat) { } } + /** Returns the frame rate from the given {@link MediaFormat}. */ + @SuppressLint("InlinedApi") // Inlined MediaFormat.KEY_FRAME_RATE. + private static float getFrameRate(MediaFormat mediaFormat) { + float frameRate = + getFloatFromIntOrFloat( + mediaFormat, MediaFormat.KEY_FRAME_RATE, /* defaultValue= */ Format.NO_VALUE); + // Some devices may produce non-positive frame rates from MediaFormat. + // See b/493371202 for more information. + if (frameRate <= 0f) { + frameRate = Format.NO_VALUE; + } + return frameRate; + } + /** Returns the ratio between a pixel's width and height for a {@link MediaFormat}. */ // Inlined MediaFormat.KEY_PIXEL_ASPECT_RATIO_WIDTH and MediaFormat.KEY_PIXEL_ASPECT_RATIO_HEIGHT. @SuppressLint("InlinedApi") diff --git a/libraries/common/src/main/java/androidx/media3/common/util/ThrowingRunnable.java b/libraries/common/src/main/java/androidx/media3/common/util/ThrowingRunnable.java new file mode 100644 index 00000000000..c1110fd08d6 --- /dev/null +++ b/libraries/common/src/main/java/androidx/media3/common/util/ThrowingRunnable.java @@ -0,0 +1,29 @@ +/* + * Copyright 2026 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 androidx.media3.common.util; + +/** + * A {@link Runnable}-like interface that allows throwing checked exceptions. + * + * @param The type of exception that the operation may throw. + */ +@UnstableApi +@FunctionalInterface +public interface ThrowingRunnable { + + /** Runs the operation. */ + void run() throws E; +} diff --git a/libraries/common/src/main/java/androidx/media3/common/util/Util.java b/libraries/common/src/main/java/androidx/media3/common/util/Util.java index 1456fdef55e..aa355920fa2 100644 --- a/libraries/common/src/main/java/androidx/media3/common/util/Util.java +++ b/libraries/common/src/main/java/androidx/media3/common/util/Util.java @@ -234,6 +234,12 @@ public static byte[] toByteArray(InputStream inputStream) throws IOException { return ByteStreams.toByteArray(inputStream); } + /** Converts a single integer into an equivalent 4-byte array in big-endian order. */ + @UnstableApi + public static byte[] toByteArray(int value) { + return Ints.toByteArray(value); + } + /** * Converts an array of integers into an equivalent byte array. * diff --git a/libraries/common/src/main/java/androidx/media3/common/video/FrameProcessor.java b/libraries/common/src/main/java/androidx/media3/common/video/FrameProcessor.java index a20a98f7b0a..963706ca932 100644 --- a/libraries/common/src/main/java/androidx/media3/common/video/FrameProcessor.java +++ b/libraries/common/src/main/java/androidx/media3/common/video/FrameProcessor.java @@ -57,9 +57,6 @@ interface Factory { /** * Creates a {@link FrameProcessor} that sends frames to the given {@link FrameWriter}. * - *

The created {@link FrameProcessor} does not {@linkplain FrameWriter#close() close} the - * passed in {@link FrameWriter}. - * * @param output The {@link FrameWriter} to which the {@link FrameProcessor} outputs. * @param listenerExecutor The {@link Executor} on which the {@code listener} is invoked. * @param listener A {@link Listener} to be invoked for {@link FrameProcessor} events. diff --git a/libraries/common/src/test/java/androidx/media3/common/util/CodecSpecificDataUtilTest.java b/libraries/common/src/test/java/androidx/media3/common/util/CodecSpecificDataUtilTest.java index a46c045586e..d8e24d776b9 100644 --- a/libraries/common/src/test/java/androidx/media3/common/util/CodecSpecificDataUtilTest.java +++ b/libraries/common/src/test/java/androidx/media3/common/util/CodecSpecificDataUtilTest.java @@ -28,6 +28,8 @@ import androidx.media3.common.MimeTypes; import androidx.media3.test.utils.TestUtil; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.google.common.collect.ImmutableList; +import java.nio.ByteBuffer; import org.junit.Test; import org.junit.runner.RunWith; @@ -368,6 +370,59 @@ public void getMediaCodecProfileAndLevel_mvHevcWithNoMatchingMediaCodecConstant_ .isEqualTo(MimeTypes.VIDEO_AV1); } + @Test + public void isHagcMetadata_withHagcPrefix_returnsTrue() { + byte[] hagcBytes = + TestUtil.createByteArray(0xB5, 0x00, 0x90, 0x00, 0x01, 0x00, 0x00, 0x01, 0x02, 0x03); + assertThat(CodecSpecificDataUtil.isHagcMetadata(hagcBytes, hagcBytes.length)).isTrue(); + + ByteBuffer buffer = ByteBuffer.wrap(hagcBytes); + assertThat(CodecSpecificDataUtil.isHagcMetadata(buffer)).isTrue(); + } + + @Test + public void isHagcMetadata_withShortBuffer_returnsFalse() { + byte[] shortBytes = TestUtil.createByteArray(0xB5, 0x00, 0x90); + assertThat(CodecSpecificDataUtil.isHagcMetadata(shortBytes, shortBytes.length)).isFalse(); + + ByteBuffer buffer = ByteBuffer.wrap(shortBytes); + assertThat(CodecSpecificDataUtil.isHagcMetadata(buffer)).isFalse(); + } + + @Test + public void isHagcTrack_withValidHagc_returnsTrue() { + byte[] hagcBytes = + TestUtil.createByteArray(0xB5, 0x00, 0x90, 0x00, 0x01, 0x00, 0x00, 0x01, 0x02, 0x03); + Format format = + new Format.Builder() + .setSampleMimeType(MimeTypes.APPLICATION_ITUT_T35) + .setInitializationData(ImmutableList.of(hagcBytes)) + .build(); + assertThat(CodecSpecificDataUtil.isHagcTrack(format)).isTrue(); + } + + @Test + public void isHagcTrack_withoutHagc_returnsFalse() { + byte[] badBytes = TestUtil.createByteArray(0x00, 0x01, 0x02); + Format formatWithBadBytes = + new Format.Builder() + .setSampleMimeType(MimeTypes.APPLICATION_ITUT_T35) + .setInitializationData(ImmutableList.of(badBytes)) + .build(); + assertThat(CodecSpecificDataUtil.isHagcTrack(formatWithBadBytes)).isFalse(); + + Format formatWithoutInitData = + new Format.Builder().setSampleMimeType(MimeTypes.APPLICATION_ITUT_T35).build(); + assertThat(CodecSpecificDataUtil.isHagcTrack(formatWithoutInitData)).isFalse(); + + Format formatWithWrongMimeType = + new Format.Builder() + .setSampleMimeType(MimeTypes.VIDEO_H265) + .setInitializationData(ImmutableList.of(badBytes)) + .build(); + assertThat(CodecSpecificDataUtil.isHagcTrack(formatWithWrongMimeType)).isFalse(); + } + private static void assertCodecProfileAndLevelForCodecsString( String sampleMimeType, String codecs, int profile, int level) { Format format = diff --git a/libraries/common/src/test/java/androidx/media3/common/util/MediaFormatUtilTest.java b/libraries/common/src/test/java/androidx/media3/common/util/MediaFormatUtilTest.java index fb89fef13f5..23f28eea9c2 100644 --- a/libraries/common/src/test/java/androidx/media3/common/util/MediaFormatUtilTest.java +++ b/libraries/common/src/test/java/androidx/media3/common/util/MediaFormatUtilTest.java @@ -58,6 +58,26 @@ public void createFormatFromMediaFormat_withEmptyMap_generatesExpectedFormat() { assertThat(format.initializationData).isEmpty(); } + @Test + public void createFormatFromMediaFormat_withZeroFrameRate_setsFrameRateToNoValue() { + MediaFormat mediaFormat = new MediaFormat(); + mediaFormat.setFloat(MediaFormat.KEY_FRAME_RATE, 0.0f); + + Format format = MediaFormatUtil.createFormatFromMediaFormat(mediaFormat); + + assertThat(format.frameRate).isEqualTo(Format.NO_VALUE); + } + + @Test + public void createFormatFromMediaFormat_withNegativeFrameRate_setsFrameRateToNoValue() { + MediaFormat mediaFormat = new MediaFormat(); + mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, -10); + + Format format = MediaFormatUtil.createFormatFromMediaFormat(mediaFormat); + + assertThat(format.frameRate).isEqualTo(Format.NO_VALUE); + } + @Test public void createFormatFromMediaFormat_withContradictoryChannelMask_dropsChannelMask() { MediaFormat mediaFormat = new MediaFormat(); diff --git a/libraries/datasource_ktor/src/androidTest/java/androidx/media3/datasource/ktor/KtorDataSourceTest.kt b/libraries/datasource_ktor/src/androidTest/java/androidx/media3/datasource/ktor/KtorDataSourceTest.kt index 2908e4ac61b..a99a5757ddb 100644 --- a/libraries/datasource_ktor/src/androidTest/java/androidx/media3/datasource/ktor/KtorDataSourceTest.kt +++ b/libraries/datasource_ktor/src/androidTest/java/androidx/media3/datasource/ktor/KtorDataSourceTest.kt @@ -15,6 +15,7 @@ */ package androidx.media3.datasource.ktor +import android.os.SystemClock import androidx.media3.datasource.DataSource import androidx.media3.datasource.DataSpec import androidx.media3.datasource.HttpDataSource @@ -341,6 +342,46 @@ class KtorDataSourceTest( assertThat(transferEndCalled).isTrue() } + @Test + fun open_doesNotWaitForResponseBody() { + val testData = "a".repeat(100) + val bodyDelayMs = 800L + val mockWebServer = MockWebServer() + mockWebServer.enqueue( + MockResponse() + .setResponseCode(200) + .setHeader("Content-Length", testData.length) + .setBody(testData) + .setBodyDelay(bodyDelayMs, TimeUnit.MILLISECONDS) + ) + + val httpClient = + HttpClient(httpClientEngineFactory) { + install(HttpTimeout) { + requestTimeoutMillis = 3000 + connectTimeoutMillis = 3000 + socketTimeoutMillis = 3000 + } + } + val dataSource = KtorDataSource.Factory(httpClient).createDataSource() + val dataSpec = DataSpec.Builder().setUri(mockWebServer.url("/test-path").toString()).build() + + val startTimeMs = SystemClock.elapsedRealtime() + assertThat(dataSource.open(dataSpec)).isEqualTo(testData.length.toLong()) + val openDurationMs = SystemClock.elapsedRealtime() - startTimeMs + + // Verify that open() completed without waiting for the delayed response body. + assertThat(openDurationMs).isLessThan(400L) + + val buffer = ByteArray(10) + val bytesRead = dataSource.read(buffer, 0, buffer.size) + val readDurationMs = SystemClock.elapsedRealtime() - startTimeMs + assertThat(bytesRead).isEqualTo(10) + assertThat(readDurationMs).isGreaterThan(bodyDelayMs) + + dataSource.close() + } + // TODO: b/503301819 - Remove this when the OkHttp engine works without it. private fun HttpClientConfig<*>.configureTimeout() { install(HttpTimeout) { diff --git a/libraries/datasource_ktor/src/main/java/androidx/media3/datasource/ktor/KtorDataSource.kt b/libraries/datasource_ktor/src/main/java/androidx/media3/datasource/ktor/KtorDataSource.kt index 39da36b5484..a56c3a34f01 100644 --- a/libraries/datasource_ktor/src/main/java/androidx/media3/datasource/ktor/KtorDataSource.kt +++ b/libraries/datasource_ktor/src/main/java/androidx/media3/datasource/ktor/KtorDataSource.kt @@ -154,7 +154,7 @@ private constructor( setBody(dataSpec.httpBody!!) } } - .execute() + .body() channel = httpResponse.bodyAsChannel() } this.response = httpResponse diff --git a/libraries/decoder_av1/proguard-rules.txt b/libraries/decoder_av1/proguard-rules.txt index d639ccdd40d..9cef13cfdf9 100644 --- a/libraries/decoder_av1/proguard-rules.txt +++ b/libraries/decoder_av1/proguard-rules.txt @@ -1,7 +1,7 @@ # Proguard rules specific to the AV1 extension. # This prevents the names of native methods from being obfuscated. --keepclasseswithmembernames class * { +-keep,includedescriptorclasses class androidx.media3.decoder.av1.** { native ; } diff --git a/libraries/decoder_av1/src/androidTest/java/androidx/media3/decoder/av1/Av1PlaybackTest.kt b/libraries/decoder_av1/src/androidTest/java/androidx/media3/decoder/av1/Av1PlaybackTest.kt index 4eef80a01bf..2519a35d644 100644 --- a/libraries/decoder_av1/src/androidTest/java/androidx/media3/decoder/av1/Av1PlaybackTest.kt +++ b/libraries/decoder_av1/src/androidTest/java/androidx/media3/decoder/av1/Av1PlaybackTest.kt @@ -16,8 +16,6 @@ package androidx.media3.decoder.av1 import android.content.Context -import android.graphics.SurfaceTexture -import android.view.Surface import androidx.media3.common.MediaItem import androidx.media3.common.Player import androidx.media3.exoplayer.ExoPlayer @@ -25,12 +23,9 @@ import androidx.media3.exoplayer.RenderersFactory import androidx.media3.exoplayer.video.VideoDecoderGLSurfaceView import androidx.media3.test.utils.awaitPlaybackState import androidx.test.core.app.ApplicationProvider.getApplicationContext -import androidx.test.filters.SdkSuppress +import androidx.test.ext.junit.runners.AndroidJUnit4 import com.google.common.truth.Truth.assertThat import com.google.common.truth.Truth.assertWithMessage -import com.google.testing.junit.testparameterinjector.KotlinTestParameters.namedTestValues -import com.google.testing.junit.testparameterinjector.TestParameter -import com.google.testing.junit.testparameterinjector.TestParameterInjector import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.runBlocking import org.junit.Before @@ -38,7 +33,7 @@ import org.junit.Test import org.junit.runner.RunWith /** Playback tests using [Libdav1dVideoRenderer]. */ -@RunWith(TestParameterInjector::class) +@RunWith(AndroidJUnit4::class) class Av1PlaybackTest { @Before @@ -47,67 +42,37 @@ class Av1PlaybackTest { } @Test - fun playback_rendersToGlSurfaceView( - @TestParameter - videoUri: String = - namedTestValues("DEFAULT" to SAMPLE_AV1_URI, "MONOCHROME" to SAMPLE_AV1_MONO_URI) - ) = + fun basicPlayback() = runBlocking(Dispatchers.Main) { - runPlaybackTest(videoUri) { player -> - player.setVideoSurfaceView(VideoDecoderGLSurfaceView(getApplicationContext())) + val context = getApplicationContext() + val renderersFactory = RenderersFactory { eventHandler, videoRendererEventListener, _, _, _ -> + arrayOf( + Libdav1dVideoRenderer( + /* allowedJoiningTimeMs= */ 0, + eventHandler, + videoRendererEventListener, + /* maxDroppedFramesToNotify= */ -1, + ) + ) } - } + val player = ExoPlayer.Builder(context).setRenderersFactory(renderersFactory).build() + player.setVideoSurfaceView(VideoDecoderGLSurfaceView(context)) + player.setMediaItem(MediaItem.fromUri(SAMPLE_AV1_URI)) + player.prepare() + player.play() - // Rendering using ANativeWindow_lock is only reliably supported on API 29+. - @Test - @SdkSuppress(minSdkVersion = 29) - fun playback_rendersToSurface( - @TestParameter - videoUri: String = - namedTestValues("DEFAULT" to SAMPLE_AV1_URI, "MONOCHROME" to SAMPLE_AV1_MONO_URI) - ) = - runBlocking(Dispatchers.Main) { - val surfaceTexture = SurfaceTexture(/* texName= */ 0) - val surface = Surface(surfaceTexture) - try { - runPlaybackTest(videoUri) { player -> player.setVideoSurface(surface) } - } finally { - surface.release() - surfaceTexture.release() - } - } + val renderedOutputBufferCount = + try { + player.awaitPlaybackState(Player.STATE_ENDED) + player.videoDecoderCounters?.renderedOutputBufferCount ?: 0 + } finally { + player.release() + } - private suspend fun runPlaybackTest(videoUri: String, setSurfaceAction: (ExoPlayer) -> Unit) { - val context = getApplicationContext() - val renderersFactory = RenderersFactory { eventHandler, videoRendererEventListener, _, _, _ -> - arrayOf( - Libdav1dVideoRenderer( - /* allowedJoiningTimeMs= */ 0, - eventHandler, - videoRendererEventListener, - /* maxDroppedFramesToNotify= */ -1, - ) - ) + assertThat(renderedOutputBufferCount).isAtLeast(1) } - val player = ExoPlayer.Builder(context).setRenderersFactory(renderersFactory).build() - setSurfaceAction(player) - player.setMediaItem(MediaItem.fromUri(videoUri)) - player.prepare() - player.play() - - val renderedOutputBufferCount = - try { - player.awaitPlaybackState(Player.STATE_ENDED) - player.videoDecoderCounters?.renderedOutputBufferCount ?: 0 - } finally { - player.release() - } - - assertThat(renderedOutputBufferCount).isAtLeast(1) - } companion object { private const val SAMPLE_AV1_URI = "asset:///media/mp4/sample_av1.mp4" - private const val SAMPLE_AV1_MONO_URI = "asset:///media/mp4/sample_av1_mono.mp4" } } diff --git a/libraries/decoder_av1/src/main/jni/CMakeLists.txt b/libraries/decoder_av1/src/main/jni/CMakeLists.txt index e894e24c005..49a91cd6086 100644 --- a/libraries/decoder_av1/src/main/jni/CMakeLists.txt +++ b/libraries/decoder_av1/src/main/jni/CMakeLists.txt @@ -55,6 +55,10 @@ add_library(dav1dJNI cpu_info.cc cpu_info.h) +set_target_properties(dav1dJNI PROPERTIES + CXX_VISIBILITY_PRESET hidden + VISIBILITY_INLINES_HIDDEN ON) + # Locate NDK log library. find_library(android_log_lib log) diff --git a/libraries/decoder_av1/src/main/jni/dav1d_jni.cc b/libraries/decoder_av1/src/main/jni/dav1d_jni.cc index f1899e80ec2..c48e81974ff 100644 --- a/libraries/decoder_av1/src/main/jni/dav1d_jni.cc +++ b/libraries/decoder_av1/src/main/jni/dav1d_jni.cc @@ -57,33 +57,6 @@ #define LOG_TAG "dav1d_jni" #define LOGE(...) \ ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)) - -#define DECODER_FUNC(RETURN_TYPE, NAME, ...) \ - extern "C" { \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_av1_Dav1dDecoder_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__); \ - } \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_av1_Dav1dDecoder_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__) - -// If ANDROID_NATIVE_LIB_MERGING is set, rename JNI_OnLoad to -// JNI_OnLoad_libdav1dJNI. The suffix has to be the same as "lib" -// where is the name of the android_jni_library target. This lets -// apps merge native libraries and reduce the binary size. See go/android_onelib -// for details. -#ifdef ANDROID_NATIVE_LIB_MERGING -jint JNI_OnLoad_libdav1dJNI -#else -jint JNI_OnLoad -#endif - (JavaVM* vm, void* reserved) { - JNIEnv* env; - if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { - return -1; - } - return JNI_VERSION_1_6; -} - namespace { // YUV plane indices. @@ -124,9 +97,6 @@ const int kDav1dThreadCountPerformanceCores = -1; const int kDav1dThreadCountExperimental = -2; // LINT.ThenChange(../java/androidx/media3/decoder/av1/Libdav1dVideoRenderer.java) -// Monochrome planes fill value -const int kMidGray = 128; - // Status codes specific to the JNI wrapper code. enum JniStatusCode { kJniStatusOk = 0, @@ -340,20 +310,8 @@ void CopyFrameToDataBuffer(const Dav1dPicture* dav1d_picture, jbyte* data) { uint64_t planeHeight = (plane_index == kPlaneY) ? dav1d_picture->p.h : ((dav1d_picture->p.h + 1) / 2); - bool is_monochrome = dav1d_picture->p.layout == DAV1D_PIXEL_LAYOUT_I400; - int stride = dav1d_picture->stride[stride_index]; - if (is_monochrome && plane_index != kPlaneY) { - stride = (dav1d_picture->stride[kPlaneY] + 1) / 2; - } - uint64_t length = stride * planeHeight; - if (length > 0) { - // Monochrome plane pointers are NULL. Fill with a neutral value (128). - if (dav1d_picture->data[plane_index] != nullptr) { - memcpy(data, dav1d_picture->data[plane_index], length); - } else { - memset(data, kMidGray, length); - } - } + uint64_t length = dav1d_picture->stride[stride_index] * planeHeight; + memcpy(data, dav1d_picture->data[plane_index], length); data += length; } } @@ -369,14 +327,6 @@ void CopyPlane(const uint8_t* source, int source_stride, uint8_t* destination, } } -void FillPlane(const uint8_t value, uint8_t* destination, - int destination_stride, int width, int height) { - while (height--) { - std::memset(destination, value, width); - destination += destination_stride; - } -} - constexpr int GetColorSpace(Dav1dColorPrimaries primary) { switch (primary) { case DAV1D_COLOR_PRI_BT601: @@ -524,8 +474,8 @@ void CleanUpAllocatorData(jlong jContext, JNIEnv* env) { } } // namespace -DECODER_FUNC(jlong, dav1dInit, jint threads, jint max_frame_delay, - jboolean use_custom_allocator, jint num_input_buffers) { +jlong dav1dInit(JNIEnv* env, jobject thiz, jint threads, jint max_frame_delay, + jboolean use_custom_allocator, jint num_input_buffers) { JniContext* context = new (std::nothrow) JniContext(); if (context == nullptr) { return kStatusError; @@ -689,7 +639,7 @@ DECODER_FUNC(jlong, dav1dInit, jint threads, jint max_frame_delay, return reinterpret_cast(context); } -DECODER_FUNC(void, dav1dClose, jlong jContext) { +void dav1dClose(JNIEnv* env, jobject thiz, jlong jContext) { if (jContext == kStatusError) { return; } @@ -729,9 +679,10 @@ DECODER_FUNC(void, dav1dClose, jlong jContext) { delete context; } -DECODER_FUNC(jint, dav1dDecode, jlong jContext, jobject jInputBuffer, - jint bufferIndex, jint offset, jint length, jboolean decodeOnly, - jint flags, jlong timeUs, jint outputMode) { +jint dav1dDecode(JNIEnv* env, jobject thiz, jlong jContext, + jobject jInputBuffer, jint bufferIndex, jint offset, + jint length, jboolean decodeOnly, jint flags, jlong timeUs, + jint outputMode) { if (jContext == kStatusError) { return kStatusError; } @@ -815,7 +766,8 @@ DECODER_FUNC(jint, dav1dDecode, jlong jContext, jobject jInputBuffer, return kStatusOk; } -DECODER_FUNC(jint, dav1dGetFrame, jlong jContext, jobject jOutputBuffer) { +jint dav1dGetFrame(JNIEnv* env, jobject thiz, jlong jContext, + jobject jOutputBuffer) { if (jContext == kStatusError) { return kStatusError; } @@ -870,11 +822,6 @@ DECODER_FUNC(jint, dav1dGetFrame, jlong jContext, jobject jOutputBuffer) { } if (returned_user_data->output_mode == kOutputModeYuv) { jboolean init_result; - int y_stride = dav1d_picture->stride[kPlaneY]; - int uv_stride = dav1d_picture->stride[kPlaneU]; - if (dav1d_picture->p.layout == DAV1D_PIXEL_LAYOUT_I400) { - uv_stride = (y_stride + 1) / 2; - } if (context->use_custom_allocator) { PictureAllocatorData* allocator_data = reinterpret_cast( @@ -884,13 +831,15 @@ DECODER_FUNC(jint, dav1dGetFrame, jlong jContext, jobject jOutputBuffer) { init_result = env->CallBooleanMethod( jOutputBuffer, context->init_for_offset_frames_method, allocator_data->offset, dav1d_picture->p.w, dav1d_picture->p.h, - y_stride, uv_stride, GetColorSpace(dav1d_picture->seq_hdr->pri), + dav1d_picture->stride[kPlaneY], dav1d_picture->stride[kPlaneU], + GetColorSpace(dav1d_picture->seq_hdr->pri), allocator_data->aligned_height); CleanUpAllocatorData(jContext, env); } else { init_result = env->CallBooleanMethod( jOutputBuffer, context->init_for_yuv_frame_method, dav1d_picture->p.w, - dav1d_picture->p.h, y_stride, uv_stride, + dav1d_picture->p.h, dav1d_picture->stride[kPlaneY], + dav1d_picture->stride[kPlaneU], GetColorSpace(dav1d_picture->seq_hdr->pri)); } if (!init_result) { @@ -943,8 +892,8 @@ DECODER_FUNC(jint, dav1dGetFrame, jlong jContext, jobject jOutputBuffer) { return kStatusOk; } -DECODER_FUNC(jint, dav1dRenderFrame, jlong jContext, jobject jSurface, - jobject jOutputBuffer) { +jint dav1dRenderFrame(JNIEnv* env, jobject thiz, jlong jContext, + jobject jSurface, jobject jOutputBuffer) { if (jContext == kStatusError) { LOGE("Failed to render frame. jContext is error."); return kStatusError; @@ -1023,45 +972,37 @@ DECODER_FUNC(jint, dav1dRenderFrame, jlong jContext, jobject jSurface, reinterpret_cast(native_window_buffer.bits), native_window_buffer.stride, y_copy_width, y_copy_height); - const int32_t y_plane_size = + const int y_plane_size = native_window_buffer.stride * native_window_buffer.height; - const int32_t native_window_buffer_uv_stride = + const int32_t native_window_buffer_uv_height = + (native_window_buffer.height + 1) / 2; + const int native_window_buffer_uv_stride = AlignTo16(native_window_buffer.stride / 2); - const int32_t uv_plane_height = (native_window_buffer.height + 1) / 2; - const int32_t uv_plane_size = - uv_plane_height * native_window_buffer_uv_stride; - - uint8_t* uv_base_ptr = - reinterpret_cast(native_window_buffer.bits) + y_plane_size; - // In YV12 format, V plane comes before U plane. - uint8_t* v_dest_ptr = uv_base_ptr; - uint8_t* u_dest_ptr = uv_base_ptr + uv_plane_size; - - const int32_t uv_copy_height = (y_copy_height + 1) / 2; - const int32_t uv_copy_width = (y_copy_width + 1) / 2; - - // Handle monochrome videos - const Dav1dSequenceHeader* header = dav1d_picture->seq_hdr; - if (header->monochrome) { - // V Plane - // Set to 128 to make it gray - FillPlane(kMidGray, v_dest_ptr, native_window_buffer_uv_stride, - uv_copy_width, uv_copy_height); - // U Plane - FillPlane(kMidGray, u_dest_ptr, native_window_buffer_uv_stride, - uv_copy_width, uv_copy_height); - } else { - // V plane - // Since the format for ANativeWindow is YV12, V plane is being processed - // before U plane. - CopyPlane(reinterpret_cast(dav1d_picture->data[kPlaneV]), - dav1d_picture->stride[kPlaneU], v_dest_ptr, - native_window_buffer_uv_stride, uv_copy_width, uv_copy_height); - // U plane - CopyPlane(reinterpret_cast(dav1d_picture->data[kPlaneU]), - dav1d_picture->stride[kPlaneU], u_dest_ptr, - native_window_buffer_uv_stride, uv_copy_width, uv_copy_height); - } + + // UV planes + const int uv_copy_height = (y_copy_height + 1) / 2; + const int v_plane_size = + native_window_buffer_uv_height * native_window_buffer_uv_stride; + + const int uv_copy_width = (y_copy_width + 1) / 2; + + // TODO(b/140606738): Handle monochrome videos. + // V plane + // Since the format for ANativeWindow is YV12, V plane is being processed + // before U plane. + CopyPlane( + reinterpret_cast(dav1d_picture->data[kPlaneV]), + dav1d_picture->stride[kPlaneU], + reinterpret_cast(native_window_buffer.bits) + y_plane_size, + native_window_buffer_uv_stride, uv_copy_width, uv_copy_height); + + // U plane + CopyPlane(reinterpret_cast(dav1d_picture->data[kPlaneU]), + dav1d_picture->stride[kPlaneU], + reinterpret_cast(native_window_buffer.bits) + + y_plane_size + v_plane_size, + native_window_buffer_uv_stride, uv_copy_width, uv_copy_height); + if (ANativeWindow_unlockAndPost(context->native_window)) { context->jni_status_code = kJniStatusANativeWindowError; LOGE("Failed to unlock and post native window."); @@ -1070,7 +1011,8 @@ DECODER_FUNC(jint, dav1dRenderFrame, jlong jContext, jobject jSurface, return kStatusOk; } -DECODER_FUNC(void, dav1dReleaseFrame, jlong jContext, jobject jOutputBuffer) { +void dav1dReleaseFrame(JNIEnv* env, jobject thiz, jlong jContext, + jobject jOutputBuffer) { if (jContext == kStatusError) { return; } @@ -1091,7 +1033,7 @@ DECODER_FUNC(void, dav1dReleaseFrame, jlong jContext, jobject jOutputBuffer) { } } -DECODER_FUNC(jstring, dav1dGetErrorMessage, jlong jContext) { +jstring dav1dGetErrorMessage(JNIEnv* env, jobject thiz, jlong jContext) { if (jContext == kStatusError) { return env->NewStringUTF("Failed to initialize JNI context."); } @@ -1118,7 +1060,7 @@ DECODER_FUNC(jstring, dav1dGetErrorMessage, jlong jContext) { return env->NewStringUTF("None."); } -DECODER_FUNC(jint, dav1dGetLastErrorJniStatusCode, jlong jContext) { +jint dav1dGetLastErrorJniStatusCode(JNIEnv* env, jobject thiz, jlong jContext) { if (jContext == kStatusError) { return kJniStatusOk; } @@ -1126,7 +1068,7 @@ DECODER_FUNC(jint, dav1dGetLastErrorJniStatusCode, jlong jContext) { return context->jni_status_code; } -DECODER_FUNC(jint, dav1dCheckError, jlong jContext) { +jint dav1dCheckError(JNIEnv* env, jobject thiz, jlong jContext) { if (jContext == kStatusError) { return kStatusError; } @@ -1139,7 +1081,7 @@ DECODER_FUNC(jint, dav1dCheckError, jlong jContext) { : kStatusOk; } -DECODER_FUNC(void, dav1dFlush, jlong jContext) { +void dav1dFlush(JNIEnv* env, jobject thiz, jlong jContext) { if (jContext == kStatusError) { return; } @@ -1150,7 +1092,8 @@ DECODER_FUNC(void, dav1dFlush, jlong jContext) { } } -DECODER_FUNC(void, releaseUnusedInputBuffers, jlong jContext, jobject decoder) { +void releaseUnusedInputBuffers(JNIEnv* env, jobject thiz, jlong jContext, + jobject decoder) { if (jContext == kStatusError) { return; } @@ -1178,3 +1121,48 @@ DECODER_FUNC(void, releaseUnusedInputBuffers, jlong jContext, jobject decoder) { CleanUpAllocatorData(jContext, env); } } + +extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { + JNIEnv* env; + if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { + return -1; + } + + jclass clazz = env->FindClass("androidx/media3/decoder/av1/Dav1dDecoder"); + if (!clazz) { + LOGE("JNI_OnLoad: FindClass failed for Dav1dDecoder"); + return -1; + } + static const JNINativeMethod kMethods[] = { + {"dav1dInit", "(IIZI)J", reinterpret_cast(dav1dInit)}, + {"dav1dClose", "(J)V", reinterpret_cast(dav1dClose)}, + {"dav1dDecode", "(JLandroidx/media3/decoder/DecoderInputBuffer;IIIZIJI)I", + reinterpret_cast(dav1dDecode)}, + {"dav1dGetFrame", + "(JLandroidx/media3/decoder/VideoDecoderOutputBuffer;)I", + reinterpret_cast(dav1dGetFrame)}, + {"dav1dRenderFrame", + "(JLandroid/view/Surface;Landroidx/media3/decoder/" + "VideoDecoderOutputBuffer;)I", + reinterpret_cast(dav1dRenderFrame)}, + {"dav1dReleaseFrame", + "(JLandroidx/media3/decoder/VideoDecoderOutputBuffer;)V", + reinterpret_cast(dav1dReleaseFrame)}, + {"dav1dGetErrorMessage", "(J)Ljava/lang/String;", + reinterpret_cast(dav1dGetErrorMessage)}, + {"dav1dGetLastErrorJniStatusCode", "(J)I", + reinterpret_cast(dav1dGetLastErrorJniStatusCode)}, + {"dav1dCheckError", "(J)I", reinterpret_cast(dav1dCheckError)}, + {"dav1dFlush", "(J)V", reinterpret_cast(dav1dFlush)}, + {"releaseUnusedInputBuffers", + "(JLandroidx/media3/decoder/av1/Dav1dDecoder;)V", + reinterpret_cast(releaseUnusedInputBuffers)}, + }; + if (env->RegisterNatives(clazz, kMethods, + sizeof(kMethods) / sizeof(kMethods[0])) < 0) { + LOGE("JNI_OnLoad: RegisterNatives failed for Dav1dDecoder"); + return -1; + } + + return JNI_VERSION_1_6; +} diff --git a/libraries/decoder_ffmpeg/proguard-rules.txt b/libraries/decoder_ffmpeg/proguard-rules.txt index aaf9280fd9b..c53b832baae 100644 --- a/libraries/decoder_ffmpeg/proguard-rules.txt +++ b/libraries/decoder_ffmpeg/proguard-rules.txt @@ -1,7 +1,7 @@ # Proguard rules specific to the FFmpeg extension. # This prevents the names of native methods from being obfuscated. --keepclasseswithmembernames class * { +-keep,includedescriptorclasses class androidx.media3.decoder.ffmpeg.** { native ; } diff --git a/libraries/decoder_ffmpeg/src/main/jni/CMakeLists.txt b/libraries/decoder_ffmpeg/src/main/jni/CMakeLists.txt index ad345fe832c..e07963d740f 100644 --- a/libraries/decoder_ffmpeg/src/main/jni/CMakeLists.txt +++ b/libraries/decoder_ffmpeg/src/main/jni/CMakeLists.txt @@ -46,6 +46,10 @@ add_library(ffmpegJNI SHARED ffmpeg_jni.cc) +set_target_properties(ffmpegJNI PROPERTIES + CXX_VISIBILITY_PRESET hidden + VISIBILITY_INLINES_HIDDEN ON) + target_link_libraries(ffmpegJNI PRIVATE android PRIVATE swresample diff --git a/libraries/decoder_ffmpeg/src/main/jni/ffmpeg_jni.cc b/libraries/decoder_ffmpeg/src/main/jni/ffmpeg_jni.cc index 43ecf04edce..4dd42aaa309 100644 --- a/libraries/decoder_ffmpeg/src/main/jni/ffmpeg_jni.cc +++ b/libraries/decoder_ffmpeg/src/main/jni/ffmpeg_jni.cc @@ -38,27 +38,6 @@ extern "C" { #define LOGD(...) \ ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)) -#define LIBRARY_FUNC(RETURN_TYPE, NAME, ...) \ - extern "C" { \ - JNIEXPORT RETURN_TYPE \ - Java_androidx_media3_decoder_ffmpeg_FfmpegLibrary_##NAME(JNIEnv* env, \ - jobject thiz, \ - ##__VA_ARGS__); \ - } \ - JNIEXPORT RETURN_TYPE \ - Java_androidx_media3_decoder_ffmpeg_FfmpegLibrary_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__) - -#define AUDIO_DECODER_FUNC(RETURN_TYPE, NAME, ...) \ - extern "C" { \ - JNIEXPORT RETURN_TYPE \ - Java_androidx_media3_decoder_ffmpeg_FfmpegAudioDecoder_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__); \ - } \ - JNIEXPORT RETURN_TYPE \ - Java_androidx_media3_decoder_ffmpeg_FfmpegAudioDecoder_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__) - #define ERROR_STRING_BUFFER_LENGTH 256 // Output format corresponding to AudioFormat.ENCODING_PCM_16BIT. @@ -119,44 +98,21 @@ void logError(const char* functionName, int errorNumber); */ void releaseContext(AVCodecContext* context); -jint JNI_OnLoad(JavaVM* vm, void* reserved) { - JNIEnv* env; - if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { - LOGE("JNI_OnLoad: GetEnv failed"); - return -1; - } - jclass clazz = - env->FindClass("androidx/media3/decoder/ffmpeg/FfmpegAudioDecoder"); - if (!clazz) { - LOGE("JNI_OnLoad: FindClass failed"); - return -1; - } - growOutputBufferMethod = - env->GetMethodID(clazz, "growOutputBuffer", - "(Landroidx/media3/decoder/" - "SimpleDecoderOutputBuffer;I)Ljava/nio/ByteBuffer;"); - if (!growOutputBufferMethod) { - LOGE("JNI_OnLoad: GetMethodID failed"); - return -1; - } - return JNI_VERSION_1_6; -} - -LIBRARY_FUNC(jstring, ffmpegGetVersion) { +jstring ffmpegGetVersion(JNIEnv* env, jobject thiz) { return env->NewStringUTF(LIBAVCODEC_IDENT); } -LIBRARY_FUNC(jint, ffmpegGetInputBufferPaddingSize) { +jint ffmpegGetInputBufferPaddingSize(JNIEnv* env, jobject thiz) { return (jint)AV_INPUT_BUFFER_PADDING_SIZE; } -LIBRARY_FUNC(jboolean, ffmpegHasDecoder, jstring codecName) { +jboolean ffmpegHasDecoder(JNIEnv* env, jobject thiz, jstring codecName) { return getCodecByName(env, codecName) != NULL; } -AUDIO_DECODER_FUNC(jlong, ffmpegInitialize, jstring codecName, - jbyteArray extraData, jboolean outputFloat, - jint rawSampleRate, jint rawChannelCount) { +jlong ffmpegInitialize(JNIEnv* env, jobject thiz, jstring codecName, + jbyteArray extraData, jboolean outputFloat, + jint rawSampleRate, jint rawChannelCount) { const AVCodec* codec = getCodecByName(env, codecName); if (!codec) { LOGE("Codec not found."); @@ -166,9 +122,9 @@ AUDIO_DECODER_FUNC(jlong, ffmpegInitialize, jstring codecName, rawChannelCount); } -AUDIO_DECODER_FUNC(jint, ffmpegDecode, jlong context, jobject inputData, - jint inputSize, jobject decoderOutputBuffer, - jobject outputData, jint outputSize) { +jint ffmpegDecode(JNIEnv* env, jobject thiz, jlong context, jobject inputData, + jint inputSize, jobject decoderOutputBuffer, + jobject outputData, jint outputSize) { if (!context) { LOGE("Context must be non-NULL."); return -1; @@ -212,7 +168,7 @@ uint8_t* GrowOutputBufferCallback::operator()(int requiredSize) const { return static_cast(env->GetDirectBufferAddress(newOutputData)); } -AUDIO_DECODER_FUNC(jint, ffmpegGetChannelCount, jlong context) { +jint ffmpegGetChannelCount(JNIEnv* env, jobject thiz, jlong context) { if (!context) { LOGE("Context must be non-NULL."); return -1; @@ -220,7 +176,7 @@ AUDIO_DECODER_FUNC(jint, ffmpegGetChannelCount, jlong context) { return ((AVCodecContext*)context)->ch_layout.nb_channels; } -AUDIO_DECODER_FUNC(jint, ffmpegGetSampleRate, jlong context) { +jint ffmpegGetSampleRate(JNIEnv* env, jobject thiz, jlong context) { if (!context) { LOGE("Context must be non-NULL."); return -1; @@ -228,7 +184,8 @@ AUDIO_DECODER_FUNC(jint, ffmpegGetSampleRate, jlong context) { return ((AVCodecContext*)context)->sample_rate; } -AUDIO_DECODER_FUNC(jlong, ffmpegReset, jlong jContext, jbyteArray extraData) { +jlong ffmpegReset(JNIEnv* env, jobject thiz, jlong jContext, + jbyteArray extraData) { AVCodecContext* context = (AVCodecContext*)jContext; if (!context) { LOGE("Tried to reset without a context."); @@ -256,7 +213,7 @@ AUDIO_DECODER_FUNC(jlong, ffmpegReset, jlong jContext, jbyteArray extraData) { return (jlong)context; } -AUDIO_DECODER_FUNC(void, ffmpegRelease, jlong context) { +void ffmpegRelease(JNIEnv* env, jobject thiz, jlong context) { if (context) { releaseContext((AVCodecContext*)context); } @@ -430,3 +387,68 @@ void releaseContext(AVCodecContext* context) { } avcodec_free_context(&context); } + +jint JNI_OnLoad(JavaVM* vm, void* reserved) { + JNIEnv* env; + if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { + LOGE("JNI_OnLoad: GetEnv failed"); + return -1; + } + jclass clazz = + env->FindClass("androidx/media3/decoder/ffmpeg/FfmpegAudioDecoder"); + if (!clazz) { + LOGE("JNI_OnLoad: FindClass failed"); + return -1; + } + growOutputBufferMethod = + env->GetMethodID(clazz, "growOutputBuffer", + "(Landroidx/media3/decoder/" + "SimpleDecoderOutputBuffer;I)Ljava/nio/ByteBuffer;"); + if (!growOutputBufferMethod) { + LOGE("JNI_OnLoad: GetMethodID failed"); + return -1; + } + static const JNINativeMethod kFfmpegAudioDecoderMethods[] = { + {"ffmpegInitialize", "(Ljava/lang/String;[BZII)J", + reinterpret_cast(ffmpegInitialize)}, + {"ffmpegDecode", + "(JLjava/nio/ByteBuffer;ILandroidx/media3/decoder/" + "SimpleDecoderOutputBuffer;Ljava/nio/ByteBuffer;I)I", + reinterpret_cast(ffmpegDecode)}, + {"ffmpegGetChannelCount", "(J)I", + reinterpret_cast(ffmpegGetChannelCount)}, + {"ffmpegGetSampleRate", "(J)I", + reinterpret_cast(ffmpegGetSampleRate)}, + {"ffmpegReset", "(J[B)J", reinterpret_cast(ffmpegReset)}, + {"ffmpegRelease", "(J)V", reinterpret_cast(ffmpegRelease)}, + }; + if (env->RegisterNatives(clazz, kFfmpegAudioDecoderMethods, + sizeof(kFfmpegAudioDecoderMethods) / + sizeof(kFfmpegAudioDecoderMethods[0])) < 0) { + LOGE("JNI_OnLoad: RegisterNatives failed for FfmpegAudioDecoder"); + return -1; + } + + jclass libraryClazz = + env->FindClass("androidx/media3/decoder/ffmpeg/FfmpegLibrary"); + if (!libraryClazz) { + LOGE("JNI_OnLoad: FindClass failed for FfmpegLibrary"); + return -1; + } + static const JNINativeMethod kFfmpegLibraryMethods[] = { + {"ffmpegGetVersion", "()Ljava/lang/String;", + reinterpret_cast(ffmpegGetVersion)}, + {"ffmpegGetInputBufferPaddingSize", "()I", + reinterpret_cast(ffmpegGetInputBufferPaddingSize)}, + {"ffmpegHasDecoder", "(Ljava/lang/String;)Z", + reinterpret_cast(ffmpegHasDecoder)}, + }; + if (env->RegisterNatives(libraryClazz, kFfmpegLibraryMethods, + sizeof(kFfmpegLibraryMethods) / + sizeof(kFfmpegLibraryMethods[0])) < 0) { + LOGE("JNI_OnLoad: RegisterNatives failed for FfmpegLibrary"); + return -1; + } + + return JNI_VERSION_1_6; +} diff --git a/libraries/decoder_iamf/proguard-rules.txt b/libraries/decoder_iamf/proguard-rules.txt index 7b4eaa02434..1804f3f7c26 100755 --- a/libraries/decoder_iamf/proguard-rules.txt +++ b/libraries/decoder_iamf/proguard-rules.txt @@ -1,6 +1,6 @@ # Proguard rules specific to the IAMF extension. # This prevents the names of native methods from being obfuscated. --keepclasseswithmembernames class * { +-keep,includedescriptorclasses class androidx.media3.decoder.iamf.** { native ; } diff --git a/libraries/decoder_iamf/src/main/jni/CMakeLists.txt b/libraries/decoder_iamf/src/main/jni/CMakeLists.txt index 3202944efa6..1892fa869c6 100644 --- a/libraries/decoder_iamf/src/main/jni/CMakeLists.txt +++ b/libraries/decoder_iamf/src/main/jni/CMakeLists.txt @@ -38,6 +38,10 @@ add_library(iamfJNI SHARED iamf_jni.cc) +set_target_properties(iamfJNI PROPERTIES + CXX_VISIBILITY_PRESET hidden + VISIBILITY_INLINES_HIDDEN ON) + # Locate NDK log library. find_library(android_log_lib log) diff --git a/libraries/decoder_iamf/src/main/jni/iamf_jni.cc b/libraries/decoder_iamf/src/main/jni/iamf_jni.cc index b3e2cf6b304..2484242b420 100644 --- a/libraries/decoder_iamf/src/main/jni/iamf_jni.cc +++ b/libraries/decoder_iamf/src/main/jni/iamf_jni.cc @@ -38,27 +38,11 @@ #include #include -#define DECODER_FUNC(RETURN_TYPE, NAME, ...) \ - extern "C" { \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_iamf_IamfDecoder_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__); \ - } \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_iamf_IamfDecoder_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__) - namespace { constexpr int ERROR = -1; constexpr int OK = 0; } // namespace -jint JNI_OnLoad(JavaVM* vm, void* reserved) { - JNIEnv* env; - if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { - return ERROR; - } - return JNI_VERSION_1_6; -} - namespace { struct IamfDecoderWrapper { std::unique_ptr decoder; @@ -235,17 +219,17 @@ iamf_tools::api::IamfDecoderFactory::Settings CreateSettings( } } // namespace -DECODER_FUNC(jlong, iamfOpen) { +jlong iamfOpen(JNIEnv* env, jobject thiz) { return reinterpret_cast(new IamfDecoderWrapper{nullptr}); } -DECODER_FUNC(void, iamfClose, jlong decoderRawPointer) { +void iamfClose(JNIEnv* env, jobject thiz, jlong decoderRawPointer) { delete reinterpret_cast(decoderRawPointer); } -DECODER_FUNC(jint, iamfCreate, jint requestedOutputLayout, - jlong requestedMixPresentationId, jint outputSampleType, - jint channelOrdering, jlong decoderRawPointer) { +jint iamfCreate(JNIEnv* env, jobject thiz, jint requestedOutputLayout, + jlong requestedMixPresentationId, jint outputSampleType, + jint channelOrdering, jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper) { @@ -263,10 +247,12 @@ DECODER_FUNC(jint, iamfCreate, jint requestedOutputLayout, return OK; } -DECODER_FUNC(jint, iamfCreateFromDescriptors, - jbyteArray initializationDataArray, jint requestedOutputLayout, - jlong requestedMixPresentationId, jint outputSampleType, - jint channelOrdering, jlong decoderRawPointer) { +jint iamfCreateFromDescriptors(JNIEnv* env, jobject thiz, + jbyteArray initializationDataArray, + jint requestedOutputLayout, + jlong requestedMixPresentationId, + jint outputSampleType, jint channelOrdering, + jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper) { @@ -292,8 +278,8 @@ DECODER_FUNC(jint, iamfCreateFromDescriptors, return OK; // Success } -DECODER_FUNC(jint, iamfDecode, jobject inputBuffer, jint inputSize, - jlong decoderRawPointer) { +jint iamfDecode(JNIEnv* env, jobject thiz, jobject inputBuffer, jint inputSize, + jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -321,8 +307,8 @@ DECODER_FUNC(jint, iamfDecode, jobject inputBuffer, jint inputSize, return OK; } -DECODER_FUNC(jint, iamfGetOutputTemporalUnit, jobject outputBuffer, - jint outputSize, jlong decoderRawPointer) { +jint iamfGetOutputTemporalUnit(JNIEnv* env, jobject thiz, jobject outputBuffer, + jint outputSize, jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -350,7 +336,8 @@ DECODER_FUNC(jint, iamfGetOutputTemporalUnit, jobject outputBuffer, return bytes_written; } -DECODER_FUNC(jboolean, iamfIsTemporalUnitAvailable, jlong decoderRawPointer) { +jboolean iamfIsTemporalUnitAvailable(JNIEnv* env, jobject thiz, + jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -360,8 +347,8 @@ DECODER_FUNC(jboolean, iamfIsTemporalUnitAvailable, jlong decoderRawPointer) { return wrapper->decoder->IsTemporalUnitAvailable(); } -DECODER_FUNC(jboolean, iamfIsDescriptorProcessingComplete, - jlong decoderRawPointer) { +jboolean iamfIsDescriptorProcessingComplete(JNIEnv* env, jobject thiz, + jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -371,7 +358,8 @@ DECODER_FUNC(jboolean, iamfIsDescriptorProcessingComplete, return wrapper->decoder->IsDescriptorProcessingComplete(); } -DECODER_FUNC(jint, iamfGetNumberOfOutputChannels, jlong decoderRawPointer) { +jint iamfGetNumberOfOutputChannels(JNIEnv* env, jobject thiz, + jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -389,7 +377,8 @@ DECODER_FUNC(jint, iamfGetNumberOfOutputChannels, jlong decoderRawPointer) { return channel_count; } -DECODER_FUNC(jint, iamfGetSelectedOutputLayout, jlong decoderRawPointer) { +jint iamfGetSelectedOutputLayout(JNIEnv* env, jobject thiz, + jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -406,7 +395,8 @@ DECODER_FUNC(jint, iamfGetSelectedOutputLayout, jlong decoderRawPointer) { return FromIamfToolsOutputLayout(selected_mix.output_layout); } -DECODER_FUNC(jlong, iamfGetSelectedMixPresentationId, jlong decoderRawPointer) { +jlong iamfGetSelectedMixPresentationId(JNIEnv* env, jobject thiz, + jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -423,7 +413,8 @@ DECODER_FUNC(jlong, iamfGetSelectedMixPresentationId, jlong decoderRawPointer) { return selected_mix.mix_presentation_id; } -DECODER_FUNC(jint, iamfGetOutputSampleType, jlong decoderRawPointer) { +jint iamfGetOutputSampleType(JNIEnv* env, jobject thiz, + jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -440,7 +431,7 @@ DECODER_FUNC(jint, iamfGetOutputSampleType, jlong decoderRawPointer) { return value; } -DECODER_FUNC(jint, iamfGetSampleRate, jlong decoderRawPointer) { +jint iamfGetSampleRate(JNIEnv* env, jobject thiz, jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -457,7 +448,7 @@ DECODER_FUNC(jint, iamfGetSampleRate, jlong decoderRawPointer) { return sample_rate; } -DECODER_FUNC(jint, iamfGetFrameSize, jlong decoderRawPointer) { +jint iamfGetFrameSize(JNIEnv* env, jobject thiz, jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -474,7 +465,7 @@ DECODER_FUNC(jint, iamfGetFrameSize, jlong decoderRawPointer) { return frame_size; } -DECODER_FUNC(jint, iamfReset, jlong decoderRawPointer) { +jint iamfReset(JNIEnv* env, jobject thiz, jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -489,8 +480,9 @@ DECODER_FUNC(jint, iamfReset, jlong decoderRawPointer) { return OK; } -DECODER_FUNC(jint, iamfResetWithNewMix, jint requestedOutputLayout, - jlong requestedMixPresentationId, jlong decoderRawPointer) { +jint iamfResetWithNewMix(JNIEnv* env, jobject thiz, jint requestedOutputLayout, + jlong requestedMixPresentationId, + jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -513,7 +505,8 @@ DECODER_FUNC(jint, iamfResetWithNewMix, jint requestedOutputLayout, return OK; } -DECODER_FUNC(jint, iamfSignalEndOfDecoding, jlong decoderRawPointer) { +jint iamfSignalEndOfDecoding(JNIEnv* env, jobject thiz, + jlong decoderRawPointer) { IamfDecoderWrapper* wrapper = reinterpret_cast(decoderRawPointer); if (!wrapper || !wrapper->decoder) { @@ -527,3 +520,55 @@ DECODER_FUNC(jint, iamfSignalEndOfDecoding, jlong decoderRawPointer) { } return OK; } + +extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { + JNIEnv* env; + if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { + return ERROR; + } + + static const JNINativeMethod kIamfDecoderMethods[] = { + {"iamfOpen", "()J", reinterpret_cast(iamfOpen)}, + {"iamfClose", "(J)V", reinterpret_cast(iamfClose)}, + {"iamfCreate", "(IIIJ)I", reinterpret_cast(iamfCreate)}, + {"iamfCreateFromDescriptors", "([BIJIIJ)I", + reinterpret_cast(iamfCreateFromDescriptors)}, + {"iamfDecode", "(Ljava/nio/ByteBuffer;IJ)I", + reinterpret_cast(iamfDecode)}, + {"iamfGetOutputTemporalUnit", "(Ljava/nio/ByteBuffer;IJ)I", + reinterpret_cast(iamfGetOutputTemporalUnit)}, + {"iamfIsTemporalUnitAvailable", "(J)Z", + reinterpret_cast(iamfIsTemporalUnitAvailable)}, + {"iamfIsDescriptorProcessingComplete", "(J)Z", + reinterpret_cast(iamfIsDescriptorProcessingComplete)}, + {"iamfGetNumberOfOutputChannels", "(J)I", + reinterpret_cast(iamfGetNumberOfOutputChannels)}, + {"iamfGetSelectedOutputLayout", "(J)I", + reinterpret_cast(iamfGetSelectedOutputLayout)}, + {"iamfGetSelectedMixPresentationId", "(J)J", + reinterpret_cast(iamfGetSelectedMixPresentationId)}, + {"iamfGetOutputSampleType", "(J)I", + reinterpret_cast(iamfGetOutputSampleType)}, + {"iamfGetSampleRate", "(J)I", reinterpret_cast(iamfGetSampleRate)}, + {"iamfGetFrameSize", "(J)I", reinterpret_cast(iamfGetFrameSize)}, + {"iamfReset", "(J)I", reinterpret_cast(iamfReset)}, + {"iamfResetWithNewMix", "(IJJ)I", + reinterpret_cast(iamfResetWithNewMix)}, + {"iamfSignalEndOfDecoding", "(J)I", + reinterpret_cast(iamfSignalEndOfDecoding)}, + }; + + jclass clazz = env->FindClass("androidx/media3/decoder/iamf/IamfDecoder"); + if (!clazz) { + LOGE("JNI_OnLoad: FindClass failed for IamfDecoder"); + return ERROR; + } + if (env->RegisterNatives( + clazz, kIamfDecoderMethods, + sizeof(kIamfDecoderMethods) / sizeof(kIamfDecoderMethods[0])) < 0) { + LOGE("JNI_OnLoad: RegisterNatives failed for IamfDecoder"); + return ERROR; + } + + return JNI_VERSION_1_6; +} diff --git a/libraries/decoder_mpegh/src/androidTest/java/androidx/media3/decoder/mpegh/MpeghPlaybackTest.java b/libraries/decoder_mpegh/src/androidTest/java/androidx/media3/decoder/mpegh/MpeghPlaybackTest.java index fdd7b6fb2a8..33de2c92c6a 100644 --- a/libraries/decoder_mpegh/src/androidTest/java/androidx/media3/decoder/mpegh/MpeghPlaybackTest.java +++ b/libraries/decoder_mpegh/src/androidTest/java/androidx/media3/decoder/mpegh/MpeghPlaybackTest.java @@ -60,6 +60,10 @@ public final class MpeghPlaybackTest { private static final String ACTION_EVENT_XML = ""; + private static final String ACTION_EVENT_NON_ASCII_XML = + ""; private static final int MAX_PERSISTENCE_STORAGE = 8096; @Nullable private ByteBuffer persistenceBuffer; @@ -73,19 +77,19 @@ public void setUp() { } @Test - public void testPlayback() throws Exception { + public void playback_matchesExpectedDump() throws Exception { playAndAssertAudioSinkInput( SAMPLE_MHM1_URI, /* command= */ null, /* persistenceBuffer= */ null, /* run= */ 1); } @Test - public void testPlaybackWithCommand() throws Exception { + public void playback_withCommand_matchesExpectedDump() throws Exception { playAndAssertAudioSinkInput( SAMPLE_MHM1_URI, ACTION_EVENT_XML, /* persistenceBuffer= */ null, /* run= */ 1); } @Test - public void testPlaybackWithCommandAndPersistence() throws Exception { + public void playback_withCommandAndPersistence_matchesExpectedDump() throws Exception { // First run with command to populate persistence playAndAssertAudioSinkInput(SAMPLE_MHM1_URI, ACTION_EVENT_XML, persistenceBuffer, /* run= */ 1); @@ -94,9 +98,30 @@ public void testPlaybackWithCommandAndPersistence() throws Exception { SAMPLE_MHM1_URI, /* command= */ null, persistenceBuffer, /* run= */ 2); } + @Test + public void playback_withNonAsciiCommand_matchesExpectedDump() throws Exception { + playAndAssertAudioSinkInput( + SAMPLE_MHM1_URI, + ACTION_EVENT_NON_ASCII_XML, + ".nonasciicmd", + /* persistenceBuffer= */ null, + /* run= */ 1); + } + private static void playAndAssertAudioSinkInput( String fileName, @Nullable String command, @Nullable ByteBuffer persistenceBuffer, int run) throws Exception { + playAndAssertAudioSinkInput( + fileName, command, command != null ? ".cmd" : "", persistenceBuffer, run); + } + + private static void playAndAssertAudioSinkInput( + String fileName, + @Nullable String command, + String commandSuffix, + @Nullable ByteBuffer persistenceBuffer, + int run) + throws Exception { CapturingAudioSink audioSink = CapturingAudioSink.create(); TestPlaybackRunnable testPlaybackRunnable = new TestPlaybackRunnable( @@ -113,8 +138,6 @@ private static void playAndAssertAudioSinkInput( if (testPlaybackRunnable.playbackException != null) { throw testPlaybackRunnable.playbackException; } - - String commandSuffix = command != null ? ".cmd" : ""; String persistenceSuffix = persistenceBuffer != null ? ".persist." + run : ""; DumpFileAsserts.assertOutput( diff --git a/libraries/decoder_mpegh/src/main/jni/mpeghuimanager_jni.cpp b/libraries/decoder_mpegh/src/main/jni/mpeghuimanager_jni.cpp index 11fe31b5c08..ffce8aaaab8 100644 --- a/libraries/decoder_mpegh/src/main/jni/mpeghuimanager_jni.cpp +++ b/libraries/decoder_mpegh/src/main/jni/mpeghuimanager_jni.cpp @@ -170,20 +170,32 @@ UIMANAGER_FUNC(jint, destroy, jobject persistenceBuffer, * will be called to pass the received MHAS frame to the UI manager */ UIMANAGER_FUNC(jboolean, command, jstring xmlAction) { + if (xmlAction == nullptr) { + return false; + } + UIMANAGER_CONTEXT* ctx = getContext_UI(env, obj); + if (ctx == nullptr || ctx->handle == nullptr) { + LOGW("MPEG-H UI manager is not initialized."); + return false; + } const char* str = env->GetStringUTFChars(xmlAction, 0); - uint32_t strlen = env->GetStringLength(xmlAction); + if (str == nullptr) { + return false; + } + uint32_t xmlActionLength = env->GetStringUTFLength(xmlAction); unsigned int flagsOut = 0; MPEGH_UI_ERROR result = - mpegh_UI_ApplyXmlAction(ctx->handle, str, strlen, &flagsOut); + mpegh_UI_ApplyXmlAction(ctx->handle, str, xmlActionLength, &flagsOut); if (result != MPEGH_UI_OK) { LOGW("Failed to apply XML action with result %d for command %s", result, str); - return false; } - return true; + + env->ReleaseStringUTFChars(xmlAction, str); + return result == MPEGH_UI_OK; } /* diff --git a/libraries/decoder_opus/proguard-rules.txt b/libraries/decoder_opus/proguard-rules.txt index 39af1402447..e962c1006c4 100644 --- a/libraries/decoder_opus/proguard-rules.txt +++ b/libraries/decoder_opus/proguard-rules.txt @@ -1,7 +1,7 @@ # Proguard rules specific to the Opus extension. # This prevents the names of native methods from being obfuscated. --keepclasseswithmembernames class * { +-keep,includedescriptorclasses class androidx.media3.decoder.opus.** { native ; } diff --git a/libraries/decoder_opus/src/androidTest/java/androidx/media3/decoder/opus/OpusDecoderTest.java b/libraries/decoder_opus/src/androidTest/java/androidx/media3/decoder/opus/OpusDecoderTest.java index c66b2486a2c..1445bd8a2b4 100644 --- a/libraries/decoder_opus/src/androidTest/java/androidx/media3/decoder/opus/OpusDecoderTest.java +++ b/libraries/decoder_opus/src/androidTest/java/androidx/media3/decoder/opus/OpusDecoderTest.java @@ -144,6 +144,39 @@ public void decode_withPaddingInSupplementalData_removesPadding() throws OpusDec .isEqualTo(DECODED_DATA_SIZE - nanosecondsToBytes(DISCARD_PADDING_NANOS)); } + // b/528791354 + @Test + public void decode_concurrentDecoders_sizesOutputBufferPerInstance() throws OpusDecoderException { + assertThat(OpusLibrary.isAvailable()).isTrue(); + OpusDecoder decoderStereo = + new OpusDecoder( + /* numInputBuffers= */ 0, + /* numOutputBuffers= */ 0, + /* initialInputBufferSize= */ 0, + createInitializationData(/* preSkipNanos= */ 0), + /* cryptoConfig= */ null, + /* outputFloat= */ false); + byte[] headerMono = HEADER.clone(); + headerMono[9] = 1; + OpusDecoder decoderMono = + new OpusDecoder( + /* numInputBuffers= */ 0, + /* numOutputBuffers= */ 0, + /* initialInputBufferSize= */ 0, + ImmutableList.of(headerMono, CUSTOM_PRE_SKIP_BYTES, CUSTOM_SEEK_PRE_ROLL_BYTES), + /* cryptoConfig= */ null, + /* outputFloat= */ false); + + DecoderInputBuffer input = + createInputBuffer(decoderStereo, ENCODED_DATA, /* supplementalData= */ null); + SimpleDecoderOutputBuffer output = decoderStereo.createOutputBuffer(); + + assertThat(decoderStereo.decode(input, output, false)).isNull(); + assertThat(output.data.capacity()).isEqualTo(960 * 6 * 2 * 2); + decoderStereo.release(); + decoderMono.release(); + } + private static long sampleCountToNanoseconds(long sampleCount) { return (sampleCount * C.NANOS_PER_SECOND) / OpusDecoder.SAMPLE_RATE; } diff --git a/libraries/decoder_opus/src/main/java/androidx/media3/decoder/opus/OpusDecoder.java b/libraries/decoder_opus/src/main/java/androidx/media3/decoder/opus/OpusDecoder.java index 051b594e4c5..cad2946253f 100644 --- a/libraries/decoder_opus/src/main/java/androidx/media3/decoder/opus/OpusDecoder.java +++ b/libraries/decoder_opus/src/main/java/androidx/media3/decoder/opus/OpusDecoder.java @@ -139,7 +139,7 @@ public OpusDecoder( this.outputFloat = outputFloat; if (outputFloat) { - opusSetFloatOutput(); + opusSetFloatOutput(nativeDecoderContext); } } @@ -351,5 +351,5 @@ private native int opusSecureDecode( private native String opusGetErrorMessage(long decoder); - private native void opusSetFloatOutput(); + private native void opusSetFloatOutput(long decoder); } diff --git a/libraries/decoder_opus/src/main/jni/CMakeLists.txt b/libraries/decoder_opus/src/main/jni/CMakeLists.txt index da055e7e2ea..0fd0a590ef6 100644 --- a/libraries/decoder_opus/src/main/jni/CMakeLists.txt +++ b/libraries/decoder_opus/src/main/jni/CMakeLists.txt @@ -36,6 +36,10 @@ add_library(opusV2JNI SHARED opus_jni.cc) +set_target_properties(opusV2JNI PROPERTIES + CXX_VISIBILITY_PRESET hidden + VISIBILITY_INLINES_HIDDEN ON) + # Locate NDK log library. find_library(android_log_lib log) diff --git a/libraries/decoder_opus/src/main/jni/opus_jni.cc b/libraries/decoder_opus/src/main/jni/opus_jni.cc index ce127d19ab2..af1cde08000 100644 --- a/libraries/decoder_opus/src/main/jni/opus_jni.cc +++ b/libraries/decoder_opus/src/main/jni/opus_jni.cc @@ -35,46 +35,24 @@ } while (0) #endif // __ANDROID__ -#define DECODER_FUNC(RETURN_TYPE, NAME, ...) \ - extern "C" { \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_opus_OpusDecoder_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__); \ - } \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_opus_OpusDecoder_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__) - -#define LIBRARY_FUNC(RETURN_TYPE, NAME, ...) \ - extern "C" { \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_opus_OpusLibrary_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__); \ - } \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_opus_OpusLibrary_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__) - // JNI references for SimpleOutputBuffer class. static jmethodID outputBufferInit; -jint JNI_OnLoad(JavaVM* vm, void* reserved) { - JNIEnv* env; - if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { - return -1; - } - return JNI_VERSION_1_6; -} - static const int kBytesPerIntPcmSample = 2; static const int kBytesPerFloatSample = 4; static const int kMaxOpusOutputPacketSizeSamples = 960 * 6; -static int channelCount; -static int errorCode; -static bool outputFloat = false; -DECODER_FUNC(jlong, opusInit, jint sampleRate, jint channelCount, - jint numStreams, jint numCoupled, jint gain, - jbyteArray jStreamMap) { +struct OpusDecoderContext { + OpusMSDecoder* decoder = nullptr; + int channelCount = 0; + bool outputFloat = false; + int errorCode = 0; +}; + +jlong opusInit(JNIEnv* env, jobject thiz, jint sampleRate, jint channelCount, + jint numStreams, jint numCoupled, jint gain, + jbyteArray jStreamMap) { int status = OPUS_INVALID_STATE; - ::channelCount = channelCount; - errorCode = 0; jbyte* streamMapBytes = env->GetByteArrayElements(jStreamMap, 0); uint8_t* streamMap = reinterpret_cast(streamMapBytes); OpusMSDecoder* decoder = opus_multistream_decoder_create( @@ -87,6 +65,7 @@ DECODER_FUNC(jlong, opusInit, jint sampleRate, jint channelCount, status = opus_multistream_decoder_ctl(decoder, OPUS_SET_GAIN(gain)); if (status != OPUS_OK) { LOGE("Failed to set Opus header gain; status=%s", opus_strerror(status)); + opus_multistream_decoder_destroy(decoder); return 0; } @@ -96,19 +75,26 @@ DECODER_FUNC(jlong, opusInit, jint sampleRate, jint channelCount, outputBufferInit = env->GetMethodID(outputBufferClass, "init", "(JI)Ljava/nio/ByteBuffer;"); - return reinterpret_cast(decoder); + OpusDecoderContext* context = new OpusDecoderContext(); + context->decoder = decoder; + context->channelCount = channelCount; + context->outputFloat = false; + context->errorCode = 0; + + return reinterpret_cast(context); } -DECODER_FUNC(jint, opusDecode, jlong jDecoder, jlong jTimeUs, - jobject jInputBuffer, jint inputSize, jobject jOutputBuffer) { - OpusMSDecoder* decoder = reinterpret_cast(jDecoder); +jint opusDecode(JNIEnv* env, jobject thiz, jlong jContext, jlong jTimeUs, + jobject jInputBuffer, jint inputSize, jobject jOutputBuffer) { + OpusDecoderContext* context = reinterpret_cast(jContext); + OpusMSDecoder* decoder = context->decoder; const uint8_t* inputBuffer = reinterpret_cast( env->GetDirectBufferAddress(jInputBuffer)); const int byteSizePerSample = - outputFloat ? kBytesPerFloatSample : kBytesPerIntPcmSample; - const jint outputSize = - kMaxOpusOutputPacketSizeSamples * byteSizePerSample * channelCount; + context->outputFloat ? kBytesPerFloatSample : kBytesPerIntPcmSample; + const jint outputSize = kMaxOpusOutputPacketSizeSamples * byteSizePerSample * + context->channelCount; env->CallObjectMethod(jOutputBuffer, outputBufferInit, jTimeUs, outputSize); if (env->ExceptionCheck()) { @@ -123,7 +109,7 @@ DECODER_FUNC(jint, opusDecode, jlong jDecoder, jlong jTimeUs, } int sampleCount; - if (outputFloat) { + if (context->outputFloat) { float* outputBufferData = reinterpret_cast( env->GetDirectBufferAddress(jOutputBufferData)); sampleCount = opus_multistream_decode_float( @@ -138,16 +124,19 @@ DECODER_FUNC(jint, opusDecode, jlong jDecoder, jlong jTimeUs, } // record error code - errorCode = (sampleCount < 0) ? sampleCount : 0; - return (sampleCount < 0) ? sampleCount - : sampleCount * byteSizePerSample * channelCount; + context->errorCode = (sampleCount < 0) ? sampleCount : 0; + return (sampleCount < 0) + ? sampleCount + : sampleCount * byteSizePerSample * context->channelCount; } -DECODER_FUNC(jint, opusSecureDecode, jlong jDecoder, jlong jTimeUs, - jobject jInputBuffer, jint inputSize, jobject jOutputBuffer, - jint sampleRate, jobject mediaCrypto, jint inputMode, - jbyteArray key, jbyteArray javaIv, jint inputNumSubSamples, - jintArray numBytesOfClearData, jintArray numBytesOfEncryptedData) { +jint opusSecureDecode(JNIEnv* env, jobject thiz, jlong jContext, jlong jTimeUs, + jobject jInputBuffer, jint inputSize, + jobject jOutputBuffer, jint sampleRate, + jobject mediaCrypto, jint inputMode, jbyteArray key, + jbyteArray javaIv, jint inputNumSubSamples, + jintArray numBytesOfClearData, + jintArray numBytesOfEncryptedData) { // Doesn't support // Java client should have checked vpxSupportSecureDecode // and avoid calling this @@ -155,29 +144,108 @@ DECODER_FUNC(jint, opusSecureDecode, jlong jDecoder, jlong jTimeUs, return -2; } -DECODER_FUNC(void, opusClose, jlong jDecoder) { - OpusMSDecoder* decoder = reinterpret_cast(jDecoder); - opus_multistream_decoder_destroy(decoder); +void opusClose(JNIEnv* env, jobject thiz, jlong jContext) { + OpusDecoderContext* context = reinterpret_cast(jContext); + if (context) { + if (context->decoder) { + opus_multistream_decoder_destroy(context->decoder); + } + delete context; + } } -DECODER_FUNC(void, opusReset, jlong jDecoder) { - OpusMSDecoder* decoder = reinterpret_cast(jDecoder); - opus_multistream_decoder_ctl(decoder, OPUS_RESET_STATE); +void opusReset(JNIEnv* env, jobject thiz, jlong jContext) { + OpusDecoderContext* context = reinterpret_cast(jContext); + if (context && context->decoder) { + opus_multistream_decoder_ctl(context->decoder, OPUS_RESET_STATE); + } } -DECODER_FUNC(jstring, opusGetErrorMessage, jlong jContext) { +jstring opusGetErrorMessage(JNIEnv* env, jobject thiz, jlong jContext) { + OpusDecoderContext* context = reinterpret_cast(jContext); + int errorCode = context ? context->errorCode : OPUS_INVALID_STATE; return env->NewStringUTF(opus_strerror(errorCode)); } -DECODER_FUNC(jint, opusGetErrorCode, jlong jContext) { return errorCode; } +jint opusGetErrorCode(JNIEnv* env, jobject thiz, jlong jContext) { + OpusDecoderContext* context = reinterpret_cast(jContext); + return context ? context->errorCode : OPUS_INVALID_STATE; +} -DECODER_FUNC(void, opusSetFloatOutput) { outputFloat = true; } +void opusSetFloatOutput(JNIEnv* env, jobject thiz, jlong jContext) { + OpusDecoderContext* context = reinterpret_cast(jContext); + if (context) { + context->outputFloat = true; + } +} -LIBRARY_FUNC(jstring, opusIsSecureDecodeSupported) { +jboolean opusIsSecureDecodeSupported(JNIEnv* env, jobject thiz) { // Doesn't support - return 0; + return JNI_FALSE; } -LIBRARY_FUNC(jstring, opusGetVersion) { +jstring opusGetVersion(JNIEnv* env, jobject thiz) { return env->NewStringUTF(opus_get_version_string()); } + +extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { + JNIEnv* env; + if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { + return -1; + } + + static const JNINativeMethod kOpusDecoderMethods[] = { + {"opusInit", "(IIIII[B)J", reinterpret_cast(opusInit)}, + {"opusClose", "(J)V", reinterpret_cast(opusClose)}, + {"opusReset", "(J)V", reinterpret_cast(opusReset)}, + {"opusDecode", + "(JJLjava/nio/ByteBuffer;ILandroidx/media3/decoder/" + "SimpleDecoderOutputBuffer;)I", + reinterpret_cast(opusDecode)}, + {"opusSecureDecode", + "(JJLjava/nio/ByteBuffer;ILandroidx/media3/decoder/" + "SimpleDecoderOutputBuffer;ILandroidx/media3/decoder/" + "CryptoConfig;I[B[BI[I[I)I", + reinterpret_cast(opusSecureDecode)}, + {"opusGetErrorMessage", "(J)Ljava/lang/String;", + reinterpret_cast(opusGetErrorMessage)}, + {"opusGetErrorCode", "(J)I", reinterpret_cast(opusGetErrorCode)}, + {"opusSetFloatOutput", "(J)V", + reinterpret_cast(opusSetFloatOutput)}, + }; + + static const JNINativeMethod kOpusLibraryMethods[] = { + {"opusGetVersion", "()Ljava/lang/String;", + reinterpret_cast(opusGetVersion)}, + {"opusIsSecureDecodeSupported", "()Z", + reinterpret_cast(opusIsSecureDecodeSupported)}, + }; + + jclass decoderClazz = + env->FindClass("androidx/media3/decoder/opus/OpusDecoder"); + if (!decoderClazz) { + LOGE("JNI_OnLoad: FindClass failed for OpusDecoder"); + return -1; + } + if (env->RegisterNatives( + decoderClazz, kOpusDecoderMethods, + sizeof(kOpusDecoderMethods) / sizeof(kOpusDecoderMethods[0])) < 0) { + LOGE("JNI_OnLoad: RegisterNatives failed for OpusDecoder"); + return -1; + } + + jclass libraryClazz = + env->FindClass("androidx/media3/decoder/opus/OpusLibrary"); + if (!libraryClazz) { + LOGE("JNI_OnLoad: FindClass failed for OpusLibrary"); + return -1; + } + if (env->RegisterNatives( + libraryClazz, kOpusLibraryMethods, + sizeof(kOpusLibraryMethods) / sizeof(kOpusLibraryMethods[0])) < 0) { + LOGE("JNI_OnLoad: RegisterNatives failed for OpusLibrary"); + return -1; + } + + return JNI_VERSION_1_6; +} diff --git a/libraries/decoder_vp9/proguard-rules.txt b/libraries/decoder_vp9/proguard-rules.txt index 7e0800afdc9..128c5c5ebb5 100644 --- a/libraries/decoder_vp9/proguard-rules.txt +++ b/libraries/decoder_vp9/proguard-rules.txt @@ -1,7 +1,7 @@ # Proguard rules specific to the VP9 extension. # This prevents the names of native methods from being obfuscated. --keepclasseswithmembernames class * { +-keep,includedescriptorclasses class androidx.media3.decoder.vp9.** { native ; } diff --git a/libraries/decoder_vp9/src/main/jni/Android.mk b/libraries/decoder_vp9/src/main/jni/Android.mk index 6d9455e3ad4..563c4d8a858 100644 --- a/libraries/decoder_vp9/src/main/jni/Android.mk +++ b/libraries/decoder_vp9/src/main/jni/Android.mk @@ -32,6 +32,7 @@ LOCAL_SRC_FILES := vpx_jni.cc LOCAL_LDLIBS := -llog -lz -lm -landroid LOCAL_SHARED_LIBRARIES := libvpx LOCAL_STATIC_LIBRARIES := cpufeatures +LOCAL_CFLAGS += -fvisibility=hidden include $(BUILD_SHARED_LIBRARY) diff --git a/libraries/decoder_vp9/src/main/jni/vpx_jni.cc b/libraries/decoder_vp9/src/main/jni/vpx_jni.cc index e983e7ff8bb..670419679e5 100644 --- a/libraries/decoder_vp9/src/main/jni/vpx_jni.cc +++ b/libraries/decoder_vp9/src/main/jni/vpx_jni.cc @@ -38,22 +38,6 @@ #define LOGE(...) \ ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)) -#define DECODER_FUNC(RETURN_TYPE, NAME, ...) \ - extern "C" { \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_vp9_VpxDecoder_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__); \ - } \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_vp9_VpxDecoder_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__) - -#define LIBRARY_FUNC(RETURN_TYPE, NAME, ...) \ - extern "C" { \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_vp9_VpxLibrary_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__); \ - } \ - JNIEXPORT RETURN_TYPE Java_androidx_media3_decoder_vp9_VpxLibrary_##NAME( \ - JNIEnv* env, jobject thiz, ##__VA_ARGS__) - // JNI references for VideoDecoderOutputBuffer class. static jmethodID initForYuvFrame; static jmethodID initForPrivateFrame; @@ -68,14 +52,6 @@ static const int kDecoderPrivateBase = 0x100; static int errorCode; -jint JNI_OnLoad(JavaVM* vm, void* reserved) { - JNIEnv* env; - if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { - return -1; - } - return JNI_VERSION_1_6; -} - #ifdef __ARM_NEON__ static int convert_16_to_8_neon(const vpx_image_t* const img, jbyte* const data, const int32_t uvHeight, const int32_t yLength, @@ -432,8 +408,8 @@ int vpx_release_frame_buffer(void* priv, vpx_codec_frame_buffer_t* fb) { return buffer_manager->release(*(int*)fb->priv); } -DECODER_FUNC(jlong, vpxInit, jboolean disableLoopFilter, - jboolean enableRowMultiThreadMode, jint threads) { +jlong vpxInit(JNIEnv* env, jobject thiz, jboolean disableLoopFilter, + jboolean enableRowMultiThreadMode, jint threads) { JniCtx* context = new JniCtx(); context->decoder = new vpx_codec_ctx_t(); vpx_codec_dec_cfg_t cfg = {0, 0, 0}; @@ -488,7 +464,8 @@ DECODER_FUNC(jlong, vpxInit, jboolean disableLoopFilter, return reinterpret_cast(context); } -DECODER_FUNC(jlong, vpxDecode, jlong jContext, jobject encoded, jint len) { +jlong vpxDecode(JNIEnv* env, jobject thiz, jlong jContext, jobject encoded, + jint len) { JniCtx* const context = reinterpret_cast(jContext); const uint8_t* const buffer = reinterpret_cast(env->GetDirectBufferAddress(encoded)); @@ -503,10 +480,11 @@ DECODER_FUNC(jlong, vpxDecode, jlong jContext, jobject encoded, jint len) { return 0; } -DECODER_FUNC(jlong, vpxSecureDecode, jlong jContext, jobject encoded, jint len, - jobject mediaCrypto, jint inputMode, jbyteArray&, jbyteArray&, - jint inputNumSubSamples, jintArray numBytesOfClearData, - jintArray numBytesOfEncryptedData) { +jlong vpxSecureDecode(JNIEnv* env, jobject thiz, jlong jContext, + jobject encoded, jint len, jobject mediaCrypto, + jint inputMode, jbyteArray&, jbyteArray&, + jint inputNumSubSamples, jintArray numBytesOfClearData, + jintArray numBytesOfEncryptedData) { // Doesn't support // Java client should have checked vpxSupportSecureDecode // and avoid calling this @@ -514,14 +492,15 @@ DECODER_FUNC(jlong, vpxSecureDecode, jlong jContext, jobject encoded, jint len, return -2; } -DECODER_FUNC(jlong, vpxClose, jlong jContext) { +jlong vpxClose(JNIEnv* env, jobject thiz, jlong jContext) { JniCtx* const context = reinterpret_cast(jContext); vpx_codec_destroy(context->decoder); delete context; return 0; } -DECODER_FUNC(jint, vpxGetFrame, jlong jContext, jobject jOutputBuffer) { +jint vpxGetFrame(JNIEnv* env, jobject thiz, jlong jContext, + jobject jOutputBuffer) { JniCtx* const context = reinterpret_cast(jContext); vpx_codec_iter_t iter = NULL; const vpx_image_t* const img = vpx_codec_get_frame(context->decoder, &iter); @@ -621,8 +600,8 @@ DECODER_FUNC(jint, vpxGetFrame, jlong jContext, jobject jOutputBuffer) { return 0; } -DECODER_FUNC(jint, vpxRenderFrame, jlong jContext, jobject jSurface, - jobject jOutputBuffer) { +jint vpxRenderFrame(JNIEnv* env, jobject thiz, jlong jContext, jobject jSurface, + jobject jOutputBuffer) { JniCtx* const context = reinterpret_cast(jContext); const int id = env->GetLongField(jOutputBuffer, decoderPrivateField) - kDecoderPrivateBase; @@ -677,30 +656,101 @@ DECODER_FUNC(jint, vpxRenderFrame, jlong jContext, jobject jSurface, return ANativeWindow_unlockAndPost(context->native_window); } -DECODER_FUNC(void, vpxReleaseFrame, jlong jContext, jobject jOutputBuffer) { +int vpxReleaseFrame(JNIEnv* env, jobject thiz, jlong jContext, + jobject jOutputBuffer) { JniCtx* const context = reinterpret_cast(jContext); const int id = env->GetLongField(jOutputBuffer, decoderPrivateField) - kDecoderPrivateBase; env->SetLongField(jOutputBuffer, decoderPrivateField, -1); context->buffer_manager->release(id); + return 0; } -DECODER_FUNC(jstring, vpxGetErrorMessage, jlong jContext) { +jstring vpxGetErrorMessage(JNIEnv* env, jobject thiz, jlong jContext) { JniCtx* const context = reinterpret_cast(jContext); return env->NewStringUTF(vpx_codec_error(context->decoder)); } -DECODER_FUNC(jint, vpxGetErrorCode, jlong jContext) { return errorCode; } +jint vpxGetErrorCode(JNIEnv* env, jobject thiz, jlong jContext) { + return errorCode; +} -LIBRARY_FUNC(jstring, vpxIsSecureDecodeSupported) { +jboolean vpxIsSecureDecodeSupported(JNIEnv* env, jobject thiz) { // Doesn't support - return 0; + return JNI_FALSE; } -LIBRARY_FUNC(jstring, vpxGetVersion) { +jstring vpxGetVersion(JNIEnv* env, jobject thiz) { return env->NewStringUTF(vpx_codec_version_str()); } -LIBRARY_FUNC(jstring, vpxGetBuildConfig) { +jstring vpxGetBuildConfig(JNIEnv* env, jobject thiz) { return env->NewStringUTF(vpx_codec_build_config()); } + +extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { + JNIEnv* env; + if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { + return -1; + } + + static const JNINativeMethod kVpxDecoderMethods[] = { + {"vpxInit", "(ZZI)J", reinterpret_cast(vpxInit)}, + {"vpxClose", "(J)J", reinterpret_cast(vpxClose)}, + {"vpxDecode", "(JLjava/nio/ByteBuffer;I)J", + reinterpret_cast(vpxDecode)}, + {"vpxSecureDecode", + "(JLjava/nio/ByteBuffer;ILandroidx/media3/decoder/CryptoConfig;I[B[BI[I" + "[I)J", + reinterpret_cast(vpxSecureDecode)}, + {"vpxGetFrame", "(JLandroidx/media3/decoder/VideoDecoderOutputBuffer;)I", + reinterpret_cast(vpxGetFrame)}, + {"vpxRenderFrame", + "(JLandroid/view/Surface;Landroidx/media3/decoder/" + "VideoDecoderOutputBuffer;)I", + reinterpret_cast(vpxRenderFrame)}, + {"vpxReleaseFrame", + "(JLandroidx/media3/decoder/VideoDecoderOutputBuffer;)I", + reinterpret_cast(vpxReleaseFrame)}, + {"vpxGetErrorCode", "(J)I", reinterpret_cast(vpxGetErrorCode)}, + {"vpxGetErrorMessage", "(J)Ljava/lang/String;", + reinterpret_cast(vpxGetErrorMessage)}, + }; + + static const JNINativeMethod kVpxLibraryMethods[] = { + {"vpxGetVersion", "()Ljava/lang/String;", + reinterpret_cast(vpxGetVersion)}, + {"vpxGetBuildConfig", "()Ljava/lang/String;", + reinterpret_cast(vpxGetBuildConfig)}, + {"vpxIsSecureDecodeSupported", "()Z", + reinterpret_cast(vpxIsSecureDecodeSupported)}, + }; + + jclass decoderClazz = + env->FindClass("androidx/media3/decoder/vp9/VpxDecoder"); + if (!decoderClazz) { + LOGE("JNI_OnLoad: FindClass failed for VpxDecoder"); + return -1; + } + if (env->RegisterNatives( + decoderClazz, kVpxDecoderMethods, + sizeof(kVpxDecoderMethods) / sizeof(kVpxDecoderMethods[0])) < 0) { + LOGE("JNI_OnLoad: RegisterNatives failed for VpxDecoder"); + return -1; + } + + jclass libraryClazz = + env->FindClass("androidx/media3/decoder/vp9/VpxLibrary"); + if (!libraryClazz) { + LOGE("JNI_OnLoad: FindClass failed for VpxLibrary"); + return -1; + } + if (env->RegisterNatives( + libraryClazz, kVpxLibraryMethods, + sizeof(kVpxLibraryMethods) / sizeof(kVpxLibraryMethods[0])) < 0) { + LOGE("JNI_OnLoad: RegisterNatives failed for VpxLibrary"); + return -1; + } + + return JNI_VERSION_1_6; +} diff --git a/libraries/effect/src/androidTest/java/androidx/media3/effect/BitmapToHardwareBufferProcessorTest.java b/libraries/effect/src/androidTest/java/androidx/media3/effect/BitmapToHardwareBufferProcessorTest.java index 7d1c94328c7..12e52a9092e 100644 --- a/libraries/effect/src/androidTest/java/androidx/media3/effect/BitmapToHardwareBufferProcessorTest.java +++ b/libraries/effect/src/androidTest/java/androidx/media3/effect/BitmapToHardwareBufferProcessorTest.java @@ -255,7 +255,7 @@ public void process_differentGenerationId_createsNewBuffer() { } @Test - public void process_releasesInputFrame() throws Exception { + public void process_defersInputFrameReleaseUntilOutputFrameRelease() throws Exception { CountDownLatch releasedLatch = new CountDownLatch(1); HardwareBufferFrame inputFrame = new HardwareBufferFrame.Builder( @@ -266,10 +266,13 @@ public void process_releasesInputFrame() throws Exception { .build(); HardwareBufferFrame outputFrame = processor.process(inputFrame); + // The input frame should not have been released yet. + assertThat(releasedLatch.getCount()).isEqualTo(1); - assertThat(releasedLatch.await(TEST_TIMEOUT_MS, MILLISECONDS)).isTrue(); - + // Releasing the output frame should trigger inputFrame release outputFrame.release(/* releaseFence= */ null); + assertThat(releasedLatch.await(TEST_TIMEOUT_MS, MILLISECONDS)).isTrue(); + assertThat(releasedLatch.getCount()).isEqualTo(0); } @Test diff --git a/libraries/effect/src/androidTest/java/androidx/media3/effect/DefaultVideoFrameProcessorPixelTest.java b/libraries/effect/src/androidTest/java/androidx/media3/effect/DefaultVideoFrameProcessorPixelTest.java index 257f0fd5aae..b23158a95c3 100644 --- a/libraries/effect/src/androidTest/java/androidx/media3/effect/DefaultVideoFrameProcessorPixelTest.java +++ b/libraries/effect/src/androidTest/java/androidx/media3/effect/DefaultVideoFrameProcessorPixelTest.java @@ -26,8 +26,10 @@ import android.content.Context; import android.graphics.Bitmap; +import android.graphics.Color; import android.graphics.Matrix; import androidx.media3.common.C; +import androidx.media3.common.ColorInfo; import androidx.media3.common.Effect; import androidx.media3.common.VideoFrameProcessingException; import androidx.media3.common.util.Size; @@ -86,6 +88,8 @@ public final class DefaultVideoFrameProcessorPixelTest { "test-generated-goldens/sample_mp4_first_frame/electrical_colors/increase_brightness.png"; private static final String GRAYSCALE_THEN_INCREASE_RED_CHANNEL_PNG_ASSET_PATH = "test-generated-goldens/sample_mp4_first_frame/electrical_colors/grayscale_then_increase_red_channel.png"; + private static final String TONE_MAP_PQ_REGISTER_INPUT_PNG_ASSET_PATH = + "test-generated-goldens/DefaultVideoFrameProcessorPixelTest/toneMap_pqRegisterInput.png"; /** Input video of which we only use the first frame. */ private static final String INPUT_SDR_MP4_ASSET_STRING = "media/mp4/sample.mp4"; @@ -159,6 +163,46 @@ public void noEffects_withDisabledColorTransfers_matchesGoldenFile() throws Exce assertThat(averagePixelAbsoluteDifference).isAtMost(MAXIMUM_AVERAGE_PIXEL_ABSOLUTE_DIFFERENCE); } + @Test + public void toneMap_pqRegisterInput_matchesGoldenFile() throws Exception { + videoFrameProcessorTestRunner = getDefaultFrameProcessorTestRunnerBuilder(testId).build(); + + int width = 64; + int height = 64; + Bitmap inputBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888); + // Use saturated primary colors (pure green and pure blue). + // In wide-gamut BT.2020 PQ space, saturated primaries lie outside the BT.709 color gamut. + // When tone-mapping to SDR (BT.709), applying the OOTF to these colors yields negative RGB + // component values in linear BT.709 space. Without clamping to 0.0 before applying the Gamma + // 2.2 OETF (pow(x, 1.0 / 2.2)), GLSL produces NaNs for pow(negative, fraction), causing severe + // rendering artifacts or corrupted output bitmaps. + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + if (x < width / 2) { + inputBitmap.setPixel(x, y, Color.GREEN); + } else { + inputBitmap.setPixel(x, y, Color.BLUE); + } + } + } + + ColorInfo pqColorInfo = + new ColorInfo.Builder() + .setColorSpace(C.COLOR_SPACE_BT2020) + .setColorRange(C.COLOR_RANGE_FULL) + .setColorTransfer(C.COLOR_TRANSFER_ST2084) + .build(); + + videoFrameProcessorTestRunner.queueInputBitmap( + inputBitmap, C.MICROS_PER_SECOND, /* offsetToAddUs= */ 0L, /* frameRate= */ 1, pqColorInfo); + videoFrameProcessorTestRunner.endFrameProcessing(); + Bitmap actualBitmap = videoFrameProcessorTestRunner.getOutputBitmap(); + Bitmap expectedBitmap = readBitmap(TONE_MAP_PQ_REGISTER_INPUT_PNG_ASSET_PATH); + float averagePixelAbsoluteDifference = + getBitmapAveragePixelAbsoluteDifferenceArgb8888(expectedBitmap, actualBitmap, testId); + assertThat(averagePixelAbsoluteDifference).isAtMost(MAXIMUM_AVERAGE_PIXEL_ABSOLUTE_DIFFERENCE); + } + @Test public void noEffects_withImageInput_matchesGoldenFile() throws Exception { videoFrameProcessorTestRunner = getDefaultFrameProcessorTestRunnerBuilder(testId).build(); diff --git a/libraries/effect/src/androidTest/java/androidx/media3/effect/FrameWriterGlTextureFrameConsumerTest.java b/libraries/effect/src/androidTest/java/androidx/media3/effect/FrameWriterGlTextureFrameConsumerTest.java index 814a5fe033b..430c1fa6d10 100644 --- a/libraries/effect/src/androidTest/java/androidx/media3/effect/FrameWriterGlTextureFrameConsumerTest.java +++ b/libraries/effect/src/androidTest/java/androidx/media3/effect/FrameWriterGlTextureFrameConsumerTest.java @@ -21,19 +21,23 @@ import static androidx.media3.test.utils.BitmapPixelTestUtil.MAXIMUM_AVERAGE_PIXEL_ABSOLUTE_DIFFERENCE; import static androidx.test.core.app.ApplicationProvider.getApplicationContext; import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.truth.Truth.assertThat; import static com.google.common.util.concurrent.MoreExecutors.directExecutor; import static com.google.common.util.concurrent.MoreExecutors.listeningDecorator; import static java.util.concurrent.Executors.newSingleThreadExecutor; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import android.content.Context; import android.graphics.Bitmap; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.ColorSpace; +import android.graphics.Matrix; import android.hardware.HardwareBuffer; import androidx.annotation.Nullable; import androidx.media3.common.C; +import androidx.media3.common.ColorInfo; import androidx.media3.common.Format; import androidx.media3.common.GlObjectsProvider; import androidx.media3.common.GlTextureInfo; @@ -69,19 +73,26 @@ public final class FrameWriterGlTextureFrameConsumerTest { private static final String TEST_IMAGE_ASSET = "media/png/first_frame_1920x1080.png"; + + private static final long TIMEOUT_MS = 5_000; private static final int BITMAP_WIDTH = 1920; private static final int BITMAP_HEIGHT = 1080; - @Rule public final TestName testName = new TestName(); - private final Context context = getApplicationContext(); + @Rule public final TestName testName; + private final Context context; private @MonotonicNonNull ListeningExecutorService glExecutorService; private @MonotonicNonNull GlObjectsProvider glObjectsProvider; - private @MonotonicNonNull HardwareBuffer frameWriterHardwareBuffer; private @MonotonicNonNull BitmapSavingFrameWriter frameWriter; private @MonotonicNonNull FakeHardwareBufferJniWrapper fakeJniWrapper; private @MonotonicNonNull FrameWriterGlTextureFrameConsumer frameWriterGlTextureFrameConsumer; - private final List actualBitmaps = new CopyOnWriteArrayList<>(); + private final List actualBitmaps; + + public FrameWriterGlTextureFrameConsumerTest() { + testName = new TestName(); + context = getApplicationContext(); + actualBitmaps = new CopyOnWriteArrayList<>(); + } @Before public void setUp() throws Exception { @@ -95,18 +106,8 @@ public void setUp() throws Exception { }) .get(); - frameWriterHardwareBuffer = - HardwareBuffer.create( - BITMAP_WIDTH, - BITMAP_HEIGHT, - HardwareBuffer.RGBA_8888, - /* layers= */ 1, - HardwareBuffer.USAGE_CPU_READ_OFTEN - | HardwareBuffer.USAGE_GPU_COLOR_OUTPUT - | HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE); - fakeJniWrapper = new FakeHardwareBufferJniWrapper(); - frameWriter = new BitmapSavingFrameWriter(frameWriterHardwareBuffer, actualBitmaps); + frameWriter = new BitmapSavingFrameWriter(actualBitmaps); frameWriterGlTextureFrameConsumer = new FrameWriterGlTextureFrameConsumer(context, frameWriter, fakeJniWrapper); } @@ -117,9 +118,6 @@ public void tearDown() throws Exception { glExecutorService.submit(this::tearDownInternal).get(); shutdownGlExecutorService(glExecutorService); } - if (frameWriterHardwareBuffer != null) { - frameWriterHardwareBuffer.close(); - } } private void tearDownInternal() { @@ -127,6 +125,9 @@ private void tearDownInternal() { if (frameWriterGlTextureFrameConsumer != null) { frameWriterGlTextureFrameConsumer.close(); } + if (frameWriter != null) { + frameWriter.close(); + } if (glObjectsProvider != null) { releaseOpenGl(glObjectsProvider); } @@ -298,11 +299,206 @@ inputFrame1, directExecutor(), /* wakeupListener= */ () -> {})) .isLessThan(MAXIMUM_AVERAGE_PIXEL_ABSOLUTE_DIFFERENCE); } + @Test + public void queue_portraitFrameWhenPortraitUnsupported_rotatesToLandscape() throws Exception { + frameWriter.supportsPortrait = false; + Bitmap landscapeBitmap = BitmapPixelTestUtil.readBitmap(TEST_IMAGE_ASSET); + Matrix matrix = new Matrix(); + matrix.postRotate(90); + Bitmap portraitInputBitmap = + Bitmap.createBitmap( + landscapeBitmap, + /* x= */ 0, + /* y= */ 0, + landscapeBitmap.getWidth(), + landscapeBitmap.getHeight(), + matrix, + /* filter= */ true); + Matrix expectedMatrix = new Matrix(); + expectedMatrix.postRotate(180); + // The input bitmap is rotated 90 clockwise, and the pipeline rotates it to landscape by another + // 90 degrees, so the output will be 180 degrees rotated. + Bitmap expectedBitmap = + Bitmap.createBitmap( + landscapeBitmap, + /* x= */ 0, + /* y= */ 0, + landscapeBitmap.getWidth(), + landscapeBitmap.getHeight(), + expectedMatrix, + /* filter= */ true); + + glExecutorService + .submit( + () -> { + try { + GlTextureFrame inputFrame = + createGlTextureFrame(portraitInputBitmap, /* presentationTimeUs= */ 1000); + assertThat( + frameWriterGlTextureFrameConsumer.queue( + inputFrame, directExecutor(), /* wakeupListener= */ () -> {})) + .isTrue(); + } catch (Exception e) { + throw new AssertionError(e); + } + }) + .get(TIMEOUT_MS, MILLISECONDS); + + Bitmap outputBitmap = actualBitmaps.get(0); + assertThat( + BitmapPixelTestUtil.getBitmapAveragePixelAbsoluteDifferenceArgb8888( + expectedBitmap, outputBitmap, testName.getMethodName())) + .isLessThan(MAXIMUM_AVERAGE_PIXEL_ABSOLUTE_DIFFERENCE); + + Format configuredFrameWriterFormat = checkNotNull(frameWriter.configuredFormat); + assertThat(configuredFrameWriterFormat.width).isEqualTo(BITMAP_WIDTH); + assertThat(configuredFrameWriterFormat.height).isEqualTo(BITMAP_HEIGHT); + assertThat(configuredFrameWriterFormat.rotationDegrees).isEqualTo(270); + } + + @Test + public void queue_landscapeThenPortrait_outputsCorrectBitmaps() throws Exception { + Bitmap inputBitmap1 = BitmapPixelTestUtil.readBitmap(TEST_IMAGE_ASSET); // 1920x1080 + Matrix matrix = new Matrix(); + matrix.postRotate(90); + Bitmap inputBitmap2 = + Bitmap.createBitmap( + inputBitmap1, + /* x= */ 0, + /* y= */ 0, + inputBitmap1.getWidth(), + inputBitmap1.getHeight(), + matrix, + /* filter= */ true); // 1080x1920 + // Construct the expected pillarboxed bitmap. + // Scale 1080x1920 to fit 1920x1080: 608x1080, hence pillar box width = (1920 - 608) / 2 = 656. + Bitmap expectedBitmap2 = + Bitmap.createBitmap(/* width= */ 1920, /* height= */ 1080, Bitmap.Config.ARGB_8888); + Canvas canvas = new Canvas(expectedBitmap2); + canvas.drawColor(Color.BLACK); // black background + Bitmap scaledInput2 = Bitmap.createScaledBitmap(inputBitmap2, 608, 1080, /* filter= */ true); + canvas.drawBitmap(scaledInput2, /* left= */ 656, /* top= */ 0, /* paint= */ null); + + glExecutorService + .submit( + () -> { + try { + GlTextureFrame inputFrame1 = + createGlTextureFrame(inputBitmap1, /* presentationTimeUs= */ 1000); + assertThat( + frameWriterGlTextureFrameConsumer.queue( + inputFrame1, directExecutor(), /* wakeupListener= */ () -> {})) + .isTrue(); + + GlTextureFrame inputFrame2 = + createGlTextureFrame(inputBitmap2, /* presentationTimeUs= */ 2000); + assertThat( + frameWriterGlTextureFrameConsumer.queue( + inputFrame2, directExecutor(), /* wakeupListener= */ () -> {})) + .isTrue(); + } catch (Exception e) { + throw new AssertionError(e); + } + }) + .get(); + + // Frame 1: 1920x1080 + Bitmap outputBitmap1 = actualBitmaps.get(0); + assertThat( + BitmapPixelTestUtil.getBitmapAveragePixelAbsoluteDifferenceArgb8888( + inputBitmap1, outputBitmap1, testName.getMethodName() + "_frame1")) + .isLessThan(MAXIMUM_AVERAGE_PIXEL_ABSOLUTE_DIFFERENCE); + + // Frame 2: Conformed to 1920x1080 (pillarboxed) + Bitmap outputBitmap2 = actualBitmaps.get(1); + assertThat( + BitmapPixelTestUtil.getBitmapAveragePixelAbsoluteDifferenceArgb8888( + expectedBitmap2, outputBitmap2, testName.getMethodName() + "_frame2")) + .isLessThan(MAXIMUM_AVERAGE_PIXEL_ABSOLUTE_DIFFERENCE); + } + + @Test + public void queue_portraitThenLandscape_outputsCorrectBitmaps() throws Exception { + Bitmap originalBitmap = BitmapPixelTestUtil.readBitmap(TEST_IMAGE_ASSET); // 1920x1080 + Matrix matrix = new Matrix(); + matrix.postRotate(90); + Bitmap inputBitmap1 = + Bitmap.createBitmap( + originalBitmap, + /* x= */ 0, + /* y= */ 0, + originalBitmap.getWidth(), + originalBitmap.getHeight(), + matrix, + /* filter= */ true); // 1080x1920 + Bitmap inputBitmap2 = originalBitmap; // 1920x1080 (landscape) + // Construct the expected letterboxed bitmap. + // Scale 1920x1080 to fit 1080x1920: 1080x608, hence letter box height = (1920 - 608) / 2 = 656. + Bitmap expectedBitmap2 = + Bitmap.createBitmap(/* width= */ 1080, /* height= */ 1920, Bitmap.Config.ARGB_8888); + Canvas canvas = new Canvas(expectedBitmap2); + canvas.drawColor(Color.BLACK); // black background + Bitmap scaledInput2 = + Bitmap.createScaledBitmap( + inputBitmap2, /* dstWidth= */ 1080, /* dstHeight= */ 608, /* filter= */ true); + canvas.drawBitmap(scaledInput2, /* left= */ 0, /* top= */ 656, /* paint= */ null); + + glExecutorService + .submit( + () -> { + try { + GlTextureFrame inputFrame1 = + createGlTextureFrame(inputBitmap1, /* presentationTimeUs= */ 1000); + assertThat( + frameWriterGlTextureFrameConsumer.queue( + inputFrame1, directExecutor(), /* wakeupListener= */ () -> {})) + .isTrue(); + + GlTextureFrame inputFrame2 = + createGlTextureFrame(inputBitmap2, /* presentationTimeUs= */ 2000); + assertThat( + frameWriterGlTextureFrameConsumer.queue( + inputFrame2, directExecutor(), /* wakeupListener= */ () -> {})) + .isTrue(); + } catch (Exception e) { + throw new AssertionError(e); + } + }) + .get(); + + // Frame 1: 1080x1920 (portrait) + Bitmap outputBitmap1 = actualBitmaps.get(0); + assertThat( + BitmapPixelTestUtil.getBitmapAveragePixelAbsoluteDifferenceArgb8888( + inputBitmap1, outputBitmap1, testName.getMethodName() + "_frame1")) + .isLessThan(MAXIMUM_AVERAGE_PIXEL_ABSOLUTE_DIFFERENCE); + + // Frame 2: Conformed to 1080x1920 (letterboxed) + Bitmap outputBitmap2 = actualBitmaps.get(1); + assertThat( + BitmapPixelTestUtil.getBitmapAveragePixelAbsoluteDifferenceArgb8888( + expectedBitmap2, outputBitmap2, testName.getMethodName() + "_frame2")) + .isLessThan(MAXIMUM_AVERAGE_PIXEL_ABSOLUTE_DIFFERENCE); + } + + /** + * Creates a {@link GlTextureFrame} that is flipped along the y-axis from the input {@link + * Bitmap}. + * + *

This method converts the input {@link Bitmap} to the OpenGL coordinate system that {@link + * FrameWriterGlTextureFrameConsumer} always receives. + */ private static GlTextureFrame createGlTextureFrame(Bitmap bitmap, long presentationTimeUs) throws GlException { int width = bitmap.getWidth(); int height = bitmap.getHeight(); - int texId = GlUtil.createTexture(bitmap); + Matrix matrix = new Matrix(); + matrix.postScale(/* sx= */ 1f, /* sy= */ -1f, width / 2f, height / 2f); + Bitmap flippedBitmap = + Bitmap.createBitmap( + bitmap, /* x= */ 0, /* y= */ 0, width, height, matrix, /* filter= */ true); + int texId = GlUtil.createTexture(flippedBitmap); + flippedBitmap.recycle(); return new GlTextureFrame.Builder( new GlTextureInfo( /* texId= */ texId, @@ -319,7 +515,12 @@ private static GlTextureFrame createGlTextureFrame(Bitmap bitmap, long presentat } }) .setPresentationTimeUs(presentationTimeUs) - .setFormat(new Format.Builder().setWidth(width).setHeight(height).build()) + .setFormat( + new Format.Builder() + .setWidth(width) + .setHeight(height) + .setColorInfo(ColorInfo.SRGB_BT709_FULL) + .build()) .build(); } @@ -357,15 +558,18 @@ public boolean nativeCopyHardwareBufferToHardwareBuffer( } private static final class BitmapSavingFrameWriter implements FrameWriter { - private final HardwareBuffer hardwareBuffer; + @Nullable private HardwareBuffer hardwareBuffer; private final List outputBitmaps; - private boolean hasCapacity = true; + private boolean hasCapacity; @Nullable private Runnable pendingWakeupListener; @Nullable private Executor pendingWakeupExecutor; + private boolean supportsPortrait; + @Nullable private Format configuredFormat; - BitmapSavingFrameWriter(HardwareBuffer hardwareBuffer, List outputBitmaps) { - this.hardwareBuffer = hardwareBuffer; + BitmapSavingFrameWriter(List outputBitmaps) { this.outputBitmaps = outputBitmaps; + supportsPortrait = true; + hasCapacity = true; } void setCapacity(boolean hasCapacity) { @@ -379,11 +583,29 @@ void setCapacity(boolean hasCapacity) { @Override public Info getInfo() { - return (format, usage) -> true; + return (format, usage) -> supportsPortrait || format.width >= format.height; } @Override - public void configure(Format format, long usage) {} + public void configure(Format format, long usage) { + this.configuredFormat = format; + if (hardwareBuffer == null + || hardwareBuffer.getWidth() != format.width + || hardwareBuffer.getHeight() != format.height) { + if (hardwareBuffer != null) { + hardwareBuffer.close(); + } + hardwareBuffer = + HardwareBuffer.create( + format.width, + format.height, + HardwareBuffer.RGBA_8888, + /* layers= */ 1, + HardwareBuffer.USAGE_CPU_READ_OFTEN + | HardwareBuffer.USAGE_GPU_COLOR_OUTPUT + | HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE); + } + } @Override public AsyncFrame dequeueInputFrame(Executor wakeupExecutor, Runnable wakeupListener) { @@ -393,7 +615,8 @@ public AsyncFrame dequeueInputFrame(Executor wakeupExecutor, Runnable wakeupList return null; } return new AsyncFrame( - new DefaultHardwareBufferFrame.Builder(hardwareBuffer).build(), /* acquireFence= */ null); + new DefaultHardwareBufferFrame.Builder(checkNotNull(hardwareBuffer)).build(), + /* acquireFence= */ null); } @Override @@ -419,6 +642,10 @@ public void queueInputFrame(Frame frame, @Nullable SyncFenceWrapper writeComplet public void signalEndOfStream() {} @Override - public void close() {} + public void close() { + if (hardwareBuffer != null) { + hardwareBuffer.close(); + } + } } } diff --git a/libraries/effect/src/androidTest/java/androidx/media3/effect/HardwareBufferToGlTextureConverterTest.java b/libraries/effect/src/androidTest/java/androidx/media3/effect/HardwareBufferToGlTextureConverterTest.java index 016965a0b3d..7a5f53005a1 100644 --- a/libraries/effect/src/androidTest/java/androidx/media3/effect/HardwareBufferToGlTextureConverterTest.java +++ b/libraries/effect/src/androidTest/java/androidx/media3/effect/HardwareBufferToGlTextureConverterTest.java @@ -311,23 +311,41 @@ public void onFrameProcessed(Frame frame, @Nullable SyncFenceWrapper releaseFenc @Test public void convert_withRgba8888HardwareBufferAndRotation_outputsCorrectGlTexture() throws Exception { + int rotationDegrees = 90; Bitmap inputBitmap = BitmapPixelTestUtil.readBitmap("media/png/first_frame_1920x1080.png"); Bitmap hardwareBitmap = inputBitmap.copy(Bitmap.Config.HARDWARE, /* isMutable= */ false); HardwareBuffer hardwareBuffer = hardwareBitmap.getHardwareBuffer(); - assertThat(hardwareBuffer.getFormat()).isEqualTo(HardwareBuffer.RGBA_8888); + Format inputFormat = + new Format.Builder() + .setWidth(inputBitmap.getWidth()) + .setHeight(inputBitmap.getHeight()) + .setRotationDegrees(rotationDegrees) + .setColorInfo(ColorInfo.SDR_BT709_LIMITED) + .build(); + HardwareBufferFrame inputHardwareBufferFrame = + new DefaultHardwareBufferFrame.Builder(hardwareBuffer).setFormat(inputFormat).build(); - int rotationDegrees = 90; - int formatWidth = inputBitmap.getHeight(); - int formatHeight = inputBitmap.getWidth(); + Matrix rotationMatrix = new Matrix(); + rotationMatrix.postRotate(rotationDegrees); + Bitmap expectedBitmap = + Bitmap.createBitmap( + inputBitmap, + /* x= */ 0, + /* y= */ 0, + /* width= */ inputBitmap.getWidth(), + /* height= */ inputBitmap.getHeight(), + rotationMatrix, + /* filter= */ true); - AtomicReference completedFrame = new AtomicReference<>(); FrameProcessor.Listener listener = new FrameProcessor.Listener() { @Override public void onWakeup() {} @Override - public void onError(VideoFrameProcessingException exception) {} + public void onError(VideoFrameProcessingException exception) { + throw new AssertionError(exception); + } @Override public void onFrameProcessed(Frame frame, @Nullable SyncFenceWrapper releaseFence) { @@ -336,40 +354,15 @@ public void onFrameProcessed(Frame frame, @Nullable SyncFenceWrapper releaseFenc releaseFence.close(); } hardwareBuffer.close(); - completedFrame.set(frame); } }; - Format inputFormat = - new Format.Builder() - .setWidth(formatWidth) - .setHeight(formatHeight) - .setRotationDegrees(rotationDegrees) - .setColorInfo(ColorInfo.SDR_BT709_LIMITED) - .build(); - - HardwareBufferFrame inputHardwareBufferFrame = - new DefaultHardwareBufferFrame.Builder(hardwareBuffer).setFormat(inputFormat).build(); - Bitmap actualBitmap = convertAndCaptureBitmap(inputHardwareBufferFrame, listener); - Matrix rotationMatrix = new Matrix(); - rotationMatrix.postRotate(rotationDegrees); - Bitmap expectedBitmap = - Bitmap.createBitmap( - inputBitmap, - /* x= */ 0, - /* y= */ 0, - /* width= */ inputBitmap.getWidth(), - /* height= */ inputBitmap.getHeight(), - rotationMatrix, - /* filter= */ true); - assertThat( getBitmapAveragePixelAbsoluteDifferenceArgb8888( expectedBitmap, actualBitmap, testName.getMethodName())) .isLessThan(MAX_PIXEL_DIFFERENCE); - assertThat(completedFrame.get()).isSameInstanceAs(inputHardwareBufferFrame); } @SdkSuppress(minSdkVersion = 31) @@ -448,6 +441,7 @@ private Bitmap convertAndCaptureBitmap( actualBitmap.set( createArgb8888BitmapFromFocusedGlFramebuffer(textureWidth, textureHeight)); glTextureFrame.release(/* releaseFence= */ null); + assertThat(glTextureFrame.format.rotationDegrees).isEqualTo(0); GlUtil.deleteFbo(fboId); // createArgb8888BitmapFromFocusedGlFramebuffer calls glReadPixels, which syncs // OpenGL diff --git a/libraries/effect/src/main/java/androidx/media3/effect/BitmapToHardwareBufferProcessor.java b/libraries/effect/src/main/java/androidx/media3/effect/BitmapToHardwareBufferProcessor.java index 9c150ad01e9..9cfaa394d88 100644 --- a/libraries/effect/src/main/java/androidx/media3/effect/BitmapToHardwareBufferProcessor.java +++ b/libraries/effect/src/main/java/androidx/media3/effect/BitmapToHardwareBufferProcessor.java @@ -165,9 +165,16 @@ public HardwareBufferFrame process(HardwareBufferFrame inputFrame) { outputFrame = checkNotNull(currentFrame).retain(); } - inputFrame.release(/* releaseFence= */ null); - return outputFrame - .buildUpon() + return new HardwareBufferFrame.Builder( + checkNotNull(outputFrame.hardwareBuffer), + directExecutor(), + /* releaseCallback= */ (fence) -> { + outputFrame.release(fence); + // inputFrame is used when creating the outputFrame synchronously, it can be safely + // released earlier without a fence. Releasing it here with the outputFrame to keep + // backpressuring the upstream. + inputFrame.release(/* releaseFence= */ null); + }) .setFormat(inputFrame.format) .setInternalFrame(nextBitmap) .setReleaseTimeNs(inputFrame.releaseTimeNs) diff --git a/libraries/effect/src/main/java/androidx/media3/effect/DefaultGlFrameProcessor.java b/libraries/effect/src/main/java/androidx/media3/effect/DefaultGlFrameProcessor.java index 6b7c146a559..96b85d2eccf 100644 --- a/libraries/effect/src/main/java/androidx/media3/effect/DefaultGlFrameProcessor.java +++ b/libraries/effect/src/main/java/androidx/media3/effect/DefaultGlFrameProcessor.java @@ -37,13 +37,14 @@ import androidx.media3.common.util.Consumer; import androidx.media3.common.util.ExperimentalApi; import androidx.media3.common.util.Log; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.common.video.AsyncFrame; import androidx.media3.common.video.Frame; import androidx.media3.common.video.FrameProcessor; import androidx.media3.common.video.FrameWriter; import androidx.media3.common.video.HardwareBufferFrame; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.effect.DefaultGlTextureFrameCompositingProcessor.CompositorGlProgram; -import androidx.media3.effect.FrameProcessorUtils.ThrowingRunnable; import com.google.common.collect.ImmutableList; import com.google.common.util.concurrent.ListeningExecutorService; import java.util.Collections; @@ -390,7 +391,7 @@ public void close() { } submitToGlExecutor( () -> { - ImmutableList.Builder closeActions = ImmutableList.builder(); + ImmutableList.Builder> closeActions = ImmutableList.builder(); closeActions.addAll(getReleaseUnqueuedFramesActions()); closeActions.add(hardwareBufferConverter::close); for (int i = 0; i < preProcessingChains.size(); i++) { @@ -402,7 +403,7 @@ public void close() { .add(compositingProcessor::close) .add(postProcessingChain::close) .add(frameWriterGlTextureFrameConsumer::close); - runAllAndAccumulateExceptions(closeActions.build().toArray(new ThrowingRunnable[0])); + runAllAndAccumulateExceptions(closeActions.build().toArray(new ThrowingRunnable[0])); return null; }); } @@ -478,7 +479,7 @@ private void handleError(Exception exception) { } runAllAndAccumulateExceptions( /* errorConsumer= */ exception::addSuppressed, - getReleaseUnqueuedFramesActions().toArray(new ThrowingRunnable[0])); + getReleaseUnqueuedFramesActions().toArray(new ThrowingRunnable[0])); convertedGlTextureFrames.clear(); glTextureFramesQueuedDownstream.clear(); listenerExecutor.execute(() -> listener.onError(VideoFrameProcessingException.from(exception))); @@ -524,8 +525,8 @@ private static int extractSequenceIndex(Frame frame) { return (Integer) checkNotNull(frame.getMetadata().get(KEY_COMPOSITION_SEQUENCE_INDEX)); } - private ImmutableList getReleaseUnqueuedFramesActions() { - ImmutableList.Builder actions = ImmutableList.builder(); + private ImmutableList> getReleaseUnqueuedFramesActions() { + ImmutableList.Builder> actions = ImmutableList.builder(); for (int i = 0; i < convertedGlTextureFrames.size(); i++) { GlTextureFrame glTextureFrame = convertedGlTextureFrames.valueAt(i); if (!glTextureFramesQueuedDownstream.contains(glTextureFrame)) { diff --git a/libraries/effect/src/main/java/androidx/media3/effect/DefaultGlTextureFrameCompositingProcessor.java b/libraries/effect/src/main/java/androidx/media3/effect/DefaultGlTextureFrameCompositingProcessor.java index b6d24a2d41a..3304df25783 100644 --- a/libraries/effect/src/main/java/androidx/media3/effect/DefaultGlTextureFrameCompositingProcessor.java +++ b/libraries/effect/src/main/java/androidx/media3/effect/DefaultGlTextureFrameCompositingProcessor.java @@ -81,6 +81,7 @@ void drawFrame(List framesToComposite, GlTextureInfo outputT @Nullable private Executor pendingWakeupExecutor; + // This is reset when a new batch of frames is queued. private boolean inputStreamEnded; /** @@ -142,6 +143,7 @@ public boolean queue( return false; } + inputStreamEnded = false; if (frames.size() == 1) { return downstreamConsumer.queue(frames.get(0), listenerExecutor, wakeupListener); } diff --git a/libraries/effect/src/main/java/androidx/media3/effect/DefaultVideoCompositor.java b/libraries/effect/src/main/java/androidx/media3/effect/DefaultVideoCompositor.java index 17c772b7411..f50c215e26c 100644 --- a/libraries/effect/src/main/java/androidx/media3/effect/DefaultVideoCompositor.java +++ b/libraries/effect/src/main/java/androidx/media3/effect/DefaultVideoCompositor.java @@ -341,7 +341,7 @@ private synchronized void maybeComposite() * Checks whether {@code inputSources} is able to composite, and if so, returns a list of {@link * FrameInfo}s that should be composited next. * - *

The first input frame info in the list is from the the primary source. An empty list is + *

The first input frame info in the list is from the primary source. An empty list is * returned if {@code inputSources} cannot composite now. */ private synchronized ImmutableList getFramesToComposite() { diff --git a/libraries/effect/src/main/java/androidx/media3/effect/FrameProcessorUtils.java b/libraries/effect/src/main/java/androidx/media3/effect/FrameProcessorUtils.java index a00ed0d0ef7..bd08ac6ed63 100644 --- a/libraries/effect/src/main/java/androidx/media3/effect/FrameProcessorUtils.java +++ b/libraries/effect/src/main/java/androidx/media3/effect/FrameProcessorUtils.java @@ -38,6 +38,7 @@ import androidx.media3.common.util.GlUtil; import androidx.media3.common.util.GlUtil.GlException; import androidx.media3.common.util.Log; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.common.video.AsyncFrame; import androidx.media3.common.video.SyncFenceWrapper; import com.google.common.collect.ImmutableList; @@ -50,7 +51,7 @@ @ExperimentalApi // TODO: b/505721737 Remove once FrameProcessor is production ready. @RequiresApi(26) -public final class FrameProcessorUtils { +/* package */ final class FrameProcessorUtils { private static final String TAG = "FrameProcessorUtils"; private static final long TIMEOUT_MS = 500; @@ -256,12 +257,6 @@ public void onFailure(Throwable t) { directExecutor()); } - /** A runnable that throws an exception. */ - public interface ThrowingRunnable { - /** Runs the operation. */ - void run() throws Exception; - } - /** * Executes multiple throwing actions sequentially, ensuring all are run even if some fail. * @@ -271,7 +266,7 @@ public interface ThrowingRunnable { * @param actions The throwing actions to execute. * @throws VideoFrameProcessingException If any of the actions fail. */ - public static void runAllAndAccumulateExceptions(ThrowingRunnable... actions) + public static void runAllAndAccumulateExceptions(ThrowingRunnable... actions) throws VideoFrameProcessingException { @Nullable VideoFrameProcessingException exception = runAllAndAccumulateExceptionInternal(actions); @@ -291,7 +286,7 @@ public static void runAllAndAccumulateExceptions(ThrowingRunnable... actions) * @param actions The throwing actions to execute. */ public static void runAllAndAccumulateExceptions( - Consumer errorConsumer, ThrowingRunnable... actions) { + Consumer errorConsumer, ThrowingRunnable... actions) { @Nullable VideoFrameProcessingException exception = runAllAndAccumulateExceptionInternal(actions); if (exception != null) { @@ -301,9 +296,9 @@ public static void runAllAndAccumulateExceptions( @Nullable private static VideoFrameProcessingException runAllAndAccumulateExceptionInternal( - ThrowingRunnable... actions) { + ThrowingRunnable... actions) { @Nullable VideoFrameProcessingException firstException = null; - for (ThrowingRunnable action : actions) { + for (ThrowingRunnable action : actions) { if (action == null) { continue; } diff --git a/libraries/effect/src/main/java/androidx/media3/effect/FrameWriterGlTextureFrameConsumer.java b/libraries/effect/src/main/java/androidx/media3/effect/FrameWriterGlTextureFrameConsumer.java index 0e6d2045714..cbcde6091cc 100644 --- a/libraries/effect/src/main/java/androidx/media3/effect/FrameWriterGlTextureFrameConsumer.java +++ b/libraries/effect/src/main/java/androidx/media3/effect/FrameWriterGlTextureFrameConsumer.java @@ -21,6 +21,7 @@ import static androidx.media3.effect.FrameProcessorUtils.releaseEglImageTexture; import static androidx.media3.effect.FrameProcessorUtils.waitAndCloseFence; import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; import android.content.Context; import android.hardware.HardwareBuffer; @@ -28,26 +29,31 @@ import android.opengl.GLES20; import androidx.annotation.Nullable; import androidx.annotation.RequiresApi; +import androidx.media3.common.ColorInfo; +import androidx.media3.common.Format; import androidx.media3.common.VideoFrameProcessingException; import androidx.media3.common.util.ExperimentalApi; import androidx.media3.common.util.GlUtil; import androidx.media3.common.util.GlUtil.GlException; import androidx.media3.common.util.Log; +import androidx.media3.common.util.Size; import androidx.media3.common.video.AsyncFrame; import androidx.media3.common.video.FrameWriter; import androidx.media3.common.video.HardwareBufferFrame; import androidx.media3.common.video.SyncFenceWrapper; import androidx.media3.effect.FrameProcessorUtils.EglImageTextureWrapper; import com.google.common.collect.ImmutableList; +import java.util.Objects; import java.util.concurrent.Executor; import org.checkerframework.checker.nullness.qual.MonotonicNonNull; -/** A {@link GlTextureFrameConsumer} that writes the input to a {@link FrameWriter}. */ +/** Writes input texture frames to a {@link FrameWriter}. */ @ExperimentalApi // TODO: b/505721737 Remove once FrameProcessor is production ready. @RequiresApi(26) /* package */ final class FrameWriterGlTextureFrameConsumer implements GlTextureFrameConsumer { private static final String TAG = "FrameWriterGlTexCons"; + private static final long OUTPUT_USAGE = USAGE_GPU_COLOR_OUTPUT; private final Context context; private final FrameWriter frameWriter; @@ -55,6 +61,9 @@ @Nullable private DefaultShaderProgram defaultShaderProgram; private @MonotonicNonNull EGLDisplay eglDisplay; + private @MonotonicNonNull Size inputSize; + private @MonotonicNonNull ColorInfo inputColorInfo; + private @MonotonicNonNull Format outputFormat; private boolean isFrameWriterConfigured; FrameWriterGlTextureFrameConsumer( @@ -70,10 +79,13 @@ public boolean queue( GlTextureFrame inputFrame, Executor listenerExecutor, Runnable wakeupListener) throws VideoFrameProcessingException { if (!isFrameWriterConfigured) { - frameWriter.configure(inputFrame.format, USAGE_GPU_COLOR_OUTPUT); + outputFormat = establishOutputFormat(inputFrame.format); + frameWriter.configure(outputFormat, OUTPUT_USAGE); isFrameWriterConfigured = true; } + maybeReconfigureShader(inputFrame); + AsyncFrame asyncFrame = frameWriter.dequeueInputFrame(listenerExecutor, wakeupListener); if (asyncFrame == null) { return false; @@ -101,15 +113,9 @@ public boolean queue( /* target= */ GLES20.GL_TEXTURE_2D, /* writesToBoundImage= */ true); - if (defaultShaderProgram == null) { - defaultShaderProgram = - DefaultShaderProgram.create( - context, - /* matrixTransformations= */ ImmutableList.of(), - /* rgbMatrices= */ ImmutableList.of(), - /* useHdr= */ false); - } - defaultShaderProgram.drawFrame(inputFrame.glTextureInfo.texId, inputFrame.presentationTimeUs); + GlUtil.clearFocusedBuffersOpaque(); + checkNotNull(defaultShaderProgram) + .drawFrame(inputFrame.glTextureInfo.texId, inputFrame.presentationTimeUs); GlUtil.checkGlError(); ImmutableList fences = generateSyncFences(/* count= */ 2); if (fences.size() == 2) { @@ -151,8 +157,119 @@ public void signalEndOfStream() { @Override public void close() throws VideoFrameProcessingException { + // Release frame writer first in case releasing the shader program throw + frameWriter.close(); if (defaultShaderProgram != null) { defaultShaderProgram.release(); + defaultShaderProgram = null; + } + } + + /** Establishes the output format based on the first frame. */ + private Format establishOutputFormat(Format inputFormat) { + int rotationDegrees = calculateOutputRotationDegrees(inputFormat); + int outputWidth = + (rotationDegrees == 90 || rotationDegrees == 270) ? inputFormat.height : inputFormat.width; + int outputHeight = + (rotationDegrees == 90 || rotationDegrees == 270) ? inputFormat.width : inputFormat.height; + return updateFormat( + inputFormat, + outputWidth, + outputHeight, + // Sets the degrees that the player needs to rotate. If we rotated 90 degrees, the player + // needs to rotate -90 degrees, which is equivalent to rotating it 270 degrees. + /* rotationDegrees= */ (360 - rotationDegrees) % 360); + } + + /** Reconfigures the shader program if the input size or color space changed. */ + private void maybeReconfigureShader(GlTextureFrame inputFrame) + throws VideoFrameProcessingException { + Format inputFormat = inputFrame.format; + // The frames in the GL pipeline should always be in the intended orientation. + checkArgument(inputFormat.rotationDegrees == 0); + ColorInfo inputColorInfo = checkNotNull(inputFormat.colorInfo); + if (inputSize != null + && inputFormat.width == inputSize.getWidth() + && inputFormat.height == inputSize.getHeight() + && Objects.equals(inputColorInfo, this.inputColorInfo)) { + return; + } + + if (defaultShaderProgram != null) { + defaultShaderProgram.release(); + defaultShaderProgram = null; + } + + // Force physical rotation to match the logical rotation of the established output format. + // The output format stores the rotation that player applies. We convert it back to the degrees + // the pipeline needs to rotate. + int rotationDegrees = (360 - checkNotNull(outputFormat).rotationDegrees) % 360; + + // Flip OpenGL coordinate system back and rotate. + GlMatrixTransformation flipAndRotate = + new ScaleAndRotateTransformation.Builder() + .setScale(/* scaleX= */ 1f, /* scaleY= */ -1f) + .setRotationDegrees(rotationDegrees) + .build(); + + ImmutableList.Builder transformationsBuilder = ImmutableList.builder(); + transformationsBuilder + .add(flipAndRotate) + .add( + Presentation.createForWidthAndHeight( + outputFormat.width, outputFormat.height, Presentation.LAYOUT_SCALE_TO_FIT)); + + defaultShaderProgram = + DefaultShaderProgram.create( + context, + /* matrixTransformations= */ transformationsBuilder.build(), + /* rgbMatrices= */ ImmutableList.of(), + /* useHdr= */ ColorInfo.isTransferHdr(inputColorInfo)); + + inputSize = new Size(inputFormat.width, inputFormat.height); + this.inputColorInfo = inputColorInfo; + Size unusedSize = + defaultShaderProgram.configure( + inputFrame.glTextureInfo.width, inputFrame.glTextureInfo.height); + } + + private int calculateOutputRotationDegrees(Format format) { + if (format.width >= format.height) { + // Input is landscape, no rotation needed. + return 0; + } + + if (frameWriter.getInfo().isSupported(format, OUTPUT_USAGE)) { + // Portrait is supported, no rotation needed. + return 0; } + + // If frameWriter doesn't support portrait, try rotating the input by 90 or 270 degrees to swap + // to landscape dimensions supported by the encoder. + int rotatedWidth = format.height; + int rotatedHeight = format.width; + Format formatRotate90 = + updateFormat(format, rotatedWidth, rotatedHeight, /* rotationDegrees= */ 90); + if (frameWriter.getInfo().isSupported(formatRotate90, OUTPUT_USAGE)) { + return 90; + } + + Format formatRotate270 = + updateFormat(format, rotatedWidth, rotatedHeight, /* rotationDegrees= */ 270); + if (frameWriter.getInfo().isSupported(formatRotate270, OUTPUT_USAGE)) { + return 270; + } + + // Fallback if nothing is supported. + return 0; + } + + private static Format updateFormat(Format format, int width, int height, int rotationDegrees) { + return format + .buildUpon() + .setWidth(width) + .setHeight(height) + .setRotationDegrees(rotationDegrees) + .build(); } } diff --git a/libraries/effect/src/main/java/androidx/media3/effect/GlTextureFrameAggregator.java b/libraries/effect/src/main/java/androidx/media3/effect/GlTextureFrameAggregator.java index e9808e26145..ba52167794c 100644 --- a/libraries/effect/src/main/java/androidx/media3/effect/GlTextureFrameAggregator.java +++ b/libraries/effect/src/main/java/androidx/media3/effect/GlTextureFrameAggregator.java @@ -26,7 +26,7 @@ import androidx.annotation.RequiresApi; import androidx.media3.common.VideoFrameProcessingException; import androidx.media3.common.util.Consumer; -import androidx.media3.effect.FrameProcessorUtils.ThrowingRunnable; +import androidx.media3.common.util.ThrowingRunnable; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.util.concurrent.ListeningExecutorService; @@ -52,6 +52,7 @@ @Nullable private ImmutableSet pendingSequenceIndices; private boolean isClosed; + // This is reset when a new batch of frames is queued. private boolean allInputStreamsEnded; public GlTextureFrameAggregator( @@ -288,12 +289,12 @@ private ImmutableList retrieveAndClearPendingFrames() { } private void releaseFrames(List frames) throws VideoFrameProcessingException { - ImmutableList.Builder releaseActions = new ImmutableList.Builder<>(); + ImmutableList.Builder> releaseActions = new ImmutableList.Builder<>(); for (int i = 0; i < frames.size(); i++) { GlTextureFrame frame = frames.get(i); releaseActions.add(() -> frame.release(/* releaseFence= */ null)); } - runAllAndAccumulateExceptions(releaseActions.build().toArray(new ThrowingRunnable[0])); + runAllAndAccumulateExceptions(releaseActions.build().toArray(new ThrowingRunnable[0])); } private final class InputFrameConsumer implements GlTextureFrameConsumer { @@ -301,6 +302,7 @@ private final class InputFrameConsumer implements GlTextureFrameConsumer { @Nullable private Runnable pendingWakeupListener; @Nullable private Executor pendingWakeupExecutor; @Nullable private GlTextureFrame pendingFrame; + // This is reset when a new batch of frames is queued. private boolean isEnded; private boolean isActive; @@ -324,6 +326,8 @@ public boolean queue(GlTextureFrame frame, Executor listenerExecutor, Runnable w return false; } + isEnded = false; + allInputStreamsEnded = false; pendingFrame = frame; tryQueueToCompositingProcessor(); // Returning true to signal the input frame is queued. If queueing to the compositing diff --git a/libraries/effect/src/main/java/androidx/media3/effect/GlTextureFrameProcessorChain.java b/libraries/effect/src/main/java/androidx/media3/effect/GlTextureFrameProcessorChain.java index ef49887f156..76ab5e6fef8 100644 --- a/libraries/effect/src/main/java/androidx/media3/effect/GlTextureFrameProcessorChain.java +++ b/libraries/effect/src/main/java/androidx/media3/effect/GlTextureFrameProcessorChain.java @@ -27,8 +27,8 @@ import androidx.media3.common.GlObjectsProvider; import androidx.media3.common.VideoFrameProcessingException; import androidx.media3.common.util.Consumer; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.common.util.Util; -import androidx.media3.effect.FrameProcessorUtils.ThrowingRunnable; import com.google.common.collect.ImmutableList; import com.google.common.util.concurrent.ListeningExecutorService; import java.util.ArrayList; @@ -156,7 +156,7 @@ private ImmutableList extractEffects(GlTextureFrame frame) { } private void closeAllProcessors() throws VideoFrameProcessingException { - ThrowingRunnable[] closeActions = new ThrowingRunnable[effectProcessorChain.size()]; + ThrowingRunnable[] closeActions = new ThrowingRunnable[effectProcessorChain.size()]; for (int i = 0; i < effectProcessorChain.size(); i++) { closeActions[i] = effectProcessorChain.get(i)::close; } diff --git a/libraries/effect/src/main/java/androidx/media3/effect/HardwareBufferToGlTextureConverter.java b/libraries/effect/src/main/java/androidx/media3/effect/HardwareBufferToGlTextureConverter.java index 62da11b6324..8d11c7ee2cf 100644 --- a/libraries/effect/src/main/java/androidx/media3/effect/HardwareBufferToGlTextureConverter.java +++ b/libraries/effect/src/main/java/androidx/media3/effect/HardwareBufferToGlTextureConverter.java @@ -97,8 +97,9 @@ public GlTextureFrame convert( @Nullable EglImageTextureWrapper eglImageTextureWrapper = null; int internalTexId = C.INDEX_UNSET; Format inputFormat = hardwareBufferFrame.getFormat(); - int outputWidth = inputFormat.width; - int outputHeight = inputFormat.height; + boolean isRotated = inputFormat.rotationDegrees == 90 || inputFormat.rotationDegrees == 270; + int outputWidth = isRotated ? inputFormat.height : inputFormat.width; + int outputHeight = isRotated ? inputFormat.width : inputFormat.height; try { if (eglDisplay == null) { eglDisplay = GlUtil.getDefaultEglDisplay(); @@ -198,7 +199,16 @@ public GlTextureFrame convert( } }) .setPresentationTimeUs(hardwareBufferFrame.getContentTimeUs()) - .setFormat(hardwareBufferFrame.getFormat()) + .setFormat( + hardwareBufferFrame + .getFormat() + .buildUpon() + .setWidth(outputWidth) + .setHeight(outputHeight) + // Reset rotation to 0 because we rotated the frame physically with OpenGL. The + // pipeline should always receive frames in their intended orientation. + .setRotationDegrees(0) + .build()) .setMetadata(hardwareBufferFrame.getMetadata()) .build(); } diff --git a/libraries/effect/src/main/res/raw/fragment_shader_transformation_external_yuv_es3.glsl b/libraries/effect/src/main/res/raw/fragment_shader_transformation_external_yuv_es3.glsl index d28264aeb9b..5a8dcba4e10 100644 --- a/libraries/effect/src/main/res/raw/fragment_shader_transformation_external_yuv_es3.glsl +++ b/libraries/effect/src/main/res/raw/fragment_shader_transformation_external_yuv_es3.glsl @@ -305,5 +305,8 @@ void main() { ? vec4(applyBt2020ToBt709Ootf(opticalColorBt2020), 1.0) : vec4(scaleHdrLuminance(opticalColorBt2020), 1.0); vec4 transformedColors = uRgbMatrix * opticalColor; - outColor = vec4(applyOetf(transformedColors.rgb), 1.0); + vec3 clampedColors = (uApplyHdrToSdrToneMapping == 1) + ? clamp(transformedColors.rgb, 0.0, 1.0) + : max(transformedColors.rgb, 0.0); + outColor = vec4(applyOetf(clampedColors), 1.0); } diff --git a/libraries/effect/src/main/res/raw/fragment_shader_transformation_hdr_internal_es3.glsl b/libraries/effect/src/main/res/raw/fragment_shader_transformation_hdr_internal_es3.glsl index b50114187d1..f62291d4bd5 100644 --- a/libraries/effect/src/main/res/raw/fragment_shader_transformation_hdr_internal_es3.glsl +++ b/libraries/effect/src/main/res/raw/fragment_shader_transformation_hdr_internal_es3.glsl @@ -292,5 +292,8 @@ void main() { ? vec4(applyBt2020ToBt709Ootf(opticalColorBt2020), 1.0) : vec4(scaleHdrLuminance(opticalColorBt2020), 1.0); vec4 transformedColors = uRgbMatrix * opticalColor; - outColor = vec4(applyOetf(transformedColors.rgb), 1.0); + vec3 clampedColors = (uApplyHdrToSdrToneMapping == 1) + ? clamp(transformedColors.rgb, 0.0, 1.0) + : max(transformedColors.rgb, 0.0); + outColor = vec4(applyOetf(clampedColors), 1.0); } diff --git a/libraries/effect/src/test/java/androidx/media3/effect/BitmapToHardwareBufferProcessorTest.java b/libraries/effect/src/test/java/androidx/media3/effect/BitmapToHardwareBufferProcessorTest.java new file mode 100644 index 00000000000..d312006583d --- /dev/null +++ b/libraries/effect/src/test/java/androidx/media3/effect/BitmapToHardwareBufferProcessorTest.java @@ -0,0 +1,90 @@ +/* + * Copyright 2026 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 androidx.media3.effect; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.util.concurrent.MoreExecutors.directExecutor; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import android.graphics.Bitmap; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.robolectric.annotation.Config; + +/** Robolectric tests for {@link BitmapToHardwareBufferProcessor}. */ +@RunWith(AndroidJUnit4.class) +@Config(minSdk = 26) // HardwareBuffers only exist on API26+. +public final class BitmapToHardwareBufferProcessorTest { + + private ExecutorService executorService; + private BitmapToHardwareBufferProcessor processor; + private HardwareBufferJniWrapper mockJniWrapper; + + @Before + public void setUp() { + executorService = Executors.newSingleThreadExecutor(); + mockJniWrapper = mock(HardwareBufferJniWrapper.class); + when(mockJniWrapper.nativeCopyBitmapToHardwareBuffer(any(), any())).thenReturn(true); + + processor = + new BitmapToHardwareBufferProcessor( + mockJniWrapper, + /* internalExecutor= */ executorService, + /* errorExecutor= */ directExecutor(), + /* errorCallback= */ (e) -> { + throw new AssertionError(e); + }); + } + + @After + public void tearDown() { + if (processor != null) { + processor.close(); + } + if (executorService != null) { + executorService.shutdown(); + } + } + + @Test + public void process_defersInputFrameReleaseUntilOutputFrameRelease() { + CountDownLatch releasedLatch = new CountDownLatch(1); + HardwareBufferFrame inputFrame = + new HardwareBufferFrame.Builder( + /* hardwareBuffer= */ null, + directExecutor(), + /* releaseCallback= */ (fence) -> releasedLatch.countDown()) + .setInternalFrame(Bitmap.createBitmap(10, 10, Bitmap.Config.ARGB_8888)) + .build(); + + HardwareBufferFrame outputFrame = processor.process(inputFrame); + + // The output frame was generated, but the input frame should NOT be released yet. + assertThat(releasedLatch.getCount()).isEqualTo(1); + + // Release the downstream output frame should trigger releasing the inputFrame + outputFrame.release(/* releaseFence= */ null); + assertThat(releasedLatch.getCount()).isEqualTo(0); + } +} diff --git a/libraries/effect/src/test/java/androidx/media3/effect/DefaultGlTextureFrameCompositingProcessorTest.java b/libraries/effect/src/test/java/androidx/media3/effect/DefaultGlTextureFrameCompositingProcessorTest.java index 08af529b044..27576f7fc40 100644 --- a/libraries/effect/src/test/java/androidx/media3/effect/DefaultGlTextureFrameCompositingProcessorTest.java +++ b/libraries/effect/src/test/java/androidx/media3/effect/DefaultGlTextureFrameCompositingProcessorTest.java @@ -250,6 +250,59 @@ public void queue_multipleFrames_preservesPrimaryFrameMetadata() throws Exceptio .isEqualTo("CUSTOM_VALUE"); } + @Test + public void queue_afterSignalEndOfStream_doesNotPrematurelySignalEos() throws Exception { + GlTextureFrame frame1 = createGlTextureFrame(/* texId= */ 0, /* sequenceIndex= */ 0); + GlTextureFrame frame2 = createGlTextureFrame(/* texId= */ 1, /* sequenceIndex= */ 1); + assertThat( + compositingProcessor.queue( + ImmutableList.of(frame1, frame2), directExecutor(), () -> {})) + .isTrue(); + assertThat(downstreamConsumer.framesReceived).isEqualTo(1); + + compositingProcessor.signalEndOfStream(); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isTrue(); + + downstreamConsumer.signalEndOfStreamCalled = false; + + GlTextureFrame frame3 = createGlTextureFrame(/* texId= */ 2, /* sequenceIndex= */ 0); + GlTextureFrame frame4 = createGlTextureFrame(/* texId= */ 3, /* sequenceIndex= */ 1); + assertThat( + compositingProcessor.queue( + ImmutableList.of(frame3, frame4), directExecutor(), () -> {})) + .isTrue(); + + assertThat(downstreamConsumer.framesReceived).isEqualTo(2); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isFalse(); + + compositingProcessor.signalEndOfStream(); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isTrue(); + } + + @Test + public void queue_singleFrameAfterSignalEndOfStream_doesNotPrematurelySignalEos() + throws Exception { + GlTextureFrame frame1 = createGlTextureFrame(/* texId= */ 0, /* sequenceIndex= */ 0); + assertThat(compositingProcessor.queue(ImmutableList.of(frame1), directExecutor(), () -> {})) + .isTrue(); + assertThat(downstreamConsumer.framesReceived).isEqualTo(1); + + compositingProcessor.signalEndOfStream(); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isTrue(); + + downstreamConsumer.signalEndOfStreamCalled = false; + + GlTextureFrame frame2 = createGlTextureFrame(/* texId= */ 1, /* sequenceIndex= */ 0); + assertThat(compositingProcessor.queue(ImmutableList.of(frame2), directExecutor(), () -> {})) + .isTrue(); + + assertThat(downstreamConsumer.framesReceived).isEqualTo(2); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isFalse(); + + compositingProcessor.signalEndOfStream(); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isTrue(); + } + private static GlTextureFrame createGlTextureFrame(int texId, int sequenceIndex) { return new GlTextureFrame.Builder( new GlTextureInfo( diff --git a/libraries/effect/src/test/java/androidx/media3/effect/GlTextureFrameAggregatorTest.java b/libraries/effect/src/test/java/androidx/media3/effect/GlTextureFrameAggregatorTest.java index a0ada35128a..1ed5a9b74a9 100644 --- a/libraries/effect/src/test/java/androidx/media3/effect/GlTextureFrameAggregatorTest.java +++ b/libraries/effect/src/test/java/androidx/media3/effect/GlTextureFrameAggregatorTest.java @@ -214,6 +214,63 @@ public void signalEndOfStream_whenCompositorRejectsInput_defersEosUntilWakeup() assertThat(downstreamConsumer.signalEndOfStreamCalled).isTrue(); } + @Test + public void signalEndOfStream_afterEndOfStreamAndQueue_signalsDownstreamAgain() throws Exception { + frameAggregator.configureSequenceIndices(ImmutableSet.of(0)); + GlTextureFrame frame1 = createGlTextureFrame(/* sequenceIndex= */ 0); + + assertThat(frameAggregator.getInputConsumer(0).queue(frame1, directExecutor(), () -> {})) + .isTrue(); + frameAggregator.getInputConsumer(0).signalEndOfStream(); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isTrue(); + + downstreamConsumer.signalEndOfStreamCalled = false; + + GlTextureFrame frame2 = createGlTextureFrame(/* sequenceIndex= */ 0); + assertThat(frameAggregator.getInputConsumer(0).queue(frame2, directExecutor(), () -> {})) + .isTrue(); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isFalse(); + + frameAggregator.getInputConsumer(0).signalEndOfStream(); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isTrue(); + } + + @Test + public void + signalEndOfStream_afterEndOfStreamAndQueueWithMultipleSequences_signalsDownstreamAgain() + throws Exception { + frameAggregator.configureSequenceIndices(/* requestedSequenceIndices= */ ImmutableSet.of(0, 1)); + // Batch A, sequences 0 and 1 + GlTextureFrame frame0A = createGlTextureFrame(/* sequenceIndex= */ 0); + GlTextureFrame frame1A = createGlTextureFrame(/* sequenceIndex= */ 1); + + assertThat(frameAggregator.getInputConsumer(0).queue(frame0A, directExecutor(), () -> {})) + .isTrue(); + assertThat(frameAggregator.getInputConsumer(1).queue(frame1A, directExecutor(), () -> {})) + .isTrue(); + frameAggregator.getInputConsumer(0).signalEndOfStream(); + frameAggregator.getInputConsumer(1).signalEndOfStream(); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isTrue(); + + downstreamConsumer.signalEndOfStreamCalled = false; + // Batch B, sequences 0 and 1 + GlTextureFrame frame0B = createGlTextureFrame(/* sequenceIndex= */ 0); + GlTextureFrame frame1B = createGlTextureFrame(/* sequenceIndex= */ 1); + assertThat(frameAggregator.getInputConsumer(0).queue(frame0B, directExecutor(), () -> {})) + .isTrue(); + assertThat(frameAggregator.getInputConsumer(1).queue(frame1B, directExecutor(), () -> {})) + .isTrue(); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isFalse(); + + frameAggregator.getInputConsumer(0).signalEndOfStream(); + // Downstream EOS is not yet signaled because sequence 1 hasn't signaled EOS since frame1B. + assertThat(downstreamConsumer.signalEndOfStreamCalled).isFalse(); + + // Verify downstream EOS is signaled only after sequence 1 also signals EOS again. + frameAggregator.getInputConsumer(1).signalEndOfStream(); + assertThat(downstreamConsumer.signalEndOfStreamCalled).isTrue(); + } + @Test public void queue_whenDownstreamThrowsVideoFrameProcessingException_throwsIllegalStateException() throws Exception { diff --git a/libraries/effect_ndk/proguard-rules.txt b/libraries/effect_ndk/proguard-rules.txt new file mode 100644 index 00000000000..5264ca5ff73 --- /dev/null +++ b/libraries/effect_ndk/proguard-rules.txt @@ -0,0 +1,6 @@ +# Proguard rules specific to the effect NDK module. + +# This prevents the names of native methods from being obfuscated. +-keep,includedescriptorclasses class androidx.media3.effect.ndk.** { + native ; +} diff --git a/libraries/effect_ndk/src/main/jni/CMakeLists.txt b/libraries/effect_ndk/src/main/jni/CMakeLists.txt index 635554366e6..4e25dc5363c 100644 --- a/libraries/effect_ndk/src/main/jni/CMakeLists.txt +++ b/libraries/effect_ndk/src/main/jni/CMakeLists.txt @@ -30,7 +30,9 @@ find_library(jnigraphics-lib jnigraphics) add_library(${PROJECT_NAME} SHARED hardware_buffer_jni.cc) - +set_target_properties(${PROJECT_NAME} PROPERTIES + CXX_VISIBILITY_PRESET hidden + VISIBILITY_INLINES_HIDDEN ON) target_link_libraries(${PROJECT_NAME} ${log-lib} diff --git a/libraries/effect_ndk/src/main/jni/hardware_buffer_jni.cc b/libraries/effect_ndk/src/main/jni/hardware_buffer_jni.cc index 103962e8117..1b2722e03f7 100644 --- a/libraries/effect_ndk/src/main/jni/hardware_buffer_jni.cc +++ b/libraries/effect_ndk/src/main/jni/hardware_buffer_jni.cc @@ -59,39 +59,9 @@ static void initializeEGLFunctions() { } } -jint JNI_OnLoad(JavaVM* vm, void* reserved) { - JNIEnv* env; - if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { - return -1; - } - - if (API_AT_LEAST(26)) { - s_AHardwareBuffer_fromHardwareBuffer = AHardwareBuffer_fromHardwareBuffer; - s_AHardwareBuffer_describe = AHardwareBuffer_describe; - s_AHardwareBuffer_lock = AHardwareBuffer_lock; - s_AHardwareBuffer_unlock = AHardwareBuffer_unlock; - } else { - LOGE( - "AHardwareBuffer APIs are not available on this Android version (API < " - "26)"); - return -1; - } - - initializeEGLFunctions(); - if (eglCreateImageKHR == nullptr || - eglGetNativeClientBufferANDROID == nullptr || - glEGLImageTargetTexture2DOES == nullptr || - eglDestroyImageKHR == nullptr) { - LOGE("Failed to get addresses of GL/EGL functions."); - return -1; - } - return JNI_VERSION_1_6; -} - -extern "C" JNIEXPORT jlong JNICALL -Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeCreateEglImageFromHardwareBuffer( - JNIEnv* env, jobject /* this */, jlong displayHandle, - jobject hardwareBufferJava) { +jlong nativeCreateEglImageFromHardwareBuffer(JNIEnv* env, jobject /* this */, + jlong displayHandle, + jobject hardwareBufferJava) { EGLDisplay display = reinterpret_cast(displayHandle); if (display == EGL_NO_DISPLAY) { LOGE("Invalid EGL display"); @@ -119,9 +89,8 @@ Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeCreateEglImageFromHardwa return (jlong)eglImage; } -extern "C" JNIEXPORT jboolean JNICALL -Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeBindEGLImage( - JNIEnv* env, jobject clazz, jint target, jlong eglImageHandle) { +jboolean nativeBindEGLImage(JNIEnv* /* env */, jobject /* this */, jint target, + jlong eglImageHandle) { if (eglImageHandle == 0) { LOGE("Invalid eglImageHandle (0)"); return JNI_FALSE; @@ -140,10 +109,9 @@ Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeBindEGLImage( return JNI_TRUE; } -extern "C" JNIEXPORT jboolean JNICALL -Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeDestroyEGLImage( - JNIEnv* env, jobject clazz, jlong displayHandle, jlong imageHandle) { - if (imageHandle == 0) { +jboolean nativeDestroyEGLImage(JNIEnv* /* env */, jobject /* this */, + jlong displayHandle, jlong eglImageHandle) { + if (eglImageHandle == 0) { LOGE("Invalid eglImageHandle (0)"); return JNI_FALSE; } @@ -153,7 +121,7 @@ Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeDestroyEGLImage( return JNI_FALSE; } - EGLImageKHR image = reinterpret_cast(imageHandle); + EGLImageKHR image = reinterpret_cast(eglImageHandle); EGLBoolean result = eglDestroyImageKHR(display, image); if (result == EGL_TRUE) { @@ -164,12 +132,12 @@ Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeDestroyEGLImage( } } -extern "C" JNIEXPORT jboolean JNICALL -Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeCopyBitmapToHardwareBuffer( - JNIEnv* env, jobject clazz, jobject bitmap, jobject hardwareBuffer) { +jboolean nativeCopyBitmapToHardwareBuffer(JNIEnv* env, jobject /* this */, + jobject bitmap, + jobject hardwareBufferJava) { AHardwareBuffer* hb; if (API_AT_LEAST(26)) { - hb = s_AHardwareBuffer_fromHardwareBuffer(env, hardwareBuffer); + hb = s_AHardwareBuffer_fromHardwareBuffer(env, hardwareBufferJava); } else { LOGE( "AHardwareBuffer APIs are not available on this Android version (API < " @@ -254,9 +222,10 @@ Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeCopyBitmapToHardwareBuff return success; } -extern "C" JNIEXPORT jboolean JNICALL -Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeCopyHardwareBufferToHardwareBuffer( - JNIEnv* env, jobject clazz, jobject srcHbJava, jobject dstHbJava) { +jboolean nativeCopyHardwareBufferToHardwareBuffer(JNIEnv* env, + jobject /* this */, + jobject srcHbJava, + jobject dstHbJava) { if (env->IsSameObject(srcHbJava, dstHbJava)) { return JNI_TRUE; } @@ -338,3 +307,59 @@ Java_androidx_media3_effect_ndk_HardwareBufferJni_nativeCopyHardwareBufferToHard return JNI_TRUE; } + +extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) { + JNIEnv* env; + if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_6) != JNI_OK) { + return -1; + } + + if (API_AT_LEAST(26)) { + s_AHardwareBuffer_fromHardwareBuffer = AHardwareBuffer_fromHardwareBuffer; + s_AHardwareBuffer_describe = AHardwareBuffer_describe; + s_AHardwareBuffer_lock = AHardwareBuffer_lock; + s_AHardwareBuffer_unlock = AHardwareBuffer_unlock; + } else { + LOGE( + "AHardwareBuffer APIs are not available on this Android version (API < " + "26)"); + return -1; + } + + initializeEGLFunctions(); + if (eglCreateImageKHR == nullptr || + eglGetNativeClientBufferANDROID == nullptr || + glEGLImageTargetTexture2DOES == nullptr || + eglDestroyImageKHR == nullptr) { + LOGE("Failed to get addresses of GL/EGL functions."); + return -1; + } + + jclass clazz = env->FindClass("androidx/media3/effect/ndk/HardwareBufferJni"); + if (!clazz) { + LOGE("JNI_OnLoad: FindClass failed for HardwareBufferJni"); + return -1; + } + static const JNINativeMethod kMethods[] = { + {"nativeCreateEglImageFromHardwareBuffer", + "(JLandroid/hardware/HardwareBuffer;)J", + reinterpret_cast(nativeCreateEglImageFromHardwareBuffer)}, + {"nativeBindEGLImage", "(IJ)Z", + reinterpret_cast(nativeBindEGLImage)}, + {"nativeDestroyEGLImage", "(JJ)Z", + reinterpret_cast(nativeDestroyEGLImage)}, + {"nativeCopyBitmapToHardwareBuffer", + "(Landroid/graphics/Bitmap;Landroid/hardware/HardwareBuffer;)Z", + reinterpret_cast(nativeCopyBitmapToHardwareBuffer)}, + {"nativeCopyHardwareBufferToHardwareBuffer", + "(Landroid/hardware/HardwareBuffer;Landroid/hardware/HardwareBuffer;)Z", + reinterpret_cast(nativeCopyHardwareBufferToHardwareBuffer)}, + }; + if (env->RegisterNatives(clazz, kMethods, + sizeof(kMethods) / sizeof(kMethods[0])) < 0) { + LOGE("JNI_OnLoad: RegisterNatives failed for HardwareBufferJni"); + return -1; + } + + return JNI_VERSION_1_6; +} diff --git a/libraries/exoplayer/src/androidTest/java/androidx/media3/exoplayer/audio/DefaultAudioSinkTest.java b/libraries/exoplayer/src/androidTest/java/androidx/media3/exoplayer/audio/DefaultAudioSinkTest.java index c392e95eb62..006582ca636 100644 --- a/libraries/exoplayer/src/androidTest/java/androidx/media3/exoplayer/audio/DefaultAudioSinkTest.java +++ b/libraries/exoplayer/src/androidTest/java/androidx/media3/exoplayer/audio/DefaultAudioSinkTest.java @@ -17,20 +17,24 @@ import static androidx.media3.common.util.Util.sampleCountToDurationUs; import static androidx.media3.common.util.Util.usToMs; -import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation; import static com.google.common.collect.Iterables.getLast; import static com.google.common.truth.Truth.assertThat; import android.content.Context; +import android.os.Handler; +import android.os.HandlerThread; import androidx.media3.common.C; import androidx.media3.common.Format; import androidx.media3.common.MimeTypes; +import androidx.media3.common.util.ThrowingRunnable; +import androidx.media3.common.util.Util; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; import androidx.test.filters.SdkSuppress; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.ArrayList; +import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicReference; @@ -43,12 +47,16 @@ public class DefaultAudioSinkTest { @Test @SdkSuppress(minSdkVersion = 24) // TODO: b/399130330 - Debug why this fails on API 23. - public void audioTrackExceedsSharedMemory_retriesUntilOngoingReleasesAreDone() throws Exception { + public void + audioTrackExceedsSharedMemory_playbackThreadStillAlive_retriesUntilOngoingReleasesAreDone() + throws Exception { Context context = ApplicationProvider.getApplicationContext(); + Handler mainHandler = Util.createHandlerForCurrentOrMainLooper(); // Create audio sinks in parallel until we exceed the device's shared audio memory. ArrayList audioSinks = new ArrayList<>(); while (true) { - runOnMainSync( + runOnHandlerSync( + mainHandler, () -> { AudioOutputProvider defaultProvider = new AudioTrackAudioOutputProvider.Builder(context).build(); @@ -71,7 +79,7 @@ public OutputConfig getOutputConfig(FormatConfig formatConfig) audioSinks.add(audioSink); }); try { - configureAudioSinkAndFeedData(getLast(audioSinks)); + configureAudioSinkAndFeedDataOnHandler(mainHandler, getLast(audioSinks)); } catch (Exception e) { // Expected to happen once we reached the shared audio memory limit of the device. break; @@ -79,19 +87,21 @@ public OutputConfig getOutputConfig(FormatConfig formatConfig) } // Trigger release of one sink and immediately try the failed sink again. This should // now succeed even if the sink is released asynchronously. - runOnMainSync( + runOnHandlerSync( + mainHandler, () -> { audioSinks.get(0).flush(); audioSinks.get(0).release(); }); try { - configureAudioSinkAndFeedData(getLast(audioSinks)); + configureAudioSinkAndFeedDataOnHandler(mainHandler, getLast(audioSinks)); } catch (Exception e) { throw new IllegalStateException(e); } // Clean-up - runOnMainSync( + runOnHandlerSync( + mainHandler, () -> { for (int i = 1; i < audioSinks.size(); i++) { audioSinks.get(i).flush(); @@ -100,6 +110,114 @@ public OutputConfig getOutputConfig(FormatConfig formatConfig) }); } + @Test + @SdkSuppress(minSdkVersion = 24) + public void + audioTrackExceedsSharedMemory_playbackThreadNotAlive_retriesUntilOngoingReleasesAreDone() + throws Exception { + Context context = ApplicationProvider.getApplicationContext(); + Handler mainHandler = Util.createHandlerForCurrentOrMainLooper(); + // Create audio sinks in parallel until we exceed the device's shared audio memory. + ArrayList mainThreadSinks = new ArrayList<>(); + while (true) { + AtomicReference sinkRef = new AtomicReference<>(); + runOnHandlerSync( + mainHandler, + () -> { + AudioOutputProvider defaultProvider = + new AudioTrackAudioOutputProvider.Builder(context).build(); + DefaultAudioSink audioSink = + new DefaultAudioSink.Builder(context) + .setAudioOutputProvider( + new ForwardingAudioOutputProvider(defaultProvider) { + @Override + public OutputConfig getOutputConfig(FormatConfig formatConfig) + throws ConfigurationException { + return super.getOutputConfig(formatConfig) + .buildUpon() + .setBufferSize(2_000_000) + .build(); + } + }) + .build(); + sinkRef.set(audioSink); + mainThreadSinks.add(audioSink); + }); + try { + // Configure the audio sinks on the main thread. + configureAudioSinkAndFeedDataOnHandler(mainHandler, sinkRef.get()); + } catch (Exception e) { + // Expected to happen once we reached the shared audio memory limit. + break; + } + } + + // Free one audio sink on the main thread so we have room to create one sink on the background + // playback thread. + runOnHandlerSync( + mainHandler, + () -> { + mainThreadSinks.get(0).flush(); + mainThreadSinks.get(0).release(); + }); + mainThreadSinks.remove(0); + + HandlerThread playbackThread = new HandlerThread("PlaybackThread"); + playbackThread.start(); + Handler playbackHandler = new Handler(playbackThread.getLooper()); + // Create and configure one audio sink on the background playback thread. + AtomicReference bgSinkRef = new AtomicReference<>(); + runOnHandlerSync( + playbackHandler, + () -> { + AudioOutputProvider defaultProvider = + new AudioTrackAudioOutputProvider.Builder(context).build(); + DefaultAudioSink audioSink = + new DefaultAudioSink.Builder(context) + .setAudioOutputProvider( + new ForwardingAudioOutputProvider(defaultProvider) { + @Override + public OutputConfig getOutputConfig(FormatConfig formatConfig) + throws ConfigurationException { + return super.getOutputConfig(formatConfig) + .buildUpon() + .setBufferSize(2_000_000) + .build(); + } + }) + .build(); + bgSinkRef.set(audioSink); + }); + configureAudioSinkAndFeedDataOnHandler(playbackHandler, bgSinkRef.get()); + + // Trigger release of the background sink and quit the thread. This simulates the player being + // destroyed. + runOnHandlerSync( + playbackHandler, + () -> { + bgSinkRef.get().flush(); + bgSinkRef.get().release(); + }); + playbackThread.quit(); + + // Immediately configure an audio sink again on the main thread. + try { + configureAudioSinkAndFeedDataOnHandler(mainHandler, getLast(mainThreadSinks)); + } catch (Exception e) { + throw new IllegalStateException(e); + } + + // Clean-up all main thread sinks safely on the main thread. + runOnHandlerSync( + mainHandler, + () -> { + for (DefaultAudioSink sink : mainThreadSinks) { + sink.flush(); + sink.release(); + } + }); + } + @Test @SdkSuppress(minSdkVersion = 24) // The test depends on AudioTrack#getUnderrunCount() (API 24+). public void audioTrackUnderruns_callsOnUnderrun() throws Exception { @@ -152,7 +270,8 @@ public void onSkipSilenceEnabledChanged(boolean skipSilenceEnabled) {} sampleCountToDurationUs(/* sampleCount= */ 25, /* sampleRate= */ 44_100); ByteBuffer smallBuffer = ByteBuffer.allocateDirect(50).order(ByteOrder.nativeOrder()); - runOnMainSync( + runOnHandlerSync( + Util.createHandlerForCurrentOrMainLooper(), () -> { try { sink.configure(new AudioSink.AudioSinkConfig.Builder(format).build()); @@ -182,9 +301,11 @@ public void onSkipSilenceEnabledChanged(boolean skipSilenceEnabled) {} assertThat(underrunCount.get()).isGreaterThan(0); } - private void configureAudioSinkAndFeedData(DefaultAudioSink audioSink) throws Exception { + private void configureAudioSinkAndFeedDataOnHandler(Handler handler, DefaultAudioSink audioSink) + throws Exception { ByteBuffer buffer = ByteBuffer.allocateDirect(8000).order(ByteOrder.nativeOrder()); - runOnMainSync( + runOnHandlerSync( + handler, () -> { Format format = new Format.Builder() @@ -198,7 +319,8 @@ private void configureAudioSinkAndFeedData(DefaultAudioSink audioSink) throws Ex }); AtomicBoolean handledBuffer = new AtomicBoolean(); while (!handledBuffer.get()) { - runOnMainSync( + runOnHandlerSync( + handler, () -> handledBuffer.set( audioSink.handleBuffer( @@ -206,23 +328,23 @@ private void configureAudioSinkAndFeedData(DefaultAudioSink audioSink) throws Ex } } - private static void runOnMainSync(ThrowingRunnable runnable) throws Exception { - AtomicReference exceptionOnMain = new AtomicReference<>(); - getInstrumentation() - .runOnMainSync( - () -> { - try { - runnable.run(); - } catch (Exception e) { - exceptionOnMain.set(e); - } - }); - if (exceptionOnMain.get() != null) { - throw exceptionOnMain.get(); + private static void runOnHandlerSync(Handler handler, ThrowingRunnable runnable) + throws Exception { + AtomicReference exceptionOnHandler = new AtomicReference<>(); + CountDownLatch latch = new CountDownLatch(1); + handler.post( + () -> { + try { + runnable.run(); + } catch (Exception e) { + exceptionOnHandler.set(e); + } finally { + latch.countDown(); + } + }); + latch.await(); + if (exceptionOnHandler.get() != null) { + throw exceptionOnHandler.get(); } } - - private interface ThrowingRunnable { - void run() throws Exception; - } } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoPlayerImplInternal.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoPlayerImplInternal.java index 3f039101ca5..264f9dd6e2e 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoPlayerImplInternal.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoPlayerImplInternal.java @@ -57,6 +57,7 @@ import androidx.media3.common.Player.PlaybackSuppressionReason; import androidx.media3.common.Player.RepeatMode; import androidx.media3.common.Timeline; +import androidx.media3.common.TrackSelectionParameters; import androidx.media3.common.audio.AudioFocusManager; import androidx.media3.common.util.Clock; import androidx.media3.common.util.ConditionVariable; @@ -691,8 +692,8 @@ public void onContinueLoadingRequested(MediaPeriod source) { // TrackSelector.InvalidationListener implementation. @Override - public void onTrackSelectionsInvalidated() { - handler.sendEmptyMessage(MSG_TRACK_SELECTION_INVALIDATED); + public void onTrackSelectionsInvalidated(@Nullable TrackSelectionParameters parameters) { + handler.obtainMessage(MSG_TRACK_SELECTION_INVALIDATED, parameters).sendToTarget(); } @Override @@ -807,6 +808,8 @@ public boolean handleMessage(Message msg) { handleContinueLoadingRequested((MediaPeriod) msg.obj); break; case MSG_TRACK_SELECTION_INVALIDATED: + @Nullable TrackSelectionParameters parameters = (TrackSelectionParameters) msg.obj; + trackSelector.onParametersActivated(parameters); reselectTracksInternal(); break; case MSG_PLAYBACK_PARAMETERS_CHANGED_INTERNAL: @@ -1467,6 +1470,7 @@ private void doSomeWork() throws ExoPlaybackException, IOException { boolean renderersEnded = true; boolean renderersAllowPlayback = true; + boolean hasActiveVideoOrImageRenderer = false; if (playingPeriodHolder.prepared) { rendererPositionElapsedRealtimeUs = msToUs(clock.elapsedRealtime()); playingPeriodHolder.mediaPeriod.discardBuffer( @@ -1484,6 +1488,13 @@ private void doSomeWork() throws ExoPlaybackException, IOException { // getting stuck if tracks in the current period have uneven durations and are still being // read by another renderer. See: https://github.com/google/ExoPlayer/issues/1874. renderersEnded = renderersEnded && renderer.isEnded(); + if (seekIsPendingWhileScrubbing + && renderer.isRendererEnabled() + && (renderer.getTrackType() == C.TRACK_TYPE_VIDEO + || renderer.getTrackType() == C.TRACK_TYPE_IMAGE) + && !renderer.isEnded()) { + hasActiveVideoOrImageRenderer = true; + } boolean allowsPlayback = renderer.allowsPlayback(playingPeriodHolder); maybeTriggerOnRendererReadyChanged(/* rendererIndex= */ i, allowsPlayback); renderersAllowPlayback = renderersAllowPlayback && allowsPlayback; @@ -1491,6 +1502,11 @@ private void doSomeWork() throws ExoPlaybackException, IOException { maybeThrowRendererStreamError(/* rendererIndex= */ i); } } + if (seekIsPendingWhileScrubbing + && !hasActiveVideoOrImageRenderer + && !handler.hasMessages(MSG_SEEK_COMPLETED_IN_SCRUBBING_MODE)) { + handler.obtainMessage(MSG_SEEK_COMPLETED_IN_SCRUBBING_MODE).sendToTarget(); + } } else { playingPeriodHolder.mediaPeriod.maybeThrowPrepareError(); } @@ -4040,13 +4056,10 @@ private static PositionUpdateForPlaylistChange resolvePositionForPlaylistChange( contentPositionForAdResolutionUs, enforceAdPlaybackOnTimelineRefresh, /* transitionsFromPlaceholderPeriod= */ isUsingPlaceholderPeriod); - boolean earliestAdGroupIsUnchangedOrLater = + boolean earliestCuePointIsUnchangedOrLater = periodIdWithAds.nextAdGroupIndex == C.INDEX_UNSET || (oldPeriodId.nextAdGroupIndex != C.INDEX_UNSET && periodIdWithAds.nextAdGroupIndex >= oldPeriodId.nextAdGroupIndex); - boolean isOldAdGroupWithinNewPeriod = - isOldAdGroupWithinNewPeriod( - timeline.getPeriodByUid(newPeriodUid, period), oldPeriodId.nextAdGroupIndex); // Drop update if we keep playing the same content (MediaPeriod.periodUid are identical) and // the only change is that MediaPeriodId.nextAdGroupIndex increased. This postpones a potential // discontinuity until we reach the former next ad group position. @@ -4055,18 +4068,18 @@ private static PositionUpdateForPlaylistChange resolvePositionForPlaylistChange( sameOldAndNewPeriodUid && !oldPeriodId.isAd() && !periodIdWithAds.isAd() - && isOldAdGroupWithinNewPeriod - && earliestAdGroupIsUnchangedOrLater; + && earliestCuePointIsUnchangedOrLater; // Drop update if the change is from/to server-side inserted ads at the same content position to // avoid any unintentional renderer reset. boolean isInStreamAdChange = isIgnorableServerSideAdInsertionPeriodChange( + timeline, isUsingPlaceholderPeriod, oldPeriodId, oldContentPositionUs, periodIdWithAds, - timeline.getPeriodByUid(newPeriodUid, period), - newContentPositionUs); + newContentPositionUs, + period); MediaPeriodId newPeriodId = onlyNextAdGroupIndexIncreased || isInStreamAdChange ? oldPeriodId : periodIdWithAds; @@ -4140,27 +4153,29 @@ private static PositionUpdateForPlaylistChange resolvePositionForPlaylistChange( } private static boolean isIgnorableServerSideAdInsertionPeriodChange( + Timeline timeline, boolean isUsingPlaceholderPeriod, MediaPeriodId oldPeriodId, long oldContentPositionUs, MediaPeriodId newPeriodId, - Timeline.Period newPeriod, - long newContentPositionUs) { + long newContentPositionUs, + Timeline.Period period) { if (isUsingPlaceholderPeriod || oldContentPositionUs != newContentPositionUs || !oldPeriodId.periodUid.equals(newPeriodId.periodUid)) { // The period position changed. return false; } - if (oldPeriodId.isAd() && newPeriod.isServerSideInsertedAdGroup(oldPeriodId.adGroupIndex)) { + timeline.getPeriodByUid(newPeriodId.periodUid, period); + if (oldPeriodId.isAd() && period.isServerSideInsertedAdGroup(oldPeriodId.adGroupIndex)) { // Whether the old period was a server side ad that doesn't need skipping to the content. - return newPeriod.getAdState(oldPeriodId.adGroupIndex, oldPeriodId.adIndexInAdGroup) + return period.getAdState(oldPeriodId.adGroupIndex, oldPeriodId.adIndexInAdGroup) != AdPlaybackState.AD_STATE_ERROR - && newPeriod.getAdState(oldPeriodId.adGroupIndex, oldPeriodId.adIndexInAdGroup) + && period.getAdState(oldPeriodId.adGroupIndex, oldPeriodId.adIndexInAdGroup) != AdPlaybackState.AD_STATE_SKIPPED; } // If the new period is a server side inserted ad, we can just continue playing. - return newPeriodId.isAd() && newPeriod.isServerSideInsertedAdGroup(newPeriodId.adGroupIndex); + return newPeriodId.isAd() && period.isServerSideInsertedAdGroup(newPeriodId.adGroupIndex); } private static boolean isUsingPlaceholderPeriod( @@ -4170,22 +4185,6 @@ private static boolean isUsingPlaceholderPeriod( return timeline.isEmpty() || timeline.getPeriodByUid(periodId.periodUid, period).isPlaceholder; } - private static boolean isOldAdGroupWithinNewPeriod( - Timeline.Period newPeriod, int oldNextAdGroupIndex) { - if (oldNextAdGroupIndex == C.INDEX_UNSET) { - return true; - } - if (oldNextAdGroupIndex >= newPeriod.adPlaybackState.adGroupCount) { - return false; - } - AdGroup newAdGroupAtOldIndex = newPeriod.adPlaybackState.getAdGroup(oldNextAdGroupIndex); - if (newAdGroupAtOldIndex.timeUs == C.TIME_END_OF_SOURCE) { - return true; - } - return newAdGroupAtOldIndex.timeUs <= newPeriod.durationUs - || newPeriod.durationUs == C.TIME_UNSET; - } - /** * Updates the {@link #isRebuffering} state and the timestamp of the last rebuffering event. * diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/RendererHolder.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/RendererHolder.java index bf693ca6e52..181a80bf682 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/RendererHolder.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/RendererHolder.java @@ -76,12 +76,15 @@ public boolean hasSecondary() { public void startPrewarming() { checkState(!isPrewarming()); - prewarmingState = - isRendererEnabled(primaryRenderer) - ? RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY - : secondaryRenderer != null && isRendererEnabled(secondaryRenderer) - ? RENDERER_PREWARMING_STATE_TRANSITIONING_TO_PRIMARY - : RENDERER_PREWARMING_STATE_PREWARMING_PRIMARY; + if (isRendererEnabled(primaryRenderer)) { + prewarmingState = RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY; + } else if (secondaryRenderer != null && isRendererEnabled(secondaryRenderer)) { + prewarmingState = RENDERER_PREWARMING_STATE_TRANSITIONING_TO_PRIMARY; + } else if (prewarmingState == RENDERER_PREWARMING_STATE_NOT_PREWARMING_USING_PRIMARY) { + prewarmingState = RENDERER_PREWARMING_STATE_PREWARMING_PRIMARY; + } else { + prewarmingState = RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY; + } } public boolean isPrewarming() { @@ -94,7 +97,8 @@ private boolean isPrimaryRendererPrewarming() { } private boolean isSecondaryRendererPrewarming() { - return prewarmingState == RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY; + return prewarmingState == RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY + || prewarmingState == RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY; } public int getEnabledRendererCount() { @@ -165,6 +169,7 @@ public void setCurrentStreamFinal(long streamEndPositionUs) { boolean isPrimaryRenderer = secondaryRenderer == null || prewarmingState == RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY + || prewarmingState == RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY || prewarmingState == RENDERER_PREWARMING_STATE_NOT_PREWARMING_USING_PRIMARY; Renderer renderer = isPrimaryRenderer ? primaryRenderer : checkNotNull(secondaryRenderer); setCurrentStreamFinalInternal(renderer, streamEndPositionUs); @@ -190,6 +195,7 @@ public void maybeSetOldStreamToFinal( boolean isPrimaryOldRenderer = secondaryRenderer == null || prewarmingState == RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY + || prewarmingState == RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY || (prewarmingState == RENDERER_PREWARMING_STATE_NOT_PREWARMING_USING_PRIMARY && isRendererEnabled(primaryRenderer)); Renderer oldRenderer = isPrimaryOldRenderer ? primaryRenderer : checkNotNull(secondaryRenderer); @@ -226,7 +232,8 @@ public void setAllNonPrewarmingRendererStreamsFinal(long streamEndPositionUs) { } if (secondaryRenderer != null && isRendererEnabled(secondaryRenderer) - && prewarmingState != RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY) { + && prewarmingState != RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY + && prewarmingState != RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY) { setCurrentStreamFinalInternal(secondaryRenderer, streamEndPositionUs); } } @@ -594,8 +601,9 @@ public void disable(DefaultMediaClock mediaClock) throws ExoPlaybackException { disableRenderer(primaryRenderer, mediaClock); if (secondaryRenderer != null) { boolean shouldTransferResources = - isRendererEnabled(secondaryRenderer) - && prewarmingState != RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY; + prewarmingState == RENDERER_PREWARMING_STATE_TRANSITIONING_TO_PRIMARY + || prewarmingState == RENDERER_PREWARMING_STATE_NOT_PREWARMING_USING_SECONDARY + || prewarmingState == RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY; disableRenderer(secondaryRenderer, mediaClock); maybeResetRenderer(/* resetPrimary= */ false); if (shouldTransferResources) { @@ -618,6 +626,8 @@ public void maybeHandlePrewarmingTransition() throws ExoPlaybackException { : RENDERER_PREWARMING_STATE_NOT_PREWARMING_USING_SECONDARY; } else if (prewarmingState == RENDERER_PREWARMING_STATE_PREWARMING_PRIMARY) { prewarmingState = RENDERER_PREWARMING_STATE_NOT_PREWARMING_USING_PRIMARY; + } else if (prewarmingState == RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY) { + prewarmingState = RENDERER_PREWARMING_STATE_NOT_PREWARMING_USING_SECONDARY; } } @@ -637,7 +647,8 @@ public void disablePrewarming(DefaultMediaClock mediaClock) { prewarmingState == RENDERER_PREWARMING_STATE_TRANSITIONING_TO_PRIMARY || prewarmingState == RENDERER_PREWARMING_STATE_PREWARMING_PRIMARY; boolean isSecondaryActiveRenderer = - prewarmingState == RENDERER_PREWARMING_STATE_TRANSITIONING_TO_PRIMARY; + prewarmingState == RENDERER_PREWARMING_STATE_TRANSITIONING_TO_PRIMARY + || prewarmingState == RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY; try { disableRenderer( isPrewarmingPrimary ? primaryRenderer : checkNotNull(secondaryRenderer), mediaClock); @@ -847,6 +858,7 @@ public void setVideoOutput(@Nullable Object videoOutput) throws ExoPlaybackExcep return; } if (prewarmingState == RENDERER_PREWARMING_STATE_TRANSITIONING_TO_PRIMARY + || prewarmingState == RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY || prewarmingState == RENDERER_PREWARMING_STATE_NOT_PREWARMING_USING_SECONDARY) { checkNotNull(secondaryRenderer).handleMessage(Renderer.MSG_SET_VIDEO_OUTPUT, videoOutput); } else { @@ -949,6 +961,7 @@ private Renderer getRendererReadingFromPeriod(@Nullable MediaPeriodHolder period RENDERER_PREWARMING_STATE_NOT_PREWARMING_USING_PRIMARY, RENDERER_PREWARMING_STATE_NOT_PREWARMING_USING_SECONDARY, RENDERER_PREWARMING_STATE_PREWARMING_PRIMARY, + RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY, RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY, RENDERER_PREWARMING_STATE_TRANSITIONING_TO_PRIMARY }) @@ -972,17 +985,23 @@ private Renderer getRendererReadingFromPeriod(@Nullable MediaPeriodHolder period */ /* package */ static final int RENDERER_PREWARMING_STATE_PREWARMING_PRIMARY = 2; + /** + * ExoPlayer is currently pre-warming the secondary renderer that is not being used for the + * current media item for a subsequent media item. + */ + /* package */ static final int RENDERER_PREWARMING_STATE_PREWARMING_SECONDARY = 3; + /** * Both a primary and secondary renderer are enabled and ExoPlayer is transitioning to a media * item using the secondary renderer. */ - /* package */ static final int RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY = 3; + /* package */ static final int RENDERER_PREWARMING_STATE_TRANSITIONING_TO_SECONDARY = 4; /** * Both a primary and secondary renderer are enabled and ExoPlayer is transitioning to a media * item using the primary renderer. */ - /* package */ static final int RENDERER_PREWARMING_STATE_TRANSITIONING_TO_PRIMARY = 4; + /* package */ static final int RENDERER_PREWARMING_STATE_TRANSITIONING_TO_PRIMARY = 5; /** Results for calls to {@link #replaceStreamsOrDisableRendererForTransition}. */ @Documented diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioOutputProvider.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioOutputProvider.java index 85f4620973e..9f4aff290e2 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioOutputProvider.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioOutputProvider.java @@ -688,6 +688,16 @@ public InitializationException(Throwable cause) { @UnstableApi default void setClock(Clock clock) {} + /** + * Returns whether there are any pending asynchronous releases of audio outputs. + * + *

Implementations that release resources synchronously should return false. + */ + @UnstableApi + default boolean hasPendingReleases() { + return false; + } + /** Releases resources held by the provider. */ void release(); } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioTrackAudioOutput.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioTrackAudioOutput.java index 3a6d02a3c85..dd7662f827b 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioTrackAudioOutput.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioTrackAudioOutput.java @@ -397,6 +397,13 @@ public boolean isStalled() { return audioTrackPositionTracker.isStalled(getWrittenFrames()); } + /** Returns whether there are any pending asynchronous releases. */ + /* package */ static boolean hasPendingReleases() { + synchronized (releaseExecutorLock) { + return pendingReleaseCount > 0; + } + } + private long getWrittenFrames() { return isOutputPcm ? Util.ceilDivide(writtenPcmBytes, pcmFrameSize) : writtenEncodedFrames; } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioTrackAudioOutputProvider.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioTrackAudioOutputProvider.java index 77d9af183a5..c20065daaad 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioTrackAudioOutputProvider.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/AudioTrackAudioOutputProvider.java @@ -424,6 +424,12 @@ public void setClock(Clock clock) { this.clock = clock; } + @UnstableApi + @Override + public boolean hasPendingReleases() { + return AudioTrackAudioOutput.hasPendingReleases(); + } + @Override public void release() { if (listeners != null) { diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/DefaultAudioSink.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/DefaultAudioSink.java index 7cf699b3648..e6007c4afd5 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/DefaultAudioSink.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/DefaultAudioSink.java @@ -77,7 +77,6 @@ import java.nio.ByteOrder; import java.util.ArrayDeque; import java.util.Objects; -import java.util.concurrent.atomic.AtomicInteger; import java.util.function.BiConsumer; import org.checkerframework.checker.nullness.qual.MonotonicNonNull; import org.checkerframework.checker.nullness.qual.RequiresNonNull; @@ -562,8 +561,6 @@ public DefaultAudioSink build() { private static final String TAG = "DefaultAudioSink"; - private static final AtomicInteger pendingReleaseCount = new AtomicInteger(); - @Nullable private final Context context; private final androidx.media3.common.audio.AudioProcessorChain audioProcessorChain; private final boolean enableFloatOutput; @@ -601,6 +598,8 @@ public DefaultAudioSink build() { private long writtenPcmBytes; private long writtenEncodedFrames; private int framesPerEncodedSample; + private int inputBufferOriginalRemaining; + private long currentBufferFramesWritten; private boolean startMediaTimeUsNeedsSync; private boolean startMediaTimeUsNeedsInit; private long startMediaTimeUs; @@ -1071,6 +1070,8 @@ public boolean handleBuffer( inputBuffer = buffer; inputBufferAccessUnitCount = encodedAccessUnitCount; + inputBufferOriginalRemaining = buffer.remaining(); + currentBufferFramesWritten = 0; } processBuffers(presentationTimeUs); @@ -1316,17 +1317,37 @@ private void drainOutputBuffer(long avSyncPresentationTimeUs) throws WriteExcept } } + int bytesWritten = bytesRemaining - outputBuffer.remaining(); if (configuration.isPcm()) { - writtenPcmBytes += bytesRemaining - outputBuffer.remaining(); + writtenPcmBytes += bytesWritten; } if (fullyHandled) { if (!configuration.isPcm()) { // When playing non-PCM, the inputBuffer is never processed, thus the last inputBuffer // must be the current input buffer. checkState(outputBuffer == inputBuffer); - writtenEncodedFrames += (long) framesPerEncodedSample * inputBufferAccessUnitCount; + // Add only the remaining unreconciled frames to ensure exact sample accuracy. + writtenEncodedFrames += + ((long) framesPerEncodedSample * inputBufferAccessUnitCount) + - currentBufferFramesWritten; + currentBufferFramesWritten = 0; } outputBuffer = null; + } else { + if (!configuration.isPcm() && bytesWritten > 0) { + checkState(inputBufferOriginalRemaining > 0); + int totalBytesWrittenForCurrentBuffer = + inputBufferOriginalRemaining - outputBuffer.remaining(); + long totalFramesWrittenForCurrentBuffer = + Util.scaleLargeValue( + totalBytesWrittenForCurrentBuffer, + (long) framesPerEncodedSample * inputBufferAccessUnitCount, + inputBufferOriginalRemaining, + RoundingMode.CEILING); + long newFramesWritten = totalFramesWrittenForCurrentBuffer - currentBufferFramesWritten; + writtenEncodedFrames += newFramesWritten; + currentBufferFramesWritten = totalFramesWrittenForCurrentBuffer; + } } } @@ -1575,7 +1596,6 @@ public void flush() { // We need to release the audio output on every flush because of known AudioTrack flush issues // on some devices. See b/7941810 or b/19193985. // TODO: b/143500232 - Experiment with not releasing AudioOutput on flush. - pendingReleaseCount.incrementAndGet(); audioOutput.release(); audioOutput = null; } @@ -1638,6 +1658,8 @@ private void resetSinkStateForFlush() { writtenEncodedFrames = 0; isWaitingForOffloadEndOfStreamHandled = false; framesPerEncodedSample = 0; + inputBufferOriginalRemaining = 0; + currentBufferFramesWritten = 0; mediaPositionParameters = new MediaPositionParameters( playbackParameters, /* mediaTimeUs= */ 0, /* audioOutputPositionUs= */ 0); @@ -1938,8 +1960,8 @@ private boolean hasAudioOutputPendingData(long writtenFrames) { return writtenFrames > currentPositionFrames; } - private static boolean hasPendingAudioOutputReleases() { - return pendingReleaseCount.get() > 0; + private boolean hasPendingAudioOutputReleases() { + return audioOutputProvider.hasPendingReleases(); } @RequiresApi(34) @@ -2025,7 +2047,6 @@ public void onUnderrun() { public void onReleased() { // Don't check for stale events. It's expected that this event arrives after the class field // has been updated to null or a new listener. - pendingReleaseCount.getAndDecrement(); if (listener != null) { listener.onAudioTrackReleased( new AudioTrackConfig( @@ -2131,7 +2152,7 @@ private boolean isPcm() { } } - private static final class PendingExceptionHolder { + private final class PendingExceptionHolder { /** * The duration for which failed audio output operations may be retried before throwing an diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/ForwardingAudioOutputProvider.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/ForwardingAudioOutputProvider.java index 0b36623799a..85bf8384da3 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/ForwardingAudioOutputProvider.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/ForwardingAudioOutputProvider.java @@ -63,6 +63,12 @@ public void setClock(Clock clock) { audioOutputProvider.setClock(clock); } + @UnstableApi + @Override + public boolean hasPendingReleases() { + return audioOutputProvider.hasPendingReleases(); + } + @Override public void release() { audioOutputProvider.release(); diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/MediaCodecAudioRenderer.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/MediaCodecAudioRenderer.java index ec4d209aaad..eb7a86bff83 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/MediaCodecAudioRenderer.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/MediaCodecAudioRenderer.java @@ -48,6 +48,7 @@ import androidx.media3.common.util.CodecSpecificDataUtil; import androidx.media3.common.util.Log; import androidx.media3.common.util.MediaFormatUtil; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.common.util.UnstableApi; import androidx.media3.common.util.Util; import androidx.media3.decoder.DecoderInputBuffer; @@ -77,6 +78,7 @@ import java.nio.ByteOrder; import java.util.List; import java.util.Objects; +import java.util.concurrent.atomic.AtomicBoolean; /** * Decodes and renders audio using {@link MediaCodec} and an {@link AudioSink}. @@ -132,6 +134,7 @@ public class MediaCodecAudioRenderer extends MediaCodecRenderer implements Media private final EventDispatcher eventDispatcher; private final AudioSink audioSink; @Nullable private final LoudnessCodecController loudnessCodecController; + private final AtomicBoolean processOutputBufferResultHolder; private int codecMaxInputSize; private boolean codecNeedsDiscardChannelsWorkaround; @@ -330,6 +333,7 @@ public MediaCodecAudioRenderer( this.loudnessCodecController = loudnessCodecController; rendererPriority = C.PRIORITY_PLAYBACK; eventDispatcher = new EventDispatcher(eventHandler, eventListener); + processOutputBufferResultHolder = new AtomicBoolean(); nextBufferToWritePresentationTimeUs = C.TIME_UNSET; firstNotReadyTimeMs = C.TIME_UNSET; hasBeenReady = false; @@ -927,9 +931,16 @@ protected boolean processOutputBuffer( return true; } - boolean fullyConsumed; try { - fullyConsumed = audioSink.handleBuffer(buffer, bufferPresentationTimeUs, sampleCount); + ThrowingRunnable handleBufferOperation = + () -> + processOutputBufferResultHolder.set( + audioSink.handleBuffer(buffer, bufferPresentationTimeUs, sampleCount)); + if (codec != null) { + codec.useBuffer(handleBufferOperation); + } else { + handleBufferOperation.run(); + } } catch (InitializationException e) { throw createRendererException( e, @@ -948,8 +959,14 @@ && getConfiguration().offloadModePreferred != AudioSink.OFFLOAD_MODE_DISABLED && getConfiguration().offloadModePreferred != AudioSink.OFFLOAD_MODE_DISABLED ? PlaybackException.ERROR_CODE_AUDIO_TRACK_OFFLOAD_WRITE_FAILED : PlaybackException.ERROR_CODE_AUDIO_TRACK_WRITE_FAILED); + } catch (RuntimeException e) { + throw e; + } catch (Exception e) { + throw new IllegalStateException(e); } + boolean fullyConsumed = processOutputBufferResultHolder.get(); + if (fullyConsumed) { if (codec != null) { if (DEBUG_LOG_ENABLED) { diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/PcmAudioUtil.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/PcmAudioUtil.java index 7e43f29f8ca..6fda8676ff9 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/PcmAudioUtil.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/PcmAudioUtil.java @@ -71,7 +71,7 @@ public static ByteBuffer rampUpVolume( public static int readAs32BitIntPcm(ByteBuffer buffer, @C.Encoding int pcmEncoding) { switch (pcmEncoding) { case C.ENCODING_PCM_8BIT: - return (buffer.get() & 0xFF) << 24; + return ((buffer.get() & 0xFF) - 128) << 24; case C.ENCODING_PCM_16BIT: return ((buffer.get() & 0xFF) << 16) | ((buffer.get() & 0xFF) << 24); case C.ENCODING_PCM_16BIT_BIG_ENDIAN: @@ -161,7 +161,7 @@ public static void write32BitIntPcm( buffer.put((byte) (pcm32bit >> 24)); return; case C.ENCODING_PCM_8BIT: - buffer.put((byte) (pcm32bit >> 24)); + buffer.put((byte) ((pcm32bit >> 24) + 128)); return; case C.ENCODING_PCM_32BIT_BIG_ENDIAN: buffer.put((byte) (pcm32bit >> 24)); diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/SilenceSkippingAudioProcessor.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/SilenceSkippingAudioProcessor.java index 3a9dc605fe4..ac68d89c655 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/SilenceSkippingAudioProcessor.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/audio/SilenceSkippingAudioProcessor.java @@ -309,7 +309,9 @@ public void onFlush(StreamMetadata streamMetadata) { bytesPerFrame = inputAudioFormat.channelCount * 2; // Divide by 2 to allow the buffer to be split into two bytesPerFrame aligned parts. int maybeSilenceBufferSize = - alignToBytePerFrameBoundary(durationUsToFrames(minimumSilenceDurationUs) / 2) * 2; + alignToBytePerFrameBoundary( + durationUsToFrames(minimumSilenceDurationUs) * bytesPerFrame / 2) + * 2; if (maybeSilenceBuffer.length != maybeSilenceBufferSize) { maybeSilenceBuffer = new byte[maybeSilenceBufferSize]; contiguousOutputBuffer = new byte[maybeSilenceBufferSize]; @@ -647,6 +649,7 @@ private void modifyVolume(byte[] sampleBuffer, int size, @VolumeChangeType int v return; } + int lastFrameIdx = (size / bytesPerFrame) - 1; for (int idx = 0; idx < size; idx += 2) { byte mostSignificantByte = sampleBuffer[idx + 1]; byte leastSignificantByte = sampleBuffer[idx]; @@ -655,10 +658,10 @@ private void modifyVolume(byte[] sampleBuffer, int size, @VolumeChangeType int v int volumeModificationPercentage; if (volumeChangeType == FADE_OUT) { volumeModificationPercentage = - calculateFadeOutPercentage(/* value= */ idx, /* max= */ size - 1); + calculateFadeOutPercentage(/* value= */ idx / bytesPerFrame, /* max= */ lastFrameIdx); } else if (volumeChangeType == FADE_IN) { volumeModificationPercentage = - calculateFadeInPercentage(/* value= */ idx, /* max= */ size - 1); + calculateFadeInPercentage(/* value= */ idx / bytesPerFrame, /* max= */ lastFrameIdx); } else { volumeModificationPercentage = minVolumeToKeepPercentageWhenMuting; } @@ -669,12 +672,18 @@ private void modifyVolume(byte[] sampleBuffer, int size, @VolumeChangeType int v } private int calculateFadeOutPercentage(int value, int max) { + if (max == 0) { + return minVolumeToKeepPercentageWhenMuting; + } return ((minVolumeToKeepPercentageWhenMuting - 100) * ((AVOID_TRUNCATION_FACTOR * value) / max)) / AVOID_TRUNCATION_FACTOR + 100; } private int calculateFadeInPercentage(int value, int max) { + if (max == 0) { + return 100; + } return (minVolumeToKeepPercentageWhenMuting + ((100 - minVolumeToKeepPercentageWhenMuting) * (AVOID_TRUNCATION_FACTOR * value) / max) / AVOID_TRUNCATION_FACTOR); diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DefaultDrmSession.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DefaultDrmSession.java index ed2c33b5d86..92fc5322104 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DefaultDrmSession.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DefaultDrmSession.java @@ -691,9 +691,12 @@ public void handleMessage(Message msg) { synchronized (keyRequestInfoLock) { if (currentKeyRequestInfo != null && keyResponse.loadEventInfo != null) { currentKeyRequestInfo.addLoadInfo( - keyResponse.loadEventInfo.copyWithTaskIdAndDurationMs( - requestTask.taskId, - SystemClock.elapsedRealtime() - requestTask.startTimeMs)); + keyResponse + .loadEventInfo + .buildUpon() + .setLoadTaskId(requestTask.taskId) + .setLoadDurationMs(SystemClock.elapsedRealtime() - requestTask.startTimeMs) + .build()); } } break; @@ -730,14 +733,13 @@ private boolean maybeRetryRequest(Message originalMsg, MediaDrmCallbackException return false; } LoadEventInfo loadEventInfo = - new LoadEventInfo( - requestTask.taskId, - exception.dataSpec, - exception.uriAfterRedirects, - exception.responseHeaders, - SystemClock.elapsedRealtime(), - /* loadDurationMs= */ SystemClock.elapsedRealtime() - requestTask.startTimeMs, - exception.bytesLoaded); + new LoadEventInfo.Builder( + requestTask.taskId, exception.dataSpec, SystemClock.elapsedRealtime()) + .setUri(exception.uriAfterRedirects) + .setResponseHeaders(exception.responseHeaders) + .setLoadDurationMs(SystemClock.elapsedRealtime() - requestTask.startTimeMs) + .setBytesLoaded(exception.bytesLoaded) + .build(); MediaLoadData mediaLoadData = new MediaLoadData(C.DATA_TYPE_DRM); IOException loadErrorCause = exception.getCause() instanceof IOException diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmUtil.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmUtil.java index 3b3430b013f..df2b696762d 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmUtil.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmUtil.java @@ -187,14 +187,14 @@ public static MediaDrmCallback.Response executePost( try { byte[] response = ByteStreams.toByteArray(inputStream); LoadEventInfo loadEventInfo = - new LoadEventInfo( - -1, // This will be replaced with the actual taskId from the request. - originalDataSpec, - statsDataSource.getLastOpenedUri(), - statsDataSource.getLastResponseHeaders(), - SystemClock.elapsedRealtime(), - /* loadDurationMs= */ 0, - response.length); + new LoadEventInfo.Builder( + -1, // This will be replaced with the actual taskId from the request. + originalDataSpec, + SystemClock.elapsedRealtime()) + .setUri(statsDataSource.getLastOpenedUri()) + .setResponseHeaders(statsDataSource.getLastResponseHeaders()) + .setBytesLoaded(response.length) + .build(); return new MediaDrmCallback.Response.Builder(response) .setLoadEventInfo(loadEventInfo) .build(); diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/AsynchronousMediaCodecAdapter.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/AsynchronousMediaCodecAdapter.java index 7ce18a39582..87ff730bb72 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/AsynchronousMediaCodecAdapter.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/AsynchronousMediaCodecAdapter.java @@ -34,6 +34,7 @@ import androidx.annotation.VisibleForTesting; import androidx.media3.common.C; import androidx.media3.common.util.ExperimentalApi; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.common.util.TraceUtil; import androidx.media3.decoder.CryptoInfo; import com.google.common.base.Supplier; @@ -266,11 +267,11 @@ public ByteBuffer getInputBuffer(int index) { } @Override - public void useInputBuffer(Runnable runnable) { - asynchronousMediaCodecCallback.useInputBuffer( + public void useBuffer(ThrowingRunnable runnable) throws E { + asynchronousMediaCodecCallback.useBuffer( () -> { bufferEnqueuer.maybeThrowException(); - asynchronousMediaCodecCallback.useInputBuffer(runnable); + runnable.run(); }); } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/AsynchronousMediaCodecCallback.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/AsynchronousMediaCodecCallback.java index 8055b2ac1d6..ae201d3e3cb 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/AsynchronousMediaCodecCallback.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/AsynchronousMediaCodecCallback.java @@ -26,6 +26,7 @@ import androidx.annotation.GuardedBy; import androidx.annotation.Nullable; import androidx.media3.common.util.CircularIntArray; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.common.util.Util; import java.util.ArrayDeque; import org.checkerframework.checker.nullness.qual.MonotonicNonNull; @@ -128,14 +129,17 @@ public void shutdown() { } /** - * Uses an acquired input buffer (e.g. to write data to it). + * Uses an acquired input or output buffer (e.g. to populate, drain, or write data to it). * - *

This can be used for error handling, e.g. to guarantee no operation can invalidate the - * buffer while it's being used. + *

This runs the provided {@link ThrowingRunnable} under the internal codec/callback monitor, + * ensuring that concurrent asynchronous framework callbacks (e.g., error reporting or pipeline + * invalidation) cannot pre-empt or interleave with active {@code ByteBuffer} memory traversals. * - * @param runnable The {@link Runnable} using an acquired input buffer. + * @param runnable The {@link ThrowingRunnable} utilizing an acquired buffer. + * @param The type of exception thrown by {@code runnable}. + * @throws E If {@code runnable} throws an exception. */ - public void useInputBuffer(Runnable runnable) { + public void useBuffer(ThrowingRunnable runnable) throws E { synchronized (lock) { // Run the Runnable under the buffer lock to ensure no new error callback can be handled // while the buffer is used (under the assumption that error callbacks invalidate the buffer). diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/ForwardingMediaCodecAdapter.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/ForwardingMediaCodecAdapter.java index 483d9a4c1a4..919e79546ee 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/ForwardingMediaCodecAdapter.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/ForwardingMediaCodecAdapter.java @@ -23,6 +23,7 @@ import android.view.Surface; import androidx.annotation.Nullable; import androidx.annotation.RequiresApi; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.common.util.UnstableApi; import androidx.media3.decoder.CryptoInfo; import java.nio.ByteBuffer; @@ -65,8 +66,8 @@ public ByteBuffer getInputBuffer(int index) { } @Override - public void useInputBuffer(Runnable runnable) { - delegate.useInputBuffer(runnable); + public void useBuffer(ThrowingRunnable runnable) throws E { + delegate.useBuffer(runnable); } @Nullable diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecAdapter.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecAdapter.java index cda3b77483f..7dbf562a983 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecAdapter.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecAdapter.java @@ -27,6 +27,7 @@ import androidx.annotation.RequiresApi; import androidx.media3.common.C; import androidx.media3.common.Format; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.common.util.UnstableApi; import androidx.media3.decoder.CryptoInfo; import java.io.IOException; @@ -208,14 +209,16 @@ default void onOutputBufferAvailable() {} ByteBuffer getInputBuffer(int index); /** - * Uses an acquired input buffer (e.g. to write data to it). + * Uses an acquired input or output buffer (e.g. to read from or write data to it). * *

This can be used for error handling, e.g. to guarantee no operation can invalidate the - * buffer while it's being used. + * buffer while it's being used by the application or downstream components. * - * @param runnable The {@link Runnable} using an acquired input buffer. + * @param runnable The {@link ThrowingRunnable} utilizing an acquired buffer. + * @param The type of exception thrown by {@code runnable}. + * @throws E If {@code runnable} throws an exception. */ - default void useInputBuffer(Runnable runnable) { + default void useBuffer(ThrowingRunnable runnable) throws E { runnable.run(); } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecInfo.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecInfo.java index ccdc4a965d7..b30898f9c33 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecInfo.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecInfo.java @@ -54,10 +54,15 @@ import androidx.media3.common.util.CodecSpecificDataUtil; import androidx.media3.common.util.CodecSpecificDataUtil.MediaCodecProfileAndLevel; import androidx.media3.common.util.Log; +import androidx.media3.common.util.NullableType; import androidx.media3.common.util.UnstableApi; import androidx.media3.common.util.Util; import androidx.media3.exoplayer.DecoderReuseEvaluation; import androidx.media3.exoplayer.DecoderReuseEvaluation.DecoderDiscardReasons; +import com.google.common.base.Strings; +import com.google.common.base.Supplier; +import com.google.common.base.Suppliers; +import com.google.common.primitives.Ints; import com.google.errorprone.annotations.InlineMe; import java.util.Objects; @@ -74,6 +79,10 @@ public final class MediaCodecInfo { */ public static final int MAX_SUPPORTED_INSTANCES_UNKNOWN = -1; + private static final Supplier<@NullableType Integer> VENDOR_API_LEVEL = + Suppliers.<@NullableType Integer>memoize( + () -> Ints.tryParse(Strings.nullToEmpty(Util.getSystemProperty("ro.vendor.api_level")))); + /** * The name of the decoder. * @@ -1072,13 +1081,12 @@ private static boolean needsProfileExcludedWorkaround(String mimeType, int profi /** Returns whether the device is known to have issues with the detached surface mode. */ private static boolean needsDetachedSurfaceUnsupportedWorkaround() { - if (!MediaLibraryInfo.enableWorkarounds()) { - return false; - } - if (SDK_INT > 37) { - // After API 37, we assume that detached surface mode is supported and we don't apply the - // workaround. Devices should not declare support for FEATURE_DetachedSurface unless they - // actually support it. + // We deliberately don't check MediaLibraryInfo.enableWorkarounds() here, because this + // workaround needs to remain active even during certification testing (b/535214648). + Integer vendorApiLevel = VENDOR_API_LEVEL.get(); + if (vendorApiLevel == null || vendorApiLevel > 202604) { + // Devices with vendor API level higher than SDK_INT 37 must only declare support for + // FEATURE_DetachedSurface if they actually support it. return false; } return Build.MANUFACTURER.equals("Xiaomi") diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecRenderer.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecRenderer.java index cd731fd2d0f..b5c2f8ecb3b 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecRenderer.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/mediacodec/MediaCodecRenderer.java @@ -391,6 +391,7 @@ private static String buildCustomDiagnosticInfo(int errorCode) { private int outputIndex; @Nullable private ByteBuffer outputBuffer; private boolean isDecodeOnlyOutputBuffer; + private boolean isOutputBufferStale; private boolean bypassEnabled; private boolean bypassSampleBufferPending; private boolean bypassDrainAndReinitialize; @@ -415,6 +416,7 @@ private static String buildCustomDiagnosticInfo(int errorCode) { private boolean experimentalEnableProcessedStreamChangedAtStart; private boolean hasSkippedFlushAndWaitingForQueueInputBuffer; private long skippedFlushOffsetUs; + private long largestStaleModifiedPresentationTimeUs; private CodecParameters activeCodecParameters; private CodecParameters lastDispatchedCodecParameters; private ImmutableSet subscribedCodecParameterKeys; @@ -479,6 +481,7 @@ public MediaCodecRenderer( decoderCounters = new DecoderCounters(); hasSkippedFlushAndWaitingForQueueInputBuffer = false; skippedFlushOffsetUs = 0; + largestStaleModifiedPresentationTimeUs = C.TIME_UNSET; this.subscribedCodecParameterKeys = ImmutableSet.of(); this.activeCodecParameters = CodecParameters.EMPTY; this.lastDispatchedCodecParameters = CodecParameters.EMPTY; @@ -1127,6 +1130,7 @@ protected void resetCodecStateForFlush() { codecReceivedBuffers = false; codecNeedsAdaptationWorkaroundBuffer = false; shouldSkipAdaptationWorkaroundOutputBuffer = false; + isOutputBufferStale = false; isDecodeOnlyOutputBuffer = false; codecDrainState = DRAIN_STATE_NONE; codecDrainAction = DRAIN_ACTION_NONE; @@ -1137,6 +1141,7 @@ protected void resetCodecStateForFlush() { codecReconfigured ? RECONFIGURATION_STATE_WRITE_PENDING : RECONFIGURATION_STATE_NONE; hasSkippedFlushAndWaitingForQueueInputBuffer = false; skippedFlushOffsetUs = 0; + largestStaleModifiedPresentationTimeUs = C.TIME_UNSET; } /** @@ -1557,7 +1562,7 @@ private boolean feedInputBuffer() throws ExoPlaybackException { FormatHolder formatHolder = getFormatHolder(); try { - codec.useInputBuffer( + codec.useBuffer( () -> readDataResultHolder.set(readSource(formatHolder, buffer, /* readFlags= */ 0))); } catch (InsufficientCapacityException e) { onCodecError(e); @@ -1659,6 +1664,18 @@ private boolean feedInputBuffer() throws ExoPlaybackException { lastStreamInfo.queuedBufferAfterReset = true; waitingForFirstSampleInFormat = false; } + + if (hasSkippedFlushAndWaitingForQueueInputBuffer) { + largestStaleModifiedPresentationTimeUs = + largestQueuedPresentationTimeUs + skippedFlushOffsetUs; + if (presentationTimeUs <= largestQueuedPresentationTimeUs) { + skippedFlushOffsetUs += largestQueuedPresentationTimeUs - presentationTimeUs + 1; + } + largestQueuedPresentationTimeUs = presentationTimeUs; + largestQueuedPresentationTimeWithinDurationUs = presentationTimeUs; + hasSkippedFlushAndWaitingForQueueInputBuffer = false; + } + largestQueuedPresentationTimeUs = max(largestQueuedPresentationTimeUs, presentationTimeUs); long streamEndPositionUs = getStreamEndPositionUs(); if (streamEndPositionUs == C.TIME_UNSET @@ -1675,15 +1692,6 @@ private boolean feedInputBuffer() throws ExoPlaybackException { handleInputBufferSupplementalData(buffer); } - if (hasSkippedFlushAndWaitingForQueueInputBuffer) { - if (presentationTimeUs <= largestQueuedPresentationTimeUs) { - skippedFlushOffsetUs += largestQueuedPresentationTimeUs - presentationTimeUs + 1; - } - largestQueuedPresentationTimeUs = presentationTimeUs; - largestQueuedPresentationTimeWithinDurationUs = presentationTimeUs; - hasSkippedFlushAndWaitingForQueueInputBuffer = false; - } - onQueueInputBuffer(buffer); int flags = getCodecBufferFlags(buffer); presentationTimeUs += skippedFlushOffsetUs; @@ -2264,6 +2272,9 @@ private boolean drainOutputBuffer(long positionUs, long elapsedRealtimeUs) } // We've dequeued a buffer. + isOutputBufferStale = + largestStaleModifiedPresentationTimeUs != C.TIME_UNSET + && outputBufferInfo.presentationTimeUs <= largestStaleModifiedPresentationTimeUs; outputBufferInfo.presentationTimeUs -= skippedFlushOffsetUs; if (shouldSkipAdaptationWorkaroundOutputBuffer) { shouldSkipAdaptationWorkaroundOutputBuffer = false; @@ -2301,7 +2312,8 @@ private boolean drainOutputBuffer(long positionUs, long elapsedRealtimeUs) && outputBufferInfo.presentationTimeUs - getOutputStreamOffsetUs() >= outputStreamInfo.durationUs; isDecodeOnlyOutputBuffer = - hasSkippedFlushAndWaitingForQueueInputBuffer + isOutputBufferStale + || hasSkippedFlushAndWaitingForQueueInputBuffer || outputBufferInfo.presentationTimeUs < getLastResetPositionUs() || isStrictDurationExceeded; boolean isLastOutputBuffer = diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/DownloadHelper.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/DownloadHelper.java index ce63faf3fea..0c9932c24bf 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/DownloadHelper.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/DownloadHelper.java @@ -563,7 +563,7 @@ public DownloadHelper( this.rendererCapabilities = rendererCapabilities; this.debugLoggingEnabled = debugLoggingEnabled; this.scratchSet = new SparseIntArray(); - trackSelector.init(/* listener= */ () -> {}, BandwidthMeter.NO_OP); + trackSelector.init(/* listener= */ trackSelector::onParametersActivated, BandwidthMeter.NO_OP); callbackHandler = Util.createHandlerForCurrentOrMainLooper(); window = new Timeline.Window(); } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/SegmentDownloader.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/SegmentDownloader.java index fedfdd80dd8..5a18faa4cd1 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/SegmentDownloader.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/SegmentDownloader.java @@ -394,6 +394,29 @@ public final void remove() { */ protected final M getManifest(DataSource dataSource, DataSpec dataSpec, boolean removing) throws InterruptedException, IOException { + return getManifest(dataSource, manifestParser, dataSpec, removing); + } + + /** + * Loads and parses a manifest with a different parser than the base parser that parsed the + * initial manifest. + * + *

This is useful for cases where the manifest needs to be loaded and parsed as a different + * type than the base parser. For example, HLS manifests can be parsed as media playlists that + * inherit variable declarations from the multivariant playlist. + * + * @param dataSource The source to use when loading the manifest. + * @param manifestParser The parser to use when parsing the manifest. + * @param dataSpec The manifest {@link DataSpec}. + * @param removing Whether the manifest is being loaded as part of the download being removed. + * @return The loaded manifest. + * @throws InterruptedException If the thread on which the method is called is interrupted. + * @throws IOException If an error occurs during execution. + */ + protected final M getManifest( + DataSource dataSource, Parser manifestParser, DataSpec dataSpec, boolean removing) + throws InterruptedException, IOException { + checkNotNull(manifestParser); return execute( () -> new RunnableFutureTask() { diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/DefaultMediaSourceFactory.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/DefaultMediaSourceFactory.java index 1ee5c795ef2..1701896c277 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/DefaultMediaSourceFactory.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/DefaultMediaSourceFactory.java @@ -496,23 +496,6 @@ public DefaultMediaSourceFactory setLoadOnlySelectedTracks(boolean loadOnlySelec return this; } - /** - * Sets whether to enable experimental HAGC (ST 2094-50) metadata playback support. When enabled, - * the player will automatically merge HAGC metadata tracks with the associated video track and - * deliver the metadata out-of-band to the decoder on API 37+. - * - *

The default value is {@code true}. - * - * @param enableHagcPlayback Whether experimental HAGC metadata playback is enabled. - * @return This factory, for convenience. - */ - @CanIgnoreReturnValue - @UnstableApi - public DefaultMediaSourceFactory setExperimentalEnableHagcPlayback(boolean enableHagcPlayback) { - delegateFactoryLoader.setExperimentalEnableHagcPlayback(enableHagcPlayback); - return this; - } - /** * Sets whether an experimental setting to delegate end position clipping to a wrapped {@link * MediaPeriod} is enabled. @@ -723,7 +706,6 @@ private static final class DelegateFactoryLoader { private SubtitleParser.Factory subtitleParserFactory; private @C.VideoCodecFlags int codecsToParseWithinGopSampleDependencies; private boolean loadOnlySelectedTracks; - private boolean experimentalEnableHagcPlayback; @Nullable private CmcdConfiguration.Factory cmcdConfigurationFactory; @Nullable private DrmSessionManagerProvider drmSessionManagerProvider; @Nullable private LoadErrorHandlingPolicy loadErrorHandlingPolicy; @@ -736,7 +718,6 @@ public DelegateFactoryLoader( mediaSourceFactorySuppliers = new HashMap<>(); mediaSourceFactories = new HashMap<>(); parseSubtitlesDuringExtraction = true; - experimentalEnableHagcPlayback = true; codecsToParseWithinGopSampleDependencies = C.VIDEO_CODEC_FLAG_H264 | C.VIDEO_CODEC_FLAG_H265; } @@ -840,10 +821,6 @@ private void setLoadOnlySelectedTracks(boolean loadOnlySelectedTracks) { this.loadOnlySelectedTracks = loadOnlySelectedTracks; } - private void setExperimentalEnableHagcPlayback(boolean experimentalEnableHagcPlayback) { - this.experimentalEnableHagcPlayback = experimentalEnableHagcPlayback; - } - private void setHeifExtractorFlags(@HeifExtractor.Flags int flags) { if (this.extractorsFactory instanceof DefaultExtractorsFactory) { ((DefaultExtractorsFactory) this.extractorsFactory).setHeifExtractorFlags(flags); @@ -917,8 +894,7 @@ private Supplier loadSupplier(@C.ContentType int contentTyp mediaSourceFactorySupplier = () -> new ProgressiveMediaSource.Factory(dataSourceFactory, extractorsFactory) - .setLoadOnlySelectedTracks(loadOnlySelectedTracks) - .setExperimentalEnableHagcPlayback(experimentalEnableHagcPlayback); + .setLoadOnlySelectedTracks(loadOnlySelectedTracks); break; default: throw new IllegalArgumentException("Unrecognized contentType: " + contentType); diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/LoadEventInfo.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/LoadEventInfo.java index 0cd0f7e12a7..dde135c86b5 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/LoadEventInfo.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/LoadEventInfo.java @@ -17,9 +17,11 @@ import android.net.Uri; import android.os.SystemClock; +import androidx.annotation.Nullable; import androidx.media3.common.util.UnstableApi; import androidx.media3.datasource.DataSpec; -import java.util.Collections; +import com.google.common.collect.ImmutableMap; +import com.google.errorprone.annotations.CanIgnoreReturnValue; import java.util.List; import java.util.Map; import java.util.concurrent.atomic.AtomicLong; @@ -28,6 +30,155 @@ @UnstableApi public final class LoadEventInfo { + /** Builder for {@link LoadEventInfo}. */ + public static final class Builder { + private long loadTaskId; + private DataSpec dataSpec; + private long elapsedRealtimeMs; + private Uri uri; + @Nullable private String steeredPathwayId; + private Map> responseHeaders; + private long loadDurationMs; + private long bytesLoaded; + + /** + * Creates a builder. + * + * @param loadTaskId See {@link LoadEventInfo#loadTaskId}. + * @param dataSpec See {@link LoadEventInfo#dataSpec}. + * @param elapsedRealtimeMs See {@link LoadEventInfo#elapsedRealtimeMs}. + */ + public Builder(long loadTaskId, DataSpec dataSpec, long elapsedRealtimeMs) { + this.loadTaskId = loadTaskId; + this.dataSpec = dataSpec; + this.uri = dataSpec.uri; + this.elapsedRealtimeMs = elapsedRealtimeMs; + this.responseHeaders = ImmutableMap.of(); + } + + /** + * Creates a builder with the values from the given {@link LoadEventInfo} instance. + * + * @param loadEventInfo The {@link LoadEventInfo} to build upon. + */ + private Builder(LoadEventInfo loadEventInfo) { + this.loadTaskId = loadEventInfo.loadTaskId; + this.dataSpec = loadEventInfo.dataSpec; + this.uri = loadEventInfo.uri; + this.responseHeaders = loadEventInfo.responseHeaders; + this.elapsedRealtimeMs = loadEventInfo.elapsedRealtimeMs; + this.loadDurationMs = loadEventInfo.loadDurationMs; + this.bytesLoaded = loadEventInfo.bytesLoaded; + } + + /** + * Sets the {@link LoadEventInfo#loadTaskId}. + * + * @param loadTaskId See {@link LoadEventInfo#loadTaskId}. + * @return This builder. + */ + @CanIgnoreReturnValue + public Builder setLoadTaskId(long loadTaskId) { + this.loadTaskId = loadTaskId; + return this; + } + + /** + * Sets the {@link LoadEventInfo#dataSpec}. + * + *

This also sets the {@link LoadEventInfo#uri} to the {@link DataSpec#uri} of the given + * {@link DataSpec}. If you need to set the {@link LoadEventInfo#uri} to a different value, call + * {@link #setUri(Uri)} to override it. + * + * @param dataSpec See {@link LoadEventInfo#dataSpec}. + * @return This builder. + */ + @CanIgnoreReturnValue + public Builder setDataSpec(DataSpec dataSpec) { + this.dataSpec = dataSpec; + this.uri = dataSpec.uri; + return this; + } + + /** + * Sets the {@link LoadEventInfo#elapsedRealtimeMs}. + * + * @param elapsedRealtimeMs See {@link LoadEventInfo#elapsedRealtimeMs}. + * @return This builder. + */ + @CanIgnoreReturnValue + public Builder setElapsedRealtimeMs(long elapsedRealtimeMs) { + this.elapsedRealtimeMs = elapsedRealtimeMs; + return this; + } + + /** + * Sets the {@link LoadEventInfo#uri}. + * + * @param uri See {@link LoadEventInfo#uri}. The default is {@code dataSpec.uri}, where {@link + * DataSpec} is the one passed to the builder constructor or {@link #setDataSpec(DataSpec)}. + * @return This builder. + */ + @CanIgnoreReturnValue + public Builder setUri(Uri uri) { + this.uri = uri; + return this; + } + + /** + * Sets the {@link LoadEventInfo#steeredPathwayId}, the default is {@code null}. + * + * @param steeredPathwayId See {@link LoadEventInfo#steeredPathwayId}. + * @return This builder. + */ + @CanIgnoreReturnValue + public Builder setSteeredPathwayId(@Nullable String steeredPathwayId) { + this.steeredPathwayId = steeredPathwayId; + return this; + } + + /** + * Sets the {@link LoadEventInfo#responseHeaders}. + * + * @param responseHeaders See {@link LoadEventInfo#responseHeaders}. + * @return This builder. + */ + @CanIgnoreReturnValue + public Builder setResponseHeaders(Map> responseHeaders) { + this.responseHeaders = responseHeaders; + return this; + } + + /** + * Sets the {@link LoadEventInfo#loadDurationMs}. + * + * @param loadDurationMs See {@link LoadEventInfo#loadDurationMs}. The default is 0. + * @return This builder. + */ + @CanIgnoreReturnValue + public Builder setLoadDurationMs(long loadDurationMs) { + this.loadDurationMs = loadDurationMs; + return this; + } + + /** + * Sets the {@link LoadEventInfo#bytesLoaded}. + * + * @param bytesLoaded See {@link LoadEventInfo#bytesLoaded}. The default is 0. + * @return This builder. + */ + @CanIgnoreReturnValue + public Builder setBytesLoaded(long bytesLoaded) { + this.bytesLoaded = bytesLoaded; + return this; + } + + /** Builds the {@link LoadEventInfo}. */ + public LoadEventInfo build() { + return new LoadEventInfo(this); + } + } + /** Used for the generation of unique ids. */ private static final AtomicLong idSource = new AtomicLong(); @@ -49,6 +200,12 @@ public static long getNewId() { */ public final Uri uri; + /** + * The ID of the steered pathway from which data is being loaded, or {@code null} if not + * applicable. + */ + @Nullable public final String steeredPathwayId; + /** The response headers associated with the load, or an empty map if unavailable. */ public final Map> responseHeaders; @@ -62,32 +219,24 @@ public static long getNewId() { public final long bytesLoaded; /** - * Equivalent to {@link #LoadEventInfo(long, DataSpec, Uri, Map, long, long, long) - * LoadEventInfo(loadTaskId, dataSpec, dataSpec.uri, Collections.emptyMap(), elapsedRealtimeMs, 0, - * 0)}. + * @deprecated Use {@link Builder} instead. */ + @Deprecated public LoadEventInfo(long loadTaskId, DataSpec dataSpec, long elapsedRealtimeMs) { this( loadTaskId, dataSpec, dataSpec.uri, - Collections.emptyMap(), + ImmutableMap.of(), elapsedRealtimeMs, /* loadDurationMs= */ 0, /* bytesLoaded= */ 0); } /** - * Creates load event info. - * - * @param loadTaskId See {@link #loadTaskId}. - * @param dataSpec See {@link #dataSpec}. - * @param uri See {@link #uri}. - * @param responseHeaders See {@link #responseHeaders}. - * @param elapsedRealtimeMs See {@link #elapsedRealtimeMs}. - * @param loadDurationMs See {@link #loadDurationMs}. - * @param bytesLoaded See {@link #bytesLoaded}. + * @deprecated Use {@link Builder} instead. */ + @Deprecated public LoadEventInfo( long loadTaskId, DataSpec dataSpec, @@ -99,14 +248,39 @@ public LoadEventInfo( this.loadTaskId = loadTaskId; this.dataSpec = dataSpec; this.uri = uri; + this.steeredPathwayId = null; this.responseHeaders = responseHeaders; this.elapsedRealtimeMs = elapsedRealtimeMs; this.loadDurationMs = loadDurationMs; this.bytesLoaded = bytesLoaded; } + /** + * Creates a {@link LoadEventInfo} from a {@link Builder}. + * + * @param builder The builder. + */ + private LoadEventInfo(Builder builder) { + this.loadTaskId = builder.loadTaskId; + this.dataSpec = builder.dataSpec; + this.uri = builder.uri; + this.steeredPathwayId = builder.steeredPathwayId; + this.responseHeaders = builder.responseHeaders; + this.elapsedRealtimeMs = builder.elapsedRealtimeMs; + this.loadDurationMs = builder.loadDurationMs; + this.bytesLoaded = builder.bytesLoaded; + } + + /** Initializes a new {@link Builder} with the values from this instance. */ + public Builder buildUpon() { + return new Builder(this); + } + + /** + * @deprecated Use {@link #buildUpon()} instead. + */ + @Deprecated public LoadEventInfo copyWithTaskIdAndDurationMs(long loadTaskId, long loadDurationMs) { - return new LoadEventInfo( - loadTaskId, dataSpec, uri, responseHeaders, elapsedRealtimeMs, loadDurationMs, bytesLoaded); + return buildUpon().setLoadTaskId(loadTaskId).setLoadDurationMs(loadDurationMs).build(); } } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ProgressiveMediaPeriod.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ProgressiveMediaPeriod.java index 29ef6f6edb6..a30c98dbee0 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ProgressiveMediaPeriod.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ProgressiveMediaPeriod.java @@ -32,6 +32,7 @@ import androidx.media3.common.MimeTypes; import androidx.media3.common.ParserException; import androidx.media3.common.TrackGroup; +import androidx.media3.common.util.CodecSpecificDataUtil; import androidx.media3.common.util.ConditionVariable; import androidx.media3.common.util.Log; import androidx.media3.common.util.NullableType; @@ -80,7 +81,7 @@ import java.util.List; import java.util.Map; import java.util.Objects; -import java.util.concurrent.atomic.AtomicReference; +import java.util.concurrent.atomic.AtomicBoolean; import org.checkerframework.checker.nullness.qual.EnsuresNonNull; import org.checkerframework.checker.nullness.qual.MonotonicNonNull; @@ -130,7 +131,6 @@ interface Listener { @Nullable private final String customCacheKey; private final long continueLoadingCheckIntervalBytes; private final boolean loadOnlySelectedTracks; - private final boolean experimentalEnableHagcPlayback; private final int singleTrackId; @Nullable private final Format singleTrackFormat; private final long singleSampleDurationUs; @@ -217,7 +217,6 @@ public ProgressiveMediaPeriod( @Nullable String customCacheKey, int continueLoadingCheckIntervalBytes, boolean loadOnlySelectedTracks, - boolean experimentalEnableHagcPlayback, int singleTrackId, @Nullable Format singleTrackFormat, long singleSampleDurationUs, @@ -233,7 +232,6 @@ public ProgressiveMediaPeriod( this.customCacheKey = customCacheKey; this.continueLoadingCheckIntervalBytes = continueLoadingCheckIntervalBytes; this.loadOnlySelectedTracks = loadOnlySelectedTracks; - this.experimentalEnableHagcPlayback = experimentalEnableHagcPlayback; this.singleTrackId = singleTrackId; this.singleTrackFormat = singleTrackFormat; this.endPositionUs = C.TIME_END_OF_SOURCE; @@ -393,8 +391,7 @@ public long selectTracks( hasPreroll |= selection.getSelectedFormat().hasPrerollSamples; SampleStream stream = new SampleStreamImpl(track, selection.getSelectedFormat().hasPrerollSamples); - if (experimentalEnableHagcPlayback - && Build.VERSION.SDK_INT >= 37 + if (Build.VERSION.SDK_INT >= 37 && !isT35TrackExplicitlySelected && MimeTypes.isVideo(selection.getSelectedFormat().sampleMimeType)) { // TODO: b/388762778 - The MP4 container has extra information (e.g. cdsc box) specifying @@ -402,36 +399,19 @@ public long selectTracks( // the correct mergingSampleStreams when multiple video/HAGC tracks exist. for (int j = 0; j < tracks.length; j++) { Format format = tracks.get(j).getFormat(0); - if (Objects.equals(format.sampleMimeType, MimeTypes.APPLICATION_ITUT_T35)) { - boolean isHagc = false; - if (!format.initializationData.isEmpty()) { - byte[] initData = format.initializationData.get(0); - if (initData.length >= 5 - && initData[0] == (byte) 0xB5 - && initData[1] == (byte) 0x00 - && initData[2] == (byte) 0x90 - && initData[3] == (byte) 0x00 - && initData[4] == (byte) 0x01) { - isHagc = true; - } - } - if (isHagc) { - checkState(!trackEnabledStates[j]); - enabledTrackCount++; - trackEnabledStates[j] = true; - if (loadOnlySelectedTracks) { - controlledTrackOutputs[j].updateSelectionState(true); - } - // HAGC it35 metadata samples are standalone and do not depend on - // previous samples, hence hasPreroll is not relevant and always false. - stream = - new MergingMetadataSampleStream( - stream, - new SampleStreamImpl(j, /* hasPreroll= */ false), - selection.getSelectedFormat()); - mergingSampleStreams.add((MergingMetadataSampleStream) stream); - break; - } + if (CodecSpecificDataUtil.isHagcTrack(format)) { + checkState(!trackEnabledStates[j]); + enabledTrackCount++; + trackEnabledStates[j] = true; + // HAGC it35 metadata samples are standalone and do not depend on + // previous samples, hence hasPreroll is not relevant and always false. + stream = + new MergingMetadataSampleStream( + stream, + new SampleStreamImpl(j, /* hasPreroll= */ false), + selection.getSelectedFormat()); + mergingSampleStreams.add((MergingMetadataSampleStream) stream); + break; } } } @@ -772,19 +752,17 @@ private boolean suppressRead() { public void onLoadStarted( ExtractingLoadable loadable, long elapsedRealtimeMs, long loadDurationMs, int retryCount) { StatsDataSource dataSource = loadable.dataSource; - LoadEventInfo loadEventInfo = - retryCount == 0 - ? new LoadEventInfo(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) - : new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - dataSource.getLastOpenedUri(), - dataSource.getLastResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - dataSource.getBytesRead()); + LoadEventInfo.Builder loadEventInfo = + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs); + if (retryCount != 0) { + loadEventInfo + .setUri(dataSource.getLastOpenedUri()) + .setResponseHeaders(dataSource.getLastResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(dataSource.getBytesRead()); + } mediaSourceEventDispatcher.loadStarted( - loadEventInfo, + loadEventInfo.build(), C.DATA_TYPE_MEDIA, C.TRACK_TYPE_UNKNOWN, /* trackFormat= */ null, @@ -809,14 +787,12 @@ public void onLoadCompleted( } StatsDataSource dataSource = loadable.dataSource; LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - dataSource.getLastOpenedUri(), - dataSource.getLastResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - dataSource.getBytesRead()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(dataSource.getLastOpenedUri()) + .setResponseHeaders(dataSource.getLastResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(dataSource.getBytesRead()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); mediaSourceEventDispatcher.loadCompleted( loadEventInfo, @@ -836,14 +812,12 @@ public void onLoadCanceled( ExtractingLoadable loadable, long elapsedRealtimeMs, long loadDurationMs, boolean released) { StatsDataSource dataSource = loadable.dataSource; LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - dataSource.getLastOpenedUri(), - dataSource.getLastResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - dataSource.getBytesRead()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(dataSource.getLastOpenedUri()) + .setResponseHeaders(dataSource.getLastResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(dataSource.getBytesRead()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); mediaSourceEventDispatcher.loadCanceled( loadEventInfo, @@ -873,14 +847,12 @@ public LoadErrorAction onLoadError( int errorCount) { StatsDataSource dataSource = loadable.dataSource; LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - dataSource.getLastOpenedUri(), - dataSource.getLastResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - dataSource.getBytesRead()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(dataSource.getLastOpenedUri()) + .setResponseHeaders(dataSource.getLastResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(dataSource.getBytesRead()) + .build(); MediaLoadData mediaLoadData = new MediaLoadData( C.DATA_TYPE_MEDIA, @@ -1171,13 +1143,28 @@ private boolean seekInsideBufferUs( continue; } - if (sampleQueue.getReadIndex() == 0 && isSameAsLastSeekPosition) { + if (isSingleSample) { + // Single sample media (like images) only have one sample, so seeking always succeeds + // by resetting to the first sample. + sampleQueue.seekTo(sampleQueue.getFirstIndex()); + continue; + } + long firstTimestampUs = sampleQueue.getFirstTimestampUs(); + if (firstTimestampUs != Long.MIN_VALUE + && positionUs <= firstTimestampUs + && sampleQueue.getFirstIndex() == 0 + && isSameAsLastSeekPosition) { + // If the seek target position is at or before the timestamp of the very first queued + // sample, + // and all samples loaded from the beginning of the stream are still present, reset to the + // first sample by index. This avoids falling through to a timestamp-based seek, which would + // reject the seek if the target position is strictly smaller than the first sample's + // timestamp (e.g., when seeking to time 0 on an audio track with encoder delay). + sampleQueue.seekTo(sampleQueue.getFirstIndex()); continue; } boolean seekInsideQueue = - isSingleSample - ? sampleQueue.seekTo(sampleQueue.getFirstIndex()) - : sampleQueue.seekTo(positionUs, /* allowTimeBeyondBuffer= */ loadingFinished); + sampleQueue.seekTo(positionUs, /* allowTimeBeyondBuffer= */ loadingFinished); // If we have AV tracks then an in-buffer seek is successful if the seek into every AV queue // is successful. We ignore whether seeks within non-AV queues are successful in this case, as // they may be sparse or poorly interleaved. If we only have non-AV tracks then a seek is @@ -1487,26 +1474,13 @@ private static int getTrackTypePriority(@C.TrackType int trackType) { private static class ControlledTrackOutput extends ForwardingTrackOutput { private final SampleQueue sampleQueue; private final DiscardingTrackOutput discardingTrackOutput; - private final AtomicReference outputMode; - - /** The mode of operation for the controlled track output. */ - static enum OutputMode { - /** Pass samples through to the downstream track output. */ - PASS_THROUGH, - /** - * Pass samples through to the downstream track output, but discard after the next sample - * metadata is received. - */ - DISCARD_AFTER_NEXT_SAMPLE_METADATA, - /** Discards all samples. */ - DISCARDING, - }; + private final AtomicBoolean isDiscarding; ControlledTrackOutput(SampleQueue sampleQueue) { super(sampleQueue); this.sampleQueue = sampleQueue; this.discardingTrackOutput = new DiscardingTrackOutput(); - this.outputMode = new AtomicReference<>(OutputMode.PASS_THROUGH); + this.isDiscarding = new AtomicBoolean(false); } @Override @@ -1540,10 +1514,6 @@ public void sampleMetadata( int offset, @Nullable CryptoData cryptoData) { getCurrentOutput().sampleMetadata(timeUs, flags, size, offset, cryptoData); - if (outputMode.get() == OutputMode.DISCARD_AFTER_NEXT_SAMPLE_METADATA) { - sampleQueue.reset(); - outputMode.set(OutputMode.DISCARDING); - } } /** @@ -1552,10 +1522,7 @@ public void sampleMetadata( * @param selected Whether the track is selected. */ void updateSelectionState(boolean selected) { - // Since there could still be some samples within the internal SampleDataQueue, we will be - // confident about releasing them all after the next sample metadata is received. - outputMode.set( - selected ? OutputMode.PASS_THROUGH : OutputMode.DISCARD_AFTER_NEXT_SAMPLE_METADATA); + isDiscarding.set(!selected); // In case the existing samples are taking too much memory, preventing further load, release // them optimistically. if (!selected) { @@ -1565,11 +1532,11 @@ void updateSelectionState(boolean selected) { /** Returns whether the track is selected. */ boolean isSelected() { - return outputMode.get() == OutputMode.PASS_THROUGH; + return !isDiscarding.get(); } private TrackOutput getCurrentOutput() { - return outputMode.get() == OutputMode.DISCARDING ? discardingTrackOutput : sampleQueue; + return isDiscarding.get() ? discardingTrackOutput : sampleQueue; } } } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ProgressiveMediaSource.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ProgressiveMediaSource.java index 87aaee8e097..3d7c8b1c0f9 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ProgressiveMediaSource.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ProgressiveMediaSource.java @@ -96,7 +96,6 @@ public static final class Factory implements MediaSourceFactory { private int singleTrackId; @Nullable private Format singleTrackFormat; private boolean loadOnlySelectedTracks; - private boolean experimentalEnableHagcPlayback; /** * Creates a new factory for {@link ProgressiveMediaSource}s. @@ -187,19 +186,6 @@ public Factory( this.drmSessionManagerProvider = drmSessionManagerProvider; this.loadErrorHandlingPolicy = loadErrorHandlingPolicy; this.continueLoadingCheckIntervalBytes = continueLoadingCheckIntervalBytes; - this.experimentalEnableHagcPlayback = true; - } - - /** - * Sets whether to enable experimental HAGC (ST 2094-50) metadata playback support. - * - * @param enableHagcPlayback Whether experimental HAGC metadata playback is enabled. - * @return This factory, for convenience. - */ - @CanIgnoreReturnValue - public Factory setExperimentalEnableHagcPlayback(boolean enableHagcPlayback) { - this.experimentalEnableHagcPlayback = enableHagcPlayback; - return this; } @CanIgnoreReturnValue @@ -317,7 +303,6 @@ public ProgressiveMediaSource createMediaSource(MediaItem mediaItem) { loadErrorHandlingPolicy, continueLoadingCheckIntervalBytes, loadOnlySelectedTracks, - experimentalEnableHagcPlayback, singleTrackId, singleTrackFormat, downloadExecutorSupplier); @@ -341,7 +326,6 @@ public ProgressiveMediaSource createMediaSource(MediaItem mediaItem) { private final LoadErrorHandlingPolicy loadableLoadErrorHandlingPolicy; private final int continueLoadingCheckIntervalBytes; private final boolean loadOnlySelectedTracks; - private final boolean experimentalEnableHagcPlayback; /** * The ID passed to {@link Factory#enableLazyLoadingWithSingleTrack(int, Format)}. Only valid if @@ -377,7 +361,6 @@ private ProgressiveMediaSource( LoadErrorHandlingPolicy loadableLoadErrorHandlingPolicy, int continueLoadingCheckIntervalBytes, boolean loadOnlySelectedTracks, - boolean experimentalEnableHagcPlayback, int singleTrackId, @Nullable Format singleTrackFormat, @Nullable Supplier downloadExecutorSupplier) { @@ -388,7 +371,6 @@ private ProgressiveMediaSource( this.loadableLoadErrorHandlingPolicy = loadableLoadErrorHandlingPolicy; this.continueLoadingCheckIntervalBytes = continueLoadingCheckIntervalBytes; this.loadOnlySelectedTracks = loadOnlySelectedTracks; - this.experimentalEnableHagcPlayback = experimentalEnableHagcPlayback; this.singleTrackFormat = singleTrackFormat; this.singleTrackId = singleTrackId; this.timelineIsPlaceholder = true; @@ -450,7 +432,6 @@ public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator, long star localConfiguration.customCacheKey, continueLoadingCheckIntervalBytes, loadOnlySelectedTracks, - experimentalEnableHagcPlayback, singleTrackId, singleTrackFormat, Util.msToUs(localConfiguration.imageDurationMs), diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ShuffleOrder.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ShuffleOrder.java index fc909b653e5..ee770c2f941 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ShuffleOrder.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ShuffleOrder.java @@ -294,7 +294,7 @@ default ShuffleOrder cloneAndMove(int indexFrom, int indexToExclusive, int newIn * * @param insertionCount The number of elements. * @param startIndex The index of the new element in the unshuffled order that should be the first - * in the shuffled order or {@link C#INDEX_UNSET} if the the first element in the shuffled + * in the shuffled order or {@link C#INDEX_UNSET} if the first element in the shuffled * order is not specified. It should be ignored if the new list is empty, or if it is larger * than the last index (inclusive) of the new list. * @return A copy of this {@link ShuffleOrder} with the elements replaced. diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/SingleSampleMediaPeriod.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/SingleSampleMediaPeriod.java index 11a9575f173..d29645ca74a 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/SingleSampleMediaPeriod.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/SingleSampleMediaPeriod.java @@ -207,19 +207,17 @@ public long getAdjustedSeekPositionUs(long positionUs, SeekParameters seekParame public void onLoadStarted( SourceLoadable loadable, long elapsedRealtimeMs, long loadDurationMs, int retryCount) { StatsDataSource dataSource = loadable.dataSource; - LoadEventInfo loadEventInfo = - retryCount == 0 - ? new LoadEventInfo(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) - : new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - dataSource.getLastOpenedUri(), - dataSource.getLastResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - dataSource.getBytesRead()); + LoadEventInfo.Builder loadEventInfo = + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs); + if (retryCount != 0) { + loadEventInfo + .setUri(dataSource.getLastOpenedUri()) + .setResponseHeaders(dataSource.getLastResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(dataSource.getBytesRead()); + } eventDispatcher.loadStarted( - loadEventInfo, + loadEventInfo.build(), C.DATA_TYPE_MEDIA, C.TRACK_TYPE_UNKNOWN, format, @@ -238,14 +236,12 @@ public void onLoadCompleted( loadingFinished = true; StatsDataSource dataSource = loadable.dataSource; LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - dataSource.getLastOpenedUri(), - dataSource.getLastResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - sampleSize); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(dataSource.getLastOpenedUri()) + .setResponseHeaders(dataSource.getLastResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(sampleSize) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); eventDispatcher.loadCompleted( loadEventInfo, @@ -263,14 +259,12 @@ public void onLoadCanceled( SourceLoadable loadable, long elapsedRealtimeMs, long loadDurationMs, boolean released) { StatsDataSource dataSource = loadable.dataSource; LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - dataSource.getLastOpenedUri(), - dataSource.getLastResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - dataSource.getBytesRead()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(dataSource.getLastOpenedUri()) + .setResponseHeaders(dataSource.getLastResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(dataSource.getBytesRead()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); eventDispatcher.loadCanceled( loadEventInfo, @@ -292,14 +286,12 @@ public LoadErrorAction onLoadError( int errorCount) { StatsDataSource dataSource = loadable.dataSource; LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - dataSource.getLastOpenedUri(), - dataSource.getLastResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - dataSource.getBytesRead()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(dataSource.getLastOpenedUri()) + .setResponseHeaders(dataSource.getLastResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(dataSource.getBytesRead()) + .build(); MediaLoadData mediaLoadData = new MediaLoadData( C.DATA_TYPE_MEDIA, diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdTimeline.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdTimeline.java deleted file mode 100644 index 5437ac0b909..00000000000 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdTimeline.java +++ /dev/null @@ -1,121 +0,0 @@ -/* - * Copyright (C) 2026 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 androidx.media3.exoplayer.source.ads; - -import static com.google.common.base.Preconditions.checkState; - -import androidx.annotation.VisibleForTesting; -import androidx.media3.common.AdPlaybackState; -import androidx.media3.common.C; -import androidx.media3.common.Timeline; -import androidx.media3.common.util.UnstableApi; -import androidx.media3.exoplayer.source.ForwardingTimeline; - -/** - * A custom {@link Timeline} for sources that have {@link AdPlaybackState} split among multiple - * periods. - * - *

For each period a modified {@link AdPlaybackState} is created: - * - *

    - *
  • Ad group time is offset relative to period start time - *
  • Post-roll ad group is kept only for last period - *
  • Ad group count and indices are kept unchanged - *
- */ -@VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE) -@UnstableApi -public final class AdTimeline extends ForwardingTimeline { - - private final AdPlaybackState[] adPlaybackStates; - - /** - * Creates a new timeline alongside which ads will be played. - * - * @param contentTimeline The timeline of the content alongside which ads will be played. - * @param adPlaybackState The state of the media's ads. The ad group times in this state must be - * relative to the start of the window (i.e. timeUs = 0 corresponds to the start of the - * window). - */ - public AdTimeline(Timeline contentTimeline, AdPlaybackState adPlaybackState) { - super(contentTimeline); - int periodCount = contentTimeline.getPeriodCount(); - checkState(contentTimeline.getWindowCount() == 1); - this.adPlaybackStates = new AdPlaybackState[periodCount]; - - Timeline.Period period = new Timeline.Period(); - for (int periodIndex = 0; periodIndex < periodCount; periodIndex++) { - timeline.getPeriod(periodIndex, period); - adPlaybackStates[periodIndex] = - forPeriod( - adPlaybackState, - period.positionInWindowUs, - period.durationUs, - /* isLastPeriod= */ periodIndex == periodCount - 1); - } - } - - @Override - public Period getPeriod(int periodIndex, Period period, boolean setIds) { - timeline.getPeriod(periodIndex, period, setIds); - long durationUs = - period.durationUs == C.TIME_UNSET - ? adPlaybackStates[periodIndex].contentDurationUs - : period.durationUs; - period.set( - period.id, - period.uid, - period.windowIndex, - durationUs, - period.getPositionInWindowUs(), - adPlaybackStates[periodIndex], - period.isPlaceholder); - return period; - } - - private AdPlaybackState forPeriod( - AdPlaybackState adPlaybackState, - long periodStartOffsetUs, - long periodDurationUs, - boolean isLastPeriod) { - if (periodStartOffsetUs == 0 && isLastPeriod) { - long contentDurationUs = - periodDurationUs == C.TIME_UNSET ? adPlaybackState.contentDurationUs : periodDurationUs; - return adPlaybackState.withContentDurationUs(contentDurationUs); - } - long contentDurationUs = periodDurationUs; - if (contentDurationUs == C.TIME_UNSET) { - contentDurationUs = - isLastPeriod && adPlaybackState.contentDurationUs != C.TIME_UNSET - ? adPlaybackState.contentDurationUs - periodStartOffsetUs - : C.TIME_UNSET; - } - adPlaybackState = adPlaybackState.withContentDurationUs(contentDurationUs); - - for (int adGroupIndex = 0; adGroupIndex < adPlaybackState.adGroupCount; adGroupIndex++) { - long adGroupTimeUs = adPlaybackState.getAdGroup(adGroupIndex).timeUs; - if (adGroupTimeUs == C.TIME_END_OF_SOURCE) { - if (!isLastPeriod) { - adPlaybackState = adPlaybackState.withSkippedAdGroup(adGroupIndex); - } - } else { - adPlaybackState = - adPlaybackState.withAdGroupTimeUs(adGroupIndex, adGroupTimeUs - periodStartOffsetUs); - } - } - return adPlaybackState; - } -} diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdsLoader.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdsLoader.java index 5d98c8223e4..52f5d318918 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdsLoader.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdsLoader.java @@ -76,9 +76,6 @@ interface EventListener { * Called when the ad playback state has been updated. The number of {@link * AdPlaybackState#adGroupCount ad groups} may not change after the first call. * - *

The ad group times in the {@link AdPlaybackState} must be relative to the start of the - * timeline window (i.e. timeUs = 0 corresponds to the start of the window). - * * @param adPlaybackState The new ad playback state. */ default void onAdPlaybackState(AdPlaybackState adPlaybackState) {} diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdsMediaSource.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdsMediaSource.java index fb67b28a619..87f3744a2a8 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdsMediaSource.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/AdsMediaSource.java @@ -59,13 +59,12 @@ import java.util.Map; import java.util.Objects; import org.checkerframework.checker.nullness.qual.MonotonicNonNull; +import org.checkerframework.checker.nullness.qual.RequiresNonNull; /** * A {@link MediaSource} that inserts ads linearly into a provided content media source. * - *

The wrapped content media source can contain multiple {@linkplain Timeline.Period periods}. - * Note that multi-period ad insertion is not supported by all {@link AdsLoader} implementations - * (for example, the IMA extension's {@code ImaAdsLoader} only supports single-period Timelines). + *

The wrapped content media source must contain a single {@link Timeline.Period}. */ @UnstableApi public final class AdsMediaSource extends CompositeMediaSource { @@ -154,12 +153,11 @@ public RuntimeException getRuntimeExceptionForUnexpected() { private final boolean useLazyContentSourcePreparation; private final boolean useAdMediaSourceClipping; private final List activeMediaSourceHolders; - private final Map activeContentClippingMediaPeriods; + private final Map activeContentClippingMediaPeriods; // Accessed on the player thread. @Nullable private ComponentListener componentListener; @Nullable private Timeline contentTimeline; - @Nullable private Timeline activeTimeline; @Nullable private AdPlaybackState adPlaybackState; private @NullableType AdMediaSourceHolder[][] adMediaSourceHolders; @Nullable private Handler playerHandler; @@ -332,16 +330,14 @@ public MediaPeriod createPeriod(MediaPeriodId id, Allocator allocator, long star if (id.nextAdGroupIndex == C.INDEX_UNSET) { return maskingMediaPeriod; } - long endPositionUs = - getContentClippingEndPositionUs( - checkNotNull(activeTimeline), id.periodUid, id.nextAdGroupIndex); + long nextAdGroupTimeUs = adPlaybackState.getAdGroup(id.nextAdGroupIndex).timeUs; ClippingMediaPeriod clippingMediaPeriod = new ClippingMediaPeriod( maskingMediaPeriod, /* enableInitialDiscontinuity= */ true, /* startUs= */ 0, - /* endUs= */ endPositionUs); - activeContentClippingMediaPeriods.put(clippingMediaPeriod, id); + /* endUs= */ nextAdGroupTimeUs); + activeContentClippingMediaPeriods.put(clippingMediaPeriod, id.nextAdGroupIndex); return clippingMediaPeriod; } } @@ -379,7 +375,6 @@ protected void releaseSourceInternal() { this.playerHandler = null; componentListener.stop(); contentTimeline = null; - activeTimeline = null; adPlaybackState = null; adMediaSourceHolders = new AdMediaSourceHolder[0][]; mainHandler.post(() -> adsLoader.stop(/* adsMediaSource= */ this, componentListener)); @@ -395,6 +390,7 @@ protected void onChildSourceInfoRefreshed( .handleSourceInfoRefresh(newTimeline); maybeUpdateSourceInfo(); } else { + checkArgument(newTimeline.getPeriodCount() == 1); contentTimeline = newTimeline; mainHandler.post( () -> { @@ -449,6 +445,14 @@ private void onAdPlaybackState(AdPlaybackState adPlaybackState) { } } } + for (Map.Entry activeClippingPeriod : + activeContentClippingMediaPeriods.entrySet()) { + int nextAdGroupIndex = activeClippingPeriod.getValue(); + long nextAdGroupTimeUs = adPlaybackState.getAdGroup(nextAdGroupIndex).timeUs; + activeClippingPeriod + .getKey() + .updateClipping(/* startUs= */ 0, /* endUs= */ nextAdGroupTimeUs); + } } this.adPlaybackState = adPlaybackState; maybeUpdateAdMediaSources(); @@ -532,30 +536,19 @@ private void maybeUpdateAdMediaSources() { private void maybeUpdateSourceInfo() { @Nullable Timeline contentTimeline = this.contentTimeline; - @Nullable AdPlaybackState adPlaybackState = this.adPlaybackState; if (adPlaybackState != null && contentTimeline != null) { if (adPlaybackState.adGroupCount == 0) { - activeTimeline = contentTimeline; refreshSourceInfo(contentTimeline); } else { - long[][] durations = getAdDurationsUs(adPlaybackState); - adPlaybackState = adPlaybackState.withAdDurationsUs(durations); - this.adPlaybackState = adPlaybackState; - Timeline activeTimeline = new AdTimeline(contentTimeline, adPlaybackState); - this.activeTimeline = activeTimeline; - for (Map.Entry activeClippingPeriod : - activeContentClippingMediaPeriods.entrySet()) { - MediaPeriodId id = activeClippingPeriod.getValue(); - long endPositionUs = - getContentClippingEndPositionUs(activeTimeline, id.periodUid, id.nextAdGroupIndex); - activeClippingPeriod.getKey().updateClipping(/* startUs= */ 0, endPositionUs); - } - refreshSourceInfo(activeTimeline); + adPlaybackState = adPlaybackState.withAdDurationsUs(getAdDurationsUs()); + refreshSourceInfo(new SinglePeriodAdTimeline(contentTimeline, adPlaybackState)); } } } - private long[][] getAdDurationsUs(AdPlaybackState adPlaybackState) { + @RequiresNonNull("adPlaybackState") + private long[][] getAdDurationsUs() { + AdPlaybackState adPlaybackState = checkNotNull(this.adPlaybackState); boolean hasPostRollPlaceholder = adPlaybackState.endsWithLivePostrollPlaceHolder(); int adGroupCount = adMediaSourceHolders.length + (hasPostRollPlaceholder ? 1 : 0); long[][] adDurationsUs = new long[adGroupCount][]; @@ -635,10 +628,11 @@ public void onAdLoadError(final AdLoadException error, DataSpec dataSpec) { } createEventDispatcher(/* mediaPeriodId= */ null) .loadError( - new LoadEventInfo( - LoadEventInfo.getNewId(), - dataSpec, - /* elapsedRealtimeMs= */ SystemClock.elapsedRealtime()), + new LoadEventInfo.Builder( + LoadEventInfo.getNewId(), + dataSpec, + /* elapsedRealtimeMs= */ SystemClock.elapsedRealtime()) + .build(), C.DATA_TYPE_AD, error, /* wasCanceled= */ true); @@ -667,10 +661,11 @@ public void onPrepareComplete(MediaPeriodId mediaPeriodId) { public void onPrepareError(MediaPeriodId mediaPeriodId, IOException exception) { createEventDispatcher(mediaPeriodId) .loadError( - new LoadEventInfo( - LoadEventInfo.getNewId(), - new DataSpec(checkNotNull(adMediaItem.localConfiguration).uri), - /* elapsedRealtimeMs= */ SystemClock.elapsedRealtime()), + new LoadEventInfo.Builder( + LoadEventInfo.getNewId(), + new DataSpec(checkNotNull(adMediaItem.localConfiguration).uri), + /* elapsedRealtimeMs= */ SystemClock.elapsedRealtime()) + .build(), C.DATA_TYPE_AD, AdLoadException.createForAd(exception), /* wasCanceled= */ true); @@ -804,14 +799,4 @@ private MaskingMediaPeriod getActiveMaskingMediaPeriod(int activeMediaPeriodInde : mediaPeriod); } } - - private long getContentClippingEndPositionUs( - Timeline activeTimeline, Object periodUid, int nextAdGroupIndex) { - int periodIndex = activeTimeline.getIndexOfPeriod(periodUid); - if (periodIndex == C.INDEX_UNSET) { - return C.TIME_END_OF_SOURCE; - } - activeTimeline.getPeriod(periodIndex, period); - return period.adPlaybackState.getAdGroup(nextAdGroupIndex).timeUs; - } } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/SinglePeriodAdTimeline.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/SinglePeriodAdTimeline.java new file mode 100644 index 00000000000..c0d6b9b4ce2 --- /dev/null +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/ads/SinglePeriodAdTimeline.java @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2017 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 androidx.media3.exoplayer.source.ads; + +import static com.google.common.base.Preconditions.checkState; + +import androidx.annotation.VisibleForTesting; +import androidx.media3.common.AdPlaybackState; +import androidx.media3.common.C; +import androidx.media3.common.Timeline; +import androidx.media3.common.util.UnstableApi; +import androidx.media3.exoplayer.source.ForwardingTimeline; + +/** A {@link Timeline} for sources that have ads. */ +@VisibleForTesting(otherwise = VisibleForTesting.PACKAGE_PRIVATE) +@UnstableApi +public final class SinglePeriodAdTimeline extends ForwardingTimeline { + + private final AdPlaybackState adPlaybackState; + + /** + * Creates a new timeline with a single period containing ads. + * + * @param contentTimeline The timeline of the content alongside which ads will be played. It must + * have one window and one period. + * @param adPlaybackState The state of the period's ads. + */ + public SinglePeriodAdTimeline(Timeline contentTimeline, AdPlaybackState adPlaybackState) { + super(contentTimeline); + checkState(contentTimeline.getPeriodCount() == 1); + checkState(contentTimeline.getWindowCount() == 1); + this.adPlaybackState = adPlaybackState; + } + + @Override + public Period getPeriod(int periodIndex, Period period, boolean setIds) { + timeline.getPeriod(periodIndex, period, setIds); + long durationUs = + period.durationUs == C.TIME_UNSET ? adPlaybackState.contentDurationUs : period.durationUs; + period.set( + period.id, + period.uid, + period.windowIndex, + durationUs, + period.getPositionInWindowUs(), + adPlaybackState, + period.isPlaceholder); + return period; + } +} diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/BaseMediaChunk.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/BaseMediaChunk.java index c7dc60b7910..387d14dd63e 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/BaseMediaChunk.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/BaseMediaChunk.java @@ -77,7 +77,8 @@ public BaseMediaChunk( trackSelectionData, startTimeUs, endTimeUs, - chunkIndex); + chunkIndex, + /* steeredPathwayId= */ null); this.clippedStartTimeUs = clippedStartTimeUs; this.clippedEndTimeUs = clippedEndTimeUs; } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/Chunk.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/Chunk.java index 9e1de1ed649..df20030dd7c 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/Chunk.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/Chunk.java @@ -75,6 +75,12 @@ public abstract class Chunk implements Loadable { */ public final long endTimeUs; + /** + * The ID of the steered pathway from which data is being loaded, or {@code null} if not + * applicable. + */ + @Nullable public final String steeredPathwayId; + protected final StatsDataSource dataSource; /** @@ -86,6 +92,7 @@ public abstract class Chunk implements Loadable { * @param trackSelectionData See {@link #trackSelectionData}. * @param startTimeUs See {@link #startTimeUs}. * @param endTimeUs See {@link #endTimeUs}. + * @param steeredPathwayId See {@link #steeredPathwayId}. */ public Chunk( DataSource dataSource, @@ -95,7 +102,8 @@ public Chunk( @C.SelectionReason int trackSelectionReason, @Nullable Object trackSelectionData, long startTimeUs, - long endTimeUs) { + long endTimeUs, + @Nullable String steeredPathwayId) { this.dataSource = new StatsDataSource(dataSource); this.dataSpec = checkNotNull(dataSpec); this.type = type; @@ -104,6 +112,7 @@ public Chunk( this.trackSelectionData = trackSelectionData; this.startTimeUs = startTimeUs; this.endTimeUs = endTimeUs; + this.steeredPathwayId = steeredPathwayId; loadTaskId = LoadEventInfo.getNewId(); } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/ChunkSampleStream.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/ChunkSampleStream.java index dff4778efd9..5ae5e7f70ad 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/ChunkSampleStream.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/ChunkSampleStream.java @@ -484,19 +484,17 @@ public int skipData(long positionUs) { @Override public void onLoadStarted( Chunk loadable, long elapsedRealtimeMs, long loadDurationMs, int retryCount) { - LoadEventInfo loadEventInfo = - retryCount == 0 - ? new LoadEventInfo(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) - : new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + LoadEventInfo.Builder loadEventInfo = + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs); + if (retryCount != 0) { + loadEventInfo + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()); + } mediaSourceEventDispatcher.loadStarted( - loadEventInfo, + loadEventInfo.build(), loadable.type, primaryTrackType, loadable.trackFormat, @@ -512,14 +510,12 @@ public void onLoadCompleted(Chunk loadable, long elapsedRealtimeMs, long loadDur loadingChunk = null; chunkSource.onChunkLoadCompleted(loadable); LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); mediaSourceEventDispatcher.loadCompleted( loadEventInfo, @@ -539,14 +535,12 @@ public void onLoadCanceled( loadingChunk = null; canceledMediaChunk = null; LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); mediaSourceEventDispatcher.loadCanceled( loadEventInfo, @@ -584,14 +578,12 @@ public LoadErrorAction onLoadError( boolean cancelable = bytesLoaded == 0 || !isMediaChunk || !haveReadFromMediaChunk(lastChunkIndex); LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - bytesLoaded); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(bytesLoaded) + .build(); MediaLoadData mediaLoadData = new MediaLoadData( loadable.type, diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/DataChunk.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/DataChunk.java index 5e8707ad2c9..38d96e9ced8 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/DataChunk.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/DataChunk.java @@ -65,7 +65,8 @@ public DataChunk( trackSelectionReason, trackSelectionData, C.TIME_UNSET, - C.TIME_UNSET); + C.TIME_UNSET, + /* steeredPathwayId= */ null); this.data = data == null ? Util.EMPTY_BYTE_ARRAY : data; } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/InitializationChunk.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/InitializationChunk.java index 4ad794a88f2..25751dbcdf5 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/InitializationChunk.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/InitializationChunk.java @@ -66,7 +66,8 @@ public InitializationChunk( trackSelectionReason, trackSelectionData, C.TIME_UNSET, - C.TIME_UNSET); + C.TIME_UNSET, + /* steeredPathwayId= */ null); this.chunkExtractor = chunkExtractor; } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/MediaChunk.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/MediaChunk.java index 8817bece221..35ec7024514 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/MediaChunk.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/chunk/MediaChunk.java @@ -40,6 +40,7 @@ public abstract class MediaChunk extends Chunk { * @param startTimeUs The start time of the media contained by the chunk, in microseconds. * @param endTimeUs The end time of the media contained by the chunk, in microseconds. * @param chunkIndex The index of the chunk, or {@link C#INDEX_UNSET} if it is not known. + * @param steeredPathwayId See {@link #steeredPathwayId}. */ public MediaChunk( DataSource dataSource, @@ -49,7 +50,8 @@ public MediaChunk( @Nullable Object trackSelectionData, long startTimeUs, long endTimeUs, - long chunkIndex) { + long chunkIndex, + @Nullable String steeredPathwayId) { super( dataSource, dataSpec, @@ -58,7 +60,8 @@ public MediaChunk( trackSelectionReason, trackSelectionData, startTimeUs, - endTimeUs); + endTimeUs, + steeredPathwayId); checkNotNull(trackFormat); this.chunkIndex = chunkIndex; } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/preload/DefaultPreloadManager.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/preload/DefaultPreloadManager.java index c363aebcae5..91634a58db6 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/preload/DefaultPreloadManager.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/source/preload/DefaultPreloadManager.java @@ -648,7 +648,7 @@ private DefaultPreloadManager(Builder builder) { preloadLooperProvider = builder.preloadLooperProvider; trackSelector = builder.trackSelectorFactory.createTrackSelector(builder.context); BandwidthMeter bandwidthMeter = builder.bandwidthMeterSupplier.get(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(trackSelector::onParametersActivated, bandwidthMeter); Looper preloadLooper = preloadLooperProvider.obtainLooper(); preloadMediaSourceFactory = new PreloadMediaSource.Factory( diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/DefaultTrackSelector.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/DefaultTrackSelector.java index b3824c00da1..6b63549119b 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/DefaultTrackSelector.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/DefaultTrackSelector.java @@ -38,7 +38,6 @@ import android.util.SparseArray; import android.util.SparseBooleanArray; import android.view.accessibility.CaptioningManager; -import androidx.annotation.GuardedBy; import androidx.annotation.IntDef; import androidx.annotation.Nullable; import androidx.media3.common.AudioAttributes; @@ -67,6 +66,7 @@ import androidx.media3.exoplayer.mediacodec.MediaCodecUtil; import androidx.media3.exoplayer.source.MediaSource.MediaPeriodId; import androidx.media3.exoplayer.source.TrackGroupArray; +import androidx.media3.exoplayer.upstream.BandwidthMeter; import androidx.media3.exoplayer.util.SpatializerWrapper; import com.google.common.base.Predicate; import com.google.common.collect.ComparisonChain; @@ -2455,16 +2455,13 @@ public static SelectionOverride fromBundle(Bundle bundle) { ? (second == Format.NO_VALUE ? 0 : -1) : (second == Format.NO_VALUE ? 1 : (first - second))); - private final Object lock; @Nullable public final Context context; private final ExoTrackSelection.Factory trackSelectionFactory; - @GuardedBy("lock") - private Parameters parameters; + private Parameters applicationParameters; + private Parameters playerParameters; - @GuardedBy("lock") - @Nullable - private Thread playbackThread; + @Nullable private volatile Thread playbackThread; @Nullable private SpatializerWrapper spatializer; private AudioAttributes audioAttributes; @@ -2531,28 +2528,46 @@ private DefaultTrackSelector( TrackSelectionParameters parameters, ExoTrackSelection.Factory trackSelectionFactory, @Nullable Context context) { - this.lock = new Object(); this.context = context != null ? context.getApplicationContext() : null; this.trackSelectionFactory = trackSelectionFactory; + Parameters initialParameters; if (parameters instanceof Parameters) { - this.parameters = (Parameters) parameters; + initialParameters = (Parameters) parameters; } else { - this.parameters = Parameters.DEFAULT.buildUpon().set(parameters).build(); + initialParameters = Parameters.DEFAULT.buildUpon().set(parameters).build(); } + this.applicationParameters = initialParameters; + this.playerParameters = initialParameters; this.audioAttributes = AudioAttributes.DEFAULT; - if (this.parameters.constrainAudioChannelCountToDeviceCapabilities && context == null) { + if (initialParameters.constrainAudioChannelCountToDeviceCapabilities && context == null) { Log.w(TAG, AUDIO_CHANNEL_COUNT_CONSTRAINTS_WARN_MESSAGE); } } + @Override + public void init(InvalidationListener listener, BandwidthMeter bandwidthMeter) { + super.init(listener, bandwidthMeter); + this.playerParameters = getParameters(); + } + + @Override + public void onParametersActivated(@Nullable TrackSelectionParameters parameters) { + if (parameters == null) { + return; + } + if (parameters instanceof Parameters) { + this.playerParameters = (Parameters) parameters; + } else { + this.playerParameters = new Parameters.Builder(this.playerParameters).set(parameters).build(); + } + } + @Override public void release() { - synchronized (lock) { - if (playbackThread != null) { - checkState( - playbackThread == Thread.currentThread(), - "DefaultTrackSelector is accessed on the wrong thread."); - } + if (playbackThread != null) { + checkState( + Thread.currentThread().equals(playbackThread), + "DefaultTrackSelector is accessed on the wrong thread."); } if (SDK_INT >= 32 && spatializer != null) { spatializer.release(); @@ -2563,9 +2578,7 @@ public void release() { @Override public Parameters getParameters() { - synchronized (lock) { - return parameters; - } + return applicationParameters; } @Override @@ -2622,17 +2635,14 @@ public Parameters.Builder buildUponParameters() { */ private void setParametersInternal(Parameters parameters) { checkNotNull(parameters); - boolean parametersChanged; - synchronized (lock) { - parametersChanged = !this.parameters.equals(parameters); - this.parameters = parameters; - } + boolean parametersChanged = !this.applicationParameters.equals(parameters); + this.applicationParameters = parameters; if (parametersChanged) { if (parameters.constrainAudioChannelCountToDeviceCapabilities && context == null) { Log.w(TAG, AUDIO_CHANNEL_COUNT_CONSTRAINTS_WARN_MESSAGE); } - invalidate(); + invalidate(parameters); } } @@ -2660,15 +2670,11 @@ public void onRendererCapabilitiesChanged(Renderer renderer) { MediaPeriodId mediaPeriodId, Timeline timeline) throws ExoPlaybackException { - Parameters parameters; - synchronized (lock) { - playbackThread = Thread.currentThread(); - parameters = this.parameters; - } + playbackThread = Thread.currentThread(); if (deviceIsTV == null && context != null) { deviceIsTV = Util.isTv(context); } - if (parameters.constrainAudioChannelCountToDeviceCapabilities + if (playerParameters.constrainAudioChannelCountToDeviceCapabilities && SDK_INT >= 32 && spatializer == null) { spatializer = @@ -2681,9 +2687,9 @@ public void onRendererCapabilitiesChanged(Renderer renderer) { new ExoTrackSelection.Definition[rendererCount]; // Apply overrides once so that selectAllTracks is aware of the overridden tracks. - applyTrackSelectionOverrides(mappedTrackInfo, parameters, definitions); - applyLegacyRendererOverrides(mappedTrackInfo, parameters, definitions); - applyRendererDisableOverrides(mappedTrackInfo, parameters, definitions); + applyTrackSelectionOverrides(mappedTrackInfo, playerParameters, definitions); + applyLegacyRendererOverrides(mappedTrackInfo, playerParameters, definitions); + applyRendererDisableOverrides(mappedTrackInfo, playerParameters, definitions); // Select remaining tracks based on parameters. selectAllTracks( @@ -2691,13 +2697,13 @@ public void onRendererCapabilitiesChanged(Renderer renderer) { mappedTrackInfo, rendererFormatSupports, rendererMixedMimeTypeAdaptationSupport, - parameters); + playerParameters); // Re-apply overrides to enforce them in case selectAllTracks changed them or added additional // tracks that shouldn't be enabled according to the overrides. - applyTrackSelectionOverrides(mappedTrackInfo, parameters, definitions); - applyLegacyRendererOverrides(mappedTrackInfo, parameters, definitions); - applyRendererDisableOverrides(mappedTrackInfo, parameters, definitions); + applyTrackSelectionOverrides(mappedTrackInfo, playerParameters, definitions); + applyLegacyRendererOverrides(mappedTrackInfo, playerParameters, definitions); + applyRendererDisableOverrides(mappedTrackInfo, playerParameters, definitions); @NullableType ExoTrackSelection[] rendererTrackSelections = @@ -2711,7 +2717,8 @@ public void onRendererCapabilitiesChanged(Renderer renderer) { for (int i = 0; i < rendererCount; i++) { @C.TrackType int rendererType = mappedTrackInfo.getRendererType(i); boolean forceRendererDisabled = - parameters.getRendererDisabled(i) || parameters.disabledTrackTypes.contains(rendererType); + playerParameters.getRendererDisabled(i) + || playerParameters.disabledTrackTypes.contains(rendererType); boolean rendererEnabled = !forceRendererDisabled && (mappedTrackInfo.getRendererType(i) == C.TRACK_TYPE_NONE @@ -2720,15 +2727,15 @@ public void onRendererCapabilitiesChanged(Renderer renderer) { } // Configure audio and video renderers to use tunneling if appropriate. - if (parameters.tunnelingEnabled) { + if (playerParameters.tunnelingEnabled) { maybeConfigureRenderersForTunneling( mappedTrackInfo, rendererFormatSupports, rendererConfigurations, rendererTrackSelections); } // Configure audio renderer to use offload if appropriate. - if (parameters.audioOffloadPreferences.audioOffloadMode != AUDIO_OFFLOAD_MODE_DISABLED) { + if (playerParameters.audioOffloadPreferences.audioOffloadMode != AUDIO_OFFLOAD_MODE_DISABLED) { maybeConfigureRendererForOffload( - parameters, + playerParameters, mappedTrackInfo, rendererFormatSupports, rendererConfigurations, @@ -3258,25 +3265,18 @@ private > Pair sel } private void maybeInvalidateForAudioChannelCountConstraints() { - boolean shouldInvalidate; - synchronized (lock) { - shouldInvalidate = - parameters.constrainAudioChannelCountToDeviceCapabilities - && SDK_INT >= 32 - && spatializer != null - && spatializer.isSpatializationSupported(); - } + boolean shouldInvalidate = + playerParameters.constrainAudioChannelCountToDeviceCapabilities + && SDK_INT >= 32 + && spatializer != null + && spatializer.isSpatializationSupported(); if (shouldInvalidate) { - invalidate(); + invalidate(/* parameters= */ null); } } private void maybeInvalidateForRendererCapabilitiesChange(Renderer renderer) { - boolean shouldInvalidate; - synchronized (lock) { - shouldInvalidate = parameters.allowInvalidateSelectionsOnRendererCapabilitiesChange; - } - if (shouldInvalidate) { + if (playerParameters.allowInvalidateSelectionsOnRendererCapabilitiesChange) { invalidateForRendererCapabilitiesChange(renderer); } } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/TrackSelector.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/TrackSelector.java index 671fa256dab..db42a091c61 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/TrackSelector.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/TrackSelector.java @@ -61,20 +61,28 @@ * the media during the 30 second gap. The player indicates to the track selector when a * selection it has previously made becomes active by calling {@link * #onSelectionActivated(Object)}. - *

  • If the track selector wishes to indicate to the player that selections it has previously - * made are invalid, it can do so by calling {@link - * InvalidationListener#onTrackSelectionsInvalidated()} on the {@link InvalidationListener} - * that was passed to {@link #init(InvalidationListener, BandwidthMeter)}. A track selector - * may wish to do this if its configuration has changed, for example if it now wishes to - * prefer audio tracks in a particular language. This will trigger the player to make new - * track selections. Note that the player will have to re-buffer in the case that the new - * track selection for the currently playing period differs from the one that was invalidated. - * Implementing subclasses can trigger invalidation by calling {@link #invalidate()}, which - * will call {@link InvalidationListener#onTrackSelectionsInvalidated()}. + *
  • When the track selector's configuration changes (for example, if it now wishes to prefer + * audio tracks in a particular language) or its previous selections become invalid, it can + * trigger invalidation by calling {@link #invalidate(TrackSelectionParameters)}. This invokes + * {@link InvalidationListener#onTrackSelectionsInvalidated(TrackSelectionParameters)} on the + * {@link InvalidationListener} that was passed to {@link #init(InvalidationListener, + * BandwidthMeter)}. When handling this callback, if {@code parameters} is not {@code null}, + * the listener must call {@link #onParametersActivated(TrackSelectionParameters)} to activate + * the updated parameters before triggering the player to make new track selections. Note that + * the player will have to re-buffer if the new track selection for the currently playing + * period differs from the one that was invalidated. *
  • When the player is {@linkplain Player#release() released}, it will release the track * selector by calling {@link #release()}. * * + *

    Track selection parameters

    + * + *

    Track selection parameters can be retrieved and modified on the application thread by calling + * {@link #getParameters()} and {@link #setParameters(TrackSelectionParameters)} respectively (if + * supported, as indicated by {@link #isSetParametersSupported()}). Modifying parameters on the + * application thread triggers the invalidation flow described above, ensuring that the updated + * parameters are activated and applied on the playback thread. + * *

    Renderer configuration

    * * The {@link TrackSelectorResult} returned by {@link #selectTracks(RendererCapabilities[], @@ -119,9 +127,16 @@ public interface InvalidationListener { /** * Called by a {@link TrackSelector} to indicate that selections it has previously made are no - * longer valid. May be called from any thread. + * longer valid, or that track selection parameters have changed. + * + *

    If {@code parameters} is not {@code null}, the receiver must call {@link + * TrackSelector#onParametersActivated(TrackSelectionParameters)} to activate the new + * parameters. + * + * @param parameters The new track selection parameters, or {@code null} if selections need to + * be re-evaluated without applying new parameters. */ - void onTrackSelectionsInvalidated(); + void onTrackSelectionsInvalidated(@Nullable TrackSelectionParameters parameters); /** * Called by a {@link TrackSelector} to indicate that selections it has previously made may no @@ -187,6 +202,18 @@ public abstract TrackSelectorResult selectTracks( */ public abstract void onSelectionActivated(@Nullable Object info); + /** + * Called by the player when track selection parameters become active for subsequent track + * selections made by {@link #selectTracks(RendererCapabilities[], TrackGroupArray, MediaPeriodId, + * Timeline)}. + * + * @param parameters The activated track selection parameters, or {@code null} if no new + * parameters need to be activated. + */ + public void onParametersActivated(@Nullable TrackSelectionParameters parameters) { + // Default implementation is no-op. + } + /** * Returns the current parameters for track selection. * @@ -237,14 +264,17 @@ public RendererCapabilities.Listener getRendererCapabilitiesListener() { } /** - * Calls {@link InvalidationListener#onTrackSelectionsInvalidated()} to invalidate all previously - * generated track selections. + * Calls {@link InvalidationListener#onTrackSelectionsInvalidated(TrackSelectionParameters)} to + * invalidate all previously generated track selections. * *

    This method can be called from both the application and the playback thread. + * + * @param parameters The track selection parameters, or {@code null} to re-evaluate selections + * without applying new parameters. */ - protected final void invalidate() { + protected final void invalidate(@Nullable TrackSelectionParameters parameters) { if (listener != null) { - listener.onTrackSelectionsInvalidated(); + listener.onTrackSelectionsInvalidated(parameters); } } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/upstream/ParsingLoadable.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/upstream/ParsingLoadable.java index d027f57a304..fece377fae6 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/upstream/ParsingLoadable.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/upstream/ParsingLoadable.java @@ -29,6 +29,7 @@ import androidx.media3.datasource.StatsDataSource; import androidx.media3.exoplayer.source.LoadEventInfo; import androidx.media3.exoplayer.upstream.Loader.Loadable; +import com.google.errorprone.annotations.CanIgnoreReturnValue; import java.io.IOException; import java.io.InputStream; import java.util.List; @@ -57,39 +58,66 @@ public interface Parser { T parse(Uri uri, InputStream inputStream) throws IOException; } - /** - * Loads a single parsable object. - * - * @param dataSource The {@link DataSource} through which the object should be read. - * @param parser The {@link Parser} to parse the object from the response. - * @param uri The {@link Uri} of the object to read. - * @param type The type of the data. One of the {@link C}{@code DATA_TYPE_*} constants. - * @return The parsed object - * @throws IOException Thrown if there is an error while loading or parsing. - */ - public static T load(DataSource dataSource, Parser parser, Uri uri, int type) - throws IOException { - ParsingLoadable loadable = new ParsingLoadable<>(dataSource, uri, type, parser); - loadable.load(); - return checkNotNull(loadable.getResult()); - } + /** Builder for {@link ParsingLoadable}. */ + public static final class Builder { + private final DataSource dataSource; + private final DataSpec dataSpec; + private final @C.DataType int type; + private final Parser parser; + @Nullable private String steeredPathwayId; - /** - * Loads a single parsable object. - * - * @param dataSource The {@link DataSource} through which the object should be read. - * @param parser The {@link Parser} to parse the object from the response. - * @param dataSpec The {@link DataSpec} of the object to read. - * @param type The type of the data. One of the {@link C}{@code DATA_TYPE_*} constants. - * @return The parsed object - * @throws IOException Thrown if there is an error while loading or parsing. - */ - public static T load( - DataSource dataSource, Parser parser, DataSpec dataSpec, int type) - throws IOException { - ParsingLoadable loadable = new ParsingLoadable<>(dataSource, dataSpec, type, parser); - loadable.load(); - return checkNotNull(loadable.getResult()); + /** + * Creates a builder. + * + * @param dataSource A {@link DataSource} to use when loading the data. + * @param uri The {@link Uri} from which the object should be loaded. + * @param type The {@linkplain C.DataType type} of the data. + * @param parser Parses the object from the response. + */ + public Builder( + DataSource dataSource, Uri uri, @C.DataType int type, Parser parser) { + this( + dataSource, + new DataSpec.Builder().setUri(uri).setFlags(DataSpec.FLAG_ALLOW_GZIP).build(), + type, + parser); + } + + /** + * Creates a builder. + * + * @param dataSource A {@link DataSource} to use when loading the data. + * @param dataSpec The {@link DataSpec} from which the object should be loaded. + * @param type The {@linkplain C.DataType type} of the data. + * @param parser Parses the object from the response. + */ + public Builder( + DataSource dataSource, + DataSpec dataSpec, + @C.DataType int type, + Parser parser) { + this.dataSource = dataSource; + this.dataSpec = dataSpec; + this.type = type; + this.parser = parser; + } + + /** + * Sets the {@link ParsingLoadable#steeredPathwayId}, the default is {@code null}. + * + * @param steeredPathwayId See {@link ParsingLoadable#steeredPathwayId}. + * @return This builder. + */ + @CanIgnoreReturnValue + public Builder setSteeredPathwayId(@Nullable String steeredPathwayId) { + this.steeredPathwayId = steeredPathwayId; + return this; + } + + /** Builds the {@link ParsingLoadable}. */ + public ParsingLoadable build() { + return new ParsingLoadable<>(this); + } } /** Identifies the load task for this loadable. */ @@ -98,11 +126,14 @@ public static T load( /** The {@link DataSpec} that defines the data to be loaded. */ public final DataSpec dataSpec; + /** The {@linkplain C.DataType type} of the data. For reporting only. */ + public final @C.DataType int type; + /** - * The type of the data. One of the {@code DATA_TYPE_*} constants defined in {@link C}. For - * reporting only. + * The ID of the steered pathway from which data is being loaded, or {@code null} if not + * applicable. */ - public final int type; + @Nullable public final String steeredPathwayId; private final StatsDataSource dataSource; private final Parser parser; @@ -110,12 +141,11 @@ public static T load( @Nullable private volatile T result; /** - * @param dataSource A {@link DataSource} to use when loading the data. - * @param uri The {@link Uri} from which the object should be loaded. - * @param type See {@link #type}. - * @param parser Parses the object from the response. + * @deprecated Use {@link Builder} instead. */ - public ParsingLoadable(DataSource dataSource, Uri uri, int type, Parser parser) { + @Deprecated + public ParsingLoadable( + DataSource dataSource, Uri uri, @C.DataType int type, Parser parser) { this( dataSource, new DataSpec.Builder().setUri(uri).setFlags(DataSpec.FLAG_ALLOW_GZIP).build(), @@ -124,20 +154,85 @@ public ParsingLoadable(DataSource dataSource, Uri uri, int type, Parser parser) { + DataSource dataSource, DataSpec dataSpec, @C.DataType int type, Parser parser) { this.dataSource = new StatsDataSource(dataSource); this.dataSpec = dataSpec; this.type = type; this.parser = parser; + this.steeredPathwayId = null; loadTaskId = LoadEventInfo.getNewId(); } + private ParsingLoadable(Builder builder) { + this.dataSource = new StatsDataSource(builder.dataSource); + this.dataSpec = builder.dataSpec; + this.type = builder.type; + this.parser = builder.parser; + this.steeredPathwayId = builder.steeredPathwayId; + loadTaskId = LoadEventInfo.getNewId(); + } + + /** + * Loads a single parsable object. + * + * @param dataSource The {@link DataSource} through which the object should be read. + * @param parser The {@link Parser} to parse the object from the response. + * @param uri The {@link Uri} of the object to read. + * @param type The {@linkplain C.DataType type} of the data. + * @return The parsed object + * @throws IOException Thrown if there is an error while loading or parsing. + */ + public static T load( + DataSource dataSource, Parser parser, Uri uri, @C.DataType int type) + throws IOException { + ParsingLoadable loadable = + new ParsingLoadable.Builder(dataSource, uri, type, parser).build(); + loadable.load(); + return checkNotNull(loadable.getResult()); + } + + /** + * Loads a single parsable object. + * + * @param dataSource The {@link DataSource} through which the object should be read. + * @param parser The {@link Parser} to parse the object from the response. + * @param dataSpec The {@link DataSpec} of the object to read. + * @param type The {@linkplain C.DataType type} of the data. + * @return The parsed object + * @throws IOException Thrown if there is an error while loading or parsing. + */ + public static T load( + DataSource dataSource, Parser parser, DataSpec dataSpec, @C.DataType int type) + throws IOException { + ParsingLoadable loadable = + new ParsingLoadable.Builder(dataSource, dataSpec, type, parser).build(); + loadable.load(); + return checkNotNull(loadable.getResult()); + } + + @Override + public final void load() throws IOException { + // We always load from the beginning, so reset bytesRead to 0. + dataSource.resetBytesRead(); + DataSourceInputStream inputStream = new DataSourceInputStream(dataSource, dataSpec); + try { + inputStream.open(); + Uri dataSourceUri = checkNotNull(dataSource.getUri()); + result = parser.parse(dataSourceUri, inputStream); + } finally { + Util.closeQuietly(inputStream); + } + } + + @Override + public final void cancelLoad() { + // Do nothing. + } + /** Returns the loaded object, or null if an object has not been loaded. */ @Nullable public final T getResult() { @@ -168,23 +263,4 @@ public Uri getUri() { public Map> getResponseHeaders() { return dataSource.getLastResponseHeaders(); } - - @Override - public final void cancelLoad() { - // Do nothing. - } - - @Override - public final void load() throws IOException { - // We always load from the beginning, so reset bytesRead to 0. - dataSource.resetBytesRead(); - DataSourceInputStream inputStream = new DataSourceInputStream(dataSource, dataSpec); - try { - inputStream.open(); - Uri dataSourceUri = checkNotNull(dataSource.getUri()); - result = parser.parse(dataSourceUri, inputStream); - } finally { - Util.closeQuietly(inputStream); - } - } } diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/upstream/contentsteering/SteeringManifestTracker.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/upstream/contentsteering/SteeringManifestTracker.java index 00fa6d06861..029cf3d61be 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/upstream/contentsteering/SteeringManifestTracker.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/upstream/contentsteering/SteeringManifestTracker.java @@ -208,14 +208,12 @@ private static Uri getSteeringManifestUrl( private static LoadEventInfo buildLoadEventInfo( ParsingLoadable loadable, long elapsedRealtimeMs, long loadDurationMs) { - return new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + return new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); } private class SteeringManifestLoaderCallback diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/HevcSeiUtil.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/HevcSeiUtil.java new file mode 100644 index 00000000000..4d7ebccb4f0 --- /dev/null +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/HevcSeiUtil.java @@ -0,0 +1,162 @@ +/* + * Copyright 2026 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 androidx.media3.exoplayer.video; + +import androidx.media3.common.util.UnstableApi; +import androidx.media3.container.NalUnitUtil; +import java.nio.ByteBuffer; + +/** Utility methods for handling HEVC SEI messages. */ +@UnstableApi +public final class HevcSeiUtil { + + private static final int SEI_PAYLOAD_TYPE_ITU_T_T35 = 4; + /* package */ static final int SEI_PAYLOAD_TYPE_UNSPECIFIED = 254; + + private HevcSeiUtil() {} + + /** + * Modifies the provided {@link ByteBuffer} in place to strip all ITU-T T.35 SEI messages. + * + *

    This is achieved by masking the payload type of any T.35 SEI message to an unspecified + * payload type ({@link #SEI_PAYLOAD_TYPE_UNSPECIFIED}). The NAL unit lengths and message lengths + * the operation can be done in-place with zero memory allocations, avoiding the need to fully + * parse emulation prevention bytes or copy the buffer. + * + * @param buffer The {@link ByteBuffer} containing the HEVC bitstream with Annex B start codes. + */ + public static void stripAllT35Metadata(ByteBuffer buffer) { + int position = buffer.position(); + int limit = buffer.limit(); + if (limit - position < 4) { + return; + } + + int searchOffset = position; + + while (searchOffset < limit) { + int nalUnitOffset = findNalUnit(buffer, searchOffset, limit); + if (nalUnitOffset == limit) { + break; // No more NAL units + } + + if (nalUnitOffset + 3 >= limit) { + break; // Not enough bytes for a NAL header. + } + + int nalUnitType = (buffer.get(nalUnitOffset + 3) & 0x7E) >> 1; + + // NAL unit types 0 to 31 indicate VCL NAL units. + // Prefix SEI messages always precede VCL NAL units, so we can safely stop parsing + // once we hit a VCL NAL unit to avoid scanning the encoded video data. + if (nalUnitType >= 0 && nalUnitType <= 31) { + break; + } + + if (nalUnitType == NalUnitUtil.H265_NAL_UNIT_TYPE_PREFIX_SEI) { + int seiOffset = nalUnitOffset + 3 + 2; // Skip 3-byte start code and 2-byte NAL header + + int nextNalUnitOffset = findNalUnit(buffer, seiOffset, limit); + int seiLimit = nextNalUnitOffset; // The SEI payload ends where the next NAL unit starts + + int consecutiveZeros = 0; // State tracked across the entire SEI NAL unit + + while (seiOffset < seiLimit) { + // Read payloadType + int payloadType = 0; + while (seiOffset < seiLimit) { + int b = buffer.get(seiOffset) & 0xFF; + if (b == 0x03 && consecutiveZeros >= 2) { + consecutiveZeros = 0; + seiOffset++; + continue; + } + consecutiveZeros = (b == 0x00) ? consecutiveZeros + 1 : 0; + + int currentOffset = seiOffset; + seiOffset++; + payloadType += b; + if (b != 0xFF) { + if (payloadType == SEI_PAYLOAD_TYPE_ITU_T_T35) { + buffer.put(currentOffset, (byte) SEI_PAYLOAD_TYPE_UNSPECIFIED); + } + break; + } + } + + if (seiOffset >= seiLimit) { + break; + } + + // Read payloadSize + int payloadSize = 0; + while (seiOffset < seiLimit) { + int b = buffer.get(seiOffset) & 0xFF; + if (b == 0x03 && consecutiveZeros >= 2) { + consecutiveZeros = 0; + seiOffset++; + continue; + } + consecutiveZeros = (b == 0x00) ? consecutiveZeros + 1 : 0; + + seiOffset++; + payloadSize += b; + if (b != 0xFF) { + break; + } + } + + // Skip the logical payloadSize bytes, taking into account physical emulation + // prevention bytes (0x03) that might be in the payload. + for (int i = 0; i < payloadSize; i++) { + if (seiOffset >= seiLimit) { + break; + } + int b = buffer.get(seiOffset++) & 0xFF; + if (b == 0x03 && consecutiveZeros >= 2) { + // Emulation prevention byte. Doesn't count towards logical payloadSize. + consecutiveZeros = 0; + i--; + } else { + consecutiveZeros = (b == 0x00) ? consecutiveZeros + 1 : 0; + } + } + } + searchOffset = nextNalUnitOffset; + } else { + searchOffset = nalUnitOffset + 3; + } + } + } + + /** + * Finds the first NAL unit start code (0x00 00 01) in the buffer and returns the offset of the + * first zero byte of the start code. Returns {@code limit} if no start code is found. + */ + private static int findNalUnit(ByteBuffer buffer, int offset, int limit) { + int consecutiveZeros = 0; + int currentOffset = offset; + while (currentOffset < limit) { + int b = buffer.get(currentOffset) & 0xFF; + if (consecutiveZeros >= 2 && b == 0x01) { + return currentOffset - 2; + } + consecutiveZeros = (b == 0x00) ? consecutiveZeros + 1 : 0; + currentOffset++; + } + return limit; + } +} diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/MediaCodecVideoRenderer.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/MediaCodecVideoRenderer.java index bac9447aad9..167bc1d0607 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/MediaCodecVideoRenderer.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/MediaCodecVideoRenderer.java @@ -1773,17 +1773,20 @@ protected DecoderReuseEvaluation onInputFormatChanged(FormatHolder formatHolder) @CallSuper @Override protected void onQueueInputBuffer(DecoderInputBuffer buffer) throws ExoPlaybackException { - if (checkNotNull(getCodecInfo()).mimeType.equals(MimeTypes.VIDEO_AV1) && buffer.data != null) { + String mimeType = checkNotNull(getCodecInfo()).mimeType; + if (mimeType.equals(MimeTypes.VIDEO_AV1) && buffer.data != null) { ByteBuffer bufferData = buffer.data; Format codecInputFormat = getCodecInputFormat(); boolean isAv1HighBitdepth = codecInputFormat != null && codecInputFormat.colorInfo != null && codecInputFormat.colorInfo.lumaBitdepth > 8; - if (isApplyingContainerHagcMetadata) { + if (isApplyingContainerHagcMetadata && !bufferData.isReadOnly()) { // Strip all T.35 metadata to prevent in-band metadata from overriding container HAGC. Av1ObuUtil.stripAllT35Metadata(bufferData); - } else if (isAv1HighBitdepth && codecNeedsStripNonHdr10PlusT35Workaround) { + } else if (isAv1HighBitdepth + && codecNeedsStripNonHdr10PlusT35Workaround + && !bufferData.isReadOnly()) { // For AV1 streams with bitdepth > 8, try to rewrite OBUs to skip non-HDR10+ metadata on // SDKs prior to 37. Av1ObuUtil.stripNonHdr10PlusT35Metadata(bufferData); @@ -1791,6 +1794,11 @@ protected void onQueueInputBuffer(DecoderInputBuffer buffer) throws ExoPlaybackE if (av1SampleDependencyParser != null && buffer.isKeyFrame()) { av1SampleDependencyParser.queueInputBuffer(bufferData); } + } else if (mimeType.equals(MimeTypes.VIDEO_H265) && buffer.data != null) { + if (isApplyingContainerHagcMetadata && !buffer.data.isReadOnly()) { + // Strip all T.35 metadata to prevent in-band metadata from overriding container HAGC. + HevcSeiUtil.stripAllT35Metadata(buffer.data); + } } consecutiveDroppedInputBufferCount = 0; // In tunneling mode the device may do frame rate conversion, so in general we can't keep track @@ -2012,10 +2020,7 @@ protected void handleInputBufferSupplementalData(DecoderInputBuffer buffer) data.position(0); setHdr10PlusInfoV29(checkNotNull(getCodec()), hdr10PlusInfo); } - } else if (SDK_INT >= 37 - && ituTT35CountryCode == (byte) 0xB5 - && ituTT35TerminalProviderCode == 0x0090 - && ituTT35TerminalProviderOrientedCode == 0x0001) { + } else if (SDK_INT >= 37 && CodecSpecificDataUtil.isHagcMetadata(data)) { // HAGC (ST 2094-50) metadata from out-of-band track. // Android's MediaCodec API for ST 2094-50 expects the payload without the 5-byte T.35 // header. diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/VideoFrameReleaseHelper.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/VideoFrameReleaseHelper.java index 767b5cc06f7..40fab560239 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/VideoFrameReleaseHelper.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/video/VideoFrameReleaseHelper.java @@ -69,7 +69,7 @@ public final class VideoFrameReleaseHelper { private final Context context; - private boolean vsyncSampleBuilt; + private boolean vsyncSamplerBuilt; @Nullable private VSyncSampler vsyncSampler; private boolean started; @Nullable private Surface surface; @@ -133,12 +133,12 @@ public void setChangeFrameRateStrategy( public void onStarted() { started = true; resetAdjustment(); - if (!vsyncSampleBuilt) { + if (!vsyncSamplerBuilt) { vsyncSampler = VSyncSampler.maybeBuildInstance(context); if (vsyncSampler != null) { vsyncSampler.listener = vsyncSamplerListener; } - vsyncSampleBuilt = true; + vsyncSamplerBuilt = true; } if (vsyncSampler != null) { vsyncSampler.register(); diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerAdPlaybackEnforcementTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerAdPlaybackEnforcementTest.java index 956b8105d00..123ff274ad7 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerAdPlaybackEnforcementTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerAdPlaybackEnforcementTest.java @@ -237,7 +237,9 @@ public void onTimelineChanged(Timeline timeline, int reason) { advance(player).untilTimelineChanges(); AdPlaybackState updatedAdPlaybackState = emptyAdPlaybackState - .withNewAdGroup(/* adGroupIndex= */ 0, /* adGroupTimeUs= */ 0) + .withNewAdGroup( + /* adGroupIndex= */ 0, + /* adGroupTimeUs= */ DEFAULT_WINDOW_OFFSET_IN_FIRST_PERIOD_US) .withAdCount(/* adGroupIndex= */ 0, /* adCount= */ 1) .withAvailableAdMediaItem( /* adGroupIndex= */ 0, @@ -379,7 +381,7 @@ public void adInsertedAtCurrentPosition_notEnforcedWithPreRoll_preRollPlaying() TestExoPlayerBuilder playerBuilder = new TestExoPlayerBuilder(ApplicationProvider.getApplicationContext()); ExoPlayer player = playerBuilder.setEnforceAdPlaybackOnTimelineRefresh(false).build(); - long firstSampleTimeUs = 0; + long firstSampleTimeUs = DEFAULT_WINDOW_OFFSET_IN_FIRST_PERIOD_US; AdPlaybackState initialAdPlaybackState = new AdPlaybackState("adsId", firstSampleTimeUs) .withAvailableAdMediaItem( @@ -463,7 +465,7 @@ public void onPlaybackStateChanged(int playbackState) { TestExoPlayerBuilder playerBuilder = new TestExoPlayerBuilder(ApplicationProvider.getApplicationContext()); ExoPlayer player = playerBuilder.setEnforceAdPlaybackOnTimelineRefresh(false).build(); - long firstSampleTimeUs = 0; + long firstSampleTimeUs = DEFAULT_WINDOW_OFFSET_IN_FIRST_PERIOD_US; AdPlaybackState initialAdPlaybackState = new AdPlaybackState("adsId", firstSampleTimeUs + 1_000_000L) .withAvailableAdMediaItem( @@ -634,7 +636,7 @@ public void adInsertedAtCurrentPosition_notEnforcedNonPlaceholderSameUid_keepsAd TestExoPlayerBuilder playerBuilder = new TestExoPlayerBuilder(ApplicationProvider.getApplicationContext()); ExoPlayer player = playerBuilder.setEnforceAdPlaybackOnTimelineRefresh(false).build(); - long firstSampleTimeUs = 0; + long firstSampleTimeUs = DEFAULT_WINDOW_OFFSET_IN_FIRST_PERIOD_US; AdPlaybackState initialAdPlaybackState = new AdPlaybackState("adsId", firstSampleTimeUs) .withAvailableAdMediaItem( diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerAdTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerAdTest.java index 1ec5d3fc57a..12034be264c 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerAdTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerAdTest.java @@ -346,7 +346,7 @@ public void playAds_midRollsWithAndWithoutDuration_clippedOrNotClippedAccordingl Timeline primaryContentTimeline = new FakeTimeline(new TimelineWindowDefinition.Builder().setDurationUs(60_000_000L).build()); AdPlaybackState adPlaybackState = - new AdPlaybackState("adsId", 10_000_000L, 20_000_000L) + new AdPlaybackState("adsId", 133_000_000L, 143_000_000L) .withAdCount(/* adGroupIndex= */ 0, /* adCount= */ 1) .withAvailableAdMediaItem( /* adGroupIndex= */ 0, @@ -1057,6 +1057,66 @@ public void adInMovingLiveWindow_keepsContentPosition() throws Exception { assertThat(contentPositionAfterLiveWindowUpdateMs).isEqualTo(2000); } + @Test + public void timelineRefresh_movingLiveDefaultPositionPastPlayingSsaiAd_keepsPlayingAd() + throws Exception { + // Live window with three 20s periods: |- p0 content -|- p1 ad -|- p2 content -|. + Object adsId = new Object(); + TimelineWindowDefinition liveWindowDefinition = + new TimelineWindowDefinition.Builder() + .setDynamic(true) + .setLive(true) + .setSeekable(true) + .setPeriodCount(3) + .setDurationUs(60_000_000) + .setWindowStartTimeUs(1_720_000_000_000_000L) + .setWindowPositionInFirstPeriodUs(0) + .setDefaultPositionUs(30_000_000) + .build(); + Timeline initialContentTimeline = new FakeTimeline(liveWindowDefinition); + // p1 is entirely covered by a server-side inserted ad. + AdPlaybackState contentOnlyAdPlaybackState = new AdPlaybackState(adsId); + AdPlaybackState adPeriodAdPlaybackState = + addAdGroupToAdPlaybackState( + contentOnlyAdPlaybackState, + /* fromPositionUs= */ 0, + /* contentResumeOffsetUs= */ 20_000_000, + /* adDurationsUs...= */ 20_000_000); + // ServerSideAdInsertionMediaSource requires an AdPlaybackState for every period. + ImmutableMap adPlaybackStates = + ImmutableMap.of( + initialContentTimeline.getUidOfPeriod(/* periodIndex= */ 0), + contentOnlyAdPlaybackState, + initialContentTimeline.getUidOfPeriod(/* periodIndex= */ 1), + adPeriodAdPlaybackState, + initialContentTimeline.getUidOfPeriod(/* periodIndex= */ 2), + contentOnlyAdPlaybackState); + FakeMediaSource contentMediaSource = new FakeMediaSource(initialContentTimeline); + ServerSideAdInsertionMediaSource mediaSource = + new ServerSideAdInsertionMediaSource( + contentMediaSource, /* adPlaybackStateUpdater= */ contentTimeline -> false); + mediaSource.setAdPlaybackStates(adPlaybackStates, initialContentTimeline); + ExoPlayer player = parameterizeTestExoPlayerBuilder(new TestExoPlayerBuilder(context)).build(); + + // Join the live stream while the ad in p1 is on air. + player.setMediaSource(mediaSource); + player.prepare(); + advance(player).untilState(Player.STATE_READY); + boolean isPlayingAdAfterJoining = player.isPlayingAd(); + // Refresh the live timeline with a default position that moved past the ad, into p2. + contentMediaSource.setNewSourceInfo( + new FakeTimeline( + liveWindowDefinition.buildUpon().setDefaultPositionUs(45_000_000).build())); + advance(player).untilPendingCommandsAreFullyHandled(); + boolean isPlayingAdAfterRefresh = player.isPlayingAd(); + @Nullable PlaybackException error = player.getPlayerError(); + player.release(); + + assertThat(isPlayingAdAfterJoining).isTrue(); + assertThat(error).isNull(); + assertThat(isPlayingAdAfterRefresh).isTrue(); + } + @Test public void addMediaSource_whilePlayingAd_correctMasking() throws Exception { long contentDurationMs = 10_000; @@ -2361,103 +2421,4 @@ public void newServerSideInsertedAdAtPlaybackPosition_keepsRenderersEnabled() th assertThat(timeline.getPeriod(0, new Timeline.Period()).adPlaybackState.adGroupCount) .isEqualTo(2); } - - @Test - public void playAds_midRollsInMultiPeriodContent_playedSuccessfully() - throws PlaybackException, TimeoutException { - Timeline primaryContentTimeline = - new FakeTimeline( - new TimelineWindowDefinition.Builder() - .setPeriodCount(2) - .setDurationUs(60_000_000L) - .setWindowPositionInFirstPeriodUs(0) - .build()); - AdPlaybackState adPlaybackState = - new AdPlaybackState("adsId", 10_000_000L, 40_000_000L) - .withAdCount(/* adGroupIndex= */ 0, /* adCount= */ 1) - .withAvailableAdMediaItem( - /* adGroupIndex= */ 0, - /* adIndexInAdGroup= */ 0, - MediaItem.fromUri("http://example.com/ad_0_0")) - .withAdCount(/* adGroupIndex= */ 1, /* adCount= */ 1) - .withAvailableAdMediaItem( - /* adGroupIndex= */ 1, - /* adIndexInAdGroup= */ 0, - MediaItem.fromUri("http://example.com/ad_1_0")); - FakeAdsLoader fakeAdsLoader = new FakeAdsLoader(); - AdsMediaSource adsMediaSource = - new AdsMediaSource( - new FakeMediaSource(primaryContentTimeline, ExoPlayerTestRunner.VIDEO_FORMAT), - new DataSpec(Uri.EMPTY), - "adsId", - /* adMediaSourceFactory= */ new FakeMediaSourceFactory( - new TimelineWindowDefinition.Builder() - .setDurationUs(10_000_000L) - .setWindowPositionInFirstPeriodUs(0)), - fakeAdsLoader, - /* adViewProvider= */ () -> null, - /* useLazyContentSourcePreparation= */ true, - /* useAdMediaSourceClipping= */ true); - ExoPlayer player = parameterizeTestExoPlayerBuilder(new TestExoPlayerBuilder(context)).build(); - Player.Listener mockListener = mock(Player.Listener.class); - player.addListener(mockListener); - player.setMediaSource(adsMediaSource); - player.prepare(); - advance(player) - .untilBackgroundThreadCondition( - (Supplier) () -> fakeAdsLoader.eventListeners.get("adsId") != null); - fakeAdsLoader.eventListeners.get("adsId").onAdPlaybackState(adPlaybackState); - - player.play(); - // Play past midroll 0 (at 10s) but before midroll 1 (at 40s) and period transition (at 30s) - advance(player).untilPositionAtLeast(/* mediaItemIndex= */ 0, /* positionMs= */ 15_000L); - // Mark midroll 0 as played. - adPlaybackState = - adPlaybackState.withPlayedAd(/* adGroupIndex= */ 0, /* adIndexInAdGroup= */ 0); - fakeAdsLoader.eventListeners.get("adsId").onAdPlaybackState(adPlaybackState); - - advance(player).untilState(Player.STATE_ENDED); - player.release(); - - ArgumentCaptor oldPositionsCaptor = ArgumentCaptor.forClass(PositionInfo.class); - ArgumentCaptor newPositionsCaptor = ArgumentCaptor.forClass(PositionInfo.class); - ArgumentCaptor reasonsCaptor = ArgumentCaptor.forClass(Integer.class); - verify(mockListener, times(5)) - .onPositionDiscontinuity( - oldPositionsCaptor.capture(), newPositionsCaptor.capture(), reasonsCaptor.capture()); - assertThat(reasonsCaptor.getAllValues()) - .containsExactly( - DISCONTINUITY_REASON_AUTO_TRANSITION, // content to midroll 0 - DISCONTINUITY_REASON_AUTO_TRANSITION, // midroll 0 to content - DISCONTINUITY_REASON_AUTO_TRANSITION, // period transition - DISCONTINUITY_REASON_AUTO_TRANSITION, // content to midroll 1 - DISCONTINUITY_REASON_AUTO_TRANSITION); // midroll 1 to content - - List oldPositions = oldPositionsCaptor.getAllValues(); - List newPositions = newPositionsCaptor.getAllValues(); - - // midroll 0 to content - assertThat(oldPositions.get(1).adGroupIndex).isEqualTo(0); - assertThat(oldPositions.get(1).positionMs).isEqualTo(10_000L); // ad duration - assertThat(oldPositions.get(1).contentPositionMs).isEqualTo(10_000L); - assertThat(newPositions.get(1).adGroupIndex).isEqualTo(C.INDEX_UNSET); - assertThat(newPositions.get(1).positionMs).isEqualTo(10_000L); - assertThat(newPositions.get(1).contentPositionMs).isEqualTo(10_000L); - - // period transition - assertThat(oldPositions.get(2).periodIndex).isEqualTo(0); - assertThat(oldPositions.get(2).adGroupIndex).isEqualTo(C.INDEX_UNSET); - assertThat(oldPositions.get(2).positionMs).isEqualTo(30_000L); - assertThat(newPositions.get(2).periodIndex).isEqualTo(1); - assertThat(newPositions.get(2).adGroupIndex).isEqualTo(C.INDEX_UNSET); - assertThat(newPositions.get(2).positionMs).isEqualTo(30_000L); - - // midroll 1 to content - assertThat(oldPositions.get(4).adGroupIndex).isEqualTo(1); - assertThat(oldPositions.get(4).positionMs).isEqualTo(10_000L); // ad duration - assertThat(oldPositions.get(4).contentPositionMs).isEqualTo(40_000L); - assertThat(newPositions.get(4).adGroupIndex).isEqualTo(C.INDEX_UNSET); - assertThat(newPositions.get(4).positionMs).isEqualTo(40_000L); - assertThat(newPositions.get(4).contentPositionMs).isEqualTo(40_000L); - } } diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerScrubbingTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerScrubbingTest.java index 2b2962e121c..93314628568 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerScrubbingTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerScrubbingTest.java @@ -67,6 +67,7 @@ import androidx.media3.exoplayer.mediacodec.ForwardingMediaCodecAdapter; import androidx.media3.exoplayer.mediacodec.MediaCodecAdapter; import androidx.media3.exoplayer.mediacodec.MediaCodecSelector; +import androidx.media3.exoplayer.source.MergingMediaSource; import androidx.media3.exoplayer.video.MediaCodecVideoRenderer; import androidx.media3.exoplayer.video.VideoFrameMetadataListener; import androidx.media3.exoplayer.video.VideoRendererEventListener; @@ -1157,6 +1158,74 @@ public void onRenderedFirstFrame() { .of(58); } + @Test + public void + scrubbingMode_seekIntoAudioOnlyPortionOfMergingMediaSource_doesNotHangSubsequentSeeks() + throws Exception { + ExoPlayer player = + new TestExoPlayerBuilder(ApplicationProvider.getApplicationContext()) + .setStuckPlayingDetectionTimeoutMs(Integer.MAX_VALUE) + .setStuckSuppressedDetectionTimeoutMs(Integer.MAX_VALUE) + .build(); + Surface surface = new Surface(new SurfaceTexture(/* texName= */ 1)); + player.setVideoSurface(surface); + // Create a source where the video track ends early to provide an 'audio-only' portion. + FakeMediaSource audioSource = + createFakeMediaSource(ExoPlayerTestRunner.AUDIO_FORMAT, /* durationUs= */ 1_000_000L); + FakeMediaSource videoSource1 = + createFakeMediaSource(ExoPlayerTestRunner.VIDEO_FORMAT, /* durationUs= */ 1_000_000L); + FakeMediaSource videoSource2 = + createFakeMediaSource(ExoPlayerTestRunner.VIDEO_FORMAT, /* durationUs= */ 500_000L); + MergingMediaSource mergingSource1 = + new MergingMediaSource( + /* adjustPeriodTimeOffsets= */ false, + /* clipDurations= */ false, + videoSource1, + audioSource); + MergingMediaSource mergingSource2 = + new MergingMediaSource( + /* adjustPeriodTimeOffsets= */ false, + /* clipDurations= */ false, + videoSource2, + audioSource); + player.setMediaSources(ImmutableList.of(mergingSource1, mergingSource2)); + player.prepare(); + advance(player).untilState(Player.STATE_READY); + List renderedFrames = new ArrayList<>(); + player.setVideoFrameMetadataListener( + (presentationTimeUs, releaseTimeNs, format, mediaFormat) -> + renderedFrames.add(presentationTimeUs)); + + player.setScrubbingModeEnabled(true); + advance(player).untilPendingCommandsAreFullyHandled(); + player.seekTo(/* mediaItemIndex= */ 1, /* positionMs= */ 800); + advance(player).untilPendingCommandsAreFullyHandled(); + player.seekTo(/* mediaItemIndex= */ 0, /* positionMs= */ 500); + advance(player).untilPendingCommandsAreFullyHandled(); + advance(player).untilBackgroundThreadCondition(() -> renderedFrames.contains(500_000L)); + + player.release(); + surface.release(); + } + + private static FakeMediaSource createFakeMediaSource(Format format, long durationUs) { + return new FakeMediaSource.Builder() + .setTimeline( + new FakeTimeline( + new TimelineWindowDefinition.Builder() + .setWindowPositionInFirstPeriodUs(0) + .setDurationUs(durationUs) + .build())) + .setFormats(format) + .setTrackDataFactory( + TrackDataFactory.samplesWithRateDurationAndKeyframeInterval( + /* initialSampleTimeUs= */ 0, + /* sampleRate= */ 30, + /* durationUs= */ durationUs, + /* keyFrameInterval= */ 1)) + .build(); + } + private static FakeMediaSource create30Fps2sGop10sDurationVideoSource() { return new FakeMediaSource.Builder() .setTimeline( diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerTest.java index ff90dff2a99..648932b7e8f 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerTest.java @@ -50,6 +50,7 @@ import static androidx.media3.common.Player.COMMAND_SET_VIDEO_SURFACE; import static androidx.media3.common.Player.COMMAND_SET_VOLUME; import static androidx.media3.common.Player.COMMAND_STOP; +import static androidx.media3.common.Player.DISCONTINUITY_REASON_SEEK; import static androidx.media3.common.Player.DISCONTINUITY_REASON_SEEK_ADJUSTMENT; import static androidx.media3.test.utils.FakeSampleStream.FakeSampleStreamItem.END_OF_STREAM_ITEM; import static androidx.media3.test.utils.FakeSampleStream.FakeSampleStreamItem.oneByteSample; @@ -162,7 +163,6 @@ import androidx.media3.exoplayer.source.SinglePeriodTimeline; import androidx.media3.exoplayer.source.TrackGroupArray; import androidx.media3.exoplayer.source.WrappingMediaSource; -import androidx.media3.exoplayer.source.ads.AdTimeline; import androidx.media3.exoplayer.text.TextOutput; import androidx.media3.exoplayer.trackselection.DefaultTrackSelector; import androidx.media3.exoplayer.trackselection.ExoTrackSelection; @@ -1577,6 +1577,52 @@ public void allActivatedTrackSelectionAreReleasedForSinglePeriod() throws Except assertThat(numSelectionsEnabled).isEqualTo(2); } + @Test + public void setTrackSelectionParameters_rapidUpdate_notifiesSequentially() throws Exception { + MediaSource mediaSource = + new FakeMediaSource(new FakeTimeline(), ExoPlayerTestRunner.VIDEO_FORMAT); + List parameterHistory = new ArrayList<>(); + FakeTrackSelector trackSelector = + new FakeTrackSelector() { + @Override + protected void selectAllTracks( + ExoTrackSelection.@NullableType Definition[] definitions, + MappedTrackInfo mappedTrackInfo, + int[][][] rendererFormatSupports, + int[] rendererMixedMimeTypeAdaptationSupports, + Parameters params) { + super.selectAllTracks( + definitions, + mappedTrackInfo, + rendererFormatSupports, + rendererMixedMimeTypeAdaptationSupports, + params); + parameterHistory.add(params); + } + }; + ExoPlayer player = + parameterizeTestExoPlayerBuilder( + new TestExoPlayerBuilder(context).setTrackSelector(trackSelector)) + .build(); + player.setMediaSource(mediaSource); + player.prepare(); + advance(player).untilState(Player.STATE_READY); + // Initial track selection happens during prepare/ready. Clear history to focus on updates. + parameterHistory.clear(); + // Trigger two parameter changes in rapid succession on the application thread. + DefaultTrackSelector.Parameters params1 = + trackSelector.buildUponParameters().setPreferredAudioLanguage("eng").build(); + DefaultTrackSelector.Parameters params2 = + trackSelector.buildUponParameters().setPreferredAudioLanguage("deu").build(); + + player.setTrackSelectionParameters(params1); + player.setTrackSelectionParameters(params2); + + advance(player).untilPendingCommandsAreFullyHandled(); + player.release(); + assertThat(parameterHistory).containsExactly(params1, params2).inOrder(); + } + @Test public void allActivatedTrackSelectionAreReleasedForMultiPeriods() throws Exception { Timeline timeline = new FakeTimeline(/* windowCount= */ 2); @@ -3731,66 +3777,6 @@ public void timelineUpdateWithNewMidrollAdCuePoint_dropsPrebufferedPeriod() thro assertThat(mediaSource.getCreatedMediaPeriods().get(3).adGroupIndex).isEqualTo(C.INDEX_UNSET); } - @Test - public void timelineUpdateWithPostroll_transitionToMultiPeriod_doesNotGetStuck() - throws Exception { - Object windowId = new Object(); - AdPlaybackState adPlaybackState = - new AdPlaybackState( - /* adsId= */ new Object(), /* adGroupTimesUs...= */ C.TIME_END_OF_SOURCE) - .withAdCount(/* adGroupIndex= */ 0, /* adCount= */ 1) - .withAvailableAdMediaItem( - /* adGroupIndex= */ 0, - /* adIndexInAdGroup= */ 0, - MediaItem.fromUri("https://google.com/ad")) - .withAdDurationsUs( - /* adGroupIndex= */ 0, /* adDurationsUs...= */ 5 * C.MICROS_PER_SECOND) - .withAdResumePositionUs(/* adResumePositionUs= */ 0); - - Timeline contentTimeline1 = - new FakeTimeline( - new FakeTimeline.TimelineWindowDefinition.Builder() - .setPeriodCount(1) - .setUid(windowId) - .setSeekable(true) - .setDurationUs(C.TIME_UNSET) - .setPlaceholder(true) - .build()); - Timeline timeline1 = new AdTimeline(contentTimeline1, adPlaybackState); - - Timeline contentTimeline2 = - new FakeTimeline( - new FakeTimeline.TimelineWindowDefinition.Builder() - .setPeriodCount(2) - .setUid(windowId) - .setSeekable(true) - .setDurationUs(10 * C.MICROS_PER_SECOND) - .build()); - Timeline timeline2 = new AdTimeline(contentTimeline2, adPlaybackState); - - FakeMediaSource mediaSource = new FakeMediaSource(timeline1, ExoPlayerTestRunner.VIDEO_FORMAT); - ActionSchedule actionSchedule = - new ActionSchedule.Builder(TAG) - .pause() - .waitForPlaybackState(Player.STATE_READY) - .executeRunnable(() -> mediaSource.setNewSourceInfo(timeline2)) - .waitForTimelineChanged( - timeline2, /* expectedReason= */ Player.TIMELINE_CHANGE_REASON_SOURCE_UPDATE) - .play() - .build(); - - ExoPlayerTestRunner testRunner = - parameterizeExoPlayerTestRunnerBuilder( - new ExoPlayerTestRunner.Builder(context) - .setMediaSources(mediaSource) - .setActionSchedule(actionSchedule)) - .build() - .start(); - - testRunner.blockUntilEnded(TIMEOUT_MS); - testRunner.assertPlayedPeriodIndices(0, 1); - } - @Test public void seekPastBufferingMidroll_playsAdAndThenContentFromSeekPosition() throws Exception { long adGroupWindowTimeMs = 1_000; @@ -8403,6 +8389,18 @@ public void maybeThrowError() throws IOException { assertThat(renderer.sampleBufferReadCount).isEqualTo(3); } + @Test + public void seekTo_withEmptyTimeline_emitsPositionDiscontinuityEvent() throws Exception { + ExoPlayer player = parameterizeTestExoPlayerBuilder(new TestExoPlayerBuilder(context)).build(); + Player.Listener mockListener = mock(Player.Listener.class); + player.addListener(mockListener); + + player.seekTo(/* positionMs= */ 2_000L); + + verify(mockListener).onPositionDiscontinuity(any(), any(), eq(DISCONTINUITY_REASON_SEEK)); + player.release(); + } + @Test public void seekTo_whileReady_callsOnIsPlayingChanged() throws Exception { ActionSchedule actionSchedule = diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerWithPrewarmingRenderersTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerWithPrewarmingRenderersTest.java index eac9780553a..9c364b6bebc 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerWithPrewarmingRenderersTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/ExoPlayerWithPrewarmingRenderersTest.java @@ -180,7 +180,7 @@ public void play_withTwoItemsAndPrewarming_secondaryRendererisEnabledButNotStart () -> secondaryVideoRenderer.getState() == Renderer.STATE_ENABLED); @Renderer.State int videoState1 = videoRenderer.getState(); @Renderer.State int secondaryVideoState1 = secondaryVideoRenderer.getState(); - // Play until until the primary renderer is being pre-warmed. + // Play until the primary renderer is being pre-warmed. advance(player) .untilBackgroundThreadCondition(() -> videoRenderer.getState() == Renderer.STATE_ENABLED); @Renderer.State int videoState2 = videoRenderer.getState(); @@ -200,6 +200,63 @@ public void play_withTwoItemsAndPrewarming_secondaryRendererisEnabledButNotStart assertThat(secondaryVideoState3).isEqualTo(Renderer.STATE_DISABLED); } + @Test + public void + play_multipleItemPlaylistAndSecondaryRendererLastActive_prewarmsAndUsesSecondaryRenderer() + throws Exception { + Clock fakeClock = new FakeClock(/* isAutoAdvancing= */ true); + ExoPlayer player = + new TestExoPlayerBuilder(context) + .setClock(fakeClock) + .setRenderersFactory( + new FakeRenderersFactorySupportingSecondaryVideoRenderer(fakeClock)) + .setPerStreamMediaProgressionEnabled(perStreamMediaProgressionEnabled) + .build(); + Renderer videoRenderer = player.getRenderer(/* index= */ 0); + Renderer secondaryVideoRenderer = player.getSecondaryRenderer(/* index= */ 0); + // Set a playlist with 2 videos, 2 audio-only items, and 1 final video item. + // Secondary-renderer should be last used and therefore pre-warmed for final item. + player.setMediaSources( + ImmutableList.of( + new FakeMediaSource(new FakeTimeline(), ExoPlayerTestRunner.VIDEO_FORMAT), + new FakeMediaSource(new FakeTimeline(), ExoPlayerTestRunner.VIDEO_FORMAT), + new FakeMediaSource(new FakeTimeline(), ExoPlayerTestRunner.AUDIO_FORMAT), + new FakeMediaSource(new FakeTimeline(), ExoPlayerTestRunner.AUDIO_FORMAT), + new FakeMediaSource(new FakeTimeline(), ExoPlayerTestRunner.VIDEO_FORMAT))); + player.prepare(); + player.play(); + // Play until the secondary video renderer is started (playing the second video item). + advance(player) + .untilBackgroundThreadCondition( + () -> secondaryVideoRenderer.getState() == Renderer.STATE_STARTED); + // Play to the audio items. + advance(player) + .untilBackgroundThreadCondition( + () -> + secondaryVideoRenderer.getState() == Renderer.STATE_DISABLED + && videoRenderer.getState() == Renderer.STATE_DISABLED); + + // Play until the secondary video renderer is enabled for pre-warming the final video item. + advance(player) + .untilBackgroundThreadCondition( + () -> secondaryVideoRenderer.getState() == Renderer.STATE_ENABLED); + @Renderer.State int videoState1 = videoRenderer.getState(); + @Renderer.State int secondaryVideoState1 = secondaryVideoRenderer.getState(); + // Play until the final media item is started. + advance(player) + .untilBackgroundThreadCondition( + () -> secondaryVideoRenderer.getState() == Renderer.STATE_STARTED); + @Renderer.State int videoState2 = videoRenderer.getState(); + @Renderer.State int secondaryVideoState2 = secondaryVideoRenderer.getState(); + + player.release(); + + assertThat(videoState1).isEqualTo(Renderer.STATE_DISABLED); + assertThat(secondaryVideoState1).isEqualTo(Renderer.STATE_ENABLED); + assertThat(videoState2).isEqualTo(Renderer.STATE_DISABLED); + assertThat(secondaryVideoState2).isEqualTo(Renderer.STATE_STARTED); + } + @Test public void prepare_withPeriodBetweenPlayingAndPrewarmingPeriods_playerSuccessfullyPrewarms() throws Exception { diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/MediaPeriodQueueTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/MediaPeriodQueueTest.java index af3b31d6bbe..01160661dbc 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/MediaPeriodQueueTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/MediaPeriodQueueTest.java @@ -54,8 +54,8 @@ import androidx.media3.exoplayer.source.SampleStream; import androidx.media3.exoplayer.source.SinglePeriodTimeline; import androidx.media3.exoplayer.source.TrackGroupArray; -import androidx.media3.exoplayer.source.ads.AdTimeline; import androidx.media3.exoplayer.source.ads.ServerSideAdInsertionMediaSource; +import androidx.media3.exoplayer.source.ads.SinglePeriodAdTimeline; import androidx.media3.exoplayer.trackselection.ExoTrackSelection; import androidx.media3.exoplayer.trackselection.TrackSelector; import androidx.media3.exoplayer.trackselection.TrackSelectorResult; @@ -321,7 +321,8 @@ public void getNextMediaPeriodInfo_withAdGroupResumeOffsets_returnsCorrectMediaP .withContentResumeOffsetUs(/* adGroupIndex= */ 0, /* contentResumeOffsetUs= */ 2000) .withContentResumeOffsetUs(/* adGroupIndex= */ 1, /* contentResumeOffsetUs= */ 3000) .withContentResumeOffsetUs(/* adGroupIndex= */ 2, /* contentResumeOffsetUs= */ 4000); - AdTimeline adTimeline = new AdTimeline(CONTENT_TIMELINE, adPlaybackState); + SinglePeriodAdTimeline adTimeline = + new SinglePeriodAdTimeline(CONTENT_TIMELINE, adPlaybackState); setupTimelines(adTimeline); setAdGroupLoaded(/* adGroupIndex= */ 0); @@ -397,7 +398,8 @@ public void getNextMediaPeriodInfo_withServerSideInsertedAds_returnsCorrectMedia .withIsServerSideInserted(/* adGroupIndex= */ 0, /* isServerSideInserted= */ true) .withIsServerSideInserted(/* adGroupIndex= */ 1, /* isServerSideInserted= */ true) .withIsServerSideInserted(/* adGroupIndex= */ 2, /* isServerSideInserted= */ true); - AdTimeline adTimeline = new AdTimeline(CONTENT_TIMELINE, adPlaybackState); + SinglePeriodAdTimeline adTimeline = + new SinglePeriodAdTimeline(CONTENT_TIMELINE, adPlaybackState); setupTimelines(adTimeline); setAdGroupLoaded(/* adGroupIndex= */ 0); @@ -475,7 +477,8 @@ public void getNextMediaPeriodInfo_withServerSideInsertedAds_returnsCorrectMedia adPlaybackState = new AdPlaybackState(/* adsId= */ new Object()) .withLivePostrollPlaceholderAppended(/* isServerSideInserted= */ false); - AdTimeline adTimeline = new AdTimeline(liveContentTimeline, adPlaybackState); + SinglePeriodAdTimeline adTimeline = + new SinglePeriodAdTimeline(liveContentTimeline, adPlaybackState); setupTimelines(adTimeline); assertGetNextMediaPeriodInfoReturnsContentMediaPeriod( @@ -886,7 +889,7 @@ public void getNextMediaPeriodInfo_ofLiveWindowWithUnsetDuration_setsStartPositi .setDefaultPositionUs(0) .setWindowPositionInFirstPeriodUs(0) .build()); - setupTimelines(new AdTimeline(liveContentTimeline, adPlaybackState)); + setupTimelines(new SinglePeriodAdTimeline(liveContentTimeline, adPlaybackState)); long[][] newDurations = new long[adPlaybackState.adGroupCount][]; newDurations[0] = new long[] {AD_DURATION_US}; adPlaybackState = @@ -894,7 +897,9 @@ public void getNextMediaPeriodInfo_ofLiveWindowWithUnsetDuration_setsStartPositi .withAdCount(0, /* adCount= */ 1) .withAvailableAdMediaItem(0, /* adIndexInAdGroup= */ 0, AD_MEDIA_ITEM) .withAdDurationsUs(newDurations); - fakeMediaSources.get(0).setNewSourceInfo(new AdTimeline(liveContentTimeline, adPlaybackState)); + fakeMediaSources + .get(0) + .setNewSourceInfo(new SinglePeriodAdTimeline(liveContentTimeline, adPlaybackState)); shadowOf(Looper.getMainLooper()).idle(); playbackInfo = playbackInfo.copyWithTimeline(mediaSourceList.createTimeline()); enqueueNext(); // Enqueue preroll ad. @@ -1006,7 +1011,8 @@ public void getNextMediaPeriodInfo_inMultiPeriodWindow_returnsCorrectMediaPeriod adPlaybackState = new AdPlaybackState(/* adsId= */ new Object(), /* adGroupTimes... */ FIRST_AD_START_TIME_US) .withIsServerSideInserted(/* adGroupIndex= */ 0, /* isServerSideInserted= */ true); - AdTimeline adTimeline = new AdTimeline(CONTENT_TIMELINE, adPlaybackState); + SinglePeriodAdTimeline adTimeline = + new SinglePeriodAdTimeline(CONTENT_TIMELINE, adPlaybackState); setupTimelines(adTimeline); setAdGroupLoaded(/* adGroupIndex= */ 0); enqueueNext(); // Content before ad. @@ -1346,7 +1352,7 @@ public void updateQueuedPeriods_withLivePeriodWithLargeStartPositionShift_remove /* useLiveConfiguration= */ true, /* manifest= */ null, AD_MEDIA_ITEM); - setupTimelines(new AdTimeline(liveTimeline, adPlaybackState)); + setupTimelines(new SinglePeriodAdTimeline(liveTimeline, adPlaybackState)); enqueueNext(); // The period needs to be prepared to get the actual buffered position from it. mediaPeriodQueue @@ -1449,7 +1455,7 @@ public void updateQueuedPeriods_withSsaiExpansionAfterReadingPeriod_keepsPeriods new AdPlaybackState(/* adsId= */ new Object(), 10 * C.MICROS_PER_SECOND) .withIsServerSideInserted(/* adGroupIndex= */ 0, true) .withContentDurationUs(CONTENT_DURATION_US); - setupTimelines(new AdTimeline(CONTENT_TIMELINE, adPlaybackState)); + setupTimelines(new SinglePeriodAdTimeline(CONTENT_TIMELINE, adPlaybackState)); enqueueNext(); // Expand the content period: move ad group start time 10s -> 12s. @@ -2353,7 +2359,8 @@ public void releasePeriod(MediaPeriod mediaPeriod) { .withAdDurationsUs(/* adGroupIndex= */ 0, 2_000L) .withAdDurationsUs(/* adGroupIndex= */ 1, 1_000L) .withContentDurationUs(CONTENT_DURATION_US); - AdTimeline adTimeline = new AdTimeline(CONTENT_TIMELINE, adPlaybackState); + SinglePeriodAdTimeline adTimeline = + new SinglePeriodAdTimeline(CONTENT_TIMELINE, adPlaybackState); setupMediaSources( new FakeMediaSource(), new FakeMediaSource(adTimeline), new FakeMediaSource()); mediaPeriodQueue.updatePreloadConfiguration( @@ -2528,7 +2535,8 @@ private void setupAdTimeline(long... adGroupTimesUs) { adPlaybackState = new AdPlaybackState(/* adsId= */ new Object(), adGroupTimesUs) .withContentDurationUs(CONTENT_DURATION_US); - AdTimeline adTimeline = new AdTimeline(CONTENT_TIMELINE, adPlaybackState); + SinglePeriodAdTimeline adTimeline = + new SinglePeriodAdTimeline(CONTENT_TIMELINE, adPlaybackState); setupTimelines(adTimeline); } @@ -2660,7 +2668,8 @@ private void updateAdPlaybackStateAndTimeline(long... adGroupTimesUs) { } private void updateAdTimeline(int mediaSourceIndex) { - AdTimeline adTimeline = new AdTimeline(CONTENT_TIMELINE, adPlaybackState); + SinglePeriodAdTimeline adTimeline = + new SinglePeriodAdTimeline(CONTENT_TIMELINE, adPlaybackState); fakeMediaSources.get(mediaSourceIndex).setNewSourceInfo(adTimeline); // Progress the looper so that the source info events have been executed. shadowOf(Looper.getMainLooper()).idle(); diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/DefaultAudioSinkTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/DefaultAudioSinkTest.java index d2e9a42517f..780d658b6c7 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/DefaultAudioSinkTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/DefaultAudioSinkTest.java @@ -63,6 +63,7 @@ import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicReference; import org.junit.After; import org.junit.Assert; @@ -1530,6 +1531,207 @@ public void setPlaybackParameters(PlaybackParameters playbackParams) { assertThat(actualPlaybackParameters.get()).isEqualTo(expectedMaxSpeedParameters); } + @Config(minSdk = 30) + @Test + public void hasPendingData_withPartialOffloadEncodedFrameWrite_returnsTrue() throws Exception { + Context context = ApplicationProvider.getApplicationContext(); + // Create a custom AudioOutputProvider that simulates a partial write of the compressed content. + AudioOutputProvider audioOutputProvider = + new ForwardingAudioOutputProvider( + new AudioTrackAudioOutputProvider.Builder(context).build()) { + @Override + public AudioOutput getAudioOutput(OutputConfig config) throws InitializationException { + return new ForwardingAudioOutput(super.getAudioOutput(config)) { + @Override + public boolean write( + ByteBuffer buffer, int encodedAccessUnitCount, long presentationTimeUs) + throws WriteException { + // Mock a partial write of 1024 bytes. + int bytesWritten = Math.min(buffer.remaining(), 1024); + buffer.position(buffer.position() + bytesWritten); + return false; + } + }; + } + }; + defaultAudioSink = + new DefaultAudioSink.Builder(context).setAudioOutputProvider(audioOutputProvider).build(); + AudioFormat audioFormat = + new AudioFormat.Builder() + .setSampleRate(SAMPLE_RATE_44_1) + .setChannelMask(AudioFormat.CHANNEL_OUT_STEREO) + .setEncoding(AudioFormat.ENCODING_AAC_LC) + .build(); + AudioAttributes audioAttributes = + new AudioAttributes.Builder() + .setContentType(C.AUDIO_CONTENT_TYPE_UNKNOWN) + .setUsage(C.USAGE_MEDIA) + .setAllowedCapturePolicy(C.ALLOW_CAPTURE_BY_ALL) + .build(); + ShadowAudioSystem.setOffloadSupported( + audioFormat, audioAttributes.getPlatformAudioAttributes(), true); + ShadowAudioSystem.setOffloadPlaybackSupport( + audioFormat, + audioAttributes.getPlatformAudioAttributes(), + AudioManager.PLAYBACK_OFFLOAD_SUPPORTED); + ShadowAudioSystem.setDirectPlaybackSupport( + audioFormat, + audioAttributes.getPlatformAudioAttributes(), + AudioManager.DIRECT_PLAYBACK_OFFLOAD_SUPPORTED); + configureDefaultAudioSinkWithOffload(); + + ByteBuffer largeBuffer = ByteBuffer.allocateDirect(11 * 1024).order(ByteOrder.nativeOrder()); + boolean handled = + defaultAudioSink.handleBuffer( + largeBuffer, /* presentationTimeUs= */ 0, /* encodedAccessUnitCount= */ 32); + assertThat(handled).isFalse(); + + assertThat(defaultAudioSink.hasPendingData()).isTrue(); + } + + @Config(minSdk = 30) + @Test + public void hasPendingData_withZeroBytesOffloadEncodedFrameWritten_returnsFalse() + throws Exception { + Context context = ApplicationProvider.getApplicationContext(); + // Create a custom AudioOutputProvider that blocks all writes. + AudioOutputProvider audioOutputProvider = + new ForwardingAudioOutputProvider( + new AudioTrackAudioOutputProvider.Builder(context).build()) { + @Override + public AudioOutput getAudioOutput(OutputConfig config) throws InitializationException { + return new ForwardingAudioOutput(super.getAudioOutput(config)) { + @Override + public boolean write( + ByteBuffer buffer, int encodedAccessUnitCount, long presentationTimeUs) + throws WriteException { + return false; + } + }; + } + }; + defaultAudioSink = + new DefaultAudioSink.Builder(context).setAudioOutputProvider(audioOutputProvider).build(); + AudioFormat audioFormat = + new AudioFormat.Builder() + .setSampleRate(SAMPLE_RATE_44_1) + .setChannelMask(AudioFormat.CHANNEL_OUT_STEREO) + .setEncoding(AudioFormat.ENCODING_AAC_LC) + .build(); + AudioAttributes audioAttributes = + new AudioAttributes.Builder() + .setContentType(C.AUDIO_CONTENT_TYPE_UNKNOWN) + .setUsage(C.USAGE_MEDIA) + .setAllowedCapturePolicy(C.ALLOW_CAPTURE_BY_ALL) + .build(); + ShadowAudioSystem.setOffloadSupported( + audioFormat, audioAttributes.getPlatformAudioAttributes(), true); + ShadowAudioSystem.setOffloadPlaybackSupport( + audioFormat, + audioAttributes.getPlatformAudioAttributes(), + AudioManager.PLAYBACK_OFFLOAD_SUPPORTED); + ShadowAudioSystem.setDirectPlaybackSupport( + audioFormat, + audioAttributes.getPlatformAudioAttributes(), + AudioManager.DIRECT_PLAYBACK_OFFLOAD_SUPPORTED); + configureDefaultAudioSinkWithOffload(); + + ByteBuffer largeBuffer = ByteBuffer.allocateDirect(11 * 1024).order(ByteOrder.nativeOrder()); + boolean handled = + defaultAudioSink.handleBuffer( + largeBuffer, /* presentationTimeUs= */ 0, /* encodedAccessUnitCount= */ 32); + assertThat(handled).isFalse(); + + assertThat(defaultAudioSink.hasPendingData()).isFalse(); + } + + @Config(minSdk = 30) + @Test + public void hasPendingData_withGaplessPartialOffloadEncodedFrameWrite_returnsTrue() + throws Exception { + Context context = ApplicationProvider.getApplicationContext(); + AtomicBoolean simulatePartialWrite = new AtomicBoolean(false); + AtomicLong mockPositionUs = new AtomicLong(0); + AudioOutputProvider audioOutputProvider = + new ForwardingAudioOutputProvider( + new AudioTrackAudioOutputProvider.Builder(context).build()) { + @Override + public AudioOutput getAudioOutput(OutputConfig config) throws InitializationException { + return new ForwardingAudioOutput(super.getAudioOutput(config)) { + @Override + public boolean write( + ByteBuffer buffer, int encodedAccessUnitCount, long presentationTimeUs) + throws WriteException { + if (simulatePartialWrite.get()) { + int bytesWritten = Math.min(buffer.remaining(), 1024); + buffer.position(buffer.position() + bytesWritten); + return false; + } + buffer.position(buffer.limit()); + return true; + } + + @Override + public long getPositionUs() { + return mockPositionUs.get(); + } + }; + } + }; + defaultAudioSink = + new DefaultAudioSink.Builder(context).setAudioOutputProvider(audioOutputProvider).build(); + AudioFormat audioFormat = + new AudioFormat.Builder() + .setSampleRate(SAMPLE_RATE_44_1) + .setChannelMask(AudioFormat.CHANNEL_OUT_STEREO) + .setEncoding(AudioFormat.ENCODING_AAC_LC) + .build(); + AudioAttributes audioAttributes = + new AudioAttributes.Builder() + .setContentType(C.AUDIO_CONTENT_TYPE_UNKNOWN) + .setUsage(C.USAGE_MEDIA) + .setAllowedCapturePolicy(C.ALLOW_CAPTURE_BY_ALL) + .build(); + ShadowAudioSystem.setOffloadSupported( + audioFormat, audioAttributes.getPlatformAudioAttributes(), true); + ShadowAudioSystem.setOffloadPlaybackSupport( + audioFormat, + audioAttributes.getPlatformAudioAttributes(), + AudioManager.PLAYBACK_OFFLOAD_SUPPORTED); + ShadowAudioSystem.setDirectPlaybackSupport( + audioFormat, + audioAttributes.getPlatformAudioAttributes(), + AudioManager.DIRECT_PLAYBACK_OFFLOAD_SUPPORTED); + configureDefaultAudioSinkWithOffload(); + ByteBuffer bufferA = ByteBuffer.allocateDirect(11 * 1024).order(ByteOrder.nativeOrder()); + boolean handledA = + defaultAudioSink.handleBuffer( + bufferA, /* presentationTimeUs= */ 0, /* encodedAccessUnitCount= */ 32); + assertThat(handledA).isTrue(); + + // Reconfigure the sink for Track B (gapless reuse transition). + Format formatB = + new Format.Builder() + .setSampleMimeType(MimeTypes.AUDIO_AAC) + .setChannelCount(2) + .setSampleRate(SAMPLE_RATE_44_1) + .setCodecs("mp4a.40.02") + .build(); + defaultAudioSink.configure(new AudioSink.AudioSinkConfig.Builder(formatB).build()); + simulatePartialWrite.set(true); + + ByteBuffer bufferB = ByteBuffer.allocateDirect(11 * 1024).order(ByteOrder.nativeOrder()); + boolean handledB = + defaultAudioSink.handleBuffer( + bufferB, /* presentationTimeUs= */ 3_000_000, /* encodedAccessUnitCount= */ 32); + assertThat(handledB).isFalse(); + + // Advance the mock playhead past Track A's duration. + mockPositionUs.set(750_000); + + assertThat(defaultAudioSink.hasPendingData()).isTrue(); + } + private void configureDefaultAudioSink(int channelCount) throws AudioSink.ConfigurationException { configureDefaultAudioSink(channelCount, /* trimStartFrames= */ 0, /* trimEndFrames= */ 0); } diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/PcmAudioUtilTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/PcmAudioUtilTest.java index eb0c092c80f..dab5af10c1e 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/PcmAudioUtilTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/PcmAudioUtilTest.java @@ -33,7 +33,7 @@ public final class PcmAudioUtilTest { @Test public void readAs32BitIntPcm_read8Bit_returnsExpectedValues() { ByteBuffer buffer = ByteBuffer.allocate(5); - buffer.put(hexToBytes("80" + "AB" + "00" + "12" + "7F")); + buffer.put(hexToBytes("00" + "2B" + "80" + "92" + "FF")); buffer.flip(); assertThat(PcmAudioUtil.readAs32BitIntPcm(buffer, C.ENCODING_PCM_8BIT)) @@ -197,7 +197,7 @@ public void write32BitIntPcm_write8Bit_returnsExpectedValues() { PcmAudioUtil.write32BitIntPcm(buffer, Integer.MAX_VALUE, C.ENCODING_PCM_8BIT); buffer.flip(); - assertThat(byteBufferToHex(buffer)).isEqualTo("80" + "AB" + "00" + "12" + "7F"); + assertThat(byteBufferToHex(buffer)).isEqualTo("00" + "2B" + "80" + "92" + "FF"); } @Test diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/SilenceSkippingAudioProcessorTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/SilenceSkippingAudioProcessorTest.java index d37de3cd098..11cc7208932 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/SilenceSkippingAudioProcessorTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/audio/SilenceSkippingAudioProcessorTest.java @@ -22,8 +22,10 @@ import androidx.media3.common.C; import androidx.media3.common.audio.AudioProcessor.AudioFormat; +import androidx.media3.common.audio.AudioProcessor.StreamMetadata; import androidx.test.ext.junit.runners.AndroidJUnit4; import com.google.common.collect.Range; +import java.io.ByteArrayOutputStream; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.ShortBuffer; @@ -95,7 +97,7 @@ public void skipInSilentSignal_skipsEverything() throws Exception { // When processing the entire signal. silenceSkippingAudioProcessor.setEnabled(true); silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); - silenceSkippingAudioProcessor.flush(); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); assertThat(silenceSkippingAudioProcessor.isActive()).isTrue(); long totalOutputFrames = process(silenceSkippingAudioProcessor, inputBufferProvider, INPUT_BUFFER_SIZE); @@ -118,7 +120,7 @@ public void skipInNoisySignal_skipsNothing() throws Exception { new SilenceSkippingAudioProcessor(); silenceSkippingAudioProcessor.setEnabled(true); silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); - silenceSkippingAudioProcessor.flush(); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); assertThat(silenceSkippingAudioProcessor.isActive()).isTrue(); long totalOutputFrames = process(silenceSkippingAudioProcessor, inputBufferProvider, INPUT_BUFFER_SIZE); @@ -142,7 +144,7 @@ public void skipInNoisySignalWithShortSilences_skipsNothing() throws Exception { new SilenceSkippingAudioProcessor(); silenceSkippingAudioProcessor.setEnabled(true); silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); - silenceSkippingAudioProcessor.flush(); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); assertThat(silenceSkippingAudioProcessor.isActive()).isTrue(); long totalOutputFrames = process(silenceSkippingAudioProcessor, inputBufferProvider, INPUT_BUFFER_SIZE); @@ -166,13 +168,14 @@ public void skipInAlternatingTestSignal_hasCorrectOutputAndSkippedFrameCounts() new SilenceSkippingAudioProcessor(); silenceSkippingAudioProcessor.setEnabled(true); silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); - silenceSkippingAudioProcessor.flush(); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); assertThat(silenceSkippingAudioProcessor.isActive()).isTrue(); long totalOutputFrames = process(silenceSkippingAudioProcessor, inputBufferProvider, INPUT_BUFFER_SIZE); - // The output has 50000 frames of noise, plus 50 * 0.2 * 1000 padding (plus rounding errors). - assertThat(totalOutputFrames).isIn(Range.closed(60000L - 500L, 60000L + 500L)); + // The output has 50000 frames of noise, plus 50 * (100 + 0.2 * 900) frames of silence (plus + // rounding errors). + assertThat(totalOutputFrames).isIn(Range.closed(64000L - 1500L, 64000L + 1500L)); assertThat(silenceSkippingAudioProcessor.getSkippedFrames()) .isEqualTo(TEST_SIGNAL_FRAME_COUNT - totalOutputFrames); } @@ -191,7 +194,7 @@ public void skipInAlternatingTestSignal_hasCorrectOutputAndSkippedFrameCounts() new SilenceSkippingAudioProcessor(); silenceSkippingAudioProcessor.setEnabled(true); silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); - silenceSkippingAudioProcessor.flush(); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); // Early configure the next format without flushing yet (this format should be ignored). silenceSkippingAudioProcessor.configure( @@ -200,8 +203,9 @@ public void skipInAlternatingTestSignal_hasCorrectOutputAndSkippedFrameCounts() long totalOutputFrames = process(silenceSkippingAudioProcessor, inputBufferProvider, INPUT_BUFFER_SIZE); - // The output has 50000 frames of noise, plus 50 * 0.2 * 1000 padding (plus rounding errors). - assertThat(totalOutputFrames).isIn(Range.closed(60000L - 500L, 60000L + 500L)); + // The output has 50000 frames of noise, plus 50 * (100 + 0.2 * 900) frames of silence (plus + // rounding errors). + assertThat(totalOutputFrames).isIn(Range.closed(64000L - 1500L, 64000L + 1500L)); assertThat(silenceSkippingAudioProcessor.getSkippedFrames()) .isEqualTo(TEST_SIGNAL_FRAME_COUNT - totalOutputFrames); } @@ -221,13 +225,14 @@ public void skipWithSmallerInputBufferSize_hasCorrectOutputAndSkippedFrameCounts new SilenceSkippingAudioProcessor(); silenceSkippingAudioProcessor.setEnabled(true); silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); - silenceSkippingAudioProcessor.flush(); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); assertThat(silenceSkippingAudioProcessor.isActive()).isTrue(); long totalOutputFrames = process(silenceSkippingAudioProcessor, inputBufferProvider, /* inputBufferSize= */ 80); - // The output has 50000 frames of noise, plus 50 * 0.2 * 1000 padding (plus rounding errors). - assertThat(totalOutputFrames).isIn(Range.closed(60000L - 500L, 60000L + 500L)); + // The output has 50000 frames of noise, plus 50 * (100 + 0.2 * 900) frames of silence (plus + // rounding errors). + assertThat(totalOutputFrames).isIn(Range.closed(64000L - 1500L, 64000L + 1500L)); assertThat(silenceSkippingAudioProcessor.getSkippedFrames()) .isEqualTo(TEST_SIGNAL_FRAME_COUNT - totalOutputFrames); } @@ -247,13 +252,14 @@ public void skipWithLargerInputBufferSize_hasCorrectOutputAndSkippedFrameCounts( new SilenceSkippingAudioProcessor(); silenceSkippingAudioProcessor.setEnabled(true); silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); - silenceSkippingAudioProcessor.flush(); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); assertThat(silenceSkippingAudioProcessor.isActive()).isTrue(); long totalOutputFrames = process(silenceSkippingAudioProcessor, inputBufferProvider, /* inputBufferSize= */ 120); - // The output has 50000 frames of noise, plus 50 * 0.2 * 1000 padding (plus rounding errors). - assertThat(totalOutputFrames).isIn(Range.closed(60000L - 500L, 60000L + 500L)); + // The output has 50000 frames of noise, plus 50 * (100 + 0.2 * 900) frames of silence (plus + // rounding errors). + assertThat(totalOutputFrames).isIn(Range.closed(64000L - 1500L, 64000L + 1500L)); assertThat(silenceSkippingAudioProcessor.getSkippedFrames()) .isEqualTo(TEST_SIGNAL_FRAME_COUNT - totalOutputFrames); } @@ -277,13 +283,14 @@ public void customSilenceRetentionValue_hasCorrectOutputAndSkippedFrameCounts() SilenceSkippingAudioProcessor.DEFAULT_SILENCE_THRESHOLD_LEVEL); silenceSkippingAudioProcessor.setEnabled(true); silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); - silenceSkippingAudioProcessor.flush(); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); assertThat(silenceSkippingAudioProcessor.isActive()).isTrue(); long totalOutputFrames = process(silenceSkippingAudioProcessor, inputBufferProvider, /* inputBufferSize= */ 120); - // The output has 50000 frames of noise, plus 50 * 0.05 * 1000 padding (plus rounding errors). - assertThat(totalOutputFrames).isIn(Range.closed(52500L - 500L, 52500L + 500L)); + // The output has 50000 frames of noise, plus 50 * (100 + 0.05 * 900) frames of silence (plus + // rounding errors). + assertThat(totalOutputFrames).isIn(Range.closed(56800L - 1500L, 56800L + 1500L)); assertThat(silenceSkippingAudioProcessor.getSkippedFrames()) .isEqualTo(TEST_SIGNAL_FRAME_COUNT - totalOutputFrames); } @@ -302,15 +309,113 @@ public void skipThenFlush_resetsSkippedFrameCount() throws Exception { new SilenceSkippingAudioProcessor(); silenceSkippingAudioProcessor.setEnabled(true); silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); - silenceSkippingAudioProcessor.flush(); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); assertThat(silenceSkippingAudioProcessor.isActive()).isTrue(); process(silenceSkippingAudioProcessor, inputBufferProvider, INPUT_BUFFER_SIZE); - silenceSkippingAudioProcessor.flush(); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); // The skipped frame count is zero. assertThat(silenceSkippingAudioProcessor.getSkippedFrames()).isEqualTo(0); } + @Test + public void process_withSingleFrameFadeBuffer_processesWithoutError() throws Exception { + // 2ms at 1000Hz results in a 2-frame buffer (1-frame fade out/in, max == 0). + SilenceSkippingAudioProcessor silenceSkippingAudioProcessor = + new SilenceSkippingAudioProcessor( + /* minimumSilenceDurationUs= */ 2_000, + SilenceSkippingAudioProcessor.DEFAULT_SILENCE_RETENTION_RATIO, + SilenceSkippingAudioProcessor.DEFAULT_MAX_SILENCE_TO_KEEP_DURATION_US, + SilenceSkippingAudioProcessor.DEFAULT_MIN_VOLUME_TO_KEEP_PERCENTAGE, + SilenceSkippingAudioProcessor.DEFAULT_SILENCE_THRESHOLD_LEVEL); + silenceSkippingAudioProcessor.setEnabled(true); + silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); + + // Provide 1 frame of noise (20000), 2 frames of silence (1000), and 1 frame of noise (20000). + ByteBuffer inputBuffer = + ByteBuffer.allocate(4 * AUDIO_FORMAT.bytesPerFrame).order(ByteOrder.nativeOrder()); + inputBuffer.putShort((short) 20000); + inputBuffer.putShort((short) 20000); + inputBuffer.putShort((short) 1000); + inputBuffer.putShort((short) 1000); + inputBuffer.putShort((short) 1000); + inputBuffer.putShort((short) 1000); + inputBuffer.putShort((short) 20000); + inputBuffer.putShort((short) 20000); + inputBuffer.flip(); + + ByteArrayOutputStream outStream = new ByteArrayOutputStream(); + while (inputBuffer.hasRemaining()) { + silenceSkippingAudioProcessor.queueInput(inputBuffer); + ByteBuffer outputBuffer = silenceSkippingAudioProcessor.getOutput(); + byte[] bytes = new byte[outputBuffer.remaining()]; + outputBuffer.get(bytes); + outStream.write(bytes); + } + silenceSkippingAudioProcessor.queueEndOfStream(); + while (!silenceSkippingAudioProcessor.isEnded()) { + ByteBuffer outputBuffer = silenceSkippingAudioProcessor.getOutput(); + byte[] bytes = new byte[outputBuffer.remaining()]; + outputBuffer.get(bytes); + outStream.write(bytes); + } + + ShortBuffer outputShortBuffer = + ByteBuffer.wrap(outStream.toByteArray()).order(ByteOrder.nativeOrder()).asShortBuffer(); + + // 1st frame: Noise (20000) + assertThat(outputShortBuffer.get()).isEqualTo((short) 20000); + assertThat(outputShortBuffer.get()).isEqualTo((short) 20000); + + // 2nd frame: 1-frame Fade-Out with max == 0 (scaled to 10% of 1000 = 100) + assertThat(outputShortBuffer.get()).isEqualTo((short) 100); + assertThat(outputShortBuffer.get()).isEqualTo((short) 100); + + // 3rd frame: 1-frame Fade-In with max == 0 (scaled to 100% of 1000 = 1000) + assertThat(outputShortBuffer.get()).isEqualTo((short) 1000); + assertThat(outputShortBuffer.get()).isEqualTo((short) 1000); + + // 4th frame: Noise (20000) + assertThat(outputShortBuffer.get()).isEqualTo((short) 20000); + assertThat(outputShortBuffer.get()).isEqualTo((short) 20000); + } + + @Test + public void queueInput_stereoFadedSilence_scalesBothChannelsEqually() throws Exception { + SilenceSkippingAudioProcessor silenceSkippingAudioProcessor = + new SilenceSkippingAudioProcessor(); + silenceSkippingAudioProcessor.setEnabled(true); + silenceSkippingAudioProcessor.configure(AUDIO_FORMAT); + silenceSkippingAudioProcessor.flush(StreamMetadata.DEFAULT); + + // Create a buffer with noise followed by silence (with non-zero sub-threshold level 500 on both + // L and R). + int frameCount = 2000; + ByteBuffer inputBuffer = + ByteBuffer.allocate(frameCount * AUDIO_FORMAT.bytesPerFrame).order(ByteOrder.nativeOrder()); + for (int i = 0; i < 500; i++) { + inputBuffer.putShort(MAX_VALUE); + inputBuffer.putShort(MAX_VALUE); + } + for (int i = 0; i < 1500; i++) { + inputBuffer.putShort((short) 500); + inputBuffer.putShort((short) 500); + } + inputBuffer.flip(); + + silenceSkippingAudioProcessor.queueInput(inputBuffer); + silenceSkippingAudioProcessor.queueEndOfStream(); + + ByteBuffer outputBuffer = silenceSkippingAudioProcessor.getOutput(); + ShortBuffer outputShortBuffer = outputBuffer.asShortBuffer(); + while (outputShortBuffer.hasRemaining()) { + short leftChannel = outputShortBuffer.get(); + short rightChannel = outputShortBuffer.get(); + assertThat(leftChannel).isEqualTo(rightChannel); + } + } + /** * Processes the entire stream provided by {@code inputBufferProvider} in chunks of {@code * inputBufferSize} and returns the total number of output frames. @@ -410,7 +515,7 @@ public Pcm16BitAudioBuilder(int channelCount, int frameCount) { public void appendFrames(int count, short... channelLevels) { checkState(!built); checkState(channelLevels.length == channelCount); - for (int i = 0; i < count; i += channelCount) { + for (int i = 0; i < count; i++) { for (short channelLevel : channelLevels) { buffer.put(channelLevel); } diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/e2etest/PrewarmingRendererPlaybackTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/e2etest/PrewarmingRendererPlaybackTest.java index ea5aa9886da..6c6b570813a 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/e2etest/PrewarmingRendererPlaybackTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/e2etest/PrewarmingRendererPlaybackTest.java @@ -344,6 +344,81 @@ public void playback_withImageVideoPlaylistAndSecondaryVideoRendererOnly_dumpsCo + ".dump"); } + @Test + public void playback_withMultipleVideoImagePlaylist_dumpsCorrectOutput() throws Exception { + Context applicationContext = ApplicationProvider.getApplicationContext(); + FakeClock clock = new FakeClock(/* isAutoAdvancing= */ true); + CapturingRenderersWithSecondaryVideoAndImageRenderersFactory capturingRenderersFactory = + new CapturingRenderersWithSecondaryVideoAndImageRenderersFactory(applicationContext, clock); + ExoPlayer player = + new ExoPlayer.Builder(applicationContext, capturingRenderersFactory) + .setClock(clock) + .enablePerStreamMediaProgression(perStreamMediaProgressionEnabled) + .build(); + Surface surface = new Surface(new SurfaceTexture(/* texName= */ 1)); + player.setVideoSurface(surface); + PlaybackOutput playbackOutput = PlaybackOutput.register(player, capturingRenderersFactory); + player.addMediaItems( + ImmutableList.of( + new MediaItem.Builder().setUri(TEST_MP4_URI).build(), + new MediaItem.Builder().setUri(TEST_MP4_URI).build(), + new MediaItem.Builder().setUri(TEST_IMAGE_URI).setImageDurationMs(1000).build(), + new MediaItem.Builder().setUri(TEST_IMAGE_URI).setImageDurationMs(1000).build(), + new MediaItem.Builder().setUri(TEST_MP4_URI).build())); + + player.prepare(); + advance(player).untilState(Player.STATE_READY); + player.play(); + advance(player).untilState(Player.STATE_ENDED); + player.release(); + surface.release(); + + DumpFileAsserts.assertOutput( + applicationContext, + playbackOutput, + /* dumpFile= */ "playbackdumps/prewarmingRenderer/" + + "multipleVideoImagePlaylist-withSecondaryRenderers" + + ".dump"); + } + + @Test + public void playback_withVideoVideoImagePlaylistThenSeekToStart_dumpsCorrectOutput() + throws Exception { + Context applicationContext = ApplicationProvider.getApplicationContext(); + FakeClock clock = new FakeClock(/* isAutoAdvancing= */ true); + CapturingRenderersWithSecondaryVideoAndImageRenderersFactory capturingRenderersFactory = + new CapturingRenderersWithSecondaryVideoAndImageRenderersFactory(applicationContext, clock); + ExoPlayer player = + new ExoPlayer.Builder(applicationContext, capturingRenderersFactory) + .setClock(clock) + .enablePerStreamMediaProgression(perStreamMediaProgressionEnabled) + .build(); + Surface surface = new Surface(new SurfaceTexture(/* texName= */ 1)); + player.setVideoSurface(surface); + PlaybackOutput playbackOutput = PlaybackOutput.register(player, capturingRenderersFactory); + player.addMediaItems( + ImmutableList.of( + new MediaItem.Builder().setUri(TEST_MP4_URI).build(), + new MediaItem.Builder().setUri(TEST_MP4_URI).build(), + new MediaItem.Builder().setUri(TEST_IMAGE_URI).setImageDurationMs(1000).build())); + + player.prepare(); + player.play(); + advance(player).untilState(Player.STATE_ENDED); + player.seekTo(/* mediaItemIndex= */ 0, /* positionMs= */ 0); + advance(player).untilState(Player.STATE_ENDED); + + player.release(); + surface.release(); + + DumpFileAsserts.assertOutput( + applicationContext, + playbackOutput, + /* dumpFile= */ "playbackdumps/prewarmingRenderer/" + + "videoVideoImagePlaylist-seekToStart-withSecondaryRenderers" + + ".dump"); + } + /** This class extends {@link CapturingRenderersFactory} to provide a secondary video renderer. */ private static final class CapturingRenderersWithSecondaryVideoRendererFactory extends CapturingRenderersFactory { diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/mediacodec/MediaCodecRendererTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/mediacodec/MediaCodecRendererTest.java index 290fa718217..6d6d5b7b096 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/mediacodec/MediaCodecRendererTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/mediacodec/MediaCodecRendererTest.java @@ -51,6 +51,7 @@ import androidx.media3.common.MimeTypes; import androidx.media3.common.util.Clock; import androidx.media3.common.util.MediaFormatUtil; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.decoder.CryptoInfo; import androidx.media3.exoplayer.CodecParameters; import androidx.media3.exoplayer.DecoderReuseEvaluation; @@ -947,11 +948,11 @@ public void resetPosition_withBuffersReceived_flushesCodec() throws Exception { MediaCodecAdapter mockCodecAdapter = mock(MediaCodecAdapter.class); doAnswer( invocation -> { - ((Runnable) invocation.getArgument(0)).run(); + ((ThrowingRunnable) invocation.getArgument(0)).run(); return null; }) .when(mockCodecAdapter) - .useInputBuffer(any()); + .useBuffer(any()); when(mockCodecAdapter.dequeueInputBufferIndex()) .thenReturn(0) .thenReturn(MediaCodec.INFO_TRY_AGAIN_LATER); diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ProgressiveMediaPeriodTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ProgressiveMediaPeriodTest.java index 64516e6bb99..85cd7772ec7 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ProgressiveMediaPeriodTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ProgressiveMediaPeriodTest.java @@ -19,8 +19,10 @@ import static androidx.media3.test.utils.robolectric.RobolectricUtil.runMainLooperUntil; import static com.google.common.truth.Truth.assertThat; import static org.junit.Assume.assumeTrue; +import static org.robolectric.Shadows.shadowOf; import android.net.Uri; +import android.os.Looper; import androidx.annotation.Nullable; import androidx.media3.common.C; import androidx.media3.common.DataReader; @@ -147,10 +149,11 @@ public void readData_forUnselectedTrack_returnsFormatAndNothingElse() throws Exc assertThat(readProgressiveStream(mediaPeriod, /* trackIndex= */ 0, buffer)) .isEqualTo(C.RESULT_BUFFER_READ); assertThat(buffer.isEndOfStream()).isFalse(); - // Read from stream 1 (unselected) to check we get no samples. - assertThat(readProgressiveStream(mediaPeriod, /* trackIndex= */ 1, buffer)) - .isEqualTo(C.RESULT_BUFFER_READ); - assertThat(buffer.isEndOfStream()).isTrue(); + + // Audio track (unselected) returns no samples (or at most in-flight samples from before track + // selection). + assertThat(readProgressiveStreamUntilEndOfStream(mediaPeriod, /* trackIndex= */ 1, buffer)) + .isAtMost(1); mediaPeriod.release(); } @@ -335,6 +338,19 @@ public void selectTracks_withHagcTrack_createsMergingMetadataSampleStream() thro return mediaPeriod.readData(trackIndex, new FormatHolder(), buffer, /* readFlags= */ 0); } + private static int readProgressiveStreamUntilEndOfStream( + ProgressiveMediaPeriod mediaPeriod, int trackIndex, DecoderInputBuffer buffer) { + int readResult; + int sampleCount = 0; + do { + readResult = readProgressiveStream(mediaPeriod, trackIndex, buffer); + if (readResult == C.RESULT_BUFFER_READ && !buffer.isEndOfStream()) { + sampleCount++; + } + } while (readResult != C.RESULT_BUFFER_READ || !buffer.isEndOfStream()); + return sampleCount; + } + private static ProgressiveMediaPeriod createMediaPeriod( ProgressiveMediaExtractor extractor, long imageDurationUs, @@ -385,7 +401,6 @@ private static ProgressiveMediaPeriod createMediaPeriod( /* customCacheKey= */ null, ProgressiveMediaSource.DEFAULT_LOADING_CHECK_INTERVAL_BYTES, /* loadOnlySelectedTracks= */ true, - /* experimentalEnableHagcPlayback= */ true, /* singleTrackId= */ 0, /* singleTrackFormat= */ null, imageDurationUs, @@ -430,6 +445,69 @@ private static void testExtractorsUpdatesSourceInfoBeforeOnPreparedCallback( mediaPeriod.release(); } + @Test + public void seekToUs_toStreamStartWithPositiveFirstSampleTimestamp_seeksInsideBuffer() + throws Exception { + ProgressiveMediaPeriod mediaPeriod = + createMediaPeriod(Uri.parse("asset://android_asset/media/mp4/sample.mp4")); + TrackGroupArray trackGroups = mediaPeriod.getTrackGroups(); + @NullableType ExoTrackSelection[] selections = new ExoTrackSelection[trackGroups.length]; + @NullableType SampleStream[] streams = new SampleStream[trackGroups.length]; + boolean[] streamResetFlags = new boolean[trackGroups.length]; + selections[1] = + new FakeTrackSelection(trackGroups.get(1), new int[] {0}, /* selectedIndex= */ 0); + long unused = + mediaPeriod.selectTracks( + selections, + new boolean[trackGroups.length], + streams, + streamResetFlags, + /* positionUs= */ 0); + + // Initial load until buffered. + boolean unusedLoad = + mediaPeriod.continueLoading(new LoadingInfo.Builder().setPlaybackPositionUs(0).build()); + runMainLooperUntil( + () -> { + mediaPeriod.reevaluateBuffer(/* positionUs= */ 0); + return mediaPeriod.getBufferedPositionUs() == C.TIME_END_OF_SOURCE; + }); + shadowOf(Looper.getMainLooper()).idle(); + + // Read first sample to advance read index past 0. + FormatHolder formatHolder = new FormatHolder(); + DecoderInputBuffer buffer = + new DecoderInputBuffer(DecoderInputBuffer.BUFFER_REPLACEMENT_MODE_NORMAL); + int readResult = streams[1].readData(formatHolder, buffer, /* readFlags= */ 0); + if (readResult == C.RESULT_FORMAT_READ) { + buffer.clear(); + readResult = streams[1].readData(formatHolder, buffer, /* readFlags= */ 0); + } + assertThat(readResult).isEqualTo(C.RESULT_BUFFER_READ); + long firstSampleTimeUs = buffer.timeUs; + assertThat(firstSampleTimeUs).isGreaterThan(0); + + // Seek back to position 0 (same as last seek position). + long seekTimeUs = mediaPeriod.seekToUs(0); + assertThat(seekTimeUs).isEqualTo(0); + + // Verify in-buffer seek was successful and loading is not restarted. + assertThat(mediaPeriod.isLoading()).isFalse(); + + // Verify reading starts again from the first sample. + buffer.clear(); + readResult = streams[1].readData(formatHolder, buffer, /* readFlags= */ 0); + if (readResult == C.RESULT_FORMAT_READ) { + buffer.clear(); + readResult = streams[1].readData(formatHolder, buffer, /* readFlags= */ 0); + } + assertThat(readResult).isEqualTo(C.RESULT_BUFFER_READ); + assertThat(buffer.timeUs).isEqualTo(firstSampleTimeUs); + + mediaPeriod.release(); + } + + private static final class ExecutionTrackingThread extends Thread { private final AtomicBoolean hasRun; diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ads/AdTimelineTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ads/AdTimelineTest.java deleted file mode 100644 index f1a2bd10690..00000000000 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ads/AdTimelineTest.java +++ /dev/null @@ -1,195 +0,0 @@ -/* - * Copyright (C) 2026 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 androidx.media3.exoplayer.source.ads; - -import static androidx.media3.common.C.INDEX_UNSET; -import static androidx.media3.common.C.MICROS_PER_SECOND; -import static androidx.media3.common.C.TIME_END_OF_SOURCE; -import static androidx.media3.common.C.TIME_UNSET; -import static com.google.common.truth.Truth.assertThat; - -import androidx.media3.common.AdPlaybackState; -import androidx.media3.common.Timeline.Period; -import androidx.media3.test.utils.FakeTimeline; -import androidx.test.ext.junit.runners.AndroidJUnit4; -import org.junit.Test; -import org.junit.runner.RunWith; - -/** Unit test for {@link AdTimeline}. */ -@RunWith(AndroidJUnit4.class) -public class AdTimelineTest { - - @Test - public void getPeriod_multiPeriod_returnsCorrectAdPlaybackStateForEachPeriod() { - String windowId = "windowId"; - FakeTimeline contentTimeline = - new FakeTimeline( - new FakeTimeline.TimelineWindowDefinition.Builder() - .setPeriodCount(3) - .setUid(windowId) - .setSeekable(true) - .setDurationUs(60 * MICROS_PER_SECOND) - .setWindowPositionInFirstPeriodUs(0) - .build()); - AdTimeline adTimeline = - new AdTimeline( - contentTimeline, - new AdPlaybackState( - "adsId", - 0L, - 10 * MICROS_PER_SECOND, // Period 0: 0s - 20s - 25 * MICROS_PER_SECOND, - 35 * MICROS_PER_SECOND, // Period 1: 20s - 40s - 45 * MICROS_PER_SECOND, - 55 * MICROS_PER_SECOND // Period 2: 40s - 60s - )); - Period period0 = new Period(); - - adTimeline.getPeriod(0, period0); - - // Period durations are uniformly split windowDuration/periodCount - assertThat(period0.durationUs).isEqualTo(20 * MICROS_PER_SECOND); - - // Positions within the 0th period - assertThat(period0.getAdGroupIndexForPositionUs(1 * MICROS_PER_SECOND)).isEqualTo(0); - assertThat(period0.getAdGroupIndexAfterPositionUs(1 * MICROS_PER_SECOND)).isEqualTo(1); - assertThat(period0.getAdGroupIndexForPositionUs(19 * MICROS_PER_SECOND)).isEqualTo(1); - // No more ads to be played in 0th period - assertThat(period0.getAdGroupIndexAfterPositionUs(19 * MICROS_PER_SECOND)) - .isEqualTo(INDEX_UNSET); - - Period period1 = new Period(); - - adTimeline.getPeriod(1, period1); - - // Positions within the 1st period - assertThat(period1.getAdGroupIndexForPositionUs(1 * MICROS_PER_SECOND)).isEqualTo(1); // 21s - assertThat(period1.getAdGroupIndexAfterPositionUs(1 * MICROS_PER_SECOND)).isEqualTo(2); // 21s - assertThat(period1.getAdGroupIndexForPositionUs(10 * MICROS_PER_SECOND)).isEqualTo(2); // 30s - assertThat(period1.getAdGroupIndexAfterPositionUs(10 * MICROS_PER_SECOND)).isEqualTo(3); // 30s - assertThat(period1.getAdGroupIndexForPositionUs(19 * MICROS_PER_SECOND)).isEqualTo(3); // 39s - // No more ads to be played in 1st period - assertThat(period1.getAdGroupIndexAfterPositionUs(19 * MICROS_PER_SECOND)) - .isEqualTo(INDEX_UNSET); // 39s - - Period period2 = new Period(); - - adTimeline.getPeriod(2, period2); - - // Positions within the 2nd period - assertThat(period2.getAdGroupIndexForPositionUs(1 * MICROS_PER_SECOND)).isEqualTo(3); // 41s - assertThat(period2.getAdGroupIndexAfterPositionUs(1 * MICROS_PER_SECOND)).isEqualTo(4); // 41s - assertThat(period2.getAdGroupIndexForPositionUs(10 * MICROS_PER_SECOND)).isEqualTo(4); // 50s - assertThat(period2.getAdGroupIndexAfterPositionUs(10 * MICROS_PER_SECOND)).isEqualTo(5); // 50s - assertThat(period2.getAdGroupIndexForPositionUs(19 * MICROS_PER_SECOND)).isEqualTo(5); // 59s - // No more ads to be played in 2nd period - assertThat(period2.getAdGroupIndexAfterPositionUs(19 * MICROS_PER_SECOND)) - .isEqualTo(INDEX_UNSET); // 59s - } - - @Test - public void getPeriod_postRoll_onlyKeptInLastPeriod() { - String windowId = "windowId"; - FakeTimeline contentTimeline = - new FakeTimeline( - new FakeTimeline.TimelineWindowDefinition.Builder() - .setPeriodCount(2) - .setUid(windowId) - .setSeekable(true) - .setDurationUs(60 * MICROS_PER_SECOND) - .setWindowPositionInFirstPeriodUs(0) - .build()); - AdTimeline adTimeline = - new AdTimeline( - contentTimeline, - new AdPlaybackState( - "adsId", TIME_END_OF_SOURCE // Period 1: 30s - 60s - )); - Period period0 = new Period(); - - adTimeline.getPeriod(0, period0); - - // Period durations are uniformly split windowDuration/periodCount - assertThat(period0.durationUs).isEqualTo(30 * MICROS_PER_SECOND); - assertThat(period0.getAdGroupIndexForPositionUs(15 * MICROS_PER_SECOND)).isEqualTo(INDEX_UNSET); - // Post-roll should not be played in 0th period - assertThat(period0.getAdGroupIndexAfterPositionUs(15 * MICROS_PER_SECOND)) - .isEqualTo(INDEX_UNSET); - - Period period1 = new Period(); - - adTimeline.getPeriod(1, period1); - - assertThat(period1.getAdGroupIndexForPositionUs(29 * MICROS_PER_SECOND)) - .isEqualTo(INDEX_UNSET); // 59s - // Post-roll in the end - assertThat(period1.getAdGroupIndexAfterPositionUs(29 * MICROS_PER_SECOND)).isEqualTo(0); // 59s - } - - @Test - public void getPeriod_setsCorrectContentDuration() { - String windowId = "windowId"; - FakeTimeline contentTimeline = - new FakeTimeline( - new FakeTimeline.TimelineWindowDefinition.Builder() - .setPeriodCount(2) - .setUid(windowId) - .setSeekable(true) - .setDurationUs(50 * MICROS_PER_SECOND) - .setWindowPositionInFirstPeriodUs(0) - .build()); - AdPlaybackState adPlaybackState = - new AdPlaybackState("adsId", 10 * MICROS_PER_SECOND) - .withContentDurationUs(50 * MICROS_PER_SECOND); - AdTimeline adTimeline = new AdTimeline(contentTimeline, adPlaybackState); - Period period0 = new Period(); - Period period1 = new Period(); - - adTimeline.getPeriod(0, period0); - adTimeline.getPeriod(1, period1); - - // Period 0 duration is 25s. Content duration in AdPlaybackState should be adjusted to 25s. - assertThat(period0.adPlaybackState.contentDurationUs).isEqualTo(25 * MICROS_PER_SECOND); - // Period 1 duration is 25s. Content duration in AdPlaybackState should be adjusted to 25s. - assertThat(period1.adPlaybackState.contentDurationUs).isEqualTo(25 * MICROS_PER_SECOND); - } - - @Test - public void getPeriod_lastPeriodUnsetDuration_fallsBackToAdPlaybackStateContentDuration() { - String windowId = "windowId"; - FakeTimeline contentTimeline = - new FakeTimeline( - new FakeTimeline.TimelineWindowDefinition.Builder() - .setPeriodCount(1) - .setUid(windowId) - .setSeekable(true) - .setDurationUs(TIME_UNSET) - .setWindowPositionInFirstPeriodUs(0) - .build()); - AdPlaybackState adPlaybackState = - new AdPlaybackState("adsId", 10 * MICROS_PER_SECOND) - .withContentDurationUs(50 * MICROS_PER_SECOND); - AdTimeline adTimeline = new AdTimeline(contentTimeline, adPlaybackState); - Period period = new Period(); - - adTimeline.getPeriod(0, period); - - // Content duration should fall back to adPlaybackState.contentDurationUs (50s) because period - // duration is unset. - assertThat(period.durationUs).isEqualTo(50 * MICROS_PER_SECOND); - assertThat(period.adPlaybackState.contentDurationUs).isEqualTo(50 * MICROS_PER_SECOND); - } -} diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ads/AdsMediaSourceTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ads/AdsMediaSourceTest.java index 0a2ad5a2282..03875aef771 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ads/AdsMediaSourceTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/ads/AdsMediaSourceTest.java @@ -190,7 +190,7 @@ public void createPeriod_forPreroll_preparesChildAdMediaSourceAndRefreshesSource verify(mockMediaSourceCaller) .onSourceInfoRefreshed( adsMediaSource, - new AdTimeline(PLACEHOLDER_CONTENT_TIMELINE, PREROLL_AD_PLAYBACK_STATE)); + new SinglePeriodAdTimeline(PLACEHOLDER_CONTENT_TIMELINE, PREROLL_AD_PLAYBACK_STATE)); } @Test @@ -213,7 +213,7 @@ public void createPeriod_forPreroll_preparesChildAdMediaSourceAndRefreshesSource verify(mockMediaSourceCaller) .onSourceInfoRefreshed( adsMediaSource, - new AdTimeline( + new SinglePeriodAdTimeline( PLACEHOLDER_CONTENT_TIMELINE, PREROLL_AD_PLAYBACK_STATE.withAdDurationsUs( new long[][] {{PREROLL_AD_DURATION_US}}))); @@ -254,7 +254,8 @@ public void createPeriod_forContent_createsChildContentMediaPeriodAndLoadsConten verify(mockMediaSourceCaller, times(2)) .onSourceInfoRefreshed(eq(adsMediaSource), adsTimelineCaptor.capture()); TestUtil.timelinesAreSame( - adsTimelineCaptor.getValue(), new AdTimeline(CONTENT_TIMELINE, PREROLL_AD_PLAYBACK_STATE)); + adsTimelineCaptor.getValue(), + new SinglePeriodAdTimeline(CONTENT_TIMELINE, PREROLL_AD_PLAYBACK_STATE)); } @Test diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/preload/PreloadAndPlaybackCoordinationTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/preload/PreloadAndPlaybackCoordinationTest.java index 5a28a3252dc..ae345a23626 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/preload/PreloadAndPlaybackCoordinationTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/preload/PreloadAndPlaybackCoordinationTest.java @@ -79,7 +79,7 @@ public PreloadAndPlaybackCoordinationTest() { FakeMediaSourceFactory mediaSourceFactory = new FakeMediaSourceFactory(); LoadControl loadControl = new DefaultLoadControl(); TrackSelector trackSelector = new DefaultTrackSelector(context); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); RenderersFactory renderersFactory = (handler, videoListener, audioListener, textOutput, metadataOutput) -> new Renderer[] { diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/preload/PreloadMediaSourceTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/preload/PreloadMediaSourceTest.java index 4bed3a6b3c1..f71311d458f 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/preload/PreloadMediaSourceTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/source/preload/PreloadMediaSourceTest.java @@ -163,7 +163,7 @@ public void preload_loadPeriodToTargetPreloadPosition() throws Exception { mediaSourceFactory.setContinueLoadingCheckIntervalBytes(LOADING_CHECK_INTERVAL_BYTES); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -203,7 +203,7 @@ public void preload_stopWhenTracksSelectedByPreloadControl() throws Exception { mediaSourceFactory.setContinueLoadingCheckIntervalBytes(LOADING_CHECK_INTERVAL_BYTES); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -242,7 +242,7 @@ public void preload_stopWhenSourcePreparedByPreloadControl() throws Exception { new DefaultDataSource.Factory(ApplicationProvider.getApplicationContext())); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -270,7 +270,7 @@ public void preload_stopWhenSourcePreparedByPreloadControl() throws Exception { @Test public void preload_whileSourceIsAccessedByExternalCaller_notProceedWithPreloading() { TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( new FakeMediaSourceFactory(), @@ -311,7 +311,7 @@ public void preload_loadToTheEndOfSource() throws Exception { mediaSourceFactory.setContinueLoadingCheckIntervalBytes(LOADING_CHECK_INTERVAL_BYTES); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -358,7 +358,7 @@ public void preload_withSmallTargetBufferBytesThreshold_onLoadingUnableToContinu mediaSourceFactory.setContinueLoadingCheckIntervalBytes(LOADING_CHECK_INTERVAL_BYTES); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); LoadControl loadControl = mock( LoadControl.class, @@ -439,7 +439,7 @@ public void maybeThrowSourceInfoRefreshError() throws IOException { }; TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -524,7 +524,7 @@ public void maybeThrowPrepareError() throws IOException { }; TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -636,7 +636,7 @@ public void maybeThrowError() throws IOException { }; TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -667,7 +667,7 @@ public void prepareSourceNotOnPreloadThread_beforePreloadCalled_throwsIllegalSta HandlerThread preloadThread = new HandlerThread("preload"); preloadThread.start(); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( new FakeMediaSourceFactory(), @@ -693,7 +693,7 @@ public void prepareSourceNotOnPreloadThread_afterPreloadCalled_throwsIllegalStat HandlerThread preloadThread = new HandlerThread("preload"); preloadThread.start(); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( new FakeMediaSourceFactory(), @@ -721,7 +721,7 @@ public void prepareSourceNotOnPreloadThread_afterPreloadCalled_throwsIllegalStat prepareSource_beforeSourceInfoRefreshedForPreloading_onlyInvokeExternalCallerOnSourceInfoRefreshed() { FakeMediaSourceFactory mediaSourceFactory = new FakeMediaSourceFactory(); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -751,7 +751,7 @@ public void prepareSourceNotOnPreloadThread_afterPreloadCalled_throwsIllegalStat public void prepareSource_afterPreload_immediatelyInvokeExternalCallerOnSourceInfoRefreshed() { FakeMediaSourceFactory mediaSourceFactory = new FakeMediaSourceFactory(); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -818,7 +818,7 @@ public void createPeriodWithSameMediaPeriodIdAndStartPosition_returnExistingPeri new ExoTrackSelection[0], Tracks.EMPTY, /* info= */ null)); - mockTrackSelector.init(() -> {}, bandwidthMeter); + mockTrackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mockMediaSourceFactory, @@ -895,7 +895,7 @@ public void createPeriodWithSameMediaPeriodIdAndDifferentStartPosition_returnNew new ExoTrackSelection[0], Tracks.EMPTY, /* info= */ null)); - mockTrackSelector.init(() -> {}, bandwidthMeter); + mockTrackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mockMediaSourceFactory, @@ -959,7 +959,7 @@ public void release() { }); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mockMediaSourceFactory, @@ -1010,7 +1010,7 @@ protected MediaPeriod createMediaPeriod( } }); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mockMediaSourceFactory, @@ -1067,7 +1067,7 @@ public synchronized void prepare(Callback callback, long positionUs) { } }); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mockMediaSourceFactory, @@ -1112,7 +1112,7 @@ public void releaseSourceByAllExternalCallers_preloadNotCalledBefore_releaseInte return mockMediaSource; }); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mockMediaSourceFactory, @@ -1161,7 +1161,7 @@ public void releaseSourceByAllExternalCallers_stillPreloading_notReleaseInternal return mockMediaSource; }); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mockMediaSourceFactory, @@ -1211,7 +1211,7 @@ public void releaseSourceByAllExternalCallers_stillPreloading_notReleaseInternal return mockMediaSource; }); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mockMediaSourceFactory, @@ -1265,7 +1265,7 @@ public void releasePreloadMediaSource_notUsedByExternalCallers_releaseInternalSo return mockMediaSource; }); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mockMediaSourceFactory, @@ -1312,7 +1312,7 @@ public void releasePreloadMediaSource_stillUsedByExternalCallers_releaseInternal return mockMediaSource; }); TrackSelector trackSelector = new FakeTrackSelector(); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mockMediaSourceFactory, diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/trackselection/DefaultTrackSelectorTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/trackselection/DefaultTrackSelectorTest.java index 60bb77928df..dfedee97b3a 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/trackselection/DefaultTrackSelectorTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/trackselection/DefaultTrackSelectorTest.java @@ -37,9 +37,10 @@ import static androidx.media3.exoplayer.audio.AudioSink.OFFLOAD_MODE_ENABLED_GAPLESS_NOT_REQUIRED; import static androidx.media3.exoplayer.audio.AudioSink.OFFLOAD_MODE_ENABLED_GAPLESS_REQUIRED; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.robolectric.Shadows.shadowOf; @@ -183,6 +184,14 @@ public void setUp() { Context context = ApplicationProvider.getApplicationContext(); defaultParameters = Parameters.DEFAULT; trackSelector = new DefaultTrackSelector(context); + doAnswer( + invocation -> { + TrackSelectionParameters parameters = invocation.getArgument(0); + trackSelector.onParametersActivated(parameters); + return null; + }) + .when(invalidationListener) + .onTrackSelectionsInvalidated(any()); trackSelector.init(invalidationListener, bandwidthMeter); } @@ -539,37 +548,38 @@ public void selectTracksWithDisabledNoSampleRenderer() throws ExoPlaybackExcepti /** * Tests that track selector will not call {@link - * InvalidationListener#onTrackSelectionsInvalidated()} when it's set with default values of - * {@link Parameters}. + * InvalidationListener#onTrackSelectionsInvalidated(TrackSelectionParameters)} when it's set with + * default values of {@link Parameters}. */ @Test public void setParameterWithDefaultParametersDoesNotNotifyInvalidationListener() { trackSelector.setParameters(defaultParameters); - verify(invalidationListener, never()).onTrackSelectionsInvalidated(); + verify(invalidationListener, never()).onTrackSelectionsInvalidated(any()); } /** - * Tests that track selector will call {@link InvalidationListener#onTrackSelectionsInvalidated()} - * when it's set with non-default values of {@link Parameters}. + * Tests that track selector will call {@link + * InvalidationListener#onTrackSelectionsInvalidated(TrackSelectionParameters)} when it's set with + * non-default values of {@link Parameters}. */ @Test public void setParameterWithNonDefaultParameterNotifyInvalidationListener() { Parameters.Builder builder = defaultParameters.buildUpon().setPreferredAudioLanguage("eng"); trackSelector.setParameters(builder); - verify(invalidationListener).onTrackSelectionsInvalidated(); + verify(invalidationListener).onTrackSelectionsInvalidated(any()); } /** * Tests that track selector will not call {@link - * InvalidationListener#onTrackSelectionsInvalidated()} again when it's set with the same values - * of {@link Parameters}. + * InvalidationListener#onTrackSelectionsInvalidated(TrackSelectionParameters)} again when it's + * set with the same values of {@link Parameters}. */ @Test public void setParameterWithSameParametersDoesNotNotifyInvalidationListenerAgain() { Parameters.Builder builder = defaultParameters.buildUpon().setPreferredAudioLanguage("eng"); trackSelector.setParameters(builder); trackSelector.setParameters(builder); - verify(invalidationListener, times(1)).onTrackSelectionsInvalidated(); + verify(invalidationListener).onTrackSelectionsInvalidated(any()); } /** diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/upstream/DefaultLoadErrorHandlingPolicyTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/upstream/DefaultLoadErrorHandlingPolicyTest.java index f2e6ffe2f9f..ad53ea90cdc 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/upstream/DefaultLoadErrorHandlingPolicyTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/upstream/DefaultLoadErrorHandlingPolicyTest.java @@ -47,14 +47,10 @@ public final class DefaultLoadErrorHandlingPolicyTest { private static final LoadEventInfo PLACEHOLDER_LOAD_EVENT_INFO = - new LoadEventInfo( - LoadEventInfo.getNewId(), - new DataSpec(Uri.EMPTY), - Uri.EMPTY, - /* responseHeaders= */ Collections.emptyMap(), - /* elapsedRealtimeMs= */ 5000, - /* loadDurationMs= */ 1000, - /* bytesLoaded= */ 0); + new LoadEventInfo.Builder( + LoadEventInfo.getNewId(), new DataSpec(Uri.EMPTY), /* elapsedRealtimeMs= */ 5000) + .setLoadDurationMs(1000) + .build(); private static final MediaLoadData PLACEHOLDER_MEDIA_LOAD_DATA = new MediaLoadData(/* dataType= */ C.DATA_TYPE_UNKNOWN); diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/util/EventLoggerTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/util/EventLoggerTest.java index e5c21e01c7a..2977d74f31a 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/util/EventLoggerTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/util/EventLoggerTest.java @@ -461,10 +461,11 @@ public void onVideoSizeChanged() { public void onLoadError() { eventLogger.onLoadError( EVENT_TIME, - new LoadEventInfo( - /* loadTaskId= */ 1, - new DataSpec(Uri.parse("http://foo.test")), - /* elapsedRealtimeMs= */ 123), + new LoadEventInfo.Builder( + /* loadTaskId= */ 1, + new DataSpec(Uri.parse("http://foo.test")), + /* elapsedRealtimeMs= */ 123) + .build(), MEDIA_LOAD_DATA, new IOException("test msg"), /* wasCanceled= */ true); diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/video/HevcSeiUtilTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/video/HevcSeiUtilTest.java new file mode 100644 index 00000000000..eca05f31aaa --- /dev/null +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/video/HevcSeiUtilTest.java @@ -0,0 +1,127 @@ +/* + * Copyright 2026 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 androidx.media3.exoplayer.video; + +import static com.google.common.truth.Truth.assertThat; + +import androidx.media3.test.utils.ImmutableByteArray; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import java.nio.ByteBuffer; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** Tests for {@link HevcSeiUtil}. */ +@RunWith(AndroidJUnit4.class) +public final class HevcSeiUtilTest { + + private static final ImmutableByteArray SEI_NAL_UNIT_HDR10_PLUS = + ImmutableByteArray.ofUnsigned( + 0x00, 0x00, 0x00, 0x01, // NAL start code + 0x4E, 0x01, // NAL Header (type 39) + 0x04, // payloadType: 4 (T.35) + 0x13, // payloadSize: 19 + 0xB5, 0x00, 0x3C, 0x00, 0x01, 0x04, 0x00, // HDR10+ header + 0x00, 0x00, 0x03, 0x00, // Emulation prevention byte (0x03) + 0x00, 0x00, 0x03, 0x01, // Emulation prevention byte (0x03) + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06); // Some payload bytes + + private static final ImmutableByteArray SEI_NAL_UNIT_MULTIPLE_MESSAGES = + ImmutableByteArray.ofUnsigned( + 0x00, + 0x00, + 0x00, + 0x01, // NAL start code + 0x4E, + 0x01, // NAL Header (type 39) + // First message: type 5 (User Data Unregistered), size 4 + 0x05, + 0x04, + 0xAA, + 0xBB, + 0xCC, + 0xDD, + // Second message: type 4 (T.35), size 5 + 0x04, + 0x05, + 0xB5, + 0x00, + 0x3C, + 0x00, + 0x01, + // Third message: type 4 (T.35), size 5 + 0x04, + 0x05, + 0xB5, + 0x00, + 0x3C, + 0x00, + 0x02, + 0x80); // rbsp_trailing_bits + + private static final ImmutableByteArray SEI_NAL_UNIT_EMULATION_IN_SIZE = + ImmutableByteArray.ofUnsigned( + 0x00, 0x00, 0x00, 0x01, // NAL start code + 0x4E, 0x01, // NAL Header (type 39) + 0x04, // payloadType: 4 (T.35) + 0x00, 0x00, 0x03, 0xFF, // payloadSize: 255 (with emulation prevention byte) + 0x80); // rbsp_trailing_bits + + @Test + public void stripAllT35Metadata_rewritesT35PayloadTypeToUnspecified() { + ByteBuffer buffer = ByteBuffer.wrap(SEI_NAL_UNIT_HDR10_PLUS.toArray()); + int originalPosition = buffer.position(); + int originalLimit = buffer.limit(); + + ByteBuffer expectedBuffer = ByteBuffer.wrap(SEI_NAL_UNIT_HDR10_PLUS.toArray()); + expectedBuffer.put( + 6, (byte) HevcSeiUtil.SEI_PAYLOAD_TYPE_UNSPECIFIED); // Change payloadType from 4 + + HevcSeiUtil.stripAllT35Metadata(buffer); + + assertThat(buffer.position()).isEqualTo(originalPosition); + assertThat(buffer.limit()).isEqualTo(originalLimit); + assertThat(buffer.array()).isEqualTo(expectedBuffer.array()); + } + + @Test + public void stripAllT35Metadata_multipleMessages_rewritesOnlyT35() { + ByteBuffer buffer = ByteBuffer.wrap(SEI_NAL_UNIT_MULTIPLE_MESSAGES.toArray()); + + ByteBuffer expectedBuffer = ByteBuffer.wrap(SEI_NAL_UNIT_MULTIPLE_MESSAGES.toArray()); + // Offset 6 is first message type (5), stays 5 + // Offset 12 is second message type (4) + expectedBuffer.put(12, (byte) HevcSeiUtil.SEI_PAYLOAD_TYPE_UNSPECIFIED); + // Offset 19 is third message type (4) + expectedBuffer.put(19, (byte) HevcSeiUtil.SEI_PAYLOAD_TYPE_UNSPECIFIED); + + HevcSeiUtil.stripAllT35Metadata(buffer); + + assertThat(buffer.array()).isEqualTo(expectedBuffer.array()); + } + + @Test + public void stripAllT35Metadata_handlesEmulationPreventionInSize() { + ByteBuffer buffer = ByteBuffer.wrap(SEI_NAL_UNIT_EMULATION_IN_SIZE.toArray()); + + ByteBuffer expectedBuffer = ByteBuffer.wrap(SEI_NAL_UNIT_EMULATION_IN_SIZE.toArray()); + // Offset 6 is payload type (4) + expectedBuffer.put(6, (byte) HevcSeiUtil.SEI_PAYLOAD_TYPE_UNSPECIFIED); + + HevcSeiUtil.stripAllT35Metadata(buffer); + + assertThat(buffer.array()).isEqualTo(expectedBuffer.array()); + } +} diff --git a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/video/MediaCodecVideoRendererTest.java b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/video/MediaCodecVideoRendererTest.java index 41079cc7a23..91864e106e3 100644 --- a/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/video/MediaCodecVideoRendererTest.java +++ b/libraries/exoplayer/src/test/java/androidx/media3/exoplayer/video/MediaCodecVideoRendererTest.java @@ -74,6 +74,7 @@ import androidx.media3.common.TrackGroup; import androidx.media3.common.VideoSize; import androidx.media3.common.util.Clock; +import androidx.media3.common.util.ThrowingRunnable; import androidx.media3.decoder.DecoderInputBuffer; import androidx.media3.exoplayer.CodecParameters; import androidx.media3.exoplayer.DecoderCounters; @@ -125,6 +126,7 @@ import java.util.List; import java.util.PriorityQueue; import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicReference; import java.util.stream.Collectors; import org.junit.After; import org.junit.Before; @@ -3991,6 +3993,103 @@ public void render_afterSeekToEoSWithFlushingAndDecodeOnlyFlagDisabled_rendersFr assertThat(argumentDecoderCounters.getValue().renderedOutputBufferCount).isEqualTo(6); } + @Test + @Config(minSdk = 34) + public void render_afterSeekWithFlushingDisabled_dropsStalePreSeekFrames() throws Exception { + AtomicReference adapter = new AtomicReference<>(); + MediaCodecAdapter.Factory customCodecAdapterFactory = + configuration -> { + MediaCodecAdapter mediaCodecAdapter = codecAdapterFactory.createAdapter(configuration); + StaleFrameTestingMediaCodecAdapter staleFrameTestingMediaCodecAdapter = + new StaleFrameTestingMediaCodecAdapter(mediaCodecAdapter); + adapter.set(staleFrameTestingMediaCodecAdapter); + return staleFrameTestingMediaCodecAdapter; + }; + mediaCodecVideoRenderer = + new MediaCodecVideoRenderer( + new MediaCodecVideoRenderer.Builder(ApplicationProvider.getApplicationContext()) + .setCodecAdapterFactory(customCodecAdapterFactory) + .setMediaCodecSelector(mediaCodecSelector) + .setAllowedJoiningTimeMs(0) + .setEnableDecoderFallback(false) + .setEventHandler(new Handler(testMainLooper)) + .setEventListener(eventListener) + .setMaxDroppedFramesToNotify(1)) { + @Override + protected @Capabilities int supportsFormat( + MediaCodecSelector mediaCodecSelector, Format format) { + return RendererCapabilities.create(C.FORMAT_HANDLED); + } + }; + FakeTimeline fakeTimeline = + new FakeTimeline( + new FakeTimeline.TimelineWindowDefinition.Builder().setDurationUs(1_000_000).build()); + mediaCodecVideoRenderer.init(/* index= */ 0, PlayerId.UNSET, Clock.DEFAULT); + mediaCodecVideoRenderer.handleMessage(Renderer.MSG_SET_VIDEO_OUTPUT, surface); + mediaCodecVideoRenderer.setTimeline(fakeTimeline); + FakeSampleStream fakeSampleStream1 = + createFakeSampleStream( + VIDEO_H264, + ImmutableList.of( + oneByteSample(/* timeUs= */ 10_000, C.BUFFER_FLAG_KEY_FRAME), + oneByteSample(/* timeUs= */ 20_000), + oneByteSample(/* timeUs= */ 30_000), // largestQueued = 30,000 + oneByteSample(/* timeUs= */ 40_000), + oneByteSample(/* timeUs= */ 50_000))); + mediaCodecVideoRenderer.enable( + RendererConfiguration.DEFAULT, + new Format[] {VIDEO_H264}, + fakeSampleStream1, + /* positionUs= */ 0, + /* joining= */ false, + /* mayRenderStartOfStream= */ true, + /* startPositionUs= */ 0, + /* offsetUs= */ 0, + new MediaSource.MediaPeriodId(fakeTimeline.getUidOfPeriod(0))); + shadowOf(testMainLooper).idle(); + ArgumentCaptor argumentDecoderCounters = + ArgumentCaptor.forClass(DecoderCounters.class); + verify(eventListener).onVideoEnabled(argumentDecoderCounters.capture()); + DecoderCounters decoderCounters = argumentDecoderCounters.getValue(); + mediaCodecVideoRenderer.start(); + + // Render once to populate a few input buffers. + mediaCodecVideoRenderer.render(0, SystemClock.elapsedRealtime() * 1000); + // Output the format change, followed by the first frame. + adapter.get().allowFormatChange = true; + mediaCodecVideoRenderer.render(0, SystemClock.elapsedRealtime() * 1000); + adapter.get().allowFirstFrameOutput = true; + mediaCodecVideoRenderer.render(0, SystemClock.elapsedRealtime() * 1000); + assertThat(decoderCounters.renderedOutputBufferCount).isEqualTo(1); + + ScrubbingModeParameters scrubbingModeParameters = + new ScrubbingModeParameters.Builder().setAllowSkippingMediaCodecFlush(true).build(); + mediaCodecVideoRenderer.handleMessage(Renderer.MSG_SET_SCRUBBING_MODE, scrubbingModeParameters); + seekToUs( + mediaCodecVideoRenderer, scrubbingModeParameters, fakeSampleStream1, /* positionUs= */ 0); + + FakeSampleStream fakeSampleStream2 = + createFakeSampleStream( + VIDEO_H264, + ImmutableList.of( + oneByteSample(/* timeUs= */ 12_800, C.BUFFER_FLAG_KEY_FRAME), END_OF_STREAM_ITEM)); + mediaCodecVideoRenderer.replaceStream( + new Format[] {VIDEO_H264}, + fakeSampleStream2, + /* startPositionUs= */ 0, + /* offsetUs= */ 0, + new MediaSource.MediaPeriodId(fakeTimeline.getUidOfPeriod(0))); + adapter.get().availableInputBufferCount = 1; + // Render to queue the new 12,800 frame and calculate the offset. + mediaCodecVideoRenderer.render(0, SystemClock.elapsedRealtime() * 1000); + // Force the adapter to output the STALE frame. + adapter.get().allowStaleFrameOutput = true; + mediaCodecVideoRenderer.render(0, SystemClock.elapsedRealtime() * 1000); + + assertThat(decoderCounters.renderedOutputBufferCount).isEqualTo(1); + assertThat(decoderCounters.skippedOutputBufferCount).isEqualTo(1); + } + @Test public void render_afterSeekWithSkipKeyFrameResetAndDecodeOnlyFlagDisabled_rendersFramesAsExpected() @@ -7668,4 +7767,91 @@ public void flush() { pendingBufferCount = 0; } } + + /** + * A custom MediaCodecAdapter that bypasses 1-in 1-out limitations and allows precise, manual + * dispatching of output buffers for testing stale frame boundaries. + */ + private static class StaleFrameTestingMediaCodecAdapter extends ForwardingMediaCodecAdapter { + + private boolean allowFormatChange = false; + private boolean allowFirstFrameOutput = false; + private boolean allowStaleFrameOutput = false; + private int availableInputBufferCount = 4; + private int inputBufferIndexCounter = 0; + private final MediaFormat mediaFormat = new MediaFormat(); + private final ByteBuffer buffer = ByteBuffer.allocate(1024); + + private StaleFrameTestingMediaCodecAdapter(MediaCodecAdapter delegate) { + super(delegate); + mediaFormat.setInteger(MediaFormat.KEY_WIDTH, 1920); + mediaFormat.setInteger(MediaFormat.KEY_HEIGHT, 1080); + } + + @Override + public void useBuffer(ThrowingRunnable runnable) throws E { + runnable.run(); + } + + @Override + public int dequeueInputBufferIndex() { + if (availableInputBufferCount > 0) { + availableInputBufferCount--; + return inputBufferIndexCounter++; + } + return MediaCodec.INFO_TRY_AGAIN_LATER; + } + + @Override + public int dequeueOutputBufferIndex(MediaCodec.BufferInfo bufferInfo) { + if (allowFormatChange) { + allowFormatChange = false; + return MediaCodec.INFO_OUTPUT_FORMAT_CHANGED; + } + if (allowFirstFrameOutput) { + allowFirstFrameOutput = false; + bufferInfo.set(0, 100, 10_000L, 0); + return 0; + } + if (allowStaleFrameOutput) { + allowStaleFrameOutput = false; + bufferInfo.set(0, 100, 30_000L, 0); + return 0; + } + return MediaCodec.INFO_TRY_AGAIN_LATER; + } + + @Override + public MediaFormat getOutputFormat() { + return mediaFormat; + } + + @Nullable + @Override + public ByteBuffer getInputBuffer(int index) { + return buffer; + } + + @Nullable + @Override + public ByteBuffer getOutputBuffer(int index) { + return buffer; + } + + @Override + public void queueInputBuffer( + int index, int offset, int size, long presentationTimeUs, int flags) { + // No-op: prevent Robolectric's strict state checks from crashing on fake indices + } + + @Override + public void releaseOutputBuffer(int index, boolean render) { + // No-op + } + + @Override + public void releaseOutputBuffer(int index, long renderTimeStampNs) { + // No-op + } + } } diff --git a/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DashMediaPeriod.java b/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DashMediaPeriod.java index 21d17a23e99..aa7c61993e8 100644 --- a/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DashMediaPeriod.java +++ b/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DashMediaPeriod.java @@ -970,22 +970,22 @@ private ChunkSampleStream buildSampleStream( } private static long getFirstChunkStartTimeUs( - long positionsUs, DashManifest manifest, int periodIndex, int[] adaptationSetIndices) { - // Use the first representation as all representations in one adaptation set (or in grouped - // adaptation sets) need to be segment-aligned. - Representation representation = - manifest - .getPeriod(periodIndex) - .adaptationSets - .get(adaptationSetIndices[0]) - .representations - .get(0); - @Nullable DashSegmentIndex segmentIndex = representation.getIndex(); - if (segmentIndex == null) { - return C.TIME_UNSET; - } + long positionUs, DashManifest manifest, int periodIndex, int[] adaptationSetIndices) { long periodDurationUs = manifest.getPeriodDurationUs(periodIndex); - return segmentIndex.getTimeUs(segmentIndex.getSegmentNum(positionsUs, periodDurationUs)); + List adaptationSets = manifest.getPeriod(periodIndex).adaptationSets; + // Use the first non-empty representation, as all representations in one adaptation set (or in + // grouped adaptation sets) need to be segment-aligned. + for (int i = 0; i < adaptationSetIndices.length; i++) { + int adaptationSetIndex = adaptationSetIndices[i]; + List representations = adaptationSets.get(adaptationSetIndex).representations; + for (int j = 0; j < representations.size(); j++) { + @Nullable DashSegmentIndex segmentIndex = representations.get(j).getIndex(); + if (segmentIndex != null && segmentIndex.getSegmentCount(periodDurationUs) != 0) { + return segmentIndex.getTimeUs(segmentIndex.getSegmentNum(positionUs, periodDurationUs)); + } + } + } + return C.TIME_UNSET; } private static boolean areAllSamplesSyncSamples( diff --git a/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DashMediaSource.java b/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DashMediaSource.java index 0a4f59524dc..621ed30896e 100644 --- a/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DashMediaSource.java +++ b/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DashMediaSource.java @@ -697,31 +697,27 @@ protected void releaseSourceInternal() { long elapsedRealtimeMs, long loadDurationMs, int retryCount) { - LoadEventInfo loadEventInfo = - retryCount == 0 - ? new LoadEventInfo(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) - : new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); - manifestEventDispatcher.loadStarted(loadEventInfo, loadable.type, retryCount); + LoadEventInfo.Builder loadEventInfo = + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs); + if (retryCount != 0) { + loadEventInfo + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()); + } + manifestEventDispatcher.loadStarted(loadEventInfo.build(), loadable.type, retryCount); } /* package */ void onManifestLoadCompleted( ParsingLoadable loadable, long elapsedRealtimeMs, long loadDurationMs) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); manifestEventDispatcher.loadCompleted(loadEventInfo, loadable.type); DashManifest newManifest = loadable.getResult(); @@ -824,14 +820,12 @@ protected void releaseSourceInternal() { IOException error, int errorCount) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); MediaLoadData mediaLoadData = new MediaLoadData(loadable.type); LoadErrorInfo loadErrorInfo = new LoadErrorInfo(loadEventInfo, mediaLoadData, error, errorCount); @@ -907,14 +901,12 @@ protected void releaseSourceInternal() { /* package */ void onUtcTimestampLoadCompleted( ParsingLoadable loadable, long elapsedRealtimeMs, long loadDurationMs) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); manifestEventDispatcher.loadCompleted(loadEventInfo, loadable.type); onUtcTimestampResolved(loadable.getResult() - elapsedRealtimeMs); @@ -926,14 +918,12 @@ protected void releaseSourceInternal() { long loadDurationMs, IOException error) { manifestEventDispatcher.loadError( - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()), + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(), loadable.type, error, /* wasCanceled= */ true); @@ -945,14 +935,12 @@ protected void releaseSourceInternal() { /* package */ void onLoadCanceled( ParsingLoadable loadable, long elapsedRealtimeMs, long loadDurationMs) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); manifestEventDispatcher.loadCanceled(loadEventInfo, loadable.type); } diff --git a/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DefaultDashChunkSource.java b/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DefaultDashChunkSource.java index 46cea070e54..a8ca990c106 100644 --- a/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DefaultDashChunkSource.java +++ b/libraries/exoplayer_dash/src/main/java/androidx/media3/exoplayer/dash/DefaultDashChunkSource.java @@ -869,10 +869,10 @@ protected Chunk newMediaChunk( CmcdData cmcdData = cmcdDataFactory.createCmcdData(); dataSpec = cmcdData.addToDataSpec(dataSpec); } - long sampleOffsetUs = -representation.presentationTimeOffsetUs; - if (MimeTypes.isImage(trackFormat.sampleMimeType)) { - sampleOffsetUs += startTimeUs; - } + long sampleOffsetUs = + MimeTypes.isImage(trackFormat.sampleMimeType) + ? startTimeUs + : -representation.presentationTimeOffsetUs; return new ContainerMediaChunk( dataSource, dataSpec, @@ -1011,19 +1011,12 @@ protected static final class RepresentationHolder { @Nullable DashSegmentIndex oldIndex = representation.getIndex(); @Nullable DashSegmentIndex newIndex = newRepresentation.getIndex(); - if (oldIndex == null) { - // Segment numbers cannot shift if the index isn't defined by the manifest. - return new RepresentationHolder( - newPeriodDurationUs, - newRepresentation, - selectedBaseUrl, - chunkExtractor, - segmentNumShift, - oldIndex); - } - - if (!oldIndex.isExplicit()) { - // Segment numbers cannot shift if the index isn't explicit. + if (oldIndex == null + || newIndex == null + || !oldIndex.isExplicit() + || oldIndex.getSegmentCount(newPeriodDurationUs) == 0 + || newIndex.getSegmentCount(newPeriodDurationUs) == 0) { + // Segment numbers cannot shift if an index is missing, non-explicit, or empty. return new RepresentationHolder( newPeriodDurationUs, newRepresentation, @@ -1034,19 +1027,6 @@ protected static final class RepresentationHolder { } long oldIndexSegmentCount = oldIndex.getSegmentCount(newPeriodDurationUs); - if (oldIndexSegmentCount == 0) { - // Segment numbers cannot shift if the old index was empty. - return new RepresentationHolder( - newPeriodDurationUs, - newRepresentation, - selectedBaseUrl, - chunkExtractor, - segmentNumShift, - newIndex); - } - - checkNotNull(newIndex); - long oldIndexFirstSegmentNum = oldIndex.getFirstSegmentNum(); long oldIndexStartTimeUs = oldIndex.getTimeUs(oldIndexFirstSegmentNum); long oldIndexLastSegmentNum = oldIndexFirstSegmentNum + oldIndexSegmentCount - 1; diff --git a/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DashMediaPeriodTest.java b/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DashMediaPeriodTest.java index 83c1d450353..39ea8f62850 100644 --- a/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DashMediaPeriodTest.java +++ b/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DashMediaPeriodTest.java @@ -361,6 +361,25 @@ public void buildSampleStream_enclosesAllClosedCaptions() throws IOException { .inOrder(); } + @Test + public void selectTracks_withEmptySegmentTimeline_doesNotCrash() throws IOException { + DashManifest manifest = parseManifest("media/dash/empty-segment-timeline/sample.mpd"); + DashMediaPeriod dashMediaPeriod = createDashMediaPeriod(manifest, /* periodIndex= */ 0); + ExoTrackSelection trackSelection = + new FixedTrackSelection(dashMediaPeriod.getTrackGroups().get(0), /* track= */ 0); + SampleStream[] sampleStreams = new SampleStream[1]; + + long unused = + dashMediaPeriod.selectTracks( + new ExoTrackSelection[] {trackSelection}, + new boolean[1], + sampleStreams, + new boolean[1], + /* positionUs= */ 0L); + + assertThat(sampleStreams[0]).isNotNull(); + } + private static DashMediaPeriod createDashMediaPeriod(DashManifest manifest, int periodIndex) { return createDashMediaPeriod(manifest, mock(DashChunkSource.Factory.class), periodIndex); } diff --git a/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DashPreloadMediaSourceTest.java b/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DashPreloadMediaSourceTest.java index 6a862e47972..4be67bb044b 100644 --- a/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DashPreloadMediaSourceTest.java +++ b/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DashPreloadMediaSourceTest.java @@ -128,7 +128,7 @@ public void preload_loadPeriodToTargetPreloadPosition() throws Exception { }); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -164,7 +164,7 @@ public void preload_stopWhenTracksSelectedByPreloadControl() throws Exception { }); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -200,7 +200,7 @@ public void preload_stopWhenSourcePreparedByPreloadControl() throws Exception { }); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -237,7 +237,7 @@ public void preload_loadToTheEndOfSource() throws Exception { .onLoadedToTheEndOfSource(any()); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -277,7 +277,7 @@ public void preload_withSmallTargetBufferBytesThreshold_onLoadingUnableToContinu .onLoadedToTheEndOfSource(any()); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); LoadControl loadControl = mock( LoadControl.class, diff --git a/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DefaultDashChunkSourceTest.java b/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DefaultDashChunkSourceTest.java index a45a7826cd4..61ade2e0ec8 100644 --- a/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DefaultDashChunkSourceTest.java +++ b/libraries/exoplayer_dash/src/test/java/androidx/media3/exoplayer/dash/DefaultDashChunkSourceTest.java @@ -19,6 +19,7 @@ import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.UTF_8; import android.net.Uri; import android.os.SystemClock; @@ -36,6 +37,9 @@ import androidx.media3.exoplayer.dash.manifest.DashManifestParser; import androidx.media3.exoplayer.source.LoadEventInfo; import androidx.media3.exoplayer.source.MediaLoadData; +import androidx.media3.exoplayer.source.SampleQueue; +import androidx.media3.exoplayer.source.chunk.BaseMediaChunk; +import androidx.media3.exoplayer.source.chunk.BaseMediaChunkOutput; import androidx.media3.exoplayer.source.chunk.BundledChunkExtractor; import androidx.media3.exoplayer.source.chunk.Chunk; import androidx.media3.exoplayer.source.chunk.ChunkHolder; @@ -43,10 +47,12 @@ import androidx.media3.exoplayer.trackselection.AdaptiveTrackSelection; import androidx.media3.exoplayer.trackselection.FixedTrackSelection; import androidx.media3.exoplayer.upstream.CmcdConfiguration; +import androidx.media3.exoplayer.upstream.DefaultAllocator; import androidx.media3.exoplayer.upstream.DefaultBandwidthMeter; import androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicy; import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy; import androidx.media3.exoplayer.upstream.LoaderErrorThrower; +import androidx.media3.test.utils.FakeDataSet; import androidx.media3.test.utils.FakeDataSource; import androidx.media3.test.utils.TestUtil; import androidx.test.core.app.ApplicationProvider; @@ -54,6 +60,7 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableListMultimap; import com.google.common.collect.ImmutableMap; +import java.io.ByteArrayInputStream; import java.io.IOException; import java.time.Duration; import java.util.ArrayList; @@ -636,6 +643,52 @@ public void getNextChunk_atEndOfLiveManifestWithKnownDuration_returnsEndOfStream assertThat(output.endOfStream).isTrue(); } + @Test + public void updateManifest_representationWithZeroSegments_doesNotThrow() throws Exception { + DashManifestParser parser = new DashManifestParser(); + DashManifest emptyManifest = + parser.parse( + Uri.EMPTY, + TestUtil.getInputStream( + ApplicationProvider.getApplicationContext(), + "media/dash/empty-segment-timeline/sample.mpd")); + DashManifest nonEmptyManifest = + parser.parse( + Uri.EMPTY, + TestUtil.getInputStream( + ApplicationProvider.getApplicationContext(), "media/dash/multi-track/sample.mpd")); + + DefaultDashChunkSource chunkSource = + new DefaultDashChunkSource( + new BundledChunkExtractor.Factory(), + new LoaderErrorThrower.Placeholder(), + emptyManifest, + new BaseUrlExclusionList(), + /* periodIndex= */ 0, + /* adaptationSetIndices= */ new int[] {0}, + new FixedTrackSelection( + new TrackGroup( + emptyManifest.getPeriod(0).adaptationSets.get(0).representations.get(0).format), + /* track= */ 0), + C.TRACK_TYPE_VIDEO, + new FakeDataSource(), + /* elapsedRealtimeOffsetMs= */ 0, + /* maxSegmentsPerLoad= */ 1, + /* enableEventMessageTrack= */ false, + /* closedCaptionFormats= */ ImmutableList.of(), + /* playerTrackEmsgHandler= */ null, + PlayerId.UNSET, + /* cmcdConfiguration= */ null); + + // Update from empty to non-empty manifest. + chunkSource.updateManifest(nonEmptyManifest, /* newPeriodIndex= */ 0); + chunkSource.maybeThrowError(); + + // Update from non-empty to empty manifest. + chunkSource.updateManifest(emptyManifest, /* newPeriodIndex= */ 0); + chunkSource.maybeThrowError(); + } + private DashChunkSource createDashChunkSource( int numberOfTracks, @Nullable CmcdConfiguration cmcdConfiguration) throws IOException { checkArgument(numberOfTracks < 6); @@ -686,7 +739,8 @@ private DashChunkSource createDashChunkSource( private LoadErrorHandlingPolicy.LoadErrorInfo createFakeLoadErrorInfo( DataSpec dataSpec, int httpResponseCode, int errorCount) { LoadEventInfo loadEventInfo = - new LoadEventInfo(/* loadTaskId= */ 0, dataSpec, SystemClock.elapsedRealtime()); + new LoadEventInfo.Builder(/* loadTaskId= */ 0, dataSpec, SystemClock.elapsedRealtime()) + .build(); MediaLoadData mediaLoadData = new MediaLoadData(C.DATA_TYPE_MEDIA); HttpDataSource.InvalidResponseCodeException invalidResponseCodeException = new HttpDataSource.InvalidResponseCodeException( @@ -699,4 +753,72 @@ private LoadErrorHandlingPolicy.LoadErrorInfo createFakeLoadErrorInfo( return new LoadErrorHandlingPolicy.LoadErrorInfo( loadEventInfo, mediaLoadData, invalidResponseCodeException, errorCount); } + + @Test + public void getNextChunk_imageTrackWithPresentationTimeOffset_setsCorrectSampleOffsetUs() + throws Exception { + String mpdXml = + "\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + " \n" + + ""; + DashManifest manifest = + new DashManifestParser() + .parse( + Uri.parse("https://example.com/test.mpd"), + new ByteArrayInputStream(mpdXml.getBytes(UTF_8))); + FakeDataSet fakeDataSet = + new FakeDataSet() + .newData("https://example.com/thumb_50000000.jpg") + .appendReadData(new byte[] {(byte) 0xFF, (byte) 0xD8, (byte) 0xFF, (byte) 0xE0}) + .endData(); + FakeDataSource fakeDataSource = new FakeDataSource(fakeDataSet); + Format trackFormat = manifest.getPeriod(0).adaptationSets.get(0).representations.get(0).format; + DefaultDashChunkSource chunkSource = + new DefaultDashChunkSource( + new BundledChunkExtractor.Factory(), + new LoaderErrorThrower.Placeholder(), + manifest, + new BaseUrlExclusionList(), + /* periodIndex= */ 0, + /* adaptationSetIndices= */ new int[] {0}, + new FixedTrackSelection(new TrackGroup(trackFormat), /* track= */ 0), + C.TRACK_TYPE_IMAGE, + fakeDataSource, + /* elapsedRealtimeOffsetMs= */ 0, + /* maxSegmentsPerLoad= */ 1, + /* enableEventMessageTrack= */ false, + /* closedCaptionFormats= */ ImmutableList.of(), + /* playerTrackEmsgHandler= */ null, + PlayerId.UNSET, + /* cmcdConfiguration= */ null); + ChunkHolder output = new ChunkHolder(); + + chunkSource.getNextChunk( + new LoadingInfo.Builder().setPlaybackPositionUs(0).build(), + /* loadPositionUs= */ 0, + /* queue= */ ImmutableList.of(), + output); + BaseMediaChunk mediaChunk = (BaseMediaChunk) output.chunk; + SampleQueue sampleQueue = + SampleQueue.createWithoutDrm( + new DefaultAllocator(/* trimOnReset= */ true, C.DEFAULT_BUFFER_SEGMENT_SIZE)); + BaseMediaChunkOutput chunkOutput = + new BaseMediaChunkOutput(new int[] {C.TRACK_TYPE_IMAGE}, new SampleQueue[] {sampleQueue}); + mediaChunk.init(chunkOutput); + mediaChunk.load(); + + assertThat(sampleQueue.getLargestQueuedTimestampUs()).isEqualTo(0); + } } diff --git a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsChunkSource.java b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsChunkSource.java index 2d8d5395469..2f7d13daf23 100644 --- a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsChunkSource.java +++ b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsChunkSource.java @@ -475,6 +475,11 @@ public void getNextChunk( int selectedTrackIndex = trackSelection.getSelectedIndexInTrackGroup(); boolean switchingTrack = oldTrackIndex != selectedTrackIndex; Uri selectedPlaylistUrl = redundantGroups[selectedTrackIndex].getCurrentPlaylistUrl(); + @Nullable + String pathwayIdForSelectedPlaylistUrl = + contentSteeringTracker != null && contentSteeringTracker.isActive() + ? redundantGroups[selectedTrackIndex].getCurrentPathwayId() + : null; if (!playlistTracker.isSnapshotValid(selectedPlaylistUrl)) { out.playlistUrl = selectedPlaylistUrl; nextChunkStuckOnPlaylistUrl = selectedPlaylistUrl; @@ -645,6 +650,7 @@ public void getNextChunk( playlist, segmentBaseHolder, selectedPlaylistUrl, + pathwayIdForSelectedPlaylistUrl, muxedCaptionFormats, trackSelection.getSelectionReason(), trackSelection.getSelectionData(), @@ -1012,6 +1018,11 @@ public FallbackOptions createFallbackOptions(Chunk chunk) { contentSteeringActive); } + /** Returns the redundant groups for this chunk source. */ + public ImmutableList getRedundantGroups() { + return ImmutableList.copyOf(redundantGroups); + } + // Private methods. /** diff --git a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsInterstitialsAdsLoader.java b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsInterstitialsAdsLoader.java index 7377dd2d9b9..4c3715edacb 100644 --- a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsInterstitialsAdsLoader.java +++ b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsInterstitialsAdsLoader.java @@ -42,7 +42,6 @@ import static com.google.common.util.concurrent.MoreExecutors.directExecutor; import static java.lang.Math.abs; import static java.lang.Math.max; -import static java.lang.Math.min; import android.content.Context; import android.net.Uri; @@ -88,7 +87,6 @@ import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy; import androidx.media3.exoplayer.upstream.Loader; import androidx.media3.exoplayer.upstream.ParsingLoadable; -import com.google.common.base.Preconditions; import com.google.common.collect.ImmutableList; import com.google.common.util.concurrent.ListenableFuture; import com.google.errorprone.annotations.CanIgnoreReturnValue; @@ -97,8 +95,10 @@ import java.util.Collection; import java.util.HashMap; import java.util.HashSet; +import java.util.Iterator; import java.util.List; import java.util.Map; +import java.util.NavigableMap; import java.util.Objects; import java.util.Set; import java.util.TreeMap; @@ -954,6 +954,7 @@ private boolean setWithAssetListReset( /* adIndexInAdGroup= */ 0, adGroup.timeUs, checkNotNull(lastProcessedPlaylist).targetDurationUs); + session.removeAssetListDurations(interstitial.id); putAndNotifyAdPlaybackStateUpdate(session.adsId, adPlaybackState); AdsConfiguration currentAdsConfiguration = @@ -1238,6 +1239,7 @@ public boolean handleContentTimelineChanged(AdsMediaSource adsMediaSource, Timel Window window = timeline.getWindow(0, new Window()); if (window.manifest instanceof HlsManifest) { HlsMediaPlaylist mediaPlaylist = ((HlsManifest) window.manifest).mediaPlaylist; + session.lastProcessedPlaylist = mediaPlaylist; int assetListCount = session.unresolvedAssetLists.size(); adPlaybackState = window.isLive() @@ -1284,7 +1286,6 @@ public boolean handleContentTimelineChanged(AdsMediaSource adsMediaSource, Timel maybeExecuteOrSetNextAssetListResolutionMessage( adsId, timeline, /* windowIndex= */ 0, publicPositionInFirstPeriod, contentPositionUs); } - session.lastProcessedPlaylist = mediaPlaylist; } boolean adPlaybackStateUpdated = putAndNotifyAdPlaybackStateUpdate(adsId, adPlaybackState); if (!adsMediaSourceSessionManager.isUnsupportedContentMediaSource(adsId)) { @@ -1651,35 +1652,43 @@ private AdPlaybackState mapInterstitialsForLive( private AdPlaybackState maybeResolvePendingSnapInResolutions( AdPlaybackState adPlaybackState, HlsMediaPlaylist mediaPlaylist, HlsAdSession session) { long endOfPlaylistUs = mediaPlaylist.startTimeUs + mediaPlaylist.durationUs; - List pendingSnapInResolutions = session.pendingSnapInResolutions; - int resolvedIndex = C.INDEX_UNSET; - for (int i = 0; i < pendingSnapInResolutions.size(); i++) { - PendingSnapInResolution pendingSnapInResolution = pendingSnapInResolutions.get(i); - if (pendingSnapInResolution.resumeTimeUs > endOfPlaylistUs) { - break; - } - Interstitial interstitial = pendingSnapInResolution.interstitial; - // Resolve the resume offset according to the snap position of the segement start - long resolvedResumeOffsetUs = resolveInterstitialResumeOffsetUs(interstitial, mediaPlaylist); - AdGroup adGroup = adPlaybackState.getAdGroup(pendingSnapInResolution.adGroupIndex); - long interstitialDurationUs = - resolveInterstitialDurationUs(interstitial, /* defaultDurationUs= */ C.TIME_UNSET); - // The content resume offset that was used before resolving the actuals offset. - long oldResumeOffsetIncrementUs = - interstitial.resumeOffsetUs != C.TIME_UNSET - ? interstitial.resumeOffsetUs - : (interstitialDurationUs != C.TIME_UNSET ? interstitialDurationUs : 0L); - // Recalculate the resume offset of the group in case the interstitial offset has changed. - long correctedAdGroupContentResumeOffsetUs = - adGroup.contentResumeOffsetUs - oldResumeOffsetIncrementUs + resolvedResumeOffsetUs; - adPlaybackState = - adPlaybackState.withContentResumeOffsetUs( - pendingSnapInResolution.adGroupIndex, correctedAdGroupContentResumeOffsetUs); - resolvedIndex++; + NavigableMap headMap = + session.pendingSnapInResolutions.headMap(endOfPlaylistUs, /* inclusive= */ true); + if (headMap.isEmpty()) { + return adPlaybackState; } - if (resolvedIndex != C.INDEX_UNSET) { - // Remove resolved interstitials from the list of pending resolutions. - session.removePendingSnapInResolutionUntilIndexInclusive(resolvedIndex); + Iterator> iterator = headMap.entrySet().iterator(); + while (iterator.hasNext()) { + Map.Entry entry = iterator.next(); + PendingSnapInResolution pendingSnapInResolution = entry.getValue(); + // The head map is expected to have very few entries only. No need to care about the + // overhead here. + Interstitial interstitial = + getInterstitialById(mediaPlaylist, pendingSnapInResolution.interstitialId); + if (interstitial != null) { + // Once the asset list durations are set, we use these instead of what's in the playlist. + long adDurationsUs = session.getSumOfAssetListDurationsUs(interstitial.id); + if (adDurationsUs == C.TIME_UNSET) { + adDurationsUs = resolveInterstitialDurationUs(interstitial, /* defaultDurationUs= */ 0); + } + // Resolve the resume offset according to the snap position of the segment start. + long resolvedResumeOffsetUs = + resolveInterstitialResumeOffsetUs( + interstitial, /* defaultDurationUs= */ adDurationsUs, mediaPlaylist); + AdGroup adGroup = adPlaybackState.getAdGroup(pendingSnapInResolution.adGroupIndex); + // The content resume offset that was used before resolving the actual offset. + long oldResumeOffsetIncrementUs = + interstitial.resumeOffsetUs != C.TIME_UNSET + ? interstitial.resumeOffsetUs + : adDurationsUs; + // Recalculate the resume offset of the group in case the interstitial offset has changed. + long correctedAdGroupContentResumeOffsetUs = + adGroup.contentResumeOffsetUs - oldResumeOffsetIncrementUs + resolvedResumeOffsetUs; + adPlaybackState = + adPlaybackState.withContentResumeOffsetUs( + pendingSnapInResolution.adGroupIndex, correctedAdGroupContentResumeOffsetUs); + } + iterator.remove(); } return adPlaybackState; } @@ -1809,20 +1818,9 @@ private AdPlaybackState insertOrUpdateInterstitialInAdGroup( } adDurations[adDurations.length - 1] = interstitial.playoutLimitUs; long resumeOffsetIncrementUs = - interstitial.resumeOffsetUs != C.TIME_UNSET - ? interstitial.resumeOffsetUs - : (interstitialDurationUs != C.TIME_UNSET ? interstitialDurationUs : 0L); - if (interstitial.snapTypes.contains(SNAP_TYPE_IN)) { - long resumeTimeUs = interstitial.startDateUnixUs + resumeOffsetIncrementUs; - if (resumeTimeUs < mediaPlaylist.startTimeUs + mediaPlaylist.durationUs) { - resumeOffsetIncrementUs = resolveInterstitialResumeOffsetUs(interstitial, mediaPlaylist); - } else { - // The segment at which to resume is not yet in the playlist. Deferring offset calculation. - session.pendingSnapInResolutions.add( - new PendingSnapInResolution(resumeTimeUs, adGroupIndex, interstitial)); - } - } - long resumeOffsetUs = adGroup.contentResumeOffsetUs + resumeOffsetIncrementUs; + getResumeOffsetUsOrDeferSnapInResolution( + interstitial, interstitialDurationUs, adGroupIndex, mediaPlaylist, session); + long resumeOffsetUs = max(adGroup.contentResumeOffsetUs, 0) + resumeOffsetIncrementUs; adPlaybackState = adPlaybackState .withAdCount(adGroupIndex, adIndexInAdGroup + 1) @@ -1860,6 +1858,44 @@ private AdPlaybackState insertOrUpdateInterstitialInAdGroup( return adPlaybackState; } + /** + * Returns the content resume offset in microseconds for a given interstitial or defers the + * calculation if the interstitial needs to snap into a segment that is not yet in the playlist. + * + *

    The {@link #maybeResolvePendingSnapInResolutions} method will handle deferred resolutions + * when the timeline updates with a playlist containing the snap-in segment. + * + * @param interstitial The {@link Interstitial}. + * @param interstitialDurationUs The resolved duration of the interstitial or {@link C#TIME_UNSET} + * if unknown. + * @param adGroupIndex The index of the ad group. + * @param mediaPlaylist The current {@link HlsMediaPlaylist}. + * @param session The {@link HlsAdSession}. + * @return The content resume offset in microseconds. + */ + private long getResumeOffsetUsOrDeferSnapInResolution( + Interstitial interstitial, + long interstitialDurationUs, + int adGroupIndex, + HlsMediaPlaylist mediaPlaylist, + HlsAdSession session) { + if (interstitial.resumeOffsetUs != C.TIME_UNSET) { + return interstitial.resumeOffsetUs; + } + long resumeOffsetUs = interstitialDurationUs != C.TIME_UNSET ? interstitialDurationUs : 0L; + if (interstitial.snapTypes.contains(SNAP_TYPE_IN)) { + long resumeTimeUs = interstitial.startDateUnixUs + resumeOffsetUs; + if (resumeTimeUs < mediaPlaylist.startTimeUs + mediaPlaylist.durationUs) { + resumeOffsetUs = + resolveInterstitialResumeOffsetUs(interstitial, interstitialDurationUs, mediaPlaylist); + } else { + // The segment at which to resume is not yet in the playlist. Deferring offset calculation. + session.addPendingSnapInResolution(resumeTimeUs, adGroupIndex, interstitial); + } + } + return resumeOffsetUs; + } + private static int getLowestValidAdGroupInsertionIndex(AdPlaybackState adPlaybackState) { for (int adGroupIndex = adPlaybackState.adGroupCount - 1; adGroupIndex >= adPlaybackState.removedAdGroupCount; @@ -1902,21 +1938,27 @@ private static long resolveInterstitialStartTimeUs( } private static long resolveInterstitialResumeOffsetUs( - Interstitial interstitial, HlsMediaPlaylist mediaPlaylist) { + Interstitial interstitial, long defaultDurationUs, HlsMediaPlaylist mediaPlaylist) { if (interstitial.snapTypes.contains(SNAP_TYPE_IN)) { long resumeOffsetUs = interstitial.resumeOffsetUs != C.TIME_UNSET ? interstitial.resumeOffsetUs - : resolveInterstitialDurationUs(interstitial, /* defaultDurationUs= */ 0L); + : resolveInterstitialDurationUs( + interstitial, + /* defaultDurationUs= */ defaultDurationUs != C.TIME_UNSET + ? defaultDurationUs + : 0L); long startTimeUs = interstitial.snapTypes.contains(SNAP_TYPE_OUT) ? getClosestSegmentBoundaryUs(interstitial.startDateUnixUs, mediaPlaylist) : interstitial.startDateUnixUs; - return getClosestSegmentBoundaryUs(startTimeUs + resumeOffsetUs, mediaPlaylist) - startTimeUs; + return max( + 0L, + getClosestSegmentBoundaryUs(startTimeUs + resumeOffsetUs, mediaPlaylist) - startTimeUs); } else { return interstitial.resumeOffsetUs != C.TIME_UNSET ? interstitial.resumeOffsetUs - : resolveInterstitialDurationUs(interstitial, C.TIME_UNSET); + : resolveInterstitialDurationUs(interstitial, defaultDurationUs); } } @@ -1928,10 +1970,17 @@ private static long resolveInterstitialResumeOffsetUs( if (lastProcessedPlaylist == null) { return null; } - for (int i = 0; i < lastProcessedPlaylist.interstitials.size(); i++) { - if (id.equals(lastProcessedPlaylist.interstitials.get(i).id)) { - Interstitial interstitial = lastProcessedPlaylist.interstitials.get(i); - return interstitial.assetListUri != null ? interstitial : null; + Interstitial interstitial = getInterstitialById(lastProcessedPlaylist, id); + return interstitial != null && interstitial.assetListUri != null ? interstitial : null; + } + + @Nullable + private static Interstitial getInterstitialById( + HlsMediaPlaylist mediaPlaylist, String interstitialId) { + for (int i = 0; i < mediaPlaylist.interstitials.size(); i++) { + Interstitial interstitial = mediaPlaylist.interstitials.get(i); + if (interstitial.id.equals(interstitialId)) { + return interstitial; } } return null; @@ -2157,13 +2206,16 @@ private void markAdAsPlayedAndNotifyListeners( /** A session for each media source that was started to play ads with this ads loader. */ /* package */ static final class HlsAdSession { + @VisibleForTesting /* package */ final TreeMap unresolvedAssetLists; + + @VisibleForTesting + /* package */ final TreeMap pendingSnapInResolutions; + private final Object adsId; private final Set insertedInterstitialIds; private final MediaItem contentMediaItem; @Nullable private final EventListener eventListener; - - @VisibleForTesting /* package */ final TreeMap unresolvedAssetLists; - @VisibleForTesting /* package */ final List pendingSnapInResolutions; + private final Map assetListDurations = new HashMap<>(); private AdPlaybackState adPlaybackState; @Nullable private HlsMediaPlaylist lastProcessedPlaylist; @@ -2176,7 +2228,7 @@ private void markAdAsPlayedAndNotifyListeners( this.eventListener = eventListener; insertedInterstitialIds = new HashSet<>(); unresolvedAssetLists = new TreeMap<>(); - pendingSnapInResolutions = new ArrayList<>(); + pendingSnapInResolutions = new TreeMap<>(); adPlaybackState = AdPlaybackState.NONE; awaitingFirstAdToStart = true; } @@ -2187,12 +2239,6 @@ private void markAdAsPlayedAndNotifyListeners( return entry != null ? entry.getValue() : null; } - /* package */ void removePendingSnapInResolutionUntilIndexInclusive(int resolvedIndex) { - Preconditions.checkArgument(resolvedIndex >= 0); - resolvedIndex = min(resolvedIndex, pendingSnapInResolutions.size() - 1); - pendingSnapInResolutions.subList(0, resolvedIndex + 1).clear(); - } - /* package */ void addUnresolvedAssetList( Interstitial interstitial, int adGroupIndex, @@ -2220,6 +2266,83 @@ private void markAdAsPlayedAndNotifyListeners( adGroupTimeUs == C.TIME_END_OF_SOURCE ? Long.MAX_VALUE : adGroupTimeUs; return unresolvedAssetLists.remove(adGroupInsertionTimeUs); } + + /** + * Sets the durations that resulted from fetching the asset list. + * + *

    Available asset list durations take precedence over the durations that were reported by + * the HLS playlist. + * + * @param interstitialId The {@linkplain Interstitial#id ID of the interstitital}. + * @param durations The durations of the interstitial as declared by the asset list. + */ + private void setAssetListDurations(String interstitialId, long[] durations) { + assetListDurations.put(interstitialId, durations); + } + + /** + * Removes the durations set for a given interstitial ID. + * + *

    This is called if an asset list of a given interstitial is {@link + * #setWithAssetListReset(Object, String) reset by the user}. + * + * @param interstitialId The {@linkplain Interstitial#id ID of the interstitital}. + */ + private void removeAssetListDurations(String interstitialId) { + assetListDurations.remove(interstitialId); + } + + /** + * Returns the sum of the durations that were declared in the asset list after resolving the + * asset, or {link C#TIME_UNSET} if no durations are available. If available, asset list + * durations take precedence over the durations that were reported in the HLS playlist. + * + * @param interstitialId The ID of the interstitial. + * @return The sum of the durations or {@link C#TIME_UNSET} if the asset list has not yet been + * resolved, or the given interstitial is not an asset list interstitial. + */ + private long getSumOfAssetListDurationsUs(String interstitialId) { + long totalDurationUs = 0; + long[] durations = assetListDurations.get(interstitialId); + if (durations == null) { + return C.TIME_UNSET; + } + for (long durationUs : durations) { + totalDurationUs += durationUs; + } + return totalDurationUs; + } + + /** + * Adds a pending snap-in resolution by making sure that there are no duplicates for the same + * interstitial. + * + *

    Note that the same interstitial may have a different {@code resumeTimeUs} when the + * duration is different. This can be the case for the same interstitial when calculating the + * resume time and the duration in the asset list is different than the duration in the + * playlist. + * + * @param resumeTimeUs The estimated resumption time of the interstitials that is used to snap + * to the corresponding nearest segment boundary. + * @param adGroupIndex The index of the ad group. + * @param interstitial The interstitial. + */ + /* package */ void addPendingSnapInResolution( + long resumeTimeUs, int adGroupIndex, Interstitial interstitial) { + PendingSnapInResolution pendingSnapInResolution = + new PendingSnapInResolution(adGroupIndex, interstitial.id); + // Linear iteration is fine to search for duplicates as we expect very few items in the map. + Iterator> iterator = + pendingSnapInResolutions.entrySet().iterator(); + while (iterator.hasNext()) { + Map.Entry entry = iterator.next(); + if (pendingSnapInResolution.equals(entry.getValue())) { + iterator.remove(); + break; + } + } + pendingSnapInResolutions.put(resumeTimeUs, pendingSnapInResolution); + } } /** A manager that manages active sessions of media sources that play ads. */ @@ -2312,14 +2435,16 @@ public void onLoadCompleted( Pair result = checkNotNull(loadable.getResult()); @Nullable AssetList assetList = result.first; HlsAdSession session = adsMediaSourceSessionManager.getSession(assetListData.adsId); - AdPlaybackState adPlaybackState = session != null ? session.adPlaybackState : null; + if (session == null) { + // Stale asset list load finished after session was removed. + return; + } + AdPlaybackState adPlaybackState = session.adPlaybackState; // Get the state of the ad to validate there was no manual change since we started // loading. int assetListAdState = - adPlaybackState != null - ? adPlaybackState.getAdGroup(assetListData.adGroupIndex) - .states[assetListData.adIndexInAdGroup] - : AD_STATE_ERROR; + adPlaybackState.getAdGroup(assetListData.adGroupIndex) + .states[assetListData.adIndexInAdGroup]; if (assetListAdState != AD_STATE_UNAVAILABLE) { // The ad was manipulated manually since the asset loading was started. Ignore asset // list and make sure the next asset list is scheduled for loading (if any). @@ -2353,6 +2478,7 @@ public void onLoadCompleted( adGroup = adPlaybackState.getAdGroup(assetListData.adGroupIndex); } int adIndex = assetListData.adIndexInAdGroup; + long[] assetDurations = new long[assetList.assets.size()]; long[] newDurationsUs = adGroup.durationsUs.clone(); for (int i = 0; i < assetList.assets.size(); i++) { Asset asset = assetList.assets.get(i); @@ -2360,6 +2486,7 @@ public void onLoadCompleted( adIndex = oldAdCount + i - 1; } newDurationsUs[adIndex] = asset.durationUs; + assetDurations[i] = asset.durationUs; sumOfAssetListAdDurationUs += asset.durationUs; MediaItem mediaItem = new MediaItem.Builder() @@ -2377,21 +2504,19 @@ public void onLoadCompleted( assetListData.adGroupIndex, adIndex, assetList.skipInfo); } } + session.setAssetListDurations(assetListData.interstitial.id, assetDurations); adPlaybackState = adPlaybackState.withAdDurationsUs(assetListData.adGroupIndex, newDurationsUs); - if (assetListData.interstitial.resumeOffsetUs == C.TIME_UNSET) { - adGroup = adPlaybackState.getAdGroup(assetListData.adGroupIndex); - long oldAdContentResumeOffset = - resolveInterstitialDurationUs( - assetListData.interstitial, /* defaultDurationUs= */ 0); - long newContentResumeOffsetUs = - adGroup.contentResumeOffsetUs - - oldAdContentResumeOffset - + sumOfAssetListAdDurationUs; - adPlaybackState = - adPlaybackState.withContentResumeOffsetUs( - assetListData.adGroupIndex, newContentResumeOffsetUs); - } + long resumeOffsetUs = + getResumeOffsetUsOrDeferSnapInResolution( + assetListData.interstitial, + sumOfAssetListAdDurationUs, + assetListData.adGroupIndex, + checkNotNull(session.lastProcessedPlaylist), + session); + adPlaybackState = + adPlaybackState.withContentResumeOffsetUs( + assetListData.adGroupIndex, resumeOffsetUs); putAndNotifyAdPlaybackStateUpdate(assetListData.adsId, adPlaybackState); notifyListeners( listener -> @@ -2538,15 +2663,32 @@ public int hashCode() { @VisibleForTesting /* package */ static class PendingSnapInResolution { - private final long resumeTimeUs; private final int adGroupIndex; - private final Interstitial interstitial; + private final String interstitialId; - /* package */ PendingSnapInResolution( - long resumeTimeUs, int adGroupIndex, Interstitial interstitial) { - this.resumeTimeUs = resumeTimeUs; + /* package */ PendingSnapInResolution(int adGroupIndex, String interstitialId) { this.adGroupIndex = adGroupIndex; - this.interstitial = interstitial; + this.interstitialId = interstitialId; + } + + @Override + public boolean equals(@Nullable Object o) { + if (this == o) { + return true; + } + if (!(o instanceof PendingSnapInResolution)) { + return false; + } + PendingSnapInResolution that = (PendingSnapInResolution) o; + return adGroupIndex == that.adGroupIndex + && Objects.equals(interstitialId, that.interstitialId); + } + + @Override + public int hashCode() { + int result = interstitialId.hashCode(); + result = 31 * result + adGroupIndex; + return result; } } } diff --git a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsMediaChunk.java b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsMediaChunk.java index 188b9de4eca..f6543df84ac 100644 --- a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsMediaChunk.java +++ b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsMediaChunk.java @@ -25,6 +25,7 @@ import androidx.media3.common.DrmInitData; import androidx.media3.common.Format; import androidx.media3.common.Metadata; +import androidx.media3.common.ParserException; import androidx.media3.common.util.ParsableByteArray; import androidx.media3.common.util.TimestampAdjuster; import androidx.media3.common.util.UriUtil; @@ -58,30 +59,31 @@ /** * Creates a new instance. * - * @param extractorFactory A {@link HlsExtractorFactory} from which the {@link - * HlsMediaChunkExtractor} is obtained. - * @param dataSource The source from which the data should be loaded. - * @param format The chunk format. - * @param startOfPlaylistInPeriodUs The position of the playlist in the period in microseconds. - * @param mediaPlaylist The media playlist from which this chunk was obtained. + * @param extractorFactory An {@link HlsExtractorFactory} for creating {@link + * HlsMediaChunkExtractor}s. + * @param dataSource The {@link DataSource} for loading the data. + * @param format The chunk {@link Format}. + * @param startOfPlaylistInPeriodUs The start time of the playlist in the period, in microseconds. + * @param mediaPlaylist The {@link HlsMediaPlaylist} from which this chunk was obtained. * @param segmentBaseHolder The segment holder. * @param playlistUrl The url of the playlist from which this chunk was obtained. + * @param steeredPathwayId The ID of the steered pathway from which data is being loaded, or + * {@code null} if not applicable. * @param muxedCaptionFormats List of muxed caption {@link Format}s. Null if no closed caption * information is available in the multivariant playlist. * @param trackSelectionReason See {@link #trackSelectionReason}. * @param trackSelectionData See {@link #trackSelectionData}. - * @param isPrimaryTimestampSource True if the chunk can initialize the timestamp adjuster. - * @param timestampAdjusterProvider The provider from which to obtain the {@link - * TimestampAdjuster}. - * @param timestampAdjusterInitializationTimeoutMs The timeout for the loading thread to wait for - * the timestamp adjuster to initialize, in milliseconds. A timeout of zero is interpreted as - * an infinite timeout. - * @param previousChunk The {@link HlsMediaChunk} that preceded this one. May be null. + * @param isPrimaryTimestampSource Whether this chunk is providing the timestamp source. + * @param timestampAdjusterProvider A provider of {@link TimestampAdjuster}s. + * @param timestampAdjusterInitializationTimeoutMs The timeout for waiting for the timestamp + * adjuster to be initialized, in milliseconds. + * @param previousChunk The previous chunk in the output, or null. * @param mediaSegmentKey The media segment decryption key, if fully encrypted. Null otherwise. * @param initSegmentKey The initialization segment decryption key, if fully encrypted. Null * otherwise. * @param shouldSpliceIn Whether samples for this chunk should be spliced into existing samples. * @param isIndependent Whether the chunk starts with a keyframe. + * @param playerId The {@link PlayerId} of the player. * @param cmcdDataFactory The {@link CmcdData.Factory} for generating {@link CmcdData}. */ public static HlsMediaChunk createInstance( @@ -92,6 +94,7 @@ public static HlsMediaChunk createInstance( HlsMediaPlaylist mediaPlaylist, HlsChunkSource.SegmentBaseHolder segmentBaseHolder, Uri playlistUrl, + @Nullable String steeredPathwayId, @Nullable List muxedCaptionFormats, @C.SelectionReason int trackSelectionReason, @Nullable Object trackSelectionData, @@ -215,7 +218,8 @@ public static HlsMediaChunk createInstance( scratchId3Data, shouldSpliceIn, isIndependent, - playerId); + playerId, + steeredPathwayId); } /** @@ -334,7 +338,8 @@ private HlsMediaChunk( ParsableByteArray scratchId3Data, boolean shouldSpliceIn, boolean isIndependent, - PlayerId playerId) { + PlayerId playerId, + @Nullable String steeredPathwayId) { super( mediaDataSource, dataSpec, @@ -343,7 +348,8 @@ private HlsMediaChunk( trackSelectionData, startTimeUs, endTimeUs, - chunkMediaSequence); + chunkMediaSequence, + steeredPathwayId); this.mediaSegmentEncrypted = mediaSegmentEncrypted; this.partIndex = partIndex; this.publishedDurationUs = isPublished ? endTimeUs - startTimeUs : C.TIME_UNSET; @@ -539,6 +545,11 @@ private void feedDataToExtractor( // See onTruncatedSegmentParsed's javadoc for more info on why we are swallowing the EOF // exception for trick play tracks. extractor.onTruncatedSegmentParsed(); + } else if (dataSpec.length != C.LENGTH_UNSET + && input.getPosition() >= dataSpec.position + dataSpec.length) { + // The chunk is fully loaded, but an EOFException was thrown. This can happen if the + // chunk is corrupted. + throw ParserException.createForMalformedContainer(/* message= */ null, e); } else { throw e; } diff --git a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsMediaPeriod.java b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsMediaPeriod.java index 501a5f7af29..02c0d38323c 100644 --- a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsMediaPeriod.java +++ b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsMediaPeriod.java @@ -57,7 +57,6 @@ import com.google.common.base.Supplier; import com.google.common.collect.ImmutableList; import com.google.common.collect.Lists; -import com.google.common.primitives.Ints; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; @@ -100,9 +99,6 @@ private @MonotonicNonNull TrackGroupArray trackGroups; private HlsSampleStreamWrapper[] sampleStreamWrappers; private HlsSampleStreamWrapper[] enabledSampleStreamWrappers; - // Maps sample stream wrappers to variant/rendition redundant group index by matching array - // positions. - private int[][] redundantGroupIndicesPerWrapper; private int audioVideoSampleStreamWrapperCount; private SequenceableLoader compositeSequenceableLoader; private long endPositionUs; @@ -177,7 +173,6 @@ public HlsMediaPeriod( timestampAdjusterProvider = new TimestampAdjusterProvider(); sampleStreamWrappers = new HlsSampleStreamWrapper[0]; enabledSampleStreamWrappers = new HlsSampleStreamWrapper[0]; - redundantGroupIndicesPerWrapper = new int[0][]; endPositionUs = C.TIME_END_OF_SOURCE; } @@ -217,27 +212,17 @@ public List getStreamKeys(List trackSelections) { // See HlsMultivariantPlaylist.copy for interpretation of StreamKeys. HlsMultivariantPlaylist multivariantPlaylist = checkNotNull(playlistTracker.getMultivariantPlaylist()); - List variantRedundantGroups = - checkNotNull(playlistTracker.getRedundantGroups(HlsRedundantGroup.VARIANT)); - List audioRenditionRedundantGroups = - checkNotNull(playlistTracker.getRedundantGroups(HlsRedundantGroup.AUDIO_RENDITION)); - List subtitleRenditionRedundantGroups = - checkNotNull(playlistTracker.getRedundantGroups(HlsRedundantGroup.SUBTITLE_RENDITION)); boolean hasVariants = !multivariantPlaylist.variants.isEmpty(); int audioWrapperOffset = hasVariants ? 1 : 0; - TrackGroupArray mainWrapperTrackGroups; - int mainWrapperPrimaryTrackGroupIndex; - int[] mainWrapperRedundantGroupIndices; + @Nullable HlsSampleStreamWrapper mainWrapper; + @Nullable TrackGroupArray mainWrapperTrackGroups; if (hasVariants) { - HlsSampleStreamWrapper mainWrapper = sampleStreamWrappers[0]; - mainWrapperRedundantGroupIndices = redundantGroupIndicesPerWrapper[0]; + mainWrapper = sampleStreamWrappers[0]; mainWrapperTrackGroups = mainWrapper.getTrackGroups(); - mainWrapperPrimaryTrackGroupIndex = mainWrapper.getPrimaryTrackGroupIndex(); } else { - mainWrapperRedundantGroupIndices = new int[0]; - mainWrapperTrackGroups = TrackGroupArray.EMPTY; - mainWrapperPrimaryTrackGroupIndex = 0; + mainWrapper = null; + mainWrapperTrackGroups = null; } List streamKeys = new ArrayList<>(); @@ -245,18 +230,21 @@ public List getStreamKeys(List trackSelections) { boolean hasPrimaryTrackGroupSelection = false; for (ExoTrackSelection trackSelection : trackSelections) { TrackGroup trackSelectionGroup = trackSelection.getTrackGroup(); - int mainWrapperTrackGroupIndex = mainWrapperTrackGroups.indexOf(trackSelectionGroup); + int mainWrapperTrackGroupIndex = + mainWrapperTrackGroups != null + ? mainWrapperTrackGroups.indexOf(trackSelectionGroup) + : C.INDEX_UNSET; if (mainWrapperTrackGroupIndex != C.INDEX_UNSET) { - if (mainWrapperTrackGroupIndex == mainWrapperPrimaryTrackGroupIndex) { + if (mainWrapperTrackGroupIndex == mainWrapper.getPrimaryTrackGroupIndex()) { // Primary group in main wrapper. hasPrimaryTrackGroupSelection = true; + ImmutableList mainWrapperRedundantGroups = + mainWrapper.getRedundantGroups(); for (int i = 0; i < trackSelection.length(); i++) { - int variantRedundantGroupIndex = - mainWrapperRedundantGroupIndices[trackSelection.getIndexInTrackGroup(i)]; - HlsRedundantGroup variantRedundantGroup = - variantRedundantGroups.get(variantRedundantGroupIndex); + HlsRedundantGroup mainWrapperSelectedRedundantGroup = + mainWrapperRedundantGroups.get(trackSelection.getIndexInTrackGroup(i)); for (int variantUrlIndexInMultivariantPlaylist : - variantRedundantGroup.getIndicesInMultivariantPlaylist()) { + mainWrapperSelectedRedundantGroup.getIndicesInMultivariantPlaylist()) { streamKeys.add( new StreamKey( HlsMultivariantPlaylist.GROUP_INDEX_VARIANT, @@ -270,28 +258,26 @@ public List getStreamKeys(List trackSelections) { } else { // Audio or subtitle group. for (int i = audioWrapperOffset; i < sampleStreamWrappers.length; i++) { + HlsSampleStreamWrapper wrapper = sampleStreamWrappers[i]; TrackGroupArray wrapperTrackGroups = sampleStreamWrappers[i].getTrackGroups(); int selectedTrackGroupIndex = wrapperTrackGroups.indexOf(trackSelectionGroup); if (selectedTrackGroupIndex != C.INDEX_UNSET) { - int groupIndexType = - wrapperTrackGroups.get(selectedTrackGroupIndex).type == C.TRACK_TYPE_AUDIO - ? HlsMultivariantPlaylist.GROUP_INDEX_AUDIO - : HlsMultivariantPlaylist.GROUP_INDEX_SUBTITLE; - List renditionRedundantGroups = - (groupIndexType == HlsMultivariantPlaylist.GROUP_INDEX_AUDIO) - ? audioRenditionRedundantGroups - : subtitleRenditionRedundantGroups; - int[] selectedWrapperRedundantGroupIndices = redundantGroupIndicesPerWrapper[i]; - for (int trackIndex = 0; trackIndex < trackSelection.length(); trackIndex++) { - int renditionRedundantGroupIndex = - selectedWrapperRedundantGroupIndices[ - trackSelection.getIndexInTrackGroup(trackIndex)]; - HlsRedundantGroup renditionRedundantGroup = - renditionRedundantGroups.get(renditionRedundantGroupIndex); - for (int renditionUrlIndexInMultivariantPlaylist : - renditionRedundantGroup.getIndicesInMultivariantPlaylist()) { - streamKeys.add( - new StreamKey(groupIndexType, renditionUrlIndexInMultivariantPlaylist)); + if (selectedTrackGroupIndex == wrapper.getPrimaryTrackGroupIndex()) { + // Primary group in the rendition wrapper. + int groupIndexType = + wrapperTrackGroups.get(selectedTrackGroupIndex).type == C.TRACK_TYPE_AUDIO + ? HlsMultivariantPlaylist.GROUP_INDEX_AUDIO + : HlsMultivariantPlaylist.GROUP_INDEX_SUBTITLE; + ImmutableList wrapperRedundantGroups = + wrapper.getRedundantGroups(); + for (int trackIndex = 0; trackIndex < trackSelection.length(); trackIndex++) { + HlsRedundantGroup wrapperSelectedRedundantGroup = + wrapperRedundantGroups.get(trackSelection.getIndexInTrackGroup(trackIndex)); + for (int renditionUrlIndexInMultivariantPlaylist : + wrapperSelectedRedundantGroup.getIndicesInMultivariantPlaylist()) { + streamKeys.add( + new StreamKey(groupIndexType, renditionUrlIndexInMultivariantPlaylist)); + } } } break; @@ -299,24 +285,25 @@ public List getStreamKeys(List trackSelections) { } } } - if (needsPrimaryTrackGroupSelection && !hasPrimaryTrackGroupSelection) { + if (hasVariants && needsPrimaryTrackGroupSelection && !hasPrimaryTrackGroupSelection) { // A track selection includes a variant-embedded track, but no variant is added yet. We use // the valid variant with the lowest bitrate to reduce overhead. - int lowestBitrateRedundantGroupIndex = mainWrapperRedundantGroupIndices[0]; + ImmutableList mainWrapperRedundantGroups = + mainWrapper.getRedundantGroups(); + int lowestBitrateRedundantGroupIndex = 0; int lowestBitrate = - variantRedundantGroups.get(mainWrapperRedundantGroupIndices[0]).groupKey.format.bitrate; - for (int i = 1; i < mainWrapperRedundantGroupIndices.length; i++) { - int variantBitrate = - variantRedundantGroups.get(mainWrapperRedundantGroupIndices[i]).groupKey.format.bitrate; + mainWrapperRedundantGroups.get(lowestBitrateRedundantGroupIndex).groupKey.format.bitrate; + for (int i = 1; i < mainWrapperRedundantGroups.size(); i++) { + int variantBitrate = mainWrapperRedundantGroups.get(i).groupKey.format.bitrate; if (variantBitrate < lowestBitrate) { lowestBitrate = variantBitrate; - lowestBitrateRedundantGroupIndex = mainWrapperRedundantGroupIndices[i]; + lowestBitrateRedundantGroupIndex = i; } } - HlsRedundantGroup variantRedundantGroupWithLowestBitrate = - variantRedundantGroups.get(lowestBitrateRedundantGroupIndex); + HlsRedundantGroup mainWrapperRedundantGroupWithLowestBitrate = + mainWrapperRedundantGroups.get(lowestBitrateRedundantGroupIndex); for (int variantUrlIndexInMultivariantPlaylist : - variantRedundantGroupWithLowestBitrate.getIndicesInMultivariantPlaylist()) { + mainWrapperRedundantGroupWithLowestBitrate.getIndicesInMultivariantPlaylist()) { streamKeys.add( new StreamKey( HlsMultivariantPlaylist.GROUP_INDEX_VARIANT, @@ -552,7 +539,6 @@ private void buildAndPrepareSampleStreamWrappers(long positionUs) { pendingPrepareCount = 0; ArrayList sampleStreamWrappers = new ArrayList<>(); - ArrayList redundantGroupIndicesPerWrapper = new ArrayList<>(); if (hasVariants) { buildAndPrepareMainSampleStreamWrapper( @@ -562,30 +548,20 @@ private void buildAndPrepareSampleStreamWrappers(long positionUs) { multivariantPlaylist.muxedCaptionFormats, positionUs, sampleStreamWrappers, - redundantGroupIndicesPerWrapper, overridingDrmInitData); } // TODO: Build video stream wrappers here. buildAndPrepareAudioSampleStreamWrappers( - positionUs, - audioRedundantGroups, - sampleStreamWrappers, - redundantGroupIndicesPerWrapper, - overridingDrmInitData); + positionUs, audioRedundantGroups, sampleStreamWrappers, overridingDrmInitData); audioVideoSampleStreamWrapperCount = sampleStreamWrappers.size(); buildAndPrepareSubtitleSampleStreamWrappers( - positionUs, - subtitleRedundantGroups, - sampleStreamWrappers, - redundantGroupIndicesPerWrapper, - overridingDrmInitData); + positionUs, subtitleRedundantGroups, sampleStreamWrappers, overridingDrmInitData); this.sampleStreamWrappers = sampleStreamWrappers.toArray(new HlsSampleStreamWrapper[0]); - this.redundantGroupIndicesPerWrapper = redundantGroupIndicesPerWrapper.toArray(new int[0][]); pendingPrepareCount = this.sampleStreamWrappers.length; // Set primary timestamp source and trigger preparation (if not already prepared) for (int i = 0; i < audioVideoSampleStreamWrapperCount; i++) { @@ -630,8 +606,6 @@ private void buildAndPrepareSampleStreamWrappers(long positionUs) { * @param positionUs If preparation requires any chunk downloads, the position in microseconds at * which downloading should start. Ignored otherwise. * @param sampleStreamWrappers List to which the built main sample stream wrapper should be added. - * @param redundantGroupIndicesPerWrapper List to which the selected variant redundant group - * indices should be added. * @param overridingDrmInitData Overriding {@link DrmInitData}, keyed by protection scheme type * (i.e. {@link DrmInitData#schemeType}). */ @@ -642,7 +616,6 @@ private void buildAndPrepareMainSampleStreamWrapper( @Nullable List muxedCaptionFormats, long positionUs, List sampleStreamWrappers, - List redundantGroupIndicesPerWrapper, Map overridingDrmInitData) { int[] variantTypes = new int[variantRedundantGroups.size()]; int videoVariantCount = 0; @@ -676,7 +649,6 @@ private void buildAndPrepareMainSampleStreamWrapper( } HlsRedundantGroup[] selectedRedundantGroups = new HlsRedundantGroup[selectedVariantsCount]; Format[] selectedRedundantGroupFormats = new Format[selectedVariantsCount]; - int[] selectedVariantRedundantGroupIndices = new int[selectedVariantsCount]; int outIndex = 0; for (int i = 0; i < variantRedundantGroups.size(); i++) { if ((!useVideoVariantsOnly || variantTypes[i] == C.TRACK_TYPE_VIDEO) @@ -684,7 +656,7 @@ private void buildAndPrepareMainSampleStreamWrapper( HlsRedundantGroup variantRedundantGroup = variantRedundantGroups.get(i); selectedRedundantGroups[outIndex] = variantRedundantGroup; selectedRedundantGroupFormats[outIndex] = variantRedundantGroup.groupKey.format; - selectedVariantRedundantGroupIndices[outIndex++] = i; + outIndex++; } } String codecs = selectedRedundantGroupFormats[0].codecs; @@ -711,7 +683,6 @@ private void buildAndPrepareMainSampleStreamWrapper( overridingDrmInitData, positionUs); sampleStreamWrappers.add(sampleStreamWrapper); - redundantGroupIndicesPerWrapper.add(selectedVariantRedundantGroupIndices); if (allowChunklessPreparation && codecsStringAllowsChunklessPreparation) { List muxedTrackGroups = new ArrayList<>(); if (numberOfVideoCodecs > 0) { @@ -781,14 +752,11 @@ private void buildAndPrepareAudioSampleStreamWrappers( long positionUs, List audioRedundantGroups, List sampleStreamWrappers, - List redundantGroupIndicesPerWrapper, Map overridingDrmInitData) { ArrayList scratchRedundantGroups = new ArrayList<>(/* initialCapacity= */ audioRedundantGroups.size()); ArrayList scratchRedundantGroupFormats = new ArrayList<>(/* initialCapacity= */ audioRedundantGroups.size()); - ArrayList scratchIndicesList = - new ArrayList<>(/* initialCapacity= */ audioRedundantGroups.size()); HashSet alreadyGroupedNames = new HashSet<>(); for (int renditionByNameIndex = 0; renditionByNameIndex < audioRedundantGroups.size(); @@ -802,7 +770,6 @@ private void buildAndPrepareAudioSampleStreamWrappers( boolean codecStringsAllowChunklessPreparation = true; scratchRedundantGroups.clear(); scratchRedundantGroupFormats.clear(); - scratchIndicesList.clear(); // Group all redundantGroups with matching name. for (int redundantGroupIndex = 0; redundantGroupIndex < audioRedundantGroups.size(); @@ -810,7 +777,6 @@ private void buildAndPrepareAudioSampleStreamWrappers( if (Objects.equals(name, audioRedundantGroups.get(redundantGroupIndex).groupKey.name)) { HlsRedundantGroup audioRedundantGroup = audioRedundantGroups.get(redundantGroupIndex); Format format = audioRedundantGroup.groupKey.format; - scratchIndicesList.add(redundantGroupIndex); scratchRedundantGroups.add(audioRedundantGroup); scratchRedundantGroupFormats.add(format); codecStringsAllowChunklessPreparation &= @@ -829,7 +795,6 @@ private void buildAndPrepareAudioSampleStreamWrappers( /* muxedCaptionFormats= */ Collections.emptyList(), overridingDrmInitData, positionUs); - redundantGroupIndicesPerWrapper.add(Ints.toArray(scratchIndicesList)); sampleStreamWrappers.add(sampleStreamWrapper); if (allowChunklessPreparation && codecStringsAllowChunklessPreparation) { @@ -856,14 +821,11 @@ private void buildAndPrepareSubtitleSampleStreamWrappers( long positionUs, List subtitleRedundantGroups, List sampleStreamWrappers, - List redundantGroupIndicesPerWrapper, Map overridingDrmInitData) { ArrayList scratchRedundantGroups = new ArrayList<>(/* initialCapacity= */ subtitleRedundantGroups.size()); ArrayList scratchRedundantGroupFormats = new ArrayList<>(/* initialCapacity= */ subtitleRedundantGroups.size()); - ArrayList scratchIndicesList = - new ArrayList<>(/* initialCapacity= */ subtitleRedundantGroups.size()); HashSet alreadyGroupedNames = new HashSet<>(); for (int renditionByNameIndex = 0; renditionByNameIndex < subtitleRedundantGroups.size(); @@ -876,7 +838,6 @@ private void buildAndPrepareSubtitleSampleStreamWrappers( scratchRedundantGroups.clear(); scratchRedundantGroupFormats.clear(); - scratchIndicesList.clear(); // Group all redundantGroups with matching name. for (int redundantGroupIndex = 0; redundantGroupIndex < subtitleRedundantGroups.size(); @@ -884,7 +845,6 @@ private void buildAndPrepareSubtitleSampleStreamWrappers( if (Objects.equals(name, subtitleRedundantGroups.get(redundantGroupIndex).groupKey.name)) { HlsRedundantGroup subtitleRedundantGroup = subtitleRedundantGroups.get(redundantGroupIndex); - scratchIndicesList.add(redundantGroupIndex); scratchRedundantGroups.add(subtitleRedundantGroup); scratchRedundantGroupFormats.add(subtitleRedundantGroup.groupKey.format); } @@ -902,7 +862,6 @@ private void buildAndPrepareSubtitleSampleStreamWrappers( /* muxedCaptionFormats= */ ImmutableList.of(), overridingDrmInitData, positionUs); - redundantGroupIndicesPerWrapper.add(Ints.toArray(scratchIndicesList)); sampleStreamWrappers.add(sampleStreamWrapper); Format[] outputTextFormats = new Format[originalSubtitleFormats.length]; diff --git a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsSampleStreamWrapper.java b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsSampleStreamWrapper.java index 5d58cb51213..b3747816c56 100644 --- a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsSampleStreamWrapper.java +++ b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/HlsSampleStreamWrapper.java @@ -49,6 +49,7 @@ import androidx.media3.exoplayer.drm.DrmSession; import androidx.media3.exoplayer.drm.DrmSessionEventListener; import androidx.media3.exoplayer.drm.DrmSessionManager; +import androidx.media3.exoplayer.hls.playlist.HlsRedundantGroup; import androidx.media3.exoplayer.source.LoadEventInfo; import androidx.media3.exoplayer.source.MediaLoadData; import androidx.media3.exoplayer.source.MediaSourceEventListener; @@ -961,19 +962,18 @@ public void reevaluateBuffer(long positionUs) { @Override public void onLoadStarted( Chunk loadable, long elapsedRealtimeMs, long loadDurationMs, int retryCount) { - LoadEventInfo loadEventInfo = - retryCount == 0 - ? new LoadEventInfo(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) - : new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + LoadEventInfo.Builder loadEventInfo = + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setSteeredPathwayId(loadable.steeredPathwayId); + if (retryCount != 0) { + loadEventInfo + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()); + } mediaSourceEventDispatcher.loadStarted( - loadEventInfo, + loadEventInfo.build(), loadable.type, trackType, loadable.trackFormat, @@ -989,14 +989,13 @@ public void onLoadCompleted(Chunk loadable, long elapsedRealtimeMs, long loadDur loadingChunk = null; chunkSource.onChunkLoadCompleted(loadable); LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setSteeredPathwayId(loadable.steeredPathwayId) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); mediaSourceEventDispatcher.loadCompleted( loadEventInfo, @@ -1019,14 +1018,13 @@ public void onLoadCanceled( Chunk loadable, long elapsedRealtimeMs, long loadDurationMs, boolean released) { loadingChunk = null; LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setSteeredPathwayId(loadable.steeredPathwayId) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); mediaSourceEventDispatcher.loadCanceled( loadEventInfo, @@ -1068,14 +1066,13 @@ public LoadErrorAction onLoadError( } long bytesLoaded = loadable.bytesLoaded(); LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - bytesLoaded); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setSteeredPathwayId(loadable.steeredPathwayId) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(bytesLoaded) + .build(); MediaLoadData mediaLoadData = new MediaLoadData( loadable.type, @@ -1184,7 +1181,7 @@ private void discardUpstream(int preferredQueueSize) { long endTimeUs = getLastMediaChunk().endTimeUs; HlsMediaChunk firstRemovedChunk = discardUpstreamMediaChunksFromIndex(newQueueSize); if (mediaChunks.isEmpty()) { - pendingResetPositionUs = lastSeekPositionUs; + pendingResetPositionUs = max(lastSeekPositionUs, firstRemovedChunk.startTimeUs); } else { getLast(mediaChunks).invalidateExtractor(); } @@ -1366,6 +1363,11 @@ public void setDrmInitData(@Nullable DrmInitData drmInitData) { } } + /** Returns the redundant groups for this sample stream wrapper. */ + public ImmutableList getRedundantGroups() { + return chunkSource.getRedundantGroups(); + } + // Internal methods. private void updateSampleStreams(@NullableType SampleStream[] streams) { diff --git a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/offline/HlsDownloader.java b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/offline/HlsDownloader.java index f2ab72c551e..facffbd7ed3 100644 --- a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/offline/HlsDownloader.java +++ b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/offline/HlsDownloader.java @@ -157,6 +157,8 @@ public HlsDownloader create(MediaItem mediaItem) { } } + private final Parser manifestParser; + /** * @deprecated Use {@link HlsDownloader.Factory#create(MediaItem)} instead. */ @@ -214,27 +216,36 @@ private HlsDownloader( maxMergedSegmentStartTimeDiffMs, startPositionUs, durationUs); + this.manifestParser = manifestParser; } @Override protected List getSegments(DataSource dataSource, HlsPlaylist manifest, boolean removing) throws IOException, InterruptedException { ArrayList mediaPlaylistDataSpecs = new ArrayList<>(); + HlsMultivariantPlaylist multivariantPlaylist = HlsMultivariantPlaylist.EMPTY; if (manifest instanceof HlsMultivariantPlaylist) { - HlsMultivariantPlaylist multivariantPlaylist = (HlsMultivariantPlaylist) manifest; + multivariantPlaylist = (HlsMultivariantPlaylist) manifest; addMediaPlaylistDataSpecs(multivariantPlaylist.mediaPlaylistUrls, mediaPlaylistDataSpecs); } else { mediaPlaylistDataSpecs.add( SegmentDownloader.getCompressibleDataSpec(Uri.parse(manifest.baseUri))); } + Parser mediaPlaylistParser = + !multivariantPlaylist.variableDefinitions.isEmpty() + ? new HlsPlaylistParser(multivariantPlaylist, /* previousMediaPlaylist= */ null) + : manifestParser; + ArrayList segments = new ArrayList<>(); HashSet seenEncryptionKeyUris = new HashSet<>(); for (DataSpec mediaPlaylistDataSpec : mediaPlaylistDataSpecs) { segments.add(new Segment(/* startTimeUs= */ 0, mediaPlaylistDataSpec)); HlsMediaPlaylist mediaPlaylist; try { - mediaPlaylist = (HlsMediaPlaylist) getManifest(dataSource, mediaPlaylistDataSpec, removing); + mediaPlaylist = + (HlsMediaPlaylist) + getManifest(dataSource, mediaPlaylistParser, mediaPlaylistDataSpec, removing); } catch (IOException e) { if (!removing) { throw e; diff --git a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/playlist/DefaultHlsPlaylistTracker.java b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/playlist/DefaultHlsPlaylistTracker.java index de4c14f1f0f..1a8a5d6007a 100644 --- a/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/playlist/DefaultHlsPlaylistTracker.java +++ b/libraries/exoplayer_hls/src/main/java/androidx/media3/exoplayer/hls/playlist/DefaultHlsPlaylistTracker.java @@ -385,18 +385,16 @@ public void onLoadStarted( long elapsedRealtimeMs, long loadDurationMs, int retryCount) { - LoadEventInfo loadEventInfo = - retryCount == 0 - ? new LoadEventInfo(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) - : new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); - eventDispatcher.loadStarted(loadEventInfo, loadable.type, retryCount); + LoadEventInfo.Builder loadEventInfo = + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs); + if (retryCount != 0) { + loadEventInfo + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()); + } + eventDispatcher.loadStarted(loadEventInfo.build(), loadable.type, retryCount); } @Override @@ -448,14 +446,12 @@ public void onLoadCompleted( listeners.add(new FirstPrimaryMediaPlaylistListener()); createBundles(); LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); RedundantGroupBundle primaryRedundantGroupBundle = checkNotNull(redundantGroupBundles.get(primaryMediaPlaylistUrl)); if (isMediaPlaylist) { @@ -477,14 +473,12 @@ public void onLoadCanceled( long loadDurationMs, boolean released) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); eventDispatcher.loadCanceled(loadEventInfo, C.DATA_TYPE_MANIFEST); } @@ -497,14 +491,12 @@ public LoadErrorAction onLoadError( IOException error, int errorCount) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); MediaLoadData mediaLoadData = new MediaLoadData(loadable.type); long retryDelayMs = loadErrorHandlingPolicy.getRetryDelayMsFor( @@ -997,18 +989,17 @@ public void onLoadStarted( long elapsedRealtimeMs, long loadDurationMs, int retryCount) { - LoadEventInfo loadEventInfo = - retryCount == 0 - ? new LoadEventInfo(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) - : new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); - eventDispatcher.loadStarted(loadEventInfo, loadable.type, retryCount); + LoadEventInfo.Builder loadEventInfo = + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setSteeredPathwayId(loadable.steeredPathwayId); + if (retryCount != 0) { + loadEventInfo + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()); + } + eventDispatcher.loadStarted(loadEventInfo.build(), loadable.type, retryCount); } @Override @@ -1016,14 +1007,13 @@ public void onLoadCompleted( ParsingLoadable loadable, long elapsedRealtimeMs, long loadDurationMs) { @Nullable HlsPlaylist result = loadable.getResult(); LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setSteeredPathwayId(loadable.steeredPathwayId) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); if (result instanceof HlsMediaPlaylist) { processLoadedPlaylist((HlsMediaPlaylist) result, loadEventInfo); eventDispatcher.loadCompleted(loadEventInfo, C.DATA_TYPE_MANIFEST); @@ -1044,14 +1034,13 @@ public void onLoadCanceled( long loadDurationMs, boolean released) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setSteeredPathwayId(loadable.steeredPathwayId) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); eventDispatcher.loadCanceled(loadEventInfo, C.DATA_TYPE_MANIFEST); } @@ -1064,14 +1053,13 @@ public LoadErrorAction onLoadError( IOException error, int errorCount) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setSteeredPathwayId(loadable.steeredPathwayId) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); boolean isBlockingRequest = loadable.getUri().getQueryParameter(BLOCK_MSN_PARAM) != null; boolean deltaUpdateFailed = error instanceof HlsPlaylistParser.DeltaUpdateException; if (isBlockingRequest || deltaUpdateFailed) { @@ -1128,7 +1116,9 @@ private void loadPlaylistInternal(Uri playlistRequestUri) { playlistRefreshHandler.postDelayed( () -> { loadPending = false; - loadPlaylistImmediately(playlistRequestUri); + if (playlistUrl.equals(primaryMediaPlaylistUrl) || isActiveForPlayback()) { + loadPlaylistImmediately(playlistRequestUri); + } }, earliestNextLoadTimeMs - currentTimeMs); } else { @@ -1154,8 +1144,10 @@ private void loadPlaylistImmediately(Uri playlistRequestUri) { dataSpec = cmcdDataFactory.createCmcdData().addToDataSpec(dataSpec); } ParsingLoadable mediaPlaylistLoadable = - new ParsingLoadable<>( - mediaPlaylistDataSource, dataSpec, C.DATA_TYPE_MANIFEST, mediaPlaylistParser); + new ParsingLoadable.Builder( + mediaPlaylistDataSource, dataSpec, C.DATA_TYPE_MANIFEST, mediaPlaylistParser) + .setSteeredPathwayId(getReportedPathwayId()) + .build(); mediaPlaylistLoader.startLoading( mediaPlaylistLoadable, /* callback= */ this, @@ -1265,6 +1257,24 @@ private Uri getMediaPlaylistUriForReload() { private void excludePlaylist(long exclusionDurationMs) { excludeUntilMs = SystemClock.DEFAULT.elapsedRealtime() + exclusionDurationMs; } + + @Nullable + private String getReportedPathwayId() { + if (contentSteeringTracker == null || !contentSteeringTracker.isActive()) { + return null; + } + @Nullable RedundantGroupBundle bundle = redundantGroupBundles.get(playlistUrl); + if (bundle != null) { + String currentPathwayId = bundle.redundantGroup.getCurrentPathwayId(); + if (pathwayIds.contains(currentPathwayId)) { + return currentPathwayId; + } + } + // If the current pathway ID is not associated with this URL, we fall back to reporting the + // first available pathway ID. This is a heuristic for rare cases where multiple pathways + // might map to the same URL. + return Iterables.getFirst(pathwayIds, null); + } } /** diff --git a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsChunkSourceTest.java b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsChunkSourceTest.java index ef1230aefa2..6bc548a2e19 100644 --- a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsChunkSourceTest.java +++ b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsChunkSourceTest.java @@ -725,6 +725,73 @@ public void getNextChunk_reloadingCurrentPreloadPartAfterPublication_returnsShou assertThat(((HlsMediaChunk) output.chunk).shouldSpliceIn()).isTrue(); } + @Test + public void getNextChunk_withContentSteeringActive_chunkHasSteeredPathwayId() throws IOException { + HlsRedundantGroup[] redundantGroups = createSampleRedundantGroups(); + when(mockPlaylistTracker.getContentSteeringTracker()).thenReturn(mockContentSteeringTracker); + HlsChunkSource testChunkSource = createHlsChunkSource(redundantGroups, mockPlaylistTracker); + HlsChunkSource.HlsChunkHolder output = new HlsChunkSource.HlsChunkHolder(); + + testChunkSource.getNextChunk( + new LoadingInfo.Builder().setPlaybackPositionUs(0).setPlaybackSpeed(1.0f).build(), + /* loadPositionUs= */ 0, + /* largestReadPositionUs= */ 0, + /* queue= */ ImmutableList.of(), + /* allowEndOfStream= */ true, + output); + + assertThat(output.chunk.steeredPathwayId).isEqualTo("CDN-A"); + + // Switch/select CDN-B pathway ID for all redundant groups + for (HlsRedundantGroup group : redundantGroups) { + group.setCurrentPathwayId("CDN-B"); + } + + testChunkSource.getNextChunk( + new LoadingInfo.Builder().setPlaybackPositionUs(4_000_000).setPlaybackSpeed(1.0f).build(), + /* loadPositionUs= */ 4_000_000, + /* largestReadPositionUs= */ 0, + /* queue= */ ImmutableList.of((HlsMediaChunk) output.chunk), + /* allowEndOfStream= */ true, + output); + + assertThat(output.chunk.steeredPathwayId).isEqualTo("CDN-B"); + } + + @Test + public void getNextChunk_withContentSteeringInactive_chunkSteeredPathwayIdIsNull() + throws IOException { + HlsRedundantGroup[] redundantGroups = createSampleRedundantGroups(); + when(mockPlaylistTracker.getContentSteeringTracker()).thenReturn(null); + HlsChunkSource testChunkSource = createHlsChunkSource(redundantGroups, mockPlaylistTracker); + HlsChunkSource.HlsChunkHolder output = new HlsChunkSource.HlsChunkHolder(); + + testChunkSource.getNextChunk( + new LoadingInfo.Builder().setPlaybackPositionUs(0).setPlaybackSpeed(1.0f).build(), + /* loadPositionUs= */ 0, + /* largestReadPositionUs= */ 0, + /* queue= */ ImmutableList.of(), + /* allowEndOfStream= */ true, + output); + + assertThat(output.chunk.steeredPathwayId).isNull(); + + // Switch/select CDN-B pathway ID for all redundant groups + for (HlsRedundantGroup group : redundantGroups) { + group.setCurrentPathwayId("CDN-B"); + } + + testChunkSource.getNextChunk( + new LoadingInfo.Builder().setPlaybackPositionUs(4_000_000).setPlaybackSpeed(1.0f).build(), + /* loadPositionUs= */ 4_000_000, + /* largestReadPositionUs= */ 0, + /* queue= */ ImmutableList.of((HlsMediaChunk) output.chunk), + /* allowEndOfStream= */ true, + output); + + assertThat(output.chunk.steeredPathwayId).isNull(); + } + @Test public void getChunkPublicationState_withCmcdQueryParameters_returnsPublished() throws Exception { CmcdConfiguration.Factory cmcdConfigurationFactory = diff --git a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsInterstitialsAdsLoaderTest.java b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsInterstitialsAdsLoaderTest.java index f301d8a8f5d..989c53389d5 100644 --- a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsInterstitialsAdsLoaderTest.java +++ b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsInterstitialsAdsLoaderTest.java @@ -16,6 +16,7 @@ package androidx.media3.exoplayer.hls; import static androidx.media3.common.AdPlaybackState.AD_STATE_AVAILABLE; +import static androidx.media3.common.AdPlaybackState.AD_STATE_SKIPPED; import static androidx.media3.common.AdPlaybackState.AD_STATE_UNAVAILABLE; import static androidx.media3.common.Player.DISCONTINUITY_REASON_AUTO_TRANSITION; import static androidx.media3.common.Player.DISCONTINUITY_REASON_SKIP; @@ -92,7 +93,10 @@ import java.nio.charset.Charset; import java.util.ArrayList; import java.util.Arrays; +import java.util.Iterator; import java.util.List; +import java.util.Map; +import java.util.NavigableMap; import java.util.concurrent.TimeoutException; import java.util.concurrent.atomic.AtomicInteger; import org.json.JSONObject; @@ -1511,7 +1515,6 @@ public void handleContentTimelineChanged_snapIn_snapToClosestSegmentBoundaryOfRe + "CLASS=\"com.apple.hls.interstitial\"," + "START-DATE=\"2020-01-02T21:55:40.000\"," // + "X-SNAP=\"IN\"," - + "X-RESUME-OFFSET=3.222," // Snaps to start of next content segment. + "X-PLAYOUT-LIMIT=3.222," + "X-ASSET-URI=\"http://example.com/media-0-0.m3u8\"" + "\n" @@ -1520,7 +1523,6 @@ public void handleContentTimelineChanged_snapIn_snapToClosestSegmentBoundaryOfRe + "CLASS=\"com.apple.hls.interstitial\"," + "START-DATE=\"2020-01-02T21:55:52.222\"," + "X-SNAP=\"IN\"," - + "X-RESUME-OFFSET=4.333," // Snaps to start of next content segment. + "X-PLAYOUT-LIMIT=4.333," + "X-ASSET-URI=\"http://example.com/media-1-0.m3u8\"" + "\n", @@ -1554,6 +1556,67 @@ public void handleContentTimelineChanged_snapIn_snapToClosestSegmentBoundaryOfRe .build())); } + @Test + public void handleContentTimelineChanged_snapInWithExplicitResumeOffset_usesExplicitResumeOffset() + throws IOException { + assertThat( + callHandleContentTimelineChangedAndCaptureAdPlaybackState( + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-PROGRAM-DATE-TIME:2020-01-02T21:55:40.000Z\n" + + "#EXTINF:6.111,\nmain1.ts\n" + + "#EXTINF:6.111,\nmain2.ts\n" // segment start at 6.111 + + "#EXTINF:6.111,\nmain3.ts\n" // end of window at 18.333 + + "#EXT-X-ENDLIST" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad0-0\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2020-01-02T21:55:40.000\"," // + + "X-SNAP=\"IN\"," + + "X-RESUME-OFFSET=1.234," + + "X-PLAYOUT-LIMIT=3.222," + + "X-ASSET-URI=\"http://example.com/media-0-0.m3u8\"" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad1-0\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2020-01-02T21:55:52.222\"," + + "X-SNAP=\"IN\"," + + "X-RESUME-OFFSET=2.345," + + "X-PLAYOUT-LIMIT=4.333," + + "X-ASSET-URI=\"http://example.com/media-1-0.m3u8\"" + + "\n", + adsLoader, + /* windowIndex= */ 0, + /* windowPositionInPeriodUs= */ 0, + /* windowEndPositionInPeriodUs= */ C.TIME_END_OF_SOURCE)) + .isEqualTo( + new AdPlaybackState("adsId", /* adGroupTimesUs...= */ 0L, 12_222_000) + .withAdCount(/* adGroupIndex= */ 0, 1) + .withAdCount(/* adGroupIndex= */ 1, 1) + .withContentResumeOffsetUs(/* adGroupIndex= */ 0, 1_234_000L) + .withContentResumeOffsetUs(/* adGroupIndex= */ 1, 2_345_000L) + .withAdDurationsUs(/* adGroupIndex= */ 0, 3_222_000L) + .withAdDurationsUs(/* adGroupIndex= */ 1, 4_333_000L) + .withAdId(/* adGroupIndex= */ 0, /* adIndexInAdGroup= */ 0, "ad0-0") + .withAdId(/* adGroupIndex= */ 1, /* adIndexInAdGroup= */ 0, "ad1-0") + .withAvailableAdMediaItem( + /* adGroupIndex= */ 0, + /* adIndexInAdGroup= */ 0, + new MediaItem.Builder() + .setUri("http://example.com/media-0-0.m3u8") + .setMimeType(MimeTypes.APPLICATION_M3U8) + .build()) + .withAvailableAdMediaItem( + /* adGroupIndex= */ 1, + /* adIndexInAdGroup= */ 0, + new MediaItem.Builder() + .setUri("http://example.com/media-1-0.m3u8") + .setMimeType(MimeTypes.APPLICATION_M3U8) + .build())); + } + @Test public void handleContentTimelineChanged_snapInLive_snapToClosestSegmentBoundaryOfResumptionPosition() @@ -1570,8 +1633,8 @@ public void handleContentTimelineChanged_snapIn_snapToClosestSegmentBoundaryOfRe + "ID=\"ad0-0\"," + "CLASS=\"com.apple.hls.interstitial\"," + "START-DATE=\"2020-01-02T21:55:40.111\"," + + "PLANNED-DURATION=4.333," + "X-SNAP=\"IN\"," - + "X-RESUME-OFFSET=3.222," // snap to end of first segment: 6.000 + "X-ASSET-URI=\"http://example.com/media-0-0.m3u8\"" + "\n" + "#EXT-X-DATERANGE:" @@ -1580,7 +1643,6 @@ public void handleContentTimelineChanged_snapIn_snapToClosestSegmentBoundaryOfRe + "START-DATE=\"2020-01-02T21:55:52.332\"," + "X-SNAP=\"IN\"," + "DURATION=4.333," - + "X-RESUME-OFFSET=4.333," // snap to end of first segment: 6.001 + "X-ASSET-URI=\"http://example.com/media-1-0.m3u8\"" + "\n" + "#EXT-X-PROGRAM-DATE-TIME:2020-01-02T21:55:40.000Z\n" @@ -1711,7 +1773,7 @@ public void handleContentTimelineChanged_snapInLiveBeforeOrAfterWindow_ignored() + "ID=\"ad0-0\"," // pre roll + "CLASS=\"com.apple.hls.interstitial\"," + "START-DATE=\"2020-01-02T21:55:48.111Z\"," // snap OUT to start of segment - + "X-RESUME-OFFSET=10.000," // snap IN to end of playlist: 12_222 + + "DURATION=10.000," // snap IN to end of playlist: 12_222 + "X-SNAP=\"OUT,IN\"," + "X-ASSET-URI=\"http://example.com/media-0-0.m3u8\"" + "\n" @@ -1726,7 +1788,7 @@ public void handleContentTimelineChanged_snapInLiveBeforeOrAfterWindow_ignored() + "ID=\"ad0-0\"," // pre roll + "CLASS=\"com.apple.hls.interstitial\"," + "START-DATE=\"2020-01-02T21:55:46.111Z\"," - + "X-RESUME-OFFSET=10.000," + + "DURATION=10.000," + "X-SNAP=\"IN,OUT\"," + "X-ASSET-URI=\"http://example.com/media-0-0.m3u8\"" + "\n" @@ -1740,6 +1802,86 @@ public void handleContentTimelineChanged_snapInLiveBeforeOrAfterWindow_ignored() expectedAdPlaybackState.withContentResumeOffsetUs(/* adGroupIndex= */ 0, 12_222_000L)); } + @Test + public void handleContentTimelineChanged_snapInLiveMultipleDeferred_resolvesInOrder() + throws IOException { + AdPlaybackState firstAdPlaybackState = + new AdPlaybackState("adsId", /* adGroupTimesUs...= */ 0L, 6_111_000L) + .withLivePostrollPlaceholderAppended(/* isServerSideInserted= */ false) + .withAdCount(/* adGroupIndex= */ 0, 1) + .withContentResumeOffsetUs(/* adGroupIndex= */ 0, 12_222_000L) + .withAdId(/* adGroupIndex= */ 0, /* adIndexInAdGroup= */ 0, "ad0-0") + .withAvailableAdMediaItem( + /* adGroupIndex= */ 0, + /* adIndexInAdGroup= */ 0, + new MediaItem.Builder() + .setUri("http://example.com/media-0-0.m3u8") + .setMimeType(MimeTypes.APPLICATION_M3U8) + .build()) + .withAdCount(/* adGroupIndex= */ 1, 1) + .withContentResumeOffsetUs(/* adGroupIndex= */ 1, 10_000_000L) + .withAdId(/* adGroupIndex= */ 1, /* adIndexInAdGroup= */ 0, "ad1-0") + .withAvailableAdMediaItem( + /* adGroupIndex= */ 1, + /* adIndexInAdGroup= */ 0, + new MediaItem.Builder() + .setUri("http://example.com/media-1-0.m3u8") + .setMimeType(MimeTypes.APPLICATION_M3U8) + .build()); + + assertThat( + callHandleContentTimelineChangedForLiveAndCaptureAdPlaybackStates( + adsLoader, + /* startAdsLoader= */ true, + /* windowOffsetInFirstPeriodUs= */ 0, + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-MEDIA-SEQUENCE:0\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad0-0\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2020-01-02T21:55:40.000Z\"," + + "DURATION=10.000," + + "X-SNAP=\"IN,OUT\"," + + "X-ASSET-URI=\"http://example.com/media-0-0.m3u8\"\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad1-0\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2020-01-02T21:55:46.111Z\"," + + "DURATION=10.000," + + "X-SNAP=\"IN,OUT\"," + + "X-ASSET-URI=\"http://example.com/media-1-0.m3u8\"\n" + + "#EXT-X-PROGRAM-DATE-TIME:2020-01-02T21:55:40.000Z\n" + + "#EXTINF:6.111,\nmain1.0.ts\n" + + "#EXTINF:6.111,\nmain2.0.ts\n" + + "\n", + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-MEDIA-SEQUENCE:0\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad0-0\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2020-01-02T21:55:40.000Z\"," + + "DURATION=10.000," + + "X-SNAP=\"IN,OUT\"," + + "X-ASSET-URI=\"http://example.com/media-0-0.m3u8\"\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad1-0\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2020-01-02T21:55:46.111Z\"," + + "DURATION=10.000," + + "X-SNAP=\"IN,OUT\"," + + "X-ASSET-URI=\"http://example.com/media-1-0.m3u8\"\n" + + "#EXT-X-PROGRAM-DATE-TIME:2020-01-02T21:55:40.000Z\n" + + "#EXTINF:6.111,\nmain1.0.ts\n" + + "#EXTINF:6.111,\nmain2.0.ts\n" + + "#EXTINF:6.111,\nmain3.0.ts\n" + + "\n")) + .containsExactly( + firstAdPlaybackState, + firstAdPlaybackState.withContentResumeOffsetUs(/* adGroupIndex= */ 1, 12_222_000L)); + } + @Test public void handleContentTimelineChanged_snapInOut_snapToSameSegmentBoundaryMergedIntoSameAdGroup() @@ -1766,7 +1908,7 @@ public void handleContentTimelineChanged_snapInLiveBeforeOrAfterWindow_ignored() + "CLASS=\"com.apple.hls.interstitial\"," + "START-DATE=\"2020-01-02T21:55:47.111\"," // snaps OUT to 6_111_000 + "X-SNAP=\"OUT,IN\"," - + "X-RESUME-OFFSET=3.111," // Changed by snap IN to 6.111 + + "DURATION=3.111," // Changed by snap IN to 6.111 + "X-ASSET-URI=\"http://example.com/media-0-1.m3u8\"" + "\n", adsLoader, @@ -1812,7 +1954,7 @@ public void handleContentTimelineChanged_snapInLiveBeforeOrAfterWindow_ignored() + "CLASS=\"com.apple.hls.interstitial\"," + "START-DATE=\"2020-01-02T21:55:45.000\"," // snaps OUT to 6_111_000L + "X-SNAP=\"OUT,IN\"," - + "X-RESUME-OFFSET=4.222," // snaps IN to 6.111 + + "DURATION=4.222," // snaps IN to 6.111 + "X-ASSET-URI=\"http://example.com/media-0-0.m3u8\"" + "\n" + "#EXT-X-DATERANGE:" @@ -2534,6 +2676,497 @@ public void handleContentTimelineChanged_preRollWithAssetList_resolveAssetListIm inOrder.verifyNoMoreInteractions(); } + @Test + public void handleContentTimelineChanged_assetListResolvedTwice_correctContentResumeOffsetUs() + throws IOException, TimeoutException { + String playlistString = + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-PROGRAM-DATE-TIME:2026-07-14T08:56:00.000Z\n" + + "#EXTINF:6.037333,\n" + + "main0.ts\n" + + "#EXTINF:6.037333,\n" + + "main1.ts\n" + + "#EXTINF:6.037333,\n" + + "main2.ts\n" + + "#EXTINF:6.037333,\n" + + "main3.ts\n" + + "#EXTINF:6.037333,\n" + + "main4.ts\n" + + "#EXTINF:6.037333,\n" + + "main5.ts\n" + + "#EXT-X-ENDLIST" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad-break-12338\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2026-07-14T08:56:17.860Z\"," + + "PLANNED-DURATION=12.074666," + + "X-PLAYOUT-LIMIT=12.074666," + + "X-ASSET-LIST=\"asset-list-two-ads\"," + + "X-SNAP=\"OUT,IN\"" + + "\n"; + when(mockPlayer.getContentPosition()).thenReturn(0L); + callHandleContentTimelineChangedAndCaptureAdPlaybackState( + playlistString, + adsLoader, + /* windowIndex= */ 0, + /* windowPositionInPeriodUs= */ 0, + /* windowEndPositionInPeriodUs= */ C.TIME_END_OF_SOURCE); + + runMainLooperUntil(assetListLoadingListener::completed, TIMEOUT_MS, Clock.DEFAULT); + + assetListLoadingListener.reset(); + adsLoader.setWithSkippedAdGroup(/* adGroupIndex= */ 0); + assertThat(adsLoader.setWithAssetListReset("adsId", "ad-break-12338")).isTrue(); + runMainLooperUntil(assetListLoadingListener::completed, TIMEOUT_MS, Clock.DEFAULT); + + ArgumentCaptor adPlaybackStateCaptor = + ArgumentCaptor.forClass(AdPlaybackState.class); + verify(mockEventListener, times(5)).onAdPlaybackState(adPlaybackStateCaptor.capture()); + List capturedStates = adPlaybackStateCaptor.getAllValues(); + AdPlaybackState initialState = capturedStates.get(0); + AdPlaybackState firstResolvedState = capturedStates.get(1); + AdPlaybackState skippedState = capturedStates.get(2); + AdPlaybackState resetState = capturedStates.get(3); + AdPlaybackState secondResolvedState = capturedStates.get(4); + assertThat(initialState.adGroupCount).isEqualTo(1); + assertThat(initialState.getAdGroup(0).contentResumeOffsetUs).isEqualTo(12_074_666L); + assertThat(firstResolvedState.adGroupCount).isEqualTo(1); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(2); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(12_074_666L); + assertThat(skippedState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(2); + assertThat(skippedState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_SKIPPED, AD_STATE_SKIPPED); + assertThat(resetState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(1); + assertThat(resetState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_UNAVAILABLE); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(2); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_AVAILABLE, AD_STATE_AVAILABLE); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(12_074_666L); + } + + @Test + public void handleContentTimelineChanged_assetListResolved_calculatesContentResumeOffsetUs() + throws Exception { + String playlistString = + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-PROGRAM-DATE-TIME:2026-07-14T08:56:00.000Z\n" + + "#EXTINF:6.037333,\n" + + "main0.ts\n" + + "#EXTINF:6.037333,\n" + + "main1.ts" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad-break-12338\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2026-07-14T08:56:17.860Z\"," + + "PLANNED-DURATION=12.074665," + + "X-PLAYOUT-LIMIT=12.074665," + + "X-ASSET-LIST=\"asset-list-two-ads\"," + + "X-SNAP=\"OUT,IN\"," + + "\n" + + "#EXTINF:6.037333,\n" + + "main2.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main3.ts" + + "\n"; + String playlistString2 = + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-PROGRAM-DATE-TIME:2026-07-14T08:56:00.000Z\n" + + "#EXTINF:6.037333,\n" + + "main0.ts\n" + + "#EXTINF:6.037333,\n" + + "main1.ts" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad-break-12338\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2026-07-14T08:56:17.860Z\"," + + "PLANNED-DURATION=12.074665," + + "X-PLAYOUT-LIMIT=12.074665," + + "X-ASSET-LIST=\"asset-list-two-ads\"," + + "X-SNAP=\"OUT,IN\"," + + "\n" + + "#EXTINF:6.037333,\n" + + "main2.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main3.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main4.ts" + + "\n"; + when(mockPlayer.getContentPosition()).thenReturn(0L); + when(mockPlayer.getCurrentMediaItem()).thenReturn(contentMediaItem); + when(mockPlayer.getCurrentTimeline()).thenReturn(new FakeTimeline(contentWindowDefinition)); + + callHandleContentTimelineChangedForLiveAndCaptureAdPlaybackStates( + adsLoader, + /* startAdsLoader= */ true, + /* windowOffsetInFirstPeriodUs= */ 0, + playlistString, + playlistString2); + + runMainLooperUntil(assetListLoadingListener::completed, TIMEOUT_MS, Clock.DEFAULT); + ArgumentCaptor adPlaybackStateCaptor = + ArgumentCaptor.forClass(AdPlaybackState.class); + verify(mockEventListener, times(3)).onAdPlaybackState(adPlaybackStateCaptor.capture()); + List capturedStates = adPlaybackStateCaptor.getAllValues(); + AdPlaybackState initialState = capturedStates.get(0); + AdPlaybackState firstResolvedState = capturedStates.get(1); + AdPlaybackState secondResolvedState = capturedStates.get(2); + assertThat(initialState.adGroupCount).isEqualTo(2); + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(1); + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(12_074_665L); + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_UNAVAILABLE); + assertThat(firstResolvedState.adGroupCount).isEqualTo(2); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(1); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(12_074_666L); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_UNAVAILABLE); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(2); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_AVAILABLE, AD_STATE_AVAILABLE); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(12_074_666L); + } + + @Test + public void + handleContentTimelineChanged_assetListResolvedWithExplicitResumeOffset_usesExplicitResumeOffsetUs() + throws IOException, TimeoutException { + String playlistString = + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-PROGRAM-DATE-TIME:2026-07-14T08:56:00.000Z\n" + + "#EXTINF:6.037333,\n" + + "main0.ts\n" + + "#EXTINF:6.037333,\n" + + "main1.ts" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad-break-12338\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2026-07-14T08:56:17.860Z\"," + + "PLANNED-DURATION=12.074665," + + "X-PLAYOUT-LIMIT=12.074665," + + "X-RESUME-OFFSET=1.2345," + + "X-ASSET-LIST=\"asset-list-two-ads\"," + + "X-SNAP=\"OUT,IN\"," + + "\n" + + "#EXTINF:6.037333,\n" + + "main2.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main3.ts" + + "\n"; + String playlistString2 = + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-PROGRAM-DATE-TIME:2026-07-14T08:56:00.000Z\n" + + "#EXTINF:6.037333,\n" + + "main0.ts\n" + + "#EXTINF:6.037333,\n" + + "main1.ts" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad-break-12338\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2026-07-14T08:56:17.860Z\"," + + "PLANNED-DURATION=12.074665," + + "X-PLAYOUT-LIMIT=12.074665," + + "X-RESUME-OFFSET=1.2345," + + "X-ASSET-LIST=\"asset-list-two-ads\"," + + "X-SNAP=\"OUT,IN\"," + + "\n" + + "#EXTINF:6.037333,\n" + + "main2.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main3.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main4.ts" + + "\n"; + when(mockPlayer.getContentPosition()).thenReturn(0L); + when(mockPlayer.getCurrentMediaItem()).thenReturn(contentMediaItem); + when(mockPlayer.getCurrentTimeline()).thenReturn(new FakeTimeline(contentWindowDefinition)); + + callHandleContentTimelineChangedForLiveAndCaptureAdPlaybackStates( + adsLoader, + /* startAdsLoader= */ true, + /* windowOffsetInFirstPeriodUs= */ 0, + playlistString, + playlistString2); + + runMainLooperUntil(assetListLoadingListener::completed, TIMEOUT_MS, Clock.DEFAULT); + ArgumentCaptor adPlaybackStateCaptor = + ArgumentCaptor.forClass(AdPlaybackState.class); + verify(mockEventListener, times(2)).onAdPlaybackState(adPlaybackStateCaptor.capture()); + List capturedStates = adPlaybackStateCaptor.getAllValues(); + AdPlaybackState initialState = capturedStates.get(0); + AdPlaybackState firstResolvedState = capturedStates.get(1); + assertThat(initialState.adGroupCount).isEqualTo(2); + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(1); + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(1_234_500L); + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_UNAVAILABLE); + assertThat(firstResolvedState.adGroupCount).isEqualTo(2); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(2); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(1_234_500L); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_AVAILABLE, AD_STATE_AVAILABLE); + } + + @Test + public void + handleContentTimelineChanged_durationChangedByAssetList_deferredCalculationSnapsToSegmentEnd() + throws Exception { + when(mockPlayer.getContentPosition()).thenReturn(0L); + when(mockPlayer.getCurrentMediaItem()).thenReturn(contentMediaItem); + when(mockPlayer.getCurrentTimeline()).thenReturn(new FakeTimeline(contentWindowDefinition)); + + callHandleContentTimelineChangedForLiveAndCaptureAdPlaybackStates( + adsLoader, + /* startAdsLoader= */ true, + /* windowOffsetInFirstPeriodUs= */ 0, + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-PROGRAM-DATE-TIME:2026-07-14T08:56:00.000Z\n" + + "#EXTINF:6.037333,\n" + + "main0.ts\n" + + "#EXTINF:6.037333,\n" + + "main1.ts" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad-break-12338\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2026-07-14T08:56:17.860Z\"," + + "PLANNED-DURATION=12.074665," // Initial duration defined by playlist. + + "X-ASSET-LIST=\"asset-list-two-ads\"," + + "X-SNAP=\"OUT,IN\"," + + "\n" + + "#EXTINF:6.037333,\n" + + "main2.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main3.ts" + + "\n"); + + runMainLooperUntil(assetListLoadingListener::completed, TIMEOUT_MS, Clock.DEFAULT); + ArgumentCaptor adPlaybackStateCaptor = + ArgumentCaptor.forClass(AdPlaybackState.class); + verify(mockEventListener, times(2)).onAdPlaybackState(adPlaybackStateCaptor.capture()); + List capturedStates = adPlaybackStateCaptor.getAllValues(); + AdPlaybackState initialState = capturedStates.get(0); + AdPlaybackState firstResolvedState = capturedStates.get(1); + assertThat(initialState.adGroupCount).isEqualTo(2); + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(1); + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(12_074_665L); // Interstitial duration in the playlist. + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_UNAVAILABLE); + assertThat(firstResolvedState.adGroupCount).isEqualTo(2); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(2); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(12_074_664L); // Snap segment not available: durations from asset list. + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_AVAILABLE, AD_STATE_AVAILABLE); + + reset(mockEventListener); + callHandleContentTimelineChangedForLiveAndCaptureAdPlaybackStates( + adsLoader, + /* startAdsLoader= */ false, + /* windowOffsetInFirstPeriodUs= */ 0, + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-PROGRAM-DATE-TIME:2026-07-14T08:56:00.000Z\n" + + "#EXTINF:6.037333,\n" + + "main0.ts\n" + + "#EXTINF:6.037333,\n" + + "main1.ts" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad-break-12338\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2026-07-14T08:56:17.860Z\"," + + "PLANNED-DURATION=12.074665," // Initial duration defined by playlist. + + "X-ASSET-LIST=\"asset-list-two-ads\"," + + "X-SNAP=\"OUT,IN\"," + + "\n" + + "#EXTINF:6.037333,\n" + + "main2.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main3.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main4.ts" + + "\n"); + + verify(mockEventListener).onAdPlaybackState(adPlaybackStateCaptor.capture()); + AdPlaybackState secondResolvedState = adPlaybackStateCaptor.getValue(); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(2); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_AVAILABLE, AD_STATE_AVAILABLE); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(12_074_666L); // The offset snapped to the end of the segment. + } + + @Test + public void + handleContentTimelineChanged_undefinedDurationChangedByAssetList_deferredCalculationSnapsToSegmentEnd() + throws Exception { + when(mockPlayer.getContentPosition()).thenReturn(0L); + when(mockPlayer.getCurrentMediaItem()).thenReturn(contentMediaItem); + when(mockPlayer.getCurrentTimeline()).thenReturn(new FakeTimeline(contentWindowDefinition)); + + callHandleContentTimelineChangedForLiveAndCaptureAdPlaybackStates( + adsLoader, + /* startAdsLoader= */ true, + /* windowOffsetInFirstPeriodUs= */ 0, + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-PROGRAM-DATE-TIME:2026-07-14T08:56:00.000Z\n" + + "#EXTINF:6.037333,\n" + + "main0.ts\n" + + "#EXTINF:6.037333,\n" + + "main1.ts" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad-break-12338\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2026-07-14T08:56:17.860Z\"," + + "X-ASSET-LIST=\"asset-list-two-ads\"," + + "X-SNAP=\"OUT,IN\"," // Snap requested with undefined duration (defaults to 0). + + "\n" + + "#EXTINF:6.037333,\n" + + "main2.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main3.ts" + + "\n"); + + runMainLooperUntil(assetListLoadingListener::completed, TIMEOUT_MS, Clock.DEFAULT); + ArgumentCaptor adPlaybackStateCaptor = + ArgumentCaptor.forClass(AdPlaybackState.class); + verify(mockEventListener, times(2)).onAdPlaybackState(adPlaybackStateCaptor.capture()); + List capturedStates = adPlaybackStateCaptor.getAllValues(); + AdPlaybackState initialState = capturedStates.get(0); + AdPlaybackState firstResolvedState = capturedStates.get(1); + assertThat(initialState.adGroupCount).isEqualTo(2); + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(1); + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(0); // Undefined duration in the playlist defaults to 0. + assertThat(initialState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_UNAVAILABLE); + assertThat(firstResolvedState.adGroupCount).isEqualTo(2); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(2); + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(12_074_664L); // Snap segment not available: durations from asset list. + assertThat(firstResolvedState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_AVAILABLE, AD_STATE_AVAILABLE); + + reset(mockEventListener); + callHandleContentTimelineChangedForLiveAndCaptureAdPlaybackStates( + adsLoader, + /* startAdsLoader= */ false, + /* windowOffsetInFirstPeriodUs= */ 0, + "#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-PROGRAM-DATE-TIME:2026-07-14T08:56:00.000Z\n" + + "#EXTINF:6.037333,\n" + + "main0.ts\n" + + "#EXTINF:6.037333,\n" + + "main1.ts" + + "\n" + + "#EXT-X-DATERANGE:" + + "ID=\"ad-break-12338\"," + + "CLASS=\"com.apple.hls.interstitial\"," + + "START-DATE=\"2026-07-14T08:56:17.860Z\"," + + "PLANNED-DURATION=12.074665," + + "X-PLAYOUT-LIMIT=12.074665," + + "X-ASSET-LIST=\"asset-list-two-ads\"," + + "X-SNAP=\"OUT,IN\"," // Snap requested with duration available from asset list. + + "\n" + + "#EXTINF:6.037333,\n" + + "main2.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main3.ts" + + "\n" + + "#EXTINF:6.037333,\n" + + "main4.ts" + + "\n"); + + verify(mockEventListener).onAdPlaybackState(adPlaybackStateCaptor.capture()); + AdPlaybackState secondResolvedState = adPlaybackStateCaptor.getValue(); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(2); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_AVAILABLE, AD_STATE_AVAILABLE); + assertThat(secondResolvedState.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(12_074_666L); // The offset snapped to the end of the segment. + // Reset the listener to be able to wait for another asset list resolution to happen. + assetListLoadingListener.reset(); + // Skip ads to allow resetting the asset list. + adsLoader.setWithSkippedAdGroup(/* adGroupIndex= */ 0); + + // Reset the asset list which removes the known durations and recalculates resume offset again. + assertThat(adsLoader.setWithAssetListReset("adsId", /* adGroupIndex= */ 0)).isTrue(); + + verify(mockEventListener, times(3)).onAdPlaybackState(adPlaybackStateCaptor.capture()); + AdPlaybackState adPlaybackStateAfterAssetReset = adPlaybackStateCaptor.getValue(); + assertThat(adPlaybackStateAfterAssetReset.getAdGroup(/* adGroupIndex= */ 0).count).isEqualTo(1); + assertThat(adPlaybackStateAfterAssetReset.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_UNAVAILABLE); + assertThat( + adPlaybackStateAfterAssetReset.getAdGroup(/* adGroupIndex= */ 0).contentResumeOffsetUs) + .isEqualTo(0L); // The offset collapsed because the interstitial duration is unset. + + // Wait for the async asset list resolution to complete... + runMainLooperUntil(assetListLoadingListener::completed, TIMEOUT_MS, Clock.DEFAULT); + // and verify the updated ad playback state that now should have a resume offset calculated with + // the durations declared by the asset list that was fetched again. + verify(mockEventListener, times(4)).onAdPlaybackState(adPlaybackStateCaptor.capture()); + AdPlaybackState adPlaybackStateAfterAssetResolution = adPlaybackStateCaptor.getValue(); + assertThat(adPlaybackStateAfterAssetResolution.getAdGroup(/* adGroupIndex= */ 0).count) + .isEqualTo(2); + assertThat(adPlaybackStateAfterAssetResolution.getAdGroup(/* adGroupIndex= */ 0).states) + .asList() + .containsExactly(AD_STATE_AVAILABLE, AD_STATE_AVAILABLE); + assertThat( + adPlaybackStateAfterAssetResolution.getAdGroup(/* adGroupIndex= */ 0) + .contentResumeOffsetUs) + .isEqualTo(12_074_666L); // The offset snapped to the end of the segment again. + } + @Test public void handleContentTimelineChanged_preRollWithAssetList_resolvesAndSchedulesNextPlayerMessage() @@ -3278,8 +3911,7 @@ public void handleContentTimelineChanged_emptyAssetList_marksAdAsFailedAndSchedu .setUri("http://2") .setMimeType(MimeTypes.APPLICATION_M3U8) .build()) - .withContentResumeOffsetUs( - /* adGroupIndex= */ 0, 3_246_000L + 10_123_000L + 11_123_000L + 12_123_000L)) + .withContentResumeOffsetUs(/* adGroupIndex= */ 0, 33_369_000L)) .inOrder(); } @@ -6486,7 +7118,7 @@ public void getClosestSegmentBoundaryUs_positionBeforeAndAfterPlaylist_getsSanit } @Test - public void removePendingSnapInResolutionUntilIncludingIndex_correctOperations() { + public void addPendingSnapInResolution_withOutOfOrderInserts_maintainsSortedOrder() { Interstitial interstitial = new Interstitial( /* id= */ "ad1", @@ -6511,53 +7143,33 @@ public void removePendingSnapInResolutionUntilIncludingIndex_correctOperations() /* skipControlLabelId= */ null); AdsMediaSourceSessionManager holder = new AdsMediaSourceSessionManager(); holder.startContentSource("adsId", MediaItem.fromUri("http://1"), mockEventListener); - holder.startContentSource("adsId_other", MediaItem.fromUri("http://1"), mockEventListener); - for (int i = 0; i < 10; i++) { + long[] resumeTimesUs = new long[] {25_001L, 20_000L, 10_000L}; + // Add pending snaps out of order. + for (int i = 0; i < resumeTimesUs.length; i++) { holder .getSession("adsId") - .pendingSnapInResolutions - .add( - new PendingSnapInResolution( - /* resumeTimeUs= */ i * 10_000L, - /* adGroupIndex= */ i, - /* interstitial= */ interstitial)); - holder - .getSession("adsId_other") - .pendingSnapInResolutions - .add( - new PendingSnapInResolution( - /* resumeTimeUs= */ i * 10_000L, - /* adGroupIndex= */ i, - /* interstitial= */ interstitial)); + .addPendingSnapInResolution( + /* resumeTimeUs= */ resumeTimesUs[i], + /* adGroupIndex= */ i, + /* interstitial= */ interstitial); } - assertThat(holder.getSession("adsId").pendingSnapInResolutions).hasSize(10); - assertThat(holder.getSession("adsId_other").pendingSnapInResolutions).hasSize(10); - - holder - .getSession("adsId") - .removePendingSnapInResolutionUntilIndexInclusive(/* resolvedIndex= */ 4); - holder - .getSession("adsId_other") - .removePendingSnapInResolutionUntilIndexInclusive(/* resolvedIndex= */ 4); + assertThat(holder.getSession("adsId").pendingSnapInResolutions).hasSize(3); + assertThat(holder.getSession("adsId").pendingSnapInResolutions.keySet()) + .containsExactly(10_000L, 20_000L, 25_001L) + .inOrder(); - assertThat(holder.getSession("adsId").pendingSnapInResolutions).hasSize(5); - assertThat(holder.getSession("adsId_other").pendingSnapInResolutions).hasSize(5); + // Get all snaps before and including a given position (like the end of the playlist). + NavigableMap headMap = + holder.getSession("adsId").pendingSnapInResolutions.headMap(25_000L, /* inclusive= */ true); - holder - .getSession("adsId") - .removePendingSnapInResolutionUntilIndexInclusive(/* resolvedIndex= */ 4); - holder - .getSession("adsId_other") - .removePendingSnapInResolutionUntilIndexInclusive(/* resolvedIndex= */ 1234); - - assertThat(holder.getSession("adsId").pendingSnapInResolutions).isEmpty(); - assertThat(holder.getSession("adsId_other").pendingSnapInResolutions).isEmpty(); - assertThrows( - IllegalArgumentException.class, - () -> - holder - .getSession("adsId") - .removePendingSnapInResolutionUntilIndexInclusive(/* resolvedIndex= */ -1)); + Iterator> iterator = headMap.entrySet().iterator(); + while (iterator.hasNext()) { + iterator.next(); + iterator.remove(); + } + assertThat(holder.getSession("adsId").pendingSnapInResolutions).hasSize(1); + assertThat(holder.getSession("adsId").pendingSnapInResolutions.keySet()) + .containsExactly(25_001L); } @Test @@ -8068,6 +8680,20 @@ public byte[] resolve(Uri uri) { /* skipInfoLabelId= */ "skip_label_from_json"); case "http://slow_loading": return getJsonAssetList(/* assetCount= */ 1, /* delayMs= */ 150); + case "asset-list-two-ads": + return ("{\n" + + " \"ASSETS\": [\n" + + " {\n" + + " \"URI\": \"http://example.com/ad/1\",\n" + + " \"DURATION\": 6.037332\n" + + " },\n" + + " {\n" + + " \"URI\": \"http://example.com/ad/2\",\n" + + " \"DURATION\": 6.037332\n" + + " }\n" + + " ]\n" + + "}\n") + .getBytes(Charset.defaultCharset()); default: return getJsonAssetList(/* assetCount= */ 1, /* delayMs= */ 0); } diff --git a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsMediaChunkTest.java b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsMediaChunkTest.java new file mode 100644 index 00000000000..059a29c0cf9 --- /dev/null +++ b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsMediaChunkTest.java @@ -0,0 +1,207 @@ +/* + * Copyright 2026 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 androidx.media3.exoplayer.hls; + +import static com.google.common.truth.Truth.assertThat; +import static org.junit.Assert.assertThrows; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import android.net.Uri; +import androidx.media3.common.C; +import androidx.media3.common.Format; +import androidx.media3.common.ParserException; +import androidx.media3.exoplayer.analytics.PlayerId; +import androidx.media3.exoplayer.drm.DrmSessionEventListener; +import androidx.media3.exoplayer.drm.DrmSessionManager; +import androidx.media3.exoplayer.hls.playlist.HlsMediaPlaylist; +import androidx.media3.exoplayer.source.MediaSourceEventListener; +import androidx.media3.exoplayer.upstream.Allocator; +import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy; +import androidx.media3.extractor.ExtractorInput; +import androidx.media3.test.utils.FakeDataSource; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import java.io.EOFException; +import java.io.IOException; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; + +/** Unit tests for {@link HlsMediaChunk}. */ +@RunWith(AndroidJUnit4.class) +public final class HlsMediaChunkTest { + + @Rule public final MockitoRule mockito = MockitoJUnit.rule(); + + @Mock private HlsMediaChunkExtractor mockExtractor; + @Mock private HlsExtractorFactory extractorFactory; + + @Before + public void setUp() throws Exception { + when(mockExtractor.isReusable()).thenReturn(true); + when(extractorFactory.createExtractor(any(), any(), any(), any(), any(), any(), any())) + .thenReturn(mockExtractor); + } + + @Test + public void load_extractorThrowsEOFExceptionAfterFullyLoadedChunk_throwsParserException() + throws Exception { + when(mockExtractor.read(any(ExtractorInput.class))) + .thenAnswer( + invocation -> { + ExtractorInput input = invocation.getArgument(0); + input.skipFully(100); + throw new EOFException(); + }); + HlsMediaPlaylist.Segment segment = + new HlsMediaPlaylist.Segment( + "https://example.com/segment.ts", + /* byteRangeOffset= */ 0, + /* byteRangeLength= */ 100, // Explicit finite length + /* fullSegmentEncryptionKeyUri= */ null, + /* encryptionIV= */ null); + HlsMediaChunk mediaChunk = createChunkWithSegment(extractorFactory, segment); + + ParserException exception = assertThrows(ParserException.class, mediaChunk::load); + assertThat(exception).hasCauseThat().isInstanceOf(EOFException.class); + } + + @Test + public void load_extractorThrowsEOFExceptionBeforeFullyLoadedChunk_propagatesEOFException() + throws Exception { + when(mockExtractor.read(any(ExtractorInput.class))) + .thenAnswer( + invocation -> { + ExtractorInput input = invocation.getArgument(0); + input.skipFully(50); // Premature read (less than segment's 100 length) + throw new EOFException(); + }); + HlsMediaPlaylist.Segment segment = + new HlsMediaPlaylist.Segment( + "https://example.com/segment.ts", + /* byteRangeOffset= */ 0, + /* byteRangeLength= */ 100, + /* fullSegmentEncryptionKeyUri= */ null, + /* encryptionIV= */ null); + HlsMediaChunk mediaChunk = createChunkWithSegment(extractorFactory, segment); + + assertThrows(EOFException.class, mediaChunk::load); + } + + @Test + public void load_extractorThrowsEOFExceptionForUnsetLengthChunk_propagatesEOFException() + throws Exception { + when(mockExtractor.read(any(ExtractorInput.class))) + .thenAnswer( + invocation -> { + throw new EOFException(); + }); + HlsMediaPlaylist.Segment segment = + new HlsMediaPlaylist.Segment( + "https://example.com/segment.ts", + /* byteRangeOffset= */ 0, + /* byteRangeLength= */ C.LENGTH_UNSET, // Unset length + /* fullSegmentEncryptionKeyUri= */ null, + /* encryptionIV= */ null); + HlsMediaChunk mediaChunk = createChunkWithSegment(extractorFactory, segment); + + assertThrows(EOFException.class, mediaChunk::load); + } + + private static HlsMediaChunk createChunkWithSegment( + HlsExtractorFactory extractorFactory, HlsMediaPlaylist.Segment segment) throws IOException { + HlsMediaPlaylist mediaPlaylist = + new HlsMediaPlaylist( + HlsMediaPlaylist.PLAYLIST_TYPE_UNKNOWN, + /* baseUri= */ "http://example.com/", + /* tags= */ ImmutableList.of(), + /* startOffsetUs= */ C.TIME_UNSET, + /* preciseStart= */ false, + /* startTimeUs= */ 0L, + /* hasDiscontinuitySequence= */ false, + /* discontinuitySequence= */ 0, + /* mediaSequence= */ 0L, + /* version= */ 7, + /* targetDurationUs= */ 4_000_000L, + /* partTargetDurationUs= */ C.TIME_UNSET, + /* hasIndependentSegments= */ true, + /* hasEndTag= */ false, + /* hasProgramDateTime= */ false, + /* protectionSchemes= */ null, + /* segments= */ ImmutableList.of(segment), + /* trailingParts= */ ImmutableList.of(), + new HlsMediaPlaylist.ServerControl( + /* skipUntilUs= */ C.TIME_UNSET, + /* canSkipDateRanges= */ false, + /* holdBackUs= */ C.TIME_UNSET, + /* partHoldBackUs= */ C.TIME_UNSET, + /* canBlockReload= */ false), + /* renditionReports= */ ImmutableMap.of(), + /* interstitials= */ ImmutableList.of(), + /* lastSeenInitSegment= */ null); + FakeDataSource fakeDataSource = new FakeDataSource(); + fakeDataSource.getDataSet().newDefaultData().appendReadData(100).endData(); + HlsMediaChunk mediaChunk = + HlsMediaChunk.createInstance( + extractorFactory, + fakeDataSource, + new Format.Builder().build(), + /* startOfPlaylistInPeriodUs= */ 0, + mediaPlaylist, + new HlsChunkSource.SegmentBaseHolder( + segment, /* mediaSequence= */ 1, /* partIndex= */ 0), + Uri.parse("https://playlist.uri/"), + /* steeredPathwayId= */ null, + /* muxedCaptionFormats= */ null, + C.SELECTION_REASON_UNKNOWN, + /* trackSelectionData= */ null, + /* isPrimaryTimestampSource= */ true, + new TimestampAdjusterProvider(), + /* timestampAdjusterInitializationTimeoutMs= */ 0, + /* previousChunk= */ null, + /* mediaSegmentKey= */ null, + /* initSegmentKey= */ null, + /* shouldSpliceIn= */ false, + /* isIndependent= */ true, + PlayerId.UNSET, + /* cmcdDataFactory= */ null); + HlsSampleStreamWrapper sampleStreamWrapper = + new HlsSampleStreamWrapper( + /* uid= */ "", + C.TRACK_TYPE_VIDEO, + mock(HlsSampleStreamWrapper.Callback.class), + mock(HlsChunkSource.class), + /* overridingDrmInitData= */ ImmutableMap.of(), + mock(Allocator.class), + /* positionUs= */ 0, + /* muxedAudioFormat= */ null, + mock(DrmSessionManager.class), + mock(DrmSessionEventListener.EventDispatcher.class), + mock(LoadErrorHandlingPolicy.class), + mock(MediaSourceEventListener.EventDispatcher.class), + /* metadataType= */ HlsMediaSource.METADATA_TYPE_ID3, + /* downloadExecutor= */ null); + mediaChunk.init(sampleStreamWrapper, ImmutableList.of()); + return mediaChunk; + } +} diff --git a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsMediaPeriodTest.java b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsMediaPeriodTest.java index 1ea8a2b4a1a..eba8642f711 100644 --- a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsMediaPeriodTest.java +++ b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsMediaPeriodTest.java @@ -70,33 +70,6 @@ public final class HlsMediaPeriodTest { @Test public void getSteamKeys_isCompatibleWithHlsMultivariantPlaylistFilter() { - HlsMultivariantPlaylist testMultivariantPlaylist = - createMultivariantPlaylist( - /* variants= */ Arrays.asList( - createAudioOnlyVariant(Uri.parse("https://variant1"), /* peakBitrate= */ 10000), - createMuxedVideoAudioVariant( - Uri.parse("https://variant2"), /* peakBitrate= */ 200000), - createMuxedVideoAudioVariant( - Uri.parse("https://backup/variant2"), /* peakBitrate= */ 200000), - createAudioOnlyVariant(Uri.parse("https://variant3"), /* peakBitrate= */ 300000), - createMuxedVideoAudioVariant( - Uri.parse("https://variant4"), /* peakBitrate= */ 400000), - createMuxedVideoAudioVariant( - Uri.parse("https://variant5"), /* peakBitrate= */ 600000)), - /* audios= */ Arrays.asList( - createAudioRendition(Uri.parse("https://audio1"), /* language= */ "spa"), - createAudioRendition(Uri.parse("https://backup/audio1"), /* language= */ "spa"), - createAudioRendition(Uri.parse("https://audio2"), /* language= */ "ger"), - createAudioRendition(Uri.parse("https://audio3"), /* language= */ "tur")), - /* subtitles= */ Arrays.asList( - createSubtitleRendition(Uri.parse("https://subtitle1"), /* language= */ "spa"), - createSubtitleRendition( - Uri.parse("https://backup/subtitle1"), /* language= */ "spa"), - createSubtitleRendition(Uri.parse("https://subtitle2"), /* language= */ "ger"), - createSubtitleRendition(Uri.parse("https://subtitle3"), /* language= */ "tur")), - /* muxedAudioFormat= */ createAudioFormat("eng"), - /* muxedCaptionFormats= */ Arrays.asList( - createSubtitleFormat("eng"), createSubtitleFormat("gsw"))); FilterableManifestMediaPeriodFactory mediaPeriodFactory = (playlist, periodIndex) -> { HlsExtractorFactory mockHlsExtractorFactory = mock(HlsExtractorFactory.class); @@ -129,11 +102,60 @@ public void getSteamKeys_isCompatibleWithHlsMultivariantPlaylistFilter() { /* downloadExecutorSupplier= */ null); }; + HlsMultivariantPlaylist testMultivariantPlaylist = + createMultivariantPlaylist( + /* variants= */ Arrays.asList( + createAudioOnlyVariant(Uri.parse("https://variant1"), /* peakBitrate= */ 10000), + createMuxedVideoAudioVariant( + Uri.parse("https://variant2"), /* peakBitrate= */ 200000), + createMuxedVideoAudioVariant( + Uri.parse("https://backup/variant2"), /* peakBitrate= */ 200000), + createAudioOnlyVariant(Uri.parse("https://variant3"), /* peakBitrate= */ 300000), + createMuxedVideoAudioVariant( + Uri.parse("https://variant4"), /* peakBitrate= */ 400000), + createMuxedVideoAudioVariant( + Uri.parse("https://variant5"), /* peakBitrate= */ 600000)), + /* audios= */ Arrays.asList( + createAudioRendition(Uri.parse("https://audio1"), /* language= */ "spa"), + createAudioRendition(Uri.parse("https://backup/audio1"), /* language= */ "spa"), + createAudioRendition(Uri.parse("https://audio2"), /* language= */ "ger"), + createAudioRendition(Uri.parse("https://audio3"), /* language= */ "tur")), + /* subtitles= */ Arrays.asList( + createSubtitleRendition(Uri.parse("https://subtitle1"), /* language= */ "spa"), + createSubtitleRendition( + Uri.parse("https://backup/subtitle1"), /* language= */ "spa"), + createSubtitleRendition(Uri.parse("https://subtitle2"), /* language= */ "ger"), + createSubtitleRendition(Uri.parse("https://subtitle3"), /* language= */ "tur")), + /* muxedAudioFormat= */ createAudioFormat("eng"), + /* muxedCaptionFormats= */ Arrays.asList( + createSubtitleFormat("eng"), createSubtitleFormat("gsw"))); MediaPeriodAsserts.assertGetStreamKeysAndManifestFilterIntegration( mediaPeriodFactory, testMultivariantPlaylist, /* periodIndex= */ 0, /* ignoredMimeType= */ APPLICATION_ID3); + + HlsMultivariantPlaylist testMultivariantPlaylistWithoutSubtitles = + createMultivariantPlaylist( + /* variants= */ Arrays.asList( + createAudioOnlyVariant(Uri.parse("https://variant1"), /* peakBitrate= */ 10000), + createMuxedVideoAudioVariant( + Uri.parse("https://variant2"), /* peakBitrate= */ 200000), + createAudioOnlyVariant(Uri.parse("https://variant3"), /* peakBitrate= */ 300000), + createMuxedVideoAudioVariant( + Uri.parse("https://variant4"), /* peakBitrate= */ 400000)), + /* audios= */ Arrays.asList( + createAudioRendition(Uri.parse("https://audio1"), /* language= */ "spa"), + createAudioRendition(Uri.parse("https://audio2"), /* language= */ "ger")), + /* subtitles= */ ImmutableList.of(), + /* muxedAudioFormat= */ createAudioFormat("eng"), + /* muxedCaptionFormats= */ Arrays.asList( + createSubtitleFormat("eng"), createSubtitleFormat("gsw"))); + MediaPeriodAsserts.assertGetStreamKeysAndManifestFilterIntegration( + mediaPeriodFactory, + testMultivariantPlaylistWithoutSubtitles, + /* periodIndex= */ 0, + /* ignoredMimeType= */ APPLICATION_ID3); } @Test @@ -332,7 +354,8 @@ private static Format createSubtitleFormat(String language) { private LoadErrorHandlingPolicy.LoadErrorInfo createFakeLoadErrorInfo( DataSpec dataSpec, int httpResponseCode, int errorCount) { LoadEventInfo loadEventInfo = - new LoadEventInfo(/* loadTaskId= */ 0, dataSpec, SystemClock.elapsedRealtime()); + new LoadEventInfo.Builder(/* loadTaskId= */ 0, dataSpec, SystemClock.elapsedRealtime()) + .build(); MediaLoadData mediaLoadData = new MediaLoadData(C.DATA_TYPE_MEDIA); HttpDataSource.InvalidResponseCodeException invalidResponseCodeException = new HttpDataSource.InvalidResponseCodeException( diff --git a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsPreloadMediaSourceTest.java b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsPreloadMediaSourceTest.java index f993cabf81a..2dba372a3bc 100644 --- a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsPreloadMediaSourceTest.java +++ b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsPreloadMediaSourceTest.java @@ -128,7 +128,7 @@ public void preload_loadPeriodToTargetPreloadPosition() throws Exception { }); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -164,7 +164,7 @@ public void preload_stopWhenTracksSelectedByPreloadControl() throws Exception { }); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -200,7 +200,7 @@ public void preload_stopWhenSourcePreparedByPreloadControl() throws Exception { }); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -237,7 +237,7 @@ public void preload_loadToTheEndOfSource() throws Exception { .onLoadedToTheEndOfSource(any()); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); PreloadMediaSource.Factory preloadMediaSourceFactory = new PreloadMediaSource.Factory( mediaSourceFactory, @@ -277,7 +277,7 @@ public void preload_withSmallTargetBufferBytesThreshold_onLoadingUnableToContinu .onLoadedToTheEndOfSource(any()); TrackSelector trackSelector = new DefaultTrackSelector(ApplicationProvider.getApplicationContext()); - trackSelector.init(() -> {}, bandwidthMeter); + trackSelector.init(unused -> {}, bandwidthMeter); LoadControl loadControl = mock( LoadControl.class, diff --git a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsSampleStreamWrapperTest.java b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsSampleStreamWrapperTest.java new file mode 100644 index 00000000000..1e0e92252ff --- /dev/null +++ b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/HlsSampleStreamWrapperTest.java @@ -0,0 +1,189 @@ +/* + * Copyright 2026 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 androidx.media3.exoplayer.hls; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.util.concurrent.MoreExecutors.directExecutor; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyBoolean; +import static org.mockito.ArgumentMatchers.anyLong; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; +import static org.robolectric.Shadows.shadowOf; + +import android.net.Uri; +import android.os.Looper; +import androidx.media3.common.C; +import androidx.media3.common.Format; +import androidx.media3.common.TrackGroup; +import androidx.media3.exoplayer.LoadingInfo; +import androidx.media3.exoplayer.analytics.PlayerId; +import androidx.media3.exoplayer.drm.DrmSessionEventListener; +import androidx.media3.exoplayer.drm.DrmSessionManager; +import androidx.media3.exoplayer.hls.playlist.HlsMediaPlaylist; +import androidx.media3.exoplayer.source.MediaSourceEventListener; +import androidx.media3.exoplayer.upstream.Allocator; +import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy; +import androidx.media3.exoplayer.util.ReleasableExecutor; +import androidx.media3.test.utils.FakeDataSource; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; + +/** Unit tests for {@link HlsSampleStreamWrapper}. */ +@RunWith(AndroidJUnit4.class) +public final class HlsSampleStreamWrapperTest { + + @Rule public final MockitoRule mockito = MockitoJUnit.rule(); + + @Mock private HlsExtractorFactory mockExtractorFactory; + @Mock private HlsChunkSource mockChunkSource; + + @Before + public void setUp() throws Exception { + HlsMediaChunkExtractor mockExtractor = mock(HlsMediaChunkExtractor.class); + when(mockExtractorFactory.createExtractor(any(), any(), any(), any(), any(), any(), any())) + .thenReturn(mockExtractor); + // Extractor returns false for read to signal mock end-of-stream and complete load successfully + when(mockExtractor.read(any())).thenReturn(false); + } + + @Test + public void discardUpstream_allChunksDiscarded_keepLoadingFromStartPositionOfFirstDroppedChunk() { + HlsSampleStreamWrapper sampleStreamWrapper = + new HlsSampleStreamWrapper( + /* uid= */ "uid", + C.TRACK_TYPE_VIDEO, + mock(HlsSampleStreamWrapper.Callback.class), + mockChunkSource, + /* overridingDrmInitData= */ ImmutableMap.of(), + mock(Allocator.class), + /* positionUs= */ 0L, + /* muxedAudioFormat= */ null, + mock(DrmSessionManager.class), + mock(DrmSessionEventListener.EventDispatcher.class), + mock(LoadErrorHandlingPolicy.class), + mock(MediaSourceEventListener.EventDispatcher.class), + /* metadataType= */ HlsMediaSource.METADATA_TYPE_ID3, + /* downloadExecutor= */ ReleasableExecutor.from(directExecutor(), e -> {})); + sampleStreamWrapper.prepareWithMultivariantPlaylistInfo( + new TrackGroup[] {new TrackGroup(new Format.Builder().build())}, + /* primaryTrackGroupIndex= */ 0); + // Create a Part with start time at 1_000_000L and duration of 1_000_000L. + HlsMediaPlaylist.Part part = + new HlsMediaPlaylist.Part( + /* url= */ "part1.ts", + /* initializationSegment= */ null, + /* durationUs= */ 1_000_000L, + /* relativeDiscontinuitySequence= */ 0, + /* relativeStartTimeUs= */ 1_000_000L, + /* drmInitData= */ null, + /* fullSegmentEncryptionKeyUri= */ null, + /* encryptionIV= */ null, + /* byteRangeOffset= */ 0, + /* byteRangeLength= */ C.LENGTH_UNSET, + /* hasGapTag= */ false, + /* isIndependent= */ true, + /* isPreload= */ false); + HlsMediaPlaylist playlist = + new HlsMediaPlaylist( + HlsMediaPlaylist.PLAYLIST_TYPE_UNKNOWN, + /* baseUri= */ "http://example.com/", + /* tags= */ ImmutableList.of(), + /* startOffsetUs= */ C.TIME_UNSET, + /* preciseStart= */ false, + /* startTimeUs= */ 0L, + /* hasDiscontinuitySequence= */ false, + /* discontinuitySequence= */ 0, + /* mediaSequence= */ 0L, + /* version= */ 7, + /* targetDurationUs= */ 4_000_000L, + /* partTargetDurationUs= */ C.TIME_UNSET, + /* hasIndependentSegments= */ true, + /* hasEndTag= */ false, + /* hasProgramDateTime= */ false, + /* protectionSchemes= */ null, + /* segments= */ ImmutableList.of(), + /* trailingParts= */ ImmutableList.of(part), + new HlsMediaPlaylist.ServerControl( + /* skipUntilUs= */ C.TIME_UNSET, + /* canSkipDateRanges= */ false, + /* holdBackUs= */ C.TIME_UNSET, + /* partHoldBackUs= */ C.TIME_UNSET, + /* canBlockReload= */ false), + /* renditionReports= */ ImmutableMap.of(), + /* interstitials= */ ImmutableList.of(), + /* lastSeenInitSegment= */ null); + FakeDataSource fakeDataSource = new FakeDataSource(); + fakeDataSource.getDataSet().newDefaultData().appendReadData(10).endData(); + HlsMediaChunk chunk = + HlsMediaChunk.createInstance( + mockExtractorFactory, + fakeDataSource, + new Format.Builder().build(), + /* startOfPlaylistInPeriodUs= */ 0L, + playlist, + new HlsChunkSource.SegmentBaseHolder( + playlist.trailingParts.get(0), /* mediaSequence= */ 0, /* partIndex= */ 0), + Uri.parse("http://example.com/part1.ts"), + /* steeredPathwayId= */ null, + /* muxedCaptionFormats= */ null, + C.SELECTION_REASON_INITIAL, + /* trackSelectionData= */ null, + /* isPrimaryTimestampSource= */ true, + new TimestampAdjusterProvider(), + /* timestampAdjusterInitializationTimeoutMs= */ 0, + /* previousChunk= */ null, + /* mediaSegmentKey= */ null, + /* initSegmentKey= */ null, + /* shouldSpliceIn= */ false, + /* isIndependent= */ true, + PlayerId.UNSET, + /* cmcdDataFactory= */ null); + doAnswer( + invocation -> { + HlsChunkSource.HlsChunkHolder chunkHolder = invocation.getArgument(5); + chunkHolder.chunk = chunk; + return null; + }) + .when(mockChunkSource) + .getNextChunk(any(), anyLong(), anyLong(), any(), anyBoolean(), any()); + // Call continueLoading to add the chunk to mediaChunks queue + sampleStreamWrapper.continueLoading(new LoadingInfo.Builder().setPlaybackPositionUs(0).build()); + shadowOf(Looper.getMainLooper()).idle(); + // Next load position should be 2_000_000L + assertThat(sampleStreamWrapper.getNextLoadPositionUs()).isEqualTo(2_000_000L); + // Stub mockChunkSource to mark the chunk as removed during reevaluation + when(mockChunkSource.shouldCancelLoad(anyLong(), any(), any())).thenReturn(false); + when(mockChunkSource.getChunkPublicationState(chunk)) + .thenReturn(HlsChunkSource.CHUNK_PUBLICATION_STATE_REMOVED); + + // Call reevaluateBuffer to trigger discardUpstream, assuming the playback position is 500ms. + sampleStreamWrapper.reevaluateBuffer(/* positionUs= */ 500_000L); + + // Since the chunk was discarded and the chunk queue is empty, the next load position should + // be reset to the start position of the first chunk dropped. + assertThat(sampleStreamWrapper.getNextLoadPositionUs()).isEqualTo(1_000_000L); + } +} diff --git a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/offline/HlsDownloaderTest.java b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/offline/HlsDownloaderTest.java index 207b50ee80f..f59da5233d5 100644 --- a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/offline/HlsDownloaderTest.java +++ b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/offline/HlsDownloaderTest.java @@ -33,6 +33,7 @@ import static androidx.media3.test.utils.CacheAsserts.assertCacheEmpty; import static androidx.media3.test.utils.CacheAsserts.assertCachedData; import static com.google.common.truth.Truth.assertThat; +import static java.nio.charset.StandardCharsets.UTF_8; import android.net.Uri; import androidx.media3.common.C; @@ -290,6 +291,162 @@ public void downloadEncMediaPlaylist() throws Exception { assertCachedData(cache, fakeDataSet); } + @Test + public void download_withVariableSubstitutionInSegmentUrls_resolvesVariables() throws Exception { + // Multivariant playlist defines a variable via EXT-X-DEFINE NAME/VALUE + byte[] multivariantPlaylistData = + ("#EXTM3U\n" + + "#EXT-X-DEFINE:NAME=\"cdnPrefix\",VALUE=\"https://cdn.example.com/\"\n" + + "#EXT-X-STREAM-INF:BANDWIDTH=232370,CODECS=\"mp4a.40.2, avc1.4d4015\"\n" + + "media_with_vars.m3u8\n") + .getBytes(UTF_8); + // Media playlist uses the variable in segment URLs with IMPORT + byte[] mediaPlaylistData = + ("#EXTM3U\n" + + "#EXT-X-TARGETDURATION:10\n" + + "#EXT-X-VERSION:8\n" + + "#EXT-X-MEDIA-SEQUENCE:0\n" + + "#EXT-X-PLAYLIST-TYPE:VOD\n" + + "#EXT-X-DEFINE:IMPORT=\"cdnPrefix\"\n" + + "#EXTINF:9.97667,\n" + + "{$cdnPrefix}segment0.ts\n" + + "#EXTINF:9.97667,\n" + + "{$cdnPrefix}segment1.ts\n" + + "#EXT-X-ENDLIST") + .getBytes(UTF_8); + fakeDataSet = + new FakeDataSet() + .setData("master_vars.m3u8", multivariantPlaylistData) + .setData("media_with_vars.m3u8", mediaPlaylistData) + .setRandomData("https://cdn.example.com/segment0.ts", 10) + .setRandomData("https://cdn.example.com/segment1.ts", 11); + // Create a downloader with CacheDataSource for validating downloaded data. + HlsDownloader downloader = + getHlsDownloader(/* mediaPlaylistUri= */ "master_vars.m3u8", getKeys(0)); + + downloader.download(progressListener); + + // Verify segments were downloaded with resolved URLs + assertCachedData(cache, fakeDataSet); + } + + @Test + public void download_withMultipleVariablesInSegmentUrls_resolvesAllVariables() throws Exception { + // Multivariant playlist defines multiple variables. + byte[] multivariantPlaylistData = + ("#EXTM3U\n" + + "#EXT-X-DEFINE:NAME=\"contentPrefix\",VALUE=\"https://media.example.com/\"\n" + + "#EXT-X-DEFINE:NAME=\"sessionId\",VALUE=\"abc123\"\n" + + "#EXT-X-STREAM-INF:BANDWIDTH=500000,CODECS=\"avc1.4d401f,mp4a.40.2\"\n" + + "{$contentPrefix}video/720p.m3u8?sid={$sessionId}\n") + .getBytes(UTF_8); + // Media playlist imports and uses both variables. + byte[] mediaPlaylistData = + ("#EXTM3U\n" + + "#EXT-X-TARGETDURATION:6\n" + + "#EXT-X-VERSION:8\n" + + "#EXT-X-MEDIA-SEQUENCE:0\n" + + "#EXT-X-PLAYLIST-TYPE:VOD\n" + + "#EXT-X-DEFINE:IMPORT=\"contentPrefix\"\n" + + "#EXT-X-DEFINE:IMPORT=\"sessionId\"\n" + + "#EXTINF:6.0,\n" + + "{$contentPrefix}seg/s0.ts?sid={$sessionId}\n" + + "#EXTINF:6.0,\n" + + "{$contentPrefix}seg/s1.ts?sid={$sessionId}\n" + + "#EXT-X-ENDLIST") + .getBytes(UTF_8); + fakeDataSet = + new FakeDataSet() + .setData("master_multi_vars.m3u8", multivariantPlaylistData) + .setData("https://media.example.com/video/720p.m3u8?sid=abc123", mediaPlaylistData) + .setRandomData("https://media.example.com/seg/s0.ts?sid=abc123", 10) + .setRandomData("https://media.example.com/seg/s1.ts?sid=abc123", 11); + // Create a downloader with CacheDataSource for validating downloaded data. + HlsDownloader downloader = + getHlsDownloader(/* mediaPlaylistUri= */ "master_multi_vars.m3u8", getKeys(0)); + + downloader.download(progressListener); + + // Verify variables have been inserted into URIs correctly. + assertCachedData(cache, fakeDataSet); + } + + @Test + public void download_withVariableInChildManifestUri_resolvesVariables() throws Exception { + // Multivariant playlist uses variable in the child manifest URI itself + byte[] multivariantPlaylistData = + ("#EXTM3U\n" + + "#EXT-X-DEFINE:NAME=\"manifestBase\",VALUE=\"https://manifest.example.com/\"\n" + + "#EXT-X-DEFINE:NAME=\"segmentBase\",VALUE=\"https://segments.example.com/\"\n" + + "#EXT-X-STREAM-INF:BANDWIDTH=128000,CODECS=\"mp4a.40.2\"\n" + + "{$manifestBase}audio/playlist.m3u8\n") + .getBytes(UTF_8); + // Media playlist uses a different variable for segment URLs + byte[] mediaPlaylistData = + ("#EXTM3U\n" + + "#EXT-X-TARGETDURATION:10\n" + + "#EXT-X-VERSION:8\n" + + "#EXT-X-MEDIA-SEQUENCE:0\n" + + "#EXT-X-PLAYLIST-TYPE:VOD\n" + + "#EXT-X-DEFINE:IMPORT=\"segmentBase\"\n" + + "#EXTINF:10.0,\n" + + "{$segmentBase}audio/chunk_0.ts\n" + + "#EXTINF:10.0,\n" + + "{$segmentBase}audio/chunk_1.ts\n" + + "#EXT-X-ENDLIST") + .getBytes(UTF_8); + fakeDataSet = + new FakeDataSet() + .setData("master_child_var.m3u8", multivariantPlaylistData) + .setData("https://manifest.example.com/audio/playlist.m3u8", mediaPlaylistData) + .setRandomData("https://segments.example.com/audio/chunk_0.ts", 10) + .setRandomData("https://segments.example.com/audio/chunk_1.ts", 11); + // Create a downloader with CacheDataSource for validating downloaded data. + HlsDownloader downloader = + getHlsDownloader(/* mediaPlaylistUri= */ "master_child_var.m3u8", getKeys(0)); + + downloader.download(progressListener); + + assertCachedData(cache, fakeDataSet); + } + + @Test + public void download_withVariableInEncryptionKeyUri_resolvesVariables() throws Exception { + // Multivariant playlist defines a variable for the key base URL + byte[] multivariantPlaylistData = + ("#EXTM3U\n" + + "#EXT-X-DEFINE:NAME=\"keyBase\",VALUE=\"https://keys.example.com/\"\n" + + "#EXT-X-STREAM-INF:BANDWIDTH=232370,CODECS=\"mp4a.40.2, avc1.4d4015\"\n" + + "media_with_key_var.m3u8\n") + .getBytes(UTF_8); + // Media playlist imports the variable and uses it in the EXT-X-KEY URI + byte[] mediaPlaylistData = + ("#EXTM3U\n" + + "#EXT-X-TARGETDURATION:10\n" + + "#EXT-X-VERSION:8\n" + + "#EXT-X-MEDIA-SEQUENCE:0\n" + + "#EXT-X-PLAYLIST-TYPE:VOD\n" + + "#EXT-X-DEFINE:IMPORT=\"keyBase\"\n" + + "#EXT-X-KEY:METHOD=AES-128,URI=\"{$keyBase}enc.key\"\n" + + "#EXTINF:9.97667,\n" + + "segment0.ts\n" + + "#EXT-X-ENDLIST") + .getBytes(UTF_8); + fakeDataSet = + new FakeDataSet() + .setData("master_key_var.m3u8", multivariantPlaylistData) + .setData("media_with_key_var.m3u8", mediaPlaylistData) + .setRandomData("https://keys.example.com/enc.key", 8) + .setRandomData("segment0.ts", 10); + // Create a downloader with CacheDataSource for validating downloaded data. + HlsDownloader downloader = + getHlsDownloader(/* mediaPlaylistUri= */ "master_key_var.m3u8", getKeys(0)); + + downloader.download(progressListener); + + assertCachedData(cache, fakeDataSet); + } + private HlsDownloader getHlsDownloader(String mediaPlaylistUri, List keys) { CacheDataSource.Factory cacheDataSourceFactory = new CacheDataSource.Factory() diff --git a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/playlist/DefaultHlsPlaylistTrackerTest.java b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/playlist/DefaultHlsPlaylistTrackerTest.java index 804fe55c348..f5d6221a7bf 100644 --- a/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/playlist/DefaultHlsPlaylistTrackerTest.java +++ b/libraries/exoplayer_hls/src/test/java/androidx/media3/exoplayer/hls/playlist/DefaultHlsPlaylistTrackerTest.java @@ -16,12 +16,24 @@ package androidx.media3.exoplayer.hls.playlist; import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth.assertWithMessage; import static com.google.common.util.concurrent.MoreExecutors.directExecutor; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyBoolean; +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; import android.net.Uri; import androidx.annotation.Nullable; +import androidx.media3.common.C; +import androidx.media3.common.util.Util; import androidx.media3.datasource.DataSource; import androidx.media3.datasource.DefaultHttpDataSource; +import androidx.media3.exoplayer.source.LoadEventInfo; +import androidx.media3.exoplayer.source.MediaLoadData; import androidx.media3.exoplayer.source.MediaSourceEventListener; import androidx.media3.exoplayer.upstream.BandwidthMeter; import androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicy; @@ -32,6 +44,7 @@ import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; import com.google.common.base.Supplier; +import com.google.common.collect.ImmutableSet; import java.io.IOException; import java.util.ArrayList; import java.util.List; @@ -46,6 +59,7 @@ import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; /** Unit test for {@link DefaultHlsPlaylistTracker}. */ @RunWith(AndroidJUnit4.class) @@ -584,6 +598,75 @@ public boolean onPlaylistError( assertThat(mediaPlaylists.get(1).trailingParts).hasSize(2); } + @Test + public void start_refreshScheduledButNotExecutedForNonPlayingPlaylist() throws Exception { + List httpUrls = + enqueueWebServerResponses( + new String[] { + "/multivariant.m3u8", + "/media0/playlist.m3u8", + "/media1/playlist.m3u8", + "/media1/playlist.m3u8", + }, + getMockResponse(SAMPLE_M3U8_LIVE_MULTIVARIANT), + getMockResponse(SAMPLE_M3U8_LIVE_MEDIA_CAN_NOT_SKIP), + getMockResponse(SAMPLE_M3U8_LIVE_MEDIA_CAN_NOT_SKIP), + getMockResponse(SAMPLE_M3U8_LIVE_MEDIA_CAN_NOT_SKIP_NEXT)); + DefaultHlsPlaylistTracker defaultHlsPlaylistTracker = + new DefaultHlsPlaylistTracker( + dataType -> new DefaultHttpDataSource.Factory().createDataSource(), + new DefaultLoadErrorHandlingPolicy(), + new DefaultHlsPlaylistParserFactory(), + /* cmcdConfiguration= */ null, + /* downloadExecutorSupplier= */ null); + AtomicInteger playlistChangedCounter = new AtomicInteger(); + defaultHlsPlaylistTracker.addListener( + new HlsPlaylistTracker.PlaylistEventListener() { + @Override + public void onPlaylistChanged() { + playlistChangedCounter.addAndGet(1); + } + + @Override + public boolean onPlaylistError( + Uri url, LoadErrorHandlingPolicy.LoadErrorInfo loadErrorInfo, boolean forceRetry) { + return false; + } + }); + + defaultHlsPlaylistTracker.start( + Uri.parse(mockWebServer.url("/multivariant.m3u8").toString()), + new MediaSourceEventListener.EventDispatcher(), + mediaPlaylist -> {}, + BandwidthMeter.NO_OP); + // Wait for playlist A (media0) to load. Since A is the initial primary playlist, it will + // schedule a refresh with a 4-second delay (based on target duration) once it finishes loading. + Uri playlistUrlA = Uri.parse(mockWebServer.url("/media0/playlist.m3u8").toString()); + RobolectricUtil.runMainLooperUntil( + () -> defaultHlsPlaylistTracker.isSnapshotValid(playlistUrlA)); + // Explicitly activate playlist A for playback. + defaultHlsPlaylistTracker.getPlaylistSnapshot(playlistUrlA, /* isForPlayback= */ true); + // Refresh B (media1) and wait for it to load. + Uri playlistUrlB = Uri.parse(mockWebServer.url("/media1/playlist.m3u8").toString()); + defaultHlsPlaylistTracker.refreshPlaylist(playlistUrlB); + RobolectricUtil.runMainLooperUntil( + () -> defaultHlsPlaylistTracker.isSnapshotValid(playlistUrlB)); + // Make playlist B primary and active. + defaultHlsPlaylistTracker.getPlaylistSnapshot(playlistUrlB, /* isForPlayback= */ true); + // Explicitly deactivate playlist A for playback, simulating the track change. The Playlist A + // is now non-primary and inactive, but its refresh task is still pending in the looper queue + // with the original 4-second delay. + defaultHlsPlaylistTracker.deactivatePlaylistForPlayback(playlistUrlA); + // Keep running the looper until the scheduled refresh tasks got run. Both A and B's refresh + // tasks will run by the looper. But A is no longer primary or active, so its task should skip + // the actual loading. + RobolectricUtil.runMainLooperUntil( + /* maxTimeDiffMs= */ 10_000, () -> playlistChangedCounter.get() >= 3); + defaultHlsPlaylistTracker.stop(); + + assertRequestUrlsCalled(httpUrls); + } + @Test public void start_refreshPlaylistWithAllowingDeliveryDirectives_requestWithCorrectDeliveryDirectives() @@ -802,18 +885,54 @@ public void start_withContentSteering_switchesToMostPrioritizedPathway() throws new MockResponse().setResponseCode(200).setBody(steeringManifest), new MockResponse().setResponseCode(200).setBody(CDN_A_PLAYLIST), new MockResponse().setResponseCode(200).setBody(CDN_B_PLAYLIST)); + MediaSourceEventListener mockListener = mock(MediaSourceEventListener.class); + MediaSourceEventListener.EventDispatcher eventDispatcher = + new MediaSourceEventListener.EventDispatcher(); + eventDispatcher.addEventListener(Util.createHandlerForCurrentLooper(), mockListener); // Use the directExecutor() to ensure the order of the playlist arrivals. List mediaPlaylists = runPlaylistTrackerAndCollectMediaPlaylists( /* dataSourceFactory= */ new DefaultHttpDataSource.Factory(), () -> ReleasableExecutor.from(directExecutor(), e -> {}), + eventDispatcher, Uri.parse(mockWebServer.url("/multivariant.m3u8").toString()), /* awaitedMediaPlaylistCount= */ 2); assertRequestUrlsCalled(httpUrls); assertThat(mediaPlaylists.get(0).segments.get(0).url).endsWith("a-segment1.ts"); assertThat(mediaPlaylists.get(1).segments.get(0).url).endsWith("b-segment1.ts"); + ArgumentCaptor loadStartedCaptor = ArgumentCaptor.forClass(LoadEventInfo.class); + ArgumentCaptor loadStartedMediaLoadDataCaptor = + ArgumentCaptor.forClass(MediaLoadData.class); + ArgumentCaptor loadCompletedCaptor = + ArgumentCaptor.forClass(LoadEventInfo.class); + ArgumentCaptor loadCompletedMediaLoadDataCaptor = + ArgumentCaptor.forClass(MediaLoadData.class); + verify(mockListener, times(4)) + .onLoadStarted( + anyInt(), + any(), + loadStartedCaptor.capture(), + loadStartedMediaLoadDataCaptor.capture(), + anyInt()); + verify(mockListener, times(4)) + .onLoadCompleted( + anyInt(), + any(), + loadCompletedCaptor.capture(), + loadCompletedMediaLoadDataCaptor.capture()); + verify(mockListener, never()).onLoadError(anyInt(), any(), any(), any(), any(), anyBoolean()); + verifySteeredPathwayIds( + loadStartedCaptor.getAllValues(), + loadStartedMediaLoadDataCaptor.getAllValues(), + "CDN-A", + "CDN-B"); + verifySteeredPathwayIds( + loadCompletedCaptor.getAllValues(), + loadCompletedMediaLoadDataCaptor.getAllValues(), + "CDN-A", + "CDN-B"); } @Test @@ -836,17 +955,64 @@ public void start_withContentSteering_switchesToMostPrioritizedPathway() throws new MockResponse().setResponseCode(404), new MockResponse().setResponseCode(404), new MockResponse().setResponseCode(200).setBody(CDN_B_PLAYLIST)); + MediaSourceEventListener mockListener = mock(MediaSourceEventListener.class); + MediaSourceEventListener.EventDispatcher eventDispatcher = + new MediaSourceEventListener.EventDispatcher(); + eventDispatcher.addEventListener(Util.createHandlerForCurrentLooper(), mockListener); // Use the directExecutor() to ensure the order of the playlist arrivals. List mediaPlaylists = runPlaylistTrackerAndCollectMediaPlaylists( /* dataSourceFactory= */ new DefaultHttpDataSource.Factory(), () -> ReleasableExecutor.from(directExecutor(), e -> {}), + eventDispatcher, Uri.parse(mockWebServer.url("/multivariant.m3u8").toString()), /* awaitedMediaPlaylistCount= */ 1); assertRequestUrlsCalled(httpUrls); assertThat(mediaPlaylists.get(0).segments.get(0).url).isEqualTo("b-segment1.ts"); + ArgumentCaptor loadStartedCaptor = ArgumentCaptor.forClass(LoadEventInfo.class); + ArgumentCaptor loadStartedMediaLoadDataCaptor = + ArgumentCaptor.forClass(MediaLoadData.class); + ArgumentCaptor loadCompletedCaptor = + ArgumentCaptor.forClass(LoadEventInfo.class); + ArgumentCaptor loadCompletedMediaLoadDataCaptor = + ArgumentCaptor.forClass(MediaLoadData.class); + ArgumentCaptor loadErrorCaptor = ArgumentCaptor.forClass(LoadEventInfo.class); + ArgumentCaptor loadErrorMediaLoadDataCaptor = + ArgumentCaptor.forClass(MediaLoadData.class); + verify(mockListener, times(5)) + .onLoadStarted( + anyInt(), + any(), + loadStartedCaptor.capture(), + loadStartedMediaLoadDataCaptor.capture(), + anyInt()); + verify(mockListener, times(3)) + .onLoadCompleted( + anyInt(), + any(), + loadCompletedCaptor.capture(), + loadCompletedMediaLoadDataCaptor.capture()); + verify(mockListener, times(2)) + .onLoadError( + anyInt(), + any(), + loadErrorCaptor.capture(), + loadErrorMediaLoadDataCaptor.capture(), + any(), + anyBoolean()); + verifySteeredPathwayIds( + loadStartedCaptor.getAllValues(), + loadStartedMediaLoadDataCaptor.getAllValues(), + "CDN-A", + "CDN-B"); + verifySteeredPathwayIds( + loadCompletedCaptor.getAllValues(), + loadCompletedMediaLoadDataCaptor.getAllValues(), + "CDN-B"); + verifySteeredPathwayIds( + loadErrorCaptor.getAllValues(), loadErrorMediaLoadDataCaptor.getAllValues(), "CDN-A"); } @Test @@ -880,18 +1046,54 @@ public void start_withContentSteeringAndPathwayClones_switchesToClonedPathway() new MockResponse().setResponseCode(200).setBody(steeringManifest), new MockResponse().setResponseCode(200).setBody(CDN_A_PLAYLIST), new MockResponse().setResponseCode(200).setBody(CDN_A_CLONE_PLAYLIST)); + MediaSourceEventListener mockListener = mock(MediaSourceEventListener.class); + MediaSourceEventListener.EventDispatcher eventDispatcher = + new MediaSourceEventListener.EventDispatcher(); + eventDispatcher.addEventListener(Util.createHandlerForCurrentLooper(), mockListener); // Use the directExecutor() to ensure the order of the playlist arrivals. List mediaPlaylists = runPlaylistTrackerAndCollectMediaPlaylists( /* dataSourceFactory= */ new DefaultHttpDataSource.Factory(), () -> ReleasableExecutor.from(directExecutor(), e -> {}), + eventDispatcher, Uri.parse(mockWebServer.url("/multivariant.m3u8").toString()), /* awaitedMediaPlaylistCount= */ 2); assertRequestUrlsCalled(httpUrls); assertThat(mediaPlaylists.get(0).segments.get(0).url).endsWith("a-segment1.ts"); assertThat(mediaPlaylists.get(1).segments.get(0).url).endsWith("a-clone-segment1.ts"); + ArgumentCaptor loadStartedCaptor = ArgumentCaptor.forClass(LoadEventInfo.class); + ArgumentCaptor loadStartedMediaLoadDataCaptor = + ArgumentCaptor.forClass(MediaLoadData.class); + ArgumentCaptor loadCompletedCaptor = + ArgumentCaptor.forClass(LoadEventInfo.class); + ArgumentCaptor loadCompletedMediaLoadDataCaptor = + ArgumentCaptor.forClass(MediaLoadData.class); + verify(mockListener, times(4)) + .onLoadStarted( + anyInt(), + any(), + loadStartedCaptor.capture(), + loadStartedMediaLoadDataCaptor.capture(), + anyInt()); + verify(mockListener, times(4)) + .onLoadCompleted( + anyInt(), + any(), + loadCompletedCaptor.capture(), + loadCompletedMediaLoadDataCaptor.capture()); + verify(mockListener, never()).onLoadError(anyInt(), any(), any(), any(), any(), anyBoolean()); + verifySteeredPathwayIds( + loadStartedCaptor.getAllValues(), + loadStartedMediaLoadDataCaptor.getAllValues(), + "CDN-A", + "CDN-A-CLONE"); + verifySteeredPathwayIds( + loadCompletedCaptor.getAllValues(), + loadCompletedMediaLoadDataCaptor.getAllValues(), + "CDN-A", + "CDN-A-CLONE"); } private List enqueueWebServerResponses(String[] paths, MockResponse... mockResponses) { @@ -920,6 +1122,21 @@ private static List runPlaylistTrackerAndCollectMediaPlaylists Uri multivariantPlaylistUri, int awaitedMediaPlaylistCount) throws TimeoutException { + return runPlaylistTrackerAndCollectMediaPlaylists( + dataSourceFactory, + downloadExecutorSupplier, + new MediaSourceEventListener.EventDispatcher(), + multivariantPlaylistUri, + awaitedMediaPlaylistCount); + } + + private static List runPlaylistTrackerAndCollectMediaPlaylists( + DataSource.Factory dataSourceFactory, + @Nullable Supplier downloadExecutorSupplier, + MediaSourceEventListener.EventDispatcher eventDispatcher, + Uri multivariantPlaylistUri, + int awaitedMediaPlaylistCount) + throws TimeoutException { DefaultHlsPlaylistTracker defaultHlsPlaylistTracker = new DefaultHlsPlaylistTracker( @@ -933,7 +1150,7 @@ private static List runPlaylistTrackerAndCollectMediaPlaylists AtomicInteger playlistCounter = new AtomicInteger(); defaultHlsPlaylistTracker.start( multivariantPlaylistUri, - new MediaSourceEventListener.EventDispatcher(), + eventDispatcher, mediaPlaylist -> { mediaPlaylists.add(mediaPlaylist); playlistCounter.addAndGet(1); @@ -948,6 +1165,40 @@ private static List runPlaylistTrackerAndCollectMediaPlaylists return mediaPlaylists; } + private static void verifySteeredPathwayIds( + List loadEventInfos, + List mediaLoadDatas, + String... expectedPathwayIds) { + ImmutableSet.Builder mediaPlaylistLoadingSteeredPathwayIds = ImmutableSet.builder(); + for (int i = 0; i < loadEventInfos.size(); i++) { + LoadEventInfo eventInfo = loadEventInfos.get(i); + MediaLoadData mediaLoadData = mediaLoadDatas.get(i); + if (eventInfo.uri.getPath() != null + && eventInfo.uri.getPath().endsWith("multivariant.m3u8")) { + // The multivariant playlist load event is initiated before the content steering manifest + // is parsed, so its steered pathway ID must be null. + assertWithMessage("loadEventInfos[%s]: %s", i, loadEventInfoString(eventInfo)) + .that(eventInfo.steeredPathwayId) + .isNull(); + } else if (mediaLoadData.dataType == C.DATA_TYPE_STEERING_MANIFEST) { + // Content steering manifest load events are decoupled from any specific steered pathway, + // so their steered pathway ID must be null. + assertWithMessage("loadEventInfos[%s]: %s", i, loadEventInfoString(eventInfo)) + .that(eventInfo.steeredPathwayId) + .isNull(); + } else if (eventInfo.steeredPathwayId != null) { + // Collect the steered pathway IDs from the media playlist requests. + mediaPlaylistLoadingSteeredPathwayIds.add(eventInfo.steeredPathwayId); + } + } + assertThat(mediaPlaylistLoadingSteeredPathwayIds.build()) + .containsExactlyElementsIn(expectedPathwayIds); + } + + private static String loadEventInfoString(LoadEventInfo loadEventInfo) { + return "LoadEventInfo{uri=" + loadEventInfo.uri + "}"; + } + private static MockResponse getMockResponse(String assetFile) throws IOException { return new MockResponse().setResponseCode(200).setBody(new Buffer().write(getBytes(assetFile))); } diff --git a/libraries/exoplayer_ima/src/main/java/androidx/media3/exoplayer/ima/AdTagLoader.java b/libraries/exoplayer_ima/src/main/java/androidx/media3/exoplayer/ima/AdTagLoader.java index 427b8e960f0..354058c183b 100644 --- a/libraries/exoplayer_ima/src/main/java/androidx/media3/exoplayer/ima/AdTagLoader.java +++ b/libraries/exoplayer_ima/src/main/java/androidx/media3/exoplayer/ima/AdTagLoader.java @@ -21,7 +21,6 @@ import static androidx.media3.exoplayer.ima.ImaUtil.TIMEOUT_UNSET; import static androidx.media3.exoplayer.ima.ImaUtil.getAdGroupTimesUsForCuePoints; import static androidx.media3.exoplayer.ima.ImaUtil.getImaLooper; -import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.base.Preconditions.checkState; import static java.lang.Math.max; @@ -491,14 +490,7 @@ public void onTimelineChanged(Timeline timeline, @Player.TimelineChangeReason in } Player player = this.player; this.timeline = timeline; - int windowIndex = player.getCurrentMediaItemIndex(); - Timeline.Window window = new Timeline.Window(); - timeline.getWindow(windowIndex, window); - checkArgument( - window.firstPeriodIndex == window.lastPeriodIndex, - "Only single-period Timelines are supported."); - long contentDurationUs = timeline.getPeriod(window.firstPeriodIndex, period).durationUs; - + long contentDurationUs = timeline.getPeriod(player.getCurrentPeriodIndex(), period).durationUs; contentDurationMs = Util.usToMs(contentDurationUs); if (contentDurationUs != adPlaybackState.contentDurationUs) { adPlaybackState = adPlaybackState.withContentDurationUs(contentDurationUs); diff --git a/libraries/exoplayer_smoothstreaming/src/main/java/androidx/media3/exoplayer/smoothstreaming/SsMediaSource.java b/libraries/exoplayer_smoothstreaming/src/main/java/androidx/media3/exoplayer/smoothstreaming/SsMediaSource.java index bbfbe2448d7..46089e6249b 100644 --- a/libraries/exoplayer_smoothstreaming/src/main/java/androidx/media3/exoplayer/smoothstreaming/SsMediaSource.java +++ b/libraries/exoplayer_smoothstreaming/src/main/java/androidx/media3/exoplayer/smoothstreaming/SsMediaSource.java @@ -529,32 +529,28 @@ public void onLoadStarted( long elapsedRealtimeMs, long loadDurationMs, int retryCount) { - LoadEventInfo loadEventInfo = - retryCount == 0 - ? new LoadEventInfo(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) - : new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); - manifestEventDispatcher.loadStarted(loadEventInfo, loadable.type, retryCount); + LoadEventInfo.Builder loadEventInfo = + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs); + if (retryCount != 0) { + loadEventInfo + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()); + } + manifestEventDispatcher.loadStarted(loadEventInfo.build(), loadable.type, retryCount); } @Override public void onLoadCompleted( ParsingLoadable loadable, long elapsedRealtimeMs, long loadDurationMs) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); manifestEventDispatcher.loadCompleted(loadEventInfo, loadable.type); manifest = loadable.getResult(); @@ -570,14 +566,12 @@ public void onLoadCanceled( long loadDurationMs, boolean released) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); loadErrorHandlingPolicy.onLoadTaskConcluded(loadable.loadTaskId); manifestEventDispatcher.loadCanceled(loadEventInfo, loadable.type); } @@ -590,14 +584,12 @@ public LoadErrorAction onLoadError( IOException error, int errorCount) { LoadEventInfo loadEventInfo = - new LoadEventInfo( - loadable.loadTaskId, - loadable.dataSpec, - loadable.getUri(), - loadable.getResponseHeaders(), - elapsedRealtimeMs, - loadDurationMs, - loadable.bytesLoaded()); + new LoadEventInfo.Builder(loadable.loadTaskId, loadable.dataSpec, elapsedRealtimeMs) + .setUri(loadable.getUri()) + .setResponseHeaders(loadable.getResponseHeaders()) + .setLoadDurationMs(loadDurationMs) + .setBytesLoaded(loadable.bytesLoaded()) + .build(); MediaLoadData mediaLoadData = new MediaLoadData(loadable.type); long retryDelayMs = loadErrorHandlingPolicy.getRetryDelayMsFor( diff --git a/libraries/extractor/src/main/java/androidx/media3/extractor/DefaultExtractorsFactory.java b/libraries/extractor/src/main/java/androidx/media3/extractor/DefaultExtractorsFactory.java index 03f062508b1..2815a36c484 100644 --- a/libraries/extractor/src/main/java/androidx/media3/extractor/DefaultExtractorsFactory.java +++ b/libraries/extractor/src/main/java/androidx/media3/extractor/DefaultExtractorsFactory.java @@ -157,6 +157,7 @@ public final class DefaultExtractorsFactory implements ExtractorsFactory { private @C.VideoCodecFlags int codecsToParseWithinGopSampleDependencies; private @JpegExtractor.Flags int jpegFlags; private @HeifExtractor.Flags int heifFlags; + private boolean parseHagcMetadata; public DefaultExtractorsFactory() { tsMode = TsExtractor.MODE_SINGLE_PMT; @@ -164,6 +165,7 @@ public DefaultExtractorsFactory() { subtitleParserFactory = new DefaultSubtitleParserFactory(); textTrackTranscodingEnabled = true; codecsToParseWithinGopSampleDependencies = C.VIDEO_CODEC_FLAG_H264 | C.VIDEO_CODEC_FLAG_H265; + parseHagcMetadata = true; } /** @@ -443,6 +445,13 @@ public synchronized DefaultExtractorsFactory setHeifExtractorFlags( return this; } + @CanIgnoreReturnValue + @Override + public synchronized DefaultExtractorsFactory setParseHagcMetadata(boolean parseHagcMetadata) { + this.parseHagcMetadata = parseHagcMetadata; + return this; + } + @Override public synchronized Extractor[] createExtractors() { return createExtractors(Uri.EMPTY, new HashMap<>()); @@ -524,7 +533,8 @@ private void addExtractorsForFileType(@FileTypes.Type int fileType, List input.getLength()) { + Log.w( + TAG, + "Skipping ID3 tag with tagLength=" + + tagLength + + " greater than input length=" + + input.getLength()); + break; + } if (metadata == null) { byte[] id3Data = new byte[tagLength]; @@ -129,7 +142,12 @@ private boolean peekId3HeaderIntoScratch(ExtractorInput input, int maxTagPeekByt scratch.setPosition(headerStartIndexInScratch); scratch.setLimit(headerEndIndexInScratch); if (scratch.peekUnsignedInt24() == Id3Decoder.ID3_TAG) { - return true; + scratch.skipBytes(3); + int majorVersion = scratch.readUnsignedByte(); + if (Id3Decoder.isSupportedMajorVersion(majorVersion)) { + scratch.setPosition(headerStartIndexInScratch); + return true; + } } else if (MpegAudioUtil.getFrameSize(scratch.peekInt()) != C.LENGTH_UNSET) { // We've found something that looks like an MP3 header, stop searching for ID3 headers. return false; diff --git a/libraries/extractor/src/main/java/androidx/media3/extractor/metadata/id3/Id3Decoder.java b/libraries/extractor/src/main/java/androidx/media3/extractor/metadata/id3/Id3Decoder.java index 55912eb131e..d8fba7652f5 100644 --- a/libraries/extractor/src/main/java/androidx/media3/extractor/metadata/id3/Id3Decoder.java +++ b/libraries/extractor/src/main/java/androidx/media3/extractor/metadata/id3/Id3Decoder.java @@ -105,6 +105,16 @@ public Id3Decoder(@Nullable FramePredicate framePredicate) { this.framePredicate = framePredicate; } + /** + * Returns whether the given major version number is supported by {@link Id3Decoder}. + * + * @param majorVersion The ID3v2 major version number. + * @return Whether the major version is supported (ID3v2.2, ID3v2.3, or ID3v2.4). + */ + public static boolean isSupportedMajorVersion(int majorVersion) { + return majorVersion >= 2 && majorVersion <= 4; + } + @Override @Nullable @SuppressWarnings("ByteBufferBackingArray") // Buffer validated by SimpleMetadataDecoder.decode @@ -183,6 +193,10 @@ private static Id3Header decodeHeader(ParsableByteArray data) { } int majorVersion = data.readUnsignedByte(); + if (!isSupportedMajorVersion(majorVersion)) { + Log.w(TAG, "Skipped ID3 tag with unsupported majorVersion=" + majorVersion); + return null; + } data.skipBytes(1); // Skip minor version. int flags = data.readUnsignedByte(); int framesSize = data.readSynchSafeInt(); @@ -211,9 +225,6 @@ private static Id3Header decodeHeader(ParsableByteArray data) { if (hasFooter) { framesSize -= 10; } - } else { - Log.w(TAG, "Skipped ID3 tag with unsupported majorVersion=" + majorVersion); - return null; } // isUnsynchronized is advisory only in version 4. Frame level flags are used instead. diff --git a/libraries/extractor/src/main/java/androidx/media3/extractor/mkv/MatroskaExtractor.java b/libraries/extractor/src/main/java/androidx/media3/extractor/mkv/MatroskaExtractor.java index 6801755c364..7dbc1dae64e 100644 --- a/libraries/extractor/src/main/java/androidx/media3/extractor/mkv/MatroskaExtractor.java +++ b/libraries/extractor/src/main/java/androidx/media3/extractor/mkv/MatroskaExtractor.java @@ -37,6 +37,7 @@ import androidx.media3.common.Metadata; import androidx.media3.common.MimeTypes; import androidx.media3.common.ParserException; +import androidx.media3.common.util.CodecSpecificDataUtil; import androidx.media3.common.util.Log; import androidx.media3.common.util.NullableType; import androidx.media3.common.util.ParsableByteArray; @@ -109,7 +110,7 @@ public static ExtractorsFactory newFactory(SubtitleParser.Factory subtitleParser @Target(TYPE_USE) @IntDef( flag = true, - value = {FLAG_DISABLE_SEEK_FOR_CUES, FLAG_EMIT_RAW_SUBTITLE_DATA}) + value = {FLAG_DISABLE_SEEK_FOR_CUES, FLAG_EMIT_RAW_SUBTITLE_DATA, FLAG_DISABLE_HAGC_METADATA}) public @interface Flags {} /** @@ -128,6 +129,9 @@ public static ExtractorsFactory newFactory(SubtitleParser.Factory subtitleParser */ public static final int FLAG_EMIT_RAW_SUBTITLE_DATA = 1 << 1; // 2 + /** Flag to disable parsing of HAGC (ST 2094-50) metadata. */ + public static final int FLAG_DISABLE_HAGC_METADATA = 1 << 2; // 4 + /** * @deprecated Use {@link #newFactory(SubtitleParser.Factory)} instead. */ @@ -453,6 +457,7 @@ public static ExtractorsFactory newFactory(SubtitleParser.Factory subtitleParser private final SparseArray tracks; private final LongSparseArray chapters; private final boolean seekForCuesEnabled; + private final boolean parseHagcMetadata; private final boolean parseSubtitlesDuringExtraction; private final SubtitleParser.Factory subtitleParserFactory; @@ -586,6 +591,7 @@ public MatroskaExtractor(SubtitleParser.Factory subtitleParserFactory, @Flags in this.perTrackCues = new SparseArray<>(); seekForCuesEnabled = (flags & FLAG_DISABLE_SEEK_FOR_CUES) == 0; parseSubtitlesDuringExtraction = (flags & FLAG_EMIT_RAW_SUBTITLE_DATA) == 0; + parseHagcMetadata = (flags & FLAG_DISABLE_HAGC_METADATA) == 0; varintReader = new VarintReader(); chapters = new LongSparseArray<>(); tracks = new SparseArray<>(); @@ -852,18 +858,8 @@ protected void startMasterElement(int id, long contentPosition, long contentSize case ID_CLUSTER: if (tracksContentPosition != C.INDEX_UNSET && !readTracks) { seekForTracks = true; - } - if (!sentSeekMap) { - // We need to build cues before parsing the cluster. - if (seekForCuesEnabled && cuesContentPosition != C.INDEX_UNSET) { - // We know where the Cues element is located. Seek to request it. - seekForCues = true; - } else { - // We don't know where the Cues element is located. It's most likely omitted. Allow - // playback, but disable seeking. - extractorOutput.seekMap(new SeekMap.Unseekable(durationUs)); - sentSeekMap = true; - } + } else { + maybePrepareSeekMap(); } break; case ID_BLOCK_GROUP: @@ -1127,6 +1123,9 @@ protected void endMasterElement(int id) throws ParserException { } readTracks = true; + if (seekPositionAfterReadingTracks != C.INDEX_UNSET) { + maybePrepareSeekMap(); + } if (maybeSendFormatsEarly) { maybeEndTracks(); } @@ -1719,6 +1718,12 @@ protected void handleBlockAdditionalData( && CODEC_ID_VP9.equals(track.codecId)) { supplementalData.reset(contentSize); input.readFully(supplementalData.getData(), 0, contentSize); + if (!parseHagcMetadata) { + byte[] data = supplementalData.getData(); + if (CodecSpecificDataUtil.isHagcMetadata(data, contentSize)) { + supplementalData.reset(0); + } + } } else { // Unhandled block additional data. input.skipFully(contentSize); @@ -2289,6 +2294,22 @@ private void assertInitialized() { checkNotNull(extractorOutput); } + private void maybePrepareSeekMap() { + if (sentSeekMap) { + return; // Already evaluated + } + // We need to build cues before parsing the cluster. + if (seekForCuesEnabled && cuesContentPosition != C.INDEX_UNSET) { + // We know where the Cues element is located. Seek to request it. + seekForCues = true; + } else { + // We don't know where the Cues element is located. It's most likely omitted. Allow + // playback, but disable seeking. + checkNotNull(extractorOutput).seekMap(new SeekMap.Unseekable(durationUs)); + sentSeekMap = true; + } + } + private void maybeEndTracks() { if (!pendingEndTracks) { return; diff --git a/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/FixedSampleSizeRechunker.java b/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/FixedSampleSizeRechunker.java index 6ee36efbcdf..0079e103b43 100644 --- a/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/FixedSampleSizeRechunker.java +++ b/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/FixedSampleSizeRechunker.java @@ -71,7 +71,9 @@ public static Results rechunk( long[] chunkOffsets, int[] chunkSampleCounts, long timestampDeltaInTimeUnits) { - int maxSampleCount = MAX_SAMPLE_SIZE / fixedSampleSize; + // Ensure maxSampleCount is at least 1 when fixedSampleSize exceeds MAX_SAMPLE_SIZE to prevent + // division by zero in rechunking. + int maxSampleCount = max(1, MAX_SAMPLE_SIZE / fixedSampleSize); // Count the number of new, rechunked buffers. int rechunkedSampleCount = 0; diff --git a/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/FragmentedMp4Extractor.java b/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/FragmentedMp4Extractor.java index 5dcc32c7392..e77b38c2a6e 100644 --- a/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/FragmentedMp4Extractor.java +++ b/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/FragmentedMp4Extractor.java @@ -35,6 +35,7 @@ import androidx.media3.common.Metadata; import androidx.media3.common.MimeTypes; import androidx.media3.common.ParserException; +import androidx.media3.common.util.CodecSpecificDataUtil; import androidx.media3.common.util.Log; import androidx.media3.common.util.ParsableByteArray; import androidx.media3.common.util.TimestampAdjuster; @@ -115,7 +116,8 @@ public static ExtractorsFactory newFactory(SubtitleParser.Factory subtitleParser FLAG_READ_WITHIN_GOP_SAMPLE_DEPENDENCIES_H265, FLAG_MERGE_FRAGMENTED_SIDX, FLAG_READ_MFRA_FOR_SEEK_MAP, - FLAG_DISABLE_ARTWORK_METADATA + FLAG_DISABLE_ARTWORK_METADATA, + FLAG_DISABLE_HAGC_METADATA }) public @interface Flags {} @@ -177,6 +179,9 @@ public static ExtractorsFactory newFactory(SubtitleParser.Factory subtitleParser /** Flag to disable parsing of artwork metadata. */ public static final int FLAG_DISABLE_ARTWORK_METADATA = 1 << 10; + /** Flag to disable parsing of HAGC (ST 2094-50) metadata. */ + public static final int FLAG_DISABLE_HAGC_METADATA = 1 << 11; + /** * @deprecated Use {@link #newFactory(SubtitleParser.Factory)} instead. */ @@ -897,6 +902,13 @@ private void onMoovContainerAtomRead(ContainerBox moov) throws ParserException { @Nullable protected Track modifyTrack(@Nullable Track track) { + if (track == null) { + return null; + } + if ((flags & FLAG_DISABLE_HAGC_METADATA) != 0 + && CodecSpecificDataUtil.isHagcTrack(track.format)) { + return null; + } return track; } diff --git a/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/Mp4Extractor.java b/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/Mp4Extractor.java index e4f1ca810e9..f5598391c92 100644 --- a/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/Mp4Extractor.java +++ b/libraries/extractor/src/main/java/androidx/media3/extractor/mp4/Mp4Extractor.java @@ -37,6 +37,7 @@ import androidx.media3.common.Metadata; import androidx.media3.common.MimeTypes; import androidx.media3.common.ParserException; +import androidx.media3.common.util.CodecSpecificDataUtil; import androidx.media3.common.util.ParsableByteArray; import androidx.media3.common.util.UnstableApi; import androidx.media3.common.util.Util; @@ -108,7 +109,8 @@ public static ExtractorsFactory newFactory(SubtitleParser.Factory subtitleParser FLAG_READ_AUXILIARY_TRACKS, FLAG_READ_WITHIN_GOP_SAMPLE_DEPENDENCIES_H265, FLAG_OMIT_TRACK_SAMPLE_TABLE, - FLAG_DISABLE_ARTWORK_METADATA + FLAG_DISABLE_ARTWORK_METADATA, + FLAG_DISABLE_HAGC_METADATA }) public @interface Flags {} @@ -175,6 +177,9 @@ public static ExtractorsFactory newFactory(SubtitleParser.Factory subtitleParser /** Flag to disable parsing of artwork metadata. */ public static final int FLAG_DISABLE_ARTWORK_METADATA = 1 << 9; + /** Flag to disable parsing of HAGC (ST 2094-50) metadata. */ + public static final int FLAG_DISABLE_HAGC_METADATA = 1 << 10; + /** The maximum number of sync samples to scan when searching for a thumbnail. */ private static final int MAX_SYNC_SAMPLES_TO_SCAN_FOR_THUMBNAIL = 20; @@ -657,7 +662,16 @@ private void processMoovAtom(ContainerBox moov) throws ParserException { /* drmInitData= */ null, ignoreEditLists, isQuickTime, - /* modifyTrackFunction= */ track -> track, + /* modifyTrackFunction= */ track -> { + if (track == null) { + return null; + } + if ((flags & FLAG_DISABLE_HAGC_METADATA) != 0 + && CodecSpecificDataUtil.isHagcTrack(track.format)) { + return null; + } + return track; + }, omitTrackSampleTable); if (readingAuxiliaryTracks) { @@ -1153,6 +1167,10 @@ private int readQuickTimeChapters(ExtractorInput input, PositionHolder seekPosit * with the next logical sample (based on sample time) exceeds {@link * #MAXIMUM_READ_AHEAD_BYTES_STREAM}. If this is the case, we continue with this sample even * though it may require a source reload. + * + *

    As an exception, dependent metadata tracks are prioritized over the aforementioned logic if + * their timestamp is behind or equal to the primary track (e.g., video). This ensures they can be + * extracted before the frames they apply to. */ private int getTrackIndexOfNextReadSample(long inputPosition) { long preferredSkipAmount = Long.MAX_VALUE; @@ -1162,12 +1180,27 @@ private int getTrackIndexOfNextReadSample(long inputPosition) { long minAccumulatedBytes = Long.MAX_VALUE; boolean minAccumulatedBytesRequiresReload = true; int minAccumulatedBytesTrackIndex = C.INDEX_UNSET; + + long minVideoTimestampUs = Long.MAX_VALUE; + long minIt35TimestampUs = Long.MAX_VALUE; + int minIt35TrackIndex = C.INDEX_UNSET; + for (int trackIndex = 0; trackIndex < tracks.length; trackIndex++) { Mp4Track track = tracks[trackIndex]; int sampleIndex = track.sampleIndex; if (sampleIndex == track.sampleTable.sampleCount) { continue; } + + long sampleTimestampUs = track.sampleTable.timestampsUs[sampleIndex]; + if (track.isVideo) { + minVideoTimestampUs = Math.min(minVideoTimestampUs, sampleTimestampUs); + } else if (track.isItutT35) { + if (sampleTimestampUs < minIt35TimestampUs) { + minIt35TimestampUs = sampleTimestampUs; + minIt35TrackIndex = trackIndex; + } + } long sampleOffset = track.sampleTable.offsets[sampleIndex]; long sampleAccumulatedBytes = checkNotNull(accumulatedSampleSizes)[trackIndex][sampleIndex]; long skipAmount = sampleOffset - inputPosition; @@ -1185,6 +1218,12 @@ private int getTrackIndexOfNextReadSample(long inputPosition) { minAccumulatedBytesTrackIndex = trackIndex; } } + if (minVideoTimestampUs != Long.MAX_VALUE + && minIt35TrackIndex != C.INDEX_UNSET + && minIt35TimestampUs <= minVideoTimestampUs) { + return minIt35TrackIndex; + } + return minAccumulatedBytes == Long.MAX_VALUE || !minAccumulatedBytesRequiresReload || preferredAccumulatedBytes < minAccumulatedBytes + MAXIMUM_READ_AHEAD_BYTES_STREAM @@ -1379,6 +1418,8 @@ private static final class Mp4Track { public final TrackSampleTable sampleTable; public final TrackOutput trackOutput; @Nullable public final TrueHdSampleRechunker trueHdSampleRechunker; + private final boolean isVideo; + private final boolean isItutT35; public int sampleIndex; @@ -1392,6 +1433,8 @@ public Mp4Track(Track track, TrackSampleTable sampleTable, TrackOutput trackOutp this.track = track; this.sampleTable = sampleTable; this.trackOutput = trackOutput; + this.isVideo = track.type == C.TRACK_TYPE_VIDEO; + this.isItutT35 = Objects.equals(track.format.sampleMimeType, MimeTypes.APPLICATION_ITUT_T35); trueHdSampleRechunker = MimeTypes.AUDIO_TRUEHD.equals(track.format.sampleMimeType) ? new TrueHdSampleRechunker() diff --git a/libraries/extractor/src/main/java/androidx/media3/extractor/text/CuesWithTimingSubtitle.java b/libraries/extractor/src/main/java/androidx/media3/extractor/text/CuesWithTimingSubtitle.java index 2ed9a983f57..99bae98b757 100644 --- a/libraries/extractor/src/main/java/androidx/media3/extractor/text/CuesWithTimingSubtitle.java +++ b/libraries/extractor/src/main/java/androidx/media3/extractor/text/CuesWithTimingSubtitle.java @@ -34,7 +34,7 @@ private static final String TAG = "CuesWithTimingSubtitle"; // eventCues and eventTimesUs are parallel collections. eventTimesUs is sorted in ascending - // order, and eventCues.get(i) contains the the cues for the event at time eventTimesUs[i]. + // order, and eventCues.get(i) contains the cues for the event at time eventTimesUs[i]. // eventTimesUs may be longer than eventCues (with padding elements at the end). // eventCues.size() is the authoritative source for the number of events in this Subtitle. private final ImmutableList> eventCues; diff --git a/libraries/extractor/src/test/java/androidx/media3/extractor/Id3PeekerTest.java b/libraries/extractor/src/test/java/androidx/media3/extractor/Id3PeekerTest.java index 6f7073ada25..03efd2986b1 100644 --- a/libraries/extractor/src/test/java/androidx/media3/extractor/Id3PeekerTest.java +++ b/libraries/extractor/src/test/java/androidx/media3/extractor/Id3PeekerTest.java @@ -164,6 +164,28 @@ public void peekId3Data_returnId3TagAccordingToGivenPredicate_ifId3TagPresent() assertThat(commentFrame.text).isEqualTo("text"); } + @Test + public void peekId3Data_withInvalidMajorVersion_returnsNull() throws IOException { + Id3Peeker id3Peeker = new Id3Peeker(); + byte[] data = new byte[] {'I', 'D', '3', 'M', '0', 'W', 0x78, 0x62, 0x32, 0x59, 0, 0, 0, 0}; + FakeExtractorInput input = new FakeExtractorInput.Builder().setData(data).build(); + + @Nullable Metadata metadata = id3Peeker.peekId3Data(input, /* id3FramePredicate= */ null, 128); + + assertThat(metadata).isNull(); + } + + @Test + public void peekId3Data_withTagLengthExceedingInputLength_returnsNull() throws IOException { + Id3Peeker id3Peeker = new Id3Peeker(); + byte[] data = new byte[] {'I', 'D', '3', 3, 0, 0, 0x78, 0x62, 0x32, 0x59, 0, 0, 0, 0}; + FakeExtractorInput input = new FakeExtractorInput.Builder().setData(data).build(); + + @Nullable Metadata metadata = id3Peeker.peekId3Data(input, /* id3FramePredicate= */ null, 128); + + assertThat(metadata).isNull(); + } + private static void assertApicFramesEqual(ApicFrame actual, ApicFrame expected) { assertThat(actual.mimeType).isEqualTo(expected.mimeType); assertThat(actual.description).isEqualTo(expected.description); diff --git a/libraries/extractor/src/test/java/androidx/media3/extractor/mp4/FixedSampleSizeRechunkerTest.java b/libraries/extractor/src/test/java/androidx/media3/extractor/mp4/FixedSampleSizeRechunkerTest.java new file mode 100644 index 00000000000..e6bc481e71b --- /dev/null +++ b/libraries/extractor/src/test/java/androidx/media3/extractor/mp4/FixedSampleSizeRechunkerTest.java @@ -0,0 +1,45 @@ +/* + * Copyright 2026 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 androidx.media3.extractor.mp4; + +import static com.google.common.truth.Truth.assertThat; + +import androidx.test.ext.junit.runners.AndroidJUnit4; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** Unit test for {@link FixedSampleSizeRechunker}. */ +@RunWith(AndroidJUnit4.class) +public class FixedSampleSizeRechunkerTest { + + @Test + public void rechunk_withFixedSampleSizeExceedingMaxSampleSize_doesNotThrowDivisionByZero() { + int fixedSampleSize = 10_000; // > MAX_SAMPLE_SIZE (8192) + long[] chunkOffsets = new long[] {100}; + int[] chunkSampleCounts = new int[] {5}; + long timestampDeltaInTimeUnits = 1000; + + FixedSampleSizeRechunker.Results results = + FixedSampleSizeRechunker.rechunk( + fixedSampleSize, chunkOffsets, chunkSampleCounts, timestampDeltaInTimeUnits); + + assertThat(results.offsets).isEqualTo(new long[] {100, 10100, 20100, 30100, 40100}); + assertThat(results.sizes).isEqualTo(new int[] {10000, 10000, 10000, 10000, 10000}); + assertThat(results.maximumSize).isEqualTo(10000); + assertThat(results.timestamps).isEqualTo(new long[] {0, 1000, 2000, 3000, 4000}); + assertThat(results.flags).isEqualTo(new int[] {1, 1, 1, 1, 1}); + } +} diff --git a/libraries/extractor/src/test/java/androidx/media3/extractor/mp4/Mp4ExtractorNonParameterizedTest.java b/libraries/extractor/src/test/java/androidx/media3/extractor/mp4/Mp4ExtractorNonParameterizedTest.java index 727ca01e482..8e1f9bccac0 100644 --- a/libraries/extractor/src/test/java/androidx/media3/extractor/mp4/Mp4ExtractorNonParameterizedTest.java +++ b/libraries/extractor/src/test/java/androidx/media3/extractor/mp4/Mp4ExtractorNonParameterizedTest.java @@ -18,11 +18,18 @@ import static com.google.common.truth.Truth.assertThat; import android.content.Context; +import androidx.media3.common.C; +import androidx.media3.common.DataReader; import androidx.media3.common.Format; +import androidx.media3.common.util.ParsableByteArray; import androidx.media3.extractor.Extractor; +import androidx.media3.extractor.ExtractorOutput; import androidx.media3.extractor.PositionHolder; +import androidx.media3.extractor.SeekMap; import androidx.media3.extractor.SniffFailure; import androidx.media3.extractor.TrackAwareSeekMap; +import androidx.media3.extractor.TrackOutput; +import androidx.media3.extractor.TrackOutput.CryptoData; import androidx.media3.extractor.text.DefaultSubtitleParserFactory; import androidx.media3.extractor.text.SubtitleParser; import androidx.media3.test.utils.DumpFileAsserts; @@ -35,6 +42,8 @@ import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; import java.io.IOException; +import java.util.ArrayList; +import java.util.List; import org.junit.Test; import org.junit.runner.RunWith; @@ -268,6 +277,81 @@ public void extract_h265WithoutGopParsingFlags() throws Exception { DumpFileAsserts.assertOutput(context, output, dumpFilePath); } + @Test + public void extract_withPoorlyMuxedIt35Track_extractsMetadataBeforeVideo() throws Exception { + Mp4Extractor extractor = new Mp4Extractor(SubtitleParser.Factory.UNSUPPORTED); + FakeExtractorInput input = createInputForSample("sample_with_it35_track.mp4"); + + List extractedTrackTypes = new ArrayList<>(); + List extractedTimeUs = new ArrayList<>(); + ExtractorOutput output = + new ExtractorOutput() { + @Override + public TrackOutput track(int id, int type) { + return new TrackOutput() { + private final byte[] scratch = new byte[4096]; + + @Override + public void format(Format format) {} + + @Override + public int sampleData( + DataReader input, int length, boolean allowEndOfInput, int sampleDataPart) + throws IOException { + return input.read(scratch, 0, Math.min(length, scratch.length)); + } + + @Override + public void sampleData(ParsableByteArray data, int length, int sampleDataPart) { + data.skipBytes(length); + } + + @Override + public void sampleMetadata( + long timeUs, int flags, int size, int offset, CryptoData cryptoData) { + extractedTrackTypes.add(type); + extractedTimeUs.add(timeUs); + } + }; + } + + @Override + public void endTracks() {} + + @Override + public void seekMap(SeekMap seekMap) {} + }; + + extractor.init(output); + PositionHolder seekPositionHolder = new PositionHolder(); + int readResult = Extractor.RESULT_CONTINUE; + + while (readResult != Extractor.RESULT_END_OF_INPUT) { + readResult = extractor.read(input, seekPositionHolder); + if (readResult == Extractor.RESULT_SEEK) { + input.setPosition((int) seekPositionHolder.position); + } + } + + // There are 30 video samples and 30 metadata samples in sample_with_it35_track.mp4. + assertThat(extractedTrackTypes).hasSize(60); + // Verify that IT35 metadata samples are loaded BEFORE any video samples that share or + // exceed their timestamp. + // Which means: If a metadata sample is loaded AFTER a video sample, its timestamp + // must strictly EXCEED the video sample's timestamp. + for (int i = 0; i < extractedTrackTypes.size(); i++) { + if (extractedTrackTypes.get(i) == C.TRACK_TYPE_VIDEO) { + long videoTimeUs = extractedTimeUs.get(i); + for (int j = i + 1; j < extractedTrackTypes.size(); j++) { + if (extractedTrackTypes.get(j) == C.TRACK_TYPE_METADATA) { + long metadataTimeUs = extractedTimeUs.get(j); + assertThat(metadataTimeUs).isGreaterThan(videoTimeUs); + } + } + } + } + } + private static String getDumpFilePath(String inputFilePath, String suffix) { return inputFilePath.replaceFirst("media", "extractordumps") + suffix; } diff --git a/libraries/muxer/src/main/java/androidx/media3/muxer/Boxes.java b/libraries/muxer/src/main/java/androidx/media3/muxer/Boxes.java index c60ad3a19f0..2cf8452683f 100644 --- a/libraries/muxer/src/main/java/androidx/media3/muxer/Boxes.java +++ b/libraries/muxer/src/main/java/androidx/media3/muxer/Boxes.java @@ -1407,7 +1407,7 @@ private static ByteBuffer trefTypeBox(int referenceType, List trackIds) contents.putInt(trackIds.get(i)); } contents.flip(); - byte[] typeBytes = Util.toByteArray(referenceType); + byte[] typeBytes = Ints.toByteArray(referenceType); return BoxUtils.wrapIntoBox(typeBytes, contents); } diff --git a/libraries/muxer/src/test/java/androidx/media3/muxer/MediaMuxerCompatTest.java b/libraries/muxer/src/test/java/androidx/media3/muxer/MediaMuxerCompatTest.java index 2a4432a6a0a..809e032897f 100644 --- a/libraries/muxer/src/test/java/androidx/media3/muxer/MediaMuxerCompatTest.java +++ b/libraries/muxer/src/test/java/androidx/media3/muxer/MediaMuxerCompatTest.java @@ -85,6 +85,22 @@ public void createMp4File_withCaptureRateKey_writesCorrectCaptureFps() throws Ex assertThat(actualCaptureFps).isEqualTo(expectedCaptureFps); } + @Test + public void addTrack_withZeroFrameRateInMediaFormat_succeeds() throws Exception { + String outputFilePath = tempFolder.newFile().getAbsolutePath(); + MediaMuxerCompat mediaMuxerCompat = new MediaMuxerCompat(outputFilePath, OUTPUT_FORMAT_MP4); + MediaFormat videoFormat = + MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, 1280, 720); + videoFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 0); + + try { + int trackIndex = mediaMuxerCompat.addTrack(videoFormat); + assertThat(trackIndex).isAtLeast(0); + } finally { + mediaMuxerCompat.release(); + } + } + private static MdtaMetadataEntry findCaptureFpsMetadata(Format format) { if (format.metadata == null) { return null; diff --git a/libraries/muxer/src/test/java/androidx/media3/muxer/Mp4MuxerEndToEndTest.java b/libraries/muxer/src/test/java/androidx/media3/muxer/Mp4MuxerEndToEndTest.java index 09b81a33755..ee1358dd48e 100644 --- a/libraries/muxer/src/test/java/androidx/media3/muxer/Mp4MuxerEndToEndTest.java +++ b/libraries/muxer/src/test/java/androidx/media3/muxer/Mp4MuxerEndToEndTest.java @@ -65,6 +65,7 @@ public class Mp4MuxerEndToEndTest { private static final String H265_HDR10_MP4 = "hdr10-720p.mp4"; private static final String AV1_MP4 = "sample_av1.mp4"; private static final String VP9_MP4 = "bbb_800x640_768kbps_30fps_vp9.mp4"; + private static final String IT35_MP4 = "sample_with_it35_track.mp4"; private final Context context = ApplicationProvider.getApplicationContext(); @Test @@ -175,6 +176,30 @@ public void createVp9Mp4File_withoutCsd_matchesExpected() throws Exception { MuxerTestUtil.getExpectedMp4DumpFilePath(VP9_MP4 + "_without_csd")); } + @Test + public void createMp4File_withIt35_matchesExpected() throws Exception { + String outputFilePath = temporaryFolder.newFile().getPath(); + + try (Mp4Muxer mp4Muxer = new Mp4Muxer.Builder(SeekableMuxerOutput.of(outputFilePath)).build()) { + mp4Muxer.addMetadataEntry( + new Mp4TimestampData( + /* creationTimestampSeconds= */ 100_000_000L, + /* modificationTimestampSeconds= */ 500_000_000L)); + feedInputDataToMuxer(context, mp4Muxer, MP4_FILE_ASSET_DIRECTORY + IT35_MP4); + mp4Muxer.addTrackReference( + /* trackId= */ 1, + Mp4Muxer.TRACK_REFERENCE_TYPE_CDSC, + /* referencedTrackIds= */ ImmutableList.of(0)); + } + + FakeExtractorOutput fakeExtractorOutput = + TestUtil.extractAllSamplesFromFilePath( + new Mp4Extractor(new DefaultSubtitleParserFactory()), checkNotNull(outputFilePath)); + + DumpFileAsserts.assertOutput( + context, fakeExtractorOutput, MuxerTestUtil.getExpectedMp4DumpFilePath(IT35_MP4)); + } + @Test public void createMp4File_muxerNotClosed_createsPartiallyWrittenValidFile() throws Exception { String outputPath = temporaryFolder.newFile().getPath(); diff --git a/libraries/session/src/main/java/androidx/media3/session/ConnectedControllersManager.java b/libraries/session/src/main/java/androidx/media3/session/ConnectedControllersManager.java index 2218875e86d..ca0c5f980e1 100644 --- a/libraries/session/src/main/java/androidx/media3/session/ConnectedControllersManager.java +++ b/libraries/session/src/main/java/androidx/media3/session/ConnectedControllersManager.java @@ -336,9 +336,11 @@ public Tracks getLastSentTracks(ControllerInfo controllerInfo) { public void updateLastSentTimelineAndTracks( ControllerInfo controllerInfo, Timeline timeline, Tracks tracks) { verifyApplicationThread(); - ConnectedControllerRecord record = checkNotNull(controllerRecords.get(controllerInfo)); - record.lastSentTimeline = timeline; - record.lastSentTracks = tracks; + @Nullable ConnectedControllerRecord record = controllerRecords.get(controllerInfo); + if (record != null) { + record.lastSentTimeline = timeline; + record.lastSentTracks = tracks; + } } public void addToCommandQueue( diff --git a/libraries/session/src/main/java/androidx/media3/session/MediaControllerImplBase.java b/libraries/session/src/main/java/androidx/media3/session/MediaControllerImplBase.java index 7a95a8aef3d..0c12e1a5db8 100644 --- a/libraries/session/src/main/java/androidx/media3/session/MediaControllerImplBase.java +++ b/libraries/session/src/main/java/androidx/media3/session/MediaControllerImplBase.java @@ -2974,11 +2974,17 @@ void onPlayerInfoChanged(PlayerInfo newPlayerInfo, BundlingExclusions bundlingEx checkNotNull(connectedToken)); PlayerInfo finalPlayerInfo = playerInfo; + // Discontinuity events are only emitted if both timelines are not empty, or if it's a seek + // discontinuity which is emitted even when the player is empty. + boolean seekOrNonEmptyTimeline = + finalPlayerInfo.discontinuityReason == DISCONTINUITY_REASON_SEEK + || (!oldPlayerInfo.timeline.isEmpty() && !finalPlayerInfo.timeline.isEmpty()); @Nullable @Player.DiscontinuityReason Integer positionDiscontinuityReason = - (!oldPlayerInfo.oldPositionInfo.equals(newPlayerInfo.oldPositionInfo) - || !oldPlayerInfo.newPositionInfo.equals(newPlayerInfo.newPositionInfo)) + (seekOrNonEmptyTimeline + && (!oldPlayerInfo.oldPositionInfo.equals(finalPlayerInfo.oldPositionInfo) + || !oldPlayerInfo.newPositionInfo.equals(finalPlayerInfo.newPositionInfo))) ? finalPlayerInfo.discontinuityReason : null; diff --git a/libraries/session/src/main/java/androidx/media3/session/MediaLibraryService.java b/libraries/session/src/main/java/androidx/media3/session/MediaLibraryService.java index 4712828ece7..5a7099dbb71 100644 --- a/libraries/session/src/main/java/androidx/media3/session/MediaLibraryService.java +++ b/libraries/session/src/main/java/androidx/media3/session/MediaLibraryService.java @@ -187,7 +187,9 @@ public interface Callback extends MediaSession.Callback { * androidx.media.MediaBrowserServiceCompat.BrowserRoot}, then the main thread may be blocked * until the returned future is done. If your service may be queried by a legacy {@code * android.support.v4.media.MediaBrowserCompat}, you should ensure that the future completes - * quickly to avoid blocking the main thread for a long period of time. + * quickly to avoid blocking the main thread for a long period of time. In particular, the + * returned future must not be completed on or by posting to the application thread (or main + * thread), as this will cause a deadlock while the thread is blocked. * * @param session The session for this event. * @param browser The browser information. diff --git a/libraries/session/src/main/java/androidx/media3/session/MediaLibraryServiceLegacyStub.java b/libraries/session/src/main/java/androidx/media3/session/MediaLibraryServiceLegacyStub.java index f706da2691a..2624cb63fbd 100644 --- a/libraries/session/src/main/java/androidx/media3/session/MediaLibraryServiceLegacyStub.java +++ b/libraries/session/src/main/java/androidx/media3/session/MediaLibraryServiceLegacyStub.java @@ -120,47 +120,48 @@ private void getRootOnHandler( haveRoot.open(); return; } + boolean isSearchSessionCommandAvailable = + getConnectedControllersManager() + .isSessionCommandAvailable(controller, SessionCommand.COMMAND_CODE_LIBRARY_SEARCH); + ImmutableList commandButtonsForMediaItems = + librarySessionImpl.getCommandButtonsForMediaItems(); + @Nullable ArrayList browserActionBundles = null; + if (!commandButtonsForMediaItems.isEmpty()) { + browserActionBundles = new ArrayList<>(); + for (int i = 0; i < commandButtonsForMediaItems.size(); i++) { + CommandButton commandButton = commandButtonsForMediaItems.get(i); + if (commandButton.sessionCommand != null + && commandButton.sessionCommand.commandCode == SessionCommand.COMMAND_CODE_CUSTOM) { + browserActionBundles.add(LegacyConversions.convertToBundle(commandButton)); + } + } + } @Nullable LibraryParams params = LegacyConversions.convertToLibraryParams(librarySessionImpl.getContext(), rootHints); ListenableFuture> future = librarySessionImpl.onGetLibraryRootOnHandler(controller, params); + @Nullable ArrayList finalBrowserActionBundles = browserActionBundles; Futures.addCallback( future, new FutureCallback>() { @Override public void onSuccess(@Nullable LibraryResult result) { + // Running on arbitrary future callback. if (result != null && result.resultCode == RESULT_SUCCESS && result.value != null) { @Nullable Bundle extras = result.params != null ? LegacyConversions.convertToRootHints(result.params) : new Bundle(); - boolean isSearchSessionCommandAvailable = - getConnectedControllersManager() - .isSessionCommandAvailable( - controller, SessionCommand.COMMAND_CODE_LIBRARY_SEARCH); checkNotNull(extras) .putBoolean( BROWSER_SERVICE_EXTRAS_KEY_SEARCH_SUPPORTED, isSearchSessionCommandAvailable); - ImmutableList commandButtonsForMediaItems = - librarySessionImpl.getCommandButtonsForMediaItems(); - if (!commandButtonsForMediaItems.isEmpty()) { - ArrayList browserActionBundles = new ArrayList<>(); - for (int i = 0; i < commandButtonsForMediaItems.size(); i++) { - CommandButton commandButton = commandButtonsForMediaItems.get(i); - if (commandButton.sessionCommand != null - && commandButton.sessionCommand.commandCode - == SessionCommand.COMMAND_CODE_CUSTOM) { - browserActionBundles.add(LegacyConversions.convertToBundle(commandButton)); - } - } - if (!browserActionBundles.isEmpty()) { - extras.putParcelableArrayList( - BROWSER_SERVICE_EXTRAS_KEY_CUSTOM_BROWSER_ACTION_ROOT_LIST, - browserActionBundles); - } + if (finalBrowserActionBundles != null && !finalBrowserActionBundles.isEmpty()) { + extras.putParcelableArrayList( + BROWSER_SERVICE_EXTRAS_KEY_CUSTOM_BROWSER_ACTION_ROOT_LIST, + finalBrowserActionBundles); } rootReference.set(new BrowserRoot(result.value.mediaId, extras)); } else { @@ -174,12 +175,13 @@ public void onSuccess(@Nullable LibraryResult result) { @Override public void onFailure(Throwable t) { + // Running on arbitrary future callback. Log.e(TAG, "Couldn't get a result from onGetLibraryRoot", t); rootReference.set(MediaUtils.defaultBrowserRoot); haveRoot.open(); } }, - this::postOrRunOnApplicationHandler); + MoreExecutors.directExecutor()); } // TODO(b/192455639): Optimize potential multiple calls of diff --git a/libraries/session/src/main/java/androidx/media3/session/MediaSession.java b/libraries/session/src/main/java/androidx/media3/session/MediaSession.java index ffc8692eafe..dce8f7b1132 100644 --- a/libraries/session/src/main/java/androidx/media3/session/MediaSession.java +++ b/libraries/session/src/main/java/androidx/media3/session/MediaSession.java @@ -1717,7 +1717,9 @@ default ConnectionResult onConnect(MediaSession session, ControllerInfo controll * legacy controller} is connecting to the session then this callback may block the main thread, * even if it's called on a different application thread. If it's possible that platform or * legacy controllers will connect to the session, you should ensure that the callback returns - * quickly to avoid blocking the main thread for a long period of time. + * quickly to avoid blocking the main thread for a long period of time. In particular, the + * returned future must not be completed on or by posting to the application thread (or main + * thread), as this will cause a deadlock while the thread is blocked. * * @param session The session for this event. * @param controller The {@linkplain ControllerInfo controller} information. diff --git a/libraries/session/src/main/java/androidx/media3/session/MediaSessionImpl.java b/libraries/session/src/main/java/androidx/media3/session/MediaSessionImpl.java index 63b11877395..de3f62bcb40 100644 --- a/libraries/session/src/main/java/androidx/media3/session/MediaSessionImpl.java +++ b/libraries/session/src/main/java/androidx/media3/session/MediaSessionImpl.java @@ -28,6 +28,7 @@ import static android.view.KeyEvent.KEYCODE_MEDIA_STOP; import static androidx.media3.common.Player.COMMAND_CHANGE_MEDIA_ITEMS; import static androidx.media3.common.Player.COMMAND_SET_MEDIA_ITEM; +import static androidx.media3.common.Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED; import static androidx.media3.common.util.Util.postOrRun; import static androidx.media3.session.MediaSessionStub.UNKNOWN_SEQUENCE_NUMBER; import static androidx.media3.session.SessionError.ERROR_SESSION_DISCONNECTED; @@ -437,7 +438,7 @@ public boolean isConnected(ControllerInfo controller) { } /** - * Returns whether the given {@link ControllerInfo} belongs to the the System UI controller. + * Returns whether the given {@link ControllerInfo} belongs to the System UI controller. * * @param controllerInfo The controller info. * @return Whether the controller info belongs to the System UI controller. @@ -2010,9 +2011,18 @@ public void onTimelineChanged(Timeline timeline, @Player.TimelineChangeReason in if (player == null) { return; } + SessionPositionInfo sessionPositionInfo = player.createSessionPositionInfo(); + if (reason == TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED + && session.playerInfo.timeline.isEmpty()) { + session.playerInfo = + new PlayerInfo.Builder(session.playerInfo) + .setOldPositionInfo(session.playerInfo.newPositionInfo) + .setNewPositionInfo(sessionPositionInfo.positionInfo) + .build(); + } session.playerInfo = session.playerInfo.copyWithTimelineAndSessionPositionInfo( - timeline, player.createSessionPositionInfo(), reason); + timeline, sessionPositionInfo, reason); session.onPlayerInfoChangedHandler.sendPlayerInfoChangedMessage( /* excludeTimeline= */ false, /* excludeTracks= */ true); session.dispatchRemoteControllerTaskToLegacyStub( diff --git a/libraries/session/src/main/java/androidx/media3/session/MediaSessionService.java b/libraries/session/src/main/java/androidx/media3/session/MediaSessionService.java index ef12d462137..50f02be54e5 100644 --- a/libraries/session/src/main/java/androidx/media3/session/MediaSessionService.java +++ b/libraries/session/src/main/java/androidx/media3/session/MediaSessionService.java @@ -587,17 +587,26 @@ public int onStartCommand(@Nullable Intent intent, int flags, int startId) { @SuppressLint("InlinedApi") // Using compile time constant FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK private void stopSelfSafely() { - Pair shutdownNotification = - getMediaNotificationManager().createShutdownNotification(/* context= */ this); - Util.setForegroundServiceNotification( - /* service= */ this, - /* notificationId= */ shutdownNotification.first, - /* notification= */ shutdownNotification.second, - ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK, - /* foregroundServiceManifestType= */ "mediaPlayback"); - getMediaNotificationManager().disableUserEngagedTimeout(); - Util.stopForeground(/* service= */ this, /* removeNotification= */ true); - stopSelf(); + try { + Pair shutdownNotification = + getMediaNotificationManager().createShutdownNotification(/* context= */ this); + Util.setForegroundServiceNotification( + /* service= */ this, + /* notificationId= */ shutdownNotification.first, + /* notification= */ shutdownNotification.second, + ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK, + /* foregroundServiceManifestType= */ "mediaPlayback"); + getMediaNotificationManager().disableUserEngagedTimeout(); + Util.stopForeground(/* service= */ this, /* removeNotification= */ true); + } catch (IllegalStateException e) { + if (SDK_INT >= 31 && e instanceof ForegroundServiceStartNotAllowedException) { + onForegroundServiceStartNotAllowedException(); + } else { + throw e; + } + } finally { + stopSelf(); + } } private static ControllerInfo createFallbackMediaButtonCaller(Intent mediaButtonIntent) { diff --git a/libraries/session/src/main/java/androidx/media3/session/MediaSessionServiceLegacyStub.java b/libraries/session/src/main/java/androidx/media3/session/MediaSessionServiceLegacyStub.java index be4cbd60241..761b2618ff3 100644 --- a/libraries/session/src/main/java/androidx/media3/session/MediaSessionServiceLegacyStub.java +++ b/libraries/session/src/main/java/androidx/media3/session/MediaSessionServiceLegacyStub.java @@ -31,6 +31,7 @@ import com.google.common.util.concurrent.FutureCallback; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; +import com.google.common.util.concurrent.MoreExecutors; import java.util.List; import java.util.concurrent.atomic.AtomicReference; @@ -83,25 +84,20 @@ public BrowserRoot onGetRoot( new FutureCallback() { @Override public void onSuccess(MediaSession.ConnectionResult result) { + // Running on arbitrary future callback. resultReference.set(result); - if (result.isAccepted) { - connectedControllersManager.addController( - info, - controller, - result.availableSessionCommands, - result.availablePlayerCommands); - } haveResult.open(); } @Override public void onFailure(Throwable t) { + // Running on arbitrary future callback. // Should not happen, onConnect should at least return a rejected result. resultReference.set(MediaSession.ConnectionResult.reject()); haveResult.open(); } }, - this::postOrRunOnApplicationHandler); + MoreExecutors.directExecutor()); }); try { haveResult.block(); @@ -110,9 +106,17 @@ public void onFailure(Throwable t) { return null; } MediaSession.ConnectionResult result = resultReference.get(); - if (!result.isAccepted) { + if (result == null || !result.isAccepted) { return null; } + postOrRunOnApplicationHandler( + () -> { + if (sessionImpl.isReleased()) { + return; + } + connectedControllersManager.addController( + info, controller, result.availableSessionCommands, result.availablePlayerCommands); + }); // No library root, but keep browser compat connected to allow getting session. return MediaUtils.defaultBrowserRoot; } diff --git a/libraries/session/src/main/java/androidx/media3/session/legacy/MediaBrowserCompat.java b/libraries/session/src/main/java/androidx/media3/session/legacy/MediaBrowserCompat.java index 15141c90a67..c4aa1ab043c 100644 --- a/libraries/session/src/main/java/androidx/media3/session/legacy/MediaBrowserCompat.java +++ b/libraries/session/src/main/java/androidx/media3/session/legacy/MediaBrowserCompat.java @@ -211,7 +211,7 @@ public boolean isConnected() { /** * Gets the root id. * - *

    Note that the root id may become invalid or change when when the browser is disconnected. + *

    Note that the root id may become invalid or change when the browser is disconnected. * * @throws IllegalStateException if not connected. */ @@ -233,7 +233,7 @@ public Bundle getExtras() { /** * Gets the media session token associated with the media browser. * - *

    Note that the session token may become invalid or change when when the browser is + *

    Note that the session token may become invalid or change when the browser is * disconnected. * * @return The session token for the browser, never null. diff --git a/libraries/session/src/main/res/values-gl/strings.xml b/libraries/session/src/main/res/values-gl/strings.xml index fe8cfef4f4c..ddffac96b64 100755 --- a/libraries/session/src/main/res/values-gl/strings.xml +++ b/libraries/session/src/main/res/values-gl/strings.xml @@ -17,7 +17,7 @@ Aquí non se pode acceder a ese contido Esta aplicación non pode realizar a acción Ese contido está bloqueado - Requírese acceso premium + Requírese acceso prémium Non se poden saltar máis pistas Datos de entrada incorrectos Erro de entrada/saída diff --git a/libraries/session/src/test/java/androidx/media3/session/MediaSessionUnitTest.java b/libraries/session/src/test/java/androidx/media3/session/MediaSessionUnitTest.java index a55be7b4523..93522ca3e7c 100644 --- a/libraries/session/src/test/java/androidx/media3/session/MediaSessionUnitTest.java +++ b/libraries/session/src/test/java/androidx/media3/session/MediaSessionUnitTest.java @@ -22,15 +22,18 @@ import android.graphics.Color; import android.os.Bundle; import androidx.media3.common.MediaLibraryInfo; +import androidx.media3.common.Player; import androidx.media3.common.util.BitmapLoader; import androidx.media3.session.legacy.MediaSessionManager; import androidx.media3.test.utils.TestExoPlayerBuilder; import androidx.test.ext.junit.runners.AndroidJUnit4; import java.io.ByteArrayOutputStream; +import java.util.concurrent.atomic.AtomicReference; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.robolectric.shadows.ShadowLooper; /** Tests for {@link MediaSession}. */ @RunWith(AndroidJUnit4.class) @@ -262,6 +265,28 @@ public void getBitmapLoader_defaultConfiguration_decodesToExactLimit() throws Ex assertThat(decodedBitmap.getHeight()).isEqualTo(limit); } + @Test + public void prepare_withControllerReleasedInListenerCallback_doesNotCrash() throws Exception { + AtomicReference controllerReference = new AtomicReference<>(); + Player.Listener listener = + new Player.Listener() { + @Override + public void onPlaybackStateChanged(int playbackState) { + MediaController controller = controllerReference.get(); + if (controller != null) { + controller.release(); + } + } + }; + MediaController controller = + new MediaController.Builder(getApplicationContext(), session.getToken()).buildAsync().get(); + controller.addListener(listener); + controllerReference.set(controller); + + session.getPlayer().prepare(); + ShadowLooper.idleMainLooper(); + } + private static MediaSession.ControllerInfo createMinimalLegacyControllerInfo( MediaSessionManager.RemoteUserInfo remoteUserInfo) { return new MediaSession.ControllerInfo( diff --git a/libraries/test_data/src/test/assets/audiosinkdumps/mp4/sample_mhm1_prefaudiolang.mp4.nonasciicmd.asi.dump b/libraries/test_data/src/test/assets/audiosinkdumps/mp4/sample_mhm1_prefaudiolang.mp4.nonasciicmd.asi.dump new file mode 100644 index 00000000000..154240907a6 --- /dev/null +++ b/libraries/test_data/src/test/assets/audiosinkdumps/mp4/sample_mhm1_prefaudiolang.mp4.nonasciicmd.asi.dump @@ -0,0 +1,46 @@ +MPEG-H ASI 0 = + + + + + + + + + p1 + + + + + + + g1 + + + + + + g2 + + + + + + g4 + + + + + + g3 + + + + + s1 + + + + + + diff --git a/libraries/test_data/src/test/assets/audiosinkdumps/mp4/sample_mhm1_prefaudiolang.mp4.nonasciicmd.audiosink.dump b/libraries/test_data/src/test/assets/audiosinkdumps/mp4/sample_mhm1_prefaudiolang.mp4.nonasciicmd.audiosink.dump new file mode 100644 index 00000000000..2794bf7bff6 --- /dev/null +++ b/libraries/test_data/src/test/assets/audiosinkdumps/mp4/sample_mhm1_prefaudiolang.mp4.nonasciicmd.audiosink.dump @@ -0,0 +1,170 @@ +AudioSink: + buffer count = 41 + discontinuity: + config: + pcmEncoding = pcm-16 + channelCount = 2 + sampleRate = 48000 + buffer #0: + time = 1000000000000 + channel[0] = 282783674 + channel[1] = 282783674 + buffer #1: + time = 1000000021333 + channel[0] = -1443166734 + channel[1] = -1443166734 + buffer #2: + time = 1000000042666 + channel[0] = -664167358 + channel[1] = -664167358 + buffer #3: + time = 1000000064000 + channel[0] = -1357830080 + channel[1] = -1357830080 + buffer #4: + time = 1000000085333 + channel[0] = -517045533 + channel[1] = -517045533 + buffer #5: + time = 1000000106666 + channel[0] = -238596381 + channel[1] = -238596381 + buffer #6: + time = 1000000128000 + channel[0] = 216065051 + channel[1] = 216065051 + buffer #7: + time = 1000000149333 + channel[0] = -876388976 + channel[1] = -876388976 + buffer #8: + time = 1000000170666 + channel[0] = 19660189 + channel[1] = 19660189 + buffer #9: + time = 1000000192000 + channel[0] = 1646453118 + channel[1] = 1646453118 + buffer #10: + time = 1000000213333 + channel[0] = 755521285 + channel[1] = 755521285 + buffer #11: + time = 1000000234666 + channel[0] = -1278578714 + channel[1] = -1278578714 + buffer #12: + time = 1000000256000 + channel[0] = -505412467 + channel[1] = -505412467 + buffer #13: + time = 1000000277333 + channel[0] = 1268823513 + channel[1] = 1268823513 + buffer #14: + time = 1000000298666 + channel[0] = -279779843 + channel[1] = -279779843 + buffer #15: + time = 1000000320000 + channel[0] = 965962998 + channel[1] = 965962998 + buffer #16: + time = 1000000341333 + channel[0] = 1916683672 + channel[1] = 1916683672 + buffer #17: + time = 1000000362666 + channel[0] = 1159431915 + channel[1] = 1159431915 + buffer #18: + time = 1000000384000 + channel[0] = -1569393028 + channel[1] = -1569393028 + buffer #19: + time = 1000000405333 + channel[0] = -144016301 + channel[1] = -144016301 + buffer #20: + time = 1000000426666 + channel[0] = 2049508790 + channel[1] = 2049508790 + buffer #21: + time = 1000000448000 + channel[0] = 1540502013 + channel[1] = 1540502013 + buffer #22: + time = 1000000469333 + channel[0] = 1803818321 + channel[1] = 1803818321 + buffer #23: + time = 1000000490666 + channel[0] = 1249500551 + channel[1] = 1249500551 + buffer #24: + time = 1000000512000 + channel[0] = -741827833 + channel[1] = -741827833 + buffer #25: + time = 1000000533333 + channel[0] = 1510404518 + channel[1] = 1510404518 + buffer #26: + time = 1000000554666 + channel[0] = 640973283 + channel[1] = 640973283 + buffer #27: + time = 1000000576000 + channel[0] = 667927860 + channel[1] = 667927860 + buffer #28: + time = 1000000597333 + channel[0] = -1400252340 + channel[1] = -1400252340 + buffer #29: + time = 1000000618666 + channel[0] = -109250957 + channel[1] = -109250957 + buffer #30: + time = 1000000640000 + channel[0] = -1213175193 + channel[1] = -1213175193 + buffer #31: + time = 1000000661333 + channel[0] = 130930266 + channel[1] = 130930266 + buffer #32: + time = 1000000682666 + channel[0] = 635431592 + channel[1] = 635431592 + buffer #33: + time = 1000000704000 + channel[0] = 66494029 + channel[1] = 66494029 + buffer #34: + time = 1000000725333 + channel[0] = 1712210053 + channel[1] = 1712210053 + buffer #35: + time = 1000000746666 + channel[0] = -1176226604 + channel[1] = -1176226604 + buffer #36: + time = 1000000768000 + channel[0] = 960464384 + channel[1] = 960464384 + buffer #37: + time = 1000000789333 + channel[0] = -712964186 + channel[1] = -712964186 + buffer #38: + time = 1000000810666 + channel[0] = -1435730719 + channel[1] = -1435730719 + buffer #39: + time = 1000000832000 + channel[0] = -1658363839 + channel[1] = -1658363839 + buffer #40: + time = 1000000853333 + data = 4096 zeroes diff --git a/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.0.dump b/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.0.dump index a20b1826dbd..7558a7ebf54 100644 --- a/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.0.dump +++ b/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.0.dump @@ -1,7 +1,10 @@ seekMap: - isSeekable = false + isSeekable = true duration = 1072000 - getPosition(0) = [[timeUs=0, position=0]] + getPosition(0) = [[timeUs=67000, position=5562]] + getPosition(1) = [[timeUs=67000, position=5562]] + getPosition(536000) = [[timeUs=67000, position=5562]] + getPosition(1072000) = [[timeUs=67000, position=5562]] numberOfTracks = 2 track 1: total output bytes = 89502 diff --git a/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.1.dump b/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.1.dump index fbda13d6b45..7558a7ebf54 100644 --- a/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.1.dump +++ b/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.1.dump @@ -1,7 +1,10 @@ seekMap: - isSeekable = false + isSeekable = true duration = 1072000 - getPosition(0) = [[timeUs=0, position=0]] + getPosition(0) = [[timeUs=67000, position=5562]] + getPosition(1) = [[timeUs=67000, position=5562]] + getPosition(536000) = [[timeUs=67000, position=5562]] + getPosition(1072000) = [[timeUs=67000, position=5562]] numberOfTracks = 2 track 1: total output bytes = 89502 @@ -18,110 +21,11 @@ track 1: chromaBitdepth = 8 selectionFlags = [default] language = und - label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee labels: lang = und - value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + metadata = entries=[ThumbnailMetadata: presentationTimeUs=67000] initializationData: data = length 30, hash F6F3D010 data = length 10, hash 7A0D0F2B @@ -150,7 +54,6 @@ eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee flags = 0 data = length 721, hash C50D1C73 sample 6: - time = 23400 time = 234000 flags = 0 data = length 519, hash 65FE1911 @@ -258,110 +161,11 @@ eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee chromaBitdepth = 8 selectionFlags = [default] language = und - label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee labels: lang = und - value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + metadata = entries=[ThumbnailMetadata: presentationTimeUs=67000] initializationData: data = length 30, hash F6F3D010 data = length 10, hash 7A0D0F2B @@ -422,7 +226,6 @@ track 2: data = length 418, hash D69A9251 sample 11: time = 512489 - fl flags = 1 data = length 418, hash BCFB758D sample 12: diff --git a/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.2.dump b/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.2.dump index fbda13d6b45..7558a7ebf54 100644 --- a/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.2.dump +++ b/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.2.dump @@ -1,7 +1,10 @@ seekMap: - isSeekable = false + isSeekable = true duration = 1072000 - getPosition(0) = [[timeUs=0, position=0]] + getPosition(0) = [[timeUs=67000, position=5562]] + getPosition(1) = [[timeUs=67000, position=5562]] + getPosition(536000) = [[timeUs=67000, position=5562]] + getPosition(1072000) = [[timeUs=67000, position=5562]] numberOfTracks = 2 track 1: total output bytes = 89502 @@ -18,110 +21,11 @@ track 1: chromaBitdepth = 8 selectionFlags = [default] language = und - label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee labels: lang = und - value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + metadata = entries=[ThumbnailMetadata: presentationTimeUs=67000] initializationData: data = length 30, hash F6F3D010 data = length 10, hash 7A0D0F2B @@ -150,7 +54,6 @@ eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee flags = 0 data = length 721, hash C50D1C73 sample 6: - time = 23400 time = 234000 flags = 0 data = length 519, hash 65FE1911 @@ -258,110 +161,11 @@ eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee chromaBitdepth = 8 selectionFlags = [default] language = und - label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee labels: lang = und - value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + metadata = entries=[ThumbnailMetadata: presentationTimeUs=67000] initializationData: data = length 30, hash F6F3D010 data = length 10, hash 7A0D0F2B @@ -422,7 +226,6 @@ track 2: data = length 418, hash D69A9251 sample 11: time = 512489 - fl flags = 1 data = length 418, hash BCFB758D sample 12: diff --git a/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.3.dump b/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.3.dump index fbda13d6b45..7558a7ebf54 100644 --- a/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.3.dump +++ b/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.3.dump @@ -1,7 +1,10 @@ seekMap: - isSeekable = false + isSeekable = true duration = 1072000 - getPosition(0) = [[timeUs=0, position=0]] + getPosition(0) = [[timeUs=67000, position=5562]] + getPosition(1) = [[timeUs=67000, position=5562]] + getPosition(536000) = [[timeUs=67000, position=5562]] + getPosition(1072000) = [[timeUs=67000, position=5562]] numberOfTracks = 2 track 1: total output bytes = 89502 @@ -18,110 +21,11 @@ track 1: chromaBitdepth = 8 selectionFlags = [default] language = und - label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee labels: lang = und - value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + metadata = entries=[ThumbnailMetadata: presentationTimeUs=67000] initializationData: data = length 30, hash F6F3D010 data = length 10, hash 7A0D0F2B @@ -150,7 +54,6 @@ eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee flags = 0 data = length 721, hash C50D1C73 sample 6: - time = 23400 time = 234000 flags = 0 data = length 519, hash 65FE1911 @@ -258,110 +161,11 @@ eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee chromaBitdepth = 8 selectionFlags = [default] language = und - label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + label = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee labels: lang = und - value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee -eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + value = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee + metadata = entries=[ThumbnailMetadata: presentationTimeUs=67000] initializationData: data = length 30, hash F6F3D010 data = length 10, hash 7A0D0F2B @@ -422,7 +226,6 @@ track 2: data = length 418, hash D69A9251 sample 11: time = 512489 - fl flags = 1 data = length 418, hash BCFB758D sample 12: diff --git a/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.unknown_length.dump b/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.unknown_length.dump index a20b1826dbd..7558a7ebf54 100644 --- a/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.unknown_length.dump +++ b/libraries/test_data/src/test/assets/extractordumps/mkv/sample_last_cluster.mkv.unknown_length.dump @@ -1,7 +1,10 @@ seekMap: - isSeekable = false + isSeekable = true duration = 1072000 - getPosition(0) = [[timeUs=0, position=0]] + getPosition(0) = [[timeUs=67000, position=5562]] + getPosition(1) = [[timeUs=67000, position=5562]] + getPosition(536000) = [[timeUs=67000, position=5562]] + getPosition(1072000) = [[timeUs=67000, position=5562]] numberOfTracks = 2 track 1: total output bytes = 89502 diff --git a/libraries/test_data/src/test/assets/media/dash/empty-segment-timeline/sample.mpd b/libraries/test_data/src/test/assets/media/dash/empty-segment-timeline/sample.mpd new file mode 100644 index 00000000000..cf12169456c --- /dev/null +++ b/libraries/test_data/src/test/assets/media/dash/empty-segment-timeline/sample.mpd @@ -0,0 +1,14 @@ + + + + + + + + + + + diff --git a/libraries/test_data/src/test/assets/media/mp4/sample_av1_mono.mp4 b/libraries/test_data/src/test/assets/media/mp4/sample_av1_mono.mp4 deleted file mode 100644 index 7d3fe6ddae4..00000000000 Binary files a/libraries/test_data/src/test/assets/media/mp4/sample_av1_mono.mp4 and /dev/null differ diff --git a/libraries/test_data/src/test/assets/muxerdumps/mp4/sample_with_it35_track.mp4.dump b/libraries/test_data/src/test/assets/muxerdumps/mp4/sample_with_it35_track.mp4.dump new file mode 100644 index 00000000000..9addf8371de --- /dev/null +++ b/libraries/test_data/src/test/assets/muxerdumps/mp4/sample_with_it35_track.mp4.dump @@ -0,0 +1,286 @@ +seekMap: + isSeekable = true + duration = 1002800 + getPosition(0) = [[timeUs=0, position=400052]] + getPosition(1) = [[timeUs=0, position=400052]] + getPosition(501400) = [[timeUs=0, position=400052]] + getPosition(1002800) = [[timeUs=0, position=400052]] +numberOfTracks = 2 +track 0: + total output bytes = 43683 + sample count = 30 + track duration = 1002800 + format 0: + averageBitrate = 348496 + id = 1 + containerMimeType = video/mp4 + sampleMimeType = video/av01 + codecs = av01.0.00M.10 + maxInputSize = 18085 + width = 480 + height = 270 + frameRate = 29.92 + colorInfo: + colorSpace = 6 + colorRange = 2 + colorTransfer = 6 + lumaBitdepth = 10 + chromaBitdepth = 10 + language = en + metadata = entries=[Mp4Timestamp: creation time=100000000, modification time=500000000, timescale=10000, ThumbnailMetadata: presentationTimeUs=0] + initializationData: + data = length 20, hash 27B68A02 + sample 0: + time = 0 + flags = 1 + data = length 18055, hash 4A4CEBD8 + sample 1: + time = 33422 + flags = 0 + data = length 10390, hash 1A97B887 + sample 2: + time = 66855 + flags = 0 + data = length 3, hash D5E0 + sample 3: + time = 100277 + flags = 0 + data = length 111, hash F52A3D2C + sample 4: + time = 133700 + flags = 0 + data = length 3, hash D5D0 + sample 5: + time = 167133 + flags = 0 + data = length 748, hash 7FA30B17 + sample 6: + time = 200555 + flags = 0 + data = length 3, hash D610 + sample 7: + time = 233977 + flags = 0 + data = length 94, hash D426B3A3 + sample 8: + time = 267411 + flags = 0 + data = length 3, hash D5C0 + sample 9: + time = 300833 + flags = 0 + data = length 1487, hash 1B89F2D3 + sample 10: + time = 334255 + flags = 0 + data = length 3, hash D5D0 + sample 11: + time = 367688 + flags = 0 + data = length 243, hash 83AC8EF9 + sample 12: + time = 401111 + flags = 0 + data = length 3, hash D600 + sample 13: + time = 434544 + flags = 0 + data = length 719, hash 3F9A2D2F + sample 14: + time = 467966 + flags = 0 + data = length 3, hash D5E0 + sample 15: + time = 501388 + flags = 0 + data = length 398, hash 29898A8D + sample 16: + time = 534822 + flags = 0 + data = length 200, hash 18678644 + sample 17: + time = 568244 + flags = 0 + data = length 3, hash D5B0 + sample 18: + time = 601666 + flags = 0 + data = length 8443, hash 90C5F9E + sample 19: + time = 635100 + flags = 0 + data = length 3, hash D5C0 + sample 20: + time = 668522 + flags = 0 + data = length 299, hash 3219B04 + sample 21: + time = 701944 + flags = 0 + data = length 222, hash FBB32D8 + sample 22: + time = 735377 + flags = 0 + data = length 3, hash D600 + sample 23: + time = 768800 + flags = 0 + data = length 645, hash 3FF6F2DF + sample 24: + time = 802233 + flags = 0 + data = length 3, hash D5E0 + sample 25: + time = 835655 + flags = 0 + data = length 251, hash 83CE17A6 + sample 26: + time = 869077 + flags = 0 + data = length 253, hash 34714BEA + sample 27: + time = 902511 + flags = 0 + data = length 3, hash D610 + sample 28: + time = 935933 + flags = 0 + data = length 482, hash 4D8E647E + sample 29: + time = 969355 + flags = 536870912 + data = length 607, hash 230AC585 +track 1: + total output bytes = 7350 + sample count = 30 + track duration = 1002800 + format 0: + averageBitrate = 58637 + id = 2 + containerMimeType = video/mp4 + sampleMimeType = application/x-itut-t35 + maxInputSize = 275 + metadata = entries=[Mp4Timestamp: creation time=100000000, modification time=500000000, timescale=10000] + initializationData: + data = length 5, hash FD925165 + sample 0: + time = 0 + flags = 1 + data = length 245, hash 9BFA0B + sample 1: + time = 33422 + flags = 1 + data = length 245, hash EA2065CD + sample 2: + time = 66855 + flags = 1 + data = length 245, hash F3A0DA5C + sample 3: + time = 100277 + flags = 1 + data = length 245, hash CF1BDEB2 + sample 4: + time = 133700 + flags = 1 + data = length 245, hash BA53650F + sample 5: + time = 167133 + flags = 1 + data = length 245, hash 88941B39 + sample 6: + time = 200555 + flags = 1 + data = length 245, hash 302A69B6 + sample 7: + time = 233977 + flags = 1 + data = length 245, hash 86A9B7CF + sample 8: + time = 267411 + flags = 1 + data = length 245, hash 6C8AF8DF + sample 9: + time = 300833 + flags = 1 + data = length 245, hash A8D264F + sample 10: + time = 334255 + flags = 1 + data = length 245, hash BF90E97B + sample 11: + time = 367688 + flags = 1 + data = length 245, hash 3A036FF7 + sample 12: + time = 401111 + flags = 1 + data = length 245, hash 4C76613D + sample 13: + time = 434544 + flags = 1 + data = length 245, hash 9C103E0D + sample 14: + time = 467966 + flags = 1 + data = length 245, hash 546611FD + sample 15: + time = 501388 + flags = 1 + data = length 245, hash 2EEAD77C + sample 16: + time = 534822 + flags = 1 + data = length 245, hash 45EE18FD + sample 17: + time = 568244 + flags = 1 + data = length 245, hash 6C4A5B60 + sample 18: + time = 601666 + flags = 1 + data = length 245, hash C55E7F4F + sample 19: + time = 635100 + flags = 1 + data = length 245, hash 8C43E61B + sample 20: + time = 668522 + flags = 1 + data = length 245, hash 88CB156F + sample 21: + time = 701944 + flags = 1 + data = length 245, hash 975E8975 + sample 22: + time = 735377 + flags = 1 + data = length 245, hash D7DAF392 + sample 23: + time = 768800 + flags = 1 + data = length 245, hash 72F8BC8A + sample 24: + time = 802233 + flags = 1 + data = length 245, hash 69F05BD3 + sample 25: + time = 835655 + flags = 1 + data = length 245, hash E12DFF0E + sample 26: + time = 869077 + flags = 1 + data = length 245, hash 5DD18D72 + sample 27: + time = 902511 + flags = 1 + data = length 245, hash 2B6AB923 + sample 28: + time = 935933 + flags = 1 + data = length 245, hash 68205A3F + sample 29: + time = 969355 + flags = 536870913 + data = length 245, hash 7D03F36A +tracksEnded = true diff --git a/libraries/test_data/src/test/assets/muxerdumps/mp4/tref_box_with_multiple_track_reference.dump b/libraries/test_data/src/test/assets/muxerdumps/mp4/tref_box_with_multiple_track_reference.dump index 1885b4d1e58..65617dc51d3 100644 --- a/libraries/test_data/src/test/assets/muxerdumps/mp4/tref_box_with_multiple_track_reference.dump +++ b/libraries/test_data/src/test/assets/muxerdumps/mp4/tref_box_with_multiple_track_reference.dump @@ -1,2 +1,2 @@ tref (40 bytes): - Data = length 32, hash FEC3528B + Data = length 32, hash 3512300F diff --git a/libraries/test_data/src/test/assets/muxerdumps/mp4/tref_box_with_one_track_reference.dump b/libraries/test_data/src/test/assets/muxerdumps/mp4/tref_box_with_one_track_reference.dump index 4ba977c7386..c91cc863461 100644 --- a/libraries/test_data/src/test/assets/muxerdumps/mp4/tref_box_with_one_track_reference.dump +++ b/libraries/test_data/src/test/assets/muxerdumps/mp4/tref_box_with_one_track_reference.dump @@ -1,2 +1,2 @@ tref (24 bytes): - Data = length 16, hash EA78AAEB + Data = length 16, hash 6F65E305 diff --git a/libraries/test_data/src/test/assets/muxerdumps/mp4_with_t35_metadata_track_referencing_video_track.box.dump b/libraries/test_data/src/test/assets/muxerdumps/mp4_with_t35_metadata_track_referencing_video_track.box.dump index 5d99312f6e1..d8ed2f9ac7a 100644 --- a/libraries/test_data/src/test/assets/muxerdumps/mp4_with_t35_metadata_track_referencing_video_track.box.dump +++ b/libraries/test_data/src/test/assets/muxerdumps/mp4_with_t35_metadata_track_referencing_video_track.box.dump @@ -57,7 +57,7 @@ moov (1666 bytes): tkhd (92 bytes): Data = length 84, hash A551A7FB tref (20 bytes): - Data = length 12, hash 2B3ACB65 + Data = length 12, hash 816C207F mdia (333 bytes): mdhd (32 bytes): Data = length 24, hash 41542D81 diff --git a/libraries/test_data/src/test/assets/playbackdumps/prewarmingRenderer/multipleVideoImagePlaylist-withSecondaryRenderers.dump b/libraries/test_data/src/test/assets/playbackdumps/prewarmingRenderer/multipleVideoImagePlaylist-withSecondaryRenderers.dump new file mode 100644 index 00000000000..8be873cf4ff --- /dev/null +++ b/libraries/test_data/src/test/assets/playbackdumps/prewarmingRenderer/multipleVideoImagePlaylist-withSecondaryRenderers.dump @@ -0,0 +1,2052 @@ +MediaCodecAdapter (media3.audio.aac): + inputBuffers: + count = 92 + input buffer #0: + timeUs = 1000000044000 + contents = length 23, hash 47DE9131 + input buffer #1: + timeUs = 1000000067219 + contents = length 6, hash 31EC5206 + input buffer #2: + timeUs = 1000000090439 + contents = length 148, hash 894A176B + input buffer #3: + timeUs = 1000000113659 + contents = length 189, hash CEF235A1 + input buffer #4: + timeUs = 1000000136879 + contents = length 205, hash BBF5F7B0 + input buffer #5: + timeUs = 1000000160099 + contents = length 210, hash F278B193 + input buffer #6: + timeUs = 1000000183319 + contents = length 210, hash 82DA1589 + input buffer #7: + timeUs = 1000000206539 + contents = length 207, hash 5BE231DF + input buffer #8: + timeUs = 1000000229759 + contents = length 225, hash 18819EE1 + input buffer #9: + timeUs = 1000000252979 + contents = length 215, hash CA7FA67B + input buffer #10: + timeUs = 1000000276199 + contents = length 211, hash 581A1C18 + input buffer #11: + timeUs = 1000000299419 + contents = length 216, hash ADB88187 + input buffer #12: + timeUs = 1000000322639 + contents = length 229, hash 2E8BA4DC + input buffer #13: + timeUs = 1000000345859 + contents = length 232, hash 22F0C510 + input buffer #14: + timeUs = 1000000369079 + contents = length 235, hash 867AD0DC + input buffer #15: + timeUs = 1000000392299 + contents = length 231, hash 84E823A8 + input buffer #16: + timeUs = 1000000415519 + contents = length 226, hash 1BEF3A95 + input buffer #17: + timeUs = 1000000438739 + contents = length 216, hash EAA345AE + input buffer #18: + timeUs = 1000000461959 + contents = length 229, hash 6957411F + input buffer #19: + timeUs = 1000000485179 + contents = length 219, hash 41275022 + input buffer #20: + timeUs = 1000000508399 + contents = length 241, hash 6495DF96 + input buffer #21: + timeUs = 1000000531619 + contents = length 228, hash 63D95906 + input buffer #22: + timeUs = 1000000554839 + contents = length 238, hash 34F676F9 + input buffer #23: + timeUs = 1000000578058 + contents = length 234, hash E5CBC045 + input buffer #24: + timeUs = 1000000601278 + contents = length 231, hash 5FC43661 + input buffer #25: + timeUs = 1000000624498 + contents = length 217, hash 682708ED + input buffer #26: + timeUs = 1000000647718 + contents = length 239, hash D43780FC + input buffer #27: + timeUs = 1000000670938 + contents = length 243, hash C5E17980 + input buffer #28: + timeUs = 1000000694158 + contents = length 231, hash AC5837BA + input buffer #29: + timeUs = 1000000717378 + contents = length 230, hash 169EE895 + input buffer #30: + timeUs = 1000000740598 + contents = length 238, hash C48FF3F1 + input buffer #31: + timeUs = 1000000763818 + contents = length 225, hash 531E4599 + input buffer #32: + timeUs = 1000000787038 + contents = length 232, hash CB3C6B8D + input buffer #33: + timeUs = 1000000810258 + contents = length 243, hash F8C94C7 + input buffer #34: + timeUs = 1000000833478 + contents = length 232, hash A646A7D0 + input buffer #35: + timeUs = 1000000856698 + contents = length 237, hash E8B787A5 + input buffer #36: + timeUs = 1000000879918 + contents = length 228, hash 3FA7A29F + input buffer #37: + timeUs = 1000000903138 + contents = length 235, hash B9B33B0A + input buffer #38: + timeUs = 1000000926358 + contents = length 264, hash 71A4869E + input buffer #39: + timeUs = 1000000949578 + contents = length 257, hash D049B54C + input buffer #40: + timeUs = 1000000972798 + contents = length 227, hash 66757231 + input buffer #41: + timeUs = 1000000996018 + contents = length 227, hash BD374F1B + input buffer #42: + timeUs = 1000001019238 + contents = length 235, hash 999477F6 + input buffer #43: + timeUs = 1000001042458 + contents = length 229, hash FFF98DF0 + input buffer #44: + timeUs = 1000001065678 + contents = length 6, hash 31B22286 + input buffer #45: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + input buffer #46: + timeUs = 1000001068000 + contents = length 23, hash 47DE9131 + input buffer #47: + timeUs = 1000001091219 + contents = length 6, hash 31EC5206 + input buffer #48: + timeUs = 1000001114439 + contents = length 148, hash 894A176B + input buffer #49: + timeUs = 1000001137659 + contents = length 189, hash CEF235A1 + input buffer #50: + timeUs = 1000001160879 + contents = length 205, hash BBF5F7B0 + input buffer #51: + timeUs = 1000001184099 + contents = length 210, hash F278B193 + input buffer #52: + timeUs = 1000001207319 + contents = length 210, hash 82DA1589 + input buffer #53: + timeUs = 1000001230539 + contents = length 207, hash 5BE231DF + input buffer #54: + timeUs = 1000001253759 + contents = length 225, hash 18819EE1 + input buffer #55: + timeUs = 1000001276979 + contents = length 215, hash CA7FA67B + input buffer #56: + timeUs = 1000001300199 + contents = length 211, hash 581A1C18 + input buffer #57: + timeUs = 1000001323419 + contents = length 216, hash ADB88187 + input buffer #58: + timeUs = 1000001346639 + contents = length 229, hash 2E8BA4DC + input buffer #59: + timeUs = 1000001369859 + contents = length 232, hash 22F0C510 + input buffer #60: + timeUs = 1000001393079 + contents = length 235, hash 867AD0DC + input buffer #61: + timeUs = 1000001416299 + contents = length 231, hash 84E823A8 + input buffer #62: + timeUs = 1000001439519 + contents = length 226, hash 1BEF3A95 + input buffer #63: + timeUs = 1000001462739 + contents = length 216, hash EAA345AE + input buffer #64: + timeUs = 1000001485959 + contents = length 229, hash 6957411F + input buffer #65: + timeUs = 1000001509179 + contents = length 219, hash 41275022 + input buffer #66: + timeUs = 1000001532399 + contents = length 241, hash 6495DF96 + input buffer #67: + timeUs = 1000001555619 + contents = length 228, hash 63D95906 + input buffer #68: + timeUs = 1000001578839 + contents = length 238, hash 34F676F9 + input buffer #69: + timeUs = 1000001602058 + contents = length 234, hash E5CBC045 + input buffer #70: + timeUs = 1000001625278 + contents = length 231, hash 5FC43661 + input buffer #71: + timeUs = 1000001648498 + contents = length 217, hash 682708ED + input buffer #72: + timeUs = 1000001671718 + contents = length 239, hash D43780FC + input buffer #73: + timeUs = 1000001694938 + contents = length 243, hash C5E17980 + input buffer #74: + timeUs = 1000001718158 + contents = length 231, hash AC5837BA + input buffer #75: + timeUs = 1000001741378 + contents = length 230, hash 169EE895 + input buffer #76: + timeUs = 1000001764598 + contents = length 238, hash C48FF3F1 + input buffer #77: + timeUs = 1000001787818 + contents = length 225, hash 531E4599 + input buffer #78: + timeUs = 1000001811038 + contents = length 232, hash CB3C6B8D + input buffer #79: + timeUs = 1000001834258 + contents = length 243, hash F8C94C7 + input buffer #80: + timeUs = 1000001857478 + contents = length 232, hash A646A7D0 + input buffer #81: + timeUs = 1000001880698 + contents = length 237, hash E8B787A5 + input buffer #82: + timeUs = 1000001903918 + contents = length 228, hash 3FA7A29F + input buffer #83: + timeUs = 1000001927138 + contents = length 235, hash B9B33B0A + input buffer #84: + timeUs = 1000001950358 + contents = length 264, hash 71A4869E + input buffer #85: + timeUs = 1000001973578 + contents = length 257, hash D049B54C + input buffer #86: + timeUs = 1000001996798 + contents = length 227, hash 66757231 + input buffer #87: + timeUs = 1000002020018 + contents = length 227, hash BD374F1B + input buffer #88: + timeUs = 1000002043238 + contents = length 235, hash 999477F6 + input buffer #89: + timeUs = 1000002066458 + contents = length 229, hash FFF98DF0 + input buffer #90: + timeUs = 1000002089678 + contents = length 6, hash 31B22286 + input buffer #91: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 90 + output buffer #0: + timeUs = 1000000044000 + size = 0 + rendered = false + output buffer #1: + timeUs = 1000000067219 + size = 0 + rendered = false + output buffer #2: + timeUs = 1000000090439 + size = 0 + rendered = false + output buffer #3: + timeUs = 1000000113659 + size = 0 + rendered = false + output buffer #4: + timeUs = 1000000136879 + size = 0 + rendered = false + output buffer #5: + timeUs = 1000000160099 + size = 0 + rendered = false + output buffer #6: + timeUs = 1000000183319 + size = 0 + rendered = false + output buffer #7: + timeUs = 1000000206539 + size = 0 + rendered = false + output buffer #8: + timeUs = 1000000229759 + size = 0 + rendered = false + output buffer #9: + timeUs = 1000000252979 + size = 0 + rendered = false + output buffer #10: + timeUs = 1000000276199 + size = 0 + rendered = false + output buffer #11: + timeUs = 1000000299419 + size = 0 + rendered = false + output buffer #12: + timeUs = 1000000322639 + size = 0 + rendered = false + output buffer #13: + timeUs = 1000000345859 + size = 0 + rendered = false + output buffer #14: + timeUs = 1000000369079 + size = 0 + rendered = false + output buffer #15: + timeUs = 1000000392299 + size = 0 + rendered = false + output buffer #16: + timeUs = 1000000415519 + size = 0 + rendered = false + output buffer #17: + timeUs = 1000000438739 + size = 0 + rendered = false + output buffer #18: + timeUs = 1000000461959 + size = 0 + rendered = false + output buffer #19: + timeUs = 1000000485179 + size = 0 + rendered = false + output buffer #20: + timeUs = 1000000508399 + size = 0 + rendered = false + output buffer #21: + timeUs = 1000000531619 + size = 0 + rendered = false + output buffer #22: + timeUs = 1000000554839 + size = 0 + rendered = false + output buffer #23: + timeUs = 1000000578058 + size = 0 + rendered = false + output buffer #24: + timeUs = 1000000601278 + size = 0 + rendered = false + output buffer #25: + timeUs = 1000000624498 + size = 0 + rendered = false + output buffer #26: + timeUs = 1000000647718 + size = 0 + rendered = false + output buffer #27: + timeUs = 1000000670938 + size = 0 + rendered = false + output buffer #28: + timeUs = 1000000694158 + size = 0 + rendered = false + output buffer #29: + timeUs = 1000000717378 + size = 0 + rendered = false + output buffer #30: + timeUs = 1000000740598 + size = 0 + rendered = false + output buffer #31: + timeUs = 1000000763818 + size = 0 + rendered = false + output buffer #32: + timeUs = 1000000787038 + size = 0 + rendered = false + output buffer #33: + timeUs = 1000000810258 + size = 0 + rendered = false + output buffer #34: + timeUs = 1000000833478 + size = 0 + rendered = false + output buffer #35: + timeUs = 1000000856698 + size = 0 + rendered = false + output buffer #36: + timeUs = 1000000879918 + size = 0 + rendered = false + output buffer #37: + timeUs = 1000000903138 + size = 0 + rendered = false + output buffer #38: + timeUs = 1000000926358 + size = 0 + rendered = false + output buffer #39: + timeUs = 1000000949578 + size = 0 + rendered = false + output buffer #40: + timeUs = 1000000972798 + size = 0 + rendered = false + output buffer #41: + timeUs = 1000000996018 + size = 0 + rendered = false + output buffer #42: + timeUs = 1000001019238 + size = 0 + rendered = false + output buffer #43: + timeUs = 1000001042458 + size = 0 + rendered = false + output buffer #44: + timeUs = 1000001065678 + size = 0 + rendered = false + output buffer #45: + timeUs = 1000001068000 + size = 0 + rendered = false + output buffer #46: + timeUs = 1000001091219 + size = 0 + rendered = false + output buffer #47: + timeUs = 1000001114439 + size = 0 + rendered = false + output buffer #48: + timeUs = 1000001137659 + size = 0 + rendered = false + output buffer #49: + timeUs = 1000001160879 + size = 0 + rendered = false + output buffer #50: + timeUs = 1000001184099 + size = 0 + rendered = false + output buffer #51: + timeUs = 1000001207319 + size = 0 + rendered = false + output buffer #52: + timeUs = 1000001230539 + size = 0 + rendered = false + output buffer #53: + timeUs = 1000001253759 + size = 0 + rendered = false + output buffer #54: + timeUs = 1000001276979 + size = 0 + rendered = false + output buffer #55: + timeUs = 1000001300199 + size = 0 + rendered = false + output buffer #56: + timeUs = 1000001323419 + size = 0 + rendered = false + output buffer #57: + timeUs = 1000001346639 + size = 0 + rendered = false + output buffer #58: + timeUs = 1000001369859 + size = 0 + rendered = false + output buffer #59: + timeUs = 1000001393079 + size = 0 + rendered = false + output buffer #60: + timeUs = 1000001416299 + size = 0 + rendered = false + output buffer #61: + timeUs = 1000001439519 + size = 0 + rendered = false + output buffer #62: + timeUs = 1000001462739 + size = 0 + rendered = false + output buffer #63: + timeUs = 1000001485959 + size = 0 + rendered = false + output buffer #64: + timeUs = 1000001509179 + size = 0 + rendered = false + output buffer #65: + timeUs = 1000001532399 + size = 0 + rendered = false + output buffer #66: + timeUs = 1000001555619 + size = 0 + rendered = false + output buffer #67: + timeUs = 1000001578839 + size = 0 + rendered = false + output buffer #68: + timeUs = 1000001602058 + size = 0 + rendered = false + output buffer #69: + timeUs = 1000001625278 + size = 0 + rendered = false + output buffer #70: + timeUs = 1000001648498 + size = 0 + rendered = false + output buffer #71: + timeUs = 1000001671718 + size = 0 + rendered = false + output buffer #72: + timeUs = 1000001694938 + size = 0 + rendered = false + output buffer #73: + timeUs = 1000001718158 + size = 0 + rendered = false + output buffer #74: + timeUs = 1000001741378 + size = 0 + rendered = false + output buffer #75: + timeUs = 1000001764598 + size = 0 + rendered = false + output buffer #76: + timeUs = 1000001787818 + size = 0 + rendered = false + output buffer #77: + timeUs = 1000001811038 + size = 0 + rendered = false + output buffer #78: + timeUs = 1000001834258 + size = 0 + rendered = false + output buffer #79: + timeUs = 1000001857478 + size = 0 + rendered = false + output buffer #80: + timeUs = 1000001880698 + size = 0 + rendered = false + output buffer #81: + timeUs = 1000001903918 + size = 0 + rendered = false + output buffer #82: + timeUs = 1000001927138 + size = 0 + rendered = false + output buffer #83: + timeUs = 1000001950358 + size = 0 + rendered = false + output buffer #84: + timeUs = 1000001973578 + size = 0 + rendered = false + output buffer #85: + timeUs = 1000001996798 + size = 0 + rendered = false + output buffer #86: + timeUs = 1000002020018 + size = 0 + rendered = false + output buffer #87: + timeUs = 1000002043238 + size = 0 + rendered = false + output buffer #88: + timeUs = 1000002066458 + size = 0 + rendered = false + output buffer #89: + timeUs = 1000002089678 + size = 0 + rendered = false +MediaCodecAdapter (media3.audio.aac): + inputBuffers: + count = 46 + input buffer #0: + timeUs = 1000004092000 + contents = length 23, hash 47DE9131 + input buffer #1: + timeUs = 1000004115219 + contents = length 6, hash 31EC5206 + input buffer #2: + timeUs = 1000004138439 + contents = length 148, hash 894A176B + input buffer #3: + timeUs = 1000004161659 + contents = length 189, hash CEF235A1 + input buffer #4: + timeUs = 1000004184879 + contents = length 205, hash BBF5F7B0 + input buffer #5: + timeUs = 1000004208099 + contents = length 210, hash F278B193 + input buffer #6: + timeUs = 1000004231319 + contents = length 210, hash 82DA1589 + input buffer #7: + timeUs = 1000004254539 + contents = length 207, hash 5BE231DF + input buffer #8: + timeUs = 1000004277759 + contents = length 225, hash 18819EE1 + input buffer #9: + timeUs = 1000004300979 + contents = length 215, hash CA7FA67B + input buffer #10: + timeUs = 1000004324199 + contents = length 211, hash 581A1C18 + input buffer #11: + timeUs = 1000004347419 + contents = length 216, hash ADB88187 + input buffer #12: + timeUs = 1000004370639 + contents = length 229, hash 2E8BA4DC + input buffer #13: + timeUs = 1000004393859 + contents = length 232, hash 22F0C510 + input buffer #14: + timeUs = 1000004417079 + contents = length 235, hash 867AD0DC + input buffer #15: + timeUs = 1000004440299 + contents = length 231, hash 84E823A8 + input buffer #16: + timeUs = 1000004463519 + contents = length 226, hash 1BEF3A95 + input buffer #17: + timeUs = 1000004486739 + contents = length 216, hash EAA345AE + input buffer #18: + timeUs = 1000004509959 + contents = length 229, hash 6957411F + input buffer #19: + timeUs = 1000004533179 + contents = length 219, hash 41275022 + input buffer #20: + timeUs = 1000004556399 + contents = length 241, hash 6495DF96 + input buffer #21: + timeUs = 1000004579619 + contents = length 228, hash 63D95906 + input buffer #22: + timeUs = 1000004602839 + contents = length 238, hash 34F676F9 + input buffer #23: + timeUs = 1000004626058 + contents = length 234, hash E5CBC045 + input buffer #24: + timeUs = 1000004649278 + contents = length 231, hash 5FC43661 + input buffer #25: + timeUs = 1000004672498 + contents = length 217, hash 682708ED + input buffer #26: + timeUs = 1000004695718 + contents = length 239, hash D43780FC + input buffer #27: + timeUs = 1000004718938 + contents = length 243, hash C5E17980 + input buffer #28: + timeUs = 1000004742158 + contents = length 231, hash AC5837BA + input buffer #29: + timeUs = 1000004765378 + contents = length 230, hash 169EE895 + input buffer #30: + timeUs = 1000004788598 + contents = length 238, hash C48FF3F1 + input buffer #31: + timeUs = 1000004811818 + contents = length 225, hash 531E4599 + input buffer #32: + timeUs = 1000004835038 + contents = length 232, hash CB3C6B8D + input buffer #33: + timeUs = 1000004858258 + contents = length 243, hash F8C94C7 + input buffer #34: + timeUs = 1000004881478 + contents = length 232, hash A646A7D0 + input buffer #35: + timeUs = 1000004904698 + contents = length 237, hash E8B787A5 + input buffer #36: + timeUs = 1000004927918 + contents = length 228, hash 3FA7A29F + input buffer #37: + timeUs = 1000004951138 + contents = length 235, hash B9B33B0A + input buffer #38: + timeUs = 1000004974358 + contents = length 264, hash 71A4869E + input buffer #39: + timeUs = 1000004997578 + contents = length 257, hash D049B54C + input buffer #40: + timeUs = 1000005020798 + contents = length 227, hash 66757231 + input buffer #41: + timeUs = 1000005044018 + contents = length 227, hash BD374F1B + input buffer #42: + timeUs = 1000005067238 + contents = length 235, hash 999477F6 + input buffer #43: + timeUs = 1000005090458 + contents = length 229, hash FFF98DF0 + input buffer #44: + timeUs = 1000005113678 + contents = length 6, hash 31B22286 + input buffer #45: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 45 + output buffer #0: + timeUs = 1000004092000 + size = 0 + rendered = false + output buffer #1: + timeUs = 1000004115219 + size = 0 + rendered = false + output buffer #2: + timeUs = 1000004138439 + size = 0 + rendered = false + output buffer #3: + timeUs = 1000004161659 + size = 0 + rendered = false + output buffer #4: + timeUs = 1000004184879 + size = 0 + rendered = false + output buffer #5: + timeUs = 1000004208099 + size = 0 + rendered = false + output buffer #6: + timeUs = 1000004231319 + size = 0 + rendered = false + output buffer #7: + timeUs = 1000004254539 + size = 0 + rendered = false + output buffer #8: + timeUs = 1000004277759 + size = 0 + rendered = false + output buffer #9: + timeUs = 1000004300979 + size = 0 + rendered = false + output buffer #10: + timeUs = 1000004324199 + size = 0 + rendered = false + output buffer #11: + timeUs = 1000004347419 + size = 0 + rendered = false + output buffer #12: + timeUs = 1000004370639 + size = 0 + rendered = false + output buffer #13: + timeUs = 1000004393859 + size = 0 + rendered = false + output buffer #14: + timeUs = 1000004417079 + size = 0 + rendered = false + output buffer #15: + timeUs = 1000004440299 + size = 0 + rendered = false + output buffer #16: + timeUs = 1000004463519 + size = 0 + rendered = false + output buffer #17: + timeUs = 1000004486739 + size = 0 + rendered = false + output buffer #18: + timeUs = 1000004509959 + size = 0 + rendered = false + output buffer #19: + timeUs = 1000004533179 + size = 0 + rendered = false + output buffer #20: + timeUs = 1000004556399 + size = 0 + rendered = false + output buffer #21: + timeUs = 1000004579619 + size = 0 + rendered = false + output buffer #22: + timeUs = 1000004602839 + size = 0 + rendered = false + output buffer #23: + timeUs = 1000004626058 + size = 0 + rendered = false + output buffer #24: + timeUs = 1000004649278 + size = 0 + rendered = false + output buffer #25: + timeUs = 1000004672498 + size = 0 + rendered = false + output buffer #26: + timeUs = 1000004695718 + size = 0 + rendered = false + output buffer #27: + timeUs = 1000004718938 + size = 0 + rendered = false + output buffer #28: + timeUs = 1000004742158 + size = 0 + rendered = false + output buffer #29: + timeUs = 1000004765378 + size = 0 + rendered = false + output buffer #30: + timeUs = 1000004788598 + size = 0 + rendered = false + output buffer #31: + timeUs = 1000004811818 + size = 0 + rendered = false + output buffer #32: + timeUs = 1000004835038 + size = 0 + rendered = false + output buffer #33: + timeUs = 1000004858258 + size = 0 + rendered = false + output buffer #34: + timeUs = 1000004881478 + size = 0 + rendered = false + output buffer #35: + timeUs = 1000004904698 + size = 0 + rendered = false + output buffer #36: + timeUs = 1000004927918 + size = 0 + rendered = false + output buffer #37: + timeUs = 1000004951138 + size = 0 + rendered = false + output buffer #38: + timeUs = 1000004974358 + size = 0 + rendered = false + output buffer #39: + timeUs = 1000004997578 + size = 0 + rendered = false + output buffer #40: + timeUs = 1000005020798 + size = 0 + rendered = false + output buffer #41: + timeUs = 1000005044018 + size = 0 + rendered = false + output buffer #42: + timeUs = 1000005067238 + size = 0 + rendered = false + output buffer #43: + timeUs = 1000005090458 + size = 0 + rendered = false + output buffer #44: + timeUs = 1000005113678 + size = 0 + rendered = false +MediaCodecAdapter (media3.video.avc): + inputBuffers: + count = 31 + input buffer #0: + timeUs = 1000000000000 + contents = length 36692, hash D216076E + input buffer #1: + timeUs = 1000000066733 + contents = length 5312, hash D45D3CA0 + input buffer #2: + timeUs = 1000000033366 + contents = length 599, hash 1BE7812D + input buffer #3: + timeUs = 1000000200200 + contents = length 7735, hash 4490F110 + input buffer #4: + timeUs = 1000000133466 + contents = length 987, hash 560B5036 + input buffer #5: + timeUs = 1000000100100 + contents = length 673, hash ED7CD8C7 + input buffer #6: + timeUs = 1000000166833 + contents = length 523, hash 3020DF50 + input buffer #7: + timeUs = 1000000333666 + contents = length 6061, hash 736C72B2 + input buffer #8: + timeUs = 1000000266933 + contents = length 992, hash FE132F23 + input buffer #9: + timeUs = 1000000233566 + contents = length 623, hash 5B2C1816 + input buffer #10: + timeUs = 1000000300300 + contents = length 421, hash 742E69C1 + input buffer #11: + timeUs = 1000000433766 + contents = length 4899, hash F72F86A1 + input buffer #12: + timeUs = 1000000400400 + contents = length 568, hash 519A8E50 + input buffer #13: + timeUs = 1000000367033 + contents = length 620, hash 3990AA39 + input buffer #14: + timeUs = 1000000567233 + contents = length 5450, hash F06EC4AA + input buffer #15: + timeUs = 1000000500500 + contents = length 1051, hash 92DFA63A + input buffer #16: + timeUs = 1000000467133 + contents = length 874, hash 69587FB4 + input buffer #17: + timeUs = 1000000533866 + contents = length 781, hash 36BE495B + input buffer #18: + timeUs = 1000000700700 + contents = length 4725, hash AC0C8CD3 + input buffer #19: + timeUs = 1000000633966 + contents = length 1022, hash 5D8BFF34 + input buffer #20: + timeUs = 1000000600600 + contents = length 790, hash 99413A99 + input buffer #21: + timeUs = 1000000667333 + contents = length 610, hash 5E129290 + input buffer #22: + timeUs = 1000000834166 + contents = length 2751, hash 769974CB + input buffer #23: + timeUs = 1000000767433 + contents = length 745, hash B78A477A + input buffer #24: + timeUs = 1000000734066 + contents = length 621, hash CF741E7A + input buffer #25: + timeUs = 1000000800800 + contents = length 505, hash 1DB4894E + input buffer #26: + timeUs = 1000000967633 + contents = length 1268, hash C15348DC + input buffer #27: + timeUs = 1000000900900 + contents = length 880, hash C2DE85D0 + input buffer #28: + timeUs = 1000000867533 + contents = length 530, hash C98BC6A8 + input buffer #29: + timeUs = 1000000934266 + contents = length 568, hash 4FE5C8EA + input buffer #30: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 30 + output buffer #0: + timeUs = 1000000000000 + size = 36692 + rendered = true + output buffer #1: + timeUs = 1000000066733 + size = 5312 + rendered = true + output buffer #2: + timeUs = 1000000033366 + size = 599 + rendered = true + output buffer #3: + timeUs = 1000000200200 + size = 7735 + rendered = true + output buffer #4: + timeUs = 1000000133466 + size = 987 + rendered = true + output buffer #5: + timeUs = 1000000100100 + size = 673 + rendered = true + output buffer #6: + timeUs = 1000000166833 + size = 523 + rendered = true + output buffer #7: + timeUs = 1000000333666 + size = 6061 + rendered = true + output buffer #8: + timeUs = 1000000266933 + size = 992 + rendered = true + output buffer #9: + timeUs = 1000000233566 + size = 623 + rendered = true + output buffer #10: + timeUs = 1000000300300 + size = 421 + rendered = true + output buffer #11: + timeUs = 1000000433766 + size = 4899 + rendered = true + output buffer #12: + timeUs = 1000000400400 + size = 568 + rendered = true + output buffer #13: + timeUs = 1000000367033 + size = 620 + rendered = true + output buffer #14: + timeUs = 1000000567233 + size = 5450 + rendered = true + output buffer #15: + timeUs = 1000000500500 + size = 1051 + rendered = true + output buffer #16: + timeUs = 1000000467133 + size = 874 + rendered = true + output buffer #17: + timeUs = 1000000533866 + size = 781 + rendered = true + output buffer #18: + timeUs = 1000000700700 + size = 4725 + rendered = true + output buffer #19: + timeUs = 1000000633966 + size = 1022 + rendered = true + output buffer #20: + timeUs = 1000000600600 + size = 790 + rendered = true + output buffer #21: + timeUs = 1000000667333 + size = 610 + rendered = true + output buffer #22: + timeUs = 1000000834166 + size = 2751 + rendered = true + output buffer #23: + timeUs = 1000000767433 + size = 745 + rendered = true + output buffer #24: + timeUs = 1000000734066 + size = 621 + rendered = true + output buffer #25: + timeUs = 1000000800800 + size = 505 + rendered = true + output buffer #26: + timeUs = 1000000967633 + size = 1268 + rendered = true + output buffer #27: + timeUs = 1000000900900 + size = 880 + rendered = true + output buffer #28: + timeUs = 1000000867533 + size = 530 + rendered = true + output buffer #29: + timeUs = 1000000934266 + size = 568 + rendered = true +MediaCodecAdapter (media3.video.avc): + inputBuffers: + count = 31 + input buffer #0: + timeUs = 1000001024000 + contents = length 36692, hash D216076E + input buffer #1: + timeUs = 1000001090733 + contents = length 5312, hash D45D3CA0 + input buffer #2: + timeUs = 1000001057366 + contents = length 599, hash 1BE7812D + input buffer #3: + timeUs = 1000001224200 + contents = length 7735, hash 4490F110 + input buffer #4: + timeUs = 1000001157466 + contents = length 987, hash 560B5036 + input buffer #5: + timeUs = 1000001124100 + contents = length 673, hash ED7CD8C7 + input buffer #6: + timeUs = 1000001190833 + contents = length 523, hash 3020DF50 + input buffer #7: + timeUs = 1000001357666 + contents = length 6061, hash 736C72B2 + input buffer #8: + timeUs = 1000001290933 + contents = length 992, hash FE132F23 + input buffer #9: + timeUs = 1000001257566 + contents = length 623, hash 5B2C1816 + input buffer #10: + timeUs = 1000001324300 + contents = length 421, hash 742E69C1 + input buffer #11: + timeUs = 1000001457766 + contents = length 4899, hash F72F86A1 + input buffer #12: + timeUs = 1000001424400 + contents = length 568, hash 519A8E50 + input buffer #13: + timeUs = 1000001391033 + contents = length 620, hash 3990AA39 + input buffer #14: + timeUs = 1000001591233 + contents = length 5450, hash F06EC4AA + input buffer #15: + timeUs = 1000001524500 + contents = length 1051, hash 92DFA63A + input buffer #16: + timeUs = 1000001491133 + contents = length 874, hash 69587FB4 + input buffer #17: + timeUs = 1000001557866 + contents = length 781, hash 36BE495B + input buffer #18: + timeUs = 1000001724700 + contents = length 4725, hash AC0C8CD3 + input buffer #19: + timeUs = 1000001657966 + contents = length 1022, hash 5D8BFF34 + input buffer #20: + timeUs = 1000001624600 + contents = length 790, hash 99413A99 + input buffer #21: + timeUs = 1000001691333 + contents = length 610, hash 5E129290 + input buffer #22: + timeUs = 1000001858166 + contents = length 2751, hash 769974CB + input buffer #23: + timeUs = 1000001791433 + contents = length 745, hash B78A477A + input buffer #24: + timeUs = 1000001758066 + contents = length 621, hash CF741E7A + input buffer #25: + timeUs = 1000001824800 + contents = length 505, hash 1DB4894E + input buffer #26: + timeUs = 1000001991633 + contents = length 1268, hash C15348DC + input buffer #27: + timeUs = 1000001924900 + contents = length 880, hash C2DE85D0 + input buffer #28: + timeUs = 1000001891533 + contents = length 530, hash C98BC6A8 + input buffer #29: + timeUs = 1000001958266 + contents = length 568, hash 4FE5C8EA + input buffer #30: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 30 + output buffer #0: + timeUs = 1000001024000 + size = 36692 + rendered = true + output buffer #1: + timeUs = 1000001090733 + size = 5312 + rendered = true + output buffer #2: + timeUs = 1000001057366 + size = 599 + rendered = true + output buffer #3: + timeUs = 1000001224200 + size = 7735 + rendered = true + output buffer #4: + timeUs = 1000001157466 + size = 987 + rendered = true + output buffer #5: + timeUs = 1000001124100 + size = 673 + rendered = true + output buffer #6: + timeUs = 1000001190833 + size = 523 + rendered = true + output buffer #7: + timeUs = 1000001357666 + size = 6061 + rendered = true + output buffer #8: + timeUs = 1000001290933 + size = 992 + rendered = true + output buffer #9: + timeUs = 1000001257566 + size = 623 + rendered = true + output buffer #10: + timeUs = 1000001324300 + size = 421 + rendered = true + output buffer #11: + timeUs = 1000001457766 + size = 4899 + rendered = true + output buffer #12: + timeUs = 1000001424400 + size = 568 + rendered = true + output buffer #13: + timeUs = 1000001391033 + size = 620 + rendered = true + output buffer #14: + timeUs = 1000001591233 + size = 5450 + rendered = true + output buffer #15: + timeUs = 1000001524500 + size = 1051 + rendered = true + output buffer #16: + timeUs = 1000001491133 + size = 874 + rendered = true + output buffer #17: + timeUs = 1000001557866 + size = 781 + rendered = true + output buffer #18: + timeUs = 1000001724700 + size = 4725 + rendered = true + output buffer #19: + timeUs = 1000001657966 + size = 1022 + rendered = true + output buffer #20: + timeUs = 1000001624600 + size = 790 + rendered = true + output buffer #21: + timeUs = 1000001691333 + size = 610 + rendered = true + output buffer #22: + timeUs = 1000001858166 + size = 2751 + rendered = true + output buffer #23: + timeUs = 1000001791433 + size = 745 + rendered = true + output buffer #24: + timeUs = 1000001758066 + size = 621 + rendered = true + output buffer #25: + timeUs = 1000001824800 + size = 505 + rendered = true + output buffer #26: + timeUs = 1000001991633 + size = 1268 + rendered = true + output buffer #27: + timeUs = 1000001924900 + size = 880 + rendered = true + output buffer #28: + timeUs = 1000001891533 + size = 530 + rendered = true + output buffer #29: + timeUs = 1000001958266 + size = 568 + rendered = true +MediaCodecAdapter (media3.video.avc): + inputBuffers: + count = 31 + input buffer #0: + timeUs = 1000004048000 + contents = length 36692, hash D216076E + input buffer #1: + timeUs = 1000004114733 + contents = length 5312, hash D45D3CA0 + input buffer #2: + timeUs = 1000004081366 + contents = length 599, hash 1BE7812D + input buffer #3: + timeUs = 1000004248200 + contents = length 7735, hash 4490F110 + input buffer #4: + timeUs = 1000004181466 + contents = length 987, hash 560B5036 + input buffer #5: + timeUs = 1000004148100 + contents = length 673, hash ED7CD8C7 + input buffer #6: + timeUs = 1000004214833 + contents = length 523, hash 3020DF50 + input buffer #7: + timeUs = 1000004381666 + contents = length 6061, hash 736C72B2 + input buffer #8: + timeUs = 1000004314933 + contents = length 992, hash FE132F23 + input buffer #9: + timeUs = 1000004281566 + contents = length 623, hash 5B2C1816 + input buffer #10: + timeUs = 1000004348300 + contents = length 421, hash 742E69C1 + input buffer #11: + timeUs = 1000004481766 + contents = length 4899, hash F72F86A1 + input buffer #12: + timeUs = 1000004448400 + contents = length 568, hash 519A8E50 + input buffer #13: + timeUs = 1000004415033 + contents = length 620, hash 3990AA39 + input buffer #14: + timeUs = 1000004615233 + contents = length 5450, hash F06EC4AA + input buffer #15: + timeUs = 1000004548500 + contents = length 1051, hash 92DFA63A + input buffer #16: + timeUs = 1000004515133 + contents = length 874, hash 69587FB4 + input buffer #17: + timeUs = 1000004581866 + contents = length 781, hash 36BE495B + input buffer #18: + timeUs = 1000004748700 + contents = length 4725, hash AC0C8CD3 + input buffer #19: + timeUs = 1000004681966 + contents = length 1022, hash 5D8BFF34 + input buffer #20: + timeUs = 1000004648600 + contents = length 790, hash 99413A99 + input buffer #21: + timeUs = 1000004715333 + contents = length 610, hash 5E129290 + input buffer #22: + timeUs = 1000004882166 + contents = length 2751, hash 769974CB + input buffer #23: + timeUs = 1000004815433 + contents = length 745, hash B78A477A + input buffer #24: + timeUs = 1000004782066 + contents = length 621, hash CF741E7A + input buffer #25: + timeUs = 1000004848800 + contents = length 505, hash 1DB4894E + input buffer #26: + timeUs = 1000005015633 + contents = length 1268, hash C15348DC + input buffer #27: + timeUs = 1000004948900 + contents = length 880, hash C2DE85D0 + input buffer #28: + timeUs = 1000004915533 + contents = length 530, hash C98BC6A8 + input buffer #29: + timeUs = 1000004982266 + contents = length 568, hash 4FE5C8EA + input buffer #30: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 30 + output buffer #0: + timeUs = 1000004048000 + size = 36692 + rendered = true + output buffer #1: + timeUs = 1000004114733 + size = 5312 + rendered = true + output buffer #2: + timeUs = 1000004081366 + size = 599 + rendered = true + output buffer #3: + timeUs = 1000004248200 + size = 7735 + rendered = true + output buffer #4: + timeUs = 1000004181466 + size = 987 + rendered = true + output buffer #5: + timeUs = 1000004148100 + size = 673 + rendered = true + output buffer #6: + timeUs = 1000004214833 + size = 523 + rendered = true + output buffer #7: + timeUs = 1000004381666 + size = 6061 + rendered = true + output buffer #8: + timeUs = 1000004314933 + size = 992 + rendered = true + output buffer #9: + timeUs = 1000004281566 + size = 623 + rendered = true + output buffer #10: + timeUs = 1000004348300 + size = 421 + rendered = true + output buffer #11: + timeUs = 1000004481766 + size = 4899 + rendered = true + output buffer #12: + timeUs = 1000004448400 + size = 568 + rendered = true + output buffer #13: + timeUs = 1000004415033 + size = 620 + rendered = true + output buffer #14: + timeUs = 1000004615233 + size = 5450 + rendered = true + output buffer #15: + timeUs = 1000004548500 + size = 1051 + rendered = true + output buffer #16: + timeUs = 1000004515133 + size = 874 + rendered = true + output buffer #17: + timeUs = 1000004581866 + size = 781 + rendered = true + output buffer #18: + timeUs = 1000004748700 + size = 4725 + rendered = true + output buffer #19: + timeUs = 1000004681966 + size = 1022 + rendered = true + output buffer #20: + timeUs = 1000004648600 + size = 790 + rendered = true + output buffer #21: + timeUs = 1000004715333 + size = 610 + rendered = true + output buffer #22: + timeUs = 1000004882166 + size = 2751 + rendered = true + output buffer #23: + timeUs = 1000004815433 + size = 745 + rendered = true + output buffer #24: + timeUs = 1000004782066 + size = 621 + rendered = true + output buffer #25: + timeUs = 1000004848800 + size = 505 + rendered = true + output buffer #26: + timeUs = 1000005015633 + size = 1268 + rendered = true + output buffer #27: + timeUs = 1000004948900 + size = 880 + rendered = true + output buffer #28: + timeUs = 1000004915533 + size = 530 + rendered = true + output buffer #29: + timeUs = 1000004982266 + size = 568 + rendered = true +AudioSink: + buffer count = 135 + config: + pcmEncoding = pcm-16 + channelCount = 1 + sampleRate = 44100 + buffer #0: + time = 1000000044000 + data = empty + buffer #1: + time = 1000000067219 + data = empty + buffer #2: + time = 1000000090439 + data = empty + buffer #3: + time = 1000000113659 + data = empty + buffer #4: + time = 1000000136879 + data = empty + buffer #5: + time = 1000000160099 + data = empty + buffer #6: + time = 1000000183319 + data = empty + buffer #7: + time = 1000000206539 + data = empty + buffer #8: + time = 1000000229759 + data = empty + buffer #9: + time = 1000000252979 + data = empty + buffer #10: + time = 1000000276199 + data = empty + buffer #11: + time = 1000000299419 + data = empty + buffer #12: + time = 1000000322639 + data = empty + buffer #13: + time = 1000000345859 + data = empty + buffer #14: + time = 1000000369079 + data = empty + buffer #15: + time = 1000000392299 + data = empty + buffer #16: + time = 1000000415519 + data = empty + buffer #17: + time = 1000000438739 + data = empty + buffer #18: + time = 1000000461959 + data = empty + buffer #19: + time = 1000000485179 + data = empty + buffer #20: + time = 1000000508399 + data = empty + buffer #21: + time = 1000000531619 + data = empty + buffer #22: + time = 1000000554839 + data = empty + buffer #23: + time = 1000000578058 + data = empty + buffer #24: + time = 1000000601278 + data = empty + buffer #25: + time = 1000000624498 + data = empty + buffer #26: + time = 1000000647718 + data = empty + buffer #27: + time = 1000000670938 + data = empty + buffer #28: + time = 1000000694158 + data = empty + buffer #29: + time = 1000000717378 + data = empty + buffer #30: + time = 1000000740598 + data = empty + buffer #31: + time = 1000000763818 + data = empty + buffer #32: + time = 1000000787038 + data = empty + buffer #33: + time = 1000000810258 + data = empty + buffer #34: + time = 1000000833478 + data = empty + buffer #35: + time = 1000000856698 + data = empty + buffer #36: + time = 1000000879918 + data = empty + buffer #37: + time = 1000000903138 + data = empty + buffer #38: + time = 1000000926358 + data = empty + buffer #39: + time = 1000000949578 + data = empty + buffer #40: + time = 1000000972798 + data = empty + buffer #41: + time = 1000000996018 + data = empty + buffer #42: + time = 1000001019238 + data = empty + buffer #43: + time = 1000001042458 + data = empty + buffer #44: + time = 1000001065678 + data = empty + discontinuity: + config: + pcmEncoding = pcm-16 + channelCount = 1 + sampleRate = 44100 + buffer #45: + time = 1000001068000 + data = empty + buffer #46: + time = 1000001091219 + data = empty + buffer #47: + time = 1000001114439 + data = empty + buffer #48: + time = 1000001137659 + data = empty + buffer #49: + time = 1000001160879 + data = empty + buffer #50: + time = 1000001184099 + data = empty + buffer #51: + time = 1000001207319 + data = empty + buffer #52: + time = 1000001230539 + data = empty + buffer #53: + time = 1000001253759 + data = empty + buffer #54: + time = 1000001276979 + data = empty + buffer #55: + time = 1000001300199 + data = empty + buffer #56: + time = 1000001323419 + data = empty + buffer #57: + time = 1000001346639 + data = empty + buffer #58: + time = 1000001369859 + data = empty + buffer #59: + time = 1000001393079 + data = empty + buffer #60: + time = 1000001416299 + data = empty + buffer #61: + time = 1000001439519 + data = empty + buffer #62: + time = 1000001462739 + data = empty + buffer #63: + time = 1000001485959 + data = empty + buffer #64: + time = 1000001509179 + data = empty + buffer #65: + time = 1000001532399 + data = empty + buffer #66: + time = 1000001555619 + data = empty + buffer #67: + time = 1000001578839 + data = empty + buffer #68: + time = 1000001602058 + data = empty + buffer #69: + time = 1000001625278 + data = empty + buffer #70: + time = 1000001648498 + data = empty + buffer #71: + time = 1000001671718 + data = empty + buffer #72: + time = 1000001694938 + data = empty + buffer #73: + time = 1000001718158 + data = empty + buffer #74: + time = 1000001741378 + data = empty + buffer #75: + time = 1000001764598 + data = empty + buffer #76: + time = 1000001787818 + data = empty + buffer #77: + time = 1000001811038 + data = empty + buffer #78: + time = 1000001834258 + data = empty + buffer #79: + time = 1000001857478 + data = empty + buffer #80: + time = 1000001880698 + data = empty + buffer #81: + time = 1000001903918 + data = empty + buffer #82: + time = 1000001927138 + data = empty + buffer #83: + time = 1000001950358 + data = empty + buffer #84: + time = 1000001973578 + data = empty + buffer #85: + time = 1000001996798 + data = empty + buffer #86: + time = 1000002020018 + data = empty + buffer #87: + time = 1000002043238 + data = empty + buffer #88: + time = 1000002066458 + data = empty + buffer #89: + time = 1000002089678 + data = empty + config: + pcmEncoding = pcm-16 + channelCount = 1 + sampleRate = 44100 + buffer #90: + time = 1000004092000 + data = empty + buffer #91: + time = 1000004115219 + data = empty + buffer #92: + time = 1000004138439 + data = empty + buffer #93: + time = 1000004161659 + data = empty + buffer #94: + time = 1000004184879 + data = empty + buffer #95: + time = 1000004208099 + data = empty + buffer #96: + time = 1000004231319 + data = empty + buffer #97: + time = 1000004254539 + data = empty + buffer #98: + time = 1000004277759 + data = empty + buffer #99: + time = 1000004300979 + data = empty + buffer #100: + time = 1000004324199 + data = empty + buffer #101: + time = 1000004347419 + data = empty + buffer #102: + time = 1000004370639 + data = empty + buffer #103: + time = 1000004393859 + data = empty + buffer #104: + time = 1000004417079 + data = empty + buffer #105: + time = 1000004440299 + data = empty + buffer #106: + time = 1000004463519 + data = empty + buffer #107: + time = 1000004486739 + data = empty + buffer #108: + time = 1000004509959 + data = empty + buffer #109: + time = 1000004533179 + data = empty + buffer #110: + time = 1000004556399 + data = empty + buffer #111: + time = 1000004579619 + data = empty + buffer #112: + time = 1000004602839 + data = empty + buffer #113: + time = 1000004626058 + data = empty + buffer #114: + time = 1000004649278 + data = empty + buffer #115: + time = 1000004672498 + data = empty + buffer #116: + time = 1000004695718 + data = empty + buffer #117: + time = 1000004718938 + data = empty + buffer #118: + time = 1000004742158 + data = empty + buffer #119: + time = 1000004765378 + data = empty + buffer #120: + time = 1000004788598 + data = empty + buffer #121: + time = 1000004811818 + data = empty + buffer #122: + time = 1000004835038 + data = empty + buffer #123: + time = 1000004858258 + data = empty + buffer #124: + time = 1000004881478 + data = empty + buffer #125: + time = 1000004904698 + data = empty + buffer #126: + time = 1000004927918 + data = empty + buffer #127: + time = 1000004951138 + data = empty + buffer #128: + time = 1000004974358 + data = empty + buffer #129: + time = 1000004997578 + data = empty + buffer #130: + time = 1000005020798 + data = empty + buffer #131: + time = 1000005044018 + data = empty + buffer #132: + time = 1000005067238 + data = empty + buffer #133: + time = 1000005090458 + data = empty + buffer #134: + time = 1000005113678 + data = empty +ImageOutput: + rendered image count = 2 + image output #1: + presentationTimeUs = 0 + bitmap hash = -1041353260 + image output #2: + presentationTimeUs = 0 + bitmap hash = -1041353260 diff --git a/libraries/test_data/src/test/assets/playbackdumps/prewarmingRenderer/videoVideoImagePlaylist-seekToStart-withSecondaryRenderers.dump b/libraries/test_data/src/test/assets/playbackdumps/prewarmingRenderer/videoVideoImagePlaylist-seekToStart-withSecondaryRenderers.dump new file mode 100644 index 00000000000..1b22823a2e2 --- /dev/null +++ b/libraries/test_data/src/test/assets/playbackdumps/prewarmingRenderer/videoVideoImagePlaylist-seekToStart-withSecondaryRenderers.dump @@ -0,0 +1,2730 @@ +MediaCodecAdapter (media3.audio.aac): + inputBuffers: + count = 92 + input buffer #0: + timeUs = 1000000044000 + contents = length 23, hash 47DE9131 + input buffer #1: + timeUs = 1000000067219 + contents = length 6, hash 31EC5206 + input buffer #2: + timeUs = 1000000090439 + contents = length 148, hash 894A176B + input buffer #3: + timeUs = 1000000113659 + contents = length 189, hash CEF235A1 + input buffer #4: + timeUs = 1000000136879 + contents = length 205, hash BBF5F7B0 + input buffer #5: + timeUs = 1000000160099 + contents = length 210, hash F278B193 + input buffer #6: + timeUs = 1000000183319 + contents = length 210, hash 82DA1589 + input buffer #7: + timeUs = 1000000206539 + contents = length 207, hash 5BE231DF + input buffer #8: + timeUs = 1000000229759 + contents = length 225, hash 18819EE1 + input buffer #9: + timeUs = 1000000252979 + contents = length 215, hash CA7FA67B + input buffer #10: + timeUs = 1000000276199 + contents = length 211, hash 581A1C18 + input buffer #11: + timeUs = 1000000299419 + contents = length 216, hash ADB88187 + input buffer #12: + timeUs = 1000000322639 + contents = length 229, hash 2E8BA4DC + input buffer #13: + timeUs = 1000000345859 + contents = length 232, hash 22F0C510 + input buffer #14: + timeUs = 1000000369079 + contents = length 235, hash 867AD0DC + input buffer #15: + timeUs = 1000000392299 + contents = length 231, hash 84E823A8 + input buffer #16: + timeUs = 1000000415519 + contents = length 226, hash 1BEF3A95 + input buffer #17: + timeUs = 1000000438739 + contents = length 216, hash EAA345AE + input buffer #18: + timeUs = 1000000461959 + contents = length 229, hash 6957411F + input buffer #19: + timeUs = 1000000485179 + contents = length 219, hash 41275022 + input buffer #20: + timeUs = 1000000508399 + contents = length 241, hash 6495DF96 + input buffer #21: + timeUs = 1000000531619 + contents = length 228, hash 63D95906 + input buffer #22: + timeUs = 1000000554839 + contents = length 238, hash 34F676F9 + input buffer #23: + timeUs = 1000000578058 + contents = length 234, hash E5CBC045 + input buffer #24: + timeUs = 1000000601278 + contents = length 231, hash 5FC43661 + input buffer #25: + timeUs = 1000000624498 + contents = length 217, hash 682708ED + input buffer #26: + timeUs = 1000000647718 + contents = length 239, hash D43780FC + input buffer #27: + timeUs = 1000000670938 + contents = length 243, hash C5E17980 + input buffer #28: + timeUs = 1000000694158 + contents = length 231, hash AC5837BA + input buffer #29: + timeUs = 1000000717378 + contents = length 230, hash 169EE895 + input buffer #30: + timeUs = 1000000740598 + contents = length 238, hash C48FF3F1 + input buffer #31: + timeUs = 1000000763818 + contents = length 225, hash 531E4599 + input buffer #32: + timeUs = 1000000787038 + contents = length 232, hash CB3C6B8D + input buffer #33: + timeUs = 1000000810258 + contents = length 243, hash F8C94C7 + input buffer #34: + timeUs = 1000000833478 + contents = length 232, hash A646A7D0 + input buffer #35: + timeUs = 1000000856698 + contents = length 237, hash E8B787A5 + input buffer #36: + timeUs = 1000000879918 + contents = length 228, hash 3FA7A29F + input buffer #37: + timeUs = 1000000903138 + contents = length 235, hash B9B33B0A + input buffer #38: + timeUs = 1000000926358 + contents = length 264, hash 71A4869E + input buffer #39: + timeUs = 1000000949578 + contents = length 257, hash D049B54C + input buffer #40: + timeUs = 1000000972798 + contents = length 227, hash 66757231 + input buffer #41: + timeUs = 1000000996018 + contents = length 227, hash BD374F1B + input buffer #42: + timeUs = 1000001019238 + contents = length 235, hash 999477F6 + input buffer #43: + timeUs = 1000001042458 + contents = length 229, hash FFF98DF0 + input buffer #44: + timeUs = 1000001065678 + contents = length 6, hash 31B22286 + input buffer #45: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + input buffer #46: + timeUs = 1000001068000 + contents = length 23, hash 47DE9131 + input buffer #47: + timeUs = 1000001091219 + contents = length 6, hash 31EC5206 + input buffer #48: + timeUs = 1000001114439 + contents = length 148, hash 894A176B + input buffer #49: + timeUs = 1000001137659 + contents = length 189, hash CEF235A1 + input buffer #50: + timeUs = 1000001160879 + contents = length 205, hash BBF5F7B0 + input buffer #51: + timeUs = 1000001184099 + contents = length 210, hash F278B193 + input buffer #52: + timeUs = 1000001207319 + contents = length 210, hash 82DA1589 + input buffer #53: + timeUs = 1000001230539 + contents = length 207, hash 5BE231DF + input buffer #54: + timeUs = 1000001253759 + contents = length 225, hash 18819EE1 + input buffer #55: + timeUs = 1000001276979 + contents = length 215, hash CA7FA67B + input buffer #56: + timeUs = 1000001300199 + contents = length 211, hash 581A1C18 + input buffer #57: + timeUs = 1000001323419 + contents = length 216, hash ADB88187 + input buffer #58: + timeUs = 1000001346639 + contents = length 229, hash 2E8BA4DC + input buffer #59: + timeUs = 1000001369859 + contents = length 232, hash 22F0C510 + input buffer #60: + timeUs = 1000001393079 + contents = length 235, hash 867AD0DC + input buffer #61: + timeUs = 1000001416299 + contents = length 231, hash 84E823A8 + input buffer #62: + timeUs = 1000001439519 + contents = length 226, hash 1BEF3A95 + input buffer #63: + timeUs = 1000001462739 + contents = length 216, hash EAA345AE + input buffer #64: + timeUs = 1000001485959 + contents = length 229, hash 6957411F + input buffer #65: + timeUs = 1000001509179 + contents = length 219, hash 41275022 + input buffer #66: + timeUs = 1000001532399 + contents = length 241, hash 6495DF96 + input buffer #67: + timeUs = 1000001555619 + contents = length 228, hash 63D95906 + input buffer #68: + timeUs = 1000001578839 + contents = length 238, hash 34F676F9 + input buffer #69: + timeUs = 1000001602058 + contents = length 234, hash E5CBC045 + input buffer #70: + timeUs = 1000001625278 + contents = length 231, hash 5FC43661 + input buffer #71: + timeUs = 1000001648498 + contents = length 217, hash 682708ED + input buffer #72: + timeUs = 1000001671718 + contents = length 239, hash D43780FC + input buffer #73: + timeUs = 1000001694938 + contents = length 243, hash C5E17980 + input buffer #74: + timeUs = 1000001718158 + contents = length 231, hash AC5837BA + input buffer #75: + timeUs = 1000001741378 + contents = length 230, hash 169EE895 + input buffer #76: + timeUs = 1000001764598 + contents = length 238, hash C48FF3F1 + input buffer #77: + timeUs = 1000001787818 + contents = length 225, hash 531E4599 + input buffer #78: + timeUs = 1000001811038 + contents = length 232, hash CB3C6B8D + input buffer #79: + timeUs = 1000001834258 + contents = length 243, hash F8C94C7 + input buffer #80: + timeUs = 1000001857478 + contents = length 232, hash A646A7D0 + input buffer #81: + timeUs = 1000001880698 + contents = length 237, hash E8B787A5 + input buffer #82: + timeUs = 1000001903918 + contents = length 228, hash 3FA7A29F + input buffer #83: + timeUs = 1000001927138 + contents = length 235, hash B9B33B0A + input buffer #84: + timeUs = 1000001950358 + contents = length 264, hash 71A4869E + input buffer #85: + timeUs = 1000001973578 + contents = length 257, hash D049B54C + input buffer #86: + timeUs = 1000001996798 + contents = length 227, hash 66757231 + input buffer #87: + timeUs = 1000002020018 + contents = length 227, hash BD374F1B + input buffer #88: + timeUs = 1000002043238 + contents = length 235, hash 999477F6 + input buffer #89: + timeUs = 1000002066458 + contents = length 229, hash FFF98DF0 + input buffer #90: + timeUs = 1000002089678 + contents = length 6, hash 31B22286 + input buffer #91: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 90 + output buffer #0: + timeUs = 1000000044000 + size = 0 + rendered = false + output buffer #1: + timeUs = 1000000067219 + size = 0 + rendered = false + output buffer #2: + timeUs = 1000000090439 + size = 0 + rendered = false + output buffer #3: + timeUs = 1000000113659 + size = 0 + rendered = false + output buffer #4: + timeUs = 1000000136879 + size = 0 + rendered = false + output buffer #5: + timeUs = 1000000160099 + size = 0 + rendered = false + output buffer #6: + timeUs = 1000000183319 + size = 0 + rendered = false + output buffer #7: + timeUs = 1000000206539 + size = 0 + rendered = false + output buffer #8: + timeUs = 1000000229759 + size = 0 + rendered = false + output buffer #9: + timeUs = 1000000252979 + size = 0 + rendered = false + output buffer #10: + timeUs = 1000000276199 + size = 0 + rendered = false + output buffer #11: + timeUs = 1000000299419 + size = 0 + rendered = false + output buffer #12: + timeUs = 1000000322639 + size = 0 + rendered = false + output buffer #13: + timeUs = 1000000345859 + size = 0 + rendered = false + output buffer #14: + timeUs = 1000000369079 + size = 0 + rendered = false + output buffer #15: + timeUs = 1000000392299 + size = 0 + rendered = false + output buffer #16: + timeUs = 1000000415519 + size = 0 + rendered = false + output buffer #17: + timeUs = 1000000438739 + size = 0 + rendered = false + output buffer #18: + timeUs = 1000000461959 + size = 0 + rendered = false + output buffer #19: + timeUs = 1000000485179 + size = 0 + rendered = false + output buffer #20: + timeUs = 1000000508399 + size = 0 + rendered = false + output buffer #21: + timeUs = 1000000531619 + size = 0 + rendered = false + output buffer #22: + timeUs = 1000000554839 + size = 0 + rendered = false + output buffer #23: + timeUs = 1000000578058 + size = 0 + rendered = false + output buffer #24: + timeUs = 1000000601278 + size = 0 + rendered = false + output buffer #25: + timeUs = 1000000624498 + size = 0 + rendered = false + output buffer #26: + timeUs = 1000000647718 + size = 0 + rendered = false + output buffer #27: + timeUs = 1000000670938 + size = 0 + rendered = false + output buffer #28: + timeUs = 1000000694158 + size = 0 + rendered = false + output buffer #29: + timeUs = 1000000717378 + size = 0 + rendered = false + output buffer #30: + timeUs = 1000000740598 + size = 0 + rendered = false + output buffer #31: + timeUs = 1000000763818 + size = 0 + rendered = false + output buffer #32: + timeUs = 1000000787038 + size = 0 + rendered = false + output buffer #33: + timeUs = 1000000810258 + size = 0 + rendered = false + output buffer #34: + timeUs = 1000000833478 + size = 0 + rendered = false + output buffer #35: + timeUs = 1000000856698 + size = 0 + rendered = false + output buffer #36: + timeUs = 1000000879918 + size = 0 + rendered = false + output buffer #37: + timeUs = 1000000903138 + size = 0 + rendered = false + output buffer #38: + timeUs = 1000000926358 + size = 0 + rendered = false + output buffer #39: + timeUs = 1000000949578 + size = 0 + rendered = false + output buffer #40: + timeUs = 1000000972798 + size = 0 + rendered = false + output buffer #41: + timeUs = 1000000996018 + size = 0 + rendered = false + output buffer #42: + timeUs = 1000001019238 + size = 0 + rendered = false + output buffer #43: + timeUs = 1000001042458 + size = 0 + rendered = false + output buffer #44: + timeUs = 1000001065678 + size = 0 + rendered = false + output buffer #45: + timeUs = 1000001068000 + size = 0 + rendered = false + output buffer #46: + timeUs = 1000001091219 + size = 0 + rendered = false + output buffer #47: + timeUs = 1000001114439 + size = 0 + rendered = false + output buffer #48: + timeUs = 1000001137659 + size = 0 + rendered = false + output buffer #49: + timeUs = 1000001160879 + size = 0 + rendered = false + output buffer #50: + timeUs = 1000001184099 + size = 0 + rendered = false + output buffer #51: + timeUs = 1000001207319 + size = 0 + rendered = false + output buffer #52: + timeUs = 1000001230539 + size = 0 + rendered = false + output buffer #53: + timeUs = 1000001253759 + size = 0 + rendered = false + output buffer #54: + timeUs = 1000001276979 + size = 0 + rendered = false + output buffer #55: + timeUs = 1000001300199 + size = 0 + rendered = false + output buffer #56: + timeUs = 1000001323419 + size = 0 + rendered = false + output buffer #57: + timeUs = 1000001346639 + size = 0 + rendered = false + output buffer #58: + timeUs = 1000001369859 + size = 0 + rendered = false + output buffer #59: + timeUs = 1000001393079 + size = 0 + rendered = false + output buffer #60: + timeUs = 1000001416299 + size = 0 + rendered = false + output buffer #61: + timeUs = 1000001439519 + size = 0 + rendered = false + output buffer #62: + timeUs = 1000001462739 + size = 0 + rendered = false + output buffer #63: + timeUs = 1000001485959 + size = 0 + rendered = false + output buffer #64: + timeUs = 1000001509179 + size = 0 + rendered = false + output buffer #65: + timeUs = 1000001532399 + size = 0 + rendered = false + output buffer #66: + timeUs = 1000001555619 + size = 0 + rendered = false + output buffer #67: + timeUs = 1000001578839 + size = 0 + rendered = false + output buffer #68: + timeUs = 1000001602058 + size = 0 + rendered = false + output buffer #69: + timeUs = 1000001625278 + size = 0 + rendered = false + output buffer #70: + timeUs = 1000001648498 + size = 0 + rendered = false + output buffer #71: + timeUs = 1000001671718 + size = 0 + rendered = false + output buffer #72: + timeUs = 1000001694938 + size = 0 + rendered = false + output buffer #73: + timeUs = 1000001718158 + size = 0 + rendered = false + output buffer #74: + timeUs = 1000001741378 + size = 0 + rendered = false + output buffer #75: + timeUs = 1000001764598 + size = 0 + rendered = false + output buffer #76: + timeUs = 1000001787818 + size = 0 + rendered = false + output buffer #77: + timeUs = 1000001811038 + size = 0 + rendered = false + output buffer #78: + timeUs = 1000001834258 + size = 0 + rendered = false + output buffer #79: + timeUs = 1000001857478 + size = 0 + rendered = false + output buffer #80: + timeUs = 1000001880698 + size = 0 + rendered = false + output buffer #81: + timeUs = 1000001903918 + size = 0 + rendered = false + output buffer #82: + timeUs = 1000001927138 + size = 0 + rendered = false + output buffer #83: + timeUs = 1000001950358 + size = 0 + rendered = false + output buffer #84: + timeUs = 1000001973578 + size = 0 + rendered = false + output buffer #85: + timeUs = 1000001996798 + size = 0 + rendered = false + output buffer #86: + timeUs = 1000002020018 + size = 0 + rendered = false + output buffer #87: + timeUs = 1000002043238 + size = 0 + rendered = false + output buffer #88: + timeUs = 1000002066458 + size = 0 + rendered = false + output buffer #89: + timeUs = 1000002089678 + size = 0 + rendered = false +MediaCodecAdapter (media3.audio.aac): + inputBuffers: + count = 92 + input buffer #0: + timeUs = 1000000044000 + contents = length 23, hash 47DE9131 + input buffer #1: + timeUs = 1000000067219 + contents = length 6, hash 31EC5206 + input buffer #2: + timeUs = 1000000090439 + contents = length 148, hash 894A176B + input buffer #3: + timeUs = 1000000113659 + contents = length 189, hash CEF235A1 + input buffer #4: + timeUs = 1000000136879 + contents = length 205, hash BBF5F7B0 + input buffer #5: + timeUs = 1000000160099 + contents = length 210, hash F278B193 + input buffer #6: + timeUs = 1000000183319 + contents = length 210, hash 82DA1589 + input buffer #7: + timeUs = 1000000206539 + contents = length 207, hash 5BE231DF + input buffer #8: + timeUs = 1000000229759 + contents = length 225, hash 18819EE1 + input buffer #9: + timeUs = 1000000252979 + contents = length 215, hash CA7FA67B + input buffer #10: + timeUs = 1000000276199 + contents = length 211, hash 581A1C18 + input buffer #11: + timeUs = 1000000299419 + contents = length 216, hash ADB88187 + input buffer #12: + timeUs = 1000000322639 + contents = length 229, hash 2E8BA4DC + input buffer #13: + timeUs = 1000000345859 + contents = length 232, hash 22F0C510 + input buffer #14: + timeUs = 1000000369079 + contents = length 235, hash 867AD0DC + input buffer #15: + timeUs = 1000000392299 + contents = length 231, hash 84E823A8 + input buffer #16: + timeUs = 1000000415519 + contents = length 226, hash 1BEF3A95 + input buffer #17: + timeUs = 1000000438739 + contents = length 216, hash EAA345AE + input buffer #18: + timeUs = 1000000461959 + contents = length 229, hash 6957411F + input buffer #19: + timeUs = 1000000485179 + contents = length 219, hash 41275022 + input buffer #20: + timeUs = 1000000508399 + contents = length 241, hash 6495DF96 + input buffer #21: + timeUs = 1000000531619 + contents = length 228, hash 63D95906 + input buffer #22: + timeUs = 1000000554839 + contents = length 238, hash 34F676F9 + input buffer #23: + timeUs = 1000000578058 + contents = length 234, hash E5CBC045 + input buffer #24: + timeUs = 1000000601278 + contents = length 231, hash 5FC43661 + input buffer #25: + timeUs = 1000000624498 + contents = length 217, hash 682708ED + input buffer #26: + timeUs = 1000000647718 + contents = length 239, hash D43780FC + input buffer #27: + timeUs = 1000000670938 + contents = length 243, hash C5E17980 + input buffer #28: + timeUs = 1000000694158 + contents = length 231, hash AC5837BA + input buffer #29: + timeUs = 1000000717378 + contents = length 230, hash 169EE895 + input buffer #30: + timeUs = 1000000740598 + contents = length 238, hash C48FF3F1 + input buffer #31: + timeUs = 1000000763818 + contents = length 225, hash 531E4599 + input buffer #32: + timeUs = 1000000787038 + contents = length 232, hash CB3C6B8D + input buffer #33: + timeUs = 1000000810258 + contents = length 243, hash F8C94C7 + input buffer #34: + timeUs = 1000000833478 + contents = length 232, hash A646A7D0 + input buffer #35: + timeUs = 1000000856698 + contents = length 237, hash E8B787A5 + input buffer #36: + timeUs = 1000000879918 + contents = length 228, hash 3FA7A29F + input buffer #37: + timeUs = 1000000903138 + contents = length 235, hash B9B33B0A + input buffer #38: + timeUs = 1000000926358 + contents = length 264, hash 71A4869E + input buffer #39: + timeUs = 1000000949578 + contents = length 257, hash D049B54C + input buffer #40: + timeUs = 1000000972798 + contents = length 227, hash 66757231 + input buffer #41: + timeUs = 1000000996018 + contents = length 227, hash BD374F1B + input buffer #42: + timeUs = 1000001019238 + contents = length 235, hash 999477F6 + input buffer #43: + timeUs = 1000001042458 + contents = length 229, hash FFF98DF0 + input buffer #44: + timeUs = 1000001065678 + contents = length 6, hash 31B22286 + input buffer #45: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + input buffer #46: + timeUs = 1000001068000 + contents = length 23, hash 47DE9131 + input buffer #47: + timeUs = 1000001091219 + contents = length 6, hash 31EC5206 + input buffer #48: + timeUs = 1000001114439 + contents = length 148, hash 894A176B + input buffer #49: + timeUs = 1000001137659 + contents = length 189, hash CEF235A1 + input buffer #50: + timeUs = 1000001160879 + contents = length 205, hash BBF5F7B0 + input buffer #51: + timeUs = 1000001184099 + contents = length 210, hash F278B193 + input buffer #52: + timeUs = 1000001207319 + contents = length 210, hash 82DA1589 + input buffer #53: + timeUs = 1000001230539 + contents = length 207, hash 5BE231DF + input buffer #54: + timeUs = 1000001253759 + contents = length 225, hash 18819EE1 + input buffer #55: + timeUs = 1000001276979 + contents = length 215, hash CA7FA67B + input buffer #56: + timeUs = 1000001300199 + contents = length 211, hash 581A1C18 + input buffer #57: + timeUs = 1000001323419 + contents = length 216, hash ADB88187 + input buffer #58: + timeUs = 1000001346639 + contents = length 229, hash 2E8BA4DC + input buffer #59: + timeUs = 1000001369859 + contents = length 232, hash 22F0C510 + input buffer #60: + timeUs = 1000001393079 + contents = length 235, hash 867AD0DC + input buffer #61: + timeUs = 1000001416299 + contents = length 231, hash 84E823A8 + input buffer #62: + timeUs = 1000001439519 + contents = length 226, hash 1BEF3A95 + input buffer #63: + timeUs = 1000001462739 + contents = length 216, hash EAA345AE + input buffer #64: + timeUs = 1000001485959 + contents = length 229, hash 6957411F + input buffer #65: + timeUs = 1000001509179 + contents = length 219, hash 41275022 + input buffer #66: + timeUs = 1000001532399 + contents = length 241, hash 6495DF96 + input buffer #67: + timeUs = 1000001555619 + contents = length 228, hash 63D95906 + input buffer #68: + timeUs = 1000001578839 + contents = length 238, hash 34F676F9 + input buffer #69: + timeUs = 1000001602058 + contents = length 234, hash E5CBC045 + input buffer #70: + timeUs = 1000001625278 + contents = length 231, hash 5FC43661 + input buffer #71: + timeUs = 1000001648498 + contents = length 217, hash 682708ED + input buffer #72: + timeUs = 1000001671718 + contents = length 239, hash D43780FC + input buffer #73: + timeUs = 1000001694938 + contents = length 243, hash C5E17980 + input buffer #74: + timeUs = 1000001718158 + contents = length 231, hash AC5837BA + input buffer #75: + timeUs = 1000001741378 + contents = length 230, hash 169EE895 + input buffer #76: + timeUs = 1000001764598 + contents = length 238, hash C48FF3F1 + input buffer #77: + timeUs = 1000001787818 + contents = length 225, hash 531E4599 + input buffer #78: + timeUs = 1000001811038 + contents = length 232, hash CB3C6B8D + input buffer #79: + timeUs = 1000001834258 + contents = length 243, hash F8C94C7 + input buffer #80: + timeUs = 1000001857478 + contents = length 232, hash A646A7D0 + input buffer #81: + timeUs = 1000001880698 + contents = length 237, hash E8B787A5 + input buffer #82: + timeUs = 1000001903918 + contents = length 228, hash 3FA7A29F + input buffer #83: + timeUs = 1000001927138 + contents = length 235, hash B9B33B0A + input buffer #84: + timeUs = 1000001950358 + contents = length 264, hash 71A4869E + input buffer #85: + timeUs = 1000001973578 + contents = length 257, hash D049B54C + input buffer #86: + timeUs = 1000001996798 + contents = length 227, hash 66757231 + input buffer #87: + timeUs = 1000002020018 + contents = length 227, hash BD374F1B + input buffer #88: + timeUs = 1000002043238 + contents = length 235, hash 999477F6 + input buffer #89: + timeUs = 1000002066458 + contents = length 229, hash FFF98DF0 + input buffer #90: + timeUs = 1000002089678 + contents = length 6, hash 31B22286 + input buffer #91: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 90 + output buffer #0: + timeUs = 1000000044000 + size = 0 + rendered = false + output buffer #1: + timeUs = 1000000067219 + size = 0 + rendered = false + output buffer #2: + timeUs = 1000000090439 + size = 0 + rendered = false + output buffer #3: + timeUs = 1000000113659 + size = 0 + rendered = false + output buffer #4: + timeUs = 1000000136879 + size = 0 + rendered = false + output buffer #5: + timeUs = 1000000160099 + size = 0 + rendered = false + output buffer #6: + timeUs = 1000000183319 + size = 0 + rendered = false + output buffer #7: + timeUs = 1000000206539 + size = 0 + rendered = false + output buffer #8: + timeUs = 1000000229759 + size = 0 + rendered = false + output buffer #9: + timeUs = 1000000252979 + size = 0 + rendered = false + output buffer #10: + timeUs = 1000000276199 + size = 0 + rendered = false + output buffer #11: + timeUs = 1000000299419 + size = 0 + rendered = false + output buffer #12: + timeUs = 1000000322639 + size = 0 + rendered = false + output buffer #13: + timeUs = 1000000345859 + size = 0 + rendered = false + output buffer #14: + timeUs = 1000000369079 + size = 0 + rendered = false + output buffer #15: + timeUs = 1000000392299 + size = 0 + rendered = false + output buffer #16: + timeUs = 1000000415519 + size = 0 + rendered = false + output buffer #17: + timeUs = 1000000438739 + size = 0 + rendered = false + output buffer #18: + timeUs = 1000000461959 + size = 0 + rendered = false + output buffer #19: + timeUs = 1000000485179 + size = 0 + rendered = false + output buffer #20: + timeUs = 1000000508399 + size = 0 + rendered = false + output buffer #21: + timeUs = 1000000531619 + size = 0 + rendered = false + output buffer #22: + timeUs = 1000000554839 + size = 0 + rendered = false + output buffer #23: + timeUs = 1000000578058 + size = 0 + rendered = false + output buffer #24: + timeUs = 1000000601278 + size = 0 + rendered = false + output buffer #25: + timeUs = 1000000624498 + size = 0 + rendered = false + output buffer #26: + timeUs = 1000000647718 + size = 0 + rendered = false + output buffer #27: + timeUs = 1000000670938 + size = 0 + rendered = false + output buffer #28: + timeUs = 1000000694158 + size = 0 + rendered = false + output buffer #29: + timeUs = 1000000717378 + size = 0 + rendered = false + output buffer #30: + timeUs = 1000000740598 + size = 0 + rendered = false + output buffer #31: + timeUs = 1000000763818 + size = 0 + rendered = false + output buffer #32: + timeUs = 1000000787038 + size = 0 + rendered = false + output buffer #33: + timeUs = 1000000810258 + size = 0 + rendered = false + output buffer #34: + timeUs = 1000000833478 + size = 0 + rendered = false + output buffer #35: + timeUs = 1000000856698 + size = 0 + rendered = false + output buffer #36: + timeUs = 1000000879918 + size = 0 + rendered = false + output buffer #37: + timeUs = 1000000903138 + size = 0 + rendered = false + output buffer #38: + timeUs = 1000000926358 + size = 0 + rendered = false + output buffer #39: + timeUs = 1000000949578 + size = 0 + rendered = false + output buffer #40: + timeUs = 1000000972798 + size = 0 + rendered = false + output buffer #41: + timeUs = 1000000996018 + size = 0 + rendered = false + output buffer #42: + timeUs = 1000001019238 + size = 0 + rendered = false + output buffer #43: + timeUs = 1000001042458 + size = 0 + rendered = false + output buffer #44: + timeUs = 1000001065678 + size = 0 + rendered = false + output buffer #45: + timeUs = 1000001068000 + size = 0 + rendered = false + output buffer #46: + timeUs = 1000001091219 + size = 0 + rendered = false + output buffer #47: + timeUs = 1000001114439 + size = 0 + rendered = false + output buffer #48: + timeUs = 1000001137659 + size = 0 + rendered = false + output buffer #49: + timeUs = 1000001160879 + size = 0 + rendered = false + output buffer #50: + timeUs = 1000001184099 + size = 0 + rendered = false + output buffer #51: + timeUs = 1000001207319 + size = 0 + rendered = false + output buffer #52: + timeUs = 1000001230539 + size = 0 + rendered = false + output buffer #53: + timeUs = 1000001253759 + size = 0 + rendered = false + output buffer #54: + timeUs = 1000001276979 + size = 0 + rendered = false + output buffer #55: + timeUs = 1000001300199 + size = 0 + rendered = false + output buffer #56: + timeUs = 1000001323419 + size = 0 + rendered = false + output buffer #57: + timeUs = 1000001346639 + size = 0 + rendered = false + output buffer #58: + timeUs = 1000001369859 + size = 0 + rendered = false + output buffer #59: + timeUs = 1000001393079 + size = 0 + rendered = false + output buffer #60: + timeUs = 1000001416299 + size = 0 + rendered = false + output buffer #61: + timeUs = 1000001439519 + size = 0 + rendered = false + output buffer #62: + timeUs = 1000001462739 + size = 0 + rendered = false + output buffer #63: + timeUs = 1000001485959 + size = 0 + rendered = false + output buffer #64: + timeUs = 1000001509179 + size = 0 + rendered = false + output buffer #65: + timeUs = 1000001532399 + size = 0 + rendered = false + output buffer #66: + timeUs = 1000001555619 + size = 0 + rendered = false + output buffer #67: + timeUs = 1000001578839 + size = 0 + rendered = false + output buffer #68: + timeUs = 1000001602058 + size = 0 + rendered = false + output buffer #69: + timeUs = 1000001625278 + size = 0 + rendered = false + output buffer #70: + timeUs = 1000001648498 + size = 0 + rendered = false + output buffer #71: + timeUs = 1000001671718 + size = 0 + rendered = false + output buffer #72: + timeUs = 1000001694938 + size = 0 + rendered = false + output buffer #73: + timeUs = 1000001718158 + size = 0 + rendered = false + output buffer #74: + timeUs = 1000001741378 + size = 0 + rendered = false + output buffer #75: + timeUs = 1000001764598 + size = 0 + rendered = false + output buffer #76: + timeUs = 1000001787818 + size = 0 + rendered = false + output buffer #77: + timeUs = 1000001811038 + size = 0 + rendered = false + output buffer #78: + timeUs = 1000001834258 + size = 0 + rendered = false + output buffer #79: + timeUs = 1000001857478 + size = 0 + rendered = false + output buffer #80: + timeUs = 1000001880698 + size = 0 + rendered = false + output buffer #81: + timeUs = 1000001903918 + size = 0 + rendered = false + output buffer #82: + timeUs = 1000001927138 + size = 0 + rendered = false + output buffer #83: + timeUs = 1000001950358 + size = 0 + rendered = false + output buffer #84: + timeUs = 1000001973578 + size = 0 + rendered = false + output buffer #85: + timeUs = 1000001996798 + size = 0 + rendered = false + output buffer #86: + timeUs = 1000002020018 + size = 0 + rendered = false + output buffer #87: + timeUs = 1000002043238 + size = 0 + rendered = false + output buffer #88: + timeUs = 1000002066458 + size = 0 + rendered = false + output buffer #89: + timeUs = 1000002089678 + size = 0 + rendered = false +MediaCodecAdapter (media3.video.avc): + inputBuffers: + count = 31 + input buffer #0: + timeUs = 1000000000000 + contents = length 36692, hash D216076E + input buffer #1: + timeUs = 1000000066733 + contents = length 5312, hash D45D3CA0 + input buffer #2: + timeUs = 1000000033366 + contents = length 599, hash 1BE7812D + input buffer #3: + timeUs = 1000000200200 + contents = length 7735, hash 4490F110 + input buffer #4: + timeUs = 1000000133466 + contents = length 987, hash 560B5036 + input buffer #5: + timeUs = 1000000100100 + contents = length 673, hash ED7CD8C7 + input buffer #6: + timeUs = 1000000166833 + contents = length 523, hash 3020DF50 + input buffer #7: + timeUs = 1000000333666 + contents = length 6061, hash 736C72B2 + input buffer #8: + timeUs = 1000000266933 + contents = length 992, hash FE132F23 + input buffer #9: + timeUs = 1000000233566 + contents = length 623, hash 5B2C1816 + input buffer #10: + timeUs = 1000000300300 + contents = length 421, hash 742E69C1 + input buffer #11: + timeUs = 1000000433766 + contents = length 4899, hash F72F86A1 + input buffer #12: + timeUs = 1000000400400 + contents = length 568, hash 519A8E50 + input buffer #13: + timeUs = 1000000367033 + contents = length 620, hash 3990AA39 + input buffer #14: + timeUs = 1000000567233 + contents = length 5450, hash F06EC4AA + input buffer #15: + timeUs = 1000000500500 + contents = length 1051, hash 92DFA63A + input buffer #16: + timeUs = 1000000467133 + contents = length 874, hash 69587FB4 + input buffer #17: + timeUs = 1000000533866 + contents = length 781, hash 36BE495B + input buffer #18: + timeUs = 1000000700700 + contents = length 4725, hash AC0C8CD3 + input buffer #19: + timeUs = 1000000633966 + contents = length 1022, hash 5D8BFF34 + input buffer #20: + timeUs = 1000000600600 + contents = length 790, hash 99413A99 + input buffer #21: + timeUs = 1000000667333 + contents = length 610, hash 5E129290 + input buffer #22: + timeUs = 1000000834166 + contents = length 2751, hash 769974CB + input buffer #23: + timeUs = 1000000767433 + contents = length 745, hash B78A477A + input buffer #24: + timeUs = 1000000734066 + contents = length 621, hash CF741E7A + input buffer #25: + timeUs = 1000000800800 + contents = length 505, hash 1DB4894E + input buffer #26: + timeUs = 1000000967633 + contents = length 1268, hash C15348DC + input buffer #27: + timeUs = 1000000900900 + contents = length 880, hash C2DE85D0 + input buffer #28: + timeUs = 1000000867533 + contents = length 530, hash C98BC6A8 + input buffer #29: + timeUs = 1000000934266 + contents = length 568, hash 4FE5C8EA + input buffer #30: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 30 + output buffer #0: + timeUs = 1000000000000 + size = 36692 + rendered = true + output buffer #1: + timeUs = 1000000066733 + size = 5312 + rendered = true + output buffer #2: + timeUs = 1000000033366 + size = 599 + rendered = true + output buffer #3: + timeUs = 1000000200200 + size = 7735 + rendered = true + output buffer #4: + timeUs = 1000000133466 + size = 987 + rendered = true + output buffer #5: + timeUs = 1000000100100 + size = 673 + rendered = true + output buffer #6: + timeUs = 1000000166833 + size = 523 + rendered = true + output buffer #7: + timeUs = 1000000333666 + size = 6061 + rendered = true + output buffer #8: + timeUs = 1000000266933 + size = 992 + rendered = true + output buffer #9: + timeUs = 1000000233566 + size = 623 + rendered = true + output buffer #10: + timeUs = 1000000300300 + size = 421 + rendered = true + output buffer #11: + timeUs = 1000000433766 + size = 4899 + rendered = true + output buffer #12: + timeUs = 1000000400400 + size = 568 + rendered = true + output buffer #13: + timeUs = 1000000367033 + size = 620 + rendered = true + output buffer #14: + timeUs = 1000000567233 + size = 5450 + rendered = true + output buffer #15: + timeUs = 1000000500500 + size = 1051 + rendered = true + output buffer #16: + timeUs = 1000000467133 + size = 874 + rendered = true + output buffer #17: + timeUs = 1000000533866 + size = 781 + rendered = true + output buffer #18: + timeUs = 1000000700700 + size = 4725 + rendered = true + output buffer #19: + timeUs = 1000000633966 + size = 1022 + rendered = true + output buffer #20: + timeUs = 1000000600600 + size = 790 + rendered = true + output buffer #21: + timeUs = 1000000667333 + size = 610 + rendered = true + output buffer #22: + timeUs = 1000000834166 + size = 2751 + rendered = true + output buffer #23: + timeUs = 1000000767433 + size = 745 + rendered = true + output buffer #24: + timeUs = 1000000734066 + size = 621 + rendered = true + output buffer #25: + timeUs = 1000000800800 + size = 505 + rendered = true + output buffer #26: + timeUs = 1000000967633 + size = 1268 + rendered = true + output buffer #27: + timeUs = 1000000900900 + size = 880 + rendered = true + output buffer #28: + timeUs = 1000000867533 + size = 530 + rendered = true + output buffer #29: + timeUs = 1000000934266 + size = 568 + rendered = true +MediaCodecAdapter (media3.video.avc): + inputBuffers: + count = 31 + input buffer #0: + timeUs = 1000001024000 + contents = length 36692, hash D216076E + input buffer #1: + timeUs = 1000001090733 + contents = length 5312, hash D45D3CA0 + input buffer #2: + timeUs = 1000001057366 + contents = length 599, hash 1BE7812D + input buffer #3: + timeUs = 1000001224200 + contents = length 7735, hash 4490F110 + input buffer #4: + timeUs = 1000001157466 + contents = length 987, hash 560B5036 + input buffer #5: + timeUs = 1000001124100 + contents = length 673, hash ED7CD8C7 + input buffer #6: + timeUs = 1000001190833 + contents = length 523, hash 3020DF50 + input buffer #7: + timeUs = 1000001357666 + contents = length 6061, hash 736C72B2 + input buffer #8: + timeUs = 1000001290933 + contents = length 992, hash FE132F23 + input buffer #9: + timeUs = 1000001257566 + contents = length 623, hash 5B2C1816 + input buffer #10: + timeUs = 1000001324300 + contents = length 421, hash 742E69C1 + input buffer #11: + timeUs = 1000001457766 + contents = length 4899, hash F72F86A1 + input buffer #12: + timeUs = 1000001424400 + contents = length 568, hash 519A8E50 + input buffer #13: + timeUs = 1000001391033 + contents = length 620, hash 3990AA39 + input buffer #14: + timeUs = 1000001591233 + contents = length 5450, hash F06EC4AA + input buffer #15: + timeUs = 1000001524500 + contents = length 1051, hash 92DFA63A + input buffer #16: + timeUs = 1000001491133 + contents = length 874, hash 69587FB4 + input buffer #17: + timeUs = 1000001557866 + contents = length 781, hash 36BE495B + input buffer #18: + timeUs = 1000001724700 + contents = length 4725, hash AC0C8CD3 + input buffer #19: + timeUs = 1000001657966 + contents = length 1022, hash 5D8BFF34 + input buffer #20: + timeUs = 1000001624600 + contents = length 790, hash 99413A99 + input buffer #21: + timeUs = 1000001691333 + contents = length 610, hash 5E129290 + input buffer #22: + timeUs = 1000001858166 + contents = length 2751, hash 769974CB + input buffer #23: + timeUs = 1000001791433 + contents = length 745, hash B78A477A + input buffer #24: + timeUs = 1000001758066 + contents = length 621, hash CF741E7A + input buffer #25: + timeUs = 1000001824800 + contents = length 505, hash 1DB4894E + input buffer #26: + timeUs = 1000001991633 + contents = length 1268, hash C15348DC + input buffer #27: + timeUs = 1000001924900 + contents = length 880, hash C2DE85D0 + input buffer #28: + timeUs = 1000001891533 + contents = length 530, hash C98BC6A8 + input buffer #29: + timeUs = 1000001958266 + contents = length 568, hash 4FE5C8EA + input buffer #30: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 30 + output buffer #0: + timeUs = 1000001024000 + size = 36692 + rendered = true + output buffer #1: + timeUs = 1000001090733 + size = 5312 + rendered = true + output buffer #2: + timeUs = 1000001057366 + size = 599 + rendered = true + output buffer #3: + timeUs = 1000001224200 + size = 7735 + rendered = true + output buffer #4: + timeUs = 1000001157466 + size = 987 + rendered = true + output buffer #5: + timeUs = 1000001124100 + size = 673 + rendered = true + output buffer #6: + timeUs = 1000001190833 + size = 523 + rendered = true + output buffer #7: + timeUs = 1000001357666 + size = 6061 + rendered = true + output buffer #8: + timeUs = 1000001290933 + size = 992 + rendered = true + output buffer #9: + timeUs = 1000001257566 + size = 623 + rendered = true + output buffer #10: + timeUs = 1000001324300 + size = 421 + rendered = true + output buffer #11: + timeUs = 1000001457766 + size = 4899 + rendered = true + output buffer #12: + timeUs = 1000001424400 + size = 568 + rendered = true + output buffer #13: + timeUs = 1000001391033 + size = 620 + rendered = true + output buffer #14: + timeUs = 1000001591233 + size = 5450 + rendered = true + output buffer #15: + timeUs = 1000001524500 + size = 1051 + rendered = true + output buffer #16: + timeUs = 1000001491133 + size = 874 + rendered = true + output buffer #17: + timeUs = 1000001557866 + size = 781 + rendered = true + output buffer #18: + timeUs = 1000001724700 + size = 4725 + rendered = true + output buffer #19: + timeUs = 1000001657966 + size = 1022 + rendered = true + output buffer #20: + timeUs = 1000001624600 + size = 790 + rendered = true + output buffer #21: + timeUs = 1000001691333 + size = 610 + rendered = true + output buffer #22: + timeUs = 1000001858166 + size = 2751 + rendered = true + output buffer #23: + timeUs = 1000001791433 + size = 745 + rendered = true + output buffer #24: + timeUs = 1000001758066 + size = 621 + rendered = true + output buffer #25: + timeUs = 1000001824800 + size = 505 + rendered = true + output buffer #26: + timeUs = 1000001991633 + size = 1268 + rendered = true + output buffer #27: + timeUs = 1000001924900 + size = 880 + rendered = true + output buffer #28: + timeUs = 1000001891533 + size = 530 + rendered = true + output buffer #29: + timeUs = 1000001958266 + size = 568 + rendered = true +MediaCodecAdapter (media3.video.avc): + inputBuffers: + count = 31 + input buffer #0: + timeUs = 1000000000000 + contents = length 36692, hash D216076E + input buffer #1: + timeUs = 1000000066733 + contents = length 5312, hash D45D3CA0 + input buffer #2: + timeUs = 1000000033366 + contents = length 599, hash 1BE7812D + input buffer #3: + timeUs = 1000000200200 + contents = length 7735, hash 4490F110 + input buffer #4: + timeUs = 1000000133466 + contents = length 987, hash 560B5036 + input buffer #5: + timeUs = 1000000100100 + contents = length 673, hash ED7CD8C7 + input buffer #6: + timeUs = 1000000166833 + contents = length 523, hash 3020DF50 + input buffer #7: + timeUs = 1000000333666 + contents = length 6061, hash 736C72B2 + input buffer #8: + timeUs = 1000000266933 + contents = length 992, hash FE132F23 + input buffer #9: + timeUs = 1000000233566 + contents = length 623, hash 5B2C1816 + input buffer #10: + timeUs = 1000000300300 + contents = length 421, hash 742E69C1 + input buffer #11: + timeUs = 1000000433766 + contents = length 4899, hash F72F86A1 + input buffer #12: + timeUs = 1000000400400 + contents = length 568, hash 519A8E50 + input buffer #13: + timeUs = 1000000367033 + contents = length 620, hash 3990AA39 + input buffer #14: + timeUs = 1000000567233 + contents = length 5450, hash F06EC4AA + input buffer #15: + timeUs = 1000000500500 + contents = length 1051, hash 92DFA63A + input buffer #16: + timeUs = 1000000467133 + contents = length 874, hash 69587FB4 + input buffer #17: + timeUs = 1000000533866 + contents = length 781, hash 36BE495B + input buffer #18: + timeUs = 1000000700700 + contents = length 4725, hash AC0C8CD3 + input buffer #19: + timeUs = 1000000633966 + contents = length 1022, hash 5D8BFF34 + input buffer #20: + timeUs = 1000000600600 + contents = length 790, hash 99413A99 + input buffer #21: + timeUs = 1000000667333 + contents = length 610, hash 5E129290 + input buffer #22: + timeUs = 1000000834166 + contents = length 2751, hash 769974CB + input buffer #23: + timeUs = 1000000767433 + contents = length 745, hash B78A477A + input buffer #24: + timeUs = 1000000734066 + contents = length 621, hash CF741E7A + input buffer #25: + timeUs = 1000000800800 + contents = length 505, hash 1DB4894E + input buffer #26: + timeUs = 1000000967633 + contents = length 1268, hash C15348DC + input buffer #27: + timeUs = 1000000900900 + contents = length 880, hash C2DE85D0 + input buffer #28: + timeUs = 1000000867533 + contents = length 530, hash C98BC6A8 + input buffer #29: + timeUs = 1000000934266 + contents = length 568, hash 4FE5C8EA + input buffer #30: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 30 + output buffer #0: + timeUs = 1000000000000 + size = 36692 + rendered = true + output buffer #1: + timeUs = 1000000066733 + size = 5312 + rendered = true + output buffer #2: + timeUs = 1000000033366 + size = 599 + rendered = true + output buffer #3: + timeUs = 1000000200200 + size = 7735 + rendered = true + output buffer #4: + timeUs = 1000000133466 + size = 987 + rendered = true + output buffer #5: + timeUs = 1000000100100 + size = 673 + rendered = true + output buffer #6: + timeUs = 1000000166833 + size = 523 + rendered = true + output buffer #7: + timeUs = 1000000333666 + size = 6061 + rendered = true + output buffer #8: + timeUs = 1000000266933 + size = 992 + rendered = true + output buffer #9: + timeUs = 1000000233566 + size = 623 + rendered = true + output buffer #10: + timeUs = 1000000300300 + size = 421 + rendered = true + output buffer #11: + timeUs = 1000000433766 + size = 4899 + rendered = true + output buffer #12: + timeUs = 1000000400400 + size = 568 + rendered = true + output buffer #13: + timeUs = 1000000367033 + size = 620 + rendered = true + output buffer #14: + timeUs = 1000000567233 + size = 5450 + rendered = true + output buffer #15: + timeUs = 1000000500500 + size = 1051 + rendered = true + output buffer #16: + timeUs = 1000000467133 + size = 874 + rendered = true + output buffer #17: + timeUs = 1000000533866 + size = 781 + rendered = true + output buffer #18: + timeUs = 1000000700700 + size = 4725 + rendered = true + output buffer #19: + timeUs = 1000000633966 + size = 1022 + rendered = true + output buffer #20: + timeUs = 1000000600600 + size = 790 + rendered = true + output buffer #21: + timeUs = 1000000667333 + size = 610 + rendered = true + output buffer #22: + timeUs = 1000000834166 + size = 2751 + rendered = true + output buffer #23: + timeUs = 1000000767433 + size = 745 + rendered = true + output buffer #24: + timeUs = 1000000734066 + size = 621 + rendered = true + output buffer #25: + timeUs = 1000000800800 + size = 505 + rendered = true + output buffer #26: + timeUs = 1000000967633 + size = 1268 + rendered = true + output buffer #27: + timeUs = 1000000900900 + size = 880 + rendered = true + output buffer #28: + timeUs = 1000000867533 + size = 530 + rendered = true + output buffer #29: + timeUs = 1000000934266 + size = 568 + rendered = true +MediaCodecAdapter (media3.video.avc): + inputBuffers: + count = 31 + input buffer #0: + timeUs = 1000001024000 + contents = length 36692, hash D216076E + input buffer #1: + timeUs = 1000001090733 + contents = length 5312, hash D45D3CA0 + input buffer #2: + timeUs = 1000001057366 + contents = length 599, hash 1BE7812D + input buffer #3: + timeUs = 1000001224200 + contents = length 7735, hash 4490F110 + input buffer #4: + timeUs = 1000001157466 + contents = length 987, hash 560B5036 + input buffer #5: + timeUs = 1000001124100 + contents = length 673, hash ED7CD8C7 + input buffer #6: + timeUs = 1000001190833 + contents = length 523, hash 3020DF50 + input buffer #7: + timeUs = 1000001357666 + contents = length 6061, hash 736C72B2 + input buffer #8: + timeUs = 1000001290933 + contents = length 992, hash FE132F23 + input buffer #9: + timeUs = 1000001257566 + contents = length 623, hash 5B2C1816 + input buffer #10: + timeUs = 1000001324300 + contents = length 421, hash 742E69C1 + input buffer #11: + timeUs = 1000001457766 + contents = length 4899, hash F72F86A1 + input buffer #12: + timeUs = 1000001424400 + contents = length 568, hash 519A8E50 + input buffer #13: + timeUs = 1000001391033 + contents = length 620, hash 3990AA39 + input buffer #14: + timeUs = 1000001591233 + contents = length 5450, hash F06EC4AA + input buffer #15: + timeUs = 1000001524500 + contents = length 1051, hash 92DFA63A + input buffer #16: + timeUs = 1000001491133 + contents = length 874, hash 69587FB4 + input buffer #17: + timeUs = 1000001557866 + contents = length 781, hash 36BE495B + input buffer #18: + timeUs = 1000001724700 + contents = length 4725, hash AC0C8CD3 + input buffer #19: + timeUs = 1000001657966 + contents = length 1022, hash 5D8BFF34 + input buffer #20: + timeUs = 1000001624600 + contents = length 790, hash 99413A99 + input buffer #21: + timeUs = 1000001691333 + contents = length 610, hash 5E129290 + input buffer #22: + timeUs = 1000001858166 + contents = length 2751, hash 769974CB + input buffer #23: + timeUs = 1000001791433 + contents = length 745, hash B78A477A + input buffer #24: + timeUs = 1000001758066 + contents = length 621, hash CF741E7A + input buffer #25: + timeUs = 1000001824800 + contents = length 505, hash 1DB4894E + input buffer #26: + timeUs = 1000001991633 + contents = length 1268, hash C15348DC + input buffer #27: + timeUs = 1000001924900 + contents = length 880, hash C2DE85D0 + input buffer #28: + timeUs = 1000001891533 + contents = length 530, hash C98BC6A8 + input buffer #29: + timeUs = 1000001958266 + contents = length 568, hash 4FE5C8EA + input buffer #30: + timeUs = 0 + flags = 4 + contents = length 0, hash 1 + outputBuffers: + count = 30 + output buffer #0: + timeUs = 1000001024000 + size = 36692 + rendered = true + output buffer #1: + timeUs = 1000001090733 + size = 5312 + rendered = true + output buffer #2: + timeUs = 1000001057366 + size = 599 + rendered = true + output buffer #3: + timeUs = 1000001224200 + size = 7735 + rendered = true + output buffer #4: + timeUs = 1000001157466 + size = 987 + rendered = true + output buffer #5: + timeUs = 1000001124100 + size = 673 + rendered = true + output buffer #6: + timeUs = 1000001190833 + size = 523 + rendered = true + output buffer #7: + timeUs = 1000001357666 + size = 6061 + rendered = true + output buffer #8: + timeUs = 1000001290933 + size = 992 + rendered = true + output buffer #9: + timeUs = 1000001257566 + size = 623 + rendered = true + output buffer #10: + timeUs = 1000001324300 + size = 421 + rendered = true + output buffer #11: + timeUs = 1000001457766 + size = 4899 + rendered = true + output buffer #12: + timeUs = 1000001424400 + size = 568 + rendered = true + output buffer #13: + timeUs = 1000001391033 + size = 620 + rendered = true + output buffer #14: + timeUs = 1000001591233 + size = 5450 + rendered = true + output buffer #15: + timeUs = 1000001524500 + size = 1051 + rendered = true + output buffer #16: + timeUs = 1000001491133 + size = 874 + rendered = true + output buffer #17: + timeUs = 1000001557866 + size = 781 + rendered = true + output buffer #18: + timeUs = 1000001724700 + size = 4725 + rendered = true + output buffer #19: + timeUs = 1000001657966 + size = 1022 + rendered = true + output buffer #20: + timeUs = 1000001624600 + size = 790 + rendered = true + output buffer #21: + timeUs = 1000001691333 + size = 610 + rendered = true + output buffer #22: + timeUs = 1000001858166 + size = 2751 + rendered = true + output buffer #23: + timeUs = 1000001791433 + size = 745 + rendered = true + output buffer #24: + timeUs = 1000001758066 + size = 621 + rendered = true + output buffer #25: + timeUs = 1000001824800 + size = 505 + rendered = true + output buffer #26: + timeUs = 1000001991633 + size = 1268 + rendered = true + output buffer #27: + timeUs = 1000001924900 + size = 880 + rendered = true + output buffer #28: + timeUs = 1000001891533 + size = 530 + rendered = true + output buffer #29: + timeUs = 1000001958266 + size = 568 + rendered = true +AudioSink: + buffer count = 180 + config: + pcmEncoding = pcm-16 + channelCount = 1 + sampleRate = 44100 + buffer #0: + time = 1000000044000 + data = empty + buffer #1: + time = 1000000067219 + data = empty + buffer #2: + time = 1000000090439 + data = empty + buffer #3: + time = 1000000113659 + data = empty + buffer #4: + time = 1000000136879 + data = empty + buffer #5: + time = 1000000160099 + data = empty + buffer #6: + time = 1000000183319 + data = empty + buffer #7: + time = 1000000206539 + data = empty + buffer #8: + time = 1000000229759 + data = empty + buffer #9: + time = 1000000252979 + data = empty + buffer #10: + time = 1000000276199 + data = empty + buffer #11: + time = 1000000299419 + data = empty + buffer #12: + time = 1000000322639 + data = empty + buffer #13: + time = 1000000345859 + data = empty + buffer #14: + time = 1000000369079 + data = empty + buffer #15: + time = 1000000392299 + data = empty + buffer #16: + time = 1000000415519 + data = empty + buffer #17: + time = 1000000438739 + data = empty + buffer #18: + time = 1000000461959 + data = empty + buffer #19: + time = 1000000485179 + data = empty + buffer #20: + time = 1000000508399 + data = empty + buffer #21: + time = 1000000531619 + data = empty + buffer #22: + time = 1000000554839 + data = empty + buffer #23: + time = 1000000578058 + data = empty + buffer #24: + time = 1000000601278 + data = empty + buffer #25: + time = 1000000624498 + data = empty + buffer #26: + time = 1000000647718 + data = empty + buffer #27: + time = 1000000670938 + data = empty + buffer #28: + time = 1000000694158 + data = empty + buffer #29: + time = 1000000717378 + data = empty + buffer #30: + time = 1000000740598 + data = empty + buffer #31: + time = 1000000763818 + data = empty + buffer #32: + time = 1000000787038 + data = empty + buffer #33: + time = 1000000810258 + data = empty + buffer #34: + time = 1000000833478 + data = empty + buffer #35: + time = 1000000856698 + data = empty + buffer #36: + time = 1000000879918 + data = empty + buffer #37: + time = 1000000903138 + data = empty + buffer #38: + time = 1000000926358 + data = empty + buffer #39: + time = 1000000949578 + data = empty + buffer #40: + time = 1000000972798 + data = empty + buffer #41: + time = 1000000996018 + data = empty + buffer #42: + time = 1000001019238 + data = empty + buffer #43: + time = 1000001042458 + data = empty + buffer #44: + time = 1000001065678 + data = empty + discontinuity: + config: + pcmEncoding = pcm-16 + channelCount = 1 + sampleRate = 44100 + buffer #45: + time = 1000001068000 + data = empty + buffer #46: + time = 1000001091219 + data = empty + buffer #47: + time = 1000001114439 + data = empty + buffer #48: + time = 1000001137659 + data = empty + buffer #49: + time = 1000001160879 + data = empty + buffer #50: + time = 1000001184099 + data = empty + buffer #51: + time = 1000001207319 + data = empty + buffer #52: + time = 1000001230539 + data = empty + buffer #53: + time = 1000001253759 + data = empty + buffer #54: + time = 1000001276979 + data = empty + buffer #55: + time = 1000001300199 + data = empty + buffer #56: + time = 1000001323419 + data = empty + buffer #57: + time = 1000001346639 + data = empty + buffer #58: + time = 1000001369859 + data = empty + buffer #59: + time = 1000001393079 + data = empty + buffer #60: + time = 1000001416299 + data = empty + buffer #61: + time = 1000001439519 + data = empty + buffer #62: + time = 1000001462739 + data = empty + buffer #63: + time = 1000001485959 + data = empty + buffer #64: + time = 1000001509179 + data = empty + buffer #65: + time = 1000001532399 + data = empty + buffer #66: + time = 1000001555619 + data = empty + buffer #67: + time = 1000001578839 + data = empty + buffer #68: + time = 1000001602058 + data = empty + buffer #69: + time = 1000001625278 + data = empty + buffer #70: + time = 1000001648498 + data = empty + buffer #71: + time = 1000001671718 + data = empty + buffer #72: + time = 1000001694938 + data = empty + buffer #73: + time = 1000001718158 + data = empty + buffer #74: + time = 1000001741378 + data = empty + buffer #75: + time = 1000001764598 + data = empty + buffer #76: + time = 1000001787818 + data = empty + buffer #77: + time = 1000001811038 + data = empty + buffer #78: + time = 1000001834258 + data = empty + buffer #79: + time = 1000001857478 + data = empty + buffer #80: + time = 1000001880698 + data = empty + buffer #81: + time = 1000001903918 + data = empty + buffer #82: + time = 1000001927138 + data = empty + buffer #83: + time = 1000001950358 + data = empty + buffer #84: + time = 1000001973578 + data = empty + buffer #85: + time = 1000001996798 + data = empty + buffer #86: + time = 1000002020018 + data = empty + buffer #87: + time = 1000002043238 + data = empty + buffer #88: + time = 1000002066458 + data = empty + buffer #89: + time = 1000002089678 + data = empty + config: + pcmEncoding = pcm-16 + channelCount = 1 + sampleRate = 44100 + buffer #90: + time = 1000000044000 + data = empty + buffer #91: + time = 1000000067219 + data = empty + buffer #92: + time = 1000000090439 + data = empty + buffer #93: + time = 1000000113659 + data = empty + buffer #94: + time = 1000000136879 + data = empty + buffer #95: + time = 1000000160099 + data = empty + buffer #96: + time = 1000000183319 + data = empty + buffer #97: + time = 1000000206539 + data = empty + buffer #98: + time = 1000000229759 + data = empty + buffer #99: + time = 1000000252979 + data = empty + buffer #100: + time = 1000000276199 + data = empty + buffer #101: + time = 1000000299419 + data = empty + buffer #102: + time = 1000000322639 + data = empty + buffer #103: + time = 1000000345859 + data = empty + buffer #104: + time = 1000000369079 + data = empty + buffer #105: + time = 1000000392299 + data = empty + buffer #106: + time = 1000000415519 + data = empty + buffer #107: + time = 1000000438739 + data = empty + buffer #108: + time = 1000000461959 + data = empty + buffer #109: + time = 1000000485179 + data = empty + buffer #110: + time = 1000000508399 + data = empty + buffer #111: + time = 1000000531619 + data = empty + buffer #112: + time = 1000000554839 + data = empty + buffer #113: + time = 1000000578058 + data = empty + buffer #114: + time = 1000000601278 + data = empty + buffer #115: + time = 1000000624498 + data = empty + buffer #116: + time = 1000000647718 + data = empty + buffer #117: + time = 1000000670938 + data = empty + buffer #118: + time = 1000000694158 + data = empty + buffer #119: + time = 1000000717378 + data = empty + buffer #120: + time = 1000000740598 + data = empty + buffer #121: + time = 1000000763818 + data = empty + buffer #122: + time = 1000000787038 + data = empty + buffer #123: + time = 1000000810258 + data = empty + buffer #124: + time = 1000000833478 + data = empty + buffer #125: + time = 1000000856698 + data = empty + buffer #126: + time = 1000000879918 + data = empty + buffer #127: + time = 1000000903138 + data = empty + buffer #128: + time = 1000000926358 + data = empty + buffer #129: + time = 1000000949578 + data = empty + buffer #130: + time = 1000000972798 + data = empty + buffer #131: + time = 1000000996018 + data = empty + buffer #132: + time = 1000001019238 + data = empty + buffer #133: + time = 1000001042458 + data = empty + buffer #134: + time = 1000001065678 + data = empty + discontinuity: + config: + pcmEncoding = pcm-16 + channelCount = 1 + sampleRate = 44100 + buffer #135: + time = 1000001068000 + data = empty + buffer #136: + time = 1000001091219 + data = empty + buffer #137: + time = 1000001114439 + data = empty + buffer #138: + time = 1000001137659 + data = empty + buffer #139: + time = 1000001160879 + data = empty + buffer #140: + time = 1000001184099 + data = empty + buffer #141: + time = 1000001207319 + data = empty + buffer #142: + time = 1000001230539 + data = empty + buffer #143: + time = 1000001253759 + data = empty + buffer #144: + time = 1000001276979 + data = empty + buffer #145: + time = 1000001300199 + data = empty + buffer #146: + time = 1000001323419 + data = empty + buffer #147: + time = 1000001346639 + data = empty + buffer #148: + time = 1000001369859 + data = empty + buffer #149: + time = 1000001393079 + data = empty + buffer #150: + time = 1000001416299 + data = empty + buffer #151: + time = 1000001439519 + data = empty + buffer #152: + time = 1000001462739 + data = empty + buffer #153: + time = 1000001485959 + data = empty + buffer #154: + time = 1000001509179 + data = empty + buffer #155: + time = 1000001532399 + data = empty + buffer #156: + time = 1000001555619 + data = empty + buffer #157: + time = 1000001578839 + data = empty + buffer #158: + time = 1000001602058 + data = empty + buffer #159: + time = 1000001625278 + data = empty + buffer #160: + time = 1000001648498 + data = empty + buffer #161: + time = 1000001671718 + data = empty + buffer #162: + time = 1000001694938 + data = empty + buffer #163: + time = 1000001718158 + data = empty + buffer #164: + time = 1000001741378 + data = empty + buffer #165: + time = 1000001764598 + data = empty + buffer #166: + time = 1000001787818 + data = empty + buffer #167: + time = 1000001811038 + data = empty + buffer #168: + time = 1000001834258 + data = empty + buffer #169: + time = 1000001857478 + data = empty + buffer #170: + time = 1000001880698 + data = empty + buffer #171: + time = 1000001903918 + data = empty + buffer #172: + time = 1000001927138 + data = empty + buffer #173: + time = 1000001950358 + data = empty + buffer #174: + time = 1000001973578 + data = empty + buffer #175: + time = 1000001996798 + data = empty + buffer #176: + time = 1000002020018 + data = empty + buffer #177: + time = 1000002043238 + data = empty + buffer #178: + time = 1000002066458 + data = empty + buffer #179: + time = 1000002089678 + data = empty +ImageOutput: + rendered image count = 2 + image output #1: + presentationTimeUs = 0 + bitmap hash = -1041353260 + image output #2: + presentationTimeUs = 0 + bitmap hash = -1041353260 diff --git a/libraries/test_data/src/test/assets/test-generated-goldens/DefaultVideoFrameProcessorPixelTest/toneMap_pqRegisterInput.png b/libraries/test_data/src/test/assets/test-generated-goldens/DefaultVideoFrameProcessorPixelTest/toneMap_pqRegisterInput.png new file mode 100644 index 00000000000..9377f4626fa Binary files /dev/null and b/libraries/test_data/src/test/assets/test-generated-goldens/DefaultVideoFrameProcessorPixelTest/toneMap_pqRegisterInput.png differ diff --git a/libraries/test_exoplayer_playback/src/androidTest/java/androidx/media3/test/exoplayer/playback/gts/DashTestRunner.java b/libraries/test_exoplayer_playback/src/androidTest/java/androidx/media3/test/exoplayer/playback/gts/DashTestRunner.java index 4b69012f773..080b937c4b9 100644 --- a/libraries/test_exoplayer_playback/src/androidTest/java/androidx/media3/test/exoplayer/playback/gts/DashTestRunner.java +++ b/libraries/test_exoplayer_playback/src/androidTest/java/androidx/media3/test/exoplayer/playback/gts/DashTestRunner.java @@ -28,6 +28,7 @@ import androidx.media3.common.C; import androidx.media3.common.Format; import androidx.media3.common.MediaItem; +import androidx.media3.common.MediaLibraryInfo; import androidx.media3.common.TrackGroup; import androidx.media3.common.util.Log; import androidx.media3.common.util.NullableType; @@ -225,6 +226,12 @@ private DashHostedTest createDashHostedTest( /** A {@link HostedTest} for DASH playback tests. */ private static final class DashHostedTest extends ExoHostedTest { + static { + // Disable all device and codec-specific workarounds, since we are interested in testing + // that the underlying platform is behaving correctly. + MediaLibraryInfo.setEnableWorkarounds(false); + } + private final String streamName; private final String manifestUrl; private final MetricsLogger metricsLogger; diff --git a/libraries/test_proguard/build.gradle.kts b/libraries/test_proguard/build.gradle.kts index b4024ac4e7a..cfa85159f4f 100644 --- a/libraries/test_proguard/build.gradle.kts +++ b/libraries/test_proguard/build.gradle.kts @@ -36,6 +36,7 @@ android { dependencies { coreLibraryDesugaring(libs.desugar.jdk.libs) + implementation(project(":lib-effect-ndk")) implementation(project(":lib-exoplayer")) implementation(project(":lib-exoplayer-dash")) implementation(project(":lib-exoplayer-hls")) diff --git a/libraries/test_proguard/src/androidTest/java/androidx/media3/test/proguard/EffectNdkModuleProguardTest.java b/libraries/test_proguard/src/androidTest/java/androidx/media3/test/proguard/EffectNdkModuleProguardTest.java new file mode 100644 index 00000000000..67b482e7f96 --- /dev/null +++ b/libraries/test_proguard/src/androidTest/java/androidx/media3/test/proguard/EffectNdkModuleProguardTest.java @@ -0,0 +1,32 @@ +/* + * Copyright 2026 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 androidx.media3.test.proguard; + +import androidx.test.ext.junit.runners.AndroidJUnit4; +import androidx.test.filters.SdkSuppress; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** Unit test executing methods in {@link EffectNdkModuleProguard}. */ +@SdkSuppress(minSdkVersion = 26) +@RunWith(AndroidJUnit4.class) +public final class EffectNdkModuleProguardTest { + + @Test + public void bindEglImage_succeeds() { + EffectNdkModuleProguard.bindEglImage(); + } +} diff --git a/libraries/test_proguard/src/main/java/androidx/media3/test/proguard/EffectNdkModuleProguard.java b/libraries/test_proguard/src/main/java/androidx/media3/test/proguard/EffectNdkModuleProguard.java new file mode 100644 index 00000000000..e66da247b43 --- /dev/null +++ b/libraries/test_proguard/src/main/java/androidx/media3/test/proguard/EffectNdkModuleProguard.java @@ -0,0 +1,38 @@ +/* + * Copyright 2026 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 androidx.media3.test.proguard; + +import static androidx.annotation.VisibleForTesting.NONE; + +import androidx.annotation.RequiresApi; +import androidx.annotation.VisibleForTesting; +import androidx.media3.effect.ndk.HardwareBufferJni; + +/** + * Class exercising native code in the Effect NDK module that relies on a correct proguard config. + */ +@RequiresApi(26) +@VisibleForTesting(otherwise = NONE) +public final class EffectNdkModuleProguard { + + private EffectNdkModuleProguard() {} + + /** Exercises {@link HardwareBufferJni} that relies on unobfuscated native method names. */ + public static void bindEglImage() { + boolean unused = + HardwareBufferJni.INSTANCE.nativeBindEGLImage(/* target= */ 0, /* eglImageHandle= */ 0); + } +} diff --git a/libraries/test_session_common/src/main/aidl/androidx/media3/test/session/common/IRemoteMediaSession.aidl b/libraries/test_session_common/src/main/aidl/androidx/media3/test/session/common/IRemoteMediaSession.aidl index 67a6a4be424..300e82b2140 100644 --- a/libraries/test_session_common/src/main/aidl/androidx/media3/test/session/common/IRemoteMediaSession.aidl +++ b/libraries/test_session_common/src/main/aidl/androidx/media3/test/session/common/IRemoteMediaSession.aidl @@ -86,6 +86,7 @@ interface IRemoteMediaSession { void setCurrentPeriodIndex(String sessionId, int index); void setTrackSelectionParameters(String sessionId, in Bundle parameters); void notifyTimelineChanged(String sessionId, int reason); + void notifyTimelineChangedWithMediaItemTransition(String sessionId); void notifyPlaylistMetadataChanged(String sessionId); void notifyShuffleModeEnabledChanged(String sessionId); void notifyRepeatModeChanged(String sessionId); diff --git a/libraries/test_session_common/src/main/java/androidx/media3/test/session/common/MediaSessionConstants.java b/libraries/test_session_common/src/main/java/androidx/media3/test/session/common/MediaSessionConstants.java index 6902907b53a..b86b1d9c2b0 100644 --- a/libraries/test_session_common/src/main/java/androidx/media3/test/session/common/MediaSessionConstants.java +++ b/libraries/test_session_common/src/main/java/androidx/media3/test/session/common/MediaSessionConstants.java @@ -58,6 +58,10 @@ public class MediaSessionConstants { public static final String CONNECTION_HINT_KEY_ASYNC_CONNECTION_DELAY_MS = "androidx.media3.session.async_connection_delay_ms"; + /** Connection hint key for requesting an async library root with a delay in milliseconds. */ + public static final String CONNECTION_HINT_KEY_ASYNC_LIBRARY_ROOT_DELAY_MS = + "androidx.media3.session.async_library_root_delay_ms"; + /** Connection hint key for requesting an async rejection with a delay in milliseconds. */ public static final String CONNECTION_HINT_KEY_ASYNC_CONNECTION_REJECT_DELAY_MS = "androidx.media3.session.async_connection_reject_delay_ms"; diff --git a/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaBrowserCompatWithMediaLibraryServiceTest.java b/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaBrowserCompatWithMediaLibraryServiceTest.java index 26f695a71a5..59571ff46de 100644 --- a/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaBrowserCompatWithMediaLibraryServiceTest.java +++ b/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaBrowserCompatWithMediaLibraryServiceTest.java @@ -66,6 +66,7 @@ import static androidx.media3.test.session.common.MediaBrowserConstants.SEARCH_RESULT_COUNT; import static androidx.media3.test.session.common.MediaBrowserConstants.SUBSCRIBE_PARENT_ID_2; import static androidx.media3.test.session.common.MediaSessionConstants.CONNECTION_HINT_KEY_ASYNC_CONNECTION_DELAY_MS; +import static androidx.media3.test.session.common.MediaSessionConstants.CONNECTION_HINT_KEY_ASYNC_LIBRARY_ROOT_DELAY_MS; import static androidx.media3.test.session.common.MediaSessionConstants.EXTRA_KEY_ASYNC_CONNECTION_CONFIRMATION; import static androidx.media3.test.session.common.MediaSessionConstants.KEY_CONTROLLER; import static androidx.media3.test.session.common.TestUtils.LONG_TIMEOUT_MS; @@ -218,6 +219,45 @@ public void getRoot_browserConnectionAsync() throws Exception { .isTrue(); } + @Test + public void getRoot_onGetLibraryRootAsync() throws Exception { + Bundle rootHints = new Bundle(); + rootHints.putLong(CONNECTION_HINT_KEY_ASYNC_LIBRARY_ROOT_DELAY_MS, 200L); + + connectAndWait(rootHints); + + assertThat(browserCompat.getRoot()).isEqualTo(ROOT_ID); + assertThat( + browserCompat + .getExtras() + .getInt(ROOT_EXTRAS_KEY, /* defaultValue= */ ROOT_EXTRAS_VALUE + 1)) + .isEqualTo(ROOT_EXTRAS_VALUE); + assertThat(TestUtils.contains(browserCompat.getExtras(), ROOT_EXTRAS)).isTrue(); + } + + @Test + public void getRoot_connectionAsyncAndOnGetLibraryRootAsync() throws Exception { + Bundle rootHints = new Bundle(); + rootHints.putLong(CONNECTION_HINT_KEY_ASYNC_CONNECTION_DELAY_MS, 100L); + rootHints.putLong(CONNECTION_HINT_KEY_ASYNC_LIBRARY_ROOT_DELAY_MS, 100L); + rootHints.putString(KEY_CONTROLLER, "getRoot_connectionAsyncAndOnGetLibraryRootAsync"); + + connectAndWait(rootHints); + + assertThat(browserCompat.getRoot()).isEqualTo(ROOT_ID); + assertThat( + browserCompat + .getExtras() + .getInt(ROOT_EXTRAS_KEY, /* defaultValue= */ ROOT_EXTRAS_VALUE + 1)) + .isEqualTo(ROOT_EXTRAS_VALUE); + assertThat(TestUtils.contains(browserCompat.getExtras(), ROOT_EXTRAS)).isTrue(); + assertThat( + browserCompat + .getExtras() + .getBoolean(EXTRA_KEY_ASYNC_CONNECTION_CONFIRMATION, /* defaultValue= */ false)) + .isTrue(); + } + @Test public void getItem_browsable() throws Exception { String mediaId = MEDIA_ID_GET_BROWSABLE_ITEM; diff --git a/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaBrowserCompatWithMediaSessionServiceTest.java b/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaBrowserCompatWithMediaSessionServiceTest.java index a0746a0807e..72b4b2df791 100644 --- a/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaBrowserCompatWithMediaSessionServiceTest.java +++ b/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaBrowserCompatWithMediaSessionServiceTest.java @@ -163,6 +163,24 @@ public void getRoot_connectionAsync() throws Exception { assertThat(connectionCallback.connectedLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); } + @Test + public void connect_asyncRejected() throws Exception { + Bundle rootHints = new Bundle(); + rootHints.putLong( + MediaSessionConstants.CONNECTION_HINT_KEY_ASYNC_CONNECTION_REJECT_DELAY_MS, 100L); + + handler.postAndSync( + () -> { + browserCompat = + new MediaBrowserCompat(context, getServiceComponent(), connectionCallback, rootHints); + }); + + browserCompat.connect(); + + assertThat(connectionCallback.failedLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); + assertThat(connectionCallback.connectedLatch.getCount()).isNotEqualTo(0); + } + @Ignore("Create a session service whose onConnect() returns null.") @Test public void connect_rejected() throws InterruptedException { diff --git a/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaControllerListenerTest.java b/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaControllerListenerTest.java index 6a7f48d4e62..401306aed21 100644 --- a/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaControllerListenerTest.java +++ b/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaControllerListenerTest.java @@ -25,15 +25,20 @@ import static androidx.media3.common.Player.COMMAND_PREPARE; import static androidx.media3.common.Player.COMMAND_RELEASE; import static androidx.media3.common.Player.COMMAND_SEEK_BACK; +import static androidx.media3.common.Player.DISCONTINUITY_REASON_SEEK; import static androidx.media3.common.Player.EVENT_AVAILABLE_COMMANDS_CHANGED; import static androidx.media3.common.Player.EVENT_IS_PLAYING_CHANGED; +import static androidx.media3.common.Player.EVENT_MEDIA_ITEM_TRANSITION; import static androidx.media3.common.Player.EVENT_PLAYBACK_STATE_CHANGED; import static androidx.media3.common.Player.EVENT_PLAYER_ERROR; import static androidx.media3.common.Player.EVENT_PLAY_WHEN_READY_CHANGED; import static androidx.media3.common.Player.EVENT_RENDERED_FIRST_FRAME; +import static androidx.media3.common.Player.EVENT_TIMELINE_CHANGED; import static androidx.media3.common.Player.MEDIA_ITEM_TRANSITION_REASON_AUTO; +import static androidx.media3.common.Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED; import static androidx.media3.common.Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT; import static androidx.media3.common.Player.MEDIA_ITEM_TRANSITION_REASON_SEEK; +import static androidx.media3.common.Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED; import static androidx.media3.session.MediaTestUtils.createMediaItem; import static androidx.media3.session.MediaTestUtils.createTimeline; import static androidx.media3.session.MediaUtils.createPlayerCommandsWith; @@ -931,13 +936,13 @@ public void setPlayer_notifiesChangedValues() throws Exception { AtomicReference timelineRef = new AtomicReference<>(); AtomicReference playlistMetadataRef = new AtomicReference<>(); AtomicReference audioAttributesRef = new AtomicReference<>(); - AtomicBoolean isPlayingAdRef = new AtomicBoolean(); AtomicInteger currentAdGroupIndexRef = new AtomicInteger(); AtomicInteger currentAdIndexInAdGroupRef = new AtomicInteger(); AtomicBoolean shuffleModeEnabledRef = new AtomicBoolean(); AtomicInteger repeatModeRef = new AtomicInteger(); AtomicReference commandsRef = new AtomicReference<>(); - CountDownLatch latch = new CountDownLatch(8); + CountDownLatch latch = new CountDownLatch(7); + // Connect to session with empty player. MediaController controller = controllerTestRule.createController(remoteSession.getToken()); threadTestRule .getHandler() @@ -966,6 +971,8 @@ public void onPlaybackStateChanged(@Player.State int playbackState) { @Override public void onTimelineChanged( Timeline timeline, @Player.TimelineChangeReason int reason) { + currentAdGroupIndexRef.set(controller.getCurrentAdGroupIndex()); + currentAdIndexInAdGroupRef.set(controller.getCurrentAdIndexInAdGroup()); timelineRef.set(timeline); latch.countDown(); } @@ -976,17 +983,6 @@ public void onPlaylistMetadataChanged(MediaMetadata playlistMetadata) { latch.countDown(); } - @Override - public void onPositionDiscontinuity( - PositionInfo oldPosition, - PositionInfo newPosition, - @Player.DiscontinuityReason int reason) { - isPlayingAdRef.set(controller.isPlayingAd()); - currentAdGroupIndexRef.set(newPosition.adGroupIndex); - currentAdIndexInAdGroupRef.set(newPosition.adIndexInAdGroup); - latch.countDown(); - } - @Override public void onShuffleModeEnabledChanged(boolean shuffleModeEnabled) { shuffleModeEnabledRef.set(shuffleModeEnabled); @@ -1081,10 +1077,8 @@ public void setPlayer_updatesGetters() throws Exception { controller.addListener( new Player.Listener() { @Override - public void onPositionDiscontinuity( - PositionInfo oldPosition, - PositionInfo newPosition, - @Player.DiscontinuityReason int reason) { + public void onTimelineChanged( + Timeline timeline, @Player.TimelineChangeReason int reason) { currentPositionMsRef.set(controller.getCurrentPosition()); contentPositionMsRef.set(controller.getContentPosition()); durationMsRef.set(controller.getDuration()); @@ -1177,7 +1171,9 @@ public void onEvents(Player player, Player.Events events) { assertThat(onEventsCurrentMediaItemIndexRef.get()).isEqualTo(testMediaItemIndex); assertThat(currentPeriodIndexRef.get()).isEqualTo(testPeriodIndex); assertThat(onEventsCurrentPeriodIndexRef.get()).isEqualTo(testPeriodIndex); - assertThat(getEventsAsList(eventsRef.get())).contains(Player.EVENT_POSITION_DISCONTINUITY); + assertThat(getEventsAsList(eventsRef.get())) + .containsExactly( + EVENT_TIMELINE_CHANGED, EVENT_MEDIA_ITEM_TRANSITION, EVENT_PLAYBACK_STATE_CHANGED); } @Test @@ -1187,9 +1183,7 @@ public void onMediaItemTransition_mediaItemTransitionSeek_callbackCalledForReaso Timeline timeline = MediaTestUtils.createTimeline(/* windowCount= */ 5, /* buildWithUri= */ false); remoteSession.getMockPlayer().setTimeline(timeline); - remoteSession - .getMockPlayer() - .notifyTimelineChanged(Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + remoteSession.getMockPlayer().notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); remoteSession.getMockPlayer().setCurrentMediaItemIndex(currentIndex); remoteSession .getMockPlayer() @@ -1241,7 +1235,7 @@ public void onEvents(Player player, Player.Events events) { assertThat(mediaItemFromGetterRef.get()).isEqualTo(currentMediaItem); assertThat(mediaItemFromOnEventsRef.get()).isEqualTo(currentMediaItem); assertThat(reasonRef.get()).isEqualTo(testReason); - assertThat(getEventsAsList(eventsRef.get())).contains(Player.EVENT_MEDIA_ITEM_TRANSITION); + assertThat(getEventsAsList(eventsRef.get())).contains(EVENT_MEDIA_ITEM_TRANSITION); } @Test @@ -1283,7 +1277,7 @@ public void onMediaItemTransition( @Override public void onEvents(Player player, Player.Events events) { - if (events.contains(Player.EVENT_MEDIA_ITEM_TRANSITION)) { + if (events.contains(EVENT_MEDIA_ITEM_TRANSITION)) { eventsRef.set(events); mediaItemFromOnEventsRef.set(player.getCurrentMediaItem()); latch.countDown(); @@ -1293,9 +1287,7 @@ public void onEvents(Player player, Player.Events events) { remoteSession.getMockPlayer().setTimeline(timeline); remoteSession.getMockPlayer().setCurrentMediaItemIndex(/* index= */ 0); remoteSession.getMockPlayer().setCurrentPeriodIndex(/* index= */ 0); - remoteSession - .getMockPlayer() - .notifyTimelineChanged(Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + remoteSession.getMockPlayer().notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); assertThat(timelineLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); remoteSession.getMockPlayer().setCurrentMediaItemIndex(/* index= */ 1); remoteSession.getMockPlayer().setCurrentPeriodIndex(/* index= */ 1); @@ -1327,7 +1319,7 @@ public void onEvents(Player player, Player.Events events) { Player.DISCONTINUITY_REASON_AUTO_TRANSITION); assertThat(latch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); - assertThat(getEventsAsList(eventsRef.get())).contains(Player.EVENT_MEDIA_ITEM_TRANSITION); + assertThat(getEventsAsList(eventsRef.get())).contains(EVENT_MEDIA_ITEM_TRANSITION); assertThat(mediaItemFromParamRef.get()).isEqualTo(expectedMediaItemWithoutUri); assertThat(mediaItemFromGetterRef.get()).isEqualTo(expectedMediaItemWithoutUri); assertThat(mediaItemFromOnEventsRef.get()).isEqualTo(expectedMediaItemWithoutUri); @@ -1371,7 +1363,7 @@ public void onMediaItemTransition( @Override public void onEvents(Player player, Player.Events events) { - if (events.contains(Player.EVENT_MEDIA_ITEM_TRANSITION)) { + if (events.contains(EVENT_MEDIA_ITEM_TRANSITION)) { eventsRef.set(events); mediaItemFromOnEventsRef.set(player.getCurrentMediaItem()); latch.countDown(); @@ -1381,9 +1373,7 @@ public void onEvents(Player player, Player.Events events) { remoteSession.getMockPlayer().setTimeline(timeline); remoteSession.getMockPlayer().setCurrentMediaItemIndex(/* index= */ 0); remoteSession.getMockPlayer().setCurrentPeriodIndex(/* index= */ 0); - remoteSession - .getMockPlayer() - .notifyTimelineChanged(Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + remoteSession.getMockPlayer().notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); assertThat(timelineLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); remoteSession.getMockPlayer().setCurrentMediaItemIndex(/* index= */ 0); remoteSession.getMockPlayer().setCurrentPeriodIndex(/* index= */ 0); @@ -1421,7 +1411,7 @@ public void onEvents(Player player, Player.Events events) { assertThat(mediaItemFromGetterRef.get()).isEqualTo(expectedMediaItemWithoutUri); assertThat(mediaItemFromOnEventsRef.get()).isEqualTo(expectedMediaItemWithoutUri); assertThat(reasonRef.get()).isEqualTo(MEDIA_ITEM_TRANSITION_REASON_REPEAT); - assertThat(getEventsAsList(eventsRef.get())).contains(Player.EVENT_MEDIA_ITEM_TRANSITION); + assertThat(getEventsAsList(eventsRef.get())).contains(EVENT_MEDIA_ITEM_TRANSITION); } @Test @@ -1471,18 +1461,16 @@ public void onEvents(Player player, Player.Events events) { remoteSession.getMockPlayer().setTimeline(timeline); remoteSession.getMockPlayer().setCurrentMediaItemIndex(/* index= */ 0); remoteSession.getMockPlayer().setCurrentPeriodIndex(/* index= */ 0); - remoteSession - .getMockPlayer() - .notifyTimelineChanged(Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + remoteSession.getMockPlayer().notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); assertThat(timelineLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); - remoteSession.getMockPlayer().setCurrentMediaItemIndex(/* index= */ 0); - remoteSession.getMockPlayer().setCurrentPeriodIndex(/* index= */ 0); + remoteSession.getMockPlayer().setCurrentMediaItemIndex(/* index= */ 1); + remoteSession.getMockPlayer().setCurrentPeriodIndex(/* index= */ 1); MediaItem expectedMediaItemWithoutUri = createMediaItem("mediaId", /* buildWithUri= */ false); remoteSession .getMockPlayer() .notifyPositionDiscontinuity( - new PositionInfo( + /* oldPosition= */ new PositionInfo( /* windowUid= */ new Object(), /* mediaItemIndex= */ 0, mediaItem, @@ -1492,7 +1480,7 @@ public void onEvents(Player player, Player.Events events) { /* contentPositionMs= */ 10_000L, /* adGroupIndex= */ C.INDEX_UNSET, /* adIndexInAdGroup= */ C.INDEX_UNSET), - new PositionInfo( + /* newPosition= */ new PositionInfo( /* windowUid= */ new Object(), /* mediaItemIndex= */ 1, mediaItem, @@ -1509,7 +1497,125 @@ public void onEvents(Player player, Player.Events events) { assertThat(mediaItemFromGetterRef.get()).isEqualTo(expectedMediaItemWithoutUri); assertThat(mediaItemFromOnEventsRef.get()).isEqualTo(expectedMediaItemWithoutUri); assertThat(reasonRef.get()).isEqualTo(MEDIA_ITEM_TRANSITION_REASON_SEEK); - assertThat(getEventsAsList(eventsRef.get())).contains(Player.EVENT_MEDIA_ITEM_TRANSITION); + assertThat(getEventsAsList(eventsRef.get())).contains(EVENT_MEDIA_ITEM_TRANSITION); + } + + @Test + public void onMediaItemTransition_seekDiscontinuitySameItemWithEmptyTimeline_callbackNotCalled() + throws Exception { + MediaItem mediaItem2 = createMediaItem("mediaId2", /* buildWithUri= */ true); + Timeline timeline = + MediaTestUtils.createTimeline( + ImmutableList.of(createMediaItem("mediaId1", /* buildWithUri= */ true), mediaItem2)); + CountDownLatch timelineLatch = new CountDownLatch(1); + CountDownLatch expectedTransitionLatch = new CountDownLatch(1); + AtomicBoolean unexpectedTransitionDetected = new AtomicBoolean(false); + CountDownLatch discontinuityLatch = new CountDownLatch(2); + // Connect the controller before there are media items in the player. + MediaController controller = controllerTestRule.createController(remoteSession.getToken()); + threadTestRule + .getHandler() + .postAndSync( + () -> + controller.addListener( + new Player.Listener() { + @Override + public void onTimelineChanged( + Timeline timeline, @Player.TimelineChangeReason int reason) { + if (reason == TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) { + timelineLatch.countDown(); + } + } + + @Override + public void onMediaItemTransition( + @Nullable MediaItem mediaItem, + @Player.MediaItemTransitionReason int reason) { + if (reason == MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED) { + expectedTransitionLatch.countDown(); + return; + } + unexpectedTransitionDetected.set(true); + } + + @Override + public void onPositionDiscontinuity( + PositionInfo oldPosition, + PositionInfo newPosition, + @Player.DiscontinuityReason int reason) { + if (reason == DISCONTINUITY_REASON_SEEK) { + discontinuityLatch.countDown(); + } + } + })); + // Move to index 1 (initial state). + remoteSession.getMockPlayer().setCurrentMediaItemIndex(/* index= */ 1); + remoteSession.getMockPlayer().setCurrentPeriodIndex(/* index= */ 1); + // Set the timeline to support a call to setMediaItems(items, 1) + remoteSession.getMockPlayer().setTimeline(timeline); + // Trigger timeline change and media item transitions in a single listener iteration. + remoteSession.getMockPlayer().notifyTimelineChangedWithMediaItemTransition(); + // Wait for the timeline update. That overrides the new position as well that was 0 in the ctrl. + assertThat(timelineLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); + assertThat(expectedTransitionLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); + remoteSession.getMockPlayer().setCurrentPosition(20_000L); + + // Trigger seek discontinuities inside index 1. + remoteSession + .getMockPlayer() + .notifyPositionDiscontinuity( + /* oldPosition= */ new PositionInfo( + /* windowUid= */ new Object(), + /* mediaItemIndex= */ 1, + mediaItem2, + /* periodUid= */ new Object(), + /* periodIndex= */ 1, + /* positionMs= */ 10_000L, + /* contentPositionMs= */ 10_000L, + /* adGroupIndex= */ C.INDEX_UNSET, + /* adIndexInAdGroup= */ C.INDEX_UNSET), + /* newPosition= */ new PositionInfo( + /* windowUid= */ new Object(), + /* mediaItemIndex= */ 1, + mediaItem2, + /* periodUid= */ new Object(), + /* periodIndex= */ 1, + /* positionMs= */ 20_000L, + /* contentPositionMs= */ 20_000L, + /* adGroupIndex= */ C.INDEX_UNSET, + /* adIndexInAdGroup= */ C.INDEX_UNSET), + DISCONTINUITY_REASON_SEEK); + remoteSession.getMockPlayer().setCurrentPosition(30_000L); + // Trigger again to make sure we would see the media item transition in between. + remoteSession + .getMockPlayer() + .notifyPositionDiscontinuity( + /* oldPosition= */ new PositionInfo( + /* windowUid= */ new Object(), + /* mediaItemIndex= */ 1, + mediaItem2, + /* periodUid= */ new Object(), + /* periodIndex= */ 1, + /* positionMs= */ 20_000L, + /* contentPositionMs= */ 20_000L, + /* adGroupIndex= */ C.INDEX_UNSET, + /* adIndexInAdGroup= */ C.INDEX_UNSET), + /* newPosition= */ new PositionInfo( + /* windowUid= */ new Object(), + /* mediaItemIndex= */ 1, + mediaItem2, + /* periodUid= */ new Object(), + /* periodIndex= */ 1, + /* positionMs= */ 30_000L, + /* contentPositionMs= */ 30_000L, + /* adGroupIndex= */ C.INDEX_UNSET, + /* adIndexInAdGroup= */ C.INDEX_UNSET), + DISCONTINUITY_REASON_SEEK); + + // Wait for two discontinuities to be processed. + assertThat(discontinuityLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); + // Verify that media item transition was NOT called for reasons other than playlist change. + assertThat(unexpectedTransitionDetected.get()).isFalse(); } @Test @@ -1551,9 +1657,7 @@ public void onEvents(Player player, Player.Events events) { })); remoteSession.getMockPlayer().setTimeline(Timeline.EMPTY); - remoteSession - .getMockPlayer() - .notifyTimelineChanged(Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + remoteSession.getMockPlayer().notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); remoteSession .getMockPlayer() .notifyMediaItemTransition( @@ -1563,7 +1667,7 @@ public void onEvents(Player player, Player.Events events) { assertThat(mediaItemFromParamRef.get()).isNull(); assertThat(mediaItemFromGetterRef.get()).isNull(); assertThat(mediaItemOnEventsRef.get()).isNull(); - assertThat(getEventsAsList(eventsRef.get())).contains(Player.EVENT_MEDIA_ITEM_TRANSITION); + assertThat(getEventsAsList(eventsRef.get())).contains(EVENT_MEDIA_ITEM_TRANSITION); } /** This also tests {@link MediaController#getPlaybackParameters()}. */ @@ -1743,7 +1847,7 @@ public void onEvents(Player player, Player.Events events) { MediaTestUtils.assertMediaIdEquals(timeline, timelineFromGetterRef.get()); MediaTestUtils.assertMediaIdEquals(timeline, timelineFromOnEventsRef.get()); assertThat(reasonRef.get()).isEqualTo(reason); - assertThat(getEventsAsList(eventsRef.get())).contains(Player.EVENT_TIMELINE_CHANGED); + assertThat(getEventsAsList(eventsRef.get())).contains(EVENT_TIMELINE_CHANGED); } @Test @@ -1790,7 +1894,7 @@ public void onEvents(Player player, Player.Events events) { assertThat(timelineFromOnEventsRef.get().getWindow(i, window).mediaItem.mediaId) .isEqualTo(TestUtils.getMediaIdInFakeTimeline(i)); } - assertThat(getEventsAsList(eventsRef.get())).contains(Player.EVENT_TIMELINE_CHANGED); + assertThat(getEventsAsList(eventsRef.get())).contains(EVENT_TIMELINE_CHANGED); } @Test @@ -1822,9 +1926,7 @@ public void onEvents(Player player, Player.Events events) { threadTestRule.getHandler().postAndSync(() -> controller.addListener(listener)); remoteSession.getMockPlayer().setTimeline(Timeline.EMPTY); - remoteSession - .getMockPlayer() - .notifyTimelineChanged(Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + remoteSession.getMockPlayer().notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); assertThat(latch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); assertThat(timelineFromParamRef.get().getWindowCount()).isEqualTo(0); @@ -1833,7 +1935,7 @@ public void onEvents(Player player, Player.Events events) { assertThat(timelineFromGetterRef.get().getPeriodCount()).isEqualTo(0); assertThat(timelineFromOnEventsRef.get().getWindowCount()).isEqualTo(0); assertThat(timelineFromOnEventsRef.get().getPeriodCount()).isEqualTo(0); - assertThat(getEventsAsList(eventsRef.get())).contains(Player.EVENT_TIMELINE_CHANGED); + assertThat(getEventsAsList(eventsRef.get())).contains(EVENT_TIMELINE_CHANGED); } /** This also tests {@link MediaController#getPlaylistMetadata()}. */ @@ -2090,7 +2192,7 @@ public void onShuffleModeEnabledChanged() throws Exception { MediaTestUtils.createMediaItems(/* size= */ 3, /* buildWithUri= */ true), /* shuffledIndices= */ new int[] {0, 2, 1}); player.setTimeline(timeline); - player.notifyTimelineChanged(Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + player.notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); player.setCurrentMediaItemIndex(2); player.setCurrentPeriodIndex(2); player.setShuffleModeEnabled(false); @@ -2149,7 +2251,7 @@ public void onRepeatModeChanged() throws Exception { Timeline timeline = MediaTestUtils.createTimeline(/* windowCount= */ 3, /* buildWithUri= */ true); player.setTimeline(timeline); - player.notifyTimelineChanged(Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + player.notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); player.setCurrentMediaItemIndex(2); player.setCurrentPeriodIndex(2); player.setRepeatMode(Player.REPEAT_MODE_OFF); @@ -2935,12 +3037,19 @@ public void onPositionDiscontinuity_isNotified() throws Exception { @Player.DiscontinuityReason int testReason = Player.DISCONTINUITY_REASON_INTERNAL; MediaController controller = controllerTestRule.createController(remoteSession.getToken()); CountDownLatch latch = new CountDownLatch(2); + CountDownLatch timelineLatch = new CountDownLatch(/* count= */ 1); AtomicReference oldPositionRef = new AtomicReference<>(); AtomicReference newPositionRef = new AtomicReference<>(); AtomicInteger positionDiscontinuityReasonRef = new AtomicInteger(); AtomicReference eventsRef = new AtomicReference<>(); Player.Listener listener = new Player.Listener() { + + @Override + public void onTimelineChanged(Timeline timeline, int reason) { + timelineLatch.countDown(); + } + @Override public void onPositionDiscontinuity( PositionInfo oldPosition, @@ -2954,11 +3063,23 @@ public void onPositionDiscontinuity( @Override public void onEvents(Player player, Player.Events events) { - eventsRef.set(events); - latch.countDown(); + if (events.contains(Player.EVENT_POSITION_DISCONTINUITY)) { + // Count down only after the discontinuity event. + eventsRef.set(events); + latch.countDown(); + } } }; threadTestRule.getHandler().postAndSync(() -> controller.addListener(listener)); + // Send down and await a timeline first. Discontinuity events are only emitted when the timeline + // is not empty. + remoteSession + .getMockPlayer() + .setTimeline(MediaTestUtils.createTimeline(/* windowCount= */ 4, /* buildWithUri= */ true)); + remoteSession.getMockPlayer().notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + assertThat(timelineLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); + remoteSession.getMockPlayer().setCurrentMediaItemIndex(/* index= */ 3); + remoteSession.getMockPlayer().setCurrentPeriodIndex(/* index= */ 3); remoteSession .getMockPlayer() @@ -2969,7 +3090,8 @@ public void onEvents(Player player, Player.Events events) { assertThat(oldPositionRef.get()).isEqualTo(testOldPosition); assertThat(newPositionRef.get()).isEqualTo(testNewPosition); assertThat(getEventsAsList(eventsRef.get())) - .containsExactly(Player.EVENT_POSITION_DISCONTINUITY); + .containsExactly(Player.EVENT_MEDIA_ITEM_TRANSITION, Player.EVENT_POSITION_DISCONTINUITY) + .inOrder(); } @Test @@ -2997,8 +3119,8 @@ public void onPositionDiscontinuity_updatesGetters() throws Exception { testContentPositionMs, testCurrentAdGroupIndex, testCurrentAdIndexInAdGroup); - MediaController controller = controllerTestRule.createController(remoteSession.getToken()); + CountDownLatch timelineLatch = new CountDownLatch(1); CountDownLatch latch = new CountDownLatch(2); AtomicLong currentPositionMsRef = new AtomicLong(); AtomicLong contentPositionMsRef = new AtomicLong(); @@ -3015,6 +3137,12 @@ public void onPositionDiscontinuity_updatesGetters() throws Exception { AtomicReference eventsRef = new AtomicReference<>(); Player.Listener listener = new Player.Listener() { + + @Override + public void onTimelineChanged(Timeline timeline, int reason) { + timelineLatch.countDown(); + } + @Override public void onPositionDiscontinuity( PositionInfo oldPosition, @@ -3037,13 +3165,22 @@ public void onPositionDiscontinuity( @Override public void onEvents(Player player, Player.Events events) { - eventsRef.set(events); - latch.countDown(); + if (events.contains(Player.EVENT_POSITION_DISCONTINUITY)) { + // Count down only after the discontinuity event. + eventsRef.set(events); + latch.countDown(); + } } }; threadTestRule.getHandler().postAndSync(() -> controller.addListener(listener)); - RemoteMockPlayer remoteMockPlayer = remoteSession.getMockPlayer(); + // We need to set an initial non-empty timeline and await the timeline changed or the + // discontinuity event will not be emited. + remoteMockPlayer.setTimeline( + new PlaylistTimeline( + ImmutableList.of(new MediaItem.Builder().setUri("http://example.com").build()))); + remoteMockPlayer.notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + assertThat(timelineLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); remoteMockPlayer.setCurrentPosition(testCurrentPositionMs); remoteMockPlayer.setContentPosition(testContentPositionMs); remoteMockPlayer.setDuration(testDurationMs); @@ -3056,6 +3193,7 @@ public void onEvents(Player player, Player.Events events) { remoteMockPlayer.setIsPlayingAd(testIsPlayingAd); remoteMockPlayer.setCurrentAdGroupIndex(testCurrentAdGroupIndex); remoteMockPlayer.setCurrentAdIndexInAdGroup(testCurrentAdIndexInAdGroup); + remoteMockPlayer.notifyPositionDiscontinuity( /* oldPosition= */ SessionPositionInfo.DEFAULT_POSITION_INFO, newPositionInfo, @@ -3074,8 +3212,7 @@ public void onEvents(Player player, Player.Events events) { assertThat(isPlayingAdRef.get()).isEqualTo(testIsPlayingAd); assertThat(currentAdGroupIndexRef.get()).isEqualTo(testCurrentAdGroupIndex); assertThat(currentAdIndexInAdGroupRef.get()).isEqualTo(testCurrentAdIndexInAdGroup); - assertThat(getEventsAsList(eventsRef.get())) - .containsExactly(Player.EVENT_POSITION_DISCONTINUITY); + assertThat(getEventsAsList(eventsRef.get())).contains(Player.EVENT_POSITION_DISCONTINUITY); } /** This also tests {@link MediaController#getAvailableSessionCommands()}. */ @@ -3109,6 +3246,67 @@ public void onAvailableSessionCommandsChanged( assertThat(sessionCommandsFromGetterRef.get()).isEqualTo(commands); } + @Test + public void onPositionDiscontinuity_seekToWithEmptyTimeline_emitsPositionDiscontinuityEvent() + throws Exception { + PositionInfo testOldPosition = + new PositionInfo( + /* windowUid= */ null, + /* mediaItemIndex= */ 0, + new MediaItem.Builder().setMediaId("media-id").build(), + /* periodUid= */ null, + /* periodIndex= */ 0, + /* positionMs= */ 0L, + /* contentPositionMs= */ 0L, + /* adGroupIndex= */ C.INDEX_UNSET, + /* adIndexInAdGroup= */ C.INDEX_UNSET); + PositionInfo testNewPosition = + new PositionInfo( + /* windowUid= */ null, + /* mediaItemIndex= */ 0, + new MediaItem.Builder().setMediaId("media-id").build(), + /* periodUid= */ null, + /* periodIndex= */ 0, + /* positionMs= */ 10L, + /* contentPositionMs= */ 10L, + /* adGroupIndex= */ C.INDEX_UNSET, + /* adIndexInAdGroup= */ C.INDEX_UNSET); + MediaController controller = controllerTestRule.createController(remoteSession.getToken()); + CountDownLatch latch = new CountDownLatch(1); + AtomicReference oldPositionRef = new AtomicReference<>(); + AtomicReference newPositionRef = new AtomicReference<>(); + AtomicInteger positionDiscontinuityReasonRef = new AtomicInteger(); + threadTestRule + .getHandler() + .postAndSync( + () -> + controller.addListener( + new Player.Listener() { + + @Override + public void onPositionDiscontinuity( + PositionInfo oldPosition, + PositionInfo newPosition, + @Player.DiscontinuityReason int reason) { + oldPositionRef.set(oldPosition); + newPositionRef.set(newPosition); + positionDiscontinuityReasonRef.set(reason); + latch.countDown(); + } + })); + remoteSession.getMockPlayer().setCurrentMediaItemIndex(/* index= */ 3); + remoteSession.getMockPlayer().setCurrentPeriodIndex(/* index= */ 3); + + remoteSession + .getMockPlayer() + .notifyPositionDiscontinuity(testOldPosition, testNewPosition, DISCONTINUITY_REASON_SEEK); + + assertThat(latch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); + assertThat(positionDiscontinuityReasonRef.get()).isEqualTo(DISCONTINUITY_REASON_SEEK); + assertThat(oldPositionRef.get()).isEqualTo(testOldPosition); + assertThat(newPositionRef.get()).isEqualTo(testNewPosition); + } + /** This also tests {@link MediaController#getAvailableCommands()}. */ @Test public void onAvailableCommandsChanged_isCalledByPlayerChange() throws Exception { @@ -3196,7 +3394,7 @@ public void onEvents(Player player, Player.Events events) { assertThat(eventsList).hasSize(2); assertThat(getEventsAsList(eventsList.get(0))) .containsExactly(EVENT_AVAILABLE_COMMANDS_CHANGED); - assertThat(getEventsAsList(eventsList.get(1))).containsExactly(Player.EVENT_TIMELINE_CHANGED); + assertThat(getEventsAsList(eventsList.get(1))).containsExactly(EVENT_TIMELINE_CHANGED); } @Test @@ -3244,7 +3442,7 @@ public void onEvents(Player player, Player.Events events) { assertThat(eventsList).hasSize(2); assertThat(getEventsAsList(eventsList.get(0))) .containsExactly(EVENT_AVAILABLE_COMMANDS_CHANGED); - assertThat(getEventsAsList(eventsList.get(1))).containsExactly(Player.EVENT_TIMELINE_CHANGED); + assertThat(getEventsAsList(eventsList.get(1))).containsExactly(EVENT_TIMELINE_CHANGED); } /** This also tests {@link MediaController#getAvailableCommands()}. */ @@ -4739,7 +4937,7 @@ public void onTimelineChanged(Timeline timeline, int reason) { assertThat(discontinuityReceived).isTrue(); assertThat(receivedNewPosition.get().mediaItemIndex).isEqualTo(targetIndex); - remotePlayer.notifyTimelineChanged(Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + remotePlayer.notifyTimelineChanged(TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); boolean timelineReceived = timelineLatch.await(TIMEOUT_MS, MILLISECONDS); assertThat(timelineReceived).isTrue(); assertThat(receivedTimeline.get().getWindowCount()).isEqualTo(newTimelineSize); diff --git a/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaSessionTest.java b/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaSessionTest.java index 0964485c3af..652d70445e9 100644 --- a/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaSessionTest.java +++ b/libraries/test_session_current/src/androidTest/java/androidx/media3/session/MediaSessionTest.java @@ -25,7 +25,10 @@ import static android.view.KeyEvent.KEYCODE_MEDIA_PREVIOUS; import static android.view.KeyEvent.KEYCODE_MEDIA_REWIND; import static android.view.KeyEvent.KEYCODE_MEDIA_STOP; +import static androidx.media3.common.Player.DISCONTINUITY_REASON_SEEK; +import static androidx.media3.common.Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED; import static androidx.media3.common.Player.STATE_IDLE; +import static androidx.media3.common.Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED; import static androidx.media3.test.session.common.TestUtils.LONG_TIMEOUT_MS; import static androidx.media3.test.session.common.TestUtils.TIMEOUT_MS; import static androidx.test.core.app.ApplicationProvider.getApplicationContext; @@ -47,12 +50,18 @@ import android.os.SystemClock; import android.text.TextUtils; import android.view.KeyEvent; +import androidx.annotation.Nullable; import androidx.media.MediaSessionManager; +import androidx.media3.common.C; import androidx.media3.common.ForwardingPlayer; +import androidx.media3.common.MediaItem; import androidx.media3.common.MediaLibraryInfo; import androidx.media3.common.Player; +import androidx.media3.common.Player.PositionInfo; import androidx.media3.common.Timeline; import androidx.media3.common.util.Log; +import androidx.media3.exoplayer.ExoPlayer; +import androidx.media3.exoplayer.source.SilenceMediaSource; import androidx.media3.session.MediaSession.ControllerInfo; import androidx.media3.test.session.common.HandlerThreadTestRule; import androidx.media3.test.session.common.MainLooperTestRule; @@ -63,6 +72,7 @@ import androidx.test.filters.LargeTest; import androidx.test.filters.SdkSuppress; import androidx.test.platform.app.InstrumentationRegistry; +import com.google.common.collect.ImmutableList; import com.google.common.util.concurrent.FutureCallback; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; @@ -1297,6 +1307,118 @@ public void testGetBitmapDimensionLimit() { assertThat(limit).isAtMost(4096); } + @Test + public void setMediaItems_withMediaItemIndexNotZero_silentPositionUpdateOnTimelineChange() + throws Exception { + AtomicReference player = new AtomicReference<>(); + try { + player.set( + new ExoPlayer.Builder(ApplicationProvider.getApplicationContext()) + .setLooper(handler.getLooper()) + .build()); + MediaSession testSession = + sessionTestRule.ensureReleaseAfterTest( + new MediaSession.Builder(context, player.get()) + .setId("setMediaItems_withMediaItemIndexNotZero_") + .build()); + CountDownLatch disconnectedLatch = new CountDownLatch(1); + MediaController testController = + new MediaController.Builder(context, testSession.getToken()) + .setListener( + new MediaController.Listener() { + @Override + public void onDisconnected(MediaController controller) { + disconnectedLatch.countDown(); + } + }) + .setApplicationLooper(handler.getLooper()) + .buildAsync() + .get(TIMEOUT_MS, MILLISECONDS); + assertThat(testController.isConnected()).isTrue(); + CountDownLatch timelineLatch = new CountDownLatch(/* count= */ 1); + CountDownLatch discontinuityLatch = new CountDownLatch(/* count= */ 2); + CountDownLatch expectedMediaItemTransitionLatch = new CountDownLatch(/* count= */ 1); + AtomicBoolean unexpectedMediaItemTransitionCall = new AtomicBoolean(false); + List discontinuityMediaItemIndices = new ArrayList<>(); + List discontinuityReasons = new ArrayList<>(); + List transitionReasons = new ArrayList<>(); + handler.postAndSync( + () -> { + testController.addListener( + new Player.Listener() { + @Override + public void onTimelineChanged( + Timeline timeline, @Player.TimelineChangeReason int reason) { + if (reason == TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED) { + timelineLatch.countDown(); + } + } + + @Override + public void onMediaItemTransition( + @Nullable MediaItem mediaItem, @Player.MediaItemTransitionReason int reason) { + transitionReasons.add(reason); + if (reason == MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED) { + expectedMediaItemTransitionLatch.countDown(); + return; + } + unexpectedMediaItemTransitionCall.set(true); + } + + @Override + public void onPositionDiscontinuity( + PositionInfo oldPosition, + PositionInfo newPosition, + @Player.DiscontinuityReason int reason) { + discontinuityReasons.add(reason); + discontinuityMediaItemIndices.add(oldPosition.mediaItemIndex); + discontinuityMediaItemIndices.add(newPosition.mediaItemIndex); + if (reason == DISCONTINUITY_REASON_SEEK) { + discontinuityLatch.countDown(); + } + } + }); + }); + // Set the media source with start position that triggers the initial events. + handler.postAndSync( + () -> { + SilenceMediaSource silenceMediaSource1 = + new SilenceMediaSource(/* durationUs= */ 10_000_000L); + SilenceMediaSource silenceMediaSource2 = + new SilenceMediaSource(/* durationUs= */ 20_000_000L); + player + .get() + .setMediaSources( + ImmutableList.of(silenceMediaSource1, silenceMediaSource2), + /* startMediaItemIndex= */ 1, + /* startPositionMs= */ C.TIME_UNSET); + }); + assertThat(timelineLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); + assertThat(expectedMediaItemTransitionLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); + assertThat(discontinuityMediaItemIndices).isEmpty(); + assertThat(unexpectedMediaItemTransitionCall.get()).isFalse(); + + // No media item transition because the media item index was silently updated. + handler.postAndSync( + () -> { + player.get().seekTo(/* mediaItemIndex= */ 1, /* positionMs= */ 2_000L); + }); + handler.postAndSync( + () -> { + player.get().seekTo(/* mediaItemIndex= */ 1, /* positionMs= */ 10_000_000L); + }); + + assertThat(discontinuityLatch.await(TIMEOUT_MS, MILLISECONDS)).isTrue(); + assertThat(unexpectedMediaItemTransitionCall.get()).isFalse(); + assertThat(transitionReasons).containsExactly(MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED); + assertThat(discontinuityMediaItemIndices).containsExactly(1, 1, 1, 1); + assertThat(discontinuityReasons) + .containsExactly(DISCONTINUITY_REASON_SEEK, DISCONTINUITY_REASON_SEEK); + } finally { + threadTestRule.getHandler().postAndSync(() -> player.get().release()); + } + } + /** * Returns the expected {@link MediaSessionManager.RemoteUserInfo#getPackageName()} of a * controller hosted in the test companion app. diff --git a/libraries/test_session_current/src/main/java/androidx/media3/session/MediaSessionProviderService.java b/libraries/test_session_current/src/main/java/androidx/media3/session/MediaSessionProviderService.java index 55be276beac..11a957dc6dc 100644 --- a/libraries/test_session_current/src/main/java/androidx/media3/session/MediaSessionProviderService.java +++ b/libraries/test_session_current/src/main/java/androidx/media3/session/MediaSessionProviderService.java @@ -108,6 +108,7 @@ import androidx.media3.common.Player.DiscontinuityReason; import androidx.media3.common.Player.PositionInfo; import androidx.media3.common.Timeline; +import androidx.media3.common.Timeline.Window; import androidx.media3.common.TrackGroup; import androidx.media3.common.TrackSelectionParameters; import androidx.media3.common.Tracks; @@ -1460,6 +1461,24 @@ public void notifyTimelineChanged(String sessionId, @Player.TimelineChangeReason }); } + @Override + public void notifyTimelineChangedWithMediaItemTransition(String sessionId) + throws RemoteException { + runOnHandler( + () -> { + MediaSession session = sessionMap.get(sessionId); + MockPlayer player = (MockPlayer) session.getPlayer(); + player.notifyTimelineChanged(Player.TIMELINE_CHANGE_REASON_PLAYLIST_CHANGED); + MediaItem mediaItem = null; + if (player.currentMediaItemIndex < player.timeline.getWindowCount()) { + mediaItem = + player.timeline.getWindow(player.currentMediaItemIndex, new Window()).mediaItem; + } + player.notifyMediaItemTransition( + mediaItem, Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED); + }); + } + @Override public void notifyPlaylistMetadataChanged(String sessionId) throws RemoteException { runOnHandler( diff --git a/libraries/test_session_current/src/main/java/androidx/media3/session/MockMediaLibraryService.java b/libraries/test_session_current/src/main/java/androidx/media3/session/MockMediaLibraryService.java index e5023ed4000..20d40bd38b2 100644 --- a/libraries/test_session_current/src/main/java/androidx/media3/session/MockMediaLibraryService.java +++ b/libraries/test_session_current/src/main/java/androidx/media3/session/MockMediaLibraryService.java @@ -66,6 +66,7 @@ import static androidx.media3.test.session.common.MediaBrowserConstants.SUBSCRIBE_PARENT_ID_2; import static androidx.media3.test.session.common.MediaSessionConstants.CONNECTION_HINT_KEY_ASYNC_CONNECTION_DELAY_MS; import static androidx.media3.test.session.common.MediaSessionConstants.CONNECTION_HINT_KEY_ASYNC_CONNECTION_REJECT_DELAY_MS; +import static androidx.media3.test.session.common.MediaSessionConstants.CONNECTION_HINT_KEY_ASYNC_LIBRARY_ROOT_DELAY_MS; import static androidx.media3.test.session.common.MediaSessionConstants.EXTRA_KEY_ASYNC_CONNECTION_CONFIRMATION; import static androidx.media3.test.session.common.MediaSessionConstants.KEY_CONTROLLER; import static com.google.common.util.concurrent.Futures.immediateFuture; @@ -400,6 +401,16 @@ public ListenableFuture> onGetLibraryRoot( rootExtras.putBoolean(EXTRA_KEY_ASYNC_CONNECTION_CONFIRMATION, true); rootParams = new LibraryParams.Builder().setExtras(rootExtras).build(); } + if (params != null + && params.extras.containsKey(CONNECTION_HINT_KEY_ASYNC_LIBRARY_ROOT_DELAY_MS)) { + long delayMs = params.extras.getLong(CONNECTION_HINT_KEY_ASYNC_LIBRARY_ROOT_DELAY_MS); + SettableFuture> future = SettableFuture.create(); + MediaItem finalRootItem = rootItem; + LibraryParams finalRootParams = rootParams; + handler.postDelayed( + () -> future.set(LibraryResult.ofItem(finalRootItem, finalRootParams)), delayMs); + return future; + } return immediateFuture(LibraryResult.ofItem(rootItem, rootParams)); } diff --git a/libraries/test_session_current/src/main/java/androidx/media3/session/RemoteMediaSession.java b/libraries/test_session_current/src/main/java/androidx/media3/session/RemoteMediaSession.java index 5c48e247c50..bb69768108b 100644 --- a/libraries/test_session_current/src/main/java/androidx/media3/session/RemoteMediaSession.java +++ b/libraries/test_session_current/src/main/java/androidx/media3/session/RemoteMediaSession.java @@ -447,6 +447,10 @@ public void notifyTimelineChanged(@Player.TimelineChangeReason int reason) binder.notifyTimelineChanged(sessionId, reason); } + public void notifyTimelineChangedWithMediaItemTransition() throws RemoteException { + binder.notifyTimelineChangedWithMediaItemTransition(sessionId); + } + public void notifyPlaylistMetadataChanged() throws RemoteException { binder.notifyPlaylistMetadataChanged(sessionId); } diff --git a/libraries/test_utils/src/main/java/androidx/media3/test/utils/EditedMediaItemAssetInfo.java b/libraries/test_utils/src/main/java/androidx/media3/test/utils/EditedMediaItemAssetInfo.java index d9854506644..237118a8828 100644 --- a/libraries/test_utils/src/main/java/androidx/media3/test/utils/EditedMediaItemAssetInfo.java +++ b/libraries/test_utils/src/main/java/androidx/media3/test/utils/EditedMediaItemAssetInfo.java @@ -325,7 +325,7 @@ public long getNextSpeedChangeTimeUs(long timeUs) { @Nullable public final Format videoFormat; /** Descriptive name of the asset configuration. */ - public final String name; + private final String name; private EditedMediaItemAssetInfo(Builder builder) { this.editedMediaItem = checkNotNull(builder.editedMediaItem); diff --git a/libraries/test_utils/src/main/java/androidx/media3/test/utils/ExoHostedTest.java b/libraries/test_utils/src/main/java/androidx/media3/test/utils/ExoHostedTest.java index 8e2823a1e37..07891897a4a 100644 --- a/libraries/test_utils/src/main/java/androidx/media3/test/utils/ExoHostedTest.java +++ b/libraries/test_utils/src/main/java/androidx/media3/test/utils/ExoHostedTest.java @@ -23,7 +23,6 @@ import android.widget.FrameLayout; import androidx.annotation.Nullable; import androidx.annotation.Size; -import androidx.media3.common.MediaLibraryInfo; import androidx.media3.common.PlaybackException; import androidx.media3.common.Player; import androidx.media3.common.util.Clock; @@ -48,12 +47,6 @@ @UnstableApi public abstract class ExoHostedTest implements HostedTest { - static { - // Disable all device and codec-specific workarounds, since we're interested in testing that the - // underlying platform is behaving correctly. - MediaLibraryInfo.setEnableWorkarounds(false); - } - public static final long MAX_PLAYING_TIME_DISCREPANCY_MS = 5000; public static final long EXPECTED_PLAYING_TIME_MEDIA_DURATION_MS = -2; public static final long EXPECTED_PLAYING_TIME_UNSET = -1; diff --git a/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeAdaptiveMediaPeriod.java b/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeAdaptiveMediaPeriod.java index ba1d80f5c75..313363722e3 100644 --- a/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeAdaptiveMediaPeriod.java +++ b/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeAdaptiveMediaPeriod.java @@ -45,7 +45,6 @@ import androidx.media3.exoplayer.upstream.Allocator; import androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicy; import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableMap; import com.google.common.collect.Lists; import java.io.IOException; import java.util.ArrayList; @@ -109,7 +108,9 @@ public void release() { @Override public void prepare(Callback callback, long positionUs) { mediaSourceEventDispatcher.loadStarted( - new LoadEventInfo(fakePreparationLoadTaskId, FAKE_DATA_SPEC, SystemClock.elapsedRealtime()), + new LoadEventInfo.Builder( + fakePreparationLoadTaskId, FAKE_DATA_SPEC, SystemClock.elapsedRealtime()) + .build(), C.DATA_TYPE_MEDIA, C.TRACK_TYPE_UNKNOWN, /* trackFormat= */ null, @@ -122,14 +123,10 @@ public void prepare(Callback callback, long positionUs) { prepared = true; Util.castNonNull(this.callback).onPrepared(this); mediaSourceEventDispatcher.loadCompleted( - new LoadEventInfo( - fakePreparationLoadTaskId, - FAKE_DATA_SPEC, - FAKE_DATA_SPEC.uri, - /* responseHeaders= */ ImmutableMap.of(), - SystemClock.elapsedRealtime(), - /* loadDurationMs= */ 0, - /* bytesLoaded= */ 100), + new LoadEventInfo.Builder( + fakePreparationLoadTaskId, FAKE_DATA_SPEC, SystemClock.elapsedRealtime()) + .setBytesLoaded(100) + .build(), C.DATA_TYPE_MEDIA, C.TRACK_TYPE_UNKNOWN, /* trackFormat= */ null, diff --git a/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeExoMediaDrm.java b/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeExoMediaDrm.java index ac62383abfc..d7cdc34b5f8 100644 --- a/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeExoMediaDrm.java +++ b/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeExoMediaDrm.java @@ -602,14 +602,10 @@ public Response executeProvisionRequest(UUID uuid, ProvisionRequest request) if (Arrays.equals(request.getData(), FAKE_PROVISION_REQUEST.getData())) { return new Response.Builder(Bytes.toArray(VALID_PROVISION_RESPONSE)) .setLoadEventInfo( - new LoadEventInfo( - /* loadTaskId= */ -1, - new DataSpec(uri), - uri, - /* responseHeaders= */ ImmutableMap.of(), - SystemClock.elapsedRealtime(), - /* loadDurationMs= */ 0, - /* bytesLoaded= */ VALID_PROVISION_RESPONSE.size())) + new LoadEventInfo.Builder( + /* loadTaskId= */ -1, new DataSpec(uri), SystemClock.elapsedRealtime()) + .setBytesLoaded(VALID_PROVISION_RESPONSE.size()) + .build()) .build(); } else { return new Response(Util.EMPTY_BYTE_ARRAY); @@ -636,14 +632,10 @@ public Response executeKeyRequest(UUID uuid, KeyRequest request) Uri uri = Uri.parse(request.getLicenseServerUrl()); return new Response.Builder(Bytes.toArray(response)) .setLoadEventInfo( - new LoadEventInfo( - /* loadTaskId= */ -1, - new DataSpec(uri), - uri, - /* responseHeaders= */ ImmutableMap.of(), - SystemClock.elapsedRealtime(), - /* loadDurationMs= */ 0, - /* bytesLoaded= */ response.size())) + new LoadEventInfo.Builder( + /* loadTaskId= */ -1, new DataSpec(uri), SystemClock.elapsedRealtime()) + .setBytesLoaded(response.size()) + .build()) .build(); } diff --git a/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaChunk.java b/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaChunk.java index 6a1bb6be839..adbede9c65a 100644 --- a/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaChunk.java +++ b/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaChunk.java @@ -63,7 +63,8 @@ public FakeMediaChunk( /* trackSelectionData= */ null, startTimeUs, endTimeUs, - /* chunkIndex= */ 0); + /* chunkIndex= */ 0, + /* steeredPathwayId= */ null); } @Override diff --git a/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaPeriod.java b/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaPeriod.java index 2aa61f39dbb..348df5b75c4 100644 --- a/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaPeriod.java +++ b/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaPeriod.java @@ -52,7 +52,6 @@ import com.google.common.math.DoubleMath; import java.io.IOException; import java.math.RoundingMode; -import java.util.Collections; import java.util.List; import java.util.Set; @@ -304,7 +303,9 @@ public void release() { @Override public synchronized void prepare(Callback callback, long positionUs) { mediaSourceEventDispatcher.loadStarted( - new LoadEventInfo(fakePreparationLoadTaskId, FAKE_DATA_SPEC, SystemClock.elapsedRealtime()), + new LoadEventInfo.Builder( + fakePreparationLoadTaskId, FAKE_DATA_SPEC, SystemClock.elapsedRealtime()) + .build(), C.DATA_TYPE_MEDIA, C.TRACK_TYPE_UNKNOWN, /* trackFormat= */ null, @@ -518,14 +519,10 @@ private void finishPreparation() { prepared = true; Util.castNonNull(prepareCallback).onPrepared(this); mediaSourceEventDispatcher.loadCompleted( - new LoadEventInfo( - fakePreparationLoadTaskId, - FAKE_DATA_SPEC, - FAKE_DATA_SPEC.uri, - /* responseHeaders= */ Collections.emptyMap(), - SystemClock.elapsedRealtime(), - /* loadDurationMs= */ 0, - /* bytesLoaded= */ 100), + new LoadEventInfo.Builder( + fakePreparationLoadTaskId, FAKE_DATA_SPEC, SystemClock.elapsedRealtime()) + .setBytesLoaded(100) + .build(), C.DATA_TYPE_MEDIA, C.TRACK_TYPE_UNKNOWN, /* trackFormat= */ null, diff --git a/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaSource.java b/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaSource.java index 46ccca97add..bb84bc682ed 100644 --- a/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaSource.java +++ b/libraries/test_utils/src/main/java/androidx/media3/test/utils/FakeMediaSource.java @@ -49,7 +49,6 @@ import androidx.media3.exoplayer.source.TrackGroupArray; import androidx.media3.exoplayer.upstream.Allocator; import androidx.media3.test.utils.FakeMediaPeriod.TrackDataFactory; -import com.google.common.collect.ImmutableMap; import com.google.common.collect.Iterables; import com.google.common.collect.ObjectArrays; import com.google.errorprone.annotations.CanIgnoreReturnValue; @@ -577,25 +576,13 @@ private void finishSourcePreparation(boolean sendManifestLoadEvents) { createEventDispatcher(/* mediaPeriodId= */ null); long loadTaskId = LoadEventInfo.getNewId(); eventDispatcher.loadStarted( - new LoadEventInfo( - loadTaskId, - FAKE_DATA_SPEC, - FAKE_DATA_SPEC.uri, - /* responseHeaders= */ ImmutableMap.of(), - elapsedRealTimeMs, - /* loadDurationMs= */ 0, - /* bytesLoaded= */ 0), + new LoadEventInfo.Builder(loadTaskId, FAKE_DATA_SPEC, elapsedRealTimeMs).build(), mediaLoadData, /* retryCount= */ 0); eventDispatcher.loadCompleted( - new LoadEventInfo( - loadTaskId, - FAKE_DATA_SPEC, - FAKE_DATA_SPEC.uri, - /* responseHeaders= */ ImmutableMap.of(), - elapsedRealTimeMs, - /* loadDurationMs= */ 0, - /* bytesLoaded= */ MANIFEST_LOAD_BYTES), + new LoadEventInfo.Builder(loadTaskId, FAKE_DATA_SPEC, elapsedRealTimeMs) + .setBytesLoaded(MANIFEST_LOAD_BYTES) + .build(), mediaLoadData); } } diff --git a/libraries/test_utils/src/main/java/androidx/media3/test/utils/InMemoryDatabaseRule.java b/libraries/test_utils/src/main/java/androidx/media3/test/utils/InMemoryDatabaseRule.java index 8f38801e02e..1739cb53ebe 100644 --- a/libraries/test_utils/src/main/java/androidx/media3/test/utils/InMemoryDatabaseRule.java +++ b/libraries/test_utils/src/main/java/androidx/media3/test/utils/InMemoryDatabaseRule.java @@ -15,6 +15,8 @@ */ package androidx.media3.test.utils; +import static com.google.common.base.StandardSystemProperty.JAVA_IO_TMPDIR; + import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import androidx.media3.common.util.UnstableApi; @@ -22,6 +24,7 @@ import androidx.media3.database.DefaultDatabaseProvider; import androidx.media3.datasource.cache.NoOpCacheEvictor; import androidx.media3.datasource.cache.SimpleCache; +import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.List; @@ -51,8 +54,27 @@ private InMemoryDatabaseRule(RuleImpl ruleImpl, RuleChain ruleChain) { public static InMemoryDatabaseRule create() { TemporaryFolder temporaryFolder = new TemporaryFolder(); RuleImpl ruleImpl = new RuleImpl(temporaryFolder); + ExternalResource tmpDirSetupResource = + new ExternalResource() { + @Override + protected void before() throws Throwable { + // On some Android environments, particularly physical devices on clean runs, the + // directory returned by JAVA_IO_TMPDIR may not exist, causing issues with + // TemporaryFolder. + String tmpDirProperty = JAVA_IO_TMPDIR.value(); + if (tmpDirProperty != null) { + File tmpDir = new File(tmpDirProperty); + if (!tmpDir.exists()) { + if (!tmpDir.mkdirs()) { + throw new IOException("Failed to create java.io.tmpdir: " + tmpDir); + } + } + } + } + }; return new InMemoryDatabaseRule( - ruleImpl, RuleChain.outerRule(temporaryFolder).around(ruleImpl)); + ruleImpl, + RuleChain.outerRule(tmpDirSetupResource).around(temporaryFolder).around(ruleImpl)); } @Override diff --git a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/AndroidTestUtil.java b/libraries/transformer/src/androidTest/java/androidx/media3/transformer/AndroidTestUtil.java index bd2bd6cbfe4..9c5ac5280bd 100644 --- a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/AndroidTestUtil.java +++ b/libraries/transformer/src/androidTest/java/androidx/media3/transformer/AndroidTestUtil.java @@ -46,6 +46,8 @@ import androidx.media3.common.util.GlUtil; import androidx.media3.common.util.NullableType; import androidx.media3.common.util.Size; +import androidx.media3.common.util.ThrowingRunnable; +import androidx.media3.common.util.Util; import androidx.media3.effect.ByteBufferGlEffect; import androidx.media3.effect.DefaultGlObjectsProvider; import androidx.media3.effect.GlEffect; @@ -176,7 +178,7 @@ public VideoGraph create( } /** Runs the given task and blocks until it completes, or timeoutSeconds has elapsed. */ - public static void runAsyncTaskAndWait(ThrowingRunnable task, int timeoutSeconds) + public static void runAsyncTaskAndWait(ThrowingRunnable task, int timeoutSeconds) throws TimeoutException, InterruptedException { CountDownLatch countDownLatch = new CountDownLatch(1); AtomicReference<@NullableType Exception> unexpectedExceptionReference = @@ -260,11 +262,6 @@ protected boolean shouldDropBuffersToKeyframe( } } - /** A type that can be used to succinctly wrap throwing {@link Runnable} objects. */ - public interface ThrowingRunnable { - void run() throws Exception; - } - /** * Creates the GL objects needed to set up a GL environment including an {@link EGLDisplay} and an * {@link EGLContext}. @@ -377,6 +374,11 @@ public Codec createForVideoEncoding(Format format, @Nullable LogSessionId logSes return encoderFactory.createForVideoEncoding(format, logSessionId); } + @Override + public boolean isVideoFormatSupported(Format format) { + return encoderFactory.isVideoFormatSupported(format); + } + @Override public boolean audioNeedsEncoding() { return true; diff --git a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/CompositionPlayerDefaultGlFrameProcessorTest.java b/libraries/transformer/src/androidTest/java/androidx/media3/transformer/CompositionPlayerDefaultGlFrameProcessorTest.java deleted file mode 100644 index 452b549c57f..00000000000 --- a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/CompositionPlayerDefaultGlFrameProcessorTest.java +++ /dev/null @@ -1,212 +0,0 @@ -/* - * Copyright 2026 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 - * - * https://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 androidx.media3.transformer; - -import static androidx.media3.common.Player.STATE_ENDED; -import static androidx.media3.common.util.Util.isRunningOnEmulator; -import static androidx.media3.test.utils.AssetInfo.MP4_ASSET_WITH_INCREASING_TIMESTAMPS_320W_240H_5S; -import static androidx.media3.test.utils.PlayerFence.futureWhen; -import static androidx.media3.transformer.GlFrameProcessorTestUtil.closeTestingGlResources; -import static com.google.common.truth.Truth.assertThat; -import static java.util.concurrent.TimeUnit.MILLISECONDS; - -import android.app.Instrumentation; -import android.content.Context; -import android.view.SurfaceView; -import androidx.annotation.Nullable; -import androidx.media3.common.C; -import androidx.media3.common.GlObjectsProvider; -import androidx.media3.common.MediaItem; -import androidx.media3.common.Player; -import androidx.media3.common.util.GlUtil; -import androidx.media3.common.util.Util; -import androidx.media3.effect.DefaultGlFrameProcessor; -import androidx.media3.effect.DefaultGlObjectsProvider; -import androidx.media3.effect.FrameProcessorUtils; -import androidx.media3.effect.ndk.HardwareBufferJni; -import androidx.test.core.app.ApplicationProvider; -import androidx.test.ext.junit.rules.ActivityScenarioRule; -import androidx.test.ext.junit.runners.AndroidJUnit4; -import androidx.test.filters.SdkSuppress; -import androidx.test.platform.app.InstrumentationRegistry; -import com.google.common.collect.ImmutableList; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; -import com.google.common.util.concurrent.SettableFuture; -import java.util.Queue; -import java.util.concurrent.ConcurrentLinkedQueue; -import org.checkerframework.checker.nullness.qual.MonotonicNonNull; -import org.junit.After; -import org.junit.Before; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TestName; -import org.junit.runner.RunWith; - -/** Instrumentation tests for {@link CompositionPlayer} using {@link DefaultGlFrameProcessor}. */ -@RunWith(AndroidJUnit4.class) -@SdkSuppress(minSdkVersion = 28) -public final class CompositionPlayerDefaultGlFrameProcessorTest { - - private static final long TEST_TIMEOUT_MS = isRunningOnEmulator() ? 20_000 : 10_000; - - private static final EditedMediaItem MP4_EDITED_MEDIA_ITEM_10_MS = - new EditedMediaItem.Builder( - new MediaItem.Builder() - .setUri(MP4_ASSET_WITH_INCREASING_TIMESTAMPS_320W_240H_5S.uri) - .setClippingConfiguration( - new MediaItem.ClippingConfiguration.Builder().setEndPositionMs(10).build()) - .build()) - .setDurationUs(MP4_ASSET_WITH_INCREASING_TIMESTAMPS_320W_240H_5S.videoDurationUs) - .build(); - private static final Composition SINGLE_ITEM_COMPOSITION = - new Composition.Builder( - EditedMediaItemSequence.withVideoFrom(ImmutableList.of(MP4_EDITED_MEDIA_ITEM_10_MS))) - .build(); - - @Rule - public ActivityScenarioRule rule = - new ActivityScenarioRule<>(SurfaceTestActivity.class); - - @Rule public final TestName testName = new TestName(); - - private final Instrumentation instrumentation; - private final Context context; - - private @MonotonicNonNull CompositionPlayer compositionPlayer; - private @MonotonicNonNull SurfaceView surfaceView; - private @MonotonicNonNull ListeningExecutorService glExecutorService; - private @MonotonicNonNull GlObjectsProvider glObjectsProvider; - - public CompositionPlayerDefaultGlFrameProcessorTest() { - instrumentation = InstrumentationRegistry.getInstrumentation(); - context = ApplicationProvider.getApplicationContext(); - } - - @Before - public void setupSurfacesAndExecutor() throws Exception { - rule.getScenario() - .onActivity( - activity -> { - surfaceView = activity.getSurfaceView(); - }); - glExecutorService = - MoreExecutors.listeningDecorator(Util.newSingleThreadExecutor("CompositionTest:GL")); - glObjectsProvider = new DefaultGlObjectsProvider(); - glExecutorService - .submit( - () -> { - try { - FrameProcessorUtils.setupOpenGl(glObjectsProvider); - } catch (GlUtil.GlException e) { - throw new AssertionError(e); - } - }) - .get(TEST_TIMEOUT_MS, MILLISECONDS); - } - - @After - public void releaseResources() { - instrumentation.runOnMainSync( - () -> { - if (compositionPlayer != null) { - compositionPlayer.release(); - } - }); - rule.getScenario().close(); - @Nullable Exception releasingException = null; - if (glExecutorService != null) { - releasingException = - closeTestingGlResources(glExecutorService, glObjectsProvider, TEST_TIMEOUT_MS); - glExecutorService.shutdown(); - } - if (releasingException != null) { - throw new AssertionError(releasingException); - } - } - - @Test - public void compositionPlayer_withDefaultGlFrameProcessor_outputsFrameBeforeEnding() - throws Exception { - SettableFuture endedFuture = SettableFuture.create(); - Queue videoTimestamps = new ConcurrentLinkedQueue<>(); - - instrumentation.runOnMainSync( - () -> { - compositionPlayer = createCompositionPlayer(); - endedFuture.setFuture( - futureWhen(compositionPlayer).entersPlaybackState(Player.STATE_ENDED)); - compositionPlayer.setVideoSurfaceView(surfaceView); - compositionPlayer.setVideoFrameMetadataListener( - (presentationTimeUs, releaseTimeNs, format, mediaFormat) -> { - videoTimestamps.add(presentationTimeUs); - }); - compositionPlayer.addListener( - new Player.Listener() { - @Override - public void onPlaybackStateChanged(int playbackState) { - if (playbackState == STATE_ENDED) { - videoTimestamps.add(-1L); - } - } - }); - compositionPlayer.setComposition(SINGLE_ITEM_COMPOSITION); - compositionPlayer.prepare(); - compositionPlayer.play(); - }); - endedFuture.get(TEST_TIMEOUT_MS, MILLISECONDS); - - assertThat(videoTimestamps).containsExactly(0L, -1L).inOrder(); - } - - @Test - public void compositionPlayer_playAfterEnded_doesNotTimeout() throws Exception { - SettableFuture endedFuture = SettableFuture.create(); - - instrumentation.runOnMainSync( - () -> { - compositionPlayer = createCompositionPlayer(); - compositionPlayer.setVideoSurfaceView(surfaceView); - endedFuture.setFuture( - futureWhen(compositionPlayer).entersPlaybackState(Player.STATE_ENDED)); - compositionPlayer.setComposition(SINGLE_ITEM_COMPOSITION); - compositionPlayer.prepare(); - compositionPlayer.play(); - }); - endedFuture.get(TEST_TIMEOUT_MS, MILLISECONDS); - - SettableFuture endedAfterPlayFuture = SettableFuture.create(); - instrumentation.runOnMainSync( - () -> { - endedAfterPlayFuture.setFuture( - futureWhen(compositionPlayer).entersPlaybackState(Player.STATE_ENDED)); - compositionPlayer.play(); - }); - endedAfterPlayFuture.get(TEST_TIMEOUT_MS, MILLISECONDS); - } - - private CompositionPlayer createCompositionPlayer() { - DefaultGlFrameProcessor.Factory frameProcessorFactory = - new DefaultGlFrameProcessor.Factory( - context, glObjectsProvider, HardwareBufferJni.INSTANCE, glExecutorService); - return new CompositionPlayer.Builder(context) - .setNativeHardwareBufferHelpers(HardwareBufferJni.INSTANCE) - .setFrameProcessorFactory(frameProcessorFactory) - // Disable frame dropping. - .experimentalSetLateThresholdToDropInputUs(C.TIME_UNSET) - .build(); - } -} diff --git a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/GlFrameProcessorTestUtil.java b/libraries/transformer/src/androidTest/java/androidx/media3/transformer/GlFrameProcessorTestUtil.java deleted file mode 100644 index ab1c7d4a736..00000000000 --- a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/GlFrameProcessorTestUtil.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright 2026 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 androidx.media3.transformer; - -import static com.google.common.base.Preconditions.checkNotNull; -import static java.util.concurrent.TimeUnit.MILLISECONDS; - -import androidx.annotation.Nullable; -import androidx.annotation.RequiresApi; -import androidx.media3.common.GlObjectsProvider; -import androidx.media3.common.util.GlUtil.GlException; -import androidx.media3.common.util.NullableType; -import androidx.media3.effect.FrameProcessorUtils; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.atomic.AtomicReference; - -/** Utility class containing fakes for GlFrameProcessor testing. */ -@RequiresApi(26) -public final class GlFrameProcessorTestUtil { - /** Releases the GL resources on the GL thread, returns the thrown exception during release. */ - @Nullable - public static Exception closeTestingGlResources( - ExecutorService glExecutorService, GlObjectsProvider glObjectsProvider, long timeoutMs) { - AtomicReference<@NullableType Exception> releaseException = new AtomicReference<>(); - try { - glExecutorService - .submit( - () -> { - try { - FrameProcessorUtils.releaseOpenGl(checkNotNull(glObjectsProvider)); - } catch (GlException e) { - releaseException.set(e); - } - }) - .get(timeoutMs, MILLISECONDS); - } catch (Exception e) { - if (e instanceof InterruptedException) { - Thread.currentThread().interrupt(); - } - if (releaseException.get() != null) { - releaseException.get().addSuppressed(e); - } else { - releaseException.set(e); - } - } - if (releaseException.get() != null) { - return releaseException.get(); - } - return null; - } - - private GlFrameProcessorTestUtil() {} -} diff --git a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/TransformerParameterizedPacketConsumerAndroidTest.java b/libraries/transformer/src/androidTest/java/androidx/media3/transformer/TransformerParameterizedPacketConsumerAndroidTest.java index b88eafc8af9..8c184612f50 100644 --- a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/TransformerParameterizedPacketConsumerAndroidTest.java +++ b/libraries/transformer/src/androidTest/java/androidx/media3/transformer/TransformerParameterizedPacketConsumerAndroidTest.java @@ -15,30 +15,16 @@ */ package androidx.media3.transformer; -import static androidx.media3.common.util.Util.isRunningOnEmulator; -import static androidx.media3.test.utils.AssetInfo.MP4_ADVANCED_ASSET; import static androidx.media3.test.utils.CompositionAssetInfo.MULTI_SEQUENCE_CONFIGS; import static androidx.media3.test.utils.CompositionAssetInfo.MULTI_SEQUENCE_VIDEO_CONFIGS; import static androidx.media3.test.utils.CompositionAssetInfo.SINGLE_SEQUENCE_CONFIGS; -import static androidx.media3.test.utils.EditedMediaItemAssetInfo.VIDEO_ONLY_CLIPPED_HALF_SPEED; -import static androidx.media3.test.utils.EditedMediaItemAssetInfo.VIDEO_ONLY_CLIPPED_TWICE_SPEED; import static androidx.media3.test.utils.FormatSupportAssumptions.assumeAllFormatsSupported; -import static androidx.media3.transformer.ExportResult.CONVERSION_PROCESS_TRANSCODED; -import static androidx.media3.transformer.GlFrameProcessorTestUtil.closeTestingGlResources; import static com.google.common.truth.Truth.assertThat; -import static java.util.concurrent.TimeUnit.MILLISECONDS; import android.content.Context; -import androidx.annotation.Nullable; import androidx.media3.common.C; -import androidx.media3.common.GlObjectsProvider; -import androidx.media3.common.MediaItem; -import androidx.media3.common.util.GlUtil; import androidx.media3.common.util.Util; -import androidx.media3.effect.DefaultGlFrameProcessor; -import androidx.media3.effect.DefaultGlObjectsProvider; import androidx.media3.effect.DefaultHardwareBufferEffectsPipeline; -import androidx.media3.effect.FrameProcessorUtils; import androidx.media3.effect.ndk.HardwareBufferJni; import androidx.media3.test.utils.CompositionAssetInfo; import androidx.test.core.app.ApplicationProvider; @@ -54,108 +40,60 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull; import org.junit.After; import org.junit.Before; -import org.junit.Rule; import org.junit.Test; -import org.junit.rules.TestName; import org.junit.runner.RunWith; /** Parameterized end-to-end export tests for {@link Transformer}. */ @RunWith(TestParameterInjector.class) -// TODO: b/479415308 - Expand API versions below 28 once supported. -@SdkSuppress(minSdkVersion = 28) public final class TransformerParameterizedPacketConsumerAndroidTest { - private static final String PACKET_PROCESSOR = "packet_processor"; - private static final String DEFAULT_GL_FRAME_PROCESSOR = "default_gl_frame_processor"; - private static final long TEST_TIMEOUT_MS = isRunningOnEmulator() ? 20_000 : 10_000; - - @Rule public final TestName testName; - - private final Context context; + private final Context context = ApplicationProvider.getApplicationContext(); private @MonotonicNonNull ListeningExecutorService glExecutorService; - private @MonotonicNonNull GlObjectsProvider glObjectsProvider; - private String testId; - - @TestParameter({PACKET_PROCESSOR, DEFAULT_GL_FRAME_PROCESSOR}) - public String pipelineMode; private static class TestConfigProvider extends TestParameterValuesProvider { @Override protected List provideValues( TestParameterValuesProvider.Context context) { - ImmutableList allConfigs = - new ImmutableList.Builder() - .addAll(SINGLE_SEQUENCE_CONFIGS) - .addAll(MULTI_SEQUENCE_VIDEO_CONFIGS) - .addAll(MULTI_SEQUENCE_CONFIGS) - .build(); - ImmutableList.Builder filteredConfigs = new ImmutableList.Builder<>(); - for (CompositionAssetInfo config : allConfigs) { - String configString = config.toString(); - // DefaultGlFrameProcessor doesn't support speed changing video effects. - // TODO: b/530108514 - Move tests to use EditedMediaItem.setSpeed(). - if (configString.contains(VIDEO_ONLY_CLIPPED_HALF_SPEED.name) - || configString.contains(VIDEO_ONLY_CLIPPED_TWICE_SPEED.name)) { - continue; - } - filteredConfigs.add(config); - } - return filteredConfigs.build(); + return new ImmutableList.Builder() + .addAll(SINGLE_SEQUENCE_CONFIGS) + .addAll(MULTI_SEQUENCE_VIDEO_CONFIGS) + .addAll(MULTI_SEQUENCE_CONFIGS) + .build(); } } - public TransformerParameterizedPacketConsumerAndroidTest() { - context = ApplicationProvider.getApplicationContext(); - testName = new TestName(); - } - @Before - public void setUp() throws Exception { - testId = testName.getMethodName(); + public void setUp() { glExecutorService = MoreExecutors.listeningDecorator(Util.newSingleThreadExecutor("PacketProcessor:Effect")); - if (pipelineMode.equals(DEFAULT_GL_FRAME_PROCESSOR)) { - glObjectsProvider = new DefaultGlObjectsProvider(); - glExecutorService - .submit( - () -> { - try { - FrameProcessorUtils.setupOpenGl(glObjectsProvider); - } catch (GlUtil.GlException e) { - throw new AssertionError(e); - } - }) - .get(TEST_TIMEOUT_MS, MILLISECONDS); - } } @After public void tearDown() { - @Nullable Exception releasingException = null; - if (pipelineMode.equals(DEFAULT_GL_FRAME_PROCESSOR)) { - releasingException = - closeTestingGlResources(glExecutorService, glObjectsProvider, TEST_TIMEOUT_MS); - } if (glExecutorService != null) { glExecutorService.shutdown(); } - if (releasingException != null) { - throw new AssertionError(releasingException); - } } + // TODO: b/479415308 - Expand API versions below 28 once supported. @Test - public void export_completesSuccessfully( + @SdkSuppress(minSdkVersion = 28) + public void export_withPacketProcessor_completesSuccessfully( @TestParameter(valuesProvider = TestConfigProvider.class) CompositionAssetInfo testConfig) throws Exception { - String testId = "export_" + pipelineMode + "_" + testConfig; + String testId = "export_withPacketProcessor_" + testConfig; Composition composition = testConfig.getComposition(); assumeAllFormatsSupported( context, testId, /* inputFormats= */ testConfig.getAllVideoFormats(), /* outputFormat= */ testConfig.getVideoEncoderInputFormat()); - Transformer transformer = buildTransformer(); + Transformer transformer = + new Transformer.Builder(context) + .setNativeHardwareBufferHelpers(HardwareBufferJni.INSTANCE) + .setHardwareBufferEffectsPipeline( + DefaultHardwareBufferEffectsPipeline.create(context, HardwareBufferJni.INSTANCE)) + .build(); ExportTestResult result = new TransformerAndroidTestRunner.Builder(context, transformer) @@ -169,34 +107,4 @@ public void export_completesSuccessfully( assertThat(result.exportResult.approximateDurationMs).isGreaterThan(0); } } - - @Test - public void export_forcesVideoTranscoding() throws Exception { - Transformer transformer = buildTransformer(); - MediaItem mediaItem = MediaItem.fromUri(MP4_ADVANCED_ASSET.uri); - - ExportTestResult result = - new TransformerAndroidTestRunner.Builder(context, transformer) - .build() - .run(testId, mediaItem); - - assertThat(result.exportResult.exportException).isNull(); - assertThat(result.exportResult.videoConversionProcess).isEqualTo(CONVERSION_PROCESS_TRANSCODED); - } - - private Transformer buildTransformer() { - Transformer.Builder transformerBuilder = - new Transformer.Builder(context).setNativeHardwareBufferHelpers(HardwareBufferJni.INSTANCE); - if (pipelineMode.equals(PACKET_PROCESSOR)) { - transformerBuilder.setHardwareBufferEffectsPipeline( - DefaultHardwareBufferEffectsPipeline.create(context, HardwareBufferJni.INSTANCE)); - } else if (pipelineMode.equals(DEFAULT_GL_FRAME_PROCESSOR)) { - transformerBuilder.setFrameProcessorFactory( - new DefaultGlFrameProcessor.Factory( - context, glObjectsProvider, HardwareBufferJni.INSTANCE, glExecutorService)); - } else { - throw new UnsupportedOperationException(pipelineMode); - } - return transformerBuilder.build(); - } } diff --git a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/mh/CompositionPlayerPacketConsumerSurfaceViewPixelTest.java b/libraries/transformer/src/androidTest/java/androidx/media3/transformer/mh/CompositionPlayerPacketConsumerSurfaceViewPixelTest.java index cf84ea20ab1..57c4d3c4b45 100644 --- a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/mh/CompositionPlayerPacketConsumerSurfaceViewPixelTest.java +++ b/libraries/transformer/src/androidTest/java/androidx/media3/transformer/mh/CompositionPlayerPacketConsumerSurfaceViewPixelTest.java @@ -18,7 +18,6 @@ import static android.os.Build.VERSION.SDK_INT; import static androidx.lifecycle.Lifecycle.State.CREATED; import static androidx.lifecycle.Lifecycle.State.RESUMED; -import static androidx.media3.common.util.Util.isRunningOnEmulator; import static androidx.media3.test.utils.AssetInfo.MP4_ASSET_COLOR_TEST_1080P_HLG10; import static androidx.media3.test.utils.AssetInfo.MP4_ASSET_WITH_INCREASING_TIMESTAMPS_320W_240H_5S; import static androidx.media3.test.utils.BitmapPixelTestUtil.maybeSaveTestBitmap; @@ -26,9 +25,7 @@ import static androidx.media3.test.utils.FormatSupportAssumptions.assumeFormatsSupported; import static androidx.media3.test.utils.PlayerFence.futureWhen; import static androidx.media3.test.utils.TestUtil.assertBitmapsAreSimilar; -import static androidx.media3.transformer.GlFrameProcessorTestUtil.closeTestingGlResources; import static com.google.common.truth.Truth.assertThat; -import static java.util.concurrent.TimeUnit.MILLISECONDS; import static org.junit.Assume.assumeTrue; import android.app.Instrumentation; @@ -53,17 +50,11 @@ import androidx.media3.common.C; import androidx.media3.common.ColorInfo; import androidx.media3.common.Format; -import androidx.media3.common.GlObjectsProvider; import androidx.media3.common.MediaItem; import androidx.media3.common.Player; import androidx.media3.common.VideoSize; import androidx.media3.common.util.ConditionVariable; -import androidx.media3.common.util.GlUtil.GlException; -import androidx.media3.common.util.Util; -import androidx.media3.effect.DefaultGlFrameProcessor; -import androidx.media3.effect.DefaultGlObjectsProvider; import androidx.media3.effect.DefaultHardwareBufferEffectsPipeline; -import androidx.media3.effect.FrameProcessorUtils; import androidx.media3.effect.SimpleGlFrameProcessor; import androidx.media3.effect.ndk.HardwareBufferJni; import androidx.media3.transformer.Composition; @@ -78,8 +69,6 @@ import androidx.test.filters.SdkSuppress; import androidx.test.platform.app.InstrumentationRegistry; import com.google.common.collect.ImmutableList; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; import com.google.common.util.concurrent.SettableFuture; import java.util.List; import java.util.Queue; @@ -110,16 +99,14 @@ public class CompositionPlayerPacketConsumerSurfaceViewPixelTest { private static final String PACKET_CONSUMER = "packet_consumer"; private static final String FRAME_PROCESSOR_ADAPTER = "frame_processor_adapter"; private static final String FRAME_PROCESSOR = "frame_processor"; - private static final String DEFAULT_GL_FRAME_PROCESSOR = "default_gl_frame_processor"; - private static final long TEST_TIMEOUT_MS = isRunningOnEmulator() ? 20_000 : 10_000; + private static final long TEST_TIMEOUT_MS = 10_000; private static final float PSNR_THRESHOLD = 23f; private static final String GOLDEN_ASSET_FOLDER_PATH = "test-generated-goldens/CompositionPlayerPacketConsumerSurfaceViewPixelTest/"; @Parameters(name = "{0}") public static ImmutableList params() { - return ImmutableList.of( - PACKET_CONSUMER, FRAME_PROCESSOR_ADAPTER, FRAME_PROCESSOR, DEFAULT_GL_FRAME_PROCESSOR); + return ImmutableList.of(PACKET_CONSUMER, FRAME_PROCESSOR_ADAPTER, FRAME_PROCESSOR); } @Parameter public String mode; @@ -136,31 +123,13 @@ public static ImmutableList params() { private @MonotonicNonNull CompositionPlayer compositionPlayer; private @MonotonicNonNull SurfaceView surfaceView; private @MonotonicNonNull ImageReaderSurfaceHolder surfaceHolder; - private @MonotonicNonNull ListeningExecutorService glExecutorService; - // Only used for DefaultGlFrameProcessor - private @MonotonicNonNull GlObjectsProvider glObjectsProvider; private String testId; @Before - public void setUp() throws Exception { + public void setUp() { testId = testName.getMethodName(); rule.getScenario().onActivity(activity -> surfaceView = activity.getSurfaceView()); - glExecutorService = - MoreExecutors.listeningDecorator(Util.newSingleThreadExecutor("PacketProcessor:Effect")); - glObjectsProvider = new DefaultGlObjectsProvider(); - if (mode.equals(DEFAULT_GL_FRAME_PROCESSOR)) { - glExecutorService - .submit( - () -> { - try { - FrameProcessorUtils.setupOpenGl(glObjectsProvider); - } catch (GlException e) { - throw new AssertionError(e); - } - }) - .get(TEST_TIMEOUT_MS, MILLISECONDS); - } } @After @@ -175,17 +144,6 @@ public void tearDown() { if (surfaceHolder != null) { surfaceHolder.release(); } - @Nullable Exception releasingException = null; - if (mode.equals(DEFAULT_GL_FRAME_PROCESSOR)) { - releasingException = - closeTestingGlResources(glExecutorService, glObjectsProvider, TEST_TIMEOUT_MS); - } - if (glExecutorService != null) { - glExecutorService.shutdown(); - } - if (releasingException != null) { - throw new AssertionError(releasingException); - } } @Test @@ -518,7 +476,8 @@ public void compositionPlayer_andHdrVideo_outputsCorrectDataSpace() throws Excep assertThat(DataSpace.getRange(actualDataSpace)).isEqualTo(DataSpace.RANGE_LIMITED); } - private CompositionPlayer.Builder createCompositionPlayerBuilder(Context context, String mode) { + private static CompositionPlayer.Builder createCompositionPlayerBuilder( + Context context, String mode) { CompositionPlayer.Builder builder = new CompositionPlayer.Builder(context) .setNativeHardwareBufferHelpers(HardwareBufferJni.INSTANCE); @@ -536,10 +495,6 @@ private CompositionPlayer.Builder createCompositionPlayerBuilder(Context context } else if (mode.equals(FRAME_PROCESSOR)) { return builder.setFrameProcessorFactory( new SimpleGlFrameProcessor.Factory(context, HardwareBufferJni.INSTANCE)); - } else if (mode.equals(DEFAULT_GL_FRAME_PROCESSOR)) { - return builder.setFrameProcessorFactory( - new DefaultGlFrameProcessor.Factory( - context, glObjectsProvider, HardwareBufferJni.INSTANCE, glExecutorService)); } throw new IllegalArgumentException("Unknown mode: " + mode); } diff --git a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/mh/TranscodeQualityTest.java b/libraries/transformer/src/androidTest/java/androidx/media3/transformer/mh/TranscodeQualityTest.java index ecd93d1804f..83375514814 100644 --- a/libraries/transformer/src/androidTest/java/androidx/media3/transformer/mh/TranscodeQualityTest.java +++ b/libraries/transformer/src/androidTest/java/androidx/media3/transformer/mh/TranscodeQualityTest.java @@ -17,7 +17,6 @@ package androidx.media3.transformer.mh; import static android.os.Build.VERSION.SDK_INT; -import static androidx.media3.common.util.Util.isRunningOnEmulator; import static androidx.media3.test.utils.AssetInfo.MP4_ASSET_COLOR_TEST_1080P_HLG10; import static androidx.media3.test.utils.AssetInfo.MP4_ASSET_WITH_INCREASING_TIMESTAMPS; import static androidx.media3.test.utils.AssetInfo.MP4_ASSET_WITH_INCREASING_TIMESTAMPS_320W_240H_15S; @@ -28,10 +27,8 @@ import static androidx.media3.test.utils.HdrCapabilitiesUtil.assumeDeviceSupportsHdrEditing; import static androidx.media3.test.utils.TestUtil.assertBitmapsAreSimilar; import static androidx.media3.test.utils.TestUtil.retrieveTrackFormat; -import static androidx.media3.transformer.GlFrameProcessorTestUtil.closeTestingGlResources; import static com.google.common.base.Preconditions.checkNotNull; import static com.google.common.truth.Truth.assertThat; -import static java.util.concurrent.TimeUnit.MILLISECONDS; import static java.util.concurrent.TimeUnit.SECONDS; import static org.junit.Assume.assumeFalse; @@ -39,18 +36,12 @@ import android.graphics.Bitmap; import android.net.Uri; import android.os.Build; -import androidx.annotation.Nullable; import androidx.media3.common.C; -import androidx.media3.common.GlObjectsProvider; import androidx.media3.common.MediaItem; import androidx.media3.common.MimeTypes; -import androidx.media3.common.util.GlUtil.GlException; import androidx.media3.common.util.Log; import androidx.media3.common.util.Util; -import androidx.media3.effect.DefaultGlFrameProcessor; -import androidx.media3.effect.DefaultGlObjectsProvider; import androidx.media3.effect.DefaultHardwareBufferEffectsPipeline; -import androidx.media3.effect.FrameProcessorUtils; import androidx.media3.effect.SimpleGlFrameProcessor; import androidx.media3.effect.ndk.HardwareBufferJni; import androidx.media3.inspector.frame.FrameExtractor; @@ -64,14 +55,10 @@ import androidx.test.core.app.ApplicationProvider; import androidx.test.filters.SdkSuppress; import com.google.common.collect.ImmutableList; -import com.google.common.util.concurrent.ListeningExecutorService; -import com.google.common.util.concurrent.MoreExecutors; import java.io.OutputStream; import java.lang.reflect.Method; import java.nio.file.Files; import java.nio.file.Paths; -import org.checkerframework.checker.nullness.qual.MonotonicNonNull; -import org.junit.After; import org.junit.Before; import org.junit.Ignore; import org.junit.Rule; @@ -93,13 +80,11 @@ public final class TranscodeQualityTest { "test-generated-goldens/FrameExtractorTest/hlg10-color-test_0.000.png"; private static final String EXPECTED_ROTATED_VIDEO_EXTRACTED_PNG_PATH = "test-generated-goldens/FrameExtractorTest/internal_emulator_transformer_output_270_rotated_0.000.png"; - private static final long TEST_TIMEOUT_MS = isRunningOnEmulator() ? 20_000 : 10_000; private static final String LEGACY = "legacy"; private static final String PACKET_CONSUMER_NDK = "packet_consumer_ndk"; private static final String FRAME_PROCESSOR_ADAPTER_NDK = "frame_processor_adapter_ndk"; private static final String FRAME_PROCESSOR_NDK = "frame_processor_ndk"; - private static final String DEFAULT_GL_FRAME_PROCESSOR_NDK = "default_gl_frame_processor_ndk"; private static final int FRAME_PROCESSOR_MIN_SDK = 28; @Rule public final TestName testName = new TestName(); @@ -108,54 +93,18 @@ public final class TranscodeQualityTest { public static ImmutableList params() { if (SDK_INT >= FRAME_PROCESSOR_MIN_SDK) { return ImmutableList.of( - LEGACY, - PACKET_CONSUMER_NDK, - FRAME_PROCESSOR_ADAPTER_NDK, - FRAME_PROCESSOR_NDK, - DEFAULT_GL_FRAME_PROCESSOR_NDK); + LEGACY, PACKET_CONSUMER_NDK, FRAME_PROCESSOR_ADAPTER_NDK, FRAME_PROCESSOR_NDK); } return ImmutableList.of(LEGACY); } @Parameter public String mode; - private @MonotonicNonNull ListeningExecutorService glExecutorService; - private @MonotonicNonNull GlObjectsProvider glObjectsProvider; private String testId; @Before - public void setUp() throws Exception { + public void setUpTestId() { testId = testName.getMethodName(); - glExecutorService = - MoreExecutors.listeningDecorator(Util.newSingleThreadExecutor("PacketProcessor:Effect")); - if (mode.equals(DEFAULT_GL_FRAME_PROCESSOR_NDK)) { - glObjectsProvider = new DefaultGlObjectsProvider(); - glExecutorService - .submit( - () -> { - try { - FrameProcessorUtils.setupOpenGl(checkNotNull(glObjectsProvider)); - } catch (GlException e) { - throw new AssertionError(e); - } - }) - .get(TEST_TIMEOUT_MS, MILLISECONDS); - } - } - - @After - public void tearDown() { - @Nullable Exception releasingException = null; - if (mode.equals(DEFAULT_GL_FRAME_PROCESSOR_NDK)) { - releasingException = - closeTestingGlResources(glExecutorService, glObjectsProvider, TEST_TIMEOUT_MS); - } - if (glExecutorService != null) { - glExecutorService.shutdown(); - } - if (releasingException != null) { - throw new AssertionError(releasingException); - } } @Test @@ -226,8 +175,7 @@ public void transcode_hlg10_outputsHlg() throws Exception { assumeFalse( mode.equals(PACKET_CONSUMER_NDK) || mode.equals(FRAME_PROCESSOR_ADAPTER_NDK) - || mode.equals(FRAME_PROCESSOR_NDK) - || mode.equals(DEFAULT_GL_FRAME_PROCESSOR_NDK)); + || mode.equals(FRAME_PROCESSOR_NDK)); assumeDeviceSupportsHdrEditing(testId, MP4_ASSET_COLOR_TEST_1080P_HLG10.videoFormat); assumeFormatsSupported( context, @@ -266,6 +214,8 @@ public void transcode_hlg10_outputsHlg() throws Exception { @Test public void transcode_rotated270_outputsRotated270() throws Exception { Context context = ApplicationProvider.getApplicationContext(); + // TODO: b/530927743 - Enable after rotation handling is fixed. + assumeFalse(mode.equals(FRAME_PROCESSOR_NDK)); assumeFormatsSupported( context, testId, @@ -295,7 +245,7 @@ public void transcode_rotated270_outputsRotated270() throws Exception { } } - private Transformer.Builder createBuilder(Context context, String mode) { + private static Transformer.Builder createBuilder(Context context, String mode) { if (SDK_INT < FRAME_PROCESSOR_MIN_SDK) { return new Transformer.Builder(context); } @@ -320,15 +270,6 @@ private Transformer.Builder createBuilder(Context context, String mode) { .setNativeHardwareBufferHelpers(HardwareBufferJni.INSTANCE) .setFrameProcessorFactory( new SimpleGlFrameProcessor.Factory(context, HardwareBufferJni.INSTANCE)); - } else if (mode.equals(DEFAULT_GL_FRAME_PROCESSOR_NDK)) { - return new Transformer.Builder(context) - .setNativeHardwareBufferHelpers(HardwareBufferJni.INSTANCE) - .setFrameProcessorFactory( - new DefaultGlFrameProcessor.Factory( - context, - checkNotNull(glObjectsProvider), - HardwareBufferJni.INSTANCE, - checkNotNull(glExecutorService))); } return new Transformer.Builder(context); } diff --git a/libraries/transformer/src/main/java/androidx/media3/transformer/CapturingEncoderFactory.java b/libraries/transformer/src/main/java/androidx/media3/transformer/CapturingEncoderFactory.java index 03a3a04f976..6660bb4eedf 100644 --- a/libraries/transformer/src/main/java/androidx/media3/transformer/CapturingEncoderFactory.java +++ b/libraries/transformer/src/main/java/androidx/media3/transformer/CapturingEncoderFactory.java @@ -46,6 +46,11 @@ public Codec createForVideoEncoding(Format format, @Nullable LogSessionId logSes return videoEncoder; } + @Override + public boolean isVideoFormatSupported(Format format) { + return encoderFactory.isVideoFormatSupported(format); + } + @Override public boolean audioNeedsEncoding() { return encoderFactory.audioNeedsEncoding(); diff --git a/libraries/transformer/src/main/java/androidx/media3/transformer/Transformer.java b/libraries/transformer/src/main/java/androidx/media3/transformer/Transformer.java index 36868552760..2de84b89df7 100644 --- a/libraries/transformer/src/main/java/androidx/media3/transformer/Transformer.java +++ b/libraries/transformer/src/main/java/androidx/media3/transformer/Transformer.java @@ -1201,7 +1201,7 @@ public void cancel() { * @param composition The {@link Composition} to resume export. * @param outputFilePath The path to the output file. This must be different from the output path * of the cancelled export. - * @param oldFilePath The output path of the the cancelled export. + * @param oldFilePath The output path of the cancelled export. */ // TODO: b/450253391 - Add support for resumption with #setSpeed(). public void resume(Composition composition, String outputFilePath, String oldFilePath) { diff --git a/libraries/ui_compose/src/main/java/androidx/media3/ui/compose/state/PresentationState.kt b/libraries/ui_compose/src/main/java/androidx/media3/ui/compose/state/PresentationState.kt index 38569902a1e..69a8adcb49d 100644 --- a/libraries/ui_compose/src/main/java/androidx/media3/ui/compose/state/PresentationState.kt +++ b/libraries/ui_compose/src/main/java/androidx/media3/ui/compose/state/PresentationState.kt @@ -154,8 +154,15 @@ class PresentationState(keepContentOnReset: Boolean = false) { if (!keepContentOnReset && !hasTracks) { coverSurface = true } - if (hasTracks && !hasSelectedVideoTrack(player)) { - coverSurface = true + if (hasTracks) { + if (hasSelectedVideoTrack(player)) { + // We don't lift the shutter here; we wait for EVENT_RENDERED_FIRST_FRAME instead. + } else if (hasSelectedTextTrack(player)) { + // No video track, but text (subtitles) is selected, lift the shutter to show them + coverSurface = false + } else { + coverSurface = true + } } } else { coverSurface = coverSurface || !keepContentOnReset @@ -199,6 +206,10 @@ class PresentationState(keepContentOnReset: Boolean = false) { player.isCommandAvailable(Player.COMMAND_GET_TRACKS) && player.currentTracks.isTypeSelected(C.TRACK_TYPE_VIDEO) + private fun hasSelectedTextTrack(player: Player): Boolean = + player.isCommandAvailable(Player.COMMAND_GET_TRACKS) && + player.currentTracks.isTypeSelected(C.TRACK_TYPE_TEXT) + companion object { init { MediaLibraryInfo.registerModule("media3.ui.compose") diff --git a/libraries/ui_compose/src/test/java/androidx/media3/ui/compose/state/PresentationStateTest.kt b/libraries/ui_compose/src/test/java/androidx/media3/ui/compose/state/PresentationStateTest.kt index bd1b3c7e54a..dc7d65afe28 100644 --- a/libraries/ui_compose/src/test/java/androidx/media3/ui/compose/state/PresentationStateTest.kt +++ b/libraries/ui_compose/src/test/java/androidx/media3/ui/compose/state/PresentationStateTest.kt @@ -31,6 +31,8 @@ import androidx.media3.common.Format import androidx.media3.common.ForwardingPlayer import androidx.media3.common.MediaItem import androidx.media3.common.MediaLibraryInfo +import androidx.media3.common.MimeTypes.AUDIO_AAC +import androidx.media3.common.MimeTypes.TEXT_VTT import androidx.media3.common.MimeTypes.VIDEO_VP9 import androidx.media3.common.Player import androidx.media3.common.SimpleBasePlayer.MediaItemData @@ -494,4 +496,121 @@ class PresentationStateTest { // Should remain visible (shutter open) because we are in the same window on the same timeline assertThat(state.coverSurface).isFalse() } + + @Test + fun videoOnly_shutterClosedUntilFirstFrame() = runComposeUiTest { + val group = + Tracks.Group( + /* mediaTrackGroup = */ TrackGroup(Format.Builder().setSampleMimeType(VIDEO_VP9).build()), + /* adaptiveSupported = */ true, + /* trackSupport = */ intArrayOf(C.FORMAT_HANDLED), + /* trackSelected = */ booleanArrayOf(true), + ) + val player = + FakePlayer( + playlist = listOf(MediaItemData.Builder("uid").setTracks(Tracks(listOf(group))).build()) + ) + + lateinit var state: PresentationState + setContent { state = rememberPresentationState(player) } + + // With video, shutter starts closed + assertThat(state.coverSurface).isTrue() + + player.renderFirstFrame(true) + waitForIdle() + + // First frame opens the shutter + assertThat(state.coverSurface).isFalse() + } + + @Test + fun videoAndText_shutterClosedUntilFirstFrame() = runComposeUiTest { + val videoGroup = + Tracks.Group( + /* mediaTrackGroup = */ TrackGroup(Format.Builder().setSampleMimeType(VIDEO_VP9).build()), + /* adaptiveSupported = */ true, + /* trackSupport = */ intArrayOf(C.FORMAT_HANDLED), + /* trackSelected = */ booleanArrayOf(true), + ) + val textGroup = + Tracks.Group( + /* mediaTrackGroup = */ TrackGroup(Format.Builder().setSampleMimeType(TEXT_VTT).build()), + /* adaptiveSupported = */ true, + /* trackSupport = */ intArrayOf(C.FORMAT_HANDLED), + /* trackSelected = */ booleanArrayOf(true), + ) + val player = + FakePlayer( + playlist = + listOf( + MediaItemData.Builder("uid").setTracks(Tracks(listOf(videoGroup, textGroup))).build() + ) + ) + + lateinit var state: PresentationState + setContent { state = rememberPresentationState(player) } + + // Even with text, because there is video, shutter starts closed + assertThat(state.coverSurface).isTrue() + + player.renderFirstFrame(true) + waitForIdle() + + // First frame opens the shutter + assertThat(state.coverSurface).isFalse() + } + + @Test + fun audioOnly_shutterClosed() = runComposeUiTest { + val audioGroup = + Tracks.Group( + /* mediaTrackGroup = */ TrackGroup(Format.Builder().setSampleMimeType(AUDIO_AAC).build()), + /* adaptiveSupported = */ true, + /* trackSupport = */ intArrayOf(C.FORMAT_HANDLED), + /* trackSelected = */ booleanArrayOf(true), + ) + val player = + FakePlayer( + playlist = + listOf(MediaItemData.Builder("uid").setTracks(Tracks(listOf(audioGroup))).build()) + ) + + lateinit var state: PresentationState + setContent { state = rememberPresentationState(player) } + + // Audio only, no video, no text -> shutter stays closed + assertThat(state.coverSurface).isTrue() + } + + @Test + fun audioAndText_shutterOpen() = runComposeUiTest { + val audioGroup = + Tracks.Group( + /* mediaTrackGroup = */ TrackGroup(Format.Builder().setSampleMimeType(AUDIO_AAC).build()), + /* adaptiveSupported = */ true, + /* trackSupport = */ intArrayOf(C.FORMAT_HANDLED), + /* trackSelected = */ booleanArrayOf(true), + ) + val textGroup = + Tracks.Group( + /* mediaTrackGroup = */ TrackGroup(Format.Builder().setSampleMimeType(TEXT_VTT).build()), + /* adaptiveSupported = */ true, + /* trackSupport = */ intArrayOf(C.FORMAT_HANDLED), + /* trackSelected = */ booleanArrayOf(true), + ) + val player = + FakePlayer( + playlist = + listOf( + MediaItemData.Builder("uid").setTracks(Tracks(listOf(audioGroup, textGroup))).build() + ) + ) + + lateinit var state: PresentationState + setContent { state = rememberPresentationState(player) } + + // Audio and text -> shutter should be immediately open to show the subtitles over black + assertThat(state.coverSurface).isFalse() + } } diff --git a/libraries/ui_compose_material3/src/main/java/androidx/media3/ui/compose/material3/PlayerDefaults.kt b/libraries/ui_compose_material3/src/main/java/androidx/media3/ui/compose/material3/PlayerDefaults.kt index 4bc4f77a609..753a8454998 100644 --- a/libraries/ui_compose_material3/src/main/java/androidx/media3/ui/compose/material3/PlayerDefaults.kt +++ b/libraries/ui_compose_material3/src/main/java/androidx/media3/ui/compose/material3/PlayerDefaults.kt @@ -218,12 +218,13 @@ object PlayerDefaults { below: @Composable ColumnScope.(Player?) -> Unit = {}, progressSlider: @Composable (Player?) -> Unit = { ProgressSlider(it) }, ) { - AnimatedVisibility(visible = visible, enter = fadeIn(), exit = fadeOut()) { - Column( - modifier - .background(brush = PlayerTokens.bottomControlsGradient) - .padding(horizontal = PlayerTokens.ControlsHorizontalPadding) - ) { + AnimatedVisibility( + visible = visible, + modifier = Modifier.background(brush = PlayerTokens.bottomControlsGradient), + enter = fadeIn(), + exit = fadeOut(), + ) { + Column(modifier.padding(horizontal = PlayerTokens.ControlsHorizontalPadding)) { above(player) Row(modifier = Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) { left(player)