home *** CD-ROM | disk | FTP | other *** search
/ Aminet 18 / aminetcdnumber181997.iso / Aminet / gfx / misc / mpeg_stat_2_2a.lha / mpeg_stat / src / readfile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-21  |  30.9 KB  |  1,121 lines
  1. /*
  2.  * Copyright (c) 1995 The Regents of the University of California.
  3.  * All rights reserved.
  4.  * 
  5.  * Permission to use, copy, modify, and distribute this software and its
  6.  * documentation for any purpose, without fee, and without written agreement is
  7.  * hereby granted, provided that the above copyright notice and the following
  8.  * two paragraphs appear in all copies of this software.
  9.  * 
  10.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  11.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  12.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  13.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  * 
  15.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  16.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  17.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  18.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  19.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  20.  */
  21.  
  22. #include "video.h"
  23. #include "proto.h"
  24. #include <sys/types.h>
  25. #include <signal.h>
  26. #include <string.h>
  27. #include <machine/endian.h>
  28.  
  29. #ifndef MIPS
  30. #include <netinet/in.h>
  31. #else
  32. #include <bsd/netinet/in.h>
  33. #endif
  34.  
  35. #ifdef __STDC__
  36. #include <stdlib.h>
  37. #else
  38. #include <malloc.h>
  39. #endif
  40.  
  41. #include "util.h"
  42. #include "opts.h"
  43.  
  44. #ifdef __SAVE_DECODED_FILE__
  45. static FILE *hackOutput;
  46. #endif
  47.  
  48. /* 
  49.   Are we a system layer parser or pure video?
  50.   (-1 is uninit, 0 is video, 1 is sys_layer)
  51. */
  52. int sys_layer = -1;
  53. /* Keep track of bytes parsed in system layer */
  54. int audBytes,vidBytes,sysBytes;
  55.  
  56. /* End of File flag. */
  57. extern int EOF_flag;
  58.  
  59. /* Global file pointer to incoming data. */
  60. extern FILE *input;
  61.  
  62. /* Options to control logging */
  63. extern FILE *syslogOutput;
  64. extern int opts;
  65.   
  66.   
  67. /*
  68.  *--------------------------------------------------------------
  69.  *
  70.  * get_more_data --
  71.  *
  72.  *    Called by get_more_data to read in more data from
  73.  *      video MPG files (non-system-layer)
  74.  *
  75.  * Results:
  76.  *    Input buffer updated, buffer length updated.
  77.  *      Returns 1 if data read, 0 if EOF, -1 if error.
  78.  *
  79.  * Side effects:
  80.  *      None.
  81.  *
  82.  *--------------------------------------------------------------
  83.  */
  84. int 
  85.   get_more_data(bs_ptr, max_length, length_ptr, buf_ptr)
  86. unsigned int **bs_ptr;
  87. int *max_length, *length_ptr;
  88. unsigned int **buf_ptr;
  89. {
  90.   static BOOLEAN swap;
  91.   int ioBytes, data, result;
  92.   unsigned int *mark;
  93.   
  94.   if (sys_layer == 0) {
  95.     return pure_get_more_data(*bs_ptr, *max_length, length_ptr, buf_ptr, swap);
  96.   }
  97.   if (sys_layer == -1) {
  98.     /* Time to init ourselves */
  99.     swap = (htonl(1)!=1);
  100.     mark = *bs_ptr;
  101.     ioBytes = fread(&data,1,4,input);
  102.     if (ioBytes!=4) return 0;
  103.     data=ntohl(data);
  104.     if ((data==PACK_START_CODE) || (data==SYSTEM_HEADER_START_CODE)) {
  105.       /* Yow, a System Layer Stream.  Much harder to parse.  Call in the
  106.      specialist.... */
  107.       fprintf(stderr,"This is an MPEG System Layer Stream.  ");
  108.       fprintf(stderr,"Audio is not analyzed.\n");
  109.       sys_layer=1;
  110.       init_read_sys();
  111.       result= read_sys(bs_ptr, max_length, length_ptr, buf_ptr, data);
  112. #ifdef __SAVE_DECODED_FILE__
  113.       fwrite((unsigned char *)(*buf_ptr),1,*length_ptr*4,hackOutput);
  114. #endif
  115.       return result;
  116.     } else {
  117.       /* No system Layer junk, just pretent we didn't peek,
  118.      and hereafter just call pure_get_more_data */
  119.       sys_layer=0;
  120.       **bs_ptr=data;
  121.       *length_ptr=1;
  122.       result= pure_get_more_data(*bs_ptr, *max_length, 
  123.                  length_ptr, buf_ptr, swap);
  124.       *buf_ptr= *bs_ptr;
  125.       return result;
  126.     }}
  127.   /* A system layer stream (called after the 1st time), call the specialist */
  128. #ifdef __SAVE_DECODED_FILE__
  129.   data= *length_ptr;
  130. #endif
  131.   result=read_sys(bs_ptr, max_length, length_ptr, buf_ptr, 0);
  132. #ifdef __SAVE_DECODED_FILE__
  133.   fwrite((unsigned char *) ((*buf_ptr)+data),1,4*((*length_ptr)-data),hackOutput);
  134. #endif
  135.   return result;
  136. }
  137. /*
  138.  *--------------------------------------------------------------
  139.  *
  140.  * pure_get_more_data --
  141.  *      (get_more_data from ver 2.0 with swap added)
  142.  *
  143.  *    Called by get_more_data to read in more data from
  144.  *      video MPG files (non-system-layer)
  145.  *
  146.  * Results:
  147.  *    Input buffer updated, buffer length updated.
  148.  *      Returns 1 if data read, 0 if EOF, -1 if error.
  149.  *
  150.  * Side effects:
  151.  *      None.
  152.  *
  153.  *--------------------------------------------------------------
  154.  */
  155.  
  156. int 
  157.   pure_get_more_data(buf_start, max_length, length_ptr, buf_ptr, swap)
  158. unsigned int *buf_start;
  159. int max_length;
  160. int *length_ptr;
  161. unsigned int **buf_ptr;
  162. BOOLEAN swap;
  163. {
  164.   
  165.   int length, num_read, i, request;
  166.   unsigned char *buffer, *mark;
  167.   unsigned int *lmark;
  168.   
  169.   if (EOF_flag) return 0;
  170.   
  171.   length = *length_ptr;
  172.   buffer = (unsigned char *) *buf_ptr;
  173.   
  174.   if (length > 0) {
  175.     memcpy((void *) buf_start, (void *) buffer, (size_t) (length*4));
  176.     mark = ((unsigned char *) (buf_start + length));
  177.   }
  178.   else {
  179.     mark = (unsigned char *) buf_start;
  180.     length = 0;
  181.   }
  182.   
  183.   request = (max_length-length)*4;
  184.   
  185.   
  186.   num_read = fread( mark, 1, request, input);
  187.   
  188.   /* Paulo Villegas - 26/1/1993: Correction for 4-byte alignment */
  189.   {
  190.     int num_read_rounded;
  191.     unsigned char *index;
  192.     
  193.     num_read_rounded = 4*(num_read/4);
  194.     
  195.     /* this can happen only if num_read<request; i.e. end of file reached */
  196.     if( num_read_rounded < num_read )
  197.       { 
  198.      num_read_rounded = 4*( num_read/4+1 );
  199.      /* fill in with zeros */
  200.      for( index=mark+num_read; index<mark+num_read_rounded; *(index++)=0 );
  201.      /* advance to the next 4-byte boundary */
  202.      num_read = num_read_rounded;
  203.       }
  204.   }
  205.   
  206.   if   (num_read < 0) {
  207.     return -1;
  208.   }
  209.   else if (num_read == 0) {
  210.     *buf_ptr = buf_start;
  211.     
  212.     /* Make 32 bits after end equal to 0 and 32
  213.        bits after that equal to seq end code
  214.        in order to prevent messy data from infinite
  215.        recursion.
  216.        */
  217.     
  218.     *(buf_start + length) = 0x0;
  219.     *(buf_start + length+1) = SEQ_END_CODE;
  220.     
  221.     EOF_flag = 1;
  222.     return 0;
  223.   }
  224.   
  225.   lmark = (unsigned int *) mark;
  226.   
  227.   num_read = num_read/4;
  228.   
  229.   if (swap) {
  230.     for (i=0; i<num_read; i++) {
  231.       *lmark = htonl(*lmark);
  232.       lmark++;
  233.     }
  234.   }
  235.   
  236.   *buf_ptr = buf_start;
  237.   *length_ptr = length + num_read;
  238.   
  239.   return 1;
  240. }
  241.  
  242.  
  243.  
  244.  
  245. /* 
  246.   Here is the specialist.... 
  247.   Code is adapted from our program demux....
  248.   A bunch of this needs to be #ifdef ANALYSIS'ed
  249.   define __SYSREAD_LOGGING_ON__ to get  an output file for debugging
  250.   */
  251.  
  252.  
  253. /* Stream IDs */
  254. static int gAudioStreamID;
  255. static int gVideoStreamID;
  256. static int gReservedStreamID;
  257.  
  258. #ifdef ANALYSIS
  259. /* Statistics */
  260. static int gNumAudioPackets;
  261. static int gNumVideoPackets;
  262. static int gNumPaddingPackets;
  263. static int gNumReservedPackets;
  264. static int gNumPrivate_1_Packets;
  265. static int gNumPrivate_2_Packets;
  266. #endif
  267.  
  268. /*
  269.  *----------------------------------------------------------
  270.  *
  271.  *  init_read_sys
  272.  *
  273.  *      Called before read_sys is used to parse the file.
  274.  *      Currently only sets up the logging file (when defined)
  275.  *
  276.  *  Results:  None
  277.  *
  278.  *  Side Effects: Zeros Byte counts, opens Hack Output if needed
  279.  *
  280.  *----------------------------------------------------------
  281.  */
  282. void init_read_sys() {
  283. #ifdef __SAVE_DECODED_FILE__
  284.   hackOutput = fopen("hack.vid", "w");
  285.   if (hackOutput == NULL) {
  286.     fprintf(stderr, "Can't open output file \"hack.vid\"\n");
  287.     exit(1);
  288.   }
  289. #endif
  290.   audBytes=0; vidBytes=0; sysBytes=0;
  291. }
  292.  
  293.  
  294. /*
  295.  *----------------------------------------------------------
  296.  *
  297.  *  read_sys
  298.  *
  299.  *      Parse out a packet of the system layer MPEG file.
  300.  *
  301.  *  Results:  Returns 0 if error or EOF
  302.  *            Returns 1 if more data read (could be just one int)
  303.  *
  304.  *  Side Effects:  ReadPacket can change *bs_ptr to be a new buffer
  305.  *                 buf_ptr will remain pointing at *length_ptr (at input)
  306.  *                         into the buffer
  307.  *                 *length_ptr will be changed to the new size
  308.  *                 *max_length can be changed if a new buffer is alloc'd
  309.  *
  310.  *----------------------------------------------------------
  311.  */
  312. int read_sys(bs_ptr, max_length, length_ptr, buf_ptr, start)
  313.      unsigned int **bs_ptr;
  314.      int *max_length, *length_ptr;
  315.      unsigned int **buf_ptr, start;  
  316.      /* start is either a start code or 0 to indicate continued parsing */
  317. {
  318.   unsigned int startCode;
  319.   int errorCode, PacketReply;
  320.   unsigned char packetID;
  321.   double systemClockTime;
  322.   unsigned long muxRate;
  323.   /* Statistics */
  324.   static int numPacks = 0;
  325.   static int numPackets = 0;
  326.   static int numSystemHeaders = 0;
  327.   static BOOLEAN Parse_done=FALSE;
  328.   BOOLEAN match;
  329.   
  330.   if (!start) {
  331.     errorCode = ReadStartCode(&startCode);
  332.     if (EOF_flag) return 0;
  333.     if (errorCode != 0) {
  334.       fprintf(stderr, "Unable to read initial pack start code\n");
  335.       return 0;
  336.     }}
  337.   else {
  338.     errorCode = 0;
  339.     startCode = start;
  340.   }
  341.   
  342.   while (1) {
  343.     match=FALSE;
  344.     if (startCode == PACK_START_CODE) {
  345.       ++numPacks; match=TRUE;
  346.       if (opts&SYSLAYER_LOG) {
  347.     fprintf(syslogOutput, "PACK #%d:\n", numPacks);
  348.       }
  349.       errorCode = ReadPackHeader( &systemClockTime, &muxRate);
  350.       if (errorCode != 0) {
  351.     fprintf(stderr, "Error in reading pack header\n");
  352.     return 0;
  353.       }
  354.       errorCode = ReadStartCode( &startCode);
  355.       if (errorCode != 0) {
  356.     fprintf(stderr, "Error in reading start code\n");
  357.     return 0;
  358.       }
  359.     }
  360.     if (startCode == SYSTEM_HEADER_START_CODE) {
  361.       if (opts&SYSLAYER_LOG) {
  362.     fprintf(syslogOutput, "SYSTEM HEADER:\n");
  363.       }
  364.       ++numSystemHeaders; match=TRUE;
  365.       errorCode = ReadSystemHeader();
  366.       if (errorCode != 0) {
  367.     fprintf(stderr, "Error in reading system header\n");
  368.     return 0;
  369.       }
  370.       errorCode = ReadStartCode( &startCode);
  371.       if (errorCode != 0) {
  372.     fprintf(stderr,"Error in reading start code after system header\n");
  373.     return 0;
  374.       }
  375.     }
  376.     packetID = startCode & 0xff;
  377.     while (((startCode & PACKET_START_CODE_MASK) == PACKET_START_CODE_PREFIX) &&
  378.        (packetID>=0xbc)) {
  379.       ++numPackets; match=TRUE;
  380.       packetID = startCode & 0xff;
  381.       if (opts&SYSLAYER_LOG) {
  382.     fprintf(syslogOutput, "PACKET ID %02x:\n", packetID);
  383.       }
  384.       PacketReply = ReadPacket(packetID, bs_ptr, max_length, length_ptr, buf_ptr);
  385.       switch (PacketReply) {
  386.       case 2: 
  387.     return 1;
  388.       case 1: 
  389.     if (opts&SYSLAYER_LOG) {
  390.       fprintf(syslogOutput, "Problems in ReadPacket, returning partial.\n");
  391.     }
  392.     return 0;
  393.       default: /* do nothing */
  394.     break;
  395.       }
  396.       errorCode = ReadStartCode( &startCode);
  397.       if (errorCode != 0) {
  398.     fprintf(stderr,"Error in start code after packet\n");
  399.     return 0;
  400.       }
  401.       if (startCode == PACK_START_CODE || startCode == ISO_11172_END_CODE)
  402.     break;
  403.     }
  404.     if (startCode == ISO_11172_END_CODE) {
  405.       match=TRUE;
  406.       if (Parse_done) return 1;
  407. #ifdef ANALYSIS
  408.       fprintf(stderr, "Successful parse of MPEG system level\n");
  409.       fprintf(stderr, "%d system headers, %d packs, %d packets\n",
  410.           numSystemHeaders, numPacks, numPackets);
  411.       fprintf(stderr, "%d audio packets, %d video packets, %d padding packets\n",
  412.           gNumAudioPackets, gNumVideoPackets, gNumPaddingPackets);
  413.       fprintf(stderr, "%d reserved packets, %d/%d private type 1/2 packets\n",
  414.           gNumReservedPackets, gNumPrivate_1_Packets, gNumPrivate_2_Packets);
  415. #endif
  416.       ReadPacket(NOT_PACKET_ID, bs_ptr, max_length, length_ptr, buf_ptr);
  417.       Parse_done=TRUE;
  418.       return 1;
  419.     }
  420.     if (errorCode != 0)
  421.       return 1;
  422.     if (!match) {
  423.       fprintf(stderr,"\nNo match found for start code %08x in system layer, skipping\n",startCode);
  424.       if (opts&SYSLAYER_LOG)
  425.     fprintf(syslogOutput, "Error with start code %08x, did not match at %d\n",
  426.         startCode, (int) ftell(input));  
  427.       startCode=(int) find_start_code();
  428.       if (opts&SYSLAYER_LOG) {
  429.     if (startCode==EOF) 
  430.       fprintf(syslogOutput, "Found EOF in find_start_code\n");
  431.     else fprintf(syslogOutput, "Found %08x at %d\n",
  432.              startCode, (int) ftell(input));  
  433.       }
  434.       if (startCode==EOF) {
  435.     EOF_flag=1;
  436.     return 0;
  437.       }
  438.     }
  439.   }
  440.   return 0; /* shouldnt get here */
  441. }
  442.  
  443. /*
  444.  *-----------------------------------------------------------
  445.  *
  446.  *  ReadStartCode
  447.  *
  448.  *      Parses a start code out of the stream
  449.  *
  450.  *  Results/Side Effects:  Sets *startCode to the code, returns
  451.  *     1 on error, 0 on success
  452.  *
  453.  *-----------------------------------------------------------
  454.  */
  455. int ReadStartCode(startCode)
  456.      unsigned int *startCode;
  457. {
  458.   int numRead;
  459.   
  460.   numRead = fread((unsigned char *)startCode, 1, 4, input);
  461.   *startCode=htonl(*startCode);
  462.   
  463.   if (numRead < 4) {
  464.     if ((opts&SYSLAYER_LOG)&&(EOF_flag==0)) {
  465.       fprintf(syslogOutput, "Error in reading start code, only got %d bytes\n", 
  466.               numRead);
  467.     }
  468.     EOF_flag=1;
  469.     return 1;
  470.   }
  471.   if (opts&SYSLAYER_LOG) {
  472.     fprintf(syslogOutput, "Read as start code: %08x\n", *startCode);
  473.   }
  474.   if ((*startCode&0xfffffe00) != 0) {
  475.     int start_pos;
  476.     fprintf(stderr,"Problem with system layer parse, skipping to start code\n");
  477.     if (opts&SYSLAYER_LOG) {
  478.       start_pos = (int) ftell(input);
  479.       fprintf(syslogOutput, "Error with start code, not a start code! at %d\n",
  480.           start_pos);  
  481.     }
  482.     *startCode=(int) find_start_code();
  483.     if (*startCode==EOF) {
  484.       if (opts&SYSLAYER_LOG) {
  485.     fprintf(syslogOutput, "Skipped all the way to EOF!\n");
  486.     }
  487.       EOF_flag=TRUE;
  488.       return 0;
  489.     }
  490.     if (opts&SYSLAYER_LOG) {
  491.       int end_pos=(int) ftell(input);
  492.       fprintf(syslogOutput, "Found %08x at %d, skipped over %d bytes.\n",
  493.           *startCode, end_pos, end_pos-start_pos);
  494.     }
  495.   }
  496.   sysBytes+=4;
  497.   return 0;
  498. }
  499.  
  500. /*
  501.  *-----------------------------------------------------------
  502.  *
  503.  *  find_start_code
  504.  *
  505.  *      Parses a start code out of the stream by tossing bytes until it gets one
  506.  *
  507.  *  Results/Side Effects:  Parses bytes of the stream, returns code
  508.  *                         Returns EOF in case of end of file
  509.  *
  510.  *-----------------------------------------------------------
  511.  */
  512. int find_start_code()
  513. {
  514.  NO_ZEROS:
  515.   switch(fgetc(input)) {
  516.   case 0:    goto ONE_ZERO;
  517.   case EOF:  goto EOF_FOUND;
  518.   default:   goto NO_ZEROS;
  519.   }
  520.  
  521.  ONE_ZERO:
  522.   switch(fgetc(input)) {
  523.   case 0:    goto TWO_ZEROS;
  524.   case EOF:  goto EOF_FOUND;
  525.   default:   goto NO_ZEROS;
  526.   }
  527.  
  528.  TWO_ZEROS:
  529.   switch(fgetc(input)) {
  530.   case 0x01:  goto CODE_FOUND;
  531.   case 0x00:  goto TWO_ZEROS;
  532.   case EOF:  goto EOF_FOUND;
  533.   default:    goto NO_ZEROS;
  534.   }
  535.  
  536.  CODE_FOUND:
  537.   return 0x00000100+fgetc(input);
  538.  
  539.  EOF_FOUND:   /* received EOF */
  540.   return EOF;
  541. }
  542.  
  543.  
  544.  
  545. /*
  546.  *-----------------------------------------------------------------
  547.  *
  548.  *  ReadPackHeader
  549.  *
  550.  *      Parses out the PACK header
  551.  *
  552.  *  Returns: 1 on error, 0 on success
  553.  *
  554.  *-------------------------------------------------------------------
  555.  */
  556. int ReadPackHeader(systemClockTime,muxRate)
  557.      double *systemClockTime;
  558.      unsigned long *muxRate;
  559. {
  560.   int numRead;
  561.   unsigned char inputBuffer[PACK_HEADER_SIZE];
  562.   unsigned long systemClockRef;
  563.   unsigned char systemClockRefHiBit;
  564.   int errorCode;
  565.   
  566.   numRead = fread(inputBuffer, 1, PACK_HEADER_SIZE, input);
  567.   if (numRead < PACK_HEADER_SIZE) {
  568.     EOF_flag=1;
  569.     if (opts&SYSLAYER_LOG) {
  570.       fprintf(syslogOutput, 
  571.               "Error in reading Pack header, only got %d bytes\n", numRead);
  572.     }
  573.     return 1;
  574.   }
  575.   sysBytes+=numRead;
  576.   ReadTimeStamp(inputBuffer, &systemClockRefHiBit, &systemClockRef);
  577.   errorCode = MakeFloatClockTime(systemClockRefHiBit, systemClockRef, 
  578.                  systemClockTime);
  579.   ReadRate(&inputBuffer[5], muxRate);
  580.   *muxRate *= MUX_RATE_SCALE_FACTOR;
  581.   if (opts&SYSLAYER_LOG) {
  582.     fprintf(syslogOutput, "\tSystem clock reference: %d, %lu (0x%x%08x)\n",
  583.         (int)systemClockRefHiBit, systemClockRef,
  584.         (int)systemClockRefHiBit, systemClockRef);
  585.     if (errorCode == 0) {
  586.       fprintf(syslogOutput, "\tSystem clock time: %1.4lf\n", *systemClockTime);
  587.     } else {
  588.       fprintf(syslogOutput, "Error reading system clock time\n");
  589.     }
  590.     fprintf(syslogOutput, "\tmuxRate: %lu (0x%08x)\n", *muxRate, *muxRate);
  591.   }
  592.   return 0;
  593. }
  594.  
  595. /*
  596.  *------------------------------------------------------------------
  597.  *
  598.  *   ReadSystemHeader
  599.  *
  600.  *      Parse out the system header, setup out dtream IDs for parsing packets
  601.  *
  602.  *   Results:  Returns 1 on error, 0 on success.
  603.  *             Sets gAudioStreamID and gVideoStreamID
  604.  *
  605.  *------------------------------------------------------------------
  606.  */
  607. int ReadSystemHeader()
  608. { 
  609.   unsigned char *inputBuffer = NULL;
  610.   int numRead;
  611.   int pos,i;
  612.   unsigned short headerSize;
  613.   unsigned char streamID;
  614.   /* Only needed for system log file */
  615.   unsigned long rateBound;
  616.   unsigned long audioBound;
  617.   unsigned char fixedFlag;
  618.   unsigned char cspsFlag;
  619.   unsigned long videoBound;
  620.   unsigned char sysAudioLockFlag;
  621.   unsigned char sysVideoLockFlag;
  622.   unsigned char stdBufferScale;
  623.   unsigned long stdBufferSize;
  624.   
  625.   numRead = fread((char *)&headerSize, 1, 2, input); 
  626.   headerSize=ntohs(headerSize);
  627.   if (numRead != 2) {
  628.     EOF_flag=1;
  629.     if (opts&SYSLAYER_LOG) {
  630.       fprintf(syslogOutput, 
  631.               "error in reading System header size, only got %d bytes\n", 
  632.               numRead);
  633.     }
  634.     return 1;
  635.   }
  636.   inputBuffer = (unsigned char *) malloc(headerSize+1);
  637.   sysBytes+=headerSize;
  638.   if (inputBuffer == NULL) {
  639.     if (opts&SYSLAYER_LOG) {
  640.       fprintf(syslogOutput, 
  641.               "error in allocating %d bytes\n", headerSize);
  642.     }
  643.     return 1;
  644.   }
  645.   inputBuffer[headerSize]=0;
  646.   numRead = fread(inputBuffer, 1, headerSize, input); 
  647.   if (opts&SYSLAYER_LOG) {
  648.     for(i=0;i<headerSize;i++) 
  649.       fprintf(syslogOutput, 
  650.               "%x ",*(inputBuffer+i));
  651.     fprintf(syslogOutput,"\n");
  652.   }
  653.   if (numRead < headerSize) {
  654.     EOF_flag=1;
  655.     if (opts&SYSLAYER_LOG) {
  656.       fprintf(syslogOutput, 
  657.               "error in reading System Header, only got %d bytes\n", 
  658.               numRead);
  659.     }
  660.     return 1;
  661.   }
  662.   if (opts&SYSLAYER_LOG) {
  663.     ReadRate(&inputBuffer[0], &rateBound);
  664.     rateBound *= MUX_RATE_SCALE_FACTOR;
  665.     fprintf(syslogOutput, "\trate_bound: %lu (0x%08x)\n", rateBound, rateBound);
  666.     audioBound = (unsigned long)inputBuffer[3] >> 2;
  667.     fprintf(syslogOutput, "\taudio_bound: %lu (0x%08x)\n", audioBound, audioBound);
  668.     fixedFlag = (inputBuffer[3] >> 1) & 0x01;
  669.     fprintf(syslogOutput, "\tfixed_flag: %d\n", fixedFlag);
  670.     cspsFlag = inputBuffer[3] & 0x01;
  671.     fprintf(syslogOutput, "\tCSPS_flag: %d\n", cspsFlag);
  672.     videoBound = (unsigned long)inputBuffer[4] & 0x1f;
  673.     fprintf(syslogOutput, "\tvideo_bound: %lu (0x%08x)\n", videoBound, videoBound);
  674.     sysAudioLockFlag = (inputBuffer[4] & 0x80) >> 7;
  675.     fprintf(syslogOutput, "\tsystem_audio_lock_flag: %d\n", sysAudioLockFlag);
  676.     sysVideoLockFlag = (inputBuffer[4] & 0x40) >> 6;
  677.     fprintf(syslogOutput, "\tsystem_video_lock_flag: %d\n", sysVideoLockFlag);
  678.   }
  679.   
  680.   pos = 6;
  681.   while ((inputBuffer[pos] & 0x80) == 0x80) {
  682.     streamID = inputBuffer[pos];
  683.     if (opts&SYSLAYER_LOG) {
  684.       ReadSTD(&inputBuffer[pos + 1], &stdBufferScale, &stdBufferSize);
  685.       fprintf(syslogOutput, 
  686.               "\tRead STD_buffer_scale = %d, STD_buffer_size = %lu (0x%0x)\n",
  687.               (int)stdBufferScale, stdBufferSize, stdBufferSize);
  688.       fprintf(syslogOutput, "\tSystem Header: stream with ID 0x%x\n", streamID); 
  689.     }
  690.     switch (streamID) {
  691.     case STD_VIDEO_STREAM_ID: 
  692.       if (opts&SYSLAYER_LOG) {
  693.     fprintf(syslogOutput, "\tSystem Header: Std video stream\n");
  694.       }
  695.       break;
  696.     case STD_AUDIO_STREAM_ID: 
  697.       if (opts&SYSLAYER_LOG) {
  698.     fprintf(syslogOutput, "\tSystem Header: Std audio stream\n");
  699.       }
  700.       break;
  701.     case RESERVED_STREAM_ID: 
  702.       if (opts&SYSLAYER_LOG) {
  703.     fprintf(syslogOutput, "\tSystem Header: Reserved stream\n");
  704.       }
  705.       break;
  706.     case PADDING_STREAM_ID: 
  707.       if (opts&SYSLAYER_LOG) {
  708.     fprintf(syslogOutput, "\tSystem Header: Padding stream\n");
  709.       }
  710.       break;
  711.     case PRIVATE_STREAM_1_ID: 
  712.       if (opts&SYSLAYER_LOG) {
  713.     fprintf(syslogOutput, "\tSystem Header: Private (1) stream\n");
  714.       }
  715.       break;
  716.     case PRIVATE_STREAM_2_ID: 
  717.       if (opts&SYSLAYER_LOG) {
  718.     fprintf(syslogOutput, "\tSystem Header: Private (2) stream\n");
  719.       }
  720.       break;
  721.     case 0xb1:
  722.       if (streamID < MIN_STREAM_ID_ID) {
  723.     if (opts&SYSLAYER_LOG) {
  724.       fprintf(syslogOutput, "\tSystem Header: Illegal stream ID\n");
  725.       fprintf(syslogOutput, "\tWe believe MPOWER is creating invalid codes here.\n");
  726.     }
  727.     return 1;
  728.       }
  729.       
  730.     default:
  731.       if (streamID < MIN_STREAM_ID_ID) {
  732.     if (opts&SYSLAYER_LOG) {
  733.       fprintf(syslogOutput, "\tSystem Header: Illegal stream ID\n");
  734.     }
  735.     return 1;
  736.       }
  737.       switch (streamID >> 4) {
  738.       case 0xc:
  739.       case 0xd:
  740.     if (opts&SYSLAYER_LOG) {
  741.       fprintf(syslogOutput, "\tSystem Header: audio stream #%d\n",
  742.           (streamID & 0x1f));
  743.     }
  744.     gAudioStreamID = streamID;
  745.     break;
  746.       case 0xe:
  747.     if (opts&SYSLAYER_LOG) {
  748.       fprintf(syslogOutput, "\tSystem Header: video stream #%d\n",
  749.           (streamID & 0xf));
  750.     }
  751.     if ((gVideoStreamID != 0) && (gVideoStreamID!=streamID)) {
  752.       if (opts&SYSLAYER_LOG) {
  753.         fprintf(syslogOutput, 
  754.             "\tThis program can only handle a single video stream\n");
  755.       }
  756.       break;
  757.     }
  758.     gVideoStreamID = streamID;
  759.     break;
  760.       case 0xf:
  761.     gReservedStreamID = streamID;
  762.     if (opts&SYSLAYER_LOG) {
  763.       fprintf(syslogOutput, "S\tystem Header: reserved stream #%d\n",
  764.           (streamID & 0xf));
  765.     }
  766.     break;
  767.       }
  768.       break;
  769.     }
  770.     pos += 3;
  771.   }
  772.   if (inputBuffer != NULL)
  773.     free(inputBuffer);
  774.   return 0;
  775. }
  776.  
  777. /*
  778.  *-----------------------------------------------------------------
  779.  *
  780.  *  ReadPacket
  781.  *
  782.  *      Reads a single packet out of the stream, and puts it in the
  783.  *      buffer if it is video.
  784.  *
  785.  *  Results:
  786.  *      Changes the value of *length_ptr to be the new length (plus old)
  787.  *      If the buffer is too small, can change *bs_ptr, *max_length, and *buf_ptr
  788.  *      to be correct for a newly allocated buffer.
  789.  *
  790.  *  State:  The buffer is in ints, but the packets can be an arbitrary number
  791.  *      of bytes, so leftover bytes are kept in static vars and added in on the
  792.  *      next call.
  793.  *
  794.  *-----------------------------------------------------------------
  795.  */   
  796. int ReadPacket(packetID, bs_ptr, max_length, length_ptr, buf_ptr) 
  797. unsigned char packetID;
  798. unsigned int **bs_ptr;
  799. int *max_length;
  800. int *length_ptr;
  801. unsigned int **buf_ptr;
  802. /* Returns:
  803.    0 - no error, but not video packet we want
  804.    1 - error
  805.    2 - got video packet into buffer
  806.    */
  807. {   
  808.   int ioBytes;
  809.   unsigned char nextByte;
  810.   unsigned short packetLength;
  811.   unsigned char *packetBuffer = NULL;
  812.   int pos;
  813.   int numStuffBytes = 0;
  814.   int packetDataLength;
  815.   int byte_length;
  816.   unsigned char scratch[10];
  817.   int errorCode; /* For syslog */
  818.   /* Leftovers from previous video packets */
  819.   static unsigned int num_left=0, leftover_bytes=0;
  820.   
  821.   if (packetID==NOT_PACKET_ID) {
  822.     /* Gross hack to handle unread bytes before end of stream */
  823.     if (num_left!=0) {
  824.       /* Sigh, deal with previous leftovers */
  825.       *(*buf_ptr+*length_ptr)=leftover_bytes;
  826.       *(*buf_ptr+*length_ptr+1)=ISO_11172_END_CODE;
  827.       *length_ptr+=2;
  828.     } else {
  829.       *(*buf_ptr+*length_ptr)=ISO_11172_END_CODE;
  830.       *length_ptr+=1;
  831.     }
  832.     return 1;
  833.   }
  834.   
  835.   ioBytes = fread(&packetLength, 1, 2, input);
  836.   packetLength=htons(packetLength);
  837.   if (ioBytes < 2) {
  838.     if (opts&SYSLAYER_LOG) {
  839.       fprintf(syslogOutput, "ReadPacket: Error in reading packet length\n");
  840.     }
  841.     return 1;
  842.   }
  843.   if (opts&SYSLAYER_LOG) {
  844.     fprintf(syslogOutput, 
  845.         "\tinput packet with ID %02x has length = %d at file offset %d\n", 
  846.         packetID, packetLength, (int) ftell(input));
  847.   }
  848.   if (packetID == gAudioStreamID) {
  849. #ifdef ANALYSIS
  850.     ++gNumAudioPackets;
  851. #endif
  852.   }
  853.   else if (packetID == gVideoStreamID) {
  854. #ifdef ANALYSIS     
  855.     ++gNumVideoPackets;
  856. #endif
  857.   }
  858.   else {
  859.     switch (packetID) {
  860.     case PADDING_STREAM_ID:
  861.       if (opts&SYSLAYER_LOG) {
  862.     fprintf(syslogOutput, "\tPadding packet.\n");
  863.       }
  864. #ifdef ANALYSIS
  865.       ++gNumPaddingPackets;
  866. #endif
  867.       break;
  868.     case RESERVED_STREAM_ID:
  869.       if (opts&SYSLAYER_LOG) {
  870.     fprintf(syslogOutput, "\tReserved packet.\n");
  871.       }
  872. #ifdef ANALYSIS
  873.       ++gNumReservedPackets;
  874. #endif
  875.       break;
  876.     case PRIVATE_STREAM_1_ID:
  877.       if (opts&SYSLAYER_LOG) {
  878.     fprintf(syslogOutput, "\tPrivate packet type 1.\n");
  879.       }
  880. #ifdef ANALYSIS
  881.       ++gNumPrivate_1_Packets;
  882. #endif
  883.       break;
  884.     case PRIVATE_STREAM_2_ID:
  885.       if (opts&SYSLAYER_LOG) {
  886.     fprintf(syslogOutput, "\tPrivate packet type 2.\n");
  887.       }
  888. #ifdef ANALYSIS
  889.       ++gNumPrivate_2_Packets;
  890. #endif
  891.       break;
  892.     default:
  893.       fprintf(stderr, "\nUnknown packet type encountered. P'bly audio? (%x) at %d\n",
  894.           packetID,(int) ftell(input));
  895.       if (opts&SYSLAYER_LOG) {
  896.     fprintf(syslogOutput,"\tUnknown packet type encountered. P'bly audio. (%x), length %d at offset %d.\n",
  897.         packetID,packetLength,(int) ftell(input));
  898.     fflush(syslogOutput);
  899.       }
  900.     } /* switch */
  901.   } /* else */
  902.  
  903.   if (packetID != gVideoStreamID) {        /* changed by jim */
  904.     if (opts&SYSLAYER_LOG) {
  905.       fprintf(syslogOutput, "\tSkipping over this packet.\n");
  906.     }
  907.     fseek(input, packetLength, 1);
  908.     sysBytes+=packetLength;
  909.     return 0;
  910.   }
  911.  
  912.   fread(&nextByte,1,1,input);
  913.   pos = 0;
  914.   while (nextByte & 0x80) {
  915.     ++numStuffBytes;
  916.     if (opts&SYSLAYER_LOG) {
  917.       if (nextByte != 0xff)
  918.     fprintf(syslogOutput, "\tWarning: stuffing byte = 0x%x not 0xff\n", 
  919.         (int)nextByte);
  920.     }
  921.     ++pos;
  922.     fread(&nextByte,1,1,input);
  923.   }
  924.   if (numStuffBytes > 0)
  925.     if (opts&SYSLAYER_LOG) {
  926.       fprintf(syslogOutput, "\tSkipped %d stuffing bytes\n", numStuffBytes);
  927.     }
  928.   if ((nextByte >> 6) == 0x01) {
  929.     pos += 2;
  930.     fread(&nextByte,1,1,input);
  931.     fread(&nextByte,1,1,input);
  932.   } 
  933.   if ((nextByte >> 4) == 0x02) {
  934.     scratch[0] = nextByte;            /* jim */
  935.     fread(&scratch[1],1,4,input);        /* jim */
  936.     fread(&nextByte,1,1,input);
  937.     pos+=5;
  938.   }
  939.   else if ((nextByte >> 4) == 0x03) {
  940.     scratch[0] = nextByte;            /* jim */
  941.     fread(&scratch[1],1,9,input);        /* jim */
  942.     fread(&nextByte,1,1,input);
  943.     pos += 10;
  944.   } 
  945.   else {
  946.     if (opts&SYSLAYER_LOG) {
  947.       fprintf(syslogOutput, "\tRead 0x%02x (s.b. 0x0f)\n", nextByte);
  948.     }
  949.     fread(&nextByte,1,1,input);
  950.     pos += 1;
  951.   }
  952. #define TC_STUFF
  953. #define xTC_DEBUG
  954. #ifdef TC_STUFF
  955.   if (((scratch[0] >> 4) == 0x02) || ((scratch[0] >> 4) == 0x03)) {
  956.     unsigned long pts, dts;
  957.     unsigned char pts_high, dts_high;
  958.     
  959.     if (opts&SYSLAYER_LOG) {
  960.       fprintf(syslogOutput, "\ttimestamp at offset %ld\n", ftell(input));
  961. #ifdef TC_DEBUG
  962.       fprintf(syslogOutput, "\tdata: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
  963.           savebyte, scratch[0], scratch[1], scratch[2], scratch[3], scratch[4],
  964.           scratch[5], scratch[6], scratch[7], scratch[8]);
  965. #endif
  966.     }
  967.  
  968.     if (opts&SYSLAYER_LOG) {
  969.       if((scratch[0] >> 4) == 0x3) {
  970.         ReadTimeStamp(&scratch[5], &dts_high, &dts);
  971.         fprintf(syslogOutput, "\tdts: %01x, %u (0x%08x)\n", dts_high, dts, dts);
  972.       }
  973.       ReadTimeStamp(scratch, &pts_high, &pts);
  974.       fprintf(syslogOutput, "\tpts: %01x, %u (0x%08x)\n", pts_high, pts, pts);
  975.     }
  976.   }
  977. #endif
  978.   /* Read all the headers, now make room for packet */
  979.   if (*bs_ptr+*max_length<*buf_ptr+packetLength/4+*length_ptr) {
  980.     if (opts&SYSLAYER_LOG) {
  981.       fprintf(syslogOutput, "\tProblems with buffer length! %d %d\n",
  982.           *max_length-*length_ptr,packetLength/4);
  983.     }
  984.     if (*max_length-*length_ptr<packetLength/4) {
  985.       /* Buffer too small for a packet (plus whats there),
  986.      time to enlarge it! */
  987.       unsigned int *old= *bs_ptr;
  988.       if (opts&SYSLAYER_LOG) {
  989.     fprintf(syslogOutput,"\tMega Resize! old=%d, new=%d\n",
  990.         *max_length,*length_ptr + packetLength/2);
  991.       }
  992.       *max_length = *length_ptr + packetLength/2;
  993.       *bs_ptr=(unsigned int *)malloc(*max_length*4);
  994.       if (*bs_ptr == NULL) {
  995.     if (opts&SYSLAYER_LOG) {
  996.       fprintf(syslogOutput, "\tReadPacket: Error in allocating %d bytes\n",
  997.           *max_length);
  998.     }
  999.     return 1;
  1000.       }
  1001.       memcpy((unsigned char *)*bs_ptr,*buf_ptr,*length_ptr*4);
  1002.       free(old);
  1003.       *buf_ptr= *bs_ptr;
  1004.     } else {
  1005.       memcpy((unsigned char *)*bs_ptr,*buf_ptr,*length_ptr*4);
  1006.       *buf_ptr = *bs_ptr;
  1007.     }}
  1008.   byte_length= *length_ptr*4;
  1009.   if (num_left!=0) {
  1010.     /* Sigh, deal with previous leftovers */
  1011.     byte_length += num_left;
  1012.     *(*buf_ptr+*length_ptr)=leftover_bytes;
  1013.   }
  1014.   packetBuffer=((unsigned char *)*buf_ptr)+byte_length;
  1015.   packetDataLength = packetLength - pos;
  1016.   *packetBuffer++=nextByte;
  1017.   if (packetID == gVideoStreamID) {
  1018.     ioBytes=fread(packetBuffer, 1, packetDataLength-1, input);
  1019.     if (ioBytes!=packetDataLength-1) {
  1020.       EOF_flag=1;
  1021.       if (opts&SYSLAYER_LOG) {
  1022.     fprintf(syslogOutput,"\tEOF in middle of packet!\n");
  1023.       }
  1024.       return 1;
  1025.     }
  1026.     if (opts&SYSLAYER_LOG) {
  1027.       fprintf(syslogOutput, "\tKeeping Video packet of length %d (%%=%d)\n",
  1028.               packetDataLength,packetDataLength%4);
  1029.     }
  1030.     if (1!=ntohl(1)) {
  1031.       unsigned int *mark= *buf_ptr+*length_ptr;
  1032.       int i;
  1033.       
  1034.       for (i=0; i < ((packetDataLength+num_left)&0xfffffffc); i+=4) {
  1035.     *mark = ntohl(*mark);
  1036.     mark++;
  1037.       }}
  1038.     byte_length = byte_length+packetDataLength;
  1039.     num_left = byte_length%4;
  1040.     *length_ptr = byte_length/4;
  1041.     leftover_bytes = *(*buf_ptr+*length_ptr);
  1042.     sysBytes += packetLength-packetDataLength;
  1043.     vidBytes += packetDataLength;
  1044.     return 2;
  1045.   }
  1046.   else if (packetID == gAudioStreamID) { 
  1047.     sysBytes += packetLength-packetDataLength;
  1048.     audBytes += packetDataLength;
  1049.     packetBuffer = (unsigned char *)(*buf_ptr+*length_ptr+1);
  1050.     fread(packetBuffer, 1, packetDataLength-1, input);
  1051.     if (opts&SYSLAYER_LOG) {
  1052.       fprintf(syslogOutput, "\tReceived Audio packet of length %d\n",
  1053.           packetDataLength);
  1054.     }
  1055.   }
  1056.   else /* Donno what it is, just nuke it */ {
  1057.     /* This code should be unreachable */
  1058.     sysBytes+=packetLength;
  1059.     packetBuffer=(unsigned char *)(*buf_ptr+*length_ptr+1);
  1060.     fread(packetBuffer, 1, packetDataLength-1, input);
  1061.     if (opts&SYSLAYER_LOG) {
  1062.       fprintf(syslogOutput, "\tReceived Unknown packet of length %d\n",
  1063.           packetDataLength);
  1064.     }
  1065.   }
  1066.   return 0; 
  1067. }
  1068.  
  1069.  
  1070. /*
  1071.  * The remaining procedures are formatting utility procedures.
  1072.  */
  1073. void ReadTimeStamp(inputBuffer,hiBit,low4Bytes)
  1074.      unsigned char *inputBuffer, *hiBit;
  1075.      unsigned long *low4Bytes;
  1076. {
  1077.   *hiBit = ((unsigned long)inputBuffer[0] >> 3) & 0x01;
  1078.   *low4Bytes = (((unsigned long)inputBuffer[0] >> 1) & 0x03) << 30; 
  1079.   *low4Bytes |= (unsigned long)inputBuffer[1] << 22; 
  1080.   *low4Bytes |= ((unsigned long)inputBuffer[2] >> 1) << 15; 
  1081.   *low4Bytes |= (unsigned long)inputBuffer[3] << 7; 
  1082.   *low4Bytes |= ((unsigned long)inputBuffer[4]) >> 1; 
  1083. }
  1084.  
  1085. void ReadSTD(
  1086.          unsigned char *inputBuffer,
  1087.          unsigned char *stdBufferScale,
  1088.          unsigned long *stdBufferSize) 
  1089. {
  1090.   *stdBufferScale = ((inputBuffer[0] & 0x20) >> 5); 
  1091.   *stdBufferSize = ((unsigned long)inputBuffer[0] & 0x1f) << 8;
  1092.   *stdBufferSize |= (unsigned long)inputBuffer[1];
  1093. }
  1094.  
  1095.  
  1096. void ReadRate(inputBuffer,rate)
  1097.      unsigned char *inputBuffer;
  1098.      unsigned long *rate;
  1099. {
  1100.   *rate = (inputBuffer[0] & 0x7f) << 15;
  1101.   *rate |= inputBuffer[1] << 7;
  1102.   *rate |= (inputBuffer[2] & 0xfe) >> 1;
  1103. }
  1104.  
  1105. #define FLOAT_0x10000 (double)((unsigned long)1 << 16)
  1106.  
  1107. int MakeFloatClockTime(hiBit,low4Bytes,floatClockTime)
  1108.      unsigned char hiBit;
  1109.      unsigned long low4Bytes;
  1110.      double *floatClockTime;
  1111. {
  1112.   if (hiBit != 0 && hiBit != 1) {
  1113.     *floatClockTime = 0.0;
  1114.     return 1;
  1115.   }
  1116.   *floatClockTime 
  1117.     = (double)hiBit*FLOAT_0x10000*FLOAT_0x10000 + (double)low4Bytes;
  1118.   *floatClockTime /= (double)STD_SYSTEM_CLOCK_FREQ;
  1119.   return 0;
  1120. }
  1121.