API tools faq
paste
Guest User

halvvej

a guest
Jan 13th, 2018
60
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.47 KB | None | 0 0
raw download clone embed print report
  1. #include "video_demo.h"
  2. #include "video_capture/video_capture.h"
  3. #include "display_ctrl/display_ctrl.h"
  4. #include "intc/intc.h"
  5. #include <stdio.h>
  6. #include "xuartps.h"
  7. #include "math.h"
  8. #include <ctype.h>
  9. #include <stdlib.h>
  10. #include "xil_types.h"
  11. #include "xil_cache.h"
  12. #include "timer_ps/timer_ps.h"
  13. #include "xparameters.h"
  14. #include <stdio.h>
  15. #include "xtime_l.h"
  16. #include "xgpio.h"
  17. #include "xscugic.h"
  18. #include <unistd.h>
  19.  
  20. Farve red={255,0,0};
  21. Farve sort = {192,192,192};
  22.  
  23. /*
  24. * XPAR redefines
  25. */
  26. #define DYNCLK_BASEADDR XPAR_AXI_DYNCLK_0_BASEADDR
  27. #define VGA_VDMA_ID XPAR_AXIVDMA_0_DEVICE_ID
  28. #define DISP_VTC_ID XPAR_VTC_0_DEVICE_ID
  29. #define VID_VTC_ID XPAR_VTC_1_DEVICE_ID
  30. #define VID_GPIO_ID XPAR_AXI_GPIO_VIDEO_DEVICE_ID
  31. #define VID_VTC_IRPT_ID XPS_FPGA3_INT_ID
  32. #define VID_GPIO_IRPT_ID XPS_FPGA4_INT_ID
  33. #define SCU_TIMER_ID XPAR_SCUTIMER_DEVICE_ID
  34. #define UART_BASEADDR XPAR_PS7_UART_1_BASEADDR
  35. #define BTNS_DEVICE_ID XPAR_AXI_GPIO_0_DEVICE_ID
  36. #define LEDS_DEVICE_ID XPAR_AXI_GPIO_1_DEVICE_ID
  37. #define INTC_GPIO_INTERRUPT_ID XPAR_FABRIC_AXI_GPIO_0_IP2INTC_IRPT_INTR
  38. #define INTC_TMR_INTERRUPT_ID XPAR_FABRIC_AXI_TIMER_0_INTERRUPT_INTR
  39. #define BTN_INT XGPIO_IR_CH1_MASK
  40. void Int_Handler(void *InstancePtr);
  41.  
  42. /* ------------------------------------------------------------ */
  43. /* Global Variables */
  44. /* ------------------------------------------------------------ */
  45. char userInput = 0;
  46. int playeNewPos;
  47. int player_pos=220;
  48.  
  49.  
  50.  
  51. int ra1;
  52. int ra2;
  53. int ra3;
  54. int r1 = 5;
  55. int r2 = 8;
  56. int r3 = 10;
  57. int enemySpeedCounter1;
  58. int enemySpeedCounter2;
  59. int enemySpeedCounter3;
  60.  
  61.  
  62.  
  63. int Enemy_X3 = 600;
  64. int Enemy3_wGreen = 0;
  65. int Enemy3_wRed = 255;
  66. int Enemy3_wBlue = 0;
  67. int enemy_y3 = 260;
  68.  
  69.  
  70. int Enemy_X2 = 600;
  71. int Enemy2_wGreen = 0;
  72. int Enemy2_wRed = 255;
  73. int Enemy2_wBlue = 0;
  74. int enemy_y2 = 220;
  75.  
  76.  
  77. int Enemy_wGreen = 0;
  78. int Enemy_wRed = 255;
  79. int Enemy_wBlue = 0;
  80. int enemy_y = 180;
  81. int Enemy_X = 600;
  82. int Enemy_y_size = 10;
  83. int Enemy_x_size = 40;
  84.  
  85.  
  86.  
  87.  
  88. XGpio LEDInst, BTNInst;
  89. XScuGic INTCInst;
  90. int SpilStartet;
  91. int r;
  92. int r2;
  93. int x=5;
  94. int led_data;
  95. int btn_value;
  96.  
  97. /*
  98. * Display and Video Driver structs
  99. */
  100. DisplayCtrl dispCtrl;
  101. XAxiVdma vdma;
  102. VideoCapture videoCapt;
  103. INTC intc;
  104. char fRefresh; //flag used to trigger a refresh of the Menu on video detect
  105.  
  106.  
  107.  
  108.  
  109. int randomCount;
  110. int count;
  111.  
  112. /*
  113. * Framebuffers for video data
  114. */
  115. u8 frameBuf[DISPLAY_NUM_FRAMES][DEMO_MAX_FRAME];
  116. u8 *pFrames[DISPLAY_NUM_FRAMES]; //array of pointers to the frame buffers
  117.  
  118. /*
  119. * Interrupt vector table
  120. */
  121. const ivt_t ivt[] = {
  122. videoGpioIvt(VID_GPIO_IRPT_ID, &videoCapt),
  123. videoVtcIvt(VID_VTC_IRPT_ID, &(videoCapt.vtc)),
  124. {66, (XInterruptHandler)Int_Handler, NULL, 0xA0, 0x3}
  125. };
  126. /* ------------------------------------------------------------ */
  127. /* PROTOTYPE Definitions */
  128. /* ------------------------------------------------------------ */
  129.  
  130.  
  131.  
  132.  
  133. /* ------------------------------------------------------------ */
  134. /* Procedure Definitions */
  135. /* ------------------------------------------------------------ */
  136. int a=1;
  137. int main(void)
  138. {
  139.  
  140. u8* frame = &frameBuf[0];
  141. DemoInitialize();
  142. PlayerBox(frame,50,220,40,10,1);
  143. DisplayChangeFrame(&dispCtrl, 0);
  144.  
  145.  
  146. while(1) {
  147.  
  148. Input();
  149.  
  150. EnemySpeed1();
  151. tegn_box(frame,Enemy_X,enemy_y,40,10,sort);
  152. MoveEnemy1();
  153. tegn_box(frame,Enemy_X,enemy_y,40,10,red);
  154.  
  155. EnemySpeed3();
  156. tegn_box(frame,Enemy_X2,enemy_y2,40,10,sort);
  157. MoveEnemy2();
  158. tegn_box(frame,Enemy_X2,enemy_y2,40,10,red);
  159.  
  160. EnemySpeed3();
  161. tegn_box(frame,Enemy_X3,enemy_y3,40,10,sort);
  162. MoveEnemy3();
  163. tegn_box(frame,Enemy_X3,enemy_y3,40,10,red);
  164.  
  165. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  166.  
  167.  
  168.  
  169. //xil_printf("test\n\r");
  170. usleep(16000);
  171. }
  172.  
  173. return 0;
  174. }
  175.  
  176.  
  177.  
  178. void Int_Handler(void *InstancePtr){
  179.  
  180. enemySpeedCounter1++;
  181. enemySpeedCounter2++;
  182. enemySpeedCounter3++;
  183.  
  184. xil_printf("%d\n\r", enemySpeedCounter3);
  185.  
  186.  
  187. }
  188.  
  189.  
  190.  
  191.  
  192.  
  193. void DemoInitialize()
  194. {
  195. int Status;
  196. XAxiVdma_Config *vdmaConfig;
  197. int i;
  198.  
  199. /*
  200. * Initialize an array of pointers to the 3 frame buffers
  201. */
  202. for (i = 0; i < DISPLAY_NUM_FRAMES; i++)
  203. {
  204. pFrames[i] = frameBuf[i];
  205. }
  206.  
  207. /*
  208. * Initialize a timer used for a simple delay
  209. */
  210. TimerInitialize(SCU_TIMER_ID);
  211.  
  212. /*
  213. * Initialize VDMA driver
  214. */
  215. vdmaConfig = XAxiVdma_LookupConfig(VGA_VDMA_ID);
  216. if (!vdmaConfig)
  217. {
  218. xil_printf("No video DMA found for ID %d\r\n", VGA_VDMA_ID);
  219. return;
  220. }
  221. Status = XAxiVdma_CfgInitialize(&vdma, vdmaConfig, vdmaConfig->BaseAddress);
  222. if (Status != XST_SUCCESS)
  223. {
  224. xil_printf("VDMA Configuration Initialization failed %d\r\n", Status);
  225. return;
  226. }
  227.  
  228. /*
  229. * Initialize the Display controller and start it
  230. */
  231. Status = DisplayInitialize(&dispCtrl, &vdma, DISP_VTC_ID, DYNCLK_BASEADDR, pFrames, DEMO_STRIDE);
  232. if (Status != XST_SUCCESS)
  233. {
  234. xil_printf("Display Ctrl initialization failed during demo initialization%d\r\n", Status);
  235. return;
  236. }
  237. Status = DisplayStart(&dispCtrl);
  238. if (Status != XST_SUCCESS)
  239. {
  240. xil_printf("Couldn't start display during demo initialization%d\r\n", Status);
  241. return;
  242. }
  243.  
  244. /*
  245. * Initialize the Interrupt controller and start it.
  246. */
  247. Status = fnInitInterruptController(&intc);
  248. if(Status != XST_SUCCESS) {
  249. xil_printf("Error initializing interrupts");
  250. return;
  251. }
  252. fnEnableInterrupts(&intc, &ivt[0], sizeof(ivt)/sizeof(ivt[0]));
  253.  
  254. /*
  255. * Initialize the Video Capture device
  256. */
  257. Status = VideoInitialize(&videoCapt, &intc, &vdma, VID_GPIO_ID, VID_VTC_ID, VID_VTC_IRPT_ID, pFrames, DEMO_STRIDE, DEMO_START_ON_DET);
  258. if (Status != XST_SUCCESS)
  259. {
  260. xil_printf("Video Ctrl initialization failed during demo initialization%d\r\n", Status);
  261. return;
  262. }
  263.  
  264. /*
  265. * Set the Video Detect callback to trigger the menu to reset, displaying the new detected resolution
  266. */
  267.  
  268. VideoSetCallback(&videoCapt, DemoISR, &fRefresh);
  269.  
  270.  
  271. StartSpil();
  272.  
  273. return;
  274.  
  275.  
  276. }
  277.  
  278.  
  279.  
  280.  
  281.  
  282. void DemoInvertFrame(u8 *srcFrame, u8 *destFrame, u32 width, u32 height, u32 stride)
  283. {
  284. u32 xcoi, ycoi;
  285. u32 lineStart = 0;
  286. for(ycoi = 0; ycoi < height; ycoi++)
  287. {
  288. for(xcoi = 0; xcoi < (width * 3); xcoi+=3)
  289. {
  290. destFrame[xcoi + lineStart] = ~srcFrame[xcoi + lineStart]; //Red
  291. destFrame[xcoi + lineStart + 1] = ~srcFrame[xcoi + lineStart + 1]; //Blue
  292. destFrame[xcoi + lineStart + 2] = ~srcFrame[xcoi + lineStart + 2]; //Green
  293. }
  294. lineStart += stride;
  295. }
  296. /*
  297. * Flush the framebuffer memory range to ensure changes are written to the
  298. * actual memory, and therefore accessible by the VDMA.
  299. */
  300. Xil_DCacheFlushRange((unsigned int) destFrame, DEMO_MAX_FRAME);
  301. }
  302.  
  303.  
  304. /*
  305. * Bilinear interpolation algorithm. Assumes both frames have the same stride.
  306. */
  307. void DemoScaleFrame(u8 *srcFrame, u8 *destFrame, u32 srcWidth, u32 srcHeight, u32 destWidth, u32 destHeight, u32 stride)
  308. {
  309. float xInc, yInc; // Width/height of a destination frame pixel in the source frame coordinate system
  310. float xcoSrc, ycoSrc; // Location of the destination pixel being operated on in the source frame coordinate system
  311. float x1y1, x2y1, x1y2, x2y2; //Used to store the color data of the four nearest source pixels to the destination pixel
  312. int ix1y1, ix2y1, ix1y2, ix2y2; //indexes into the source frame for the four nearest source pixels to the destination pixel
  313. float xDist, yDist; //distances between destination pixel and x1y1 source pixels in source frame coordinate system
  314.  
  315. int xcoDest, ycoDest; // Location of the destination pixel being operated on in the destination coordinate system
  316. int iy1; //Used to store the index of the first source pixel in the line with y1
  317. int iDest; //index of the pixel data in the destination frame being operated on
  318.  
  319. int i;
  320.  
  321. xInc = ((float) srcWidth - 1.0) / ((float) destWidth);
  322. yInc = ((float) srcHeight - 1.0) / ((float) destHeight);
  323.  
  324. ycoSrc = 0.0;
  325. for (ycoDest = 0; ycoDest < destHeight; ycoDest++)
  326. {
  327. iy1 = ((int) ycoSrc) * stride;
  328. yDist = ycoSrc - ((float) ((int) ycoSrc));
  329.  
  330. /*
  331. * Save some cycles in the loop below by presetting the destination
  332. * index to the first pixel in the current line
  333. */
  334. iDest = ycoDest * stride;
  335.  
  336. xcoSrc = 0.0;
  337. for (xcoDest = 0; xcoDest < destWidth; xcoDest++)
  338. {
  339. ix1y1 = iy1 + ((int) xcoSrc) * 3;
  340. ix2y1 = ix1y1 + 3;
  341. ix1y2 = ix1y1 + stride;
  342. ix2y2 = ix1y1 + stride + 3;
  343.  
  344. xDist = xcoSrc - ((float) ((int) xcoSrc));
  345.  
  346. /*
  347. * For loop handles all three colors
  348. */
  349. for (i = 0; i < 3; i++)
  350. {
  351. x1y1 = (float) srcFrame[ix1y1 + i];
  352. x2y1 = (float) srcFrame[ix2y1 + i];
  353. x1y2 = (float) srcFrame[ix1y2 + i];
  354. x2y2 = (float) srcFrame[ix2y2 + i];
  355.  
  356. /*
  357. * Bilinear interpolation function
  358. */
  359. destFrame[iDest] = (u8) ((1.0-yDist)*((1.0-xDist)*x1y1+xDist*x2y1) + yDist*((1.0-xDist)*x1y2+xDist*x2y2));
  360. iDest++;
  361. }
  362. xcoSrc += xInc;
  363. }
  364. ycoSrc += yInc;
  365. }
  366.  
  367. /*
  368. * Flush the framebuffer memory range to ensure changes are written to the
  369. * actual memory, and therefore accessible by the VDMA.
  370. */
  371. Xil_DCacheFlushRange((unsigned int) destFrame, DEMO_MAX_FRAME);
  372.  
  373. return;
  374. }
  375.  
  376.  
  377.  
  378.  
  379. void RandomEnemies(){
  380.  
  381.  
  382. if (randomCount == 18) {
  383. r=rand()%2;
  384.  
  385. if(r == 0){
  386.  
  387. if(enemy_y2 == 180){
  388. enemy_y2 = enemy_y2 + 40 ;
  389.  
  390. }
  391. else{
  392. enemy_y2 = enemy_y2 - 40 ;
  393.  
  394. }
  395. }
  396.  
  397. if(r == 1){
  398. if(enemy_y2 == 260){
  399. enemy_y2 = enemy_y2 - 40;
  400. }
  401. else{
  402. enemy_y2 = enemy_y2 + 40;
  403.  
  404. }
  405. }
  406.  
  407. randomCount = 0;
  408.  
  409. }
  410.  
  411.  
  412. }
  413.  
  414.  
  415.  
  416.  
  417.  
  418.  
  419. void Input(){
  420.  
  421. fRefresh = 0;
  422.  
  423. /* Store the first character in the UART receive FIFO and echo it */
  424. if (XUartPs_IsReceiveData(UART_BASEADDR))
  425. {
  426. userInput = XUartPs_ReadReg(UART_BASEADDR, XUARTPS_FIFO_OFFSET);
  427. xil_printf("%c", userInput);
  428. }
  429. else //Refresh triggered by video detect interrupt
  430. {
  431. userInput = 'r';
  432. }
  433.  
  434. if(userInput == '1'){
  435. PlayerMove(1);
  436.  
  437.  
  438. }
  439.  
  440.  
  441. if(userInput == '2'){
  442. PlayerMove(2);
  443.  
  444.  
  445. }
  446.  
  447.  
  448. }
  449.  
  450.  
  451.  
  452.  
  453.  
  454. void MoveEnemy1(){
  455.  
  456.  
  457.  
  458. Enemy_X = Enemy_X - r1;
  459.  
  460. if (Enemy_X <= 0) {
  461. Enemy_X = 600;
  462. }
  463.  
  464. }
  465.  
  466. void MoveEnemy2(){
  467.  
  468.  
  469. Enemy_X2 = Enemy_X2 - r2;
  470.  
  471. if (Enemy_X2 <= 0) {
  472. Enemy_X2 = 600;
  473. }
  474.  
  475. }
  476.  
  477. void MoveEnemy3(){
  478.  
  479. Enemy_X3 = Enemy_X3 - r3;
  480.  
  481.  
  482. if (Enemy_X3 <= 0) {
  483. Enemy_X3 = 600;
  484. }
  485.  
  486. }
  487.  
  488.  
  489. void EnemySpeed1(){
  490.  
  491. if(enemySpeedCounter1 >= 100 && Enemy_X >= 580){
  492. ra1=rand()%3;
  493.  
  494. if(ra1 == 0){
  495. r1 = 5;
  496. }
  497.  
  498.  
  499. if(ra1 == 1) {
  500. r1 = 8;
  501.  
  502. }
  503.  
  504. if(ra1 == 2) {
  505. r1 = 11;
  506.  
  507. }
  508. enemySpeedCounter1 = 0;
  509. }
  510. }
  511.  
  512.  
  513.  
  514. void EnemySpeed2(){
  515.  
  516. if(enemySpeedCounter2 >= 100 && Enemy_X2 >= 580){
  517. ra2=rand()%3;
  518.  
  519. if(ra2 == 0){
  520. r2 = 5;
  521. }
  522.  
  523.  
  524. if(ra2 == 1) {
  525. r2 = 8;
  526.  
  527. }
  528.  
  529. if(ra2 == 2) {
  530. r2 = 11;
  531.  
  532. }
  533. enemySpeedCounter2 = 0;
  534. }
  535. }
  536.  
  537.  
  538.  
  539. void EnemySpeed3(){
  540.  
  541. if(enemySpeedCounter3 >= 100 && Enemy_X3 >= 580){
  542. ra3=rand()%3;
  543.  
  544. if(ra3 == 0){
  545. r3 = 5;
  546. }
  547.  
  548.  
  549. if(ra3 == 1) {
  550. r3 = 8;
  551.  
  552. }
  553.  
  554. if(ra3 == 2) {
  555. r3 = 11;
  556.  
  557. }
  558. enemySpeedCounter3 = 0;
  559. }
  560. }
  561.  
  562.  
  563.  
  564.  
  565.  
  566.  
  567. void tegn_box(u8* frame, u32 x, u32 y, u32 dx, u32 dy, Farve f){
  568. u32 x_tmp, y_tmp;
  569. u32 iPixelAddr;
  570. for(x_tmp = x ; x_tmp < x+dx; x_tmp++)
  571. {
  572. for(y_tmp=y; y_tmp < y+dy; y_tmp++)
  573. {
  574. iPixelAddr = 3*x_tmp + y_tmp*DEMO_STRIDE;
  575.  
  576. frame[iPixelAddr] = f.g;
  577. frame[iPixelAddr + 1] = f.b;
  578. frame[iPixelAddr + 2] = f.r;
  579.  
  580. }
  581. }
  582. }
  583.  
  584.  
  585. /*
  586.  
  587. void ShowEnemy1(u8 *frame){
  588.  
  589. u32 x_tmp, y_tmp, x_tmp2, y_tmp2;
  590. u32 iPixelAddr, iPixelAddr2;
  591.  
  592.  
  593. // Farve white = {255,255,255};
  594.  
  595.  
  596. tegn_box(frame,Enemy_X, enemy_y, 40, 10, red);
  597. }
  598.  
  599. */
  600.  
  601. void PlayerBox(u8 *frame, u32 x, u32 y, u32 x_size, u32 y_size, u32 color) {
  602.  
  603. u32 iPixelAddr;
  604. u8 wRed, wBlue, wGreen;
  605. u32 x_tmp, y_tmp;
  606.  
  607.  
  608. //Hvid farve
  609. if(color == 1) {
  610.  
  611. wGreen = 255;
  612. wRed = 255;
  613. wBlue = 255;
  614. }
  615.  
  616. //Sort farve
  617. else {
  618. wGreen = 192;
  619. wRed = 192;
  620. wBlue = 192;
  621. }
  622.  
  623.  
  624. //Tegner boxen
  625. for(x_tmp=x; x_tmp < x+x_size; x_tmp++)
  626. {
  627. for(y_tmp=y; y_tmp < y+y_size; y_tmp++)
  628. {
  629. iPixelAddr = 3*x_tmp + y_tmp*DEMO_STRIDE;
  630.  
  631. frame[iPixelAddr] = wGreen;
  632. frame[iPixelAddr + 1] = wBlue;
  633. frame[iPixelAddr + 2] = wRed;
  634.  
  635. }
  636. }
  637.  
  638. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  639.  
  640. }
  641.  
  642.  
  643. void PlayerMove(u32 playerNewPos){
  644.  
  645.  
  646. //playeNewPos = userInput;
  647.  
  648. /*
  649. if(playeNewPos == 4){
  650. playeNewPos = 1;
  651. }
  652.  
  653. if(playeNewPos == 5){
  654. playeNewPos = 2;
  655. }
  656.  
  657. */
  658. int y;
  659.  
  660.  
  661.  
  662. y = player_pos;
  663.  
  664.  
  665. // Flytter player op
  666. if(playerNewPos == 1 && player_pos == 260 ){
  667. PlayerBox(frameBuf[0],50,y,40,10,2);
  668.  
  669. y = y-40;
  670. PlayerBox(frameBuf[0],50,y,40,10,1);
  671. //PlayerBox(frameBuf[0],50,y,40,10,0);
  672.  
  673. }
  674.  
  675.  
  676. if(playerNewPos == 1 && player_pos == 220 ){
  677. PlayerBox(frameBuf[0],50,y,40,10,2);
  678.  
  679. y = y-40;
  680. PlayerBox(frameBuf[0],50,y,40,10,1);
  681. //PlayerBox(frameBuf[0],50,y,40,10,0);
  682.  
  683.  
  684. }
  685.  
  686.  
  687.  
  688. // Flytter player ned
  689. if(playerNewPos == 2 && player_pos == 180 ){
  690. PlayerBox(frameBuf[0],50,y,40,10,2);
  691.  
  692. y = y+40;
  693. PlayerBox(frameBuf[0],50,y,40,10,1);
  694. //PlayerBox(frameBuf[0],50,y,40,10,0);
  695.  
  696. }
  697.  
  698. // Flytter player ned
  699. if(playerNewPos == 2 && player_pos == 220 ){
  700. PlayerBox(frameBuf[0],50,y,40,10,2);
  701.  
  702. y = y+40;
  703. PlayerBox(frameBuf[0],50,y,40,10,1);
  704. //PlayerBox(frameBuf[0],50,y,40,10,0);
  705.  
  706. }
  707. player_pos=y;
  708.  
  709. }
  710.  
  711.  
  712.  
  713. void StartSpil(){
  714. SpilStartet = 1;
  715. led_data=2;
  716. Background(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  717.  
  718. Platform2(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  719. Platform(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  720. OpStribe(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  721. NedStribe(pFrames[dispCtrl.curFrame], dispCtrl.vMode.width, dispCtrl.vMode.height, DEMO_STRIDE);
  722.  
  723.  
  724.  
  725. }
  726.  
  727.  
  728.  
  729.  
  730.  
  731. void Platform2(u8 *frame, u32 width, u32 height, u32 stride){
  732. u32 xcoi, ycoi;
  733. u32 iPixelAddr;
  734. u8 wRed, wBlue, wGreen;
  735.  
  736. wGreen = 255;
  737. wRed = 255;
  738. wBlue = 255;
  739.  
  740. for(xcoi = 0; xcoi < (width*3); xcoi+=3)
  741. {
  742. iPixelAddr = xcoi + 280*stride;
  743. for(ycoi = 270; ycoi < height-200; ycoi++)
  744. {
  745. frame[iPixelAddr] = wGreen;
  746. frame[iPixelAddr + 1] = wBlue;
  747. frame[iPixelAddr + 2] = wRed;
  748.  
  749. iPixelAddr += stride;
  750.  
  751. }
  752. }
  753. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  754. }
  755.  
  756.  
  757.  
  758.  
  759.  
  760.  
  761.  
  762. void Platform(u8 *frame, u32 width, u32 height, u32 stride){
  763.  
  764. u32 xcoi, ycoi;
  765. u32 iPixelAddr;
  766. u8 wRed, wBlue, wGreen;
  767.  
  768. wGreen = 255;
  769. wRed = 255;
  770. wBlue = 255;
  771.  
  772. for(xcoi = 0; xcoi < (width*3); xcoi+=3)
  773. {
  774. iPixelAddr = xcoi + 158*stride;
  775. for(ycoi = 270; ycoi < height-200; ycoi++)
  776. {
  777. frame[iPixelAddr] = wGreen;
  778. frame[iPixelAddr + 1] = wBlue;
  779. frame[iPixelAddr + 2] = wRed;
  780.  
  781. iPixelAddr += stride;
  782.  
  783. }
  784. }
  785. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  786. }
  787.  
  788.  
  789.  
  790. void Background(u8 *frame, u32 width, u32 height, u32 stride)
  791. {
  792. u32 xcoi, ycoi;
  793. u32 iPixelAddr;
  794. u8 wRed, wBlue, wGreen;
  795.  
  796. wGreen = 192;
  797. wRed = 192;
  798. wBlue = 192;
  799.  
  800. for(xcoi = 0; xcoi < (width*3)-1; xcoi+=3)
  801. {
  802. iPixelAddr = xcoi + 165*stride;
  803. for(ycoi = 0; ycoi < height-360; ycoi++)
  804. {
  805. frame[iPixelAddr] = wGreen;
  806. frame[iPixelAddr +1] = wBlue;
  807. frame[iPixelAddr + 2] = wRed;
  808. iPixelAddr += stride;
  809. }
  810. }
  811.  
  812. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  813. }
  814.  
  815.  
  816. void OpStribe(u8 *frame, u32 width, u32 height, u32 stride){
  817.  
  818. u32 xcoi, ycoi;
  819. u32 iPixelAddr;
  820. u8 wRed, wBlue, wGreen;
  821.  
  822. wGreen = 255;
  823. wRed = 255;
  824. wBlue = 255;
  825.  
  826. for(xcoi = 0; xcoi < (width*3); xcoi+=3)
  827. {
  828. iPixelAddr = xcoi + 200*stride;
  829. for(ycoi = 276; ycoi < height-200; ycoi++)
  830. {
  831. frame[iPixelAddr] = wGreen;
  832. frame[iPixelAddr + 1] = wBlue;
  833. frame[iPixelAddr + 2] = wRed;
  834.  
  835. iPixelAddr += stride;
  836.  
  837. }
  838. }
  839. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  840. }
  841.  
  842.  
  843.  
  844. void NedStribe(u8 *frame, u32 width, u32 height, u32 stride){
  845.  
  846. u32 xcoi, ycoi;
  847. u32 iPixelAddr;
  848. u8 wRed, wBlue, wGreen;
  849.  
  850. wGreen = 255;
  851. wRed = 255;
  852. wBlue = 255;
  853.  
  854. for(xcoi = 0; xcoi < (width*3); xcoi+=3)
  855. {
  856. iPixelAddr = xcoi + 240*stride;
  857. for(ycoi = 276; ycoi < height-200; ycoi++)
  858. {
  859. frame[iPixelAddr] = wGreen;
  860. frame[iPixelAddr + 1] = wBlue;
  861. frame[iPixelAddr + 2] = wRed;
  862.  
  863. iPixelAddr += stride;
  864.  
  865. }
  866. }
  867. Xil_DCacheFlushRange((unsigned int) frame, DEMO_MAX_FRAME);
  868. }
  869.  
  870.  
  871.  
  872.  
  873.  
  874.  
  875.  
  876.  
  877.  
  878.  
  879.  
  880.  
  881.  
  882.  
  883.  
  884.  
  885.  
  886.  
  887.  
  888.  
  889.  
  890. void DemoISR(void *callBackRef, void *pVideo)
  891. {
  892. char *data = (char *) callBackRef;
  893. *data = 1; //set fRefresh to 1
  894. }
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!