int main(int argc, char **argv) { char sin[4096], *ptr; beep_parms_t *parms = (beep_parms_t *)malloc(sizeof(beep_parms_t)); parms->freq = 0; parms->length = DEFAULT_LENGTH; parms->reps = DEFAULT_REPS; parms->delay = DEFAULT_DELAY; parms->end_delay = DEFAULT_END_DELAY; parms->stdin_beep = DEFAULT_STDIN_BEEP; parms->verbose = 0; parms->next = NULL; signal(SIGINT, handle_signal); signal(SIGTERM, handle_signal); parse_command_line(argc, argv, parms); /* this outermost while loop handles the possibility that -n/--new has been used, i.e. that we have multiple beeps specified. Each iteration will play, then free() one parms instance. */ while(parms) { beep_parms_t *next = parms->next; if(parms->stdin_beep) { /* in this case, beep is probably part of a pipe, in which case POSIX says stdin and out should be fuly buffered. This however means very laggy performance with beep just twiddling it's thumbs until a buffer fills. Thus, kill the buffering. In some situations, this too won't be enough, namely if we're in the middle of a long pipe, and the processes feeding us stdin are buffered, we'll have to wait for them, not much to be done about that. */ setvbuf(stdin, NULL, _IONBF, 0); setvbuf(stdout, NULL, _IONBF, 0); while(fgets(sin, 4096, stdin)) { if(parms->stdin_beep==CHAR_STDIN_BEEP) { for(ptr=sin;*ptr;ptr++) { putchar(*ptr); fflush(stdout); play_beep(*parms); } } else { fputs(sin, stdout); play_beep(*parms); } } } else { play_beep(*parms); } /* Junk each parms struct after playing it */ free(parms); parms = next; } if(console_device) free(console_device); return EXIT_SUCCESS; }
/* ======================================================================= */ void sound(int pSoundLength) { beep_parms_t *parms = (beep_parms_t *)malloc(sizeof(beep_parms_t)); if (pSoundLength == MAEL_KEY_BEEP_LENGTH) parms->freq = MAEL_KEY_BEEP_FREQ; else parms->freq = DEFAULT_FREQ; if (pSoundLength < 1 ) parms->length = DEFAULT_LENGTH; else parms->length = pSoundLength; parms->reps = DEFAULT_REPS; parms->delay = DEFAULT_DELAY; parms->end_delay = DEFAULT_END_DELAY; parms->stdin_beep = DEFAULT_STDIN_BEEP; parms->next = NULL; play_beep(*parms); /* system("./beep"); */ return; }
int event_thread(void *data) { for(;;) { SDL_mutexP(wii_lock); if(wiiuse_poll(wiimotes, wiimotes_connected)) { int i; for(i = 0;i<wiimotes_connected;i++) { if(wiimotes[i]->event == WIIUSE_EVENT) { if (IS_JUST_PRESSED(wiimotes[i], WIIMOTE_BUTTON_A)) { play_beep(); } if (IS_JUST_PRESSED(wiimotes[i], WIIMOTE_BUTTON_B)) { play_ricochet(); } } else if(wiimotes[i]->event == WIIUSE_DISCONNECT) { wiiuse_cleanup(wiimotes, 4); wiimotes_connected = 0; wiimotes = NULL; break; } } } SDL_mutexV(wii_lock); } }
void beep(float frequency, unsigned int length, unsigned int repetitions, unsigned int delay, int increment) { beep_parms_t beep; beep.freq = frequency; beep.length = length; beep.reps = repetitions; beep.delay = delay; beep.inc = increment; play_beep(beep); }
void SingleClassicMode::trigger_pressed(int id, qreal trigger) { if(have_won) { emit change_sound_volume(1.0); } else { /* Check if the trigger is fully pressed */ if(trigger/255.) { if(current_distance < obstacle_hearing_sound) { emit change_sound_volume(1.5*(obstacle_hearing_sound - current_distance)/obstacle_hearing_sound); if(!set_beep) { set_beep = 1; emit play_beep(); } } } else { emit change_sound_volume(1.0); if(set_beep) { set_beep = 0; stop_music(); } return; } } }
readpw(Display *dpy, const char *pws) #endif { char buf[32], passwd[256]; int num, screen; #if !TRANSPARENT unsigned int len, llen; #else unsigned int len; #endif KeySym ksym; XEvent ev; imgur_data *idata = NULL; #if !TRANSPARENT len = llen = 0; #else len = 0; #endif running = True; /* As "slock" stands for "Simple X display locker", the DPMS settings * had been removed and you can set it with "xset" or some other * utility. This way the user can easily set a customized DPMS * timeout. */ while(running && !XNextEvent(dpy, &ev)) { if(ev.type == KeyPress) { buf[0] = 0; num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0); if(IsKeypadKey(ksym)) { if(ksym == XK_KP_Enter) ksym = XK_Return; else if(ksym >= XK_KP_0 && ksym <= XK_KP_9) ksym = (ksym - XK_KP_0) + XK_0; } if(IsFunctionKey(ksym) || IsKeypadKey(ksym) || IsMiscFunctionKey(ksym) || IsPFKey(ksym) || IsPrivateKeypadKey(ksym)) continue; switch(ksym) { case XK_Return: passwd[len] = 0; if(g_pw) { running = !!strcmp(passwd, g_pw); } else { #ifdef HAVE_BSD_AUTH running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd); #else running = !!strcmp(crypt(passwd, pws), pws); #endif } if(running) { XBell(dpy, 100); lock_tries++; // Poweroff if there are more than 5 bad attempts. if(lock_tries > 5) { // Disable alt+sysrq and crtl+alt+backspace disable_kill(); // Take a webcam shot of whoever is tampering with our machine: webcam_shot(0); // Upload the image: idata = imgur_upload(); // Send an SMS/MMS via twilio: twilio_send("Bad screenlock password.", idata, 0); // Delete the image from imgur: imgur_delete(idata); // Immediately poweroff: poweroff(); // If we failed, simply resume: len = 0; break; } else { // Take a webcam shot of whoever is tampering with our machine: webcam_shot(1); // Send an SMS via twilio: twilio_send("Bad screenlock password.", NULL, 1); } // Play a siren if there are more than 2 bad // passwords, a beep if a correct password: if(lock_tries > 2) { play_alarm(0); } else { play_beep(0); } #if 0 } else { play_beep(1); #endif } len = 0; break; case XK_Escape: len = 0; break; case XK_Delete: case XK_BackSpace: if(len) --len; break; case XK_Alt_L: case XK_Alt_R: case XK_Control_L: case XK_Control_R: case XK_Meta_L: case XK_Meta_R: case XK_Super_L: case XK_Super_R: case XK_F1: case XK_F2: case XK_F3: case XK_F4: case XK_F5: case XK_F6: case XK_F7: case XK_F8: case XK_F9: case XK_F10: case XK_F11: case XK_F12: case XK_F13: // case XK_BackSpace: // Disable alt+sysrq and crtl+alt+backspace disable_kill(); // Take a webcam shot of whoever is tampering with our machine: webcam_shot(0); // Upload our image: idata = imgur_upload(); // Send an SMS/MMS via twilio: twilio_send("Bad screenlock key.", idata, 0); // Delete the image from imgur: imgur_delete(idata); // Immediately poweroff: poweroff(); ; // fall-through if we fail default: if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) { memcpy(passwd + len, buf, num); len += num; } break; } #if !TRANSPARENT if(llen == 0 && len != 0) { for(screen = 0; screen < nscreens; screen++) { XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[1]); XClearWindow(dpy, locks[screen]->win); } } else if(llen != 0 && len == 0) { for(screen = 0; screen < nscreens; screen++) { XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[0]); XClearWindow(dpy, locks[screen]->win); } } llen = len; #endif } else for(screen = 0; screen < nscreens; screen++) XRaiseWindow(dpy, locks[screen]->win); } }
void cycle(){ u16 addr, xx, yy, id; u8 x, y, value, tmp, w, h; // Fetch opcode opcode = memory[PC] << 8 | memory[PC + 1]; // Decode Opcode & Execute Opcode if(opcode == 0x0){ return; } printf("PC = %d; opcode = %x\n", PC, opcode); switch((opcode & 0xF000) >> 12){ case 0x0: if((opcode & 0x0F) == 0){ //00E0 Clears the screen memset(gfx, 0, sizeof(gfx)); PC += 2; }else{ //00EE Returns from a subroutine --SP; PC = stack[SP]; } break; case 0x1: // 1NNN Jumps to address NNN addr = (opcode & 0x0FFF); PC = addr; break; case 0x2: //2NNN Calls subroutine at NNN stack[SP] = PC + 2; ++SP; addr = (opcode & 0x0FFF); PC = addr; break; case 0x3: //3XNN Skips the next instruction if VX equals NN x = (opcode & 0x0F00) >> 8; value = opcode & 0xFF; if(V[x] == value){ PC += 4; }else{ PC += 2; } break; case 0x4: //4XNN Skips the next instruction if VX doesn't equal NN x = (opcode & 0x0F00) >> 8; value = opcode & 0xFF; if(V[x] != value){ PC += 4; }else{ PC += 2; } break; case 0x5: //5XY0 Skips the next instruction if VX equals VY. x = (opcode & 0x0F00) >> 8; y = (opcode & 0xF0) >> 4; if(V[x] == V[y]){ PC += 4; }else{ PC += 2; } break; case 0x6: //6XNN Sets VX to NN. x = (opcode & 0x0F00) >> 8; value = (opcode & 0xFF); V[x] = value; PC += 2; break; case 0x7: //7XNN Adds NN to VX. x = (opcode & 0x0F00) >> 8; value = (opcode & 0xFF); V[x] += value; PC += 2; break; case 0x8: x = (opcode & 0x0F00) >> 8; y = (opcode & 0xF0) >> 4; switch(opcode & 0x0F){ case 0x0: //8XY0 Sets VX to the value of VY V[x] = V[y]; break; case 0x1: //8XY1 Sets VX to VX or VY V[x] |= V[y]; break; case 0x2: //8XY2 Sets VX to VX and VY V[x] &= V[y]; break; case 0x3: //8XY3 Sets VX to VX xor VY V[x] ^= V[y]; break; case 0x4: //8XY4 Adds VY to VX. VF is set to 1 when there's a carry, and to 0 when there isn't tmp = V[x] + V[y]; if(tmp >= V[x] && tmp >= V[y]){ V[0xF] = 0; }else{ V[0xF] = 1; } V[x] = tmp; break; case 0x5: //8XY5 VY is subtracted from VX. VF is set to 0 when there's a borrow, and 1 when there isn't. if(V[x] < V[y]){ V[0xF] = 1; V[x] += 256 - V[y]; }else{ V[0xF] = 0; V[x] -= V[y]; } break; case 0x6: //8XY6 Shifts VX right by one. VF is set to the value of the least significant bit of VX before the shift V[0xF] = V[x] & 0x1; V[x] >>= 1; break; case 0x7: //8XY7 Sets VX to VY minus VX. VF is set to 0 when there's a borrow, and 1 when there isn't if(V[y] < V[x]){ V[0xF] = 1; V[x] = V[y] + (256 - V[x]); }else{ V[0xF] = 0; V[x] = V[y] - V[x]; } break; case 0xE: //8XYE Shifts VX left by one. VF is set to the value of the most significant bit of VX before the shift V[0xF] = (V[x] & 0x80) >> 7; V[x] <<= 1; break; } PC += 2; break; case 0x9: //9XY0 Skips the next instruction if VX doesn't equal VY x = (opcode & 0x0F00) >> 8; y = (opcode & 0xF0) >> 4; if(V[x] != V[y]){ PC += 4; }else{ PC += 2; } case 0xA: //ANNN Sets I to the address NNN. addr = opcode & 0x0FFF; I = addr; PC += 2; break; case 0xB: //BNNN Jumps to the address NNN plus V0 addr = (opcode & 0x0FFF) + V[0]; PC = addr; break; case 0xC: //CXNN Sets VX to the result of a bitwise and operation on a random number and NN x = (opcode & 0x0F00) >> 8; value = (opcode & 0xFF) & (rand() % 256); V[x] = value; PC += 2; break; case 0xD: //DXYN Sprites stored in memory at location in index register (I), 8bits wide. Wraps around the screen. //If when drawn, clears a pixel, register VF is set to 1 otherwise it is zero. //All drawing is XOR drawing (i.e. it toggles the screen pixels). //Sprites are drawn starting at position VX, VY. N is the number of 8bit rows that need to be drawn. //If N is greater than 1, second line continues at position VX, VY+1, and so on w = 8; h = opcode & 0x0F; x = (opcode & 0x0F00) >> 8; y = (opcode & 0xF0) >> 4; for(u8 i = 0; i < h; ++i){ u8 line = memory[I + i]; for(u8 j = 0; j < w; ++j){ xx = x + j; yy = y + i; id = yy * 64 + xx; if((line & (0x80 >> j)) != 0){ if(gfx[id] == 1){ V[0x0F] = 1; } gfx[id] ^= 1; } } } PC += 2; break; case 0xE: x = (opcode & 0x0F00) >> 8; switch(opcode & 0xFF){ case 0x9E: //EX9E Skips the next instruction if the key stored in VX is pressed if(key[V[x]] != 0){ PC += 4; }else{ PC += 2; } break; case 0xA1: //EXA1 Skips the next instruction if the key stored in VX isn't pressed if(key[V[x]] == 0){ PC += 4; }else{ PC += 2; } } break; case 0xF: x = (opcode & 0x0F00) >> 8; switch(opcode & 0xFF){ case 0x07: //FX07 Sets VX to the value of the delay timer V[x] = delay_timer; break; case 0x0A:{ //FX0A A key press is awaited, and then stored in VX. bool keyPressed = false; for(xx = 0; xx < 16; ++xx){ if(key[xx] != 0){ keyPressed = true; V[x] = xx; } } if(!keyPressed){ return; } } break; case 0x15: //FX15 Sets the delay timer to VX. delay_timer = V[x]; break; case 0x18: //FX18 Sets the sound timer to VX. sound_timer = V[x]; break; case 0x1E: //FX1E Adds VX to I I += V[x]; if(I > 0xFFF){ V[0xF] = 1; }else{ V[0xF] = 0; } break; case 0x29: //FX29 Sets I to the location of the sprite for the character in VX. //Characters 0-F (in hexadecimal) are represented by a 4x5 font I = V[x] * 5; break; case 0x33: //FX33 Stores the binary-coded decimal representation of VX, //with the most significant of three digits at the address in I, //the middle digit at I plus 1, and the least significant digit at I plus 2. //(In other words, take the decimal representation of VX, //place the hundreds digit in memory at location in I, the tens digit at location I+1, //and the ones digit at location I+2 memory[I] = V[x] / 100; memory[I+1] = (V[x] % 100) / 10; memory[I+2] = V[x] % 10; break; case 0x55: //FX55 Stores V0 to VX (including VX) in memory starting at address I for(xx = 0; xx <= x; ++xx){ memory[I + xx] = V[xx]; } I += x + 1; break; case 0x65: //FX65 Fills V0 to VX (including VX) with values from memory starting at address I for(xx = 0; xx <= x; ++xx){ V[xx] = memory[I + xx]; } I += x + 1; break; } PC += 2; break; } // Update timers if(delay_timer > 0){ --delay_timer; } if(sound_timer > 0){ if(sound_timer == 1){ play_beep(); } --sound_timer; } }