def video_autoinit(): if not sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO): pre_video_init() if sdl.SDL_InitSubSystem(sdl.SDL_INIT_VIDEO): return False sdl.SDL_EnableUNICODE(1) return True
def set_palette(self, colors): """ set_palette([RGB, RGB, RGB, ...]) -> None set the color palette for an 8bit Surface """ palette = self._format.palette if not palette: raise SDLError("Surface has no palette") if not hasattr(colors, '__iter__'): raise ValueError("Argument must be a sequence type") if not sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO): raise SDLError( "cannot set palette without pygame.display initialized") length = min(palette.ncolors, len(colors)) c_colors = ffi.new('SDL_Color[]', length) for i in range(length): rgb = colors[i] if (not hasattr(rgb, '__iter__')) or len(rgb) < 3 or len(rgb) > 4: raise ValueError("takes a sequence of integers of RGB") c_colors[i].r = rgb[0] c_colors[i].g = rgb[1] c_colors[i].b = rgb[2] if len(rgb) == 4 and rgb[3] != 255: raise ValueError("takes an alpha value of 255") sdl.SDL_SetColors(self._c_surface, c_colors, 0, length)
def get_busy(): """get_busy(): return bool test if any sound is being mixed""" if not sdl.SDL_WasInit(sdl.SDL_INIT_AUDIO): return False return sdl.Mix_Playing(-1) != 0
def autoinit(): if not sdl.SDL_WasInit(sdl.SDL_INIT_JOYSTICK): if sdl.SDL_InitSubSystem(sdl.SDL_INIT_JOYSTICK): return False sdl.SDL_JoystickEventState(sdl.SDL_ENABLE) register_quit(autoquit) return True
def __del__(self): if self._c_surface and (sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO) or not \ (self._c_surface.flags & sdl.SDL_HWSURFACE)): sdl.SDL_FreeSurface(self._c_surface) self._c_surface = None self._format = None self._w = None self._h = None
def autoquit(): for joydata in Joystick._OPEN_JOYSTICKS: sdl.SDL_JoystickClose(joydata) Joystick._OPEN_JOYSTICKS.clear() if sdl.SDL_WasInit(sdl.SDL_INIT_JOYSTICK): sdl.SDL_JoystickEventState(sdl.SDL_DISABLE) sdl.SDL_QuitSubSystem(sdl.SDL_INIT_JOYSTICK)
def _timer_callback(interval, param): if sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO): event = ffi.new("SDL_Event*") event.type = ffi.cast("intptr_t", param) # SDL will make a copy of the event while handling SDL_PushEvent, # so we don't need to hold the allocated memory after this call. sdl.SDL_PushEvent(event) return interval
def autoinit(frequency=None, size=None, channels=None, chunksize=None): if not frequency: frequency = _request_frequency if not size: size = _request_size if not channels: channels = _request_stereo if not chunksize: chunksize = _request_chunksize if channels >= 2: channels = 2 else: channels = 1 # chunk must be a power of 2 chunksize = int(math.log(chunksize, 2)) chunksize = 2**chunksize if chunksize < buffer: chunksize *= 2 # fmt is a bunch of flags if size == 8: fmt = sdl.AUDIO_U8 elif size == -8: fmt = sdl.AUDIO_S8 elif size == 16: fmt = sdl.AUDIO_U16SYS elif size == -16: fmt = sdl.AUDIO_S16SYS else: raise ValueError("unsupported size %d" % size) global _numchanneldata, _channeldata if not sdl.SDL_WasInit(sdl.SDL_INIT_AUDIO): register_quit(autoquit) # channel stuff if not _channeldata: _numchanneldata = sdl.MIX_CHANNELS _channeldata = [ChannelData() for i in range(_numchanneldata)] if sdl.SDL_InitSubSystem(sdl.SDL_INIT_AUDIO) == -1: return False if sdl.Mix_OpenAudio(frequency, fmt, channels, chunksize) == -1: sdl.SDL_QuitSubSystem(sdl.SDL_INIT_AUDIO) return False sdl.Mix_ChannelFinished(_endsound_callback) # TODO: reverse stereo for 8-bit below SDL 1.2.8 sdl.Mix_VolumeMusic(127) return True
def _endmusic_callback(): global _current_music, _queue_music, _music_pos, _music_pos_time if _endmusic_event is not None and sdl.SDL_WasInit(sdl.SDL_INIT_AUDIO): event.post(event.Event(_endmusic_event)) if _queue_music: if _current_music: sdl.Mix_FreeMusic(_current_music) _current_music = _queue_music _queue_music = None sdl.Mix_HookMusicFinished(_endmusic_callback) _music_pos = 0 sdl.Mix_PlayMusic(_current_music, 0) else: _music_pos_time = -1 sdl.Mix_SetPostMix(ffi.NULL, ffi.NULL)
def get_init(): """get_init(): return (frequency, format, channels) test if the mixer is initialized""" if not sdl.SDL_WasInit(sdl.SDL_INIT_AUDIO): return None freq = ffi.new("int *") audioformat = ffi.new("uint16_t *") chan = ffi.new("int *") if not sdl.Mix_QuerySpec(freq, audioformat, chan): return None if audioformat[0] & ~0xff: format_in_bits = -(audioformat[0] & 0xff) else: format_in_bits = audioformat[0] & 0xff return (int(freq[0]), format_in_bits, int(chan[0]))
def autoquit(): global _channeldata, _numchanneldata, _current_music, \ _queue_music if sdl.SDL_WasInit(sdl.SDL_INIT_AUDIO): sdl.Mix_HaltMusic() # cleanup if _channeldata: _channeldata = None _numchanneldata = 0 if _current_music: sdl.Mix_FreeMusic(_current_music) _current_music = None if _queue_music: sdl.Mix_FreeMusic(_queue_music) _queue_music = None sdl.Mix_CloseAudio() sdl.SDL_QuitSubSystem(sdl.SDL_INIT_AUDIO)
def convert(self, arg=None, flags=0): with locked(self._c_surface): if isinstance(arg, Surface): flags = arg._c_surface.flags | ( self._c_surface.flags & (sdl.SDL_SRCCOLORKEY | sdl.SDL_SRCALPHA)) newsurf = sdl.SDL_ConvertSurface(self._c_surface, arg._format, flags) elif arg is None: if sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO): newsurf = sdl.SDL_DisplayFormat(self._c_surface) else: newsurf = sdl.SDL_ConvertSurface(self._c_surface, self._format, self._c_surface.flags) else: xxx return Surface._from_sdl_surface(newsurf)
def set_palette_at(self, index, rgb): """ set_palette_at(index, RGB) -> None set the color for a single index in an 8bit Surface palette """ palette = self._format.palette if not palette: raise SDLError("Surface has no palette") if index < 0 or index >= palette.ncolors: raise IndexError("index out of bounds") if not sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO): raise SDLError("cannot set palette without pygame.display initialized") if (not hasattr(rgb, '__iter__')) or len(rgb) < 3 or len(rgb) > 4: raise ValueError("takes a sequence of integers of RGB for argument 2") color = ffi.new('SDL_Color*') color[0].r = rgb[0] color[0].g = rgb[1] color[0].b = rgb[2] sdl.SDL_SetColors(self._c_surface, color, index, 1)
def _endmusic_callback(): global _current_music, _queue_music, _music_pos, _music_pos_time if _endmusic_event is not None and sdl.SDL_WasInit(sdl.SDL_INIT_AUDIO): # Pygame doesn't do the same checks for this path as in # event.post, and people rely on that, so we also duplicate # the logic event = ffi.new('SDL_Event*') event.type = _endmusic_event sdl.SDL_PushEvent(event) if _queue_music: if _current_music: sdl.Mix_FreeMusic(_current_music) _current_music = _queue_music _queue_music = None sdl.Mix_HookMusicFinished(_endmusic_callback) _music_pos = 0 sdl.Mix_PlayMusic(_current_music, 0) else: _music_pos_time = -1 sdl.Mix_SetPostMix(ffi.NULL, ffi.NULL)
def _endsound_callback(channelnum): if not _channeldata: return data = _channeldata[channelnum] # post sound ending event if data.endevent != sdl.SDL_NOEVENT and sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO): event = ffi.new('SDL_Event*') event.type = data.endevent if event.type >= sdl.SDL_USEREVENT and event.type < sdl.SDL_NUMEVENTS: event.user.code = channelnum sdl.SDL_PushEvent(event) if data.queue: sound_chunk = data.sound.chunk data.sound = data.queue data.queue = None channelnum = sdl.Mix_PlayChannelTimed(channelnum, sound_chunk, 0, -1) if channelnum != -1: sdl.Mix_GroupChannel(channelnum, data.sound._chunk_tag) else: data.sound = None
def _get_init(): return sdl.SDL_WasInit(sdl.SDL_INIT_TIMER)
def _check_init(): if not sdl.SDL_WasInit(sdl.SDL_INIT_JOYSTICK): raise SDLError("joystick system not initialized")
def get_init(): """ get_init() -> bool Returns True if the joystick module is initialized. """ return sdl.SDL_WasInit(sdl.SDL_INIT_JOYSTICK) != 0
def get_init(): """ get_init() -> bool Returns True if the display module has been initialized """ return sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO) != 0
def __init__(self, size, flags=0, depth=0, masks=None): w, h = unpack_rect(size) if isinstance(depth, Surface): if masks: raise ValueError( "cannot pass surface for depth and color masks") surface = depth depth = 0 else: surface = None depth = int(depth) if depth and masks: Rmask, Gmask, Bmask, Amask = masks bpp = depth elif surface is None: if depth: bpp = depth Rmask, Gmask, Bmask, Amask = \ self._get_default_masks(bpp, False) elif sdl.SDL_GetVideoSurface(): pix = sdl.SDL_GetVideoSurface().format bpp = pix.BitsPerPixel Amask = pix.Amask Rmask = pix.Rmask Gmask = pix.Gmask Bmask = pix.Bmask elif sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO): pix = sdl.SDL_GetVideoInfo().vfmt bpp = pix.BitsPerPixel Amask = pix.Amask Rmask = pix.Rmask Gmask = pix.Gmask Bmask = pix.Bmask else: bpp = 32 Rmask, Gmask, Bmask, Amask = \ self._get_default_masks(32, False) # the alpha mask might be different - must update if flags & sdl.SDL_SRCALPHA: Rmask, Gmask, Bmask, Amask = \ self._get_default_masks(bpp, True) # depth argument was a Surface object else: pix = surface._c_surface.format bpp = pix.BitsPerPixel if flags & sdl.SDL_SRCALPHA: Rmask, Gmask, Bmask, Amask = \ self._get_default_masks(bpp, True) else: Amask = pix.Amask Rmask = pix.Rmask Gmask = pix.Gmask Bmask = pix.Bmask self._c_surface = sdl.SDL_CreateRGBSurface(flags, w, h, bpp, Rmask, Gmask, Bmask, Amask) self._format = self._c_surface.format self._w = self._c_surface.w self._h = self._c_surface.h if not self._c_surface: raise SDLError.from_sdl_error() if masks: """ Confirm the surface was created correctly (masks were valid). Also ensure that 24 and 32 bit surfaces have 8 bit fields (no losses). """ format = self._format Rmask = (0xFF >> format.Rloss) << format.Rshift Gmask = (0xFF >> format.Gloss) << format.Gshift Bmask = (0xFF >> format.Bloss) << format.Bshift Amask = (0xFF >> format.Aloss) << format.Ashift bad_loss = format.Rloss or format.Gloss or format.Bloss if flags & sdl.SDL_SRCALPHA: bad_loss = bad_loss or format.Aloss else: bad_loss = bad_loss or format.Aloss != 8 if (format.Rmask != Rmask or format.Gmask != Gmask or format.Bmask != Bmask or format.Amask != Amask or (format.BytesPerPixel >= 3 and bad_loss)): # Note: don't free _c_surface here. It will # be done in __del__. raise ValueError("Invalid mask values")
def blit(self, source, dest, area=None, special_flags=0): """ blit(source, dest, area=None, special_flags = 0) -> Rect draw one image onto another """ if not self._c_surface or not source._c_surface: raise SDLError("display Surface quit") if self.is_pure_opengl(): raise SDLError("Cannot blit to OPENGL Surfaces (OPENGLBLIT is ok)") srcrect = ffi.new('SDL_Rect*') destrect = ffi.new('SDL_Rect*') if area is not None: srcrect.x, srcrect.y, srcrect.w, srcrect.h = \ rect_vals_from_obj(area) else: srcrect.w = source._w srcrect.h = source._h if isinstance(dest, tuple) and len(dest) == 2: destrect.x = int(dest[0]) destrect.y = int(dest[1]) destrect.w = source._w destrect.h = source._h else: destrect.x, destrect.y, destrect.w, destrect.h = \ rect_vals_from_obj(dest) c_dest = self._c_surface c_src = source._c_surface c_subsurface = None flags = special_flags if self.subsurfacedata: owner = self.subsurfacedata.owner c_subsurface = owner._c_surface suboffsetx = self.subsurfacedata.xoffset suboffsety = self.subsurfacedata.yoffset while owner.subsurfacedata: subdata = owner.subsurfacedata owner = subdata.owner c_subsurface = owner._c_surface suboffsetx += subdata.xoffset suboffsety += subdata.yoffset orig_clip = ffi.new('SDL_Rect*') sub_clip = ffi.new('SDL_Rect*') sdl.SDL_GetClipRect(c_subsurface, orig_clip) sdl.SDL_GetClipRect(self._c_surface, sub_clip) sub_clip[0].x += suboffsetx sub_clip[0].y += suboffsety sdl.SDL_SetClipRect(c_subsurface, sub_clip) destrect.x += suboffsetx destrect.y += suboffsety c_dest = c_subsurface # TODO: implement special blend flags # these checks come straight from pygame - copied comments if (c_dest.format.Amask and (c_dest.flags & sdl.SDL_SRCALPHA) and not (c_src.format.Amask and not (c_src.flags & sdl.SDL_SRCALPHA)) and (c_dest.format.BytesPerPixel == 2 or c_dest.format.BytesPerPixel == 4)): # SDL works for 2 and 4 bytes res = sdl.pygame_Blit(c_src, srcrect, c_dest, destrect, flags) elif flags or (c_src.flags & (sdl.SDL_SRCALPHA | sdl.SDL_SRCCOLORKEY) and c_dest.pixels == c_src.pixels and check_surface_overlap(c_src, srcrect, c_dest, destrect)): ''' This simplification is possible because a source subsurface is converted to its owner with a clip rect and a dst subsurface cannot be blitted to its owner because the owner is locked. ''' res = sdl.pygame_Blit(c_src, srcrect, c_dest, destrect, flags) # can't blit alpha to 8bit, crashes SDL elif (c_dest.format.BytesPerPixel == 1 and (c_src.format.Amask or c_src.flags & sdl.SDL_SRCALPHA)): if c_src.format.BytesPerPixel == 1: res = sdl.pygame_Blit(c_src, srcrect, c_dest, destrect, 0) elif sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO): # TODO: SDL_DisplayFormat segfaults c_src = sdl.SDL_DisplayFormat(c_src) if c_src: res = sdl.SDL_BlitSurface(c_src, srcrect, c_dest, destrect) sdl.SDL_FreeSurface(c_src) else: res = -1 else: raise NotImplementedError() else: res = sdl.SDL_BlitSurface(c_src, srcrect, c_dest, destrect) if c_subsurface: sdl.SDL_SetClipRect(c_subsurface, orig_clip) destrect.x -= suboffsetx destrect.y -= suboffsety else: # TODO: prep/unprep pass if res == -1: raise SDLError.from_sdl_error() elif res == -2: raise SDLError("Surface was lost") return Rect._from4(destrect.x, destrect.y, destrect.w, destrect.h)
def check_mixer(): """Helper function to check if sound was initialised""" # Defined here so we don't need circular imports between # mixer and this if not sdl.SDL_WasInit(sdl.SDL_INIT_AUDIO): raise SDLError("mixer system not initialized")
def video_autoquit(): if sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO): sdl.SDL_QuitSubSystem(sdl.SDL_INIT_VIDEO)
def _timer_callback(interval, param): if sdl.SDL_WasInit(sdl.SDL_INIT_VIDEO): event = ffi.new("SDL_Event") event.type = ffi.cast("intptr_t", param) sdl.SDL_PushEvent(event) return interval