Subversion Repositories NedoOS

Rev

Rev 2249 | Blame | Compare with Previous | Last modification | View Log | Download

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <intrz80.h>
  4. #include <stdlib.h>
  5. #include <oscalls.h>
  6. #include <../common/terminal.c>
  7. #include <tcp.h>
  8. #include <osfs.h>
  9. #include <ctype.h>
  10. #include <math.h>
  11. //
  12. #define true 1
  13. #define false 0
  14. #define COMMANDLINE 0x0080
  15.  
  16. unsigned int RBR_THR = 0xf8ef;
  17. unsigned int IER = 0xf9ef;
  18. unsigned int IIR_FCR = 0xfaef;
  19. unsigned int LCR = 0xfbef;
  20. unsigned int MCR = 0xfcef;
  21. unsigned int LSR = 0xfdef;
  22. unsigned int MSR = 0xfeef;
  23. unsigned int SR = 0xffef;
  24. unsigned int divider = 1;
  25. unsigned char comType = 0;
  26. unsigned int espType = 32;
  27.  
  28. const unsigned char sendOk[] = "SEND OK";
  29. const unsigned char gotWiFi[] = "WIFI GOT IP";
  30. unsigned char minRating[] = "0000000000";
  31. const unsigned char userAgent[] = " HTTP/1.1\r\nHost: zxart.ee\r\nUser-Agent: Mozilla/4.0 (compatible; MSIE5.01; NedoOS; Radio)\r\n\r\n\0";
  32. const unsigned char cmdlist1[] = "GET /file/id:";
  33. unsigned char userQuery[256] = "/api/export:zxMusic/limit:10/filter:zxMusicId=44816";
  34. unsigned char fileName[] = "radio/player.ovl";
  35. unsigned char appCmd[128] = "player.com ";
  36. unsigned char curPath[128];
  37. unsigned char ver[] = "3.4";
  38.  
  39. unsigned char queryType[64];
  40. unsigned char netbuf[4096];
  41. unsigned char dataBuffer[8192];
  42. unsigned char crlf[2] = {13, 10};
  43. unsigned char formats[4][4] = {"pt3", "pt2", "tfc", "ts"};
  44. unsigned char interfaces[2][8] = {"NedoNET", "ESP-COM"};
  45. unsigned char cmd[256];
  46. unsigned char link[512];
  47. unsigned char toLog[256];
  48. unsigned char queryNum;
  49.  
  50. struct sockaddr_in targetadr;
  51. struct readstructure readStruct;
  52. struct sockaddr_in dnsaddress;
  53.  
  54. unsigned long contLen;
  55. long count;
  56. unsigned char saveFlag, saveBak, rptFlag, netDriver, changedFormat;
  57. unsigned char status, key, curFormat;
  58. union APP_PAGES main_pg;
  59. union APP_PAGES player_pg;
  60. unsigned int loaded;
  61. unsigned int headlng;
  62. unsigned char cutOff = 1;
  63. int remainTime;
  64.  
  65. struct fileStruct
  66. {
  67.   long picId;
  68.   unsigned long fileSize;
  69.   unsigned int picYear;
  70.   unsigned long totalAmount;
  71.   unsigned int curPos;
  72.   unsigned int startBar;
  73.   unsigned int trackInSeconds;
  74.   unsigned int httpErr;
  75.   unsigned char time[16];
  76.   unsigned char picRating[8];
  77.   unsigned char trackName[256];
  78.   unsigned char fileName[256];
  79.   unsigned char authorIds[64];
  80.   unsigned char authorTitle[64];
  81.   unsigned char authorRealName[64];
  82.   unsigned char afn[64];
  83.   unsigned char tfn[64];
  84. } curFileStruct;
  85.  
  86. struct window
  87. {
  88.   unsigned char x;
  89.   unsigned char y;
  90.   unsigned char w;
  91.   unsigned char h;
  92.   unsigned char text;
  93.   unsigned char back;
  94.   unsigned char tittle[80];
  95. } curWin;
  96.  
  97. void writeLog(char *logline)
  98. {
  99.   FILE *LogFile;
  100.   unsigned long fileSize;
  101.  
  102.   LogFile = OS_OPENHANDLE("m:/bin/radio/radio.log", 0x80);
  103.   if (((int)LogFile) & 0xff)
  104.   {
  105.     LogFile = OS_CREATEHANDLE("m:/bin/radio/radio.log", 0x80);
  106.     OS_CLOSEHANDLE(LogFile);
  107.     LogFile = OS_OPENHANDLE("m:/bin/radio/radio.log", 0x80);
  108.   }
  109.  
  110.   fileSize = OS_GETFILESIZE(LogFile);
  111.   OS_SEEKHANDLE(LogFile, fileSize);
  112.   OS_WRITEHANDLE(logline, LogFile, strlen(logline));
  113.   OS_CLOSEHANDLE(LogFile);
  114. }
  115.  
  116. void delay(unsigned long counter)
  117. {
  118.   unsigned long start, finish;
  119.   counter = counter / 20;
  120.   if (counter < 1)
  121.   {
  122.     counter = 1;
  123.   }
  124.   start = time();
  125.   finish = start + counter;
  126.  
  127.   while (start < finish)
  128.   {
  129.     start = time();
  130.   }
  131. }
  132.  
  133. void spaces(unsigned char number)
  134. {
  135.   while (number > 0)
  136.   {
  137.     putchar(' ');
  138.     number--;
  139.   }
  140. }
  141.  
  142. void clearStatus(void)
  143. {
  144.   OS_SETCOLOR(5);
  145.   OS_SETXY(0, 24);
  146.   spaces(79);
  147.   putchar('\r');
  148. }
  149.  
  150. void clearNetbuf(void)
  151. {
  152.   int counter = 0;
  153.   for (counter = 0; counter < sizeof(netbuf); counter++)
  154.   {
  155.     netbuf[counter] = 0;
  156.   }
  157. }
  158.  
  159. void printProgress(const char type)
  160. {
  161.   unsigned char bar, minutes, seconds;
  162.   unsigned char *position;
  163.   long barLenght;
  164.   int timer;
  165.   switch (type)
  166.   {
  167.   case 0: // print empty bar
  168.     OS_SETXY(5, 10);
  169.     OS_SETCOLOR(70);
  170.     printf("%02u:%02u", 0, 0);
  171.     OS_SETXY(14, 10);
  172.     OS_SETCOLOR(71);
  173.     for (bar = 0; bar < 50; bar++)
  174.     {
  175.       putchar(176);
  176.     }
  177.     putchar(' ');
  178.     putchar(' ');
  179.     minutes = atoi(curFileStruct.time);
  180.     position = (strstr(curFileStruct.time, ":")) + 1;
  181.     seconds = atoi(position);
  182.     curFileStruct.trackInSeconds = minutes * 60 + seconds;
  183.     curFileStruct.curPos = 0;
  184.     curFileStruct.startBar = 0;
  185.     break;
  186.   case 1: // print progress bar
  187.  
  188.     OS_SETXY(5, 10);
  189.     OS_SETCOLOR(70);
  190.     timer = floor(curFileStruct.curPos / 60);
  191.     printf("%02u:%02u", timer, (curFileStruct.curPos - (timer * 60)));
  192.  
  193.     barLenght = (curFileStruct.curPos * 50 / curFileStruct.trackInSeconds);
  194.     if (barLenght > 49)
  195.     {
  196.       barLenght = 50;
  197.     }
  198.     OS_SETXY(14 + curFileStruct.startBar, 10);
  199.     OS_SETCOLOR(71);
  200.     for (bar = 0; bar < barLenght - curFileStruct.startBar; bar++)
  201.     {
  202.       putchar(178);
  203.     }
  204.     OS_SETXY(0, 0);
  205.     curFileStruct.startBar = bar;
  206.     break;
  207.   case 2: // print full bar
  208.     OS_SETXY(14, 10);
  209.     OS_SETCOLOR(71);
  210.     for (bar = 0; bar < 50; bar++)
  211.     {
  212.       putchar(178);
  213.     }
  214.     break;
  215.   }
  216. }
  217.  
  218. void printHelp(void)
  219. {
  220.   OS_SETXY(0, 14);
  221.   OS_SETCOLOR(71);
  222.   printf(" [<-] [B] Previous track          [->] [ ] Next track      \r\n");
  223.   printf(" [S]  Stop player                 [R]  Repeat track mode   \r\n");
  224.   printf(" [K]  Toggle saving tracks        [D]  Download track      \r\n");
  225.   printf(" [Q]  Select Query type           [F]  Select tracks format\r\n");
  226.   printf(" [I]  Interface ZXNETUSB/ESP32    [J]  Jump to NNNN file   \r\n");
  227.   printf(" [ESC] Exit to OS                 [M]  Minimal Rating(Q:2,3)\r\n");
  228.   printf("                                                           \r\n");
  229. }
  230.  
  231. void printStatus(void)
  232. {
  233.   OS_SETXY(0, 8);
  234.   OS_SETCOLOR(70);
  235.   printf(" [Q]Query : ");
  236.   OS_SETCOLOR(71);
  237.   printf("%s", queryType);
  238.   printf("  ");
  239.   OS_SETXY(0, 23);
  240.   OS_SETCOLOR(95);
  241.   printf("                                                                                ");
  242.   OS_SETXY(1, 23);
  243.   printf(" [F]Format: ");
  244.   OS_SETCOLOR(94);
  245.   printf("%s", formats[curFormat]);
  246.   OS_SETCOLOR(95);
  247.   printf(" [K]Keep files: ");
  248.   OS_SETCOLOR(94);
  249.   printf("%u", saveFlag);
  250.   OS_SETCOLOR(95);
  251.   printf(" [R]Repeat: ");
  252.   OS_SETCOLOR(94);
  253.   printf("%u", rptFlag);
  254.   OS_SETCOLOR(95);
  255.   printf(" [J]Jump to ");
  256.   printf(" [E]Exit        [%s]", ver);
  257.  
  258.   OS_SETCOLOR(71);
  259.   YIELD();
  260. }
  261.  
  262. void printInfo(void)
  263. {
  264.   BDBOX(30, 2, 50, 6, 71, ' ');
  265.   OS_SETXY(0, 1);
  266.   OS_SETCOLOR(70);
  267.   printf(" #: ");
  268.   OS_SETCOLOR(71);
  269.   printf("%lu", count);
  270.   OS_SETCOLOR(70);
  271.   printf(" ID: ");
  272.   OS_SETCOLOR(71);
  273.   printf("%lu", curFileStruct.picId);
  274.   OS_SETCOLOR(70);
  275.   printf(" Total Tracks: ");
  276.   OS_SETCOLOR(71);
  277.   printf("%lu               \r\n", curFileStruct.totalAmount);
  278.   OS_SETCOLOR(70);
  279.   printf(" RATING: ");
  280.   OS_SETCOLOR(71);
  281.   printf("%s", curFileStruct.picRating);
  282.   OS_SETCOLOR(70);
  283.   printf(" YEAR: ");
  284.   OS_SETCOLOR(71);
  285.   printf("%u", curFileStruct.picYear);
  286.   OS_SETCOLOR(70);
  287.   printf(" DURATION: ");
  288.   OS_SETCOLOR(71);
  289.   printf("%s", curFileStruct.time);
  290.   printf(" \r\n\r\n");
  291.   OS_SETCOLOR(70);
  292.   printf(" AuthorsIDs ");
  293.   OS_SETCOLOR(71);
  294.   printf("%s", curFileStruct.authorIds);
  295.   OS_SETCOLOR(70);
  296.   printf(" Author: ");
  297.   OS_SETCOLOR(71);
  298.   printf("%s", curFileStruct.authorTitle);
  299.   OS_SETCOLOR(70);
  300.   printf(" Real name: ");
  301.   OS_SETCOLOR(71);
  302.   printf("%s", curFileStruct.authorRealName);
  303.   printf(" \r\n\r\n");
  304.   OS_SETCOLOR(69);
  305.   printf("                                                                           \r");
  306.   printf("   TITLE: %s\r\n", curFileStruct.trackName);
  307. }
  308.  
  309. void refreshScreen(void)
  310. {
  311.   OS_CLS(0);
  312.   printInfo();
  313.   printProgress(0);
  314.   printProgress(1);
  315.   printHelp();
  316.   printStatus();
  317. }
  318.  
  319. int pos(unsigned char *s, unsigned char *c, unsigned int n, unsigned int startPos)
  320. {
  321.   unsigned int i, j;
  322.   unsigned int lenC, lenS;
  323.  
  324.   for (lenC = 0; c[lenC]; lenC++)
  325.     ;
  326.   for (lenS = 0; s[lenS]; lenS++)
  327.     ;
  328.  
  329.   for (i = startPos; i <= lenS - lenC; i++)
  330.   {
  331.     for (j = 0; s[i + j] == c[j]; j++)
  332.       ;
  333.  
  334.     if (j - lenC == 1 && i == lenS - lenC && !(n - 1))
  335.       return i;
  336.     if (j == lenC)
  337.       if (n - 1)
  338.         n--;
  339.       else
  340.         return i;
  341.   }
  342.   return -1;
  343. }
  344.  
  345. ///////////////////////////
  346. #include <../common/esp-com.c>
  347. #include <../common/network.c>
  348. //////////////////////////
  349.  
  350. int cutHeader(unsigned int todo)
  351. {
  352.   unsigned char *count1;
  353.  
  354.   curFileStruct.httpErr = httpError();
  355.   if (curFileStruct.httpErr != 200)
  356.   {
  357.     clearStatus();
  358.     printf("HTTP response:[%u]", curFileStruct.httpErr);
  359.     return 0;
  360.   }
  361.   count1 = strstr(netbuf, "Content-Length:");
  362.   if (count1 == NULL)
  363.   {
  364.     clearStatus();
  365.     printf("contLen not found");
  366.     contLen = 0;
  367.     curFileStruct.httpErr = 999; // bad kostil
  368.     return 0;
  369.   }
  370.   contLen = atol(count1 + 15);
  371.   // printf("Content-Length: %lu \n\r", contLen);
  372.  
  373.   count1 = strstr(netbuf, "\r\n\r\n");
  374.   if (count1 == NULL)
  375.   {
  376.     clearStatus();
  377.     printf("end of header not found\r\n");
  378.   }
  379.   else
  380.   {
  381.     headlng = ((unsigned int)count1 - (unsigned int)netbuf + 4);
  382.     // printf("header %u bytes\r\n", headlng);
  383.   }
  384.   return todo - headlng;
  385. }
  386.  
  387. unsigned char inputBox(struct window w, unsigned const char *prefilled)
  388. {
  389.   unsigned char wcount, tempx, tittleStart;
  390.   unsigned char byte, counter;
  391.   w.h++;
  392.   OS_SETXY(w.x, w.y - 1);
  393.   BDBOX(w.x, w.y, w.w + 1, w.h, w.back, 32);
  394.   OS_SETXY(w.x, w.y);
  395.   OS_SETCOLOR(w.text);
  396.   putchar(201);
  397.   for (wcount = 0; wcount < w.w; wcount++)
  398.   {
  399.     putchar(205);
  400.   }
  401.   putchar(187);
  402.   OS_SETXY(w.x, w.y + w.h);
  403.   putchar(200);
  404.   for (wcount = 0; wcount < w.w; wcount++)
  405.   {
  406.     putchar(205);
  407.   }
  408.   putchar(188);
  409.  
  410.   tempx = w.x + w.w + 1;
  411.   for (wcount = 1; wcount < w.h; wcount++)
  412.   {
  413.     OS_SETXY(w.x, w.y + wcount);
  414.     putchar(186);
  415.     OS_SETXY(tempx, w.y + wcount);
  416.     putchar(186);
  417.   }
  418.   tittleStart = w.x + (w.w / 2) - (strlen(w.tittle) / 2);
  419.   OS_SETXY(tittleStart, w.y);
  420.   printf("[%s]", w.tittle);
  421.   OS_SETXY(w.x + 1, w.y + 1);
  422.   OS_SETCOLOR(w.back);
  423.   putchar(219);
  424.  
  425.   cmd[0] = 0;
  426.  
  427.   counter = strlen(prefilled);
  428.   if (counter != 0)
  429.   {
  430.     strcpy(cmd, prefilled);
  431.     goto skipKeys;
  432.   }
  433.  
  434.   do
  435.   {
  436.     byte = OS_GETKEY();
  437.     if (byte != 0)
  438.     {
  439.       switch (byte)
  440.       {
  441.       case 0x08:
  442.         if (counter > 0)
  443.         {
  444.           counter--;
  445.           cmd[counter] = 0;
  446.         }
  447.         break;
  448.       case 0x0d:
  449.  
  450.         if (counter == 0)
  451.         {
  452.           return false;
  453.         }
  454.         else
  455.         {
  456.           return true;
  457.         }
  458.  
  459.       case 31:
  460.         break;
  461.       case 250:
  462.         break;
  463.       case 249:
  464.         break;
  465.       case 248:
  466.         break;
  467.       case 251: // Right
  468.         break;
  469.       case 252: // Del
  470.         OS_SETXY(w.x + 1, w.y + 1);
  471.         spaces(counter + 1);
  472.         cmd[0] = 0;
  473.         counter = 0;
  474.         break;
  475.       case 27:
  476.         cmd[0] = 0;
  477.         return false;
  478.       default:
  479.         if (counter < w.w - 1)
  480.         {
  481.           cmd[counter] = byte;
  482.           counter++;
  483.           cmd[counter] = 0;
  484.         }
  485.         break;
  486.       }
  487.     skipKeys:
  488.       OS_SETXY(w.x + 1, w.y + 1);
  489.       printf("%s", cmd);
  490.       putchar(219);
  491.       if (byte == 0x08)
  492.       {
  493.         putchar(' ');
  494.       }
  495.     }
  496.     YIELD();
  497.   } while (42);
  498.   return false;
  499. }
  500.  
  501. char *str_replace(char *dst, int num, const char *str, const char *orig, const char *rep)
  502. {
  503.   const char *ptr;
  504.   size_t len1 = strlen(orig);
  505.   size_t len2 = strlen(rep);
  506.   char *tmp = dst;
  507.  
  508.   num -= 1;
  509.   while ((ptr = strstr(str, orig)) != NULL)
  510.   {
  511.     num -= (ptr - str) + len2;
  512.     if (num < 1)
  513.       break;
  514.  
  515.     strncpy(dst, str, (size_t)(ptr - str));
  516.     dst += ptr - str;
  517.     strncpy(dst, rep, len2);
  518.     dst += len2;
  519.     str = ptr + len1;
  520.   }
  521.  
  522.   for (; (*dst = *str) && (num > 0); --num)
  523.   {
  524.     ++dst;
  525.     ++str;
  526.   }
  527.   return tmp;
  528. }
  529.  
  530. const char *parseJson(unsigned char *property)
  531. {
  532.   unsigned int w, lng, lngp1, findEnd, listPos;
  533.   unsigned char terminator;
  534.   int n;
  535.   n = -1;
  536.   netbuf[0] = 0;
  537.   n = pos(dataBuffer, property, 1, 0);
  538.   if (n == -1)
  539.   {
  540.     strcpy(netbuf, "-");
  541.     return netbuf;
  542.   }
  543.   lng = n - 1 + strlen(property);
  544.   if (dataBuffer[lng] == ':')
  545.   {
  546.     terminator = '\0';
  547.   }
  548.   if (dataBuffer[lng] == '\"')
  549.   {
  550.     terminator = '\"';
  551.   }
  552.   if (dataBuffer[lng] == '[')
  553.   {
  554.     terminator = ']';
  555.   }
  556.  
  557.   findEnd = 1;
  558.   lngp1 = lng + 1;
  559.  
  560.   while (42)
  561.   {
  562.  
  563.     if ((dataBuffer[lngp1 + findEnd] == ','))
  564.     {
  565.       if (terminator == '\0')
  566.       {
  567.         break;
  568.       }
  569.       if ((dataBuffer[lng + findEnd] == terminator))
  570.       {
  571.         findEnd--;
  572.         break;
  573.       }
  574.     }
  575.     findEnd++;
  576.   }
  577.   listPos = 0;
  578.   for (w = lngp1; w < findEnd + lngp1; w++)
  579.   {
  580.     netbuf[listPos] = dataBuffer[w];
  581.     listPos++;
  582.   }
  583.   netbuf[listPos] = 0;
  584.   return netbuf;
  585. }
  586.  
  587. void convert866(void)
  588. {
  589.   unsigned int lng, targetPos, w, q = 0;
  590.   unsigned char buffer[8], one, two;
  591.   unsigned int decVal;
  592.   lng = strlen(netbuf);
  593.   targetPos = lng + 1;
  594.  
  595.   while (q < lng)
  596.   {
  597.     one = netbuf[q];
  598.     two = netbuf[q + 1];
  599.     if (one == 92 && two == 117)
  600.     {
  601.       q = q + 2;
  602.       for (w = 0; w < 4; w++)
  603.       {
  604.         buffer[w] = netbuf[q + w];
  605.       }
  606.       q = q + 4;
  607.       buffer[4] = '\0';
  608.       decVal = (unsigned int)strtol(buffer, NULL, 16);
  609.  
  610.       if (decVal < 1088)
  611.       {
  612.         decVal = decVal - 912;
  613.       }
  614.       if (decVal > 1087)
  615.       {
  616.         decVal = decVal - 864;
  617.       }
  618.       if (decVal == 1025)
  619.       {
  620.         decVal = 240;
  621.       }
  622.       if (decVal == 1105)
  623.       {
  624.         decVal = 241;
  625.       }
  626.       netbuf[targetPos] = decVal;
  627.     }
  628.     else
  629.     {
  630.       netbuf[targetPos] = netbuf[q];
  631.       q++;
  632.     }
  633.     targetPos++;
  634.   }
  635.   netbuf[targetPos] = '\0';
  636.  
  637.   for (w = lng + 1; w < targetPos + 1; w++)
  638.   {
  639.     netbuf[w - lng - 1] = netbuf[w];
  640.   }
  641. }
  642.  
  643. void nameRepair(unsigned char *pfn, unsigned int tfnSize)
  644. {
  645.   str_replace(pfn, tfnSize, pfn, "\\", "_");
  646.   str_replace(pfn, tfnSize, pfn, "/", "_");
  647.   str_replace(pfn, tfnSize, pfn, ":", "_");
  648.   str_replace(pfn, tfnSize, pfn, "*", "_");
  649.   str_replace(pfn, tfnSize, pfn, "?", "_");
  650.   str_replace(pfn, tfnSize, pfn, "<", "_");
  651.   str_replace(pfn, tfnSize, pfn, ">", "_");
  652.   str_replace(pfn, tfnSize, pfn, "|", "_");
  653.   str_replace(pfn, tfnSize, pfn, " ", "_");
  654.   str_replace(pfn, tfnSize, pfn, "&#039;", "'");
  655.   str_replace(pfn, tfnSize, pfn, "&amp;", "&");
  656.   str_replace(pfn, tfnSize, pfn, "&quot;", "'");
  657.   str_replace(pfn, tfnSize, pfn, "&gt;", ")");
  658.   str_replace(pfn, tfnSize, pfn, "&lt;", "(");
  659.   str_replace(pfn, tfnSize, pfn, "\"", "'");
  660. }
  661.  
  662. void stringRepair(unsigned char *pfn, unsigned int tSize)
  663. {
  664.   str_replace(pfn, tSize, pfn, "&#039;", "'");
  665.   str_replace(pfn, tSize, pfn, "&amp;", "&");
  666.   str_replace(pfn, tSize, pfn, "&gt;", ">");
  667.   str_replace(pfn, tSize, pfn, "&lt;", "<");
  668.   str_replace(pfn, tSize, pfn, "&quot;", "\"");
  669.   str_replace(pfn, tSize, pfn, "\\/", "/");
  670. }
  671.  
  672. void ncReplace(void)
  673. {
  674.   unsigned char len;
  675.   for (len = 0; len < strlen(curFileStruct.afn); len++)
  676.   {
  677.     if (curFileStruct.afn[len] < ' ')
  678.     {
  679.       curFileStruct.afn[len] = '_';
  680.     }
  681.   }
  682.  
  683.   for (len = 0; len < strlen(curFileStruct.tfn); len++)
  684.   {
  685.     if (curFileStruct.tfn[len] < ' ')
  686.     {
  687.       curFileStruct.tfn[len] = '_';
  688.     }
  689.   }
  690. }
  691.  
  692. unsigned char saveBuf(unsigned long fileId, unsigned char operation, unsigned int sizeOfBuf)
  693. {
  694.   FILE *fp2;
  695.   unsigned long fileSize;
  696.   unsigned char afnSize, tfnSize;
  697.   unsigned char fileIdChar[10];
  698.  
  699.   if (operation == 00)
  700.   {
  701.  
  702.     if (saveFlag == 0)
  703.     {
  704.       sprintf(curFileStruct.fileName, "temp.%s", formats[curFormat]);
  705.     }
  706.     else
  707.     {
  708.       afnSize = sizeof(curFileStruct.afn) - 1;
  709.       tfnSize = sizeof(curFileStruct.tfn) - 1;
  710.  
  711.       strcpy(curFileStruct.afn, curFileStruct.authorTitle);
  712.       nameRepair(curFileStruct.afn, afnSize);
  713.       strcpy(curFileStruct.tfn, curFileStruct.trackName);
  714.       nameRepair(curFileStruct.tfn, tfnSize);
  715.       sprintf(curFileStruct.fileName, "%s-%s.%s", curFileStruct.afn, curFileStruct.tfn, formats[curFormat]);
  716.       ncReplace();
  717.  
  718.       if (strlen(curFileStruct.fileName) > 63)
  719.       {
  720.         sprintf(fileIdChar, "-%ld", fileId);
  721.         str_replace(curFileStruct.fileName, sizeof(curFileStruct.fileName) - 1, curFileStruct.fileName, fileIdChar, "");
  722.         curFileStruct.fileName[50] = '\0';
  723.         strcat(curFileStruct.fileName, fileIdChar);
  724.         strcat(curFileStruct.fileName, formats[curFormat]);
  725.       }
  726.     }
  727.     OS_SETSYSDRV();
  728.     OS_MKDIR("../downloads/radio"); // Create if not exist
  729.     OS_CHDIR("../downloads/radio");
  730.     fp2 = OS_CREATEHANDLE(curFileStruct.fileName, 0x80);
  731.     if (((int)fp2) & 0xff)
  732.     {
  733.       clearStatus();
  734.       printf("%s creating error. Check for  downloads\\radio folder.", curFileStruct.fileName);
  735.       getchar();
  736.       exit(0);
  737.     }
  738.     OS_CLOSEHANDLE(fp2);
  739.     return 0;
  740.   }
  741.  
  742.   if (operation == 01)
  743.   {
  744.     fp2 = OS_OPENHANDLE(curFileStruct.fileName, 0x80);
  745.     if (((int)fp2) & 0xff)
  746.     {
  747.  
  748.       clearStatus();
  749.       printf("%s opening error.", curFileStruct.fileName);
  750.       exit(0);
  751.     }
  752.     fileSize = OS_GETFILESIZE(fp2);
  753.     OS_SEEKHANDLE(fp2, fileSize);
  754.     OS_WRITEHANDLE(netbuf + headlng, fp2, sizeOfBuf);
  755.     OS_CLOSEHANDLE(fp2);
  756.     return 0;
  757.   }
  758.  
  759.   if (operation == 02)
  760.   {
  761.     OS_CLOSEHANDLE(fp2);
  762.     return 0;
  763.   }
  764.  
  765.   return 0;
  766. }
  767.  
  768. char getDataNet(void)
  769. {
  770.   unsigned int todo, downloaded;
  771.   unsigned char socket, firstPacket;
  772.   clearStatus();
  773.   socket = OpenSock(AF_INET, SOCK_STREAM);
  774.   testOperation("OS_NETSOCKET", socket);
  775.  
  776.   todo = netConnect(socket, 2);
  777.   testOperation("OS_NETCONNECT", todo);
  778.  
  779.   todo = tcpSend(socket, (unsigned int)&netbuf, strlen(netbuf), 2);
  780.   testOperation("OS_WIZNETWRITE", todo);
  781.  
  782.   downloaded = 0;
  783.   firstPacket = true;
  784.   do
  785.   {
  786.     headlng = 0;
  787.     todo = tcpRead(socket, 2);
  788.     clearStatus();
  789.     testOperation("OS_WIZNETREAD", todo);
  790.     if (todo == 0)
  791.     {
  792.       break;
  793.     }
  794.     if (firstPacket)
  795.     {
  796.       todo = cutHeader(todo);
  797.       firstPacket = false;
  798.       if (curFileStruct.httpErr != 200)
  799.       {
  800.         netShutDown(socket, 1);
  801.         return false;
  802.       }
  803.     }
  804.  
  805.     if (downloaded + todo > sizeof(dataBuffer - 1))
  806.     {
  807.       clearStatus();
  808.       printf("dataBuffer overrun...");
  809.       getchar();
  810.       break;
  811.     }
  812.     memcpy(dataBuffer + downloaded, netbuf + headlng, todo);
  813.     downloaded = downloaded + todo;
  814.   } while (downloaded < contLen);
  815.   netShutDown(socket, 1);
  816.   return true;
  817. }
  818.  
  819. unsigned int getDataEsp(void)
  820. {
  821.   unsigned char firstPacket;
  822.   unsigned long downloaded;
  823.   unsigned char byte, countl = 0;
  824.   unsigned int todo, sizeLink;
  825.   unsigned char *count1;
  826.  
  827.   strcpy(link, netbuf);
  828.   sizeLink = strlen(link);
  829.   do
  830.   {
  831.     sendcommand("AT+CIPSTART=\"TCP\",\"zxart.ee\",80");
  832.     getAnswer2(); // CONNECT or ERROR or link is not valid
  833.     count1 = strstr(netbuf, "CONNECT");
  834.   } while (count1 == NULL);
  835.  
  836.   getAnswer2();                                   // OK
  837.   sprintf(netbuf, "AT+CIPSEND=%u", sizeLink + 2); // second CRLF in send command
  838.   sendcommand(netbuf);
  839.   getAnswer2();
  840.   do
  841.   {
  842.     byte = uart_readBlock();
  843.     // putchar(byte);
  844.   } while (byte != '>');
  845.   sendcommand(link);
  846.   countl = 0;
  847.   do
  848.   {
  849.     byte = uart_readBlock();
  850.     if (byte == sendOk[countl])
  851.     {
  852.       countl++;
  853.     }
  854.     else
  855.     {
  856.       countl = 0;
  857.     }
  858.   } while (countl < strlen(sendOk));
  859.   uart_readBlock(); // CR
  860.   uart_readBlock(); // LF
  861.   downloaded = 0;
  862.   firstPacket = true;
  863.   do
  864.   {
  865.     headlng = 0;
  866.     todo = recvHead();
  867.     getdataEsp(todo); // Requested size
  868.     if (firstPacket)
  869.     {
  870.       todo = cutHeader(todo);
  871.       firstPacket = false;
  872.       if (curFileStruct.httpErr != 200)
  873.       {
  874.         sendcommand("AT+CIPCLOSE");
  875.         getAnswer2(); // CLOSED
  876.         getAnswer2(); // OK
  877.         return false;
  878.       }
  879.     }
  880.     memcpy(dataBuffer + downloaded, netbuf + headlng, todo);
  881.     downloaded = downloaded + todo;
  882.   } while (downloaded < contLen);
  883.   sendcommand("AT+CIPCLOSE");
  884.   getAnswer2(); // CLOSED
  885.   getAnswer2(); // OK
  886.   return true;
  887. }
  888.  
  889. long processJson(unsigned long startPos, unsigned char limit, unsigned char queryNum)
  890. {
  891.   FILE *fp3;
  892.   unsigned int tSize;
  893.   unsigned char *countl, result;
  894.   clearStatus();
  895.   printf("Getting data(%u)...", queryNum);
  896.  
  897.   switch (queryNum)
  898.   {
  899.   case 0:
  900.     sprintf(netbuf, "GET /api/export:zxMusic/limit:%u/start:%lu/filter:zxMusicFormat=%s/order:date,desc%s", limit, startPos, formats[curFormat], userAgent);
  901.     break;
  902.   case 1:
  903.     startPos = 0;
  904.     sprintf(netbuf, "GET /api/types:zxMusic/export:zxMusic/language:eng/limit:%u/start:%lu/order:votes,rand/filter:zxMusicMinRating=%s;zxMusicFormat=%s%s", limit, startPos, minRating, formats[curFormat], userAgent);
  905.     break;
  906.   case 2:
  907.     startPos = 0;
  908.     sprintf(netbuf, "GET /api/types:zxMusic/export:zxMusic/language:eng/limit:%u/start:%lu/order:rand/filter:zxMusicMinRating=%s;zxMusicFormat=%s%s", limit, startPos, minRating, formats[curFormat], userAgent);
  909.     break;
  910.  
  911.   case 3:
  912.     fp3 = OS_OPENHANDLE("../ini/user.que", 0x80);
  913.     if (((int)fp3) & 0xff)
  914.     {
  915.       fp3 = OS_CREATEHANDLE("../ini/user.que", 0x80);
  916.       OS_WRITEHANDLE(userQuery, fp3, sizeof(userQuery));
  917.       OS_CLOSEHANDLE(fp3);
  918.       fp3 = OS_OPENHANDLE("../ini/user.que", 0x80);
  919.     }
  920.     OS_READHANDLE(userQuery, fp3, sizeof(userQuery));
  921.     OS_CLOSEHANDLE(fp3);
  922.     sprintf(netbuf, "GET /api/limit:%u/start:%lu%s%s", limit, startPos, userQuery, userAgent);
  923.     break;
  924.   case 99:
  925.     sprintf(netbuf, "GET /jsonElementData/elementId:%lu%s", startPos, userAgent);
  926.     break;
  927.   }
  928.  
  929.   switch (netDriver)
  930.   {
  931.   case 0:
  932.     result = getDataNet();
  933.     break;
  934.   case 1:
  935.     result = getDataEsp();
  936.     break;
  937.   }
  938.  
  939.   if (!result)
  940.   {
  941.     return -1;
  942.   }
  943.  
  944.   clearStatus();
  945.   printf("Processing data (%u)...", queryNum);
  946.  
  947.   countl = strstr(dataBuffer, "responseStatus\":\"success");
  948.   if (countl == NULL)
  949.   {
  950.     OS_CLS(0);
  951.     OS_SETCOLOR(66);
  952.     puts("Bad responseStatus - dataBuffer[]:");
  953.     puts(dataBuffer);
  954.     puts("---------------");
  955.     printf("PROCESS JSON: [ERROR: Bad responseStatus.] [Query:%u] [Track:%lu]\r\n", queryNum, startPos);
  956.     YIELD();
  957.     getchar();
  958.     return -1;
  959.   }
  960.   countl = strstr(dataBuffer, "\"id\":");
  961.   if (countl == NULL)
  962.   {
  963.     parseJson("\"totalAmount\":");
  964.  
  965.     if (atol(netbuf) == 0)
  966.     {
  967.       return -3;
  968.     }
  969.  
  970.     if (netbuf[0] != '-')
  971.     {
  972.       return -4;
  973.     }
  974.  
  975.     OS_CLS(0);
  976.     OS_SETCOLOR(66);
  977.     puts("ID not found - dataBuffer[]:");
  978.     puts(dataBuffer);
  979.     puts("---------------");
  980.     printf("PROCESS JSON: [ERROR: ID not found] [Query:%u] [Track:%lu]", queryNum, startPos);
  981.     YIELD();
  982.     getchar();
  983.     return -2;
  984.   }
  985.   if (queryNum < 4)
  986.   {
  987.     netbuf[0] = '\0';
  988.     parseJson("\"id\":");
  989.     curFileStruct.picId = atol(netbuf);
  990.     parseJson(",\"title\":\"");
  991.     convert866();
  992.     strcpy(curFileStruct.trackName, netbuf);
  993.  
  994.     tSize = sizeof(curFileStruct.trackName);
  995.     stringRepair(curFileStruct.trackName, tSize);
  996.  
  997.     parseJson("\"rating\":\"");
  998.     strcpy(curFileStruct.picRating, netbuf);
  999.     parseJson("\"year\":\"");
  1000.     curFileStruct.picYear = atoi(netbuf);
  1001.     parseJson("\"totalAmount\":");
  1002.     curFileStruct.totalAmount = atol(netbuf);
  1003.     parseJson("\"time\":\"");
  1004.     strcpy(curFileStruct.time, netbuf);
  1005.     parseJson("\"authorIds\":[");
  1006.     strcpy(curFileStruct.authorIds, netbuf);
  1007.   }
  1008.   if (queryNum == 99)
  1009.   {
  1010.     parseJson(",\"title\":\"");
  1011.     convert866();
  1012.     strcpy(curFileStruct.authorTitle, netbuf);
  1013.     parseJson(",\"realName\":\"");
  1014.     convert866();
  1015.     strcpy(curFileStruct.authorRealName, netbuf);
  1016.   }
  1017.   return curFileStruct.picId;
  1018. }
  1019. /*
  1020. unsigned char getTrack2(unsigned long fileId)
  1021. {
  1022.   int todo;
  1023.   char socket;
  1024.   unsigned int packSize = 2000;
  1025.   unsigned long downloaded, firstPacket;
  1026.   unsigned char try = 0, byte = 0;
  1027.   unsigned int countl;
  1028.   unsigned char *count1;
  1029.   clearStatus();
  1030.   printf("Getting track...");
  1031.   sprintf(netbuf, "GET /file/id:%lu%s", fileId, userAgent);
  1032.   if (netDriver == 0)
  1033.   {
  1034.     socket = OpenSock(AF_INET, SOCK_STREAM);
  1035.     clearStatus();
  1036.     testOperation("OS_NETSOCKET", socket);
  1037.  
  1038.     todo = netConnect(socket, 10);
  1039.     testOperation("OS_NETCONNECT", todo);
  1040.  
  1041.     todo = tcpSend(socket, (unsigned int)&netbuf, strlen(netbuf), 10);
  1042.     testOperation("OS_WIZNETWRITE", todo);
  1043.     saveBuf(curFileStruct.picId, 00, 0);
  1044.     downloaded = 0;
  1045.     firstPacket = true;
  1046.     do
  1047.     {
  1048.       headlng = 0;
  1049.       // clearNetbuf();
  1050.       todo = tcpRead(socket, 10);
  1051.       testOperation("OS_WIZNETREAD", todo);
  1052.  
  1053.       if (todo == 0)
  1054.       {
  1055.         break;
  1056.       }
  1057.  
  1058.       if (firstPacket)
  1059.       {
  1060.         todo = cutHeader(todo);
  1061.         firstPacket = false;
  1062.         if (curFileStruct.httpErr != 200)
  1063.         {
  1064.           netShutDown(socket, 1);
  1065.           return false;
  1066.         }
  1067.       }
  1068.       saveBuf(curFileStruct.picId, 01, todo);
  1069.       downloaded = downloaded + todo;
  1070.     } while (downloaded < contLen);
  1071.     netShutDown(socket, 0);
  1072.   }
  1073.   else
  1074.   {
  1075.     strcpy(link, netbuf);
  1076.     saveBuf(curFileStruct.picId, 00, 0);
  1077.     do
  1078.     {
  1079.       sendcommand("AT+CIPSTART=\"TCP\",\"zxart.ee\",80");
  1080.       getAnswer2(); // CONNECT or ERROR or link is not valid
  1081.       count1 = strstr(netbuf, "CONNECT");
  1082.     } while (count1 == NULL);
  1083.  
  1084.     getAnswer2(); // OK
  1085.  
  1086.     sprintf(cmd, "AT+CIPSEND=%u", strlen(link) + 2); // second CRLF in send command
  1087.     sendcommand(cmd);
  1088.     getAnswer2();
  1089.  
  1090.     do
  1091.     {
  1092.       byte = uart_readBlock();
  1093.       // putchar(byte);
  1094.     } while (byte != '>');
  1095.     sendcommand(link);
  1096.     countl = 0;
  1097.  
  1098.     do
  1099.     {
  1100.       byte = uart_readBlock();
  1101.       if (byte == sendOk[countl])
  1102.       {
  1103.         countl++;
  1104.       }
  1105.       else
  1106.       {
  1107.         countl = 0;
  1108.       }
  1109.     } while (countl < strlen(sendOk));
  1110.     uart_readBlock(); // CR
  1111.     uart_readBlock(); // LF
  1112.     downloaded = 0;
  1113.     firstPacket = true;
  1114.     do
  1115.     {
  1116.       headlng = 0;
  1117.       todo = recvHead();
  1118.       getdataEsp(todo); // Requested size
  1119.       if (firstPacket)
  1120.       {
  1121.         todo = cutHeader(todo);
  1122.         firstPacket = false;
  1123.       }
  1124.       downloaded = downloaded + todo;
  1125.       saveBuf(curFileStruct.picId, 01, todo);
  1126.     } while (downloaded < contLen);
  1127.     sendcommand("AT+CIPCLOSE");
  1128.     getAnswer2(); // CLOSED
  1129.     getAnswer2(); // OK
  1130.     saveBuf(curFileStruct.picId, 02, 0);
  1131.   }
  1132.   return true;
  1133. }
  1134. */
  1135. unsigned char getTrack2Net(unsigned long fileId)
  1136. {
  1137.   int todo;
  1138.   char socket;
  1139.   unsigned int packSize = 2000;
  1140.   unsigned long downloaded, firstPacket;
  1141.   unsigned char try = 0, byte = 0;
  1142.   clearStatus();
  1143.   printf("Getting track...");
  1144.   sprintf(netbuf, "GET /file/id:%lu%s", fileId, userAgent);
  1145.   socket = OpenSock(AF_INET, SOCK_STREAM);
  1146.   clearStatus();
  1147.   testOperation("OS_NETSOCKET", socket);
  1148.  
  1149.   todo = netConnect(socket, 10);
  1150.   testOperation("OS_NETCONNECT", todo);
  1151.  
  1152.   todo = tcpSend(socket, (unsigned int)&netbuf, strlen(netbuf), 10);
  1153.   testOperation("OS_WIZNETWRITE", todo);
  1154.   saveBuf(curFileStruct.picId, 00, 0);
  1155.   downloaded = 0;
  1156.   firstPacket = true;
  1157.   do
  1158.   {
  1159.     headlng = 0;
  1160.     // clearNetbuf();
  1161.     todo = tcpRead(socket, 10);
  1162.     testOperation("OS_WIZNETREAD", todo);
  1163.  
  1164.     if (todo == 0)
  1165.     {
  1166.       break;
  1167.     }
  1168.  
  1169.     if (firstPacket)
  1170.     {
  1171.       todo = cutHeader(todo);
  1172.       firstPacket = false;
  1173.       if (curFileStruct.httpErr != 200)
  1174.       {
  1175.         netShutDown(socket, 1);
  1176.         return false;
  1177.       }
  1178.     }
  1179.     saveBuf(curFileStruct.picId, 01, todo);
  1180.     downloaded = downloaded + todo;
  1181.   } while (downloaded < contLen);
  1182.   netShutDown(socket, 0);
  1183.   return true;
  1184. }
  1185.  
  1186. unsigned char getTrack2Esp(unsigned long fileId)
  1187. {
  1188.   int todo;
  1189.   unsigned int packSize = 2000;
  1190.   unsigned long downloaded, firstPacket;
  1191.   unsigned char try = 0, byte = 0;
  1192.   unsigned int countl;
  1193.   unsigned char *count1;
  1194.   clearStatus();
  1195.   printf("Getting track...");
  1196.   sprintf(netbuf, "GET /file/id:%lu%s", fileId, userAgent);
  1197.   strcpy(link, netbuf);
  1198.   saveBuf(curFileStruct.picId, 00, 0);
  1199.   do
  1200.   {
  1201.     sendcommand("AT+CIPSTART=\"TCP\",\"zxart.ee\",80");
  1202.     getAnswer2(); // CONNECT or ERROR or link is not valid
  1203.     count1 = strstr(netbuf, "CONNECT");
  1204.   } while (count1 == NULL);
  1205.  
  1206.   getAnswer2(); // OK
  1207.  
  1208.   sprintf(cmd, "AT+CIPSEND=%u", strlen(link) + 2); // second CRLF in send command
  1209.   sendcommand(cmd);
  1210.   getAnswer2();
  1211.  
  1212.   do
  1213.   {
  1214.     byte = uart_readBlock();
  1215.     // putchar(byte);
  1216.   } while (byte != '>');
  1217.   sendcommand(link);
  1218.   countl = 0;
  1219.  
  1220.   do
  1221.   {
  1222.     byte = uart_readBlock();
  1223.     if (byte == sendOk[countl])
  1224.     {
  1225.       countl++;
  1226.     }
  1227.     else
  1228.     {
  1229.       countl = 0;
  1230.     }
  1231.   } while (countl < strlen(sendOk));
  1232.   uart_readBlock(); // CR
  1233.   uart_readBlock(); // LF
  1234.   downloaded = 0;
  1235.   firstPacket = true;
  1236.   do
  1237.   {
  1238.     headlng = 0;
  1239.     todo = recvHead();
  1240.     getdataEsp(todo); // Requested size
  1241.     if (firstPacket)
  1242.     {
  1243.       todo = cutHeader(todo);
  1244.       firstPacket = false;
  1245.       if (curFileStruct.httpErr != 200)
  1246.       {
  1247.         sendcommand("AT+CIPCLOSE");
  1248.         getAnswer2(); // CLOSED
  1249.         getAnswer2(); // OK
  1250.         return false;
  1251.       }
  1252.     }
  1253.     downloaded = downloaded + todo;
  1254.     saveBuf(curFileStruct.picId, 01, todo);
  1255.   } while (downloaded < contLen);
  1256.   sendcommand("AT+CIPCLOSE");
  1257.   getAnswer2(); // CLOSED
  1258.   getAnswer2(); // OK
  1259.   saveBuf(curFileStruct.picId, 02, 0);
  1260.   return true;
  1261. }
  1262.  
  1263. int getTrack3(long iddqd)
  1264. {
  1265.   int errn;
  1266.   switch (netDriver)
  1267.   {
  1268.   case 0:
  1269.     errn = getTrack2Net(iddqd);
  1270.     break;
  1271.   case 1:
  1272.     errn = getTrack2Esp(iddqd);
  1273.     break;
  1274.   }
  1275.  
  1276.   if (errn < 0)
  1277.   {
  1278.     clearStatus();
  1279.     printf("[%u]Error getting track, next please(%ld)...", curFileStruct.httpErr, errn);
  1280.   }
  1281.   return errn;
  1282. }
  1283.  
  1284. unsigned char runPlayer(void)
  1285. {
  1286.   FILE *fp2;
  1287.   unsigned long playerSize, loaded, loop;
  1288.   unsigned char pgbak;
  1289.   clearStatus();
  1290.   printf("Running player...");
  1291.   sprintf(appCmd, "player.com %s", curFileStruct.fileName);
  1292.   player_pg.l = OS_GETMAINPAGES();
  1293.   pgbak = main_pg.pgs.window_3;
  1294.   loaded = 0;
  1295.   loop = 0;
  1296.   OS_GETPATH((unsigned int)&curPath);
  1297.   OS_SETSYSDRV();
  1298.   fp2 = OS_OPENHANDLE(fileName, 0x80);
  1299.   if (((int)fp2) & 0xff)
  1300.   {
  1301.     clearStatus();
  1302.     printf("%s", fileName);
  1303.     printf(" not found.");
  1304.     exit(0);
  1305.   }
  1306.   playerSize = OS_GETFILESIZE(fp2);
  1307.   OS_CHDIR(curPath);
  1308.   OS_NEWAPP((unsigned int)&player_pg);
  1309.   SETPG32KHIGH(player_pg.pgs.window_3);
  1310.   memcpy((char *)(0xC080), &appCmd, sizeof(appCmd));
  1311.  
  1312.   do
  1313.   {
  1314.     loaded = OS_READHANDLE(dataBuffer, fp2, sizeof(dataBuffer));
  1315.     memcpy((char *)(0xC100 + loop), &dataBuffer, loaded);
  1316.     loop = loop + loaded;
  1317.   } while (loop < playerSize);
  1318.  
  1319.   OS_CLOSEHANDLE(fp2);
  1320.   SETPG32KHIGH(pgbak);
  1321.   OS_RUNAPP(player_pg.pgs.pId);
  1322.  
  1323.   return player_pg.pgs.pId;
  1324. }
  1325.  
  1326. long trackSelector(unsigned char mode)
  1327. {
  1328.   switch (mode)
  1329.   {
  1330.   case 0: // Next track
  1331.     count++;
  1332.     if (count > curFileStruct.totalAmount - 1)
  1333.     {
  1334.       count = 0;
  1335.     }
  1336.     break;
  1337.   case 1: // Prev. track
  1338.     count--;
  1339.     if (count < 0)
  1340.     {
  1341.       count = curFileStruct.totalAmount - 1;
  1342.     }
  1343.     break;
  1344.   }
  1345.   return count;
  1346. }
  1347.  
  1348. unsigned char testPlayer(void)
  1349. {
  1350.   union APP_PAGES player2_pg;
  1351.   player2_pg.l = OS_GETAPPMAINPAGES(player_pg.pgs.pId);
  1352.   if (errno == 0)
  1353.   {
  1354.     return 1;
  1355.   }
  1356.   else
  1357.   {
  1358.     return 0;
  1359.   }
  1360. }
  1361.  
  1362. void infoBox(struct window w, const char *message)
  1363. {
  1364.   unsigned char wcount, tempx, tittleStart;
  1365.  
  1366.   w.h++;
  1367.   OS_SETXY(w.x, w.y - 1);
  1368.   BDBOX(w.x, w.y, w.w + 1, w.h, w.back, 32);
  1369.   OS_SETXY(w.x, w.y);
  1370.   OS_SETCOLOR(w.text);
  1371.   putchar(201);
  1372.   for (wcount = 0; wcount < w.w; wcount++)
  1373.   {
  1374.     putchar(205);
  1375.   }
  1376.   putchar(187);
  1377.   OS_SETXY(w.x, w.y + w.h);
  1378.   putchar(200);
  1379.   for (wcount = 0; wcount < w.w; wcount++)
  1380.   {
  1381.     putchar(205);
  1382.   }
  1383.   putchar(188);
  1384.  
  1385.   tempx = w.x + w.w + 1;
  1386.   for (wcount = 1; wcount < w.h; wcount++)
  1387.   {
  1388.     OS_SETXY(w.x, w.y + wcount);
  1389.     putchar(186);
  1390.     OS_SETXY(tempx, w.y + wcount);
  1391.     putchar(186);
  1392.   }
  1393.   tittleStart = w.x + (w.w / 2) - (strlen(w.tittle) / 2);
  1394.   OS_SETXY(tittleStart, w.y);
  1395.   printf("[%s]", w.tittle);
  1396.  
  1397.   OS_SETXY(w.x + 1, w.y + 1);
  1398.   OS_SETCOLOR(w.back);
  1399.   tittleStart = w.x + (w.w / 2) - (strlen(message) / 2);
  1400.   OS_SETXY(tittleStart, w.y + 1);
  1401.   printf("%s", message);
  1402. }
  1403.  
  1404. /*
  1405. char optionsMenu(void)
  1406. {
  1407.   unsigned char options[7][16] = {"Music format", "Plaing queue", "Net interface", "Keep files", "Minimal rating", "", ""};
  1408.   char line = 0;
  1409.  
  1410.   //  curFormat++;
  1411.   //  queryNum++; //  скопировать строки
  1412.   //  netDriver++;
  1413.   //  saveFlag++;
  1414.   //  minRating++;
  1415.  
  1416.   strcpy(curWin.tittle, "Radio options");
  1417.   curWin.w = 22;
  1418.   curWin.x = 39 - curWin.w / 2;
  1419.   curWin.y = 7;
  1420.   curWin.h = 7;
  1421.   curWin.text = 95;
  1422.   curWin.back = 95;
  1423.   infoBox(curWin, "");
  1424.   curWin.x++;
  1425.   curWin.y++;
  1426.   OS_SETCOLOR(95);
  1427.   while (strlen(options[line]) != 0)
  1428.   {
  1429.     OS_SETXY(curWin.x, curWin.y + line);
  1430.     printf("%s", options[line]);
  1431.     line++;
  1432.   }
  1433.  
  1434.   getchar();
  1435.   return true;
  1436. }
  1437. */
  1438. void refreshQueryNames(int queryNum)
  1439. {
  1440.   switch (queryNum)
  1441.   {
  1442.   case 0:
  1443.     strcpy(queryType, "from newest to oldest                   ");
  1444.     break;
  1445.   case 1:
  1446.     sprintf(queryType, "Random most voted tracks with rating %s+    ", minRating);
  1447.     break;
  1448.   case 2:
  1449.     sprintf(queryType, "Random play with rating %s+                  ", minRating);
  1450.     break;
  1451.   case 3:
  1452.     strcpy(queryType, "User defined query from \"user.que\"     ");
  1453.     break;
  1454.   }
  1455. }
  1456.  
  1457. C_task main(int argc, char *argv[])
  1458. {
  1459.   unsigned char errn, keypress, pId;
  1460.   long iddqd, idkfa;
  1461.   unsigned long curTimer, startTimer, oldTimer;
  1462.   srand(time());
  1463.  
  1464.   OS_HIDEFROMPARENT();
  1465.   OS_SETGFX(0x86);
  1466.   OS_CLS(0);
  1467.  
  1468.   count = 0;
  1469.   saveFlag = 0;
  1470.   queryNum = 0;
  1471.   curFormat = 0;
  1472.   changedFormat = 0;
  1473.   rptFlag = 0;
  1474.   netDriver = 0;
  1475.   strcpy(minRating, "4.0");
  1476.  
  1477.   targetadr.family = AF_INET;
  1478.   targetadr.porth = 00;
  1479.   targetadr.portl = 80;
  1480.   targetadr.b1 = 217; // D9
  1481.   targetadr.b2 = 146; // 92
  1482.   targetadr.b3 = 69;  // 45
  1483.   targetadr.b4 = 13;  // 0D
  1484.  
  1485.   if (argc > 1)
  1486.   {
  1487.     if ((argv[1][0] == 'e') || (argv[1][0] == 'E'))
  1488.     {
  1489.       netDriver = 1;
  1490.       clearStatus();
  1491.       printf("    ESP-COM mode enabled...");
  1492.       BDBOX(1, 14, 80, 8, 71, ' ');
  1493.       OS_SETXY(0, 14);
  1494.       loadEspConfig();
  1495.       uart_init(divider);
  1496.       espReBoot();
  1497.       printHelp();
  1498.     }
  1499.   }
  1500.  
  1501.   strcpy(queryType, "from newest to oldest");
  1502.   OS_CLS(0);
  1503.   OS_SETCOLOR(71);
  1504.   OS_SETCOLOR(95);
  1505.   printf("                           ZXART.EE radio for %s                           ", interfaces[netDriver]);
  1506.   OS_SETCOLOR(6);
  1507.   printStatus();
  1508.  
  1509.   if (netDriver == 0)
  1510.   {
  1511.     get_dns();
  1512.     clearStatus();
  1513.     dnsResolve("zxart.ee");
  1514.   }
  1515. start:
  1516.   OS_SETSYSDRV();
  1517.   printHelp();
  1518.   curFileStruct.fileSize = 0;
  1519.  
  1520.   iddqd = processJson(count, 1, queryNum); // Query for track info
  1521.  
  1522.   switch (iddqd)
  1523.   {
  1524.   case -3: // return 0 pictures
  1525.     strcpy(minRating, "1.0");
  1526.     refreshQueryNames(queryNum);
  1527.     clearStatus();
  1528.     refreshScreen();
  1529.     printf("No picture is returned in query. Minimal rating is set to %s", minRating);
  1530.     goto start;
  1531.   case -4: // return xxxx picture, but empty body.
  1532.     clearStatus();
  1533.     refreshScreen();
  1534.     printf("Empty body is returned for %ld. Next picture, please.", count);
  1535.     count++;
  1536.     goto start;
  1537.   case -1: // return HTTP error != 200
  1538.     clearStatus();
  1539.     printf("[%u]Error getting track info, next please(%ld)...", curFileStruct.httpErr, iddqd);
  1540.  
  1541.     OS_DROPAPP(pId);
  1542.     changedFormat = 1;
  1543.     goto rekey;
  1544.   }
  1545.  
  1546.  idkfa = processJson(atol(curFileStruct.authorIds), 0, 99); // Query for AuthorID
  1547.  
  1548.   if (idkfa < 0)
  1549.   {
  1550.     clearStatus();
  1551.     printf("Error getting author info %lu", atol(curFileStruct.authorIds));
  1552.     strcpy(curFileStruct.authorTitle, "-");
  1553.     strcpy(curFileStruct.authorRealName, "-");
  1554.   }
  1555.  
  1556.   /////////////////////////////////////////////////
  1557.   // optionsMenu();
  1558.  
  1559. replay:
  1560.  
  1561.   // errn = getTrack2(iddqd); // Downloading the track
  1562.  
  1563.   errn = getTrack3(iddqd);
  1564.  
  1565.   if (errn == 0)
  1566.   {
  1567.     /*
  1568.       count = trackSelector(0);
  1569.       goto start;
  1570.     */
  1571.     OS_DROPAPP(pId);
  1572.     changedFormat = 1;
  1573.     goto rekey;
  1574.   }
  1575. resume:
  1576.   startTimer = time();
  1577.   printProgress(0);
  1578.   pId = runPlayer(); // Start the Player!
  1579.   printStatus();
  1580.   printInfo();
  1581. rekey:
  1582.   keypress = OS_GETKEY();
  1583.  
  1584.   switch (keypress)
  1585.   {
  1586.   case 27:
  1587.   case 'e':
  1588.   case 'E':
  1589.     OS_DROPAPP(pId);
  1590.     OS_CLS(0);
  1591.     printf("Good bye...\r\n");
  1592.     OS_SETCOLOR(7);
  1593.     exit(0);
  1594.   case 248:
  1595.   case 'b':
  1596.   case 'B':
  1597.     changedFormat = 0;
  1598.     OS_DROPAPP(pId);
  1599.     clearStatus();
  1600.     printf("Player stopped...");
  1601.     count = trackSelector(1);
  1602.     goto start;
  1603.   case 251:
  1604.   case 32:
  1605.   case 'n':
  1606.   case 'N':
  1607.     changedFormat = 0;
  1608.     OS_DROPAPP(pId);
  1609.     clearStatus();
  1610.     printf("Player stopped...");
  1611.     count = trackSelector(0);
  1612.     goto start;
  1613.   case 'k':
  1614.   case 'K':
  1615.     OS_DROPAPP(pId);
  1616.     clearStatus();
  1617.     printf("Player stopped...");
  1618.     saveFlag = !saveFlag;
  1619.     printStatus();
  1620.     changedFormat = 0;
  1621.     goto replay;
  1622.   case 'q':
  1623.   case 'Q':
  1624.     OS_DROPAPP(pId);
  1625.     clearStatus();
  1626.     printf("Player stopped...");
  1627.     queryNum++;
  1628.     if (queryNum > 3)
  1629.     {
  1630.       queryNum = 0;
  1631.     }
  1632.     refreshQueryNames(queryNum);
  1633.     count = 0;
  1634.     changedFormat = 0;
  1635.     printStatus();
  1636.     goto start;
  1637.   case 'j':
  1638.   case 'J':
  1639.     curWin.w = 22;
  1640.     curWin.x = 80 / 2 - curWin.w / 2 - 2;
  1641.     curWin.y = 14;
  1642.     curWin.h = 1;
  1643.     curWin.text = 103;
  1644.     curWin.back = 103;
  1645.     strcpy(curWin.tittle, "Track number:");
  1646.     if (inputBox(curWin, ""))
  1647.     {
  1648.       sscanf(cmd, "%ld", &count);
  1649.       OS_DROPAPP(pId);
  1650.       if (count > curFileStruct.totalAmount - 1)
  1651.       {
  1652.         count = curFileStruct.totalAmount - 1;
  1653.       }
  1654.       changedFormat = 0;
  1655.       goto start;
  1656.     }
  1657.     printHelp();
  1658.     break;
  1659.   case 'm':
  1660.   case 'M':
  1661.     curWin.w = 22;
  1662.     curWin.x = 80 / 2 - curWin.w / 2 - 2;
  1663.     curWin.y = 14;
  1664.     curWin.h = 1;
  1665.     curWin.text = 103;
  1666.     curWin.back = 103;
  1667.     strcpy(curWin.tittle, "Minimal rating:");
  1668.  
  1669.     if (inputBox(curWin, ""))
  1670.     {
  1671.       char counter;
  1672.       for (counter = 0; counter < strlen(cmd); counter++)
  1673.       {
  1674.         if ((((cmd[counter] < '0') || (cmd[counter] > '9'))) && cmd[counter] != '.')
  1675.         {
  1676.           clearStatus();
  1677.           printf("Wrong input.[%s]", cmd);
  1678.           counter = 0;
  1679.           break;
  1680.         }
  1681.       }
  1682.  
  1683.       if (counter != 0)
  1684.       {
  1685.         strncpy(minRating, cmd, 5);
  1686.         refreshQueryNames(queryNum);
  1687.         count = 0;
  1688.       }
  1689.       refreshScreen();
  1690.     }
  1691.     break;
  1692.   case 'f':
  1693.   case 'F':
  1694.     OS_DROPAPP(pId);
  1695.     clearStatus();
  1696.     printf("Player stopped...");
  1697.     curFormat++;
  1698.     count = -1;
  1699.     if (curFormat > 3)
  1700.     {
  1701.       curFormat = 0;
  1702.     }
  1703.     changedFormat = 1;
  1704.     curFileStruct.totalAmount = 1;
  1705.     /*
  1706.         if (strstr(formats[curFormat], "tfc") != NULL)
  1707.         {
  1708.           cutOff = 0;
  1709.         }
  1710.         else
  1711.         {
  1712.           cutOff = 0;
  1713.         }
  1714.     */
  1715.     printStatus();
  1716.     printProgress(0);
  1717.     BDBOX(1, 2, 80, 6, 71, ' ');
  1718.     goto rekey;
  1719.   case 's':
  1720.   case 'S':
  1721.     OS_DROPAPP(pId);
  1722.     clearStatus();
  1723.     printf("Player stopped...");
  1724.     printProgress(0);
  1725.     changedFormat = 0;
  1726.     getchar();
  1727.     goto resume;
  1728.   case 'r':
  1729.   case 'R':
  1730.     rptFlag = !rptFlag;
  1731.     clearStatus();
  1732.     printStatus();
  1733.     goto rekey;
  1734.   case 'd':
  1735.   case 'D':
  1736.     saveBak = saveFlag;
  1737.     saveFlag = 1;
  1738.  
  1739.     // errn = getTrack2(iddqd); // Downloading the track
  1740.  
  1741.     errn = getTrack3(iddqd);
  1742.  
  1743.     if (errn == 0)
  1744.     {
  1745.       /*
  1746.         count = trackSelector(0);
  1747.         goto start;
  1748.       */
  1749.       OS_DROPAPP(pId);
  1750.       changedFormat = 1;
  1751.       goto rekey;
  1752.     }
  1753.  
  1754.     saveFlag = saveBak;
  1755.     clearStatus();
  1756.     printf("File saved: [%s]...", curFileStruct.fileName);
  1757.     goto rekey;
  1758.   case 'i':
  1759.   case 'I':
  1760.     netDriver = !netDriver;
  1761.     if (netDriver == 1)
  1762.     {
  1763.       clearStatus();
  1764.       printf("    ESP-COM mode enabled...");
  1765.       BDBOX(1, 14, 80, 8, 71, ' ');
  1766.       OS_SETXY(0, 14);
  1767.       loadEspConfig();
  1768.       uart_init(divider);
  1769.       espReBoot();
  1770.       printHelp();
  1771.     }
  1772.     else
  1773.     {
  1774.       clearStatus();
  1775.       printf("    ZXNETUSB mode enabled...");
  1776.     }
  1777.     OS_SETXY(0, 0);
  1778.     OS_SETCOLOR(71);
  1779.     OS_SETCOLOR(95);
  1780.     printf("                           ZXART.EE radio for %s                    ", interfaces[netDriver]);
  1781.     OS_SETCOLOR(6);
  1782.     break;
  1783.   case 31:
  1784.     refreshScreen();
  1785.     break;
  1786.   default:
  1787.     break;
  1788.   }
  1789.   curTimer = time();
  1790.   curFileStruct.curPos = (curTimer - startTimer) / 50;
  1791.   /*
  1792.     if ((curTimer - oldTimer) > 49)
  1793.     {
  1794.       alive = testPlayer();
  1795.       sprintf(toLog, ",%u", alive);
  1796.       //writeLog(toLog);
  1797.     }
  1798.     if (alive == 0 && !changedFormat)
  1799.     {
  1800.       if (rptFlag == 1)
  1801.       {
  1802.         goto resume;
  1803.       }
  1804.       //writeLog("\r\nalive == 0. Next track please.\r\n");
  1805.       printProgress(2);
  1806.       count = trackSelector(0);
  1807.       goto start;
  1808.     }
  1809.  
  1810.     if (alive == 1 && ((curTimer - oldTimer) > 49))
  1811.     {
  1812.       sprintf(toLog, ".%u", curFileStruct.trackInSeconds - curFileStruct.curPos);
  1813.       //writeLog(toLog);
  1814.       printProgress(1);
  1815.       oldTimer = curTimer;
  1816.     }
  1817.   */
  1818.  
  1819.   remainTime = curFileStruct.trackInSeconds - curFileStruct.curPos;
  1820.  
  1821.   if ((remainTime < cutOff) && !changedFormat)
  1822.   {
  1823.  
  1824.     OS_DROPAPP(pId);
  1825.     clearStatus();
  1826.     printf("Player stopped...");
  1827.  
  1828.     if (rptFlag == 1)
  1829.     {
  1830.       goto resume;
  1831.     }
  1832.     printProgress(2);
  1833.     count = trackSelector(0);
  1834.     goto start;
  1835.   }
  1836.   if ((curTimer - oldTimer) > 49 && !changedFormat)
  1837.   {
  1838.     printProgress(1);
  1839.     oldTimer = curTimer;
  1840.   }
  1841.   YIELD();
  1842.   goto rekey;
  1843. }
  1844.