2 * Copyright (C) 2011 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #ifndef SYSTEM_CORE_INCLUDE_ANDROID_WINDOW_H
18 #define SYSTEM_CORE_INCLUDE_ANDROID_WINDOW_H
20 #include <cutils/native_handle.h>
25 #include <sync/sync.h>
26 #include <sys/cdefs.h>
27 #include <system/graphics.h>
36 /*****************************************************************************/
38 #define ANDROID_NATIVE_MAKE_CONSTANT(a,b,c,d) \
39 (((unsigned)(a)<<24)|((unsigned)(b)<<16)|((unsigned)(c)<<8)|(unsigned)(d))
41 #define ANDROID_NATIVE_WINDOW_MAGIC \
42 ANDROID_NATIVE_MAKE_CONSTANT('_','w','n','d')
44 #define ANDROID_NATIVE_BUFFER_MAGIC \
45 ANDROID_NATIVE_MAKE_CONSTANT('_','b','f','r')
47 // ---------------------------------------------------------------------------
49 // This #define may be used to conditionally compile device-specific code to
50 // support either the prior ANativeWindow interface, which did not pass libsync
51 // fences around, or the new interface that does. This #define is only present
52 // when the ANativeWindow interface does include libsync support.
53 #define ANDROID_NATIVE_WINDOW_HAS_SYNC 1
55 // ---------------------------------------------------------------------------
57 typedef const native_handle_t
* buffer_handle_t
;
59 // ---------------------------------------------------------------------------
61 typedef struct android_native_rect_t
67 } android_native_rect_t
;
69 // ---------------------------------------------------------------------------
71 typedef struct android_native_base_t
73 /* a magic value defined by the actual EGL native type */
76 /* the sizeof() of the actual EGL native type */
81 /* reference-counting interface */
82 void (*incRef
)(struct android_native_base_t
* base
);
83 void (*decRef
)(struct android_native_base_t
* base
);
84 } android_native_base_t
;
86 typedef struct ANativeWindowBuffer
89 ANativeWindowBuffer() {
90 common
.magic
= ANDROID_NATIVE_BUFFER_MAGIC
;
91 common
.version
= sizeof(ANativeWindowBuffer
);
92 memset(common
.reserved
, 0, sizeof(common
.reserved
));
95 // Implement the methods that sp<ANativeWindowBuffer> expects so that it
96 // can be used to automatically refcount ANativeWindowBuffer's.
97 void incStrong(const void* id
) const {
98 common
.incRef(const_cast<android_native_base_t
*>(&common
));
100 void decStrong(const void* id
) const {
101 common
.decRef(const_cast<android_native_base_t
*>(&common
));
105 struct android_native_base_t common
;
115 buffer_handle_t handle
;
117 void* reserved_proc
[8];
118 } ANativeWindowBuffer_t
;
120 // Old typedef for backwards compatibility.
121 typedef ANativeWindowBuffer_t android_native_buffer_t
;
123 // ---------------------------------------------------------------------------
125 /* attributes queriable with query() */
127 NATIVE_WINDOW_WIDTH
= 0,
128 NATIVE_WINDOW_HEIGHT
= 1,
129 NATIVE_WINDOW_FORMAT
= 2,
131 /* The minimum number of buffers that must remain un-dequeued after a buffer
132 * has been queued. This value applies only if set_buffer_count was used to
133 * override the number of buffers and if a buffer has since been queued.
134 * Users of the set_buffer_count ANativeWindow method should query this
135 * value before calling set_buffer_count. If it is necessary to have N
136 * buffers simultaneously dequeued as part of the steady-state operation,
137 * and this query returns M then N+M buffers should be requested via
138 * native_window_set_buffer_count.
140 * Note that this value does NOT apply until a single buffer has been
141 * queued. In particular this means that it is possible to:
143 * 1. Query M = min undequeued buffers
144 * 2. Set the buffer count to N + M
145 * 3. Dequeue all N + M buffers
146 * 4. Cancel M buffers
147 * 5. Queue, dequeue, queue, dequeue, ad infinitum
149 NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS
= 3,
151 /* Check whether queueBuffer operations on the ANativeWindow send the buffer
152 * to the window compositor. The query sets the returned 'value' argument
153 * to 1 if the ANativeWindow DOES send queued buffers directly to the window
154 * compositor and 0 if the buffers do not go directly to the window
157 * This can be used to determine whether protected buffer content should be
158 * sent to the ANativeWindow. Note, however, that a result of 1 does NOT
159 * indicate that queued buffers will be protected from applications or users
160 * capturing their contents. If that behavior is desired then some other
161 * mechanism (e.g. the GRALLOC_USAGE_PROTECTED flag) should be used in
162 * conjunction with this query.
164 NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER
= 4,
166 /* Get the concrete type of a ANativeWindow. See below for the list of
167 * possible return values.
169 * This query should not be used outside the Android framework and will
170 * likely be removed in the near future.
172 NATIVE_WINDOW_CONCRETE_TYPE
= 5,
176 * Default width and height of ANativeWindow buffers, these are the
177 * dimensions of the window buffers irrespective of the
178 * NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS call and match the native window
179 * size unless overridden by NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS.
181 NATIVE_WINDOW_DEFAULT_WIDTH
= 6,
182 NATIVE_WINDOW_DEFAULT_HEIGHT
= 7,
185 * transformation that will most-likely be applied to buffers. This is only
186 * a hint, the actual transformation applied might be different.
190 * The transform hint can be used by a producer, for instance the GLES
191 * driver, to pre-rotate the rendering such that the final transformation
192 * in the composer is identity. This can be very useful when used in
193 * conjunction with the h/w composer HAL, in situations where it
194 * cannot handle arbitrary rotations.
196 * 1. Before dequeuing a buffer, the GL driver (or any other ANW client)
197 * queries the ANW for NATIVE_WINDOW_TRANSFORM_HINT.
199 * 2. The GL driver overrides the width and height of the ANW to
200 * account for NATIVE_WINDOW_TRANSFORM_HINT. This is done by querying
201 * NATIVE_WINDOW_DEFAULT_{WIDTH | HEIGHT}, swapping the dimensions
202 * according to NATIVE_WINDOW_TRANSFORM_HINT and calling
203 * native_window_set_buffers_dimensions().
205 * 3. The GL driver dequeues a buffer of the new pre-rotated size.
207 * 4. The GL driver renders to the buffer such that the image is
208 * already transformed, that is applying NATIVE_WINDOW_TRANSFORM_HINT
211 * 5. The GL driver calls native_window_set_transform to apply
212 * inverse transformation to the buffer it just rendered.
213 * In order to do this, the GL driver needs
214 * to calculate the inverse of NATIVE_WINDOW_TRANSFORM_HINT, this is
217 * int hintTransform, inverseTransform;
218 * query(..., NATIVE_WINDOW_TRANSFORM_HINT, &hintTransform);
219 * inverseTransform = hintTransform;
220 * if (hintTransform & HAL_TRANSFORM_ROT_90)
221 * inverseTransform ^= HAL_TRANSFORM_ROT_180;
224 * 6. The GL driver queues the pre-transformed buffer.
226 * 7. The composer combines the buffer transform with the display
227 * transform. If the buffer transform happens to cancel out the
228 * display transform then no rotation is needed.
231 NATIVE_WINDOW_TRANSFORM_HINT
= 8,
234 * Boolean that indicates whether the consumer is running more than
235 * one buffer behind the producer.
237 NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND
= 9
240 /* Valid operations for the (*perform)() hook.
242 * Values marked as 'deprecated' are supported, but have been superceded by
243 * other functionality.
245 * Values marked as 'private' should be considered private to the framework.
246 * HAL implementation code with access to an ANativeWindow should not use these,
247 * as it may not interact properly with the framework's use of the
251 NATIVE_WINDOW_SET_USAGE
= 0,
252 NATIVE_WINDOW_CONNECT
= 1, /* deprecated */
253 NATIVE_WINDOW_DISCONNECT
= 2, /* deprecated */
254 NATIVE_WINDOW_SET_CROP
= 3, /* private */
255 NATIVE_WINDOW_SET_BUFFER_COUNT
= 4,
256 NATIVE_WINDOW_SET_BUFFERS_GEOMETRY
= 5, /* deprecated */
257 NATIVE_WINDOW_SET_BUFFERS_TRANSFORM
= 6,
258 NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP
= 7,
259 NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS
= 8,
260 NATIVE_WINDOW_SET_BUFFERS_FORMAT
= 9,
261 NATIVE_WINDOW_SET_SCALING_MODE
= 10, /* private */
262 NATIVE_WINDOW_LOCK
= 11, /* private */
263 NATIVE_WINDOW_UNLOCK_AND_POST
= 12, /* private */
264 NATIVE_WINDOW_API_CONNECT
= 13, /* private */
265 NATIVE_WINDOW_API_DISCONNECT
= 14, /* private */
266 NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS
= 15, /* private */
267 NATIVE_WINDOW_SET_POST_TRANSFORM_CROP
= 16, /* private */
268 NATIVE_WINDOW_SET_BUFFERS_SIZE
= 17, /* private */
270 NATIVE_WINDOW_UPDATE_BUFFERS_GEOMETRY
= 18, /* private */
274 /* parameter for NATIVE_WINDOW_[API_][DIS]CONNECT */
276 /* Buffers will be queued by EGL via eglSwapBuffers after being filled using
279 NATIVE_WINDOW_API_EGL
= 1,
281 /* Buffers will be queued after being filled using the CPU
283 NATIVE_WINDOW_API_CPU
= 2,
285 /* Buffers will be queued by Stagefright after being filled by a video
286 * decoder. The video decoder can either be a software or hardware decoder.
288 NATIVE_WINDOW_API_MEDIA
= 3,
290 /* Buffers will be queued by the the camera HAL.
292 NATIVE_WINDOW_API_CAMERA
= 4,
295 /* parameter for NATIVE_WINDOW_SET_BUFFERS_TRANSFORM */
297 /* flip source image horizontally */
298 NATIVE_WINDOW_TRANSFORM_FLIP_H
= HAL_TRANSFORM_FLIP_H
,
299 /* flip source image vertically */
300 NATIVE_WINDOW_TRANSFORM_FLIP_V
= HAL_TRANSFORM_FLIP_V
,
301 /* rotate source image 90 degrees clock-wise */
302 NATIVE_WINDOW_TRANSFORM_ROT_90
= HAL_TRANSFORM_ROT_90
,
303 /* rotate source image 180 degrees */
304 NATIVE_WINDOW_TRANSFORM_ROT_180
= HAL_TRANSFORM_ROT_180
,
305 /* rotate source image 270 degrees clock-wise */
306 NATIVE_WINDOW_TRANSFORM_ROT_270
= HAL_TRANSFORM_ROT_270
,
309 /* parameter for NATIVE_WINDOW_SET_SCALING_MODE */
311 /* the window content is not updated (frozen) until a buffer of
312 * the window size is received (enqueued)
314 NATIVE_WINDOW_SCALING_MODE_FREEZE
= 0,
315 /* the buffer is scaled in both dimensions to match the window size */
316 NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW
= 1,
317 /* the buffer is scaled uniformly such that the smaller dimension
318 * of the buffer matches the window size (cropping in the process)
320 NATIVE_WINDOW_SCALING_MODE_SCALE_CROP
= 2,
321 /* the window is clipped to the size of the buffer's crop rectangle; pixels
322 * outside the crop rectangle are treated as if they are completely
325 NATIVE_WINDOW_SCALING_MODE_NO_SCALE_CROP
= 3,
328 /* values returned by the NATIVE_WINDOW_CONCRETE_TYPE query */
330 NATIVE_WINDOW_FRAMEBUFFER
= 0, /* FramebufferNativeWindow */
331 NATIVE_WINDOW_SURFACE
= 1, /* Surface */
332 NATIVE_WINDOW_SURFACE_TEXTURE_CLIENT
= 2, /* SurfaceTextureClient */
335 /* parameter for NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP
337 * Special timestamp value to indicate that timestamps should be auto-generated
338 * by the native window when queueBuffer is called. This is equal to INT64_MIN,
339 * defined directly to avoid problems with C99/C++ inclusion of stdint.h.
341 static const int64_t NATIVE_WINDOW_TIMESTAMP_AUTO
= (-9223372036854775807LL-1);
347 : flags(0), minSwapInterval(0), maxSwapInterval(0), xdpi(0), ydpi(0)
349 common
.magic
= ANDROID_NATIVE_WINDOW_MAGIC
;
350 common
.version
= sizeof(ANativeWindow
);
351 memset(common
.reserved
, 0, sizeof(common
.reserved
));
354 /* Implement the methods that sp<ANativeWindow> expects so that it
355 can be used to automatically refcount ANativeWindow's. */
356 void incStrong(const void* id
) const {
357 common
.incRef(const_cast<android_native_base_t
*>(&common
));
359 void decStrong(const void* id
) const {
360 common
.decRef(const_cast<android_native_base_t
*>(&common
));
364 struct android_native_base_t common
;
366 /* flags describing some attributes of this surface or its updater */
367 const uint32_t flags
;
369 /* min swap interval supported by this updated */
370 const int minSwapInterval
;
372 /* max swap interval supported by this updated */
373 const int maxSwapInterval
;
375 /* horizontal and vertical resolution in DPI */
379 /* Some storage reserved for the OEM's driver. */
383 * Set the swap interval for this surface.
385 * Returns 0 on success or -errno on error.
387 int (*setSwapInterval
)(struct ANativeWindow
* window
,
391 * Hook called by EGL to acquire a buffer. After this call, the buffer
392 * is not locked, so its content cannot be modified. This call may block if
393 * no buffers are available.
395 * The window holds a reference to the buffer between dequeueBuffer and
396 * either queueBuffer or cancelBuffer, so clients only need their own
397 * reference if they might use the buffer after queueing or canceling it.
398 * Holding a reference to a buffer after queueing or canceling it is only
399 * allowed if a specific buffer count has been set.
401 * Returns 0 on success or -errno on error.
403 * XXX: This function is deprecated. It will continue to work for some
404 * time for binary compatibility, but the new dequeueBuffer function that
405 * outputs a fence file descriptor should be used in its place.
407 int (*dequeueBuffer_DEPRECATED
)(struct ANativeWindow
* window
,
408 struct ANativeWindowBuffer
** buffer
);
411 * hook called by EGL to lock a buffer. This MUST be called before modifying
412 * the content of a buffer. The buffer must have been acquired with
413 * dequeueBuffer first.
415 * Returns 0 on success or -errno on error.
417 * XXX: This function is deprecated. It will continue to work for some
418 * time for binary compatibility, but it is essentially a no-op, and calls
419 * to it should be removed.
421 int (*lockBuffer_DEPRECATED
)(struct ANativeWindow
* window
,
422 struct ANativeWindowBuffer
* buffer
);
425 * Hook called by EGL when modifications to the render buffer are done.
426 * This unlocks and post the buffer.
428 * The window holds a reference to the buffer between dequeueBuffer and
429 * either queueBuffer or cancelBuffer, so clients only need their own
430 * reference if they might use the buffer after queueing or canceling it.
431 * Holding a reference to a buffer after queueing or canceling it is only
432 * allowed if a specific buffer count has been set.
434 * Buffers MUST be queued in the same order than they were dequeued.
436 * Returns 0 on success or -errno on error.
438 * XXX: This function is deprecated. It will continue to work for some
439 * time for binary compatibility, but the new queueBuffer function that
440 * takes a fence file descriptor should be used in its place (pass a value
441 * of -1 for the fence file descriptor if there is no valid one to pass).
443 int (*queueBuffer_DEPRECATED
)(struct ANativeWindow
* window
,
444 struct ANativeWindowBuffer
* buffer
);
447 * hook used to retrieve information about the native window.
449 * Returns 0 on success or -errno on error.
451 int (*query
)(const struct ANativeWindow
* window
,
452 int what
, int* value
);
455 * hook used to perform various operations on the surface.
456 * (*perform)() is a generic mechanism to add functionality to
457 * ANativeWindow while keeping backward binary compatibility.
459 * DO NOT CALL THIS HOOK DIRECTLY. Instead, use the helper functions
462 * (*perform)() returns -ENOENT if the 'what' parameter is not supported
463 * by the surface's implementation.
465 * The valid operations are:
466 * NATIVE_WINDOW_SET_USAGE
467 * NATIVE_WINDOW_CONNECT (deprecated)
468 * NATIVE_WINDOW_DISCONNECT (deprecated)
469 * NATIVE_WINDOW_SET_CROP (private)
470 * NATIVE_WINDOW_SET_BUFFER_COUNT
471 * NATIVE_WINDOW_SET_BUFFERS_GEOMETRY (deprecated)
472 * NATIVE_WINDOW_SET_BUFFERS_TRANSFORM
473 * NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP
474 * NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS
475 * NATIVE_WINDOW_SET_BUFFERS_FORMAT
476 * NATIVE_WINDOW_SET_SCALING_MODE (private)
477 * NATIVE_WINDOW_LOCK (private)
478 * NATIVE_WINDOW_UNLOCK_AND_POST (private)
479 * NATIVE_WINDOW_API_CONNECT (private)
480 * NATIVE_WINDOW_API_DISCONNECT (private)
481 * NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS (private)
482 * NATIVE_WINDOW_SET_POST_TRANSFORM_CROP (private)
486 int (*perform
)(struct ANativeWindow
* window
,
487 int operation
, ... );
490 * Hook used to cancel a buffer that has been dequeued.
491 * No synchronization is performed between dequeue() and cancel(), so
492 * either external synchronization is needed, or these functions must be
493 * called from the same thread.
495 * The window holds a reference to the buffer between dequeueBuffer and
496 * either queueBuffer or cancelBuffer, so clients only need their own
497 * reference if they might use the buffer after queueing or canceling it.
498 * Holding a reference to a buffer after queueing or canceling it is only
499 * allowed if a specific buffer count has been set.
501 * XXX: This function is deprecated. It will continue to work for some
502 * time for binary compatibility, but the new cancelBuffer function that
503 * takes a fence file descriptor should be used in its place (pass a value
504 * of -1 for the fence file descriptor if there is no valid one to pass).
506 int (*cancelBuffer_DEPRECATED
)(struct ANativeWindow
* window
,
507 struct ANativeWindowBuffer
* buffer
);
510 * Hook called by EGL to acquire a buffer. This call may block if no
511 * buffers are available.
513 * The window holds a reference to the buffer between dequeueBuffer and
514 * either queueBuffer or cancelBuffer, so clients only need their own
515 * reference if they might use the buffer after queueing or canceling it.
516 * Holding a reference to a buffer after queueing or canceling it is only
517 * allowed if a specific buffer count has been set.
519 * The libsync fence file descriptor returned in the int pointed to by the
520 * fenceFd argument will refer to the fence that must signal before the
521 * dequeued buffer may be written to. A value of -1 indicates that the
522 * caller may access the buffer immediately without waiting on a fence. If
523 * a valid file descriptor is returned (i.e. any value except -1) then the
524 * caller is responsible for closing the file descriptor.
526 * Returns 0 on success or -errno on error.
528 int (*dequeueBuffer
)(struct ANativeWindow
* window
,
529 struct ANativeWindowBuffer
** buffer
, int* fenceFd
);
532 * Hook called by EGL when modifications to the render buffer are done.
533 * This unlocks and post the buffer.
535 * The window holds a reference to the buffer between dequeueBuffer and
536 * either queueBuffer or cancelBuffer, so clients only need their own
537 * reference if they might use the buffer after queueing or canceling it.
538 * Holding a reference to a buffer after queueing or canceling it is only
539 * allowed if a specific buffer count has been set.
541 * The fenceFd argument specifies a libsync fence file descriptor for a
542 * fence that must signal before the buffer can be accessed. If the buffer
543 * can be accessed immediately then a value of -1 should be used. The
544 * caller must not use the file descriptor after it is passed to
545 * queueBuffer, and the ANativeWindow implementation is responsible for
548 * Returns 0 on success or -errno on error.
550 int (*queueBuffer
)(struct ANativeWindow
* window
,
551 struct ANativeWindowBuffer
* buffer
, int fenceFd
);
554 * Hook used to cancel a buffer that has been dequeued.
555 * No synchronization is performed between dequeue() and cancel(), so
556 * either external synchronization is needed, or these functions must be
557 * called from the same thread.
559 * The window holds a reference to the buffer between dequeueBuffer and
560 * either queueBuffer or cancelBuffer, so clients only need their own
561 * reference if they might use the buffer after queueing or canceling it.
562 * Holding a reference to a buffer after queueing or canceling it is only
563 * allowed if a specific buffer count has been set.
565 * The fenceFd argument specifies a libsync fence file decsriptor for a
566 * fence that must signal before the buffer can be accessed. If the buffer
567 * can be accessed immediately then a value of -1 should be used.
569 * Note that if the client has not waited on the fence that was returned
570 * from dequeueBuffer, that same fence should be passed to cancelBuffer to
571 * ensure that future uses of the buffer are preceded by a wait on that
572 * fence. The caller must not use the file descriptor after it is passed
573 * to cancelBuffer, and the ANativeWindow implementation is responsible for
576 * Returns 0 on success or -errno on error.
578 int (*cancelBuffer
)(struct ANativeWindow
* window
,
579 struct ANativeWindowBuffer
* buffer
, int fenceFd
);
582 /* Backwards compatibility: use ANativeWindow (struct ANativeWindow in C).
583 * android_native_window_t is deprecated.
585 typedef struct ANativeWindow ANativeWindow
;
586 typedef struct ANativeWindow android_native_window_t
;
589 * native_window_set_usage(..., usage)
590 * Sets the intended usage flags for the next buffers
591 * acquired with (*lockBuffer)() and on.
592 * By default (if this function is never called), a usage of
593 * GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE
595 * Calling this function will usually cause following buffers to be
599 static inline int native_window_set_usage(
600 struct ANativeWindow
* window
, int usage
)
602 return window
->perform(window
, NATIVE_WINDOW_SET_USAGE
, usage
);
605 /* deprecated. Always returns 0. Don't call. */
606 static inline int native_window_connect(
607 struct ANativeWindow
* window
, int api
) {
611 /* deprecated. Always returns 0. Don't call. */
612 static inline int native_window_disconnect(
613 struct ANativeWindow
* window
, int api
) {
618 * native_window_set_crop(..., crop)
619 * Sets which region of the next queued buffers needs to be considered.
620 * Depending on the scaling mode, a buffer's crop region is scaled and/or
621 * cropped to match the surface's size. This function sets the crop in
622 * pre-transformed buffer pixel coordinates.
624 * The specified crop region applies to all buffers queued after it is called.
626 * If 'crop' is NULL, subsequently queued buffers won't be cropped.
628 * An error is returned if for instance the crop region is invalid, out of the
629 * buffer's bound or if the window is invalid.
631 static inline int native_window_set_crop(
632 struct ANativeWindow
* window
,
633 android_native_rect_t
const * crop
)
635 return window
->perform(window
, NATIVE_WINDOW_SET_CROP
, crop
);
639 * native_window_set_post_transform_crop(..., crop)
640 * Sets which region of the next queued buffers needs to be considered.
641 * Depending on the scaling mode, a buffer's crop region is scaled and/or
642 * cropped to match the surface's size. This function sets the crop in
643 * post-transformed pixel coordinates.
645 * The specified crop region applies to all buffers queued after it is called.
647 * If 'crop' is NULL, subsequently queued buffers won't be cropped.
649 * An error is returned if for instance the crop region is invalid, out of the
650 * buffer's bound or if the window is invalid.
652 static inline int native_window_set_post_transform_crop(
653 struct ANativeWindow
* window
,
654 android_native_rect_t
const * crop
)
656 return window
->perform(window
, NATIVE_WINDOW_SET_POST_TRANSFORM_CROP
, crop
);
660 * native_window_set_active_rect(..., active_rect)
662 * This function is deprecated and will be removed soon. For now it simply
663 * sets the post-transform crop for compatibility while multi-project commits
666 static inline int native_window_set_active_rect(
667 struct ANativeWindow
* window
,
668 android_native_rect_t
const * active_rect
)
670 return native_window_set_post_transform_crop(window
, active_rect
);
674 * native_window_set_buffer_count(..., count)
675 * Sets the number of buffers associated with this native window.
677 static inline int native_window_set_buffer_count(
678 struct ANativeWindow
* window
,
681 return window
->perform(window
, NATIVE_WINDOW_SET_BUFFER_COUNT
, bufferCount
);
685 * native_window_set_buffers_geometry(..., int w, int h, int format)
686 * All buffers dequeued after this call will have the dimensions and format
687 * specified. A successful call to this function has the same effect as calling
688 * native_window_set_buffers_size and native_window_set_buffers_format.
690 * XXX: This function is deprecated. The native_window_set_buffers_dimensions
691 * and native_window_set_buffers_format functions should be used instead.
693 static inline int native_window_set_buffers_geometry(
694 struct ANativeWindow
* window
,
695 int w
, int h
, int format
)
697 return window
->perform(window
, NATIVE_WINDOW_SET_BUFFERS_GEOMETRY
,
702 * native_window_set_buffers_dimensions(..., int w, int h)
703 * All buffers dequeued after this call will have the dimensions specified.
704 * In particular, all buffers will have a fixed-size, independent from the
705 * native-window size. They will be scaled according to the scaling mode
706 * (see native_window_set_scaling_mode) upon window composition.
708 * If w and h are 0, the normal behavior is restored. That is, dequeued buffers
709 * following this call will be sized to match the window's size.
711 * Calling this function will reset the window crop to a NULL value, which
712 * disables cropping of the buffers.
714 static inline int native_window_set_buffers_dimensions(
715 struct ANativeWindow
* window
,
718 return window
->perform(window
, NATIVE_WINDOW_SET_BUFFERS_DIMENSIONS
,
723 * native_window_set_buffers_user_dimensions(..., int w, int h)
725 * Sets the user buffer size for the window, which overrides the
726 * window's size. All buffers dequeued after this call will have the
727 * dimensions specified unless overridden by
728 * native_window_set_buffers_dimensions. All buffers will have a
729 * fixed-size, independent from the native-window size. They will be
730 * scaled according to the scaling mode (see
731 * native_window_set_scaling_mode) upon window composition.
733 * If w and h are 0, the normal behavior is restored. That is, the
734 * default buffer size will match the windows's size.
736 * Calling this function will reset the window crop to a NULL value, which
737 * disables cropping of the buffers.
739 static inline int native_window_set_buffers_user_dimensions(
740 struct ANativeWindow
* window
,
743 return window
->perform(window
, NATIVE_WINDOW_SET_BUFFERS_USER_DIMENSIONS
,
748 * native_window_set_buffers_format(..., int format)
749 * All buffers dequeued after this call will have the format specified.
751 * If the specified format is 0, the default buffer format will be used.
753 static inline int native_window_set_buffers_format(
754 struct ANativeWindow
* window
,
757 return window
->perform(window
, NATIVE_WINDOW_SET_BUFFERS_FORMAT
, format
);
761 * native_window_set_buffers_transform(..., int transform)
762 * All buffers queued after this call will be displayed transformed according
763 * to the transform parameter specified.
765 static inline int native_window_set_buffers_transform(
766 struct ANativeWindow
* window
,
769 return window
->perform(window
, NATIVE_WINDOW_SET_BUFFERS_TRANSFORM
,
774 * native_window_set_buffers_timestamp(..., int64_t timestamp)
775 * All buffers queued after this call will be associated with the timestamp
776 * parameter specified. If the timestamp is set to NATIVE_WINDOW_TIMESTAMP_AUTO
777 * (the default), timestamps will be generated automatically when queueBuffer is
778 * called. The timestamp is measured in nanoseconds, and is normally monotonically
779 * increasing. The timestamp should be unaffected by time-of-day adjustments,
780 * and for a camera should be strictly monotonic but for a media player may be
781 * reset when the position is set.
783 static inline int native_window_set_buffers_timestamp(
784 struct ANativeWindow
* window
,
787 return window
->perform(window
, NATIVE_WINDOW_SET_BUFFERS_TIMESTAMP
,
792 * native_window_set_scaling_mode(..., int mode)
793 * All buffers queued after this call will be associated with the scaling mode
796 static inline int native_window_set_scaling_mode(
797 struct ANativeWindow
* window
,
800 return window
->perform(window
, NATIVE_WINDOW_SET_SCALING_MODE
,
805 * native_window_api_connect(..., int api)
806 * connects an API to this window. only one API can be connected at a time.
807 * Returns -EINVAL if for some reason the window cannot be connected, which
808 * can happen if it's connected to some other API.
810 static inline int native_window_api_connect(
811 struct ANativeWindow
* window
, int api
)
813 return window
->perform(window
, NATIVE_WINDOW_API_CONNECT
, api
);
817 * native_window_api_disconnect(..., int api)
818 * disconnect the API from this window.
819 * An error is returned if for instance the window wasn't connected in the
822 static inline int native_window_api_disconnect(
823 struct ANativeWindow
* window
, int api
)
825 return window
->perform(window
, NATIVE_WINDOW_API_DISCONNECT
, api
);
829 * native_window_dequeue_buffer_and_wait(...)
830 * Dequeue a buffer and wait on the fence associated with that buffer. The
831 * buffer may safely be accessed immediately upon this function returning. An
832 * error is returned if either of the dequeue or the wait operations fail.
834 static inline int native_window_dequeue_buffer_and_wait(ANativeWindow
*anw
,
835 struct ANativeWindowBuffer
** anb
) {
836 return anw
->dequeueBuffer_DEPRECATED(anw
, anb
);
842 #endif /* SYSTEM_CORE_INCLUDE_ANDROID_WINDOW_H */