Java DecoderQueryException类代码示例

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
protected boolean handlesTrack(MediaFormat mediaFormat) throws DecoderQueryException {
    // TODO: Use MediaCodecList.findDecoderForFormat on API 23.
    String mimeType = mediaFormat.mimeType;
    return MimeTypes.isVideo(mimeType) && (MimeTypes.VIDEO_UNKNOWN.equals(mimeType)
            || MediaCodecUtil.getDecoderInfo(mimeType, false) != null);
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
protected DecoderInfo getDecoderInfo(String mimeType, boolean requiresSecureDecoder)
    throws DecoderQueryException {
  if (MimeTypes.isPassthroughAudio(mimeType)) {
    return new DecoderInfo(RAW_DECODER_NAME, true);
  }
  return super.getDecoderInfo(mimeType, requiresSecureDecoder);
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
public void onError(Exception e) {
    String errorString = null;
    if (e instanceof UnsupportedDrmException) {
        // Special case DRM failures.
        UnsupportedDrmException unsupportedDrmException = (UnsupportedDrmException) e;
        errorString = getString(Util.SDK_INT < 18 ? R.string.error_drm_not_supported
                : unsupportedDrmException.reason == UnsupportedDrmException.REASON_UNSUPPORTED_SCHEME
                ? R.string.error_drm_unsupported_scheme : R.string.error_drm_unknown);
    } else if (e instanceof ExoPlaybackException
            && e.getCause() instanceof DecoderInitializationException) {
        // Special case for decoder initialization failures.
        DecoderInitializationException decoderInitializationException =
                (DecoderInitializationException) e.getCause();
        if (decoderInitializationException.decoderName == null) {
            if (decoderInitializationException.getCause() instanceof DecoderQueryException) {
                errorString = getString(R.string.error_querying_decoders);
            } else if (decoderInitializationException.secureDecoderRequired) {
                errorString = getString(R.string.error_no_secure_decoder,
                        decoderInitializationException.mimeType);
            } else {
                errorString = getString(R.string.error_no_decoder,
                        decoderInitializationException.mimeType);
            }
        } else {
            errorString = getString(R.string.error_instantiating_decoder,
                    decoderInitializationException.decoderName);
        }
    }
    if (errorString != null) {
        Toast.makeText(getApplicationContext(), errorString, Toast.LENGTH_LONG).show();
    }
    playerNeedsPrepare = true;
    updateButtonVisibilities();
    showControls();
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
/**
 * Determines whether an individual format is playable, given an array of allowed container types,
 * whether HD formats should be filtered and a maximum decodable frame size in pixels.
 */
private static boolean isFormatPlayable(Format format, String[] allowedContainerMimeTypes,
    boolean filterHdFormats) throws DecoderQueryException {
  if (allowedContainerMimeTypes != null
      && !Util.contains(allowedContainerMimeTypes, format.mimeType)) {
    // Filtering format based on its container mime type.
    return false;
  }
  if (filterHdFormats && (format.width >= 1280 || format.height >= 720)) {
    // Filtering format because it's HD.
    return false;
  }
  if (format.width > 0 && format.height > 0) {
    if (Util.SDK_INT >= 21) {
      String videoMediaMimeType = MimeTypes.getVideoMediaMimeType(format.codecs);
      if (MimeTypes.VIDEO_UNKNOWN.equals(videoMediaMimeType)) {
        // Assume the video is H.264.
        videoMediaMimeType = MimeTypes.VIDEO_H264;
      }
      if (format.frameRate > 0) {
        return MediaCodecUtil.isSizeAndRateSupportedV21(videoMediaMimeType, false, format.width,
            format.height, format.frameRate);
      } else {
        return MediaCodecUtil.isSizeSupportedV21(videoMediaMimeType, false, format.width,
            format.height);
      }
    }
    // Assume the video is H.264.
    if (format.width * format.height > MediaCodecUtil.maxH264DecodableFrameSize()) {
      // Filtering format because it exceeds the maximum decodable frame size.
      return false;
    }
  }
  return true;
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
protected boolean handlesTrack(MediaCodecSelector mediaCodecSelector, MediaFormat mediaFormat)
    throws DecoderQueryException {
  String mimeType = mediaFormat.mimeType;
  return MimeTypes.isVideo(mimeType) && (MimeTypes.VIDEO_UNKNOWN.equals(mimeType)
      || mediaCodecSelector.getDecoderInfo(mimeType, false) != null);
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
protected boolean handlesTrack(MediaCodecSelector mediaCodecSelector, MediaFormat mediaFormat)
    throws DecoderQueryException {
  String mimeType = mediaFormat.mimeType;
  return MimeTypes.isAudio(mimeType) && (MimeTypes.AUDIO_UNKNOWN.equals(mimeType)
      || (allowPassthrough(mimeType) && mediaCodecSelector.getPassthroughDecoderInfo() != null)
      || mediaCodecSelector.getDecoderInfo(mimeType, false) != null);
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
protected DecoderInfo getDecoderInfo(MediaCodecSelector mediaCodecSelector, String mimeType,
    boolean requiresSecureDecoder) throws DecoderQueryException {
  if (allowPassthrough(mimeType)) {
    DecoderInfo passthroughDecoderInfo = mediaCodecSelector.getPassthroughDecoderInfo();
    if (passthroughDecoderInfo != null) {
      passthroughEnabled = true;
      return passthroughDecoderInfo;
    }
  }
  passthroughEnabled = false;
  return super.getDecoderInfo(mediaCodecSelector, mimeType, requiresSecureDecoder);
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
public void onError(Exception e) {
    String errorString = null;
    if (e instanceof UnsupportedDrmException) {
        // Special case DRM failures.
        UnsupportedDrmException unsupportedDrmException = (UnsupportedDrmException) e;
        errorString = getString(Util.SDK_INT < 18 ? R.string.video_error_drm_not_supported
                : unsupportedDrmException.reason == UnsupportedDrmException.REASON_UNSUPPORTED_SCHEME
                ? R.string.video_error_drm_unsupported_scheme : R.string.video_error_drm_unknown);
    } else if (e instanceof ExoPlaybackException
            && e.getCause() instanceof DecoderInitializationException) {
        // Special case for decoder initialization failures.
        DecoderInitializationException decoderInitializationException =
                (DecoderInitializationException) e.getCause();
        if (decoderInitializationException.decoderName == null) {
            if (decoderInitializationException.getCause() instanceof DecoderQueryException) {
                errorString = getString(R.string.video_error_querying_decoders);
            } else if (decoderInitializationException.secureDecoderRequired) {
                errorString = getString(R.string.video_error_no_secure_decoder,
                        decoderInitializationException.mimeType);
            } else {
                errorString = getString(R.string.video_error_no_decoder,
                        decoderInitializationException.mimeType);
            }
        } else {
            errorString = getString(R.string.video_error_instantiating_decoder,
                    decoderInitializationException.decoderName);
        }
    }
    if (errorString != null) {
        Toast.makeText(getApplicationContext(), errorString, Toast.LENGTH_LONG).show();
    }
    playerNeedsPrepare = true;
    showControls();
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
public void onSingleManifest(HlsPlaylist manifest) {
  Handler mainHandler = player.getMainHandler();

  LoadControl loadControl = new DefaultLoadControl(new DefaultAllocator(BUFFER_SEGMENT_SIZE));
  DefaultBandwidthMeter bandwidthMeter = new DefaultBandwidthMeter();

  int[] variantIndices = null;
  if (manifest instanceof HlsMasterPlaylist) {
    HlsMasterPlaylist masterPlaylist = (HlsMasterPlaylist) manifest;
    try {
      variantIndices = VideoFormatSelectorUtil.selectVideoFormatsForDefaultDisplay(
              context, masterPlaylist.variants, null, false);
    } catch (DecoderQueryException e) {
      callback.onRenderersError(e);
      return;
    }
  }

  DataSource dataSource = new DefaultUriDataSource(context, bandwidthMeter, userAgent);
  HlsChunkSource chunkSource = new HlsChunkSource(dataSource, url, manifest, bandwidthMeter,
      variantIndices, HlsChunkSource.ADAPTIVE_MODE_SPLICE, audioCapabilities);
  HlsSampleSource sampleSource = new HlsSampleSource(chunkSource, loadControl,
      BUFFER_SEGMENTS * BUFFER_SEGMENT_SIZE, true, mainHandler, player, DemoPlayer.TYPE_VIDEO);
  MediaCodecVideoTrackRenderer videoRenderer = new MediaCodecVideoTrackRenderer(sampleSource,
      MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT, 5000, mainHandler, player, 50);
  MediaCodecAudioTrackRenderer audioRenderer = new MediaCodecAudioTrackRenderer(sampleSource);

  TrackRenderer[] renderers = new TrackRenderer[DemoPlayer.RENDERER_COUNT];
  renderers[DemoPlayer.TYPE_VIDEO] = videoRenderer;
  renderers[DemoPlayer.TYPE_AUDIO] = audioRenderer;
  callback.onRenderers(null, null, renderers, bandwidthMeter);
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
public void onError(Exception e) {
	String errorString = null;
	if (e instanceof UnsupportedDrmException) {
		// Special case DRM failures.
		UnsupportedDrmException unsupportedDrmException = (UnsupportedDrmException) e;
		errorString = getString(Util.SDK_INT < 18 ? R.string.error_drm_not_supported
				: unsupportedDrmException.reason == UnsupportedDrmException.REASON_UNSUPPORTED_SCHEME
				? R.string.error_drm_unsupported_scheme : R.string.error_drm_unknown);
	} else if (e instanceof ExoPlaybackException
			&& e.getCause() instanceof DecoderInitializationException) {
		// Special case for decoder initialization failures.
		DecoderInitializationException decoderInitializationException =
				(DecoderInitializationException) e.getCause();
		if (decoderInitializationException.decoderName == null) {
			if (decoderInitializationException.getCause() instanceof DecoderQueryException) {
				errorString = getString(R.string.error_querying_decoders);
			} else if (decoderInitializationException.secureDecoderRequired) {
				errorString = getString(R.string.error_no_secure_decoder,
						decoderInitializationException.mimeType);
			} else {
				errorString = getString(R.string.error_no_decoder,
						decoderInitializationException.mimeType);
			}
		} else {
			errorString = getString(R.string.error_instantiating_decoder,
					decoderInitializationException.decoderName);
		}
	}
	if (errorString != null) {
		Toast.makeText(getApplicationContext(), errorString, Toast.LENGTH_LONG).show();
	}
	playerNeedsPrepare = true;
	updateButtonVisibilities();
	showControls();
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
public void onSingleManifest(HlsPlaylist manifest) {
  if (canceled) {
    return;
  }

  Handler mainHandler = player.getMainHandler();
  LoadControl loadControl = new DefaultLoadControl(new DefaultAllocator(BUFFER_SEGMENT_SIZE));
  DefaultBandwidthMeter bandwidthMeter = new DefaultBandwidthMeter();

  int[] variantIndices = null;
  if (manifest instanceof HlsMasterPlaylist) {
    HlsMasterPlaylist masterPlaylist = (HlsMasterPlaylist) manifest;
    try {
      variantIndices = VideoFormatSelectorUtil.selectVideoFormatsForDefaultDisplay(
          context, masterPlaylist.variants, null, false);
    } catch (DecoderQueryException e) {
      player.onRenderersError(e);
      return;
    }
    if (variantIndices.length == 0) {
      player.onRenderersError(new IllegalStateException("No variants selected."));
      return;
    }
  }

  DataSource dataSource = new DefaultUriDataSource(context, bandwidthMeter, userAgent);
  HlsChunkSource chunkSource = new HlsChunkSource(dataSource, url, manifest, bandwidthMeter,
      variantIndices, HlsChunkSource.ADAPTIVE_MODE_SPLICE);
  HlsSampleSource sampleSource = new HlsSampleSource(chunkSource, loadControl,
      BUFFER_SEGMENTS * BUFFER_SEGMENT_SIZE, mainHandler, player, DemoPlayer.TYPE_VIDEO);
  MediaCodecVideoTrackRenderer videoRenderer = new MediaCodecVideoTrackRenderer(context,
      sampleSource, MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT, 5000, mainHandler, player, 50);
  MediaCodecAudioTrackRenderer audioRenderer = new MediaCodecAudioTrackRenderer(sampleSource,
      null, true, player.getMainHandler(), player, AudioCapabilities.getCapabilities(context));
  MetadataTrackRenderer<Map<String, Object>> id3Renderer = new MetadataTrackRenderer<>(
      sampleSource, new Id3Parser(), player, mainHandler.getLooper());
  Eia608TrackRenderer closedCaptionRenderer = new Eia608TrackRenderer(sampleSource, player,
      mainHandler.getLooper());

  TrackRenderer[] renderers = new TrackRenderer[DemoPlayer.RENDERER_COUNT];
  renderers[DemoPlayer.TYPE_VIDEO] = videoRenderer;
  renderers[DemoPlayer.TYPE_AUDIO] = audioRenderer;
  renderers[DemoPlayer.TYPE_METADATA] = id3Renderer;
  renderers[DemoPlayer.TYPE_TEXT] = closedCaptionRenderer;
  player.onRenderers(renderers, bandwidthMeter);
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
public void onSingleManifest(HlsPlaylist manifest) {
  if (canceled) {
    return;
  }

  Handler mainHandler = player.getMainHandler();
  LoadControl loadControl = new DefaultLoadControl(new DefaultAllocator(BUFFER_SEGMENT_SIZE));
  DefaultBandwidthMeter bandwidthMeter = new DefaultBandwidthMeter();

  int[] variantIndices = null;
  if (manifest instanceof HlsMasterPlaylist) {
    HlsMasterPlaylist masterPlaylist = (HlsMasterPlaylist) manifest;
    try {
      variantIndices = VideoFormatSelectorUtil.selectVideoFormatsForDefaultDisplay(
        context, masterPlaylist.variants, null, false);
    } catch (DecoderQueryException e) {
      player.onRenderersError(e);
      return;
    }
    if (variantIndices.length == 0) {
      player.onRenderersError(new IllegalStateException("No variants selected."));
      return;
    }
  }

  DataSource dataSource = new DefaultUriDataSource(context, bandwidthMeter, userAgent);
  HlsChunkSource chunkSource = new HlsChunkSource(dataSource, url, manifest, bandwidthMeter,
      variantIndices, HlsChunkSource.ADAPTIVE_MODE_SPLICE, audioCapabilities);
  HlsSampleSource sampleSource = new HlsSampleSource(chunkSource, loadControl,
      BUFFER_SEGMENTS * BUFFER_SEGMENT_SIZE, mainHandler, player, MediaPlayer.TYPE_VIDEO);
  MediaCodecVideoTrackRenderer videoRenderer = new MediaCodecVideoTrackRenderer(sampleSource,
      MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT, 5000, mainHandler, player, 50);
  MediaCodecAudioTrackRenderer audioRenderer = new MediaCodecAudioTrackRenderer(sampleSource);
  MetadataTrackRenderer<Map<String, Object>> id3Renderer = new MetadataTrackRenderer<>(
      sampleSource, new Id3Parser(), player, mainHandler.getLooper());
  Eia608TrackRenderer closedCaptionRenderer = new Eia608TrackRenderer(sampleSource, player,
      mainHandler.getLooper());
  TrackRenderer[] renderers = new TrackRenderer[MediaPlayer.RENDERER_COUNT];
  renderers[MediaPlayer.TYPE_VIDEO] = videoRenderer;
  renderers[MediaPlayer.TYPE_AUDIO] = audioRenderer;
  renderers[MediaPlayer.TYPE_METADATA] = id3Renderer;
  renderers[MediaPlayer.TYPE_TEXT] = closedCaptionRenderer;
  player.onRenderers(null, null, renderers, bandwidthMeter);
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
protected final boolean handlesTrack(MediaFormat mediaFormat) throws DecoderQueryException {
  return handlesTrack(mediaCodecSelector, mediaFormat);
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
protected final boolean doPrepare(long positionUs) throws ExoPlaybackException {
  boolean allSourcesPrepared = true;
  for (int i = 0; i < sources.length; i++) {
    allSourcesPrepared &= sources[i].prepare(positionUs);
  }
  if (!allSourcesPrepared) {
    return false;
  }
  // The sources are all prepared.
  int totalSourceTrackCount = 0;
  for (int i = 0; i < sources.length; i++) {
    totalSourceTrackCount += sources[i].getTrackCount();
  }
  long durationUs = 0;
  int handledTrackCount = 0;
  int[] handledSourceIndices = new int[totalSourceTrackCount];
  int[] handledTrackIndices = new int[totalSourceTrackCount];
  int sourceCount = sources.length;
  for (int sourceIndex = 0; sourceIndex < sourceCount; sourceIndex++) {
    SampleSourceReader source = sources[sourceIndex];
    int sourceTrackCount = source.getTrackCount();
    for (int trackIndex = 0; trackIndex < sourceTrackCount; trackIndex++) {
      MediaFormat format = source.getFormat(trackIndex);
      boolean handlesTrack;
      try {
        handlesTrack = handlesTrack(format);
      } catch (DecoderQueryException e) {
        throw new ExoPlaybackException(e);
      }
      if (handlesTrack) {
        handledSourceIndices[handledTrackCount] = sourceIndex;
        handledTrackIndices[handledTrackCount] = trackIndex;
        handledTrackCount++;
        if (durationUs == TrackRenderer.UNKNOWN_TIME_US) {
          // We've already encountered a track for which the duration is unknown, so the media
          // duration is unknown regardless of the duration of this track.
        } else {
          long trackDurationUs = format.durationUs;
          if (trackDurationUs == TrackRenderer.UNKNOWN_TIME_US) {
            durationUs = TrackRenderer.UNKNOWN_TIME_US;
          } else if (trackDurationUs == TrackRenderer.MATCH_LONGEST_US) {
            // Do nothing.
          } else {
            durationUs = Math.max(durationUs, trackDurationUs);
          }
        }
      }
    }
  }
  this.durationUs = durationUs;
  this.handledSourceIndices = Arrays.copyOf(handledSourceIndices, handledTrackCount);
  this.handledSourceTrackIndices = Arrays.copyOf(handledTrackIndices, handledTrackCount);
  return true;
}
 

import com.google.android.exoplayer.MediaCodecUtil.DecoderQueryException; //导入依赖的package包/类
@Override
public DecoderInfo getDecoderInfo(String mimeType, boolean requiresSecureDecoder)
    throws DecoderQueryException {
  return MediaCodecUtil.getDecoderInfo(mimeType, requiresSecureDecoder);
}