summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorDaniel Stenberg <daniel@haxx.se>2006-03-03 08:14:44 +0000
committerDaniel Stenberg <daniel@haxx.se>2006-03-03 08:14:44 +0000
commit220fafdd72eab05eb49cf6811d15d6618a168910 (patch)
treec90ef2fe3e9bb932197ac3ff5b305dd39a66204e
parente248eac20fc75566605aee705c130e0fa456aced (diff)
downloadrockbox-220fafdd72eab05eb49cf6811d15d6618a168910.tar.gz
rockbox-220fafdd72eab05eb49cf6811d15d6618a168910.zip
Code Police raid. Mostly changed // comments and indented to Rockbox style.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@8894 a1c6a512-1295-4272-9138-f99709370657
-rw-r--r--apps/plugins/fire.c2
-rw-r--r--apps/plugins/firmware_flash.c4
-rw-r--r--apps/plugins/grayscale.c4
-rw-r--r--apps/plugins/jpeg.c8
-rw-r--r--apps/plugins/mandelbrot.c12
-rw-r--r--apps/plugins/metronome.c4
-rw-r--r--apps/plugins/midi2wav.c12
-rw-r--r--apps/plugins/minesweeper.c6
-rw-r--r--apps/plugins/mp3_encoder.c134
-rw-r--r--apps/plugins/plasma.c2
-rw-r--r--apps/plugins/star.c12
-rw-r--r--apps/plugins/starfield.c4
-rw-r--r--apps/plugins/sudoku.c1389
-rw-r--r--apps/plugins/video.c495
-rw-r--r--apps/plugins/wav2wv.c2
15 files changed, 1068 insertions, 1022 deletions
diff --git a/apps/plugins/fire.c b/apps/plugins/fire.c
index 64c9fa9371..722f2bfc2e 100644
--- a/apps/plugins/fire.c
+++ b/apps/plugins/fire.c
@@ -404,4 +404,4 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
return ret;
}
-#endif // #ifdef HAVE_LCD_BITMAP
+#endif /* #ifdef HAVE_LCD_BITMAP */
diff --git a/apps/plugins/firmware_flash.c b/apps/plugins/firmware_flash.c
index fa77a33697..1fc6b07a89 100644
--- a/apps/plugins/firmware_flash.c
+++ b/apps/plugins/firmware_flash.c
@@ -362,13 +362,13 @@ tCheckResult CheckFirmwareFile(char* filename, int chipsize, bool is_romless)
}
if (fileleft == 256*1024)
- { // original dumped firmware file has no CRC nor platform ID
+ { /* original dumped firmware file has no CRC nor platform ID */
has_crc = false;
}
else
{
has_crc = true;
- fileleft -= sizeof(unsigned); // exclude the last 4 bytes
+ fileleft -= sizeof(unsigned); /* exclude the last 4 bytes */
}
/* do some sanity checks */
diff --git a/apps/plugins/grayscale.c b/apps/plugins/grayscale.c
index 4ca2ba09b3..dfb48785cf 100644
--- a/apps/plugins/grayscale.c
+++ b/apps/plugins/grayscale.c
@@ -328,11 +328,11 @@ int main(void)
enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
{
- rb = api; // copy to global api pointer
+ rb = api; /* copy to global api pointer */
(void)parameter;
return main();
}
-#endif // #ifdef HAVE_LCD_BITMAP
+#endif /* #ifdef HAVE_LCD_BITMAP */
diff --git a/apps/plugins/jpeg.c b/apps/plugins/jpeg.c
index a39e6dc933..62d6f1efe9 100644
--- a/apps/plugins/jpeg.c
+++ b/apps/plugins/jpeg.c
@@ -1235,7 +1235,7 @@ void build_lut(struct jpeg* p_jpeg)
}
else
{
- // error
+ /* error */
}
}
@@ -1429,7 +1429,7 @@ int jpeg_decode(struct jpeg* p_jpeg, unsigned char* p_pixel[3],
int k_need; /* AC coefficients needed up to here */
int zero_need; /* init the block with this many zeros */
- int last_dc_val[3] = {0, 0, 0}; // or 128 for chroma?
+ int last_dc_val[3] = {0, 0, 0}; /* or 128 for chroma? */
int store_offs[4]; /* memory offsets: order of Y11 Y12 Y21 Y22 U V */
int restart = p_jpeg->restart_interval; /* MCUs until restart marker */
@@ -1483,7 +1483,7 @@ int jpeg_decode(struct jpeg* p_jpeg, unsigned char* p_pixel[3],
for(y=0; y<p_jpeg->y_mbl && bs.next_input_byte <= bs.input_end; y++)
{
- for (i=0; i<3; i++) // scan line init
+ for (i=0; i<3; i++) /* scan line init */
{
p_byte[i] = p_line[i];
p_line[i] += skip_strip[i];
@@ -1567,7 +1567,7 @@ int jpeg_decode(struct jpeg* p_jpeg, unsigned char* p_pixel[3],
skip_line[ci]);
}
} /* for blkn */
- p_byte[0] += skip_mcu[0]; // unrolled for (i=0; i<3; i++) loop
+ p_byte[0] += skip_mcu[0]; /* unrolled for (i=0; i<3; i++) loop */
p_byte[1] += skip_mcu[1];
p_byte[2] += skip_mcu[2];
if (p_jpeg->restart_interval && --restart == 0)
diff --git a/apps/plugins/mandelbrot.c b/apps/plugins/mandelbrot.c
index d4e399c057..6fe6b352e0 100644
--- a/apps/plugins/mandelbrot.c
+++ b/apps/plugins/mandelbrot.c
@@ -321,14 +321,14 @@ void recalc_parameters(void)
void init_mandelbrot_set(void)
{
#if CONFIG_LCD == LCD_SSD1815 /* Recorder, Ondio. */
- x_min = -38L<<22; // -2.375<<26
- x_max = 15L<<22; // 0.9375<<26
+ x_min = -38L<<22; /* -2.375<<26 */
+ x_max = 15L<<22; /* 0.9375<<26 */
#else /* all others (square pixels) */
- x_min = -36L<<22; // -2.25<<26
- x_max = 12L<<22; // 0.75<<26
+ x_min = -36L<<22; /* -2.25<<26 */
+ x_max = 12L<<22; /* 0.75<<26 */
#endif
- y_min = -19L<<22; // -1.1875<<26
- y_max = 19L<<22; // 1.1875<<26
+ y_min = -19L<<22; /* -1.1875<<26 */
+ y_max = 19L<<22; /* 1.1875<<26 */
recalc_parameters();
}
diff --git a/apps/plugins/metronome.c b/apps/plugins/metronome.c
index c7200300f3..8e185b58a9 100644
--- a/apps/plugins/metronome.c
+++ b/apps/plugins/metronome.c
@@ -746,7 +746,7 @@ void play_tock(void) {
void calc_period(void)
{
- period = 61440/bpm-1; // (60*1024)/bpm;
+ period = 61440/bpm-1; /* (60*1024)/bpm; */
}
@@ -904,7 +904,7 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter){
rb = api;
if (MET_IS_PLAYING)
- MET_PLAY_STOP; // stop audio IS
+ MET_PLAY_STOP; /* stop audio IS */
#if CONFIG_CODEC != SWCODEC
rb->bitswap(sound, sizeof(sound));
diff --git a/apps/plugins/midi2wav.c b/apps/plugins/midi2wav.c
index d0d46612b6..d4d5166fe0 100644
--- a/apps/plugins/midi2wav.c
+++ b/apps/plugins/midi2wav.c
@@ -23,7 +23,7 @@
/* Only define LOCAL_DSP on Simulator or else we're asking for trouble */
#if defined(SIMULATOR)
/*Enable this to write to the soundcard via a /dsv/dsp symlink in */
- //#define LOCAL_DSP
+ /*#define LOCAL_DSP */
#endif
@@ -39,7 +39,7 @@
#include "../../plugin.h"
-//#include "../codecs/lib/xxx2wav.h"
+/*#include "../codecs/lib/xxx2wav.h" */
PLUGIN_HEADER
@@ -200,14 +200,14 @@ int midimain(void * filename)
* why this happens.
*/
- outputBuffer[outputBufferPosition]=outputSampleOne&0XFF; // Low byte first
+ outputBuffer[outputBufferPosition]=outputSampleOne&0XFF; /* Low byte first */
outputBufferPosition++;
- outputBuffer[outputBufferPosition]=outputSampleOne>>8; //High byte second
+ outputBuffer[outputBufferPosition]=outputSampleOne>>8; /*High byte second */
outputBufferPosition++;
- outputBuffer[outputBufferPosition]=outputSampleTwo&0XFF; // Low byte first
+ outputBuffer[outputBufferPosition]=outputSampleTwo&0XFF; /* Low byte first */
outputBufferPosition++;
- outputBuffer[outputBufferPosition]=outputSampleTwo>>8; //High byte second
+ outputBuffer[outputBufferPosition]=outputSampleTwo>>8; /*High byte second */
outputBufferPosition++;
diff --git a/apps/plugins/minesweeper.c b/apps/plugins/minesweeper.c
index c855f8a99d..23d6e07157 100644
--- a/apps/plugins/minesweeper.c
+++ b/apps/plugins/minesweeper.c
@@ -33,7 +33,7 @@ use F3 to see how many mines are left (supposing all your flags are correct)
PLUGIN_HEADER
-//what the minesweeper() function can return
+/*what the minesweeper() function can return */
#define MINESWEEPER_USB 3
#define MINESWEEPER_QUIT 2
#define MINESWEEPER_LOSE 1
@@ -402,10 +402,10 @@ int minesweeper(void)
while(true){
- //clear the screen buffer
+ /*clear the screen buffer */
rb->lcd_clear_display();
- //display the mine field
+ /*display the mine field */
for(i=0;i<height;i++){
for(j=0;j<width;j++){
#if LCD_DEPTH > 1
diff --git a/apps/plugins/mp3_encoder.c b/apps/plugins/mp3_encoder.c
index f4f6b56f22..e5b7cc8f6e 100644
--- a/apps/plugins/mp3_encoder.c
+++ b/apps/plugins/mp3_encoder.c
@@ -1,15 +1,15 @@
-// Shine is an MP3 encoder
-// Copyright (C) 1999-2000 Gabriel Bouvigne
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Library General Public
-// License as published by the Free Software Foundation; either
-// version 2 of the License, or (at your option) any later version.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Library General Public License for more details.
+/* Shine is an MP3 encoder
+ * Copyright (C) 1999-2000 Gabriel Bouvigne
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details. */
#define samp_per_frame 1152
#define samp_per_frame2 576
@@ -112,55 +112,55 @@ struct huffcodetab {
};
/* !!!!!!!! start of IRAM area: do not insert before x_int1 array !!!!!!!!!!!!! */
-short x_int0 [HAN_SIZE] IBSS_ATTR; // 1024 Bytes
-int mdct_freq [2][2][samp_per_frame2] IBSS_ATTR; // 9216 Bytes
-short x_int1 [HAN_SIZE] IBSS_ATTR; // 1024 Bytes
+short x_int0 [HAN_SIZE] IBSS_ATTR; /* 1024 Bytes */
+int mdct_freq [2][2][samp_per_frame2] IBSS_ATTR; /* 9216 Bytes */
+short x_int1 [HAN_SIZE] IBSS_ATTR; /* 1024 Bytes */
/* !!!!!!!!!!!!!!!!!!!!! here you may insert other data !!!!!!!!!!!!!!!!!!!!!!! */
-uint8 int2idx [4096] IBSS_ATTR; // 4096 Bytes
-enct8 enc_data [2][2][samp_per_frame2] IBSS_ATTR; // 4608 Bytes
-short y_int [64] IBSS_ATTR; // 256 Bytes
-int off [2] IBSS_ATTR; // 16 Bytes
-int scalefac_long[23] IBSS_ATTR; // 96 Bytes
-int mdct_in [36] IBSS_ATTR; // 144 Bytes
-int sb_sample [2][3][18][SBLIMIT] IBSS_ATTR; // 13824 Bytes
-BF_Data CodedData IBSS_ATTR; // 1040 Bytes
-int ca_int [8] IBSS_ATTR; // 32 Bytes
-int cs_int [8] IBSS_ATTR; // 32 Bytes
-int win_int [18][36] IBSS_ATTR; // 2592 Bytes
-short filter_int [SBLIMIT][64] IBSS_ATTR; // 8192 Bytes
-short enwindow_int[512] IBSS_ATTR; // 1024 Bytes
-uint8 ht_count1 [2][2][16] IBSS_ATTR; // 64 Bytes
-uint16 t1HB [ 4] IBSS_ATTR; // Bytes
-uint16 t2HB [ 9] IBSS_ATTR; // Bytes
-uint16 t3HB [ 9] IBSS_ATTR; // Bytes
-uint16 t5HB [ 16] IBSS_ATTR; // Bytes
-uint16 t6HB [ 16] IBSS_ATTR; // Bytes
-uint16 t7HB [ 36] IBSS_ATTR; // Bytes
-uint16 t8HB [ 36] IBSS_ATTR; // Bytes
-uint16 t9HB [ 36] IBSS_ATTR; // Bytes
-uint16 t10HB [ 64] IBSS_ATTR; // Bytes
-uint16 t11HB [ 64] IBSS_ATTR; // Bytes
-uint16 t12HB [ 64] IBSS_ATTR; // Bytes
-uint16 t13HB [256] IBSS_ATTR; // Bytes
-uint16 t15HB [256] IBSS_ATTR; // Bytes
-uint16 t16HB [256] IBSS_ATTR; // Bytes
-uint16 t24HB [256] IBSS_ATTR; // Bytes
-uint8 t1l [ 4] IBSS_ATTR; // Bytes
-uint8 t2l [ 9] IBSS_ATTR; // Bytes
-uint8 t3l [ 9] IBSS_ATTR; // Bytes
-uint8 t5l [ 16] IBSS_ATTR; // Bytes
-uint8 t6l [ 16] IBSS_ATTR; // Bytes
-uint8 t7l [ 36] IBSS_ATTR; // Bytes
-uint8 t8l [ 36] IBSS_ATTR; // Bytes
-uint8 t9l [ 36] IBSS_ATTR; // Bytes
-uint8 t10l [ 64] IBSS_ATTR; // Bytes
-uint8 t11l [ 64] IBSS_ATTR; // Bytes
-uint8 t12l [ 64] IBSS_ATTR; // Bytes
-uint8 t13l [256] IBSS_ATTR; // Bytes
-uint8 t15l [256] IBSS_ATTR; // Bytes
-uint8 t16l [256] IBSS_ATTR; // Bytes
-uint8 t24l [256] IBSS_ATTR; // Bytes
-struct huffcodetab ht [HTN] IBSS_ATTR; // Bytes
+uint8 int2idx [4096] IBSS_ATTR; /* 4096 Bytes */
+enct8 enc_data [2][2][samp_per_frame2] IBSS_ATTR; /* 4608 Bytes */
+short y_int [64] IBSS_ATTR; /* 256 Bytes */
+int off [2] IBSS_ATTR; /* 16 Bytes */
+int scalefac_long[23] IBSS_ATTR; /* 96 Bytes */
+int mdct_in [36] IBSS_ATTR; /* 144 Bytes */
+int sb_sample [2][3][18][SBLIMIT] IBSS_ATTR; /* 13824 Bytes */
+BF_Data CodedData IBSS_ATTR; /* 1040 Bytes */
+int ca_int [8] IBSS_ATTR; /* 32 Bytes */
+int cs_int [8] IBSS_ATTR; /* 32 Bytes */
+int win_int [18][36] IBSS_ATTR; /* 2592 Bytes */
+short filter_int [SBLIMIT][64] IBSS_ATTR; /* 8192 Bytes */
+short enwindow_int[512] IBSS_ATTR; /* 1024 Bytes */
+uint8 ht_count1 [2][2][16] IBSS_ATTR; /* 64 Bytes */
+uint16 t1HB [ 4] IBSS_ATTR; /* Bytes */
+uint16 t2HB [ 9] IBSS_ATTR; /* Bytes */
+uint16 t3HB [ 9] IBSS_ATTR; /* Bytes */
+uint16 t5HB [ 16] IBSS_ATTR; /* Bytes */
+uint16 t6HB [ 16] IBSS_ATTR; /* Bytes */
+uint16 t7HB [ 36] IBSS_ATTR; /* Bytes */
+uint16 t8HB [ 36] IBSS_ATTR; /* Bytes */
+uint16 t9HB [ 36] IBSS_ATTR; /* Bytes */
+uint16 t10HB [ 64] IBSS_ATTR; /* Bytes */
+uint16 t11HB [ 64] IBSS_ATTR; /* Bytes */
+uint16 t12HB [ 64] IBSS_ATTR; /* Bytes */
+uint16 t13HB [256] IBSS_ATTR; /* Bytes */
+uint16 t15HB [256] IBSS_ATTR; /* Bytes */
+uint16 t16HB [256] IBSS_ATTR; /* Bytes */
+uint16 t24HB [256] IBSS_ATTR; /* Bytes */
+uint8 t1l [ 4] IBSS_ATTR; /* Bytes */
+uint8 t2l [ 9] IBSS_ATTR; /* Bytes */
+uint8 t3l [ 9] IBSS_ATTR; /* Bytes */
+uint8 t5l [ 16] IBSS_ATTR; /* Bytes */
+uint8 t6l [ 16] IBSS_ATTR; /* Bytes */
+uint8 t7l [ 36] IBSS_ATTR; /* Bytes */
+uint8 t8l [ 36] IBSS_ATTR; /* Bytes */
+uint8 t9l [ 36] IBSS_ATTR; /* Bytes */
+uint8 t10l [ 64] IBSS_ATTR; /* Bytes */
+uint8 t11l [ 64] IBSS_ATTR; /* Bytes */
+uint8 t12l [ 64] IBSS_ATTR; /* Bytes */
+uint8 t13l [256] IBSS_ATTR; /* Bytes */
+uint8 t15l [256] IBSS_ATTR; /* Bytes */
+uint8 t16l [256] IBSS_ATTR; /* Bytes */
+uint8 t24l [256] IBSS_ATTR; /* Bytes */
+struct huffcodetab ht [HTN] IBSS_ATTR; /* Bytes */
static const uint8 ht_count1_const[2][2][16] =
{ { { 1, 5, 4, 5, 6, 5, 4, 4, 7, 3, 6, 0, 7, 2, 3, 1 }, /* table0 */
@@ -240,7 +240,7 @@ const struct huffcodetab ht_const[HTN] =
{ 2, 2, 0, 0, t1HB, t1l},
{ 3, 3, 0, 0, t2HB, t2l},
{ 3, 3, 0, 0, t3HB, t3l},
-{ 0, 0, 0, 0, NULL, NULL},// Apparently not used
+{ 0, 0, 0, 0, NULL, NULL},/* Apparently not used */
{ 4, 4, 0, 0, t5HB, t5l},
{ 4, 4, 0, 0, t6HB, t6l},
{ 6, 6, 0, 0, t7HB, t7l},
@@ -250,7 +250,7 @@ const struct huffcodetab ht_const[HTN] =
{ 8, 8, 0, 0,t11HB, t11l},
{ 8, 8, 0, 0,t12HB, t12l},
{16,16, 0, 0,t13HB, t13l},
-{ 0, 0, 0, 0, NULL, NULL},// Apparently not used
+{ 0, 0, 0, 0, NULL, NULL},/* Apparently not used */
{16,16, 0, 0,t15HB, t15l},
{16,16, 1, 1,t16HB, t16l},
{16,16, 2, 3,t16HB, t16l},
@@ -1025,7 +1025,7 @@ int count_bit(enct8 ix[samp_per_frame2], unsigned int start, unsigned int end, u
ylen = h->ylen;
if(table > 15)
- { // ESC-table is used
+ { /* ESC-table is used */
linbits = h->linbits;
for(i=start; i<end; i+=2)
{
@@ -1532,7 +1532,7 @@ void filter_subband(short *buffer, int s[SBLIMIT], int k)
#endif
/* 147456=72*2048 */
- for(i=SBLIMIT; i--; ) // SBLIMIT: 32
+ for(i=SBLIMIT; i--; ) /* SBLIMIT: 32 */
{
short *filt = filter_int[i];
@@ -1691,11 +1691,11 @@ void compress(void)
memcpy(ht , ht_const , sizeof(ht ));
/* I don't know, wether this is really necessary */
- ht[ 0].table = NULL; ht[ 0].hlen = NULL;// Apparently not used
+ ht[ 0].table = NULL; ht[ 0].hlen = NULL;/* Apparently not used */
ht[ 1].table = t1HB; ht[ 1].hlen = t1l;
ht[ 2].table = t2HB; ht[ 2].hlen = t2l;
ht[ 3].table = t3HB; ht[ 3].hlen = t3l;
- ht[ 4].table = NULL; ht[ 4].hlen = NULL;// Apparently not used
+ ht[ 4].table = NULL; ht[ 4].hlen = NULL;/* Apparently not used */
ht[ 5].table = t5HB; ht[ 5].hlen = t5l;
ht[ 6].table = t6HB; ht[ 6].hlen = t6l;
ht[ 7].table = t7HB; ht[ 7].hlen = t7l;
@@ -1705,7 +1705,7 @@ void compress(void)
ht[11].table = t11HB; ht[11].hlen = t11l;
ht[12].table = t12HB; ht[12].hlen = t12l;
ht[13].table = t13HB; ht[13].hlen = t13l;
- ht[14].table = NULL; ht[14].hlen = NULL;// Apparently not used
+ ht[14].table = NULL; ht[14].hlen = NULL;/* Apparently not used */
ht[15].table = t15HB; ht[15].hlen = t15l;
ht[16].table = t16HB; ht[16].hlen = t16l;
ht[17].table = t16HB; ht[17].hlen = t16l;
diff --git a/apps/plugins/plasma.c b/apps/plugins/plasma.c
index 934def4434..c6e76a965b 100644
--- a/apps/plugins/plasma.c
+++ b/apps/plugins/plasma.c
@@ -326,7 +326,7 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
{
int ret;
- rb = api; // copy to global api pointer
+ rb = api; /* copy to global api pointer */
(void)parameter;
if (rb->global_settings->backlight_timeout > 0)
rb->backlight_set_timeout(1);/* keep the light on */
diff --git a/apps/plugins/star.c b/apps/plugins/star.c
index 5b100707d0..f5f281bf13 100644
--- a/apps/plugins/star.c
+++ b/apps/plugins/star.c
@@ -448,19 +448,19 @@ static void star_display_text(char *str, bool waitkey)
line[chars_for_line] = '\0';
- // test if we have cutted a word. If it is the case we don't have to
- // skip the space
+ /* test if we have cutted a word. If it is the case we don't have to */
+ /* skip the space */
if (i == chars_by_line && chars_for_line == chars_by_line)
first_char_index += chars_for_line;
else
first_char_index += chars_for_line + 1;
- // print the line on the screen
+ /* print the line on the screen */
rb->lcd_putsxy(0, current_line * char_height, line);
- // if the number of line showed on the screen is equals to the
- // maximum number of line we can show, we wait for a key pressed to
- // clear and show the remaining text.
+ /* if the number of line showed on the screen is equals to the */
+ /* maximum number of line we can show, we wait for a key pressed to */
+ /* clear and show the remaining text. */
current_line++;
if (current_line == lines_by_screen || *ptr_char == '\0')
{
diff --git a/apps/plugins/starfield.c b/apps/plugins/starfield.c
index 032b6acf7c..388d59bb9d 100644
--- a/apps/plugins/starfield.c
+++ b/apps/plugins/starfield.c
@@ -267,7 +267,7 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
{
int ret;
- rb = api; // copy to global api pointer
+ rb = api; /* copy to global api pointer */
(void)parameter;
if (rb->global_settings->backlight_timeout > 0)
rb->backlight_set_timeout(1);/* keep the light on */
@@ -277,4 +277,4 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
return ret;
}
-#endif // #ifdef HAVE_LCD_BITMAP
+#endif /* #ifdef HAVE_LCD_BITMAP */
diff --git a/apps/plugins/sudoku.c b/apps/plugins/sudoku.c
index 4db3fd6950..ece0fbb564 100644
--- a/apps/plugins/sudoku.c
+++ b/apps/plugins/sudoku.c
@@ -240,19 +240,19 @@ typedef unsigned int Bitset;
#define false 0
typedef struct _Sudoku {
- Bitset table[SIZE][SIZE];
+ Bitset table[SIZE][SIZE];
}Sudoku;
typedef struct _Stats {
- int numTries;
- int backTracks;
- int numEmpty;
- bool solutionFound;
+ int numTries;
+ int backTracks;
+ int numEmpty;
+ bool solutionFound;
}Stats;
typedef struct _Options {
- bool allSolutions;
- bool uniquenessCheck;
+ bool allSolutions;
+ bool uniquenessCheck;
}Options;
void sudoku_init(Sudoku* sud);
@@ -268,589 +268,635 @@ int sudoku_get(Sudoku* sud, int x, int y, bool* original);
#define ALL_BITS (BIT(1) | BIT(2) | BIT(3) | BIT(4) | BIT(5) | BIT(6) | BIT(7) | BIT(8) | BIT(9))
/* initialize a sudoku problem, should be called before using set or get */
-void sudoku_init(Sudoku* sud){
- int y, x;
- for (y = 0; y < SIZE; y++){
- for (x = 0; x < SIZE; x++){
- sud->table[x][y] = ALL_BITS;
+void sudoku_init(Sudoku* sud)
+{
+ int y, x;
+ for (y = 0; y < SIZE; y++){
+ for (x = 0; x < SIZE; x++){
+ sud->table[x][y] = ALL_BITS;
+ }
}
- }
}
/* set the number at a particular x and y column */
-void sudoku_set(Sudoku* sud, int x, int y, int num, bool original){
- int i, j;
- int bx, by;
- Bitset orig;
-
- // clear the row and columns
- for (i = 0; i < SIZE; i++){
- BIT_CLEAR(sud->table[i][y], num);
- BIT_CLEAR(sud->table[x][i], num);
- }
- // clear the block
- bx = x - (x % BLOCK);
- by = y - (y % BLOCK);
- for (i = 0; i < BLOCK; i++){
- for (j = 0; j < BLOCK; j++){
- BIT_CLEAR(sud->table[bx+j][by+i], num);
+void sudoku_set(Sudoku* sud, int x, int y, int num, bool original)
+{
+ int i, j;
+ int bx, by;
+ Bitset orig;
+
+ /* clear the row and columns */
+ for (i = 0; i < SIZE; i++){
+ BIT_CLEAR(sud->table[i][y], num);
+ BIT_CLEAR(sud->table[x][i], num);
}
- }
- // mark the table
- orig = original ? ORIGINAL_BIT : 0;
- sud->table[x][y] = BIT(num) | MARK_BIT | orig;
+ /* clear the block */
+ bx = x - (x % BLOCK);
+ by = y - (y % BLOCK);
+ for (i = 0; i < BLOCK; i++){
+ for (j = 0; j < BLOCK; j++){
+ BIT_CLEAR(sud->table[bx+j][by+i], num);
+ }
+ }
+ /* mark the table */
+ orig = original ? ORIGINAL_BIT : 0;
+ sud->table[x][y] = BIT(num) | MARK_BIT | orig;
}
/* get the number at a particular x and y column, if this
is not unique return 0 */
-int sudoku_get(Sudoku* sud, int x, int y, bool* original){
- Bitset val = sud->table[x][y];
- int result = 0;
- int i;
-
- if (original){
- *original = val & ORIGINAL_BIT;
- }
- for (i = 1; i <= SIZE; i++){
- if (BIT_TEST(val, i)){
- if (result != 0){
- return 0;
- }
- result = i;
+int sudoku_get(Sudoku* sud, int x, int y, bool* original)
+{
+ Bitset val = sud->table[x][y];
+ int result = 0;
+ int i;
+
+ if (original) {
+ *original = val & ORIGINAL_BIT;
}
- }
- return result;
+ for (i = 1; i <= SIZE; i++){
+ if (BIT_TEST(val, i)){
+ if (result != 0){
+ return 0;
+ }
+ result = i;
+ }
+ }
+ return result;
}
/* returns true if this is a valid problem, this is necessary because the input
problem might be degenerate which breaks the solver algorithm. */
-static bool is_valid(const Sudoku* sud){
- int x, y;
-
- for (y = 0; y < SIZE; y++){
- for (x = 0; x < SIZE; x++){
- if ((sud->table[x][y] & ALL_BITS) == 0){
- return false;
- }
+static bool is_valid(const Sudoku* sud)
+{
+ int x, y;
+
+ for (y = 0; y < SIZE; y++){
+ for (x = 0; x < SIZE; x++){
+ if ((sud->table[x][y] & ALL_BITS) == 0){
+ return false;
+ }
+ }
}
- }
- return true;
+ return true;
}
-/* scan the table for the most constrained item, giving all it's options,
- sets the best x and y coordinates, the number of options and the options for that coordinate and
- returns true if the puzzle is finished */
-static bool scan(const Sudoku* sud, int* rX, int* rY, int *num, int* options){
- int x, y, i, j;
- int bestCount = SIZE+1;
- Bitset val;
- bool allMarked = true;
-
- for (y = 0; y < SIZE; y++){
- for (x = 0; x < SIZE; x++){
- Bitset val = sud->table[x][y];
- int i;
- int count = 0;
-
- if (val & MARK_BIT){
- // already set
- continue;
- }
- allMarked = false;
- for (i = 1; i <= SIZE; i++){
- if (BIT_TEST(val, i)){
- count++;
- }
- }
- if (count < bestCount){
- bestCount = count;
- *rX = x;
- *rY = y;
- if (count == 0){
- // can't possibly be beaten
- *num = 0;
- return false;
+/* scan the table for the most constrained item, giving all it's options, sets
+ the best x and y coordinates, the number of options and the options for
+ that coordinate and returns true if the puzzle is finished */
+static bool scan(const Sudoku* sud, int* rX, int* rY, int *num, int* options)
+{
+ int x, y, i, j;
+ int bestCount = SIZE+1;
+ Bitset val;
+ bool allMarked = true;
+
+ for (y = 0; y < SIZE; y++){
+ for (x = 0; x < SIZE; x++){
+ Bitset val = sud->table[x][y];
+ int i;
+ int count = 0;
+
+ if (val & MARK_BIT) {
+ /* already set */
+ continue;
+ }
+ allMarked = false;
+ for (i = 1; i <= SIZE; i++){
+ if (BIT_TEST(val, i)){
+ count++;
+ }
+ }
+ if (count < bestCount){
+ bestCount = count;
+ *rX = x;
+ *rY = y;
+ if (count == 0){
+ /* can't possibly be beaten */
+ *num = 0;
+ return false;
+ }
+ }
}
- }
}
- }
- // now copy into options
- *num = bestCount;
- val = sud->table[*rX][*rY];
- for (i = 1, j = 0; i <= SIZE; i++){
- if (BIT_TEST(val, i)){
- options[j++] = i;
+ /* now copy into options */
+ *num = bestCount;
+ val = sud->table[*rX][*rY];
+ for (i = 1, j = 0; i <= SIZE; i++){
+ if (BIT_TEST(val, i)){
+ options[j++] = i;
+ }
}
- }
- return allMarked;
+ return allMarked;
}
static bool solve(Sudoku* sud, Stats* stats, const Options* options);
-/* try a particular option and return true if that gives a solution
- or false if it doesn't, restores board on backtracking */
-static bool spawn_option(Sudoku* sud, Stats* stats, const Options* options, int x, int y, int num){
- Sudoku copy;
-
- rb->memcpy(&copy,sud,sizeof(Sudoku));
- sudoku_set(&copy, x, y, num, false);
- stats->numTries += 1;
- if (solve(&copy, stats, options)){
- if (!options->allSolutions && stats->solutionFound){
- rb->memcpy(sud,&copy,sizeof(Sudoku));
- }
- return true;
- }else{
- stats->backTracks++;
- }
- return false;
-}
+/* try a particular option and return true if that gives a solution or false
+ if it doesn't, restores board on backtracking */
+static bool spawn_option(Sudoku* sud, Stats* stats, const Options* options,
+ int x, int y, int num)
+{
+ Sudoku copy;
-/* solve a sudoku problem, returns true if there is a solution and false otherwise.
- stats is used to track statisticss */
-static bool solve(Sudoku* sud, Stats* stats, const Options* options){
- while (true){
- int x, y, i, num;
- int places[SIZE];
-
- if (scan(sud, &x, &y, &num, places)){
- // a solution was found!
- if (options->uniquenessCheck && stats->solutionFound){
- //printf("\n\t... But the solution is not unique!\n");
- return true;
- }
- stats->solutionFound = true;
- if (options->allSolutions || options->uniquenessCheck){
- //printf("\n\tSolution after %d iterations\n", stats->numTries);
- //sudoku_print(sud);
- return false;
- }else{
+ rb->memcpy(&copy,sud,sizeof(Sudoku));
+ sudoku_set(&copy, x, y, num, false);
+ stats->numTries += 1;
+ if (solve(&copy, stats, options)){
+ if (!options->allSolutions && stats->solutionFound){
+ rb->memcpy(sud,&copy,sizeof(Sudoku));
+ }
return true;
- }
+ }else{
+ stats->backTracks++;
}
- if (num == 0){
- // can't be satisfied
- return false;
- }
- // try all the places (except the last one)
- for (i = 0; i < num-1; i++){
- if (spawn_option(sud, stats, options, x, y, places[i])){
- // solution found!
- if (!options->allSolutions && stats->solutionFound){
- return true;
+ return false;
+}
+
+/* solve a sudoku problem, returns true if there is a solution and false
+ otherwise. stats is used to track statisticss */
+static bool solve(Sudoku* sud, Stats* stats, const Options* options)
+{
+ while (true){
+ int x, y, i, num;
+ int places[SIZE];
+
+ if (scan(sud, &x, &y, &num, places)){
+ /* a solution was found! */
+ if (options->uniquenessCheck && stats->solutionFound){
+ /*printf("\n\t... But the solution is not unique!\n"); */
+ return true;
+ }
+ stats->solutionFound = true;
+ if (options->allSolutions || options->uniquenessCheck){
+ /*printf("\n\tSolution after %d iterations\n", stats->numTries); */
+ /*sudoku_print(sud); */
+ return false;
+ }
+ else{
+ return true;
+ }
}
- }
+ if (num == 0){
+ /* can't be satisfied */
+ return false;
+ }
+ /* try all the places (except the last one) */
+ for (i = 0; i < num-1; i++){
+ if (spawn_option(sud, stats, options, x, y, places[i])){
+ /* solution found! */
+ if (!options->allSolutions && stats->solutionFound){
+ return true;
+ }
+ }
+ }
+ /* take the last place ourself */
+ stats->numTries += 1;
+ sudoku_set(sud, x, y, places[num-1], false);
}
- // take the last place ourself
- stats->numTries += 1;
- sudoku_set(sud, x, y, places[num-1], false);
- }
}
/******** END OF IMPORTED CODE */
/* A wrapper function between the Sudoku plugin and the above solver code */
-void sudoku_solve(struct sudoku_state_t* state) {
- bool ret;
- Stats stats;
- Options options;
- Sudoku sud;
- bool original;
- int r,c;
-
- /* Initialise the parameters */
- sudoku_init(&sud);
- rb->memset(&stats,0,sizeof(stats));
- options.allSolutions=false;
- options.uniquenessCheck=false;
-
- /* Convert Rockbox format into format for solver */
- for (r=0;r<9;r++) {
- for (c=0;c<9;c++) {
- if (state->startboard[r][c]!='0') {
- sudoku_set(&sud, c, r, state->startboard[r][c]-'0', true);
- }
+void sudoku_solve(struct sudoku_state_t* state)
+{
+ bool ret;
+ Stats stats;
+ Options options;
+ Sudoku sud;
+ bool original;
+ int r,c;
+
+ /* Initialise the parameters */
+ sudoku_init(&sud);
+ rb->memset(&stats,0,sizeof(stats));
+ options.allSolutions=false;
+ options.uniquenessCheck=false;
+
+ /* Convert Rockbox format into format for solver */
+ for (r=0;r<9;r++) {
+ for (c=0;c<9;c++) {
+ if (state->startboard[r][c]!='0') {
+ sudoku_set(&sud, c, r, state->startboard[r][c]-'0', true);
+ }
+ }
}
- }
- // need to check for degenerate input problems ...
- if (is_valid(&sud)){
- ret = solve(&sud, &stats, &options);
- } else {
- ret = false;
- }
-
- if (ret) {
- /* Populate the board with the solution. */
- for (r=0;r<9;r++) {
- for (c=0;c<9;c++) {
- state->currentboard[r][c]='0'+sudoku_get(&sud, c, r, &original);
- }
+ /* need to check for degenerate input problems ... */
+ if (is_valid(&sud)){
+ ret = solve(&sud, &stats, &options);
+ } else {
+ ret = false;
+ }
+
+ if (ret) {
+ /* Populate the board with the solution. */
+ for (r=0;r<9;r++) {
+ for (c=0;c<9;c++) {
+ state->currentboard[r][c]='0'+
+ sudoku_get(&sud, c, r, &original);
+ }
+ }
+ } else {
+ rb->splash(HZ*2, true, "Solve failed");
}
- } else {
- rb->splash(HZ*2, true, "Solve failed");
- }
- return;
+ return;
}
void clear_state(struct sudoku_state_t* state)
{
- int r,c;
+ int r,c;
- state->filename[0]=0;
- for (r=0;r<9;r++) {
- for (c=0;c<9;c++) {
- state->startboard[r][c]='0';
- state->currentboard[r][c]='0';
+ state->filename[0]=0;
+ for (r=0;r<9;r++) {
+ for (c=0;c<9;c++) {
+ state->startboard[r][c]='0';
+ state->currentboard[r][c]='0';
#ifdef SUDOKU_BUTTON_POSSIBLE
- state->possiblevals[r][c]=0;
+ state->possiblevals[r][c]=0;
#endif
+ }
}
- }
- state->x=0;
- state->y=0;
- state->editmode=0;
+ state->x=0;
+ state->y=0;
+ state->editmode=0;
}
/* Load game - only ".ss" is officially supported, but any sensible
text representation (one line per row) may load.
*/
-bool load_sudoku(struct sudoku_state_t* state, char* filename) {
- int fd;
- size_t n;
- int r = 0, c = 0;
- unsigned int i;
- int valid=0;
- char buf[300]; /* A buffer to read a sudoku board from */
-
- fd=rb->open(filename, O_RDONLY);
- if (fd < 0) {
- rb->splash(HZ*2, true, "Can not open");
- LOGF("Invalid sudoku file: %s\n",filename);
- return(false);
- }
-
- rb->strncpy(state->filename,filename,MAX_PATH);
- n=rb->read(fd,buf,300);
- if (n <= 0) {
- return(false);
- }
- rb->close(fd);
-
- r=0;
- c=0;
- i=0;
- while ((i < n) && (r < 9)) {
- switch (buf[i]){
- case ' ': case '\t':
- if (c > 0)
- valid=1;
- break;
- case '|':
- case '*':
- case '-':
- case '\r':
- break;
- case '\n':
- if (valid) {
- r++;
- valid=0;
- }
- c = 0;
- break;
- case '_': case '.':
- valid=1;
- if (c >= SIZE || r >= SIZE){
- LOGF("ERROR: sudoku problem is the wrong size (%d,%d)\n", c, r);
+bool load_sudoku(struct sudoku_state_t* state, char* filename)
+{
+ int fd;
+ size_t n;
+ int r = 0, c = 0;
+ unsigned int i;
+ int valid=0;
+ char buf[300]; /* A buffer to read a sudoku board from */
+
+ fd=rb->open(filename, O_RDONLY);
+ if (fd < 0) {
+ rb->splash(HZ*2, true, "Can not open");
+ LOGF("Invalid sudoku file: %s\n",filename);
return(false);
- }
- c++;
- break;
- default:
- if (((buf[i]>='A') && (buf[i]<='I')) || ((buf[i]>='0') && (buf[i]<='9'))) {
- valid=1;
- if (r >= SIZE || c >= SIZE){
- LOGF("ERROR: sudoku problem is the wrong size (%d,%d)\n", c, r);
- return(false);
- }
- if ((buf[i]>='0') && (buf[i]<='9')) {
- state->startboard[r][c]=buf[i];
- state->currentboard[r][c]=buf[i];
- } else {
- state->currentboard[r][c]='1'+(buf[i]-'A');
+ }
+
+ rb->strncpy(state->filename,filename,MAX_PATH);
+ n=rb->read(fd,buf,300);
+ if (n <= 0) {
+ return(false);
+ }
+ rb->close(fd);
+
+ r=0;
+ c=0;
+ i=0;
+ while ((i < n) && (r < 9)) {
+ switch (buf[i]){
+ case ' ': case '\t':
+ if (c > 0)
+ valid=1;
+ break;
+ case '|':
+ case '*':
+ case '-':
+ case '\r':
+ break;
+ case '\n':
+ if (valid) {
+ r++;
+ valid=0;
+ }
+ c = 0;
+ break;
+ case '_': case '.':
+ valid=1;
+ if (c >= SIZE || r >= SIZE){
+ LOGF("ERROR: sudoku problem is the wrong size (%d,%d)\n",
+ c, r);
+ return(false);
+ }
+ c++;
+ break;
+ default:
+ if (((buf[i]>='A') && (buf[i]<='I')) ||
+ ((buf[i]>='0') && (buf[i]<='9'))) {
+ valid=1;
+ if (r >= SIZE || c >= SIZE){
+ LOGF("ERROR: sudoku problem is the wrong size "
+ "(%d,%d)\n", c, r);
+ return(false);
+ }
+ if ((buf[i]>='0') && (buf[i]<='9')) {
+ state->startboard[r][c]=buf[i];
+ state->currentboard[r][c]=buf[i];
+ } else {
+ state->currentboard[r][c]='1'+(buf[i]-'A');
+ }
+ c++;
+ }
+ /* Ignore any other characters */
+ break;
}
- c++;
- }
- /* Ignore any other characters */
- break;
+ i++;
}
- i++;
- }
- /* Save a copy of the saved state - so we can reload without
- using the disk */
- rb->memcpy(state->savedboard,state->currentboard,81);
- return(true);
+ /* Save a copy of the saved state - so we can reload without using the
+ disk */
+ rb->memcpy(state->savedboard,state->currentboard,81);
+ return(true);
}
-bool save_sudoku(struct sudoku_state_t* state) {
- int fd;
- int r,c;
- int i;
- char line[16];
- char sep[16];
+bool save_sudoku(struct sudoku_state_t* state)
+{
+ int fd;
+ int r,c;
+ int i;
+ char line[16];
+ char sep[16];
- rb->memcpy(line,"...|...|...\r\n",13);
- rb->memcpy(sep,"-----------\r\n",13);
+ rb->memcpy(line,"...|...|...\r\n",13);
+ rb->memcpy(sep,"-----------\r\n",13);
- if (state->filename[0]==0) {
- return false;
- }
+ if (state->filename[0]==0) {
+ return false;
+ }
- fd=rb->open(state->filename, O_WRONLY|O_CREAT);
- if (fd >= 0) {
- for (r=0;r<9;r++) {
- i=0;
- for (c=0;c<9;c++) {
- if (state->startboard[r][c]!='0') {
- line[i]=state->startboard[r][c];
- } else if (state->currentboard[r][c]!='0') {
- line[i]='A'+(state->currentboard[r][c]-'1');
- } else {
- line[i]='.';
+ fd=rb->open(state->filename, O_WRONLY|O_CREAT);
+ if (fd >= 0) {
+ for (r=0;r<9;r++) {
+ i=0;
+ for (c=0;c<9;c++) {
+ if (state->startboard[r][c]!='0') {
+ line[i]=state->startboard[r][c];
+ } else if (state->currentboard[r][c]!='0') {
+ line[i]='A'+(state->currentboard[r][c]-'1');
+ } else {
+ line[i]='.';
+ }
+ i++;
+ if ((c==2) || (c==5)) {
+ i++;
+ }
+ }
+ rb->write(fd,line,sizeof(line)-1);
+ if ((r==2) || (r==5)) {
+ rb->write(fd,sep,sizeof(sep)-1);
+ }
}
- i++;
- if ((c==2) || (c==5)) { i++; }
- }
- rb->write(fd,line,sizeof(line)-1);
- if ((r==2) || (r==5)) {
- rb->write(fd,sep,sizeof(sep)-1);
- }
+ /* Add a blank line at end */
+ rb->write(fd,"\r\n",2);
+ rb->close(fd);
+ /* Save a copy of the saved state - so we can reload without
+ using the disk */
+ rb->memcpy(state->savedboard,state->currentboard,81);
+ return true;
+ } else {
+ return false;
}
- /* Add a blank line at end */
- rb->write(fd,"\r\n",2);
- rb->close(fd);
- /* Save a copy of the saved state - so we can reload without
- using the disk */
- rb->memcpy(state->savedboard,state->currentboard,81);
- return true;
- } else {
- return false;
- }
}
void restore_state(struct sudoku_state_t* state)
{
- rb->memcpy(state->currentboard,state->savedboard,81);
+ rb->memcpy(state->currentboard,state->savedboard,81);
}
void clear_board(struct sudoku_state_t* state)
{
- int r,c;
+ int r,c;
- for (r=0;r<9;r++) {
- for (c=0;c<9;c++) {
- state->currentboard[r][c]=state->startboard[r][c];
+ for (r=0;r<9;r++) {
+ for (c=0;c<9;c++) {
+ state->currentboard[r][c]=state->startboard[r][c];
+ }
}
- }
- state->x=0;
- state->y=0;
+ state->x=0;
+ state->y=0;
}
void update_cell(struct sudoku_state_t* state, int r, int c)
{
- /* We have four types of cell:
- 1) User-entered number
- 2) Starting number
- 3) Cursor in cell
- */
-
- if ((r==state->y) && (c==state->x)) {
- rb->lcd_bitmap_part(sudoku_inverse,0,BITMAP_HEIGHT*(state->currentboard[r][c]-'0'),BITMAP_STRIDE,
- XOFS+cellxpos[c],YOFS+cellypos[r],CELL_WIDTH,CELL_HEIGHT);
- } else {
+ /* We have four types of cell:
+ 1) User-entered number
+ 2) Starting number
+ 3) Cursor in cell
+ */
+
+ if ((r==state->y) && (c==state->x)) {
+ rb->lcd_bitmap_part(sudoku_inverse,0,
+ BITMAP_HEIGHT*(state->currentboard[r][c]-'0'),
+ BITMAP_STRIDE,
+ XOFS+cellxpos[c],YOFS+cellypos[r],CELL_WIDTH,
+ CELL_HEIGHT);
+ } else {
if (state->startboard[r][c]!='0') {
- rb->lcd_bitmap_part(sudoku_start,0,BITMAP_HEIGHT*(state->startboard[r][c]-'0'),BITMAP_STRIDE,
- XOFS+cellxpos[c],YOFS+cellypos[r],CELL_WIDTH,CELL_HEIGHT);
+ rb->lcd_bitmap_part(sudoku_start,0,
+ BITMAP_HEIGHT*(state->startboard[r][c]-'0'),
+ BITMAP_STRIDE,
+ XOFS+cellxpos[c],YOFS+cellypos[r],
+ CELL_WIDTH,CELL_HEIGHT);
} else {
- rb->lcd_bitmap_part(sudoku_normal,0,BITMAP_HEIGHT*(state->currentboard[r][c]-'0'),BITMAP_STRIDE,
- XOFS+cellxpos[c],YOFS+cellypos[r],CELL_WIDTH,CELL_HEIGHT);
+ rb->lcd_bitmap_part(sudoku_normal,0,
+ BITMAP_HEIGHT*(state->currentboard[r][c]-'0'),
+ BITMAP_STRIDE,
+ XOFS+cellxpos[c],YOFS+cellypos[r],
+ CELL_WIDTH,CELL_HEIGHT);
}
- }
+ }
- rb->lcd_update_rect(cellxpos[c],cellypos[r],CELL_WIDTH,CELL_HEIGHT);
+ rb->lcd_update_rect(cellxpos[c],cellypos[r],CELL_WIDTH,CELL_HEIGHT);
}
void display_board(struct sudoku_state_t* state)
{
- int r,c;
+ int r,c;
- /* Clear the display buffer */
- rb->lcd_clear_display();
+ /* Clear the display buffer */
+ rb->lcd_clear_display();
- /* Draw the gridlines - differently for different targets */
+ /* Draw the gridlines - differently for different targets */
#if LCD_HEIGHT > 64
- /* Large targets - draw single/double lines */
- for (r=0;r<9;r++) {
- rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[r]-1);
- rb->lcd_vline(XOFS+cellxpos[r]-1,YOFS,YOFS+BOARD_HEIGHT-1);
- if ((r % 3)==0) {
- rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[r]-2);
- rb->lcd_vline(XOFS+cellxpos[r]-2,YOFS,YOFS+BOARD_HEIGHT-1);
+ /* Large targets - draw single/double lines */
+ for (r=0;r<9;r++) {
+ rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[r]-1);
+ rb->lcd_vline(XOFS+cellxpos[r]-1,YOFS,YOFS+BOARD_HEIGHT-1);
+ if ((r % 3)==0) {
+ rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[r]-2);
+ rb->lcd_vline(XOFS+cellxpos[r]-2,YOFS,YOFS+BOARD_HEIGHT-1);
+ }
}
- }
- rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[8]+CELL_HEIGHT);
- rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[8]+CELL_HEIGHT+1);
- rb->lcd_vline(XOFS+cellxpos[8]+CELL_WIDTH,YOFS,YOFS+BOARD_HEIGHT-1);
- rb->lcd_vline(XOFS+cellxpos[8]+CELL_WIDTH+1,YOFS,YOFS+BOARD_HEIGHT-1);
+ rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[8]+CELL_HEIGHT);
+ rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[8]+CELL_HEIGHT+1);
+ rb->lcd_vline(XOFS+cellxpos[8]+CELL_WIDTH,YOFS,YOFS+BOARD_HEIGHT-1);
+ rb->lcd_vline(XOFS+cellxpos[8]+CELL_WIDTH+1,YOFS,YOFS+BOARD_HEIGHT-1);
#elif (LCD_HEIGHT==64)
- /* Small targets - draw dotted/single lines */
- for (r=0;r<9;r++) {
- if ((r % 3)==0) {
- /* Solid Line */
- rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[r]-1);
- rb->lcd_vline(XOFS+cellxpos[r]-1,YOFS,YOFS+BOARD_HEIGHT-1);
- } else {
- /* Dotted line */
- for (c=XOFS;c<XOFS+BOARD_WIDTH;c+=2) {
- rb->lcd_drawpixel(c,YOFS+cellypos[r]-1);
- }
- for (c=YOFS;c<YOFS+BOARD_HEIGHT;c+=2) {
- rb->lcd_drawpixel(XOFS+cellxpos[r]-1,c);
- }
+ /* Small targets - draw dotted/single lines */
+ for (r=0;r<9;r++) {
+ if ((r % 3)==0) {
+ /* Solid Line */
+ rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[r]-1);
+ rb->lcd_vline(XOFS+cellxpos[r]-1,YOFS,YOFS+BOARD_HEIGHT-1);
+ } else {
+ /* Dotted line */
+ for (c=XOFS;c<XOFS+BOARD_WIDTH;c+=2) {
+ rb->lcd_drawpixel(c,YOFS+cellypos[r]-1);
+ }
+ for (c=YOFS;c<YOFS+BOARD_HEIGHT;c+=2) {
+ rb->lcd_drawpixel(XOFS+cellxpos[r]-1,c);
+ }
+ }
}
- }
- rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[8]+CELL_HEIGHT);
- rb->lcd_vline(XOFS+cellxpos[8]+CELL_WIDTH,YOFS,YOFS+BOARD_HEIGHT-1);
+ rb->lcd_hline(XOFS,XOFS+BOARD_WIDTH-1,YOFS+cellypos[8]+CELL_HEIGHT);
+ rb->lcd_vline(XOFS+cellxpos[8]+CELL_WIDTH,YOFS,YOFS+BOARD_HEIGHT-1);
#else
- #error SUDOKU: Unsupported LCD height
+#error SUDOKU: Unsupported LCD height
#endif
#ifdef SUDOKU_BUTTON_POSSIBLE
- rb->lcd_vline(XOFSSCRATCHPAD,YOFS,YOFS+BOARD_HEIGHT-1);
- rb->lcd_vline(XOFSSCRATCHPAD+CELL_WIDTH+1,YOFS,YOFS+BOARD_HEIGHT-1);
- for (r=0;r<9;r++) {
+ rb->lcd_vline(XOFSSCRATCHPAD,YOFS,YOFS+BOARD_HEIGHT-1);
+ rb->lcd_vline(XOFSSCRATCHPAD+CELL_WIDTH+1,YOFS,YOFS+BOARD_HEIGHT-1);
+ for (r=0;r<9;r++) {
#if LCD_HEIGHT > 64
- /* Large targets - draw single/double lines */
- rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
- YOFS+cellypos[r]-1);
- if ((r % 3)==0)
- rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
- YOFS+cellypos[r]-2);
+ /* Large targets - draw single/double lines */
+ rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
+ YOFS+cellypos[r]-1);
+ if ((r % 3)==0)
+ rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
+ YOFS+cellypos[r]-2);
#elif LCD_HEIGHT == 64
- /* Small targets - draw dotted/single lines */
- if ((r % 3)==0) {
- /* Solid Line */
- rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
- YOFS+cellypos[r]-1);
- } else {
- /* Dotted line */
- for (c=XOFSSCRATCHPAD;c<XOFSSCRATCHPAD+CELL_WIDTH+1;c+=2) {
- rb->lcd_drawpixel(c,YOFS+cellypos[r]-1);
- }
- }
+ /* Small targets - draw dotted/single lines */
+ if ((r % 3)==0) {
+ /* Solid Line */
+ rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
+ YOFS+cellypos[r]-1);
+ } else {
+ /* Dotted line */
+ for (c=XOFSSCRATCHPAD;c<XOFSSCRATCHPAD+CELL_WIDTH+1;c+=2) {
+ rb->lcd_drawpixel(c,YOFS+cellypos[r]-1);
+ }
+ }
#endif
- if ((r>0) && state->possiblevals[state->y][state->x]&(1<<(r)))
- rb->lcd_bitmap_part(sudoku_normal,0,BITMAP_HEIGHT*r,BITMAP_STRIDE,
- XOFSSCRATCHPAD+1,YOFS+cellypos[r-1],
- CELL_WIDTH,CELL_HEIGHT);
- }
- rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
- YOFS+cellypos[8]+CELL_HEIGHT);
+ if ((r>0) && state->possiblevals[state->y][state->x]&(1<<(r)))
+ rb->lcd_bitmap_part(sudoku_normal,0,BITMAP_HEIGHT*r,BITMAP_STRIDE,
+ XOFSSCRATCHPAD+1,YOFS+cellypos[r-1],
+ CELL_WIDTH,CELL_HEIGHT);
+ }
+ rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
+ YOFS+cellypos[8]+CELL_HEIGHT);
#if LCD_HEIGHT > 64
- rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
- YOFS+cellypos[8]+CELL_HEIGHT+1);
+ rb->lcd_hline(XOFSSCRATCHPAD,XOFSSCRATCHPAD+CELL_WIDTH+1,
+ YOFS+cellypos[8]+CELL_HEIGHT+1);
#endif
- if (state->possiblevals[state->y][state->x]&(1<<(r)))
- rb->lcd_bitmap_part(sudoku_normal,0,BITMAP_HEIGHT*r,BITMAP_STRIDE,
- XOFSSCRATCHPAD+1,YOFS+cellypos[8],
- CELL_WIDTH,CELL_HEIGHT);
+ if (state->possiblevals[state->y][state->x]&(1<<(r)))
+ rb->lcd_bitmap_part(sudoku_normal,0,BITMAP_HEIGHT*r,BITMAP_STRIDE,
+ XOFSSCRATCHPAD+1,YOFS+cellypos[8],
+ CELL_WIDTH,CELL_HEIGHT);
#endif
- /* Draw the numbers */
- for (r=0;r<9;r++) {
- for (c=0;c<9;c++) {
- /* We have four types of cell:
- 1) User-entered number
- 2) Starting number
- 3) Cursor in cell
- */
-
- if ((r==state->y) && (c==state->x)) {
- rb->lcd_bitmap_part(sudoku_inverse,0,BITMAP_HEIGHT*(state->currentboard[r][c]-'0'),BITMAP_STRIDE,
- XOFS+cellxpos[c],YOFS+cellypos[r],CELL_WIDTH,CELL_HEIGHT);
- } else {
- if (state->startboard[r][c]!='0') {
- rb->lcd_bitmap_part(sudoku_start,0,BITMAP_HEIGHT*(state->startboard[r][c]-'0'),BITMAP_STRIDE,
- XOFS+cellxpos[c],YOFS+cellypos[r],CELL_WIDTH,CELL_HEIGHT);
- } else {
- rb->lcd_bitmap_part(sudoku_normal,0,BITMAP_HEIGHT*(state->currentboard[r][c]-'0'),BITMAP_STRIDE,
- XOFS+cellxpos[c],YOFS+cellypos[r],CELL_WIDTH,CELL_HEIGHT);
+ /* Draw the numbers */
+ for (r=0;r<9;r++) {
+ for (c=0;c<9;c++) {
+ /* We have four types of cell:
+ 1) User-entered number
+ 2) Starting number
+ 3) Cursor in cell
+ */
+
+ if ((r==state->y) && (c==state->x)) {
+ rb->lcd_bitmap_part(sudoku_inverse,0,
+ BITMAP_HEIGHT*(state->currentboard[r][c]-
+ '0'),
+ BITMAP_STRIDE,
+ XOFS+cellxpos[c],YOFS+cellypos[r],
+ CELL_WIDTH,CELL_HEIGHT);
+ } else {
+ if (state->startboard[r][c]!='0') {
+ rb->lcd_bitmap_part(sudoku_start,0,
+ BITMAP_HEIGHT*(state->startboard[r][c]-
+ '0'),
+ BITMAP_STRIDE,
+ XOFS+cellxpos[c],YOFS+cellypos[r],
+ CELL_WIDTH,CELL_HEIGHT);
+ } else {
+ rb->lcd_bitmap_part(sudoku_normal,0,
+ BITMAP_HEIGHT*
+ (state->currentboard[r][c]-'0'),
+ BITMAP_STRIDE,
+ XOFS+cellxpos[c],YOFS+cellypos[r],
+ CELL_WIDTH,CELL_HEIGHT);
+ }
+ }
}
- }
}
- }
- /* update the screen */
- rb->lcd_update();
+ /* update the screen */
+ rb->lcd_update();
}
/* Check the status of the board, assuming a change at the cursor location */
-bool check_status(struct sudoku_state_t* state) {
- int check[9];
- int r,c;
- int r1,c1;
- int cell;
-
- /* First, check the column */
- for (cell=0;cell<9;cell++) { check[cell]=0; }
- for (r=0;r<9;r++) {
- cell=state->currentboard[r][state->x];
- if (cell!='0') {
- if (check[cell-'1']==1) {
- return true;
- }
- check[cell-'1']=1;
+bool check_status(struct sudoku_state_t* state)
+{
+ int check[9];
+ int r,c;
+ int r1,c1;
+ int cell;
+
+ /* First, check the column */
+ for (cell=0;cell<9;cell++) {
+ check[cell]=0;
}
- }
-
- /* Second, check the row */
- for (cell=0;cell<9;cell++) { check[cell]=0; }
- for (c=0;c<9;c++) {
- cell=state->currentboard[state->y][c];
- if (cell!='0') {
- if (check[cell-'1']==1) {
- return true;
- }
- check[cell-'1']=1;
+ for (r=0;r<9;r++) {
+ cell=state->currentboard[r][state->x];
+ if (cell!='0') {
+ if (check[cell-'1']==1) {
+ return true;
+ }
+ check[cell-'1']=1;
+ }
+ }
+
+ /* Second, check the row */
+ for (cell=0;cell<9;cell++) {
+ check[cell]=0;
+ }
+ for (c=0;c<9;c++) {
+ cell=state->currentboard[state->y][c];
+ if (cell!='0') {
+ if (check[cell-'1']==1) {
+ return true;
+ }
+ check[cell-'1']=1;
+ }
}
- }
-
- /* Finally, check the 3x3 sub-grid */
- for (cell=0;cell<9;cell++) { check[cell]=0; }
- r1=(state->y/3)*3;
- c1=(state->x/3)*3;
- for (r=r1;r<r1+3;r++) {
- for (c=c1;c<c1+3;c++) {
- cell=state->currentboard[r][c];
- if (cell!='0') {
- if (check[cell-'1']==1) {
- return true;
+
+ /* Finally, check the 3x3 sub-grid */
+ for (cell=0;cell<9;cell++) {
+ check[cell]=0;
+ }
+ r1=(state->y/3)*3;
+ c1=(state->x/3)*3;
+ for (r=r1;r<r1+3;r++) {
+ for (c=c1;c<c1+3;c++) {
+ cell=state->currentboard[r][c];
+ if (cell!='0') {
+ if (check[cell-'1']==1) {
+ return true;
+ }
+ check[cell-'1']=1;
+ }
}
- check[cell-'1']=1;
- }
}
- }
- /* We passed all the checks :) */
+ /* We passed all the checks :) */
- return false;
+ return false;
}
int sudoku_menu_cb(int key, int m)
@@ -878,242 +924,243 @@ int sudoku_menu_cb(int key, int m)
bool sudoku_menu(struct sudoku_state_t* state)
{
- int m;
- int result;
-
- static const struct menu_item items[] = {
- { "Save", NULL },
- { "Reload", NULL },
- { "Clear", NULL },
- { "Solve", NULL },
- { "New", NULL },
- };
-
- m = rb->menu_init(items, sizeof(items) / sizeof(*items),
- sudoku_menu_cb, NULL, NULL, NULL);
-
- result=rb->menu_show(m);
-
- switch (result) {
- case 0: /* Save state */
- save_sudoku(state);
- break;
+ int m;
+ int result;
+
+ static const struct menu_item items[] = {
+ { "Save", NULL },
+ { "Reload", NULL },
+ { "Clear", NULL },
+ { "Solve", NULL },
+ { "New", NULL },
+ };
+
+ m = rb->menu_init(items, sizeof(items) / sizeof(*items),
+ sudoku_menu_cb, NULL, NULL, NULL);
+
+ result=rb->menu_show(m);
+
+ switch (result) {
+ case 0: /* Save state */
+ save_sudoku(state);
+ break;
- case 1: /* Restore state */
- restore_state(state);
- break;
+ case 1: /* Restore state */
+ restore_state(state);
+ break;
- case 2: /* Clear all */
- clear_board(state);
- break;
+ case 2: /* Clear all */
+ clear_board(state);
+ break;
- case 3: /* Solve */
- sudoku_solve(state);
- break;
+ case 3: /* Solve */
+ sudoku_solve(state);
+ break;
- case 4: /* Create a new game manually */
- clear_state(state);
- state->editmode=1;
- break;
+ case 4: /* Create a new game manually */
+ clear_state(state);
+ state->editmode=1;
+ break;
- default:
- break;
- }
+ default:
+ break;
+ }
- rb->menu_exit(m);
+ rb->menu_exit(m);
- return (result==MENU_ATTACHED_USB);
+ return (result==MENU_ATTACHED_USB);
}
-void move_cursor(struct sudoku_state_t* state, int newx, int newy) {
- int oldx, oldy;
-
- /* Check that the character at the cursor position is legal */
- if (check_status(state)) {
- rb->splash(HZ*2, true, "Illegal move!");
- /* Ignore any button presses during the splash */
- rb->button_clear_queue();
- return;
- }
+void move_cursor(struct sudoku_state_t* state, int newx, int newy)
+{
+ int oldx, oldy;
+
+ /* Check that the character at the cursor position is legal */
+ if (check_status(state)) {
+ rb->splash(HZ*2, true, "Illegal move!");
+ /* Ignore any button presses during the splash */
+ rb->button_clear_queue();
+ return;
+ }
- /* Move Cursor */
- oldx=state->x;
- oldy=state->y;
- state->x=newx;
- state->y=newy;
+ /* Move Cursor */
+ oldx=state->x;
+ oldy=state->y;
+ state->x=newx;
+ state->y=newy;
- /* Redraw current and old cells */
- update_cell(state,oldx,oldy);
- update_cell(state,newx,newy);
+ /* Redraw current and old cells */
+ update_cell(state,oldx,oldy);
+ update_cell(state,newx,newy);
}
/* plugin entry point */
enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
{
- bool exit;
- int button;
- int lastbutton = BUTTON_NONE;
- long ticks;
- struct sudoku_state_t state;
-
- /* plugin init */
- rb = api;
- /* end of plugin init */
-
- clear_state(&state);
-
- if (parameter==NULL) {
- state.editmode=1;
- } else {
- if (!load_sudoku(&state,(char*)parameter)) {
- rb->splash(HZ*2, true, "Load error");
- return(PLUGIN_ERROR);
+ bool exit;
+ int button;
+ int lastbutton = BUTTON_NONE;
+ long ticks;
+ struct sudoku_state_t state;
+
+ /* plugin init */
+ rb = api;
+ /* end of plugin init */
+
+ clear_state(&state);
+
+ if (parameter==NULL) {
+ state.editmode=1;
+ } else {
+ if (!load_sudoku(&state,(char*)parameter)) {
+ rb->splash(HZ*2, true, "Load error");
+ return(PLUGIN_ERROR);
+ }
}
- }
- display_board(&state);
+ display_board(&state);
- /* The main game loop */
- exit=false;
- ticks=0;
- while(!exit) {
- button = rb->button_get(true);
+ /* The main game loop */
+ exit=false;
+ ticks=0;
+ while(!exit) {
+ button = rb->button_get(true);
- switch(button){
- /* Exit game */
- case SUDOKU_BUTTON_QUIT:
- exit=1;
- break;
+ switch(button){
+ /* Exit game */
+ case SUDOKU_BUTTON_QUIT:
+ exit=1;
+ break;
/* Increment digit */
#ifdef SUDOKU_BUTTON_ALTTOGGLE
- case SUDOKU_BUTTON_ALTTOGGLE | BUTTON_REPEAT:
+ case SUDOKU_BUTTON_ALTTOGGLE | BUTTON_REPEAT:
#endif
- case SUDOKU_BUTTON_TOGGLE | BUTTON_REPEAT:
- /* Slow down the repeat speed to 1/3 second */
- if ((*rb->current_tick-ticks) < (HZ/3)) {
- break;
- }
+ case SUDOKU_BUTTON_TOGGLE | BUTTON_REPEAT:
+ /* Slow down the repeat speed to 1/3 second */
+ if ((*rb->current_tick-ticks) < (HZ/3)) {
+ break;
+ }
#ifdef SUDOKU_BUTTON_ALTTOGGLE
- case SUDOKU_BUTTON_ALTTOGGLE:
+ case SUDOKU_BUTTON_ALTTOGGLE:
#endif
- case SUDOKU_BUTTON_TOGGLE:
+ case SUDOKU_BUTTON_TOGGLE:
#ifdef SUDOKU_BUTTON_TOGGLE_PRE
- if ((button == SUDOKU_BUTTON_TOGGLE)
- && (lastbutton != SUDOKU_BUTTON_TOGGLE_PRE))
- break;
+ if ((button == SUDOKU_BUTTON_TOGGLE)
+ && (lastbutton != SUDOKU_BUTTON_TOGGLE_PRE))
+ break;
#endif
- /* Increment digit */
- ticks=*rb->current_tick;
- if (state.editmode) {
- if (state.startboard[state.y][state.x]=='9') {
- state.startboard[state.y][state.x]='0';
- state.currentboard[state.y][state.x]='0';
- } else {
- state.startboard[state.y][state.x]++;
- state.currentboard[state.y][state.x]++;
- }
- } else {
- if (state.startboard[state.y][state.x]=='0') {
- if (state.currentboard[state.y][state.x]=='9') {
- state.currentboard[state.y][state.x]='0';
- } else {
+ /* Increment digit */
+ ticks=*rb->current_tick;
+ if (state.editmode) {
+ if (state.startboard[state.y][state.x]=='9') {
+ state.startboard[state.y][state.x]='0';
+ state.currentboard[state.y][state.x]='0';
+ } else {
+ state.startboard[state.y][state.x]++;
+ state.currentboard[state.y][state.x]++;
+ }
+ } else {
+ if (state.startboard[state.y][state.x]=='0') {
+ if (state.currentboard[state.y][state.x]=='9') {
+ state.currentboard[state.y][state.x]='0';
+ } else {
state.currentboard[state.y][state.x]++;
- }
- }
- }
- update_cell(&state,state.y,state.x);
- break;
-
- /* move cursor left */
- case BUTTON_LEFT:
- case (BUTTON_LEFT | BUTTON_REPEAT):
- if (state.x==0) {
- move_cursor(&state,8,state.y);
- } else {
- move_cursor(&state,state.x-1,state.y);
- }
- break;
-
- /* move cursor right */
- case BUTTON_RIGHT:
- case (BUTTON_RIGHT | BUTTON_REPEAT):
- if (state.x==8) {
- move_cursor(&state,0,state.y);
- } else {
- move_cursor(&state,state.x+1,state.y);
- }
- break;
-
- /* move cursor up */
- case SUDOKU_BUTTON_UP:
- case (SUDOKU_BUTTON_UP | BUTTON_REPEAT):
- if (state.y==0) {
- move_cursor(&state,state.x,8);
- } else {
- move_cursor(&state,state.x,state.y-1);
- }
- break;
-
- /* move cursor down */
- case SUDOKU_BUTTON_DOWN:
- case (SUDOKU_BUTTON_DOWN | BUTTON_REPEAT):
- if (state.y==8) {
- move_cursor(&state,state.x,0);
- } else {
- move_cursor(&state,state.x,state.y+1);
- }
- break;
-
- case SUDOKU_BUTTON_MENU:
+ }
+ }
+ }
+ update_cell(&state,state.y,state.x);
+ break;
+
+ /* move cursor left */
+ case BUTTON_LEFT:
+ case (BUTTON_LEFT | BUTTON_REPEAT):
+ if (state.x==0) {
+ move_cursor(&state,8,state.y);
+ } else {
+ move_cursor(&state,state.x-1,state.y);
+ }
+ break;
+
+ /* move cursor right */
+ case BUTTON_RIGHT:
+ case (BUTTON_RIGHT | BUTTON_REPEAT):
+ if (state.x==8) {
+ move_cursor(&state,0,state.y);
+ } else {
+ move_cursor(&state,state.x+1,state.y);
+ }
+ break;
+
+ /* move cursor up */
+ case SUDOKU_BUTTON_UP:
+ case (SUDOKU_BUTTON_UP | BUTTON_REPEAT):
+ if (state.y==0) {
+ move_cursor(&state,state.x,8);
+ } else {
+ move_cursor(&state,state.x,state.y-1);
+ }
+ break;
+
+ /* move cursor down */
+ case SUDOKU_BUTTON_DOWN:
+ case (SUDOKU_BUTTON_DOWN | BUTTON_REPEAT):
+ if (state.y==8) {
+ move_cursor(&state,state.x,0);
+ } else {
+ move_cursor(&state,state.x,state.y+1);
+ }
+ break;
+
+ case SUDOKU_BUTTON_MENU:
#ifdef SUDOKU_BUTTON_MENU_PRE
- if (lastbutton != SUDOKU_BUTTON_MENU_PRE)
- break;
+ if (lastbutton != SUDOKU_BUTTON_MENU_PRE)
+ break;
#endif
- /* Don't let the user leave a game in a bad state */
- if (check_status(&state)) {
- rb->splash(HZ*2, true, "Illegal move!");
- /* Ignore any button presses during the splash */
- rb->button_clear_queue();
- } else {
- if (state.editmode) {
- rb->kbd_input(state.filename,MAX_PATH);
- if (save_sudoku(&state)) {
- state.editmode=0;
- } else {
- rb->splash(HZ*2, true, "Save failed");
- }
- } else {
- if (sudoku_menu(&state)) {
- return PLUGIN_USB_CONNECTED;
- }
- }
- }
- break;
+ /* Don't let the user leave a game in a bad state */
+ if (check_status(&state)) {
+ rb->splash(HZ*2, true, "Illegal move!");
+ /* Ignore any button presses during the splash */
+ rb->button_clear_queue();
+ } else {
+ if (state.editmode) {
+ rb->kbd_input(state.filename,MAX_PATH);
+ if (save_sudoku(&state)) {
+ state.editmode=0;
+ } else {
+ rb->splash(HZ*2, true, "Save failed");
+ }
+ } else {
+ if (sudoku_menu(&state)) {
+ return PLUGIN_USB_CONNECTED;
+ }
+ }
+ }
+ break;
#ifdef SUDOKU_BUTTON_POSSIBLE
- case SUDOKU_BUTTON_POSSIBLE:
- /* Toggle current number in the possiblevals structure */
- if (state.currentboard[state.y][state.x]!='0') {
- state.possiblevals[state.y][state.x]^=
- (1 << (state.currentboard[state.y][state.x] - '0'));
- }
- break;
+ case SUDOKU_BUTTON_POSSIBLE:
+ /* Toggle current number in the possiblevals structure */
+ if (state.currentboard[state.y][state.x]!='0') {
+ state.possiblevals[state.y][state.x]^=
+ (1 << (state.currentboard[state.y][state.x] - '0'));
+ }
+ break;
#endif
- default:
- if (rb->default_event_handler(button) == SYS_USB_CONNECTED) {
- /* Quit if USB has been connected */
- return PLUGIN_USB_CONNECTED;
+ default:
+ if (rb->default_event_handler(button) == SYS_USB_CONNECTED) {
+ /* Quit if USB has been connected */
+ return PLUGIN_USB_CONNECTED;
+ }
+ break;
}
- break;
- }
- if (button != BUTTON_NONE)
- lastbutton = button;
+ if (button != BUTTON_NONE)
+ lastbutton = button;
- display_board(&state);
- }
+ display_board(&state);
+ }
- return PLUGIN_OK;
+ return PLUGIN_OK;
}
#endif
diff --git a/apps/plugins/video.c b/apps/plugins/video.c
index 53535597c9..e82ec1a84f 100644
--- a/apps/plugins/video.c
+++ b/apps/plugins/video.c
@@ -27,10 +27,10 @@
#include "plugin.h"
#include "sh7034.h"
#include "system.h"
-#include "../apps/recorder/widgets.h" // not in search path, booh
+#include "../apps/recorder/widgets.h" /* not in search path, booh */
-#ifndef SIMULATOR // not for simulator by now
-#ifdef HAVE_LCD_BITMAP // and definitely not for the Player, haha
+#ifndef SIMULATOR /* not for simulator by now */
+#ifdef HAVE_LCD_BITMAP /* and definitely not for the Player, haha */
PLUGIN_HEADER
@@ -52,89 +52,89 @@ PLUGIN_HEADER
#endif
/****************** constants ******************/
-#define SCREENSIZE (LCD_WIDTH*LCD_HEIGHT/8) // in bytes
-#define FPS 68 // default fps for headerless (old video-only) file
-#define MAX_ACC 20 // maximum FF/FR speedup
-#define FF_TICKS 3000; // experimentally found nice
+#define SCREENSIZE (LCD_WIDTH*LCD_HEIGHT/8) /* in bytes */
+#define FPS 68 /* default fps for headerless (old video-only) file */
+#define MAX_ACC 20 /* maximum FF/FR speedup */
+#define FF_TICKS 3000; /* experimentally found nice */
-// trigger levels, we need about 80 kB/sec
-#define SPINUP_INIT 5000 // from what level on to refill, in milliseconds
-#define SPINUP_SAFETY 700 // how much on top of the measured spinup time
-#define CHUNK (1024*32) // read size
+/* trigger levels, we need about 80 kB/sec */
+#define SPINUP_INIT 5000 /* from what level on to refill, in milliseconds */
+#define SPINUP_SAFETY 700 /* how much on top of the measured spinup time */
+#define CHUNK (1024*32) /* read size */
/****************** prototypes ******************/
-void timer4_isr(void); // IMIA4 ISR
-int check_button(void); // determine next relative frame
+void timer4_isr(void); /* IMIA4 ISR */
+int check_button(void); /* determine next relative frame */
/****************** data types ******************/
-// plugins don't introduce headers, so structs are repeated from rvf_format.h
+/* plugins don't introduce headers, so structs are repeated from rvf_format.h */
-#define HEADER_MAGIC 0x52564668 // "RVFh" at file start
-#define AUDIO_MAGIC 0x41756446 // "AudF" for each audio block
-#define FILEVERSION 100 // 1.00
+#define HEADER_MAGIC 0x52564668 /* "RVFh" at file start */
+#define AUDIO_MAGIC 0x41756446 /* "AudF" for each audio block */
+#define FILEVERSION 100 /* 1.00 */
-// format type definitions
+/* format type definitions */
#define VIDEOFORMAT_NO_VIDEO 0
#define VIDEOFORMAT_RAW 1
#define AUDIOFORMAT_NO_AUDIO 0
#define AUDIOFORMAT_MP3 1
#define AUDIOFORMAT_MP3_BITSWAPPED 2
-// bit flags
-#define FLAG_LOOP 0x00000001 // loop the playback, e.g. for stills
+/* bit flags */
+#define FLAG_LOOP 0x00000001 /* loop the playback, e.g. for stills */
-typedef struct // contains whatever might be useful to the player
+typedef struct /* contains whatever might be useful to the player */
{
- // general info (16 entries = 64 byte)
- unsigned long magic; // HEADER_MAGIC
- unsigned long version; // file version
- unsigned long flags; // combination of FLAG_xx
- unsigned long blocksize; // how many bytes per block (=video frame)
- unsigned long bps_average; // bits per second of the whole stream
- unsigned long bps_peak; // max. of above (audio may be VBR)
- unsigned long resume_pos; // file position to resume to
- unsigned long reserved[9]; // reserved, should be zero
-
- // video info (16 entries = 64 byte)
- unsigned long video_format; // one of VIDEOFORMAT_xxx
- unsigned long video_1st_frame; // byte position of first video frame
- unsigned long video_duration; // total length of video part, in ms
- unsigned long video_payload_size; // total amount of video data, in bytes
- unsigned long video_bitrate; // derived from resolution and frame time, in bps
- unsigned long video_frametime; // frame interval in 11.0592 MHz clocks
- long video_preroll; // video is how much ahead, in 11.0592 MHz clocks
- unsigned long video_width; // in pixels
- unsigned long video_height; // in pixels
- unsigned long video_reserved[7]; // reserved, should be zero
-
- // audio info (16 entries = 64 byte)
- unsigned long audio_format; // one of AUDIOFORMAT_xxx
- unsigned long audio_1st_frame; // byte position of first video frame
- unsigned long audio_duration; // total length of audio part, in ms
- unsigned long audio_payload_size; // total amount of audio data, in bytes
- unsigned long audio_avg_bitrate; // average audio bitrate, in bits per second
- unsigned long audio_peak_bitrate; // maximum bitrate
- unsigned long audio_headersize; // offset to payload in audio frames
- long audio_min_associated; // minimum offset to video frame, in bytes
- long audio_max_associated; // maximum offset to video frame, in bytes
- unsigned long audio_reserved[7]; // reserved, should be zero
-
- // more to come... ?
-
- // Note: padding up to 'blocksize' with zero following this header
+ /* general info (16 entries = 64 byte) */
+ unsigned long magic; /* HEADER_MAGIC */
+ unsigned long version; /* file version */
+ unsigned long flags; /* combination of FLAG_xx */
+ unsigned long blocksize; /* how many bytes per block (=video frame) */
+ unsigned long bps_average; /* bits per second of the whole stream */
+ unsigned long bps_peak; /* max. of above (audio may be VBR) */
+ unsigned long resume_pos; /* file position to resume to */
+ unsigned long reserved[9]; /* reserved, should be zero */
+
+ /* video info (16 entries = 64 byte) */
+ unsigned long video_format; /* one of VIDEOFORMAT_xxx */
+ unsigned long video_1st_frame; /* byte position of first video frame */
+ unsigned long video_duration; /* total length of video part, in ms */
+ unsigned long video_payload_size; /* total amount of video data, in bytes */
+ unsigned long video_bitrate; /* derived from resolution and frame time, in bps */
+ unsigned long video_frametime; /* frame interval in 11.0592 MHz clocks */
+ long video_preroll; /* video is how much ahead, in 11.0592 MHz clocks */
+ unsigned long video_width; /* in pixels */
+ unsigned long video_height; /* in pixels */
+ unsigned long video_reserved[7]; /* reserved, should be zero */
+
+ /* audio info (16 entries = 64 byte) */
+ unsigned long audio_format; /* one of AUDIOFORMAT_xxx */
+ unsigned long audio_1st_frame; /* byte position of first video frame */
+ unsigned long audio_duration; /* total length of audio part, in ms */
+ unsigned long audio_payload_size; /* total amount of audio data, in bytes */
+ unsigned long audio_avg_bitrate; /* average audio bitrate, in bits per second */
+ unsigned long audio_peak_bitrate; /* maximum bitrate */
+ unsigned long audio_headersize; /* offset to payload in audio frames */
+ long audio_min_associated; /* minimum offset to video frame, in bytes */
+ long audio_max_associated; /* maximum offset to video frame, in bytes */
+ unsigned long audio_reserved[7]; /* reserved, should be zero */
+
+ /* more to come... ? */
+
+ /* Note: padding up to 'blocksize' with zero following this header */
} tFileHeader;
-typedef struct // the little header for all audio blocks
+typedef struct /* the little header for all audio blocks */
{
- unsigned long magic; // AUDIO_MAGIC indicates an audio block
- unsigned char previous_block; // previous how many blocks backwards
- unsigned char next_block; // next how many blocks forward
- short associated_video; // offset to block with corresponding video
- unsigned short frame_start; // offset to first frame starting in this block
- unsigned short frame_end; // offset to behind last frame ending in this block
+ unsigned long magic; /* AUDIO_MAGIC indicates an audio block */
+ unsigned char previous_block; /* previous how many blocks backwards */
+ unsigned char next_block; /* next how many blocks forward */
+ short associated_video; /* offset to block with corresponding video */
+ unsigned short frame_start; /* offset to first frame starting in this block */
+ unsigned short frame_end; /* offset to behind last frame ending in this block */
} tAudioFrameHeader;
@@ -145,7 +145,7 @@ static struct plugin_api* rb; /* here is a global api struct pointer */
static char gPrint[32]; /* a global printf buffer, saves stack */
-// playstate
+/* playstate */
static struct
{
enum
@@ -157,40 +157,40 @@ static struct
bool bVideoUnderrun;
bool bHasAudio;
bool bHasVideo;
- int nTimeOSD; // OSD should stay for this many frames
- bool bDirtyOSD; // OSD needs redraw
- bool bRefilling; // set if refilling buffer
+ int nTimeOSD; /* OSD should stay for this many frames */
+ bool bDirtyOSD; /* OSD needs redraw */
+ bool bRefilling; /* set if refilling buffer */
bool bSeeking;
- int nSeekAcc; // accelleration value for seek
- int nSeekPos; // current file position for seek
- bool bDiskSleep; // disk is suspended
+ int nSeekAcc; /* accelleration value for seek */
+ int nSeekPos; /* current file position for seek */
+ bool bDiskSleep; /* disk is suspended */
#if FREQ == 12000000 /* Ondio speed kludge */
int nFrameTimeAdjusted;
#endif
} gPlay;
-// buffer information
+/* buffer information */
static struct
{
int bufsize;
- int granularity; // common multiple of block and sector size
- unsigned char* pBufStart; // start of ring buffer
- unsigned char* pBufEnd; // end of ring buffer
- unsigned char* pOSD; // OSD memory (112 bytes for 112*8 pixels)
-
- int vidcount; // how many video blocks are known in a row
- unsigned char* pBufFill; // write pointer for disk, owned by main task
- unsigned char* pReadVideo; // video readout, maintained by timer ISR
- unsigned char* pReadAudio; // audio readout, maintained by demand ISR
- bool bEOF; // flag for end of file
- int low_water; // reload threshold
- int high_water; // end of reload threshold
- int spinup_safety; // safety margin when recalculating low_water
- int nReadChunk; // how much data for normal buffer fill
- int nSeekChunk; // how much data while seeking
+ int granularity; /* common multiple of block and sector size */
+ unsigned char* pBufStart; /* start of ring buffer */
+ unsigned char* pBufEnd; /* end of ring buffer */
+ unsigned char* pOSD; /* OSD memory (112 bytes for 112*8 pixels) */
+
+ int vidcount; /* how many video blocks are known in a row */
+ unsigned char* pBufFill; /* write pointer for disk, owned by main task */
+ unsigned char* pReadVideo; /* video readout, maintained by timer ISR */
+ unsigned char* pReadAudio; /* audio readout, maintained by demand ISR */
+ bool bEOF; /* flag for end of file */
+ int low_water; /* reload threshold */
+ int high_water; /* end of reload threshold */
+ int spinup_safety; /* safety margin when recalculating low_water */
+ int nReadChunk; /* how much data for normal buffer fill */
+ int nSeekChunk; /* how much data while seeking */
} gBuf;
-// statistics
+/* statistics */
static struct
{
int minAudioAvail;
@@ -201,11 +201,11 @@ static struct
long maxSpinup;
} gStats;
-tFileHeader gFileHdr; // file header
+tFileHeader gFileHdr; /* file header */
/****************** implementation ******************/
-// tool function: return how much playable audio/video is left
+/* tool function: return how much playable audio/video is left */
int Available(unsigned char* pSnapshot)
{
if (pSnapshot <= gBuf.pBufFill)
@@ -214,35 +214,35 @@ int Available(unsigned char* pSnapshot)
return gBuf.bufsize - (pSnapshot - gBuf.pBufFill);
}
-// debug function to draw buffer indicators
+/* debug function to draw buffer indicators */
void DrawBuf(void)
{
int fill, video, audio;
- rb->memset(gBuf.pOSD, 0x10, LCD_WIDTH); // draw line
- gBuf.pOSD[0] = gBuf.pOSD[LCD_WIDTH-1] = 0xFE; // ends
+ rb->memset(gBuf.pOSD, 0x10, LCD_WIDTH); /* draw line */
+ gBuf.pOSD[0] = gBuf.pOSD[LCD_WIDTH-1] = 0xFE; /* ends */
- // calculate new tick positions
+ /* calculate new tick positions */
fill = 1 + ((gBuf.pBufFill - gBuf.pBufStart) * (LCD_WIDTH-2)) / gBuf.bufsize;
video = 1 + ((gBuf.pReadVideo - gBuf.pBufStart) * (LCD_WIDTH-2)) / gBuf.bufsize;
audio = 1 + ((gBuf.pReadAudio - gBuf.pBufStart) * (LCD_WIDTH-2)) / gBuf.bufsize;
- gBuf.pOSD[fill] |= 0x20; // below the line, two pixels
- gBuf.pOSD[video] |= 0x08; // one above
- gBuf.pOSD[audio] |= 0x04; // two above
+ gBuf.pOSD[fill] |= 0x20; /* below the line, two pixels */
+ gBuf.pOSD[video] |= 0x08; /* one above */
+ gBuf.pOSD[audio] |= 0x04; /* two above */
- if (gPlay.state == paused) // we have to draw ourselves
+ if (gPlay.state == paused) /* we have to draw ourselves */
rb->lcd_update_rect(0, LCD_HEIGHT-8, LCD_WIDTH, 8);
else
- gPlay.bDirtyOSD = true; // redraw it with next timer IRQ
+ gPlay.bDirtyOSD = true; /* redraw it with next timer IRQ */
}
-// helper function to draw a position indicator
+/* helper function to draw a position indicator */
void DrawPosition(int pos, int total)
{
int w,h;
- int sec; // estimated seconds
+ int sec; /* estimated seconds */
/* print the estimated position */
@@ -258,17 +258,17 @@ void DrawPosition(int pos, int total)
w++;
rb->scrollbar(w, LCD_HEIGHT-7, LCD_WIDTH-w, 7, total, 0, pos, HORIZONTAL);
- if (gPlay.state == paused) // we have to draw ourselves
+ if (gPlay.state == paused) /* we have to draw ourselves */
rb->lcd_update_rect(0, LCD_HEIGHT-8, LCD_WIDTH, 8);
- else // let the display time do it
+ else /* let the display time do it */
{
gPlay.nTimeOSD = 70;
- gPlay.bDirtyOSD = true; // redraw it with next timer IRQ
+ gPlay.bDirtyOSD = true; /* redraw it with next timer IRQ */
}
}
-// helper function to change the volume by a certain amount, +/-
+/* helper function to change the volume by a certain amount, +/- */
void ChangeVolume(int delta)
{
int minvol = rb->sound_min(SOUND_VOLUME);
@@ -283,18 +283,18 @@ void ChangeVolume(int delta)
rb->global_settings->volume = vol;
rb->snprintf(gPrint, sizeof(gPrint), "Vol: %d dB", vol);
rb->lcd_puts(0, 7, gPrint);
- if (gPlay.state == paused) // we have to draw ourselves
+ if (gPlay.state == paused) /* we have to draw ourselves */
rb->lcd_update_rect(0, LCD_HEIGHT-8, LCD_WIDTH, 8);
- else // let the display time do it
+ else /* let the display time do it */
{
- gPlay.nTimeOSD = 50; // display it for 50 frames
- gPlay.bDirtyOSD = true; // let the refresh copy it to LCD
+ gPlay.nTimeOSD = 50; /* display it for 50 frames */
+ gPlay.bDirtyOSD = true; /* let the refresh copy it to LCD */
}
}
}
-// helper function to change the LCD contrast by a certain amount, +/-
+/* helper function to change the LCD contrast by a certain amount, +/- */
void ChangeContrast(int delta)
{
static int mycontrast = -1; /* the "permanent" value while running */
@@ -312,18 +312,18 @@ void ChangeContrast(int delta)
mycontrast = contrast;
rb->snprintf(gPrint, sizeof(gPrint), "Contrast: %d", contrast);
rb->lcd_puts(0, 7, gPrint);
- if (gPlay.state == paused) // we have to draw ourselves
+ if (gPlay.state == paused) /* we have to draw ourselves */
rb->lcd_update_rect(0, LCD_HEIGHT-8, LCD_WIDTH, 8);
- else // let the display time do it
+ else /* let the display time do it */
{
- gPlay.nTimeOSD = 50; // display it for 50 frames
- gPlay.bDirtyOSD = true; // let the refresh copy it to LCD
+ gPlay.nTimeOSD = 50; /* display it for 50 frames */
+ gPlay.bDirtyOSD = true; /* let the refresh copy it to LCD */
}
}
}
-// sync the video to the current audio
+/* sync the video to the current audio */
void SyncVideo(void)
{
tAudioFrameHeader* pAudioBuf;
@@ -331,12 +331,12 @@ void SyncVideo(void)
pAudioBuf = (tAudioFrameHeader*)(gBuf.pReadAudio);
if (pAudioBuf->magic == AUDIO_MAGIC)
{
- gBuf.vidcount = 0; // nothing known
- // sync the video position
+ gBuf.vidcount = 0; /* nothing known */
+ /* sync the video position */
gBuf.pReadVideo = gBuf.pReadAudio +
(long)pAudioBuf->associated_video * (long)gFileHdr.blocksize;
- // handle possible wrap
+ /* handle possible wrap */
if (gBuf.pReadVideo >= gBuf.pBufEnd)
gBuf.pReadVideo -= gBuf.bufsize;
else if (gBuf.pReadVideo < gBuf.pBufStart)
@@ -345,21 +345,21 @@ void SyncVideo(void)
}
-// timer interrupt handler to display a frame
+/* timer interrupt handler to display a frame */
void timer4_isr(void)
{
int available;
tAudioFrameHeader* pAudioBuf;
- int height; // height to display
+ int height; /* height to display */
- // reduce height if we have OSD on
+ /* reduce height if we have OSD on */
height = gFileHdr.video_height/8;
if (gPlay.nTimeOSD > 0)
{
gPlay.nTimeOSD--;
- height = MIN(LCD_HEIGHT/8-1, height); // reserve bottom line
+ height = MIN(LCD_HEIGHT/8-1, height); /* reserve bottom line */
if (gPlay.bDirtyOSD)
- { // OSD to bottom line
+ { /* OSD to bottom line */
rb->lcd_blit(gBuf.pOSD, 0, LCD_HEIGHT/8-1,
LCD_WIDTH, 1, LCD_WIDTH);
gPlay.bDirtyOSD = false;
@@ -371,58 +371,58 @@ void timer4_isr(void)
available = Available(gBuf.pReadVideo);
- // loop to skip audio frame(s)
+ /* loop to skip audio frame(s) */
while(1)
{
- // just for the statistics
+ /* just for the statistics */
if (!gBuf.bEOF && available < gStats.minVideoAvail)
gStats.minVideoAvail = available;
if (available <= (int)gFileHdr.blocksize)
- { // no data for next frame
+ { /* no data for next frame */
if (gBuf.bEOF && (gFileHdr.flags & FLAG_LOOP))
- { // loop now, assuming the looped clip fits in memory
+ { /* loop now, assuming the looped clip fits in memory */
gBuf.pReadVideo = gBuf.pBufStart + gFileHdr.video_1st_frame;
- // FixMe: pReadVideo is incremented below
+ /* FixMe: pReadVideo is incremented below */
}
else
{
gPlay.bVideoUnderrun = true;
- rb->timer_unregister(); // disable ourselves
- return; // no data available
+ rb->timer_unregister(); /* disable ourselves */
+ return; /* no data available */
}
}
- else // normal advance for next time
+ else /* normal advance for next time */
{
gBuf.pReadVideo += gFileHdr.blocksize;
if (gBuf.pReadVideo >= gBuf.pBufEnd)
- gBuf.pReadVideo -= gBuf.bufsize; // wraparound
+ gBuf.pReadVideo -= gBuf.bufsize; /* wraparound */
available -= gFileHdr.blocksize;
}
if (!gPlay.bHasAudio)
- break; // no need to skip any audio
+ break; /* no need to skip any audio */
if (gBuf.vidcount)
{
- // we know the next is a video frame
+ /* we know the next is a video frame */
gBuf.vidcount--;
- break; // exit the loop
+ break; /* exit the loop */
}
pAudioBuf = (tAudioFrameHeader*)(gBuf.pReadVideo);
if (pAudioBuf->magic == AUDIO_MAGIC)
- { // we ran into audio, can happen after seek
+ { /* we ran into audio, can happen after seek */
gBuf.vidcount = pAudioBuf->next_block;
if (gBuf.vidcount)
- gBuf.vidcount--; // minus the audio block
+ gBuf.vidcount--; /* minus the audio block */
}
- } // while
+ } /* while */
}
-// ISR function to get more mp3 data
+/* ISR function to get more mp3 data */
void GetMoreMp3(unsigned char** start, int* size)
{
int available;
@@ -434,19 +434,19 @@ void GetMoreMp3(unsigned char** start, int* size)
available = Available(gBuf.pReadAudio);
- // just for the statistics
+ /* just for the statistics */
if (!gBuf.bEOF && available < gStats.minAudioAvail)
gStats.minAudioAvail = available;
if (available < advance + (int)gFileHdr.blocksize || advance == 0)
{
gPlay.bAudioUnderrun = true;
- return; // no data available
+ return; /* no data available */
}
gBuf.pReadAudio += advance;
if (gBuf.pReadAudio >= gBuf.pBufEnd)
- gBuf.pReadAudio -= gBuf.bufsize; // wraparound
+ gBuf.pReadAudio -= gBuf.bufsize; /* wraparound */
*start = gBuf.pReadAudio + gFileHdr.audio_headersize;
*size = gFileHdr.blocksize - gFileHdr.audio_headersize;
@@ -489,23 +489,23 @@ int SeekTo(int fd, int nPos)
int read_now, got_now;
if (gPlay.bHasAudio)
- rb->mp3_play_stop(); // stop audio ISR
+ rb->mp3_play_stop(); /* stop audio ISR */
if (gPlay.bHasVideo)
- rb->timer_unregister(); // stop the timer
+ rb->timer_unregister(); /* stop the timer */
rb->lseek(fd, nPos, SEEK_SET);
- gBuf.pBufFill = gBuf.pBufStart; // all empty
+ gBuf.pBufFill = gBuf.pBufStart; /* all empty */
gBuf.pReadVideo = gBuf.pReadAudio = gBuf.pBufStart;
- read_now = gBuf.low_water - 1; // less than low water, so loading will continue
- read_now -= read_now % gBuf.granularity; // round down to granularity
+ read_now = gBuf.low_water - 1; /* less than low water, so loading will continue */
+ read_now -= read_now % gBuf.granularity; /* round down to granularity */
got_now = rb->read(fd, gBuf.pBufFill, read_now);
gBuf.bEOF = (read_now != got_now);
gBuf.pBufFill += got_now;
if (nPos == 0)
- { // we seeked to the start
+ { /* we seeked to the start */
if (gPlay.bHasVideo)
gBuf.pReadVideo += gFileHdr.video_1st_frame;
@@ -513,31 +513,31 @@ int SeekTo(int fd, int nPos)
gBuf.pReadAudio += gFileHdr.audio_1st_frame;
}
else
- { // we have to search for the positions
- if (gPlay.bHasAudio) // prepare audio playback, if contained
+ { /* we have to search for the positions */
+ if (gPlay.bHasAudio) /* prepare audio playback, if contained */
{
- // search for audio frame
+ /* search for audio frame */
while (((tAudioFrameHeader*)(gBuf.pReadAudio))->magic != AUDIO_MAGIC)
gBuf.pReadAudio += gFileHdr.blocksize;
if (gPlay.bHasVideo)
- SyncVideo(); // pick the right video for that
+ SyncVideo(); /* pick the right video for that */
}
}
- // synchronous start
+ /* synchronous start */
gPlay.state = playing;
if (gPlay.bHasAudio)
{
gPlay.bAudioUnderrun = false;
rb->mp3_play_data(gBuf.pReadAudio + gFileHdr.audio_headersize,
gFileHdr.blocksize - gFileHdr.audio_headersize, GetMoreMp3);
- rb->mp3_play_pause(true); // kickoff audio
+ rb->mp3_play_pause(true); /* kickoff audio */
}
if (gPlay.bHasVideo)
{
gPlay.bVideoUnderrun = false;
- // start display interrupt
+ /* start display interrupt */
#if FREQ == 12000000 /* Ondio speed kludge */
rb->timer_register(1, NULL, gPlay.nFrameTimeAdjusted, 1, timer4_isr);
#else
@@ -548,25 +548,25 @@ int SeekTo(int fd, int nPos)
return 0;
}
-// called from default_event_handler_ex() or at end of playback
+/* called from default_event_handler_ex() or at end of playback */
void Cleanup(void *fd)
{
- rb->close(*(int*)fd); // close the file
+ rb->close(*(int*)fd); /* close the file */
if (gPlay.bHasVideo)
- rb->timer_unregister(); // stop video ISR, now I can use the display again
+ rb->timer_unregister(); /* stop video ISR, now I can use the display again */
if (gPlay.bHasAudio)
- rb->mp3_play_stop(); // stop audio ISR
+ rb->mp3_play_stop(); /* stop audio ISR */
- // restore normal backlight setting
+ /* restore normal backlight setting */
rb->backlight_set_timeout(rb->global_settings->backlight_timeout);
- // restore normal contrast
+ /* restore normal contrast */
rb->lcd_set_contrast(rb->global_settings->contrast);
}
-// returns >0 if continue, =0 to stop, <0 to abort (USB)
+/* returns >0 if continue, =0 to stop, <0 to abort (USB) */
int PlayTick(int fd)
{
int button;
@@ -575,7 +575,7 @@ int PlayTick(int fd)
int retval = 1;
int filepos;
- // check buffer level
+ /* check buffer level */
if (gPlay.bHasAudio)
avail_audio = Available(gBuf.pReadAudio);
@@ -593,41 +593,41 @@ int PlayTick(int fd)
&& gBuf.bEOF)
{
if (gFileHdr.resume_pos)
- { // we played til the end, clear resume position
+ { /* we played til the end, clear resume position */
gFileHdr.resume_pos = 0;
- rb->lseek(fd, 0, SEEK_SET); // save resume position
+ rb->lseek(fd, 0, SEEK_SET); /* save resume position */
rb->write(fd, &gFileHdr, sizeof(gFileHdr));
}
Cleanup(&fd);
- return 0; // all expired
+ return 0; /* all expired */
}
if (!gPlay.bRefilling || gBuf.bEOF)
- { // nothing to do
+ { /* nothing to do */
button = rb->button_get_w_tmo(HZ/10);
}
else
- { // refill buffer
+ { /* refill buffer */
int read_now, got_now;
int buf_free;
- long spinup; // measure the spinup time
+ long spinup; /* measure the spinup time */
- // how much can we reload, don't fill completely, would appear empty
+ /* how much can we reload, don't fill completely, would appear empty */
buf_free = gBuf.bufsize - MAX(avail_audio, avail_video) - gBuf.high_water;
if (buf_free < 0)
- buf_free = 0; // just for safety
- buf_free -= buf_free % gBuf.granularity; // round down to granularity
+ buf_free = 0; /* just for safety */
+ buf_free -= buf_free % gBuf.granularity; /* round down to granularity */
- // in one piece max. up to buffer end (wrap after that)
+ /* in one piece max. up to buffer end (wrap after that) */
read_now = MIN(buf_free, gBuf.pBufEnd - gBuf.pBufFill);
- // load piecewise, to stay responsive
+ /* load piecewise, to stay responsive */
read_now = MIN(read_now, gBuf.nReadChunk);
if (read_now == buf_free)
- gPlay.bRefilling = false; // last piece requested
+ gPlay.bRefilling = false; /* last piece requested */
- spinup = *rb->current_tick; // in case this is interesting below
+ spinup = *rb->current_tick; /* in case this is interesting below */
got_now = rb->read(fd, gBuf.pBufFill, read_now);
if (got_now != read_now || read_now == 0)
@@ -636,7 +636,7 @@ int PlayTick(int fd)
gPlay.bRefilling = false;
}
- if (gPlay.bDiskSleep) // statistics about the spinup time
+ if (gPlay.bDiskSleep) /* statistics about the spinup time */
{
spinup = *rb->current_tick - spinup;
gPlay.bDiskSleep = false;
@@ -645,49 +645,48 @@ int PlayTick(int fd)
if (spinup < gStats.minSpinup)
gStats.minSpinup = spinup;
- // recalculate the low water mark from real measurements
+ /* recalculate the low water mark from real measurements */
gBuf.low_water = (gStats.maxSpinup + gBuf.spinup_safety)
* gFileHdr.bps_peak / 8 / HZ;
}
if (!gPlay.bRefilling
- && rb->global_settings->disk_spindown < 20) // condition for test only
+ && rb->global_settings->disk_spindown < 20) /* condition for test only */
{
- rb->ata_sleep(); // no point in leaving the disk run til timeout
+ rb->ata_sleep(); /* no point in leaving the disk run til timeout */
gPlay.bDiskSleep = true;
}
gBuf.pBufFill += got_now;
if (gBuf.pBufFill >= gBuf.pBufEnd)
- gBuf.pBufFill = gBuf.pBufStart; // wrap
+ gBuf.pBufFill = gBuf.pBufStart; /* wrap */
- rb->yield(); // have mercy with the other threads
+ rb->yield(); /* have mercy with the other threads */
button = rb->button_get(false);
}
- // check keypresses
+ /* check keypresses */
if (button != BUTTON_NONE)
{
filepos = rb->lseek(fd, 0, SEEK_CUR);
- if (gPlay.bHasVideo) // video position is more accurate
- filepos -= Available(gBuf.pReadVideo); // take video position
+ if (gPlay.bHasVideo) /* video position is more accurate */
+ filepos -= Available(gBuf.pReadVideo); /* take video position */
else
- filepos -= Available(gBuf.pReadAudio); // else audio
+ filepos -= Available(gBuf.pReadAudio); /* else audio */
- switch (button)
- { // set exit conditions
+ switch (button) { /* set exit conditions */
case BUTTON_OFF:
- if (gFileHdr.magic == HEADER_MAGIC // only if file has header
- && !(gFileHdr.flags & FLAG_LOOP)) // not for stills
+ if (gFileHdr.magic == HEADER_MAGIC /* only if file has header */
+ && !(gFileHdr.flags & FLAG_LOOP)) /* not for stills */
{
gFileHdr.resume_pos = filepos;
- rb->lseek(fd, 0, SEEK_SET); // save resume position
+ rb->lseek(fd, 0, SEEK_SET); /* save resume position */
rb->write(fd, &gFileHdr, sizeof(gFileHdr));
}
Cleanup(&fd);
- retval = 0; // signal "stopped" to caller
+ retval = 0; /* signal "stopped" to caller */
break;
case VIDEO_STOP_SEEK:
#ifdef VIDEO_STOP_SEEK_PRE
@@ -704,9 +703,9 @@ int PlayTick(int fd)
{
gPlay.state = paused;
if (gPlay.bHasAudio)
- rb->mp3_play_pause(false); // pause audio
+ rb->mp3_play_pause(false); /* pause audio */
if (gPlay.bHasVideo)
- rb->timer_unregister(); // stop the timer
+ rb->timer_unregister(); /* stop the timer */
}
else if (gPlay.state == paused)
{
@@ -715,10 +714,10 @@ int PlayTick(int fd)
{
if (gPlay.bHasVideo)
SyncVideo();
- rb->mp3_play_pause(true); // play audio
+ rb->mp3_play_pause(true); /* play audio */
}
if (gPlay.bHasVideo)
- { // start the video
+ { /* start the video */
#if FREQ == 12000000 /* Ondio speed kludge */
rb->timer_register(1, NULL,
gPlay.nFrameTimeAdjusted, 1, timer4_isr);
@@ -741,44 +740,44 @@ int PlayTick(int fd)
break;
case BUTTON_LEFT:
case BUTTON_LEFT | BUTTON_REPEAT:
- if (!gPlay.bSeeking) // prepare seek
+ if (!gPlay.bSeeking) /* prepare seek */
{
gPlay.nSeekPos = filepos;
gPlay.bSeeking = true;
gPlay.nSeekAcc = 0;
}
- else if (gPlay.nSeekAcc > 0) // other direction, stop sliding
+ else if (gPlay.nSeekAcc > 0) /* other direction, stop sliding */
gPlay.nSeekAcc = 0;
else
gPlay.nSeekAcc--;
break;
case BUTTON_RIGHT:
case BUTTON_RIGHT | BUTTON_REPEAT:
- if (!gPlay.bSeeking) // prepare seek
+ if (!gPlay.bSeeking) /* prepare seek */
{
gPlay.nSeekPos = filepos;
gPlay.bSeeking = true;
gPlay.nSeekAcc = 0;
}
- else if (gPlay.nSeekAcc < 0) // other direction, stop sliding
+ else if (gPlay.nSeekAcc < 0) /* other direction, stop sliding */
gPlay.nSeekAcc = 0;
else
gPlay.nSeekAcc++;
break;
#ifdef VIDEO_DEBUG
- case VIDEO_DEBUG: // debug key
+ case VIDEO_DEBUG: /* debug key */
case VIDEO_DEBUG | BUTTON_REPEAT:
- DrawBuf(); // show buffer status
+ DrawBuf(); /* show buffer status */
gPlay.nTimeOSD = 30;
gPlay.bDirtyOSD = true;
break;
#endif
- case VIDEO_CONTRAST_DOWN: // contrast down
+ case VIDEO_CONTRAST_DOWN: /* contrast down */
case VIDEO_CONTRAST_DOWN | BUTTON_REPEAT:
if (gPlay.bHasVideo)
ChangeContrast(-1);
break;
- case VIDEO_CONTRAST_UP: // contrast up
+ case VIDEO_CONTRAST_UP: /* contrast up */
case VIDEO_CONTRAST_UP | BUTTON_REPEAT:
if (gPlay.bHasVideo)
ChangeContrast(1);
@@ -786,7 +785,7 @@ int PlayTick(int fd)
default:
if (rb->default_event_handler_ex(button, Cleanup, &fd)
== SYS_USB_CONNECTED)
- retval = -1; // signal "aborted" to caller
+ retval = -1; /* signal "aborted" to caller */
break;
}
@@ -794,9 +793,9 @@ int PlayTick(int fd)
} /* if (button != BUTTON_NONE) */
- // handle seeking
+ /* handle seeking */
- if (gPlay.bSeeking) // seeking?
+ if (gPlay.bSeeking) /* seeking? */
{
if (gPlay.nSeekAcc < -MAX_ACC)
gPlay.nSeekAcc = -MAX_ACC;
@@ -815,23 +814,23 @@ int PlayTick(int fd)
}
- // check + recover underruns
+ /* check + recover underruns */
if ((gPlay.bAudioUnderrun || gPlay.bVideoUnderrun) && !gBuf.bEOF)
{
- gBuf.spinup_safety += HZ/2; // add extra spinup time for the future
+ gBuf.spinup_safety += HZ/2; /* add extra spinup time for the future */
filepos = rb->lseek(fd, 0, SEEK_CUR);
if (gPlay.bHasVideo && gPlay.bVideoUnderrun)
{
gStats.nVideoUnderruns++;
- filepos -= Available(gBuf.pReadVideo); // take video position
+ filepos -= Available(gBuf.pReadVideo); /* take video position */
SeekTo(fd, filepos);
}
else if (gPlay.bHasAudio && gPlay.bAudioUnderrun)
{
gStats.nAudioUnderruns++;
- filepos -= Available(gBuf.pReadAudio); // else audio
+ filepos -= Available(gBuf.pReadAudio); /* else audio */
SeekTo(fd, filepos);
}
}
@@ -848,46 +847,46 @@ int main(char* filename)
int button = 0;
int retval;
- // try to open the file
+ /* try to open the file */
fd = rb->open(filename, O_RDWR);
if (fd < 0)
return PLUGIN_ERROR;
file_size = rb->filesize(fd);
- // reset pitch value to ensure synchronous playback
+ /* reset pitch value to ensure synchronous playback */
rb->sound_set_pitch(1000);
- // init statistics
+ /* init statistics */
rb->memset(&gStats, 0, sizeof(gStats));
gStats.minAudioAvail = gStats.minVideoAvail = INT_MAX;
gStats.minSpinup = INT_MAX;
- // init playback state
+ /* init playback state */
rb->memset(&gPlay, 0, sizeof(gPlay));
- // init buffer
+ /* init buffer */
rb->memset(&gBuf, 0, sizeof(gBuf));
- gBuf.pOSD = rb->lcd_framebuffer + LCD_WIDTH*7; // last screen line
+ gBuf.pOSD = rb->lcd_framebuffer + LCD_WIDTH*7; /* last screen line */
gBuf.pBufStart = rb->plugin_get_audio_buffer(&gBuf.bufsize);
- //gBuf.bufsize = 1700*1024; // test, like 2MB version!!!!
- gBuf.pBufFill = gBuf.pBufStart; // all empty
+ /*gBuf.bufsize = 1700*1024; // test, like 2MB version!!!! */
+ gBuf.pBufFill = gBuf.pBufStart; /* all empty */
- // load file header
+ /* load file header */
read_now = sizeof(gFileHdr);
got_now = rb->read(fd, &gFileHdr, read_now);
- rb->lseek(fd, 0, SEEK_SET); // rewind to restart sector-aligned
+ rb->lseek(fd, 0, SEEK_SET); /* rewind to restart sector-aligned */
if (got_now != read_now)
{
rb->close(fd);
return (PLUGIN_ERROR);
}
- // check header
+ /* check header */
if (gFileHdr.magic != HEADER_MAGIC)
- { // old file, use default info
+ { /* old file, use default info */
rb->memset(&gFileHdr, 0, sizeof(gFileHdr));
gFileHdr.blocksize = SCREENSIZE;
- if (file_size < SCREENSIZE * FPS) // less than a second
+ if (file_size < SCREENSIZE * FPS) /* less than a second */
gFileHdr.flags |= FLAG_LOOP;
gFileHdr.video_format = VIDEOFORMAT_RAW;
gFileHdr.video_width = LCD_WIDTH;
@@ -900,60 +899,60 @@ int main(char* filename)
gPlay.nFrameTimeAdjusted = (gFileHdr.video_frametime * 625) / 576;
#endif
- // continue buffer init: align the end, calc low water, read sizes
+ /* continue buffer init: align the end, calc low water, read sizes */
gBuf.granularity = gFileHdr.blocksize;
- while (gBuf.granularity % 512) // common multiple of sector size
+ while (gBuf.granularity % 512) /* common multiple of sector size */
gBuf.granularity *= 2;
- gBuf.bufsize -= gBuf.bufsize % gBuf.granularity; // round down
+ gBuf.bufsize -= gBuf.bufsize % gBuf.granularity; /* round down */
gBuf.pBufEnd = gBuf.pBufStart + gBuf.bufsize;
gBuf.low_water = SPINUP_INIT * gFileHdr.bps_peak / 8000;
- gBuf.spinup_safety = SPINUP_SAFETY * HZ / 1000; // in time ticks
+ gBuf.spinup_safety = SPINUP_SAFETY * HZ / 1000; /* in time ticks */
if (gFileHdr.audio_min_associated < 0)
gBuf.high_water = 0 - gFileHdr.audio_min_associated;
else
- gBuf.high_water = 1; // never fill buffer completely, would appear empty
- gBuf.nReadChunk = (CHUNK + gBuf.granularity - 1); // round up
- gBuf.nReadChunk -= gBuf.nReadChunk % gBuf.granularity;// and align
+ gBuf.high_water = 1; /* never fill buffer completely, would appear empty */
+ gBuf.nReadChunk = (CHUNK + gBuf.granularity - 1); /* round up */
+ gBuf.nReadChunk -= gBuf.nReadChunk % gBuf.granularity;/* and align */
gBuf.nSeekChunk = rb->filesize(fd) / FF_TICKS;
- gBuf.nSeekChunk += gBuf.granularity - 1; // round up
- gBuf.nSeekChunk -= gBuf.nSeekChunk % gBuf.granularity; // and align
+ gBuf.nSeekChunk += gBuf.granularity - 1; /* round up */
+ gBuf.nSeekChunk -= gBuf.nSeekChunk % gBuf.granularity; /* and align */
- // prepare video playback, if contained
+ /* prepare video playback, if contained */
if (gFileHdr.video_format == VIDEOFORMAT_RAW)
{
gPlay.bHasVideo = true;
if (rb->global_settings->backlight_timeout > 0)
- rb->backlight_set_timeout(1); // keep the light on
+ rb->backlight_set_timeout(1); /* keep the light on */
}
- // prepare audio playback, if contained
+ /* prepare audio playback, if contained */
if (gFileHdr.audio_format == AUDIOFORMAT_MP3_BITSWAPPED)
{
gPlay.bHasAudio = true;
}
- // start playback by seeking to zero or resume position
- if (gFileHdr.resume_pos && WantResume(fd)) // ask the user
+ /* start playback by seeking to zero or resume position */
+ if (gFileHdr.resume_pos && WantResume(fd)) /* ask the user */
SeekTo(fd, gFileHdr.resume_pos);
else
SeekTo(fd, 0);
- // all that's left to do is keep the buffer full
- do // the main loop
+ /* all that's left to do is keep the buffer full */
+ do /* the main loop */
{
retval = PlayTick(fd);
} while (retval > 0);
- if (retval < 0) // aborted?
+ if (retval < 0) /* aborted? */
{
return PLUGIN_USB_CONNECTED;
}
-#ifndef DEBUG // for release compilations, only display the stats in case of error
+#ifndef DEBUG /* for release compilations, only display the stats in case of error */
if (gStats.nAudioUnderruns || gStats.nVideoUnderruns)
#endif
{
- // display statistics
+ /* display statistics */
rb->lcd_clear_display();
rb->snprintf(gPrint, sizeof(gPrint), "%d Audio Underruns", gStats.nAudioUnderruns);
rb->lcd_puts(0, 0, gPrint);
@@ -983,7 +982,7 @@ int main(char* filename)
enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
{
- rb = api; // copy to global api pointer
+ rb = api; /* copy to global api pointer */
if (parameter == NULL)
{
@@ -991,10 +990,10 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
return PLUGIN_ERROR;
}
- // now go ahead and have fun!
+ /* now go ahead and have fun! */
return main((char*) parameter);
}
-#endif // #ifdef HAVE_LCD_BITMAP
-#endif // #ifndef SIMULATOR
+#endif /* #ifdef HAVE_LCD_BITMAP */
+#endif /* #ifndef SIMULATOR */
diff --git a/apps/plugins/wav2wv.c b/apps/plugins/wav2wv.c
index 812ed176c4..7e85572d78 100644
--- a/apps/plugins/wav2wv.c
+++ b/apps/plugins/wav2wv.c
@@ -161,7 +161,7 @@ static int wav2wv (char *filename)
num_chans = config.num_channels = native_header.NumChannels;
total_samples = native_header.data_ckSize / native_header.BlockAlign;
-// config.flags |= CONFIG_HIGH_FLAG;
+/* config.flags |= CONFIG_HIGH_FLAG; */
if (!WavpackSetConfiguration (wpc, &config, total_samples)) {
rb->splash(HZ*2, true, "internal error!");