Lines Matching defs:input
53 In broad terms, a codec processes input data to generate output data. It processes data
54 asynchronously and uses a set of input and output buffers. At a simplistic level, you request
55 (or receive) an empty input buffer, fill it up with data and send it to the codec for
114 CodecCapabilities#COLOR_FormatSurface} and it can be used with an input or output Surface.</li>
116 CodecCapabilities#COLOR_FormatYUV420Flexible}): These can be used with an input/output Surface,
219 as the first input buffer is dequeued, the codec moves to the Running sub-state, where it spends
220 most of its life. When you queue an input buffer with the {@linkplain #BUFFER_FLAG_END_OF_STREAM
222 codec no longer accepts further input buffers, but still generates output buffers until the
277 Since {@link android.os.Build.VERSION_CODES#LOLLIPOP}, you can query the resulting input and
281 If you want to process raw input video buffers natively with a video consumer – a codec
282 that processes raw video input, such as a video encoder – create a destination Surface for
283 your input data using {@link #createInputSurface} after configuration. Alternately, set up the
284 codec to use a previously created {@linkplain #createPersistentInputSurface persistent input
382 Each codec maintains a set of input and output buffers that are referred to by a buffer-ID in
383 API calls. After a successful call to {@link #start} the client "owns" neither input nor output
385 #dequeueOutputBuffer OutputBuffer(…)} to obtain (get ownership of) an input or output
390 Upon obtaining an input buffer, fill it with data and submit it to the codec using {@link
392 queueSecureInputBuffer} if using decryption. Do not submit multiple input buffers with the same
402 input and/or output buffers may stall the codec, and this behavior is device dependent.
440 #flush} to transition the codec to the Running sub-state and start receiving input buffers.
442 sub-state and start passing available input buffers via the callback.
493 Since {@link android.os.Build.VERSION_CODES#LOLLIPOP}, you should retrieve input and output
539 In versions {@link android.os.Build.VERSION_CODES#KITKAT_WATCH} and before, the set of input and
544 between the size of the arrays and the number of input and output buffers used by the system,
576 When you reach the end of the input data, you must signal it to the codec by specifying the
578 queueInputBuffer}. You can do this on the last valid input buffer, or by submitting an additional
579 empty input buffer with the end-of-stream flag set. If using an empty buffer, the timestamp will
588 Do not submit additional input buffers after signaling the end of the input stream, unless the
646 When using an input Surface, there are no accessible input buffers, as buffers are automatically
647 passed from the input surface to the codec. Calling {@link #dequeueInputBuffer
651 Call {@link #signalEndOfInputStream} to signal end-of-stream. The input surface will stop
667 It is important that the input data after {@link #start} or {@link #flush} starts at a suitable
708 before you call {@code flush}. It is important that the input data after a flush starts at a
724 seek) it is <em>not necessary</em> to flush the decoder; however, input data after the
730 any start codes), and submit it as a <strong>regular</strong> input buffer.
803 <tr><td>⎋</td><td>Restricted to surface input mode</td></tr>
805 <tr><td>▧</td><td>Restricted to ByteBuffer input mode</td></tr>
1511 * with the corresponding input buffer. This should be ignored for
1523 * <p>The last output buffer corresponding to the input buffer
1693 * Instantiate the preferred decoder supporting input data of the given mime type.
1716 * @param type The mime type of the input data.
1828 * @param format The format of the input data (decoder) or the desired
1909 * Create a persistent input surface that can be used with codecs that normally have an input
1910 * surface, such as video encoders. A persistent input can be reused by subsequent
1916 * @return an input surface that can be used with {@link #setInputSurface}.
1937 * Configures the codec (e.g. encoder) to use a persistent input surface in place of input
1940 * @param surface a persistent input surface created by {@link #createPersistentInputSurface}
1941 * @throws IllegalStateException if not in the Configured state or does not require an input
1965 * Requests a Surface to use as the input to an encoder, in place of input buffers. This
1983 * and it has just been flushed, to resume requesting input buffers.
1993 cacheBuffers(true /* input */);
1994 cacheBuffers(false /* input */);
2024 * Flush both input and output ports of the component.
2034 * will not request input buffers until this has happened.
2041 * automatically if it is configured with an input surface. Otherwise, it
2139 * Thrown when a crypto error occurs while queueing a secure input buffer.
2217 * After filling a range of the input buffer at the specified index
2218 * submit it to the component. Once an input buffer is queued to
2241 * To indicate that this is the final piece of input data (or rather that
2242 * no more input data follows unless the decoder is subsequently flushed)
2254 * @param index The index of a client-owned input buffer previously returned
2256 * @param offset The byte offset into the input buffer at which the data starts.
2257 * @param size The number of bytes of valid input data.
2267 * {@link #BUFFER_FLAG_KEY_FRAME} flag for input buffers.
2301 * input sample.
2451 * @param index The index of a client-owned input buffer previously returned
2453 * @param offset The byte offset into the input buffer at which the data starts.
2462 * {@link #BUFFER_FLAG_KEY_FRAME} flag for input buffers.
2496 * Returns the index of an input buffer to be filled with valid data
2499 * for the availability of an input buffer if timeoutUs < 0 or wait up
2573 cacheBuffers(false /* input */);
2684 * Signals end-of-stream on input. Equivalent to submitting an empty buffer with
2686 * encoders receiving input from a Surface created by {@link #createInputSurface}.
2706 return new MediaFormat(getFormatNative(false /* input */));
2711 * get the input format accepted by the codec. Do this to
2721 return new MediaFormat(getFormatNative(true /* input */));
2727 * @param index The index of a client-owned input buffer previously
2739 private native final Map<String, Object> getFormatNative(boolean input);
2899 private final void cacheBuffers(boolean input) {
2902 buffers = getBuffers(input);
2907 if (input) {
2915 * Retrieve the set of input buffers. Call this after start()
2921 * each time an input buffer is dequeued.
2923 * <b>Note:</b> As of API 21, dequeued input buffers are
2926 * <em>Do not use this method if using an input surface.</em>
2974 * object for a dequeued input buffer index to contain the input data.
2977 * previously returned for the same input index MUST no longer
2980 * @param index The index of a client-owned input buffer previously
2984 * @return the input buffer, or null if the index is not a dequeued
2985 * input buffer, or if the codec is configured for surface input.
2992 ByteBuffer newBuffer = getBuffer(true /* input */, index);
3001 * Returns a writable Image object for a dequeued input buffer
3002 * index to contain the raw input video frame.
3005 * previously returned for the same input index MUST no longer
3008 * @param index The index of a client-owned input buffer previously
3012 * @return the input image, or null if the index is not a
3013 * dequeued input buffer, or not a ByteBuffer that contains a
3021 Image newImage = getImage(true /* input */, index);
3050 ByteBuffer newBuffer = getBuffer(false /* input */, index);
3078 Image newImage = getImage(false /* input */, index);
3143 * Temporarily suspend/resume encoding of input data. While suspended
3144 * input data is effectively discarded instead of being fed into the
3146 * in "surface-input" mode, as the client code has no control over the
3147 * input-side of the encoder in that case.
3151 public static final String PARAMETER_KEY_SUSPEND = "drop-input-frames";
3195 * {@code flush}, you must call {@link #start} to "resume" receiving input buffers,
3196 * even if an input surface was created.
3332 * Called when an input buffer becomes available.
3335 * @param index The index of the available input buffer.
3397 private native final ByteBuffer[] getBuffers(boolean input);
3400 private native final ByteBuffer getBuffer(boolean input, int index);
3403 private native final Image getImage(boolean input, int index);