9dc4b12708
- Don't show debug info by default - Other minor formatting changes
647 lines
16 KiB
C
647 lines
16 KiB
C
// Copyright 2015-2020 <>< Charles Lohr under the ColorChord License.
|
|
|
|
#if defined( WINDOWS ) || defined( USE_WINDOWS ) || defined( WIN32 ) || defined( WIN64 ) || \
|
|
defined( _WIN32 ) || defined( _WIN64 )
|
|
#ifdef TCC
|
|
#include <winsock2.h>
|
|
#endif
|
|
#ifndef strdup
|
|
#define strdup _strdup
|
|
#endif
|
|
// define convenient macro to detect windows
|
|
#define IS_WINDOWS 1
|
|
#else
|
|
// this isn't windows
|
|
#define IS_WINDOWS 0
|
|
#endif
|
|
|
|
#include "color.h"
|
|
#include "configs.h"
|
|
#include "decompose.h"
|
|
#include "dft.h"
|
|
#include "filter.h"
|
|
#include "hook.h"
|
|
#include "notefinder.h"
|
|
#include "os_generic.h"
|
|
#include "outdrivers.h"
|
|
#include "parameters.h"
|
|
#include <ctype.h>
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
|
|
#define CNFG_IMPLEMENTATION
|
|
#include "CNFG.h"
|
|
|
|
#define CNFA_IMPLEMENTATION
|
|
#include "CNFA.h"
|
|
|
|
|
|
// Sound driver.
|
|
struct CNFADriver *sd;
|
|
|
|
int bQuitColorChord = 0;
|
|
|
|
|
|
#ifdef ANDROID
|
|
#include <android/log.h>
|
|
#include <fcntl.h>
|
|
#include <pthread.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
void HandleDestroy()
|
|
{
|
|
bQuitColorChord = 1;
|
|
CNFAClose( sd );
|
|
}
|
|
|
|
|
|
#endif
|
|
|
|
|
|
#define GENLINEWIDTH 89
|
|
#define GENLINES 67
|
|
|
|
char genlog[ ( GENLINEWIDTH + 1 ) * ( GENLINES + 1 ) + 2 ] = "log";
|
|
int genloglen;
|
|
int genloglines;
|
|
int genlinelen = 0;
|
|
int firstnewline = -1;
|
|
|
|
|
|
// Define application colors RGBA format
|
|
#define BACKGROUND_COLOR 0x000000ff
|
|
#define LINE_COLOR 0xffffffff
|
|
#define TEXT_COLOR 0xffffffff
|
|
// Text colors for the debug options at the bottom of the screen
|
|
#define ENABLED_COLOR 0xffffffff
|
|
#define DISABLED_COLOR 0x800000ff
|
|
|
|
void example_log_function( int readSize, char *buf )
|
|
{
|
|
static og_mutex_t *mt;
|
|
if ( !mt ) mt = OGCreateMutex();
|
|
OGLockMutex( mt );
|
|
for ( int i = 0; readSize && i <= readSize && buf[ i ]; i++ )
|
|
{
|
|
char c = buf[ i ];
|
|
if ( c == '\0' ) c = '\n';
|
|
if ( ( c != '\n' && genlinelen >= GENLINEWIDTH ) || c == '\n' )
|
|
{
|
|
genloglines++;
|
|
if ( genloglines >= GENLINES )
|
|
{
|
|
genloglen -= firstnewline + 1;
|
|
int offset = firstnewline;
|
|
firstnewline = -1;
|
|
int k;
|
|
for ( k = 0; k < genloglen; k++ )
|
|
{
|
|
if ( ( genlog[ k ] = genlog[ k + offset + 1 ] ) == '\n' && firstnewline < 0 )
|
|
firstnewline = k;
|
|
}
|
|
genlog[ k ] = 0;
|
|
genloglines--;
|
|
}
|
|
genlinelen = 0;
|
|
if ( c != '\n' )
|
|
{
|
|
genlog[ genloglen + 1 ] = 0;
|
|
genlog[ genloglen++ ] = '\n';
|
|
}
|
|
if ( firstnewline < 0 ) firstnewline = genloglen;
|
|
}
|
|
genlog[ genloglen + 1 ] = 0;
|
|
genlog[ genloglen++ ] = c;
|
|
if ( c != '\n' ) genlinelen++;
|
|
}
|
|
|
|
OGUnlockMutex( mt );
|
|
}
|
|
|
|
|
|
#if defined( WIN32 ) || defined( USE_WINDOWS )
|
|
#define ESCAPE_KEY 0x1B
|
|
|
|
void HandleDestroy()
|
|
{
|
|
CNFAClose( sd );
|
|
}
|
|
#else
|
|
#define ESCAPE_KEY 65307
|
|
// Stub function for Linux
|
|
void HandleDestroy()
|
|
{
|
|
}
|
|
|
|
#endif
|
|
|
|
float DeltaFrameTime = 0;
|
|
double Now = 0;
|
|
int is_suspended = 0;
|
|
int lastfps;
|
|
short screenx, screeny;
|
|
|
|
struct DriverInstances *outdriver[ MAX_OUT_DRIVERS ];
|
|
int headless = 0; REGISTER_PARAM( headless, PAINT );
|
|
int set_screenx = 640; REGISTER_PARAM( set_screenx, PAINT );
|
|
int set_screeny = 480; REGISTER_PARAM( set_screeny, PAINT );
|
|
char sound_source[ 16 ]; REGISTER_PARAM( sound_source, PABUFFER );
|
|
int cpu_autolimit = 1; REGISTER_PARAM( cpu_autolimit, PAINT );
|
|
float cpu_autolimit_interval = 0.016; REGISTER_PARAM( cpu_autolimit_interval, PAFLOAT );
|
|
int sample_channel = -1; REGISTER_PARAM( sample_channel, PAINT );
|
|
int showfps = 1; REGISTER_PARAM( showfps, PAINT );
|
|
|
|
#if defined( ANDROID ) || defined( __android__ )
|
|
float in_amplitude = 2;
|
|
#else
|
|
float in_amplitude = 1;
|
|
#endif
|
|
REGISTER_PARAM( in_amplitude, PAFLOAT );
|
|
|
|
struct NoteFinder *nf;
|
|
|
|
// Sound circular buffer
|
|
#define SOUNDCBSIZE 8096
|
|
#define MAX_CHANNELS 2
|
|
|
|
double VisTimeEnd, VisTimeStart;
|
|
float sound[ SOUNDCBSIZE ];
|
|
int soundhead = 0;
|
|
int show_debug = 0;
|
|
int show_debug_basic = 0;
|
|
|
|
int gKey = 0;
|
|
extern int force_white;
|
|
|
|
void RecalcBaseHz()
|
|
{
|
|
nf->base_hz = 55 * pow( 2, gKey / 12.0 );
|
|
ChangeNFParameters( nf );
|
|
}
|
|
|
|
void HandleKey( int keycode, int bDown )
|
|
{
|
|
char c = toupper( keycode );
|
|
#ifdef ANDROID
|
|
if ( keycode == 4 && bDown )
|
|
{
|
|
// Back button.
|
|
printf( "Back button pressed\n" );
|
|
AndroidSendToBack( 0 );
|
|
return;
|
|
}
|
|
#endif
|
|
if( keycode == ESCAPE_KEY ) exit( 0 );
|
|
if( c == 'W' ) force_white = bDown;
|
|
if( c == 'D' && bDown ) show_debug = !show_debug;
|
|
if( c == '9' && bDown ) { gKey--; RecalcBaseHz(); }
|
|
if( c == '-' && bDown ) { gKey++; RecalcBaseHz(); }
|
|
if( c == '0' && bDown ) { gKey = 0; RecalcBaseHz(); }
|
|
if( c == 'E' && bDown ) show_debug_basic = !show_debug_basic;
|
|
if( c == 'K' && bDown ) DumpParameters();
|
|
printf( "Key: %d -> %d\n", keycode, bDown );
|
|
KeyHappened( keycode, bDown );
|
|
}
|
|
|
|
// On Android we want a really basic GUI
|
|
void HandleButton( int x, int y, int button, int bDown )
|
|
{
|
|
printf( "Button: %d,%d (%d) -> %d\n", x, y, button, bDown );
|
|
if ( bDown )
|
|
{
|
|
if ( y < 800 )
|
|
{
|
|
if ( x < screenx / 3 )
|
|
gKey--;
|
|
else if ( x < ( screenx * 2 / 3 ) )
|
|
gKey = 0;
|
|
else
|
|
gKey++;
|
|
printf( "KEY: %d\n", gKey );
|
|
RecalcBaseHz();
|
|
}
|
|
}
|
|
}
|
|
|
|
void HandleMotion( int x, int y, int mask )
|
|
{
|
|
}
|
|
|
|
void SoundCB( struct CNFADriver *sd, short *out, short *in, int framesp, int framesr )
|
|
{
|
|
int channelin = sd->channelsRec;
|
|
int channelout = sd->channelsPlay;
|
|
|
|
// Load the samples into a ring buffer. Split the channels from interleved to one per buffer.
|
|
if ( in )
|
|
{
|
|
for ( int i = 0; i < framesr; i++ )
|
|
{
|
|
if ( sample_channel < 0 )
|
|
{
|
|
float fo = 0;
|
|
for ( int j = 0; j < channelin; j++ )
|
|
{
|
|
float f = in[ i * channelin + j ] / 32767.;
|
|
if ( f >= -1 && f <= 1 )
|
|
fo += f;
|
|
else
|
|
fo += ( f > 0 ) ? 1 : -1;
|
|
}
|
|
fo /= channelin;
|
|
sound[ soundhead ] = fo * in_amplitude;
|
|
soundhead = ( soundhead + 1 ) % SOUNDCBSIZE;
|
|
}
|
|
else
|
|
{
|
|
float f = in[ i * channelin + sample_channel ] / 32767.;
|
|
if ( f > 1 || f < -1 ) f = ( f > 0 ) ? 1 : -1;
|
|
sound[ soundhead ] = f * in_amplitude;
|
|
soundhead = ( soundhead + 1 ) % SOUNDCBSIZE;
|
|
}
|
|
}
|
|
SoundEventHappened( framesr, in, 0, channelin );
|
|
}
|
|
|
|
|
|
if ( out )
|
|
{
|
|
memset( out, 0, framesp * channelout );
|
|
SoundEventHappened( framesp, out, 1, channelout );
|
|
}
|
|
}
|
|
|
|
#ifdef ANDROID
|
|
void HandleSuspend()
|
|
{
|
|
is_suspended = 1;
|
|
}
|
|
|
|
void HandleResume()
|
|
{
|
|
is_suspended = 0;
|
|
}
|
|
#endif
|
|
|
|
// function for calling initilization functions if we are using TCC
|
|
#ifdef TCC
|
|
void RegisterConstructorFunctions()
|
|
{
|
|
|
|
// Basic Window stuff
|
|
REGISTERheadless();
|
|
REGISTERset_screenx();
|
|
REGISTERset_screeny();
|
|
REGISTERsound_source();
|
|
REGISTERcpu_autolimit();
|
|
REGISTERcpu_autolimit_interval();
|
|
REGISTERsample_channel();
|
|
REGISTERshowfps();
|
|
REGISTERin_amplitude();
|
|
|
|
// Audio stuff
|
|
REGISTERNullCNFA();
|
|
REGISTERWinCNFA();
|
|
REGISTERcnfa_wasapi();
|
|
|
|
// Video Stuff
|
|
REGISTERnull();
|
|
REGISTERDisplayArray();
|
|
REGISTERDisplayHIDAPI();
|
|
REGISTERDisplayNetwork();
|
|
REGISTERDisplayOutDriver();
|
|
REGISTERDisplayPie();
|
|
REGISTERDisplayRadialPoles();
|
|
// block trying to load linux specific displays
|
|
#if not IS_WINDOWS
|
|
REGISTERDisplayDMX();
|
|
REGISTERDisplayFileWrite();
|
|
REGISTERDisplaySHM();
|
|
REGISTERDisplayUSB2812();
|
|
#endif
|
|
|
|
// Output stuff
|
|
REGISTEROutputCells();
|
|
REGISTEROutputLinear();
|
|
REGISTEROutputProminent();
|
|
REGISTEROutputVoronoi();
|
|
}
|
|
#endif
|
|
|
|
int main( int argc, char **argv )
|
|
{
|
|
#ifdef TCC
|
|
RegisterConstructorFunctions();
|
|
#endif
|
|
|
|
|
|
printf( "Output Drivers:\n" );
|
|
for ( int i = 0; i < MAX_OUT_DRIVERS; i++ )
|
|
{
|
|
if ( ODList[ i ].Name ) printf( "\t%s\n", ODList[ i ].Name );
|
|
}
|
|
|
|
#if defined( WIN32 ) || defined( USE_WINDOWS )
|
|
// In case something needs network access.
|
|
WSADATA wsaData;
|
|
WSAStartup( 0x202, &wsaData );
|
|
#elif defined( ANDROID )
|
|
int hasperm = AndroidHasPermissions( "READ_EXTERNAL_STORAGE" );
|
|
int haspermInternet = AndroidHasPermissions( "INTERNET" );
|
|
if ( !hasperm ) AndroidRequestAppPermissions( "READ_EXTERNAL_STORAGE" );
|
|
if ( !haspermInternet ) AndroidRequestAppPermissions( "INTERNET" );
|
|
#else
|
|
// Linux
|
|
#endif
|
|
|
|
gargc = argc;
|
|
gargv = argv;
|
|
|
|
SetupConfigs();
|
|
|
|
// Initialize Rawdraw
|
|
int frames = 0;
|
|
double ThisTime;
|
|
double SecToWait;
|
|
double LastFPSTime = OGGetAbsoluteTime();
|
|
double LastFrameTime = OGGetAbsoluteTime();
|
|
CNFGBGColor = BACKGROUND_COLOR;
|
|
|
|
// Generate the window title
|
|
char title[ 1024 ];
|
|
strcpy( title, "Colorchord " );
|
|
for ( int i = 1; i < argc; i++ )
|
|
{
|
|
strcat( title, argv[ i ] );
|
|
strcat( title, " " );
|
|
}
|
|
if ( !headless ) CNFGSetup( title, set_screenx, set_screeny );
|
|
|
|
char *OutDriverNames = strdup( GetParameterS( "outdrivers", "null" ) );
|
|
char *ThisDriver = OutDriverNames;
|
|
char *TDStart;
|
|
for ( int i = 0; i < MAX_OUT_DRIVERS; i++ )
|
|
{
|
|
while ( *ThisDriver == ' ' || *ThisDriver == '\t' ) ThisDriver++;
|
|
if ( !*ThisDriver ) break;
|
|
|
|
TDStart = ThisDriver;
|
|
|
|
while ( *ThisDriver != 0 && *ThisDriver != ',' )
|
|
{
|
|
if ( *ThisDriver == '\t' || *ThisDriver == ' ' ) *ThisDriver = 0;
|
|
ThisDriver++;
|
|
}
|
|
|
|
if ( *ThisDriver )
|
|
{
|
|
*ThisDriver = 0;
|
|
ThisDriver++;
|
|
}
|
|
|
|
printf( "Loading: %s\n", TDStart );
|
|
outdriver[ i ] = SetupOutDriver( TDStart );
|
|
}
|
|
free( OutDriverNames );
|
|
|
|
|
|
do {
|
|
#if IS_WINDOWS
|
|
const char *record_dev_name = "defaultRender";
|
|
#else
|
|
const char *record_dev_name = "@DEFAULT_MONITOR@";
|
|
#endif
|
|
// Initialize Sound
|
|
sd = CNFAInit( sound_source, "colorchord", &SoundCB, GetParameterI( "samplerate", 44100 ),
|
|
GetParameterI( "samplerate", 44100 ), GetParameterI( "channels", 2 ),
|
|
GetParameterI( "channels", 2 ), GetParameterI( "buffer", 1024 ),
|
|
GetParameterS( "devplay", "default" ), GetParameterS( "devrecord", record_dev_name ),
|
|
NULL );
|
|
|
|
if ( sd ) break;
|
|
|
|
CNFGColor( LINE_COLOR );
|
|
CNFGPenX = 10;
|
|
CNFGPenY = 100;
|
|
CNFGHandleInput();
|
|
CNFGClearFrame();
|
|
CNFGDrawText( "Colorchord must be used with sound. Sound not available.", 10 );
|
|
CNFGSwapBuffers();
|
|
OGSleep( 1 );
|
|
} while ( 1 );
|
|
nf = CreateNoteFinder( sd->spsRec );
|
|
|
|
// Once everything was reinitialized, re-read the ini files.
|
|
SetEnvValues( 1 );
|
|
|
|
printf( "================================================= Set Up\n" );
|
|
|
|
Now = OGGetAbsoluteTime();
|
|
double Last = Now;
|
|
while ( !bQuitColorChord )
|
|
{
|
|
char stt[ 1024 ];
|
|
// Handle Rawdraw frame swappign
|
|
|
|
Now = OGGetAbsoluteTime();
|
|
DeltaFrameTime = Now - Last;
|
|
|
|
if ( !headless )
|
|
{
|
|
CNFGHandleInput();
|
|
CNFGClearFrame();
|
|
CNFGColor( LINE_COLOR );
|
|
CNFGGetDimensions( &screenx, &screeny );
|
|
}
|
|
|
|
RunNoteFinder( nf, sound, ( soundhead - 1 + SOUNDCBSIZE ) % SOUNDCBSIZE, SOUNDCBSIZE );
|
|
// Done all ColorChord work.
|
|
|
|
|
|
VisTimeStart = OGGetAbsoluteTime();
|
|
|
|
// call the output drivers with the updated note finder data
|
|
for ( int i = 0; i < MAX_OUT_DRIVERS; i++ )
|
|
{
|
|
if ( force_white ) memset( OutLEDs, 0x7f, MAX_LEDS * 3 );
|
|
if ( outdriver[ i ] ) outdriver[ i ]->Func( outdriver[ i ]->id, nf );
|
|
}
|
|
|
|
VisTimeEnd = OGGetAbsoluteTime();
|
|
|
|
|
|
if ( !headless )
|
|
{
|
|
// Handle outputs.
|
|
int freqbins = nf->freqbins;
|
|
int note_peaks = freqbins / 2;
|
|
int freqs = freqbins * nf->octaves;
|
|
|
|
// Do a bunch of debugging.
|
|
if ( show_debug_basic && !is_suspended )
|
|
{
|
|
CNFGColor( TEXT_COLOR );
|
|
for ( int i = 0; i < nf->dists_count; i++ )
|
|
{
|
|
// Move over 0.5 for visual purposes. The means is correct.
|
|
CNFGPenX = ( nf->dists[ i ].mean + 0.5 ) / freqbins * screenx;
|
|
CNFGPenY = 400 - nf->dists[ i ].amp * 150.0 / nf->dists[ i ].sigma;
|
|
sprintf( stt, "%f\n%f\n", nf->dists[ i ].mean, nf->dists[ i ].amp );
|
|
CNFGDrawText( stt, 2 );
|
|
}
|
|
|
|
CNFGColor( LINE_COLOR );
|
|
// Draw the folded bins
|
|
for ( int bin = 0; bin < freqbins; bin++ )
|
|
{
|
|
const float x0 = bin / (float)freqbins * (float)screenx;
|
|
const float x1 = ( bin + 1 ) / (float)freqbins * (float)screenx;
|
|
const float amp = nf->folded_bins[ bin ] * 250.0;
|
|
const float note = (float)( bin + 0.5 ) / freqbins;
|
|
CNFGDialogColor = CCtoHEX( note, 1.0, 1.0 );
|
|
CNFGDrawBox( x0, 400 - amp, x1, 400 );
|
|
}
|
|
|
|
// Draw the note peaks
|
|
for ( int peak = 0; peak < note_peaks; peak++ )
|
|
{
|
|
if ( nf->note_amplitudes_out[ peak ] < 0 ) continue;
|
|
float note = (float)nf->note_positions[ peak ] / freqbins;
|
|
CNFGDialogColor = CCtoHEX( note, 1.0, 1.0 );
|
|
const int x1 = ( (float)peak / note_peaks ) * screenx;
|
|
const int x2 = ( (float)( peak + 1 ) / note_peaks ) * screenx;
|
|
const int y1 = 480 - nf->note_amplitudes_out[ peak ] * 100;
|
|
const int y2 = 480;
|
|
CNFGColor( LINE_COLOR );
|
|
CNFGDrawBox( x1, y1, x2, y2 );
|
|
|
|
CNFGPenX = ( (float)( peak + .4 ) / note_peaks ) * screenx;
|
|
CNFGPenY = screeny - 30;
|
|
sprintf( stt, "%d\n%0.0f", nf->enduring_note_id[ peak ],
|
|
nf->note_amplitudes2[ peak ] * 1000.0 );
|
|
|
|
CNFGColor( TEXT_COLOR );
|
|
CNFGDrawText( stt, 2 );
|
|
}
|
|
|
|
CNFGColor( LINE_COLOR );
|
|
// Let's draw the o-scope.
|
|
int lasty;
|
|
int thissoundhead = ( soundhead - 1 + SOUNDCBSIZE ) % SOUNDCBSIZE;
|
|
int thisy = sound[ thissoundhead ] * -128 + 128;
|
|
for ( int i = screenx - 1; i > 0; i-- )
|
|
{
|
|
lasty = thisy;
|
|
thissoundhead = ( thissoundhead - 1 + SOUNDCBSIZE ) % SOUNDCBSIZE;
|
|
thisy = sound[ thissoundhead ] * -128 + 128;
|
|
CNFGTackSegment( i, lasty, i - 1, thisy );
|
|
}
|
|
}
|
|
|
|
// Extra debugging?
|
|
if ( show_debug && !is_suspended )
|
|
{
|
|
// Draw the histogram
|
|
float lasthistval;
|
|
CNFGColor( LINE_COLOR );
|
|
for ( int x_val = -1; x_val < screenx; x_val++ )
|
|
{
|
|
// Calculate the value of the histogram at the current screen position
|
|
float hist_point = (float)x_val / (float)screenx * freqbins - 0.5;
|
|
float thishistval =
|
|
CalcHistAt( hist_point, nf->freqbins, nf->dists, nf->dists_count );
|
|
|
|
// Display the value on the screen
|
|
const short y = 400 - lasthistval * 250.0;
|
|
if ( x_val >= 0 ) CNFGTackSegment( x_val, y, x_val + 1, y );
|
|
lasthistval = thishistval;
|
|
}
|
|
|
|
CNFGColor( LINE_COLOR );
|
|
// Draw the bins
|
|
for ( int bin = 0; bin < freqs; bin++ )
|
|
{
|
|
float x0 = bin / (float)freqs * (float)screenx;
|
|
float x1 = ( bin + 1 ) / (float)freqs * (float)screenx;
|
|
float amp = nf->outbins[ bin ] * 250.0;
|
|
float note = (float)bin / freqbins;
|
|
CNFGDialogColor = CCtoHEX( note, 1.0, 1.0 );
|
|
CNFGDrawBox( x0, 0, x1, amp );
|
|
}
|
|
|
|
CNFGColor( TEXT_COLOR );
|
|
char stdebug[ 1024 ];
|
|
sprintf( stdebug, "DFT:%8.2fms\nFLT:%8.2f\nDEC:%8.2f\nFNL:%8.2f\nDPY:%8.2f",
|
|
( nf->DFTTime - nf->StartTime ) * 1000, ( nf->FilterTime - nf->DFTTime ) * 1000,
|
|
( nf->DecomposeTime - nf->FilterTime ) * 1000,
|
|
( nf->FinalizeTime - nf->DecomposeTime ) * 1000,
|
|
( VisTimeEnd - VisTimeStart ) * 1000 );
|
|
CNFGPenX = 50;
|
|
CNFGPenY = 50;
|
|
CNFGDrawText( stdebug, 2 );
|
|
}
|
|
|
|
if ( !is_suspended )
|
|
{
|
|
CNFGColor( show_debug ? ENABLED_COLOR : DISABLED_COLOR );
|
|
CNFGPenX = 0;
|
|
CNFGPenY = screeny - 10;
|
|
CNFGDrawText( "Extra Debug (D)", 2 );
|
|
|
|
CNFGColor( show_debug_basic ? ENABLED_COLOR : DISABLED_COLOR );
|
|
CNFGPenX = 120;
|
|
CNFGPenY = screeny - 10;
|
|
CNFGDrawText( "Basic Debug (E)", 2 );
|
|
|
|
CNFGColor( show_debug_basic ? ENABLED_COLOR : DISABLED_COLOR );
|
|
CNFGPenX = 240;
|
|
CNFGPenY = screeny - 10;
|
|
sprintf( stt, "[9] Key: %d [0] (%3.1f) [-]", gKey, nf->base_hz );
|
|
CNFGDrawText( stt, 2 );
|
|
|
|
CNFGColor( TEXT_COLOR );
|
|
CNFGPenX = 440;
|
|
CNFGPenY = screeny - 10;
|
|
sprintf( stt, "FPS: %d", lastfps );
|
|
CNFGDrawText( stt, 2 );
|
|
|
|
#ifdef ANDROID
|
|
CNFGColor( TEXT_COLOR );
|
|
CNFGPenX = 10;
|
|
CNFGPenY = 600;
|
|
CNFGDrawText( genlog, 3 );
|
|
#endif
|
|
CNFGSwapBuffers();
|
|
}
|
|
}
|
|
|
|
// Finish Rawdraw with FPS counter, and a nice delay loop.
|
|
frames++;
|
|
|
|
ThisTime = OGGetAbsoluteTime();
|
|
if ( ThisTime > LastFPSTime + 1 && showfps )
|
|
{
|
|
lastfps = frames;
|
|
frames = 0;
|
|
LastFPSTime += 1;
|
|
}
|
|
|
|
if ( cpu_autolimit )
|
|
{
|
|
SecToWait = cpu_autolimit_interval - ( ThisTime - LastFrameTime );
|
|
LastFrameTime += cpu_autolimit_interval;
|
|
if ( SecToWait < -.1 ) LastFrameTime = ThisTime - .1;
|
|
if ( SecToWait > 0 ) OGUSleep( (int)( SecToWait * 1000000 ) );
|
|
}
|
|
|
|
if ( !is_suspended ) SetEnvValues( 0 );
|
|
|
|
Last = Now;
|
|
}
|
|
}
|