package vendor:android/media

Source

ABitrateMode :: enum i32 {
	CQ     = 0, 
	VBR    = 1, 
	CBR    = 2, 
	CBR_FD = 3, 
}

ACodecAudioCapabilities :: struct {}

ACodecEncoderCapabilities :: struct {}

ACodecPerformancePoint :: struct {}

ACodecVideoCapabilities :: struct {}

ADoubleRange :: struct {
	mLower: f64,
	mUpper: f64,
}

AIMAGE_FORMATS :: enum i32 {
	RGBA_8888         = 0x1, 
	RGBX_8888         = 0x2, 
	RGB_888           = 0x3, 
	RGB_565           = 0x4, 
	RGBA_FP16         = 0x16, 
	YUV_420_888       = 0x23, 
	JPEG              = 0x100, 
	RAW16             = 0x20, 
	RAW_PRIVATE       = 0x24, 
	RAW10             = 0x25, 
	RAW12             = 0x26, 
	RAW14             = 0x2C, 
	DEPTH16           = 0x44363159, 
	DEPTH_POINT_CLOUD = 0x101, 
	PRIVATE           = 0x22, 
	Y8                = 0x20203859, 
	HEIC              = 0x48454946, 
	DEPTH_JPEG        = 0x69656963, 
}

AImage :: struct {}

AImageCropRect :: struct {
	left:   i32,
	top:    i32,
	right:  i32,
	bottom: i32,
}

AImageReader :: struct {}

AImageReader_BufferRemovedCallback :: proc "c" (context_: rawptr, reader: ^AImageReader, buffer: ^android.AHardwareBuffer)

AImageReader_BufferRemovedListener :: struct {
	context_:        rawptr,
	onBufferRemoved: AImageReader_BufferRemovedCallback,
}

AImageReader_ImageCallback :: proc "c" (context_: rawptr, reader: ^AImageReader)

AImageReader_ImageListener :: struct {
	context_:         rawptr,
	onImageAvailable: AImageReader_ImageCallback,
}

AIntRange :: struct {
	mLower: i32,
	mUpper: i32,
}

AMediaCodec :: struct {}

AMediaCodecBufferFlag :: enum u32 {
	KEY_FRAME     = 0, 
	CODEC_CONFIG  = 1, 
	END_OF_STREAM = 2, 
	PARTIAL_FRAME = 3, 
	MUXER_DATA    = 4, 
	DECODE_ONLY   = 5, 
}

AMediaCodecBufferFlags :: distinct bit_set[AMediaCodecBufferFlag; u32]

AMediaCodecBufferInfo :: struct {
	offset:             i32,
	size:               i32,
	presentationTimeUs: i64,
	flags:              AMediaCodecBufferFlags,
}

AMediaCodecConfigureFlag :: enum u32 {
	ENCODE = 0, 
}

AMediaCodecConfigureFlags :: distinct bit_set[AMediaCodecConfigureFlag; u32]

AMediaCodecCryptoInfo :: struct {}

AMediaCodecInfo :: struct {}

AMediaCodecKind :: enum i32 {
	INVALID = 0, 
	DECODER = 1, 
	ENCODER = 2, 
}

AMediaCodecOnAsyncError :: proc "c" (codec: ^AMediaCodec, userdata: rawptr, error: media_status_t, actionCode: i32, detail: cstring)

AMediaCodecOnAsyncFormatChanged :: proc "c" (codec: ^AMediaCodec, userdata: rawptr, format: ^AMediaFormat)

AMediaCodecOnAsyncInputAvailable :: proc "c" (codec: ^AMediaCodec, userdata: rawptr, index: i32)

AMediaCodecOnAsyncNotifyCallback :: struct {
	onAsyncInputAvailable:  AMediaCodecOnAsyncInputAvailable,
	onAsyncOutputAvailable: AMediaCodecOnAsyncOutputAvailable,
	onAsyncFormatChanged:   AMediaCodecOnAsyncFormatChanged,
	onAsyncError:           AMediaCodecOnAsyncError,
}

AMediaCodecOnAsyncOutputAvailable :: proc "c" (codec: ^AMediaCodec, userdata: rawptr, index: i32, bufferInfo: ^AMediaCodecBufferInfo)

AMediaCodecOnFrameRendered :: proc "c" (codec: ^AMediaCodec, userdata: rawptr, mediaTimeUs: i64, systemNano: i64)

AMediaCodecSupportedMediaType :: struct {
	mMediaType: cstring,
	mMode:      u32,
}

AMediaCodecType :: enum i32 {
	INVALID_CODEC_INFO          = 0, 
	SOFTWARE_ONLY               = 1, 
	HARDWARE_ACCELERATED        = 2, 
	SOFTWARE_WITH_DEVICE_ACCESS = 3, 
}

AMediaCrypto :: struct {}

AMediaDataSource :: struct {}

AMediaDataSourceClose :: proc "c" (userdata: rawptr)

AMediaDataSourceGetAvailableSize :: proc "c" (userdata: rawptr, offset: i64) -> int

AMediaDataSourceGetSize :: proc "c" (userdata: rawptr) -> int

AMediaDataSourceReadAt :: proc "c" (userdata: rawptr, offset: i64, buffer: rawptr, size: uint) -> int

AMediaDrm :: struct {}

AMediaDrmByteArray :: struct {
	ptr:    ^u8,
	length: uint,
}

AMediaDrmEventListener :: proc "c" (^AMediaDrm, ^AMediaDrmByteArray, AMediaDrmEventType, i32, ^u8, uint)

AMediaDrmEventType :: enum i32 {
	PROVISION_REQUIRED = 1, 
	KEY_REQUIRED       = 2, 
	KEY_EXPIRED        = 3, 
	VENDOR_DEFINED     = 4, 
	SESSION_RECLAIMED  = 5, 
}

AMediaDrmExpirationUpdateListener :: proc "c" (^AMediaDrm, ^AMediaDrmByteArray, i64)

AMediaDrmKeyId :: AMediaDrmByteArray

AMediaDrmKeyRequestType :: enum i32 {
	INITIAL = 0, 
	RENEWAL = 1, 
	RELEASE = 2, 
	NONE    = 3, 
	UPDATE  = 4, 
}

AMediaDrmKeySetId :: AMediaDrmByteArray

AMediaDrmKeyStatus :: struct {
	keyId:   AMediaDrmByteArray,
	keyType: AMediaDrmKeyStatusType,
}

AMediaDrmKeyStatusType :: enum i32 {
	USABLE           = 0, 
	EXPIRED          = 1, 
	OUTPUTNOTALLOWED = 2, 
	STATUSPENDING    = 3, 
	INTERNALERROR    = 4, 
}

AMediaDrmKeyType :: enum i32 {
	STREAMING = 1, 
	OFFLINE   = 2, 
	RELEASE   = 3, 
}

AMediaDrmKeyValue :: struct {
	mKey:   cstring,
	mValue: cstring,
}

AMediaDrmKeysChangeListener :: proc "c" (^AMediaDrm, ^AMediaDrmByteArray, ^AMediaDrmKeyStatus, uint, bool)

AMediaDrmScope :: AMediaDrmByteArray

AMediaDrmSecureStop :: AMediaDrmByteArray

AMediaDrmSessionId :: AMediaDrmByteArray

AMediaExtractor :: struct {}

AMediaExtractorSampleFlag :: enum u32 {
	SYNC      = 0, 
	ENCRYPTED = 1, 
}

AMediaExtractorSampleFlags :: distinct bit_set[AMediaExtractorSampleFlag; u32]

AMediaFormat :: struct {}

AMediaMuxer :: struct {}

AMediaUUID :: [16]u8

ANativeWindow :: android.ANativeWindow

AppendMode :: enum i32 {
	IGNORE_LAST_VIDEO_GOP = 0, 
	TO_EXISTING_DATA      = 1, 
}

OutputFormat :: enum i32 {
	MPEG_4    = 0, 
	WEBM      = 1, 
	THREE_GPP = 2, 
	HEIF      = 3, 
	OGG       = 4, 
}

PsshEntry :: struct {
	uuid:    [16]u8,
	datalen: uint,
	data:    rawptr,
}

PsshInfo :: struct {
	numentries: uint,
	entries:    [0]PsshEntry,
}

SeekMode :: enum i32 {
	PREVIOUS_SYNC = 0, 
	NEXT_SYNC     = 1, 
	CLOSEST_SYNC  = 2, 
}

cryptoinfo_mode_t :: enum i32 {
	CLEAR   = 0, 
	AES_CTR = 1, 
	AES_WV  = 2, 
	AES_CBC = 3, 
}

cryptoinfo_pattern_t :: struct {
	encryptBlocks: i32,
	skipBlocks:    i32,
}

media_status_t :: enum i32 {
	OK                                      = 0, 
	AMEDIACODEC_ERROR_INSUFFICIENT_RESOURCE = 1100, 
	AMEDIACODEC_ERROR_RECLAIMED             = 1101, 
	ERROR_BASE                              = -10000, 
	ERROR_UNKNOWN                           = -10000, 
	ERROR_MALFORMED                         = -10001, 
	ERROR_UNSUPPORTED                       = -10002, 
	ERROR_INVALID_OBJECT                    = -10003, 
	ERROR_INVALID_PARAMETER                 = -10004, 
	ERROR_INVALID_OPERATION                 = -10005, 
	ERROR_END_OF_STREAM                     = -10006, 
	ERROR_IO                                = -10007, 
	ERROR_WOULD_BLOCK                       = -10008, 
	DRM_ERROR_BASE                          = -20000, 
	DRM_NOT_PROVISIONED                     = -20001, 
	DRM_RESOURCE_BUSY                       = -20002, 
	DRM_DEVICE_REVOKED                      = -20003, 
	DRM_SHORT_BUFFER                        = -20004, 
	DRM_SESSION_NOT_OPENED                  = -20005, 
	DRM_TAMPER_DETECTED                     = -20006, 
	DRM_VERIFY_FAILED                       = -20007, 
	DRM_NEED_KEY                            = -20008, 
	DRM_LICENSE_EXPIRED                     = -20009, 
	IMGREADER_ERROR_BASE                    = -30000, 
	IMGREADER_NO_BUFFER_AVAILABLE           = -30001, 
	IMGREADER_MAX_IMAGES_ACQUIRED           = -30002, 
	IMGREADER_CANNOT_LOCK_IMAGE             = -30003, 
	IMGREADER_CANNOT_UNLOCK_IMAGE           = -30004, 
	IMGREADER_IMAGE_NOT_LOCKED              = -30005, 
}

AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED :: -3

AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED :: -2

AMEDIACODEC_INFO_TRY_AGAIN_LATER :: -1

PROPERTY_ALGORITHMS :: "algorithms"

PROPERTY_DESCRIPTION :: "description"

PROPERTY_DEVICE_UNIQUE_ID :: "deviceUniqueId"

PROPERTY_VENDOR :: "vendor"

PROPERTY_VERSION :: "version"

AMEDIACODEC_KEY_HDR10_PLUS_INFO: cstring

AMEDIACODEC_KEY_LOW_LATENCY: cstring

AMEDIACODEC_KEY_OFFSET_TIME: cstring

AMEDIACODEC_KEY_REQUEST_SYNC_FRAME: cstring

AMEDIACODEC_KEY_SUSPEND: cstring

AMEDIACODEC_KEY_SUSPEND_TIME: cstring

AMEDIACODEC_KEY_VIDEO_BITRATE: cstring

AMEDIAFORMAT_KEY_AAC_DRC_ATTENUATION_FACTOR: cstring

AMEDIAFORMAT_KEY_AAC_DRC_BOOST_FACTOR: cstring

AMEDIAFORMAT_KEY_AAC_DRC_HEAVY_COMPRESSION: cstring

AMEDIAFORMAT_KEY_AAC_DRC_TARGET_REFERENCE_LEVEL: cstring

AMEDIAFORMAT_KEY_AAC_ENCODED_TARGET_LEVEL: cstring

AMEDIAFORMAT_KEY_AAC_MAX_OUTPUT_CHANNEL_COUNT: cstring

AMEDIAFORMAT_KEY_AAC_PROFILE: cstring

AMEDIAFORMAT_KEY_AAC_SBR_MODE: cstring

AMEDIAFORMAT_KEY_ALBUM: cstring

AMEDIAFORMAT_KEY_ALBUMART: cstring

AMEDIAFORMAT_KEY_ALBUMARTIST: cstring

AMEDIAFORMAT_KEY_ALLOW_FRAME_DROP: cstring

AMEDIAFORMAT_KEY_ARTIST: cstring

AMEDIAFORMAT_KEY_AUDIO_PRESENTATION_INFO: cstring

AMEDIAFORMAT_KEY_AUDIO_SESSION_ID: cstring

AMEDIAFORMAT_KEY_AUTHOR: cstring

AMEDIAFORMAT_KEY_BITRATE_MODE: cstring

AMEDIAFORMAT_KEY_BITS_PER_SAMPLE: cstring

AMEDIAFORMAT_KEY_BIT_RATE: cstring

AMEDIAFORMAT_KEY_CAPTURE_RATE: cstring

AMEDIAFORMAT_KEY_CDTRACKNUMBER: cstring

AMEDIAFORMAT_KEY_CHANNEL_COUNT: cstring

AMEDIAFORMAT_KEY_CHANNEL_MASK: cstring

AMEDIAFORMAT_KEY_COLOR_FORMAT: cstring

AMEDIAFORMAT_KEY_COLOR_RANGE: cstring

AMEDIAFORMAT_KEY_COLOR_STANDARD: cstring

AMEDIAFORMAT_KEY_COLOR_TRANSFER: cstring

AMEDIAFORMAT_KEY_COMPILATION: cstring

AMEDIAFORMAT_KEY_COMPLEXITY: cstring

AMEDIAFORMAT_KEY_COMPOSER: cstring

AMEDIAFORMAT_KEY_CREATE_INPUT_SURFACE_SUSPENDED: cstring

AMEDIAFORMAT_KEY_CRYPTO_DEFAULT_IV_SIZE: cstring

AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_BYTE_BLOCK: cstring

AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_SIZES: cstring

AMEDIAFORMAT_KEY_CRYPTO_IV: cstring

AMEDIAFORMAT_KEY_CRYPTO_KEY: cstring

AMEDIAFORMAT_KEY_CRYPTO_MODE: cstring

AMEDIAFORMAT_KEY_CRYPTO_PLAIN_SIZES: cstring

AMEDIAFORMAT_KEY_CRYPTO_SKIP_BYTE_BLOCK: cstring

AMEDIAFORMAT_KEY_CSD: cstring

AMEDIAFORMAT_KEY_CSD_0: cstring

AMEDIAFORMAT_KEY_CSD_1: cstring

AMEDIAFORMAT_KEY_CSD_2: cstring

AMEDIAFORMAT_KEY_CSD_AVC: cstring

AMEDIAFORMAT_KEY_CSD_HEVC: cstring

AMEDIAFORMAT_KEY_CSD_VVC: cstring

AMEDIAFORMAT_KEY_D263: cstring

AMEDIAFORMAT_KEY_DATE: cstring

AMEDIAFORMAT_KEY_DISCNUMBER: cstring

AMEDIAFORMAT_KEY_DISPLAY_CROP: cstring

AMEDIAFORMAT_KEY_DISPLAY_HEIGHT: cstring

AMEDIAFORMAT_KEY_DISPLAY_WIDTH: cstring

AMEDIAFORMAT_KEY_DURATION: cstring

AMEDIAFORMAT_KEY_ENCODER_DELAY: cstring

AMEDIAFORMAT_KEY_ENCODER_PADDING: cstring

AMEDIAFORMAT_KEY_ESDS: cstring

AMEDIAFORMAT_KEY_EXIF_OFFSET: cstring

AMEDIAFORMAT_KEY_EXIF_SIZE: cstring

AMEDIAFORMAT_KEY_FLAC_COMPRESSION_LEVEL: cstring

AMEDIAFORMAT_KEY_FRAME_COUNT: cstring

AMEDIAFORMAT_KEY_FRAME_RATE: cstring

AMEDIAFORMAT_KEY_GENRE: cstring

AMEDIAFORMAT_KEY_GRID_COLUMNS: cstring

AMEDIAFORMAT_KEY_GRID_ROWS: cstring

AMEDIAFORMAT_KEY_HAPTIC_CHANNEL_COUNT: cstring

AMEDIAFORMAT_KEY_HDR10_PLUS_INFO: cstring

AMEDIAFORMAT_KEY_HDR_ST2094_50_INFO: cstring

AMEDIAFORMAT_KEY_HDR_STATIC_INFO: cstring

AMEDIAFORMAT_KEY_HEIGHT: cstring

AMEDIAFORMAT_KEY_HORIZONTAL_FLIP: cstring

AMEDIAFORMAT_KEY_ICC_PROFILE: cstring

AMEDIAFORMAT_KEY_INTRA_REFRESH_PERIOD: cstring

AMEDIAFORMAT_KEY_IS_ADTS: cstring

AMEDIAFORMAT_KEY_IS_AUTOSELECT: cstring

AMEDIAFORMAT_KEY_IS_DEFAULT: cstring

AMEDIAFORMAT_KEY_IS_FORCED_SUBTITLE: cstring

AMEDIAFORMAT_KEY_IS_SYNC_FRAME: cstring

AMEDIAFORMAT_KEY_I_FRAME_INTERVAL: cstring

AMEDIAFORMAT_KEY_LANGUAGE: cstring

AMEDIAFORMAT_KEY_LAST_SAMPLE_INDEX_IN_CHUNK: cstring

AMEDIAFORMAT_KEY_LATENCY: cstring

AMEDIAFORMAT_KEY_LEVEL: cstring

AMEDIAFORMAT_KEY_LOCATION: cstring

AMEDIAFORMAT_KEY_LOOP: cstring

AMEDIAFORMAT_KEY_LOW_LATENCY: cstring

AMEDIAFORMAT_KEY_LYRICIST: cstring

AMEDIAFORMAT_KEY_MANUFACTURER: cstring

AMEDIAFORMAT_KEY_MAX_BIT_RATE: cstring

AMEDIAFORMAT_KEY_MAX_B_FRAMES: cstring

AMEDIAFORMAT_KEY_MAX_FPS_TO_ENCODER: cstring

AMEDIAFORMAT_KEY_MAX_HEIGHT: cstring

AMEDIAFORMAT_KEY_MAX_INPUT_SIZE: cstring

AMEDIAFORMAT_KEY_MAX_PTS_GAP_TO_ENCODER: cstring

AMEDIAFORMAT_KEY_MAX_WIDTH: cstring

AMEDIAFORMAT_KEY_MIME: cstring

AMEDIAFORMAT_KEY_MPEG2_STREAM_HEADER: cstring

AMEDIAFORMAT_KEY_MPEGH_COMPATIBLE_SETS: cstring

AMEDIAFORMAT_KEY_MPEGH_PROFILE_LEVEL_INDICATION: cstring

AMEDIAFORMAT_KEY_MPEGH_REFERENCE_CHANNEL_LAYOUT: cstring

AMEDIAFORMAT_KEY_MPEG_USER_DATA: cstring

AMEDIAFORMAT_KEY_OPERATING_RATE: cstring

AMEDIAFORMAT_KEY_PCM_BIG_ENDIAN: cstring

AMEDIAFORMAT_KEY_PCM_ENCODING: cstring

AMEDIAFORMAT_KEY_PRIORITY: cstring

AMEDIAFORMAT_KEY_PROFILE: cstring

AMEDIAFORMAT_KEY_PSSH: cstring

AMEDIAFORMAT_KEY_PUSH_BLANK_BUFFERS_ON_STOP: cstring

AMEDIAFORMAT_KEY_REPEAT_PREVIOUS_FRAME_AFTER: cstring

AMEDIAFORMAT_KEY_ROTATION: cstring

AMEDIAFORMAT_KEY_SAMPLE_FILE_OFFSET: cstring

AMEDIAFORMAT_KEY_SAMPLE_RATE: cstring

AMEDIAFORMAT_KEY_SAMPLE_TIME_BEFORE_APPEND: cstring

AMEDIAFORMAT_KEY_SAR_HEIGHT: cstring

AMEDIAFORMAT_KEY_SAR_WIDTH: cstring

AMEDIAFORMAT_KEY_SEI: cstring

AMEDIAFORMAT_KEY_SLICE_HEIGHT: cstring

AMEDIAFORMAT_KEY_SLOW_MOTION_MARKERS: cstring

AMEDIAFORMAT_KEY_STRIDE: cstring

AMEDIAFORMAT_KEY_TARGET_TIME: cstring

AMEDIAFORMAT_KEY_TEMPORAL_LAYERING: cstring

AMEDIAFORMAT_KEY_TEMPORAL_LAYER_COUNT: cstring

AMEDIAFORMAT_KEY_TEMPORAL_LAYER_ID: cstring

AMEDIAFORMAT_KEY_TEXT_FORMAT_DATA: cstring

AMEDIAFORMAT_KEY_THUMBNAIL_CSD_AV1C: cstring

AMEDIAFORMAT_KEY_THUMBNAIL_CSD_HEVC: cstring

AMEDIAFORMAT_KEY_THUMBNAIL_HEIGHT: cstring

AMEDIAFORMAT_KEY_THUMBNAIL_TIME: cstring

AMEDIAFORMAT_KEY_THUMBNAIL_WIDTH: cstring

AMEDIAFORMAT_KEY_TILE_HEIGHT: cstring

AMEDIAFORMAT_KEY_TILE_WIDTH: cstring

AMEDIAFORMAT_KEY_TIME_US: cstring

AMEDIAFORMAT_KEY_TITLE: cstring

AMEDIAFORMAT_KEY_TRACK_ID: cstring

AMEDIAFORMAT_KEY_TRACK_INDEX: cstring

AMEDIAFORMAT_KEY_VALID_SAMPLES: cstring

AMEDIAFORMAT_KEY_WIDTH: cstring

AMEDIAFORMAT_KEY_XMP_OFFSET: cstring

AMEDIAFORMAT_KEY_XMP_SIZE: cstring

AMEDIAFORMAT_KEY_YEAR: cstring

AMediaCodecInfo_FEATURE_AdaptivePlayback: cstring

AMediaCodecInfo_FEATURE_DetachedSurface: cstring

AMediaCodecInfo_FEATURE_DynamicColorAspects: cstring

AMediaCodecInfo_FEATURE_DynamicTimestamp: cstring

AMediaCodecInfo_FEATURE_EncodingStatistics: cstring

AMediaCodecInfo_FEATURE_FrameParsing: cstring

AMediaCodecInfo_FEATURE_HdrEditing: cstring

AMediaCodecInfo_FEATURE_HlgEditing: cstring

AMediaCodecInfo_FEATURE_IntraRefresh: cstring

AMediaCodecInfo_FEATURE_LowLatency: cstring

AMediaCodecInfo_FEATURE_MultipleFrames: cstring

AMediaCodecInfo_FEATURE_PartialFrame: cstring

AMediaCodecInfo_FEATURE_QpBounds: cstring

AMediaCodecInfo_FEATURE_Roi: cstring

AMediaCodecInfo_FEATURE_SecurePlayback: cstring

AMediaCodecInfo_FEATURE_TunneledPlayback: cstring

ACodecAudioCapabilities_getBitrateRange :: proc "c" (
	audioCaps: ^ACodecAudioCapabilities, 
	outRange:  ^AIntRange, 
) -> media_status_t ---

ACodecAudioCapabilities_getInputChannelCountRanges :: proc "c" (
	audioCaps:   ^ACodecAudioCapabilities, 
	outArrayPtr: ^^AIntRange, 
	outCount:    ^uint, 
) -> media_status_t ---

ACodecAudioCapabilities_getMaxInputChannelCount :: proc "c" (audioCaps: ^ACodecAudioCapabilities) -> i32 ---

ACodecAudioCapabilities_getMinInputChannelCount :: proc "c" (audioCaps: ^ACodecAudioCapabilities) -> i32 ---

ACodecAudioCapabilities_getSupportedSampleRateRanges :: proc "c" (
	audioCaps:   ^ACodecAudioCapabilities, 
	outArrayPtr: ^^AIntRange, 
	outCount:    ^uint, 
) -> media_status_t ---

ACodecAudioCapabilities_getSupportedSampleRates :: proc "c" (
	audioCaps:   ^ACodecAudioCapabilities, 
	outArrayPtr: ^^i32, 
	outCount:    ^uint, 
) -> media_status_t ---

ACodecAudioCapabilities_isSampleRateSupported :: proc "c" (
	audioCaps:  ^ACodecAudioCapabilities, 
	sampleRate: i32, 
) -> i32 ---

ACodecEncoderCapabilities_getComplexityRange :: proc "c" (
	encoderCaps: ^ACodecEncoderCapabilities, 
	outRange:    ^AIntRange, 
) -> media_status_t ---

ACodecEncoderCapabilities_getQualityRange :: proc "c" (
	encoderCaps: ^ACodecEncoderCapabilities, 
	outRange:    ^AIntRange, 
) -> media_status_t ---

ACodecEncoderCapabilities_getSupportedLayeringSchemas :: proc "c" (
	encoderCaps:                        ^ACodecEncoderCapabilities, 
	outSupportedLayeringSchemaArrayPtr: ^^cstring, 
	outCount:                           ^uint, 
) -> media_status_t ---

ACodecEncoderCapabilities_isBitrateModeSupported :: proc "c" (
	encoderCaps: ^ACodecEncoderCapabilities, 
	mode:        ABitrateMode, 
) -> i32 ---

ACodecPerformancePoint_covers :: proc "c" (
	one:     ^ACodecPerformancePoint, 
	another: ^ACodecPerformancePoint, 
) -> i32 ---

ACodecPerformancePoint_coversFormat :: proc "c" (
	performancePoint: ^ACodecPerformancePoint, 
	format:           ^AMediaFormat, 
) -> i32 ---

ACodecPerformancePoint_create :: proc "c" (
	width:     i32, 
	height:    i32, 
	frameRate: i32, 
) -> ^ACodecPerformancePoint ---

ACodecPerformancePoint_destroy :: proc "c" (performancePoint: ^ACodecPerformancePoint) ---

ACodecPerformancePoint_equals :: proc "c" (
	one:     ^ACodecPerformancePoint, 
	another: ^ACodecPerformancePoint, 
) -> i32 ---

ACodecVideoCapabilities_areSizeAndRateSupported :: proc "c" (
	videoCaps: ^ACodecVideoCapabilities, 
	width:     i32, 
	height:    i32, 
	frameRate: f64, 
) -> i32 ---

ACodecVideoCapabilities_getAchievableFrameRatesFor :: proc "c" (
	videoCaps: ^ACodecVideoCapabilities, 
	width:     i32, 
	height:    i32, 
	outRange:  ^ADoubleRange, 
) -> media_status_t ---

ACodecVideoCapabilities_getBitrateRange :: proc "c" (
	videoCaps: ^ACodecVideoCapabilities, 
	outRange:  ^AIntRange, 
) -> media_status_t ---

ACodecVideoCapabilities_getHeightAlignment :: proc "c" (videoCaps: ^ACodecVideoCapabilities) -> i32 ---

ACodecVideoCapabilities_getNextSupportedPerformancePoint :: proc "c" (
	videoCaps:           ^ACodecVideoCapabilities, 
	outPerformancePoint: ^^ACodecPerformancePoint, 
) -> media_status_t ---

ACodecVideoCapabilities_getSupportedFrameRates :: proc "c" (
	videoCaps: ^ACodecVideoCapabilities, 
	outRange:  ^AIntRange, 
) -> media_status_t ---

ACodecVideoCapabilities_getSupportedFrameRatesFor :: proc "c" (
	videoCaps: ^ACodecVideoCapabilities, 
	width:     i32, 
	height:    i32, 
	outRange:  ^ADoubleRange, 
) -> media_status_t ---

ACodecVideoCapabilities_getSupportedHeights :: proc "c" (
	videoCaps: ^ACodecVideoCapabilities, 
	outRange:  ^AIntRange, 
) -> media_status_t ---

ACodecVideoCapabilities_getSupportedHeightsFor :: proc "c" (
	videoCaps: ^ACodecVideoCapabilities, 
	width:     i32, 
	outRange:  ^AIntRange, 
) -> media_status_t ---

ACodecVideoCapabilities_getSupportedWidths :: proc "c" (
	videoCaps: ^ACodecVideoCapabilities, 
	outRange:  ^AIntRange, 
) -> media_status_t ---

ACodecVideoCapabilities_getSupportedWidthsFor :: proc "c" (
	videoCaps: ^ACodecVideoCapabilities, 
	height:    i32, 
	outRange:  ^AIntRange, 
) -> media_status_t ---

ACodecVideoCapabilities_getWidthAlignment :: proc "c" (videoCaps: ^ACodecVideoCapabilities) -> i32 ---

ACodecVideoCapabilities_isSizeSupported :: proc "c" (
	videoCaps: ^ACodecVideoCapabilities, 
	width:     i32, 
	height:    i32, 
) -> i32 ---

AImageReader_acquireLatestImage :: proc "c" (
	reader: ^AImageReader, 
	image:  ^^AImage, 
) -> media_status_t ---

AImageReader_acquireLatestImageAsync :: proc "c" (
	reader:         ^AImageReader, 
	image:          ^^AImage, 
	acquireFenceFd: ^i32, 
) -> media_status_t ---

AImageReader_acquireNextImage :: proc "c" (
	reader: ^AImageReader, 
	image:  ^^AImage, 
) -> media_status_t ---

AImageReader_acquireNextImageAsync :: proc "c" (
	reader:         ^AImageReader, 
	image:          ^^AImage, 
	acquireFenceFd: ^i32, 
) -> media_status_t ---

AImageReader_delete :: proc "c" (reader: ^AImageReader) ---

AImageReader_getFormat :: proc "c" (reader: ^AImageReader, format: ^i32) -> media_status_t ---

AImageReader_getHeight :: proc "c" (reader: ^AImageReader, height: ^i32) -> media_status_t ---

AImageReader_getMaxImages :: proc "c" (
	reader:    ^AImageReader, 
	maxImages: ^i32, 
) -> media_status_t ---

AImageReader_getWidth :: proc "c" (reader: ^AImageReader, width: ^i32) -> media_status_t ---

AImageReader_getWindow :: proc "c" (
	reader: ^AImageReader, 
	window: ^^android.ANativeWindow, 
) -> media_status_t ---

AImageReader_new :: proc "c" (
	width:     i32, 
	height:    i32, 
	format:    AIMAGE_FORMATS, 
	maxImages: i32, 
	reader:    ^^AImageReader, 
) -> media_status_t ---

AImageReader_newWithDataSpace :: proc "c" (
	width:                i32, 
	height:               i32, 
	usage:                android.AHardwareBuffer_UsageFlags, 
	maxImages:            i32, 
	hardwareBufferFormat: android.AHardwareBuffer_Format, 
	dataSpace:            android.ADataSpace, 
	reader:               ^^AImageReader, 
) -> media_status_t ---

AImageReader_newWithUsage :: proc "c" (
	width:     i32, 
	height:    i32, 
	format:    AIMAGE_FORMATS, 
	usage:     android.AHardwareBuffer_UsageFlags, 
	maxImages: i32, 
	reader:    ^^AImageReader, 
) -> media_status_t ---

AImageReader_setBufferRemovedListener :: proc "c" (
	reader:   ^AImageReader, 
	listener: ^AImageReader_BufferRemovedListener, 
) -> media_status_t ---

AImageReader_setDefaultAHardwareBufferFormat :: proc "c" (
	reader: ^AImageReader, 
	format: android.AHardwareBuffer_Format, 
) -> media_status_t ---

AImageReader_setDefaultBufferDataSpace :: proc "c" (
	reader:    ^AImageReader, 
	dataSpace: i32, 
) -> media_status_t ---

AImageReader_setDefaultBufferSize :: proc "c" (
	reader: ^AImageReader, 
	width:  i32, 
	height: i32, 
) -> media_status_t ---

AImageReader_setImageListener :: proc "c" (
	reader:   ^AImageReader, 
	listener: ^AImageReader_ImageListener, 
) -> media_status_t ---

AImage_delete :: proc "c" (image: ^AImage) ---

AImage_deleteAsync :: proc "c" (image: ^AImage, releaseFenceFd: i32) ---

AImage_getCropRect :: proc "c" (image: ^AImage, rect: ^AImageCropRect) -> media_status_t ---

AImage_getDataSpace :: proc "c" (image: ^AImage, dataSpace: ^i32) -> media_status_t ---

AImage_getFormat :: proc "c" (image: ^AImage, format: ^AIMAGE_FORMATS) -> media_status_t ---

AImage_getHardwareBuffer :: proc "c" (
	image:  ^AImage, 
	buffer: ^^android.AHardwareBuffer, 
) -> media_status_t ---

AImage_getHeight :: proc "c" (image: ^AImage, height: ^i32) -> media_status_t ---

AImage_getNumberOfPlanes :: proc "c" (image: ^AImage, numPlanes: ^i32) -> media_status_t ---

AImage_getPlaneData :: proc "c" (
	image:      ^AImage, 
	planeIdx:   i32, 
	data:       ^^u8, 
	dataLength: ^i32, 
) -> media_status_t ---

AImage_getPlanePixelStride :: proc "c" (
	image:       ^AImage, 
	planeIdx:    i32, 
	pixelStride: ^i32, 
) -> media_status_t ---

AImage_getPlaneRowStride :: proc "c" (
	image:     ^AImage, 
	planeIdx:  i32, 
	rowStride: ^i32, 
) -> media_status_t ---

AImage_getTimestamp :: proc "c" (image: ^AImage, timestampNs: ^i64) -> media_status_t ---

AImage_getTransform :: proc "c" (image: ^AImage, transform: ^i32) -> media_status_t ---

AImage_getWidth :: proc "c" (image: ^AImage, width: ^i32) -> media_status_t ---

AMediaCodecActionCode_isRecoverable :: proc "c" (actionCode: i32) -> bool ---

AMediaCodecActionCode_isTransient :: proc "c" (actionCode: i32) -> bool ---

AMediaCodecCryptoInfo_delete :: proc "c" (_0: ^AMediaCodecCryptoInfo) -> media_status_t ---

AMediaCodecCryptoInfo_getClearBytes :: proc "c" (
	_0:  ^AMediaCodecCryptoInfo, 
	dst: ^uint, 
) -> media_status_t ---

AMediaCodecCryptoInfo_getEncryptedBytes :: proc "c" (
	_0:  ^AMediaCodecCryptoInfo, 
	dst: ^uint, 
) -> media_status_t ---

AMediaCodecCryptoInfo_getIV :: proc "c" (
	_0:  ^AMediaCodecCryptoInfo, 
	dst: ^u8, 
) -> media_status_t ---

AMediaCodecCryptoInfo_getKey :: proc "c" (
	_0:  ^AMediaCodecCryptoInfo, 
	dst: ^u8, 
) -> media_status_t ---

AMediaCodecCryptoInfo_getMode :: proc "c" (_0: ^AMediaCodecCryptoInfo) -> cryptoinfo_mode_t ---

AMediaCodecCryptoInfo_getNumSubSamples :: proc "c" (_0: ^AMediaCodecCryptoInfo) -> uint ---

AMediaCodecCryptoInfo_new :: proc "c" (
	numsubsamples:  i32, 
	key:            ^u8, 
	iv:             ^u8, 
	mode:           cryptoinfo_mode_t, 
	clearbytes:     ^uint, 
	encryptedbytes: ^uint, 
) -> ^AMediaCodecCryptoInfo ---

AMediaCodecCryptoInfo_setPattern :: proc "c" (
	info:    ^AMediaCodecCryptoInfo, 
	pattern: ^cryptoinfo_pattern_t, 
) ---

AMediaCodecInfo_getAudioCapabilities :: proc "c" (
	info:         ^AMediaCodecInfo, 
	outAudioCaps: ^^ACodecAudioCapabilities, 
) -> media_status_t ---

AMediaCodecInfo_getCanonicalName :: proc "c" (info: ^AMediaCodecInfo) -> cstring ---

AMediaCodecInfo_getEncoderCapabilities :: proc "c" (
	info:           ^AMediaCodecInfo, 
	outEncoderCaps: ^^ACodecEncoderCapabilities, 
) -> media_status_t ---

AMediaCodecInfo_getKind :: proc "c" (info: ^AMediaCodecInfo) -> AMediaCodecKind ---

AMediaCodecInfo_getMaxSupportedInstances :: proc "c" (info: ^AMediaCodecInfo) -> i32 ---

AMediaCodecInfo_getMediaCodecInfoType :: proc "c" (info: ^AMediaCodecInfo) -> AMediaCodecType ---

AMediaCodecInfo_getMediaType :: proc "c" (info: ^AMediaCodecInfo) -> cstring ---

AMediaCodecInfo_getVideoCapabilities :: proc "c" (
	info:         ^AMediaCodecInfo, 
	outVideoCaps: ^^ACodecVideoCapabilities, 
) -> media_status_t ---

AMediaCodecInfo_isFeatureRequired :: proc "c" (
	info:        ^AMediaCodecInfo, 
	featureName: cstring, 
) -> i32 ---

AMediaCodecInfo_isFeatureSupported :: proc "c" (
	info:        ^AMediaCodecInfo, 
	featureName: cstring, 
) -> i32 ---

AMediaCodecInfo_isFormatSupported :: proc "c" (
	info:   ^AMediaCodecInfo, 
	format: ^AMediaFormat, 
) -> i32 ---

AMediaCodecInfo_isVendor :: proc "c" (info: ^AMediaCodecInfo) -> i32 ---

AMediaCodecStore_findNextDecoderForFormat :: proc "c" (
	format:       ^AMediaFormat, 
	outCodecInfo: ^^AMediaCodecInfo, 
) -> media_status_t ---

AMediaCodecStore_findNextEncoderForFormat :: proc "c" (
	format:       ^AMediaFormat, 
	outCodecInfo: ^^AMediaCodecInfo, 
) -> media_status_t ---

AMediaCodecStore_getCodecInfo :: proc "c" (
	name:         cstring, 
	outCodecInfo: ^^AMediaCodecInfo, 
) -> media_status_t ---

AMediaCodecStore_getSupportedMediaTypes :: proc "c" (
	outMediaTypes: ^^AMediaCodecSupportedMediaType, 
	outCount:      ^uint, 
) -> media_status_t ---

AMediaCodec_configure :: proc "c" (
	_0:      ^AMediaCodec, 
	format:  ^AMediaFormat, 
	surface: ^android.ANativeWindow, 
	crypto:  ^AMediaCrypto, 
	flags:   AMediaCodecConfigureFlags, 
) -> media_status_t ---

AMediaCodec_createCodecByName :: proc "c" (name: cstring) -> ^AMediaCodec ---

AMediaCodec_createDecoderByType :: proc "c" (mime_type: cstring) -> ^AMediaCodec ---

AMediaCodec_createEncoderByType :: proc "c" (mime_type: cstring) -> ^AMediaCodec ---

AMediaCodec_createInputSurface :: proc "c" (
	mData:   ^AMediaCodec, 
	surface: ^^android.ANativeWindow, 
) -> media_status_t ---

AMediaCodec_createPersistentInputSurface :: proc "c" (surface: ^^android.ANativeWindow) -> media_status_t ---

AMediaCodec_delete :: proc "c" (_0: ^AMediaCodec) -> media_status_t ---

AMediaCodec_dequeueInputBuffer :: proc "c" (_0: ^AMediaCodec, timeoutUs: i64) -> int ---

AMediaCodec_dequeueOutputBuffer :: proc "c" (
	_0:        ^AMediaCodec, 
	info:      ^AMediaCodecBufferInfo, 
	timeoutUs: i64, 
) -> int ---

AMediaCodec_flush :: proc "c" (_0: ^AMediaCodec) -> media_status_t ---

AMediaCodec_getBufferFormat :: proc "c" (_0: ^AMediaCodec, index: uint) -> ^AMediaFormat ---

AMediaCodec_getInputBuffer :: proc "c" (_0: ^AMediaCodec, idx: uint, out_size: ^uint) -> ^u8 ---

AMediaCodec_getInputFormat :: proc "c" (_0: ^AMediaCodec) -> ^AMediaFormat ---

AMediaCodec_getName :: proc "c" (_0: ^AMediaCodec, out_name: ^[^]u8) -> media_status_t ---

AMediaCodec_getOutputBuffer :: proc "c" (_0: ^AMediaCodec, idx: uint, out_size: ^uint) -> ^u8 ---

AMediaCodec_getOutputFormat :: proc "c" (_0: ^AMediaCodec) -> ^AMediaFormat ---

AMediaCodec_queueInputBuffer :: proc "c" (
	_0:     ^AMediaCodec, 
	idx:    uint, 
	offset: i64, 
	size:   uint, 
	time:   u64, 
	flags:  AMediaCodecBufferFlags, 
) -> media_status_t ---

AMediaCodec_queueSecureInputBuffer :: proc "c" (
	_0:     ^AMediaCodec, 
	idx:    uint, 
	offset: i64, 
	_3:     ^AMediaCodecCryptoInfo, 
	time:   u64, 
	flags:  AMediaCodecBufferFlags, 
) -> media_status_t ---

AMediaCodec_releaseCrypto :: proc "c" (_0: ^AMediaCodec) -> media_status_t ---

AMediaCodec_releaseName :: proc "c" (_0: ^AMediaCodec, name: [^]u8) ---

AMediaCodec_releaseOutputBuffer :: proc "c" (
	_0:     ^AMediaCodec, 
	idx:    uint, 
	render: bool, 
) -> media_status_t ---

AMediaCodec_releaseOutputBufferAtTime :: proc "c" (
	mData:       ^AMediaCodec, 
	idx:         uint, 
	timestampNs: i64, 
) -> media_status_t ---

AMediaCodec_setAsyncNotifyCallback :: proc "c" (
	_0:       ^AMediaCodec, 
	callback: AMediaCodecOnAsyncNotifyCallback, 
	userdata: rawptr, 
) -> media_status_t ---

AMediaCodec_setInputSurface :: proc "c" (
	mData:   ^AMediaCodec, 
	surface: ^android.ANativeWindow, 
) -> media_status_t ---

AMediaCodec_setOnFrameRenderedCallback :: proc "c" (
	_0:       ^AMediaCodec, 
	callback: AMediaCodecOnFrameRendered, 
	userdata: rawptr, 
) -> media_status_t ---

AMediaCodec_setOutputSurface :: proc "c" (
	_0:      ^AMediaCodec, 
	surface: ^android.ANativeWindow, 
) -> media_status_t ---

AMediaCodec_setParameters :: proc "c" (
	mData:  ^AMediaCodec, 
	params: ^AMediaFormat, 
) -> media_status_t ---

AMediaCodec_signalEndOfInputStream :: proc "c" (mData: ^AMediaCodec) -> media_status_t ---

AMediaCodec_start :: proc "c" (_0: ^AMediaCodec) -> media_status_t ---

AMediaCodec_stop :: proc "c" (_0: ^AMediaCodec) -> media_status_t ---

AMediaCrypto_delete :: proc "c" (crypto: ^AMediaCrypto) ---

AMediaCrypto_isCryptoSchemeSupported :: proc "c" (uuid: ^u8) -> bool ---

AMediaCrypto_new :: proc "c" (
	uuid:         ^u8, 
	initData:     rawptr, 
	initDataSize: uint, 
) -> ^AMediaCrypto ---

AMediaCrypto_requiresSecureDecoderComponent :: proc "c" (mime: cstring) -> bool ---

AMediaDataSource_close :: proc "c" (_0: ^AMediaDataSource) ---

AMediaDataSource_delete :: proc "c" (_0: ^AMediaDataSource) ---

AMediaDataSource_new :: proc "c" () -> ^AMediaDataSource ---

AMediaDataSource_newUri :: proc "c" (
	uri:        cstring, 
	numheaders: i32, 
	key_values: ^cstring, 
) -> ^AMediaDataSource ---

AMediaDataSource_setClose :: proc "c" (_0: ^AMediaDataSource, _1: AMediaDataSourceClose) ---

AMediaDataSource_setGetAvailableSize :: proc "c" (
	_0: ^AMediaDataSource, 
	_1: AMediaDataSourceGetAvailableSize, 
) ---

AMediaDataSource_setGetSize :: proc "c" (_0: ^AMediaDataSource, _1: AMediaDataSourceGetSize) ---

AMediaDataSource_setReadAt :: proc "c" (_0: ^AMediaDataSource, _1: AMediaDataSourceReadAt) ---

AMediaDataSource_setUserdata :: proc "c" (_0: ^AMediaDataSource, userdata: rawptr) ---

AMediaDrm_closeSession :: proc "c" (
	_0:        ^AMediaDrm, 
	sessionId: ^AMediaDrmByteArray, 
) -> media_status_t ---

AMediaDrm_createByUUID :: proc "c" (uuid: ^u8) -> ^AMediaDrm ---

AMediaDrm_decrypt :: proc "c" (
	_0:              ^AMediaDrm, 
	sessionId:       ^AMediaDrmByteArray, 
	cipherAlgorithm: cstring, 
	keyId:           ^u8, 
	iv:              ^u8, 
	input:           ^u8, 
	output:          ^u8, 
	dataSize:        uint, 
) -> media_status_t ---

AMediaDrm_encrypt :: proc "c" (
	_0:              ^AMediaDrm, 
	sessionId:       ^AMediaDrmByteArray, 
	cipherAlgorithm: cstring, 
	keyId:           ^u8, 
	iv:              ^u8, 
	input:           ^u8, 
	output:          ^u8, 
	dataSize:        uint, 
) -> media_status_t ---

AMediaDrm_getKeyRequest :: proc "c" (
	_0:                    ^AMediaDrm, 
	scope:                 ^AMediaDrmByteArray, 
	init:                  ^u8, 
	initSize:              uint, 
	mimeType:              cstring, 
	keyType:               AMediaDrmKeyType, 
	optionalParameters:    ^AMediaDrmKeyValue, 
	numOptionalParameters: uint, 
	keyRequest:            ^^u8, 
	keyRequestSize:        ^uint, 
) -> media_status_t ---

AMediaDrm_getKeyRequestWithDefaultUrlAndType :: proc "c" (
	_0:                    ^AMediaDrm, 
	scope:                 ^AMediaDrmByteArray, 
	init:                  ^u8, 
	initSize:              uint, 
	mimeType:              cstring, 
	keyType:               AMediaDrmKeyType, 
	optionalParameters:    ^AMediaDrmKeyValue, 
	numOptionalParameters: uint, 
	keyRequest:            ^^u8, 
	keyRequestSize:        ^uint, 
	defaultUrl:            ^cstring, 
	keyRequestType:        ^AMediaDrmKeyRequestType, 
) -> media_status_t ---

AMediaDrm_getPropertyByteArray :: proc "c" (
	_0:            ^AMediaDrm, 
	propertyName:  cstring, 
	propertyValue: ^AMediaDrmByteArray, 
) -> media_status_t ---

AMediaDrm_getPropertyString :: proc "c" (
	_0:            ^AMediaDrm, 
	propertyName:  cstring, 
	propertyValue: ^cstring, 
) -> media_status_t ---

AMediaDrm_getProvisionRequest :: proc "c" (
	_0:                   ^AMediaDrm, 
	provisionRequest:     ^^u8, 
	provisionRequestSize: ^uint, 
	serverUrl:            ^cstring, 
) -> media_status_t ---

AMediaDrm_getSecureStops :: proc "c" (
	_0:             ^AMediaDrm, 
	secureStops:    ^AMediaDrmByteArray, 
	numSecureStops: ^uint, 
) -> media_status_t ---

AMediaDrm_isCryptoSchemeSupported :: proc "c" (uuid: ^u8, mimeType: cstring) -> bool ---

AMediaDrm_openSession :: proc "c" (
	_0:        ^AMediaDrm, 
	sessionId: ^AMediaDrmByteArray, 
) -> media_status_t ---

AMediaDrm_provideKeyResponse :: proc "c" (
	_0:           ^AMediaDrm, 
	scope:        ^AMediaDrmByteArray, 
	response:     ^u8, 
	responseSize: uint, 
	keySetId:     ^AMediaDrmByteArray, 
) -> media_status_t ---

AMediaDrm_provideProvisionResponse :: proc "c" (
	_0:           ^AMediaDrm, 
	response:     ^u8, 
	responseSize: uint, 
) -> media_status_t ---

AMediaDrm_queryKeyStatus :: proc "c" (
	_0:            ^AMediaDrm, 
	sessionId:     ^AMediaDrmByteArray, 
	keyValuePairs: ^AMediaDrmKeyValue, 
	numPairs:      ^uint, 
) -> media_status_t ---

AMediaDrm_release :: proc "c" (_0: ^AMediaDrm) ---