static size_t SDLCALL win32_file_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum) { size_t total_need; size_t total_read = 0; size_t read_ahead; DWORD byte_read; total_need = size * maxnum; if (!context || context->hidden.win32io.h == INVALID_HANDLE_VALUE || !total_need) return 0; if (context->hidden.win32io.buffer.left > 0) { void *data = (char *) context->hidden.win32io.buffer.data + context->hidden.win32io.buffer.size - context->hidden.win32io.buffer.left; read_ahead = SDL_min(total_need, context->hidden.win32io.buffer.left); SDL_memcpy(ptr, data, read_ahead); context->hidden.win32io.buffer.left -= read_ahead; if (read_ahead == total_need) { return maxnum; } ptr = (char *) ptr + read_ahead; total_need -= read_ahead; total_read += read_ahead; } if (total_need < READAHEAD_BUFFER_SIZE) { if (!ReadFile (context->hidden.win32io.h, context->hidden.win32io.buffer.data, READAHEAD_BUFFER_SIZE, &byte_read, NULL)) { SDL_Error(SDL_EFREAD); return 0; } read_ahead = SDL_min(total_need, (int) byte_read); SDL_memcpy(ptr, context->hidden.win32io.buffer.data, read_ahead); context->hidden.win32io.buffer.size = byte_read; context->hidden.win32io.buffer.left = byte_read - read_ahead; total_read += read_ahead; } else { if (!ReadFile (context->hidden.win32io.h, ptr, (DWORD)total_need, &byte_read, NULL)) { SDL_Error(SDL_EFREAD); return 0; } total_read += byte_read; } return (total_read / size); }
size_t SDL_utf8strlcpy(char *dst, const char *src, size_t dst_bytes) { size_t src_bytes = SDL_strlen(src); size_t bytes = SDL_min(src_bytes, dst_bytes - 1); size_t i = 0; char trailing_bytes = 0; if (bytes) { unsigned char c = (unsigned char)src[bytes - 1]; if (UTF8_IsLeadByte(c)) --bytes; else if (UTF8_IsTrailingByte(c)) { for (i = bytes - 1; i != 0; --i) { c = (unsigned char)src[i]; trailing_bytes = UTF8_TrailingBytes(c); if (trailing_bytes) { if (bytes - i != trailing_bytes + 1) bytes = i; break; } } } SDL_memcpy(dst, src, bytes); } dst[bytes] = '\0'; return bytes; }
void VID_Init (void) { int i; // Enumerate modes. vid_num_modes = SDL_min(VID_MAX_MODES, SDL_GetNumDisplayModes(0)); for (i = 0; i < vid_num_modes; ++i) { SDL_DisplayMode mode = { 0 }; SDL_GetDisplayMode(0, i, &mode); vid_modes[i].width = mode.w; vid_modes[i].height = mode.h; } qsort(&vid_modes[0], vid_num_modes, sizeof(vidmode_t), &CompareModes); /* Create the video variables so we know how to start the graphics drivers */ vid_ref = Cvar_Get ("vid_ref", "gl", CVAR_ARCHIVE); vid_fullscreen = Cvar_Get ("vid_fullscreen", "0", CVAR_ARCHIVE); vid_gamma = Cvar_Get( "vid_gamma", "1", CVAR_ARCHIVE ); /* Add some console commands that we want to handle */ Cmd_AddCommand ("vid_restart", VID_Restart_f); /* Start the graphics mode and load refresh DLL */ VID_CheckChanges(); }
bool SDLManager::checkOSEvents() { const bool CLOSE = true; const bool OPEN = false; if (SDL_PollEvent(eventQueue.get()) == 1) { if (eventQueue->type == SDL_WINDOWEVENT) { switch (eventQueue->window.event) { case SDL_WINDOWEVENT_RESIZED: { resize_factor = SDL_min(eventQueue->window.data1 / 64, eventQueue->window.data2 / 32); } break; case SDL_WINDOWEVENT_CLOSE: { return CLOSE; } break; default: return OPEN; } } } return OPEN; }
static Sint64 SDLCALL rw_seekfunc(SDL_RWops *context, Sint64 offset, int whence) { Sint64 newpos; if (context->type != SDL_RW_TAG_CURRENT) { return SDL_SetError("bad RWops type"); } switch (whence) { case RW_SEEK_SET: newpos = context->hidden.rwops.begin + offset; break; case RW_SEEK_CUR: newpos = context->hidden.rwops.current + offset; break; case RW_SEEK_END: newpos = context->hidden.rwops.end + offset; break; default: return SDL_SetError("Unknown value for seek 'whence'"); } context->hidden.rwops.current = SDL_max( SDL_min(newpos, context->hidden.rwops.end), context->hidden.rwops.begin ); return newpos - context->hidden.rwops.begin; }
int AudioQueue_copy (AudioQueue* self, Uint8* buf, int size) { if (size <= 0) return 0; if (SDL_SemValue(self->full_node) > 0) { if (!self->buf) self->buf = self->cur->buf; int cur_size = self->cur->size - (self->buf - self->cur->buf); int size_taken = SDL_min(size, cur_size); Copy(buf, self->buf, size_taken, Uint8); cur_size -= size_taken; if (cur_size <= 0) { // move to the next node SDL_SemPost(self->empty_node); if (++self->cur - self->nodes >= self->n) self->cur = self->nodes; self->buf = NULL; buf += size_taken; size -= size_taken; SDL_SemWait(self->full_node); // this never blocks return size_taken + AudioQueue_copy(self, buf, size); } else { // didn't use the entire current node self->buf += size_taken; return size_taken; } } else { Zero(buf, size, Uint8); return 0; } }
static void handle_configure_wl_shell_surface(void *data, struct wl_shell_surface *shell_surface, uint32_t edges, int32_t width, int32_t height) { SDL_WindowData *wind = (SDL_WindowData *)data; SDL_Window *window = wind->sdlwindow; struct wl_region *region; /* wl_shell_surface spec states that this is a suggestion. Ignore if less than or greater than max/min size. */ if (width == 0 || height == 0) { return; } if (!(window->flags & SDL_WINDOW_FULLSCREEN)) { if ((window->flags & SDL_WINDOW_RESIZABLE)) { if (window->max_w > 0) { width = SDL_min(width, window->max_w); } width = SDL_max(width, window->min_w); if (window->max_h > 0) { height = SDL_min(height, window->max_h); } height = SDL_max(height, window->min_h); } else { return; } } if (width == window->w && height == window->h) { return; } window->w = width; window->h = height; WAYLAND_wl_egl_window_resize(wind->egl_window, window->w, window->h, 0, 0); region = wl_compositor_create_region(wind->waylandData->compositor); wl_region_add(region, 0, 0, window->w, window->h); wl_surface_set_opaque_region(wind->surface, region); wl_region_destroy(region); SDL_SendWindowEvent(window, SDL_WINDOWEVENT_RESIZED, window->w, window->h); }
SDL_JoystickGUID SDL_SYS_JoystickGetDeviceGUID( int device_index ) { SDL_JoystickGUID guid; /* the GUID is just the first 16 chars of the name for now */ const char *name = SDL_SYS_JoystickNameForDeviceIndex( device_index ); SDL_zero( guid ); SDL_memcpy( &guid, name, SDL_min( sizeof(guid), SDL_strlen( name ) ) ); return guid; }
SDL_JoystickGUID SDL_SYS_JoystickGetGUID(SDL_Joystick * joystick) { SDL_JoystickGUID guid; /* the GUID is just the first 16 chars of the name for now */ const char *name = joystick->name; SDL_zero( guid ); SDL_memcpy( &guid, name, SDL_min( sizeof(guid), SDL_strlen( name ) ) ); return guid; }
int Android_AddJoystick(int device_id, const char *name, const char *desc, SDL_bool is_accelerometer, int nbuttons, int naxes, int nhats, int nballs) { SDL_JoystickGUID guid; SDL_joylist_item *item; if(JoystickByDeviceId(device_id) != NULL || name == NULL) { return -1; } /* the GUID is just the first 16 chars of the name for now */ SDL_zero( guid ); SDL_memcpy( &guid, desc, SDL_min( sizeof(guid), SDL_strlen( desc) ) ); item = (SDL_joylist_item *) SDL_malloc(sizeof (SDL_joylist_item)); if (item == NULL) { return -1; } SDL_zerop(item); item->guid = guid; item->device_id = device_id; item->name = SDL_strdup(name); if ( item->name == NULL ) { SDL_free(item); return -1; } item->is_accelerometer = is_accelerometer; if (nbuttons > -1) { item->nbuttons = nbuttons; } else { item->nbuttons = ANDROID_MAX_NBUTTONS; } item->naxes = naxes; item->nhats = nhats; item->nballs = nballs; item->device_instance = instance_counter++; if (SDL_joylist_tail == NULL) { SDL_joylist = SDL_joylist_tail = item; } else { SDL_joylist_tail->next = item; SDL_joylist_tail = item; } /* Need to increment the joystick count before we post the event */ ++numjoysticks; SDL_PrivateJoystickAdded(numjoysticks - 1); #ifdef DEBUG_JOYSTICK SDL_Log("Added joystick %s with device_id %d", name, device_id); #endif return numjoysticks; }
size_t SDL_strlcpy(char *dst, const char *src, size_t maxlen) { size_t srclen = SDL_strlen(src); if ( maxlen > 0 ) { size_t len = SDL_min(srclen, maxlen-1); SDL_memcpy(dst, src, len); dst[len] = '\0'; } return srclen; }
size_t SDL_wcslcpy(wchar_t *dst, const wchar_t *src, size_t maxlen) { size_t srclen = SDL_wcslen(src); if (maxlen > 0) { size_t len = SDL_min(srclen, maxlen - 1); SDL_memcpy(dst, src, len * sizeof(wchar_t)); dst[len] = '\0'; } return srclen; }
static void handle_configure_xdg_toplevel(void *data, struct xdg_toplevel *xdg_toplevel, int32_t width, int32_t height, struct wl_array *states) { SDL_WindowData *wind = (SDL_WindowData *)data; SDL_Window *window = wind->sdlwindow; /* wl_shell_surface spec states that this is a suggestion. Ignore if less than or greater than max/min size. */ if (width == 0 || height == 0) { return; } if (!(window->flags & SDL_WINDOW_FULLSCREEN)) { if ((window->flags & SDL_WINDOW_RESIZABLE)) { if (window->max_w > 0) { width = SDL_min(width, window->max_w); } width = SDL_max(width, window->min_w); if (window->max_h > 0) { height = SDL_min(height, window->max_h); } height = SDL_max(height, window->min_h); } else { return; } } if (width == window->w && height == window->h) { return; } window->w = width; window->h = height; }
static size_t SDLCALL rw_writefunc(SDL_RWops *context, const void *ptr, size_t size, size_t num) { if (context->type != SDL_RW_TAG_CURRENT) { return SDL_SetError("bad RWops type"); } Sint64 pos = SDL_RWseek((SDL_RWops *) context->hidden.rwops.baseRW, context->hidden.rwops.current, RW_SEEK_SET); if (pos == -1) { return SDL_SetError("Can't seek"); } size_t realSize = SDL_min(size * num, context->hidden.rwops.end - pos); size_t bytesWritten = SDL_RWwrite((SDL_RWops *) context->hidden.rwops.baseRW, ptr, 1, realSize); context->hidden.rwops.current += bytesWritten; return bytesWritten / size; }
size_t SDL_strlcpy(char *dst, const char *src, size_t maxlen) { #if defined(HAVE_STRLCPY) return strlcpy(dst, src, maxlen); #else size_t srclen = SDL_strlen(src); if (maxlen > 0) { size_t len = SDL_min(srclen, maxlen - 1); SDL_memcpy(dst, src, len); dst[len] = '\0'; } return srclen; #endif /* HAVE_STRLCPY */ }
size_t SDL_wcslcpy(wchar_t *dst, const wchar_t *src, size_t maxlen) { #if defined(HAVE_WCSLCPY) return wcslcpy(dst, src, maxlen); #else size_t srclen = SDL_wcslen(src); if (maxlen > 0) { size_t len = SDL_min(srclen, maxlen - 1); SDL_memcpy(dst, src, len * sizeof(wchar_t)); dst[len] = '\0'; } return srclen; #endif /* HAVE_WCSLCPY */ }
static int PULSEAUDIO_CaptureFromDevice(_THIS, void *buffer, int buflen) { struct SDL_PrivateAudioData *h = this->hidden; const void *data = NULL; size_t nbytes = 0; while (SDL_AtomicGet(&this->enabled)) { if (h->capturebuf != NULL) { const int cpy = SDL_min(buflen, h->capturelen); SDL_memcpy(buffer, h->capturebuf, cpy); /*printf("PULSEAUDIO: fed %d captured bytes\n", cpy);*/ h->capturebuf += cpy; h->capturelen -= cpy; if (h->capturelen == 0) { h->capturebuf = NULL; PULSEAUDIO_pa_stream_drop(h->stream); /* done with this fragment. */ } return cpy; /* new data, return it. */ } if (PULSEAUDIO_pa_context_get_state(h->context) != PA_CONTEXT_READY || PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY || PULSEAUDIO_pa_mainloop_iterate(h->mainloop, 1, NULL) < 0) { SDL_OpenedAudioDeviceDisconnected(this); return -1; /* uhoh, pulse failed! */ } if (PULSEAUDIO_pa_stream_readable_size(h->stream) == 0) { continue; /* no data available yet. */ } /* a new fragment is available! */ PULSEAUDIO_pa_stream_peek(h->stream, &data, &nbytes); SDL_assert(nbytes > 0); if (data == NULL) { /* NULL==buffer had a hole. Ignore that. */ PULSEAUDIO_pa_stream_drop(h->stream); /* drop this fragment. */ } else { /* store this fragment's data, start feeding it to SDL. */ /*printf("PULSEAUDIO: captured %d new bytes\n", (int) nbytes);*/ h->capturebuf = (const Uint8 *) data; h->capturelen = nbytes; } } return -1; /* not enabled? */ }
static void DSP_FlushCapture(_THIS) { struct SDL_PrivateAudioData *h = this->hidden; audio_buf_info info; if (ioctl(h->audio_fd, SNDCTL_DSP_GETISPACE, &info) == 0) { while (info.bytes > 0) { char buf[512]; const size_t len = SDL_min(sizeof (buf), info.bytes); const ssize_t br = read(h->audio_fd, buf, len); if (br <= 0) { break; } info.bytes -= br; } } }
/*------------------------------------------------------ Setup OpenGL parameters (viewport, projection, display rect, ...) --------------------------------------------------------*/ void opengl_setup_parameters ( void ) { float ratio_x, ratio_y; glEnable ( GL_TEXTURE_2D ); glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f ); glViewport ( 0, 0, video_screen->w, video_screen->h ); glClear ( GL_COLOR_BUFFER_BIT ); glMatrixMode ( GL_PROJECTION ); glLoadIdentity(); glOrtho ( 0.0f, video_screen->w, video_screen->h, 0.0f, -1.0f, 1.0f ); glMatrixMode ( GL_MODELVIEW ); glLoadIdentity(); ratio_x = ( float ) video_screen->w / 320.0f; ratio_y = ( float ) video_screen->h / 240.0f; if ( ( video_keep_aspect_ratio ) && ( video_fullscreen ) ) ratio_x = ratio_y = SDL_min ( ratio_x, ratio_y ); if ( video_display_border ) { opengl_display_rect.w = ( int ) ( ratio_x * 304.0f + 0.5f ); opengl_display_rect.h = ( int ) ( ratio_y * 224.0f + 0.5f ); } else { opengl_display_rect.w = ( int ) ( ratio_x * 320.0f + 0.5f ); opengl_display_rect.h = ( int ) ( ratio_y * 240.0f + 0.5f ); } opengl_display_rect.x = ( video_screen->w - opengl_display_rect.w ) / 2; opengl_display_rect.y = ( video_screen->h - opengl_display_rect.h ) / 2; opengl_create_textures(); }
static void NETBSDAUDIO_FlushCapture(_THIS) { audio_info_t info; size_t remain; Uint8 buf[512]; if (ioctl(this->hidden->audio_fd, AUDIO_GETINFO, &info) < 0) { return; /* oh well. */ } remain = (size_t) (info.record.samples * (SDL_AUDIO_BITSIZE(this->spec.format) / 8)); while (remain > 0) { const size_t len = SDL_min(sizeof (buf), remain); const int br = read(this->hidden->audio_fd, buf, len); if (br <= 0) { return; /* oh well. */ } remain -= br; } }
size_t SDL_ReadFromDataQueue(SDL_DataQueue *queue, void *_buf, const size_t _len) { size_t len = _len; Uint8 *buf = (Uint8 *) _buf; Uint8 *ptr = buf; SDL_DataQueuePacket *packet; if (!queue) { return 0; } while ((len > 0) && ((packet = queue->head) != NULL)) { const size_t avail = packet->datalen - packet->startpos; const size_t cpy = SDL_min(len, avail); SDL_assert(queue->queued_bytes >= avail); SDL_memcpy(ptr, packet->data + packet->startpos, cpy); packet->startpos += cpy; ptr += cpy; queue->queued_bytes -= cpy; len -= cpy; if (packet->startpos == packet->datalen) { /* packet is done, put it in the pool. */ queue->head = packet->next; SDL_assert((packet->next != NULL) || (packet == queue->tail)); packet->next = queue->pool; queue->pool = packet; } } SDL_assert((queue->head != NULL) == (queue->queued_bytes != 0)); if (queue->head == NULL) { queue->tail = NULL; /* in case we drained the queue entirely. */ } return (size_t) (ptr - buf); }
static float bestDollarDifference(SDL_FloatPoint* points,SDL_FloatPoint* templ) { /*------------BEGIN DOLLAR BLACKBOX------------------ -TRANSLATED DIRECTLY FROM PSUDEO-CODE AVAILABLE AT- -"http://depts.washington.edu/aimgroup/proj/dollar/" */ double ta = -M_PI/4; double tb = M_PI/4; double dt = M_PI/90; float x1 = (float)(PHI*ta + (1-PHI)*tb); float f1 = dollarDifference(points,templ,x1); float x2 = (float)((1-PHI)*ta + PHI*tb); float f2 = dollarDifference(points,templ,x2); while (SDL_fabs(ta-tb) > dt) { if (f1 < f2) { tb = x2; x2 = x1; f2 = f1; x1 = (float)(PHI*ta + (1-PHI)*tb); f1 = dollarDifference(points,templ,x1); } else { ta = x1; x1 = x2; f1 = f2; x2 = (float)((1-PHI)*ta + PHI*tb); f2 = dollarDifference(points,templ,x2); } } /* if (f1 <= f2) printf("Min angle (x1): %f\n",x1); else if (f1 > f2) printf("Min angle (x2): %f\n",x2); */ return SDL_min(f1,f2); }
Uint32 SDL_WasInit(Uint32 flags) { int i; int num_subsystems = SDL_arraysize(SDL_SubsystemRefCount); Uint32 initialized = 0; if (!flags) { flags = SDL_INIT_EVERYTHING; } num_subsystems = SDL_min(num_subsystems, SDL_MostSignificantBitIndex32(flags) + 1); /* Iterate over each bit in flags, and check the matching subsystem. */ for (i = 0; i < num_subsystems; ++i) { if ((flags & 1) && SDL_SubsystemRefCount[i] > 0) { initialized |= (1 << i); } flags >>= 1; } return initialized; }
int SDL_WriteToDataQueue(SDL_DataQueue *queue, const void *_data, const size_t _len) { size_t len = _len; const Uint8 *data = (const Uint8 *) _data; const size_t packet_size = queue ? queue->packet_size : 0; SDL_DataQueuePacket *orighead; SDL_DataQueuePacket *origtail; size_t origlen; size_t datalen; if (!queue) { return SDL_InvalidParamError("queue"); } orighead = queue->head; origtail = queue->tail; origlen = origtail ? origtail->datalen : 0; while (len > 0) { SDL_DataQueuePacket *packet = queue->tail; SDL_assert(!packet || (packet->datalen <= packet_size)); if (!packet || (packet->datalen >= packet_size)) { /* tail packet missing or completely full; we need a new packet. */ packet = queue->pool; if (packet != NULL) { /* we have one available in the pool. */ queue->pool = packet->next; } else { /* Have to allocate a new one! */ packet = (SDL_DataQueuePacket *) SDL_malloc(sizeof (SDL_DataQueuePacket) + packet_size); if (packet == NULL) { /* uhoh, reset so we've queued nothing new, free what we can. */ if (!origtail) { packet = queue->head; /* whole queue. */ } else { packet = origtail->next; /* what we added to existing queue. */ origtail->next = NULL; origtail->datalen = origlen; } queue->head = orighead; queue->tail = origtail; queue->pool = NULL; SDL_FreeDataQueueList(packet); /* give back what we can. */ return SDL_OutOfMemory(); } } packet->datalen = 0; packet->startpos = 0; packet->next = NULL; SDL_assert((queue->head != NULL) == (queue->queued_bytes != 0)); if (queue->tail == NULL) { queue->head = packet; } else { queue->tail->next = packet; } queue->tail = packet; } datalen = SDL_min(len, packet_size - packet->datalen); SDL_memcpy(packet->data + packet->datalen, data, datalen); data += datalen; len -= datalen; packet->datalen += datalen; queue->queued_bytes += datalen; } return 0; }
static int SDL_RendererEventWatch(void *userdata, SDL_Event *event) { SDL_Renderer *renderer = (SDL_Renderer *)userdata; if (event->type == SDL_WINDOWEVENT) { SDL_Window *window = SDL_GetWindowFromID(event->window.windowID); if (window == renderer->window) { if (renderer->WindowEvent) { renderer->WindowEvent(renderer, &event->window); } if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) { if (renderer->logical_w) { UpdateLogicalSize(renderer); } else { /* Window was resized, reset viewport */ int w, h; SDL_GetWindowSize(window, &w, &h); if (renderer->target) { renderer->viewport_backup.x = 0; renderer->viewport_backup.y = 0; renderer->viewport_backup.w = w; renderer->viewport_backup.h = h; } else { renderer->viewport.x = 0; renderer->viewport.y = 0; renderer->viewport.w = w; renderer->viewport.h = h; renderer->UpdateViewport(renderer); } } } else if (event->window.event == SDL_WINDOWEVENT_HIDDEN) { renderer->hidden = SDL_TRUE; } else if (event->window.event == SDL_WINDOWEVENT_SHOWN) { if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)) { renderer->hidden = SDL_FALSE; } } else if (event->window.event == SDL_WINDOWEVENT_MINIMIZED) { renderer->hidden = SDL_TRUE; } else if (event->window.event == SDL_WINDOWEVENT_RESTORED) { if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_HIDDEN)) { renderer->hidden = SDL_FALSE; } } } } else if (event->type == SDL_MOUSEMOTION) { if (renderer->logical_w) { event->motion.x -= renderer->viewport.x; event->motion.y -= renderer->viewport.y; event->motion.x = (int)(event->motion.x / renderer->scale.x); event->motion.y = (int)(event->motion.y / renderer->scale.y); if (event->motion.xrel > 0) { event->motion.xrel = SDL_max(1, (int)(event->motion.xrel / renderer->scale.x)); } else if (event->motion.xrel < 0) { event->motion.xrel = SDL_min(-1, (int)(event->motion.xrel / renderer->scale.x)); } if (event->motion.yrel > 0) { event->motion.yrel = SDL_max(1, (int)(event->motion.yrel / renderer->scale.y)); } else if (event->motion.yrel < 0) { event->motion.yrel = SDL_min(-1, (int)(event->motion.yrel / renderer->scale.y)); } } } else if (event->type == SDL_MOUSEBUTTONDOWN || event->type == SDL_MOUSEBUTTONUP) { if (renderer->logical_w) { event->button.x -= renderer->viewport.x; event->button.y -= renderer->viewport.y; event->button.x = (int)(event->button.x / renderer->scale.x); event->button.y = (int)(event->button.y / renderer->scale.y); } } return 0; }
int Android_AddJoystick(int device_id, const char *name, SDL_bool is_accelerometer, int nbuttons, int naxes, int nhats, int nballs) { SDL_JoystickGUID guid; SDL_joylist_item *item; #if !SDL_EVENTS_DISABLED SDL_Event event; #endif if(JoystickByDeviceId(device_id) != NULL || name == NULL) { return -1; } /* the GUID is just the first 16 chars of the name for now */ SDL_zero( guid ); SDL_memcpy( &guid, name, SDL_min( sizeof(guid), SDL_strlen( name ) ) ); item = (SDL_joylist_item *) SDL_malloc(sizeof (SDL_joylist_item)); if (item == NULL) { return -1; } SDL_zerop(item); item->guid = guid; item->device_id = device_id; item->name = SDL_strdup(name); if ( item->name == NULL ) { SDL_free(item); return -1; } item->is_accelerometer = is_accelerometer; if (nbuttons > -1) { item->nbuttons = nbuttons; } else { item->nbuttons = ANDROID_MAX_NBUTTONS; } item->naxes = naxes; item->nhats = nhats; item->nballs = nballs; item->device_instance = instance_counter++; if (SDL_joylist_tail == NULL) { SDL_joylist = SDL_joylist_tail = item; } else { SDL_joylist_tail->next = item; SDL_joylist_tail = item; } /* Need to increment the joystick count before we post the event */ ++numjoysticks; #if !SDL_EVENTS_DISABLED event.type = SDL_JOYDEVICEADDED; if (SDL_GetEventState(event.type) == SDL_ENABLE) { event.jdevice.which = (numjoysticks - 1); if ( (SDL_EventOK == NULL) || (*SDL_EventOK) (SDL_EventOKParam, &event) ) { SDL_PushEvent(&event); } } #endif /* !SDL_EVENTS_DISABLED */ SDL_Log("Added joystick %s with device_id %d", name, device_id); return numjoysticks; }
static int SDL_PrivateSendMouseButton(SDL_Window * window, SDL_MouseID mouseID, Uint8 state, Uint8 button, int clicks) { SDL_Mouse *mouse = SDL_GetMouse(); int posted; Uint32 type; Uint32 buttonstate = mouse->buttonstate; /* SDL_HINT_MOUSE_TOUCH_EVENTS: controlling whether mouse events should generate synthetic touch events */ if (mouse->mouse_touch_events) { if (mouseID != SDL_TOUCH_MOUSEID && button == SDL_BUTTON_LEFT) { if (state == SDL_PRESSED) { track_mouse_down = SDL_TRUE; } else { track_mouse_down = SDL_FALSE; } if (window) { float fx = (float)mouse->x / (float)window->w; float fy = (float)mouse->y / (float)window->h; SDL_SendTouch(SDL_MOUSE_TOUCHID, 0, track_mouse_down, fx, fy, 1.0f); } } } /* Figure out which event to perform */ switch (state) { case SDL_PRESSED: type = SDL_MOUSEBUTTONDOWN; buttonstate |= SDL_BUTTON(button); break; case SDL_RELEASED: type = SDL_MOUSEBUTTONUP; buttonstate &= ~SDL_BUTTON(button); break; default: /* Invalid state -- bail */ return 0; } /* We do this after calculating buttonstate so button presses gain focus */ if (window && state == SDL_PRESSED) { SDL_UpdateMouseFocus(window, mouse->x, mouse->y, buttonstate); } if (buttonstate == mouse->buttonstate) { /* Ignore this event, no state change */ return 0; } mouse->buttonstate = buttonstate; if (clicks < 0) { SDL_MouseClickState *clickstate = GetMouseClickState(mouse, button); if (clickstate) { if (state == SDL_PRESSED) { Uint32 now = SDL_GetTicks(); if (SDL_TICKS_PASSED(now, clickstate->last_timestamp + mouse->double_click_time) || SDL_abs(mouse->x - clickstate->last_x) > mouse->double_click_radius || SDL_abs(mouse->y - clickstate->last_y) > mouse->double_click_radius) { clickstate->click_count = 0; } clickstate->last_timestamp = now; clickstate->last_x = mouse->x; clickstate->last_y = mouse->y; if (clickstate->click_count < 255) { ++clickstate->click_count; } } clicks = clickstate->click_count; } else { clicks = 1; } } /* Post the event, if desired */ posted = 0; if (SDL_GetEventState(type) == SDL_ENABLE) { SDL_Event event; event.type = type; event.button.windowID = mouse->focus ? mouse->focus->id : 0; event.button.which = mouseID; event.button.state = state; event.button.button = button; event.button.clicks = (Uint8) SDL_min(clicks, 255); event.button.x = mouse->x; event.button.y = mouse->y; posted = (SDL_PushEvent(&event) > 0); } /* We do this after dispatching event so button releases can lose focus */ if (window && state == SDL_RELEASED) { SDL_UpdateMouseFocus(window, mouse->x, mouse->y, buttonstate); } return posted; }
static int MusicResource_load_music (void* udata) { MusicResource* self = (MusicResource*)udata; SDL_RWops* stream = ArchiveEntry_get_stream(self->entry); Uint8 shift = *self->entry->ext_data; bool compressed = shift != 0xFF; Uint8* output_buffer = NULL; Sint32 size = 0; Sint32 remaining_size = self->entry->size; Sint16 cur_value = 0; // want audio samples bytes of usable data at the end, so divide by // what we would normally multiply by to get the output size Sint32 unpacked_size = _audio.spec.samples / self->queue.cvt.len_ratio; // audio unpacks to twice the size if DW ADPCM compressed int unpacking_mult = compressed ? 2 : 1; // we need less input if we get more by unpacking Sint32 node_size = unpacked_size / unpacking_mult; while (!self->stop) { // we're at the start of a new node if (size <= 0) { size = node_size; output_buffer = AudioQueue_next(&self->queue, unpacked_size, SDL_TRUE); } Sint32 size_taken = SDL_min(size, remaining_size); remaining_size -= size_taken; size -= size_taken; Uint8* input_buffer = compressed ? output_buffer + size_taken : output_buffer; if (self->stop) break; SDL_RWread(stream, input_buffer, size_taken, 1); if (self->stop) break; if (shift != 0xFF) { // DW ADPCM compressed Sint16* output_buf = (Sint16*)output_buffer; Sint8* input_buf = (Sint8*)input_buffer; Sint8* input_end = input_buf + size_taken; while (input_buf < input_end) { cur_value += *input_buf++; *output_buf++ = SDL_SwapLE16(cur_value << shift); } } if (size > 0) { // unfinished buffer output_buffer += size_taken * unpacking_mult; } else { // convert and push the buffer we got with "next" to the queue AudioQueue_push(&self->queue); } if (remaining_size <= 0) { // loop back to the start of the audio SDL_RWseek(stream, self->entry->offset, SEEK_SET); remaining_size = self->entry->size; cur_value = 0; } } SDL_RWclose(stream); AudioQueue_destroy_buffers(&self->queue); return 0; }