diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/Xext/Xv/Xv.c')
-rw-r--r-- | apps/plugins/sdl/src/video/Xext/Xv/Xv.c | 1151 |
1 files changed, 1151 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/Xext/Xv/Xv.c b/apps/plugins/sdl/src/video/Xext/Xv/Xv.c new file mode 100644 index 0000000000..7147b9e8cb --- /dev/null +++ b/apps/plugins/sdl/src/video/Xext/Xv/Xv.c | |||
@@ -0,0 +1,1151 @@ | |||
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 "../extensions/Xext.h" | ||
56 | #include <X11/extensions/XShm.h> | ||
57 | #include "../extensions/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 | SDL_strlcpy(name, u.string, size); | ||
236 | pa->name = name; | ||
237 | |||
238 | u.buffer += (size + 3) & ~3; | ||
239 | |||
240 | /* GET FORMATS */ | ||
241 | |||
242 | size = pa->num_formats*sizeof(SDL_NAME(XvFormat)); | ||
243 | if ((pfs=(SDL_NAME(XvFormat) *)Xmalloc(size))==NULL) { | ||
244 | SDL_NAME(XvFreeAdaptorInfo)(pas); | ||
245 | Xfree(buffer); | ||
246 | UnlockDisplay(dpy); | ||
247 | SyncHandle(); | ||
248 | return(XvBadAlloc); | ||
249 | } | ||
250 | |||
251 | pf = pfs; | ||
252 | for (jj=0; jj<pa->num_formats; jj++) { | ||
253 | pf->depth = u.pf->depth; | ||
254 | pf->visual_id = u.pf->visual; | ||
255 | pf++; | ||
256 | |||
257 | u.buffer += (sz_xvFormat + 3) & ~3; | ||
258 | } | ||
259 | |||
260 | pa->formats = pfs; | ||
261 | |||
262 | pa++; | ||
263 | |||
264 | } | ||
265 | |||
266 | *p_nAdaptors = rep.num_adaptors; | ||
267 | *p_pAdaptors = pas; | ||
268 | |||
269 | Xfree(buffer); | ||
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 | SDL_strlcpy(name, u.string, size); | ||
387 | pe->name = name; | ||
388 | pe++; | ||
389 | |||
390 | u.buffer += (size + 3) & ~3; | ||
391 | } | ||
392 | |||
393 | *p_nEncodings = rep.num_encodings; | ||
394 | *p_pEncodings = pes; | ||
395 | |||
396 | Xfree(buffer); | ||
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 | return ret; | ||
981 | } | ||
982 | |||
983 | SDL_NAME(XvImage) * SDL_NAME(XvShmCreateImage) ( | ||
984 | Display *dpy, | ||
985 | XvPortID port, | ||
986 | int id, | ||
987 | char *data, | ||
988 | int width, | ||
989 | int height, | ||
990 | XShmSegmentInfo *shminfo | ||
991 | ){ | ||
992 | SDL_NAME(XvImage) *ret; | ||
993 | |||
994 | ret = SDL_NAME(XvCreateImage)(dpy, port, id, data, width, height); | ||
995 | |||
996 | if(ret) ret->obdata = (XPointer)shminfo; | ||
997 | |||
998 | return ret; | ||
999 | } | ||
1000 | |||
1001 | int SDL_NAME(XvPutImage) ( | ||
1002 | Display *dpy, | ||
1003 | XvPortID port, | ||
1004 | Drawable d, | ||
1005 | GC gc, | ||
1006 | SDL_NAME(XvImage) *image, | ||
1007 | int src_x, | ||
1008 | int src_y, | ||
1009 | unsigned int src_w, | ||
1010 | unsigned int src_h, | ||
1011 | int dest_x, | ||
1012 | int dest_y, | ||
1013 | unsigned int dest_w, | ||
1014 | unsigned int dest_h | ||
1015 | ){ | ||
1016 | XExtDisplayInfo *info = xv_find_display(dpy); | ||
1017 | xvPutImageReq *req; | ||
1018 | int len; | ||
1019 | |||
1020 | XvCheckExtension(dpy, info, XvBadExtension); | ||
1021 | |||
1022 | LockDisplay(dpy); | ||
1023 | |||
1024 | FlushGC(dpy, gc); | ||
1025 | |||
1026 | XvGetReq(PutImage, req); | ||
1027 | |||
1028 | req->port = port; | ||
1029 | req->drawable = d; | ||
1030 | req->gc = gc->gid; | ||
1031 | req->id = image->id; | ||
1032 | req->src_x = src_x; | ||
1033 | req->src_y = src_y; | ||
1034 | req->src_w = src_w; | ||
1035 | req->src_h = src_h; | ||
1036 | req->drw_x = dest_x; | ||
1037 | req->drw_y = dest_y; | ||
1038 | req->drw_w = dest_w; | ||
1039 | req->drw_h = dest_h; | ||
1040 | req->width = image->width; | ||
1041 | req->height = image->height; | ||
1042 | |||
1043 | len = (image->data_size + 3) >> 2; | ||
1044 | SetReqLen(req, len, len); | ||
1045 | |||
1046 | /* Yes it's kindof lame that we are sending the whole thing, | ||
1047 | but for video all of it may be needed even if displaying | ||
1048 | only a subsection, and I don't want to go through the | ||
1049 | trouble of creating subregions to send */ | ||
1050 | Data(dpy, (char *)image->data, image->data_size); | ||
1051 | |||
1052 | UnlockDisplay(dpy); | ||
1053 | SyncHandle(); | ||
1054 | |||
1055 | return Success; | ||
1056 | } | ||
1057 | |||
1058 | int SDL_NAME(XvShmPutImage) ( | ||
1059 | Display *dpy, | ||
1060 | XvPortID port, | ||
1061 | Drawable d, | ||
1062 | GC gc, | ||
1063 | SDL_NAME(XvImage) *image, | ||
1064 | int src_x, | ||
1065 | int src_y, | ||
1066 | unsigned int src_w, | ||
1067 | unsigned int src_h, | ||
1068 | int dest_x, | ||
1069 | int dest_y, | ||
1070 | unsigned int dest_w, | ||
1071 | unsigned int dest_h, | ||
1072 | Bool send_event | ||
1073 | ){ | ||
1074 | XExtDisplayInfo *info = xv_find_display(dpy); | ||
1075 | XShmSegmentInfo *shminfo = (XShmSegmentInfo *)image->obdata; | ||
1076 | xvShmPutImageReq *req; | ||
1077 | |||
1078 | XvCheckExtension(dpy, info, XvBadExtension); | ||
1079 | |||
1080 | LockDisplay(dpy); | ||
1081 | |||
1082 | FlushGC(dpy, gc); | ||
1083 | |||
1084 | XvGetReq(ShmPutImage, req); | ||
1085 | |||
1086 | req->port = port; | ||
1087 | req->drawable = d; | ||
1088 | req->gc = gc->gid; | ||
1089 | req->shmseg = shminfo->shmseg; | ||
1090 | req->id = image->id; | ||
1091 | req->src_x = src_x; | ||
1092 | req->src_y = src_y; | ||
1093 | req->src_w = src_w; | ||
1094 | req->src_h = src_h; | ||
1095 | req->drw_x = dest_x; | ||
1096 | req->drw_y = dest_y; | ||
1097 | req->drw_w = dest_w; | ||
1098 | req->drw_h = dest_h; | ||
1099 | req->offset = image->data - shminfo->shmaddr; | ||
1100 | req->width = image->width; | ||
1101 | req->height = image->height; | ||
1102 | req->send_event = send_event; | ||
1103 | |||
1104 | UnlockDisplay(dpy); | ||
1105 | SyncHandle(); | ||
1106 | |||
1107 | return Success; | ||
1108 | } | ||
1109 | |||
1110 | |||
1111 | static Bool | ||
1112 | xv_wire_to_event(Display *dpy, XEvent *host, xEvent *wire) | ||
1113 | { | ||
1114 | XExtDisplayInfo *info = xv_find_display(dpy); | ||
1115 | SDL_NAME(XvEvent) *re = (SDL_NAME(XvEvent) *)host; | ||
1116 | xvEvent *event = (xvEvent *)wire; | ||
1117 | |||
1118 | XvCheckExtension(dpy, info, False); | ||
1119 | |||
1120 | switch((event->u.u.type & 0x7F) - info->codes->first_event) | ||
1121 | { | ||
1122 | case XvVideoNotify: | ||
1123 | re->xvvideo.type = event->u.u.type & 0x7f; | ||
1124 | re->xvvideo.serial = | ||
1125 | _XSetLastRequestRead(dpy, (xGenericReply *)event); | ||
1126 | re->xvvideo.send_event = ((event->u.u.type & 0x80) != 0); | ||
1127 | re->xvvideo.display = dpy; | ||
1128 | re->xvvideo.time = event->u.videoNotify.time; | ||
1129 | re->xvvideo.reason = event->u.videoNotify.reason; | ||
1130 | re->xvvideo.drawable = event->u.videoNotify.drawable; | ||
1131 | re->xvvideo.port_id = event->u.videoNotify.port; | ||
1132 | break; | ||
1133 | case XvPortNotify: | ||
1134 | re->xvport.type = event->u.u.type & 0x7f; | ||
1135 | re->xvport.serial = | ||
1136 | _XSetLastRequestRead(dpy, (xGenericReply *)event); | ||
1137 | re->xvport.send_event = ((event->u.u.type & 0x80) != 0); | ||
1138 | re->xvport.display = dpy; | ||
1139 | re->xvport.time = event->u.portNotify.time; | ||
1140 | re->xvport.port_id = event->u.portNotify.port; | ||
1141 | re->xvport.attribute = event->u.portNotify.attribute; | ||
1142 | re->xvport.value = event->u.portNotify.value; | ||
1143 | break; | ||
1144 | default: | ||
1145 | return False; | ||
1146 | } | ||
1147 | |||
1148 | return (True); | ||
1149 | } | ||
1150 | |||
1151 | |||