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 / GOPutils.cpp < prev    next >
C/C++ Source or Header  |  2005-04-30  |  14KB  |  475 lines
  1. /*
  2. #
  3. # Worker for writing GOP information to files
  4. #
  5. # $Id: GOPutils.cpp,v 1.9 2005/04/30 20:10:01 keescook Exp $
  6. #
  7. # Copyright (C) 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. #include "GOPutils.h"
  29.  
  30. #include "MPEG2Parser.h"
  31. #include "Picture.h"
  32.  
  33. // display writing locations (from write_GOP) to stderr
  34. #undef MPEG2_CLIPS_TO_STDERR
  35.  
  36. #include "mpeg2consts.h"
  37. void write_timestamp(unsigned char * head, uint32_t pictures, int rate);
  38.  
  39. /*
  40.  * This exports a text file that can be used to re-load an MPEG2-PS
  41.  * much more quickly.  (And this file can be used to check the results
  42.  * of GOPchop's parser.)
  43.  *
  44.  * Format is:
  45.  *   TAG COUNT OFFSET[:LENGTH]
  46.  *
  47.  * GOP %u %llu:%lu
  48.  * pack %u %llu
  49.  * ...
  50.  * pic %u %llu:%lu
  51.  * ves %u %llu:%lu
  52.  * ...
  53.  *
  54.  * If you have more GOPs than can be indexed by a 32bit variable,
  55.  * then you can change the index variable yourself.  ;)
  56.  *
  57.  */
  58. int write_gop_cache(char * filename, MPEG2Parser * mpeg2parser)
  59. {
  60.     int result=-1;
  61.     List *GOPs;
  62.     List *packets;
  63.     List *pictures;
  64.     List *ves;
  65.     Vector *vector;
  66.     uint32_t gopnum, gopmax;
  67.     FILE * fp;
  68.  
  69.     if (!(fp=fopen(filename,"w"))) {
  70.         perror(filename);
  71.         return -1;
  72.     }
  73.  
  74.     if (!(GOPs = mpeg2parser->getGOPs())) {
  75.         printf("%s",_("NULL GOP list?!\n"));
  76.         goto need_close;
  77.     }
  78.     if (!(packets = mpeg2parser->getPackets())) {
  79.         printf("%s", _("NULL packet list?!\n"));
  80.         goto need_close;
  81.     }
  82.     if (!(pictures = mpeg2parser->getPictures())) {
  83.         printf("%s", _("NULL picture list?!\n"));
  84.         goto need_close;
  85.     }
  86.     if (!(ves = mpeg2parser->getVideo())) {
  87.         printf("%s", _("NULL VES list?!\n"));
  88.         goto need_close;
  89.     }
  90.  
  91.     gopmax=GOPs->getNum();
  92.     for (gopnum=0;gopnum<gopmax;gopnum++) {
  93.         GroupOfPictures *gop;
  94.         Bounds *bounds;
  95.         uint32_t num, max;
  96.         Vector *header;
  97.  
  98.         if (!(gop=(GroupOfPictures*)GOPs->vector(gopnum))) {
  99.             printf("%s", _("Missing GOP %u!?\n"),gopnum);
  100.             goto need_close;
  101.         }
  102.  
  103.         if (!(header=gop->getHeader())) {
  104.             printf("%s",_("Missing GOP %u header!?\n"),gopnum);
  105.             goto need_close;
  106.         }
  107.  
  108.         fprintf(fp,"GOP %u %" OFF_T_FORMAT "\n",
  109.                    gopnum, header->getStart());
  110.  
  111.         /* report packets */
  112.         if (!(bounds=gop->getPacketBounds())) {
  113.             printf("%s", _("NULL packet list for GOP %d?!\n"), gopnum);
  114.             goto need_close;
  115.         }
  116.         max=bounds->getMax();
  117.         for (num=bounds->getFirst();num<max;num++) {
  118.             Pack *pack;
  119.  
  120.             if (!(pack=(Pack*)packets->vector(num))) {
  121.                 printf("%s",_("Missing Pack %u!?\n"),num);
  122.                 goto need_close;
  123.             }
  124.  
  125.             fprintf(fp,"pack %u %" OFF_T_FORMAT "\n",
  126.                        num, pack->getStart());
  127.             
  128.         }
  129.  
  130.         /* report pictures */
  131.         if (!(bounds=gop->getPictureBounds())) {
  132.             printf("%s", _("NULL picture list for GOP %d?!\n"), gopnum);
  133.             goto need_close;
  134.         }
  135.         max=bounds->getMax();
  136.         for (num=bounds->getFirst();num<max;num++) {
  137.             Picture *picture;
  138.             Bounds * vesbounds;
  139.             uint32_t vesnum, vesmax;
  140.  
  141.             if (!(picture=(Picture*)pictures->vector(num))) {
  142.                 printf("%s",_("Missing Picture %u!?\n"),num);
  143.                 goto need_close;
  144.             }
  145.  
  146.             fprintf(fp,"pic %u %" OFF_T_FORMAT "\n",
  147.                        num,picture->getStart());
  148.  
  149.             /* report video */
  150.             if (!(vesbounds=picture->getVideoBounds())) {
  151.                 printf("%s", _("NULL video ES list for GOP %d?!\n"), gopnum);
  152.                 goto need_close;
  153.             }
  154.             vesmax=vesbounds->getMax();
  155.             for (vesnum=vesbounds->getFirst();vesnum<vesmax;vesnum++) {
  156.                 ElementStream *es;
  157.  
  158.                 if (!(es=(ElementStream*)ves->vector(vesnum))) {
  159.                     printf("%s",_("Missing VES packet %u!?\n"),vesnum);
  160.                     goto need_close;
  161.                 }
  162.  
  163.                 fprintf(fp,"ves %u %" OFF_T_FORMAT ":%lu\n",
  164.                            vesnum,es->getStart(),es->getLen());
  165.             }
  166.         }
  167.     }
  168.  
  169.     result=0;
  170.  
  171. need_close:
  172.     if (fclose(fp)) {
  173.         perror(filename);
  174.         result=-1;
  175.     }
  176.     return result;
  177. }
  178.  
  179. void write_clip_list(char * filename, struct clip_list_t * clips)
  180. {
  181. }
  182.  
  183. /*
  184.  * Global memory area to do GOPheader manipulations
  185.  */
  186. uint8_t * GOPareaPtr = NULL;
  187. size_t GOPareaSize = 0;
  188. /*
  189.  * file: stream to write to
  190.  * mpeg2parser: object to read MPEG2 data from
  191.  * num: which GOP to write
  192.  * continuous: was the GOP before this one the "original" prior GOP?
  193.  * drop_orphaned_frames: should non-continuous orphaned B/P frames get dropped?
  194.  * adjust_timestamps: should timestamps be updated?
  195.  * pictures_written: pointer to read/update number of pictures written
  196.  *
  197.  */
  198. off_t write_GOP(FILE * file, MPEG2Parser * mpeg2parser,
  199.                 uint32_t num, int continuous,
  200.                 int drop_orphaned_frames,
  201.                 int adjust_timestamps,
  202.                 uint32_t *pictures_written,
  203.                 bool is_last_gop,
  204.                 bool drop_trailing_pack_with_system_header
  205.                 )
  206. {
  207.     List *GOPs;
  208.     GroupOfPictures *GOP;
  209.     Vector *GOPheader;
  210.     List *packets;
  211.     Bounds *packet_bounds;
  212.     Bounds *picture_bounds;
  213.     Vector *pes_vector;
  214.     Pack *packet;
  215.     uint32_t pes, pes_max;
  216.     uint8_t old_bits;
  217.     uint8_t *header;
  218.     uint8_t *area;
  219.     int P_Frame_seen;
  220.     int open_GOP;
  221.  
  222.     off_t written_bytes;
  223.     uint32_t written_pictures;
  224.  
  225.     size_t GOPlen;
  226.     size_t GOPoffset;
  227.  
  228.  
  229.     written_bytes = 0;
  230.     written_pictures = 0;
  231.     P_Frame_seen = 0;
  232.     open_GOP = 0;
  233.  
  234.     if (!mpeg2parser || !file) return 0;
  235.  
  236.     if (!(GOPs = mpeg2parser->getGOPs())) {
  237.         printf("%s", _("NULL GOP list?!\n"));
  238.         return 0;
  239.     }
  240.     if (!(packets = mpeg2parser->getPackets())) {
  241.         printf("%s", _("NULL packet list?!\n"));
  242.         return 0;
  243.     }
  244.     if (!(GOP = (GroupOfPictures *) GOPs->vector(num))) {
  245.         printf("%s", _("NULL GOP?!\n"));
  246.         return 0;
  247.     }
  248.     if (!(GOPheader = (Vector *) GOP->getHeader())) {
  249.         printf("%s", _("NULL GOP header?!\n"));
  250.         return 0;
  251.     }
  252.     if (!(packet_bounds = GOP->getPacketBounds())) {
  253.         printf("%s", _("NULL packet bounds?!\n"));
  254.         return 0;
  255.     }
  256.  
  257.     // figure out how many pictures we're going to write
  258.     if (!(picture_bounds = GOP->getPictureBounds())) {
  259.         printf("%s", _("NULL GOP picture bounds?!\n"));
  260.         return 0;
  261.     }
  262.     written_pictures = picture_bounds->getMax() - picture_bounds->getFirst();
  263.  
  264.     // instead of writing one packet at a time, let's try
  265.     // writing whole GOPs at once.
  266.  
  267.     // figure out size of GOP in memory
  268.     GOPlen = 0;
  269.     pes_max = packet_bounds->getMax();
  270.     
  271.     /* TI! */
  272.     if (drop_trailing_pack_with_system_header &&
  273.         is_last_gop) //check if the last pack has a system header
  274.     {
  275.         Pack *last_packet = (Pack *) packets->vector(pes_max - 1);  //last packet
  276.         
  277.         pack_header_t *pk_header = (pack_header_t *)mpeg2parser->bytesAvail(last_packet->getStart(), sizeof(pack_header_t));
  278.         
  279.         //is it here the system header?
  280.         off_t addr_system_header= last_packet->getStart() + sizeof(pack_header_t) + (pk_header->bits[9] & 0x07);
  281.         //printf("addr_system_header [%lu]\n",(unsigned long) addr_system_header);
  282.         
  283.         system_header_t *sys_header = (system_header_t *)
  284.             mpeg2parser->bytesAvail(addr_system_header, sizeof(system_header_t));
  285.         
  286.         if (sys_header->start_code[0]==0x00 &&
  287.             sys_header->start_code[1]==0x00 &&
  288.             sys_header->start_code[2]==0x01 &&
  289.             sys_header->start_code[3]==0xBB)
  290.         {    
  291.             //printf("Found system header in Last Pack\n");
  292.             pes_max--;
  293.         }
  294.     }
  295.     /* end TI! */
  296.     
  297.     for (pes = packet_bounds->getFirst(); pes < pes_max; pes++)
  298.     {
  299.         if (!(packet = (Pack *) packets->vector(pes)))
  300.         {
  301.             printf("%s", _("NULL PES?!\n"));
  302.             return 0;
  303.         }
  304.         GOPlen += packet->getLen();
  305.     }
  306.     if (GOPlen > GOPareaSize)
  307.     {
  308.         // let's not realloc because we don't need to keep the
  309.         // contents
  310.         if (GOPareaPtr)
  311.             free(GOPareaPtr);
  312.         if (!(GOPareaPtr = (uint8_t *) malloc(GOPlen)))
  313.         {
  314.             printf("%s", _("Ran out of memory!?\n"));
  315.             return 0;
  316.         }
  317.         GOPareaSize = GOPlen;
  318.     }
  319.  
  320.     GOPoffset = 0;
  321.     //pes_max = packet_bounds->getMax(); //TI!
  322.     for (pes = packet_bounds->getFirst(); pes < pes_max; pes++)
  323.     {
  324.         size_t len;
  325.         int undo;
  326.         int okay_to_write;
  327.         int has_header;
  328.  
  329.         // assume we can write this packet...
  330.         okay_to_write = 1;
  331.         has_header = 0;
  332.         //printf("writing PES %d\n",pes);
  333.  
  334.         if (!(packet = (Pack *) packets->vector(pes)))
  335.         {
  336.             printf("%s", _("NULL PES?!\n"));
  337.             goto abort;
  338.         }
  339.  
  340.         len = packet->getLen();
  341.         if (!(area = mpeg2parser->bytesAvail(packet->getStart(), len)))
  342.         {
  343.             printf("%s", _("unavailable memory?!\n"));
  344.             goto abort;
  345.         }
  346.  
  347.         // do our header verifications in mmap, but make the
  348.         // actual changes in our shared memory area
  349.         if (GOPheader->getStart() > packet->getStart() &&
  350.             GOPheader->getStart() + GOPheader->getLen() <
  351.             packet->getStart() + packet->getLen())
  352.         {
  353.             // GOP header is in this packet
  354.             has_header = 1;
  355.             header = area + (GOPheader->getStart() - packet->getStart());
  356.  
  357.             // do we have an open GOP?
  358.             open_GOP = ((header[7] & 0x40) == 0);
  359.         }
  360.  
  361.         // handle B-frame dropping
  362.         if (drop_orphaned_frames && open_GOP && !continuous && !P_Frame_seen)
  363.         {
  364.             Vector *pic_header;
  365.  
  366.             // if this packet has a B-frame, skip it
  367.             if ((pic_header =
  368.                  mpeg2parser->findCode((Vector *) packet,
  369.                                        (uint8_t*)picture_start_code,
  370.                                        6)))
  371.             {
  372.                 int pic_type;
  373.  
  374.                 pic_type =
  375.                     (area[pic_header->getStart() - packet->getStart() + 5] &
  376.                      PICTURE_CODING_MASK) >> 3;
  377.  
  378.                 if (pic_type == PICTURE_CODING_BIDIRECTIONAL)
  379.                 {
  380.                     //printf("Dropping open GOP B-frame on splice\n");
  381.                     okay_to_write = 0;
  382.                     written_pictures--;
  383.                 }
  384.                 if (pic_type == PICTURE_CODING_PREDICTIVE)
  385.                 {
  386.                     //printf("Keeping rest of frames in open GOP splice\n");
  387.                     P_Frame_seen = 1;
  388.                 }
  389.             }
  390.         }
  391.  
  392.         if (okay_to_write)
  393.         {
  394. #ifdef MPEG2_CLIPS_TO_STDERR
  395.             fprintf(stderr, _("\tWriting @ %llu for %d bytes\n"),
  396.                     packet->getStart(), len);
  397. #endif
  398.             memcpy(GOPareaPtr + GOPoffset, area, len);
  399.  
  400.             /* handle making adjustments to GOP header */
  401.             if (has_header)
  402.             {
  403.                 // GOP header is in our current memory area
  404.                 header = GOPareaPtr + GOPoffset +
  405.                             (GOPheader->getStart() - packet->getStart());
  406.  
  407.                 if (!continuous && open_GOP) {
  408.                     // need to set the "broken" flag
  409.  
  410.                     // an editor has been here
  411.                     header[7] |= GOP_FLAG_BROKEN;   
  412.                     // but most decoders don't care
  413.                     if (drop_orphaned_frames)
  414.                         header[7] |= GOP_FLAG_CLOSED;   
  415.                     /*
  416.                        printf("GOP: 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",
  417.                        header[0],header[1],header[2],header[3],
  418.                        header[4],header[5],header[6],header[7]);
  419.                      */
  420.                 }
  421.  
  422.                 if (adjust_timestamps) {
  423.                     struct sequence_info info;
  424.                     // do it
  425.                     GOP->get_sequence_info(&info);
  426.                     write_timestamp(header,*pictures_written,info.frame_rate);
  427.                 }
  428.             }
  429.  
  430.             GOPoffset += len;
  431.         }
  432.     }
  433.  
  434.     if (GOPoffset > 0)
  435.     {
  436.         // flush to disk
  437.         if (fwrite(GOPareaPtr, sizeof(uint8_t), GOPoffset, file) != GOPoffset)
  438.         {
  439.             printf("%s", _("write failed\n"));
  440.             goto abort;
  441.         }
  442.         written_bytes += GOPoffset;
  443.         *pictures_written += written_pictures;
  444.     }
  445.   abort:
  446.     return written_bytes;
  447. }
  448.  
  449. void write_timestamp(unsigned char * head, uint32_t pictures, int rate) {
  450.     uint32_t seconds, minutes, hours, top, remainder;
  451.  
  452.     //printf("pictures: %u rate: %s ", pictures,frame_str[rate]);
  453.  
  454.     /*
  455.         rate = frames/second
  456.         seconds = frames / rate
  457.         frames = seconds * rate
  458.      */
  459.  
  460.     seconds = pictures * rate_frac[rate].seconds / rate_frac[rate].frames;
  461.     hours = (seconds/60)/60;
  462.     minutes = (seconds/60) % 60;
  463.     seconds = seconds % 60;
  464.     pictures -= seconds * rate_frac[rate].frames / rate_frac[rate].seconds;
  465.  
  466.     //printf("(%d:%d:%d.%d)\n", hours,minutes,seconds,pictures);
  467.  
  468.     head[4]=(head[4]&128)|((hours&0xFF)<<2)|((minutes&0x30)<<4);
  469.     head[5]=((minutes&0x0F)<<4)|(head[5]&0x08)|((seconds&0x38)>>3);
  470.     head[6]=((seconds&0x07)<<5)|((pictures&0x3F)>>1);
  471.     head[7]=((pictures&0x1)<<7)|(head[7]&0x7F);
  472. }
  473.  
  474. /* vi:set ai ts=4 sw=4 expandtab: */
  475.