Mercurial > sdl-ios-xcode

comparison src/video/Xext/Xv/Xv.c @ 292:eadc0746dfaf

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added SDL_LockRect() and SDL_UnlockRect() Incorporated XFree86 extension libraries into the source
author Sam Lantinga <slouken@libsdl.org>
date Tue, 05 Mar 2002 19:55:32 +0000
parents
children 8c4999b0ac10
comparison
equal deleted inserted replaced
291:68a8a8237c09 292:eadc0746dfaf
1 /***********************************************************
2 Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
3 and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
4
5 All Rights Reserved
6
7 Permission to use, copy, modify, and distribute this software and its
8 documentation for any purpose and without fee is hereby granted,
9 provided that the above copyright notice appear in all copies and that
10 both that copyright notice and this permission notice appear in
11 supporting documentation, and that the names of Digital or MIT not be
12 used in advertising or publicity pertaining to distribution of the
13 software without specific, written prior permission.
14
15 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
16 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
17 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
18 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
19 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
20 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
21 SOFTWARE.
22
23 ******************************************************************/
24 /* $XFree86: xc/lib/Xv/Xv.c,v 1.15 2001/05/11 08:23:22 alanh Exp $ */
25 /*
26 ** File:
27 **
28 ** Xv.c --- Xv library extension module.
29 **
30 ** Author:
31 **
32 ** David Carver (Digital Workstation Engineering/Project Athena)
33 **
34 ** Revisions:
35 **
36 ** 26.06.91 Carver
37 ** - changed XvFreeAdaptors to XvFreeAdaptorInfo
38 ** - changed XvFreeEncodings to XvFreeEncodingInfo
39 **
40 ** 11.06.91 Carver
41 ** - changed SetPortControl to SetPortAttribute
42 ** - changed GetPortControl to GetPortAttribute
43 ** - changed QueryBestSize
44 **
45 ** 15.05.91 Carver
46 ** - version 2.0 upgrade
47 **
48 ** 240.01.91 Carver
49 ** - version 1.4 upgrade
50 **
51 */
52
53 #include <stdio.h>
54 #include "Xvlibint.h"
55 #include <X11/extensions/Xext.h>
56 #include <X11/extensions/XShm.h>
57 #include "extutil.h"
58
59 static XExtensionInfo _xv_info_data;
60 static XExtensionInfo *xv_info = &_xv_info_data;
61 static char *xv_extension_name = XvName;
62
63 #define XvCheckExtension(dpy, i, val) \
64 XextCheckExtension(dpy, i, xv_extension_name, val)
65
66 static char *xv_error_string();
67 static int xv_close_display();
68 static Bool xv_wire_to_event();
69
70 static XExtensionHooks xv_extension_hooks = {
71 NULL, /* create_gc */
72 NULL, /* copy_gc */
73 NULL, /* flush_gc */
74 NULL, /* free_gc */
75 NULL, /* create_font */
76 NULL, /* free_font */
77 xv_close_display, /* close_display */
78 xv_wire_to_event, /* wire_to_event */
79 NULL, /* event_to_wire */
80 NULL, /* error */
81 xv_error_string /* error_string */
82 };
83
84
85 static char *xv_error_list[] =
86 {
87 "BadPort", /* XvBadPort */
88 "BadEncoding", /* XvBadEncoding */
89 "BadControl" /* XvBadControl */
90 };
91
92 static XEXT_GENERATE_CLOSE_DISPLAY (xv_close_display, xv_info)
93
94
95 static XEXT_GENERATE_FIND_DISPLAY (xv_find_display, xv_info,
96 xv_extension_name,
97 &xv_extension_hooks,
98 XvNumEvents, NULL)
99
100
101 static XEXT_GENERATE_ERROR_STRING (xv_error_string, xv_extension_name,
102 XvNumErrors, xv_error_list)
103
104
105 int
106 SDL_NAME(XvQueryExtension)(
107 Display *dpy,
108 unsigned int *p_version,
109 unsigned int *p_revision,
110 unsigned int *p_requestBase,
111 unsigned int *p_eventBase,
112 unsigned int *p_errorBase
113 ){
114 XExtDisplayInfo *info = xv_find_display(dpy);
115 xvQueryExtensionReq *req;
116 xvQueryExtensionReply rep;
117
118 XvCheckExtension(dpy, info, XvBadExtension);
119
120 LockDisplay(dpy);
121
122 XvGetReq(QueryExtension, req);
123
124 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
125 UnlockDisplay(dpy);
126 SyncHandle();
127 return XvBadExtension;
128 }
129
130 *p_version = rep.version;
131 *p_revision = rep.revision;
132 *p_requestBase = info->codes->major_opcode;
133 *p_eventBase = info->codes->first_event;
134 *p_errorBase = info->codes->first_error;
135
136 UnlockDisplay(dpy);
137 SyncHandle();
138
139 return Success;
140 }
141
142 int
143 SDL_NAME(XvQueryAdaptors)(
144 Display *dpy,
145 Window window,
146 unsigned int *p_nAdaptors,
147 SDL_NAME(XvAdaptorInfo) **p_pAdaptors
148 ){
149 XExtDisplayInfo *info = xv_find_display(dpy);
150 xvQueryAdaptorsReq *req;
151 xvQueryAdaptorsReply rep;
152 int size,ii,jj;
153 char *name;
154 SDL_NAME(XvAdaptorInfo) *pas, *pa;
155 SDL_NAME(XvFormat) *pfs, *pf;
156 char *buffer;
157 union
158 {
159 char *buffer;
160 char *string;
161 xvAdaptorInfo *pa;
162 xvFormat *pf;
163 } u;
164
165 XvCheckExtension(dpy, info, XvBadExtension);
166
167 LockDisplay(dpy);
168
169 XvGetReq(QueryAdaptors, req);
170 req->window = window;
171
172 /* READ THE REPLY */
173
174 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
175 UnlockDisplay(dpy);
176 SyncHandle();
177 return(XvBadReply);
178 }
179
180 size = rep.length << 2;
181 if ( (buffer = (char *)Xmalloc ((unsigned) size)) == NULL) {
182 UnlockDisplay(dpy);
183 SyncHandle();
184 return(XvBadAlloc);
185 }
186 _XRead (dpy, buffer, size);
187
188 u.buffer = buffer;
189
190 /* GET INPUT ADAPTORS */
191
192 if (rep.num_adaptors == 0) {
193 pas = NULL;
194 } else {
195 size = rep.num_adaptors*sizeof(SDL_NAME(XvAdaptorInfo));
196 if ((pas=(SDL_NAME(XvAdaptorInfo) *)Xmalloc(size))==NULL) {
197 Xfree(buffer);
198 UnlockDisplay(dpy);
199 SyncHandle();
200 return(XvBadAlloc);
201 }
202 }
203
204 /* INIT ADAPTOR FIELDS */
205
206 pa = pas;
207 for (ii=0; ii<rep.num_adaptors; ii++) {
208 pa->num_adaptors = 0;
209 pa->name = (char *)NULL;
210 pa->formats = (SDL_NAME(XvFormat) *)NULL;
211 pa++;
212 }
213
214 pa = pas;
215 for (ii=0; ii<rep.num_adaptors; ii++) {
216 pa->type = u.pa->type;
217 pa->base_id = u.pa->base_id;
218 pa->num_ports = u.pa->num_ports;
219 pa->num_formats = u.pa->num_formats;
220 pa->num_adaptors = rep.num_adaptors - ii;
221
222 /* GET ADAPTOR NAME */
223
224 size = u.pa->name_size;
225 u.buffer += (sz_xvAdaptorInfo + 3) & ~3;
226
227 if ( (name = (char *)Xmalloc(size+1)) == NULL)
228 {
229 SDL_NAME(XvFreeAdaptorInfo)(pas);
230 Xfree(buffer);
231 UnlockDisplay(dpy);
232 SyncHandle();
233 return(XvBadAlloc);
234 }
235 (void)strncpy(name, u.string, size);
236 name[size] = '\0';
237 pa->name = name;
238
239 u.buffer += (size + 3) & ~3;
240
241 /* GET FORMATS */
242
243 size = pa->num_formats*sizeof(SDL_NAME(XvFormat));
244 if ((pfs=(SDL_NAME(XvFormat) *)Xmalloc(size))==NULL) {
245 SDL_NAME(XvFreeAdaptorInfo)(pas);
246 Xfree(buffer);
247 UnlockDisplay(dpy);
248 SyncHandle();
249 return(XvBadAlloc);
250 }
251
252 pf = pfs;
253 for (jj=0; jj<pa->num_formats; jj++) {
254 pf->depth = u.pf->depth;
255 pf->visual_id = u.pf->visual;
256 pf++;
257
258 u.buffer += (sz_xvFormat + 3) & ~3;
259 }
260
261 pa->formats = pfs;
262
263 pa++;
264
265 }
266
267 *p_nAdaptors = rep.num_adaptors;
268 *p_pAdaptors = pas;
269
270 UnlockDisplay(dpy);
271 SyncHandle();
272
273 return (Success);
274 }
275
276
277 void
278 SDL_NAME(XvFreeAdaptorInfo)(SDL_NAME(XvAdaptorInfo) *pAdaptors)
279 {
280
281 SDL_NAME(XvAdaptorInfo) *pa;
282 int ii;
283
284 if (!pAdaptors) return;
285
286 pa = pAdaptors;
287
288 for (ii=0; ii<pAdaptors->num_adaptors; ii++, pa++)
289 {
290 if (pa->name)
291 {
292 Xfree(pa->name);
293 }
294 if (pa->formats)
295 {
296 Xfree(pa->formats);
297 }
298 }
299
300 Xfree(pAdaptors);
301 }
302
303 int
304 SDL_NAME(XvQueryEncodings)(
305 Display *dpy,
306 XvPortID port,
307 unsigned int *p_nEncodings,
308 SDL_NAME(XvEncodingInfo) **p_pEncodings
309 ){
310 XExtDisplayInfo *info = xv_find_display(dpy);
311 xvQueryEncodingsReq *req;
312 xvQueryEncodingsReply rep;
313 int size, jj;
314 char *name;
315 SDL_NAME(XvEncodingInfo) *pes, *pe;
316 char *buffer;
317 union
318 {
319 char *buffer;
320 char *string;
321 xvEncodingInfo *pe;
322 } u;
323
324 XvCheckExtension(dpy, info, XvBadExtension);
325
326 LockDisplay(dpy);
327
328 XvGetReq(QueryEncodings, req);
329 req->port = port;
330
331 /* READ THE REPLY */
332
333 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
334 UnlockDisplay(dpy);
335 SyncHandle();
336 return(XvBadReply);
337 }
338
339 size = rep.length << 2;
340 if ( (buffer = (char *)Xmalloc ((unsigned) size)) == NULL) {
341 UnlockDisplay(dpy);
342 SyncHandle();
343 return(XvBadAlloc);
344 }
345 _XRead (dpy, buffer, size);
346
347 u.buffer = buffer;
348
349 /* GET ENCODINGS */
350
351 size = rep.num_encodings*sizeof(SDL_NAME(XvEncodingInfo));
352 if ( (pes = (SDL_NAME(XvEncodingInfo) *)Xmalloc(size)) == NULL) {
353 Xfree(buffer);
354 UnlockDisplay(dpy);
355 SyncHandle();
356 return(XvBadAlloc);
357 }
358
359 /* INITIALIZE THE ENCODING POINTER */
360
361 pe = pes;
362 for (jj=0; jj<rep.num_encodings; jj++) {
363 pe->name = (char *)NULL;
364 pe->num_encodings = 0;
365 pe++;
366 }
367
368 pe = pes;
369 for (jj=0; jj<rep.num_encodings; jj++) {
370 pe->encoding_id = u.pe->encoding;
371 pe->width = u.pe->width;
372 pe->height = u.pe->height;
373 pe->rate.numerator = u.pe->rate.numerator;
374 pe->rate.denominator = u.pe->rate.denominator;
375 pe->num_encodings = rep.num_encodings - jj;
376
377 size = u.pe->name_size;
378 u.buffer += (sz_xvEncodingInfo + 3) & ~3;
379
380 if ( (name = (char *)Xmalloc(size+1)) == NULL) {
381 Xfree(buffer);
382 UnlockDisplay(dpy);
383 SyncHandle();
384 return(XvBadAlloc);
385 }
386 strncpy(name, u.string, size);
387 name[size] = '\0';
388 pe->name = name;
389 pe++;
390
391 u.buffer += (size + 3) & ~3;
392 }
393
394 *p_nEncodings = rep.num_encodings;
395 *p_pEncodings = pes;
396
397 UnlockDisplay(dpy);
398 SyncHandle();
399
400 return (Success);
401 }
402
403 void
404 SDL_NAME(XvFreeEncodingInfo)(SDL_NAME(XvEncodingInfo) *pEncodings)
405 {
406
407 SDL_NAME(XvEncodingInfo) *pe;
408 int ii;
409
410 if (!pEncodings) return;
411
412 pe = pEncodings;
413
414 for (ii=0; ii<pEncodings->num_encodings; ii++, pe++) {
415 if (pe->name) Xfree(pe->name);
416 }
417
418 Xfree(pEncodings);
419 }
420
421 int
422 SDL_NAME(XvPutVideo)(
423 Display *dpy,
424 XvPortID port,
425 Drawable d,
426 GC gc,
427 int vx, int vy,
428 unsigned int vw, unsigned int vh,
429 int dx, int dy,
430 unsigned int dw, unsigned int dh
431 ){
432 XExtDisplayInfo *info = xv_find_display(dpy);
433 xvPutVideoReq *req;
434
435 XvCheckExtension(dpy, info, XvBadExtension);
436
437 LockDisplay(dpy);
438
439 FlushGC(dpy, gc);
440
441 XvGetReq(PutVideo, req);
442
443 req->port = port;
444 req->drawable = d;
445 req->gc = gc->gid;
446 req->vid_x = vx;
447 req->vid_y = vy;
448 req->vid_w = vw;
449 req->vid_h = vh;
450 req->drw_x = dx;
451 req->drw_y = dy;
452 req->drw_w = dw;
453 req->drw_h = dh;
454
455 UnlockDisplay(dpy);
456 SyncHandle();
457
458 return Success;
459 }
460
461 int
462 SDL_NAME(XvPutStill)(
463 Display *dpy,
464 XvPortID port,
465 Drawable d,
466 GC gc,
467 int vx, int vy,
468 unsigned int vw, unsigned int vh,
469 int dx, int dy,
470 unsigned int dw, unsigned int dh
471 ){
472 XExtDisplayInfo *info = xv_find_display(dpy);
473 xvPutStillReq *req;
474
475 XvCheckExtension(dpy, info, XvBadExtension);
476
477 LockDisplay(dpy);
478
479 FlushGC(dpy, gc);
480
481 XvGetReq(PutStill, req);
482 req->port = port;
483 req->drawable = d;
484 req->gc = gc->gid;
485 req->vid_x = vx;
486 req->vid_y = vy;
487 req->vid_w = vw;
488 req->vid_h = vh;
489 req->drw_x = dx;
490 req->drw_y = dy;
491 req->drw_w = dw;
492 req->drw_h = dh;
493
494 UnlockDisplay(dpy);
495 SyncHandle();
496
497 return Success;
498 }
499
500 int
501 SDL_NAME(XvGetVideo)(
502 Display *dpy,
503 XvPortID port,
504 Drawable d,
505 GC gc,
506 int vx, int vy,
507 unsigned int vw, unsigned int vh,
508 int dx, int dy,
509 unsigned int dw, unsigned int dh
510 ){
511 XExtDisplayInfo *info = xv_find_display(dpy);
512 xvGetVideoReq *req;
513
514 XvCheckExtension(dpy, info, XvBadExtension);
515
516 LockDisplay(dpy);
517
518 FlushGC(dpy, gc);
519
520 XvGetReq(GetVideo, req);
521 req->port = port;
522 req->drawable = d;
523 req->gc = gc->gid;
524 req->vid_x = vx;
525 req->vid_y = vy;
526 req->vid_w = vw;
527 req->vid_h = vh;
528 req->drw_x = dx;
529 req->drw_y = dy;
530 req->drw_w = dw;
531 req->drw_h = dh;
532
533 UnlockDisplay(dpy);
534 SyncHandle();
535
536 return Success;
537 }
538
539 int
540 SDL_NAME(XvGetStill)(
541 Display *dpy,
542 XvPortID port,
543 Drawable d,
544 GC gc,
545 int vx, int vy,
546 unsigned int vw, unsigned int vh,
547 int dx, int dy,
548 unsigned int dw, unsigned int dh
549 ){
550 XExtDisplayInfo *info = xv_find_display(dpy);
551 xvGetStillReq *req;
552
553 XvCheckExtension(dpy, info, XvBadExtension);
554
555 LockDisplay(dpy);
556
557 FlushGC(dpy, gc);
558
559 XvGetReq(GetStill, req);
560 req->port = port;
561 req->drawable = d;
562 req->gc = gc->gid;
563 req->vid_x = vx;
564 req->vid_y = vy;
565 req->vid_w = vw;
566 req->vid_h = vh;
567 req->drw_x = dx;
568 req->drw_y = dy;
569 req->drw_w = dw;
570 req->drw_h = dh;
571
572 UnlockDisplay(dpy);
573 SyncHandle();
574
575 return Success;
576 }
577
578 int
579 SDL_NAME(XvStopVideo)(
580 Display *dpy,
581 XvPortID port,
582 Drawable draw
583 ){
584 XExtDisplayInfo *info = xv_find_display(dpy);
585 xvStopVideoReq *req;
586
587 XvCheckExtension(dpy, info, XvBadExtension);
588
589 LockDisplay(dpy);
590
591 XvGetReq(StopVideo, req);
592 req->port = port;
593 req->drawable = draw;
594
595 UnlockDisplay(dpy);
596 SyncHandle();
597
598 return Success;
599 }
600
601 int
602 SDL_NAME(XvGrabPort)(
603 Display *dpy,
604 XvPortID port,
605 Time time
606 ){
607 XExtDisplayInfo *info = xv_find_display(dpy);
608 int result;
609 xvGrabPortReply rep;
610 xvGrabPortReq *req;
611
612 XvCheckExtension(dpy, info, XvBadExtension);
613
614 LockDisplay(dpy);
615
616 XvGetReq(GrabPort, req);
617 req->port = port;
618 req->time = time;
619
620 if (_XReply (dpy, (xReply *) &rep, 0, xTrue) == 0)
621 rep.result = GrabSuccess;
622
623 result = rep.result;
624
625 UnlockDisplay(dpy);
626 SyncHandle();
627
628 return result;
629 }
630
631 int
632 SDL_NAME(XvUngrabPort)(
633 Display *dpy,
634 XvPortID port,
635 Time time
636 ){
637 XExtDisplayInfo *info = xv_find_display(dpy);
638 xvUngrabPortReq *req;
639
640 XvCheckExtension(dpy, info, XvBadExtension);
641
642 LockDisplay(dpy);
643
644 XvGetReq(UngrabPort, req);
645 req->port = port;
646 req->time = time;
647
648 UnlockDisplay(dpy);
649 SyncHandle();
650
651 return Success;
652 }
653
654 int
655 SDL_NAME(XvSelectVideoNotify)(
656 Display *dpy,
657 Drawable drawable,
658 Bool onoff
659 ){
660 XExtDisplayInfo *info = xv_find_display(dpy);
661 xvSelectVideoNotifyReq *req;
662
663 XvCheckExtension(dpy, info, XvBadExtension);
664
665 LockDisplay(dpy);
666
667 XvGetReq(SelectVideoNotify, req);
668 req->drawable = drawable;
669 req->onoff = onoff;
670
671 UnlockDisplay(dpy);
672 SyncHandle();
673
674 return Success;
675 }
676
677 int
678 SDL_NAME(XvSelectPortNotify)(
679 Display *dpy,
680 XvPortID port,
681 Bool onoff
682 ){
683 XExtDisplayInfo *info = xv_find_display(dpy);
684 xvSelectPortNotifyReq *req;
685
686 XvCheckExtension(dpy, info, XvBadExtension);
687
688 LockDisplay(dpy);
689
690 XvGetReq(SelectPortNotify, req);
691 req->port = port;
692 req->onoff = onoff;
693
694 UnlockDisplay(dpy);
695 SyncHandle();
696
697 return Success;
698 }
699
700 int
701 SDL_NAME(XvSetPortAttribute) (
702 Display *dpy,
703 XvPortID port,
704 Atom attribute,
705 int value
706 )
707 {
708 XExtDisplayInfo *info = xv_find_display(dpy);
709 xvSetPortAttributeReq *req;
710
711 XvCheckExtension(dpy, info, XvBadExtension);
712
713 LockDisplay(dpy);
714
715 XvGetReq(SetPortAttribute, req);
716 req->port = port;
717 req->attribute = attribute;
718 req->value = value;
719
720 UnlockDisplay(dpy);
721 SyncHandle();
722
723 return (Success);
724 }
725
726 int
727 SDL_NAME(XvGetPortAttribute) (
728 Display *dpy,
729 XvPortID port,
730 Atom attribute,
731 int *p_value
732 )
733 {
734 XExtDisplayInfo *info = xv_find_display(dpy);
735 xvGetPortAttributeReq *req;
736 xvGetPortAttributeReply rep;
737
738 XvCheckExtension(dpy, info, XvBadExtension);
739
740 LockDisplay(dpy);
741
742 XvGetReq(GetPortAttribute, req);
743 req->port = port;
744 req->attribute = attribute;
745
746 /* READ THE REPLY */
747
748 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
749 UnlockDisplay(dpy);
750 SyncHandle();
751 return(XvBadReply);
752 }
753
754 *p_value = rep.value;
755
756 UnlockDisplay(dpy);
757 SyncHandle();
758
759 return (Success);
760 }
761
762 int
763 SDL_NAME(XvQueryBestSize)(
764 Display *dpy,
765 XvPortID port,
766 Bool motion,
767 unsigned int vid_w,
768 unsigned int vid_h,
769 unsigned int drw_w,
770 unsigned int drw_h,
771 unsigned int *p_actual_width,
772 unsigned int *p_actual_height
773 )
774 {
775 XExtDisplayInfo *info = xv_find_display(dpy);
776 xvQueryBestSizeReq *req;
777 xvQueryBestSizeReply rep;
778
779 XvCheckExtension(dpy, info, XvBadExtension);
780
781 LockDisplay(dpy);
782
783 XvGetReq(QueryBestSize, req);
784 req->port = port;
785 req->motion = motion;
786 req->vid_w = vid_w;
787 req->vid_h = vid_h;
788 req->drw_w = drw_w;
789 req->drw_h = drw_h;
790
791 /* READ THE REPLY */
792
793 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
794 UnlockDisplay(dpy);
795 SyncHandle();
796 return(XvBadReply);
797 }
798
799 *p_actual_width = rep.actual_width;
800 *p_actual_height = rep.actual_height;
801
802 UnlockDisplay(dpy);
803 SyncHandle();
804
805 return (Success);
806 }
807
808
809 SDL_NAME(XvAttribute)*
810 SDL_NAME(XvQueryPortAttributes)(Display *dpy, XvPortID port, int *num)
811 {
812 XExtDisplayInfo *info = xv_find_display(dpy);
813 xvQueryPortAttributesReq *req;
814 xvQueryPortAttributesReply rep;
815 SDL_NAME(XvAttribute) *ret = NULL;
816
817 *num = 0;
818
819 XvCheckExtension(dpy, info, NULL);
820
821 LockDisplay(dpy);
822
823 XvGetReq(QueryPortAttributes, req);
824 req->port = port;
825
826 /* READ THE REPLY */
827
828 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
829 UnlockDisplay(dpy);
830 SyncHandle();
831 return ret;
832 }
833
834 if(rep.num_attributes) {
835 int size = (rep.num_attributes * sizeof(SDL_NAME(XvAttribute))) + rep.text_size;
836
837 if((ret = Xmalloc(size))) {
838 char* marker = (char*)(&ret[rep.num_attributes]);
839 xvAttributeInfo Info;
840 int i;
841
842 for(i = 0; i < rep.num_attributes; i++) {
843 _XRead(dpy, (char*)(&Info), sz_xvAttributeInfo);
844 ret[i].flags = (int)Info.flags;
845 ret[i].min_value = Info.min;
846 ret[i].max_value = Info.max;
847 ret[i].name = marker;
848 _XRead(dpy, marker, Info.size);
849 marker += Info.size;
850 (*num)++;
851 }
852 } else
853 _XEatData(dpy, rep.length << 2);
854 }
855
856 UnlockDisplay(dpy);
857 SyncHandle();
858
859 return ret;
860 }
861
862 SDL_NAME(XvImageFormatValues) * SDL_NAME(XvListImageFormats) (
863 Display *dpy,
864 XvPortID port,
865 int *num
866 ){
867 XExtDisplayInfo *info = xv_find_display(dpy);
868 xvListImageFormatsReq *req;
869 xvListImageFormatsReply rep;
870 SDL_NAME(XvImageFormatValues) *ret = NULL;
871
872 *num = 0;
873
874 XvCheckExtension(dpy, info, NULL);
875
876 LockDisplay(dpy);
877
878 XvGetReq(ListImageFormats, req);
879 req->port = port;
880
881 /* READ THE REPLY */
882
883 if (_XReply(dpy, (xReply *)&rep, 0, xFalse) == 0) {
884 UnlockDisplay(dpy);
885 SyncHandle();
886 return NULL;
887 }
888
889 if(rep.num_formats) {
890 int size = (rep.num_formats * sizeof(SDL_NAME(XvImageFormatValues)));
891
892 if((ret = Xmalloc(size))) {
893 xvImageFormatInfo Info;
894 int i;
895
896 for(i = 0; i < rep.num_formats; i++) {
897 _XRead(dpy, (char*)(&Info), sz_xvImageFormatInfo);
898 ret[i].id = Info.id;
899 ret[i].type = Info.type;
900 ret[i].byte_order = Info.byte_order;
901 memcpy(&(ret[i].guid[0]), &(Info.guid[0]), 16);
902 ret[i].bits_per_pixel = Info.bpp;
903 ret[i].format = Info.format;
904 ret[i].num_planes = Info.num_planes;
905 ret[i].depth = Info.depth;
906 ret[i].red_mask = Info.red_mask;
907 ret[i].green_mask = Info.green_mask;
908 ret[i].blue_mask = Info.blue_mask;
909 ret[i].y_sample_bits = Info.y_sample_bits;
910 ret[i].u_sample_bits = Info.u_sample_bits;
911 ret[i].v_sample_bits = Info.v_sample_bits;
912 ret[i].horz_y_period = Info.horz_y_period;
913 ret[i].horz_u_period = Info.horz_u_period;
914 ret[i].horz_v_period = Info.horz_v_period;
915 ret[i].vert_y_period = Info.vert_y_period;
916 ret[i].vert_u_period = Info.vert_u_period;
917 ret[i].vert_v_period = Info.vert_v_period;
918 memcpy(&(ret[i].component_order[0]), &(Info.comp_order[0]), 32);
919 ret[i].scanline_order = Info.scanline_order;
920 (*num)++;
921 }
922 } else
923 _XEatData(dpy, rep.length << 2);
924 }
925
926 UnlockDisplay(dpy);
927 SyncHandle();
928
929 return ret;
930 }
931
932 SDL_NAME(XvImage) * SDL_NAME(XvCreateImage) (
933 Display *dpy,
934 XvPortID port,
935 int id,
936 char *data,
937 int width,
938 int height
939 ) {
940 XExtDisplayInfo *info = xv_find_display(dpy);
941 xvQueryImageAttributesReq *req;
942 xvQueryImageAttributesReply rep;
943 SDL_NAME(XvImage) *ret = NULL;
944
945 XvCheckExtension(dpy, info, NULL);
946
947 LockDisplay(dpy);
948
949 XvGetReq(QueryImageAttributes, req);
950 req->id = id;
951 req->port = port;
952 req->width = width;
953 req->height = height;
954
955 /* READ THE REPLY */
956
957 if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
958 UnlockDisplay(dpy);
959 SyncHandle();
960 return NULL;
961 }
962
963 if((ret = (SDL_NAME(XvImage)*)Xmalloc(sizeof(SDL_NAME(XvImage)) + (rep.num_planes << 3)))) {
964 ret->id = id;
965 ret->width = rep.width;
966 ret->height = rep.height;
967 ret->data_size = rep.data_size;
968 ret->num_planes = rep.num_planes;
969 ret->pitches = (int*)(&ret[1]);
970 ret->offsets = ret->pitches + rep.num_planes;
971 ret->data = data;
972 ret->obdata = NULL;
973 _XRead(dpy, (char*)(ret->pitches), rep.num_planes << 2);
974 _XRead(dpy, (char*)(ret->offsets), rep.num_planes << 2);
975 } else
976 _XEatData(dpy, rep.length << 2);
977
978 UnlockDisplay(dpy);
979 SyncHandle();
980
981 return ret;
982 }
983
984 SDL_NAME(XvImage) * SDL_NAME(XvShmCreateImage) (
985 Display *dpy,
986 XvPortID port,
987 int id,
988 char *data,
989 int width,
990 int height,
991 XShmSegmentInfo *shminfo
992 ){
993 SDL_NAME(XvImage) *ret;
994
995 ret = SDL_NAME(XvCreateImage)(dpy, port, id, data, width, height);
996
997 if(ret) ret->obdata = (XPointer)shminfo;
998
999 return ret;
1000 }
1001
1002 int SDL_NAME(XvPutImage) (
1003 Display *dpy,
1004 XvPortID port,
1005 Drawable d,
1006 GC gc,
1007 SDL_NAME(XvImage) *image,
1008 int src_x,
1009 int src_y,
1010 unsigned int src_w,
1011 unsigned int src_h,
1012 int dest_x,
1013 int dest_y,
1014 unsigned int dest_w,
1015 unsigned int dest_h
1016 ){
1017 XExtDisplayInfo *info = xv_find_display(dpy);
1018 xvPutImageReq *req;
1019 int len;
1020
1021 XvCheckExtension(dpy, info, XvBadExtension);
1022
1023 LockDisplay(dpy);
1024
1025 FlushGC(dpy, gc);
1026
1027 XvGetReq(PutImage, req);
1028
1029 req->port = port;
1030 req->drawable = d;
1031 req->gc = gc->gid;
1032 req->id = image->id;
1033 req->src_x = src_x;
1034 req->src_y = src_y;
1035 req->src_w = src_w;
1036 req->src_h = src_h;
1037 req->drw_x = dest_x;
1038 req->drw_y = dest_y;
1039 req->drw_w = dest_w;
1040 req->drw_h = dest_h;
1041 req->width = image->width;
1042 req->height = image->height;
1043
1044 len = (image->data_size + 3) >> 2;
1045 SetReqLen(req, len, len);
1046
1047 /* Yes it's kindof lame that we are sending the whole thing,
1048 but for video all of it may be needed even if displaying
1049 only a subsection, and I don't want to go through the
1050 trouble of creating subregions to send */
1051 Data(dpy, (char *)image->data, image->data_size);
1052
1053 UnlockDisplay(dpy);
1054 SyncHandle();
1055
1056 return Success;
1057 }
1058
1059 int SDL_NAME(XvShmPutImage) (
1060 Display *dpy,
1061 XvPortID port,
1062 Drawable d,
1063 GC gc,
1064 SDL_NAME(XvImage) *image,
1065 int src_x,
1066 int src_y,
1067 unsigned int src_w,
1068 unsigned int src_h,
1069 int dest_x,
1070 int dest_y,
1071 unsigned int dest_w,
1072 unsigned int dest_h,
1073 Bool send_event
1074 ){
1075 XExtDisplayInfo *info = xv_find_display(dpy);
1076 XShmSegmentInfo *shminfo = (XShmSegmentInfo *)image->obdata;
1077 xvShmPutImageReq *req;
1078
1079 XvCheckExtension(dpy, info, XvBadExtension);
1080
1081 LockDisplay(dpy);
1082
1083 FlushGC(dpy, gc);
1084
1085 XvGetReq(ShmPutImage, req);
1086
1087 req->port = port;
1088 req->drawable = d;
1089 req->gc = gc->gid;
1090 req->shmseg = shminfo->shmseg;
1091 req->id = image->id;
1092 req->src_x = src_x;
1093 req->src_y = src_y;
1094 req->src_w = src_w;
1095 req->src_h = src_h;
1096 req->drw_x = dest_x;
1097 req->drw_y = dest_y;
1098 req->drw_w = dest_w;
1099 req->drw_h = dest_h;
1100 req->offset = image->data - shminfo->shmaddr;
1101 req->width = image->width;
1102 req->height = image->height;
1103 req->send_event = send_event;
1104
1105 UnlockDisplay(dpy);
1106 SyncHandle();
1107
1108 return Success;
1109 }
1110
1111
1112 static Bool
1113 xv_wire_to_event(Display *dpy, XEvent *host, xEvent *wire)
1114 {
1115 XExtDisplayInfo *info = xv_find_display(dpy);
1116 SDL_NAME(XvEvent) *re = (SDL_NAME(XvEvent) *)host;
1117 xvEvent *event = (xvEvent *)wire;
1118
1119 XvCheckExtension(dpy, info, False);
1120
1121 switch((event->u.u.type & 0x7F) - info->codes->first_event)
1122 {
1123 case XvVideoNotify:
1124 re->xvvideo.type = event->u.u.type & 0x7f;
1125 re->xvvideo.serial =
1126 _XSetLastRequestRead(dpy, (xGenericReply *)event);
1127 re->xvvideo.send_event = ((event->u.u.type & 0x80) != 0);
1128 re->xvvideo.display = dpy;
1129 re->xvvideo.time = event->u.videoNotify.time;
1130 re->xvvideo.reason = event->u.videoNotify.reason;
1131 re->xvvideo.drawable = event->u.videoNotify.drawable;
1132 re->xvvideo.port_id = event->u.videoNotify.port;
1133 break;
1134 case XvPortNotify:
1135 re->xvport.type = event->u.u.type & 0x7f;
1136 re->xvport.serial =
1137 _XSetLastRequestRead(dpy, (xGenericReply *)event);
1138 re->xvport.send_event = ((event->u.u.type & 0x80) != 0);
1139 re->xvport.display = dpy;
1140 re->xvport.time = event->u.portNotify.time;
1141 re->xvport.port_id = event->u.portNotify.port;
1142 re->xvport.attribute = event->u.portNotify.attribute;
1143 re->xvport.value = event->u.portNotify.value;
1144 break;
1145 default:
1146 return False;
1147 }
1148
1149 return (True);
1150 }
1151
1152