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 / Main.cpp < prev    next >
C/C++ Source or Header  |  2005-05-01  |  29KB  |  1,016 lines
  1. /*
  2. #
  3. # Main interface tool for GOPchop.  Implements multiple utility functions.
  4. #
  5. # $Id: Main.cpp,v 1.66 2005/05/01 17:59:23 keescook Exp $
  6. #
  7. # Copyright (C) 2001-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.  * Initial main.c file generated by Glade. Edit as required.
  28.  * Glade will not overwrite this file.
  29.  */
  30.  
  31. #include "GOPchop.h"
  32.  
  33. #include <stdio.h>
  34. #include <inttypes.h>
  35. #include <sys/types.h>
  36. #include <sys/time.h>
  37. #include <sys/stat.h>
  38. #include <sys/mman.h>
  39. #include <stdlib.h>
  40. #include <fcntl.h>
  41. #include <unistd.h>
  42. #include <sys/uio.h>
  43. #include <string.h>
  44. #include <errno.h>
  45. #include <time.h>
  46.  
  47. #ifdef ENABLE_NLS
  48. # include <locale.h>
  49. #endif
  50.  
  51. #include "Vector.h"
  52. #include "List.h"
  53. #include "ElementStream.h"
  54. #include "Pack.h"
  55. #include "GroupOfPictures.h"
  56. #include "Picture.h"
  57. #include "MPEG2Parser.h"
  58. #include "mpeg2consts.h"
  59. #include "widgets.h"
  60. #include "FirstPack.h"
  61.  
  62. #include "GOPutils.h"
  63.  
  64. #ifdef __cplusplus
  65. extern "C" {
  66. #endif
  67.  
  68. /* libmpeg2 */
  69. #include "video_out.h"
  70. #include <mpeg2dec/mpeg2.h>
  71.  
  72. #ifdef __cplusplus
  73. }
  74. #endif
  75.  
  76. #include <gtk/gtk.h>
  77. #include <gdk/gdkx.h>
  78. #include <X11/Xlib.h>
  79. #include <math.h>
  80.  
  81. #include "main.h"
  82.  
  83. #include "display.h"
  84.  
  85. #include <getopt.h>
  86.  
  87. /* */
  88. /* globals for everyone to beat on */
  89. /* */
  90. // strings
  91. char *GOPchop_cvsid = "$Id: Main.cpp,v 1.66 2005/05/01 17:59:23 keescook Exp $";
  92.  
  93. // objects
  94. MPEG2Parser *mpeg2parser;
  95.  
  96. // command line options
  97. char * opt_videoout    = NULL; // default to the first libvo driver
  98. char * opt_pipe        = NULL; // default to no command
  99. int    opt_show_states = 0;    // default to not reporting libmpeg2 states
  100.  
  101. // decode variables
  102. int                   desired_output = GOPCHOP_OUTPUT_LIBVO;
  103. /*
  104. static mpeg2dec_t    *mpeg2dec = NULL;
  105. static vo_open_t     *output_open = NULL;
  106. static vo_instance_t *output = NULL;
  107. */
  108. struct display_engine_t * engine = NULL;
  109.  
  110. // mark settings
  111. gint main_clist_count = 0;
  112. uint32_t mark_start = 0;
  113. uint32_t mark_end = 0;
  114.  
  115. // pipe variables
  116. int pipes[2];
  117. int *client_pipe = NULL;
  118.  
  119. /* global preferences */
  120. /*
  121.  * add new options below.
  122.  * If you want it saved to the rc file, add it to the "parsable_items" list.
  123.  * Update the "handle_rc" function below for rc options.
  124.  * Update the menu activation handler to auto-save the rc file.
  125.  */
  126. global_options options={
  127.     run_loop:             0, /* don't wrap arround by default */
  128.     run_speed:            1, /* one frame at a time by default */
  129.     default_run_speed:    1, /* one frame at a time by default */
  130.     auto_refresh:         1, /* show gop position changes by default */
  131.     ignore_errors:        0, /* don't ignore errors by default */
  132.     drop_orphaned_frames: 0, /* orphaned frame dropping can be nasty */
  133.     adjust_timestamps:    1, /* adjust by default */
  134.     video_driver_ptr:     NULL, /* prefered video driver */
  135.     video_driver:         "\0",
  136.     force_system_header:  0, /* force prepended system header pack */
  137.     drop_trailing_pack_with_system_header: 0, /* drop final pack if it has a system header */
  138.     ignore_endcode:       0, /* don't stop parsing when an End Code is seen */
  139. };
  140. rc_parse_item parsable_items[] = {
  141.     { "run_loop",             &options.run_loop,             RC_TYPE_BOOLEAN },
  142.     { "default_run_speed",    &options.default_run_speed,    RC_TYPE_INTEGER },
  143.     { "auto_refresh",         &options.auto_refresh,         RC_TYPE_BOOLEAN },
  144.     { "ignore_errors",        &options.ignore_errors,        RC_TYPE_BOOLEAN },
  145.     { "drop_orphaned_frames", &options.drop_orphaned_frames, RC_TYPE_BOOLEAN },
  146.     { "adjust_timestamps",    &options.adjust_timestamps,    RC_TYPE_BOOLEAN },
  147.     { "video_driver_ptr",     &options.video_driver_ptr,     RC_TYPE_STRING  },
  148.     { "force_system_header",  &options.force_system_header,  RC_TYPE_BOOLEAN },
  149.     { "drop_trailing_pack_with_system_header",  &options.drop_trailing_pack_with_system_header,  RC_TYPE_BOOLEAN },
  150.     { "ignore_endcode",       &options.ignore_endcode,       RC_TYPE_BOOLEAN },
  151.     { NULL, NULL, 0 }
  152. };
  153.  
  154. ///// My various supporting functions
  155. void flush()
  156. {
  157.     while (g_main_iteration(FALSE));
  158.     /*
  159.        while(gtk_events_pending())
  160.        gtk_main_iteration();
  161.      */
  162. }
  163.  
  164. void status_on(const gchar * owner, char *text)
  165. {
  166.     guint context;
  167.  
  168.     context = gtk_statusbar_get_context_id(GTK_STATUSBAR(main_statusbar),
  169.                                            owner);
  170.     gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), context, text);
  171.     flush();
  172. }
  173.  
  174. void status_off(const gchar * owner)
  175. {
  176.     guint context;
  177.  
  178.     context = gtk_statusbar_get_context_id(GTK_STATUSBAR(main_statusbar),
  179.                                            owner);
  180.     gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar), context);
  181.     flush();
  182.     //gtk_main_iteration_do(0);
  183.  
  184. }
  185.  
  186. const gchar *fileops = "fileops";
  187.  
  188. void progress(char *task, float done)
  189. {
  190.     static gchar *lasttask = NULL;
  191.     static float lastdone = 0.0;
  192.     float diff;
  193.  
  194.     int tasksdiffer;
  195.     gint context;
  196.  
  197.     context = gtk_statusbar_get_context_id(GTK_STATUSBAR(main_statusbar),
  198.                                            fileops);
  199.  
  200.     if (lasttask)
  201.     {
  202.         tasksdiffer = strcmp(lasttask, task);
  203.     }
  204.     else
  205.     {
  206.         tasksdiffer = 1;
  207.     }
  208.  
  209.     if (tasksdiffer)
  210.     {
  211.         if (lasttask)
  212.             gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar), context);
  213.  
  214.         lasttask = (char *) g_realloc(lasttask, strlen(task) + 1);
  215.         strcpy(lasttask, task);
  216.  
  217.         gtk_statusbar_push(GTK_STATUSBAR(main_statusbar), context, lasttask);
  218.         flush();
  219.     }
  220.  
  221.     diff = fabs(done - lastdone);
  222.  
  223.     if (!tasksdiffer && diff < 0.01)
  224.         return;
  225.  
  226.     lastdone = done;
  227.  
  228.     gtk_progress_set_percentage(GTK_PROGRESS(main_progressbar), lastdone);
  229.  
  230.     /*   sending to stderr instead...
  231.        if (mpeg2parser->getError())
  232.        show_error(mpeg2parser->getError());
  233.      */
  234.  
  235.     flush();
  236. }
  237.  
  238. void show_error(const gchar *text)
  239. {
  240.     GtkTextIter iter;
  241.     GtkTextBuffer *buffer;
  242.  
  243.     buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(error_text_why));
  244.     gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER(buffer),&iter);
  245.     gtk_text_iter_forward_to_end(&iter);
  246.     gtk_text_buffer_insert(buffer,&iter,text,-1);
  247.  
  248. }
  249.  
  250.  
  251. void get_clips_from_list(GtkTreeModel *model,
  252.                          GtkTreeIter  *iter,
  253.                          struct clip_list_t * clips)
  254. {
  255.     GValue list_GOP_first;
  256.     GValue list_GOP_last;
  257.  
  258.     if (!model || !iter || !clips) return;
  259.  
  260.     memset(&list_GOP_first,0,sizeof(list_GOP_first));
  261.     memset(&list_GOP_last, 0,sizeof(list_GOP_last));
  262.  
  263.     gtk_tree_model_get_value(GTK_TREE_MODEL(model), iter,
  264.                              ITEM_GOP_FIRST, &list_GOP_first);
  265.     gtk_tree_model_get_value(GTK_TREE_MODEL(model), iter,
  266.                              ITEM_GOP_LAST,  &list_GOP_last);
  267.  
  268.     clips->GOP_first = g_value_get_uint(&list_GOP_first);
  269.     clips->GOP_last =  g_value_get_uint(&list_GOP_last);
  270.  
  271.     g_value_unset(&list_GOP_first);
  272.     g_value_unset(&list_GOP_last);
  273. }
  274.  
  275.  
  276. /* "foreach" functions used to walk the main_clist */
  277. gboolean foreach_count_GOPs(GtkTreeModel *model,
  278.                             GtkTreePath *path,
  279.                             GtkTreeIter *iter,
  280.                             gpointer data)
  281. {
  282.     uint32_t * count = (uint32_t *)data;
  283.     struct clip_list_t clips;
  284.  
  285.     if (!count) return TRUE;
  286.  
  287.     get_clips_from_list(model,iter,&clips);
  288.  
  289.     *count += clips.GOP_last - clips.GOP_first + 1;
  290.  
  291.     return FALSE; /* keep traversing */
  292. }
  293.  
  294.  
  295. gboolean foreach_save_clips_to_file(GtkTreeModel *model,
  296.                                     GtkTreePath *path,
  297.                                     GtkTreeIter *iter,
  298.                                     gpointer data)
  299. {
  300.     struct clip_list_t clips;
  301.     uint32_t i;
  302.     struct save_clip_info_t * clip_info = (struct save_clip_info_t*)data;
  303.  
  304.     if (!clip_info) return TRUE; /* abort */
  305.  
  306.     get_clips_from_list(model,iter,&clips);
  307.  
  308.  
  309.     for (i = clips.GOP_first; i <= clips.GOP_last; i++) {
  310.         progress(clip_info->progress_task,
  311.                  (float)( (float) clip_info->count++ /
  312.                           (float) clip_info->total     ) );
  313.         
  314.         clip_info->written_bytes +=
  315.             write_GOP(clip_info->file, mpeg2parser, i,
  316.                     ((clip_info->GOP_previous + 1) == i),
  317.                     options.drop_orphaned_frames,
  318.                     options.adjust_timestamps,
  319.                     &clip_info->written_pictures,
  320.                     //TI!
  321.                     (clip_info->total - clip_info->count)==0,
  322.                     options.drop_trailing_pack_with_system_header);
  323.         clip_info->GOP_previous = i;
  324.  
  325.     }
  326.  
  327.     return FALSE; /* keep on steppin */
  328. }
  329.  
  330.  
  331.  
  332.  
  333. void save_file(char *filename)
  334. {
  335.     char buf[1024];
  336.     FILE *mpeg2;
  337.     struct save_clip_info_t clip_info;
  338.  
  339.     clip_info.progress_task = _("Saving MPEG2");
  340.  
  341.     if (!(mpeg2 = fopen(filename, "w")))
  342.     {
  343.         snprintf(buf, 1024, "%s: %s\n", filename, strerror(errno));
  344.         show_error(buf);
  345.     }
  346.     else
  347.     {
  348.         time_t begin, finish;
  349.         char report[REPORT_LENGTH];
  350.  
  351.         time(&begin);
  352.         clip_info.total=0;
  353.  
  354.         /* count up how many GOPs there are to write */
  355.         gtk_tree_model_foreach(GTK_TREE_MODEL(main_list_store),
  356.                                foreach_count_GOPs,
  357.                                &clip_info.total);
  358.  
  359.         clip_info.file=mpeg2;
  360.         clip_info.count=0;
  361.         clip_info.written_pictures=0;
  362.         clip_info.written_bytes=0;
  363.         // make sure the first GOP is closed
  364.         clip_info.GOP_previous = (uint32_t) -2;
  365.         
  366.         //TI! save first dummy pack with valid system header
  367.         if (options.force_system_header)
  368.         {
  369.             clip_info.written_bytes+=(mpeg2parser->getFirstPack())->saveFirstPack(mpeg2);
  370.         }
  371.         
  372.         /* save each clip in the list */
  373.         gtk_tree_model_foreach(GTK_TREE_MODEL(main_list_store),
  374.                                foreach_save_clips_to_file,
  375.                                &clip_info);
  376.  
  377.         progress(clip_info.progress_task, 1.0);
  378.         status_off(fileops);
  379.  
  380.         // write an end-of-PS marker
  381.         fwrite(eos_buf, sizeof(eos_buf), 1, mpeg2);
  382.         fclose(mpeg2);
  383.  
  384.         time(&finish);
  385.         finish -= begin;
  386.  
  387.         clip_info.written_bytes /= 1048576;
  388.         if (finish > 0)
  389.             clip_info.written_bytes /= finish;
  390.         if (clip_info.written_bytes == 0)
  391.             clip_info.written_bytes = 1;
  392.  
  393.         // FIXME: bad pluralization
  394.         snprintf(report,REPORT_LENGTH,finish == 1
  395.                 ? _("Wrote %s (GOPs: %u, pictures: %u) in %d second (%%%sMB/s)\n")
  396.                 : _("Wrote %s (GOPs: %u, pictures: %u) in %d seconds (%%%sMB/s)\n"),
  397.                 filename, clip_info.total, clip_info.written_pictures, finish, OFF_T_FORMAT);
  398.  
  399.         fprintf(stderr, report, clip_info.written_bytes);
  400.     }
  401. }
  402.  
  403. void open_file(char *filename)
  404. {
  405.     time_t begin, finish;
  406.     char buf[128];
  407.     off_t speed;
  408.     char report[REPORT_LENGTH];
  409.     char * gop_cache_filename;
  410.  
  411.     time(&begin);
  412.     if (!mpeg2parser->init(filename, progress))
  413.     {
  414.         show_error(mpeg2parser->getError());
  415.     }
  416.     else
  417.     {
  418.         mpeg2parser->parse(options.ignore_errors);
  419.         if (mpeg2parser->getError())
  420.             show_error(mpeg2parser->getError());
  421.  
  422.         // make sure we actually HAVE something...
  423.         List *GOPs = mpeg2parser->getGOPs();
  424.         if (GOPs && GOPs->getNum())
  425.             file_is_loaded();
  426.         else
  427.             mpeg2parser->reset();
  428.     }
  429.  
  430.     // load-time calculation
  431.     time(&finish);
  432.     finish -= begin;
  433.     speed = mpeg2parser->getSize() / 1048576;   // max speed is max size
  434.     if (finish > 0)
  435.         speed /= finish;
  436.     if (speed == 0)
  437.         speed = 1;              // claim at least 1MB/s
  438.  
  439.     snprintf(report,REPORT_LENGTH,finish == 1
  440.             ? _("Loaded %s in %d second (%%%sMB/s)\n")
  441.             : _("Loaded %s in %d seconds (%%%sMB/s)\n"),
  442.             filename, finish, OFF_T_FORMAT);
  443.  
  444.     fprintf(stderr, report, speed);
  445.  
  446.     progress(_("Caching"), 1.0);
  447.     /* write out the offset map */
  448.     if (!(gop_cache_filename=(char*)malloc(strlen(filename)+5))) {
  449.         perror("malloc");
  450.     }
  451.     else {
  452.         sprintf(gop_cache_filename,"%s.gop",filename);
  453.         if (write_gop_cache(gop_cache_filename,mpeg2parser)) {
  454.             printf("%s",_("Skipping offset cache writing.\n"));
  455.         }
  456.     }
  457.  
  458.     progress(_("Done"), 1.0);
  459.     status_off(fileops);
  460. }
  461.  
  462. /* gtk stupid: no way to get row count from a clist */
  463. void update_GOP_slice_count(int count) {
  464.     gchar buf[128];
  465.  
  466.     /* update the count of clips */
  467.     sprintf(buf, _("Clips: %d"), count);
  468.     gtk_label_set_text(GTK_LABEL(main_label_clips), buf);
  469. }
  470.  
  471. void add_GOP_slice(uint32_t start, uint32_t end)
  472. {
  473.     GtkTreeIter iter;
  474.     gchar *pathname;
  475.  
  476.     pathname = mpeg2parser->getFilename();
  477.     if (!pathname)
  478.         pathname = _("unknown pathname");
  479.  
  480.     gtk_list_store_append (main_list_store, &iter);
  481.     gtk_list_store_set (main_list_store, &iter,
  482.                         ITEM_FILENAME,  pathname,
  483.                         ITEM_GOP_FIRST, start,
  484.                         ITEM_GOP_LAST,  end,
  485.                         -1);
  486.  
  487.     main_clist_count++;
  488.     update_GOP_slice_count(main_clist_count);
  489. }
  490.  
  491. void clear_GOP_slices()
  492. {
  493.     gchar buf[128];
  494.  
  495.     gtk_list_store_clear(main_list_store);
  496.  
  497.     main_clist_count=0;
  498.     update_GOP_slice_count(main_clist_count);
  499. }
  500.  
  501. void remove_GOP_slice(GtkTreeIter *iter)
  502. {
  503.     if (!iter) return;
  504.  
  505.     gtk_list_store_remove(main_list_store,iter);
  506.  
  507.     main_clist_count--;
  508.     update_GOP_slice_count(main_clist_count);
  509. }
  510.  
  511. GdkFilterReturn filter_event(GdkXEvent *xevent,
  512.                              GdkEvent  *event,
  513.                              gpointer   data)
  514. {
  515.     //report_event(event);
  516.     printf("got event\n");
  517.     return GDK_FILTER_CONTINUE;
  518. }
  519.  
  520. const mpeg2_info_t *parser_info = NULL;
  521.  
  522. // decode_start
  523. // decode_stop
  524.  
  525. void clear_GOP_info()
  526. {
  527.     gtk_list_store_clear(GOP_list_store);
  528.     gtk_label_set_text(GTK_LABEL(GOP_label_filename), "");
  529.     gtk_label_set_text(GTK_LABEL(GOP_label_GOP), _("No GOP selected"));
  530.     gtk_label_set_text(GTK_LABEL(GOP_label_sequence_info),
  531.         _("No Sequence Info Found") );
  532. }
  533.  
  534. void update_GOP_info(uint32_t num)
  535. {
  536.     int i;
  537.     GroupOfPictures *GOP;
  538.     Bounds *picture_bounds;
  539.     Bounds *packet_bounds;
  540.     Picture *picture;
  541.     List *GOPs;
  542.     List *picture_list;
  543.     List *packet_list;
  544.     List *audio_list;
  545.     List *video_list;
  546.     Vector *head_vector;
  547.     uint32_t picture_index, picture_max;
  548.     uint32_t packet_min, packet_index, packet_max;
  549.     uint32_t audio_index, audio_max;
  550.     off_t gop_len, gop_start;
  551.     off_t audio_len;
  552.     //int   aindex, amax;
  553.     uint8_t *head;
  554.     int drop, hour, min, sec, pictures, closed, broken;
  555.  
  556.     GtkTreeIter iter;
  557.     gchar datatype[128];
  558.     gchar dataoffset[128];
  559.     gchar datasize[128];
  560.  
  561.     gchar seqbuf[128];
  562.     struct sequence_info info;
  563.  
  564.     /* wipe out the old list */
  565.     gtk_list_store_clear(GOP_list_store);
  566.     // wipe out labels
  567.     sprintf(seqbuf,_("GOP %u information:"),num);
  568.     gtk_label_set_text(GTK_LABEL(GOP_label_GOP), seqbuf);
  569.     gtk_label_set_text(GTK_LABEL(GOP_label_sequence_info),
  570.                        _("No Sequence Info Found"));
  571.  
  572.     if (!(GOPs = mpeg2parser->getGOPs()))
  573.     {
  574.         printf(_("no GOPs ?!\n"));
  575.         goto failure;
  576.     }
  577.     if (!(packet_list = mpeg2parser->getPackets()))
  578.     {
  579.         printf(_("NULL picture list ?!\n"));
  580.         goto failure;
  581.     }
  582.     if (!(picture_list = mpeg2parser->getPictures()))
  583.     {
  584.         printf(_("NULL picture list ?!\n"));
  585.         goto failure;
  586.     }
  587.     if (!(audio_list = mpeg2parser->getAudio()))
  588.     {
  589.         printf(_("NULL audio list ?!\n"));
  590.         goto failure;
  591.     }
  592.     if (!(video_list = mpeg2parser->getVideo()))
  593.     {
  594.         printf(_("NULL video list ?!\n"));
  595.         goto failure;
  596.     }
  597.     if (!(GOP = (GroupOfPictures *) GOPs->vector(num)))
  598.     {
  599.         printf(_("no such GOP %d ?!\n"), num);
  600.         goto failure;
  601.     }
  602.     if (!(head_vector = GOP->getHeader()))
  603.     {
  604.         printf(_("GOP header missing?!\n"));
  605.         goto failure;
  606.     }
  607.     if (!(head = mpeg2parser->bytesAvail(head_vector->getStart(), 8)))
  608.     {
  609.         printf(_("GOP header not available?!\n"));
  610.         goto failure;
  611.     }
  612.  
  613.     // calculate GOP information
  614.     /*
  615.        4         5         6        7
  616.        |         |         |        |
  617.        7 65432 107654 3 210765 432107 6 543210
  618.        1 11111 111111 1 111111 111111 1 1
  619.        d hour  min    m sec    pic    c b
  620.        r              a               l roken
  621.        o              r               osed
  622.        p              k
  623.      */
  624.     drop = ((head[4] & 0x80) > 0);
  625.     hour = ((head[4] & 0x7C) >> 2);
  626.     min = ((head[4] & 0x3) << 4) | ((head[5] & 0xF0) >> 4);
  627.  
  628.     // sec/picture decoding corrected, care of Scott Smith
  629.     sec = ((head[5] & 0x7) << 3) | ((head[6] & 0xE0) >> 5);
  630.     pictures = ((head[6] & 0x1F) << 1) | ((head[7] & 0x80) >> 7);
  631.  
  632.     closed = ((head[7] & 0x40) > 0);
  633.     broken = ((head[7] & 0x20) > 0);
  634.  
  635.     if (!(picture_bounds = GOP->getPictureBounds()))
  636.     {
  637.         printf(_("NULL GOP picture bounds?!\n"));
  638.         goto failure;
  639.     }
  640.  
  641.     // FIXME: technically, this loop does a lot of needless
  642.     //        reassigning of values.  However, this loop doesn't
  643.     //        happen often, and it's the easiest way I could think
  644.     //        of to sort by offset.
  645.  
  646.     // get picture bounds
  647.     picture_index = picture_bounds->getFirst();
  648.     picture_max = picture_bounds->getMax();
  649.  
  650.     for (; picture_index < picture_max; picture_index++)
  651.     {
  652.         Bounds *pic_bounds;
  653.         uint32_t ves, ves_min, ves_max;
  654.         Vector *pic_vector;
  655.         off_t pic_start;
  656.         off_t pic_len;
  657.  
  658.         if (!(picture = (Picture *) picture_list->vector(picture_index)))
  659.         {
  660.             printf(_("NULL picture?!\n"));
  661.             goto failure;
  662.         }
  663.  
  664.         if (!(pic_bounds = picture->getVideoBounds()))
  665.         {
  666.             printf(_("NULL picture bounds?!\n"));
  667.             goto failure;
  668.         }
  669.         ves_min = pic_bounds->getFirst();
  670.         ves_max = pic_bounds->getMax();
  671.         pic_len = 0;
  672.         for (ves = ves_min; ves < ves_max; ves++)
  673.         {
  674.             if (!(pic_vector = (Vector *) video_list->vector(ves)))
  675.             {
  676.                 printf(_("NULL picture VES vector?!\n"));
  677.                 goto failure;
  678.             }
  679.             if (ves == ves_min)
  680.                 pic_start = pic_vector->getStart();
  681.             pic_len += pic_vector->getLen();
  682.         }
  683.  
  684.         snprintf(datatype,   128, _("  Picture (%s: %02d)"),
  685.                 frame_type_str(picture->getType()), picture->getTime());
  686.         snprintf(dataoffset, 128, "%" OFF_T_FORMAT, pic_start);
  687.         snprintf(datasize,   128, "%" OFF_T_FORMAT, pic_len);
  688.         gtk_list_store_append(GOP_list_store, &iter);
  689.         gtk_list_store_set(GOP_list_store, &iter,
  690.                 ITEM_DATATYPE, datatype,
  691.                 ITEM_OFFSET,   dataoffset,
  692.                 ITEM_SIZE,     datasize,
  693.                 -1);
  694.     }
  695.  
  696.     // process GOP packets
  697.     if (!(packet_bounds = GOP->getPacketBounds()))
  698.     {
  699.         printf(_("NULL GOP packet bounds?!\n"));
  700.         goto failure;
  701.     }
  702.     packet_min = packet_bounds->getFirst();
  703.     packet_max = packet_bounds->getMax();
  704.     gop_len = 0;
  705.     audio_len = 0;
  706.     for (packet_index = packet_min; packet_index < packet_max; packet_index++)
  707.     {
  708.         Pack *packet;
  709.  
  710.         if (!(packet = (Pack *) packet_list->vector(packet_index)))
  711.         {
  712.             printf(_("NULL GOP packet vector?!\n"));
  713.             goto failure;
  714.         }
  715.         if (packet_index == packet_min)
  716.             gop_start = packet->getStart();
  717.         gop_len += packet->getLen();
  718.  
  719.         audio_index = packet->getAudioFirst();
  720.         audio_max = packet->getAudioMax();
  721.  
  722.         for (; audio_index < audio_max; audio_index++)
  723.         {
  724.             Bounds *audio_bounds;
  725.             int aes, aes_min, aes_max;
  726.             Vector *audio_vector;
  727.  
  728.             if (!(audio_vector = (Vector *) audio_list->vector(audio_index)))
  729.             {
  730.                 printf(_("NULL GOP AES vector?!\n"));
  731.                 goto failure;
  732.             }
  733.  
  734.             audio_len += audio_vector->getLen();
  735.  
  736.         }
  737.     }
  738.  
  739.     // display GOP
  740.     snprintf(datatype,   128, _("GOP (%02d:%02d:%02d.%02d%s%s%s)"),
  741.             hour, min, sec, pictures,
  742.             drop ? _(" drop") : _(" keep"),
  743.             closed ? _(" closed") : _(" open"),
  744.             broken ? _(" broken") : _(" whole"));
  745.     snprintf(dataoffset, 128, "%" OFF_T_FORMAT, gop_start);
  746.     snprintf(datasize,   128, "%" OFF_T_FORMAT, gop_len);
  747.     gtk_list_store_prepend(GOP_list_store, &iter);
  748.     gtk_list_store_set(GOP_list_store, &iter,
  749.             ITEM_DATATYPE, datatype,
  750.             ITEM_OFFSET,   dataoffset,
  751.             ITEM_SIZE,     datasize,
  752.             -1);
  753.  
  754.     // display audio info
  755.     snprintf(datatype,   128, "%s", _("  Audio"));
  756.     snprintf(dataoffset, 128, "%" OFF_T_FORMAT, gop_start);
  757.     snprintf(datasize,   128, "%" OFF_T_FORMAT, audio_len);
  758.     gtk_list_store_append(GOP_list_store, &iter);
  759.     gtk_list_store_set(GOP_list_store, &iter,
  760.             ITEM_DATATYPE, datatype,
  761.             ITEM_OFFSET,   dataoffset,
  762.             ITEM_SIZE,     datasize,
  763.             -1);
  764.  
  765.     // update labels with info
  766.     GOP->get_sequence_info(&info);    
  767.     snprintf(seqbuf,128,_("%dx%d: %s aspect, %s fps, %s%s"),
  768.         info.horizontal_size, info.vertical_size,
  769.         aspect_str[info.aspect_ratio],
  770.         frame_str[info.frame_rate],
  771.         speed_str(info.bit_rate * 400),
  772.         info.constrained ? _(", constrained") : "");
  773.     gtk_label_set_text(GTK_LABEL(GOP_label_sequence_info),seqbuf);
  774.  
  775.   failure:
  776.     /* perform any cleanups */
  777.     while (0) {}; // keep compiler quiet
  778. }
  779.  
  780. #define MAX_FRAME_TYPES 4
  781. const char *frame_type_map[MAX_FRAME_TYPES] = {
  782.     N_("Bad Frame"),
  783.     N_("I-Frame"),
  784.     N_("P-Frame"),
  785.     N_("B-Frame")
  786. };
  787. const char *frame_type_str(int type)
  788. {
  789.     if (type >= MAX_FRAME_TYPES || type < 0)
  790.         type = 0;
  791.     return _(frame_type_map[type]);
  792. }
  793.  
  794.  
  795. uint32_t get_GOP_selected()
  796. {
  797.     return (uint32_t) gtk_range_get_value(GTK_RANGE(GOP_selector));
  798. }
  799.  
  800. void set_GOP_selected(uint32_t num)
  801. {
  802.     uint32_t max;
  803.     uint32_t old;
  804.  
  805.     max = mpeg2parser->numGOPs();
  806.     // correct our bounds
  807.     if (num >= max)
  808.         num = max - 1;
  809.     if (num < 0)
  810.         num = 0;
  811.  
  812.     // remember where we were
  813.     old = get_GOP_selected();
  814.  
  815.     gtk_range_set_value(GTK_RANGE(GOP_selector), (gdouble) num);
  816. }
  817.  
  818. void handle_rc_load()
  819. {
  820.     if (rc_load(PACKAGE,parsable_items))
  821.         fprintf(stderr,"%s",_("Could not load rc file -- using defaults.\n"));
  822.  
  823.     /* handle side-effects */
  824.  
  825.     /* synchronize the loaded/default values to the slider */
  826.     options.run_speed = options.default_run_speed;
  827.     gtk_range_set_value(GTK_RANGE(slider_run_speed), options.run_speed);
  828.  
  829.     mpeg2parser->set_ignore_endcode(options.ignore_endcode);
  830. }
  831.  
  832. void Usage(char *title)
  833. {
  834.     printf("Usage: %s [OPTIONS] [FILE]\n\
  835. \n\
  836.   -h, --help         This help\n\
  837.   -v, --vo DRIVER    Choose internal output driver.  Use 'help' for a list.\n\
  838.   -p, --pipe CMD     Use external command for output.  Recommended:\n\
  839.                         'mplayer -nocache -novm -'\n\
  840.   -s, --states       Report libmpeg2 states\n\
  841.   FILE               MPEG2 to load on startup\n\
  842. \n", title);
  843.  
  844.     exit(1);
  845. }
  846.  
  847. void handle_args(int argc, char *argv[])
  848. {
  849.     static struct option long_options[] = {
  850.         { "help",   0, NULL, 'h' }, // 0
  851.         { "vo",     1, NULL, 'v' },
  852.         { "pipe",   1, NULL, 'p' },
  853.         { "states", 0, NULL, 's' },
  854.         { "version",0, NULL, 'V' },
  855.         { 0,        0, 0,    0 }
  856.     };
  857.  
  858.     /* do our option handling */
  859.     while (1)
  860.     {
  861.         int c;
  862.         int index;
  863.  
  864.         c = getopt_long(argc, argv, "Vhsv:p:", long_options, &index);
  865.  
  866.         if (c == -1)
  867.             break; // done with args
  868.  
  869.         switch (c)
  870.         {
  871.             case 0:
  872.                 // got a matching long argument (with no short equiv)
  873.                 switch (index)
  874.                 {
  875.                     default:
  876.                         fprintf(stderr,
  877.                                 _("Unknown long argument index %d found!\n"),
  878.                                 index);
  879.                 }
  880.                 break;
  881.             case 'h':
  882.                 Usage(argv[0]);
  883.                 break;
  884.             case 'V':
  885.                 printf("GOPchop %s (%s)\n", VERSION, __DATE__);
  886.                 exit(0);
  887.                 break;
  888.             case 's':
  889.                 opt_show_states=1;
  890.                 break;
  891.             case 'v':
  892.                 opt_videoout=optarg;
  893.                 if (strcmp(opt_videoout,"help")==0)
  894.                 {
  895.                     // display a list of libvo drivers
  896.                     int i;
  897.                     vo_driver_t const *drivers;
  898.  
  899.                     printf(_("Video output options:\n"));
  900.                     drivers = vo_drivers();
  901.                     for (i = 0; drivers[i].name; i++)
  902.                         printf("\t%s\n",drivers[i].name);
  903.                     exit(1);
  904.                 }
  905.                 else
  906.                 {
  907.                     // verify selected libvo driver
  908.                     if (!find_libvo_driver(opt_videoout))
  909.                     {
  910.                         fprintf(stderr,_("No such video driver: '%s'\n"),
  911.                                 opt_videoout);
  912.                         exit(1);
  913.                     }
  914.                     desired_output=GOPCHOP_OUTPUT_LIBVO;
  915.                 }
  916.                 break;
  917.             case 'p':
  918.                 opt_pipe=optarg;
  919.                 desired_output=GOPCHOP_OUTPUT_PIPE;
  920.                 break;
  921.             default:
  922.                 fprintf(stderr, _("Unknown short argument '%c' found?!\n"), c);
  923.                 /* fall through to the Usage ... */
  924.             case '?':
  925.                 Usage(argv[0]);
  926.                 break;
  927.         }
  928.     }
  929. }
  930.  
  931. /*
  932.  * There must be a way to hook up an event watcher to frame_window
  933.  * directly.  Until I figure it out, this will have to do.  Overkill,
  934.  * but it works.
  935.  */
  936. void gopchop_events(GdkEvent *event, gpointer data)
  937. {
  938.     GdkEventExpose *expose = (GdkEventExpose*)event;
  939.     if (event)
  940.         switch (event->type)
  941.         {
  942.             // this doesn't catch window movement :(
  943.             case GDK_VISIBILITY_NOTIFY: // forces repaint of frame window
  944.                 // don't attempt repaint while totally hidden
  945.                 if (((GdkEventVisibility*)event)->state == GDK_VISIBILITY_FULLY_OBSCURED)
  946.                     break;
  947.  
  948.                 if (display_is_window(engine,((GdkEventAny*)event)->window))
  949.                     display_redraw(engine);
  950.  
  951.                 break;
  952.             /*
  953.             case GDK_EXPOSE: // forces repaint of frame window
  954.                 if (display_is_window(engine,expose->window))
  955.                     display_redraw(engine);
  956.  
  957.                 break;
  958.                 */
  959.         }
  960.     
  961.     // process events normally
  962.     gtk_main_do_event(event);
  963.     return;
  964. }
  965.  
  966. int main(int argc, char *argv[])
  967. {
  968.  
  969.  
  970.     /* deal with internationalization support */
  971. #ifdef ENABLE_NLS
  972.     setlocale(LC_ALL, "");
  973.     bindtextdomain(GETTEXT_PACKAGE, PACKAGE_DATA_DIR "/locale");
  974.     textdomain(GETTEXT_PACKAGE);
  975. #endif
  976.     gtk_set_locale();
  977.  
  978.     /* pass command line args to gtk (which may modify them) */
  979.     gtk_init(&argc, &argv);
  980.     /* handle our command line args */
  981.     handle_args(argc, argv);
  982.  
  983.     /* setup the parsing object */
  984.     mpeg2parser = new MPEG2Parser;
  985.  
  986.     /* set up all the gtk windows and widgets */
  987.     setup_gtk_stuff();
  988.  
  989.     /* verify that we're working with largefile support
  990.      * (report to Gtk window)
  991.      */
  992.     if (sizeof(off_t) < 8)
  993.     {
  994.         show_error(_("Type 'off_t' is less than 8 bytes.\n"
  995.                      "Largefile support requires at least 8 bytes.\n"));
  996.         gtk_widget_show(error_dialog);
  997.     }
  998.  
  999.     /* load any saved options (prior to opening the first file) */
  1000.     handle_rc_load();
  1001.  
  1002.     /* attempt to load the filename mentioned on the command line 
  1003.      * (requires MPEG2Parser and GTK loaded
  1004.      */
  1005.     if (optind < argc)
  1006.         open_file(argv[optind]);
  1007.  
  1008.     /* start the event handler */
  1009.     gdk_event_handler_set(gopchop_events,NULL,NULL);
  1010.     gtk_main();
  1011.     return 0;
  1012. }
  1013.  
  1014.  
  1015. /* vi:set ai ts=4 sw=4 expandtab: */
  1016.