sjs/media
1
0
Fork 0
mirror of https://github.com/samsonjs/media.git synced 2026-03-27 09:45:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove asyncErrorListener

Browse source 
PiperOrigin-RevId: 488310077
This commit is contained in:
kimvde 2022-11-14 10:38:05 +00:00 committed by Ian Baker
parent 83b4d00081
commit e1a9ce71df
6 changed files with 40 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
libraries/transformer/src/main/java/androidx/media3/transformer/ExoPlayerAssetLoader.java
View file

@ -92,8 +92,7 @@ import androidx.media3.exoplayer.video.VideoRendererEventListener;
progressState = PROGRESS_STATE_NO_TRANSFORMATION;
}
public void start(
MediaItem mediaItem, Listener listener, Transformer.AsyncErrorListener asyncErrorListener) {
public void start(MediaItem mediaItem, Listener listener) {
DefaultTrackSelector trackSelector = new DefaultTrackSelector(context);
trackSelector.setParameters(
new DefaultTrackSelector.Parameters.Builder(context)
@ -110,9 +109,7 @@ import androidx.media3.exoplayer.video.VideoRendererEventListener;
DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS / 10)
.build();
ExoPlayer.Builder playerBuilder =
new ExoPlayer.Builder(
context,
new RenderersFactoryImpl(removeAudio, removeVideo, listener, asyncErrorListener))
new ExoPlayer.Builder(context, new RenderersFactoryImpl(removeAudio, removeVideo, listener))
.setMediaSourceFactory(mediaSourceFactory)
.setTrackSelector(trackSelector)
.setLoadControl(loadControl)
@ -156,17 +153,14 @@ import androidx.media3.exoplayer.video.VideoRendererEventListener;
private final boolean removeAudio;
private final boolean removeVideo;
private final ExoPlayerAssetLoader.Listener assetLoaderListener;
private final Transformer.AsyncErrorListener asyncErrorListener;
public RenderersFactoryImpl(
boolean removeAudio,
boolean removeVideo,
ExoPlayerAssetLoader.Listener assetLoaderListener,
Transformer.AsyncErrorListener asyncErrorListener) {
ExoPlayerAssetLoader.Listener assetLoaderListener) {
this.removeAudio = removeAudio;
this.removeVideo = removeVideo;
this.assetLoaderListener = assetLoaderListener;
this.asyncErrorListener = asyncErrorListener;
mediaClock = new TransformerMediaClock();
}
@ -182,14 +176,12 @@ import androidx.media3.exoplayer.video.VideoRendererEventListener;
int index = 0;
if (!removeAudio) {
renderers[index] =
new ExoPlayerAssetLoaderRenderer(
C.TRACK_TYPE_AUDIO, mediaClock, assetLoaderListener, asyncErrorListener);
new ExoPlayerAssetLoaderRenderer(C.TRACK_TYPE_AUDIO, mediaClock, assetLoaderListener);
index++;
}
if (!removeVideo) {
renderers[index] =
new ExoPlayerAssetLoaderRenderer(
C.TRACK_TYPE_VIDEO, mediaClock, assetLoaderListener, asyncErrorListener);
new ExoPlayerAssetLoaderRenderer(C.TRACK_TYPE_VIDEO, mediaClock, assetLoaderListener);
index++;
}
return renderers;

7
libraries/transformer/src/main/java/androidx/media3/transformer/ExoPlayerAssetLoaderRenderer.java
View file

@ -40,7 +40,6 @@ import org.checkerframework.checker.nullness.qual.RequiresNonNull;
private final TransformerMediaClock mediaClock;
private final ExoPlayerAssetLoader.Listener assetLoaderListener;
private final Transformer.AsyncErrorListener asyncErrorListener;
private final DecoderInputBuffer decoderInputBuffer;
private boolean isTransformationRunning;
@ -51,12 +50,10 @@ import org.checkerframework.checker.nullness.qual.RequiresNonNull;
public ExoPlayerAssetLoaderRenderer(
int trackType,
TransformerMediaClock mediaClock,
ExoPlayerAssetLoader.Listener assetLoaderListener,
Transformer.AsyncErrorListener asyncErrorListener) {
ExoPlayerAssetLoader.Listener assetLoaderListener) {
super(trackType);
this.mediaClock = mediaClock;
this.assetLoaderListener = assetLoaderListener;
this.asyncErrorListener = asyncErrorListener;
decoderInputBuffer = new DecoderInputBuffer(BUFFER_REPLACEMENT_MODE_DISABLED);
}
@ -104,7 +101,7 @@ import org.checkerframework.checker.nullness.qual.RequiresNonNull;
while (samplePipeline.processData() || feedPipelineFromInput()) {}
} catch (TransformationException e) {
isTransformationRunning = false;
asyncErrorListener.onTransformationError(e);
assetLoaderListener.onError(e);
}
}

9
libraries/transformer/src/main/java/androidx/media3/transformer/MuxerWrapper.java
View file

@ -29,6 +29,7 @@ import androidx.annotation.Nullable;
import androidx.media3.common.C;
import androidx.media3.common.Format;
import androidx.media3.common.MimeTypes;
import androidx.media3.common.util.Consumer;
import androidx.media3.common.util.Util;
import com.google.common.collect.ImmutableList;
import java.nio.ByteBuffer;
@ -57,7 +58,7 @@ import org.checkerframework.checker.nullness.qual.RequiresNonNull;
@Nullable private final String outputPath;
@Nullable private final ParcelFileDescriptor outputParcelFileDescriptor;
private final Muxer.Factory muxerFactory;
private final Transformer.AsyncErrorListener asyncErrorListener;
private final Consumer<TransformationException> errorConsumer;
private final SparseIntArray trackTypeToIndex;
private final SparseIntArray trackTypeToSampleCount;
private final SparseLongArray trackTypeToTimeUs;
@ -77,7 +78,7 @@ import org.checkerframework.checker.nullness.qual.RequiresNonNull;
@Nullable String outputPath,
@Nullable ParcelFileDescriptor outputParcelFileDescriptor,
Muxer.Factory muxerFactory,
Transformer.AsyncErrorListener asyncErrorListener) {
Consumer<TransformationException> errorConsumer) {
if (outputPath == null && outputParcelFileDescriptor == null) {
throw new NullPointerException("Both output path and ParcelFileDescriptor are null");
}
@ -85,7 +86,7 @@ import org.checkerframework.checker.nullness.qual.RequiresNonNull;
this.outputPath = outputPath;
this.outputParcelFileDescriptor = outputParcelFileDescriptor;
this.muxerFactory = muxerFactory;
this.asyncErrorListener = asyncErrorListener;
this.errorConsumer = errorConsumer;
trackTypeToIndex = new SparseIntArray();
trackTypeToSampleCount = new SparseIntArray();
@ -306,7 +307,7 @@ import org.checkerframework.checker.nullness.qual.RequiresNonNull;
return;
}
isAborted = true;
asyncErrorListener.onTransformationError(
errorConsumer.accept(
TransformationException.createForMuxer(
new IllegalStateException(
"No output sample written in the last "

26
libraries/transformer/src/main/java/androidx/media3/transformer/Transformer.java
View file

@ -715,22 +715,19 @@ public final class Transformer {
throw new IllegalStateException("There is already a transformation in progress.");
}
transformationInProgress = true;
ComponentListener componentListener = new ComponentListener(mediaItem, looper);
TransformerInternalListener transformerInternalListener =
new TransformerInternalListener(mediaItem, looper);
MuxerWrapper muxerWrapper =
new MuxerWrapper(
outputPath,
outputParcelFileDescriptor,
muxerFactory,
/* asyncErrorListener= */ componentListener);
/* errorConsumer= */ transformerInternalListener::onTransformationError);
this.muxerWrapper = muxerWrapper;
FallbackListener fallbackListener =
new FallbackListener(mediaItem, listeners, transformationRequest);
transformerInternal.start(
mediaItem,
muxerWrapper,
/* listener= */ componentListener,
fallbackListener,
/* asyncErrorListener= */ componentListener);
mediaItem, muxerWrapper, transformerInternalListener, fallbackListener);
}
/**
@ -824,23 +821,12 @@ public final class Transformer {
return fileSize;
}
/** Listener for exceptions that occur during a transformation. */
/* package */ interface AsyncErrorListener {
/**
* Called when a {@link TransformationException} occurs.
*
* <p>Can be called from any thread.
*/
void onTransformationError(TransformationException exception);
}
private final class ComponentListener
implements TransformerInternal.Listener, AsyncErrorListener {
private final class TransformerInternalListener implements TransformerInternal.Listener {
private final MediaItem mediaItem;
private final Handler handler;
public ComponentListener(MediaItem mediaItem, Looper looper) {
public TransformerInternalListener(MediaItem mediaItem, Looper looper) {
this.mediaItem = mediaItem;
handler = new Handler(looper);
}

34
libraries/transformer/src/main/java/androidx/media3/transformer/TransformerInternal.java
View file

@ -80,12 +80,10 @@ import com.google.common.collect.ImmutableList;
MediaItem mediaItem,
MuxerWrapper muxerWrapper,
Listener listener,
FallbackListener fallbackListener,
Transformer.AsyncErrorListener asyncErrorListener) {
ComponentListener componentListener =
new ComponentListener(
mediaItem, muxerWrapper, listener, fallbackListener, asyncErrorListener);
exoPlayerAssetLoader.start(mediaItem, componentListener, asyncErrorListener);
FallbackListener fallbackListener) {
AssetLoaderListener assetLoaderListener =
new AssetLoaderListener(mediaItem, muxerWrapper, listener, fallbackListener);
exoPlayerAssetLoader.start(mediaItem, assetLoaderListener);
}
public @Transformer.ProgressState int getProgress(ProgressHolder progressHolder) {
@ -96,27 +94,24 @@ import com.google.common.collect.ImmutableList;
exoPlayerAssetLoader.release();
}
private class ComponentListener implements ExoPlayerAssetLoader.Listener {
private class AssetLoaderListener implements ExoPlayerAssetLoader.Listener {
private final MediaItem mediaItem;
private final MuxerWrapper muxerWrapper;
private final TransformerInternal.Listener listener;
private final FallbackListener fallbackListener;
private final Transformer.AsyncErrorListener asyncErrorListener;
private volatile boolean trackRegistered;
public ComponentListener(
public AssetLoaderListener(
MediaItem mediaItem,
MuxerWrapper muxerWrapper,
Listener listener,
FallbackListener fallbackListener,
Transformer.AsyncErrorListener asyncErrorListener) {
FallbackListener fallbackListener) {
this.mediaItem = mediaItem;
this.muxerWrapper = muxerWrapper;
this.listener = listener;
this.fallbackListener = fallbackListener;
this.asyncErrorListener = asyncErrorListener;
}
@Override
@ -142,10 +137,15 @@ import com.google.common.collect.ImmutableList;
@Override
public void onError(Exception e) {
TransformationException transformationException =
e instanceof PlaybackException
? TransformationException.createForPlaybackException((PlaybackException) e)
: TransformationException.createForUnexpected(e);
TransformationException transformationException;
if (e instanceof TransformationException) {
transformationException = (TransformationException) e;
} else if (e instanceof PlaybackException) {
transformationException =
TransformationException.createForPlaybackException((PlaybackException) e);
} else {
transformationException = TransformationException.createForUnexpected(e);
}
listener.onTransformationError(transformationException);
}
@ -181,7 +181,7 @@ import com.google.common.collect.ImmutableList;
encoderFactory,
muxerWrapper,
fallbackListener,
asyncErrorListener,
listener::onTransformationError,
debugViewProvider);
} else {
return new PassthroughSamplePipeline(

9
libraries/transformer/src/main/java/androidx/media3/transformer/VideoTranscodingSamplePipeline.java
View file

@ -35,6 +35,7 @@ import androidx.media3.common.FrameInfo;
import androidx.media3.common.FrameProcessingException;
import androidx.media3.common.FrameProcessor;
import androidx.media3.common.SurfaceInfo;
import androidx.media3.common.util.Consumer;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.Util;
import androidx.media3.decoder.DecoderInputBuffer;
@ -75,7 +76,7 @@ import org.checkerframework.dataflow.qual.Pure;
Codec.EncoderFactory encoderFactory,
MuxerWrapper muxerWrapper,
FallbackListener fallbackListener,
Transformer.AsyncErrorListener asyncErrorListener,
Consumer<TransformationException> errorConsumer,
DebugViewProvider debugViewProvider)
throws TransformationException {
super(
@ -154,7 +155,7 @@ import org.checkerframework.dataflow.qual.Pure;
checkNotNull(frameProcessor)
.setOutputSurfaceInfo(encoderWrapper.getSurfaceInfo(width, height));
} catch (TransformationException exception) {
asyncErrorListener.onTransformationError(exception);
errorConsumer.accept(exception);
}
}
@ -165,7 +166,7 @@ import org.checkerframework.dataflow.qual.Pure;
@Override
public void onFrameProcessingError(FrameProcessingException exception) {
asyncErrorListener.onTransformationError(
errorConsumer.accept(
TransformationException.createForFrameProcessingException(
exception, TransformationException.ERROR_CODE_FRAME_PROCESSING_FAILED));
}
@ -175,7 +176,7 @@ import org.checkerframework.dataflow.qual.Pure;
try {
encoderWrapper.signalEndOfInputStream();
} catch (TransformationException exception) {
asyncErrorListener.onTransformationError(exception);
errorConsumer.accept(exception);
}
}
},