Illusion/ndk-odin
1
0
Fork 0
mirror of https://github.com/IllusionMan1212/ndk-odin.git synced 2026-10-24 10:12:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

amidi, aaudio, and mediandk done

Browse Source
This commit is contained in:
Illusion
2024-08-08 12:27:09 +02:00
parent 66d5815ca7
commit a9c12c3e16
14 changed files with 5473 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
aaudio/AAudio.odin
+1750
View File
File diff suppressed because it is too large Load Diff
amidi/AMidi.odin
+329
View File
@@ -0,0 +1,329 @@
//+build android
package amidi
foreign import amidi "system:amidi"
/*
* Message Op Codes. Used to parse MIDI data packets
*/
AMidiOpcode :: enum i32 {
DATA = 1, /* The MIDI packet contains normal MIDI data */
FLUSH = 2, /* The MIDI packet contains just a MIDI FLUSH command. */
/* Forces the send of any pending MIDI data. */
}
/*
* Type IDs for various MIDI devices.
*/
AMidiDeviceType :: enum i32 {
USB = 1, /* A MIDI device connected to the Android USB port */
VIRTUAL = 2, /* A software object implementing MidiDeviceService */
BLUETOOTH = 3 /* A MIDI device connected via BlueTooth */
}
/*
* Protocol IDs for various MIDI devices.
*
* Introduced in API 33.
*/
AMidiDevice_Protocol :: enum i32 {
/**
* Constant representing a default protocol with Universal MIDI Packets (UMP).
* UMP is defined in "Universal MIDI Packet (UMP) Format and MIDI 2.0 Protocol" spec.
* All UMP data should be a multiple of 4 bytes.
* Use UMP to negotiate with the device with MIDI-CI.
* MIDI-CI is defined in "MIDI Capability Inquiry (MIDI-CI)" spec.
*/
UMP_USE_MIDI_CI = 0,
/**
* Constant representing a default protocol with Universal MIDI Packets (UMP).
* UMP is defined in "Universal MIDI Packet (UMP) Format and MIDI 2.0 Protocol" spec.
* All UMP data should be a multiple of 4 bytes.
* Use MIDI 1.0 through UMP with packet sizes up to 64 bits.
*/
UMP_MIDI_1_0_UP_TO_64_BITS = 1,
/**
* Constant representing a default protocol with Universal MIDI Packets (UMP).
* UMP is defined in "Universal MIDI Packet (UMP) Format and MIDI 2.0 Protocol" spec.
* All UMP data should be a multiple of 4 bytes.
* Use MIDI 1.0 through UMP with packet sizes up to 64 bits and jitter reduction timestamps.
*/
UMP_MIDI_1_0_UP_TO_64_BITS_AND_JRTS = 2,
/**
* Constant representing a default protocol with Universal MIDI Packets (UMP).
* UMP is defined in "Universal MIDI Packet (UMP) Format and MIDI 2.0 Protocol" spec.
* All UMP data should be a multiple of 4 bytes.
* Use MIDI 1.0 through UMP with packet sizes up to 128 bits.
*/
UMP_MIDI_1_0_UP_TO_128_BITS = 3,
/**
* Constant representing a default protocol with Universal MIDI Packets (UMP).
* UMP is defined in "Universal MIDI Packet (UMP) Format and MIDI 2.0 Protocol" spec.
* All UMP data should be a multiple of 4 bytes.
* Use MIDI 1.0 through UMP with packet sizes up to 128 bits and jitter reduction timestamps.
*/
UMP_MIDI_1_0_UP_TO_128_BITS_AND_JRTS = 4,
/**
* Constant representing a default protocol with Universal MIDI Packets (UMP).
* UMP is defined in "Universal MIDI Packet (UMP) Format and MIDI 2.0 Protocol" spec.
* All UMP data should be a multiple of 4 bytes.
* Use MIDI 2.0 through UMP.
*/
UMP_MIDI_2_0 = 17,
/**
* Constant representing a default protocol with Universal MIDI Packets (UMP).
* UMP is defined in "Universal MIDI Packet (UMP) Format and MIDI 2.0 Protocol" spec.
* All UMP data should be a multiple of 4 bytes.
* Use MIDI 2.0 through UMP and jitter reduction timestamps.
*/
UMP_MIDI_2_0_AND_JRTS = 18,
/**
* Constant representing a device with an unknown default protocol.
* If Universal MIDI Packets (UMP) are needed, use MIDI-CI through MIDI 1.0.
* UMP is defined in "Universal MIDI Packet (UMP) Format and MIDI 2.0 Protocol" spec.
* MIDI-CI is defined in "MIDI Capability Inquiry (MIDI-CI)" spec.
*/
UNKNOWN = -1
}
AMidiDevice :: struct{}
AMidiInputPort :: struct{}
AMidiOutputPort :: struct{}
foreign amidi {
/*
* Device API
*/
/**
* Connects a native Midi Device object to the associated Java MidiDevice object. Use this
* AMidiDevice to access the rest of the native MIDI API. Use AMidiDevice_release() to
* disconnect from the Java object when not being used any more.
*
* @param env Points to the Java Environment.
* @param midiDeviceObj The Java MidiDevice Object.
* @param outDevicePtrPtr Points to the pointer to receive the AMidiDevice
*
* @return AMEDIA_OK on success, or a negative error value:
* @see AMEDIA_ERROR_INVALID_OBJECT - the midiDeviceObj
* is null or already connected to a native AMidiDevice
* @see AMEDIA_ERROR_UNKNOWN - an unknown error occurred.
*
* Available since API level 29.
*/
AMidiDevice_fromJava :: proc(env: ^JNIEnv, midiDeviceObj: jobject, outDevicePtrPtr: ^^AMidiDevice) -> media_status_t ---
/**
* Disconnects the native Midi Device Object from the associated Java MidiDevice object.
*
* @param midiDevice Points to the native AMIDI_MidiDevice.
*
* @return AMEDIA_OK on success,
* or a negative error value:
* @see AMEDIA_ERROR_INVALID_PARAMETER - the device parameter is NULL.
* @see AMEDIA_ERROR_INVALID_OBJECT - the device is not consistent with the associated Java MidiDevice.
* @see AMEDIA_ERROR_INVALID_OBJECT - the JNI interface initialization to the associated java MidiDevice failed.
* @see AMEDIA_ERROR_UNKNOWN - couldn't retrieve the device info.
*
* Available since API level 29.
*/
AMidiDevice_release :: proc(midiDevice: ^AMidiDevice) -> media_status_t ---
/**
* Gets the MIDI device type.
*
* @param device Specifies the MIDI device.
*
* @return The identifier of the MIDI device type:
* AMIDI_DEVICE_TYPE_USB
* AMIDI_DEVICE_TYPE_VIRTUAL
* AMIDI_DEVICE_TYPE_BLUETOOTH
* or a negative error value:
* @see AMEDIA_ERROR_INVALID_PARAMETER - the device parameter is NULL.
* @see AMEDIA_ERROR_UNKNOWN - Unknown error.
*
* Available since API level 29.
*/
AMidiDevice_getType :: proc(device: ^AMidiDevice) -> i32 ---
/**
* Gets the number of input (sending) ports available on the specified MIDI device.
*
* @param device Specifies the MIDI device.
*
* @return If successful, returns the number of MIDI input (sending) ports available on the
* device. If an error occurs, returns a negative value indicating the error:
* @see AMEDIA_ERROR_INVALID_PARAMETER - the device parameter is NULL.
* @see AMEDIA_ERROR_UNKNOWN - couldn't retrieve the device info.
*
* Available since API level 29.
*/
AMidiDevice_getNumInputPorts :: proc(device: ^AMidiDevice) -> int ---
/**
* Gets the number of output (receiving) ports available on the specified MIDI device.
*
* @param device Specifies the MIDI device.
*
* @return If successful, returns the number of MIDI output (receiving) ports available on the
* device. If an error occurs, returns a negative value indicating the error:
* @see AMEDIA_ERROR_INVALID_PARAMETER - the device parameter is NULL.
* @see AMEDIA_ERROR_UNKNOWN - couldn't retrieve the device info.
*
* Available since API level 29.
*/
AMidiDevice_getNumOutputPorts :: proc(device: ^AMidiDevice) -> int ---
/**
* Gets the MIDI device default protocol.
*
* @param device Specifies the MIDI device.
*
* @return The identifier of the MIDI device default protocol:
* AMIDI_DEVICE_PROTOCOL_UMP_USE_MIDI_CI
* AMIDI_DEVICE_PROTOCOL_UMP_MIDI_1_0_UP_TO_64_BITS
* AMIDI_DEVICE_PROTOCOL_UMP_MIDI_1_0_UP_TO_64_BITS_AND_JRTS
* AMIDI_DEVICE_PROTOCOL_UMP_MIDI_1_0_UP_TO_128_BITS
* AMIDI_DEVICE_PROTOCOL_UMP_MIDI_1_0_UP_TO_128_BITS_AND_JRTS
* AMIDI_DEVICE_PROTOCOL_UMP_MIDI_2_0
* AMIDI_DEVICE_PROTOCOL_UMP_MIDI_2_0_AND_JRTS
* AMIDI_DEVICE_PROTOCOL_UNKNOWN
*
* Most devices should return PROTOCOL_UNKNOWN (-1). This is intentional as devices
* with default UMP support are not backwards compatible. When the device is null,
* return AMIDI_DEVICE_PROTOCOL_UNKNOWN.
*
* Available since API 33.
*/
AMidiDevice_getDefaultProtocol :: proc(device: AMidiDevice) -> AMidiDevice_Protocol ---
/*
* API for receiving data from the Output port of a device.
*/
/**
* Opens the output port so that the client can receive data from it. The port remains open and
* valid until AMidiOutputPort_close() is called for the returned AMidiOutputPort.
*
* @param device Specifies the MIDI device.
* @param portNumber Specifies the zero-based port index on the device to open. This value ranges
* between 0 and one less than the number of output ports reported by the
* AMidiDevice_getNumOutputPorts function.
* @param outOutputPortPtr Receives the native API port identifier of the opened port.
*
* @return AMEDIA_OK, or a negative error code:
* @see AMEDIA_ERROR_UNKNOWN - Unknown Error.
*
* Available since API level 29.
*/
AMidiOutputPort_open :: proc(device: ^AMidiDevice, portNumber: i32, outOutputPortPtr: ^^AMidiOutputPort) -> media_status_t ---
/**
* Closes the output port.
*
* @param outputPort The native API port identifier of the port.
*
* Available since API level 29.
*/
AMidiOutputPort_close :: proc(outputPort: ^AMidiOutputPort) ---
/**
* Receives the next pending MIDI message. To retrieve all pending messages, the client should
* repeatedly call this method until it returns 0.
*
* Note that this is a non-blocking call. If there are no Midi messages are available, the function
* returns 0 immediately (for 0 messages received).
*
* @param outputPort Identifies the port to receive messages from.
* @param opcodePtr Receives the message Op Code.
* @param buffer Points to the buffer to receive the message data bytes.
* @param maxBytes Specifies the size of the buffer pointed to by the buffer parameter.
* @param numBytesReceivedPtr On exit, receives the actual number of bytes stored in buffer.
* @param outTimestampPtr If non-NULL, receives the timestamp associated with the message.
* (the current value of the running Java Virtual Machine's high-resolution time source,
* in nanoseconds)
* @return the number of messages received (either 0 or 1), or a negative error code:
* @see AMEDIA_ERROR_UNKNOWN - Unknown Error.
*
* Available since API level 29.
*/
AMidiOutputPort_receive :: proc(outputPort: ^AMidiOutputPort, opcodePtr: ^AMidiOpcode, buffer: [^]byte, maxBytes: uint, numBytesReceivedPtr: ^uint, outTimestampPtr: ^i64) -> int ---
/*
* API for sending data to the Input port of a device.
*/
/**
* Opens the input port so that the client can send data to it. The port remains open and
* valid until AMidiInputPort_close() is called for the returned AMidiInputPort.
*
* @param device Specifies the MIDI device.
* @param portNumber Specifies the zero-based port index on the device to open. This value ranges
* between 0 and one less than the number of input ports reported by the
* AMidiDevice_getNumInputPorts() function..
* @param outInputPortPtr Receives the native API port identifier of the opened port.
*
* @return AMEDIA_OK, or a negative error code:
* @see AMEDIA_ERROR_UNKNOWN - Unknown Error.
*
* Available since API level 29.
*/
AMidiInputPort_open :: proc(device: ^AMidiDevice, portNumber: i32, outInputPortPtr: ^^AMidiInputPort) -> media_status_t ---
/**
* Sends data to the specified input port.
*
* @param inputPort The identifier of the port to send data to.
* @param buffer Points to the array of bytes containing the data to send.
* @param numBytes Specifies the number of bytes to write.
*
* @return The number of bytes sent, which could be less than specified or a negative error code:
* @see AMEDIA_ERROR_INVALID_PARAMETER - The specified port was NULL, the specified buffer was NULL.
*
* Available since API level 29.
*/
AMidiInputPort_send :: proc(inputPort: ^AMidiInputPort, buffer: [^]byte, numBytes: uint) -> int ---
/**
* Sends data to the specified input port with a timestamp.
*
* @param inputPort The identifier of the port to send data to.
* @param buffer Points to the array of bytes containing the data to send.
* @param numBytes Specifies the number of bytes to write.
* @param timestamp The CLOCK_MONOTONIC time in nanoseconds to associate with the sent data.
*
* @return The number of bytes sent, which could be less than specified or a negative error code:
* @see AMEDIA_ERROR_INVALID_PARAMETER - The specified port was NULL, the specified buffer was NULL.
*
* Available since API level 29.
*/
AMidiInputPort_sendWithTimestamp :: proc(inputPort: ^AMidiInputPort, buffer: [^]byte, numBytes: uint, timestamp: i64) -> int ---
/**
* Sends a message with a 'MIDI flush command code' to the specified port. This should cause
* a receiver to discard any pending MIDI data it may have accumulated and not processed.
*
* @param inputPort The identifier of the port to send the flush command to.
*
* @returns @see AMEDIA_OK if successful, otherwise a negative error code:
* @see AMEDIA_ERROR_INVALID_PARAMETER - The specified port was NULL
* @see AMEDIA_ERROR_UNSUPPORTED - The FLUSH command couldn't
* be sent.
*
* Available since API level 29.
*/
AMidiInputPort_sendFlush :: proc(inputPort: ^AMidiInputPort) -> media_status_t ---
/**
* Closes the input port.
*
* @param inputPort Identifies the input (sending) port to close.
*
* Available since API level 29.
*/
AMidiInputPort_close :: proc(inputPort: ^AMidiInputPort) ---
}
android_native_app_glue.odin
-1
View File
@@ -122,7 +122,6 @@ android_poll_source :: struct {
// Function to call to perform the standard processing of data from
// this source.
//void (*process)(struct android_app* app, struct android_poll_source* source),
process: #type proc "c" (app: ^android_app, source: ^android_poll_source),
}
media/NdkImage.odin
+784
View File
@@ -0,0 +1,784 @@
//+build android
package mediandk
import "../"
foreign import mediandk "system:mediandk"
/**
* AImage supported formats: AImageReader only guarantees the support for the formats
* listed here.
*/
AImageFormats :: enum i32 {
/**
* 32 bits RGBA format, 8 bits for each of the four channels.
*
* <p>
* Corresponding formats:
* <ul>
* <li>AHardwareBuffer: AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM</li>
* <li>Vulkan: VK_FORMAT_R8G8B8A8_UNORM</li>
* <li>OpenGL ES: GL_RGBA8</li>
* </ul>
* </p>
*
* @see AImage
* @see AImageReader
* @see AHardwareBuffer
*/
RGBA_8888 = 0x1,
/**
* 32 bits RGBX format, 8 bits for each of the four channels. The values
* of the alpha channel bits are ignored (image is assumed to be opaque).
*
* <p>
* Corresponding formats:
* <ul>
* <li>AHardwareBuffer: AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM</li>
* <li>Vulkan: VK_FORMAT_R8G8B8A8_UNORM</li>
* <li>OpenGL ES: GL_RGB8</li>
* </ul>
* </p>
*
* @see AImage
* @see AImageReader
* @see AHardwareBuffer
*/
RGBX_8888 = 0x2,
/**
* 24 bits RGB format, 8 bits for each of the three channels.
*
* <p>
* Corresponding formats:
* <ul>
* <li>AHardwareBuffer: AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM</li>
* <li>Vulkan: VK_FORMAT_R8G8B8_UNORM</li>
* <li>OpenGL ES: GL_RGB8</li>
* </ul>
* </p>
*
* @see AImage
* @see AImageReader
* @see AHardwareBuffer
*/
RGB_888 = 0x3,
/**
* 16 bits RGB format, 5 bits for Red channel, 6 bits for Green channel,
* and 5 bits for Blue channel.
*
* <p>
* Corresponding formats:
* <ul>
* <li>AHardwareBuffer: AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM</li>
* <li>Vulkan: VK_FORMAT_R5G6B5_UNORM_PACK16</li>
* <li>OpenGL ES: GL_RGB565</li>
* </ul>
* </p>
*
* @see AImage
* @see AImageReader
* @see AHardwareBuffer
*/
RGB_565 = 0x4,
/**
* 64 bits RGBA format, 16 bits for each of the four channels.
*
* <p>
* Corresponding formats:
* <ul>
* <li>AHardwareBuffer: AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT</li>
* <li>Vulkan: VK_FORMAT_R16G16B16A16_SFLOAT</li>
* <li>OpenGL ES: GL_RGBA16F</li>
* </ul>
* </p>
*
* @see AImage
* @see AImageReader
* @see AHardwareBuffer
*/
RGBA_FP16 = 0x16,
/**
* Multi-plane Android YUV 420 format.
*
* <p>This format is a generic YCbCr format, capable of describing any 4:2:0
* chroma-subsampled planar or semiplanar buffer (but not fully interleaved),
* with 8 bits per color sample.</p>
*
* <p>Images in this format are always represented by three separate buffers
* of data, one for each color plane. Additional information always
* accompanies the buffers, describing the row stride and the pixel stride
* for each plane.</p>
*
* <p>The order of planes is guaranteed such that plane #0 is always Y, plane #1 is always
* U (Cb), and plane #2 is always V (Cr).</p>
*
* <p>The Y-plane is guaranteed not to be interleaved with the U/V planes
* (in particular, pixel stride is always 1 in {@link AImage_getPlanePixelStride}).</p>
*
* <p>The U/V planes are guaranteed to have the same row stride and pixel stride, that is, the
* return value of {@link AImage_getPlaneRowStride} for the U/V plane are guaranteed to be the
* same, and the return value of {@link AImage_getPlanePixelStride} for the U/V plane are also
* guaranteed to be the same.</p>
*
* <p>For example, the {@link AImage} object can provide data
* in this format from a {@link ACameraDevice} through an {@link AImageReader} object.</p>
*
* <p>This format is always supported as an output format for the android Camera2 NDK API.</p>
*
* @see AImage
* @see AImageReader
* @see ACameraDevice
*/
YUV_420_888 = 0x23,
/**
* Compressed JPEG format.
*
* <p>This format is always supported as an output format for the android Camera2 NDK API.</p>
*/
JPEG = 0x100,
/**
* 16 bits per pixel raw camera sensor image format, usually representing a single-channel
* Bayer-mosaic image.
*
* <p>The layout of the color mosaic, the maximum and minimum encoding
* values of the raw pixel data, the color space of the image, and all other
* needed information to interpret a raw sensor image must be queried from
* the {@link ACameraDevice} which produced the image.</p>
*/
RAW16 = 0x20,
/**
* Private raw camera sensor image format, a single channel image with implementation depedent
* pixel layout.
*
* <p>RAW_PRIVATE is a format for unprocessed raw image buffers coming from an
* image sensor. The actual structure of buffers of this format is implementation-dependent.</p>
*
*/
RAW_PRIVATE = 0x24,
/**
* Android 10-bit raw format.
*
* <p>
* This is a single-plane, 10-bit per pixel, densely packed (in each row),
* unprocessed format, usually representing raw Bayer-pattern images coming
* from an image sensor.
* </p>
* <p>
* In an image buffer with this format, starting from the first pixel of
* each row, each 4 consecutive pixels are packed into 5 bytes (40 bits).
* Each one of the first 4 bytes contains the top 8 bits of each pixel, The
* fifth byte contains the 2 least significant bits of the 4 pixels, the
* exact layout data for each 4 consecutive pixels is illustrated below
* (Pi[j] stands for the jth bit of the ith pixel):
* </p>
* <table>
* <tr>
* <th align="center"></th>
* <th align="center">bit 7</th>
* <th align="center">bit 6</th>
* <th align="center">bit 5</th>
* <th align="center">bit 4</th>
* <th align="center">bit 3</th>
* <th align="center">bit 2</th>
* <th align="center">bit 1</th>
* <th align="center">bit 0</th>
* </tr>
* <tr>
* <td align="center">Byte 0:</td>
* <td align="center">P0[9]</td>
* <td align="center">P0[8]</td>
* <td align="center">P0[7]</td>
* <td align="center">P0[6]</td>
* <td align="center">P0[5]</td>
* <td align="center">P0[4]</td>
* <td align="center">P0[3]</td>
* <td align="center">P0[2]</td>
* </tr>
* <tr>
* <td align="center">Byte 1:</td>
* <td align="center">P1[9]</td>
* <td align="center">P1[8]</td>
* <td align="center">P1[7]</td>
* <td align="center">P1[6]</td>
* <td align="center">P1[5]</td>
* <td align="center">P1[4]</td>
* <td align="center">P1[3]</td>
* <td align="center">P1[2]</td>
* </tr>
* <tr>
* <td align="center">Byte 2:</td>
* <td align="center">P2[9]</td>
* <td align="center">P2[8]</td>
* <td align="center">P2[7]</td>
* <td align="center">P2[6]</td>
* <td align="center">P2[5]</td>
* <td align="center">P2[4]</td>
* <td align="center">P2[3]</td>
* <td align="center">P2[2]</td>
* </tr>
* <tr>
* <td align="center">Byte 3:</td>
* <td align="center">P3[9]</td>
* <td align="center">P3[8]</td>
* <td align="center">P3[7]</td>
* <td align="center">P3[6]</td>
* <td align="center">P3[5]</td>
* <td align="center">P3[4]</td>
* <td align="center">P3[3]</td>
* <td align="center">P3[2]</td>
* </tr>
* <tr>
* <td align="center">Byte 4:</td>
* <td align="center">P3[1]</td>
* <td align="center">P3[0]</td>
* <td align="center">P2[1]</td>
* <td align="center">P2[0]</td>
* <td align="center">P1[1]</td>
* <td align="center">P1[0]</td>
* <td align="center">P0[1]</td>
* <td align="center">P0[0]</td>
* </tr>
* </table>
* <p>
* This format assumes
* <ul>
* <li>a width multiple of 4 pixels</li>
* <li>an even height</li>
* </ul>
* </p>
*
* <pre>size = row stride * height</pre> where the row stride is in <em>bytes</em>,
* not pixels.
*
* <p>
* Since this is a densely packed format, the pixel stride is always 0. The
* application must use the pixel data layout defined in above table to
* access each row data. When row stride is equal to (width * (10 / 8)), there
* will be no padding bytes at the end of each row, the entire image data is
* densely packed. When stride is larger than (width * (10 / 8)), padding
* bytes will be present at the end of each row.
* </p>
* <p>
* For example, the {@link AImage} object can provide data in this format from a
* {@link ACameraDevice} (if supported) through a {@link AImageReader} object.
* The number of planes returned by {@link AImage_getNumberOfPlanes} will always be 1.
* The pixel stride is undefined ({@link AImage_getPlanePixelStride} will return
* {@link AMEDIA_ERROR_UNSUPPORTED}), and the {@link AImage_getPlaneRowStride} described the
* vertical neighboring pixel distance (in bytes) between adjacent rows.
* </p>
*
* @see AImage
* @see AImageReader
* @see ACameraDevice
*/
RAW10 = 0x25,
/**
* Android 12-bit raw format.
*
* <p>
* This is a single-plane, 12-bit per pixel, densely packed (in each row),
* unprocessed format, usually representing raw Bayer-pattern images coming
* from an image sensor.
* </p>
* <p>
* In an image buffer with this format, starting from the first pixel of each
* row, each two consecutive pixels are packed into 3 bytes (24 bits). The first
* and second byte contains the top 8 bits of first and second pixel. The third
* byte contains the 4 least significant bits of the two pixels, the exact layout
* data for each two consecutive pixels is illustrated below (Pi[j] stands for
* the jth bit of the ith pixel):
* </p>
* <table>
* <tr>
* <th align="center"></th>
* <th align="center">bit 7</th>
* <th align="center">bit 6</th>
* <th align="center">bit 5</th>
* <th align="center">bit 4</th>
* <th align="center">bit 3</th>
* <th align="center">bit 2</th>
* <th align="center">bit 1</th>
* <th align="center">bit 0</th>
* </tr>
* <tr>
* <td align="center">Byte 0:</td>
* <td align="center">P0[11]</td>
* <td align="center">P0[10]</td>
* <td align="center">P0[ 9]</td>
* <td align="center">P0[ 8]</td>
* <td align="center">P0[ 7]</td>
* <td align="center">P0[ 6]</td>
* <td align="center">P0[ 5]</td>
* <td align="center">P0[ 4]</td>
* </tr>
* <tr>
* <td align="center">Byte 1:</td>
* <td align="center">P1[11]</td>
* <td align="center">P1[10]</td>
* <td align="center">P1[ 9]</td>
* <td align="center">P1[ 8]</td>
* <td align="center">P1[ 7]</td>
* <td align="center">P1[ 6]</td>
* <td align="center">P1[ 5]</td>
* <td align="center">P1[ 4]</td>
* </tr>
* <tr>
* <td align="center">Byte 2:</td>
* <td align="center">P1[ 3]</td>
* <td align="center">P1[ 2]</td>
* <td align="center">P1[ 1]</td>
* <td align="center">P1[ 0]</td>
* <td align="center">P0[ 3]</td>
* <td align="center">P0[ 2]</td>
* <td align="center">P0[ 1]</td>
* <td align="center">P0[ 0]</td>
* </tr>
* </table>
* <p>
* This format assumes
* <ul>
* <li>a width multiple of 4 pixels</li>
* <li>an even height</li>
* </ul>
* </p>
*
* <pre>size = row stride * height</pre> where the row stride is in <em>bytes</em>,
* not pixels.
*
* <p>
* Since this is a densely packed format, the pixel stride is always 0. The
* application must use the pixel data layout defined in above table to
* access each row data. When row stride is equal to (width * (12 / 8)), there
* will be no padding bytes at the end of each row, the entire image data is
* densely packed. When stride is larger than (width * (12 / 8)), padding
* bytes will be present at the end of each row.
* </p>
* <p>
* For example, the {@link AImage} object can provide data in this format from a
* {@link ACameraDevice} (if supported) through a {@link AImageReader} object.
* The number of planes returned by {@link AImage_getNumberOfPlanes} will always be 1.
* The pixel stride is undefined ({@link AImage_getPlanePixelStride} will return
* {@link AMEDIA_ERROR_UNSUPPORTED}), and the {@link AImage_getPlaneRowStride} described the
* vertical neighboring pixel distance (in bytes) between adjacent rows.
* </p>
*
* @see AImage
* @see AImageReader
* @see ACameraDevice
*/
RAW12 = 0x26,
/**
* Android dense depth image format.
*
* <p>Each pixel is 16 bits, representing a depth ranging measurement from a depth camera or
* similar sensor. The 16-bit sample consists of a confidence value and the actual ranging
* measurement.</p>
*
* <p>The confidence value is an estimate of correctness for this sample. It is encoded in the
* 3 most significant bits of the sample, with a value of 0 representing 100% confidence, a
* value of 1 representing 0% confidence, a value of 2 representing 1/7, a value of 3
* representing 2/7, and so on.</p>
*
* <p>As an example, the following sample extracts the range and confidence from the first pixel
* of a DEPTH16-format {@link AImage}, and converts the confidence to a floating-point value
* between 0 and 1.f inclusive, with 1.f representing maximum confidence:
*
* <pre>
* uint16_t* data;
* int dataLength;
* AImage_getPlaneData(image, 0, (uint8_t**)&data, &dataLength);
* uint16_t depthSample = data[0];
* uint16_t depthRange = (depthSample & 0x1FFF);
* uint16_t depthConfidence = ((depthSample >> 13) & 0x7);
* float depthPercentage = depthConfidence == 0 ? 1.f : (depthConfidence - 1) / 7.f;
* </pre>
* </p>
*
* <p>This format assumes
* <ul>
* <li>an even width</li>
* <li>an even height</li>
* <li>a horizontal stride multiple of 16 pixels</li>
* </ul>
* </p>
*
* <pre> y_size = stride * height </pre>
*
* When produced by a camera, the units for the range are millimeters.
*/
DEPTH16 = 0x44363159,
/**
* Android sparse depth point cloud format.
*
* <p>A variable-length list of 3D points plus a confidence value, with each point represented
* by four floats; first the X, Y, Z position coordinates, and then the confidence value.</p>
*
* <p>The number of points is ((size of the buffer in bytes) / 16).
*
* <p>The coordinate system and units of the position values depend on the source of the point
* cloud data. The confidence value is between 0.f and 1.f, inclusive, with 0 representing 0%
* confidence and 1.f representing 100% confidence in the measured position values.</p>
*
* <p>As an example, the following code extracts the first depth point in a DEPTH_POINT_CLOUD
* format {@link AImage}:
* <pre>
* float* data;
* int dataLength;
* AImage_getPlaneData(image, 0, (uint8_t**)&data, &dataLength);
* float x = data[0];
* float y = data[1];
* float z = data[2];
* float confidence = data[3];
* </pre>
*
*/
DEPTH_POINT_CLOUD = 0x101,
/**
* Android private opaque image format.
*
* <p>The choices of the actual format and pixel data layout are entirely up to the
* device-specific and framework internal implementations, and may vary depending on use cases
* even for the same device. Also note that the contents of these buffers are not directly
* accessible to the application.</p>
*
* <p>When an {@link AImage} of this format is obtained from an {@link AImageReader} or
* {@link AImage_getNumberOfPlanes()} method will return zero.</p>
*/
PRIVATE = 0x22,
/**
* Android Y8 format.
*
* <p>Y8 is a planar format comprised of a WxH Y plane only, with each pixel
* being represented by 8 bits.</p>
*
* <p>This format assumes
* <ul>
* <li>an even width</li>
* <li>an even height</li>
* <li>a horizontal stride multiple of 16 pixels</li>
* </ul>
* </p>
*
* <pre> size = stride * height </pre>
*
* <p>For example, the {@link AImage} object can provide data
* in this format from a {@link ACameraDevice} (if supported) through a
* {@link AImageReader} object. The number of planes returned by
* {@link AImage_getNumberOfPlanes} will always be 1. The pixel stride returned by
* {@link AImage_getPlanePixelStride} will always be 1, and the
* {@link AImage_getPlaneRowStride} described the vertical neighboring pixel distance
* (in bytes) between adjacent rows.</p>
*
*/
Y8 = 0x20203859,
/**
* Compressed HEIC format.
*
* <p>This format defines the HEIC brand of High Efficiency Image File
* Format as described in ISO/IEC 23008-12.</p>
*/
HEIC = 0x48454946,
/**
* Depth augmented compressed JPEG format.
*
* <p>JPEG compressed main image along with XMP embedded depth metadata
* following ISO 16684-1:2011(E).</p>
*/
DEPTH_JPEG = 0x69656963,
}
/**
* AImage is an opaque type that provides access to image generated by {@link AImageReader}.
*/
AImage :: struct{}
/**
* Data type describing an cropped rectangle returned by {@link AImage_getCropRect}.
*
* <p>Note that the right and bottom coordinates are exclusive, so the width of the rectangle is
* (right - left) and the height of the rectangle is (bottom - top).</p>
*/
AImageCropRect :: struct {
left: i32,
top: i32,
right: i32,
bottom: i32,
}
foreign mediandk {
/**
* Return the image back the the system and delete the AImage object from memory.
*
* <p>Do NOT use the image pointer after this method returns.
* Note that if the parent {@link AImageReader} is closed, all the {@link AImage} objects acquired
* from the parent reader will be returned to system. All AImage_* methods except this method will
* return {@link AMEDIA_ERROR_INVALID_OBJECT}. Application still needs to call this method on those
* {@link AImage} objects to fully delete the {@link AImage} object from memory.</p>
*
* Available since API level 24.
*
* @param image The {@link AImage} to be deleted.
*/
AImage_delete :: proc(image: ^AImage) ---
/**
* Query the width of the input {@link AImage}.
*
* Available since API level 24.
*
* @param image the {@link AImage} of interest.
* @param width the width of the image will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or width is NULL.</li>
* <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
* image has been deleted.</li></ul>
*/
AImage_getWidth :: proc(image: ^AImage, width: ^i32) -> media_status_t ---
/**
* Query the height of the input {@link AImage}.
*
* Available since API level 24.
*
* @param image the {@link AImage} of interest.
* @param height the height of the image will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or height is NULL.</li>
* <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
* image has been deleted.</li></ul>
*/
AImage_getHeight :: proc(image: ^AImage, height: ^i32) -> media_status_t ---
/**
* Query the format of the input {@link AImage}.
*
* <p>The format value will be one of AIMAGE_FORMAT_* enum value.</p>
*
* Available since API level 24.
*
* @param image the {@link AImage} of interest.
* @param format the format of the image will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or format is NULL.</li>
* <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
* image has been deleted.</li></ul>
*/
AImage_getFormat :: proc(image: ^AImage, format: ^AImageFormats) -> media_status_t ---
/**
* Query the cropped rectangle of the input {@link AImage}.
*
* <p>The crop rectangle specifies the region of valid pixels in the image, using coordinates in the
* largest-resolution plane.</p>
*
* Available since API level 24.
*
* @param image the {@link AImage} of interest.
* @param rect the cropped rectangle of the image will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or rect is NULL.</li>
* <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
* image has been deleted.</li></ul>
*/
AImage_getCropRect :: proc(image: ^AImage, rect: ^AImageCropRect) -> media_status_t ---
/**
* Query the timestamp of the input {@link AImage}.
*
* <p>
* The timestamp is measured in nanoseconds, and is normally monotonically increasing. The
* timestamps for the images from different sources may have different timebases therefore may not
* be comparable. The specific meaning and timebase of the timestamp depend on the source providing
* images. For images generated by camera, the timestamp value will match
* {@link ACAMERA_SENSOR_TIMESTAMP} of the {@link ACameraMetadata} in
* {@link ACameraCaptureSession_captureCallbacks#onCaptureStarted} and
* {@link ACameraCaptureSession_captureCallbacks#onCaptureCompleted} callback.
* </p>
*
* Available since API level 24.
*
* @param image the {@link AImage} of interest.
* @param timestampNs the timestamp of the image will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or timestampNs is NULL.</li>
* <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
* image has been deleted.</li></ul>
*/
AImage_getTimestamp :: proc(image: ^AImage, timestampNs: ^i64) -> media_status_t ---
/**
* Query the number of planes of the input {@link AImage}.
*
* <p>The number of plane of an {@link AImage} is determined by its format, which can be queried by
* {@link AImage_getFormat} method.</p>
*
* Available since API level 24.
*
* @param image the {@link AImage} of interest.
* @param numPlanes the number of planes of the image will be filled here if the method call
* succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or numPlanes is NULL.</li>
* <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
* image has been deleted.</li></ul>
*/
AImage_getNumberOfPlanes :: proc(image: ^AImage, numPlanes: ^i32) -> media_status_t ---
/**
* Query the pixel stride of the input {@link AImage}.
*
* <p>This is the distance between two consecutive pixel values in a row of pixels. It may be
* larger than the size of a single pixel to account for interleaved image data or padded formats.
* Note that pixel stride is undefined for some formats such as {@link AIMAGE_FORMAT_RAW_PRIVATE},
* and calling this method on images of these formats will cause {@link AMEDIA_ERROR_UNSUPPORTED}
* being returned.
* For formats where pixel stride is well defined, the pixel stride is always greater than 0.</p>
*
* Available since API level 24.
*
* @param image the {@link AImage} of interest.
* @param planeIdx the index of the plane. Must be less than the number of planes of input image.
* @param pixelStride the pixel stride of the image will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or pixelStride is NULL, or planeIdx
* is out of the range of [0, numOfPlanes - 1].</li>
* <li>{@link AMEDIA_ERROR_UNSUPPORTED} if pixel stride is undefined for the format of input
* image.</li>
* <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
* image has been deleted.</li>
* <li>{@link AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE} if the {@link AImage} cannot be locked
* for CPU access.</li></ul>
*/
AImage_getPlanePixelStride :: proc(image: ^AImage, planeIdx: i32, pixelStride: ^i32) -> media_status_t ---
/**
* Query the row stride of the input {@link AImage}.
*
* <p>This is the distance between the start of two consecutive rows of pixels in the image. Note
* that row stried is undefined for some formats such as {@link AIMAGE_FORMAT_RAW_PRIVATE}, and
* calling this method on images of these formats will cause {@link AMEDIA_ERROR_UNSUPPORTED}
* being returned.
* For formats where row stride is well defined, the row stride is always greater than 0.</p>
*
* Available since API level 24.
*
* @param image the {@link AImage} of interest.
* @param planeIdx the index of the plane. Must be less than the number of planes of input image.
* @param rowStride the row stride of the image will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or rowStride is NULL, or planeIdx
* is out of the range of [0, numOfPlanes - 1].</li>
* <li>{@link AMEDIA_ERROR_UNSUPPORTED} if row stride is undefined for the format of input
* image.</li>
* <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
* image has been deleted.</li>
* <li>{@link AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE} if the {@link AImage} cannot be locked
* for CPU access.</li></ul>
*/
AImage_getPlaneRowStride :: proc(image: ^AImage, planeIdx: i32, rowStride: ^i32) -> media_status_t ---
/**
* Get the data pointer of the input image for direct application access.
*
* <p>Note that once the {@link AImage} or the parent {@link AImageReader} is deleted, the data
* pointer from previous AImage_getPlaneData call becomes invalid. Do NOT use it after the
* {@link AImage} or the parent {@link AImageReader} is deleted.</p>
*
* Available since API level 24.
*
* @param image the {@link AImage} of interest.
* @param planeIdx the index of the plane. Must be less than the number of planes of input image.
* @param data the data pointer of the image will be filled here if the method call succeeeds.
* @param dataLength the valid length of data will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image, data or dataLength is NULL, or
* planeIdx is out of the range of [0, numOfPlanes - 1].</li>
* <li>{@link AMEDIA_ERROR_INVALID_OBJECT} if the {@link AImageReader} generated this
* image has been deleted.</li>
* <li>{@link AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE} if the {@link AImage} cannot be locked
* for CPU access.</li></ul>
*/
AImage_getPlaneData :: proc(image: ^AImage, planeIdx: i32, data: ^[^]u8, dataLength: ^i32) -> media_status_t ---
/**
* Return the image back the the system and delete the AImage object from memory asynchronously.
*
* <p>Similar to {@link AImage_delete}, do NOT use the image pointer after this method returns.
* However, the caller can still hold on to the {@link AHardwareBuffer} returned from this image and
* signal the release of the hardware buffer back to the {@link AImageReader}'s queue using
* releaseFenceFd.</p>
*
* Available since API level 26.
*
* @param image The {@link AImage} to be deleted.
* @param releaseFenceFd A sync fence fd defined in {@link sync.h}, which signals the release of
* underlying {@link AHardwareBuffer}.
*
* @see sync.h
*/
AImage_deleteAsync :: proc(image: ^AImage, releaseFenceFd: i32) ---
/**
* Get the hardware buffer handle of the input image intended for GPU and/or hardware access.
*
* <p>Note that no reference on the returned {@link AHardwareBuffer} handle is acquired
* automatically. Once the {@link AImage} or the parent {@link AImageReader} is deleted, the
* {@link AHardwareBuffer} handle from previous {@link AImage_getHardwareBuffer} becomes
* invalid.</p>
*
* <p>If the caller ever needs to hold on a reference to the {@link AHardwareBuffer} handle after
* the {@link AImage} or the parent {@link AImageReader} is deleted, it must call {@link
* AHardwareBuffer_acquire} to acquire an extra reference, and call {@link AHardwareBuffer_release}
* once it has finished using it in order to properly deallocate the underlying memory managed by
* {@link AHardwareBuffer}. If the caller has acquired extra reference on an {@link AHardwareBuffer}
* returned from this function, it must also register a listener using the function
* {@link AImageReader_setBufferRemovedListener} to be notified when the buffer is no longer used
* by {@link AImageReader}.</p>
*
* Available since API level 26.
*
* @param image the {@link AImage} of interest.
* @param buffer The memory area pointed to by buffer will contain the acquired AHardwareBuffer
* handle.
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if image or buffer is NULL</li></ul>
*
* @see AImageReader_ImageCallback
*/
AImage_getHardwareBuffer :: proc(image: ^AImage, buffer: ^^android.AHardwareBuffer) -> media_status_t ---
}
media/NdkImageReader.odin
+443
View File
@@ -0,0 +1,443 @@
//+build android
package mediandk
import "../"
foreign import mediandk "system:mediandk"
/**
* AImage is an opaque type that allows direct application access to image data rendered into a
* {@link ANativeWindow}.
*/
AImageReader :: struct{}
AImageReader_ImageListener :: struct {
/// Optional application context passed as the first parameter of the callback.
_context: rawptr,
/**
* This callback is called when there is a new image available in the image reader's queue.
*
* <p>The callback happens on one dedicated thread per {@link AImageReader} instance. It is okay
* to use AImageReader_* and AImage_* methods within the callback. Note that it is possible that
* calling {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}
* returns {@link AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE} within this callback. For example, when
* there are multiple images and callbacks queued, if application called
* {@link AImageReader_acquireLatestImage}, some images will be returned to system before their
* corresponding callback is executed.</p>
*/
onImageAvailable: AImageReader_ImageCallback,
}
/**
* A listener to the AHardwareBuffer removal event, use
* {@link AImageReader_setBufferRemovedListener} to register the listener object to AImageReader.
*/
AImageReader_BufferRemovedListener :: struct {
/// Optional application context passed as the first parameter of the callback.
_context: rawptr,
/**
* This callback is called when an old {@link AHardwareBuffer} is about to be removed from the
* image reader.
*
* <p>Note that registering this callback is optional unless the user holds on extra reference
* to {@link AHardwareBuffer} returned from {@link AImage_getHardwareBuffer} by calling {@link
* AHardwareBuffer_acquire} or creating external graphic objects, such as EglImage, from it.</p>
*
* <p>If the callback is registered, the {@link AImageReader} will hold on the last of its
* references to the {@link AHardwareBuffer} until this callback returns. User can use the
* callback to get notified that it becomes the last owner of the buffer. It is up to the user
* to decide to either 1) immediately release all of its references to the buffer or 2) keep
* using the buffer and release it in future. Note that, if option 2 if used, user of this API
* is responsible to deallocate the buffer properly by calling {@link AHardwareBuffer_release}.
* </p>
*
* @see AHardwareBuffer_release
* @see AImage_getHardwareBuffer
*/
onBufferRemoved: AImageReader_BufferRemovedCallback,
}
/**
* Signature of the callback which is called when a new image is available from {@link AImageReader}.
*
* @param context The optional application context provided by user in
* {@link AImageReader_setImageListener}.
* @param session The camera capture session whose state is changing.
*/
AImageReader_ImageCallback :: #type proc "c" (_context: rawptr, reader: ^AImageReader)
/**
* Signature of the callback which is called when {@link AImageReader} is about to remove a buffer.
*
* @param context The optional application context provided by user in
* {@link AImageReader_setBufferRemovedListener}.
* @param reader The {@link AImageReader} of interest.
* @param buffer The {@link AHardwareBuffer} that is being removed from this image reader.
*/
AImageReader_BufferRemovedCallback :: #type proc "c" (_context: rawptr, reader: ^AImageReader, buffer: ^android.AHardwareBuffer)
foreign mediandk {
/**
* Create a new reader for images of the desired size and format.
*
* <p>
* The maxImages parameter determines the maximum number of {@link AImage} objects that can be
* acquired from the {@link AImageReader} simultaneously. Requesting more buffers will use up
* more memory, so it is important to use only the minimum number necessary for the use case.
* </p>
* <p>
* The valid sizes and formats depend on the source of the image data.
* </p>
*
* Available since API level 24.
*
* @param width The default width in pixels of the Images that this reader will produce.
* @param height The default height in pixels of the Images that this reader will produce.
* @param format The format of the Image that this reader will produce. This must be one of the
* AIMAGE_FORMAT_* enum value defined in {@link AIMAGE_FORMATS}. Note that not all
* formats are supported. One example is {@link AIMAGE_FORMAT_PRIVATE}, as it is not
* intended to be read by applications directly. That format is supported by
* {@link AImageReader_newWithUsage} introduced in API 26.
* @param maxImages The maximum number of images the user will want to access simultaneously. This
* should be as small as possible to limit memory use. Once maxImages Images are obtained
* by the user, one of them has to be released before a new {@link AImage} will become
* available for access through {@link AImageReader_acquireLatestImage} or
* {@link AImageReader_acquireNextImage}. Must be greater than 0.
* @param reader The created image reader will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader is NULL, or one or more of width,
* height, format, maxImages arguments is not supported.</li>
* <li>{@link AMEDIA_ERROR_UNKNOWN} if the method fails for some other reasons.</li></ul>
*
* @see AImage
*/
AImageReader_new :: proc(width: i32, height: i32, format: AImageFormats, maxImages: i32, reader: ^^AImageReader) -> media_status_t ---
/**
* Delete an {@link AImageReader} and return all images generated by this reader to system.
*
* <p>This method will return all {@link AImage} objects acquired by this reader (via
* {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}) to system,
* making any of data pointers obtained from {@link AImage_getPlaneData} invalid. Do NOT access
* the reader object or any of those data pointers after this method returns.</p>
*
* Available since API level 24.
*
* @param reader The image reader to be deleted.
*/
AImageReader_delete :: proc(reader: ^AImageReader) ---
/**
* Get a {@link ANativeWindow} that can be used to produce {@link AImage} for this image reader.
*
* Available since API level 24.
*
* @param reader The image reader of interest.
* @param window The output {@link ANativeWindow} will be filled here if the method call succeeds.
* The {@link ANativeWindow} is managed by this image reader. Do NOT call
* {@link ANativeWindow_release} on it. Instead, use {@link AImageReader_delete}.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or window is NULL.</li></ul>
*/
AImageReader_getWindow :: proc(reader: ^AImageReader, window: ^^android.ANativeWindow) -> media_status_t ---
/**
* Query the default width of the {@link AImage} generated by this reader, in pixels.
*
* <p>The width may be overridden by the producer sending buffers to this reader's
* {@link ANativeWindow}. If so, the actual width of the images can be found using
* {@link AImage_getWidth}.</p>
*
* Available since API level 24.
*
* @param reader The image reader of interest.
* @param width the default width of the reader will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or width is NULL.</li></ul>
*/
AImageReader_getWidth :: proc(reader: ^AImageReader, width: ^i32) -> media_status_t ---
/**
* Query the default height of the {@link AImage} generated by this reader, in pixels.
*
* <p>The height may be overridden by the producer sending buffers to this reader's
* {@link ANativeWindow}. If so, the actual height of the images can be found using
* {@link AImage_getHeight}.</p>
*
* Available since API level 24.
*
* @param reader The image reader of interest.
* @param height the default height of the reader will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or height is NULL.</li></ul>
*/
AImageReader_getHeight :: proc(reader: ^AImageReader, height: ^i32) -> media_status_t ---
/**
* Query the format of the {@link AImage} generated by this reader.
*
* Available since API level 24.
*
* @param reader The image reader of interest.
* @param format the fromat of the reader will be filled here if the method call succeeeds. The
* value will be one of the AIMAGE_FORMAT_* enum value defiend in {@link NdkImage.h}.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or format is NULL.</li></ul>
*/
AImageReader_getFormat :: proc(reader: ^AImageReader, format: ^AImageFormats) -> media_status_t ---
/**
* Query the maximum number of concurrently acquired {@link AImage}s of this reader.
*
* Available since API level 24.
*
* @param reader The image reader of interest.
* @param maxImages the maximum number of concurrently acquired images of the reader will be filled
* here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or maxImages is NULL.</li></ul>
*/
AImageReader_getMaxImages :: proc(reader: ^AImageReader, maxImages: ^i32) -> media_status_t ---
/**
* Acquire the next {@link AImage} from the image reader's queue.
*
* <p>Warning: Consider using {@link AImageReader_acquireLatestImage} instead, as it will
* automatically release older images, and allow slower-running processing routines to catch
* up to the newest frame. Usage of {@link AImageReader_acquireNextImage} is recommended for
* batch/background processing. Incorrectly using this method can cause images to appear
* with an ever-increasing delay, followed by a complete stall where no new images seem to appear.
* </p>
*
* <p>
* This method will fail if {@link AImageReader_getMaxImages maxImages} have been acquired with
* {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}. In particular
* a sequence of {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}
* calls greater than {@link AImageReader_getMaxImages maxImages} without calling
* {@link AImage_delete} in-between will exhaust the underlying queue. At such a time,
* {@link AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED} will be returned until more images are released with
* {@link AImage_delete}.
* </p>
*
* Available since API level 24.
*
* @param reader The image reader of interest.
* @param image the acquired {@link AImage} will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or image is NULL.</li>
* <li>{@link AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED} if the number of concurrently acquired
* images has reached the limit.</li>
* <li>{@link AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE} if there is no buffers currently
* available in the reader queue.</li>
* <li>{@link AMEDIA_ERROR_UNKNOWN} if the method fails for some other reasons.</li></ul>
*
* @see AImageReader_acquireLatestImage
*/
AImageReader_acquireNextImage :: proc(reader: ^AImageReader, image: ^^AImage) -> media_status_t ---
/**
* Acquire the latest {@link AImage} from the image reader's queue, dropping older images.
*
* <p>
* This operation will acquire all the images possible from the image reader, but
* {@link AImage_delete} all images that aren't the latest. This function is recommended to use over
* {@link AImageReader_acquireNextImage} for most use-cases, as it's more suited for real-time
* processing.
* </p>
* <p>
* Note that {@link AImageReader_getMaxImages maxImages} should be at least 2 for
* {@link AImageReader_acquireLatestImage} to be any different than
* {@link AImageReader_acquireNextImage} - discarding all-but-the-newest {@link AImage} requires
* temporarily acquiring two {@link AImage}s at once. Or more generally, calling
* {@link AImageReader_acquireLatestImage} with less than two images of margin, that is
* (maxImages - currentAcquiredImages < 2) will not discard as expected.
* </p>
* <p>
* This method will fail if {@link AImageReader_getMaxImages maxImages} have been acquired with
* {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}. In particular
* a sequence of {@link AImageReader_acquireNextImage} or {@link AImageReader_acquireLatestImage}
* calls greater than {@link AImageReader_getMaxImages maxImages} without calling
* {@link AImage_delete} in-between will exhaust the underlying queue. At such a time,
* {@link AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED} will be returned until more images are released with
* {@link AImage_delete}.
* </p>
*
* Available since API level 24.
*
* @param reader The image reader of interest.
* @param image the acquired {@link AImage} will be filled here if the method call succeeeds.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader or image is NULL.</li>
* <li>{@link AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED} if the number of concurrently acquired
* images has reached the limit.</li>
* <li>{@link AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE} if there is no buffers currently
* available in the reader queue.</li>
* <li>{@link AMEDIA_ERROR_UNKNOWN} if the method fails for some other reasons.</li></ul>
*
* @see AImageReader_acquireNextImage
*/
AImageReader_acquireLatestImage :: proc(reader: ^AImageReader, image: ^^AImage) -> media_status_t ---
/**
* Set the onImageAvailable listener of this image reader.
*
* Calling this method will replace previously registered listeners.
*
* Available since API level 24.
*
* @param reader The image reader of interest.
* @param listener The {@link AImageReader_ImageListener} to be registered. Set this to NULL if
* the application no longer needs to listen to new images.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader is NULL.</li></ul>
*/
AImageReader_setImageListener :: proc(reader: ^AImageReader, listener: ^AImageReader_ImageListener) -> media_status_t ---
/**
* AImageReader constructor similar to {@link AImageReader_new} that takes an additional parameter
* for the consumer usage. All other parameters and the return values are identical to those passed
* to {@link AImageReader_new}.
*
* <p>If the \c format is {@link AIMAGE_FORMAT_PRIVATE}, the created {@link AImageReader}
* will produce images whose contents are not directly accessible by the application. The application can
* still acquire images from this {@link AImageReader} and access {@link AHardwareBuffer} via
* {@link AImage_getHardwareBuffer()}. The {@link AHardwareBuffer} gained this way can then
* be passed back to hardware (such as GPU or hardware encoder if supported) for future processing.
* For example, you can obtain an EGLClientBuffer from the {@link AHardwareBuffer} by using
* eglGetNativeClientBufferANDROID extension and pass that EGLClientBuffer to
* eglCreateImageKHR to create an EGLImage resource type, which may then be bound to a
* texture via glEGLImageTargetTexture2DOES on supported devices. This can be useful for
* transporting textures that may be shared cross-process.</p>
* <p>In general, when software access to image data is not necessary, an {@link AImageReader}
* created with {@link AIMAGE_FORMAT_PRIVATE} format is more efficient, compared with {@link
* AImageReader}s using other format such as {@link AIMAGE_FORMAT_YUV_420_888}.</p>
*
* <p>Note that not all format and usage flag combination is supported by the {@link AImageReader},
* especially if \c format is {@link AIMAGE_FORMAT_PRIVATE}, \c usage must not include either
* {@link AHARDWAREBUFFER_USAGE_CPU_READ_RARELY} or {@link AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN}</p>
*
* @param width The default width in pixels of the Images that this reader will produce.
* @param height The default height in pixels of the Images that this reader will produce.
* @param format The format of the Image that this reader will produce. This must be one of the
* AIMAGE_FORMAT_* enum value defined in {@link AIMAGE_FORMATS}.
* @param usage specifies how the consumer will access the AImage, using combination of the
* AHARDWAREBUFFER_USAGE flags described in {@link hardware_buffer.h}.
* Passing {@link AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN} is equivalent to calling
* {@link AImageReader_new} with the same parameters.
*
* Note that not all format and usage flag combination is supported by the {@link AImageReader}.
* Below are the combinations supported by the {@link AImageReader}.
* <table>
* <tr>
* <th>Format</th>
* <th>Compatible usage flags</th>
* </tr>
* <tr>
* <td>non-{@link AIMAGE_FORMAT_PRIVATE} formats defined in {@link NdkImage.h}
* </td>
* <td>{@link AHARDWAREBUFFER_USAGE_CPU_READ_RARELY} or
* {@link AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN}</td>
* </tr>
* <tr>
* <td>{@link AIMAGE_FORMAT_RGBA_8888}</td>
* <td>{@link AHARDWAREBUFFER_USAGE_VIDEO_ENCODE} or
* {@link AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE}, or combined</td>
* </tr>
* </table>
*
* Available since API level 26.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader is NULL, or one or more of width,
* height, format, maxImages, or usage arguments is not supported.</li>
* <li>{@link AMEDIA_ERROR_UNKNOWN} if the method fails for some other reasons.</li></ul>
*
* @see AImage
* @see AImageReader_new
* @see AHardwareBuffer
*/
AImageReader_newWithUsage :: proc(width: i32, height: i32, format: AImageFormats, usage: u64, maxImages: i32, reader: ^^AImageReader) -> media_status_t ---
/**
* Acquire the next {@link AImage} from the image reader's queue asynchronously.
*
* <p>AImageReader acquire method similar to {@link AImageReader_acquireNextImage} that takes an
* additional parameter for the sync fence. All other parameters and the return values are
* identical to those passed to {@link AImageReader_acquireNextImage}.</p>
*
* Available since API level 26.
*
* @param acquireFenceFd A sync fence fd defined in {@link sync.h}, which is used to signal when the
* buffer is ready to consume. When synchronization fence is not needed, fence will be set
* to -1 and the {@link AImage} returned is ready for use immediately. Otherwise, user shall
* use syscalls such as \c poll(), \c epoll(), \c select() to wait for the
* fence fd to change status before attempting to access the {@link AImage} returned.
*
* @see sync.h
* @see sync_get_fence_info
*/
AImageReader_acquireNextImageAsync :: proc(reader: ^AImageReader, image: ^^AImage, acquireFenceFd: ^i32) -> media_status_t ---
/**
* Acquire the latest {@link AImage} from the image reader's queue asynchronously, dropping older
* images.
*
* <p>AImageReader acquire method similar to {@link AImageReader_acquireLatestImage} that takes an
* additional parameter for the sync fence. All other parameters and the return values are
* identical to those passed to {@link AImageReader_acquireLatestImage}.</p>
*
* Available since API level 26.
*
* @param acquireFenceFd A sync fence fd defined in {@link sync.h}, which is used to signal when the
* buffer is ready to consume. When synchronization fence is not needed, fence will be set
* to -1 and the {@link AImage} returned is ready for use immediately. Otherwise, user shall
* use syscalls such as \c poll(), \c epoll(), \c select() to wait for the
* fence fd to change status before attempting to access the {@link AImage} returned.
*
* @see sync.h
* @see sync_get_fence_info
*/
AImageReader_acquireLatestImageAsync :: proc(reader: ^AImageReader, image: ^^AImage, acquireFenceFd: ^i32) -> media_status_t ---
/**
* Set the onBufferRemoved listener of this image reader.
*
* <p>Note that calling this method will replace previously registered listeners.</p>
*
* Available since API level 26.
*
* @param reader The image reader of interest.
* @param listener the {@link AImageReader_BufferRemovedListener} to be registered. Set this to
* NULL if application no longer needs to listen to buffer removed events.
*
* @return <ul>
* <li>{@link AMEDIA_OK} if the method call succeeds.</li>
* <li>{@link AMEDIA_ERROR_INVALID_PARAMETER} if reader is NULL.</li></ul>
*
* @see AImage_getHardwareBuffer
*/
AImageReader_setBufferRemovedListener :: proc(reader: ^AImageReader, listener: ^AImageReader_BufferRemovedListener) -> media_status_t ---
}
media/NdkMediaCodec.odin
+560
View File
@@ -0,0 +1,560 @@
//+build android
package mediandk
import android "../"
foreign import mediandk "system:android"
AMEDIACODEC_KEY_HDR10_PLUS_INFO: cstring // __INTRODUCED_IN(31);
AMEDIACODEC_KEY_LOW_LATENCY: cstring // __INTRODUCED_IN(31);
AMEDIACODEC_KEY_OFFSET_TIME: cstring // __INTRODUCED_IN(31);
AMEDIACODEC_KEY_REQUEST_SYNC_FRAME: cstring // __INTRODUCED_IN(31);
AMEDIACODEC_KEY_SUSPEND: cstring // __INTRODUCED_IN(31);
AMEDIACODEC_KEY_SUSPEND_TIME: cstring // __INTRODUCED_IN(31);
AMEDIACODEC_KEY_VIDEO_BITRATE: cstring // __INTRODUCED_IN(31);
AMEDIACODEC_BUFFER_FLAG_CODEC_CONFIG :: 2
AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM :: 4
AMEDIACODEC_BUFFER_FLAG_PARTIAL_FRAME :: 8
AMEDIACODEC_CONFIGURE_FLAG_ENCODE :: 1
AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED :: -3
AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED :: -2
AMEDIACODEC_INFO_TRY_AGAIN_LATER :: -1
_off_t_compat :: i64
cryptoinfo_mode_t :: enum {
CLEAR = 0,
AES_CTR = 1,
AES_WV = 2,
AES_CBC = 3
}
AMediaCodec :: struct{}
AMediaCodecBufferInfo :: struct {
offset: i32,
size: i32,
presentationTimeUs: i64,
flags: u32,
}
AMediaCodecCryptoInfo :: struct{}
AMediaCodecOnAsyncNotifyCallback :: struct {
onAsyncInputAvailable: AMediaCodecOnAsyncInputAvailable,
onAsyncOutputAvailable: AMediaCodecOnAsyncOutputAvailable,
onAsyncFormatChanged: AMediaCodecOnAsyncFormatChanged,
onAsyncError: AMediaCodecOnAsyncError,
}
cryptoinfo_pattern_t :: struct {
encryptBlocks: i32,
skipBlocks: i32,
}
/**
* Called when an input buffer becomes available.
* The specified index is the index of the available input buffer.
*/
AMediaCodecOnAsyncInputAvailable :: #type proc "c" (codec: ^AMediaCodec, userdata: rawptr, index: i32)
/**
* Called when an output buffer becomes available.
* The specified index is the index of the available output buffer.
* The specified bufferInfo contains information regarding the available output buffer.
*/
AMediaCodecOnAsyncOutputAvailable :: #type proc "c" (codec: ^AMediaCodec, userdata: rawptr, index: i32, bufferInfo: ^AMediaCodecBufferInfo)
/**
* Called when the output format has changed.
* The specified format contains the new output format.
*/
AMediaCodecOnAsyncFormatChanged :: #type proc "c" (codec: ^AMediaCodec, userdata: rawptr, format: ^AMediaFormat)
/**
* Called when the MediaCodec encountered an error.
* The specified actionCode indicates the possible actions that client can take,
* and it can be checked by calling AMediaCodecActionCode_isRecoverable or
* AMediaCodecActionCode_isTransient. If both AMediaCodecActionCode_isRecoverable()
* and AMediaCodecActionCode_isTransient() return false, then the codec error is fatal
* and the codec must be deleted.
* The specified detail may contain more detailed messages about this error.
*/
AMediaCodecOnAsyncError :: #type proc "c" (
codec: ^AMediaCodec,
userdata: rawptr,
error: media_status_t,
actionCode: i32,
detail: cstring
)
/**
* Called when an output frame has rendered on the output surface.
*
* \param codec The codec object that generated this notification.
* \param userdata The user data set at AMediaCodec_setOnFrameRenderedCallback.
* \param mediaTimeUs The presentation time (media time) of the frame rendered.
* This is usually the same as specified in
* AMediaCodec_queueInputBuffer, but some codecs may alter
* the media time by applying some time-based transformation,
* such as frame rate conversion. In that case, presentation
* time corresponds to the actual output frame rendered.
* \param systemNano The system time when the frame was rendered.
*/
AMediaCodecOnFrameRendered :: #type proc "c" (
codec: ^AMediaCodec,
userdata: rawptr,
mediaTimeUs: i64,
systemNano: i64,
)
foreign mediandk {
/**
* Create codec by name. Use this if you know the exact codec you want to use.
* When configuring, you will need to specify whether to use the codec as an
* encoder or decoder.
*
* Available since API level 21.
*/
AMediaCodec_createCodecByName :: proc(name: cstring) -> ^AMediaCodec ---
/**
* Create codec by mime type. Most applications will use this, specifying a
* mime type obtained from media extractor.
*
* Available since API level 21.
*/
AMediaCodec_createDecoderByType :: proc(mime_type: cstring) -> ^AMediaCodec ---
/**
* Create encoder by name.
*
* Available since API level 21.
*/
AMediaCodec_createEncoderByType :: proc(mime_type: cstring) -> ^AMediaCodec ---
/**
* Delete the codec and free its resources.
*
* Available since API level 21.
*/
AMediaCodec_delete :: proc(codec: ^AMediaCodec) -> media_status_t ---
/**
* Configure the codec. For decoding you would typically get the format from an extractor.
*
* Available since API level 21.
*/
AMediaCodec_configure :: proc(coded: ^AMediaCodec, format: ^AMediaFormat, surface: ^android.ANativeWindow, crypto: ^AMediaCrypto, flags: u32) -> media_status_t ---
/**
* Start the codec. A codec must be configured before it can be started, and must be started
* before buffers can be sent to it.
*
* Available since API level 21.
*/
AMediaCodec_start :: proc(codec: ^AMediaCodec) -> media_status_t ---
/**
* Stop the codec.
*
* Available since API level 21.
*/
AMediaCodec_stop :: proc(codec: ^AMediaCodec) -> media_status_t ---
/*
* Flush the codec's input and output. All indices previously returned from calls to
* AMediaCodec_dequeueInputBuffer and AMediaCodec_dequeueOutputBuffer become invalid.
*
* Available since API level 21.
*/
AMediaCodec_flush :: proc(codec: ^AMediaCodec) -> media_status_t ---
/**
* Get an input buffer. The specified buffer index must have been previously obtained from
* dequeueInputBuffer, and not yet queued.
*
* Available since API level 21.
*/
AMediaCodec_getInputBuffer :: proc(codec: ^AMediaCodec, idx: uint, out_size: ^uint) -> [^]byte ---
/**
* Get an output buffer. The specified buffer index must have been previously obtained from
* dequeueOutputBuffer, and not yet queued.
*
* Available since API level 21.
*/
AMediaCodec_getOutputBuffer :: proc(codec: ^AMediaCodec, idx: uint, out_size: ^uint) -> [^]byte ---
/**
* Get the index of the next available input buffer. An app will typically use this with
* getInputBuffer() to get a pointer to the buffer, then copy the data to be encoded or decoded
* into the buffer before passing it to the codec.
*
* Available since API level 21.
*/
AMediaCodec_dequeueInputBuffer :: proc(codec: ^AMediaCodec, timeoutUs: i64) -> int ---
/**
* Send the specified buffer to the codec for processing.
*
* Available since API level 21.
*/
AMediaCodec_queueInputBuffer :: proc(
codec: ^AMediaCodec,
idx: uint,
offset: _off_t_compat,
size: uint,
time: u64,
flags: u32) -> media_status_t ---
/**
* Send the specified buffer to the codec for processing.
*
* Available since API level 21.
*/
AMediaCodec_queueSecureInputBuffer :: proc(
codec: ^AMediaCodec,
idx: uint,
offset: _off_t_compat,
crypto_info: ^AMediaCodecCryptoInfo,
time: u64,
flags: u32) -> media_status_t ---
/**
* Get the index of the next available buffer of processed data.
*
* Available since API level 21.
*/
AMediaCodec_dequeueOutputBuffer :: proc(codec: ^AMediaCodec, info: ^AMediaCodecBufferInfo, timeoutUs: i64) -> int ---
/**
* Returns the format of the codec's output.
* The caller must free the returned format.
*
* Available since API level 21.
*/
AMediaCodec_getOutputFormat :: proc(codec: ^AMediaCodec) -> ^AMediaFormat ---
/**
* If you are done with a buffer, use this call to return the buffer to
* the codec. If you previously specified a surface when configuring this
* video decoder you can optionally render the buffer.
*
* Available since API level 21.
*/
AMediaCodec_releaseOutputBuffer :: proc(codec: ^AMediaCodec, idx: uint, render: bool) -> media_status_t ---
/**
* Dynamically sets the output surface of a codec.
*
* This can only be used if the codec was configured with an output surface. The
* new output surface should have a compatible usage type to the original output surface.
* E.g. codecs may not support switching from a SurfaceTexture (GPU readable) output
* to ImageReader (software readable) output.
*
* For more details, see the Java documentation for MediaCodec.setOutputSurface.
*
* Available since API level 21.
*/
AMediaCodec_setOutputSurface :: proc(codec: ^AMediaCodec, surface: ^android.ANativeWindow) -> media_status_t ---
/**
* If you are done with a buffer, use this call to update its surface timestamp
* and return it to the codec to render it on the output surface. If you
* have not specified an output surface when configuring this video codec,
* this call will simply return the buffer to the codec.
*
* For more details, see the Java documentation for MediaCodec.releaseOutputBuffer.
*
* Available since API level 21.
*/
AMediaCodec_releaseOutputBufferAtTime :: proc(mData: ^AMediaCodec, idx: uint, timestampNs: i64) -> media_status_t ---
/**
* Creates a Surface that can be used as the input to encoder, in place of input buffers
*
* This can only be called after the codec has been configured via
* AMediaCodec_configure(..) and before AMediaCodec_start() has been called.
*
* The application is responsible for releasing the surface by calling
* ANativeWindow_release() when done.
*
* For more details, see the Java documentation for MediaCodec.createInputSurface.
*
* Available since API level 26.
*/
AMediaCodec_createInputSurface :: proc(mData: ^AMediaCodec, surface: ^^android.ANativeWindow) -> media_status_t ---
/**
* Creates a persistent Surface that can be used as the input to encoder
*
* Persistent surface can be reused by MediaCodec instances and can be set
* on a new instance via AMediaCodec_setInputSurface().
* A persistent surface can be connected to at most one instance of MediaCodec
* at any point in time.
*
* The application is responsible for releasing the surface by calling
* ANativeWindow_release() when done.
*
* For more details, see the Java documentation for MediaCodec.createPersistentInputSurface.
*
* Available since API level 26.
*/
AMediaCodec_createPersistentInputSurface :: proc(surface: ^^android.ANativeWindow) -> media_status_t ---
/**
* Set a persistent-surface that can be used as the input to encoder, in place of input buffers
*
* The surface provided *must* be a persistent surface created via
* AMediaCodec_createPersistentInputSurface()
* This can only be called after the codec has been configured by calling
* AMediaCodec_configure(..) and before AMediaCodec_start() has been called.
*
* For more details, see the Java documentation for MediaCodec.setInputSurface.
*
* Available since API level 26.
*/
AMediaCodec_setInputSurface :: proc(mData: ^AMediaCodec, surface: ^android.ANativeWindow) -> media_status_t ---
/**
* Signal additional parameters to the codec instance.
*
* Parameters can be communicated only when the codec is running, i.e
* after AMediaCodec_start() has been called.
*
* NOTE: Some of these parameter changes may silently fail to apply.
*
* Available since API level 26.
*/
AMediaCodec_setParameters :: proc(mData: ^AMediaCodec, params: ^AMediaFormat) -> media_status_t ---
/**
* Signals end-of-stream on input. Equivalent to submitting an empty buffer with
* AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM set.
*
* Returns AMEDIA_ERROR_INVALID_OPERATION when used with an encoder not in executing state
* or not receiving input from a Surface created by AMediaCodec_createInputSurface or
* AMediaCodec_createPersistentInputSurface.
*
* Returns the previous codec error if one exists.
*
* Returns AMEDIA_OK when completed succesfully.
*
* For more details, see the Java documentation for MediaCodec.signalEndOfInputStream.
*
* Available since API level 26.
*/
AMediaCodec_signalEndOfInputStream :: proc(mData: ^AMediaCodec) -> media_status_t ---
/**
* Get format of the buffer. The specified buffer index must have been previously obtained from
* dequeueOutputBuffer.
* The caller must free the returned format.
*
* Available since API level 28.
*/
AMediaCodec_getBufferFormat :: proc(codec: ^AMediaCodec, index: uint) -> ^AMediaFormat ---
/**
* Get the component name. If the codec was created by createDecoderByType
* or createEncoderByType, what component is chosen is not known beforehand.
* Caller shall call AMediaCodec_releaseName to free the returned pointer.
*
* Available since API level 28.
*/
AMediaCodec_getName :: proc(codec: ^AMediaCodec, out_name: ^cstring) -> media_status_t ---
/**
* Free the memory pointed by name which is returned by AMediaCodec_getName.
*
* Available since API level 28.
*/
AMediaCodec_releaseName :: proc(codec: ^AMediaCodec, name: cstring) ---
/**
* Set an asynchronous callback for actionable AMediaCodec events.
* When asynchronous callback is enabled, it is an error for the client to call
* AMediaCodec_getInputBuffers(), AMediaCodec_getOutputBuffers(),
* AMediaCodec_dequeueInputBuffer() or AMediaCodec_dequeueOutputBuffer().
*
* AMediaCodec_flush() behaves differently in asynchronous mode.
* After calling AMediaCodec_flush(), the client must call AMediaCodec_start() to
* "resume" receiving input buffers. Even if the client does not receive
* AMediaCodecOnAsyncInputAvailable callbacks from video encoders configured
* with an input surface, the client still needs to call AMediaCodec_start()
* to resume the input surface to send buffers to the encoders.
*
* When called with null callback, this method unregisters any previously set callback.
*
* Refer to the definition of AMediaCodecOnAsyncNotifyCallback on how each
* callback function is called and what are specified.
* The specified userdata is opaque data which will be passed along
* when the callback functions are called. MediaCodec does not look at or alter the
* value of userdata. Often it is a pointer to a client-owned object,
* and client manages the lifecycle of the object in that case.
*
* Once the callback is unregistered or the codec is reset / released, the
* previously registered callback will not be called.
*
* All callbacks are fired on one NDK internal thread.
* AMediaCodec_setAsyncNotifyCallback should not be called on the callback thread.
* No heavy duty task should be performed on callback thread.
*
* Available since API level 28.
*/
AMediaCodec_setAsyncNotifyCallback :: proc(
codec: ^AMediaCodec,
callback: AMediaCodecOnAsyncNotifyCallback,
userdata: rawptr) -> media_status_t ---
/**
* Registers a callback to be invoked when an output frame is rendered on the output surface.
*
* This method can be called in any codec state, but will only have an effect in the
* Executing state for codecs that render buffers to the output surface.
*
* This callback is for informational purposes only: to get precise
* render timing samples, and can be significantly delayed and batched. Some frames may have
* been rendered even if there was no callback generated.
*
* When called with null callback, this method unregisters any previously set callback.
*
* Refer to the definition of AMediaCodecOnFrameRendered on how each
* callback function is called and what are specified.
* The specified userdata is opaque data which will be passed along
* when the callback functions are called. MediaCodec does not look at or alter the
* value of userdata. Often it is a pointer to a client-owned object,
* and client manages the lifecycle of the object in that case.
*
* Once the callback is unregistered or the codec is reset / released, the
* previously registered callback will not be called.
*
* All callbacks are fired on one NDK internal thread.
* AMediaCodec_setOnFrameRenderedCallback should not be called on the callback thread.
* No heavy duty task should be performed on callback thread.
*
* Available since Android T.
*/
AMediaCodec_setOnFrameRenderedCallback :: proc(
codec: ^AMediaCodec,
callback: AMediaCodecOnFrameRendered,
userdata: rawptr) -> media_status_t ---
/**
* Release the crypto if applicable.
*
* Available since API level 28.
*/
AMediaCodec_releaseCrypto :: proc(codec: ^AMediaCodec) -> media_status_t ---
/**
* Call this after AMediaCodec_configure() returns successfully to get the input
* format accepted by the codec. Do this to determine what optional configuration
* parameters were supported by the codec.
* The caller must free the returned format.
*
* Available since API level 28.
*/
AMediaCodec_getInputFormat :: proc(codec: ^AMediaCodec) -> ^AMediaFormat ---
/**
* Returns true if the codec cannot proceed further, but can be recovered by stopping,
* configuring, and starting again.
*
* Available since API level 28.
*/
AMediaCodecActionCode_isRecoverable :: proc(actionCode: i32) -> bool ---
/**
* Returns true if the codec error is a transient issue, perhaps due to
* resource constraints, and that the method (or encoding/decoding) may be
* retried at a later time.
*
* Available since API level 28.
*/
AMediaCodecActionCode_isTransient :: proc(actionCode: i32) -> bool ---
/**
* Create an AMediaCodecCryptoInfo from scratch. Use this if you need to use custom
* crypto info, rather than one obtained from AMediaExtractor.
*
* AMediaCodecCryptoInfo describes the structure of an (at least
* partially) encrypted input sample.
* A buffer's data is considered to be partitioned into "subsamples",
* each subsample starts with a (potentially empty) run of plain,
* unencrypted bytes followed by a (also potentially empty) run of
* encrypted bytes.
* numBytesOfClearData can be null to indicate that all data is encrypted.
* This information encapsulates per-sample metadata as outlined in
* ISO/IEC FDIS 23001-7:2011 "Common encryption in ISO base media file format files".
*
* Available since API level 21.
*/
AMediaCodecCryptoInfo_new :: proc(
numsubsamples: i32,
key: [16]byte,
iv: [16]byte,
mode: cryptoinfo_mode_t,
clearbytes: ^uint,
encryptedbytes: ^uint) -> ^AMediaCodecCryptoInfo ---
/**
* Delete an AMediaCodecCryptoInfo created previously with AMediaCodecCryptoInfo_new, or
* obtained from AMediaExtractor.
*
* Available since API level 21.
*/
AMediaCodecCryptoInfo_delete :: proc(info: ^AMediaCodecCryptoInfo) -> media_status_t ---
/**
* Set the crypto pattern on an AMediaCryptoInfo object.
*
* Available since API level 21.
*/
AMediaCodecCryptoInfo_setPattern :: proc(info: ^AMediaCodecCryptoInfo, pattern: ^cryptoinfo_pattern_t) ---
/**
* The number of subsamples that make up the buffer's contents.
*
* Available since API level 21.
*/
AMediaCodecCryptoInfo_getNumSubSamples :: proc(info: ^AMediaCodecCryptoInfo) -> uint ---
/**
* A 16-byte opaque key.
*
* Available since API level 21.
*/
AMediaCodecCryptoInfo_getKey :: proc(info: ^AMediaCodecCryptoInfo, dst: [^]byte) -> media_status_t ---
/**
* A 16-byte initialization vector.
*
* Available since API level 21.
*/
AMediaCodecCryptoInfo_getIV :: proc(info: ^AMediaCodecCryptoInfo, dst: [^]byte) -> media_status_t ---
/**
* The type of encryption that has been applied,
* one of AMEDIACODECRYPTOINFO_MODE_CLEAR or AMEDIACODECRYPTOINFO_MODE_AES_CTR.
*
* Available since API level 21.
*/
AMediaCodecCryptoInfo_getMode :: proc(info: ^AMediaCodecCryptoInfo) -> cryptoinfo_mode_t ---
/**
* The number of leading unencrypted bytes in each subsample.
*
* Available since API level 21.
*/
AMediaCodecCryptoInfo_getClearBytes :: proc(info: ^AMediaCodecCryptoInfo, dst: ^uint) -> media_status_t ---
/**
* The number of trailing encrypted bytes in each subsample.
*
* Available since API level 21.
*/
AMediaCodecCryptoInfo_getEncryptedBytes :: proc(info: ^AMediaCodecCryptoInfo, dst: ^uint) -> media_status_t ---
}
media/NdkMediaCrypto.odin
+29
View File
@@ -0,0 +1,29 @@
//+build android
package mediandk
foreign import mediandk "system:mediandk"
AMediaCrypto :: struct{}
AMediaUUID :: [16]u8
foreign mediandk {
/**
* Available since API level 21.
*/
AMediaCrypto_isCryptoSchemeSupported :: proc(uuid: AMediaUUID) -> bool ---
/**
* Available since API level 21.
*/
AMediaCrypto_requiresSecureDecoderComponent :: proc(mime: cstring) -> bool ---
/**
* Available since API level 21.
*/
AMediaCrypto_new :: proc(uuid: AMediaUUID, initData: rawptr, initDataSize: uint) -> ^AMediaCrypto ---
/**
* Available since API level 21.
*/
AMediaCrypto_delete :: proc(crypto: ^AMediaCrypto) ---
}
media/NdkMediaDataSource.odin
+164
View File
@@ -0,0 +1,164 @@
//+build android
package mediandk
import "../"
foreign import mediandk "system:mediandk"
AMediaDataSource :: struct{}
/*
* AMediaDataSource's callbacks will be invoked on an implementation-defined thread
* or thread pool. No guarantees are provided about which thread(s) will be used for
* callbacks. For example, |close| can be invoked from a different thread than the
* thread invoking |readAt|. As such, the Implementations of AMediaDataSource callbacks
* must be threadsafe.
*/
/**
* Called to request data from the given |offset|.
*
* Implementations should should write up to |size| bytes into
* |buffer|, and return the number of bytes written.
*
* Return 0 if size is zero (thus no bytes are read).
*
* Return -1 to indicate that end of stream is reached.
*/
AMediaDataSourceReadAt :: #type proc "c" (userdata: rawptr, offset: android.off64_t, buffer: rawptr, size: uint) -> int
/**
* Called to get the size of the data source.
*
* Return the size of data source in bytes, or -1 if the size is unknown.
*/
AMediaDataSourceGetSize :: #type proc "c" (userdata: rawptr) -> int
/**
* Called to close the data source, unblock reads, and release associated
* resources.
*
* The NDK media framework guarantees that after the first |close| is
* called, no future callbacks will be invoked on the data source except
* for |close| itself.
*
* Closing a data source allows readAt calls that were blocked waiting
* for I/O data to return promptly.
*
* When using AMediaDataSource as input to AMediaExtractor, closing
* has the effect of unblocking slow reads inside of setDataSource
* and readSampleData.
*/
AMediaDataSourceClose :: #type proc "c" (userdata: rawptr)
/**
* Called to get an estimate of the number of bytes that can be read from this data source
* starting at |offset| without blocking for I/O.
*
* Return -1 when such an estimate is not possible.
*/
AMediaDataSourceGetAvailableSize :: #type proc "c" (userdata: rawptr, offset: android.off64_t) -> int
foreign mediandk {
/**
* Create new media data source. Returns NULL if memory allocation
* for the new data source object fails.
*
* Available since API level 28.
*/
AMediaDataSource_new :: proc() -> ^AMediaDataSource ---
/**
* Create new media data source. Returns NULL if memory allocation
* for the new data source object fails.
*
* Set the |uri| from which the data source will read,
* plus additional http headers when initiating the request.
*
* Headers will contain corresponding items from |key_values|
* in the following fashion:
*
* key_values[0]:key_values[1]
* key_values[2]:key_values[3]
* ...
* key_values[(numheaders - 1) * 2]:key_values[(numheaders - 1) * 2 + 1]
*
* Available since API level 29.
*/
AMediaDataSource_newUri :: proc(uri: cstring, numheaders: i32, key_values: ^[^]u8) -> ^AMediaDataSource ---
/**
* Delete a previously created media data source.
*
* Available since API level 28.
*/
AMediaDataSource_delete :: proc(ds: ^AMediaDataSource) ---
/**
* Set an user provided opaque handle. This opaque handle is passed as
* the first argument to the data source callbacks.
*
* Available since API level 28.
*/
AMediaDataSource_setUserdata :: proc(ds: ^AMediaDataSource, userdata: rawptr) ---
/**
* Set a custom callback for supplying random access media data to the
* NDK media framework.
*
* Implement this if your app has special requirements for the way media
* data is obtained, or if you need a callback when data is read by the
* NDK media framework.
*
* Please refer to the definition of AMediaDataSourceReadAt for
* additional details.
*
* Available since API level 28.
*/
AMediaDataSource_setReadAt :: proc(ds: ^AMediaDataSource, cb: AMediaDataSourceReadAt) ---
/**
* Set a custom callback for supplying the size of the data source to the
* NDK media framework.
*
* Please refer to the definition of AMediaDataSourceGetSize for
* additional details.
*
* Available since API level 28.
*/
AMediaDataSource_setGetSize :: proc(ds: ^AMediaDataSource, cb: AMediaDataSourceGetSize) ---
/**
* Set a custom callback to receive signal from the NDK media framework
* when the data source is closed.
*
* Please refer to the definition of AMediaDataSourceClose for
* additional details.
*
* Available since API level 28.
*/
AMediaDataSource_setClose :: proc(ds: ^AMediaDataSource, cb: AMediaDataSourceClose) ---
/**
* Close the data source, unblock reads, and release associated resources.
*
* Please refer to the definition of AMediaDataSourceClose for
* additional details.
*
* Available since API level 29.
*/
AMediaDataSource_close :: proc(ds: ^AMediaDataSource) ---
/**
* Set a custom callback for supplying the estimated number of bytes
* that can be read from this data source starting at an offset without
* blocking for I/O.
*
* Please refer to the definition of AMediaDataSourceGetAvailableSize
* for additional details.
*
* Available since API level 29.
*/
AMediaDataSource_setGetAvailableSize :: proc(ds: ^AMediaDataSource, cb: AMediaDataSourceGetAvailableSize) ---
}
media/NdkMediaDrm.odin
+658
View File
@@ -0,0 +1,658 @@
//+build android
package mediandk
foreign import mediandk "system:mediandk"
/**
* String property name: identifies the maker of the DRM engine plugin
*/
PROPERTY_VENDOR :: "vendor"
/**
* String property name: identifies the version of the DRM engine plugin
*/
PROPERTY_VERSION :: "version"
/**
* String property name: describes the DRM engine plugin
*/
PROPERTY_DESCRIPTION :: "description"
/**
* String property name: a comma-separated list of cipher and mac algorithms
* supported by CryptoSession. The list may be empty if the DRM engine
* plugin does not support CryptoSession operations.
*/
PROPERTY_ALGORITHMS :: "algorithms"
/**
* Byte array property name: the device unique identifier is established during
* device provisioning and provides a means of uniquely identifying each device.
*/
PROPERTY_DEVICE_UNIQUE_ID :: "deviceUniqueId"
AMediaDrm :: struct{}
AMediaDrmByteArray :: struct {
ptr: [^]byte,
length: uint,
}
AMediaDrmSessionId :: AMediaDrmByteArray
AMediaDrmScope :: AMediaDrmByteArray
AMediaDrmKeySetId :: AMediaDrmByteArray
AMediaDrmSecureStop :: AMediaDrmByteArray
AMediaDrmKeyId :: AMediaDrmByteArray
AMediaDrmEventType :: enum {
/**
* This event type indicates that the app needs to request a certificate from
* the provisioning server. The request message data is obtained using
* AMediaDrm_getProvisionRequest.
*/
PROVISION_REQUIRED = 1,
/**
* This event type indicates that the app needs to request keys from a license
* server. The request message data is obtained using AMediaDrm_getKeyRequest.
*/
KEY_REQUIRED = 2,
/**
* This event type indicates that the licensed usage duration for keys in a session
* has expired. The keys are no longer valid.
*/
KEY_EXPIRED = 3,
/**
* This event may indicate some specific vendor-defined condition, see your
* DRM provider documentation for details
*/
VENDOR_DEFINED = 4,
/**
* This event indicates that a session opened by the app has been reclaimed
* by the resource manager.
*/
SESSION_RECLAIMED = 5,
}
AMediaDrmKeyType :: enum {
/**
* This key request type specifies that the keys will be for online use, they will
* not be saved to the device for subsequent use when the device is not connected
* to a network.
*/
STREAMING = 1,
/**
* This key request type specifies that the keys will be for offline use, they
* will be saved to the device for use when the device is not connected to a network.
*/
OFFLINE = 2,
/**
* This key request type specifies that previously saved offline keys should be released.
*/
RELEASE = 3
}
/**
* Introduced in API 33.
*/
AMediaDrmKeyRequestType :: enum i32 {
/**
* Key request type is initial license request.
* An initial license request is necessary to load keys.
*/
INITIAL,
/**
* Key request type is license renewal.
* A renewal license request is necessary to prevent the keys from expiring.
*/
RENEWAL,
/**
* Key request type is license release.
* A license release request indicates that keys are removed.
*/
RELEASE,
/**
* Keys are already loaded and are available for use. No license request is necessary, and
* no key request data is returned.
*/
NONE,
/**
* Keys have been loaded but an additional license request is needed
* to update their values.
*/
UPDATE
}
/**
* Data type containing {key, value} pair
*/
AMediaDrmKeyValue :: struct {
mKey: cstring,
mValue: cstring,
}
AMediaDrmKeyStatusType :: enum {
/**
* The key is currently usable to decrypt media data.
*/
USABLE,
/**
* The key is no longer usable to decrypt media data because its expiration
* time has passed.
*/
EXPIRED,
/**
* The key is not currently usable to decrypt media data because its output
* requirements cannot currently be met.
*/
OUTPUTNOTALLOWED,
/**
* The status of the key is not yet known and is being determined.
*/
STATUSPENDING,
/**
* The key is not currently usable to decrypt media data because of an
* internal error in processing unrelated to input parameters.
*/
INTERNALERROR,
}
AMediaDrmKeyStatus :: struct {
keyId: AMediaDrmKeyId,
keyType: AMediaDrmKeyStatusType,
}
AMediaDrmEventListener :: #type proc "c" (drm: ^AMediaDrm, sessionId: ^AMediaDrmSessionId, eventType: AMediaDrmEventType, extra: i32, data: [^]byte, dataSize: uint)
AMediaDrmExpirationUpdateListener :: #type proc "c" (drm: ^AMediaDrm, sessionId: ^AMediaDrmSessionId, expiryTimeInMS: i64)
AMediaDrmKeysChangeListener :: #type proc "c" (drm: ^AMediaDrm, sessionId: ^AMediaDrmSessionId, keyStatus: ^AMediaDrmKeyStatus, numKeys: uint, hasNewUsableKey: bool)
foreign mediandk {
/**
* Query if the given scheme identified by its UUID is supported on this device, and
* whether the drm plugin is able to handle the media container format specified by mimeType.
*
* uuid identifies the universal unique ID of the crypto scheme. uuid must be 16 bytes.
* mimeType is the MIME type of the media container, e.g. "video/mp4". If mimeType
* is not known or required, it can be provided as NULL.
*
* Available since API level 21.
*/
AMediaDrm_isCryptoSchemeSupported :: proc(uuid: [^]byte, mimeType: cstring) -> bool ---
/**
* Create a MediaDrm instance from a UUID.
* uuid identifies the universal unique ID of the crypto scheme. uuid must be 16 bytes.
*
* Available since API level 21.
*/
AMediaDrm_createByUUID :: proc(uuid: [^]byte) -> ^AMediaDrm ---
/**
* Release a MediaDrm object.
*
* Available since API level 21.
*/
AMediaDrm_release :: proc(drm: ^AMediaDrm) ---
/**
* Register a callback to be invoked when an event occurs.
*
* listener is the callback that will be invoked on event.
*
* Available since API level 21.
*/
AMediaDrm_setOnEventListener :: proc(drm: ^AMediaDrm, listener: AMediaDrmEventListener) -> media_status_t ---
/**
* Register a callback to be invoked when an expiration update event occurs.
*
* listener is the callback that will be invoked on event.
*
* Available since API level 29.
*/
AMediaDrm_setOnExpirationUpdateListener :: proc(drm: ^AMediaDrm, listener: AMediaDrmExpirationUpdateListener) -> media_status_t ---
/**
* Register a callback to be invoked when a key status change event occurs.
*
* listener is the callback that will be invoked on event.
*
* Available since API level 29.
*/
AMediaDrm_setOnKeysChangeListener :: proc(drm: ^AMediaDrm, listener: AMediaDrmKeysChangeListener) -> media_status_t ---
/**
* Open a new session with the MediaDrm object. A session ID is returned.
*
* Returns AMEDIA_DRM_NOT_PROVISIONED if provisioning is needed.
* Returns AMEDIA_DRM_RESOURCE_BUSY if required resources are in use.
*
* Available since API level 21.
*/
AMediaDrm_openSession :: proc(drm: ^AMediaDrm, sessionId: ^AMediaDrmSessionId) -> media_status_t ---
/**
* Close a session on the MediaDrm object that was previously opened
* with AMediaDrm_openSession.
*
* Available since API level 21.
*/
AMediaDrm_closeSession :: proc(drm: ^AMediaDrm, sessionId: ^AMediaDrmSessionId) -> media_status_t ---
/**
* A key request/response exchange occurs between the app and a license server
* to obtain or release keys used to decrypt encrypted content.
* AMediaDrm_getKeyRequest is used to obtain an opaque key request byte array that
* is delivered to the license server. The opaque key request byte array is
* returned in *keyRequest and the number of bytes in the request is
* returned in *keyRequestSize.
* This API has same functionality as AMediaDrm_getKeyRequestWithDefaultUrlAndType()
* when defaultUrl and keyRequestType are passed in as NULL.
*
* After the app has received the key request response from the server,
* it should deliver to the response to the DRM engine plugin using the method
* AMediaDrm_provideKeyResponse.
*
* scope may be a sessionId or a keySetId, depending on the specified keyType.
* When the keyType is KEY_TYPE_STREAMING or KEY_TYPE_OFFLINE, scope should be set
* to the sessionId the keys will be provided to. When the keyType is
* KEY_TYPE_RELEASE, scope should be set to the keySetId of the keys being released.
* Releasing keys from a device invalidates them for all sessions.
*
* init container-specific data, its meaning is interpreted based on the mime type
* provided in the mimeType parameter. It could contain, for example, the content
* ID, key ID or other data obtained from the content metadata that is required in
* generating the key request. init may be null when keyType is KEY_TYPE_RELEASE.
*
* initSize is the number of bytes of initData
*
* mimeType identifies the mime type of the content.
*
* keyType specifes the type of the request. The request may be to acquire keys for
* streaming or offline content, or to release previously acquired keys, which are
* identified by a keySetId.
*
* optionalParameters are included in the key request message to allow a client
* application to provide additional message parameters to the server.
*
* numOptionalParameters indicates the number of optional parameters provided
* by the caller
*
* On exit:
* If this returns AMEDIA_OK,
* 1. The keyRequest pointer will reference the opaque key request data. It
* will reside in memory owned by the AMediaDrm object, and will remain
* accessible until the next call to AMediaDrm_getKeyRequest
* or AMediaDrm_getKeyRequestWithDefaultUrlAndType or until the
* MediaDrm object is released.
* 2. keyRequestSize will be set to the size of the request
* If this does not return AMEDIA_OK, value of these parameters should not be used.
*
* Returns AMEDIA_DRM_NOT_PROVISIONED if reprovisioning is needed, due to a
* problem with the device certificate.
*
* Available since API level 21.
*/
AMediaDrm_getKeyRequest :: proc(
drm: ^AMediaDrm,
scope: ^AMediaDrmScope,
init: [^]byte,
initSize: uint,
mimeType: cstring,
keyType: AMediaDrmKeyType,
optionalParameters: [^]AMediaDrmKeyValue,
numOptionalParameters: uint,
keyRequest: ^[^]byte,
keyRequestSize: ^uint) -> media_status_t ---
/**
* A key request/response exchange occurs between the app and a license server
* to obtain or release keys used to decrypt encrypted content.
* AMediaDrm_getKeyRequest is used to obtain an opaque key request byte array that
* is delivered to the license server. The opaque key request byte array is
* returned in *keyRequest and the number of bytes in the request is
* returned in *keyRequestSize.
*
* After the app has received the key request response from the server,
* it should deliver to the response to the DRM engine plugin using the method
* AMediaDrm_provideKeyResponse.
*
* scope may be a sessionId or a keySetId, depending on the specified keyType.
* When the keyType is KEY_TYPE_STREAMING or KEY_TYPE_OFFLINE, scope should be set
* to the sessionId the keys will be provided to. When the keyType is
* KEY_TYPE_RELEASE, scope should be set to the keySetId of the keys being released.
* Releasing keys from a device invalidates them for all sessions.
*
* init container-specific data, its meaning is interpreted based on the mime type
* provided in the mimeType parameter. It could contain, for example, the content
* ID, key ID or other data obtained from the content metadata that is required in
* generating the key request. init may be null when keyType is KEY_TYPE_RELEASE.
*
* initSize is the number of bytes of initData
*
* mimeType identifies the mime type of the content.
*
* keyType specifes the type of the request. The request may be to acquire keys for
* streaming or offline content, or to release previously acquired keys, which are
* identified by a keySetId.
*
* optionalParameters are included in the key request message to allow a client
* application to provide additional message parameters to the server.
*
* numOptionalParameters indicates the number of optional parameters provided
* by the caller
*
* On exit:
* If this returns AMEDIA_OK,
* 1. The keyRequest pointer will reference the opaque key request data. It
* will reside in memory owned by the AMediaDrm object, and will remain
* accessible until the next call to either AMediaDrm_getKeyRequest
* or AMediaDrm_getKeyRequestWithDefaultUrlAndType or until the
* MediaDrm object is released.
* 2. keyRequestSize will be set to the size of the request.
* 3. defaultUrl will be set to the recommended URL to deliver the key request.
* The defaultUrl pointer will reference a NULL terminated URL string.
* It will be UTF-8 encoded and have same lifetime with the key request data
* KeyRequest pointer references to. Passing in NULL means you don't need it
* to be reported.
* 4. keyRequestType will be set to the key request type. Passing in NULL means
* you don't need it to be reported.
*
* Returns AMEDIA_DRM_NOT_PROVISIONED if reprovisioning is needed, due to a
* problem with the device certificate.
*
* Available since API level 33.
*/
AMediaDrm_getKeyRequestWithDefaultUrlAndType :: proc(
drm: ^AMediaDrm,
scope: ^AMediaDrmScope,
init: [^]byte,
initSize: uint,
mimeType: cstring,
keyType: AMediaDrmKeyType,
optionalParameters: [^]AMediaDrmKeyValue,
numOptionalParameters: uint,
keyRequest: ^[^]byte,
keyRequestSize: ^uint,
defaultUrl: ^cstring,
keyRequestType: ^AMediaDrmKeyRequestType) -> media_status_t ---
/**
* A key response is received from the license server by the app, then it is
* provided to the DRM engine plugin using provideKeyResponse. When the
* response is for an offline key request, a keySetId is returned that can be
* used to later restore the keys to a new session with AMediaDrm_restoreKeys.
* When the response is for a streaming or release request, a null keySetId is
* returned.
*
* scope may be a sessionId or keySetId depending on the type of the
* response. Scope should be set to the sessionId when the response is for either
* streaming or offline key requests. Scope should be set to the keySetId when
* the response is for a release request.
*
* response points to the opaque response from the server
* responseSize should be set to the size of the response in bytes
*
* Available since API level 21.
*/
AMediaDrm_provideKeyResponse :: proc(
drm: ^AMediaDrm,
scope: ^AMediaDrmScope,
response: [^]byte,
responseSize: uint,
keySetId: ^AMediaDrmKeySetId) -> media_status_t ---
/**
* Restore persisted offline keys into a new session. keySetId identifies the
* keys to load, obtained from a prior call to AMediaDrm_provideKeyResponse.
*
* sessionId is the session ID for the DRM session.
* keySetId identifies the saved key set to restore.
*
* Available since API level 21.
*/
AMediaDrm_restoreKeys :: proc(drm: ^AMediaDrm, sessionId: ^AMediaDrmSessionId, keySetId: ^AMediaDrmKeySetId) -> media_status_t ---
/**
* Remove the current keys from a session.
*
* keySetId identifies keys to remove.
*
* Available since API level 21.
*/
AMediaDrm_removeKeys :: proc(drm: ^AMediaDrm, keySetId: ^AMediaDrmSessionId) -> media_status_t ---
/**
* Request an informative description of the key status for the session. The status is
* in the form of {key, value} pairs. Since DRM license policies vary by vendor,
* the specific status field names are determined by each DRM vendor. Refer to your
* DRM provider documentation for definitions of the field names for a particular
* DRM engine plugin.
*
* On entry, numPairs should be set by the caller to the maximum number of pairs
* that can be returned (the size of the array). On exit, numPairs will be set
* to the number of entries written to the array. If the number of {key, value} pairs
* to be returned is greater than *numPairs, AMEDIA_DRM_SHORT_BUFFER will be returned
* and numPairs will be set to the number of pairs available.
*
* Available since API level 21.
*/
AMediaDrm_queryKeyStatus :: proc(drm: ^AMediaDrm, sessionId: ^AMediaDrmSessionId, keyValuePairs: [^]AMediaDrmKeyValue, numPairs: ^uint) -> media_status_t ---
/**
* A provision request/response exchange occurs between the app and a provisioning
* server to retrieve a device certificate. If provisionining is required, the
* EVENT_PROVISION_REQUIRED event will be sent to the event handler.
* getProvisionRequest is used to obtain the opaque provision request byte array that
* should be delivered to the provisioning server.
* On exit:
* 1. The provision request data will be referenced by provisionRequest, in
* memory owned by the AMediaDrm object. It will remain accessible until the
* next call to getProvisionRequest.
* 2. provisionRequestSize will be set to the size of the request data.
* 3. serverUrl will reference a NULL terminated string containing the URL
* the provisioning request should be sent to. It will remain accessible until
* the next call to getProvisionRequest.
*
* Available since API level 21.
*/
AMediaDrm_getProvisionRequest :: proc(drm: ^AMediaDrm, provisionRequest: ^[^]byte, provisionRequestSize: ^uint, serverUrl: ^cstring) -> media_status_t ---
/**
* After a provision response is received by the app, it is provided to the DRM
* engine plugin using this method.
*
* response is the opaque provisioning response byte array to provide to the
* DRM engine plugin.
* responseSize is the length of the provisioning response in bytes.
*
* Returns AMEDIA_DRM_DEVICE_REVOKED if the response indicates that the
* server rejected the request
*
* Available since API level 21.
*/
AMediaDrm_provideProvisionResponse :: proc(drm: ^AMediaDrm, response: [^]byte, responseSize: uint) -> media_status_t ---
/**
* A means of enforcing limits on the number of concurrent streams per subscriber
* across devices is provided via SecureStop. This is achieved by securely
* monitoring the lifetime of sessions.
*
* Information from the server related to the current playback session is written
* to persistent storage on the device when each MediaCrypto object is created.
*
* In the normal case, playback will be completed, the session destroyed and the
* Secure Stops will be queried. The app queries secure stops and forwards the
* secure stop message to the server which verifies the signature and notifies the
* server side database that the session destruction has been confirmed. The persisted
* record on the client is only removed after positive confirmation that the server
* received the message using releaseSecureStops().
*
* numSecureStops is set by the caller to the maximum number of secure stops to
* return. On exit, *numSecureStops will be set to the number actually returned.
* If *numSecureStops is too small for the number of secure stops available,
* AMEDIA_DRM_SHORT_BUFFER will be returned and *numSecureStops will be set to the
* number required.
*
* Available since API level 21.
*/
AMediaDrm_getSecureStops :: proc(drm: ^AMediaDrm, secureStops: ^AMediaDrmSecureStop, numSecureStops: ^uint) -> media_status_t ---
/**
* Process the SecureStop server response message ssRelease. After authenticating
* the message, remove the SecureStops identified in the response.
*
* ssRelease is the server response indicating which secure stops to release
*
* Available since API level 21.
*/
AMediaDrm_releaseSecureStops :: proc(drm: ^AMediaDrm, ssRelease: ^AMediaDrmSecureStop) -> media_status_t ---
/**
* Read a DRM engine plugin String property value, given the property name string.
*
* propertyName identifies the property to query
* On return, propertyValue will be set to point to the property value. The
* memory that the value resides in is owned by the NDK MediaDrm API and
* will remain valid until the next call to AMediaDrm_getPropertyString.
*
* Available since API level 21.
*/
AMediaDrm_getPropertyString :: proc(drm: ^AMediaDrm, propertyName: cstring, propertyValue: ^cstring) -> media_status_t ---
/**
* Read a DRM engine plugin byte array property value, given the property name string.
* On return, *propertyValue will be set to point to the property value. The
* memory that the value resides in is owned by the NDK MediaDrm API and
* will remain valid until the next call to AMediaDrm_getPropertyByteArray.
*
* Available since API level 21.
*/
AMediaDrm_getPropertyByteArray :: proc(drm: ^AMediaDrm, propertyName: cstring, propertyValue: ^AMediaDrmByteArray) -> media_status_t ---
/**
* Set a DRM engine plugin String property value.
*
* Available since API level 21.
*/
AMediaDrm_setPropertyString :: proc(drm: ^AMediaDrm, propertyName: cstring, value: cstring) -> media_status_t ---
/**
* Set a DRM engine plugin byte array property value.
*
* Available since API level 21.
*/
AMediaDrm_setPropertyByteArray :: proc(drm: ^AMediaDrm, propertyName: cstring, value: [^]byte, valueSize: uint) -> media_status_t ---
/**
* In addition to supporting decryption of DASH Common Encrypted Media, the
* MediaDrm APIs provide the ability to securely deliver session keys from
* an operator's session key server to a client device, based on the factory-installed
* root of trust, and then perform encrypt, decrypt, sign and verify operations
* with the session key on arbitrary user data.
*
* Operators create session key servers that receive session key requests and provide
* encrypted session keys which can be used for general purpose crypto operations.
*
* Generic encrypt/decrypt/sign/verify methods are based on the established session
* keys. These keys are exchanged using the getKeyRequest/provideKeyResponse methods.
*
* Applications of this capability include securing various types of purchased or
* private content, such as applications, books and other media, photos or media
* delivery protocols.
*/
/*
* Encrypt the data referenced by input of length dataSize using algorithm specified
* by cipherAlgorithm, and write the encrypted result into output. The caller must
* ensure that the output buffer is large enough to accept dataSize bytes. The key
* to use is identified by the 16 byte keyId. The key must have been loaded into
* the session using provideKeyResponse.
*
* Available since API level 21.
*/
AMediaDrm_encrypt :: proc(
drm: ^AMediaDrm,
sessionId: ^AMediaDrmSessionId,
cipherAlgorithm: cstring,
keyId: [^]byte,
iv: [^]byte,
input: [^]byte,
output: [^]byte,
dataSize: uint) -> media_status_t ---
/*
* Decrypt the data referenced by input of length dataSize using algorithm specified
* by cipherAlgorithm, and write the decrypted result into output. The caller must
* ensure that the output buffer is large enough to accept dataSize bytes. The key
* to use is identified by the 16 byte keyId. The key must have been loaded into
* the session using provideKeyResponse.
*
* Available since API level 21.
*/
AMediaDrm_decrypt :: proc(
drm: ^AMediaDrm,
sessionId: ^AMediaDrmSessionId,
cipherAlgorithm: cstring,
keyId: [^]byte,
iv: [^]byte,
input: [^]byte,
output: [^]byte,
dataSize: uint) -> media_status_t ---
/*
* Generate a signature using the specified macAlgorithm over the message data
* referenced by message of size messageSize and store the signature in the
* buffer referenced signature of max size *signatureSize. If the buffer is not
* large enough to hold the signature, AMEDIA_DRM_SHORT_BUFFER is returned and
* *signatureSize is set to the buffer size required. The key to use is identified
* by the 16 byte keyId. The key must have been loaded into the session using
* provideKeyResponse.
*
* Available since API level 21.
*/
AMediaDrm_sign :: proc(
drm: ^AMediaDrm,
sessionId: ^AMediaDrmSessionId,
macAlgorithm: cstring,
keyId: [^]byte,
message: [^]byte,
messageSize: uint,
signature: [^]byte,
signatureSize: ^uint) -> media_status_t ---
/*
* Perform a signature verification using the specified macAlgorithm over the message
* data referenced by the message parameter of size messageSize. Returns AMEDIA_OK
* if the signature matches, otherwise MEDAIDRM_VERIFY_FAILED is returned. The key to
* use is identified by the 16 byte keyId. The key must have been loaded into the
* session using provideKeyResponse.
*
* Available since API level 21.
*/
AMediaDrm_verify :: proc(
drm: ^AMediaDrm,
sessionId: ^AMediaDrmSessionId,
macAlgorithm: cstring,
keyId: [^]byte,
message: [^]byte,
messageSize: uint,
signature: [^]byte,
signatureSize: uint) -> media_status_t ---
}
media/NdkMediaError.odin
+81
View File
@@ -0,0 +1,81 @@
//+build android
package mediandk
/**
* Media error message types returned from NDK media functions.
*/
media_status_t :: enum {
/** The requested media operation completed successfully. */
AMEDIA_OK = 0,
/**
* This indicates required resource was not able to be allocated.
*/
AMEDIACODEC_ERROR_INSUFFICIENT_RESOURCE = 1100,
/**
* This indicates the resource manager reclaimed the media resource used by the codec.
* With this error, the codec must be released, as it has moved to terminal state.
*/
AMEDIACODEC_ERROR_RECLAIMED = 1101,
AMEDIA_ERROR_BASE = -10000,
/** The called media function failed with an unknown error. */
AMEDIA_ERROR_UNKNOWN = AMEDIA_ERROR_BASE,
/** The input media data is corrupt or incomplete. */
AMEDIA_ERROR_MALFORMED = AMEDIA_ERROR_BASE - 1,
/** The required operation or media formats are not supported. */
AMEDIA_ERROR_UNSUPPORTED = AMEDIA_ERROR_BASE - 2,
/** An invalid (or already closed) object is used in the function call. */
AMEDIA_ERROR_INVALID_OBJECT = AMEDIA_ERROR_BASE - 3,
/** At least one of the invalid parameters is used. */
AMEDIA_ERROR_INVALID_PARAMETER = AMEDIA_ERROR_BASE - 4,
/** The media object is not in the right state for the required operation. */
AMEDIA_ERROR_INVALID_OPERATION = AMEDIA_ERROR_BASE - 5,
/** Media stream ends while processing the requested operation. */
AMEDIA_ERROR_END_OF_STREAM = AMEDIA_ERROR_BASE - 6,
/** An Error occurred when the Media object is carrying IO operation. */
AMEDIA_ERROR_IO = AMEDIA_ERROR_BASE - 7,
/** The required operation would have to be blocked (on I/O or others),
* but blocking is not enabled.
*/
AMEDIA_ERROR_WOULD_BLOCK = AMEDIA_ERROR_BASE - 8,
AMEDIA_DRM_ERROR_BASE = -20000,
AMEDIA_DRM_NOT_PROVISIONED = AMEDIA_DRM_ERROR_BASE - 1,
AMEDIA_DRM_RESOURCE_BUSY = AMEDIA_DRM_ERROR_BASE - 2,
AMEDIA_DRM_DEVICE_REVOKED = AMEDIA_DRM_ERROR_BASE - 3,
AMEDIA_DRM_SHORT_BUFFER = AMEDIA_DRM_ERROR_BASE - 4,
AMEDIA_DRM_SESSION_NOT_OPENED = AMEDIA_DRM_ERROR_BASE - 5,
AMEDIA_DRM_TAMPER_DETECTED = AMEDIA_DRM_ERROR_BASE - 6,
AMEDIA_DRM_VERIFY_FAILED = AMEDIA_DRM_ERROR_BASE - 7,
AMEDIA_DRM_NEED_KEY = AMEDIA_DRM_ERROR_BASE - 8,
AMEDIA_DRM_LICENSE_EXPIRED = AMEDIA_DRM_ERROR_BASE - 9,
AMEDIA_IMGREADER_ERROR_BASE = -30000,
/** There are no more image buffers to read/write image data. */
AMEDIA_IMGREADER_NO_BUFFER_AVAILABLE = AMEDIA_IMGREADER_ERROR_BASE - 1,
/** The AImage object has used up the allowed maximum image buffers. */
AMEDIA_IMGREADER_MAX_IMAGES_ACQUIRED = AMEDIA_IMGREADER_ERROR_BASE - 2,
/** The required image buffer could not be locked to read. */
AMEDIA_IMGREADER_CANNOT_LOCK_IMAGE = AMEDIA_IMGREADER_ERROR_BASE - 3,
/** The media data or buffer could not be unlocked. */
AMEDIA_IMGREADER_CANNOT_UNLOCK_IMAGE = AMEDIA_IMGREADER_ERROR_BASE - 4,
/** The media/buffer needs to be locked to perform the required operation. */
AMEDIA_IMGREADER_IMAGE_NOT_LOCKED = AMEDIA_IMGREADER_ERROR_BASE - 5,
}
media/NdkMediaExtractor.odin
+213
View File
@@ -0,0 +1,213 @@
//+build android
package mediandk
import "../"
foreign import mediandk "system:mediandk"
SeekMode :: enum {
PREVIOUS_SYNC,
NEXT_SYNC,
CLOSEST_SYNC
}
SampleFlags :: enum u32 {
SYNC = 1,
ENCRYPTED = 2,
}
AMediaExtractor :: struct{}
/**
* mapping of crypto scheme uuid to the scheme specific data for that scheme
*/
PsshEntry :: struct {
uuid: AMediaUUID,
datalen: uint,
data: rawptr,
}
/**
* list of crypto schemes and their data
*/
PsshInfo :: struct {
numentries: uint,
entries: [0]PsshEntry,
}
foreign mediandk {
/**
* Create new media extractor.
*
* Available since API level 21.
*/
AMediaExtractor_new :: proc() -> ^AMediaExtractor ---
/**
* Delete a previously created media extractor.
*
* Available since API level 21.
*/
AMediaExtractor_delete :: proc(extractor: ^AMediaExtractor) -> media_status_t ---
/**
* Set the file descriptor from which the extractor will read.
*
* Available since API level 21.
*/
AMediaExtractor_setDataSourceFd :: proc(extractor: ^AMediaExtractor, fd: i32, offset: android.off64_t, length: android.off64_t) -> media_status_t ---
/**
* Set the URI from which the extractor will read.
*
* Available since API level 21.
*/
AMediaExtractor_setDataSource :: proc(extractor: ^AMediaExtractor, location: cstring) -> media_status_t ---
/**
* Set the custom data source implementation from which the extractor will read.
*
* Available since API level 28.
*/
AMediaExtractor_setDataSourceCustom :: proc(extractor: ^AMediaExtractor, src: ^AMediaDataSource) -> media_status_t ---
/**
* Return the number of tracks in the previously specified media file
*
* Available since API level 21.
*/
AMediaExtractor_getTrackCount :: proc(extractor: ^AMediaExtractor) -> uint ---
/**
* Return the format of the specified track. The caller must free the returned format
*
* Available since API level 21.
*/
AMediaExtractor_getTrackFormat :: proc(extractor: ^AMediaExtractor, idx: uint) -> ^AMediaFormat ---
/**
* Select the specified track. Subsequent calls to readSampleData, getSampleTrackIndex and
* getSampleTime only retrieve information for the subset of tracks selected.
* Selecting the same track multiple times has no effect, the track is
* only selected once.
*
* Available since API level 21.
*/
AMediaExtractor_selectTrack :: proc(extractor: ^AMediaExtractor, idx: uint) -> media_status_t ---
/**
* Unselect the specified track. Subsequent calls to readSampleData, getSampleTrackIndex and
* getSampleTime only retrieve information for the subset of tracks selected.
*
* Available since API level 21.
*/
AMediaExtractor_unselectTrack :: proc(extractor: ^AMediaExtractor, idx: uint) -> media_status_t ---
/**
* Read the current sample.
*
* Available since API level 21.
*/
AMediaExtractor_readSampleData :: proc(extractor: ^AMediaExtractor, buffer: [^]u8, capacity: uint) -> int ---
/**
* Read the current sample's flags.
*
* Available since API level 21.
*/
AMediaExtractor_getSampleFlags :: proc(extractor: ^AMediaExtractor) -> SampleFlags ---
/**
* Returns the track index the current sample originates from (or -1
* if no more samples are available)
*
* Available since API level 21.
*/
AMediaExtractor_getSampleTrackIndex :: proc(extractor: ^AMediaExtractor) -> i32 ---
/**
* Returns the current sample's presentation time in microseconds.
* or -1 if no more samples are available.
*
* Available since API level 21.
*/
AMediaExtractor_getSampleTime :: proc(extractor: ^AMediaExtractor) -> i64 ---
/**
* Advance to the next sample. Returns false if no more sample data
* is available (end of stream).
*
* Available since API level 21.
*/
AMediaExtractor_advance :: proc(extractor: ^AMediaExtractor) -> bool ---
/**
* Available since API level 21.
*/
AMediaExtractor_seekTo :: proc(extractor: ^AMediaExtractor, seekPosUs: i64, mode: SeekMode) -> media_status_t ---
/**
* Get the PSSH info if present.
*
* Available since API level 21.
*/
AMediaExtractor_getPsshInfo :: proc(extractor: ^AMediaExtractor) -> ^PsshInfo ---
/**
* Available since API level 21.
*/
AMediaExtractor_getSampleCryptoInfo :: proc(extractor: ^AMediaExtractor) -> ^AMediaCodecCryptoInfo ---
/**
* Returns the format of the extractor. The caller must free the returned format
* using AMediaFormat_delete(format).
*
* This function will always return a format however, the format could be empty
* (no key-value pairs) if the media container does not provide format information.
*
* Available since API level 28.
*/
AMediaExtractor_getFileFormat :: proc(extractor: ^AMediaExtractor) -> ^AMediaFormat ---
/**
* Returns the size of the current sample in bytes, or -1 when no samples are
* available (end of stream). This API can be used in in conjunction with
* AMediaExtractor_readSampleData:
*
* ssize_t sampleSize = AMediaExtractor_getSampleSize(ex)
* uint8_t *buf = new uint8_t[sampleSize]
* AMediaExtractor_readSampleData(ex, buf, sampleSize)
*
* Available since API level 28.
*/
AMediaExtractor_getSampleSize :: proc(extractor: ^AMediaExtractor) -> int ---
/**
* Returns the duration of cached media samples downloaded from a network data source
* (AMediaExtractor_setDataSource with a "http(s)" URI) in microseconds.
*
* This information is calculated using total bitrate if total bitrate is not in the
* media container it is calculated using total duration and file size.
*
* Returns -1 when the extractor is not reading from a network data source, or when the
* cached duration cannot be calculated (bitrate, duration, and file size information
* not available).
*
* Available since API level 28.
*/
AMediaExtractor_getCachedDuration :: proc(extractor: ^AMediaExtractor) -> i64 ---
/**
* Read the current sample's metadata format into |fmt|. Examples of sample metadata are
* SEI (supplemental enhancement information) and MPEG user data, both of which can embed
* closed-caption data.
*
* Returns AMEDIA_OK on success or AMEDIA_ERROR_* to indicate failure reason.
* Existing key-value pairs in |fmt| would be removed if this API returns AMEDIA_OK.
* The contents of |fmt| is undefined if this API returns AMEDIA_ERROR_*.
*
* Available since API level 28.
*/
AMediaExtractor_getSampleFormat :: proc(ex: ^AMediaExtractor, fmt: ^AMediaFormat) -> media_status_t ---
}
media/NdkMediaFormat.odin
+306
View File
@@ -0,0 +1,306 @@
//+build android
package mediandk
foreign import mediandk "system:mediandk"
AMediaFormat :: struct{}
AMEDIAFORMAT_KEY_AAC_DRC_ATTENUATION_FACTOR: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_AAC_DRC_BOOST_FACTOR: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_AAC_DRC_HEAVY_COMPRESSION: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_AAC_DRC_TARGET_REFERENCE_LEVEL: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_AAC_ENCODED_TARGET_LEVEL: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_AAC_MAX_OUTPUT_CHANNEL_COUNT: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_AAC_PROFILE: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_AAC_SBR_MODE: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_AUDIO_SESSION_ID: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_BITRATE_MODE: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_BIT_RATE: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_CAPTURE_RATE: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_CHANNEL_COUNT: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_CHANNEL_MASK: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_COLOR_FORMAT: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_COLOR_RANGE: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_COLOR_STANDARD: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_COLOR_TRANSFER: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_COMPLEXITY: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_CSD: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_CSD_0: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_CSD_1: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_CSD_2: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_DISPLAY_CROP: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_DISPLAY_HEIGHT: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_DISPLAY_WIDTH: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_DURATION: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_FLAC_COMPRESSION_LEVEL: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_FRAME_RATE: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_GRID_COLUMNS: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_GRID_ROWS: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_HDR_STATIC_INFO: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_HEIGHT: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_INTRA_REFRESH_PERIOD: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_IS_ADTS: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_IS_AUTOSELECT: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_IS_DEFAULT: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_IS_FORCED_SUBTITLE: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_I_FRAME_INTERVAL: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_LANGUAGE: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_LATENCY: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_LEVEL: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_MAX_HEIGHT: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_MAX_INPUT_SIZE: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_MAX_WIDTH: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_MIME: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_MPEG_USER_DATA: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_OPERATING_RATE: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_PCM_ENCODING: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_PRIORITY: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_PROFILE: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_PUSH_BLANK_BUFFERS_ON_STOP: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_REPEAT_PREVIOUS_FRAME_AFTER: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_ROTATION: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_SAMPLE_RATE: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_SEI: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_SLICE_HEIGHT: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_STRIDE: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_TEMPORAL_LAYER_ID: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_TEMPORAL_LAYERING: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_TILE_HEIGHT: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_TILE_WIDTH: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_TIME_US: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_TRACK_ID: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_TRACK_INDEX: cstring //__INTRODUCED_IN(28)
AMEDIAFORMAT_KEY_WIDTH: cstring //__INTRODUCED_IN(21)
AMEDIAFORMAT_KEY_ALBUM: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_ALBUMART: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_ALBUMARTIST: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_ARTIST: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_AUDIO_PRESENTATION_INFO: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_AUDIO_PRESENTATION_PRESENTATION_ID: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_AUDIO_PRESENTATION_PROGRAM_ID: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_AUTHOR: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_BITS_PER_SAMPLE: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CDTRACKNUMBER: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_COMPILATION: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_COMPOSER: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CREATE_INPUT_SURFACE_SUSPENDED: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CRYPTO_DEFAULT_IV_SIZE: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_BYTE_BLOCK: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CRYPTO_ENCRYPTED_SIZES: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CRYPTO_IV: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CRYPTO_KEY: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CRYPTO_MODE: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CRYPTO_PLAIN_SIZES: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CRYPTO_SKIP_BYTE_BLOCK: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CSD_AVC: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_CSD_HEVC: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_D263: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_DATE: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_DISCNUMBER: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_ENCODER_DELAY: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_ENCODER_PADDING: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_ESDS: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_EXIF_OFFSET: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_EXIF_SIZE: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_FRAME_COUNT: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_GENRE: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_HAPTIC_CHANNEL_COUNT: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_ICC_PROFILE: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_IS_SYNC_FRAME: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_LOCATION: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_LOOP: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_LYRICIST: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_MANUFACTURER: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_MAX_BIT_RATE: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_MAX_FPS_TO_ENCODER: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_MAX_PTS_GAP_TO_ENCODER: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_MPEG2_STREAM_HEADER: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_PCM_BIG_ENDIAN: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_PSSH: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_SAR_HEIGHT: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_SAR_WIDTH: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_TARGET_TIME: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_TEMPORAL_LAYER_COUNT: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_TEXT_FORMAT_DATA: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_THUMBNAIL_CSD_HEVC: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_THUMBNAIL_HEIGHT: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_THUMBNAIL_TIME: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_THUMBNAIL_WIDTH: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_TITLE: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_VALID_SAMPLES: cstring //__INTRODUCED_IN(29)
AMEDIAFORMAT_KEY_YEAR: cstring //__INTRODUCED_IN(29)
/**
* An optional key describing the low latency decoding mode. This is an optional parameter
* that applies only to decoders. If enabled, the decoder doesn't hold input and output
* data more than required by the codec standards.
* The associated value is an integer (0 or 1): 1 when low-latency decoding is enabled,
* 0 otherwise. The default value is 0.
*
* Available since API level 30.
*/
AMEDIAFORMAT_KEY_LOW_LATENCY: cstring //__INTRODUCED_IN(30)
AMEDIAFORMAT_KEY_HDR10_PLUS_INFO: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_KEY_SLOW_MOTION_MARKERS: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_KEY_THUMBNAIL_CSD_AV1C: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_KEY_XMP_OFFSET: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_KEY_XMP_SIZE: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_KEY_SAMPLE_FILE_OFFSET: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_KEY_LAST_SAMPLE_INDEX_IN_CHUNK: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_KEY_SAMPLE_TIME_BEFORE_APPEND: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_KEY_PICTURE_TYPE: cstring //__INTRODUCED_IN(33)
AMEDIAFORMAT_KEY_VIDEO_ENCODING_STATISTICS_LEVEL: cstring //__INTRODUCED_IN(33)
AMEDIAFORMAT_KEY_VIDEO_QP_AVERAGE: cstring //__INTRODUCED_IN(33)
AMEDIAFORMAT_VIDEO_QP_B_MAX: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_VIDEO_QP_B_MIN: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_VIDEO_QP_I_MAX: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_VIDEO_QP_I_MIN: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_VIDEO_QP_MAX: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_VIDEO_QP_MIN: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_VIDEO_QP_P_MAX: cstring //__INTRODUCED_IN(31)
AMEDIAFORMAT_VIDEO_QP_P_MIN: cstring //__INTRODUCED_IN(31)
/**
* MPEG-H audio profile and level compatibility.
*
* See FDAmd_2 of ISO_IEC_23008-3;2019 MHAProfileAndLevelCompatibilitySetBox.
*
* Available since API level 32.
*/
AMEDIAFORMAT_KEY_MPEGH_COMPATIBLE_SETS: cstring //__INTRODUCED_IN(32)
/**
* MPEG-H audio profile level indication.
*
* See ISO_IEC_23008-3;2019 MHADecoderConfigurationRecord mpegh3daProfileLevelIndication.
*
* Available since API level 32.
*/
AMEDIAFORMAT_KEY_MPEGH_PROFILE_LEVEL_INDICATION: cstring //__INTRODUCED_IN(32)
/**
* MPEG-H audio reference channel layout.
*
* See ISO_IEC_23008-3;2019 MHADecoderConfigurationRecord referenceChannelLayout
* and ISO_IEC_23001‐8 ChannelConfiguration value.
*
* Available since API level 32.
*/
AMEDIAFORMAT_KEY_MPEGH_REFERENCE_CHANNEL_LAYOUT: cstring //__INTRODUCED_IN(32)
foreign mediandk {
/**
* Available since API level 21.
*/
AMediaFormat_new :: proc() -> ^AMediaFormat ---
/**
* Available since API level 21.
*/
AMediaFormat_delete :: proc(format: ^AMediaFormat) -> media_status_t ---
/**
* Human readable representation of the format. The returned string is owned by the format,
* and remains valid until the next call to toString, or until the format is deleted.
*
* Available since API level 21.
*/
AMediaFormat_toString :: proc(format: ^AMediaFormat) -> cstring ---
/**
* Available since API level 21.
*/
AMediaFormat_getInt32 :: proc(format: ^AMediaFormat, name: cstring, out: ^i32) -> bool ---
/**
* Available since API level 21.
*/
AMediaFormat_getInt64 :: proc(format: ^AMediaFormat, name: cstring, out: ^i64) -> bool ---
/**
* Available since API level 21.
*/
AMediaFormat_getFloat :: proc(format: ^AMediaFormat, name: cstring, out: ^f32) -> bool ---
/**
* Available since API level 21.
*/
AMediaFormat_getSize :: proc(format: ^AMediaFormat, name: cstring, out: ^uint) -> bool ---
/**
* The returned data is owned by the format and remains valid as long as the named entry
* is part of the format.
*
* Available since API level 21.
*/
AMediaFormat_getBuffer :: proc(format: ^AMediaFormat, name: cstring, data: ^rawptr, size: ^uint) -> bool ---
/**
* The returned string is owned by the format, and remains valid until the next call to getString,
* or until the format is deleted.
*
* Available since API level 21.
*/
AMediaFormat_getString :: proc(format: ^AMediaFormat, name: cstring, out: ^cstring) -> bool ---
/**
* Available since API level 21.
*/
AMediaFormat_setInt32 :: proc(format: ^AMediaFormat, name: cstring, value: i32) ---
/**
* Available since API level 21.
*/
AMediaFormat_setInt64 :: proc(format: ^AMediaFormat, name: cstring, value: i64) ---
/**
* Available since API level 21.
*/
AMediaFormat_setFloat :: proc(format: ^AMediaFormat, name: cstring, value: f32) ---
/**
* The provided string is copied into the format.
*
* Available since API level 21.
*/
AMediaFormat_setString :: proc(format: ^AMediaFormat, name: cstring, value: cstring) ---
/**
* The provided data is copied into the format.
*
* Available since API level 21.
*/
AMediaFormat_setBuffer :: proc(format: ^AMediaFormat, name: cstring, data: rawptr, size: uint) ---
/**
* Available since API level 28.
*/
AMediaFormat_getDouble :: proc(format: ^AMediaFormat, name: cstring, out: ^f64) -> bool ---
/**
* Available since API level 28.
*/
AMediaFormat_getRect :: proc(format: ^AMediaFormat, name: cstring, left: ^i32, top: ^i32, right: ^i32, bottom: ^i32) -> bool ---
/**
* Available since API level 28.
*/
AMediaFormat_setDouble :: proc(format: ^AMediaFormat, name: cstring, value: f64) ---
/**
* Available since API level 28.
*/
AMediaFormat_setSize :: proc(format: ^AMediaFormat, name: cstring, value: uint) ---
/**
* Available since API level 28.
*/
AMediaFormat_setRect :: proc(format: ^AMediaFormat, name: cstring, left: i32, top: i32, right: i32, bottom: i32) ---
/**
* Remove all key/value pairs from the given AMediaFormat.
*
* Available since API level 29.
*/
AMediaFormat_clear :: proc(format: ^AMediaFormat) ---
/**
* Copy one AMediaFormat to another.
*
* Available since API level 29.
*/
AMediaFormat_copy :: proc(to: ^AMediaFormat, from: ^AMediaFormat) -> media_status_t ---
}
media/NdkMediaMuxer.odin
+146
View File
@@ -0,0 +1,146 @@
//+build android
package mediandk
foreign import mediandk "system:mediandk"
OutputFormat :: enum i32 {
MPEG_4 = 0,
WEBM = 1,
THREE_GPP = 2,
}
AppendMode :: enum i32 {
/* Last group of pictures(GOP) of video track can be incomplete, so it would be safe to
* scrap that and rewrite. If both audio and video tracks are present in a file, then
* samples of audio track after last GOP of video would be scrapped too.
* If only audio track is present, then no sample would be discarded.
*/
IGNORE_LAST_VIDEO_GOP = 0,
// Keep all existing samples as it is and append new samples after that only.
TO_EXISTING_DATA = 1,
}
AMediaMuxer :: struct{}
foreign mediandk {
/**
* Create new media muxer.
*
* Available since API level 21.
*/
AMediaMuxer_new :: proc(fd: i32, format: OutputFormat) -> ^AMediaMuxer ---
/**
* Delete a previously created media muxer.
*
* Available since API level 21.
*/
AMediaMuxer_delete :: proc(muxer: ^AMediaMuxer) -> media_status_t ---
/**
* Set and store the geodata (latitude and longitude) in the output file.
* This method should be called before AMediaMuxer_start. The geodata is stored
* in udta box if the output format is AMEDIAMUXER_OUTPUT_FORMAT_MPEG_4, and is
* ignored for other output formats.
* The geodata is stored according to ISO-6709 standard.
*
* Both values are specified in degrees.
* Latitude must be in the range [-90, 90].
* Longitude must be in the range [-180, 180].
*
* Available since API level 21.
*/
AMediaMuxer_setLocation :: proc(muxer: ^AMediaMuxer, latitude: f32, longitude: f32) -> media_status_t ---
/**
* Sets the orientation hint for output video playback.
* This method should be called before AMediaMuxer_start. Calling this
* method will not rotate the video frame when muxer is generating the file,
* but add a composition matrix containing the rotation angle in the output
* video if the output format is AMEDIAMUXER_OUTPUT_FORMAT_MPEG_4, so that a
* video player can choose the proper orientation for playback.
* Note that some video players may choose to ignore the composition matrix
* during playback.
* The angle is specified in degrees, clockwise.
* The supported angles are 0, 90, 180, and 270 degrees.
*
* Available since API level 21.
*/
AMediaMuxer_setOrientationHint :: proc(muxer: ^AMediaMuxer, degrees: i32) -> media_status_t ---
/**
* Adds a track with the specified format.
* Returns the index of the new track or a negative value in case of failure,
* which can be interpreted as a media_status_t.
*
* Available since API level 21.
*/
AMediaMuxer_addTrack :: proc(muxer: ^AMediaMuxer, format: ^AMediaFormat) -> int ---
/**
* Start the muxer. Should be called after AMediaMuxer_addTrack and
* before AMediaMuxer_writeSampleData.
*
* Available since API level 21.
*/
AMediaMuxer_start :: proc(muxer: ^AMediaMuxer) -> media_status_t ---
/**
* Stops the muxer.
* Once the muxer stops, it can not be restarted.
*
* Available since API level 21.
*/
AMediaMuxer_stop :: proc(muxer: ^AMediaMuxer) -> media_status_t ---
/**
* Writes an encoded sample into the muxer.
* The application needs to make sure that the samples are written into
* the right tracks. Also, it needs to make sure the samples for each track
* are written in chronological order (e.g. in the order they are provided
* by the encoder.)
*
* Available since API level 21.
*/
AMediaMuxer_writeSampleData :: proc(muxer: ^AMediaMuxer, trackIdx: uint, data: [^]u8, info: ^AMediaCodecBufferInfo) -> media_status_t ---
/**
* Creates a new media muxer for appending data to an existing MPEG4 file.
* This is a synchronous API call and could take a while to return if the existing file is large.
* Only works for MPEG4 files matching one of the following characteristics:
* <ul>
* <li>a single audio track.</li>
* <li>a single video track.</li>
* <li>a single audio and a single video track.</li>
* </ul>
* @param fd Must be opened with read and write permission. Does not take ownership of
* this fd i.e., caller is responsible for closing fd.
* @param mode Specifies how data will be appended the AppendMode enum describes
* the possible methods for appending..
* @return Pointer to AMediaMuxer if the file(fd) has tracks already, otherwise, nullptr.
* {@link AMediaMuxer_delete} should be used to free the returned pointer.
*
* Available since API level 31.
*/
AMediaMuxer_append :: proc(fd: i32, mode: AppendMode) -> ^AMediaMuxer ---
/**
* Returns the number of tracks added in the file passed to {@link AMediaMuxer_new} or
* the number of existing tracks in the file passed to {@link AMediaMuxer_append}.
* Should be called in INITIALIZED or STARTED state, otherwise returns -1.
*
* Available since API level 31.
*/
AMediaMuxer_getTrackCount :: proc(muxer: ^AMediaMuxer) -> int ---
/**
* Returns AMediaFormat of the added track with index idx in the file passed to
* {@link AMediaMuxer_new} or the AMediaFormat of the existing track with index idx
* in the file passed to {@link AMediaMuxer_append}.
* Should be called in INITIALIZED or STARTED state, otherwise returns nullptr.
* {@link AMediaFormat_delete} should be used to free the returned pointer.
*
* Available since API level 31.
*/
AMediaMuxer_getTrackFormat :: proc(muxer: ^AMediaMuxer, idx: uint) -> ^AMediaFormat ---
}
sensor.odin
+10 -2
View File
@@ -48,6 +48,11 @@ SensorType :: enum i32 {
* field in the X, Y and Z axis.
*/
MAGNETIC_FIELD = 2,
/* Deprecated in API level 15
* This isn't defined in the NDK but the procedures report it as a valid sensor and can work with it.
*/
ORIENTATION = 3,
/**
* {@link ASENSOR_TYPE_GYROSCOPE}
* reporting-mode: continuous
@@ -69,6 +74,11 @@ SensorType :: enum i32 {
* The pressure sensor value is returned in hPa (millibar).
*/
PRESSURE = 6,
/* Deprecated in API level 15. Use AMBIENT_TEMPERATURE instead.
* This isn't defined in the NDK but the procedures report it as a valid sensor and can work with it.
*/
TEMPERATURE = 7,
/**
* {@link ASENSOR_TYPE_PROXIMITY}
* reporting-mode: on-change
@@ -381,8 +391,6 @@ ASensorVector :: struct {
reserved: [3]u8,
}
// TODO: sensor might be SensorType here, will need some code to confirm though.
// Not sure what "what" is, maybe code will confirm this too.
AMetaDataEvent :: struct {
what: i32,
sensor: i32,