home *** CD-ROM | disk | FTP | other *** search
/ Chip 2005 June / ccd0605.iso / LINUX / gopchop-1.1.7.tar.tar / gopchop-1.1.7.tar / gopchop-1.1.7 / src / gtkspu.c < prev    next >
C/C++ Source or Header  |  2004-02-24  |  34KB  |  1,097 lines
  1. /*
  2. #
  3. # Tool for displaying SPU graphics from DVD navigation streams
  4. #
  5. # $Id: gtkspu.c,v 1.19 2004/02/24 05:52:10 nemies Exp $
  6. #
  7. # Copyright (C) 2002-2003 Kees Cook
  8. # kees@outflux.net, http://outflux.net/
  9. # 
  10. # This program is free software; you can redistribute it and/or
  11. # modify it under the terms of the GNU General Public License
  12. # as published by the Free Software Foundation; either version 2
  13. # of the License, or (at your option) any later version.
  14. # 
  15. # This program is distributed in the hope that it will be useful,
  16. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18. # GNU General Public License for more details.
  19. # 
  20. # You should have received a copy of the GNU General Public License
  21. # along with this program; if not, write to the Free Software
  22. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23. # http://www.gnu.org/copyleft/gpl.html
  24. #
  25. */
  26.  
  27. #include "GOPchop.h"
  28.  
  29. #include <stdio.h>
  30. #include <sys/types.h>
  31. #include <sys/stat.h>
  32. #include <unistd.h>
  33. #include <stdlib.h>
  34. #include <string.h>
  35. #include <getopt.h>
  36. #include <gtk/gtk.h>
  37. #include "file_buffer.h"
  38.  
  39. typedef struct
  40. {
  41.     gint red;
  42.     gint green;
  43.     gint blue;
  44. }
  45. quick_color;
  46.  
  47. quick_color clut[0xF];
  48.  
  49. /* since we don't have a valid color map, we're going to just
  50.  * display the 4 possible colors as red, green, blue, or yellow
  51.  */
  52. #define COLOR_BACK      0 /* Green */
  53. #define COLOR_PATTERN   1 /* Red */
  54. #define COLOR_EMP1      2 /* Blue */
  55. #define COLOR_EMP2      3 /* Yellow */
  56. #define COLOR_NOTHING   4
  57.  
  58. gint width = 0;
  59. gint height = 0;
  60. guchar *rgbbuf = NULL;
  61. guchar *backbuf = NULL;
  62. uint8_t *spu_pixelbuf = NULL;
  63.  
  64. int clut_index[4];
  65. int alpha[5] = { 0x0, 0x0, 0x0, 0x0, 0x0 };     // all transparent
  66. quick_color cmap[4];
  67.  
  68. static struct option long_options[] = {
  69.         // name, has_arg, flag, val
  70.         {"help",    0, 0, 'h'},
  71.         {"blind",   0, 0, 'b'},
  72.         {"width",   1, 0, 'x'},
  73.         {"height",  1, 0, 'y'},
  74.         {"skip",    1, 0, 's'},
  75.         {"debug",   0, 0, 'd'},
  76.         {"version", 0, 0, 'V'},
  77.         {NULL,      0, 0, 0},
  78. };
  79. static char *short_options = "h?bdVx:y:s:";
  80. int opt_debug = 0;
  81. int opt_version = 0;
  82. int opt_blind = 0;
  83. // This is used to size the SPU display area, in the case that it
  84. // shouldn't be auto-sized to the spu bounding box
  85. int opt_width = -1;
  86. int opt_height = -1;
  87. off_t opt_skip = 0;
  88.  
  89. void usage(char *argv[])
  90. {
  91.     printf("Usage: %s [OPTIONS] SPU_FILE [packet-number]\n",argv[0]);
  92.     printf("\n");
  93.     printf("-b,--blind     Blindly read the input file as a SPU stream\n");
  94.     printf("-x,--width=X   Force display area width to at least X\n");
  95.     printf("-y,--height=Y  Force display area height to at least Y\n");
  96.     printf("-s,--skip=B    Skip B bytes before processing SPU stream\n");
  97.     printf("-d,--debug     Display debugging information\n");
  98.     printf("-V,--version   Display version number\n");
  99.     printf("-h,-?,--help   Display this help\n");
  100.     printf("\n");
  101.     printf("To generate the SPU_FILE, you can extract the stream\n");
  102.     printf("from a DVD VOB file with 'mpegcat -w'.  They are usually\n");
  103.     printf("in the DVD audio streams, starting from sub-id's 0x20.\n");
  104.     printf("Try: 'mpegcat -iDaw dump.spu,0xBD,0x20 FILE.VOB'\n");
  105.  
  106.     exit(1);
  107. }
  108.  
  109. int handle_options(int argc, char *argv[])
  110. {
  111.     int c;
  112.     int option_index = 0;
  113.  
  114.     while (1) {
  115.         c = getopt_long(argc, argv, short_options, long_options, &option_index);
  116.         if (c == -1)
  117.             break;
  118.  
  119.         switch (c)
  120.         {
  121.             case '?':
  122.             case 'h':
  123.                 usage(argv);
  124.                 break;
  125.             case 'b':
  126.                 opt_blind = 1;
  127.                 break;
  128.             case 'd':
  129.                 opt_debug = 1;
  130.                 break;
  131.             case 'V':
  132.                 opt_version = 1;
  133.                 break;
  134.             case 'x':
  135.                 opt_width = atol(optarg);
  136.                 break;
  137.             case 'y':
  138.                 opt_height = atol(optarg);
  139.                 break;
  140.             case 's':
  141.                 opt_skip = atol(optarg);
  142.                 break;
  143.             default:
  144.                 printf("?? getopt return character code 0x%x ??\n", c);
  145.                 break;
  146.         }
  147.     }
  148.  
  149.     return optind;
  150. }
  151.  
  152. gboolean on_darea_expose(GtkWidget * widget,
  153.                          GdkEventExpose * event, gpointer user_data);
  154.  
  155. int yank_nibble(guchar * rledata, int *addr, int *halfbyte)
  156. {
  157.     int val = 0;
  158.  
  159.     if (!*halfbyte)
  160.     {
  161.         // take the top half
  162.         val = (rledata[*addr] & 0xF0) >> 4;
  163.  
  164.         *halfbyte = 1;
  165.     }
  166.     else
  167.     {
  168.         // take the bottom half
  169.         val = rledata[*addr] & 0x0F;
  170.  
  171.         *halfbyte = 0;
  172.         *addr += 1;
  173.     }
  174.     return val;
  175. }
  176.  
  177. void count_colors(uint8_t *spu, int height, int width) {
  178.     int color_count[4];
  179.     int x, y;
  180.  
  181.     /* clear count */
  182.     for (x=0;x<4;x++) { color_count[x]=0; }
  183.     for (y = 0; y < height; y++) {
  184.         for (x = 0; x < width; x++) {
  185.             if (*spu != COLOR_NOTHING) color_count[*spu++]++;
  186.         }
  187.     }
  188.  
  189.     printf("Pattern   (R): %d\n",color_count[COLOR_PATTERN]);
  190.     printf("Background(G): %d\n",color_count[COLOR_BACK]);
  191.     printf("Emphasis1 (B): %d\n",color_count[COLOR_EMP1]);
  192.     printf("Emphasis2 (Y): %d\n",color_count[COLOR_EMP2]);
  193.  
  194. }
  195.  
  196. #define GRAB_NIBBLE             yank_nibble(rledata,&addr,&halfbyte)
  197. // depends on global "height" and "width"
  198. // what I really need here is a struct for the SPU area, and just draw
  199. // it.  I should deal with screen width/height when merging instead.
  200. void draw_spu(uint8_t *drawbuf,
  201.               int row_start, int row_end, int row_step,
  202.               int colstart, int colend,
  203.               uint8_t * rledata, int addr)
  204. {
  205.     int row;
  206.     int col = colstart;
  207.  
  208.     int halfbyte = 0;
  209.     unsigned int bits;
  210.     unsigned int number;
  211.     uint8_t cindex;
  212.  
  213.     for (row = row_start; row <= row_end;)
  214.     {
  215.         bits = GRAB_NIBBLE;
  216.         if ((bits & 0xC) != 0x0)
  217.         {
  218.             // have 4-bit code
  219.             number = (bits & 0xC) >> 2;
  220.             cindex = (bits & 0x3);
  221.         }
  222.         else
  223.         {
  224.             bits <<= 4;
  225.             bits |= GRAB_NIBBLE;
  226.  
  227.             if ((bits & 0xF0) != 0)
  228.             {
  229.                 // have 8-bit code
  230.                 number = (bits & 0x3C) >> 2;
  231.                 cindex = (bits & 0x3);
  232.             }
  233.             else
  234.             {
  235.                 bits <<= 4;
  236.                 bits |= GRAB_NIBBLE;
  237.  
  238.                 if ((bits & 0xFC0) != 0)
  239.                 {
  240.                     // have 12-bit code
  241.                     number = (bits & 0xFC) >> 2;
  242.                     cindex = (bits & 0x3);
  243.                 }
  244.                 else
  245.                 {
  246.                     // have 16-bit code
  247.                     bits <<= 4;
  248.                     bits |= GRAB_NIBBLE;
  249.  
  250.                     number = (bits & 0x3FC) >> 2;
  251.                     cindex = (bits & 0x3);
  252.  
  253.                     if (number == 0)
  254.                         number = width; // entire row
  255.                 }
  256.             }
  257.         }
  258.  
  259.  
  260.         // write "number" many "cindex"s until end of row
  261.         //printf("row: %d col: %d cindex: %d\n", row,col,cindex);
  262.         for (; number > 0 && col <= colend; number--)
  263.         {
  264.             drawbuf[row * width + col++] = cindex;
  265.         }
  266.  
  267.         if (col > colend)
  268.         {
  269.             row += row_step;
  270.             col = colstart;
  271.  
  272.             // fill to end of byte on row end
  273.             if (halfbyte)
  274.             {
  275.                 halfbyte = 0;
  276.                 addr++;
  277.             }
  278.         }
  279.     }
  280.  
  281. }
  282.  
  283. #define SPU_CMD_END                     0xFF    // ends one SP_DCSQ
  284. #define SPU_FORCED_START_DISPLAY        0x00    // no arguments
  285. #define SPU_START_DISPLAY               0x01    // no arguments
  286. #define SPU_STOP_DISPLAY                0x02    // no arguments
  287.  
  288. // provides four indices into the CLUT for the current PGC to associate with
  289. // the four pixel values. One nibble per pixel value for a total of 2 bytes: 
  290. // emphasis2 emphasis1 pattern background
  291. #define SPU_SET_COLOR                   0x03
  292.  
  293. // directly provides the four contrast (alpha blend) values to associate with
  294. // the four pixel values. One nibble per pixel value for a total of 2 bytes.
  295. // 0x0 = transparent, 0xF = opaque
  296. // e2 e1   p b 
  297. #define SPU_SET_CONTRAST                0x04
  298.  
  299. // defines the display area, each pair (X and Y) of values is 3 bytes wide,
  300. // for a total of 6 bytes, and has the form:
  301. // sx sx   sx ex   ex ex   sy sy   sy ey   ey ey
  302. // sx = starting X coordinate
  303. // ex = ending X coordinate
  304. // sy = starting Y coordinate
  305. // ey = ending Y coordinate 
  306. #define SPU_DEFINE_AREA                 0x05
  307.  
  308. // defines the pixel data addresses. First a 2-byte offset to the top field
  309. // data, followed by a 2-byte offset to the bottom field data, for a total of
  310. // 4 bytes.
  311. #define SPU_DEFINE_PIXEL_ADDRESS        0x06
  312.  
  313. // allows for changing the COLor and CONtrast within one or more areas of the
  314. // display. This command contains a series of parameters, arranged in a
  315. // hierarchy.
  316. // Following the command byte is a 2-byte value for the total size of the
  317. // parameter area, including the size word.
  318. //
  319. // The parameter sequence begins with a LN_CTLI, which defines a vertically
  320. // bounded area of the display. The LN_CTLI may include from one to fifteen
  321. // PX_CTLI parameters, which define a starting horizontal position and new
  322. // color and contrast value to apply from that column on towards the right to
  323. // the next PX_CTLI or the right side of the display. 
  324. //
  325. // LN_CTLI, 4 bytes, special value of 0f ff ff ff signifies the end of the
  326. // parameter area (this termination code MUST be present as the last parameter)
  327. // 0 s   s s   n t   t t
  328. // sss = csln, the starting (top-most) line number for this area
  329. // n = number of PX_CTLI to follow
  330. // ttt = ctln, the terminating (bottom-most) line number for this area
  331. //
  332. // PX_CTLI, 6 bytes, defines a starting column and new color and contrast values
  333. // bytes 0 and 1 - starting column number
  334. // bytes 2 and 3 - new color values, as per SET_COLOR
  335. // bytes 4 and 5 - new contrast values, as per SET_CONTR 
  336. #define SPU_CHANGE_COLOR_CONTRAST       0x07
  337.  
  338. struct spu_cmds_t {
  339.     uint8_t cmd;
  340.     int     arg_bytes;
  341.     char *  name;
  342. };
  343.  
  344. // -1 arg_bytes means two-byte arg length
  345. struct spu_cmds_t spu_cmds[]={
  346.     { SPU_FORCED_START_DISPLAY,     0,  "Forced Start Display" },
  347.     { SPU_START_DISPLAY,            0,  "Start Display" },
  348.     { SPU_STOP_DISPLAY,             0,  "Stop Display" },
  349.     { SPU_SET_COLOR,                2,  "Set Color" },
  350.     { SPU_SET_CONTRAST,             2,  "Set Contrast" },
  351.     { SPU_DEFINE_AREA,              6,  "Define Area" },
  352.     { SPU_DEFINE_PIXEL_ADDRESS,     4,  "Define Pixel Address" },
  353.     { SPU_CHANGE_COLOR_CONTRAST,   -1,  "Change Color and Contrast" },
  354.     { SPU_CMD_END,                  0,  "Command End" },
  355.     { 0,                            0,  NULL },
  356. };
  357.  
  358. #define ADDR_OKAY               (location<spu_len)
  359. #define GRAB_BYTE               (buf[location])
  360. #define GRAB_WORD(buf,loc)      (((buf)[(loc)]<<8)|(buf)[(loc)+1])
  361. #define GRAB_HIGH_NIBBLE        ((buf[location]&0xF0)>>4)
  362. #define GRAB_LOW_NIBBLE         ((buf[location]&0x0F))
  363.  
  364. // ran past the end of the buffer
  365. #define SPU_ERR_OUT_OF_BOUNDS   -1
  366. // no valid command found
  367. #define SPU_ERR_NO_CMD          -2
  368. // null pointer argument
  369. #define SPU_ERR_NULL_ARG        -3
  370.  
  371. /* this expects to find a SPU command at the current location */
  372. // the returned spu_cmd must be free'd by the caller
  373. struct spu_cmds_t * spu_cmd_lookup(file_buf * fb,
  374.                                    struct spu_cmds_t * spu_cmd_copy)
  375. {
  376.     uint8_t             cmd_info[3];
  377.     unsigned int        cmd_len=0;
  378.     struct spu_cmds_t * spu_cmd;
  379.  
  380.     if (!fb) return NULL;
  381.  
  382.     if (buffer_look_ahead(fb, cmd_info, 1) != FILE_BUF_OKAY) {
  383.         if (opt_debug)
  384.             printf("\t\tFile ends before next command\n");
  385.         return NULL;
  386.     }
  387.  
  388.     for (spu_cmd=spu_cmds; spu_cmd->name; spu_cmd++) {
  389.         if (spu_cmd->cmd == cmd_info[0]) {
  390.             if (opt_debug)
  391.                 printf("\t\tChecking command 0x%02X (%s)\n",
  392.                        cmd_info[0], spu_cmd->name);
  393.             break;
  394.         }
  395.     }
  396.     if (!spu_cmd->name) {
  397.         if (opt_debug)
  398.             printf("\t\tNo such command 0x%02X\n",cmd_info[0]);
  399.         return NULL;
  400.     }
  401.     if (spu_cmd->arg_bytes!=0) {
  402.         // variable length arguments
  403.         if (spu_cmd->arg_bytes==-1) {
  404.             if (buffer_look_ahead(fb, cmd_info, 3) != FILE_BUF_OKAY) {
  405.                 if (opt_debug)
  406.                     printf("\t\tFile ends before variable command length\n");
  407.                 return NULL;
  408.             }
  409.             cmd_len=GRAB_WORD(cmd_info,1);
  410.         }
  411.         else {
  412.             cmd_len=spu_cmd->arg_bytes;
  413.         }
  414.     }
  415.     if (!spu_cmd_copy) {
  416.         if (!(spu_cmd_copy=(struct spu_cmds_t *)
  417.                             malloc(sizeof(*spu_cmd_copy)))) {
  418.             perror("malloc");
  419.             exit(1);
  420.         }
  421.     }
  422.     *spu_cmd_copy=*spu_cmd;
  423.     spu_cmd_copy->arg_bytes=cmd_len;
  424.  
  425.     if (opt_debug)
  426.         printf("\t\tCommand length 0x%04X valid\n",cmd_len);
  427.  
  428.     return spu_cmd_copy;
  429. }
  430.  
  431.  
  432. #define SPU_PACKET_VALID         0 
  433. #define SPU_PACKET_NOT_VALID    -1
  434. #define SPU_PACKET_EOF          -2
  435. #define SPU_PACKET_NULL_BUFFER  -3
  436. int spu_packet_valid(file_buf * fb, off_t file_loc, uint8_t ** buf) {
  437.     uint8_t words[4];
  438.     size_t  packet_len;
  439.     size_t  dscq_table;
  440.     size_t  dscq;
  441.     size_t  next_dscq;
  442.     size_t  prev_dscq;
  443.     size_t  loc; // location within the packet
  444.  
  445.     // sanity-check the data area between the spu header and the dscq table
  446.     int has_pixel_data=0;
  447.     int has_pixel_cmd=0;
  448.     int commands=0;
  449.  
  450.     if (!buf) return SPU_PACKET_NULL_BUFFER;
  451.  
  452.     if (opt_debug)
  453.         printf("%06"OFF_T_FORMAT" ...\n",file_loc);
  454.     if (buffer_look_ahead(fb, words, 4) != FILE_BUF_OKAY) {
  455.         if (opt_debug)
  456.             printf("\tFile ends within 4 bytes "
  457.                    "(no room for SPU packet header)\n");
  458.         return SPU_PACKET_EOF;
  459.     }
  460.     packet_len=GRAB_WORD(words,0);
  461.     dscq_table=GRAB_WORD(words,2);
  462.  
  463.     // packet_len must be at least 4+4+1 long (spu header, dscq,
  464.     // and a single "end" command
  465.     if (packet_len<9) {
  466.         if (opt_debug)
  467.             printf("\tPacket length < 9 bytes\n");
  468.         return SPU_PACKET_NOT_VALID;
  469.     }
  470.  
  471.     // is there a gap between the header and the dscq table?
  472.     if (dscq_table>4)
  473.         has_pixel_data=1;
  474.  
  475.     // if the table is beyond the packet len, it's not a SPU
  476.     if (dscq_table>=packet_len) {
  477.         if (opt_debug)
  478.             printf("\tdscq table can't be past end of packet\n");
  479.         return SPU_PACKET_NOT_VALID;
  480.     }
  481.  
  482.     if (!(*buf=(uint8_t*)realloc(*buf,packet_len))) {
  483.         perror("realloc");
  484.         exit(1);
  485.     }
  486.     // if we can't read in the remaining packet, it's not a SPU
  487.     if (buffer_look_ahead(fb, *buf, packet_len) != FILE_BUF_OKAY) {
  488.         if (opt_debug)
  489.             printf("\tFile ends before end of packet\n");
  490.         return SPU_PACKET_NOT_VALID;
  491.     }
  492.  
  493.     // FIXME: when decoding dscq starts, each should start right after the
  494.     // previous one
  495.     prev_dscq=0;
  496.     loc=dscq_table;
  497.     for (dscq=dscq_table;
  498.          dscq<packet_len && prev_dscq!=dscq;
  499.          dscq=next_dscq) {
  500.         struct spu_cmds_t spu_cmd;
  501.         struct spu_cmds_t * spu_cmd_valid;
  502.         unsigned int clocks;
  503.  
  504.         // notice when next == current
  505.         prev_dscq=dscq;
  506.  
  507.         // freak out if dscq!=loc
  508.         if (dscq != loc) {
  509.             if (opt_debug)
  510.                 printf("\tNext dscq is at 0x%04X instead of loc 0x%04X\n",
  511.                        dscq,loc);
  512.             return SPU_PACKET_NOT_VALID;
  513.         }
  514.  
  515.         clocks   =GRAB_WORD(*buf,dscq);
  516.         next_dscq=GRAB_WORD(*buf,dscq+2);
  517.  
  518.         if (opt_debug)
  519.             printf("\tDSCQ 0x%04X (Next 0x%04X)\n",dscq,next_dscq);
  520.  
  521.         // spu's don't go backwards
  522.         if (next_dscq<dscq) {
  523.             if (opt_debug)
  524.                 printf("\tNext dscq can't be before current dscq\n");
  525.             return SPU_PACKET_NOT_VALID;
  526.         }
  527.  
  528.         // move to cmd area
  529.         loc+=4;
  530.  
  531.         // I can leave the command loop when I either
  532.         // a) see an "END" command
  533.         // b) exactly hit the end-of-packet boundry?
  534.         // c) exactly hit the end-of-dscq boundry?
  535.         do {
  536.             // seek
  537.             if (buffer_seek(fb,file_loc+loc) != FILE_BUF_OKAY) {
  538.                 if (opt_debug)
  539.                     printf("\tFile ends before next command area\n");
  540.                 return SPU_PACKET_NOT_VALID;
  541.             }
  542.             // lookup & check
  543.             if (!(spu_cmd_valid=spu_cmd_lookup(fb,&spu_cmd))) {
  544.                 if (opt_debug)
  545.                     printf("\tNo valid SPU command not found\n");
  546.                 return SPU_PACKET_NOT_VALID;
  547.             }
  548.             // verify packet contains command
  549.             loc+=spu_cmd.arg_bytes+1; // total length of command
  550.             if (loc>packet_len) {
  551.                 if (opt_debug)
  552.                     printf("\tCommand can't be outside current packet\n");
  553.                 return SPU_PACKET_NOT_VALID;
  554.             }
  555.             // handle command?
  556.             commands++;
  557.             if (spu_cmd.cmd==SPU_DEFINE_PIXEL_ADDRESS) {
  558.                 has_pixel_cmd=1;
  559.             }
  560.             // leave on "last" cmd
  561.         } while (spu_cmd.cmd!=SPU_CMD_END);
  562.     }
  563.  
  564.     if (prev_dscq!=dscq) {
  565.         // end without correct end-of-dscq's
  566.         if (opt_debug)
  567.             printf("\tPacket finished without finishing last dscq\n");
  568.         return SPU_PACKET_NOT_VALID;
  569.     }
  570.  
  571.     // at least one command in a SPU packet
  572.     if (commands<1) {
  573.         if (opt_debug)
  574.             printf("\tSPU packet has no commands\n");
  575.         return SPU_PACKET_NOT_VALID;
  576.     }
  577.     // check pixel data space
  578.     if (has_pixel_data != has_pixel_cmd) {
  579.         if (opt_debug) {
  580.             if (has_pixel_data)
  581.                 printf("\tSPU has pixel area used but no cmd addressing it\n");
  582.             if (has_pixel_cmd)
  583.                 printf("\tSPU has pixel cmd but no area defined for use\n");
  584.         }
  585.         return SPU_PACKET_NOT_VALID;
  586.     }
  587.  
  588.     // It sure LOOKS like a SPU...
  589.     if (opt_debug)
  590.         printf("\tLooks good, with length %u\n",packet_len);
  591.     return SPU_PACKET_VALID;
  592. }
  593.  
  594. /* sub-picture unit header (spuh):
  595.  * offset  size      description
  596.  * 0x0:    0x2       total length of all packets in bytes
  597.  * 0x2:    0x2       offset to first sp_dcsqt
  598.  * 0x4:    variable  pixel data
  599.  *
  600.  * sub-picture display control sequence table (sp_dcsqt):
  601.  * offset  size      description
  602.  * 0x0:    0x2       90KHz/1024 clock units to wait until running
  603.  * 0x2:    0x2       next sp_dcsq (or self if end)
  604.  *
  605.  * One way to scan for a SPU packet would be to look for
  606.  * DWORD-aligned pairs of WORDs where WORD1 > WORD2
  607.  * and offset+WORD2 is a valid SPU command (0-7, 0xFF).
  608.  * Or rather, a series of valid commands.
  609.  *
  610.  * Additionally, you could check for 0xFF near the end?
  611.  *
  612.  */
  613. int seek_to_next_valid_spu(file_buf * fb) {
  614.     off_t        file_loc;
  615.     uint8_t *    buf=NULL;
  616.     uint8_t      skip_byte;
  617.     int          valid=0;
  618.     int          percent, prev_percent=-1;
  619.     double       calc;
  620.     off_t        file_size;
  621.  
  622.     if (!fb) return -1;
  623.  
  624.     file_loc = buffer_tell(fb);
  625.     file_size = buffer_file_size(fb);
  626.     do {
  627.         switch (spu_packet_valid(fb,file_loc,&buf)) {
  628.         case SPU_PACKET_VALID:
  629.                 // it's valid
  630.                 valid=1;
  631.                 break;
  632.         case SPU_PACKET_NOT_VALID:
  633.                 // it's not valid
  634.                 break;
  635.         default:
  636.                 // eof or other error
  637.                 goto eof;
  638.         }
  639.  
  640.         // reset file location
  641.         if (buffer_seek(fb,file_loc) != FILE_BUF_OKAY)
  642.             goto eof;
  643.  
  644.         if (valid) break;
  645.  
  646.         // advance the buffer to the next byte
  647.         if (buffer_get_byte(fb,&skip_byte) != FILE_BUF_OKAY)
  648.             goto eof;
  649.         file_loc = buffer_tell(fb);
  650.  
  651.         // update a little counter
  652.         calc=(double)file_loc;
  653.         calc/=(double)file_size;
  654.         calc*=(double)10000;
  655.         percent=(int)(calc);
  656.         if (percent!=prev_percent) {
  657.             printf("%"OFF_T_FORMAT"/%"OFF_T_FORMAT" (%0.2f%%)\r",
  658.                    file_loc, file_size, (double)percent/(double)100);
  659.             fflush(NULL);
  660.         }
  661.         prev_percent=percent;
  662.     } while (1);
  663.  
  664.     // good packet!
  665.     if (buf) free(buf);
  666.     return 0;
  667.  
  668. eof:
  669.     if (buf) free(buf);
  670.     return -1;
  671. }
  672.  
  673. unsigned int odd_pixel_rows;
  674. unsigned int even_pixel_rows;
  675. gint sx, sy, ex, ey, i;
  676.  
  677. // returns -1 if done, or offset of next sequence
  678. int spu_run(uint8_t * buf, off_t file_offset, int spu_seq_loc, size_t spu_len)
  679. {
  680.     int location = spu_seq_loc;
  681.     int my_location = spu_seq_loc;
  682.     unsigned int stall_time;
  683.     unsigned int next_sequence;
  684.     unsigned int size;
  685.     uint8_t cmd;
  686.  
  687.     // adjust our buffer & max_addr
  688.     if (!buf) return -1;
  689.  
  690.     printf("0x%05X: ", location);
  691.     stall_time = GRAB_WORD(buf,location);
  692.     location += 2;
  693.     next_sequence = GRAB_WORD(buf,location);
  694.     printf("SEQ: Stall time: %u, Next sequence: 0x%X\n",
  695.            stall_time, next_sequence);
  696.     location += 2;
  697.  
  698.     for (cmd = buf[location]; ADDR_OKAY; cmd = buf[location])
  699.     {
  700.         printf("0x%05X: ", location);
  701.         location++;
  702.  
  703.         switch (cmd)
  704.         {
  705.             case SPU_FORCED_START_DISPLAY:
  706.                 printf("Forced Start Display\n");
  707.                 break;
  708.             case SPU_START_DISPLAY:
  709.                 printf("Start Display\n");
  710.                 break;
  711.             case SPU_STOP_DISPLAY:
  712.                 printf("Stop Display\n");
  713.                 break;
  714.  
  715.             case SPU_SET_COLOR:
  716.                 clut_index[COLOR_EMP2] = GRAB_HIGH_NIBBLE;
  717.                 clut_index[COLOR_EMP1] = GRAB_LOW_NIBBLE;
  718.                 location++;
  719.                 clut_index[COLOR_PATTERN] = GRAB_HIGH_NIBBLE;
  720.                 clut_index[COLOR_BACK] = GRAB_LOW_NIBBLE;
  721.                 location++;
  722.                 printf
  723.                     ("Set Color (pat(R): 0x%X back(G): 0x%X emp1(B): 0x%X emp2(Y): 0x%X)\n",
  724.                      clut_index[COLOR_PATTERN], clut_index[COLOR_BACK],
  725.                      clut_index[COLOR_EMP1], clut_index[COLOR_EMP2]);
  726.  
  727.                 cmap[0] = clut[clut_index[0]];
  728.                 cmap[1] = clut[clut_index[1]];
  729.                 cmap[2] = clut[clut_index[2]];
  730.                 cmap[3] = clut[clut_index[3]];
  731.  
  732.                 /* over-ride the colors, since we don't have a color map */
  733.                 cmap[COLOR_PATTERN].red=0xFF;
  734.                 cmap[COLOR_PATTERN].green=0x00;
  735.                 cmap[COLOR_PATTERN].blue=0x00;
  736.  
  737.                 cmap[COLOR_BACK].red=0x00;
  738.                 cmap[COLOR_BACK].green=0xFF;
  739.                 cmap[COLOR_BACK].blue=0x00;
  740.  
  741.                 cmap[COLOR_EMP1].red=0x00;
  742.                 cmap[COLOR_EMP1].green=0x00;
  743.                 cmap[COLOR_EMP1].blue=0xFF;
  744.  
  745.                 cmap[COLOR_EMP2].red=0xFF;
  746.                 cmap[COLOR_EMP2].green=0xFF;
  747.                 cmap[COLOR_EMP2].blue=0x80;
  748.  
  749.                 break;
  750.  
  751.             case SPU_SET_CONTRAST:
  752.                 alpha[COLOR_EMP2] = GRAB_HIGH_NIBBLE;
  753.                 alpha[COLOR_EMP1] = GRAB_LOW_NIBBLE;
  754.                 location++;
  755.                 alpha[COLOR_PATTERN] = GRAB_HIGH_NIBBLE;
  756.                 alpha[COLOR_BACK] = GRAB_LOW_NIBBLE;
  757.                 location++;
  758.                 printf
  759.                     ("Set Alpha (pat(R): 0x%X back(G): 0x%X emp1(B): 0x%X emp2(Y): 0x%X)\n",
  760.                      alpha[COLOR_PATTERN], alpha[COLOR_BACK],
  761.                      alpha[COLOR_EMP1], alpha[COLOR_EMP2]);
  762.  
  763.                 // force visible bitmap if they're all transparent
  764.                 if (alpha[COLOR_PATTERN] == 0x0 &&
  765.                     alpha[COLOR_BACK]    == 0x0 &&
  766.                     alpha[COLOR_EMP1]    == 0x0 &&
  767.                     alpha[COLOR_EMP2]    == 0x0)
  768.                 {
  769.                     printf("All transparent, forcing full visibility...\n");
  770.                     alpha[COLOR_PATTERN] = 0xF;
  771.                     alpha[COLOR_BACK]    = 0xF;
  772.                     alpha[COLOR_EMP1]    = 0xF;
  773.                     alpha[COLOR_EMP2]    = 0xF;
  774.                 }
  775.                 break;
  776.  
  777.             case SPU_DEFINE_AREA:
  778.                 sx = GRAB_BYTE;
  779.                 location++;
  780.                 sx <<= 4;
  781.                 sx |= GRAB_HIGH_NIBBLE;
  782.                 ex = GRAB_LOW_NIBBLE;
  783.                 location++;
  784.                 ex <<= 8;
  785.                 ex |= GRAB_BYTE;
  786.                 location++;
  787.  
  788.                 sy = GRAB_BYTE;
  789.                 location++;
  790.                 sy <<= 4;
  791.                 sy |= GRAB_HIGH_NIBBLE;
  792.                 ey = GRAB_LOW_NIBBLE;
  793.                 location++;
  794.                 ey <<= 8;
  795.                 ey |= GRAB_BYTE;
  796.                 location++;
  797.  
  798.                 printf("Define Area (%d,%d)-(%d,%d) %dx%d\n",
  799.                        sx, sy, ex, ey, (ex-sx)+1, (ey-sy)+1);
  800.                 if (opt_width != -1 || opt_height != -1) {
  801.                     // this version draws from the screen's top left
  802.                     // plus any extra space created by the cmdline opts
  803.                     width  = MAX(opt_width,ex + 1);
  804.                     height = MAX(opt_height,ey + 1);
  805.                 }
  806.                 else {
  807.                     // this version draws only the defined SPU area
  808.                     width  = (ex - sx) + 1;
  809.                     height = (ey - sy) + 1;
  810.                 }
  811.  
  812.                 break;
  813.  
  814.             case SPU_DEFINE_PIXEL_ADDRESS:
  815.                 odd_pixel_rows = GRAB_WORD(buf,location);
  816.                 location += 2;
  817.                 even_pixel_rows = GRAB_WORD(buf,location);
  818.                 location += 2;
  819.                 printf("Define Pixels (odd: 0x%X even: 0x%X)\n",
  820.                        odd_pixel_rows, even_pixel_rows);
  821.                 // FIXME: validate pixel location
  822.                 break;
  823.  
  824.             case SPU_CHANGE_COLOR_CONTRAST:
  825.                 size = GRAB_WORD(buf,location);
  826.                 location += size;
  827.                 printf("Change Color & Contrast (%d)\n", size);
  828.                 break;
  829.  
  830.             case SPU_CMD_END:
  831.                 printf("End of Commands\n");
  832.  
  833.                 // handle drawing now that we got everything
  834.                 if (spu_pixelbuf)
  835.                     free(spu_pixelbuf);
  836.                 if (!(spu_pixelbuf =
  837.                       (uint8_t *) malloc(sizeof(*spu_pixelbuf) * width * height)))
  838.                 {
  839.                     perror("malloc");
  840.                     exit(1);
  841.                 }
  842.                 // clear the pixels
  843.                 memset(spu_pixelbuf, COLOR_NOTHING, width * height);
  844.  
  845.                 if (opt_width != -1 || opt_height != -1) {
  846.                     // this version draws from the screen's top left corner
  847.                     draw_spu(spu_pixelbuf, sy,     ey, 2, sx, ex,
  848.                              buf, odd_pixel_rows);
  849.                     draw_spu(spu_pixelbuf, sy + 1, ey, 2, sx, ex,
  850.                              buf, even_pixel_rows);
  851.                 }
  852.                 else {
  853.                     // this version draws only the defined SPU area
  854.                     draw_spu(spu_pixelbuf, 0, height-1, 2, 0, width-1,
  855.                              buf, odd_pixel_rows);
  856.                     draw_spu(spu_pixelbuf, 1, height-1, 2, 0, width-1,
  857.                              buf, even_pixel_rows);
  858.                 }
  859.  
  860.                 if (my_location == next_sequence)
  861.                     return -1;
  862.  
  863.                 return next_sequence;
  864.  
  865.             default:
  866.                 printf("Can't handle SPU command 0x%02X\n", cmd);
  867.                 return -1;
  868.         }
  869.     }
  870.     printf("SPU packet ran past end of buffer\n");
  871.     return -1;
  872. }
  873.  
  874.  
  875. void init_colors()
  876. {
  877.     int x;
  878.  
  879.     gdk_rgb_init();
  880.  
  881.     // make up a color map with shades
  882.     for (x = 0; x < 0xF; x++)
  883.     {
  884.         clut[x].red = (x+1)*0x11;
  885.         clut[x].green = (x+1)*0x11;
  886.         clut[x].blue = (x+1)*0x11;
  887.     }
  888. }
  889.  
  890. // if packet is -1, do an auto-find
  891. void prepare_packet(int packet, file_buf * fb) {
  892. }
  893.  
  894. int main(int argc, char *argv[])
  895. {
  896.     GtkWidget *window, *darea;
  897.     gint x, y;
  898.     guchar *pos;
  899.     guchar info[4];
  900.  
  901.     char *filename;
  902.     file_buf * fb=NULL;
  903.     int packet;
  904.     int packet_wanted=0;
  905.     off_t spu_packet_start;
  906.     uint8_t * buf=NULL;
  907.     int spu_seq_loc;
  908.     size_t spu_len;
  909.  
  910.  
  911.     gtk_init(&argc, &argv);
  912.     optind = handle_options(argc,argv);
  913.  
  914.     if (opt_version) {
  915.         printf("$Id: gtkspu.c,v 1.19 2004/02/24 05:52:10 nemies Exp $\n");
  916.         exit(0);
  917.     }
  918.  
  919.     if (argc - optind < 1)
  920.         usage(argv);
  921.  
  922.     // start up program initialization
  923.     init_colors();
  924.  
  925.     filename = argv[optind];
  926.     if (argc - optind > 1)
  927.         packet_wanted = atoi(argv[optind+1]);
  928.  
  929.     if (!(fb=buffer_start(fb,filename,DEFAULT_FILE_BUFFER_SIZE))) {
  930.         perror(filename);
  931.         exit(1);
  932.     }
  933.  
  934.     spu_packet_start = opt_skip;
  935.     if (buffer_seek(fb,spu_packet_start) != FILE_BUF_OKAY) {
  936.             perror("seek");
  937.             exit(1);
  938.     }
  939.     for (packet = 0; packet <= packet_wanted; packet++) {
  940.         if (!opt_blind) {
  941.             if (seek_to_next_valid_spu(fb)<0) {
  942.                 printf("No more SPU packets can be found\n");
  943.                 exit(1);
  944.             }
  945.         }
  946.         spu_packet_start=buffer_tell(fb);
  947.         if (buffer_look_ahead(fb, info, 4) == FILE_BUF_OKAY) {
  948.             // execute every sequence in this SPU packet
  949.             spu_len     = GRAB_WORD(info,0);
  950.             spu_seq_loc = GRAB_WORD(info,2);
  951.         }
  952.         else {
  953.             printf("No more packets in file\n");
  954.             exit(1);
  955.         }
  956.                        
  957.         if (packet == packet_wanted) {
  958.             if (!(buf=(uint8_t *)realloc(buf,spu_len))) {
  959.                 perror("malloc");
  960.                 exit(1);
  961.             }
  962.             if (buffer_look_ahead(fb,buf,spu_len) != FILE_BUF_OKAY) {
  963.                 printf("Tried to read SPU packet, but read off end of file\n");
  964.                 free(buf);
  965.                 exit(1);
  966.             }
  967.  
  968.             printf("Packet %d @ offset %"OFF_T_FORMAT" length %u\n",
  969.                    packet,spu_packet_start,spu_len);
  970.             while (spu_seq_loc != -1) {
  971.                 spu_seq_loc = spu_run(buf, spu_packet_start,
  972.                                       spu_seq_loc, spu_len);
  973.             }
  974.             break; // we processed the packet we wanted
  975.         }
  976.         else {
  977.             if (buffer_seek(fb,spu_packet_start+spu_len) != FILE_BUF_OKAY) {
  978.                 printf("Ran off the end of file\n");
  979.                 exit(2);
  980.             }
  981.         }
  982.     }
  983.     if (buf)
  984.         free(buf);
  985.  
  986.     if (width == 0 || height == 0)
  987.     {
  988.         printf("SPU didn't have enough info about window size\n");
  989.         exit(1);
  990.     }
  991.  
  992.     if (!(backbuf = (guchar *) malloc(sizeof(*backbuf) * 3 * width * height)))
  993.     {
  994.         perror("malloc");
  995.         exit(1);
  996.     }
  997.     memset(backbuf, 0xFF, 3 * width * height);
  998.  
  999.     if (!(rgbbuf = (guchar *) malloc(sizeof(*rgbbuf) * 3 * width * height)))
  1000.     {
  1001.         perror("malloc");
  1002.         exit(1);
  1003.     }
  1004.     memset(rgbbuf, 0xFF, 3 * width * height);
  1005.  
  1006.     window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  1007.     darea = gtk_drawing_area_new();
  1008.     gtk_drawing_area_size(GTK_DRAWING_AREA(darea), width, height);
  1009.     gtk_container_add(GTK_CONTAINER(window), darea);
  1010.     gtk_signal_connect(GTK_OBJECT(darea), "expose-event",
  1011.                        GTK_SIGNAL_FUNC(on_darea_expose), NULL);
  1012.     gtk_widget_show_all(window);
  1013.  
  1014.     /* Set up the background RGB buffer. */
  1015.     pos = backbuf;
  1016.     for (y = 0; y < height; y++)
  1017.     {
  1018.         int on = 0;
  1019.         for (x = 0; x < width; x++)
  1020.         {
  1021.             // checker board a la Gimp
  1022.             on = ((x >> 4) & 1);
  1023.             if ((y >> 4 & 1)) on = !on;
  1024.             *pos++ = 0xFF - (on ? 0x80 : 0);      /* Red. */
  1025.             *pos++ = 0xFF - (on ? 0x80 : 0);      /* Green. */
  1026.             *pos++ = 0xFF - (on ? 0x80 : 0);      /* Blue. */
  1027.         }
  1028.     }
  1029.  
  1030.     /* count colors */
  1031.     count_colors(spu_pixelbuf,height,width);
  1032.  
  1033.     gtk_main();
  1034.     return 0;
  1035. }
  1036.  
  1037. // I should deal with the SPU being smaller than the screen area here,
  1038. // rather than drawing a giant spu in the draw_spu function
  1039. gboolean
  1040. on_darea_expose(GtkWidget * widget,
  1041.                 GdkEventExpose * event, gpointer user_data)
  1042. {
  1043.     uint8_t *spu;
  1044.     guchar *screen;
  1045.     guchar *back;
  1046.     gint x, y;
  1047.  
  1048.  
  1049.     // merge back with SPU onto rgbbuf
  1050.     spu = spu_pixelbuf;
  1051.     back = backbuf;
  1052.     screen = rgbbuf;
  1053.     for (y = 0; y < height; y++)
  1054.     {
  1055.         for (x = 0; x < width; x++)
  1056.         {
  1057.             if (*spu > COLOR_NOTHING)
  1058.             {
  1059.                 printf("spu buffer freaked out (%d @ %d,%d)\n", *spu, x, y);
  1060.                 exit(1);
  1061.             }
  1062.             /*
  1063.              * Optimized alpha blending
  1064.              *
  1065.              *   x*a + y*(1-a)       =
  1066.              *   x*a + y*(1) - y*a   =
  1067.              *   x*a - y*a + y       =
  1068.              *   (x-y)*a + y
  1069.              */
  1070.  
  1071.             // Red
  1072.             //*screen = alpha[*spu] * cmap[*spu].red + (0xF-alpha[*spu]) * *back;
  1073.             *screen = (cmap[*spu].red-*back)*alpha[*spu] + *back;
  1074.             screen++;
  1075.             back++;
  1076.             // Green
  1077.             //*screen = alpha[*spu] * cmap[*spu].green + (0xF-alpha[*spu]) * *back;
  1078.             *screen = (cmap[*spu].green-*back)*alpha[*spu] + *back;
  1079.             screen++;
  1080.             back++;
  1081.             // Blue
  1082.             //*screen = alpha[*spu] * cmap[*spu].blue + (0xF-alpha[*spu]) * *back;
  1083.             *screen = (cmap[*spu].blue-*back)*alpha[*spu] + *back;
  1084.             screen++;
  1085.             back++;
  1086.             spu++;
  1087.         }
  1088.     }
  1089.  
  1090.     gdk_draw_rgb_image(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
  1091.                        0, 0, width, height,
  1092.                        GDK_RGB_DITHER_MAX, rgbbuf, width * 3);
  1093.     return 1;
  1094. }
  1095.  
  1096. /* vi:set ai ts=4 sw=4 expandtab: */
  1097.