2 * Copyright 2007 by VMware, Inc.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
22 * Except as contained in this notice, the name of the copyright holder(s)
23 * and author(s) shall not be used in advertising or otherwise to promote
24 * the sale, use or other dealings in this Software without prior written
25 * authorization from the copyright holder(s) and author(s).
31 * Xv extension support.
32 * See http://www.xfree86.org/current/DESIGN16.html
40 #include "pipe/p_compiler.h"
42 * We can't incude svga_types.h due to conflicting types for Bool.
44 typedef int64_t int64
;
45 typedef uint64_t uint64
;
47 typedef int32_t int32
;
48 typedef uint32_t uint32
;
50 typedef int16_t int16
;
51 typedef uint16_t uint16
;
54 typedef uint8_t uint8
;
56 #include "svga/include/svga_reg.h"
57 #include "svga/include/svga_escape.h"
58 #include "svga/include/svga_overlay.h"
60 #include "vmw_driver.h"
62 #include <X11/extensions/Xv.h>
65 #include "../../winsys/svga/drm/vmwgfx_drm.h"
67 #define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)
70 * Number of videos that can be played simultaneously
72 #define VMWARE_VID_NUM_PORTS 1
75 * Using a dark shade as the default colorKey
77 #define VMWARE_VIDEO_COLORKEY 0x100701
82 #define VMWARE_VID_MAX_WIDTH 2048
83 #define VMWARE_VID_MAX_HEIGHT 2048
85 #define VMWARE_VID_NUM_ENCODINGS 1
86 static XF86VideoEncodingRec vmwareVideoEncodings
[] =
91 VMWARE_VID_MAX_WIDTH
, VMWARE_VID_MAX_HEIGHT
,
96 #define VMWARE_VID_NUM_FORMATS 2
97 static XF86VideoFormatRec vmwareVideoFormats
[] =
103 #define VMWARE_VID_NUM_IMAGES 3
104 static XF86ImageRec vmwareVideoImages
[] =
111 #define VMWARE_VID_NUM_ATTRIBUTES 2
112 static XF86AttributeRec vmwareVideoAttributes
[] =
115 XvGettable
| XvSettable
,
121 XvGettable
| XvSettable
,
124 "XV_AUTOPAINT_COLORKEY"
129 * Video frames are stored in a circular list of buffers.
130 * Must be power or two, See vmw_video_port_play.
132 #define VMWARE_VID_NUM_BUFFERS 1
135 * Defines the structure used to hold and pass video data to the host
137 struct vmw_video_buffer
143 struct vmw_dma_buffer
*buf
;
148 * Structure representing a single video stream, aka port.
150 * Ports maps one to one to a SVGA stream. Port is just
151 * what Xv calls a SVGA stream.
153 struct vmw_video_port
156 * Function prototype same as XvPutImage.
158 * This is either set to vmw_video_port_init or vmw_video_port_play.
159 * At init this function is set to port_init. In port_init we set it
160 * to port_play and call it, after initializing the struct.
162 int (*play
)(ScrnInfoPtr
, struct vmw_video_port
*,
163 short, short, short, short, short,
164 short, short, short, int, unsigned char*,
165 short, short, RegionPtr
);
167 /* values to go into the SVGAOverlayUnit */
172 /* round robin of buffers */
174 struct vmw_video_buffer bufs
[VMWARE_VID_NUM_BUFFERS
];
176 /* properties that applies to all buffers */
183 Bool isAutoPaintColorkey
;
188 * Structure holding all the infromation for video.
190 struct vmw_video_private
195 struct vmw_video_port port
[VMWARE_VID_NUM_PORTS
];
197 /** Used to store port pointers pointers */
198 DevUnion port_ptr
[VMWARE_VID_NUM_PORTS
];
203 * Callback functions exported to Xv, prefixed with vmw_xv_*.
205 static int vmw_xv_put_image(ScrnInfoPtr pScrn
, short src_x
, short src_y
,
206 short drw_x
, short drw_y
, short src_w
, short src_h
,
207 short drw_w
, short drw_h
, int image
,
208 unsigned char *buf
, short width
, short height
,
209 Bool sync
, RegionPtr clipBoxes
, pointer data
,
211 static void vmw_xv_stop_video(ScrnInfoPtr pScrn
, pointer data
, Bool Cleanup
);
212 static int vmw_xv_query_image_attributes(ScrnInfoPtr pScrn
, int format
,
213 unsigned short *width
,
214 unsigned short *height
, int *pitches
,
216 static int vmw_xv_set_port_attribute(ScrnInfoPtr pScrn
, Atom attribute
,
217 INT32 value
, pointer data
);
218 static int vmw_xv_get_port_attribute(ScrnInfoPtr pScrn
, Atom attribute
,
219 INT32
*value
, pointer data
);
220 static void vmw_xv_query_best_size(ScrnInfoPtr pScrn
, Bool motion
,
221 short vid_w
, short vid_h
, short drw_w
,
222 short drw_h
, unsigned int *p_w
,
223 unsigned int *p_h
, pointer data
);
229 static XF86VideoAdaptorPtr
vmw_video_init_adaptor(ScrnInfoPtr pScrn
, struct vmw_customizer
*vmw
);
231 static int vmw_video_port_init(ScrnInfoPtr pScrn
,
232 struct vmw_video_port
*port
,
233 short src_x
, short src_y
, short drw_x
,
234 short drw_y
, short src_w
, short src_h
,
235 short drw_w
, short drw_h
, int format
,
236 unsigned char *buf
, short width
,
237 short height
, RegionPtr clipBoxes
);
238 static int vmw_video_port_play(ScrnInfoPtr pScrn
, struct vmw_video_port
*port
,
239 short src_x
, short src_y
, short drw_x
,
240 short drw_y
, short src_w
, short src_h
,
241 short drw_w
, short drw_h
, int format
,
242 unsigned char *buf
, short width
,
243 short height
, RegionPtr clipBoxes
);
244 static void vmw_video_port_cleanup(ScrnInfoPtr pScrn
, struct vmw_video_port
*port
);
246 static int vmw_video_buffer_alloc(struct vmw_customizer
*vmw
, int size
,
247 struct vmw_video_buffer
*out
);
248 static int vmw_video_buffer_free(struct vmw_customizer
*vmw
,
249 struct vmw_video_buffer
*out
);
253 *-----------------------------------------------------------------------------
257 * Initializes Xv support.
260 * TRUE on success, FALSE on error.
263 * Xv support is initialized. Memory is allocated for all supported
266 *-----------------------------------------------------------------------------
270 vmw_video_init(struct vmw_customizer
*vmw
)
272 ScrnInfoPtr pScrn
= vmw
->pScrn
;
273 ScreenPtr pScreen
= pScrn
->pScreen
;
274 XF86VideoAdaptorPtr
*overlayAdaptors
, *newAdaptors
= NULL
;
275 XF86VideoAdaptorPtr newAdaptor
= NULL
;
277 unsigned int ntot
, nfree
;
279 debug_printf("%s: enter\n", __func__
);
281 if (vmw_ioctl_num_streams(vmw
, &ntot
, &nfree
) != 0) {
282 debug_printf("No stream ioctl support\n");
287 debug_printf("No free streams\n");
291 numAdaptors
= xf86XVListGenericAdaptors(pScrn
, &overlayAdaptors
);
293 newAdaptor
= vmw_video_init_adaptor(pScrn
, vmw
);
295 debug_printf("Failed to initialize Xv extension\n");
301 overlayAdaptors
= &newAdaptor
;
303 newAdaptors
= xalloc((numAdaptors
+ 1) *
304 sizeof(XF86VideoAdaptorPtr
*));
306 xf86XVFreeVideoAdaptorRec(newAdaptor
);
310 memcpy(newAdaptors
, overlayAdaptors
,
311 numAdaptors
* sizeof(XF86VideoAdaptorPtr
));
312 newAdaptors
[numAdaptors
++] = newAdaptor
;
313 overlayAdaptors
= newAdaptors
;
316 if (!xf86XVScreenInit(pScreen
, overlayAdaptors
, numAdaptors
)) {
317 debug_printf("Failed to initialize Xv extension\n");
318 xf86XVFreeVideoAdaptorRec(newAdaptor
);
326 debug_printf("Initialized VMware Xv extension successfully\n");
333 *-----------------------------------------------------------------------------
343 * vmw->video_priv = NULL
345 *-----------------------------------------------------------------------------
349 vmw_video_close(struct vmw_customizer
*vmw
)
351 ScrnInfoPtr pScrn
= vmw
->pScrn
;
352 struct vmw_video_private
*video
;
355 debug_printf("%s: enter\n", __func__
);
357 video
= vmw
->video_priv
;
361 for (i
= 0; i
< VMWARE_VID_NUM_PORTS
; ++i
) {
362 /* make sure the port is stoped as well */
363 vmw_xv_stop_video(pScrn
, &video
->port
[i
], TRUE
);
364 vmw_ioctl_unref_stream(vmw
, video
->port
[i
].streamId
);
367 /* XXX: I'm sure this function is missing code for turning off Xv */
369 free(vmw
->video_priv
);
370 vmw
->video_priv
= NULL
;
377 *-----------------------------------------------------------------------------
379 * vmw_video_stop_all --
381 * Stop all video streams from playing.
387 * All buffers are freed.
389 *-----------------------------------------------------------------------------
392 void vmw_video_stop_all(struct vmw_customizer
*vmw
)
394 ScrnInfoPtr pScrn
= vmw
->pScrn
;
395 struct vmw_video_private
*video
= vmw
->video_priv
;
398 debug_printf("%s: enter\n", __func__
);
403 for (i
= 0; i
< VMWARE_VID_NUM_PORTS
; ++i
) {
404 vmw_xv_stop_video(pScrn
, &video
->port
[i
], TRUE
);
410 *-----------------------------------------------------------------------------
412 * vmw_video_init_adaptor --
414 * Initializes a XF86VideoAdaptor structure with the capabilities and
415 * functions supported by this video driver.
418 * On success initialized XF86VideoAdaptor struct or NULL on error
423 *-----------------------------------------------------------------------------
426 static XF86VideoAdaptorPtr
427 vmw_video_init_adaptor(ScrnInfoPtr pScrn
, struct vmw_customizer
*vmw
)
429 XF86VideoAdaptorPtr adaptor
;
430 struct vmw_video_private
*video
;
433 debug_printf("%s: enter \n", __func__
);
435 adaptor
= xf86XVAllocateVideoAdaptorRec(pScrn
);
437 debug_printf("Not enough memory\n");
441 video
= xcalloc(1, sizeof(*video
));
443 debug_printf("Not enough memory.\n");
444 xf86XVFreeVideoAdaptorRec(adaptor
);
448 vmw
->video_priv
= video
;
450 adaptor
->type
= XvInputMask
| XvImageMask
| XvWindowMask
;
451 adaptor
->flags
= VIDEO_OVERLAID_IMAGES
| VIDEO_CLIP_TO_VIEWPORT
;
452 adaptor
->name
= "VMware Video Engine";
453 adaptor
->nEncodings
= VMWARE_VID_NUM_ENCODINGS
;
454 adaptor
->pEncodings
= vmwareVideoEncodings
;
455 adaptor
->nFormats
= VMWARE_VID_NUM_FORMATS
;
456 adaptor
->pFormats
= vmwareVideoFormats
;
457 adaptor
->nPorts
= VMWARE_VID_NUM_PORTS
;
458 adaptor
->pPortPrivates
= video
->port_ptr
;
460 for (i
= 0; i
< VMWARE_VID_NUM_PORTS
; ++i
) {
461 vmw_ioctl_claim_stream(vmw
, &video
->port
[i
].streamId
);
462 video
->port
[i
].play
= vmw_video_port_init
;
463 video
->port
[i
].flags
= SVGA_VIDEO_FLAG_COLORKEY
;
464 video
->port
[i
].colorKey
= VMWARE_VIDEO_COLORKEY
;
465 video
->port
[i
].isAutoPaintColorkey
= TRUE
;
466 adaptor
->pPortPrivates
[i
].ptr
= &video
->port
[i
];
469 adaptor
->nAttributes
= VMWARE_VID_NUM_ATTRIBUTES
;
470 adaptor
->pAttributes
= vmwareVideoAttributes
;
472 adaptor
->nImages
= VMWARE_VID_NUM_IMAGES
;
473 adaptor
->pImages
= vmwareVideoImages
;
475 adaptor
->PutVideo
= NULL
;
476 adaptor
->PutStill
= NULL
;
477 adaptor
->GetVideo
= NULL
;
478 adaptor
->GetStill
= NULL
;
479 adaptor
->StopVideo
= vmw_xv_stop_video
;
480 adaptor
->SetPortAttribute
= vmw_xv_set_port_attribute
;
481 adaptor
->GetPortAttribute
= vmw_xv_get_port_attribute
;
482 adaptor
->QueryBestSize
= vmw_xv_query_best_size
;
483 adaptor
->PutImage
= vmw_xv_put_image
;
484 adaptor
->QueryImageAttributes
= vmw_xv_query_image_attributes
;
486 debug_printf("%s: done %p\n", __func__
, adaptor
);
493 *-----------------------------------------------------------------------------
495 * vmw_video_port_init --
497 * Initializes a video stream in response to the first PutImage() on a
498 * video stream. The process goes as follows:
499 * - Figure out characteristics according to format
500 * - Allocate offscreen memory
501 * - Pass on video to Play() functions
504 * Success or XvBadAlloc on failure.
507 * Video stream is initialized and its first frame sent to the host
508 * (done by VideoPlay() function called at the end)
510 *-----------------------------------------------------------------------------
514 vmw_video_port_init(ScrnInfoPtr pScrn
, struct vmw_video_port
*port
,
515 short src_x
, short src_y
, short drw_x
,
516 short drw_y
, short src_w
, short src_h
,
517 short drw_w
, short drw_h
, int format
,
518 unsigned char *buf
, short width
,
519 short height
, RegionPtr clipBoxes
)
521 struct vmw_customizer
*vmw
= vmw_customizer(xorg_customizer(pScrn
));
525 debug_printf("\t%s: id %d, format %d\n", __func__
, port
->streamId
, format
);
529 /* init all the format attributes, used for buffers */
530 port
->size
= vmw_xv_query_image_attributes(pScrn
, format
, &w
, &h
,
531 port
->pitches
, port
->offsets
);
533 if (port
->size
== -1)
536 port
->play
= vmw_video_port_play
;
538 for (i
= 0; i
< VMWARE_VID_NUM_BUFFERS
; ++i
) {
539 ret
= vmw_video_buffer_alloc(vmw
, port
->size
, &port
->bufs
[i
]);
544 /* Free all allocated buffers on failure */
545 if (ret
!= Success
) {
546 for (--i
; i
>= 0; --i
) {
547 vmw_video_buffer_free(vmw
, &port
->bufs
[i
]);
554 REGION_COPY(pScrn
->pScreen
, &port
->clipBoxes
, clipBoxes
);
556 if (port
->isAutoPaintColorkey
)
557 xf86XVFillKeyHelper(pScrn
->pScreen
, port
->colorKey
, clipBoxes
);
559 return port
->play(pScrn
, port
, src_x
, src_y
, drw_x
, drw_y
, src_w
, src_h
,
560 drw_w
, drw_h
, format
, buf
, width
, height
, clipBoxes
);
565 *-----------------------------------------------------------------------------
567 * vmw_video_port_play --
569 * Sends all the attributes associated with the video frame using the
570 * FIFO ESCAPE mechanism to the host.
573 * Always returns Success.
578 *-----------------------------------------------------------------------------
582 vmw_video_port_play(ScrnInfoPtr pScrn
, struct vmw_video_port
*port
,
583 short src_x
, short src_y
, short drw_x
,
584 short drw_y
, short src_w
, short src_h
,
585 short drw_w
, short drw_h
, int format
,
586 unsigned char *buf
, short width
,
587 short height
, RegionPtr clipBoxes
)
589 struct vmw_customizer
*vmw
= vmw_customizer(xorg_customizer(pScrn
));
590 struct drm_vmw_control_stream_arg arg
;
595 debug_printf("\t%s: enter\n", __func__
);
600 /* we don't update the ports size */
601 size
= vmw_xv_query_image_attributes(pScrn
, format
, &w
, &h
,
602 port
->pitches
, port
->offsets
);
604 if (size
> port
->size
) {
605 debug_printf("\t%s: Increase in size of Xv video frame streamId:%d.\n",
606 __func__
, port
->streamId
);
607 vmw_xv_stop_video(pScrn
, port
, TRUE
);
608 return port
->play(pScrn
, port
, src_x
, src_y
, drw_x
, drw_y
, src_w
,
609 src_h
, drw_w
, drw_h
, format
, buf
, width
, height
,
613 memcpy(port
->bufs
[port
->currBuf
].data
, buf
, port
->size
);
615 memset(&arg
, 0, sizeof(arg
));
617 arg
.stream_id
= port
->streamId
;
619 arg
.flags
= port
->flags
;
620 arg
.color_key
= port
->colorKey
;
621 arg
.handle
= port
->bufs
[port
->currBuf
].handle
;
623 arg
.size
= port
->size
;
634 arg
.pitch
[0] = port
->pitches
[0];
635 arg
.pitch
[1] = port
->pitches
[1];
636 arg
.pitch
[2] = port
->pitches
[2];
640 * Update the clipList and paint the colorkey, if required.
642 if (!REGION_EQUAL(pScrn
->pScreen
, &port
->clipBoxes
, clipBoxes
)) {
643 REGION_COPY(pScrn
->pScreen
, &port
->clipBoxes
, clipBoxes
);
644 if (port
->isAutoPaintColorkey
) {
645 xf86XVFillKeyHelper(pScrn
->pScreen
, port
->colorKey
, clipBoxes
);
649 ret
= drmCommandWrite(vmw
->fd
, DRM_VMW_CONTROL_STREAM
, &arg
, sizeof(arg
));
651 vmw_video_port_cleanup(pScrn
, port
);
655 if (++(port
->currBuf
) >= VMWARE_VID_NUM_BUFFERS
)
663 *-----------------------------------------------------------------------------
665 * vmw_video_port_cleanup --
667 * Frees up all resources (if any) taken by a video stream.
675 *-----------------------------------------------------------------------------
679 vmw_video_port_cleanup(ScrnInfoPtr pScrn
, struct vmw_video_port
*port
)
681 struct vmw_customizer
*vmw
= vmw_customizer(xorg_customizer(pScrn
));
682 uint32 id
, colorKey
, flags
;
683 Bool isAutoPaintColorkey
;
686 debug_printf("\t%s: enter\n", __func__
);
688 for (i
= 0; i
< VMWARE_VID_NUM_BUFFERS
; i
++) {
689 vmw_video_buffer_free(vmw
, &port
->bufs
[i
]);
693 * reset stream for next video
696 colorKey
= port
->colorKey
;
698 isAutoPaintColorkey
= port
->isAutoPaintColorkey
;
700 memset(port
, 0, sizeof(*port
));
703 port
->play
= vmw_video_port_init
;
704 port
->colorKey
= colorKey
;
706 port
->isAutoPaintColorkey
= isAutoPaintColorkey
;
711 *-----------------------------------------------------------------------------
713 * vmw_video_buffer_alloc --
715 * Allocates and map a kernel buffer to be used as data storage.
718 * XvBadAlloc on failure, otherwise Success.
721 * Calls into the kernel, sets members of out.
723 *-----------------------------------------------------------------------------
727 vmw_video_buffer_alloc(struct vmw_customizer
*vmw
, int size
,
728 struct vmw_video_buffer
*out
)
730 out
->buf
= vmw_ioctl_buffer_create(vmw
, size
, &out
->handle
);
734 out
->data
= vmw_ioctl_buffer_map(vmw
, out
->buf
);
736 vmw_ioctl_buffer_destroy(vmw
, out
->buf
);
745 out
->extra_data
= xcalloc(1, size
);
747 debug_printf("\t\t%s: allocated buffer %p of size %i\n", __func__
, out
, size
);
754 *-----------------------------------------------------------------------------
756 * vmw_video_buffer_free --
758 * Frees and unmaps an allocated kernel buffer.
764 * Calls into the kernel, sets members of out to 0.
766 *-----------------------------------------------------------------------------
770 vmw_video_buffer_free(struct vmw_customizer
*vmw
,
771 struct vmw_video_buffer
*out
)
776 xfree(out
->extra_data
);
777 vmw_ioctl_buffer_unmap(vmw
, out
->buf
);
778 vmw_ioctl_buffer_destroy(vmw
, out
->buf
);
785 debug_printf("\t\t%s: freed buffer %p\n", __func__
, out
);
792 *-----------------------------------------------------------------------------
794 * vmw_xv_put_image --
796 * Main video playback function. It copies the passed data which is in
797 * the specified format (e.g. FOURCC_YV12) into the overlay.
799 * If sync is TRUE the driver should not return from this
800 * function until it is through reading the data from buf.
803 * Success or XvBadAlloc on failure
806 * Video port will be played(initialized if 1st frame) on success
807 * or will fail on error.
809 *-----------------------------------------------------------------------------
813 vmw_xv_put_image(ScrnInfoPtr pScrn
, short src_x
, short src_y
,
814 short drw_x
, short drw_y
, short src_w
, short src_h
,
815 short drw_w
, short drw_h
, int format
,
816 unsigned char *buf
, short width
, short height
,
817 Bool sync
, RegionPtr clipBoxes
, pointer data
,
820 struct vmw_customizer
*vmw
= vmw_customizer(xorg_customizer(pScrn
));
821 struct vmw_video_port
*port
= data
;
823 debug_printf("%s: enter (%u, %u) (%ux%u) (%u, %u) (%ux%u) (%ux%u)\n", __func__
,
824 src_x
, src_y
, src_w
, src_h
,
825 drw_x
, drw_y
, drw_w
, drw_h
,
828 if (!vmw
->video_priv
)
831 return port
->play(pScrn
, port
, src_x
, src_y
, drw_x
, drw_y
, src_w
, src_h
,
832 drw_w
, drw_h
, format
, buf
, width
, height
, clipBoxes
);
837 *-----------------------------------------------------------------------------
839 * vmw_xv_stop_video --
841 * Called when we should stop playing video for a particular stream. If
842 * Cleanup is FALSE, the "stop" operation is only temporary, and thus we
843 * don't do anything. If Cleanup is TRUE we kill the video port by
844 * sending a message to the host and freeing up the stream.
852 *-----------------------------------------------------------------------------
856 vmw_xv_stop_video(ScrnInfoPtr pScrn
, pointer data
, Bool cleanup
)
858 struct vmw_customizer
*vmw
= vmw_customizer(xorg_customizer(pScrn
));
859 struct vmw_video_port
*port
= data
;
860 struct drm_vmw_control_stream_arg arg
;
863 debug_printf("%s: cleanup is %s\n", __func__
, cleanup
? "TRUE" : "FALSE");
865 if (!vmw
->video_priv
)
872 memset(&arg
, 0, sizeof(arg
));
873 arg
.stream_id
= port
->streamId
;
876 ret
= drmCommandWrite(vmw
->fd
, DRM_VMW_CONTROL_STREAM
, &arg
, sizeof(arg
));
879 vmw_video_port_cleanup(pScrn
, port
);
884 *-----------------------------------------------------------------------------
886 * vmw_xv_query_image_attributes --
888 * From the spec: This function is called to let the driver specify how data
889 * for a particular image of size width by height should be stored.
890 * Sometimes only the size and corrected width and height are needed. In
891 * that case pitches and offsets are NULL.
894 * The size of the memory required for the image, or -1 on error.
899 *-----------------------------------------------------------------------------
903 vmw_xv_query_image_attributes(ScrnInfoPtr pScrn
, int format
,
904 unsigned short *width
, unsigned short *height
,
905 int *pitches
, int *offsets
)
909 if (*width
> VMWARE_VID_MAX_WIDTH
) {
910 *width
= VMWARE_VID_MAX_WIDTH
;
912 if (*height
> VMWARE_VID_MAX_HEIGHT
) {
913 *height
= VMWARE_VID_MAX_HEIGHT
;
916 *width
= (*width
+ 1) & ~1;
917 if (offsets
!= NULL
) {
923 *height
= (*height
+ 1) & ~1;
924 size
= (*width
+ 3) & ~3;
932 tmp
= ((*width
>> 1) + 3) & ~3;
934 pitches
[1] = pitches
[2] = tmp
;
936 tmp
*= (*height
>> 1);
952 debug_printf("Query for invalid video format %d\n", format
);
960 *-----------------------------------------------------------------------------
962 * vmw_xv_set_port_attribute --
964 * From the spec: A port may have particular attributes such as colorKey, hue,
965 * saturation, brightness or contrast. Xv clients set these
966 * attribute values by sending attribute strings (Atoms) to the server.
969 * Success if the attribute exists and XvBadAlloc otherwise.
972 * The respective attribute gets the new value.
974 *-----------------------------------------------------------------------------
978 vmw_xv_set_port_attribute(ScrnInfoPtr pScrn
, Atom attribute
,
979 INT32 value
, pointer data
)
981 struct vmw_video_port
*port
= data
;
982 Atom xvColorKey
= MAKE_ATOM("XV_COLORKEY");
983 Atom xvAutoPaint
= MAKE_ATOM("XV_AUTOPAINT_COLORKEY");
985 if (attribute
== xvColorKey
) {
986 debug_printf("%s: Set colorkey:0x%x\n", __func__
, (unsigned)value
);
987 port
->colorKey
= value
;
988 } else if (attribute
== xvAutoPaint
) {
989 debug_printf("%s: Set autoPaint: %s\n", __func__
, value
? "TRUE": "FALSE");
990 port
->isAutoPaintColorkey
= value
;
1000 *-----------------------------------------------------------------------------
1002 * vmw_xv_get_port_attribute --
1004 * From the spec: A port may have particular attributes such as hue,
1005 * saturation, brightness or contrast. Xv clients get these
1006 * attribute values by sending attribute strings (Atoms) to the server
1009 * Success if the attribute exists and XvBadAlloc otherwise.
1012 * "value" contains the requested attribute on success.
1014 *-----------------------------------------------------------------------------
1018 vmw_xv_get_port_attribute(ScrnInfoPtr pScrn
, Atom attribute
,
1019 INT32
*value
, pointer data
)
1021 struct vmw_video_port
*port
= data
;
1022 Atom xvColorKey
= MAKE_ATOM("XV_COLORKEY");
1023 Atom xvAutoPaint
= MAKE_ATOM("XV_AUTOPAINT_COLORKEY");
1025 if (attribute
== xvColorKey
) {
1026 *value
= port
->colorKey
;
1027 } else if (attribute
== xvAutoPaint
) {
1028 *value
= port
->isAutoPaintColorkey
;
1038 *-----------------------------------------------------------------------------
1040 * vmw_xv_query_best_size --
1042 * From the spec: QueryBestSize provides the client with a way to query what
1043 * the destination dimensions would end up being if they were to request
1044 * that an area vid_w by vid_h from the video stream be scaled to rectangle
1045 * of drw_w by drw_h on the screen. Since it is not expected that all
1046 * hardware will be able to get the target dimensions exactly, it is
1047 * important that the driver provide this function.
1049 * This function seems to never be called, but to be on the safe side
1050 * we apply the same logic that QueryImageAttributes has for width
1059 *-----------------------------------------------------------------------------
1063 vmw_xv_query_best_size(ScrnInfoPtr pScrn
, Bool motion
,
1064 short vid_w
, short vid_h
, short drw_w
,
1065 short drw_h
, unsigned int *p_w
,
1066 unsigned int *p_h
, pointer data
)
1068 *p_w
= (drw_w
+ 1) & ~1;