Java 类com.google.android.exoplayer2.Format 实例源码

/**
 * Returns the DTS format given {@code data} containing the DTS frame according to ETSI TS 102 114
 * subsections 5.3/5.4.
 *
 * @param frame The DTS frame to parse.
 * @param trackId The track identifier to set on the format, or null.
 * @param language The language to set on the format.
 * @param drmInitData {@link DrmInitData} to be included in the format.
 * @return The DTS format parsed from data in the header.
 */
public static Format parseDtsFormat(byte[] frame, String trackId, String language,
    DrmInitData drmInitData) {
  ParsableBitArray frameBits = new ParsableBitArray(frame);
  frameBits.skipBits(4 * 8 + 1 + 5 + 1 + 7 + 14); // SYNC, FTYPE, SHORT, CPF, NBLKS, FSIZE
  int amode = frameBits.readBits(6);
  int channelCount = CHANNELS_BY_AMODE[amode];
  int sfreq = frameBits.readBits(4);
  int sampleRate = SAMPLE_RATE_BY_SFREQ[sfreq];
  int rate = frameBits.readBits(5);
  int bitrate = rate >= TWICE_BITRATE_KBPS_BY_RATE.length ? Format.NO_VALUE
      : TWICE_BITRATE_KBPS_BY_RATE[rate] * 1000 / 2;
  frameBits.skipBits(10); // MIX, DYNF, TIMEF, AUXF, HDCD, EXT_AUDIO_ID, EXT_AUDIO, ASPF
  channelCount += frameBits.readBits(2) > 0 ? 1 : 0; // LFF
  return Format.createAudioSampleFormat(trackId, MimeTypes.AUDIO_DTS, null, bitrate,
      Format.NO_VALUE, channelCount, sampleRate, null, drmInitData, 0, language);
}

/**
 * Computes the ideal selected index ignoring buffer health.
 *
 * @param nowMs The current time in the timebase of {@link SystemClock#elapsedRealtime()}, or
 *     {@link Long#MIN_VALUE} to ignore blacklisting.
 */
private int determineIdealSelectedIndex(long nowMs) {
  long bitrateEstimate = bandwidthMeter.getBitrateEstimate();
  long effectiveBitrate = bitrateEstimate == BandwidthMeter.NO_ESTIMATE
      ? maxInitialBitrate : (long) (bitrateEstimate * bandwidthFraction);
  int lowestBitrateNonBlacklistedIndex = 0;
  for (int i = 0; i < length; i++) {
    if (nowMs == Long.MIN_VALUE || !isBlacklisted(i, nowMs)) {
      Format format = getFormat(i);
      if (format.bitrate <= effectiveBitrate) {
        return i;
      } else {
        lowestBitrateNonBlacklistedIndex = i;
      }
    }
  }
  return lowestBitrateNonBlacklistedIndex;
}

private static int getAudioTrackScore(int formatSupport, String preferredLanguage,
    Format format) {
  boolean isDefault = (format.selectionFlags & C.SELECTION_FLAG_DEFAULT) != 0;
  int trackScore;
  if (formatHasLanguage(format, preferredLanguage)) {
    if (isDefault) {
      trackScore = 4;
    } else {
      trackScore = 3;
    }
  } else if (isDefault) {
    trackScore = 2;
  } else {
    trackScore = 1;
  }
  if (isSupported(formatSupport, false)) {
    trackScore += WITHIN_RENDERER_CAPABILITIES_BONUS;
  }
  return trackScore;
}

/**
 * @param context A context.
 * @param mediaCodecSelector A decoder selector.
 * @param allowedJoiningTimeMs The maximum duration in milliseconds for which this video renderer
 *     can attempt to seamlessly join an ongoing playback.
 * @param drmSessionManager For use with encrypted content. May be null if support for encrypted
 *     content is not required.
 * @param playClearSamplesWithoutKeys Encrypted media may contain clear (un-encrypted) regions.
 *     For example a media file may start with a short clear region so as to allow playback to
 *     begin in parallel with key acquisition. This parameter specifies whether the renderer is
 *     permitted to play clear regions of encrypted media files before {@code drmSessionManager}
 *     has obtained the keys necessary to decrypt encrypted regions of the media.
 * @param eventHandler A handler to use when delivering events to {@code eventListener}. May be
 *     null if delivery of events is not required.
 * @param eventListener A listener of events. May be null if delivery of events is not required.
 * @param maxDroppedFramesToNotify The maximum number of frames that can be dropped between
 *     invocations of {@link VideoRendererEventListener#onDroppedFrames(int, long)}.
 */
public MediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector,
    long allowedJoiningTimeMs, DrmSessionManager<FrameworkMediaCrypto> drmSessionManager,
    boolean playClearSamplesWithoutKeys, Handler eventHandler,
    VideoRendererEventListener eventListener, int maxDroppedFramesToNotify) {
  super(C.TRACK_TYPE_VIDEO, mediaCodecSelector, drmSessionManager, playClearSamplesWithoutKeys);
  this.allowedJoiningTimeMs = allowedJoiningTimeMs;
  this.maxDroppedFramesToNotify = maxDroppedFramesToNotify;
  frameReleaseTimeHelper = new VideoFrameReleaseTimeHelper(context);
  eventDispatcher = new EventDispatcher(eventHandler, eventListener);
  deviceNeedsAutoFrcWorkaround = deviceNeedsAutoFrcWorkaround();
  joiningDeadlineMs = C.TIME_UNSET;
  currentWidth = Format.NO_VALUE;
  currentHeight = Format.NO_VALUE;
  currentPixelWidthHeightRatio = Format.NO_VALUE;
  pendingPixelWidthHeightRatio = Format.NO_VALUE;
  scalingMode = C.VIDEO_SCALING_MODE_DEFAULT;
  clearReportedVideoSize();
}

int readData(int group, FormatHolder formatHolder, DecoderInputBuffer buffer,
    boolean requireFormat) {
  if (isPendingReset()) {
    return C.RESULT_NOTHING_READ;
  }

  while (mediaChunks.size() > 1 && finishedReadingChunk(mediaChunks.getFirst())) {
    mediaChunks.removeFirst();
  }
  HlsMediaChunk currentChunk = mediaChunks.getFirst();
  Format trackFormat = currentChunk.trackFormat;
  if (!trackFormat.equals(downstreamTrackFormat)) {
    eventDispatcher.downstreamFormatChanged(trackType, trackFormat,
        currentChunk.trackSelectionReason, currentChunk.trackSelectionData,
        currentChunk.startTimeUs);
  }
  downstreamTrackFormat = trackFormat;

  return sampleQueues.valueAt(group).readData(formatHolder, buffer, requireFormat,
      loadingFinished, lastSeekPositionUs);
}

/**
 * Returns the E-AC-3 format given {@code data} containing the EC3SpecificBox according to
 * ETSI TS 102 366 Annex F. The reading position of {@code data} will be modified.
 *
 * @param data The EC3SpecificBox to parse.
 * @param trackId The track identifier to set on the format, or null.
 * @param language The language to set on the format.
 * @param drmInitData {@link DrmInitData} to be included in the format.
 * @return The E-AC-3 format parsed from data in the header.
 */
public static Format parseEAc3AnnexFFormat(ParsableByteArray data, String trackId,
    String language, DrmInitData drmInitData) {
  data.skipBytes(2); // data_rate, num_ind_sub

  // Read only the first substream.
  // TODO: Read later substreams?
  int fscod = (data.readUnsignedByte() & 0xC0) >> 6;
  int sampleRate = SAMPLE_RATE_BY_FSCOD[fscod];
  int nextByte = data.readUnsignedByte();
  int channelCount = CHANNEL_COUNT_BY_ACMOD[(nextByte & 0x0E) >> 1];
  if ((nextByte & 0x01) != 0) { // lfeon
    channelCount++;
  }
  return Format.createAudioSampleFormat(trackId, MimeTypes.AUDIO_E_AC3, null, Format.NO_VALUE,
      Format.NO_VALUE, channelCount, sampleRate, null, drmInitData, 0, language);
}

/**
 * Parses the sample header.
 */
@SuppressWarnings("ReferenceEquality")
private void parseHeader() {
  headerScratchBits.setPosition(0);
  Ac3Util.Ac3SyncFrameInfo frameInfo = Ac3Util.parseAc3SyncframeInfo(headerScratchBits);
  if (format == null || frameInfo.channelCount != format.channelCount
      || frameInfo.sampleRate != format.sampleRate
      || frameInfo.mimeType != format.sampleMimeType) {
    format = Format.createAudioSampleFormat(trackFormatId, frameInfo.mimeType, null,
        Format.NO_VALUE, Format.NO_VALUE, frameInfo.channelCount, frameInfo.sampleRate, null,
        null, 0, language);
    output.format(format);
  }
  sampleSize = frameInfo.frameSize;
  // In this class a sample is an access unit (syncframe in AC-3), but the MediaFormat sample rate
  // specifies the number of PCM audio samples per second.
  sampleDurationUs = C.MICROS_PER_SECOND * frameInfo.sampleCount / format.sampleRate;
}

@Override
public void consume(ParsableByteArray sectionData) {
  if (!formatDeclared) {
    if (timestampAdjuster.getTimestampOffsetUs() == C.TIME_UNSET) {
      // There is not enough information to initialize the timestamp adjuster.
      return;
    }
    output.format(Format.createSampleFormat(null, MimeTypes.APPLICATION_SCTE35,
        timestampAdjuster.getTimestampOffsetUs()));
    formatDeclared = true;
  }
  int sampleSize = sectionData.bytesLeft();
  output.sampleData(sectionData, sampleSize);
  output.sampleMetadata(timestampAdjuster.getLastAdjustedTimestampUs(), C.BUFFER_FLAG_KEY_FRAME,
      sampleSize, 0, null);
}

@Override
protected boolean readHeaders(ParsableByteArray packet, long position, SetupData setupData)
    throws IOException, InterruptedException {
  if (!headerRead) {
    byte[] metadata = Arrays.copyOf(packet.data, packet.limit());
    int channelCount = metadata[9] & 0xFF;
    int preskip = ((metadata[11] & 0xFF) << 8) | (metadata[10] & 0xFF);

    List<byte[]> initializationData = new ArrayList<>(3);
    initializationData.add(metadata);
    putNativeOrderLong(initializationData, preskip);
    putNativeOrderLong(initializationData, DEFAULT_SEEK_PRE_ROLL_SAMPLES);

    setupData.format = Format.createAudioSampleFormat(null, MimeTypes.AUDIO_OPUS, null,
        Format.NO_VALUE, Format.NO_VALUE, channelCount, SAMPLE_RATE, initializationData, null, 0,
        null);
    headerRead = true;
  } else {
    boolean headerPacket = packet.readInt() == OPUS_CODE;
    packet.setPosition(0);
    return headerPacket;
  }
  return true;
}

public Track(int id, int type, long timescale, long movieTimescale, long durationUs,
    Format format, @Transformation int sampleTransformation,
    TrackEncryptionBox[] sampleDescriptionEncryptionBoxes, int nalUnitLengthFieldLength,
    long[] editListDurations, long[] editListMediaTimes) {
  this.id = id;
  this.type = type;
  this.timescale = timescale;
  this.movieTimescale = movieTimescale;
  this.durationUs = durationUs;
  this.format = format;
  this.sampleTransformation = sampleTransformation;
  this.sampleDescriptionEncryptionBoxes = sampleDescriptionEncryptionBoxes;
  this.nalUnitLengthFieldLength = nalUnitLengthFieldLength;
  this.editListDurations = editListDurations;
  this.editListMediaTimes = editListMediaTimes;
}

@Override
public SubtitleDecoder createDecoder(Format format) {
  switch (format.sampleMimeType) {
    case MimeTypes.TEXT_VTT:
      return new WebvttDecoder();
    case MimeTypes.APPLICATION_MP4VTT:
      return new Mp4WebvttDecoder();
    case MimeTypes.APPLICATION_TTML:
      return new TtmlDecoder();
    case MimeTypes.APPLICATION_SUBRIP:
      return new SubripDecoder();
    case MimeTypes.APPLICATION_TX3G:
      return new Tx3gDecoder(format.initializationData);
    case MimeTypes.APPLICATION_CEA608:
    case MimeTypes.APPLICATION_MP4CEA608:
      return new Cea608Decoder(format.sampleMimeType, format.accessibilityChannel);
    case MimeTypes.APPLICATION_CEA708:
      return new Cea708Decoder(format.accessibilityChannel);
    case MimeTypes.APPLICATION_DVBSUBS:
      return new DvbDecoder(format.initializationData);
    default:
      throw new IllegalArgumentException("Attempted to create decoder for unsupported format");
  }
}

private void videoLoaded() {
    if (loadVideoStarted) {
        loadVideoStarted = false;
        Format videoFormat = player.getVideoFormat();
        int width = videoFormat != null ? videoFormat.width : 0;
        int height = videoFormat != null ? videoFormat.height : 0;
        eventEmitter.load(player.getDuration(), player.getCurrentPosition(), width, height);
    }
}

@Override
protected boolean canReconfigureCodec(MediaCodec codec, boolean codecIsAdaptive,
    Format oldFormat, Format newFormat) {
  return areAdaptationCompatible(codecIsAdaptive, oldFormat, newFormat)
      && newFormat.width <= codecMaxValues.width && newFormat.height <= codecMaxValues.height
      && newFormat.maxInputSize <= codecMaxValues.inputSize;
}

@Override
protected void onInputFormatChanged(Format newFormat) throws ExoPlaybackException {
  super.onInputFormatChanged(newFormat);
  eventDispatcher.inputFormatChanged(newFormat);
  // If the input format is anything other than PCM then we assume that the audio decoder will
  // output 16-bit PCM.
  pcmEncoding = MimeTypes.AUDIO_RAW.equals(newFormat.sampleMimeType) ? newFormat.pcmEncoding
      : C.ENCODING_PCM_16BIT;
  channelCount = newFormat.channelCount;
}

private static boolean isSupportedAdaptiveAudioTrack(Format format, int formatSupport,
    AudioConfigurationTuple configuration) {
  return isSupported(formatSupport, false) && format.channelCount == configuration.channelCount
      && format.sampleRate == configuration.sampleRate
      && (configuration.mimeType == null
          || TextUtils.equals(configuration.mimeType, format.sampleMimeType));
}

@Override
public void onLoadError(DataSpec dataSpec, int dataType, int trackType, Format trackFormat,
    int trackSelectionReason, Object trackSelectionData, long mediaStartTimeMs,
    long mediaEndTimeMs, long elapsedRealtimeMs, long loadDurationMs, long bytesLoaded,
    IOException error, boolean wasCanceled) {
  printInternalError("loadError", error);
}

@Override
public MetadataDecoder createDecoder(Format format) {
  switch (format.sampleMimeType) {
    case MimeTypes.APPLICATION_ID3:
      return new Id3Decoder();
    case MimeTypes.APPLICATION_EMSG:
      return new EventMessageDecoder();
    case MimeTypes.APPLICATION_SCTE35:
      return new SpliceInfoDecoder();
    default:
      throw new IllegalArgumentException("Attempted to create decoder for unsupported format");
  }
}

/**
 * Parses AVC configuration data.
 *
 * @param data A {@link ParsableByteArray}, whose position is set to the start of the AVC
 *     configuration data to parse.
 * @return A parsed representation of the HEVC configuration data.
 * @throws ParserException If an error occurred parsing the data.
 */
public static AvcConfig parse(ParsableByteArray data) throws ParserException {
  try {
    data.skipBytes(4); // Skip to the AVCDecoderConfigurationRecord (defined in 14496-15)
    int nalUnitLengthFieldLength = (data.readUnsignedByte() & 0x3) + 1;
    if (nalUnitLengthFieldLength == 3) {
      throw new IllegalStateException();
    }
    List<byte[]> initializationData = new ArrayList<>();
    int numSequenceParameterSets = data.readUnsignedByte() & 0x1F;
    for (int j = 0; j < numSequenceParameterSets; j++) {
      initializationData.add(buildNalUnitForChild(data));
    }
    int numPictureParameterSets = data.readUnsignedByte();
    for (int j = 0; j < numPictureParameterSets; j++) {
      initializationData.add(buildNalUnitForChild(data));
    }

    int width = Format.NO_VALUE;
    int height = Format.NO_VALUE;
    float pixelWidthAspectRatio = 1;
    if (numSequenceParameterSets > 0) {
      byte[] sps = initializationData.get(0);
      SpsData spsData = NalUnitUtil.parseSpsNalUnit(initializationData.get(0),
          nalUnitLengthFieldLength, sps.length);
      width = spsData.width;
      height = spsData.height;
      pixelWidthAspectRatio = spsData.pixelWidthAspectRatio;
    }
    return new AvcConfig(initializationData, nalUnitLengthFieldLength, width, height,
        pixelWidthAspectRatio);
  } catch (ArrayIndexOutOfBoundsException e) {
    throw new ParserException("Error parsing AVC config", e);
  }
}

@Override
public final int supportsFormat(Format format) throws ExoPlaybackException {
  try {
    return supportsFormat(mediaCodecSelector, format);
  } catch (DecoderQueryException e) {
    throw ExoPlaybackException.createForRenderer(e, getIndex());
  }
}

public DecoderInitializationException(Format format, Throwable cause,
    boolean secureDecoderRequired, String decoderName) {
  super("Decoder init failed: " + decoderName + ", " + format, cause);
  this.mimeType = format.sampleMimeType;
  this.secureDecoderRequired = secureDecoderRequired;
  this.decoderName = decoderName;
  this.diagnosticInfo = Util.SDK_INT >= 21 ? getDiagnosticInfoV21(cause) : null;
}

public void loadCanceled(final DataSpec dataSpec, final int dataType, final int trackType,
    final Format trackFormat, final int trackSelectionReason, final Object trackSelectionData,
    final long mediaStartTimeUs, final long mediaEndTimeUs, final long elapsedRealtimeMs,
    final long loadDurationMs, final long bytesLoaded) {
  if (listener != null) {
    handler.post(new Runnable()  {
      @Override
      public void run() {
        listener.onLoadCanceled(dataSpec, dataType, trackType, trackFormat,
            trackSelectionReason, trackSelectionData, adjustMediaTime(mediaStartTimeUs),
            adjustMediaTime(mediaEndTimeUs), elapsedRealtimeMs, loadDurationMs, bytesLoaded);
      }
    });
  }
}

@Override
protected int supportsFormat(MediaCodecSelector mediaCodecSelector, Format format)
    throws DecoderQueryException {
  String mimeType = format.sampleMimeType;
  if (!MimeTypes.isVideo(mimeType)) {
    return FORMAT_UNSUPPORTED_TYPE;
  }
  boolean requiresSecureDecryption = false;
  DrmInitData drmInitData = format.drmInitData;
  if (drmInitData != null) {
    for (int i = 0; i < drmInitData.schemeDataCount; i++) {
      requiresSecureDecryption |= drmInitData.get(i).requiresSecureDecryption;
    }
  }
  MediaCodecInfo decoderInfo = mediaCodecSelector.getDecoderInfo(mimeType,
      requiresSecureDecryption);
  if (decoderInfo == null) {
    return FORMAT_UNSUPPORTED_SUBTYPE;
  }

  boolean decoderCapable = decoderInfo.isCodecSupported(format.codecs);
  if (decoderCapable && format.width > 0 && format.height > 0) {
    if (Util.SDK_INT >= 21) {
      decoderCapable = decoderInfo.isVideoSizeAndRateSupportedV21(format.width, format.height,
          format.frameRate);
    } else {
      decoderCapable = format.width * format.height <= MediaCodecUtil.maxH264DecodableFrameSize();
      if (!decoderCapable) {
        Log.d(TAG, "FalseCheck [legacyFrameSize, " + format.width + "x" + format.height + "] ["
            + Util.DEVICE_DEBUG_INFO + "]");
      }
    }
  }

  int adaptiveSupport = decoderInfo.adaptive ? ADAPTIVE_SEAMLESS : ADAPTIVE_NOT_SEAMLESS;
  int tunnelingSupport = decoderInfo.tunneling ? TUNNELING_SUPPORTED : TUNNELING_NOT_SUPPORTED;
  int formatSupport = decoderCapable ? FORMAT_HANDLED : FORMAT_EXCEEDS_CAPABILITIES;
  return adaptiveSupport | tunnelingSupport | formatSupport;
}

@Override
public void onTracksChanged(TrackGroupArray trackGroups, TrackSelectionArray trackSelections) {
    if (trackGroups.length > 0) {
        // update format metadata of station
        Format format = trackGroups.get(0).getFormat(0);
        mStation.setMimeType(format.sampleMimeType);
        mStation.setChannelCount(format.channelCount);
        mStation.setSampleRate(format.sampleRate);
        mStation.setBitrate(format.bitrate);
        saveAppState();
    }
}

private TrackOutput buildTrackOutput(long subsampleOffsetUs) {
  TrackOutput trackOutput = output.track(0, C.TRACK_TYPE_TEXT);
  trackOutput.format(Format.createTextSampleFormat(null, MimeTypes.TEXT_VTT, null,
      Format.NO_VALUE, 0, language, null, subsampleOffsetUs));
  output.endTracks();
  return trackOutput;
}

/**
 * @param baseUri The base uri. Used to resolve relative paths.
 * @param variants See {@link #variants}.
 * @param audios See {@link #audios}.
 * @param subtitles See {@link #subtitles}.
 * @param muxedAudioFormat See {@link #muxedAudioFormat}.
 * @param muxedCaptionFormats See {@link #muxedCaptionFormats}.
 */
public HlsMasterPlaylist(String baseUri, List<HlsUrl> variants, List<HlsUrl> audios,
    List<HlsUrl> subtitles, Format muxedAudioFormat, List<Format> muxedCaptionFormats) {
  super(baseUri);
  this.variants = Collections.unmodifiableList(variants);
  this.audios = Collections.unmodifiableList(audios);
  this.subtitles = Collections.unmodifiableList(subtitles);
  this.muxedAudioFormat = muxedAudioFormat;
  this.muxedCaptionFormats = muxedCaptionFormats != null
      ? Collections.unmodifiableList(muxedCaptionFormats) : null;
}

/**
 * @param dataSource The source from which the data should be loaded.
 * @param dataSpec Defines the data to be loaded.
 * @param type See {@link #type}.
 * @param trackFormat See {@link #trackFormat}.
 * @param trackSelectionReason See {@link #trackSelectionReason}.
 * @param trackSelectionData See {@link #trackSelectionData}.
 * @param startTimeUs See {@link #startTimeUs}.
 * @param endTimeUs See {@link #endTimeUs}.
 */
public Chunk(DataSource dataSource, DataSpec dataSpec, int type, Format trackFormat,
    int trackSelectionReason, Object trackSelectionData, long startTimeUs, long endTimeUs) {
  this.dataSource = Assertions.checkNotNull(dataSource);
  this.dataSpec = Assertions.checkNotNull(dataSpec);
  this.type = type;
  this.trackFormat = trackFormat;
  this.trackSelectionReason = trackSelectionReason;
  this.trackSelectionData = trackSelectionData;
  this.startTimeUs = startTimeUs;
  this.endTimeUs = endTimeUs;
}

public void createTracks(ExtractorOutput extractorOutput, TrackIdGenerator idGenerator) {
  for (int i = 0; i < outputs.length; i++) {
    idGenerator.generateNewId();
    TrackOutput output = extractorOutput.track(idGenerator.getTrackId(), C.TRACK_TYPE_TEXT);
    Format channelFormat = closedCaptionFormats.get(i);
    String channelMimeType = channelFormat.sampleMimeType;
    Assertions.checkArgument(MimeTypes.APPLICATION_CEA608.equals(channelMimeType)
        || MimeTypes.APPLICATION_CEA708.equals(channelMimeType),
        "Invalid closed caption mime type provided: " + channelMimeType);
    output.format(Format.createTextSampleFormat(idGenerator.getFormatId(), channelMimeType, null,
        Format.NO_VALUE, channelFormat.selectionFlags, channelFormat.language,
        channelFormat.accessibilityChannel, null));
    outputs[i] = output;
  }
}

@Override
public final int supportsFormat(Format format) {
  int formatSupport = supportsFormatInternal(format);
  if (formatSupport == FORMAT_UNSUPPORTED_TYPE || formatSupport == FORMAT_UNSUPPORTED_SUBTYPE) {
    return formatSupport;
  }
  int tunnelingSupport = Util.SDK_INT >= 21 ? TUNNELING_SUPPORTED : TUNNELING_NOT_SUPPORTED;
  return ADAPTIVE_NOT_SEAMLESS | tunnelingSupport | formatSupport;
}

/**
 * Invokes {@link AudioRendererEventListener#onAudioInputFormatChanged(Format)}.
 */
public void inputFormatChanged(final Format format) {
  if (listener != null) {
    handler.post(new Runnable() {
      @Override
      public void run() {
        listener.onAudioInputFormatChanged(format);
      }
    });
  }
}

@Override
public void createTracks(ExtractorOutput extractorOutput, TrackIdGenerator idGenerator) {
  idGenerator.generateNewId();
  output = extractorOutput.track(idGenerator.getTrackId(), C.TRACK_TYPE_METADATA);
  output.format(Format.createSampleFormat(idGenerator.getFormatId(), MimeTypes.APPLICATION_ID3,
      null, Format.NO_VALUE, null));
}

private void discardDownstreamMediaChunks(int primaryStreamReadIndex) {
  while (mediaChunks.size() > 1
      && mediaChunks.get(1).getFirstSampleIndex(0) <= primaryStreamReadIndex) {
    mediaChunks.removeFirst();
  }
  BaseMediaChunk currentChunk = mediaChunks.getFirst();
  Format trackFormat = currentChunk.trackFormat;
  if (!trackFormat.equals(primaryDownstreamTrackFormat)) {
    eventDispatcher.downstreamFormatChanged(primaryTrackType, trackFormat,
        currentChunk.trackSelectionReason, currentChunk.trackSelectionData,
        currentChunk.startTimeUs);
  }
  primaryDownstreamTrackFormat = trackFormat;
}

@Override
public int read(ExtractorInput input, PositionHolder seekPosition)
    throws IOException, InterruptedException {
  if (wavHeader == null) {
    wavHeader = WavHeaderReader.peek(input);
    if (wavHeader == null) {
      // Should only happen if the media wasn't sniffed.
      throw new ParserException("Unsupported or unrecognized wav header.");
    }
    Format format = Format.createAudioSampleFormat(null, MimeTypes.AUDIO_RAW, null,
        wavHeader.getBitrate(), MAX_INPUT_SIZE, wavHeader.getNumChannels(),
        wavHeader.getSampleRateHz(), wavHeader.getEncoding(), null, null, 0, null);
    trackOutput.format(format);
    bytesPerFrame = wavHeader.getBytesPerFrame();
  }

  if (!wavHeader.hasDataBounds()) {
    WavHeaderReader.skipToData(input, wavHeader);
    extractorOutput.seekMap(this);
  }

  int bytesAppended = trackOutput.sampleData(input, MAX_INPUT_SIZE - pendingBytes, true);
  if (bytesAppended != RESULT_END_OF_INPUT) {
    pendingBytes += bytesAppended;
  }

  // Samples must consist of a whole number of frames.
  int pendingFrames = pendingBytes / bytesPerFrame;
  if (pendingFrames > 0) {
    long timeUs = wavHeader.getTimeUs(input.getPosition() - pendingBytes);
    int size = pendingFrames * bytesPerFrame;
    pendingBytes -= size;
    trackOutput.sampleMetadata(timeUs, C.BUFFER_FLAG_KEY_FRAME, size, pendingBytes, null);
  }

  return bytesAppended == RESULT_END_OF_INPUT ? RESULT_END_OF_INPUT : RESULT_CONTINUE;
}

/**
 * Called when a new format is read from the upstream {@link MediaPeriod}.
 *
 * @param newFormat The new format.
 * @throws ExoPlaybackException If an error occurs reinitializing the {@link MediaCodec}.
 */
protected void onInputFormatChanged(Format newFormat) throws ExoPlaybackException {
  Format oldFormat = format;
  format = newFormat;

  boolean drmInitDataChanged = !Util.areEqual(format.drmInitData, oldFormat == null ? null
      : oldFormat.drmInitData);
  if (drmInitDataChanged) {
    if (format.drmInitData != null) {
      if (drmSessionManager == null) {
        throw ExoPlaybackException.createForRenderer(
            new IllegalStateException("Media requires a DrmSessionManager"), getIndex());
      }
      pendingDrmSession = drmSessionManager.acquireSession(Looper.myLooper(), format.drmInitData);
      if (pendingDrmSession == drmSession) {
        drmSessionManager.releaseSession(pendingDrmSession);
      }
    } else {
      pendingDrmSession = null;
    }
  }

  if (pendingDrmSession == drmSession && codec != null
      && canReconfigureCodec(codec, codecIsAdaptive, oldFormat, format)) {
    codecReconfigured = true;
    codecReconfigurationState = RECONFIGURATION_STATE_WRITE_PENDING;
    codecNeedsAdaptationWorkaroundBuffer = codecNeedsAdaptationWorkaround
        && format.width == oldFormat.width && format.height == oldFormat.height;
  } else {
    if (codecReceivedBuffers) {
      // Signal end of stream and wait for any final output buffers before re-initialization.
      codecReinitializationState = REINITIALIZATION_STATE_SIGNAL_END_OF_STREAM;
    } else {
      // There aren't any final output buffers, so perform re-initialization immediately.
      releaseCodec();
      maybeInitCodec();
    }
  }
}

/**
 * Parses a stsd atom (defined in 14496-12).
 *
 * @param stsd The stsd atom to decode.
 * @param trackId The track's identifier in its container.
 * @param rotationDegrees The rotation of the track in degrees.
 * @param language The language of the track.
 * @param drmInitData {@link DrmInitData} to be included in the format.
 * @param isQuickTime True for QuickTime media. False otherwise.
 * @return An object containing the parsed data.
 */
private static StsdData parseStsd(ParsableByteArray stsd, int trackId, int rotationDegrees,
    String language, DrmInitData drmInitData, boolean isQuickTime) throws ParserException {
  stsd.setPosition(Atom.FULL_HEADER_SIZE);
  int numberOfEntries = stsd.readInt();
  StsdData out = new StsdData(numberOfEntries);
  for (int i = 0; i < numberOfEntries; i++) {
    int childStartPosition = stsd.getPosition();
    int childAtomSize = stsd.readInt();
    Assertions.checkArgument(childAtomSize > 0, "childAtomSize should be positive");
    int childAtomType = stsd.readInt();
    if (childAtomType == Atom.TYPE_avc1 || childAtomType == Atom.TYPE_avc3
        || childAtomType == Atom.TYPE_encv || childAtomType == Atom.TYPE_mp4v
        || childAtomType == Atom.TYPE_hvc1 || childAtomType == Atom.TYPE_hev1
        || childAtomType == Atom.TYPE_s263 || childAtomType == Atom.TYPE_vp08
        || childAtomType == Atom.TYPE_vp09) {
      parseVideoSampleEntry(stsd, childAtomType, childStartPosition, childAtomSize, trackId,
          rotationDegrees, drmInitData, out, i);
    } else if (childAtomType == Atom.TYPE_mp4a || childAtomType == Atom.TYPE_enca
        || childAtomType == Atom.TYPE_ac_3 || childAtomType == Atom.TYPE_ec_3
        || childAtomType == Atom.TYPE_dtsc || childAtomType == Atom.TYPE_dtse
        || childAtomType == Atom.TYPE_dtsh || childAtomType == Atom.TYPE_dtsl
        || childAtomType == Atom.TYPE_samr || childAtomType == Atom.TYPE_sawb
        || childAtomType == Atom.TYPE_lpcm || childAtomType == Atom.TYPE_sowt
        || childAtomType == Atom.TYPE__mp3 || childAtomType == Atom.TYPE_alac) {
      parseAudioSampleEntry(stsd, childAtomType, childStartPosition, childAtomSize, trackId,
          language, isQuickTime, drmInitData, out, i);
    } else if (childAtomType == Atom.TYPE_TTML || childAtomType == Atom.TYPE_tx3g
        || childAtomType == Atom.TYPE_wvtt || childAtomType == Atom.TYPE_stpp
        || childAtomType == Atom.TYPE_c608) {
      parseTextSampleEntry(stsd, childAtomType, childStartPosition, childAtomSize, trackId,
          language, drmInitData, out);
    } else if (childAtomType == Atom.TYPE_camm) {
      out.format = Format.createSampleFormat(Integer.toString(trackId),
          MimeTypes.APPLICATION_CAMERA_MOTION, null, Format.NO_VALUE, drmInitData);
    }
    stsd.setPosition(childStartPosition + childAtomSize);
  }
  return out;
}

@Override
public int evaluateQueueSize(long playbackPositionUs, List<? extends MediaChunk> queue) {
  if (queue.isEmpty()) {
    return 0;
  }
  int queueSize = queue.size();
  long bufferedDurationUs = queue.get(queueSize - 1).endTimeUs - playbackPositionUs;
  if (bufferedDurationUs < minDurationToRetainAfterDiscardUs) {
    return queueSize;
  }
  int idealSelectedIndex = determineIdealSelectedIndex(SystemClock.elapsedRealtime());
  Format idealFormat = getFormat(idealSelectedIndex);
  // If the chunks contain video, discard from the first SD chunk beyond
  // minDurationToRetainAfterDiscardUs whose resolution and bitrate are both lower than the ideal
  // track.
  for (int i = 0; i < queueSize; i++) {
    MediaChunk chunk = queue.get(i);
    Format format = chunk.trackFormat;
    long durationBeforeThisChunkUs = chunk.startTimeUs - playbackPositionUs;
    if (durationBeforeThisChunkUs >= minDurationToRetainAfterDiscardUs
        && format.bitrate < idealFormat.bitrate
        && format.height != Format.NO_VALUE && format.height < 720
        && format.width != Format.NO_VALUE && format.width < 1280
        && format.height < idealFormat.height) {
      return i;
    }
  }
  return queueSize;
}

@Override
protected void onInputFormatChanged(Format newFormat) throws ExoPlaybackException {
  super.onInputFormatChanged(newFormat);
  eventDispatcher.inputFormatChanged(newFormat);
  pendingPixelWidthHeightRatio = getPixelWidthHeightRatio(newFormat);
  pendingRotationDegrees = getRotationDegrees(newFormat);
}

/**
 * Creates a new audio processor that converts audio data to {@link C#ENCODING_PCM_16BIT}.
 */
public ResamplingAudioProcessor() {
  sampleRateHz = Format.NO_VALUE;
  channelCount = Format.NO_VALUE;
  encoding = C.ENCODING_INVALID;
  buffer = EMPTY_BUFFER;
  outputBuffer = EMPTY_BUFFER;
}

/**
 * Returns {@link CodecMaxValues} suitable for configuring a codec for {@code format} in a way
 * that will allow possible adaptation to other compatible formats in {@code streamFormats}.
 *
 * @param codecInfo Information about the {@link MediaCodec} being configured.
 * @param format The format for which the codec is being configured.
 * @param streamFormats The possible stream formats.
 * @return Suitable {@link CodecMaxValues}.
 * @throws DecoderQueryException If an error occurs querying {@code codecInfo}.
 */
private static CodecMaxValues getCodecMaxValues(MediaCodecInfo codecInfo, Format format,
    Format[] streamFormats) throws DecoderQueryException {
  int maxWidth = format.width;
  int maxHeight = format.height;
  int maxInputSize = getMaxInputSize(format);
  if (streamFormats.length == 1) {
    // The single entry in streamFormats must correspond to the format for which the codec is
    // being configured.
    return new CodecMaxValues(maxWidth, maxHeight, maxInputSize);
  }
  boolean haveUnknownDimensions = false;
  for (Format streamFormat : streamFormats) {
    if (areAdaptationCompatible(codecInfo.adaptive, format, streamFormat)) {
      haveUnknownDimensions |= (streamFormat.width == Format.NO_VALUE
          || streamFormat.height == Format.NO_VALUE);
      maxWidth = Math.max(maxWidth, streamFormat.width);
      maxHeight = Math.max(maxHeight, streamFormat.height);
      maxInputSize = Math.max(maxInputSize, getMaxInputSize(streamFormat));
    }
  }
  if (haveUnknownDimensions) {
    Log.w(TAG, "Resolutions unknown. Codec max resolution: " + maxWidth + "x" + maxHeight);
    Point codecMaxSize = getCodecMaxSize(codecInfo, format);
    if (codecMaxSize != null) {
      maxWidth = Math.max(maxWidth, codecMaxSize.x);
      maxHeight = Math.max(maxHeight, codecMaxSize.y);
      maxInputSize = Math.max(maxInputSize,
          getMaxInputSize(format.sampleMimeType, maxWidth, maxHeight));
      Log.w(TAG, "Codec max resolution adjusted to: " + maxWidth + "x" + maxHeight);
    }
  }
  return new CodecMaxValues(maxWidth, maxHeight, maxInputSize);
}

@Override
public void reset() {
  flush();
  buffer = EMPTY_BUFFER;
  channelCount = Format.NO_VALUE;
  sampleRateHz = Format.NO_VALUE;
  outputChannels = null;
  active = false;
}

public Cea708Decoder(int accessibilityChannel) {
  ccData = new ParsableByteArray();
  serviceBlockPacket = new ParsableBitArray();
  selectedServiceNumber = (accessibilityChannel == Format.NO_VALUE) ? 1 : accessibilityChannel;

  cueBuilders = new CueBuilder[NUM_WINDOWS];
  for (int i = 0; i < NUM_WINDOWS; i++) {
    cueBuilders[i] = new CueBuilder();
  }

  currentCueBuilder = cueBuilders[0];
  resetCueBuilders();
}