API tools faq
paste
Guest User

main.c

a guest
Jan 18th, 2023
284
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.88 KB | None | 0 0
raw download clone embed print report
  1. #include <sys/types.h>
  2. #include <stdint.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6.  
  7. #include "hw_md.h"
  8. #include "files.h"
  9.  
  10. #define HIRES_BMP 1
  11.  
  12. static unsigned short clookup[8] = { 0, 1, 1, 2, 3, 4, 5, 5 };
  13.  
  14. extern int z80_ambtc_start;
  15. extern int z80_ambtc_end;
  16.  
  17. void load_driver(void)
  18. {
  19. // hold z80 bus - halt z80
  20. z80_busrequest(Z80_BUS_REQUEST);
  21. // clear z80 sram
  22. z80_memclr((void *)0xA00000, 0x2000);
  23. // copy driver to z80 sram
  24. z80_memcpy((void *)0xA00000, &z80_ambtc_start, (int)&z80_ambtc_end - (int)&z80_ambtc_start);
  25. // reset z80
  26. z80_reset(Z80_ASSERT_RESET);
  27. // release z80 bus
  28. z80_busrequest(Z80_BUS_RELEASE);
  29. // finish z80 reset - start driver
  30. z80_reset(Z80_CLEAR_RESET);
  31. }
  32.  
  33. int start_song(char *fname)
  34. {
  35. volatile uint8_t *pb;
  36.  
  37. int fd;
  38. int addr = 0, len = 0;
  39.  
  40. for (fd = 0; fd < NUM_FILES; fd++)
  41. if (!memcmp(fname, fileName[fd], strlen(fname)))
  42. {
  43. addr = filePtr[fd];
  44. len = fileSize[fd];
  45. break;
  46. }
  47.  
  48. if (!addr || !len)
  49. return 0; // bad filename
  50.  
  51. z80_busrequest(Z80_BUS_REQUEST);
  52.  
  53. // point to Z80 base parameters
  54. pb = (uint8_t *)0xA00040;
  55.  
  56. // sample address
  57. pb[0x00] = addr >> 0;
  58. pb[0x01] = addr >> 8;
  59. pb[0x02] = addr >> 16;
  60.  
  61. // sample length
  62. pb[0x03] = len >> 0;
  63. pb[0x04] = len >> 8;
  64. pb[0x05] = len >> 16;
  65.  
  66. // DELAY - set the playback sample rate
  67. pb[0x0C] = 4; // ~ 22000 samples/sec
  68. // PAN (left / right / center)
  69. pb[0x0D] = 0xC0; // center
  70. // PLAY
  71. pb[0x0E] = -1; // play forever
  72. // PAUSE
  73. pb[0x0F] = 0;
  74.  
  75. z80_busrequest(Z80_BUS_RELEASE);
  76.  
  77. return 1;
  78. }
  79.  
  80. void stop_song(void)
  81. {
  82. volatile uint8_t *pb;
  83.  
  84. z80_busrequest(Z80_BUS_REQUEST);
  85.  
  86. // point to Z80 base parameters
  87. pb = (uint8_t *)0xA00040;
  88.  
  89. // PAUSE
  90. pb[0x0F] = 1; // pause
  91. // PLAY
  92. pb[0x0E] = 0; // stop
  93.  
  94. z80_busrequest(Z80_BUS_RELEASE);
  95. delay(2);
  96. }
  97.  
  98. void pause_song(short flag)
  99. {
  100. volatile uint8_t *pb;
  101.  
  102. z80_busrequest(Z80_BUS_REQUEST);
  103.  
  104. // point to Z80 base parameters
  105. pb = (uint8_t *)0xA00040;
  106.  
  107. // PAUSE
  108. pb[0x0F] = flag; // pause
  109.  
  110. z80_busrequest(Z80_BUS_RELEASE);
  111. }
  112.  
  113. int is_playing(void)
  114. {
  115. volatile uint8_t *pb, res;
  116.  
  117. z80_busrequest(Z80_BUS_REQUEST);
  118.  
  119. // point to Z80 base parameters
  120. pb = (uint8_t *)0xA00040;
  121.  
  122. // PLAY
  123. res = pb[0x0E];
  124.  
  125. z80_busrequest(Z80_BUS_RELEASE);
  126.  
  127. return res;
  128. }
  129.  
  130. int bmp_valid(void *bmp)
  131. {
  132. char *p = (char *)bmp;
  133. return (p[0] == 'B' && p[1] == 'M' && p[14] == 40) ? 1 : 0;
  134. }
  135.  
  136. int bmp_width(void *bmp)
  137. {
  138. unsigned char *p = (unsigned char *)bmp;
  139. return p[0x12] | (p[0x13]<<8) | (p[0x14]<<16) | (p[0x15]<<24);
  140. }
  141.  
  142. int bmp_height(void *bmp)
  143. {
  144. unsigned char *p = (unsigned char *)bmp;
  145. return p[0x16] | (p[0x17]<<8) | (p[0x18]<<16) | (p[0x19]<<24);
  146. }
  147.  
  148. inline unsigned short swap(unsigned short val)
  149. {
  150. return (val>>8) | (val<<8);
  151. }
  152.  
  153. inline unsigned short blue(unsigned short color)
  154. {
  155. unsigned short ret = clookup[(swap(color)&0x001F)>>2];
  156. return ret ? ret : 0;
  157. }
  158.  
  159. inline unsigned short green(unsigned short color)
  160. {
  161. unsigned short ret = clookup[(swap(color)&0x03E0)>>7];
  162. return ret ? ret+5 : 0;
  163. }
  164.  
  165. inline unsigned short red(unsigned short color)
  166. {
  167. unsigned short ret = clookup[(swap(color)&0x7C00)>>12];
  168. return ret ? ret+10 : 0;
  169. }
  170.  
  171. int main(void)
  172. {
  173. unsigned short current = 0, next;
  174.  
  175. clear_screen();
  176. clear_text();
  177. put_str("Direct Color Graphics Test", TEXT_WHITE, 20-13, 2);
  178.  
  179. // load Z80 driver
  180. load_driver();
  181.  
  182. if (start_song(fileName[0]))
  183. {
  184. put_str(" ", TEXT_WHITE, 2, 5);
  185. put_str("Playing:", TEXT_GREEN, 2, 5);
  186. put_str(fileName[0], TEXT_RED, 11, 5);
  187. }
  188. else
  189. {
  190. put_str(" ", TEXT_WHITE, 2, 5);
  191. put_str("Error:", TEXT_GREEN, 2, 5);
  192. put_str(fileName[0], TEXT_RED, 11, 5);
  193. }
  194.  
  195. while (1)
  196. {
  197. next = (gTicks / 600) % (NUM_FILES - 1) + 1;
  198. if (next != current)
  199. {
  200. unsigned short *p;
  201. unsigned short sc, dc;
  202. void *bmp = (void *)filePtr[next];
  203. int x, y, yy, offs, w, h;
  204.  
  205. clear_screen();
  206. if (bmp_valid(bmp))
  207. {
  208. p = (unsigned short *)((int)bmp + 0x36);
  209. w = bmp_width(bmp);
  210. h = bmp_height(bmp);
  211. #ifdef HIRES_BMP
  212. // draw hires bmp to bitmap
  213. for (yy=0; yy<h; yy++)
  214. {
  215. y = (h - 1) - yy; // draw bottom to top
  216. offs = 0x1C00 + ((((yy & 0xF8)<<3) + ((yy & 0xF8)<<5))<<2) + ((yy & 7)<<2);
  217. for (x=0; x<w; x+=8)
  218. {
  219. if (!(yy & 1))
  220. {
  221. // R0G1R2G3R4G5R6G7
  222. sc = p[y*w + x];
  223. dc = red(sc) << 12; // R0
  224. sc = p[y*w + x + 1];
  225. dc |= green(sc) << 8; // G1
  226. sc = p[y*w + x + 2];
  227. dc |= red(sc) << 4; // R2
  228. sc = p[y*w + x + 3];
  229. dc |= green(sc); // G3
  230. set_vram(offs, dc);
  231. sc = p[y*w + x + 4];
  232. dc = red(sc) << 12; // R4
  233. sc = p[y*w + x + 5];
  234. dc |= green(sc) << 8; // G5
  235. sc = p[y*w + x + 6];
  236. dc |= red(sc) << 4; // R6
  237. sc = p[y*w + x + 7];
  238. dc |= green(sc); // G7
  239. next_vram(dc);
  240. }
  241. else
  242. {
  243. // G0B1G2B3G4B5G6B7
  244. sc = p[y*w + x];
  245. dc = green(sc) << 12; // G0
  246. sc = p[y*w + x + 1];
  247. dc |= blue(sc) << 8; // B1
  248. sc = p[y*w + x + 2];
  249. dc |= green(sc) << 4; // G2
  250. sc = p[y*w + x + 3];
  251. dc |= blue(sc); // B3
  252. set_vram(offs, dc);
  253. sc = p[y*w + x + 4];
  254. dc = green(sc) << 12; // G4
  255. sc = p[y*w + x + 5];
  256. dc |= blue(sc) << 8; // B5
  257. sc = p[y*w + x + 6];
  258. dc |= green(sc) << 4; // G6
  259. sc = p[y*w + x + 7];
  260. dc |= blue(sc); // B7
  261. next_vram(dc);
  262. }
  263. offs += 32;
  264. }
  265. }
  266. for (y=h; y<224; y++)
  267. {
  268. offs = 0x1C00 + ((((y & 0xF8)<<3) + ((y & 0xF8)<<5))<<2) + ((y & 7)<<2);
  269. for (x=0; x<w; x+=8)
  270. {
  271. set_vram(offs, 0);
  272. next_vram(0);
  273. offs += 32;
  274. }
  275. }
  276. #else
  277. // draw lores bmp to bitmap
  278. for (yy=0; yy<h; yy++)
  279. {
  280. y = (h - 1) - yy; // draw bottom to top
  281. offs = 0x1C00 + ((((yy*2 & 0xF8)<<3) + ((yy*2 & 0xF8)<<5))<<2) + ((yy*2 & 7)<<2);
  282. for (x=0; x<w; x+=4)
  283. {
  284. // R0G0R1G1R2G2R3G3
  285. sc = p[y*w + x];
  286. dc = red(sc) << 12; // R0
  287. dc |= green(sc) << 8; // G0
  288. sc = p[y*w + x + 1];
  289. dc |= red(sc) << 4; // R1
  290. dc |= green(sc); // G1
  291. set_vram(offs, dc);
  292. sc = p[y*w + x + 2];
  293. dc = red(sc) << 12; // R2
  294. dc |= green(sc) << 8; // G2
  295. sc = p[y*w + x + 3];
  296. dc |= red(sc) << 4; // R3
  297. dc |= green(sc); // G3
  298. next_vram(dc);
  299. // G0B0G1B1G2B2G3B3
  300. sc = p[y*w + x];
  301. dc = green(sc) << 12; // G0
  302. dc |= blue(sc) << 8; // B0
  303. sc = p[y*w + x + 1];
  304. dc |= green(sc) << 4; // G1
  305. dc |= blue(sc); // B1
  306. next_vram(dc);
  307. sc = p[y*w + x + 2];
  308. dc = green(sc) << 12; // G2
  309. dc |= blue(sc) << 8; // B2
  310. sc = p[y*w + x + 3];
  311. dc |= green(sc) << 4; // G3
  312. dc |= blue(sc); // B3
  313. next_vram(dc);
  314. offs += 32;
  315. }
  316. }
  317. for (y=h; y<112; y++)
  318. {
  319. offs = 0x1C00 + ((((y*2 & 0xF8)<<3) + ((y*2 & 0xF8)<<5))<<2) + ((y*2 & 7)<<2);
  320. for (x=0; x<w; x+=4)
  321. {
  322. set_vram(offs, 0);
  323. next_vram(0);
  324. next_vram(0);
  325. next_vram(0);
  326. offs += 32;
  327. }
  328. }
  329. #endif
  330. // show bitmap
  331. map_screen();
  332. }
  333. current = next;
  334. }
  335. delay(10);
  336. }
  337.  
  338. clear_screen();
  339. return 0;
  340. }
  341.  
  342.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!