Java MimeTypes.VIDEO_H264属性代码示例

private static String fourCCToMimeType(String fourCC) {
  if (fourCC.equalsIgnoreCase("H264") || fourCC.equalsIgnoreCase("X264")
      || fourCC.equalsIgnoreCase("AVC1") || fourCC.equalsIgnoreCase("DAVC")) {
    return MimeTypes.VIDEO_H264;
  } else if (fourCC.equalsIgnoreCase("AAC") || fourCC.equalsIgnoreCase("AACL")
      || fourCC.equalsIgnoreCase("AACH") || fourCC.equalsIgnoreCase("AACP")) {
    return MimeTypes.AUDIO_AAC;
  } else if (fourCC.equalsIgnoreCase("TTML")) {
    return MimeTypes.APPLICATION_TTML;
  } else if (fourCC.equalsIgnoreCase("ac-3") || fourCC.equalsIgnoreCase("dac3")) {
    return MimeTypes.AUDIO_AC3;
  } else if (fourCC.equalsIgnoreCase("ec-3") || fourCC.equalsIgnoreCase("dec3")) {
    return MimeTypes.AUDIO_E_AC3;
  } else if (fourCC.equalsIgnoreCase("dtsc")) {
    return MimeTypes.AUDIO_DTS;
  } else if (fourCC.equalsIgnoreCase("dtsh") || fourCC.equalsIgnoreCase("dtsl")) {
    return MimeTypes.AUDIO_DTS_HD;
  } else if (fourCC.equalsIgnoreCase("dtse")) {
    return MimeTypes.AUDIO_DTS_EXPRESS;
  } else if (fourCC.equalsIgnoreCase("opus")) {
    return MimeTypes.AUDIO_OPUS;
  }
  return null;
}
 

public void testParcelable() {
  DrmInitData.SchemeData DRM_DATA_1 = new DrmInitData.SchemeData(WIDEVINE_UUID, VIDEO_MP4,
      TestUtil.buildTestData(128, 1 /* data seed */));
  DrmInitData.SchemeData DRM_DATA_2 = new DrmInitData.SchemeData(C.UUID_NIL, VIDEO_WEBM,
      TestUtil.buildTestData(128, 1 /* data seed */));
  DrmInitData drmInitData = new DrmInitData(DRM_DATA_1, DRM_DATA_2);
  byte[] projectionData = new byte[] {1, 2, 3};

  Format formatToParcel = new Format("id", MimeTypes.VIDEO_MP4, MimeTypes.VIDEO_H264, null,
      1024, 2048, 1920, 1080, 24, 90, 2, projectionData, C.STEREO_MODE_TOP_BOTTOM, 6, 44100,
      C.ENCODING_PCM_24BIT, 1001, 1002, 0, "und", Format.OFFSET_SAMPLE_RELATIVE, INIT_DATA,
      drmInitData);

  Parcel parcel = Parcel.obtain();
  formatToParcel.writeToParcel(parcel, 0);
  parcel.setDataPosition(0);

  Format formatFromParcel = Format.CREATOR.createFromParcel(parcel);
  assertEquals(formatToParcel, formatFromParcel);

  parcel.recycle();
}
 

/**
 * Returns codec-specific initialization data contained in an esds box.
 */
private static Pair<String, byte[]> parseEsdsFromParent(ParsableByteArray parent, int position) {
  parent.setPosition(position + Atom.HEADER_SIZE + 4);
  // Start of the ES_Descriptor (defined in 14496-1)
  parent.skipBytes(1); // ES_Descriptor tag
  parseExpandableClassSize(parent);
  parent.skipBytes(2); // ES_ID

  int flags = parent.readUnsignedByte();
  if ((flags & 0x80 /* streamDependenceFlag */) != 0) {
    parent.skipBytes(2);
  }
  if ((flags & 0x40 /* URL_Flag */) != 0) {
    parent.skipBytes(parent.readUnsignedShort());
  }
  if ((flags & 0x20 /* OCRstreamFlag */) != 0) {
    parent.skipBytes(2);
  }

  // Start of the DecoderConfigDescriptor (defined in 14496-1)
  parent.skipBytes(1); // DecoderConfigDescriptor tag
  parseExpandableClassSize(parent);

  // Set the MIME type based on the object type indication (14496-1 table 5).
  int objectTypeIndication = parent.readUnsignedByte();
  String mimeType;
  switch (objectTypeIndication) {
    case 0x6B:
      mimeType = MimeTypes.AUDIO_MPEG;
      return Pair.create(mimeType, null);
    case 0x20:
      mimeType = MimeTypes.VIDEO_MP4V;
      break;
    case 0x21:
      mimeType = MimeTypes.VIDEO_H264;
      break;
    case 0x23:
      mimeType = MimeTypes.VIDEO_H265;
      break;
    case 0x40:
    case 0x66:
    case 0x67:
    case 0x68:
      mimeType = MimeTypes.AUDIO_AAC;
      break;
    case 0xA5:
      mimeType = MimeTypes.AUDIO_AC3;
      break;
    case 0xA6:
      mimeType = MimeTypes.AUDIO_E_AC3;
      break;
    case 0xA9:
    case 0xAC:
      mimeType = MimeTypes.AUDIO_DTS;
      return Pair.create(mimeType, null);
    case 0xAA:
    case 0xAB:
      mimeType = MimeTypes.AUDIO_DTS_HD;
      return Pair.create(mimeType, null);
    default:
      mimeType = null;
      break;
  }

  parent.skipBytes(12);

  // Start of the AudioSpecificConfig.
  parent.skipBytes(1); // AudioSpecificConfig tag
  int initializationDataSize = parseExpandableClassSize(parent);
  byte[] initializationData = new byte[initializationDataSize];
  parent.readBytes(initializationData, 0, initializationDataSize);
  return Pair.create(mimeType, initializationData);
}
 

/**
 * Returns a maximum input size for a given mime type, width and height.
 *
 * @param sampleMimeType The format mime type.
 * @param width The width in pixels.
 * @param height The height in pixels.
 * @return A maximum input size in bytes, or {@link Format#NO_VALUE} if a maximum could not be
 *     determined.
 */
private static int getMaxInputSize(String sampleMimeType, int width, int height) {
  if (width == Format.NO_VALUE || height == Format.NO_VALUE) {
    // We can't infer a maximum input size without video dimensions.
    return Format.NO_VALUE;
  }

  // Attempt to infer a maximum input size from the format.
  int maxPixels;
  int minCompressionRatio;
  switch (sampleMimeType) {
    case MimeTypes.VIDEO_H263:
    case MimeTypes.VIDEO_MP4V:
      maxPixels = width * height;
      minCompressionRatio = 2;
      break;
    case MimeTypes.VIDEO_H264:
      if ("BRAVIA 4K 2015".equals(Util.MODEL)) {
        // The Sony BRAVIA 4k TV has input buffers that are too small for the calculated 4k video
        // maximum input size, so use the default value.
        return Format.NO_VALUE;
      }
      // Round up width/height to an integer number of macroblocks.
      maxPixels = Util.ceilDivide(width, 16) * Util.ceilDivide(height, 16) * 16 * 16;
      minCompressionRatio = 2;
      break;
    case MimeTypes.VIDEO_VP8:
      // VPX does not specify a ratio so use the values from the platform's SoftVPX.cpp.
      maxPixels = width * height;
      minCompressionRatio = 2;
      break;
    case MimeTypes.VIDEO_H265:
    case MimeTypes.VIDEO_VP9:
      maxPixels = width * height;
      minCompressionRatio = 4;
      break;
    default:
      // Leave the default max input size.
      return Format.NO_VALUE;
  }
  // Estimate the maximum input size assuming three channel 4:2:0 subsampled input frames.
  return (maxPixels * 3) / (2 * minCompressionRatio);
}
 

/**
 * Returns a maximum input size for a given format.
 *
 * @param format The format.
 * @return An maximum input size in bytes, or {@link Format#NO_VALUE} if a maximum could not be
 *     determined.
 */
private static int getMaxInputSize(Format format) {
  if (format.maxInputSize != Format.NO_VALUE) {
    // The format defines an explicit maximum input size.
    return format.maxInputSize;
  }

  if (format.width == Format.NO_VALUE || format.height == Format.NO_VALUE) {
    // We can't infer a maximum input size without video dimensions.
    return Format.NO_VALUE;
  }

  // Attempt to infer a maximum input size from the format.
  int maxPixels;
  int minCompressionRatio;
  switch (format.sampleMimeType) {
    case MimeTypes.VIDEO_H263:
    case MimeTypes.VIDEO_MP4V:
      maxPixels = format.width * format.height;
      minCompressionRatio = 2;
      break;
    case MimeTypes.VIDEO_H264:
      if ("BRAVIA 4K 2015".equals(Util.MODEL)) {
        // The Sony BRAVIA 4k TV has input buffers that are too small for the calculated 4k video
        // maximum input size, so use the default value.
        return Format.NO_VALUE;
      }
      // Round up width/height to an integer number of macroblocks.
      maxPixels = ((format.width + 15) / 16) * ((format.height + 15) / 16) * 16 * 16;
      minCompressionRatio = 2;
      break;
    case MimeTypes.VIDEO_VP8:
      // VPX does not specify a ratio so use the values from the platform's SoftVPX.cpp.
      maxPixels = format.width * format.height;
      minCompressionRatio = 2;
      break;
    case MimeTypes.VIDEO_H265:
    case MimeTypes.VIDEO_VP9:
      maxPixels = format.width * format.height;
      minCompressionRatio = 4;
      break;
    default:
      // Leave the default max input size.
      return Format.NO_VALUE;
  }
  // Estimate the maximum input size assuming three channel 4:2:0 subsampled input frames.
  return (maxPixels * 3) / (2 * minCompressionRatio);
}