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 / MPEG2Parser.cpp < prev    next >
C/C++ Source or Header  |  2005-05-02  |  34KB  |  1,259 lines
  1. /*
  2. #
  3. # Implements the structure-parsing routines needs to parse an MPEG2 using
  4. # the Parser class memory-management interface.
  5. #
  6. # $Id: MPEG2Parser.cpp,v 1.40 2005/05/02 04:45:57 keescook Exp $
  7. #
  8. # Copyright (C) 2001-2003 Kees Cook
  9. # kees@outflux.net, http://outflux.net/
  10. # 
  11. # This program is free software; you can redistribute it and/or
  12. # modify it under the terms of the GNU General Public License
  13. # as published by the Free Software Foundation; either version 2
  14. # of the License, or (at your option) any later version.
  15. # 
  16. # This program is distributed in the hope that it will be useful,
  17. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19. # GNU General Public License for more details.
  20. # 
  21. # You should have received a copy of the GNU General Public License
  22. # along with this program; if not, write to the Free Software
  23. # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  24. # http://www.gnu.org/copyleft/gpl.html
  25. #
  26. */
  27.  
  28. #include "GOPchop.h"
  29.  
  30. #include "MPEG2Parser.h"
  31. #include "ElementStream.h"
  32. #include "Picture.h"
  33. #include "mpeg2consts.h"
  34.  
  35. #include "FirstPack.h"
  36.  
  37. // send packet info to stderr
  38. #undef MPEG2_PARSE_TO_STDERR
  39. // write maps to disk
  40. #undef MPEG2_MAP
  41. // write debugging to disk (you don't want this)
  42. #undef MPEG2_DEBUG
  43.  
  44. #if defined(MPEG2_MAP) || defined(MPEG2_DEBUG)
  45. # define MPEG2_DUMP
  46. #endif
  47.  
  48. #ifdef MPEG2_DUMP
  49. FILE *report;
  50. #endif
  51.  
  52. #define WRITE_OUT(t, s...)    fprintf(report, t, ##s)
  53.  
  54. #ifdef MPEG2_MAP
  55. # define DUMP_MAP(t, s...)    WRITE_OUT(t, ##s)
  56. #else
  57. # define DUMP_MAP(t, s...)      /* */
  58. #endif
  59.  
  60. #ifdef MPEG2_DEBUG
  61. # define DUMP_DEBUG(t, s...)    WRITE_OUT(t, ##s)
  62. #else
  63. # define DUMP_DEBUG(t, s...)    /* */
  64. #endif
  65.  
  66. // NOTES
  67.  
  68. // I'm assuming that GOP and picture start codes are not split across
  69. // packet boundries
  70.  
  71. // Any edits must set broken_link to "1" if the prior GOP has been
  72. // dropped?
  73.  
  74.  
  75. MPEG2Parser::MPEG2Parser():Parser()
  76. {
  77.     picture_list = NULL;
  78.     packet_list = NULL;
  79.     video_list = NULL;
  80.     audio_list = NULL;
  81.     GOP_list = NULL;
  82.     ignore_endcode = false;
  83.     first_pack = new FirstPack();   //TI!
  84. }
  85.  
  86. MPEG2Parser::~MPEG2Parser()
  87. {
  88.     if (packet_list)
  89.         delete packet_list;
  90.     if (picture_list)
  91.         delete picture_list;
  92.     if (GOP_list)
  93.         delete GOP_list;
  94.     if (video_list)
  95.         delete video_list;
  96.     if (audio_list)
  97.         delete audio_list;
  98. }
  99.  
  100. void MPEG2Parser::set_ignore_endcode(bool setting)
  101. {
  102.     ignore_endcode = setting;
  103. }
  104.  
  105. List *MPEG2Parser::getGOPs()
  106. {
  107.     return GOP_list;
  108. }
  109.  
  110. List *MPEG2Parser::getPackets()
  111. {
  112.     return packet_list;
  113. }
  114.  
  115. List *MPEG2Parser::getVideo()
  116. {
  117.     return video_list;
  118. }
  119.  
  120. List *MPEG2Parser::getAudio()
  121. {
  122.     return audio_list;
  123. }
  124.  
  125. List *MPEG2Parser::getPictures()
  126. {
  127.     return picture_list;
  128. }
  129.  
  130. uint32_t MPEG2Parser::numGOPs()
  131. {
  132.     return GOP_list ? GOP_list->getNum() : 0;
  133. }
  134.  
  135. #define SKIP_BYTES(b)        location+=(b)
  136. #define SKIP_SIZEOF(v)        SKIP_BYTES(sizeof(v))
  137.  
  138. #define ADDERROR(f, s...)    \
  139. {    \
  140.     addError("%s @ %" OFF_T_FORMAT "(%.2f%%): ",    \
  141.         __FUNCTION__, location,    \
  142.                100.0*(float)((float)location/(float)filesize));    \
  143.     addError(f, ##s);    \
  144. }
  145.  
  146. #define VERIFY_FAILED(s,l)    \
  147. {    \
  148.     ADDERROR(_("header %s (length %d) not found\n"),    # s, (l));    \
  149. }
  150. #define ATTACH_FAILED(s,l)    \
  151. {    \
  152.     ADDERROR(_("%s (length %d) structure attach failed\n"), (s), (l));    \
  153. }
  154. #define    FIXME_FAIL(s)    \
  155. {    \
  156.     ADDERROR(_("stream has %s marker! (Need to finish parsing routine...)\n"),(s));\
  157. }
  158. #define CONSUME_FAILED(s, l)    \
  159. {    \
  160.     ADDERROR(_("expecting %s marker (length %d)\n"),    # s, (l) );    \
  161. }
  162.  
  163. #define CheckMaskValue(byte, mask, value)       (((byte) & (mask))==(value))
  164.  
  165. void MPEG2Parser::parse_PES_packet(void)
  166. {
  167.     PES_packet_header_t *header;
  168.     PES_packet_internals_t *internals_area;
  169.     PES_packet_internals_t internals;
  170.     PES_packet_additional_copy_info_t *additional_copy_info;
  171.     uint8_t *PES_private_data;  // 16 bytes
  172.     uint8_t *STD_data;          // 16 bits
  173.     uint8_t *PTS_data;          // 40 bits
  174.     uint8_t *DTS_data;          // 40 bits
  175.     uint8_t *data;              // ES data
  176.  
  177.  
  178.     // for ES extraction
  179.     int type = ES_TYPE_WEIRD;
  180.     uint8_t id = 0;
  181.  
  182.     unsigned int length;
  183.  
  184.     off_t marked_offset;
  185.     off_t data_loc;
  186.     off_t pes_loc;
  187.  
  188.     pes_loc = location;
  189.     if (!(header = (PES_packet_header_t *)attach(sizeof(*header))))
  190.     {
  191.         ATTACH_FAILED(_("header"), sizeof(*header));
  192.         return;
  193.     }
  194.     // verify start code
  195.     if (!verify(header->start_code, 3, (uint8_t*)packet_start_code_prefix))
  196.     {
  197.         VERIFY_FAILED(packet_start_code_prefix, 3);
  198.         return;
  199.     }
  200.  
  201.     length = (header->PES_packet_length[0] << 8) +
  202.         header->PES_packet_length[1];
  203.  
  204. #ifdef MPEG2_PARSE_TO_STDERR
  205.     fprintf(stderr, _("found PES 0x%02X @ %llu (%d bytes)\n"),
  206.             header->stream_id, pes_loc, length);
  207. #endif
  208.  
  209.     switch (header->stream_id)
  210.     {
  211.         // "simple" length info
  212.         case PES_TYPE_private_stream_2:
  213.         case PES_TYPE_ECM_stream:
  214.         case PES_TYPE_EMM_stream:
  215.         case PES_TYPE_program_stream_directory:
  216.         case PES_TYPE_DSMCC_stream:
  217.         case PES_TYPE_H2221E:
  218.         case PES_TYPE_program_stream_map:
  219.             SKIP_BYTES(length);
  220.             break;
  221.  
  222.             if (!(data = (uint8_t *)attach(length)))
  223.             {
  224.                 ATTACH_FAILED(_("stream data"), length);
  225.                 return;
  226.             }
  227.             /*
  228.                if (verbose)
  229.                Report("%d byte%s of odd stream data",
  230.                length,
  231.                length==1?"":"s");
  232.              */
  233.             break;
  234.  
  235.         case PES_TYPE_padding_stream:
  236.             SKIP_BYTES(length);
  237.             break;
  238.  
  239.             if (!(data = (uint8_t *)attach(length)))
  240.             {
  241.                 ATTACH_FAILED(_("padding data"), length);
  242.                 return;
  243.             }
  244.             /*
  245.                if (verbose)
  246.                Report("%d byte%s of padding",
  247.                length,
  248.                length==1?"":"s");
  249.              */
  250.             break;
  251.  
  252.         default:               // total insano flag freakies
  253.             // Report!
  254.             if ((header->stream_id & PES_TYPE_MASK_audio) == PES_TYPE_audio)
  255.             {
  256.                 id = header->stream_id & ~PES_TYPE_MASK_audio;
  257.                 type = ES_TYPE_AUDIO;
  258.  
  259.                 /*
  260.                    if (verbose)
  261.                    Report("found header for audio stream 0x%02X",id);
  262.                  */
  263.             }
  264.             else if (header->stream_id == PES_TYPE_private_stream_1)
  265.             {
  266.                 // assume private stream 1 is going to be DVD audio
  267.                 id = PES_TYPE_private_stream_1;
  268.                 type = ES_TYPE_AUDIO;
  269.  
  270.                 /*
  271.                    if (verbose)
  272.                    Report("found header for DVD audio stream");
  273.                  */
  274.             }
  275.             else if ((header->stream_id & PES_TYPE_MASK_video) ==
  276.                      PES_TYPE_video)
  277.             {
  278.                 id = header->stream_id & ~PES_TYPE_MASK_video;
  279.                 type = ES_TYPE_VIDEO;
  280.  
  281.                 /*
  282.                    if (verbose)
  283.                    Report("found header for video stream 0x%02X", id);
  284.                  */
  285.             }
  286.             else                // if (type==ES_TYPE_WEIRD)
  287.             {
  288.                 ADDERROR(_("Whoa: got PES id 0x%02X.  Skipping...\n"),
  289.                          header->stream_id);
  290.                 SKIP_BYTES(length);
  291.                 break;
  292.             }
  293.  
  294.         // MPEG-1 allows stuffing bytes here
  295.  
  296.         while (forwardMatch(1, (uint8_t*)stuffing_byte))
  297.             {
  298.                 if (!consume(1, (uint8_t*)stuffing_byte))
  299.                 {
  300.                     CONSUME_FAILED(stuffing_byte, 1);
  301.                     return;
  302.                 }
  303.         length --;
  304.         }
  305.  
  306.             // verify marker bits
  307.  
  308.         if (forwardBitMatch(2,0x1)) {
  309.  
  310.         // MPEG 1 STD buffer
  311.         if (!(STD_data = attach(2)))
  312.         {
  313.             ATTACH_FAILED(_("STD data"), 5);
  314.             return;
  315.         }
  316.         length -= 2;
  317.  
  318.         }
  319.  
  320.         if (forwardBitMatch(4,0x2)) {
  321.  
  322.         // MPEG 1 type 2 PES
  323.         if (!(PTS_data = attach(5)))
  324.         {
  325.             ATTACH_FAILED(_("PTS data"), 5);
  326.             return;
  327.         }
  328.         length -= 5;
  329.  
  330.         } else if (forwardBitMatch(4,0x3)) {
  331.  
  332.         // MPEG 1 type 3 PES
  333.         if (!(PTS_data = attach(5)))
  334.         {
  335.             ATTACH_FAILED(_("PTS data"), 5);
  336.             return;
  337.         }
  338.         if (!(DTS_data = attach(5)))
  339.         {
  340.             ATTACH_FAILED(_("DTS data"), 5);
  341.             return;
  342.         }
  343.         length -= 10;
  344.  
  345.         } else if (forwardBitMatch(8,0x15)) {
  346.  
  347.         // MPEG 1 - no header extensions
  348.         if (! attach(1))
  349.         {
  350.             ATTACH_FAILED(_("MPEG 1 flag byte"), 1);
  351.             return;
  352.         }
  353.         length --;
  354.  
  355.         } else if (forwardBitMatch(2,0x2)) {
  356.  
  357.         // MPEG 2 header
  358.         if (!(internals_area = (PES_packet_internals_t*)attach(sizeof(internals))))
  359.         {
  360.             ATTACH_FAILED(_("flag data"), sizeof(internals));
  361.             return;
  362.         }
  363.         // we need to keep a copy of this in case we flip 
  364.         // across mmap boundries.  tricky!
  365.         memcpy(&internals, internals_area, sizeof(internals));
  366.  
  367.         marked_offset = location;
  368.  
  369.         /*
  370.           if (debug) Report("PES_header_data_length: %d",
  371.           internals.PES_header_data_length);
  372.         */
  373.  
  374.         if (CheckMaskValue(internals.bits[1], 0xC0, 0x80))
  375.         {
  376.             if (!(PTS_data = attach(5)))
  377.             {
  378.             ATTACH_FAILED(_("PTS data"), 5);
  379.             return;
  380.             }
  381.             // FIXME: verify marker bits
  382.             /*
  383.               if (debug) Report("has PTS");
  384.             */
  385.         }
  386.         if (CheckMaskValue(internals.bits[1], 0xC0, 0xC0))
  387.         {
  388.             if (!(PTS_data = attach(5)))
  389.             {
  390.             ATTACH_FAILED(_("PTS data"), 5);
  391.             return;
  392.             }
  393.             // FIXME: verify marker bits
  394.             /*
  395.               if (debug) Report("has PTS");
  396.             */
  397.             if (!(DTS_data = attach(5)))
  398.             {
  399.             ATTACH_FAILED(_("DTS data"), 5);
  400.             return;
  401.             }
  402.             // FIXME: verify marker bits
  403.             /*
  404.               if (debug) Report("has DTS");
  405.             */
  406.         }
  407.         if (CheckMaskValue(internals.bits[1], 0x20, 0x20))
  408.         {
  409.             FIXME_FAIL("ESCR");
  410.             return;
  411.         }
  412.         if (CheckMaskValue(internals.bits[1], 0x10, 0x10))
  413.         {
  414.             FIXME_FAIL("ES rate");
  415.             return;
  416.         }
  417.         if (CheckMaskValue(internals.bits[1], 0x8, 0x8))
  418.         {
  419.             FIXME_FAIL("DSM trick mode");
  420.             return;
  421.         }
  422.         if (CheckMaskValue(internals.bits[1], 0x4, 0x4))
  423.         {
  424.             if (!
  425.             (additional_copy_info =
  426.              (PES_packet_additional_copy_info_t*)attach(sizeof(*additional_copy_info))))
  427.             {
  428.             ATTACH_FAILED(_("additional copy info"),
  429.                       sizeof(*additional_copy_info));
  430.             return;
  431.             }
  432.             // FIXME: verify marker bit
  433.             /*
  434.               if (debug)
  435.               Report("has additional copy info 0x%02X",
  436.               additional_copy_info->data);
  437.             */
  438.         }
  439.         if (CheckMaskValue(internals.bits[1], 0x2, 0x2))
  440.         {
  441.             // isn't this only used in Transport Streams?
  442.             FIXME_FAIL("PES CRC");
  443.             return;
  444.         }
  445.         if (CheckMaskValue(internals.bits[1], 0x1, 0x1))
  446.         {
  447.             PES_packet_extension_t *extension;
  448.  
  449.             if (!(extension = (PES_packet_extension_t*)attach(sizeof(*extension))))
  450.             {
  451.             ATTACH_FAILED(_("extension data"), sizeof(*extension));
  452.             return;
  453.             }
  454.  
  455.             if (PPE_PES_private_data_flag(extension->bits[0]))
  456.             {
  457.             if (!(PES_private_data = attach(16)))
  458.             {
  459.                 ATTACH_FAILED(_("PES private data"), 16);
  460.                 return;
  461.             }
  462.             }
  463.             if (PPE_pack_header_field_flag(extension->bits[0]))
  464.             {
  465.             uint8_t *pack_field_length;
  466.             if (!(pack_field_length = attach(1)))
  467.             {
  468.                 ATTACH_FAILED(_("PES extension pack field length"),
  469.                       1);
  470.                 return;
  471.             }
  472.             if (!attach(*pack_field_length))
  473.             {
  474.                 ATTACH_FAILED(_("PES extension pack field header"),
  475.                       *pack_field_length);
  476.                 return;
  477.  
  478.             }
  479.             }
  480.             if (PPE_program_packet_sequence_counter_flag
  481.             (extension->bits[0]))
  482.             {
  483.             FIXME_FAIL
  484.                 ("PES extension program packet sequence  counter");
  485.             return;
  486.             }
  487.             if (PPE_P_STD_buffer_flag(extension->bits[0]))
  488.             {
  489.             FIXME_FAIL("PES extension P-STD buffer");
  490.                     return;
  491.             }
  492.             if (PPE_PES_extension_flag_2(extension->bits[0]))
  493.             {
  494.             FIXME_FAIL("second PES extension");
  495.             return;
  496.             }
  497.         }
  498.  
  499.         DUMP_DEBUG("ES packet analysis @ %llu\n", pes_loc);
  500.  
  501.         DUMP_DEBUG("\tPES packet length: %d\n", length);
  502.  
  503.         DUMP_DEBUG("\tmarked_offset (flag start?) @ %llu\n",
  504.                marked_offset);
  505.  
  506.         DUMP_DEBUG("\tPES_header_data_length: %d\n",
  507.                internals.PES_header_data_length);
  508.  
  509.         DUMP_DEBUG("\tstart of non-flags @ %llu\n", location);
  510.  
  511.         off_t newloc = (marked_offset + internals.PES_header_data_length);
  512.         if (location != newloc)
  513.         {
  514.             DUMP_DEBUG
  515.             ("\t\twas at %llu, should be at %llu -- adjusting\n",
  516.              location, newloc);
  517.             location = newloc;
  518.         }
  519.  
  520.         // FIXME: no more than 32 of these
  521.         // FIXME: with above adjustment, I'll never seen stuffing bytes
  522.         while (location - marked_offset < internals.PES_header_data_length
  523.                && forwardMatch(1, (uint8_t*)stuffing_byte))
  524.         {
  525.             if (!consume(1, (uint8_t*)stuffing_byte))
  526.             {
  527.             CONSUME_FAILED(stuffing_byte, 1);
  528.             return;
  529.             }
  530.             DUMP_MAP("\t\tstuffing found @ %llu\n", location - 1);
  531.         }
  532.  
  533.         DUMP_DEBUG("\tstart of non-stuffing @ %llu\n", location);
  534.  
  535.         // adjust down for extra headers (where does this 3 come from?)
  536.         length -= (internals.PES_header_data_length + 3);
  537.  
  538.         } else {
  539.         ADDERROR(_("unknown marker bits (%02x)\n"), internals.bits[0]);
  540.         }
  541.  
  542.             data_loc = location;
  543.             if (!(data = (uint8_t*)attach(length)))
  544.             {
  545.                 ATTACH_FAILED(_("ES data"), length);
  546.                 return;
  547.             }
  548.  
  549.             DUMP_DEBUG("\tdata length calculated to be %d\n", length);
  550.  
  551.             DUMP_DEBUG("\tnext location @ %llu\n", location);
  552.  
  553.             if (type != ES_TYPE_WEIRD)
  554.             {
  555.                 ElementStream *es;
  556.                 es = new ElementStream(data_loc, length, type, id);
  557.  
  558.                 if (type == ES_TYPE_VIDEO)
  559.                 {
  560.                     video_list->add(es);
  561.  
  562.                     /*
  563.                      * Really should do GOP processing here
  564.                      */
  565.                 }
  566.                 else
  567.                 {
  568.                     audio_list->add(es);
  569.                 }
  570.             }
  571.  
  572.             break;
  573.     }
  574. }
  575.  
  576. void MPEG2Parser::parse_system_header(void)
  577. {
  578.     system_header_t *header;
  579.     stream_id_t *stream;
  580.  
  581. #ifdef MPEG2_PARSE_TO_STDERR
  582.     fprintf(stderr, "System @ %llu?\n", location);
  583. #endif
  584.  
  585.     if (!(header = (system_header_t *)attach(sizeof(*header))))
  586.     {
  587.         ATTACH_FAILED(_("header"), sizeof(*header));
  588.         return;
  589.     }
  590.  
  591.     // verify start code
  592.     if (!verify(header->start_code, 4, (uint8_t*)system_header_start_code))
  593.     {
  594.         VERIFY_FAILED(system_header_start_code, 4);
  595.         return;
  596.     }
  597.  
  598. #ifdef MPEG2_PARSE_TO_STDERR
  599.     fprintf(stderr, "\tsystem header: 0x%02X\n", header->start_code[3]);
  600. #endif
  601.  
  602.     
  603.     first_pack->setSystemHeader(header);    //TI! save system header info
  604.     
  605.     // FIXME: verify marker bits
  606.         
  607.     // report!
  608.     /*
  609.     if (verbose) Report("found system_header");
  610.     */
  611.     
  612.     uint16_t index = 0;
  613.     
  614.     while (forwardBitMatch(1, 0x1))
  615.     {
  616.         if (!(stream = (stream_id_t *)attach(sizeof(*stream))))
  617.         {
  618.             ATTACH_FAILED(_("stream header"), sizeof(*stream));
  619.             return;
  620.             }
  621.             // verify stream id
  622.         if ((stream->stream_id & 0xF8) < 0xB8)
  623.         {
  624.             ADDERROR(_("invalid stream_id 0x%02X\n"), stream->stream_id);
  625.             return;
  626.         }
  627.         
  628.         first_pack->addStreamId(stream);    //TI! save stream id info
  629.            
  630.         // report!
  631.         /*
  632.         if (verbose) Report("found stream_id 0x%02X",stream->stream_id);
  633.         */
  634.     }   
  635. }
  636.  
  637. void MPEG2Parser::parse_pack_header(void)
  638. {
  639.     int i;
  640.     pack_header_t *header;
  641.     pack_header_MPEG1_t *MPEG1_header;
  642.     int pack_stuffing_length;
  643.  
  644.     pack_start = location;
  645.  
  646.     // verify start code
  647.     if (!consume(4, (uint8_t*)pack_start_code))
  648.     {
  649.         CONSUME_FAILED(pack_start_code, 4);
  650.         return;
  651.     }
  652.  
  653.     // verify marker bits
  654.     if (forwardBitMatch(4,0x2)) {
  655.         // MPEG 1
  656.         if (!(MPEG1_header = (pack_header_MPEG1_t*)attach(sizeof(*MPEG1_header))))
  657.         {
  658.                ATTACH_FAILED(_("MPEG1_header"), sizeof(*MPEG1_header));
  659.                return;
  660.         }
  661.  
  662.         printf("Detected MPEG1 stream!  This is experimental code.\n",
  663.                pack_start);
  664.  
  665. #ifdef MPEG2_PARSE_TO_STDERR
  666.         fprintf(stderr, "found MPEG-1 Pack @ %llu?\n", pack_start);
  667. #endif
  668.     } else if (forwardBitMatch(2,0x1)) {
  669.         // MPEG 2
  670.         if (!(header = (pack_header_t*)attach(sizeof(*header))))
  671.         {
  672.                ATTACH_FAILED(_("header"), sizeof(*header));
  673.                return;
  674.         }
  675.  
  676. #ifdef MPEG2_PARSE_TO_STDERR
  677.         fprintf(stderr, "found MPEG-2 Pack @ %llu?\n", pack_start);
  678. #endif
  679.  
  680.         first_pack->setPackHeader(header);  //TI! save pack header info
  681.  
  682.         pack_stuffing_length = header->bits[9] & 0x7;
  683.  
  684.         // report!
  685.         /*
  686.            if (verbose)
  687.            Report("pack_header found");
  688.          */
  689.  
  690.         for (i = 0; i < pack_stuffing_length; i++)
  691.         {
  692.             if (!consume(1, (uint8_t*)stuffing_byte))
  693.             {
  694.                 CONSUME_FAILED(stuffing_byte, 1);
  695.                 return;
  696.             }
  697.         }
  698.     } 
  699.     else {
  700.         ADDERROR(_("Neither MPEG1 nor MPEG2 Pack header - 0x%02x!\n"),
  701.                 MPEG1_header->bits[0]);
  702.         consume(4, (uint8_t*)pack_start_code);
  703.     }
  704.  
  705.     if (forwardMatch(4, (uint8_t*)system_header_start_code))
  706.         parse_system_header();
  707. }
  708.  
  709.  
  710. void MPEG2Parser::parse_pack(void)
  711. {
  712.     parse_pack_header();
  713.     while (location + sizeof(PES_packet_header_t) <= filesize &&
  714.            forwardMatch(3, (uint8_t*)packet_start_code_prefix) &&
  715.            !forwardMatch(4, (uint8_t*)pack_start_code) &&
  716.            (ignore_endcode || !forwardMatch(4, (uint8_t*)MPEG_program_end_code)))
  717.         parse_PES_packet();
  718. }
  719.  
  720. /*
  721.  * This function steps through the stream, looking for "Pack" boundries.
  722.  * For each pack boundry, all the PES packets within it are examined and
  723.  * added to the overall index of packets.  We track the video and audio
  724.  * packets by simply saying "here where the next _will_ go" (first_video),
  725.  * before we've actually seen it.  Once we're done processing a pack, we
  726.  * store our current video position as the 'max'.
  727.  *
  728.  */
  729. void MPEG2Parser::parse_MPEG2_program_stream(void)
  730. {
  731.     Pack *packet;
  732.  
  733.     int first_video;
  734.     int first_audio;
  735.     int error_found = 0;
  736.  
  737.     char *task = _("Reading MPEG2");
  738.  
  739.     setParsingState(PARSER_STATE_PARSING);
  740.  
  741.     while ((location < filesize)
  742.               && (ignore_endcode ||
  743.                   !forwardMatch(4,(uint8_t*)MPEG_program_end_code)))
  744.     {
  745.         // callback our progress
  746.         if (tick)
  747.             tick(task, (float) ((float) location / (float) filesize));
  748.  
  749.         if (forwardMatch(4, (uint8_t*)pack_start_code))
  750.         {
  751.  
  752.             first_video = video_list->getNum();
  753.             first_audio = audio_list->getNum();
  754.  
  755.             parse_pack();
  756.  
  757.             // did we see a packet?
  758.             if (pack_start != location)
  759.             {
  760.                 packet = new Pack(pack_start, location - pack_start,
  761.                                   first_video, video_list->getNum(),
  762.                                   first_audio, audio_list->getNum(),
  763.                                   error_found);
  764.                 packet_list->add(packet);
  765.                 error_found = 0;
  766.             }
  767.         }
  768.         else
  769.         {
  770.             // abort if we're out of data (any code is at least 6)
  771.             if (location + sizeof(PES_packet_header_t) >= filesize)
  772.                 break;
  773.  
  774.             // if we didn't match a pack_start_code
  775.             // then we should see an MPEG_program_end_code
  776.             // if not, we hit garbage
  777.             if (!forwardMatch(4, (uint8_t*)MPEG_program_end_code))
  778.             {
  779.                 uint8_t *garbage;
  780.                 int garbage_count;
  781.                 off_t garbage_start;
  782.                 char report[REPORT_LENGTH];
  783.  
  784.                 garbage = examine(4);
  785.  
  786.                 ADDERROR(_
  787.                          ("expecting pack_start_code, got 0x%02X 0x%02X 0x%02X 0x%02X\n"),
  788.                          garbage[0], garbage[1], garbage[2], garbage[3]);
  789.  
  790.                 garbage_start = location;
  791.  
  792.                 error_found = 1;
  793.  
  794.                 garbage_count = 0;
  795.                 while (location < filesize &&
  796.                        garbage_count < 102400 &&
  797.                        !forwardMatch(4, (uint8_t*)pack_start_code))
  798.                 {
  799.                     SKIP_SIZEOF(uint8_t);
  800.                     garbage_count++;
  801.                 }
  802.                 snprintf(report,REPORT_LENGTH,
  803.                          _("garbage data seen from %%%s to %%%s.\n"),
  804.                          OFF_T_FORMAT,OFF_T_FORMAT);
  805.                 ADDERROR(report, garbage_start, location);
  806.                 if (garbage_count == 102400)
  807.                 {
  808.                     ADDERROR(_
  809.                              ("More than 100K of garbage -- aborting parse.\n"));
  810.                     break;
  811.                 }
  812.                 else if (location < filesize)
  813.                 {
  814.                     ADDERROR(_("found long-lost pack_start_code\n"));
  815.                 }
  816.             }
  817.         }
  818.     }
  819.     // They *should* have end code, but nothing ever does
  820.     // Therefore, we'll skip this test if we're EOF
  821.     if (location != filesize && !consume(4, (uint8_t*)MPEG_program_end_code))
  822.     {
  823.         CONSUME_FAILED(MPEG_program_end_code, 4);
  824.     }
  825.  
  826.     if (tick)
  827.         tick(task, 1.0);
  828.  
  829.     setParsingState(PARSER_STATE_FINISHED);
  830. }
  831.  
  832. // FIXME: Assumes headers will be fully contained by single video ES packet
  833. Vector *MPEG2Parser::findCode(Vector * area, uint8_t * code, size_t size)
  834. {
  835.     uint8_t *buf;
  836.     uint8_t *head;
  837.     uint8_t *ptr;
  838.     size_t tosearch;
  839.     uint8_t *header = NULL;
  840.  
  841.     tosearch = area->getLen();
  842.  
  843.     // can't search what we don't have
  844.     if (size > tosearch)
  845.         return NULL;
  846.  
  847.     if (!(buf = bytesAvail(area->getStart(), tosearch)))
  848.         return NULL;
  849.     head = buf;
  850.  
  851.     // Can't scan x-1 few bytes for an x-byte marker
  852.     tosearch -= (size - 1);
  853.  
  854.     while (tosearch > 0)
  855.     {
  856.         if ((ptr = (uint8_t*)memchr(buf, 0x00, tosearch)))
  857.         {
  858.             if (verify(ptr, 4, code))
  859.             {
  860.                 header = ptr;
  861.                 break;
  862.             }
  863.             // advance searcher and buffer head
  864.             tosearch -= (ptr - buf) + 1;
  865.             buf = ptr + 1;
  866.         }
  867.         else
  868.             tosearch = 0;
  869.     }
  870.  
  871.  
  872.     if (header)
  873.         return new Vector(area->getStart() + (header - head), size);
  874.  
  875.     return NULL;
  876. }
  877.  
  878. #define GOPADDERROR(f, s...)    \
  879. {    \
  880.     addError("%s @ %" OFF_T_FORMAT "(%.2f%%): ",    \
  881.         __FUNCTION__, header->getStart(),    \
  882.                100.0*(float)((float)header->getStart()/(float)filesize));    \
  883.     addError(f, ##s);    \
  884. }
  885.  
  886. /*
  887.  * This function examines the list of Packs and creates the GOP table.
  888.  * Packs track video and audio packet vectors.
  889.  * GOPs track Packs and Pictures
  890.  * Pictures track video vectors.
  891.  */
  892. void MPEG2Parser::buildGOPs(void)
  893. {
  894.     GroupOfPictures *GOP = NULL;
  895.     Picture *picture = NULL;
  896.  
  897.     int packet_index;
  898.     int packet_max;
  899.  
  900.     char *task = _("Building GOP table");
  901.  
  902.     int GOP_count = 0;
  903.     int picture_count = 0;
  904.  
  905.     int fake_GOPs = 0;
  906.     int I_frame_count = 0;
  907.  
  908.     // verify MPEG2's internals
  909.     if (!packet_list)
  910.     {
  911.         printf("%s", _("NULL packet list?!\n"));
  912.         return;
  913.     }
  914.     if (!video_list)
  915.     {
  916.         printf("%s", _("NULL video list?!\n"));
  917.         return;
  918.     }
  919.     if (!audio_list)
  920.     {
  921.         printf("%s", _("NULL audio list?!\n"));
  922.         return;
  923.     }
  924.     if (!picture_list)
  925.     {
  926.         printf("%s", _("NULL picture list?!\n"));
  927.         return;
  928.     }
  929.     if (!GOP_list)
  930.     {
  931.         printf("%s", _("NULL GOP list?!\n"));
  932.         return;
  933.     }
  934.  
  935.     packet_max = packet_list->getNum();
  936.     for (packet_index = 0; packet_index < packet_max; packet_index++)
  937.     {
  938.         Pack *packet;
  939.         int pack_ves_first, pack_aes_first;
  940.         int pack_ves_index, pack_aes_index;
  941.         int pack_ves_max, pack_aes_max;
  942.  
  943.         // update status bar
  944.         if (tick)
  945.             tick(task, (float) ((float) packet_index / (float) packet_max));
  946.  
  947.         if (!(packet = (Pack *) packet_list->vector(packet_index)))
  948.         {
  949.             printf("%s", _("NULL packet?!\n"));
  950.             return;
  951.         }
  952.  
  953.         if (packet->getFoundError())
  954.         {
  955.             ADDERROR(_("Garbage was detected at GOP %d\n"), GOP_count - 1);
  956.         }
  957.  
  958.  
  959.         DUMP_MAP("Pack: %d @ %llu-%llu\n",
  960.                  packet_index,
  961.                  packet->getStart(),
  962.                  packet->getStart() + packet->getLen() - 1);
  963.  
  964.         pack_ves_first = packet->getVideoFirst();
  965.         pack_ves_max = packet->getVideoMax();
  966.  
  967.         for (pack_ves_index = pack_ves_first;
  968.              pack_ves_index < pack_ves_max; pack_ves_index++)
  969.         {
  970.             ElementStream *ves;
  971.             Vector *header;
  972.  
  973.             if (!(ves = (ElementStream *) video_list->vector(pack_ves_index)))
  974.             {
  975.                 printf("%s", _("NULL VES?!\n"));
  976.                 return;
  977.             }
  978.  
  979.             DUMP_MAP("\tVES: %d @ %llu-%llu\n",
  980.                      pack_ves_index,
  981.                      ves->getStart(), ves->getStart() + ves->getLen() - 1);
  982.  
  983.             // first VES packet in system packet will
  984.             // be checked for GOP... (not really "proper")
  985.             // but is the only sane way to handle GOP editing
  986.             // without a full stream demuxer
  987.             if (pack_ves_index == pack_ves_first) {
  988.                 bool saw_sequence = false;
  989.                 sequence_header seq_header;
  990.                 struct sequence_info info;
  991.  
  992.                 memset(&info,0,sizeof(info));
  993.  
  994.                 // look for sequence header
  995.                 if ((header = findCode(ves, (uint8_t*)sequence_start_code,
  996.                                        sizeof(sequence_header)))) {
  997.                     uint8_t *bytes;
  998.  
  999.                     if (!(bytes = bytesAvail(header->getStart(), sizeof(sequence_header))))
  1000.                     {
  1001.                         printf("%s", _("Sequence header not available?!\n"));
  1002.                     }
  1003.                     else
  1004.                     {
  1005.                         memcpy(&seq_header,bytes,sizeof(sequence_header));
  1006.                         bytes+=4; // skip the header codes
  1007.  
  1008.                         // see mpegcat.c for formula details
  1009.                         info.horizontal_size = (bytes[0] << 4) |
  1010.                                                 ((bytes[1] & 0xF0) >> 4);
  1011.                         info.vertical_size = ((bytes[1] & 0x0F) << 8) |
  1012.                                                 bytes[2];
  1013.                         info.aspect_ratio = (bytes[3] & 0xF0) >> 4;
  1014.                         info.frame_rate = (bytes[3] & 0x0F);
  1015.                         info.bit_rate =
  1016.                             (bytes[4] << 10) | (bytes[5] << 2) |
  1017.                             ((bytes[6] & 0xC0) >> 6);
  1018.                         info.constrained = (bytes[7] & 0x04) >> 2;
  1019.  
  1020.                         saw_sequence = true;
  1021.  
  1022.                         /*
  1023.                         printf("Sequence Header (%dx%d: %s, %sfps, %s%s)\n",
  1024.                             info.horizontal_size, info.vertical_size,
  1025.                             aspect_str[info.aspect_ratio],
  1026.                             frame_str[info.frame_rate],
  1027.                             speed_str(info.bit_rate * 400),
  1028.                             info.constrained ? " constrained" : "");
  1029.                         */
  1030.                     }
  1031.                 }
  1032.  
  1033.                 // look for GOP
  1034.                 if ((header = findCode(ves, (uint8_t*)group_start_code, 8))) {
  1035.                     GOP = new GroupOfPictures(header);
  1036.                     if (saw_sequence) {
  1037.                         GOP->set_sequence_info(&info);
  1038.                         GOP->set_sequence_header(&seq_header);
  1039.                     }
  1040.                     GOP_list->add(GOP);
  1041.  
  1042.                     GOP_count++;
  1043.                     DUMP_MAP("\t\tGOP: %d @ %llu\n", GOP_count,
  1044.                          header->getStart());
  1045.  
  1046.                     // we found a real GOP, so no more fake ones
  1047.                     fake_GOPs = 0;
  1048.                     I_frame_count = 0;
  1049.                 }
  1050.             }
  1051.  
  1052.             if ((header = findCode(ves, (uint8_t*)picture_start_code, 6)))
  1053.             {
  1054.                 uint8_t *area;
  1055.                 int pic_type;
  1056.                 int pic_time;
  1057.  
  1058.                 area = bytesAvail(header->getStart(), header->getLen());
  1059.                 pic_type = (area[5] & PICTURE_CODING_MASK) >> 3;
  1060.                 pic_time = area[4];
  1061.                 pic_time <<= 2;
  1062.                 pic_time |= ((area[5] & 0xC0) >> 6);
  1063.  
  1064.                 picture = new Picture(header->getStart(), header->getLen(),
  1065.                                       pic_type, pic_time);
  1066.                 picture_list->add(picture);
  1067.  
  1068.                 DUMP_MAP("\t\t\tPicture %d (%s) @ %llu\n",
  1069.                          picture_count++,
  1070.                          pic_str[pic_type], header->getStart());
  1071.  
  1072.                 if (pic_type == PICTURE_CODING_INTRA)
  1073.                 {
  1074.                     I_frame_count++;
  1075.  
  1076.                     if (!GOP || (fake_GOPs))
  1077.                     {
  1078.                         GOPADDERROR(_
  1079.                                     ("Whoa: no GOP seen before an I-Frame!?\n (You might want to re-multiplex your MPEG2-PS file first.)\n"));
  1080. #if 0
  1081.                         // in the situation where we don't find a
  1082.                         // GOP, we can play along and try to trick
  1083.                         // ourself into thinking this MPEG2-PS file
  1084.                         // actually has GOP headers.
  1085.  
  1086.                         if (!fake_GOPs)
  1087.                             ADDERROR(_
  1088.                                      ("No GOP seen before first Picture header.  Attempting to do I-frame splitting...\n"));
  1089.                         fake_GOPs = 1;
  1090.  
  1091.                         // FIXME: build a better GOP header???!
  1092.  
  1093.                         GOP = new GroupOfPictures(header);
  1094.                         GOP_list->add(GOP);
  1095.  
  1096.                         GOP_count++;
  1097.                         DUMP_MAP("\t\tPretend GOP: %d @ %llu\n", GOP_count,
  1098.                                  header->getStart());
  1099. #endif
  1100.                     }
  1101.  
  1102.                     if (I_frame_count > 1)
  1103.                     {
  1104.                         GOPADDERROR(_
  1105.                                     ("Whoa: I-Frame number %d seen in the same GOP!?\n (You might want to re-multiplex your MPEG2-PS file first.)\n"),
  1106.                                     I_frame_count);
  1107.  
  1108.                     }
  1109.                 }
  1110.  
  1111.                 if (GOP)
  1112.                     GOP->getPictureBounds()->extendTo(picture_list->getNum());
  1113.             }
  1114.  
  1115.             if (picture)
  1116.                 picture->getVideoBounds()->extendTo(pack_ves_index + 1);
  1117.  
  1118.  
  1119.         }
  1120.  
  1121.         // Don't forget trailing packets...
  1122.         if (picture)
  1123.             picture->getVideoBounds()->extendTo(pack_ves_index);
  1124.  
  1125.         // handle imbedded audio packets too!
  1126.         pack_aes_first = packet->getAudioFirst();
  1127.         pack_aes_max = packet->getAudioMax();
  1128.  
  1129.         for (pack_aes_index = pack_aes_first;
  1130.              pack_aes_index < pack_aes_max; pack_aes_index++)
  1131.         {
  1132.             ElementStream *aes;
  1133.             Vector *header;
  1134.  
  1135.             if (!(aes = (ElementStream *) audio_list->vector(pack_aes_index)))
  1136.             {
  1137.                 printf("%s", _("NULL AES?!\n"));
  1138.                 return;
  1139.             }
  1140.  
  1141.             DUMP_MAP("\tAES: %d @ %llu-%llu\n",
  1142.                      pack_aes_index,
  1143.                      aes->getStart(), aes->getStart() + aes->getLen() - 1);
  1144.  
  1145.         }
  1146.  
  1147.         // we want to INCLUDE this packet, so packet_index+1
  1148.         if (GOP)
  1149.             GOP->getPacketBounds()->extendTo(packet_index + 1);
  1150.  
  1151.     }
  1152.     // Don't forget trailing packets...
  1153.     if (GOP)
  1154.         GOP->getPacketBounds()->extendTo(packet_index);
  1155. }
  1156.  
  1157. int MPEG2Parser::parse(char ignore_errors)
  1158. {
  1159.     clearError();
  1160.     report_errors = !ignore_errors;
  1161.  
  1162.     // reset and clear lists
  1163.     if (GOP_list)
  1164.         GOP_list->reset();
  1165.     else
  1166.     {
  1167.         if (!(GOP_list = new List))
  1168.         {
  1169.             reset();
  1170.             addError("cannot allocate GOP list\n");
  1171.             return FALSE;
  1172.         }
  1173.     }
  1174.     if (packet_list)
  1175.         packet_list->reset();
  1176.     else
  1177.     {
  1178.         if (!(packet_list = new List))
  1179.         {
  1180.             reset();
  1181.             addError("cannot allocate packet list\n");
  1182.             return FALSE;
  1183.         }
  1184.     }
  1185.  
  1186.     if (video_list)
  1187.         video_list->reset();
  1188.     else
  1189.     {
  1190.         if (!(video_list = new List))
  1191.         {
  1192.             reset();
  1193.             addError("cannot allocate video ES list\n");
  1194.             return FALSE;
  1195.         }
  1196.     }
  1197.  
  1198.     if (audio_list)
  1199.         audio_list->reset();
  1200.     else
  1201.     {
  1202.         if (!(audio_list = new List))
  1203.         {
  1204.             reset();
  1205.             addError("cannot allocate audio ES list\n");
  1206.             return FALSE;
  1207.         }
  1208.     }
  1209.  
  1210.     if (picture_list)
  1211.         picture_list->reset();
  1212.     else
  1213.     {
  1214.         if (!(picture_list = new List))
  1215.         {
  1216.             reset();
  1217.             addError("cannot allocate Picture list\n");
  1218.             return FALSE;
  1219.         }
  1220.     }
  1221.  
  1222.     picture_start = 0;
  1223.     GOP_start = 0;
  1224.  
  1225. #ifdef MPEG2_DUMP
  1226.     report = fopen("mpeg2parsing.output", "w");
  1227. #endif
  1228.  
  1229.     parse_MPEG2_program_stream();
  1230.  
  1231.     buildGOPs();
  1232.  
  1233.     //printf(_("GOPs: %d\n"),numGOPs());
  1234.  
  1235. #ifdef MPEG2_DUMP
  1236.     fclose(report);
  1237. #endif
  1238.  
  1239.     if (!GOP_list || !GOP_list->getNum())
  1240.     {
  1241.         //reset();
  1242.         addError("No Groups of Pictures found!\n");
  1243.         return FALSE;
  1244.     }
  1245.  
  1246.     return TRUE;
  1247. }
  1248.  
  1249. /* TI! *
  1250.  * Return first dummy pack
  1251.  */
  1252. FirstPack *MPEG2Parser::getFirstPack(){
  1253.     return first_pack;
  1254. }
  1255.     
  1256.     
  1257.  
  1258. /* vi:set ai ts=4 sw=4 expandtab: */
  1259.