test/testgesture.c
author Sam Lantinga <slouken@libsdl.org>
Sun, 07 Jul 2019 09:10:56 -0700
changeset 12928 3c4a4b1077cd
parent 12732 0280fd2d02ca
permissions -rw-r--r--
Fixed bug 4710 - audio/alsa: avoid configuring hardware parameters with only a single period

Anthony Pesch

The previous code first configured the period size using snd_pcm_hw_par-
ams_set_period_size_near. Then, it further narrowed the configuration
space by calling snd_pcm_hw_params_set_buffer_size_near using a buffer
size of 2 times the _requested_ period size in order to try and get a
configuration with only 2 periods. If the configured period size was
larger than the requested size, the second call could inadvertently
narrow the configuration space to contain only a single period.

Rather than fixing the call to snd_pcm_hw_params_set_buffer_size_near
to use a size of 2 times the configured period size, the code has been
changed to use snd_pcm_hw_params_set_periods_min in order to more
clearly explain the intent.
     1 /*
     2   Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
     3 
     4   This software is provided 'as-is', without any express or implied
     5   warranty.  In no event will the authors be held liable for any damages
     6   arising from the use of this software.
     7 
     8   Permission is granted to anyone to use this software for any purpose,
     9   including commercial applications, and to alter it and redistribute it
    10   freely.
    11 */
    12 
    13 /*  Usage:
    14  *  Spacebar to begin recording a gesture on all touches.
    15  *  s to save all touches into "./gestureSave"
    16  *  l to load all touches from "./gestureSave"
    17  */
    18 
    19 #include "SDL.h"
    20 #include <stdlib.h> /* for exit() */
    21 
    22 #ifdef __EMSCRIPTEN__
    23 #include <emscripten/emscripten.h>
    24 #endif
    25 
    26 #include "SDL_test.h"
    27 #include "SDL_test_common.h"
    28 
    29 #define WIDTH 640
    30 #define HEIGHT 480
    31 #define BPP 4
    32 
    33 /* MUST BE A POWER OF 2! */
    34 #define EVENT_BUF_SIZE 256
    35 
    36 #define VERBOSE 0
    37 
    38 static SDLTest_CommonState *state;
    39 static SDL_Event events[EVENT_BUF_SIZE];
    40 static int eventWrite;
    41 static int colors[7] = {0xFF,0xFF00,0xFF0000,0xFFFF00,0x00FFFF,0xFF00FF,0xFFFFFF};
    42 static int quitting = 0;
    43 
    44 typedef struct
    45 {
    46     float x, y;
    47 } Point;
    48 
    49 typedef struct
    50 {
    51     float ang, r;
    52     Point p;
    53 } Knob;
    54 
    55 static Knob knob = { 0.0f, 0.1f, { 0.0f, 0.0f } };
    56 
    57 
    58 static void
    59 setpix(SDL_Surface *screen, float _x, float _y, unsigned int col)
    60 {
    61     Uint32 *pixmem32;
    62     Uint32 colour;
    63     Uint8 r, g, b;
    64     const int x = (int)_x;
    65     const int y = (int)_y;
    66     float a;
    67 
    68     if ( (x < 0) || (x >= screen->w) || (y < 0) || (y >= screen->h) ) {
    69         return;
    70     }
    71 
    72     pixmem32 = (Uint32 *) screen->pixels + y * screen->pitch / BPP + x;
    73 
    74     SDL_memcpy(&colour, pixmem32, screen->format->BytesPerPixel);
    75 
    76     SDL_GetRGB(colour,screen->format,&r,&g,&b);
    77 
    78     /* r = 0;g = 0; b = 0; */
    79     a = (float) ((col >> 24) & 0xFF);
    80     if (a == 0) {
    81         a = 0xFF; /* Hack, to make things easier. */
    82     }
    83 
    84     a = (a == 0.0f) ? 1 : (a / 255.0f);
    85     r = (Uint8) (r * (1 - a) + ((col >> 16) & 0xFF) * a);
    86     g = (Uint8) (g * (1 - a) + ((col >> 8) & 0xFF) * a);
    87     b = (Uint8) (b * (1 - a) + ((col >> 0) & 0xFF) * a);
    88     colour = SDL_MapRGB(screen->format, r, g, b);
    89 
    90     *pixmem32 = colour;
    91 }
    92 
    93 static void
    94 drawLine(SDL_Surface *screen, float x0, float y0, float x1, float y1, unsigned int col)
    95 {
    96     float t;
    97     for (t = 0; t < 1; t += (float) (1.0f / SDL_max(SDL_fabs(x0 - x1), SDL_fabs(y0 - y1)))) {
    98         setpix(screen, x1 + t * (x0 - x1), y1 + t * (y0 - y1), col);
    99     }
   100 }
   101 
   102 static void
   103 drawCircle(SDL_Surface *screen, float x, float y, float r, unsigned int c)
   104 {
   105     float tx,ty, xr;
   106     for (ty = (float) -SDL_fabs(r); ty <= (float) SDL_fabs((int) r); ty++) {
   107         xr = (float) SDL_sqrt(r * r - ty * ty);
   108         if (r > 0) { /* r > 0 ==> filled circle */
   109             for(tx = -xr + 0.5f; tx <= xr - 0.5f; tx++) {
   110                 setpix(screen, x + tx, y + ty, c);
   111             }
   112         } else {
   113             setpix(screen, x - xr + 0.5f, y + ty, c);
   114             setpix(screen, x + xr - 0.5f, y + ty, c);
   115         }
   116     }
   117 }
   118 
   119 static void
   120 drawKnob(SDL_Surface *screen, const Knob *k)
   121 {
   122     drawCircle(screen, k->p.x * screen->w, k->p.y * screen->h, k->r * screen->w, 0xFFFFFF);
   123     drawCircle(screen, (k->p.x + k->r / 2 * SDL_cosf(k->ang)) * screen->w,
   124                (k->p.y + k->r / 2 * SDL_sinf(k->ang)) * screen->h, k->r / 4 * screen->w, 0);
   125 }
   126 
   127 static void
   128 DrawScreen(SDL_Window *window)
   129 {
   130     SDL_Surface *screen = SDL_GetWindowSurface(window);
   131     int i;
   132 
   133     if (!screen) {
   134         return;
   135     }
   136 
   137     SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 75, 75, 75));
   138 
   139     /* draw Touch History */
   140     for (i = eventWrite; i < eventWrite + EVENT_BUF_SIZE; ++i) {
   141         const SDL_Event *event = &events[i & (EVENT_BUF_SIZE - 1)];
   142         const float age = (float)(i - eventWrite) / EVENT_BUF_SIZE;
   143         float x, y;
   144         unsigned int c, col;
   145 
   146         if ( (event->type == SDL_FINGERMOTION) ||
   147              (event->type == SDL_FINGERDOWN) ||
   148              (event->type == SDL_FINGERUP) ) {
   149             x = event->tfinger.x;
   150             y = event->tfinger.y;
   151 
   152             /* draw the touch: */
   153             c = colors[event->tfinger.fingerId % 7];
   154             col = ((unsigned int) (c * (0.1f + 0.85f))) | (unsigned int) (0xFF * age) << 24;
   155 
   156             if (event->type == SDL_FINGERMOTION) {
   157                 drawCircle(screen, x * screen->w, y * screen->h, 5, col);
   158             } else if (event->type == SDL_FINGERDOWN) {
   159                 drawCircle(screen, x * screen->w, y * screen->h, -10, col);
   160             }
   161         }
   162     }
   163 
   164     if (knob.p.x > 0) {
   165         drawKnob(screen, &knob);
   166     }
   167 
   168     SDL_UpdateWindowSurface(window);
   169 }
   170 
   171 static void
   172 loop(void)
   173 {
   174     SDL_Event event;
   175     SDL_RWops *stream;
   176     int i;
   177 
   178     while (SDL_PollEvent(&event)) {
   179         SDLTest_CommonEvent(state, &event, &quitting);
   180 
   181         /* Record _all_ events */
   182         events[eventWrite & (EVENT_BUF_SIZE-1)] = event;
   183         eventWrite++;
   184 
   185         switch (event.type) {
   186             case SDL_KEYDOWN:
   187                 switch (event.key.keysym.sym) {
   188                     case SDLK_i: {
   189                         for (i = 0; i < SDL_GetNumTouchDevices(); ++i) {
   190                             const SDL_TouchID id = SDL_GetTouchDevice(i);
   191                             SDL_Log("Fingers Down on device %"SDL_PRIs64": %d", id, SDL_GetNumTouchFingers(id));
   192                         }
   193                         break;
   194                     }
   195 
   196                     case SDLK_SPACE:
   197                         SDL_RecordGesture(-1);
   198                         break;
   199 
   200                     case SDLK_s:
   201                         stream = SDL_RWFromFile("gestureSave", "w");
   202                         SDL_Log("Wrote %i templates", SDL_SaveAllDollarTemplates(stream));
   203                         SDL_RWclose(stream);
   204                         break;
   205 
   206                     case SDLK_l:
   207                         stream = SDL_RWFromFile("gestureSave", "r");
   208                         SDL_Log("Loaded: %i", SDL_LoadDollarTemplates(-1, stream));
   209                         SDL_RWclose(stream);
   210                         break;
   211                 }
   212                 break;
   213 
   214 #if VERBOSE
   215             case SDL_FINGERMOTION:
   216                 SDL_Log("Finger: %"SDL_PRIs64",x: %f, y: %f",event.tfinger.fingerId,
   217                         event.tfinger.x,event.tfinger.y);
   218                 break;
   219 
   220             case SDL_FINGERDOWN:
   221                 SDL_Log("Finger: %"SDL_PRIs64" down - x: %f, y: %f",
   222                         event.tfinger.fingerId,event.tfinger.x,event.tfinger.y);
   223                 break;
   224 
   225             case SDL_FINGERUP:
   226                 SDL_Log("Finger: %"SDL_PRIs64" up - x: %f, y: %f",
   227                         event.tfinger.fingerId,event.tfinger.x,event.tfinger.y);
   228                 break;
   229 #endif
   230 
   231             case SDL_MULTIGESTURE:
   232 #if VERBOSE
   233                 SDL_Log("Multi Gesture: x = %f, y = %f, dAng = %f, dR = %f",
   234                         event.mgesture.x, event.mgesture.y,
   235                         event.mgesture.dTheta, event.mgesture.dDist);
   236                 SDL_Log("MG: numDownTouch = %i",event.mgesture.numFingers);
   237 #endif
   238 
   239                 knob.p.x = event.mgesture.x;
   240                 knob.p.y = event.mgesture.y;
   241                 knob.ang += event.mgesture.dTheta;
   242                 knob.r += event.mgesture.dDist;
   243                 break;
   244 
   245             case SDL_DOLLARGESTURE:
   246                 SDL_Log("Gesture %"SDL_PRIs64" performed, error: %f",
   247                         event.dgesture.gestureId, event.dgesture.error);
   248                 break;
   249 
   250             case SDL_DOLLARRECORD:
   251                 SDL_Log("Recorded gesture: %"SDL_PRIs64"",event.dgesture.gestureId);
   252                 break;
   253         }
   254     }
   255 
   256     for (i = 0; i < state->num_windows; ++i) {
   257         if (state->windows[i]) {
   258             DrawScreen(state->windows[i]);
   259         }
   260     }
   261 
   262 #ifdef __EMSCRIPTEN__
   263     if (quitting) {
   264         emscripten_cancel_main_loop();
   265     }
   266 #endif
   267 }
   268 
   269 int main(int argc, char* argv[])
   270 {
   271     state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
   272     if (!state) {
   273         return 1;
   274     }
   275 
   276     state->window_title = "Gesture Test";
   277     state->window_w = WIDTH;
   278     state->window_h = HEIGHT;
   279     state->skip_renderer = SDL_TRUE;
   280 
   281     if (!SDLTest_CommonDefaultArgs(state, argc, argv) || !SDLTest_CommonInit(state)) {
   282         SDLTest_CommonQuit(state);
   283         return 1;
   284     }
   285 
   286 #ifdef __EMSCRIPTEN__
   287     emscripten_set_main_loop(loop, 0, 1);
   288 #else
   289     while (!quitting) {
   290         loop();
   291     }
   292 #endif
   293 
   294     SDLTest_CommonQuit(state);
   295     return 0;
   296 }
   297