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 / display.cpp < prev    next >
C/C++ Source or Header  |  2005-05-02  |  23KB  |  695 lines
  1. /*
  2. #
  3. # Display subsystem.
  4. #
  5. # $Id: display.cpp,v 1.9 2005/05/02 04:45:57 keescook Exp $
  6. #
  7. # Copyright (C) 2001-2005 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 "display.h"
  28.  
  29. #ifdef __cplusplus
  30. extern "C" {
  31. #endif
  32.  
  33. /* libmpeg2 */
  34. #include "video_out.h"
  35. #include <mpeg2dec/mpeg2.h>
  36.  
  37. #ifdef __cplusplus
  38. }
  39. #endif
  40.  
  41. #include <stdio.h>
  42. #include <unistd.h>
  43. #include <stdlib.h>
  44. #include <string.h>
  45.  
  46. #include "GOPchop.h"
  47. #include "main.h"
  48. #include "List.h"
  49. #include "Pack.h"
  50. #include "ElementStream.h"
  51. #include "mpeg2consts.h"
  52.  
  53. static
  54. void frame_draw(struct display_engine_t * engine)
  55. {
  56.     if (!engine) return;
  57.  
  58.     if (engine && engine->output && engine->output->draw &&
  59.         engine->parser_info && engine->parser_info->display_fbuf) {
  60.  
  61.         engine->output->draw(engine->output,
  62.                      engine->parser_info->display_fbuf->buf,
  63.                      engine->parser_info->display_fbuf->id);
  64.     }
  65. }
  66.  
  67. // decode function
  68. static
  69. void decode(struct display_engine_t * engine, uint8_t * buffer, size_t len)
  70. {
  71.     Window xwindow;
  72.     vo_setup_result_t setup_result;
  73.     int state;
  74. #ifdef DEBUG_VES
  75.     FILE *ves_debug;
  76. #endif
  77.  
  78.     //printf("decoding %ld bytes of VES data\n",len);
  79.  
  80.     /* make sure output and decoder are available */
  81.     if (!engine) {
  82.         fprintf(stderr, "%s", _("Display engine missing!\n"));
  83.         return;
  84.     }
  85.     if (!engine->output) {
  86.         fprintf(stderr, "%s", _("Output window missing!\n"));
  87.         return;
  88.     }
  89.     if (!engine->mpeg2dec) {
  90.         fprintf(stderr, "%s", _("MPEG2 decoder missing!\n"));
  91.         return;
  92.     }
  93.  
  94.     if (!buffer) {
  95.         fprintf(stderr,"%s",_("decode called with a missing buffer!?\n"));
  96.         return;
  97.     }
  98.  
  99.     //if (len) {
  100.         mpeg2_buffer(engine->mpeg2dec, buffer, buffer + len);
  101.         if (!(engine->parser_info = mpeg2_info(engine->mpeg2dec)))
  102.         {
  103.             fprintf(stderr, "%s", _("MPEG2 decoder info not available!?\n"));
  104.             exit(1);
  105.         }
  106.     //}
  107.  
  108. #ifdef DEBUG_VES
  109.     /* dump the VES packets to a file */
  110.     ves_debug = fopen("video.es", "a");
  111.     fwrite(buffer, len, 1, ves_debug);
  112.     fclose(ves_debug);
  113. #endif
  114.  
  115.     while ((state = mpeg2_parse(engine->mpeg2dec)) != STATE_BUFFER)
  116.     {
  117.         switch (state)
  118.         {
  119.             case STATE_SEQUENCE:
  120.                 if (engine->opt_show_states) printf("STATE_SEQUENCE\n");
  121.                 if (!engine->parser_info->sequence) {
  122.                     fprintf(stderr,"%s",_("Got STATE_SEQUENCE without a sequence!?\n"));
  123.                     break;
  124.                 }
  125.                 if (engine->opt_show_states)
  126.                     printf("saw sequence (%ux%u, pix %u:%u, disp %ux%u)\n",
  127.                         engine->parser_info->sequence->width,
  128.                         engine->parser_info->sequence->height,
  129.                         engine->parser_info->sequence->pixel_width,
  130.                         engine->parser_info->sequence->pixel_height,
  131.                         engine->parser_info->sequence->display_width*engine->parser_info->sequence->pixel_width/engine->parser_info->sequence->pixel_height,
  132.                         engine->parser_info->sequence->picture_height
  133.                         );
  134.                 /* sequence started, so initialize output window */
  135.                 if (engine->output->setup(engine->output,
  136.                                   engine->parser_info->sequence->width,
  137.                                   engine->parser_info->sequence->height,
  138.                                   engine->parser_info->sequence->display_width*engine->parser_info->sequence->pixel_width/engine->parser_info->sequence->pixel_height,
  139.                                   engine->parser_info->sequence->height,
  140.                                   engine->parser_info->sequence->chroma_width,
  141.                                   engine->parser_info->sequence->chroma_height,
  142.                                   &setup_result))
  143.                 {
  144.                     fprintf(stderr, "%s", _("Failed to setup display\n"));
  145.                     return;
  146.                 }
  147.  
  148.                 if (engine->output->window_handle) {
  149.                     xwindow = (Window)engine->output->window_handle(engine->output);
  150.                     engine->frame_window = gdk_window_foreign_new((int)xwindow);
  151.                     if (engine->frame_window) {
  152.                         gdk_window_set_events(engine->frame_window,GDK_ALL_EVENTS_MASK);
  153.                         // this doesn't catch screen motion :(
  154.                         XSelectInput(GDK_DISPLAY(), xwindow,
  155.                                      VisibilityChangeMask
  156.                                      // ExposureMask
  157.                                      // | PointerMotionMask
  158.                                      );
  159.                     }
  160.                 }
  161.  
  162.                 /* does the output need to be converted? */
  163.                 if (setup_result.convert)
  164.                     mpeg2_convert(engine->mpeg2dec, setup_result.convert, NULL);
  165.                 /* can the output provide an fbuf area? */
  166.                 if (engine->output->set_fbuf)
  167.                 {
  168.                     uint8_t *buf[3];
  169.                     void *id;
  170.  
  171.                     mpeg2_custom_fbuf(engine->mpeg2dec, 1);
  172.  
  173.                     engine->output->set_fbuf(engine->output, buf, &id);
  174.                     mpeg2_set_buf(engine->mpeg2dec, buf, id);
  175.  
  176.                     engine->output->set_fbuf(engine->output, buf, &id);
  177.                     mpeg2_set_buf(engine->mpeg2dec, buf, id);
  178.                 }
  179.                 else if (engine->output->setup_fbuf)
  180.                 {
  181.                     uint8_t *buf[3];
  182.                     void *id;
  183.  
  184.                     engine->output->setup_fbuf(engine->output, buf, &id);
  185.                     mpeg2_set_buf(engine->mpeg2dec, buf, id);
  186.                     engine->output->setup_fbuf(engine->output, buf, &id);
  187.                     mpeg2_set_buf(engine->mpeg2dec, buf, id);
  188.                     engine->output->setup_fbuf(engine->output, buf, &id);
  189.                     mpeg2_set_buf(engine->mpeg2dec, buf, id);
  190.                 }
  191.                 break;
  192.             case STATE_PICTURE:
  193.                 if (engine->opt_show_states) {
  194.                     printf("STATE_PICTURE:   ");
  195.                     if (engine->parser_info &&
  196.                         engine->parser_info->current_picture) {
  197.                         switch (engine->parser_info->current_picture->flags &
  198.                                 PIC_MASK_CODING_TYPE) {
  199.                             case PIC_FLAG_CODING_TYPE_I:
  200.                                 printf("I");
  201.                                 break;
  202.                             case PIC_FLAG_CODING_TYPE_B:
  203.                                 printf("B");
  204.                                 break;
  205.                             case PIC_FLAG_CODING_TYPE_P:
  206.                                 printf("P");
  207.                                 break;
  208.                             case PIC_FLAG_CODING_TYPE_D:
  209.                                 printf("D");
  210.                                 break;
  211.                             default:
  212.                                 printf("unknown");
  213.                                 break;
  214.                         }
  215.                         printf("(%02d)",
  216.                                engine->parser_info->current_picture->temporal_reference);
  217.                     }
  218.                     printf("       parsed\n");
  219.                 }
  220.  
  221.                 /* picture is starting */
  222.                 if (engine->output->set_fbuf)
  223.                 {
  224.                     uint8_t *buf[3];
  225.                     void *id;
  226.  
  227.                     engine->output->set_fbuf(engine->output, buf, &id);
  228.                     mpeg2_set_buf(engine->mpeg2dec, buf, id);
  229.                 }
  230.                 if (engine->output->start_fbuf) {
  231.                     if (engine->parser_info->current_fbuf) {
  232.                         engine->output->start_fbuf(engine->output,
  233.                                            engine->parser_info->current_fbuf->buf,
  234.                                            engine->parser_info->current_fbuf->id);
  235.                     }
  236.                     else {
  237.                         fprintf(stderr,"%s",_("Got STATE_PICTURE without a current_fbuf!?\n"));
  238.                     }
  239.                 }
  240.                 break;
  241.             case STATE_SLICE:
  242.             case STATE_END:
  243. #ifdef HAVE_MPEG2_FLUSH_PICTURE
  244.             case STATE_FLUSHED:
  245. #endif
  246.                 if (engine->opt_show_states) {
  247.                     printf("STATE_%s       ",
  248.                             state == STATE_SLICE ?    "SLICE:    "
  249.                               : (state == STATE_END ? "END:      "
  250.                                  :                    "FLUSHED:  "));
  251.                     if (engine->parser_info &&
  252.                         engine->parser_info->display_picture)
  253.                     {
  254.                         switch (engine->parser_info->display_picture->flags & PIC_MASK_CODING_TYPE)
  255.                         {
  256.                             case PIC_FLAG_CODING_TYPE_I:
  257.                                 printf("I");
  258.                                 break;
  259.                             case PIC_FLAG_CODING_TYPE_P:
  260.                                 printf("P");
  261.                                 break;
  262.                             case PIC_FLAG_CODING_TYPE_B:
  263.                                 printf("B");
  264.                                 break;
  265.                             case PIC_FLAG_CODING_TYPE_D:
  266.                                 printf("D");
  267.                                 break;
  268.                             default:
  269.                                 printf("unknown");
  270.                                 break;
  271.                         }
  272.                         printf("(%02d)",
  273.                            engine->parser_info->display_picture->temporal_reference);
  274.                     }
  275.                     else
  276.                     {
  277.                         printf("      nothing loaded to be");
  278.                     }
  279.                     printf(" rendered\n");
  280.                 }
  281.  
  282.                 /* draw current picture */
  283.                 frame_draw(engine);
  284.                 if (engine->output->discard && engine->parser_info->discard_fbuf)
  285.                     engine->output->discard(engine->output,
  286.                                     engine->parser_info->discard_fbuf->buf,
  287.                                     engine->parser_info->discard_fbuf->id);
  288.                 break;
  289.             case STATE_INVALID:
  290.                 if (engine->opt_show_states) printf("STATE_INVALID\n");
  291.                 break;
  292.             case STATE_INVALID_END:
  293.                 if (engine->opt_show_states) printf("STATE_INVALID_END\n");
  294.                 break;
  295.             case STATE_SEQUENCE_REPEATED:
  296.                 if (engine->opt_show_states) printf("STATE_SEQUENCE_REPEATED\n");
  297.                 break;
  298.             case STATE_GOP:
  299.                 if (engine->opt_show_states) printf("STATE_GOP\n");
  300.                 break;
  301.             case STATE_SLICE_1ST:
  302.                 if (engine->opt_show_states) printf("STATE_SLICE_1ST\n");
  303.                 break;
  304.             case STATE_PICTURE_2ND:
  305.                 if (engine->opt_show_states) printf("STATE_PICTURE_2ND\n");
  306.                 break;
  307.             default:
  308.                 if (engine->opt_show_states) printf("STATE: %d\n",state);
  309.                 break;
  310.         }
  311.     }
  312.     if (engine->opt_show_states) printf("STATE_BUFFER\n");
  313. }
  314.  
  315. struct display_engine_t * display_open(
  316.         int    desired_output,
  317.         char * opt_output_arg,
  318.         char * opt_videoout,
  319.         int    opt_show_states)
  320. {
  321.     struct display_engine_t * engine;
  322.  
  323.     if (!(engine=(struct display_engine_t*)calloc(1,sizeof(*engine)))) {
  324.         perror("malloc");
  325.         return NULL;
  326.     }
  327.     engine->opt_show_states=opt_show_states;
  328.     engine->desired_output=desired_output;
  329.  
  330.     vo_open_t * output_open = NULL;
  331.  
  332.     if (engine->desired_output==GOPCHOP_OUTPUT_LIBVO)
  333.     {
  334.         // decoding
  335.         uint32_t accel = 0;
  336.  
  337.         if (!(output_open=find_libvo_driver(opt_videoout)))
  338.         {
  339.             fprintf(stderr, _("Can't find output driver '%s'\n"), opt_videoout);
  340.             exit(1);
  341.         }
  342.     
  343.         if (!(engine->output = output_open()))
  344.         {
  345.             fprintf(stderr, _("Can't open output driver '%s'\n"), opt_videoout);
  346.         }
  347.     
  348.         accel = mpeg2_accel(MPEG2_ACCEL_DETECT);
  349. #ifdef ARCH_X86
  350.         if (accel & MPEG2_ACCEL_X86_MMXEXT)
  351.             printf("%s", _("Using x86 MMXext acceleration\n"));
  352.         else if (accel & MPEG2_ACCEL_X86_3DNOW)
  353.             printf("%s", _("Using x86 3DNow acceleration\n"));
  354.         else if (accel & MPEG2_ACCEL_X86_MMX)
  355.             printf("%s", _("Using x86 MMX acceleration\n"));
  356. #endif
  357. #ifdef ARCH_PPC
  358.         if (accel & MPEG2_ACCEL_PPC_ALTIVEC)
  359.             printf("%s", _("Using PowerPC Altivec acceleration\n"));
  360. #endif
  361. #ifdef ARCH_ALPHA
  362.         if (accel & MPEG2_ACCEL_ALPHA_MVI)
  363.             printf("%s", _("Using Alpha MVI acceleration\n"));
  364.         else if (accel & MPEG2_ACCEL_ALPHA)
  365.             printf("%s", _("Using Alpha acceleration\n"));
  366. #endif
  367. #ifdef ARCH_SPARC
  368.         if (accel & MPEG2_ACCEL_SPARC_VIS)
  369.             printf("%s", _("Using Sparc VIS acceleration\n"));
  370.         else if (accel & MPEG2_ACCEL_SPARC_VIS2)
  371.             printf("%s", _("Using Sparc VIS2 acceleration\n"));
  372. #endif
  373.         else
  374.             printf("%s", _("Using no special acceleration\n"));
  375.     
  376.         if (!(engine->mpeg2dec = mpeg2_init()))
  377.         {
  378.             fprintf(stderr, "%s", _("Cannot initialize mpeg2 decoder!\n"));
  379.             exit(1);
  380.         }
  381.     }
  382.     else if (engine->desired_output == GOPCHOP_OUTPUT_PIPE)
  383.     {
  384.         // try a piped command instead
  385.  
  386.         if (!opt_output_arg)
  387.         {
  388.             fprintf(stderr, "%s", _("Pipe command required.  Try --pipe\n"));
  389.             exit(1);
  390.         }
  391.  
  392.         // fork off a command
  393.         if (pipe(engine->pipes) < 0)
  394.         {
  395.             perror("pipe");
  396.             exit(1);
  397.         }
  398.  
  399.         pid_t pid = fork();
  400.  
  401.         // failure
  402.         if (pid < 0)
  403.         {
  404.             perror("fork");
  405.             exit(1);
  406.         }
  407.  
  408.         // child
  409.         if (pid == 0)
  410.         {
  411.             char * shell;
  412.  
  413.             close(engine->pipes[1]);
  414.             if (dup2(engine->pipes[0], STDIN_FILENO) < 0)
  415.             {
  416.                 perror("dup2");
  417.                 exit(1);
  418.             }
  419.     
  420.             // get the shell to use
  421.             if (!(shell=getenv("SHELL")))
  422.             {
  423.                 fprintf(stderr,"%s",
  424.                         _("Cannot figure out from environment what shell to exec.\n"));
  425.                 exit(1);
  426.             }
  427.  
  428.             execl(shell,shell,"-c", opt_output_arg, NULL);
  429.             perror("execl");
  430.             exit(1);
  431.         }
  432.     
  433.         // parent
  434.         engine->client_pipe = &engine->pipes[1];
  435.         close(engine->pipes[0]);
  436.     }
  437.     else {
  438.         fprintf(stderr,_("Unknown output desired!?\n"));
  439.     }
  440.  
  441.  
  442.     return engine;
  443. }
  444.  
  445. void display_close(struct display_engine_t * engine)
  446. {
  447.     if (!engine) return;
  448.  
  449.     if (engine->output)
  450.     {
  451.         // invalidate these
  452.         engine->frame_window = NULL;
  453.         engine->parser_info  = NULL;
  454.  
  455.         mpeg2_close(engine->mpeg2dec);
  456.         engine->mpeg2dec = NULL;
  457.         if (engine->output->close)
  458.             engine->output->close(engine->output);
  459.         engine->output = NULL;
  460.     }
  461.  
  462.     if (engine->client_pipe)
  463.     {
  464.         close(*engine->client_pipe);
  465.         engine->client_pipe = NULL;
  466.     }
  467.  
  468.     engine->last_valid=0;
  469.     engine->GOP=NULL;
  470. }
  471.  
  472. vo_open_t * find_libvo_driver(char * desired_driver)
  473. {
  474.     int i;
  475.     vo_driver_t const *drivers;
  476.  
  477.     drivers = vo_drivers();
  478.     for (i = 0; drivers[i].name; i++)
  479.         if (!desired_driver || !strcmp(drivers[i].name, desired_driver))
  480.             return drivers[i].open;
  481.  
  482.     return NULL;
  483. }
  484.  
  485.  
  486. void show_GOP(struct display_engine_t * engine, uint32_t wantedGOP)
  487. {
  488.     static int initdone = 0;
  489.     List *packets;
  490.     Pack *packet;
  491.     List *GOPs;
  492.     GroupOfPictures *GOP;
  493.     Bounds *bounds;
  494.     ElementStream *ves;
  495.     int start, stop;
  496.  
  497.     uint8_t *loc;
  498.     size_t len;
  499.  
  500.     if (!engine) return;
  501.  
  502.     if (engine->opt_show_states) printf("show GOP: %u\n",wantedGOP);
  503.  
  504.     // get our GOP list
  505.     if (!(GOPs = mpeg2parser->getGOPs()))
  506.     {
  507.         printf("%s", _("\tNo GOPs\n"));
  508.         return;
  509.     }
  510.  
  511.     // get our packet list
  512.     if (!(packets = mpeg2parser->getPackets()))
  513.     {
  514.         printf("%s", _("\tNo packets\n"));
  515.         return;
  516.     }
  517.  
  518.     // get GOP we're after
  519.     if (!(GOP = (GroupOfPictures *) GOPs->vector(wantedGOP)))
  520.     {
  521.         printf(_("\tGOP %d missing\n"), wantedGOP);
  522.         return;
  523.     }
  524.  
  525.     // handle reset logic
  526.     if (engine->last_valid) {
  527.         if (wantedGOP == engine->last_group) return;
  528.         if (  (engine->last_group+1 != wantedGOP) ||
  529.               (engine->last_flushed)  ) {
  530.             if (engine->opt_show_states) printf("MPEG2 reset\n");
  531.             mpeg2_reset(engine->mpeg2dec,0);
  532.             if (wantedGOP>0 && !GOP->has_sequence_info()) {
  533.                 uint32_t num;
  534.                 GroupOfPictures *previous=NULL;
  535.  
  536.                 for (num=wantedGOP-1;
  537.                      ;
  538.                      num--)
  539.                 {
  540.                     if (!(previous=(GroupOfPictures *) GOPs->vector(num))) {
  541.                         printf(_("\tGOP %d missing\n"), num);
  542.                         return;
  543.                     }
  544.                     if (previous->has_sequence_info()) break;
  545.                     previous=NULL;
  546.  
  547.                     if (num==0) break;
  548.                 }
  549.  
  550.                 // found a prior sequence header
  551.                 if (previous) {
  552.                     sequence_header bytes;
  553.                     if (engine->opt_show_states)
  554.                         printf("Injecting sequence from GOP %d\n",num);
  555.                     previous->get_sequence_header(&bytes);
  556.                     decode(engine,(uint8_t*)&bytes,sizeof(bytes));
  557.                 }
  558.                 else {
  559.                     if (engine->opt_show_states)
  560.                         printf("could not find needed sequence\n");
  561.                 }
  562.             }
  563.         }
  564.     }
  565.     engine->last_group = wantedGOP;
  566.     engine->last_flushed = 0;
  567.     engine->last_valid = 1;
  568.  
  569.  
  570.     // get our GOP's range of packets
  571.     bounds = GOP->getPacketBounds();
  572.     // remember our start and finish points
  573.     start = bounds->getFirst();
  574.     stop = bounds->getMax();
  575.  
  576.     for (uint32_t j = start; j < stop; j++)
  577.     {
  578.         if (!(packet = (Pack *) packets->vector(j)))
  579.         {
  580.             printf("%s", _("NULL packet?!\n"));
  581.             exit(1);
  582.         }
  583.  
  584.         if (engine->desired_output==GOPCHOP_OUTPUT_LIBVO && engine->output)
  585.         {
  586.             uint32_t ves_start, ves_stop;
  587.  
  588.             ves_start = packet->getVideoFirst();
  589.             ves_stop = packet->getVideoMax();
  590.  
  591.             for (uint32_t k = ves_start; k < ves_stop; k++)
  592.             {
  593.                 if (!(ves =
  594.                       (ElementStream *)mpeg2parser->getVideo()->vector(k)))
  595.                 {
  596.                     printf("%s", _("NULL VES?!\n"));
  597.                     exit(1);
  598.                 }
  599.     
  600.                 len = ves->getLen();
  601.                 loc = (uint8_t *)mpeg2parser->bytesAvail(ves->getStart(), len);
  602.     
  603.                 /*
  604.                 fprintf(stderr,_("\t\tVES: %d @ %llu (%d): 0x%08x\n"),
  605.                         k,ves->getStart(),len,
  606.                         (unsigned int)loc);
  607.                 */
  608.     
  609.                 if (loc && len)
  610.                     decode(engine, loc, len);
  611.             }
  612.         }
  613.         else if (engine->desired_output==GOPCHOP_OUTPUT_PIPE && engine->client_pipe)
  614.         {
  615.             // send entire packet to pipe
  616.  
  617.             len = packet->getLen();
  618.             loc = (uint8_t*)mpeg2parser->bytesAvail(packet->getStart(), len);
  619.             if (loc && engine->client_pipe)
  620.             {
  621.                 int written;
  622.     
  623.                 // stuff things into the pipe
  624.                 while (len > 0)
  625.                 {
  626.                     if ((written = write(*(engine->client_pipe), loc, len)) < 0)
  627.                     {
  628.                         perror("write");
  629.                         exit(1);
  630.                     }
  631.                     loc += written;
  632.                     len -= written;
  633.                 }
  634.             }
  635.         }
  636.         else {
  637.             fprintf(stderr,_("Unknown output desired!?\n"));
  638.         }
  639.  
  640.     }
  641. }
  642.  
  643. void display_flush(struct display_engine_t * engine)
  644. {
  645.     if (engine && engine->last_valid && !engine->last_flushed) {
  646.         if (engine->opt_show_states) printf("-- trying to flush pictures\n");
  647.         /* throw in an end-of-stream to make sure libvo kicks out the last frame */
  648.         if (engine->desired_output==GOPCHOP_OUTPUT_LIBVO && engine->output) {
  649. #ifdef HAVE_MPEG2_FLUSH_PICTURE
  650.             mpeg2_flush_picture(mpeg2dec);
  651.             decode(engine, (uint8_t*)"",0);
  652. #else
  653.             decode(engine, (uint8_t*)seq_end_buf,sizeof(seq_end_buf));
  654. #endif
  655.             engine->last_flushed = 1;
  656.         }
  657.         if (engine->opt_show_states) printf("-- done\n");
  658.     }
  659. }
  660.  
  661. void display_hookup_gop(struct display_engine_t * engine,
  662.                         GroupOfPictures *GOP)
  663. {
  664.     if (!engine) return;
  665.  
  666.     engine->GOP=GOP;
  667.     engine->last_valid=0;
  668. }
  669.  
  670. bool display_is_window(struct display_engine_t * engine,
  671.                                GdkWindow * window)
  672. {
  673.     if (engine && engine->frame_window == window) return true;
  674.     return false;
  675. }
  676.  
  677. void display_redraw(struct display_engine_t * engine)
  678. {
  679.     if (!engine) return;
  680.  
  681.     /* how the hell do we keep the window visible?  I don't want to have
  682.      * to totally reprocess the GOP every time we get visibility noticiation
  683.      */
  684.     if (engine->last_valid) {
  685.         // "forget" we were already here, and force a redraw
  686.         uint32_t gop = engine->last_group;
  687.         engine->last_group= gop + 1;
  688.         show_GOP(engine,gop);
  689.         flush();
  690.         display_flush(engine);
  691.     }
  692. }
  693.  
  694. /* vi:set ai ts=4 sw=4 expandtab: */
  695.