GD2.h 37 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400
  1. /*
  2. * Copyright (C) 2013-2017 by James Bowman <jamesb@excamera.com>
  3. * Gameduino 2/3 library for Arduino, Arduino Due, Raspberry Pi,
  4. * Teensy 3.2 and ESP8266.
  5. *
  6. */
  7. #ifndef _GD2_H_INCLUDED
  8. #define _GD2_H_INCLUDED
  9. #if defined(RASPBERRY_PI) || defined(DUMPDEV)
  10. #include "wiring.h"
  11. #endif
  12. #include "Arduino.h"
  13. #include <stdarg.h>
  14. #define RGB(r, g, b) ((uint32_t)((((r) & 0xffL) << 16) | (((g) & 0xffL) << 8) | ((b) & 0xffL)))
  15. #define F8(x) (int((x) * 256L))
  16. #define F16(x) ((int32_t)((x) * 65536L))
  17. #define GD_CALIBRATE 1
  18. #define GD_TRIM 2
  19. #define GD_STORAGE 4
  20. #ifdef __SAM3X8E__
  21. #define __DUE__ 1
  22. #endif
  23. ////////////////////////////////////////////////////////////////////////
  24. // Decide if we want to compile in SDcard support
  25. //
  26. // For stock Arduino models: yes
  27. // Raspberry PI: no
  28. // Arduino Due: no
  29. //
  30. #if !defined(RASPBERRY_PI) && !defined(DUMPDEV)
  31. #define SDCARD 1
  32. #else
  33. #define SDCARD 0
  34. #endif
  35. #if defined(__DUE__)
  36. #define MOSI 11
  37. #define MISO 12
  38. #define SCK 13 // B.27
  39. class ASPI_t {
  40. public:
  41. void begin(void) {
  42. pinMode(MOSI, OUTPUT);
  43. pinMode(MISO, INPUT);
  44. pinMode(SCK, OUTPUT);
  45. digitalWrite(SCK, 0);
  46. // PIOB->PIO_PER = PIO_PB27;
  47. // PIOB->PIO_CODR = PIO_PB27;
  48. // PIOB->PIO_PUDR = PIO_PB27;
  49. }
  50. byte transfer(byte x ) {
  51. byte r = 0;
  52. for (byte i = 8; i; i--) {
  53. if (x & 0x80)
  54. PIOD->PIO_SODR = PIO_PD7;
  55. else
  56. PIOD->PIO_CODR = PIO_PD7;
  57. // digitalWrite(MOSI, (x >> 7) & 1);
  58. x <<= 1;
  59. // digitalWrite(SCK, 1);
  60. PIOB->PIO_SODR = PIO_PB27;
  61. r <<= 1;
  62. r |= digitalRead(MISO);
  63. // digitalWrite(SCK, 0);
  64. PIOB->PIO_CODR = PIO_PB27;
  65. }
  66. return r;
  67. }
  68. };
  69. static class ASPI_t ASPI;
  70. #define SPI ASPI
  71. #endif
  72. #if defined(ARDUINO_STM32L4_BLACKICE)
  73. // BlackIce Board uses SPI1 on the Arduino header.
  74. #define SPI SPI1
  75. // Board Support:
  76. // JSON: http://www.hamnavoe.com/package_millerresearch_mystorm_index.json
  77. // Source: https://github.com/millerresearch/arduino-mystorm
  78. #endif
  79. #if SDCARD
  80. #if defined(VERBOSE) && (VERBOSE > 0)
  81. #define INFO(X) Serial.println((X))
  82. #if defined(RASPBERRY_PI)
  83. #define REPORT(VAR) fprintf(stderr, #VAR "=%d\n", (VAR))
  84. #else
  85. #define REPORT(VAR) (Serial.print(#VAR "="), Serial.print(VAR, DEC), Serial.print(' '), Serial.println(VAR, HEX))
  86. #endif
  87. #else
  88. #define INFO(X)
  89. #define REPORT(X)
  90. #endif
  91. struct dirent {
  92. char name[8];
  93. char ext[3];
  94. byte attribute;
  95. byte reserved[8];
  96. uint16_t cluster_hi; // FAT32 only
  97. uint16_t time;
  98. uint16_t date;
  99. uint16_t cluster;
  100. uint32_t size;
  101. };
  102. // https://www.sdcard.org/downloads/pls/simplified_specs/Part_1_Physical_Layer_Simplified_Specification_Ver_3.01_Final_100518.pdf
  103. // page 22
  104. // http://mac6.ma.psu.edu/space2008/RockSat/microController/sdcard_appnote_foust.pdf
  105. // http://elm-chan.org/docs/mmc/mmc_e.html
  106. // http://www.pjrc.com/tech/8051/ide/fat32.html
  107. #define FAT16 0
  108. #define FAT32 1
  109. #define DD
  110. class sdcard {
  111. public:
  112. void sel() {
  113. digitalWrite(pin, LOW);
  114. delay(1);
  115. }
  116. void desel() {
  117. digitalWrite(pin, HIGH);
  118. SPI.transfer(0xff); // force DO release
  119. }
  120. void sd_delay(byte n) {
  121. while (n--) {
  122. DD SPI.transfer(0xff);
  123. }
  124. }
  125. void cmd(byte cmd, uint32_t lba = 0, uint8_t crc = 0x95) {
  126. #if VERBOSE > 1
  127. Serial.print("cmd ");
  128. Serial.print(cmd, DEC);
  129. Serial.print(" ");
  130. Serial.print(lba, HEX);
  131. Serial.println();
  132. #endif
  133. sel();
  134. // DD SPI.transfer(0xff);
  135. DD SPI.transfer(0x40 | cmd);
  136. DD SPI.transfer(0xff & (lba >> 24));
  137. DD SPI.transfer(0xff & (lba >> 16));
  138. DD SPI.transfer(0xff & (lba >> 8));
  139. DD SPI.transfer(0xff & (lba));
  140. DD SPI.transfer(crc);
  141. // DD SPI.transfer(0xff);
  142. }
  143. byte response() {
  144. byte r;
  145. DD
  146. r = SPI.transfer(0xff);
  147. while (r & 0x80) {
  148. DD
  149. r = SPI.transfer(0xff);
  150. }
  151. return r;
  152. }
  153. byte R1() { // read response R1
  154. byte r = response();
  155. desel();
  156. SPI.transfer(0xff); // trailing byte
  157. return r;
  158. }
  159. byte sdR3(uint32_t &ocr) { // read response R3
  160. byte r = response();
  161. for (byte i = 4; i; i--)
  162. ocr = (ocr << 8) | SPI.transfer(0xff);
  163. SPI.transfer(0xff); // trailing byte
  164. desel();
  165. return r;
  166. }
  167. byte sdR7() { // read response R3
  168. byte r = response();
  169. for (byte i = 4; i; i--)
  170. // Serial.println(SPI.transfer(0xff), HEX);
  171. SPI.transfer(0xff);
  172. desel();
  173. return r;
  174. }
  175. void appcmd(byte cc, uint32_t lba = 0) {
  176. cmd(55); R1();
  177. cmd(cc, lba);
  178. }
  179. void begin(byte p) {
  180. byte type_code;
  181. byte sdhc;
  182. pin = p;
  183. pinMode(pin, OUTPUT);
  184. #if !defined(__DUE__) && !defined(TEENSYDUINO) && !defined(ARDUINO_ARCH_STM32L4)
  185. SPI.setClockDivider(SPI_CLOCK_DIV64);
  186. #endif
  187. desel();
  188. // for (;;) SPI.transfer(0xff);
  189. delay(50); // wait for boot
  190. sd_delay(10); // deselected, 80 pulses
  191. INFO("Attempting card reset... ");
  192. byte r1;
  193. static int attempts;
  194. attempts = 0;
  195. do { // reset, enter idle
  196. cmd(0);
  197. while ((r1 = SPI.transfer(0xff)) & 0x80)
  198. if (++attempts == 1000)
  199. goto finished;
  200. desel();
  201. SPI.transfer(0xff); // trailing byte
  202. REPORT(r1);
  203. } while (r1 != 1);
  204. INFO("reset ok\n");
  205. sdhc = 0;
  206. cmd(8, 0x1aa, 0x87);
  207. r1 = sdR7();
  208. sdhc = (r1 == 1);
  209. REPORT(sdhc);
  210. INFO("Sending card init command");
  211. attempts = 0;
  212. while (1) {
  213. appcmd(41, sdhc ? (1UL << 30) : 0); // card init
  214. r1 = R1();
  215. #if VERBOSE
  216. Serial.println(r1, HEX);
  217. #endif
  218. if ((r1 & 1) == 0)
  219. break;
  220. if (++attempts == 300)
  221. goto finished;
  222. delay(1);
  223. }
  224. INFO("OK");
  225. if (sdhc) {
  226. uint32_t OCR = 0;
  227. for (int i = 10; i; i--) {
  228. cmd(58);
  229. sdR3(OCR);
  230. REPORT(OCR);
  231. }
  232. ccs = 1UL & (OCR >> 30);
  233. } else {
  234. ccs = 0;
  235. }
  236. REPORT(ccs);
  237. // Test point: dump sector 0 to serial.
  238. // should see first 512 bytes of card, ending 55 AA.
  239. #if 0
  240. cmd17(0);
  241. for (int i = 0; i < 512; i++) {
  242. delay(10);
  243. byte b = SPI.transfer(0xff);
  244. Serial.print(b, HEX);
  245. Serial.print(' ');
  246. if ((i & 15) == 15)
  247. Serial.println();
  248. }
  249. desel();
  250. for (;;);
  251. #endif
  252. #if !defined(__DUE__) && !defined(ESP8266) && !defined(ARDUINO_ARCH_STM32L4)
  253. SPI.setClockDivider(SPI_CLOCK_DIV2);
  254. SPSR = (1 << SPI2X);
  255. #endif
  256. #if defined(ESP8266)
  257. SPI.setFrequency(40000000L);
  258. #endif
  259. type_code = rd(0x1be + 0x4);
  260. switch (type_code) {
  261. default:
  262. type = FAT16;
  263. break;
  264. case 0x0b:
  265. case 0x0c:
  266. type = FAT32;
  267. break;
  268. }
  269. REPORT(type_code);
  270. o_partition = 512L * rd4(0x1be + 0x8);
  271. sectors_per_cluster = rd(o_partition + 0xd);
  272. reserved_sectors = rd2(o_partition + 0xe);
  273. cluster_size = 512L * sectors_per_cluster;
  274. REPORT(sectors_per_cluster);
  275. // Serial.println("Bytes per sector: %d\n", rd2(o_partition + 0xb));
  276. // Serial.println("Sectors per cluster: %d\n", sectors_per_cluster);
  277. if (type == FAT16) {
  278. max_root_dir_entries = rd2(o_partition + 0x11);
  279. sectors_per_fat = rd2(o_partition + 0x16);
  280. o_fat = o_partition + 512L * reserved_sectors;
  281. o_root = o_fat + (2 * 512L * sectors_per_fat);
  282. // data area starts with cluster 2, so offset it here
  283. o_data = o_root + (max_root_dir_entries * 32L) - (2L * cluster_size);
  284. } else {
  285. uint32_t sectors_per_fat = rd4(o_partition + 0x24);
  286. root_dir_first_cluster = rd4(o_partition + 0x2c);
  287. uint32_t fat_begin_lba = (o_partition >> 9) + reserved_sectors;
  288. uint32_t cluster_begin_lba = (o_partition >> 9) + reserved_sectors + (2 * sectors_per_fat);
  289. o_fat = 512L * fat_begin_lba;
  290. o_root = (512L * (cluster_begin_lba + (root_dir_first_cluster - 2) * sectors_per_cluster));
  291. o_data = (512L * (cluster_begin_lba - 2 * sectors_per_cluster));
  292. }
  293. finished:
  294. INFO("finished");
  295. ;
  296. }
  297. void cmd17(uint32_t off) {
  298. if (ccs)
  299. cmd(17, off >> 9);
  300. else
  301. cmd(17, off & ~511L);
  302. R1();
  303. sel();
  304. while (SPI.transfer(0xff) != 0xfe)
  305. ;
  306. }
  307. void rdn(byte *d, uint32_t off, uint16_t n) {
  308. cmd17(off);
  309. uint16_t i;
  310. uint16_t bo = (off & 511);
  311. for (i = 0; i < bo; i++)
  312. SPI.transfer(0xff);
  313. for (i = 0; i < n; i++)
  314. *d++ = SPI.transfer(0xff);
  315. for (i = 0; i < (514 - bo - n); i++)
  316. SPI.transfer(0xff);
  317. desel();
  318. }
  319. uint32_t rd4(uint32_t off) {
  320. uint32_t r;
  321. rdn((byte*)&r, off, sizeof(r));
  322. return r;
  323. }
  324. uint16_t rd2(uint32_t off) {
  325. uint16_t r;
  326. rdn((byte*)&r, off, sizeof(r));
  327. return r;
  328. }
  329. byte rd(uint32_t off) {
  330. byte r;
  331. rdn((byte*)&r, off, sizeof(r));
  332. return r;
  333. }
  334. byte pin;
  335. byte ccs;
  336. byte type;
  337. uint16_t sectors_per_cluster;
  338. uint16_t reserved_sectors;
  339. uint16_t max_root_dir_entries;
  340. uint16_t sectors_per_fat;
  341. uint16_t cluster_size;
  342. uint32_t root_dir_first_cluster;
  343. // These are all linear addresses, hence the o_ prefix
  344. uint32_t o_partition;
  345. uint32_t o_fat;
  346. uint32_t o_root;
  347. uint32_t o_data;
  348. };
  349. static void dos83(byte dst[11], const char *ps)
  350. {
  351. byte i = 0;
  352. while (*ps) {
  353. if (*ps != '.')
  354. dst[i++] = toupper(*ps);
  355. else {
  356. while (i < 8)
  357. dst[i++] = ' ';
  358. }
  359. ps++;
  360. }
  361. while (i < 11)
  362. dst[i++] = ' ';
  363. }
  364. #else
  365. class sdcard {
  366. public:
  367. void begin(int p) {};
  368. };
  369. #endif
  370. ////////////////////////////////////////////////////////////////////////
  371. class xy {
  372. public:
  373. int x, y;
  374. void set(int _x, int _y);
  375. void rmove(int distance, int angle);
  376. int angleto(class xy &other);
  377. void draw(byte offset = 0);
  378. void rotate(int angle);
  379. int onscreen(void);
  380. class xy operator<<=(int d);
  381. class xy operator+=(class xy &other);
  382. class xy operator-=(class xy &other);
  383. long operator*(class xy &other);
  384. class xy operator*=(int);
  385. int nearer_than(int distance, xy &other);
  386. };
  387. class Bitmap {
  388. public:
  389. xy size, center;
  390. uint32_t source;
  391. uint8_t format;
  392. int8_t handle;
  393. void fromtext(int font, const char* s);
  394. void fromfile(const char *filename, int format = 7);
  395. void bind(uint8_t handle);
  396. void wallpaper();
  397. void draw(int x, int y, int16_t angle = 0);
  398. void draw(const xy &pos, int16_t angle = 0);
  399. private:
  400. void defaults(uint8_t f);
  401. void setup(void);
  402. };
  403. class Bitmap __fromatlas(uint32_t addr);
  404. ////////////////////////////////////////////////////////////////////////
  405. class GDClass {
  406. public:
  407. int w, h;
  408. uint32_t loadptr;
  409. void begin(uint8_t options = (GD_CALIBRATE | GD_TRIM | GD_STORAGE));
  410. uint16_t random();
  411. uint16_t random(uint16_t n);
  412. uint16_t random(uint16_t n0, uint16_t n1);
  413. void seed(uint16_t n);
  414. int16_t rsin(int16_t r, uint16_t th);
  415. int16_t rcos(int16_t r, uint16_t th);
  416. void polar(int &x, int &y, int16_t r, uint16_t th);
  417. uint16_t atan2(int16_t y, int16_t x);
  418. #if !defined(ESP8266)
  419. void copy(const PROGMEM uint8_t *src, int count);
  420. #else
  421. void copy(const uint8_t *src, int count);
  422. #endif
  423. void copyram(byte *src, int count);
  424. void self_calibrate(void);
  425. void swap(void);
  426. void flush(void);
  427. void finish(void);
  428. void play(uint8_t instrument, uint8_t note = 0);
  429. void sample(uint32_t start, uint32_t len, uint16_t freq, uint16_t format, int loop = 0);
  430. void get_inputs(void);
  431. void get_accel(int &x, int &y, int &z);
  432. struct {
  433. uint16_t track_tag;
  434. uint16_t track_val;
  435. uint16_t rz;
  436. uint16_t __dummy_1;
  437. int16_t y;
  438. int16_t x;
  439. int16_t tag_y;
  440. int16_t tag_x;
  441. uint8_t tag;
  442. uint8_t ptag;
  443. uint8_t touching;
  444. xy xytouch;
  445. } inputs;
  446. void AlphaFunc(byte func, byte ref);
  447. void Begin(byte prim);
  448. void BitmapHandle(byte handle);
  449. void BitmapLayout(byte format, uint16_t linestride, uint16_t height);
  450. void BitmapSize(byte filter, byte wrapx, byte wrapy, uint16_t width, uint16_t height);
  451. void BitmapSource(uint32_t addr);
  452. void BitmapTransformA(int32_t a);
  453. void BitmapTransformB(int32_t b);
  454. void BitmapTransformC(int32_t c);
  455. void BitmapTransformD(int32_t d);
  456. void BitmapTransformE(int32_t e);
  457. void BitmapTransformF(int32_t f);
  458. void BlendFunc(byte src, byte dst);
  459. void Call(uint16_t dest);
  460. void Cell(byte cell);
  461. void ClearColorA(byte alpha);
  462. void ClearColorRGB(byte red, byte green, byte blue);
  463. void ClearColorRGB(uint32_t rgb);
  464. void Clear(byte c, byte s, byte t);
  465. void Clear(void);
  466. void ClearStencil(byte s);
  467. void ClearTag(byte s);
  468. void ColorA(byte alpha);
  469. void ColorMask(byte r, byte g, byte b, byte a);
  470. void ColorRGB(byte red, byte green, byte blue);
  471. void ColorRGB(uint32_t rgb);
  472. void Display(void);
  473. void End(void);
  474. void Jump(uint16_t dest);
  475. void LineWidth(uint16_t width);
  476. void Macro(byte m);
  477. void PointSize(uint16_t size);
  478. void RestoreContext(void);
  479. void Return(void);
  480. void SaveContext(void);
  481. void ScissorSize(uint16_t width, uint16_t height);
  482. void ScissorXY(uint16_t x, uint16_t y);
  483. void StencilFunc(byte func, byte ref, byte mask);
  484. void StencilMask(byte mask);
  485. void StencilOp(byte sfail, byte spass);
  486. void TagMask(byte mask);
  487. void Tag(byte s);
  488. void Vertex2f(int16_t x, int16_t y);
  489. void Vertex2ii(uint16_t x, uint16_t y, byte handle = 0, byte cell = 0);
  490. void VertexFormat(byte frac);
  491. void BitmapLayoutH(byte linestride, byte height);
  492. void BitmapSizeH(byte width, byte height);
  493. void PaletteSource(uint32_t addr);
  494. void VertexTranslateX(uint32_t x);
  495. void VertexTranslateY(uint32_t y);
  496. void Nop(void);
  497. // Higher-level graphics commands
  498. void cmd_append(uint32_t ptr, uint32_t num);
  499. void cmd_bgcolor(uint32_t c);
  500. void cmd_button(int16_t x, int16_t y, uint16_t w, uint16_t h, byte font, uint16_t options, const char *s);
  501. void cmd_calibrate(void);
  502. void cmd_clock(int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t h, uint16_t m, uint16_t s, uint16_t ms);
  503. void cmd_coldstart(void);
  504. void cmd_dial(int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t val);
  505. void cmd_dlstart(void);
  506. void cmd_fgcolor(uint32_t c);
  507. void cmd_gauge(int16_t x, int16_t y, int16_t r, uint16_t options, uint16_t major, uint16_t minor, uint16_t val, uint16_t range);
  508. void cmd_getmatrix(void);
  509. void cmd_getprops(uint32_t &ptr, uint32_t &w, uint32_t &h);
  510. void cmd_getptr(void);
  511. void cmd_gradcolor(uint32_t c);
  512. void cmd_gradient(int16_t x0, int16_t y0, uint32_t rgb0, int16_t x1, int16_t y1, uint32_t rgb1);
  513. void cmd_inflate(uint32_t ptr);
  514. void cmd_interrupt(uint32_t ms);
  515. void cmd_keys(int16_t x, int16_t y, int16_t w, int16_t h, byte font, uint16_t options, const char*s);
  516. void cmd_loadidentity(void);
  517. void cmd_loadimage(uint32_t ptr, int32_t options);
  518. void cmd_memcpy(uint32_t dest, uint32_t src, uint32_t num);
  519. void cmd_memset(uint32_t ptr, byte value, uint32_t num);
  520. uint32_t cmd_memcrc(uint32_t ptr, uint32_t num);
  521. void cmd_memwrite(uint32_t ptr, uint32_t num);
  522. void cmd_regwrite(uint32_t ptr, uint32_t val);
  523. void cmd_number(int16_t x, int16_t y, byte font, uint16_t options, uint32_t n);
  524. void cmd_progress(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t options, uint16_t val, uint16_t range);
  525. void cmd_regread(uint32_t ptr);
  526. void cmd_rotate(int32_t a);
  527. void cmd_scale(int32_t sx, int32_t sy);
  528. void cmd_screensaver(void);
  529. void cmd_scrollbar(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t options, uint16_t val, uint16_t size, uint16_t range);
  530. void cmd_setfont(byte font, uint32_t ptr);
  531. void cmd_setmatrix(void);
  532. void cmd_sketch(int16_t x, int16_t y, uint16_t w, uint16_t h, uint32_t ptr, uint16_t format);
  533. void cmd_slider(int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t options, uint16_t val, uint16_t range);
  534. void cmd_snapshot(uint32_t ptr);
  535. void cmd_spinner(int16_t x, int16_t y, byte style, byte scale);
  536. void cmd_stop(void);
  537. void cmd_swap(void);
  538. void cmd_text(int16_t x, int16_t y, byte font, uint16_t options, const char *s);
  539. void cmd_toggle(int16_t x, int16_t y, int16_t w, byte font, uint16_t options, uint16_t state, const char *s);
  540. void cmd_track(int16_t x, int16_t y, uint16_t w, uint16_t h, byte tag);
  541. void cmd_translate(int32_t tx, int32_t ty);
  542. void cmd_playvideo(int32_t options);
  543. void cmd_romfont(uint32_t font, uint32_t romslot);
  544. void cmd_mediafifo(uint32_t ptr, uint32_t size);
  545. void cmd_setbase(uint32_t b);
  546. void cmd_videoframe(uint32_t dst, uint32_t ptr);
  547. void cmd_snapshot2(uint32_t fmt, uint32_t ptr, int16_t x, int16_t y, int16_t w, int16_t h);
  548. void cmd_setfont2(uint32_t font, uint32_t ptr, uint32_t firstchar);
  549. void cmd_setrotate(uint32_t r);
  550. void cmd_videostart();
  551. void cmd_setbitmap(uint32_t source, uint16_t fmt, uint16_t w, uint16_t h);
  552. void cmd_sync();
  553. byte rd(uint32_t addr);
  554. void wr(uint32_t addr, uint8_t v);
  555. uint16_t rd16(uint32_t addr);
  556. void wr16(uint32_t addr, uint16_t v);
  557. uint32_t rd32(uint32_t addr);
  558. void wr32(uint32_t addr, uint32_t v);
  559. void wr_n(uint32_t addr, byte *src, uint32_t n);
  560. void cmd32(uint32_t b);
  561. void bulkrd(uint32_t a);
  562. void resume(void);
  563. void __end(void);
  564. void reset(void);
  565. void dumpscreen(void);
  566. byte load(const char *filename, void (*progress)(long, long) = NULL);
  567. void safeload(const char *filename);
  568. void alert(const char *message);
  569. void textsize(int &w, int &h, int font, const char *s);
  570. sdcard SD;
  571. void storage(void);
  572. void tune(void);
  573. private:
  574. static void cFFFFFF(byte v);
  575. static void cI(uint32_t);
  576. static void ci(int32_t);
  577. static void cH(uint16_t);
  578. static void ch(int16_t);
  579. static void cs(const char *);
  580. static void fmtcmd(const char *fmt, ...);
  581. static void align(byte n);
  582. void cmdbyte(uint8_t b);
  583. uint32_t measure_freq(void);
  584. uint32_t rseed;
  585. };
  586. extern GDClass GD;
  587. extern byte ft8xx_model;
  588. #if SDCARD
  589. class Reader {
  590. public:
  591. int openfile(const char *filename) {
  592. int i = 0;
  593. byte dosname[11];
  594. dirent de;
  595. dos83(dosname, filename);
  596. do {
  597. GD.SD.rdn((byte*)&de, GD.SD.o_root + i * 32, sizeof(de));
  598. // Serial.println(de.name);
  599. if (0 == memcmp(de.name, dosname, 11)) {
  600. begin(de);
  601. return 1;
  602. }
  603. i++;
  604. } while (de.name[0]);
  605. return 0;
  606. }
  607. void begin(dirent &de) {
  608. nseq = 0;
  609. size = de.size;
  610. cluster0 = de.cluster;
  611. if (GD.SD.type == FAT32)
  612. cluster0 |= ((long)de.cluster_hi << 16);
  613. rewind();
  614. }
  615. void rewind(void) {
  616. cluster = cluster0;
  617. sector = 0;
  618. offset = 0;
  619. }
  620. void nextcluster() {
  621. if (GD.SD.type == FAT16)
  622. cluster = GD.SD.rd2(GD.SD.o_fat + 2 * cluster);
  623. else
  624. cluster = GD.SD.rd4(GD.SD.o_fat + 4 * cluster);
  625. #if VERBOSE
  626. Serial.print("nextcluster=");
  627. Serial.println(cluster, DEC);
  628. #endif
  629. }
  630. void fetch512(byte *dst) {
  631. #if defined(__DUE__) || defined(TEENSYDUINO) || defined(ESP8266) || 1
  632. #if defined(ESP8266)
  633. SPI.transferBytes(NULL, dst, 512);
  634. #else
  635. // for (int i = 0; i < 512; i++) *dst++ = SPI.transfer(0xff);
  636. memset(dst, 0xff, 512); SPI.transfer(dst, 512);
  637. #endif
  638. SPI.transfer(0xff); // consume CRC
  639. SPI.transfer(0xff);
  640. #else
  641. SPDR = 0xff;
  642. asm volatile("nop"); while (!(SPSR & _BV(SPIF))) ;
  643. for (int i = 0; i < 512; i++) {
  644. while (!(SPSR & _BV(SPIF))) ;
  645. asm volatile("nop");
  646. asm volatile("nop");
  647. asm volatile("nop");
  648. asm volatile("nop");
  649. asm volatile("nop");
  650. asm volatile("nop");
  651. asm volatile("nop");
  652. asm volatile("nop");
  653. asm volatile("nop");
  654. asm volatile("nop");
  655. asm volatile("nop");
  656. *dst++ = SPDR;
  657. SPDR = 0xff;
  658. }
  659. asm volatile("nop"); while (!(SPSR & _BV(SPIF))) ;
  660. SPI.transfer(0xff);
  661. #endif
  662. GD.SD.desel();
  663. }
  664. void nextcluster2(byte *dst) {
  665. if (nseq) {
  666. nseq--;
  667. cluster++;
  668. return;
  669. }
  670. uint32_t off = GD.SD.o_fat + 4 * cluster;
  671. GD.SD.cmd17(off & ~511L);
  672. fetch512(dst);
  673. int i = off & 511;
  674. cluster = *(uint32_t*)&dst[i];
  675. nseq = 0;
  676. for (uint32_t c = cluster;
  677. (i < 512) && *(uint32_t*)&dst[i] == c;
  678. i += 4, c++)
  679. nseq++;
  680. }
  681. void skipcluster() {
  682. nextcluster();
  683. offset += GD.SD.cluster_size;
  684. }
  685. void skipsector() {
  686. if (sector == GD.SD.sectors_per_cluster) {
  687. sector = 0;
  688. nextcluster();
  689. }
  690. sector++;
  691. offset += 512;
  692. }
  693. void seek(uint32_t o) {
  694. union {
  695. uint8_t buf[512];
  696. uint32_t fat32[128];
  697. uint16_t fat16[256];
  698. };
  699. uint32_t co = ~0;
  700. if (o < offset)
  701. rewind();
  702. while (offset < o) {
  703. if ((sector == GD.SD.sectors_per_cluster) && ((o - offset) > (long)GD.SD.cluster_size)) {
  704. uint32_t o;
  705. if (GD.SD.type == FAT16)
  706. o = (GD.SD.o_fat + 2 * cluster) & ~511;
  707. else
  708. o = (GD.SD.o_fat + 4 * cluster) & ~511;
  709. if (o != co) {
  710. GD.SD.rdn(buf, o, 512);
  711. co = o;
  712. }
  713. cluster = fat32[cluster & 127];
  714. offset += GD.SD.cluster_size;
  715. } else
  716. skipsector();
  717. }
  718. }
  719. void readsector(byte *dst) {
  720. if (sector == GD.SD.sectors_per_cluster) {
  721. sector = 0;
  722. nextcluster2(dst);
  723. }
  724. REPORT(cluster);
  725. uint32_t off = GD.SD.o_data + ((long)GD.SD.cluster_size * cluster) + (512L * sector);
  726. REPORT(off);
  727. GD.SD.cmd17(off & ~511L);
  728. REPORT(off);
  729. sector++;
  730. offset += 512;
  731. fetch512(dst);
  732. }
  733. int eof(void) {
  734. return size <= offset;
  735. }
  736. uint32_t cluster, cluster0;
  737. uint32_t offset;
  738. uint32_t size;
  739. byte sector;
  740. byte nseq;
  741. };
  742. #endif
  743. typedef struct {
  744. byte handle;
  745. uint16_t w, h;
  746. uint16_t size;
  747. } shape_t;
  748. // convert integer pixels to subpixels
  749. #define PIXELS(x) int((x) * 16)
  750. // Convert degrees to Furmans
  751. #define DEGREES(n) ((65536L * (n)) / 360)
  752. #define NEVER 0
  753. #define LESS 1
  754. #define LEQUAL 2
  755. #define GREATER 3
  756. #define GEQUAL 4
  757. #define EQUAL 5
  758. #define NOTEQUAL 6
  759. #define ALWAYS 7
  760. #define ARGB1555 0
  761. #define L1 1
  762. #define L4 2
  763. #define L8 3
  764. #define RGB332 4
  765. #define ARGB2 5
  766. #define ARGB4 6
  767. #define RGB565 7
  768. #define PALETTED 8
  769. #define TEXT8X8 9
  770. #define TEXTVGA 10
  771. #define BARGRAPH 11
  772. #define L2 17
  773. #define NEAREST 0
  774. #define BILINEAR 1
  775. #define BORDER 0
  776. #define REPEAT 1
  777. #define KEEP 1
  778. #define REPLACE 2
  779. #define INCR 3
  780. #define DECR 4
  781. #define INVERT 5
  782. #define DLSWAP_DONE 0
  783. #define DLSWAP_LINE 1
  784. #define DLSWAP_FRAME 2
  785. #define INT_SWAP 1
  786. #define INT_TOUCH 2
  787. #define INT_TAG 4
  788. #define INT_SOUND 8
  789. #define INT_PLAYBACK 16
  790. #define INT_CMDEMPTY 32
  791. #define INT_CMDFLAG 64
  792. #define INT_CONVCOMPLETE 128
  793. #define TOUCHMODE_OFF 0
  794. #define TOUCHMODE_ONESHOT 1
  795. #define TOUCHMODE_FRAME 2
  796. #define TOUCHMODE_CONTINUOUS 3
  797. #define ZERO 0
  798. #define ONE 1
  799. #define SRC_ALPHA 2
  800. #define DST_ALPHA 3
  801. #define ONE_MINUS_SRC_ALPHA 4
  802. #define ONE_MINUS_DST_ALPHA 5
  803. #define BITMAPS 1
  804. #define POINTS 2
  805. #define LINES 3
  806. #define LINE_STRIP 4
  807. #define EDGE_STRIP_R 5
  808. #define EDGE_STRIP_L 6
  809. #define EDGE_STRIP_A 7
  810. #define EDGE_STRIP_B 8
  811. #define RECTS 9
  812. #define OPT_MONO 1
  813. #define OPT_NODL 2
  814. #define OPT_FLAT 256
  815. #define OPT_CENTERX 512
  816. #define OPT_CENTERY 1024
  817. #define OPT_CENTER (OPT_CENTERX | OPT_CENTERY)
  818. #define OPT_NOBACK 4096
  819. #define OPT_NOTICKS 8192
  820. #define OPT_NOHM 16384
  821. #define OPT_NOPOINTER 16384
  822. #define OPT_NOSECS 32768
  823. #define OPT_NOHANDS 49152
  824. #define OPT_RIGHTX 2048
  825. #define OPT_SIGNED 256
  826. #define OPT_SOUND 32
  827. #define OPT_NOTEAR 4
  828. #define OPT_FULLSCREEN 8
  829. #define OPT_MEDIAFIFO 16
  830. #define LINEAR_SAMPLES 0
  831. #define ULAW_SAMPLES 1
  832. #define ADPCM_SAMPLES 2
  833. // 'instrument' argument to GD.play()
  834. #define SILENCE 0x00
  835. #define SQUAREWAVE 0x01
  836. #define SINEWAVE 0x02
  837. #define SAWTOOTH 0x03
  838. #define TRIANGLE 0x04
  839. #define BEEPING 0x05
  840. #define ALARM 0x06
  841. #define WARBLE 0x07
  842. #define CAROUSEL 0x08
  843. #define PIPS(n) (0x0f + (n))
  844. #define HARP 0x40
  845. #define XYLOPHONE 0x41
  846. #define TUBA 0x42
  847. #define GLOCKENSPIEL 0x43
  848. #define ORGAN 0x44
  849. #define TRUMPET 0x45
  850. #define PIANO 0x46
  851. #define CHIMES 0x47
  852. #define MUSICBOX 0x48
  853. #define BELL 0x49
  854. #define CLICK 0x50
  855. #define SWITCH 0x51
  856. #define COWBELL 0x52
  857. #define NOTCH 0x53
  858. #define HIHAT 0x54
  859. #define KICKDRUM 0x55
  860. #define POP 0x56
  861. #define CLACK 0x57
  862. #define CHACK 0x58
  863. #define MUTE 0x60
  864. #define UNMUTE 0x61
  865. #define RAM_PAL 1056768UL
  866. #define RAM_CMD (ft8xx_model ? 0x308000UL : 0x108000UL)
  867. #define RAM_DL (ft8xx_model ? 0x300000UL : 0x100000UL)
  868. #define REG_CLOCK (ft8xx_model ? 0x302008UL : 0x102408UL)
  869. #define REG_CMD_DL (ft8xx_model ? 0x302100UL : 0x1024ecUL)
  870. #define REG_CMD_READ (ft8xx_model ? 0x3020f8UL : 0x1024e4UL)
  871. #define REG_CMD_WRITE (ft8xx_model ? 0x3020fcUL : 0x1024e8UL)
  872. #define REG_CPURESET (ft8xx_model ? 0x302020UL : 0x10241cUL)
  873. #define REG_CSPREAD (ft8xx_model ? 0x302068UL : 0x102464UL)
  874. #define REG_DITHER (ft8xx_model ? 0x302060UL : 0x10245cUL)
  875. #define REG_DLSWAP (ft8xx_model ? 0x302054UL : 0x102450UL)
  876. #define REG_FRAMES (ft8xx_model ? 0x302004UL : 0x102404UL)
  877. #define REG_FREQUENCY (ft8xx_model ? 0x30200cUL : 0x10240cUL)
  878. #define REG_GPIO (ft8xx_model ? 0x302094UL : 0x102490UL)
  879. #define REG_GPIO_DIR (ft8xx_model ? 0x302090UL : 0x10248cUL)
  880. #define REG_HCYCLE (ft8xx_model ? 0x30202cUL : 0x102428UL)
  881. #define REG_HOFFSET (ft8xx_model ? 0x302030UL : 0x10242cUL)
  882. #define REG_HSIZE (ft8xx_model ? 0x302034UL : 0x102430UL)
  883. #define REG_HSYNC0 (ft8xx_model ? 0x302038UL : 0x102434UL)
  884. #define REG_HSYNC1 (ft8xx_model ? 0x30203cUL : 0x102438UL)
  885. #define REG_ID (ft8xx_model ? 0x302000UL : 0x102400UL)
  886. #define REG_INT_EN (ft8xx_model ? 0x3020acUL : 0x10249cUL)
  887. #define REG_INT_FLAGS (ft8xx_model ? 0x3020a8UL : 0x102498UL)
  888. #define REG_INT_MASK (ft8xx_model ? 0x3020b0UL : 0x1024a0UL)
  889. #define REG_MACRO_0 (ft8xx_model ? 0x3020d8UL : 0x1024c8UL)
  890. #define REG_MACRO_1 (ft8xx_model ? 0x3020dcUL : 0x1024ccUL)
  891. #define REG_OUTBITS (ft8xx_model ? 0x30205cUL : 0x102458UL)
  892. #define REG_PCLK (ft8xx_model ? 0x302070UL : 0x10246cUL)
  893. #define REG_PCLK_POL (ft8xx_model ? 0x30206cUL : 0x102468UL)
  894. #define REG_PLAY (ft8xx_model ? 0x30208cUL : 0x102488UL)
  895. #define REG_PLAYBACK_FORMAT (ft8xx_model ? 0x3020c4UL : 0x1024b4UL)
  896. #define REG_PLAYBACK_FREQ (ft8xx_model ? 0x3020c0UL : 0x1024b0UL)
  897. #define REG_PLAYBACK_LENGTH (ft8xx_model ? 0x3020b8UL : 0x1024a8UL)
  898. #define REG_PLAYBACK_LOOP (ft8xx_model ? 0x3020c8UL : 0x1024b8UL)
  899. #define REG_PLAYBACK_PLAY (ft8xx_model ? 0x3020ccUL : 0x1024bcUL)
  900. #define REG_PLAYBACK_READPTR (ft8xx_model ? 0x3020bcUL : 0x1024acUL)
  901. #define REG_PLAYBACK_START (ft8xx_model ? 0x3020b4UL : 0x1024a4UL)
  902. #define REG_PWM_DUTY (ft8xx_model ? 0x3020d4UL : 0x1024c4UL)
  903. #define REG_PWM_HZ (ft8xx_model ? 0x3020d0UL : 0x1024c0UL)
  904. #define REG_ROTATE (ft8xx_model ? 0x302058UL : 0x102454UL)
  905. #define REG_SOUND (ft8xx_model ? 0x302088UL : 0x102484UL)
  906. #define REG_SWIZZLE (ft8xx_model ? 0x302064UL : 0x102460UL)
  907. #define REG_TAG (ft8xx_model ? 0x30207cUL : 0x102478UL)
  908. #define REG_TAG_X (ft8xx_model ? 0x302074UL : 0x102470UL)
  909. #define REG_TAG_Y (ft8xx_model ? 0x302078UL : 0x102474UL)
  910. #define REG_TOUCH_ADC_MODE (ft8xx_model ? 0x302108UL : 0x1024f4UL)
  911. #define REG_TOUCH_CHARGE (ft8xx_model ? 0x30210cUL : 0x1024f8UL)
  912. #define REG_TOUCH_DIRECT_XY (ft8xx_model ? 0x30218cUL : 0x102574UL)
  913. #define REG_TOUCH_DIRECT_Z1Z2 (ft8xx_model ? 0x302190UL : 0x102578UL)
  914. #define REG_TOUCH_MODE (ft8xx_model ? 0x302104UL : 0x1024f0UL)
  915. #define REG_TOUCH_OVERSAMPLE (ft8xx_model ? 0x302114UL : 0x102500UL)
  916. #define REG_TOUCH_RAW_XY (ft8xx_model ? 0x30211cUL : 0x102508UL)
  917. #define REG_TOUCH_RZ (ft8xx_model ? 0x302120UL : 0x10250cUL)
  918. #define REG_TOUCH_RZTHRESH (ft8xx_model ? 0x302118UL : 0x102504UL)
  919. #define REG_TOUCH_SCREEN_XY (ft8xx_model ? 0x302124UL : 0x102510UL)
  920. #define REG_TOUCH_SETTLE (ft8xx_model ? 0x302110UL : 0x1024fcUL)
  921. #define REG_TOUCH_TAG (ft8xx_model ? 0x30212cUL : 0x102518UL)
  922. #define REG_TOUCH_TAG_XY (ft8xx_model ? 0x302128UL : 0x102514UL)
  923. #define REG_TOUCH_TRANSFORM_A (ft8xx_model ? 0x302150UL : 0x10251cUL)
  924. #define REG_TOUCH_TRANSFORM_B (ft8xx_model ? 0x302154UL : 0x102520UL)
  925. #define REG_TOUCH_TRANSFORM_C (ft8xx_model ? 0x302158UL : 0x102524UL)
  926. #define REG_TOUCH_TRANSFORM_D (ft8xx_model ? 0x30215cUL : 0x102528UL)
  927. #define REG_TOUCH_TRANSFORM_E (ft8xx_model ? 0x302160UL : 0x10252cUL)
  928. #define REG_TOUCH_TRANSFORM_F (ft8xx_model ? 0x302164UL : 0x102530UL)
  929. #define REG_TRACKER (ft8xx_model ? 0x309000UL : 0x109000UL)
  930. #define REG_TRIM (ft8xx_model ? 0x302180UL : 0x10256cUL)
  931. #define REG_VCYCLE (ft8xx_model ? 0x302040UL : 0x10243cUL)
  932. #define REG_VOFFSET (ft8xx_model ? 0x302044UL : 0x102440UL)
  933. #define REG_VOL_PB (ft8xx_model ? 0x302080UL : 0x10247cUL)
  934. #define REG_VOL_SOUND (ft8xx_model ? 0x302084UL : 0x102480UL)
  935. #define REG_VSIZE (ft8xx_model ? 0x302048UL : 0x102444UL)
  936. #define REG_VSYNC0 (ft8xx_model ? 0x30204cUL : 0x102448UL)
  937. #define REG_VSYNC1 (ft8xx_model ? 0x302050UL : 0x10244cUL)
  938. #define FONT_ROOT (ft8xx_model ? 0x2ffffcUL : 0x0ffffcUL)
  939. #define REG_MEDIAFIFO_READ 0x309014
  940. #define REG_MEDIAFIFO_WRITE 0x309018
  941. #define VERTEX2II(x, y, handle, cell) \
  942. ((2UL << 30) | (((x) & 511UL) << 21) | (((y) & 511UL) << 12) | (((handle) & 31) << 7) | (((cell) & 127) << 0))
  943. #define ROM_PIXEL_FF 0xc0400UL
  944. class Poly {
  945. int x0, y0, x1, y1;
  946. int x[8], y[8];
  947. byte n;
  948. void restart() {
  949. n = 0;
  950. x0 = 16 * 480;
  951. x1 = 0;
  952. y0 = 16 * 272;
  953. y1 = 0;
  954. }
  955. void perim() {
  956. for (byte i = 0; i < n; i++)
  957. GD.Vertex2f(x[i], y[i]);
  958. GD.Vertex2f(x[0], y[0]);
  959. }
  960. public:
  961. void begin() {
  962. restart();
  963. GD.ColorMask(0,0,0,0);
  964. GD.StencilOp(KEEP, INVERT);
  965. GD.StencilFunc(ALWAYS, 255, 255);
  966. }
  967. void v(int _x, int _y) {
  968. x0 = min(x0, _x >> 4);
  969. x1 = max(x1, _x >> 4);
  970. y0 = min(y0, _y >> 4);
  971. y1 = max(y1, _y >> 4);
  972. x[n] = _x;
  973. y[n] = _y;
  974. n++;
  975. }
  976. void paint() {
  977. x0 = max(0, x0);
  978. y0 = max(0, y0);
  979. x1 = min(16 * 480, x1);
  980. y1 = min(16 * 272, y1);
  981. GD.ScissorXY(x0, y0);
  982. GD.ScissorSize(x1 - x0 + 1, y1 - y0 + 1);
  983. GD.Begin(EDGE_STRIP_B);
  984. perim();
  985. }
  986. void finish() {
  987. GD.ColorMask(1,1,1,1);
  988. GD.StencilFunc(EQUAL, 255, 255);
  989. GD.Begin(EDGE_STRIP_B);
  990. GD.Vertex2ii(0, 0);
  991. GD.Vertex2ii(511, 0);
  992. }
  993. void draw() {
  994. paint();
  995. finish();
  996. }
  997. void outline() {
  998. GD.Begin(LINE_STRIP);
  999. perim();
  1000. }
  1001. };
  1002. #if SDCARD
  1003. class Streamer {
  1004. public:
  1005. void begin(const char *rawsamples,
  1006. uint16_t freq = 44100,
  1007. byte format = ADPCM_SAMPLES,
  1008. uint32_t _base = (0x40000UL - 8192), uint16_t size = 8192) {
  1009. GD.__end();
  1010. r.openfile(rawsamples);
  1011. GD.resume();
  1012. base = _base;
  1013. mask = size - 1;
  1014. wp = 0;
  1015. for (byte i = 10; i; i--)
  1016. feed();
  1017. GD.sample(base, size, freq, format, 1);
  1018. }
  1019. int feed() {
  1020. uint16_t rp = GD.rd32(REG_PLAYBACK_READPTR) - base;
  1021. uint16_t freespace = mask & ((rp - 1) - wp);
  1022. if (freespace >= 512) {
  1023. // REPORT(base);
  1024. // REPORT(rp);
  1025. // REPORT(wp);
  1026. // REPORT(freespace);
  1027. // Serial.println();
  1028. byte buf[512];
  1029. // uint16_t n = min(512, r.size - r.offset);
  1030. // n = (n + 3) & ~3; // force 32-bit alignment
  1031. GD.__end();
  1032. r.readsector(buf);
  1033. GD.resume();
  1034. GD.cmd_memwrite(base + wp, 512);
  1035. GD.copyram(buf, 512);
  1036. wp = (wp + 512) & mask;
  1037. }
  1038. return r.offset < r.size;
  1039. }
  1040. void progress(uint16_t &val, uint16_t &range) {
  1041. uint32_t m = r.size;
  1042. uint32_t p = min(r.offset, m);
  1043. while (m > 0x10000) {
  1044. m >>= 1;
  1045. p >>= 1;
  1046. }
  1047. val = p;
  1048. range = m;
  1049. }
  1050. private:
  1051. Reader r;
  1052. uint32_t base;
  1053. uint16_t mask;
  1054. uint16_t wp;
  1055. };
  1056. #else
  1057. class Streamer {
  1058. public:
  1059. void begin(const char *rawsamples,
  1060. uint16_t freq = 44100,
  1061. byte format = ADPCM_SAMPLES,
  1062. uint32_t _base = (0x40000UL - 4096), uint16_t size = 4096) {}
  1063. int feed() {}
  1064. void progress(uint16_t &val, uint16_t &range) {}
  1065. };
  1066. #endif
  1067. ////////////////////////////////////////////////////////////////////////
  1068. // TileMap: maps made with the "tiled" map editor
  1069. ////////////////////////////////////////////////////////////////////////
  1070. class TileMap {
  1071. uint32_t chunkstart;
  1072. int chunkw, chunkh;
  1073. int stride;
  1074. int bpc;
  1075. byte layers;
  1076. public:
  1077. uint16_t w, h;
  1078. void begin(uint32_t loadpoint) {
  1079. GD.finish();
  1080. w = GD.rd16(loadpoint + 0);
  1081. h = GD.rd16(loadpoint + 2);
  1082. chunkw = GD.rd16(loadpoint + 4);
  1083. chunkh = GD.rd16(loadpoint + 6);
  1084. stride = GD.rd16(loadpoint + 8);
  1085. layers = GD.rd16(loadpoint + 10);
  1086. bpc = (4 * 16);
  1087. chunkstart = loadpoint + 12;
  1088. }
  1089. void draw(uint16_t x, uint16_t y, uint16_t layermask = ~0) {
  1090. int16_t chunk_x = (x / chunkw);
  1091. int16_t ox0 = -(x % chunkw);
  1092. int16_t chunk_y = (y / chunkh);
  1093. int16_t oy = -(y % chunkh);
  1094. GD.Begin(BITMAPS);
  1095. GD.SaveContext();
  1096. GD.BlendFunc(ONE, ONE_MINUS_SRC_ALPHA);
  1097. while (oy < GD.h) {
  1098. int16_t ox = ox0;
  1099. GD.VertexTranslateY(oy << 4);
  1100. uint32_t pos = chunkstart + (chunk_x + long(stride) * chunk_y) * layers * bpc;
  1101. while (ox < GD.w) {
  1102. GD.VertexTranslateX(ox << 4);
  1103. for (byte layer = 0; layer < layers; layer++)
  1104. if (layermask & (1 << layer))
  1105. GD.cmd_append(pos + bpc * layer, bpc);
  1106. pos += (layers * bpc);
  1107. ox += chunkw;
  1108. }
  1109. oy += chunkh;
  1110. chunk_y++;
  1111. }
  1112. GD.RestoreContext();
  1113. }
  1114. void draw(xy pos) {
  1115. draw(pos.x >> 4, pos.y >> 4);
  1116. }
  1117. uint32_t addr(uint16_t x, uint16_t y, byte layer) {
  1118. int16_t tx = (x / (chunkw >> 2));
  1119. int16_t ty = (y / (chunkh >> 2));
  1120. return
  1121. chunkstart +
  1122. ((tx >> 2) + long(stride) * (ty >> 2)) * layers * bpc +
  1123. (tx & 3) * 4 +
  1124. (ty & 3) * 16 +
  1125. layer * 64;
  1126. }
  1127. int read(uint16_t x, uint16_t y, byte layer) {
  1128. uint32_t op = GD.rd32(addr(x, y, layer));
  1129. if ((op >> 24) == 0x2d)
  1130. return 0;
  1131. else
  1132. return 1 + (op & 2047);
  1133. }
  1134. void write(uint16_t x, uint16_t y, byte layer, int tile) {
  1135. uint32_t op;
  1136. uint32_t a = addr(x, y, layer);
  1137. if (tile == 0)
  1138. op = 0x2d000000UL;
  1139. else
  1140. op = (GD.rd32(a) & ~2047) | ((tile - 1) & 2047);
  1141. GD.wr32(a, op);
  1142. }
  1143. int read(xy pos, byte layer) {
  1144. return read(pos.x >> 4, pos.y >> 4, layer);
  1145. }
  1146. void write(xy pos, byte layer, int tile) {
  1147. write(pos.x >> 4, pos.y >> 4, layer, tile);
  1148. }
  1149. };
  1150. class MoviePlayer
  1151. {
  1152. uint32_t mf_size, mf_base, wp;
  1153. Reader r;
  1154. void loadsector() {
  1155. byte buf[512];
  1156. GD.__end();
  1157. r.readsector(buf);
  1158. GD.resume();
  1159. GD.wr_n(mf_base + wp, buf, 512);
  1160. wp = (wp + 512) & (mf_size - 1);
  1161. }
  1162. public:
  1163. int begin(const char *filename) {
  1164. mf_size = 0x40000UL;
  1165. mf_base = 0x100000UL - mf_size;
  1166. GD.__end();
  1167. if (!r.openfile(filename)) {
  1168. // Serial.println("Open failed");
  1169. return 0;
  1170. }
  1171. GD.resume();
  1172. wp = 0;
  1173. while (wp < (mf_size - 512)) {
  1174. loadsector();
  1175. }
  1176. GD.cmd_mediafifo(mf_base, mf_size);
  1177. GD.cmd_regwrite(REG_MEDIAFIFO_WRITE, wp);
  1178. GD.finish();
  1179. return 1;
  1180. }
  1181. int service() {
  1182. if (r.eof()) {
  1183. return 0;
  1184. } else {
  1185. byte buf[512];
  1186. uint32_t fullness = (wp - GD.rd32(REG_MEDIAFIFO_READ)) & (mf_size - 1);
  1187. while (fullness < (mf_size - 512)) {
  1188. loadsector();
  1189. fullness += 512;
  1190. GD.wr32(REG_MEDIAFIFO_WRITE, wp);
  1191. }
  1192. return 1;
  1193. }
  1194. }
  1195. void play() {
  1196. GD.cmd_playvideo(OPT_MEDIAFIFO | OPT_FULLSCREEN);
  1197. GD.flush();
  1198. while (service())
  1199. ;
  1200. GD.cmd_memcpy(0, 0, 4);
  1201. GD.finish();
  1202. }
  1203. };
  1204. class Dirsearch {
  1205. struct dirent de;
  1206. int index;
  1207. public:
  1208. char name[13];
  1209. void begin() {
  1210. index = 0;
  1211. }
  1212. int get(const char *ext) {
  1213. byte i;
  1214. GD.__end();
  1215. char e3[3];
  1216. do {
  1217. GD.SD.rdn((byte*)&de, GD.SD.o_root + index++ * 32, sizeof(de));
  1218. for (i = 0; i < 3; i++)
  1219. e3[i] = tolower(de.ext[i]);
  1220. } while (de.name[0] &&
  1221. ((de.name[0] & 0x80) || (memcmp(ext, e3, 3) != 0)));
  1222. GD.resume();
  1223. char *pc = name;
  1224. for (i = 0; i < 8 && de.name[i] != ' '; i++)
  1225. *pc++ = tolower(de.name[i]);
  1226. *pc++ = '.';
  1227. for (i = 0; i < 3 && de.ext[i] != ' '; i++)
  1228. *pc++ = tolower(de.ext[i]);
  1229. *pc++ = 0;
  1230. return de.name[0];
  1231. }
  1232. };
  1233. /*
  1234. * PROGMEM declarations are currently not supported by the ESP8266
  1235. * compiler. So redefine PROGMEM to nothing.
  1236. */
  1237. #if defined(ESP8266) || defined(ARDUINO_ARCH_STM32L4)
  1238. #undef PROGMEM
  1239. #define PROGMEM
  1240. #endif
  1241. #endif