loliball/media
1
0
Fork 0
mirror of https://github.com/androidx/media.git synced 2025-05-04 06:00:37 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename CompositeAssetLoader to SequenceAssetLoader

Browse Source 
This clarifies that a SequenceAssetLoader loads data corresponding to an
EditedMediaItemSequence.

PiperOrigin-RevId: 514442681
This commit is contained in:
kimvde 2023-03-06 17:59:12 +00:00 committed by Rohit Singh
parent f94d3cf6c4
commit ce9fa88c0d
2 changed files with 34 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
library/transformer/src/main/java/com/google/android/exoplayer2/transformer/CompositeAssetLoader.java → library/transformer/src/main/java/com/google/android/exoplayer2/transformer/SequenceAssetLoader.java
View File

@ -44,10 +44,10 @@ import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
/** /**
* An {@link AssetLoader} that is composed of a sequence of non-overlapping {@linkplain AssetLoader * An {@link AssetLoader} that is composed of a {@linkplain EditedMediaItemSequence sequence} of
* asset loaders}. * non-overlapping {@linkplain AssetLoader asset loaders}.
*/ */
/* package */ final class CompositeAssetLoader implements AssetLoader, AssetLoader.Listener { /* package */ final class SequenceAssetLoader implements AssetLoader, AssetLoader.Listener {
private static final Format FORCE_AUDIO_TRACK_FORMAT = private static final Format FORCE_AUDIO_TRACK_FORMAT =
new Format.Builder() new Format.Builder()
@ -61,7 +61,7 @@ import java.util.concurrent.atomic.AtomicInteger;
private final boolean forceAudioTrack; private final boolean forceAudioTrack;
private final AssetLoader.Factory assetLoaderFactory; private final AssetLoader.Factory assetLoaderFactory;
private final HandlerWrapper handler; private final HandlerWrapper handler;
private final Listener compositeAssetLoaderListener; private final Listener sequenceAssetLoaderListener;
/** /**
* A mapping from track types to {@link SampleConsumer} instances. * A mapping from track types to {@link SampleConsumer} instances.
* *
@ -88,7 +88,7 @@ import java.util.concurrent.atomic.AtomicInteger;
private volatile long currentDurationUs; private volatile long currentDurationUs;
public CompositeAssetLoader( public SequenceAssetLoader(
EditedMediaItemSequence sequence, EditedMediaItemSequence sequence,
boolean forceAudioTrack, boolean forceAudioTrack,
AssetLoader.Factory assetLoaderFactory, AssetLoader.Factory assetLoaderFactory,
@ -98,7 +98,7 @@ import java.util.concurrent.atomic.AtomicInteger;
editedMediaItems = sequence.editedMediaItems; editedMediaItems = sequence.editedMediaItems;
this.forceAudioTrack = forceAudioTrack; this.forceAudioTrack = forceAudioTrack;
this.assetLoaderFactory = assetLoaderFactory; this.assetLoaderFactory = assetLoaderFactory;
compositeAssetLoaderListener = listener; sequenceAssetLoaderListener = listener;
currentMediaItemIndex = new AtomicInteger(); currentMediaItemIndex = new AtomicInteger();
handler = clock.createHandler(looper, /* callback= */ null); handler = clock.createHandler(looper, /* callback= */ null);
sampleConsumersByTrackType = new HashMap<>(); sampleConsumersByTrackType = new HashMap<>();
@ -182,9 +182,9 @@ import java.util.concurrent.atomic.AtomicInteger;
+ ". An unset duration is only allowed for the last EditedMediaItem in the sequence."); + ". An unset duration is only allowed for the last EditedMediaItem in the sequence.");
currentDurationUs = durationUs; currentDurationUs = durationUs;
if (editedMediaItems.size() == 1) { if (editedMediaItems.size() == 1) {
compositeAssetLoaderListener.onDurationUs(durationUs); sequenceAssetLoaderListener.onDurationUs(durationUs);
} else if (currentMediaItemIndex == 0) { } else if (currentMediaItemIndex == 0) {
compositeAssetLoaderListener.onDurationUs(C.TIME_UNSET); sequenceAssetLoaderListener.onDurationUs(C.TIME_UNSET);
} }
} }
@ -210,12 +210,12 @@ import java.util.concurrent.atomic.AtomicInteger;
if (!trackCountReported) { if (!trackCountReported) {
int trackCount = nonEndedTracks.get() + (addForcedAudioTrack ? 1 : 0); int trackCount = nonEndedTracks.get() + (addForcedAudioTrack ? 1 : 0);
compositeAssetLoaderListener.onTrackCount(trackCount); sequenceAssetLoaderListener.onTrackCount(trackCount);
trackCountReported = true; trackCountReported = true;
} }
boolean decodeOutput = boolean decodeOutput =
compositeAssetLoaderListener.onTrackAdded( sequenceAssetLoaderListener.onTrackAdded(
inputFormat, supportedOutputTypes, streamStartPositionUs, streamOffsetUs); inputFormat, supportedOutputTypes, streamStartPositionUs, streamOffsetUs);
if (isAudio) { if (isAudio) {
@ -225,7 +225,7 @@ import java.util.concurrent.atomic.AtomicInteger;
} }
if (addForcedAudioTrack) { if (addForcedAudioTrack) {
compositeAssetLoaderListener.onTrackAdded( sequenceAssetLoaderListener.onTrackAdded(
FORCE_AUDIO_TRACK_FORMAT, FORCE_AUDIO_TRACK_FORMAT,
SUPPORTED_OUTPUT_TYPE_DECODED, SUPPORTED_OUTPUT_TYPE_DECODED,
streamStartPositionUs, streamStartPositionUs,
@ -242,7 +242,7 @@ import java.util.concurrent.atomic.AtomicInteger;
SampleConsumer sampleConsumer; SampleConsumer sampleConsumer;
if (currentMediaItemIndex.get() == 0) { if (currentMediaItemIndex.get() == 0) {
@Nullable @Nullable
SampleConsumer wrappedSampleConsumer = compositeAssetLoaderListener.onOutputFormat(format); SampleConsumer wrappedSampleConsumer = sequenceAssetLoaderListener.onOutputFormat(format);
if (wrappedSampleConsumer == null) { if (wrappedSampleConsumer == null) {
return null; return null;
} }
@ -252,7 +252,7 @@ import java.util.concurrent.atomic.AtomicInteger;
if (forceAudioTrack && nonEndedTracks.get() == 1 && trackType == C.TRACK_TYPE_VIDEO) { if (forceAudioTrack && nonEndedTracks.get() == 1 && trackType == C.TRACK_TYPE_VIDEO) {
SampleConsumer wrappedAudioSampleConsumer = SampleConsumer wrappedAudioSampleConsumer =
checkStateNotNull( checkStateNotNull(
compositeAssetLoaderListener.onOutputFormat( sequenceAssetLoaderListener.onOutputFormat(
FORCE_AUDIO_TRACK_FORMAT FORCE_AUDIO_TRACK_FORMAT
.buildUpon() .buildUpon()
.setSampleMimeType(MimeTypes.AUDIO_RAW) .setSampleMimeType(MimeTypes.AUDIO_RAW)
@ -289,7 +289,7 @@ import java.util.concurrent.atomic.AtomicInteger;
@Override @Override
public void onError(ExportException exportException) { public void onError(ExportException exportException) {
compositeAssetLoaderListener.onError(exportException); sequenceAssetLoaderListener.onError(exportException);
} }
private void onMediaItemChanged(int trackType, @Nullable Format format) { private void onMediaItemChanged(int trackType, @Nullable Format format) {
@ -402,7 +402,7 @@ import java.util.concurrent.atomic.AtomicInteger;
assetLoaderFactory.createAssetLoader( assetLoaderFactory.createAssetLoader(
editedMediaItem, editedMediaItem,
checkNotNull(Looper.myLooper()), checkNotNull(Looper.myLooper()),
/* listener= */ CompositeAssetLoader.this); /* listener= */ SequenceAssetLoader.this);
currentAssetLoader.start(); currentAssetLoader.start();
}); });
} }

38
library/transformer/src/main/java/com/google/android/exoplayer2/transformer/TransformerInternal.java
View File

@ -99,7 +99,7 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
private final Clock clock; private final Clock clock;
private final HandlerThread internalHandlerThread; private final HandlerThread internalHandlerThread;
private final HandlerWrapper internalHandler; private final HandlerWrapper internalHandler;
private final List<CompositeAssetLoader> compositeAssetLoaders; private final List<SequenceAssetLoader> sequenceAssetLoaders;
private final AtomicInteger trackCountsToReport; private final AtomicInteger trackCountsToReport;
private final AtomicInteger tracksToAdd; private final AtomicInteger tracksToAdd;
private final AtomicBoolean outputHasAudio; private final AtomicBoolean outputHasAudio;
@ -137,23 +137,23 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
this.clock = clock; this.clock = clock;
internalHandlerThread = new HandlerThread("Transformer:Internal"); internalHandlerThread = new HandlerThread("Transformer:Internal");
internalHandlerThread.start(); internalHandlerThread.start();
compositeAssetLoaders = new ArrayList<>(); sequenceAssetLoaders = new ArrayList<>();
Looper internalLooper = internalHandlerThread.getLooper(); Looper internalLooper = internalHandlerThread.getLooper();
for (int i = 0; i < composition.sequences.size(); i++) { for (int i = 0; i < composition.sequences.size(); i++) {
CompositeAssetLoaderListener compositeAssetLoaderListener = SequenceAssetLoaderListener sequenceAssetLoaderListener =
new CompositeAssetLoaderListener( new SequenceAssetLoaderListener(
/* sequenceIndex= */ i, /* sequenceIndex= */ i,
composition, composition,
transformationRequest, transformationRequest,
fallbackListener, fallbackListener,
debugViewProvider); debugViewProvider);
compositeAssetLoaders.add( sequenceAssetLoaders.add(
new CompositeAssetLoader( new SequenceAssetLoader(
composition.sequences.get(i), composition.sequences.get(i),
composition.forceAudioTrack, composition.forceAudioTrack,
assetLoaderFactory, assetLoaderFactory,
internalLooper, internalLooper,
compositeAssetLoaderListener, sequenceAssetLoaderListener,
clock)); clock));
} }
trackCountsToReport = new AtomicInteger(composition.sequences.size()); trackCountsToReport = new AtomicInteger(composition.sequences.size());
@ -286,8 +286,8 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
} }
private void startInternal() { private void startInternal() {
for (int i = 0; i < compositeAssetLoaders.size(); i++) { for (int i = 0; i < sequenceAssetLoaders.size(); i++) {
compositeAssetLoaders.get(i).start(); sequenceAssetLoaders.get(i).start();
} }
} }
@ -312,8 +312,8 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
private void endInternal(@EndReason int endReason, @Nullable ExportException exportException) { private void endInternal(@EndReason int endReason, @Nullable ExportException exportException) {
ImmutableList.Builder<ExportResult.ProcessedInput> processedInputsBuilder = ImmutableList.Builder<ExportResult.ProcessedInput> processedInputsBuilder =
new ImmutableList.Builder<>(); new ImmutableList.Builder<>();
for (int i = 0; i < compositeAssetLoaders.size(); i++) { for (int i = 0; i < sequenceAssetLoaders.size(); i++) {
processedInputsBuilder.addAll(compositeAssetLoaders.get(i).getProcessedInputs()); processedInputsBuilder.addAll(sequenceAssetLoaders.get(i).getProcessedInputs());
} }
exportResultBuilder exportResultBuilder
.setProcessedInputs(processedInputsBuilder.build()) .setProcessedInputs(processedInputsBuilder.build())
@ -324,9 +324,9 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
@Nullable ExportException releaseExportException = null; @Nullable ExportException releaseExportException = null;
if (!released) { if (!released) {
released = true; released = true;
for (int i = 0; i < compositeAssetLoaders.size(); i++) { for (int i = 0; i < sequenceAssetLoaders.size(); i++) {
try { try {
compositeAssetLoaders.get(i).release(); sequenceAssetLoaders.get(i).release();
} catch (RuntimeException e) { } catch (RuntimeException e) {
if (releaseExportException == null) { if (releaseExportException == null) {
releaseExportException = ExportException.createForUnexpected(e); releaseExportException = ExportException.createForUnexpected(e);
@ -391,19 +391,19 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
private void updateProgressInternal(ProgressHolder progressHolder) { private void updateProgressInternal(ProgressHolder progressHolder) {
int progressSum = 0; int progressSum = 0;
ProgressHolder individualProgressHolder = new ProgressHolder(); ProgressHolder individualProgressHolder = new ProgressHolder();
for (int i = 0; i < compositeAssetLoaders.size(); i++) { for (int i = 0; i < sequenceAssetLoaders.size(); i++) {
progressState = compositeAssetLoaders.get(i).getProgress(individualProgressHolder); progressState = sequenceAssetLoaders.get(i).getProgress(individualProgressHolder);
if (progressState != PROGRESS_STATE_AVAILABLE) { if (progressState != PROGRESS_STATE_AVAILABLE) {
transformerConditionVariable.open(); transformerConditionVariable.open();
return; return;
} }
progressSum += individualProgressHolder.progress; progressSum += individualProgressHolder.progress;
} }
progressHolder.progress = progressSum / compositeAssetLoaders.size(); progressHolder.progress = progressSum / sequenceAssetLoaders.size();
transformerConditionVariable.open(); transformerConditionVariable.open();
} }
private final class CompositeAssetLoaderListener implements AssetLoader.Listener { private final class SequenceAssetLoaderListener implements AssetLoader.Listener {
private final int sequenceIndex; private final int sequenceIndex;
private final ImmutableList<EditedMediaItem> editedMediaItems; private final ImmutableList<EditedMediaItem> editedMediaItems;
@ -413,7 +413,7 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
private final DebugViewProvider debugViewProvider; private final DebugViewProvider debugViewProvider;
private final Map<Integer, AddedTrackInfo> addedTrackInfoByTrackType; private final Map<Integer, AddedTrackInfo> addedTrackInfoByTrackType;
public CompositeAssetLoaderListener( public SequenceAssetLoaderListener(
int sequenceIndex, int sequenceIndex,
Composition composition, Composition composition,
TransformationRequest transformationRequest, TransformationRequest transformationRequest,
@ -486,7 +486,7 @@ import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
AddedTrackInfo trackInfo = checkStateNotNull(addedTrackInfoByTrackType.get(trackType)); AddedTrackInfo trackInfo = checkStateNotNull(addedTrackInfoByTrackType.get(trackType));
SamplePipeline samplePipeline = getSamplePipeline(assetLoaderOutputFormat, trackInfo); SamplePipeline samplePipeline = getSamplePipeline(assetLoaderOutputFormat, trackInfo);
compositeAssetLoaders sequenceAssetLoaders
.get(sequenceIndex) .get(sequenceIndex)
.addOnMediaItemChangedListener(samplePipeline, trackType); .addOnMediaItemChangedListener(samplePipeline, trackType);
internalHandler.obtainMessage(MSG_REGISTER_SAMPLE_PIPELINE, samplePipeline).sendToTarget(); internalHandler.obtainMessage(MSG_REGISTER_SAMPLE_PIPELINE, samplePipeline).sendToTarget();