4 // Copyright (C) 2005 David J. Goehrig <dgoehrig@cpan.org>
6 // ------------------------------------------------------------------------------
8 // This library is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU Lesser General Public
10 // License as published by the Free Software Foundation; either
11 // version 2.1 of the License, or (at your option) any later version.
13 // This library is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 // Lesser General Public License for more details.
18 // You should have received a copy of the GNU Lesser General Public
19 // License along with this library; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 // ------------------------------------------------------------------------------
24 // Please feel free to send questions, suggestions or improvements to:
49 #include <SDL_image.h>
53 #include <SDL_mixer.h>
54 void (*mix_music_finished_cv)();
58 #include <SDL_sound.h>
69 #define TEXT_BLENDED 4
71 #define UTF8_SHADED 16
72 #define UTF8_BLENDED 32
73 #define UNICODE_SOLID 64
74 #define UNICODE_SHADED 128
75 #define UNICODE_BLENDED 256
79 #include <smpeg/smpeg.h>
81 static int sdl_perl_use_smpeg_audio = 0;
86 #include <SDL_rotozoom.h>
87 #include <SDL_gfxPrimitives.h>
88 #include <SDL_framerate.h>
89 #include <SDL_imageFilter.h>
97 #define HAVE_TLS_CONTEXT
101 #ifndef SDL_PERL_DEFINES_H
102 #define SDL_PERL_DEFINES_H
104 #ifdef HAVE_TLS_CONTEXT
105 PerlInterpreter *parent_perl = NULL;
106 extern PerlInterpreter *parent_perl;
107 #define GET_TLS_CONTEXT parent_perl = PERL_GET_CONTEXT;
108 #define ENTER_TLS_CONTEXT \
109 PerlInterpreter *current_perl = PERL_GET_CONTEXT; \
110 PERL_SET_CONTEXT(parent_perl); { \
111 PerlInterpreter *my_perl = parent_perl;
112 #define LEAVE_TLS_CONTEXT \
113 } PERL_SET_CONTEXT(current_perl);
115 #define GET_TLS_CONTEXT /* TLS context not enabled */
116 #define ENTER_TLS_CONTEXT /* TLS context not enabled */
117 #define LEAVE_TLS_CONTEXT /* TLS context not enabled */
123 sdl_perl_timer_callback ( Uint32 interval, void* param )
136 XPUSHs(sv_2mortal(newSViv(interval)));
139 if (0 != (back = call_sv(cmd,G_SCALAR))) {
141 if (back != 1 ) Perl_croak (aTHX_ "Timer Callback failed!");
144 Perl_croak(aTHX_ "Timer Callback failed!");
156 sdl_perl_audio_callback ( void* data, Uint8 *stream, int len )
167 XPUSHs(sv_2mortal(newSViv(PTR2IV(stream))));
168 XPUSHs(sv_2mortal(newSViv(len)));
171 call_sv(cmd,G_VOID|G_DISCARD);
180 #ifdef HAVE_SDL_MIXER
183 sdl_perl_music_callback ( void )
189 cmd = (SV*)Mix_GetMusicHookData();
196 call_sv(cmd,G_VOID|G_DISCARD);
206 sdl_perl_music_finished_callback ( void )
212 cmd = (SV*)mix_music_finished_cv;
213 if ( cmd == NULL ) return;
220 call_sv(cmd,G_VOID|G_DISCARD);
231 #define INIT_NS_APPLICATION
232 #define QUIT_NS_APPLICATION
236 sdl_perl_atexit (void)
243 void boot_SDL__OpenGL();
251 MODULE = SDL_perl PACKAGE = SDL
257 RETVAL = SDL_GetError();
266 RETVAL = SDL_Init(flags);
267 #ifdef HAVE_TLS_CONTEXT
268 Perl_call_atexit(PERL_GET_CONTEXT, (void*)sdl_perl_atexit,0);
270 atexit(sdl_perl_atexit);
276 InitSubSystem ( flags )
279 RETVAL = SDL_InitSubSystem(flags);
284 QuitSubSystem ( flags )
287 SDL_QuitSubSystem(flags);
299 RETVAL = SDL_WasInit(flags);
312 RETVAL = SDL_GetTicks();
317 SetTimer ( interval, callback )
319 SDL_TimerCallback callback
321 RETVAL = SDL_SetTimer(interval,callback);
326 AddTimer ( interval, callback, param )
328 SDL_NewTimerCallback callback
331 RETVAL = SDL_AddTimer(interval,callback,param);
338 RETVAL = sdl_perl_timer_callback;
343 NewTimer ( interval, cmd )
347 RETVAL = SDL_AddTimer(interval,sdl_perl_timer_callback,cmd);
355 RETVAL = SDL_RemoveTimer(id);
360 RWFromFile ( file, mode )
364 RETVAL = SDL_RWFromFile(file,mode);
369 RWFromFP ( fp, autoclose )
373 RETVAL = SDL_RWFromFP(fp,autoclose);
378 RWFromMem ( mem, size )
382 RETVAL = SDL_RWFromMem((void*)mem,size);
387 RWFromConstMem ( mem, size )
391 RETVAL = SDL_RWFromConstMem((const void*)mem,size);
398 RETVAL = SDL_AllocRW();
409 RWseek ( rw, off, whence )
414 RETVAL = SDL_RWseek(rw,off,whence);
422 RETVAL = SDL_RWtell(rw);
427 RWread ( rw, mem, size, n )
433 RETVAL = SDL_RWread(rw,mem,size,n);
438 RWwrite ( rw, mem, size, n )
444 RETVAL = SDL_RWwrite(rw,mem,size,n);
452 RETVAL = SDL_RWclose(rw);
459 RETVAL = SDL_CDNumDrives();
467 RETVAL = strdup(SDL_CDName(drive));
475 RETVAL = SDL_CDOpen(drive);
488 CDTrackType ( track )
491 RETVAL = track->type;
496 CDTrackLength ( track )
499 RETVAL = track->length;
504 CDTrackOffset ( track )
507 RETVAL = track->offset;
515 RETVAL = SDL_CDStatus(cd);
520 CDPlayTracks ( cd, start_track, ntracks, start_frame, nframes )
527 RETVAL = SDL_CDPlayTracks(cd,start_track,start_frame,ntracks,nframes);
532 CDPlay ( cd, start, length )
537 RETVAL = SDL_CDPlay(cd,start,length);
545 RETVAL = SDL_CDPause(cd);
553 RETVAL = SDL_CDResume(cd);
561 RETVAL = SDL_CDStop(cd);
569 RETVAL = SDL_CDEject(cd);
591 RETVAL = cd->numtracks;
599 RETVAL = cd->cur_track;
607 RETVAL = cd->cur_frame;
612 CDTrack ( cd, number )
616 RETVAL = (SDL_CDtrack *)(cd->track + number);
629 RETVAL = SDL_PushEvent( e );
636 RETVAL = (SDL_Event *) safemalloc (sizeof(SDL_Event));
650 RETVAL = SDL_PollEvent(e);
658 RETVAL = SDL_WaitEvent(e);
663 EventState ( type, state )
667 RETVAL = SDL_EventState(type,state);
680 SetEventType ( e, type )
690 ActiveEventGain ( e )
693 RETVAL = e->active.gain;
698 ActiveEventState ( e )
701 RETVAL = e->active.state;
709 RETVAL = e->key.state;
717 RETVAL = e->key.keysym.sym;
725 RETVAL = e->key.keysym.mod;
730 KeyEventUnicode ( e )
733 RETVAL = e->key.keysym.unicode;
738 KeyEventScanCode ( e )
741 RETVAL = e->key.keysym.scancode;
746 MouseMotionState ( e )
749 RETVAL = e->motion.state;
757 RETVAL = e->motion.x;
765 RETVAL = e->motion.y;
773 RETVAL = e->motion.xrel;
778 MouseMotionYrel ( e )
781 RETVAL = e->motion.yrel;
786 MouseButtonState ( e )
789 RETVAL = e->button.state;
797 RETVAL = e->button.button;
805 RETVAL = e->button.x;
813 RETVAL = e->button.y;
821 RETVAL = e->syswm.msg;
826 EnableUnicode ( enable )
829 RETVAL = SDL_EnableUNICODE(enable);
834 EnableKeyRepeat ( delay, interval )
838 SDL_EnableKeyRepeat(delay,interval);
843 RETVAL = SDL_GetModState();
848 SetModState ( state )
851 SDL_SetModState(state);
857 RETVAL = SDL_GetKeyName(sym);
862 CreateRGBSurface (flags, width, height, depth, Rmask, Gmask, Bmask, Amask )
872 RETVAL = SDL_CreateRGBSurface ( flags, width, height,
873 depth, Rmask, Gmask, Bmask, Amask );
879 CreateRGBSurfaceFrom (pixels, width, height, depth, pitch, Rmask, Gmask, Bmask, Amask )
891 Uint32 len = pitch * height;
892 New(0,pixeldata,len,Uint8);
893 Copy(pixels,pixeldata,len,Uint8);
894 RETVAL = SDL_CreateRGBSurfaceFrom ( pixeldata, width, height,
895 depth, pitch, Rmask, Gmask, Bmask, Amask );
899 #ifdef HAVE_SDL_IMAGE
905 RETVAL = IMG_Load(fname);
912 SurfaceCopy ( surface )
916 Uint32 size = surface->pitch * surface->h;
917 New(0,pixels,size,Uint8);
918 Copy(surface->pixels,pixels,size,Uint8);
919 RETVAL = SDL_CreateRGBSurfaceFrom(pixels,surface->w,surface->h,
920 surface->format->BitsPerPixel, surface->pitch,
921 surface->format->Rmask, surface->format->Gmask,
922 surface->format->Bmask, surface->format->Amask);
927 FreeSurface ( surface )
931 Uint8* pixels = surface->pixels;
932 Uint32 flags = surface->flags;
933 SDL_FreeSurface(surface);
934 if (flags & SDL_PREALLOC)
939 SurfaceFlags ( surface )
942 RETVAL = surface->flags;
947 SurfacePalette ( surface )
950 RETVAL = surface->format->palette;
955 SurfaceBitsPerPixel ( surface )
958 RETVAL = surface->format->BitsPerPixel;
963 SurfaceBytesPerPixel ( surface )
966 RETVAL = surface->format->BytesPerPixel;
971 SurfaceRshift ( surface )
974 RETVAL = surface->format->Rshift;
979 SurfaceGshift ( surface )
982 RETVAL = surface->format->Gshift;
987 SurfaceBshift ( surface )
990 RETVAL = surface->format->Bshift;
995 SurfaceAshift ( surface )
998 RETVAL = surface->format->Ashift;
1003 SurfaceRmask( surface )
1004 SDL_Surface *surface
1006 RETVAL = surface->format->Rmask;
1011 SurfaceGmask ( surface )
1012 SDL_Surface *surface
1014 RETVAL = surface->format->Gmask;
1019 SurfaceBmask ( surface )
1020 SDL_Surface *surface
1022 RETVAL = surface->format->Bmask;
1027 SurfaceAmask ( surface )
1028 SDL_Surface *surface
1030 RETVAL = surface->format->Amask;
1035 SurfaceColorKey ( surface )
1036 SDL_Surface *surface
1038 RETVAL = surface->format->colorkey;
1043 SurfaceAlpha( surface )
1044 SDL_Surface *surface
1046 RETVAL = surface->format->alpha;
1051 SurfaceW ( surface )
1052 SDL_Surface *surface
1054 RETVAL = surface->w;
1059 SurfaceH ( surface )
1060 SDL_Surface *surface
1062 RETVAL = surface->h;
1067 SurfacePitch ( surface )
1068 SDL_Surface *surface
1070 RETVAL = surface->pitch;
1075 SurfacePixels ( surface )
1076 SDL_Surface *surface
1078 RETVAL = newSVpvn(surface->pixels,surface->pitch*surface->h);
1083 SurfacePixel ( surface, x, y, ... )
1084 SDL_Surface *surface
1091 int bpp = surface->format->BytesPerPixel;
1092 Uint8* p = (Uint8*)surface->pixels + bpp*x + surface->pitch*y;
1093 if ( items < 3 || items > 4 )
1094 Perl_croak(aTHX_ "usage: SDL::SurfacePixel(surface,x,y,[color])");
1096 color = (SDL_Color*)SvIV(ST(3));
1097 pix = SDL_MapRGB(surface->format,color->r,color->g,color->b);
1106 if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
1107 p[0] = (pix >> 16) & 0xff;
1108 p[1] = (pix >> 8) & 0xff;
1112 p[1] = (pix >> 8) & 0xff;
1113 p[2] = (pix >> 16) & 0xff;
1121 RETVAL = (SDL_Color *) safemalloc(sizeof(SDL_Color));
1125 memcpy(RETVAL,&surface->format->palette[index],sizeof(SDL_Color));
1129 SDL_GetRGB(pix,surface->format,&r,&g,&b);
1137 SDL_GetRGB(pix,surface->format,&r,&g,&b);
1147 MUSTLOCK ( surface )
1148 SDL_Surface *surface
1150 RETVAL = SDL_MUSTLOCK(surface);
1155 SurfaceLock ( surface )
1156 SDL_Surface *surface
1158 RETVAL = SDL_LockSurface(surface);
1163 SurfaceUnlock ( surface )
1164 SDL_Surface *surface
1166 SDL_UnlockSurface(surface);
1171 RETVAL = SDL_GetVideoSurface();
1180 SDL_VideoInfo *info;
1181 info = (SDL_VideoInfo *) safemalloc ( sizeof(SDL_VideoInfo));
1182 memcpy(info,SDL_GetVideoInfo(),sizeof(SDL_VideoInfo));
1184 hv_store(hv,"hw_available",strlen("hw_available"),
1185 newSViv(info->hw_available),0);
1186 hv_store(hv,"wm_available",strlen("wm_available"),
1187 newSViv(info->wm_available),0);
1188 hv_store(hv,"blit_hw",strlen("blit_hw"),
1189 newSViv(info->blit_hw),0);
1190 hv_store(hv,"blit_hw_CC",strlen("blit_hw_CC"),
1191 newSViv(info->blit_hw_CC),0);
1192 hv_store(hv,"blit_hw_A",strlen("blit_hw_A"),
1193 newSViv(info->blit_hw_A),0);
1194 hv_store(hv,"blit_sw",strlen("blit_sw"),
1195 newSViv(info->blit_sw),0);
1196 hv_store(hv,"blit_sw_CC",strlen("blit_sw_CC"),
1197 newSViv(info->blit_sw_CC),0);
1198 hv_store(hv,"blit_sw_A",strlen("blit_sw_A"),
1199 newSViv(info->blit_sw_A),0);
1200 hv_store(hv,"blit_fill",strlen("blit_fill"),
1201 newSViv(info->blit_fill),0);
1202 hv_store(hv,"video_mem",strlen("video_mem"),
1203 newSViv(info->video_mem),0);
1209 NewRect ( x, y, w, h )
1215 RETVAL = (SDL_Rect *) safemalloc (sizeof(SDL_Rect));
1233 if (items > 1 ) rect->x = SvIV(ST(1));
1242 if (items > 1 ) rect->y = SvIV(ST(1));
1251 if (items > 1 ) rect->w = SvIV(ST(1));
1260 if (items > 1 ) rect->h = SvIV(ST(1));
1266 ListModes ( format, flags )
1268 SDL_PixelFormat *format
1272 mode = SDL_ListModes(format,flags);
1273 if (mode == (SDL_Rect**)-1 ) {
1274 av_push(RETVAL,newSVpv("all",0));
1275 } else if (! mode ) {
1276 av_push(RETVAL,newSVpv("none",0));
1278 for (;*mode;mode++) {
1279 av_push(RETVAL,newSViv(PTR2IV(*mode)));
1287 NewColor ( r, g, b )
1292 RETVAL = (SDL_Color *) safemalloc(sizeof(SDL_Color));
1300 ColorR ( color, ... )
1303 if (items > 1 ) color->r = SvIV(ST(1));
1309 ColorG ( color, ... )
1312 if (items > 1 ) color->g = SvIV(ST(1));
1318 ColorB ( color, ... )
1321 if (items > 1 ) color->b = SvIV(ST(1));
1328 ColorRGB ( color, ... )
1332 color->r = SvIV(ST(1));
1333 color->g = SvIV(ST(2));
1334 color->b = SvIV(ST(3));
1336 mXPUSHi( color->r );
1337 mXPUSHi( color->g );
1338 mXPUSHi( color->b );
1345 return; safefree(color);
1348 NewPalette ( number )
1351 RETVAL = (SDL_Palette *)safemalloc(sizeof(SDL_Palette));
1352 RETVAL->colors = (SDL_Color *)safemalloc(number *
1354 RETVAL->ncolors = number;
1359 PaletteNColors ( palette, ... )
1360 SDL_Palette *palette
1362 if ( items > 1 ) palette->ncolors = SvIV(ST(1));
1363 RETVAL = palette->ncolors;
1368 PaletteColors ( palette, index, ... )
1369 SDL_Palette *palette
1373 palette->colors[index].r = SvUV(ST(2));
1374 palette->colors[index].g = SvUV(ST(3));
1375 palette->colors[index].b = SvUV(ST(4));
1377 RETVAL = (SDL_Color *)(palette->colors + index);
1382 VideoModeOK ( width, height, bpp, flags )
1388 RETVAL = SDL_VideoModeOK(width,height,bpp,flags);
1393 SetVideoMode ( width, height, bpp, flags )
1399 RETVAL = SDL_SetVideoMode(width,height,bpp,flags);
1404 UpdateRect ( surface, x, y, w ,h )
1405 SDL_Surface *surface
1411 SDL_UpdateRect(surface,x,y,w,h);
1414 UpdateRects ( surface, ... )
1415 SDL_Surface *surface
1417 SDL_Rect *rects, *oldrects, *temp;
1419 if ( items < 2 ) return;
1420 num_rects = items - 1;
1422 rects = (SDL_Rect *)safemalloc(sizeof(SDL_Rect)*items);
1423 for(i=0;i<num_rects;i++) {
1424 temp = (SDL_Rect *)SvIV(ST(i+1));
1425 rects[i].x = temp->x;
1426 rects[i].y = temp->y;
1427 rects[i].w = temp->w;
1428 rects[i].h = temp->h;
1430 SDL_UpdateRects(surface,num_rects,rects);
1436 SDL_Surface *surface
1438 RETVAL = SDL_Flip(surface);
1443 SetColors ( surface, start, ... )
1444 SDL_Surface *surface
1447 SDL_Color *colors,*temp;
1449 if ( items < 3 ) { RETVAL = 0; goto all_done; }
1451 colors = (SDL_Color *)safemalloc(sizeof(SDL_Color)*(length+1));
1452 for ( i = 0; i < length ; i++ ) {
1453 temp = (SDL_Color *)SvIV(ST(i+2));
1454 colors[i].r = temp->r;
1455 colors[i].g = temp->g;
1456 colors[i].b = temp->b;
1458 RETVAL = SDL_SetColors(surface, colors, start, length );
1465 MapRGB ( surface, r, g, b )
1466 SDL_Surface *surface
1471 RETVAL = SDL_MapRGB(surface->format,r,g,b);
1476 MapRGBA ( surface, r, g, b, a )
1477 SDL_Surface *surface
1483 RETVAL = SDL_MapRGBA(surface->format,r,g,b,a);
1488 GetRGB ( surface, pixel )
1489 SDL_Surface *surface
1493 SDL_GetRGB(pixel,surface->format,&r,&g,&b);
1495 av_push(RETVAL,newSViv(r));
1496 av_push(RETVAL,newSViv(g));
1497 av_push(RETVAL,newSViv(b));
1502 GetRGBA ( surface, pixel )
1503 SDL_Surface *surface
1507 SDL_GetRGBA(pixel,surface->format,&r,&g,&b,&a);
1509 av_push(RETVAL,newSViv(r));
1510 av_push(RETVAL,newSViv(g));
1511 av_push(RETVAL,newSViv(b));
1512 av_push(RETVAL,newSViv(a));
1517 SaveBMP ( surface, filename )
1518 SDL_Surface *surface
1521 RETVAL = SDL_SaveBMP(surface,filename);
1526 SetColorKey ( surface, flag, key )
1527 SDL_Surface *surface
1531 Uint32 pixel = SDL_MapRGB(surface->format,key->r,key->g,key->b);
1532 RETVAL = SDL_SetColorKey(surface,flag,pixel);
1537 SetAlpha ( surface, flag, alpha )
1538 SDL_Surface *surface
1542 RETVAL = SDL_SetAlpha(surface,flag,alpha);
1547 DisplayFormat ( surface )
1548 SDL_Surface *surface
1550 RETVAL = SDL_DisplayFormat(surface);
1555 DisplayFormatAlpha ( surface )
1556 SDL_Surface *surface
1558 RETVAL = SDL_DisplayFormatAlpha(surface);
1563 ConvertRGB ( surface )
1564 SDL_Surface * surface
1566 SDL_PixelFormat fmt;
1568 fmt.BitsPerPixel = 24;
1569 fmt.BytesPerPixel = 3;
1570 fmt.Rmask = 0x000000ff;
1571 fmt.Gmask = 0x0000ff00;
1572 fmt.Bmask = 0x00ff0000;
1573 fmt.Amask = 0x00000000;
1584 RETVAL = SDL_ConvertSurface(surface,&fmt,surface->flags);
1589 ConvertRGBA ( surface )
1590 SDL_Surface * surface
1592 SDL_PixelFormat fmt;
1594 fmt.BitsPerPixel = 32;
1595 fmt.BytesPerPixel = 4;
1596 fmt.Rmask = 0x000000ff;
1597 fmt.Gmask = 0x0000ff00;
1598 fmt.Bmask = 0x00ff0000;
1599 fmt.Amask = 0xff000000;
1610 RETVAL = SDL_ConvertSurface(surface,&fmt,surface->flags);
1615 BlitSurface ( src, src_rect, dest, dest_rect )
1621 RETVAL = SDL_BlitSurface(src,src_rect,dest,dest_rect);
1626 FillRect ( dest, dest_rect, color )
1631 Uint32 pixel = SDL_MapRGB(dest->format,color->r,color->g,color->b);
1632 RETVAL = SDL_FillRect(dest,dest_rect,pixel);
1639 RETVAL = SDL_GetAppState();
1645 WMSetCaption ( title, icon )
1649 SDL_WM_SetCaption(title,icon);
1655 SDL_WM_GetCaption(&title,&icon);
1657 av_push(RETVAL,newSVpv(title,0));
1658 av_push(RETVAL,newSVpv(icon,0));
1666 SDL_WM_SetIcon(icon,NULL);
1681 mask = SDL_GetMouseState(&x,&y);
1683 av_push(RETVAL,newSViv(mask));
1684 av_push(RETVAL,newSViv(x));
1685 av_push(RETVAL,newSViv(y));
1690 GetRelativeMouseState ()
1695 mask = SDL_GetRelativeMouseState(&x,&y);
1697 av_push(RETVAL,newSViv(mask));
1698 av_push(RETVAL,newSViv(x));
1699 av_push(RETVAL,newSViv(y));
1704 NewCursor ( data, mask, x ,y )
1710 RETVAL = SDL_CreateCursor((Uint8*)data->pixels,
1711 (Uint8*)mask->pixels,data->w,data->h,x,y);
1716 FreeCursor ( cursor )
1719 SDL_FreeCursor(cursor);
1722 SetCursor ( cursor )
1725 SDL_SetCursor(cursor);
1730 RETVAL = SDL_GetCursor();
1735 ShowCursor ( toggle )
1738 RETVAL = SDL_ShowCursor(toggle);
1743 NewAudioSpec ( freq, format, channels, samples )
1749 RETVAL = (SDL_AudioSpec *)safemalloc(sizeof(SDL_AudioSpec));
1750 RETVAL->freq = freq;
1751 RETVAL->format = format;
1752 RETVAL->channels = channels;
1753 RETVAL->samples = samples;
1758 FreeAudioSpec ( spec )
1764 NewAudioCVT ( src_format, src_channels, src_rate, dst_format, dst_channels, dst_rate)
1772 RETVAL = (SDL_AudioCVT *)safemalloc(sizeof(SDL_AudioCVT));
1773 if (SDL_BuildAudioCVT(RETVAL,src_format, src_channels, src_rate,
1774 dst_format, dst_channels, dst_rate)) {
1775 safefree(RETVAL); RETVAL = NULL; }
1780 FreeAudioCVT ( cvt )
1786 ConvertAudioData ( cvt, data, len )
1792 cvt->buf = (Uint8*) safemalloc(cvt->len*cvt->len_mult);
1793 memcpy(cvt->buf,data,cvt->len);
1794 RETVAL = SDL_ConvertAudio(cvt);
1799 OpenAudio ( spec, callback )
1803 spec->userdata = (void*)callback;
1804 spec->callback = sdl_perl_audio_callback;
1805 RETVAL = SDL_OpenAudio(spec,NULL);
1812 RETVAL = SDL_GetAudioStatus ();
1820 SDL_PauseAudio(p_on);
1844 LoadWAV ( filename, spec )
1848 SDL_AudioSpec *temp;
1853 temp = SDL_LoadWAV(filename,spec,&buf,&len);
1854 if ( ! temp ) goto error;
1855 av_push(RETVAL,newSViv(PTR2IV(temp)));
1856 av_push(RETVAL,newSViv(PTR2IV(buf)));
1857 av_push(RETVAL,newSViv(len));
1862 #ifdef HAVE_SDL_MIXER
1865 MixAudio ( dst, src, len, volume )
1871 SDL_MixAudio(dst,src,len,volume);
1874 MixOpenAudio ( frequency, format, channels, chunksize )
1880 RETVAL = Mix_OpenAudio(frequency, format, channels, chunksize);
1885 MixAllocateChannels ( number )
1888 RETVAL = Mix_AllocateChannels(number);
1895 int freq, channels, status;
1897 status = Mix_QuerySpec(&freq,&format,&channels);
1899 av_push(RETVAL,newSViv(status));
1900 av_push(RETVAL,newSViv(freq));
1901 av_push(RETVAL,newSViv(format));
1902 av_push(RETVAL,newSViv(channels));
1907 MixLoadWAV ( filename )
1910 RETVAL = Mix_LoadWAV(filename);
1915 MixLoadMusic ( filename )
1918 RETVAL = Mix_LoadMUS(filename);
1923 MixQuickLoadWAV ( buf )
1926 RETVAL = Mix_QuickLoad_WAV(buf);
1931 MixFreeChunk( chunk )
1934 Mix_FreeChunk(chunk);
1937 MixFreeMusic ( music )
1940 Mix_FreeMusic(music);
1943 MixSetPostMixCallback ( func, arg )
1947 Mix_SetPostMix(func,arg);
1952 RETVAL = sdl_perl_music_callback;
1957 MixSetMusicHook ( func, arg )
1961 Mix_HookMusic(func,arg);
1964 MixSetMusicFinishedHook ( func )
1967 mix_music_finished_cv = func;
1968 Mix_HookMusicFinished(sdl_perl_music_finished_callback);
1971 MixGetMusicHookData ()
1973 RETVAL = Mix_GetMusicHookData();
1978 MixReverseChannels ( number )
1981 RETVAL = Mix_ReserveChannels ( number );
1986 MixGroupChannel ( which, tag )
1990 RETVAL = Mix_GroupChannel(which,tag);
1995 MixGroupChannels ( from, to, tag )
2000 RETVAL = Mix_GroupChannels(from,to,tag);
2005 MixGroupAvailable ( tag )
2008 RETVAL = Mix_GroupAvailable(tag);
2013 MixGroupCount ( tag )
2016 RETVAL = Mix_GroupCount(tag);
2021 MixGroupOldest ( tag )
2024 RETVAL = Mix_GroupOldest(tag);
2029 MixGroupNewer ( tag )
2032 RETVAL = Mix_GroupNewer(tag);
2037 MixPlayChannel ( channel, chunk, loops )
2042 RETVAL = Mix_PlayChannel(channel,chunk,loops);
2047 MixPlayChannelTimed ( channel, chunk, loops, ticks )
2053 RETVAL = Mix_PlayChannelTimed(channel,chunk,loops,ticks);
2058 MixPlayMusic ( music, loops )
2062 RETVAL = Mix_PlayMusic(music,loops);
2067 MixFadeInChannel ( channel, chunk, loops, ms )
2073 RETVAL = Mix_FadeInChannel(channel,chunk,loops,ms);
2078 MixFadeInChannelTimed ( channel, chunk, loops, ms, ticks )
2085 RETVAL = Mix_FadeInChannelTimed(channel,chunk,loops,ms,ticks);
2090 MixFadeInMusic ( music, loops, ms )
2095 RETVAL = Mix_FadeInMusic(music,loops,ms);
2100 MixVolume ( channel, volume )
2104 RETVAL = Mix_Volume(channel,volume);
2109 MixVolumeChunk ( chunk, volume )
2113 RETVAL = Mix_VolumeChunk(chunk,volume);
2118 MixVolumeMusic ( volume )
2121 RETVAL = Mix_VolumeMusic(volume);
2126 MixHaltChannel ( channel )
2129 RETVAL = Mix_HaltChannel(channel);
2134 MixHaltGroup ( tag )
2137 RETVAL = Mix_HaltGroup(tag);
2144 RETVAL = Mix_HaltMusic();
2149 MixExpireChannel ( channel, ticks )
2153 RETVAL = Mix_ExpireChannel ( channel,ticks);
2158 MixFadeOutChannel ( which, ms )
2162 RETVAL = Mix_FadeOutChannel(which,ms);
2167 MixFadeOutGroup ( which, ms )
2171 RETVAL = Mix_FadeOutGroup(which,ms);
2176 MixFadeOutMusic ( ms )
2179 RETVAL = Mix_FadeOutMusic(ms);
2186 RETVAL = Mix_FadingMusic();
2191 MixFadingChannel( which )
2194 RETVAL = Mix_FadingChannel(which);
2199 MixPause ( channel )
2205 MixResume ( channel )
2208 Mix_Resume(channel);
2211 MixPaused ( channel )
2214 RETVAL = Mix_Paused(channel);
2236 RETVAL = Mix_PausedMusic();
2241 MixPlaying( channel )
2244 RETVAL = Mix_Playing(channel);
2251 RETVAL = Mix_PlayingMusic();
2264 GLLoadLibrary ( path )
2267 RETVAL = SDL_GL_LoadLibrary(path);
2272 GLGetProcAddress ( proc )
2275 RETVAL = SDL_GL_GetProcAddress(proc);
2280 GLSetAttribute ( attr, value )
2284 RETVAL = SDL_GL_SetAttribute(attr, value);
2289 GLGetAttribute ( attr )
2294 av_push(RETVAL,newSViv(SDL_GL_GetAttribute(attr, &value)));
2295 av_push(RETVAL,newSViv(value));
2302 SDL_GL_SwapBuffers ();
2308 RETVAL = (SDL_BYTEORDER == SDL_BIG_ENDIAN);
2315 RETVAL = SDL_NumJoysticks();
2320 JoystickName ( index )
2323 RETVAL = (char*)SDL_JoystickName(index);
2328 JoystickOpen ( index )
2331 RETVAL = SDL_JoystickOpen(index);
2336 JoystickOpened ( index )
2339 RETVAL = SDL_JoystickOpened(index);
2344 JoystickIndex ( joystick )
2345 SDL_Joystick *joystick
2347 RETVAL = SDL_JoystickIndex(joystick);
2352 JoystickNumAxes ( joystick )
2353 SDL_Joystick *joystick
2355 RETVAL = SDL_JoystickNumAxes(joystick);
2360 JoystickNumBalls ( joystick )
2361 SDL_Joystick *joystick
2363 RETVAL = SDL_JoystickNumBalls(joystick);
2368 JoystickNumHats ( joystick )
2369 SDL_Joystick *joystick
2371 RETVAL = SDL_JoystickNumHats(joystick);
2376 JoystickNumButtons ( joystick )
2377 SDL_Joystick *joystick
2379 RETVAL = SDL_JoystickNumButtons(joystick);
2386 SDL_JoystickUpdate();
2389 JoystickGetAxis ( joystick, axis )
2390 SDL_Joystick *joystick
2393 RETVAL = SDL_JoystickGetAxis(joystick,axis);
2398 JoystickGetHat ( joystick, hat )
2399 SDL_Joystick *joystick
2402 RETVAL = SDL_JoystickGetHat(joystick,hat);
2407 JoystickGetButton ( joystick, button)
2408 SDL_Joystick *joystick
2411 RETVAL = SDL_JoystickGetButton(joystick,button);
2416 JoystickGetBall ( joystick, ball )
2417 SDL_Joystick *joystick
2421 success = SDL_JoystickGetBall(joystick,ball,&dx,&dy);
2423 av_push(RETVAL,newSViv(success));
2424 av_push(RETVAL,newSViv(dx));
2425 av_push(RETVAL,newSViv(dy));
2430 JoystickClose ( joystick )
2431 SDL_Joystick *joystick
2433 SDL_JoystickClose(joystick);
2436 JoyAxisEventWhich ( e )
2439 RETVAL = e->jaxis.which;
2444 JoyAxisEventAxis ( e )
2447 RETVAL = e->jaxis.axis;
2452 JoyAxisEventValue ( e )
2455 RETVAL = e->jaxis.value;
2460 JoyButtonEventWhich ( e )
2463 RETVAL = e->jbutton.which;
2468 JoyButtonEventButton ( e )
2471 RETVAL = e->jbutton.button;
2476 JoyButtonEventState ( e )
2479 RETVAL = e->jbutton.state;
2484 JoyHatEventWhich ( e )
2487 RETVAL = e->jhat.which;
2492 JoyHatEventHat ( e )
2495 RETVAL = e->jhat.hat;
2500 JoyHatEventValue ( e )
2503 RETVAL = e->jhat.value;
2508 JoyBallEventWhich ( e )
2511 RETVAL = e->jball.which;
2516 JoyBallEventBall ( e )
2519 RETVAL = e->jball.ball;
2524 JoyBallEventXrel ( e )
2527 RETVAL = e->jball.xrel;
2532 JoyBallEventYrel ( e )
2535 RETVAL = e->jball.yrel;
2540 SetClipRect ( surface, rect )
2541 SDL_Surface *surface
2544 SDL_SetClipRect(surface,rect);
2547 GetClipRect ( surface )
2548 SDL_Surface *surface
2550 RETVAL = (SDL_Rect*) safemalloc(sizeof(SDL_Rect));
2551 SDL_GetClipRect(surface,RETVAL);
2561 RETVAL = SDLNet_Init();
2571 NetNewIPaddress ( host, port )
2575 RETVAL = (IPaddress*) safemalloc(sizeof(IPaddress));
2576 RETVAL->host = host;
2577 RETVAL->port = port;
2582 NetIPaddressHost ( ip )
2590 NetIPaddressPort ( ip )
2598 NetFreeIPaddress ( ip )
2604 NetResolveIP ( address )
2607 RETVAL = SDLNet_ResolveIP(address);
2612 NetResolveHost ( address, host, port )
2617 RETVAL = SDLNet_ResolveHost(address,host,port);
2625 RETVAL = SDLNet_TCP_Open(ip);
2630 NetTCPAccept ( server )
2633 RETVAL = SDLNet_TCP_Accept(server);
2638 NetTCPGetPeerAddress ( sock )
2641 RETVAL = SDLNet_TCP_GetPeerAddress(sock);
2646 NetTCPSend ( sock, data, len )
2651 RETVAL = SDLNet_TCP_Send(sock,data,len);
2656 NetTCPRecv ( sock, maxlen )
2662 buffer = safemalloc(maxlen);
2664 status = SDLNet_TCP_Recv(sock,buffer,maxlen);
2665 av_push(RETVAL,newSViv(status));
2666 av_push(RETVAL,newSVpvn((char*)buffer,maxlen));
2671 NetTCPClose ( sock )
2674 SDLNet_TCP_Close(sock);
2677 NetAllocPacket ( size )
2680 RETVAL = SDLNet_AllocPacket(size);
2685 NetAllocPacketV ( howmany, size )
2689 RETVAL = SDLNet_AllocPacketV(howmany,size);
2694 NetResizePacket ( packet, newsize )
2698 RETVAL = SDLNet_ResizePacket(packet,newsize);
2703 NetFreePacket ( packet )
2706 SDLNet_FreePacket(packet);
2709 NetFreePacketV ( packet )
2712 SDLNet_FreePacketV(packet);
2718 RETVAL = SDLNet_UDP_Open(port);
2723 NetUDPBind ( sock, channel, address )
2728 RETVAL = SDLNet_UDP_Bind(sock,channel,address);
2733 NetUDPUnbind ( sock, channel )
2737 SDLNet_UDP_Unbind(sock,channel);
2740 NetUDPGetPeerAddress ( sock, channel )
2744 RETVAL = SDLNet_UDP_GetPeerAddress(sock,channel);
2749 NetUDPSendV ( sock, packets, npackets )
2754 RETVAL = SDLNet_UDP_SendV(sock,packets,npackets);
2759 NetUDPSend ( sock, channel, packet )
2764 RETVAL = SDLNet_UDP_Send(sock,channel,packet);
2769 NetUDPRecvV ( sock, packets )
2773 RETVAL = SDLNet_UDP_RecvV(sock,packets);
2778 NetUDPRecv ( sock, packet )
2782 RETVAL = SDLNet_UDP_Recv(sock,packet);
2787 NetUDPClose ( sock )
2790 SDLNet_UDP_Close(sock);
2793 NetAllocSocketSet ( maxsockets )
2796 RETVAL = SDLNet_AllocSocketSet(maxsockets);
2801 NetTCP_AddSocket ( set, sock )
2802 SDLNet_SocketSet set
2805 RETVAL = SDLNet_TCP_AddSocket(set,sock);
2810 NetUDP_AddSocket ( set, sock )
2811 SDLNet_SocketSet set
2814 RETVAL = SDLNet_UDP_AddSocket(set,sock);
2819 NetTCP_DelSocket ( set, sock )
2820 SDLNet_SocketSet set
2823 RETVAL = SDLNet_TCP_DelSocket(set,sock);
2828 NetUDP_DelSocket ( set, sock )
2829 SDLNet_SocketSet set
2832 RETVAL = SDLNet_UDP_DelSocket(set,sock);
2837 NetCheckSockets ( set, timeout )
2838 SDLNet_SocketSet set
2841 RETVAL = SDLNet_CheckSockets(set,timeout);
2846 NetSocketReady ( sock )
2847 SDLNet_GenericSocket sock
2849 RETVAL = SDLNet_SocketReady(sock);
2854 NetFreeSocketSet ( set )
2855 SDLNet_SocketSet set
2857 SDLNet_FreeSocketSet(set);
2860 NetWrite16 ( value, area )
2864 SDLNet_Write16(value,area);
2867 NetWrite32 ( value, area )
2871 SDLNet_Write32(value,area);
2877 RETVAL = SDLNet_Read16(area);
2885 RETVAL = SDLNet_Read32(area);
2896 RETVAL = TTF_Init();
2906 TTFOpenFont ( file, ptsize )
2910 RETVAL = TTF_OpenFont(file,ptsize);
2915 TTFGetFontStyle ( font )
2918 RETVAL = TTF_GetFontStyle(font);
2923 TTFSetFontStyle ( font, style )
2927 TTF_SetFontStyle(font,style);
2930 TTFFontHeight ( font )
2933 RETVAL = TTF_FontHeight(font);
2938 TTFFontAscent ( font )
2941 RETVAL = TTF_FontAscent(font);
2946 TTFFontDescent ( font )
2949 RETVAL = TTF_FontDescent(font);
2954 TTFFontLineSkip ( font )
2957 RETVAL = TTF_FontLineSkip(font);
2962 TTFGlyphMetrics ( font, ch )
2966 int minx, miny, maxx, maxy, advance;
2968 TTF_GlyphMetrics(font, ch, &minx, &miny, &maxx, &maxy, &advance);
2969 av_push(RETVAL,newSViv(minx));
2970 av_push(RETVAL,newSViv(miny));
2971 av_push(RETVAL,newSViv(maxx));
2972 av_push(RETVAL,newSViv(maxy));
2973 av_push(RETVAL,newSViv(advance));
2978 TTFSizeText ( font, text )
2984 if(TTF_SizeText(font,text,&w,&h))
2986 av_push(RETVAL,newSViv(w));
2987 av_push(RETVAL,newSViv(h));
2988 sv_2mortal((SV*)RETVAL);
2992 printf("TTF error at TTFSizeText: %s \n", TTF_GetError());
2993 Perl_croak (aTHX_ "TTF error \n");
3002 TTFSizeUTF8 ( font, text )
3008 if(TTF_SizeUTF8(font,text,&w,&h))
3010 av_push(RETVAL,newSViv(w));
3011 av_push(RETVAL,newSViv(h));
3012 sv_2mortal((SV*)RETVAL);
3017 printf("TTF error at TTFSizeUTF8 with : %s \n", TTF_GetError());
3018 Perl_croak (aTHX_ "TTF error \n");
3025 TTFSizeUNICODE ( font, text )
3031 if(TTF_SizeUNICODE(font,text,&w,&h))
3033 av_push(RETVAL,newSViv(w));
3034 av_push(RETVAL,newSViv(h));
3035 sv_2mortal((SV*)RETVAL);
3040 printf("TTF error at TTFSizeUNICODE : %s \n", TTF_GetError());
3041 Perl_croak (aTHX_ "TTF error \n");
3048 TTFRenderTextSolid ( font, text, fg )
3053 RETVAL = TTF_RenderText_Solid(font,text,*fg);
3058 TTFRenderUTF8Solid ( font, text, fg )
3063 RETVAL = TTF_RenderUTF8_Solid(font,text,*fg);
3068 TTFRenderUNICODESolid ( font, text, fg )
3073 RETVAL = TTF_RenderUNICODE_Solid(font,text,*fg);
3078 TTFRenderGlyphSolid ( font, ch, fg )
3083 RETVAL = TTF_RenderGlyph_Solid(font,ch,*fg);
3088 TTFRenderTextShaded ( font, text, fg, bg )
3094 RETVAL = TTF_RenderText_Shaded(font,text,*fg,*bg);
3099 TTFRenderUTF8Shaded( font, text, fg, bg )
3105 RETVAL = TTF_RenderUTF8_Shaded(font,text,*fg,*bg);
3110 TTFRenderUNICODEShaded( font, text, fg, bg )
3116 RETVAL = TTF_RenderUNICODE_Shaded(font,text,*fg,*bg);
3121 TTFRenderGlyphShaded ( font, ch, fg, bg )
3127 RETVAL = TTF_RenderGlyph_Shaded(font,ch,*fg,*bg);
3132 TTFRenderTextBlended( font, text, fg )
3137 RETVAL = TTF_RenderText_Blended(font,text,*fg);
3142 TTFRenderUTF8Blended( font, text, fg )
3147 RETVAL = TTF_RenderUTF8_Blended(font,text,*fg);
3152 TTFRenderUNICODEBlended( font, text, fg )
3157 RETVAL = TTF_RenderUNICODE_Blended(font,text,*fg);
3162 TTFRenderGlyphBlended( font, ch, fg )
3167 RETVAL = TTF_RenderGlyph_Blended(font,ch,*fg);
3172 TTFCloseFont ( font )
3175 TTF_CloseFont(font);
3176 font=NULL; //to be safe http://sdl.beuc.net/sdl.wiki/SDL_ttf_copy_Functions_Management_TTF_CloseFont
3179 TTFPutString ( font, mode, surface, x, y, fg, bg, text )
3182 SDL_Surface *surface
3197 img = TTF_RenderText_Solid(font,text,*fg);
3198 TTF_SizeText(font,text,&w,&h);
3203 img = TTF_RenderText_Shaded(font,text,*fg,*bg);
3204 TTF_SizeText(font,text,&w,&h);
3209 img = TTF_RenderText_Blended(font,text,*fg);
3210 TTF_SizeText(font,text,&w,&h);
3215 img = TTF_RenderUTF8_Solid(font,text,*fg);
3216 TTF_SizeUTF8(font,text,&w,&h);
3221 img = TTF_RenderUTF8_Shaded(font,text,*fg,*bg);
3222 TTF_SizeUTF8(font,text,&w,&h);
3227 img = TTF_RenderUTF8_Blended(font,text,*fg);
3228 TTF_SizeUTF8(font,text,&w,&h);
3233 img = TTF_RenderUNICODE_Solid(font,(Uint16*)text,*fg);
3234 TTF_SizeUNICODE(font,(Uint16*)text,&w,&h);
3238 case UNICODE_SHADED:
3239 img = TTF_RenderUNICODE_Shaded(font,(Uint16*)text,*fg,*bg);
3240 TTF_SizeUNICODE(font,(Uint16*)text,&w,&h);
3244 case UNICODE_BLENDED:
3245 img = TTF_RenderUNICODE_Blended(font,(Uint16*)text,*fg);
3246 TTF_SizeUNICODE(font,(Uint16*)text,&w,&h);
3251 img = TTF_RenderText_Shaded(font,text,*fg,*bg);
3252 TTF_SizeText(font,text,&w,&h);
3256 if ( img && img->format && img->format->palette ) {
3257 SDL_Color *c = &img->format->palette->colors[0];
3258 Uint32 key = SDL_MapRGB( img->format, c->r, c->g, c->b );
3259 SDL_SetColorKey(img,SDL_SRCCOLORKEY,key );
3260 if (0 > SDL_BlitSurface(img,NULL,surface,&dest)) {
3261 SDL_FreeSurface(img);
3273 CreateYUVOverlay ( width, height, format, display )
3277 SDL_Surface *display
3279 RETVAL = SDL_CreateYUVOverlay ( width, height, format, display );
3284 LockYUVOverlay ( overlay )
3285 SDL_Overlay *overlay
3287 RETVAL = SDL_LockYUVOverlay(overlay);
3292 UnlockYUVOverlay ( overlay )
3293 SDL_Overlay *overlay
3295 SDL_UnlockYUVOverlay(overlay);
3298 DisplayYUVOverlay ( overlay, dstrect )
3299 SDL_Overlay *overlay
3302 RETVAL = SDL_DisplayYUVOverlay ( overlay, dstrect );
3307 FreeYUVOverlay ( overlay )
3308 SDL_Overlay *overlay
3310 SDL_FreeYUVOverlay ( overlay );
3313 OverlayFormat ( overlay, ... )
3314 SDL_Overlay *overlay
3317 overlay->format = SvIV(ST(1));
3318 RETVAL = overlay->format;
3323 OverlayW ( overlay, ... )
3324 SDL_Overlay *overlay
3327 overlay->w = SvIV(ST(1));
3328 RETVAL = overlay->w;
3333 OverlayH ( overlay, ... )
3334 SDL_Overlay *overlay
3337 overlay->h = SvIV(ST(1));
3338 RETVAL = overlay->h;
3343 OverlayPlanes ( overlay, ... )
3344 SDL_Overlay *overlay
3347 overlay->planes = SvIV(ST(1));
3348 RETVAL = overlay->planes;
3353 OverlayHW ( overlay )
3354 SDL_Overlay *overlay
3356 RETVAL = overlay->hw_overlay;
3361 OverlayPitches ( overlay )
3362 SDL_Overlay *overlay
3364 RETVAL = overlay->pitches;
3369 OverlayPixels ( overlay )
3370 SDL_Overlay *overlay
3372 RETVAL = overlay->pixels;
3377 WMToggleFullScreen ( surface )
3378 SDL_Surface *surface
3380 RETVAL = SDL_WM_ToggleFullScreen(surface);
3385 WMGrabInput ( mode )
3388 RETVAL = SDL_WM_GrabInput(mode);
3395 RETVAL = SDL_WM_IconifyWindow();
3403 RETVAL = e->resize.w;
3411 RETVAL = e->resize.h;
3419 RETVAL = SDL_AudioDriverName(name,32);
3427 if (k >= SDLK_LAST) Perl_croak (aTHX_ "Key out of range");
3428 RETVAL = SDL_GetKeyState(NULL)[k];
3437 RETVAL = (SMPEG_Info *) safemalloc (sizeof(SMPEG_Info));
3442 FreeSMPEGInfo ( info )
3448 SMPEGInfoHasAudio ( info )
3451 RETVAL = info->has_audio;
3456 SMPEGInfoHasVideo ( info )
3459 RETVAL = info->has_video;
3464 SMPEGInfoWidth ( info )
3467 RETVAL = info->width;
3472 SMPEGInfoHeight ( info )
3475 RETVAL = info->height;
3480 SMPEGInfoCurrentFrame ( info )
3483 RETVAL = info->current_frame;
3488 SMPEGInfoCurrentFPS ( info )
3491 RETVAL = info->current_fps;
3496 SMPEGInfoCurrentAudioFrame ( info )
3499 RETVAL = info->audio_current_frame;
3504 SMPEGInfoCurrentOffset ( info )
3507 RETVAL = info->current_offset;
3512 SMPEGInfoTotalSize ( info )
3515 RETVAL = info->total_size;
3520 SMPEGInfoCurrentTime ( info )
3523 RETVAL = info->current_time;
3528 SMPEGInfoTotalTime ( info )
3531 RETVAL = info->total_time;
3539 RETVAL = SMPEG_error(mpeg);
3544 NewSMPEG ( filename, info, use_audio )
3549 #ifdef HAVE_SDL_MIXER
3550 RETVAL = SMPEG_new(filename,info,0);
3552 RETVAL = SMPEG_new(filename,info,use_audio);
3564 SMPEGEnableAudio ( mpeg , flag )
3568 SMPEG_enableaudio(mpeg,flag);
3569 #ifdef HAVE_SDL_MIXER
3570 sdl_perl_use_smpeg_audio = flag;
3574 SMPEGEnableVideo ( mpeg , flag )
3578 SMPEG_enablevideo(mpeg,flag);
3581 SMPEGSetVolume ( mpeg , volume )
3585 SMPEG_setvolume(mpeg,volume);
3588 SMPEGSetDisplay ( mpeg, dest, surfLock )
3593 SMPEG_setdisplay(mpeg,dest,surfLock,NULL);
3596 SMPEGScaleXY ( mpeg, w, h)
3601 SMPEG_scaleXY(mpeg,w,h);
3604 SMPEGScale ( mpeg, scale )
3608 SMPEG_scale(mpeg,scale);
3614 SDL_AudioSpec audiofmt;
3617 #ifdef HAVE_SDL_MIXER
3618 if (sdl_perl_use_smpeg_audio ) {
3619 SMPEG_enableaudio(mpeg, 0);
3620 Mix_QuerySpec(&freq, &format, &channels);
3621 audiofmt.format = format;
3622 audiofmt.freq = freq;
3623 audiofmt.channels = channels;
3624 SMPEG_actualSpec(mpeg, &audiofmt);
3625 Mix_HookMusic(SMPEG_playAudioSDL, mpeg);
3626 SMPEG_enableaudio(mpeg, 1);
3632 SMPEGStatus ( mpeg )
3635 RETVAL = SMPEG_status(mpeg);
3646 SMPEGLoop ( mpeg, repeat )
3650 SMPEG_loop(mpeg,repeat);
3657 #ifdef HAVE_SDL_MIXER
3658 Mix_HookMusic(NULL, NULL);
3662 SMPEGRewind ( mpeg )
3668 SMPEGSeek ( mpeg, bytes )
3672 SMPEG_seek(mpeg,bytes);
3675 SMPEGSkip ( mpeg, seconds )
3679 SMPEG_skip(mpeg,seconds);
3682 SMPEGSetDisplayRegion ( mpeg, rect )
3686 SMPEG_setdisplayregion(mpeg,rect->x,rect->y,rect->w,rect->h);
3689 SMPEGRenderFrame ( mpeg, frame )
3693 SMPEG_renderFrame(mpeg,frame);
3696 SMPEGGetInfo ( mpeg )
3699 RETVAL = (SMPEG_Info *) safemalloc (sizeof(SMPEG_Info));
3700 SMPEG_getinfo(mpeg,RETVAL);
3710 GFXRotoZoom ( src, angle, zoom, smooth)
3716 RETVAL = rotozoomSurface( src, angle, zoom, smooth);
3721 GFXZoom ( src, zoomx, zoomy, smooth)
3727 RETVAL = zoomSurface( src, zoomx, zoomy, smooth);
3732 GFXPixelColor ( dst, x, y, color )
3738 RETVAL = pixelColor( dst, x, y, color);
3743 GFXPixelRGBA ( dst, x, y, r, g, b, a )
3752 RETVAL = pixelRGBA( dst, x, y, r, g, b, a );
3757 GFXHlineColor ( dst, x1, x2, y, color )
3764 RETVAL = hlineColor( dst, x1, x2, y, color );
3769 GFXHlineRGBA ( dst, x1, x2, y, r, g, b, a )
3779 RETVAL = hlineRGBA( dst, x1, x2, y, r, g, b, a );
3784 GFXVlineColor ( dst, x, y1, y2, color )
3791 RETVAL = vlineColor( dst, x, y1, y2, color );
3796 GFXVlineRGBA ( dst, x, y1, y2, r, g, b, a )
3806 RETVAL = vlineRGBA( dst, x, y1, y2, r, g, b, a );
3811 GFXRectangleColor ( dst, x1, y1, x2, y2, color )
3819 RETVAL = rectangleColor( dst, x1, y1, x2, y2, color );
3824 GFXRectangleRGBA ( dst, x1, y1, x2, y2, r, g, b, a )
3835 RETVAL = rectangleRGBA( dst, x1, y1, x2, y2, r, g, b, a );
3840 GFXBoxColor ( dst, x1, y1, x2, y2, color )
3848 RETVAL = boxColor( dst, x1, y1, x2, y2, color );
3853 GFXBoxRGBA ( dst, x1, y1, x2, y2, r, g, b, a )
3864 RETVAL = boxRGBA( dst, x1, y1, x2, y2, r, g, b, a );
3869 GFXLineColor ( dst, x1, y1, x2, y2, color )
3877 RETVAL = lineColor( dst, x1, y1, x2, y2, color );
3882 GFXLineRGBA ( dst, x1, y1, x2, y2, r, g, b, a )
3893 RETVAL = lineRGBA( dst, x1, y1, x2, y2, r, g, b, a );
3898 GFXAalineColor ( dst, x1, y1, x2, y2, color )
3906 RETVAL = aalineColor( dst, x1, y1, x2, y2, color );
3911 GFXAalineRGBA ( dst, x1, y1, x2, y2, r, g, b, a )
3922 RETVAL = aalineRGBA( dst, x1, y1, x2, y2, r, g, b, a );
3927 GFXCircleColor ( dst, x, y, r, color )
3934 RETVAL = circleColor( dst, x, y, r, color );
3939 GFXCircleRGBA ( dst, x, y, rad, r, g, b, a )
3949 RETVAL = circleRGBA( dst, x, y, rad, r, g, b, a );
3954 GFXAacircleColor ( dst, x, y, r, color )
3961 RETVAL = aacircleColor( dst, x, y, r, color );
3966 GFXAacircleRGBA ( dst, x, y, rad, r, g, b, a )
3976 RETVAL = aacircleRGBA( dst, x, y, rad, r, g, b, a );
3981 GFXFilledCircleColor ( dst, x, y, r, color )
3988 RETVAL = filledCircleColor( dst, x, y, r, color );
3993 GFXFilledCircleRGBA ( dst, x, y, rad, r, g, b, a )
4003 RETVAL = filledCircleRGBA( dst, x, y, rad, r, g, b, a );
4008 GFXEllipseColor ( dst, x, y, rx, ry, color )
4016 RETVAL = ellipseColor( dst, x, y, rx, ry, color );
4021 GFXEllipseRGBA ( dst, x, y, rx, ry, r, g, b, a )
4032 RETVAL = ellipseRGBA( dst, x, y, rx, ry, r, g, b, a );
4037 GFXAaellipseColor ( dst, xc, yc, rx, ry, color )
4045 RETVAL = aaellipseColor( dst, xc, yc, rx, ry, color );
4050 GFXAaellipseRGBA ( dst, x, y, rx, ry, r, g, b, a )
4061 RETVAL = aaellipseRGBA( dst, x, y, rx, ry, r, g, b, a );
4066 GFXFilledEllipseColor ( dst, x, y, rx, ry, color )
4074 RETVAL = filledEllipseColor( dst, x, y, rx, ry, color );
4079 GFXFilledEllipseRGBA ( dst, x, y, rx, ry, r, g, b, a )
4090 RETVAL = filledEllipseRGBA( dst, x, y, rx, ry, r, g, b, a );
4095 GFXFilledPieColor ( dst, x, y, rad, start, end, color )
4104 RETVAL = filledPieColor( dst, x, y, rad, start, end, color );
4109 GFXFilledPieRGBA ( dst, x, y, rad, start, end, r, g, b, a )
4121 RETVAL = filledPieRGBA( dst, x, y, rad, start, end, r, g, b, a );
4126 GFXPolygonColor ( dst, vx, vy, n, color )
4133 RETVAL = polygonColor( dst, vx, vy, n, color );
4138 GFXPolygonRGBA ( dst, vx, vy, n, r, g, b, a )
4148 RETVAL = polygonRGBA( dst, vx, vy, n, r, g, b, a );
4153 GFXAapolygonColor ( dst, vx, vy, n, color )
4160 RETVAL = aapolygonColor( dst, vx, vy, n, color );
4165 GFXAapolygonRGBA ( dst, vx, vy, n, r, g, b, a )
4175 RETVAL = aapolygonRGBA( dst, vx, vy, n, r, g, b, a );
4180 GFXFilledPolygonColor ( dst, vx, vy, n, color )
4187 RETVAL = filledPolygonColor( dst, vx, vy, n, color );
4192 GFXFilledPolygonRGBA ( dst, vx, vy, n, r, g, b, a )
4202 RETVAL = filledPolygonRGBA( dst, vx, vy, n, r, g, b, a );
4207 GFXCharacterColor ( dst, x, y, c, color )
4214 RETVAL = characterColor( dst, x, y, c, color );
4219 GFXCharacterRGBA ( dst, x, y, c, r, g, b, a )
4229 RETVAL = characterRGBA( dst, x, y, c, r, g, b, a );
4234 GFXStringColor ( dst, x, y, c, color )
4241 RETVAL = stringColor( dst, x, y, c, color );
4246 GFXStringRGBA ( dst, x, y, c, r, g, b, a )
4256 RETVAL = stringRGBA( dst, x, y, c, r, g, b, a );
4266 SVG_Load ( filename )
4269 RETVAL = SVG_Load(filename);
4274 SVG_LoadBuffer ( data, len )
4278 RETVAL = SVG_LoadBuffer(data,len);
4283 SVG_SetOffset ( source, xoff, yoff )
4284 SDL_svg_context* source
4288 RETVAL = SVG_SetOffset(source,xoff,yoff);
4293 SVG_SetScale ( source, xscale, yscale )
4294 SDL_svg_context* source
4298 RETVAL = SVG_SetScale(source,xscale,yscale);
4303 SVG_RenderToSurface ( source, x, y, dest )
4304 SDL_svg_context* source
4309 RETVAL = SVG_RenderToSurface(source,x,y,dest);
4315 SDL_svg_context* source
4320 SVG_Set_Flags ( source, flags )
4321 SDL_svg_context* source
4324 SVG_Set_Flags(source,flags);
4327 SVG_Width ( source )
4328 SDL_svg_context* source
4330 RETVAL = SVG_Width(source);
4335 SVG_HEIGHT ( source )
4336 SDL_svg_context* source
4338 RETVAL = SVG_Height(source);
4343 SVG_SetClipping ( source, minx, miny, maxx, maxy )
4344 SDL_svg_context* source
4350 SVG_SetClipping(source,minx,miny,maxx,maxy);
4355 RETVAL = SVG_Version();
4362 #ifdef HAVE_SDL_SOUND
4365 SoundAudioInfoFormat ( audioinfo )
4366 Sound_AudioInfo* audioinfo
4368 RETVAL = audioinfo->format;
4373 SoundAudioInfoChannels ( audioinfo )
4374 Sound_AudioInfo* audioinfo
4376 RETVAL = audioinfo->channels;
4381 SoundAudioInforate ( audioinfo )
4382 Sound_AudioInfo* audioinfo
4384 RETVAL = audioinfo->rate;
4389 SoundDecoderInfoExtensions ( decoderinfo )
4390 Sound_DecoderInfo* decoderinfo
4393 for ( ext = decoderinfo->extensions; *ext != NULL; ext++ ){
4394 av_push(RETVAL,newSVpv(*ext,0));
4400 SoundDecoderInfoDescription ( decoderinfo )
4401 Sound_DecoderInfo* decoderinfo
4403 RETVAL = decoderinfo->description;
4408 SoundDecoderInfoAuthor ( decoderinfo )
4409 Sound_DecoderInfo* decoderinfo
4411 RETVAL = decoderinfo->author;
4416 SoundDecoderInfoUrl ( decoderinfo )
4417 Sound_DecoderInfo* decoderinfo
4419 RETVAL = decoderinfo->url;
4423 const Sound_DecoderInfo*
4424 SoundSampleDecoder ( sample )
4425 Sound_Sample* sample
4427 RETVAL = sample->decoder;
4432 SoundSampleDesired ( sample )
4433 Sound_Sample* sample
4435 RETVAL = &sample->desired;
4440 SoundSampleAcutal ( sample )
4441 Sound_Sample* sample
4443 RETVAL = &sample->actual;
4448 SoundSampleBuffer ( sample )
4449 Sound_Sample* sample
4451 RETVAL = sample->buffer;
4456 SoundSampleBufferSize ( sample )
4457 Sound_Sample* sample
4459 RETVAL = sample->buffer_size;
4464 SoundSampleFlags ( sample )
4465 Sound_Sample* sample
4467 RETVAL = (Uint32)sample->flags;
4474 RETVAL = Sound_Init();
4481 RETVAL = Sound_Quit();
4486 Sound_AvailableDecoders ( )
4489 const Sound_DecoderInfo** sdi;
4490 sdi = Sound_AvailableDecoders();
4492 for (;*sdi != NULL; ++sdi) {
4493 av_push(RETVAL,sv_2mortal(newSViv(PTR2IV(*sdi))));
4502 RETVAL = Sound_GetError();
4507 Sound_ClearError ( )
4512 Sound_NewSample ( rw, ext, desired, buffsize )
4515 Sound_AudioInfo* desired
4518 RETVAL = Sound_NewSample(rw,ext,desired,buffsize);
4523 Sound_NewSampleFromMem ( data, size, ext, desired, buffsize )
4527 Sound_AudioInfo* desired
4530 RETVAL = Sound_NewSampleFromMem(data,size,ext,desired,buffsize);
4535 Sound_NewSampleFromFile ( fname, desired, buffsize )
4537 Sound_AudioInfo* desired
4540 RETVAL = Sound_NewSampleFromFile(fname,desired,buffsize);
4545 Sound_FreeSample ( sample )
4546 Sound_Sample* sample
4548 Sound_FreeSample(sample);
4551 Sound_GetDuration ( sample )
4552 Sound_Sample* sample
4554 RETVAL = Sound_GetDuration(sample);
4559 Sound_SetBufferSize ( sample, size )
4560 Sound_Sample* sample
4563 RETVAL = Sound_SetBufferSize(sample,size);
4568 Sound_Decode ( sample )
4569 Sound_Sample* sample
4571 RETVAL = Sound_Decode(sample);
4576 Sound_DecodeAll ( sample )
4577 Sound_Sample* sample
4579 RETVAL = Sound_DecodeAll(sample);
4584 Sound_Rewind ( sample )
4585 Sound_Sample* sample
4587 RETVAL = Sound_Rewind(sample);
4592 Sound_Seek ( sample, ms )
4593 Sound_Sample* sample
4596 RETVAL = Sound_Seek(sample,ms);
4602 MODULE = SDL PACKAGE = SDL
4603 PROTOTYPES : DISABLE