Java ParsableByteArray.setPosition方法代码示例

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
/**
 * Attempts to locate the start of the next frame header.
 * <p>
 * If a frame header is located then the state is changed to {@link #STATE_READING_HEADER}, the
 * first two bytes of the header are written into {@link #headerScratch}, and the position of the
 * source is advanced to the byte that immediately follows these two bytes.
 * <p>
 * If a frame header is not located then the position of the source is advanced to the limit, and
 * the method should be called again with the next source to continue the search.
 *
 * @param source The source from which to read.
 */
private void findHeader(ParsableByteArray source) {
  byte[] data = source.data;
  int startOffset = source.getPosition();
  int endOffset = source.limit();
  for (int i = startOffset; i < endOffset; i++) {
    boolean byteIsFF = (data[i] & 0xFF) == 0xFF;
    boolean found = lastByteWasFF && (data[i] & 0xE0) == 0xE0;
    lastByteWasFF = byteIsFF;
    if (found) {
      source.setPosition(i + 1);
      // Reset lastByteWasFF for next time.
      lastByteWasFF = false;
      headerScratch.data[1] = data[i];
      frameBytesRead = 2;
      state = STATE_READING_HEADER;
      return;
    }
  }
  source.setPosition(endOffset);
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
@Override
public void consume(ParsableByteArray data) {
  if (writingSample) {
    if (bytesToCheck == 2 && !checkNextByte(data, 0x20)) {
      // Failed to check data_identifier
      return;
    }
    if (bytesToCheck == 1 && !checkNextByte(data, 0x00)) {
      // Check and discard the subtitle_stream_id
      return;
    }
    int dataPosition = data.getPosition();
    int bytesAvailable = data.bytesLeft();
    for (TrackOutput output : outputs) {
      data.setPosition(dataPosition);
      output.sampleData(data, bytesAvailable);
    }
    sampleBytesWritten += bytesAvailable;
  }
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
private static TrackEncryptionBox parseSchiFromParent(ParsableByteArray parent, int position,
    int size) {
  int childPosition = position + Atom.HEADER_SIZE;
  while (childPosition - position < size) {
    parent.setPosition(childPosition);
    int childAtomSize = parent.readInt();
    int childAtomType = parent.readInt();
    if (childAtomType == Atom.TYPE_tenc) {
      parent.skipBytes(6);
      boolean defaultIsEncrypted = parent.readUnsignedByte() == 1;
      int defaultInitVectorSize = parent.readUnsignedByte();
      byte[] defaultKeyId = new byte[16];
      parent.readBytes(defaultKeyId, 0, defaultKeyId.length);
      return new TrackEncryptionBox(defaultIsEncrypted, defaultInitVectorSize, defaultKeyId);
    }
    childPosition += childAtomSize;
  }
  return null;
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
/**
 * Parses the edts atom (defined in 14496-12 subsection 8.6.5).
 *
 * @param edtsAtom edts (edit box) atom to decode.
 * @return Pair of edit list durations and edit list media times, or a pair of nulls if they are
 * not present.
 */
private static Pair<long[], long[]> parseEdts(Atom.ContainerAtom edtsAtom) {
  Atom.LeafAtom elst;
  if (edtsAtom == null || (elst = edtsAtom.getLeafAtomOfType(Atom.TYPE_elst)) == null) {
    return Pair.create(null, null);
  }
  ParsableByteArray elstData = elst.data;
  elstData.setPosition(Atom.HEADER_SIZE);
  int fullAtom = elstData.readInt();
  int version = Atom.parseFullAtomVersion(fullAtom);
  int entryCount = elstData.readUnsignedIntToInt();
  long[] editListDurations = new long[entryCount];
  long[] editListMediaTimes = new long[entryCount];
  for (int i = 0; i < entryCount; i++) {
    editListDurations[i] =
        version == 1 ? elstData.readUnsignedLongToLong() : elstData.readUnsignedInt();
    editListMediaTimes[i] = version == 1 ? elstData.readLong() : elstData.readInt();
    int mediaRateInteger = elstData.readShort();
    if (mediaRateInteger != 1) {
      // The extractor does not handle dwell edits (mediaRateInteger == 0).
      throw new IllegalArgumentException("Unsupported media rate.");
    }
    elstData.skipBytes(2);
  }
  return Pair.create(editListDurations, editListMediaTimes);
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
/**
 * Parses an hdlr atom.
 *
 * @param hdlr The hdlr atom to decode.
 * @return The track type.
 */
private static int parseHdlr(ParsableByteArray hdlr) {
  hdlr.setPosition(Atom.FULL_HEADER_SIZE + 4);
  int trackType = hdlr.readInt();
  if (trackType == TYPE_soun) {
    return C.TRACK_TYPE_AUDIO;
  } else if (trackType == TYPE_vide) {
    return C.TRACK_TYPE_VIDEO;
  } else if (trackType == TYPE_text || trackType == TYPE_sbtl || trackType == TYPE_subt
      || trackType == TYPE_clcp) {
    return C.TRACK_TYPE_TEXT;
  } else if (trackType == TYPE_meta) {
    return C.TRACK_TYPE_METADATA;
  } else {
    return C.TRACK_TYPE_UNKNOWN;
  }
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
/**
 * Positions the input right before the next event, and returns the kind of event found. Does not
 * consume any data from such event, if any.
 *
 * @return The kind of event found.
 */
private static int getNextEvent(ParsableByteArray parsableWebvttData) {
  int foundEvent = EVENT_NONE;
  int currentInputPosition = 0;
  while (foundEvent == EVENT_NONE) {
    currentInputPosition = parsableWebvttData.getPosition();
    String line = parsableWebvttData.readLine();
    if (line == null) {
      foundEvent = EVENT_END_OF_FILE;
    } else if (STYLE_START.equals(line)) {
      foundEvent = EVENT_STYLE_BLOCK;
    } else if (COMMENT_START.startsWith(line)) {
      foundEvent = EVENT_COMMENT;
    } else {
      foundEvent = EVENT_CUE;
    }
  }
  parsableWebvttData.setPosition(currentInputPosition);
  return foundEvent;
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
/**
 * Parses the proj box from sv3d box, as specified by https://github.com/google/spatial-media
 */
private static byte[] parseProjFromParent(ParsableByteArray parent, int position, int size) {
  int childPosition = position + Atom.HEADER_SIZE;
  while (childPosition - position < size) {
    parent.setPosition(childPosition);
    int childAtomSize = parent.readInt();
    int childAtomType = parent.readInt();
    if (childAtomType == Atom.TYPE_proj) {
      return Arrays.copyOfRange(parent.data, childPosition, childPosition + childAtomSize);
    }
    childPosition += childAtomSize;
  }
  return null;
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
/**
 * Inspects an sei message to determine whether it contains CEA-608.
 * <p>
 * The position of {@code payload} is left unchanged.
 *
 * @param payloadType The payload type of the message.
 * @param payloadLength The length of the payload.
 * @param payload A {@link ParsableByteArray} containing the payload.
 * @return Whether the sei message contains CEA-608.
 */
private static boolean isSeiMessageCea608(int payloadType, int payloadLength,
    ParsableByteArray payload) {
  if (payloadType != PAYLOAD_TYPE_CC || payloadLength < 8) {
    return false;
  }
  int startPosition = payload.getPosition();
  int countryCode = payload.readUnsignedByte();
  int providerCode = payload.readUnsignedShort();
  int userIdentifier = payload.readInt();
  int userDataTypeCode = payload.readUnsignedByte();
  payload.setPosition(startPosition);
  return countryCode == COUNTRY_CODE && providerCode == PROVIDER_CODE
      && userIdentifier == USER_ID && userDataTypeCode == USER_DATA_TYPE_CODE;
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
private static ChapterFrame decodeChapterFrame(ParsableByteArray id3Data, int frameSize,
    int majorVersion, boolean unsignedIntFrameSizeHack, int frameHeaderSize,
    FramePredicate framePredicate) throws UnsupportedEncodingException {
  int framePosition = id3Data.getPosition();
  int chapterIdEndIndex = indexOfZeroByte(id3Data.data, framePosition);
  String chapterId = new String(id3Data.data, framePosition, chapterIdEndIndex - framePosition,
      "ISO-8859-1");
  id3Data.setPosition(chapterIdEndIndex + 1);

  int startTime = id3Data.readInt();
  int endTime = id3Data.readInt();
  long startOffset = id3Data.readUnsignedInt();
  if (startOffset == 0xFFFFFFFFL) {
    startOffset = C.POSITION_UNSET;
  }
  long endOffset = id3Data.readUnsignedInt();
  if (endOffset == 0xFFFFFFFFL) {
    endOffset = C.POSITION_UNSET;
  }

  ArrayList<Id3Frame> subFrames = new ArrayList<>();
  int limit = framePosition + frameSize;
  while (id3Data.getPosition() < limit) {
    Id3Frame frame = decodeFrame(majorVersion, id3Data, unsignedIntFrameSizeHack,
        frameHeaderSize, framePredicate);
    if (frame != null) {
      subFrames.add(frame);
    }
  }

  Id3Frame[] subFrameArray = new Id3Frame[subFrames.size()];
  subFrames.toArray(subFrameArray);
  return new ChapterFrame(chapterId, startTime, endTime, startOffset, endOffset, subFrameArray);
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
/**
 * Parses a mvhd atom (defined in 14496-12), returning the timescale for the movie.
 *
 * @param mvhd Contents of the mvhd atom to be parsed.
 * @return Timescale for the movie.
 */
private static long parseMvhd(ParsableByteArray mvhd) {
  mvhd.setPosition(Atom.HEADER_SIZE);
  int fullAtom = mvhd.readInt();
  int version = Atom.parseFullAtomVersion(fullAtom);
  mvhd.skipBytes(version == 0 ? 8 : 16);
  return mvhd.readUnsignedInt();
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
/**
 * Parses encryption data from an audio/video sample entry, populating {@code out} and returning
 * the unencrypted atom type, or 0 if no common encryption sinf atom was present.
 */
private static int parseSampleEntryEncryptionData(ParsableByteArray parent, int position,
    int size, StsdData out, int entryIndex) {
  int childPosition = parent.getPosition();
  while (childPosition - position < size) {
    parent.setPosition(childPosition);
    int childAtomSize = parent.readInt();
    Assertions.checkArgument(childAtomSize > 0, "childAtomSize should be positive");
    int childAtomType = parent.readInt();
    if (childAtomType == Atom.TYPE_sinf) {
      Pair<Integer, TrackEncryptionBox> result = parseSinfFromParent(parent, childPosition,
          childAtomSize);
      if (result != null) {
        out.trackEncryptionBoxes[entryIndex] = result.second;
        return result.first;
      }
    }
    childPosition += childAtomSize;
  }
  // This enca/encv box does not have a data format so return an invalid atom type.
  return 0;
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
private static void parseTextSampleEntry(ParsableByteArray parent, int atomType, int position,
    int atomSize, int trackId, String language, DrmInitData drmInitData, StsdData out)
    throws ParserException {
  parent.setPosition(position + Atom.HEADER_SIZE + StsdData.STSD_HEADER_SIZE);

  // Default values.
  List<byte[]> initializationData = null;
  long subsampleOffsetUs = Format.OFFSET_SAMPLE_RELATIVE;

  String mimeType;
  if (atomType == Atom.TYPE_TTML) {
    mimeType = MimeTypes.APPLICATION_TTML;
  } else if (atomType == Atom.TYPE_tx3g) {
    mimeType = MimeTypes.APPLICATION_TX3G;
    int sampleDescriptionLength = atomSize - Atom.HEADER_SIZE - 8;
    byte[] sampleDescriptionData = new byte[sampleDescriptionLength];
    parent.readBytes(sampleDescriptionData, 0, sampleDescriptionLength);
    initializationData = Collections.singletonList(sampleDescriptionData);
  } else if (atomType == Atom.TYPE_wvtt) {
    mimeType = MimeTypes.APPLICATION_MP4VTT;
  } else if (atomType == Atom.TYPE_stpp) {
    mimeType = MimeTypes.APPLICATION_TTML;
    subsampleOffsetUs = 0; // Subsample timing is absolute.
  } else if (atomType == Atom.TYPE_c608) {
    // Defined by the QuickTime File Format specification.
    mimeType = MimeTypes.APPLICATION_MP4CEA608;
    out.requiredSampleTransformation = Track.TRANSFORMATION_CEA608_CDAT;
  } else {
    // Never happens.
    throw new IllegalStateException();
  }

  out.format = Format.createTextSampleFormat(Integer.toString(trackId), mimeType, null,
      Format.NO_VALUE, 0, language, Format.NO_VALUE, drmInitData, subsampleOffsetUs,
      initializationData);
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
@Override
public boolean sniff(ExtractorInput input) throws IOException, InterruptedException {
  // Skip any ID3 headers.
  ParsableByteArray scratch = new ParsableByteArray(10);
  ParsableBitArray scratchBits = new ParsableBitArray(scratch.data);
  int startPosition = 0;
  while (true) {
    input.peekFully(scratch.data, 0, 10);
    scratch.setPosition(0);
    if (scratch.readUnsignedInt24() != ID3_TAG) {
      break;
    }
    scratch.skipBytes(3);
    int length = scratch.readSynchSafeInt();
    startPosition += 10 + length;
    input.advancePeekPosition(length);
  }
  input.resetPeekPosition();
  input.advancePeekPosition(startPosition);

  // Try to find four or more consecutive AAC audio frames, exceeding the MPEG TS packet size.
  int headerPosition = startPosition;
  int validFramesSize = 0;
  int validFramesCount = 0;
  while (true) {
    input.peekFully(scratch.data, 0, 2);
    scratch.setPosition(0);
    int syncBytes = scratch.readUnsignedShort();
    if ((syncBytes & 0xFFF6) != 0xFFF0) {
      validFramesCount = 0;
      validFramesSize = 0;
      input.resetPeekPosition();
      if (++headerPosition - startPosition >= MAX_SNIFF_BYTES) {
        return false;
      }
      input.advancePeekPosition(headerPosition);
    } else {
      if (++validFramesCount >= 4 && validFramesSize > 188) {
        return true;
      }

      // Skip the frame.
      input.peekFully(scratch.data, 0, 4);
      scratchBits.setPosition(14);
      int frameSize = scratchBits.readBits(13);
      // Either the stream is malformed OR we're not parsing an ADTS stream.
      if (frameSize <= 6) {
        return false;
      }
      input.advancePeekPosition(frameSize - 6);
      validFramesSize += frameSize;
    }
  }
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
@Override
public boolean sniff(ExtractorInput input) throws IOException, InterruptedException {
  // Skip any ID3 headers.
  ParsableByteArray scratch = new ParsableByteArray(10);
  int startPosition = 0;
  while (true) {
    input.peekFully(scratch.data, 0, 10);
    scratch.setPosition(0);
    if (scratch.readUnsignedInt24() != ID3_TAG) {
      break;
    }
    scratch.skipBytes(3);
    int length = scratch.readSynchSafeInt();
    startPosition += 10 + length;
    input.advancePeekPosition(length);
  }
  input.resetPeekPosition();
  input.advancePeekPosition(startPosition);

  int headerPosition = startPosition;
  int validFramesCount = 0;
  while (true) {
    input.peekFully(scratch.data, 0, 5);
    scratch.setPosition(0);
    int syncBytes = scratch.readUnsignedShort();
    if (syncBytes != AC3_SYNC_WORD) {
      validFramesCount = 0;
      input.resetPeekPosition();
      if (++headerPosition - startPosition >= MAX_SNIFF_BYTES) {
        return false;
      }
      input.advancePeekPosition(headerPosition);
    } else {
      if (++validFramesCount >= 4) {
        return true;
      }
      int frameSize = Ac3Util.parseAc3SyncframeSize(scratch.data);
      if (frameSize == C.LENGTH_UNSET) {
        return false;
      }
      input.advancePeekPosition(frameSize - 5);
    }
  }
}
 

import com.google.android.exoplayer2.util.ParsableByteArray; //导入方法依赖的package包/类
/**
 * Parses a single ilst element from a {@link ParsableByteArray}. The element is read starting
 * from the current position of the {@link ParsableByteArray}, and the position is advanced by
 * the size of the element. The position is advanced even if the element's type is unrecognized.
 *
 * @param ilst Holds the data to be parsed.
 * @return The parsed element, or null if the element's type was not recognized.
 */
public static Metadata.Entry parseIlstElement(ParsableByteArray ilst) {
  int position = ilst.getPosition();
  int endPosition = position + ilst.readInt();
  int type = ilst.readInt();
  int typeTopByte = (type >> 24) & 0xFF;
  try {
    if (typeTopByte == '\u00A9' /* Copyright char */
        || typeTopByte == '\uFFFD' /* Replacement char */) {
      int shortType = type & 0x00FFFFFF;
      if (shortType == SHORT_TYPE_COMMENT) {
        return parseCommentAttribute(type, ilst);
      } else if (shortType == SHORT_TYPE_NAME_1 || shortType == SHORT_TYPE_NAME_2) {
        return parseTextAttribute(type, "TIT2", ilst);
      } else if (shortType == SHORT_TYPE_COMPOSER_1 || shortType == SHORT_TYPE_COMPOSER_2) {
        return parseTextAttribute(type, "TCOM", ilst);
      } else if (shortType == SHORT_TYPE_YEAR) {
        return parseTextAttribute(type, "TDRC", ilst);
      } else if (shortType == SHORT_TYPE_ARTIST) {
        return parseTextAttribute(type, "TPE1", ilst);
      } else if (shortType == SHORT_TYPE_ENCODER) {
        return parseTextAttribute(type, "TSSE", ilst);
      } else if (shortType == SHORT_TYPE_ALBUM) {
        return parseTextAttribute(type, "TALB", ilst);
      } else if (shortType == SHORT_TYPE_LYRICS) {
        return parseTextAttribute(type, "USLT", ilst);
      } else if (shortType == SHORT_TYPE_GENRE) {
        return parseTextAttribute(type, "TCON", ilst);
      } else if (shortType == TYPE_GROUPING) {
        return parseTextAttribute(type, "TIT1", ilst);
      }
    } else if (type == TYPE_GENRE) {
      return parseStandardGenreAttribute(ilst);
    } else if (type == TYPE_DISK_NUMBER) {
      return parseIndexAndCountAttribute(type, "TPOS", ilst);
    } else if (type == TYPE_TRACK_NUMBER) {
      return parseIndexAndCountAttribute(type, "TRCK", ilst);
    } else if (type == TYPE_TEMPO) {
      return parseUint8Attribute(type, "TBPM", ilst, true, false);
    } else if (type == TYPE_COMPILATION) {
      return parseUint8Attribute(type, "TCMP", ilst, true, true);
    } else if (type == TYPE_COVER_ART) {
      return parseCoverArt(ilst);
    } else if (type == TYPE_ALBUM_ARTIST) {
      return parseTextAttribute(type, "TPE2", ilst);
    } else if (type == TYPE_SORT_TRACK_NAME) {
      return parseTextAttribute(type, "TSOT", ilst);
    } else if (type == TYPE_SORT_ALBUM) {
      return parseTextAttribute(type, "TSO2", ilst);
    } else if (type == TYPE_SORT_ARTIST) {
      return parseTextAttribute(type, "TSOA", ilst);
    } else if (type == TYPE_SORT_ALBUM_ARTIST) {
      return parseTextAttribute(type, "TSOP", ilst);
    } else if (type == TYPE_SORT_COMPOSER) {
      return parseTextAttribute(type, "TSOC", ilst);
    } else if (type == TYPE_RATING) {
      return parseUint8Attribute(type, "ITUNESADVISORY", ilst, false, false);
    } else if (type == TYPE_GAPLESS_ALBUM) {
      return parseUint8Attribute(type, "ITUNESGAPLESS", ilst, false, true);
    } else if (type == TYPE_TV_SORT_SHOW) {
      return parseTextAttribute(type, "TVSHOWSORT", ilst);
    } else if (type == TYPE_TV_SHOW) {
      return parseTextAttribute(type, "TVSHOW", ilst);
    } else if (type == TYPE_INTERNAL) {
      return parseInternalAttribute(ilst, endPosition);
    }
    Log.d(TAG, "Skipped unknown metadata entry: " + Atom.getAtomTypeString(type));
    return null;
  } finally {
    ilst.setPosition(endPosition);
  }
}