开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
vout.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：39k
源码类别：

midi

开发平台：

Unix_Linux

vout.c：源码内容
  1. /*****************************************************************************
  2.  * vout.c: QNX RTOS video output display method
  3.  *****************************************************************************
  4.  * Copyright (C) 2001, 2002 the VideoLAN team
  5.  *
  6.  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
  7.  *          Pascal Levesque <Pascal.Levesque@mindready.com>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22.  *****************************************************************************/
  24. /*****************************************************************************
  25.  * Preamble
  26.  *****************************************************************************/
  27. #include <errno.h>                                                 /* ENOMEM */
  29. #include <photon/PtWidget.h>
  30. #include <photon/PtWindow.h>
  31. #include <photon/PtLabel.h>
  32. #include <photon/PdDirect.h>
  34. #ifdef HAVE_CONFIG_H
  35. # include "config.h"
  36. #endif
  38. #include <vlc_common.h>
  39. #include <vlc_interface.h>
  40. #include <vlc_vout.h>
  42. /*****************************************************************************
  43.  * vout_sys_t: video output QNX method descriptor
  44.  *****************************************************************************
  45.  * This structure is part of the video output thread descriptor.
  46.  * It describes the QNX specific properties of an output thread. QNX video
  47.  * output is performed through regular resizable windows. Windows can be
  48.  * dynamically resized to adapt to the size of the streams.
  49.  *****************************************************************************/
  50. #define MAX_DIRECTBUFFERS 2
  52. #define MODE_NORMAL_MEM     0
  53. #define MODE_SHARED_MEM     1
  54. #define MODE_VIDEO_MEM      2
  55. #define MODE_VIDEO_OVERLAY  3
  57. struct vout_sys_t
  58. {
  59.     /* video mode */
  60.     int                     i_mode;
  62.     /* internal stuff */
  63.     PtWidget_t *            p_window;
  65.     /* Color palette for 8bpp */
  66.     PgColor_t p_colors[255];
  68.     /* [shared] memory blit */
  69.     int                     i_img_type;
  71.     /* video memory blit */
  73.     /* video overlay */
  74.     PgVideoChannel_t *      p_channel;
  75.     int                     i_vc_flags;
  76.     int                     i_vc_format;
  78.     int                 i_screen_depth;
  79.     int                 i_bytes_per_pixel;
  80.     int                 i_bytes_per_line;
  82.     /* position & dimensions */
  83.     PhPoint_t               pos;
  84.     PhDim_t                 dim;
  85.     PhPoint_t               old_pos;
  86.     PhDim_t                 old_dim;
  87.     PhDim_t                 screen_dim;
  88.     PhRect_t                frame;
  89. };
  92. /*****************************************************************************
  93.  * picture_sys_t: direct buffer method descriptor
  94.  *****************************************************************************
  95.  * This structure is part of the picture descriptor, it describes the
  96.  * XVideo specific properties of a direct buffer.
  97.  *****************************************************************************/
  98. struct picture_sys_t
  99. {
  100.     /* [shared] memory blit */
  101.     PhImage_t *             p_image;
  103.     /* video memory blit and video overlay */
  104.     PdOffscreenContext_t *  p_ctx[3];   /* 0: y, 1: u, 2: v */
  105.     char *                  p_buf[3];
  106. };
  109. /*****************************************************************************
  110.  * Local prototypes
  111.  *****************************************************************************/
  112. static int  QNXInit      ( vout_thread_t * );
  113. static void QNXEnd       ( vout_thread_t * );
  114. static int  QNXManage    ( vout_thread_t * );
  115. static void QNXDisplay   ( vout_thread_t *, picture_t * );
  117. static int  QNXInitDisplay ( vout_thread_t * );
  118. static int  QNXCreateWnd   ( vout_thread_t * );
  119. static int  QNXDestroyWnd  ( vout_thread_t * );
  121. static int  NewPicture     ( vout_thread_t *, picture_t *, int );
  122. static void FreePicture    ( vout_thread_t *, picture_t * );
  123. static int  ResizeOverlayOutput ( vout_thread_t * );
  124. static void SetPalette     ( vout_thread_t *, uint16_t *, uint16_t *, uint16_t * );
  126. /*****************************************************************************
  127.  * OpenVideo: allocate QNX video thread output method
  128.  *****************************************************************************
  129.  * This function allocate and initialize a QNX vout method. It uses some of the
  130.  * vout properties to choose the window size, and change them according to the
  131.  * actual properties of the display.
  132.  *****************************************************************************/
  133. int OpenVideo ( vlc_object_t *p_this )
  134. {
  135.     vout_thread_t * p_vout = (vout_thread_t *)p_this;
  137.     /* init connection to photon */
  138.     if( PtInit( "/dev/photon" ) != 0 )
  139.     {
  140.         msg_Err( p_vout, "unable to connect to photon" );
  141.         return( 1 );
  142.     }
  144.     /* allocate structure */
  145.     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
  146.     if( p_vout->p_sys == NULL )
  147.         return( 1 );
  149.     memset( p_vout->p_sys, 0, sizeof( vout_sys_t ) );
  151.     p_vout->b_fullscreen = config_GetInt( p_vout, "fullscreen" );
  152.     p_vout->p_sys->i_mode = config_GetInt( p_vout, "overlay" ) ?
  153.                                 MODE_VIDEO_OVERLAY : MODE_VIDEO_MEM;
  154.     p_vout->p_sys->dim.w = p_vout->i_window_width;
  155.     p_vout->p_sys->dim.h = p_vout->i_window_height;
  157.     /* init display and create window */
  158.     if( QNXInitDisplay( p_vout ) || QNXCreateWnd( p_vout ) )
  159.     {
  160.         free( p_vout->p_sys );
  161.         return( 1 );
  162.     }
  164.     p_vout->pf_init = QNXInit;
  165.     p_vout->pf_end = QNXEnd;
  166.     p_vout->pf_manage = QNXManage;
  167.     p_vout->pf_render = NULL;
  168.     p_vout->pf_display = QNXDisplay;
  170.     return( 0 );
  171. }
  173. /*****************************************************************************
  174.  * QNXInit: initialize QNX video thread output method
  175.  *****************************************************************************
  176.  * This function create the buffers needed by the output thread. It is called
  177.  * at the beginning of the thread, but also each time the window is resized.
  178.  *****************************************************************************/
  179. static int QNXInit( vout_thread_t *p_vout )
  180. {
  181.     int i_index;
  182.     picture_t *p_pic;
  184.     I_OUTPUTPICTURES = 0;
  186.     switch( p_vout->p_sys->i_mode )
  187.     {
  188.     case MODE_NORMAL_MEM:
  189.     case MODE_SHARED_MEM:
  190.         p_vout->output.i_width = p_vout->p_sys->dim.w;
  191.         p_vout->output.i_height = p_vout->p_sys->dim.h;
  193.         /* Assume we have square pixels */
  194.         p_vout->output.i_aspect = p_vout->p_sys->dim.w
  195.                                * VOUT_ASPECT_FACTOR / p_vout->p_sys->dim.h;
  196.         break;
  198.     case MODE_VIDEO_MEM:
  199.         p_vout->output.i_width = p_vout->p_sys->dim.w;
  200.         p_vout->output.i_height = p_vout->p_sys->dim.h;
  202.         /* Assume we have square pixels */
  203.         p_vout->output.i_aspect = p_vout->p_sys->dim.w
  204.                                * VOUT_ASPECT_FACTOR / p_vout->p_sys->dim.h;
  205.         break;
  207.     case MODE_VIDEO_OVERLAY:
  208.         p_vout->output.i_width  = p_vout->render.i_width;
  209.         p_vout->output.i_height = p_vout->render.i_height;
  210.         p_vout->output.i_aspect = p_vout->render.i_aspect;
  212.         if (ResizeOverlayOutput(p_vout))
  213.         {
  214.             return (1);
  215.         }
  216.         break;
  218.     default:
  219.         /* This shouldn't happen ! */
  220.         break;
  221.     }
  223.     /* Try to initialize up to MAX_DIRECTBUFFERS direct buffers */
  224.     while( I_OUTPUTPICTURES < MAX_DIRECTBUFFERS )
  225.     {
  226.         p_pic = NULL;
  228.         /* Find an empty picture slot */
  229.         for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
  230.         {
  231.             if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
  232.             {
  233.                 p_pic = p_vout->p_picture + i_index;
  234.                 break;
  235.             }
  236.         }
  238.         /* Allocate the picture */
  239.         if( p_pic == NULL || NewPicture( p_vout, p_pic, I_OUTPUTPICTURES ) )
  240.         {
  241.             break;
  242.         }
  244.         p_pic->i_status = DESTROYED_PICTURE;
  245.         p_pic->i_type   = DIRECT_PICTURE;
  247.         PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
  249.         I_OUTPUTPICTURES++;
  250.     }
  252.     return( 0 );
  253. }
  255. /*****************************************************************************
  256.  * QNXEnd: terminate QNX video thread output method
  257.  *****************************************************************************
  258.  * Destroy the buffers created by QNXInit. It is called at the end of
  259.  * the thread, but also each time the window is resized.
  260.  *****************************************************************************/
  261. static void QNXEnd( vout_thread_t *p_vout )
  262. {
  263.     int i_index;
  265.     /* Free the direct buffers we allocated */
  266.     for( i_index = I_OUTPUTPICTURES ; i_index ; )
  267.     {
  268.         i_index--;
  269.         FreePicture( p_vout, PP_OUTPUTPICTURE[ i_index ] );
  270.     }
  271. }
  273. /*****************************************************************************
  274.  * CloseVideo: destroy QNX video thread output method
  275.  *****************************************************************************
  276.  * Terminate an output method created by QNXCreate
  277.  *****************************************************************************/
  278. void CloseVideo ( vlc_object_t *p_this )
  279. {
  280.     vout_thread_t * p_vout = (vout_thread_t *)p_this;
  282.     /* destroy the window */
  283.     QNXDestroyWnd( p_vout );
  285.     /* destroy structure */
  286.     free( p_vout->p_sys );
  287. }
  289. /*****************************************************************************
  290.  * QNXManage: handle QNX events
  291.  *****************************************************************************
  292.  * This function should be called regularly by video output thread. It allows
  293.  * window resizing. It returns a non null value on error.
  294.  *****************************************************************************/
  295. static int QNXManage( vout_thread_t *p_vout )
  296. {
  297.     int i_ev,  i_buflen;
  298.     PhEvent_t *p_event;
  299.     bool b_repos = 0;
  301.     if (!vlc_object_alive (p_vout))
  302.     {
  303.         return ( 0 );
  304.     }
  306.     /* allocate buffer for event */
  307.     i_buflen = sizeof( PhEvent_t ) * 4;
  308.     if( ( p_event = malloc( i_buflen ) ) == NULL )
  309.         return( 1 );
  311.     /* event loop */
  312.     do
  313.     {
  314.         memset( p_event, 0, i_buflen );
  315.         i_ev = PhEventPeek( p_event, i_buflen );
  317.         if( i_ev == Ph_RESIZE_MSG )
  318.         {
  319.             PhEvent_t *buf;
  321.             i_buflen = PhGetMsgSize( p_event );
  322.             buf = realloc( p_event, i_buflen );
  323.             if( buf == NULL )
  324.             {
  325.                 free( p_event );
  326.                 return( 1 );
  327.             }
  328.             p_event = buf;
  329.         }
  330.         else if( i_ev == Ph_EVENT_MSG )
  331.         {
  332.             PtEventHandler( p_event );
  334.             if( p_event->type == Ph_EV_WM )
  335.             {
  336.                 PhWindowEvent_t *p_ev = PhGetData( p_event );
  338.                 switch( p_ev->event_f )
  339.                 {
  340.                 case Ph_WM_CLOSE:
  341.                     p_vout->p_libvlc->b_die = true;
  342.                     break;
  344.                 case Ph_WM_MOVE:
  345.                     p_vout->p_sys->pos.x = p_ev->pos.x;
  346.                     p_vout->p_sys->pos.y = p_ev->pos.y;
  347.                     b_repos = 1;
  348.                     break;
  350.                 case Ph_WM_RESIZE:
  351.                     p_vout->p_sys->old_dim.w = p_vout->p_sys->dim.w;
  352.                     p_vout->p_sys->old_dim.h = p_vout->p_sys->dim.h;
  353.                     p_vout->p_sys->dim.w = p_ev->size.w;
  354.                     p_vout->p_sys->dim.h = p_ev->size.h;
  355.                     p_vout->i_changes |= VOUT_SIZE_CHANGE;
  356.                     break;
  357.                 }
  358.             }
  359.             else if( p_event->type == Ph_EV_KEY )
  360.             {
  361.                 PhKeyEvent_t *p_ev = PhGetData( p_event );
  362.                 long i_key = p_ev->key_sym;
  364.                 if( ( p_ev->key_flags & Pk_KF_Key_Down ) &&
  365.                     ( p_ev->key_flags & Pk_KF_Sym_Valid ) )
  366.                 {
  367.                     switch( i_key )
  368.                     {
  369.                     case Pk_q:
  370.                     case Pk_Q:
  371.                         p_vout->p_libvlc->b_die = true;
  372.                         break;
  374.                     case Pk_f:
  375.                     case Pk_F:
  376.                         p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
  377.                         break;
  379.                     default:
  380.                         break;
  381.                     }
  382.                 }
  383.             }
  384.         }
  385.     } while( i_ev != -1 && i_ev != 0 );
  387.     free( p_event );
  389.     /*
  390.      * fullscreen
  391.      */
  392.     if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
  393.     {
  394.         PhDim_t dim;
  396.         p_vout->b_fullscreen = !p_vout->b_fullscreen;
  397.         p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
  399.         if( p_vout->b_fullscreen )
  400.         {
  401.             p_vout->p_sys->old_pos.x = p_vout->p_sys->pos.x;
  402.             p_vout->p_sys->old_pos.y = p_vout->p_sys->pos.y;
  403.             p_vout->p_sys->pos.x = p_vout->p_sys->pos.y = 0;
  404.             dim.w = p_vout->p_sys->screen_dim.w + 1;
  405.             dim.h = p_vout->p_sys->screen_dim.h + 1;
  406.         }
  407.         else
  408.         {
  409.             p_vout->p_sys->pos.x = p_vout->p_sys->old_pos.x;
  410.             p_vout->p_sys->pos.y = p_vout->p_sys->old_pos.y;
  411.             dim.w = p_vout->p_sys->old_dim.w + 1;
  412.             dim.h = p_vout->p_sys->old_dim.h + 1;
  413.         }
  415.         /* modify render flags, border */
  416.         PtSetResource( p_vout->p_sys->p_window,
  417.             Pt_ARG_WINDOW_RENDER_FLAGS,
  418.             p_vout->b_fullscreen ? Pt_FALSE : Pt_TRUE,
  419.             Ph_WM_RENDER_BORDER | Ph_WM_RENDER_TITLE );
  421.         /* set position and dimension */
  422.         PtSetResource( p_vout->p_sys->p_window,
  423.                        Pt_ARG_POS, &p_vout->p_sys->pos, 0 );
  424.         PtSetResource( p_vout->p_sys->p_window,
  425.                        Pt_ARG_DIM, &dim, 0 );
  427.         /* mark as damaged to force redraw */
  428.         PtDamageWidget( p_vout->p_sys->p_window );
  429.     }
  431.     /*
  432.      * size change
  433.      */
  434.     if( p_vout->i_changes & VOUT_SIZE_CHANGE )
  435.     {
  436.         p_vout->i_changes &= ~VOUT_SIZE_CHANGE;
  438.         if( p_vout->p_sys->i_mode == MODE_VIDEO_OVERLAY )
  439.         {
  440.             ResizeOverlayOutput(p_vout);
  441.         }
  442. #if 0
  443.         else
  444.         {
  445.             p_vout->output.i_width = p_vout->p_sys->dim.w;
  446.             p_vout->output.i_height = p_vout->p_sys->dim.h;
  447.             p_vout->i_changes |= VOUT_YUV_CHANGE;
  449.             QNXEnd( p_vout );
  450.             if( QNXInit( p_vout ) )
  451.             {
  452.                 msg_Err( p_vout, "cannot resize display" );
  453.                 return( 1 );
  454.             }
  455.         }
  456. #endif
  458.         msg_Dbg( p_vout, "video display resized (%dx%d)",
  459.                          p_vout->p_sys->dim.w, p_vout->p_sys->dim.h );
  460.     }
  462.     /*
  463.      * position change, move video channel
  464.      */
  465.     if( b_repos && p_vout->p_sys->i_mode == MODE_VIDEO_OVERLAY )
  466.     {
  467.         ResizeOverlayOutput(p_vout);
  468.     }
  470.     return( i_ev == -1 );
  471. }
  473. /*****************************************************************************
  474.  * QNXDisplay: displays previously rendered output
  475.  *****************************************************************************
  476.  * This function send the currently rendered image to QNX server, wait until
  477.  * it is displayed and switch the two rendering buffer, preparing next frame.
  478.  *****************************************************************************/
  479. static void QNXDisplay( vout_thread_t *p_vout, picture_t *p_pic )
  480. {
  481.     if( p_vout->p_sys->i_mode == MODE_NORMAL_MEM ||
  482.         p_vout->p_sys->i_mode == MODE_SHARED_MEM )
  483.     {
  484.         PhPoint_t pos = { 0, 0 };
  486.         PgSetRegion( PtWidgetRid( p_vout->p_sys->p_window ) );
  487.         if (p_vout->p_sys->i_screen_depth == 8)
  488.         {
  489.             PgSetPalette( p_vout->p_sys->p_colors, 0, 0, 255, Pg_PALSET_SOFT, 0);
  490.         }
  491.         PgDrawPhImagemx( &pos, p_pic->p_sys->p_image, 0 );
  492.         PgFlush();
  493.     }
  494.     else if( p_vout->p_sys->i_mode == MODE_VIDEO_MEM )
  495.     {
  496.         PhRect_t rc = { { 0, 0 }, { p_vout->output.i_width, p_vout->output.i_height } };
  498. //        PgSetRegion( PtWidgetRid ( p_vout->p_sys->p_window ) );
  499.         PgContextBlit( p_pic->p_sys->p_ctx[0], &rc, NULL, &rc );
  500.         PgFlush();
  501.     }
  502. }
  504. /*****************************************************************************
  505.  * QNXInitDisplay: check screen resolution, depth, amount of video ram, etc
  506.  *****************************************************************************/
  507. static int QNXInitDisplay( vout_thread_t * p_vout )
  508. {
  509.     PgHWCaps_t hwcaps;
  510.     PgDisplaySettings_t cfg;
  511.     PgVideoModeInfo_t minfo;
  513.     /* get graphics card hw capabilities */
  514.     if( PgGetGraphicsHWCaps( &hwcaps ) != 0 )
  515.     {
  516.         msg_Err( p_vout, "unable to get gfx card capabilities" );
  517.         return( 1 );
  518.     }
  520.     /* get current video mode */
  521.     if( PgGetVideoMode( &cfg ) != 0 )
  522.     {
  523.         msg_Err( p_vout, "unable to get current video mode" );
  524.         return( 1 );
  525.     }
  527.     /* get video mode info */
  528.     if( PgGetVideoModeInfo( cfg.mode, &minfo ) != 0 )
  529.     {
  530.         msg_Err( p_vout, "unable to get info for video mode" );
  531.         return( 1 );
  532.     }
  534.     if( p_vout->p_sys->i_mode == MODE_VIDEO_OVERLAY )
  535.     {
  536.         int i = 0;
  537.         PgScalerCaps_t vcaps;
  539.         if( ( p_vout->p_sys->p_channel =
  540.             PgCreateVideoChannel( Pg_VIDEO_CHANNEL_SCALER, 0 ) ) == NULL )
  541.         {
  542.             msg_Err( p_vout, "unable to create video channel" );
  543.             printf("errno = %dn", errno);
  544.             p_vout->p_sys->i_mode = MODE_NORMAL_MEM;
  545.         }
  546.         else
  547.         {
  548.             vcaps.size = sizeof( vcaps );
  549.             while( PgGetScalerCapabilities( p_vout->p_sys->p_channel,
  550.                                             i++, &vcaps ) == 0 )
  551.             {
  552.                 printf("vcaps.format = 0x%xn", vcaps.format);
  553.                 if( vcaps.format == Pg_VIDEO_FORMAT_YV12 ||
  554.                     vcaps.format == Pg_VIDEO_FORMAT_YUV420 ||
  555.                     vcaps.format == Pg_VIDEO_FORMAT_YUY2 ||
  556.                     vcaps.format == Pg_VIDEO_FORMAT_UYVY ||
  557.                     vcaps.format == Pg_VIDEO_FORMAT_RGB555 ||
  558.                     vcaps.format == Pg_VIDEO_FORMAT_RGB565 ||
  559.                     vcaps.format == Pg_VIDEO_FORMAT_RGB8888 )
  560.                 {
  561.                     p_vout->p_sys->i_vc_flags  = vcaps.flags;
  562.                     p_vout->p_sys->i_vc_format = vcaps.format;
  563.                 }
  565.                 vcaps.size = sizeof( vcaps );
  566.             }
  568.             if( p_vout->p_sys->i_vc_format == 0 )
  569.             {
  570.                 msg_Warn( p_vout, "need YV12, YUY2 or RGB8888 overlay" );
  572.                 p_vout->p_sys->i_mode = MODE_NORMAL_MEM;
  573.             }
  574.         }
  575.     }
  577.     /* use video ram if we have enough available */
  578.     if( p_vout->p_sys->i_mode == MODE_NORMAL_MEM &&
  579.         (minfo.bits_per_pixel != 8) &&
  580.         hwcaps.currently_available_video_ram >=
  581.         ( ( minfo.width * minfo.height * minfo.bits_per_pixel * MAX_DIRECTBUFFERS) / 8 ) )
  582.     {
  583.         p_vout->p_sys->i_mode = MODE_VIDEO_MEM;
  584.         printf("Using video memory...n");
  585.     }
  587.     p_vout->p_sys->i_img_type = minfo.type;
  588.     p_vout->p_sys->screen_dim.w = minfo.width;
  589.     p_vout->p_sys->screen_dim.h = minfo.height;
  590.     p_vout->p_sys->i_screen_depth = minfo.bits_per_pixel;
  592.     switch( p_vout->p_sys->i_screen_depth )
  593.     {
  594.         case 8:
  595.             p_vout->output.i_chroma = VLC_FOURCC('R','G','B','2');
  596.             p_vout->p_sys->i_bytes_per_pixel = 1;
  597.             p_vout->output.pf_setpalette = SetPalette;
  598.             break;
  600.         case 15:
  601.             p_vout->output.i_chroma = VLC_FOURCC('R','V','1','5');
  602.             p_vout->p_sys->i_bytes_per_pixel = 2;
  603.             p_vout->output.i_rmask = 0x7c00;
  604.             p_vout->output.i_gmask = 0x03e0;
  605.             p_vout->output.i_bmask = 0x001f;
  606.             break;
  608.         case 16:
  609.             p_vout->output.i_chroma = VLC_FOURCC('R','V','1','6');
  610.             p_vout->p_sys->i_bytes_per_pixel = 2;
  611.             p_vout->output.i_rmask = 0xf800;
  612.             p_vout->output.i_gmask = 0x07e0;
  613.             p_vout->output.i_bmask = 0x001f;
  614.             break;
  616.         case 24:
  617.             p_vout->output.i_chroma = VLC_FOURCC('R','V','2','4');
  618.             p_vout->p_sys->i_bytes_per_pixel = 3;
  619.             p_vout->output.i_rmask = 0xff0000;
  620.             p_vout->output.i_gmask = 0x00ff00;
  621.             p_vout->output.i_bmask = 0x0000ff;
  622.             break;
  624.         case 32:
  625.         default:
  626.             p_vout->output.i_chroma = VLC_FOURCC('R','V','3','2');
  627.             p_vout->p_sys->i_bytes_per_pixel = 4;
  628.             p_vout->output.i_rmask = 0xff0000;
  629.             p_vout->output.i_gmask = 0x00ff00;
  630.             p_vout->output.i_bmask = 0x0000ff;
  631.             break;
  632.     }
  634.     return( 0 );
  635. }
  637. /*****************************************************************************
  638.  * QNXCreateWnd: create and realize the main window
  639.  *****************************************************************************/
  640. static int QNXCreateWnd( vout_thread_t * p_vout )
  641. {
  642.     PtArg_t args[8];
  643.     PhPoint_t pos = { 0, 0 };
  644.     PgColor_t color = Pg_BLACK;
  646.     if( p_vout->p_sys->i_mode == MODE_VIDEO_OVERLAY )
  647.     {
  648.         if( p_vout->p_sys->i_vc_flags & Pg_SCALER_CAP_DST_CHROMA_KEY )
  649.         {
  650.             color = PgGetOverlayChromaColor();
  651.         }
  652.     }
  654.     /* fullscreen, set dimension */
  655.     if( p_vout->b_fullscreen )
  656.     {
  657.         p_vout->p_sys->old_dim.w = p_vout->p_sys->dim.w;
  658.         p_vout->p_sys->old_dim.h = p_vout->p_sys->dim.h;
  659.         p_vout->output.i_width = p_vout->p_sys->dim.w = p_vout->p_sys->screen_dim.w;
  660.         p_vout->output.i_height = p_vout->p_sys->dim.h = p_vout->p_sys->screen_dim.h;
  661.     }
  663.     /* set window parameters */
  664.     PtSetArg( &args[0], Pt_ARG_POS, &pos, 0 );
  665.     PtSetArg( &args[1], Pt_ARG_DIM, &p_vout->p_sys->dim, 0 );
  666.     PtSetArg( &args[2], Pt_ARG_FILL_COLOR, color, 0 );
  667.     PtSetArg( &args[3], Pt_ARG_WINDOW_TITLE, "VLC media player", 0 );
  668.     PtSetArg( &args[4], Pt_ARG_WINDOW_MANAGED_FLAGS, Pt_FALSE, Ph_WM_CLOSE );
  669.     PtSetArg( &args[5], Pt_ARG_WINDOW_NOTIFY_FLAGS, Pt_TRUE,
  670.               Ph_WM_MOVE | Ph_WM_RESIZE | Ph_WM_CLOSE );
  671.     PtSetArg( &args[6], Pt_ARG_WINDOW_RENDER_FLAGS,
  672.               p_vout->b_fullscreen ? Pt_FALSE : Pt_TRUE,
  673.               Ph_WM_RENDER_BORDER | Ph_WM_RENDER_TITLE );
  675.     /* create window */
  676.     p_vout->p_sys->p_window = PtCreateWidget( PtWindow, Pt_NO_PARENT, 7, args);
  677.     if( p_vout->p_sys->p_window == NULL )
  678.     {
  679.         msg_Err( p_vout, "unable to create window" );
  680.         return( 1 );
  681.     }
  683.     /* realize the window widget */
  684.     if( PtRealizeWidget( p_vout->p_sys->p_window ) != 0 )
  685.     {
  686.         msg_Err( p_vout, "unable to realize window widget" );
  687.         PtDestroyWidget( p_vout->p_sys->p_window );
  688.         return( 1 );
  689.     }
  691.     /* get window frame size */
  692.     if( PtWindowFrameSize( NULL, p_vout->p_sys->p_window,
  693.                            &p_vout->p_sys->frame ) != 0 )
  694.     {
  695.         msg_Err( p_vout, "unable to get window frame size" );
  696.         PtDestroyWidget( p_vout->p_sys->p_window );
  697.         return( 1 );
  698.     }
  700.     return( 0 );
  701. }
  703. /*****************************************************************************
  704.  * QNXDestroyWnd: unrealize and destroy the main window
  705.  *****************************************************************************/
  706. static int QNXDestroyWnd( vout_thread_t * p_vout )
  707. {
  708.     /* destroy the window widget */
  709.     PtUnrealizeWidget( p_vout->p_sys->p_window );
  710. //    PtDestroyWidget( p_vout->p_sys->p_window );
  712.     /* destroy video channel */
  713.     if( p_vout->p_sys->i_mode == MODE_VIDEO_OVERLAY )
  714.     {
  715.         PgDestroyVideoChannel( p_vout->p_sys->p_channel );
  716.     }
  718.     return( 0 );
  719. }
  722. /*****************************************************************************
  723.  * NewPicture: allocate a picture
  724.  *****************************************************************************
  725.  * Returns 0 on success, -1 otherwise
  726.  *****************************************************************************/
  727. static int NewPicture( vout_thread_t *p_vout, picture_t *p_pic, int index )
  728. {
  729.     /* We know the chroma, allocate a buffer which will be used
  730.      * directly by the decoder */
  731.     p_pic->p_sys = malloc( sizeof( picture_sys_t ) );
  733.     if( p_pic->p_sys == NULL )
  734.     {
  735.         return -1;
  736.     }
  738.     switch( p_vout->p_sys->i_mode )
  739.     {
  740.     case MODE_NORMAL_MEM:
  741.     case MODE_SHARED_MEM:
  742.         /* create images for [shared] memory blit */
  743.         if( !( p_pic->p_sys->p_image = PhCreateImage( NULL,
  744.                     p_vout->p_sys->dim.w, p_vout->p_sys->dim.h,
  745.                     p_vout->p_sys->i_img_type, NULL, 0,
  746.                     p_vout->p_sys->i_mode == MODE_SHARED_MEM ) ) ) {
  747.             msg_Err( p_vout, "cannot create image" );
  748.             free( p_pic->p_sys );
  749.             return( -1 );
  750.         }
  752.         p_pic->p->p_pixels = p_pic->p_sys->p_image->image;
  753.         p_pic->p->i_lines = p_pic->p_sys->p_image->size.h;
  754.         p_pic->p->i_visible_lines = p_pic->p_sys->p_image->size.h;
  755.         p_pic->p->i_pitch = p_pic->p_sys->p_image->bpl;
  756.         p_pic->p->i_pixel_pitch = p_vout->p_sys->i_bytes_per_pixel;
  757.         p_pic->p->i_visible_pitch = p_vout->p_sys->i_bytes_per_pixel
  758.                                      * p_pic->p_sys->p_image->size.w;
  759.         p_pic->i_planes = 1;
  760.         break;
  762.     case MODE_VIDEO_MEM:
  763.         /* create offscreen contexts for video memory blit */
  764.         if( ( p_pic->p_sys->p_ctx[0] = PdCreateOffscreenContext( 0,
  765.                         p_vout->p_sys->dim.w, p_vout->p_sys->dim.h,
  766.                        Pg_OSC_MEM_PAGE_ALIGN) ) == NULL )
  767.         {
  768.             msg_Err( p_vout, "unable to create offscreen context" );
  769.             free( p_pic->p_sys );
  770.             return( -1 );
  771.         }
  773.         /* get context pointers */
  774.         if( (  p_pic->p_sys->p_buf[0] =
  775.             PdGetOffscreenContextPtr ( p_pic->p_sys->p_ctx[0] ) ) == NULL )
  776.         {
  777.             msg_Err( p_vout, "unable to get offscreen context ptr" );
  778.             PhDCRelease ( p_pic->p_sys->p_ctx[0] );
  779.             p_pic->p_sys->p_ctx[0] = NULL;
  780.             free( p_pic->p_sys );
  781.             return( -1 );
  782.         }
  784.         p_vout->p_sys->i_bytes_per_line = p_pic->p_sys->p_ctx[0]->pitch;
  785.         memset( p_pic->p_sys->p_buf[0], 0,
  786.             p_vout->p_sys->i_bytes_per_line * p_vout->p_sys->dim.h );
  788.         p_pic->p->p_pixels = p_pic->p_sys->p_buf[0];
  789.         p_pic->p->i_lines = p_pic->p_sys->p_ctx[0]->dim.h;
  790.         p_pic->p->i_visible_lines = p_pic->p_sys->p_ctx[0]->dim.h;
  791.         p_pic->p->i_pitch = p_pic->p_sys->p_ctx[0]->pitch;
  792.         p_pic->p->i_pixel_pitch = p_vout->p_sys->i_bytes_per_pixel;
  793.         p_pic->p->i_visible_pitch = p_vout->p_sys->i_bytes_per_pixel
  794.                                      * p_pic->p_sys->p_ctx[0]->dim.w;
  795.         p_pic->i_planes = 1;
  796.         break;
  798.     case MODE_VIDEO_OVERLAY:
  799.         if (index == 0)
  800.         {
  801.             p_pic->p_sys->p_ctx[Y_PLANE] = p_vout->p_sys->p_channel->yplane1;
  802.             p_pic->p_sys->p_ctx[U_PLANE] = p_vout->p_sys->p_channel->uplane1;
  803.             p_pic->p_sys->p_ctx[V_PLANE] = p_vout->p_sys->p_channel->vplane1;
  804.         }
  805.         else
  806.         {
  807.             p_pic->p_sys->p_ctx[Y_PLANE] = p_vout->p_sys->p_channel->yplane2;
  808.             p_pic->p_sys->p_ctx[U_PLANE] = p_vout->p_sys->p_channel->uplane2;
  809.             p_pic->p_sys->p_ctx[V_PLANE] = p_vout->p_sys->p_channel->vplane2;
  810.         }
  812.         p_pic->p_sys->p_buf[Y_PLANE] = PdGetOffscreenContextPtr( p_pic->p_sys->p_ctx[Y_PLANE] );
  813.         if( p_pic->p_sys->p_buf[Y_PLANE] == NULL )
  814.         {
  815.             msg_Err( p_vout, "unable to get video channel ctx ptr" );
  816.             return( 1 );
  817.         }
  819.         switch (p_vout->p_sys->i_vc_format)
  820.         {
  821.             case Pg_VIDEO_FORMAT_YUV420:
  822.                 p_vout->output.i_chroma = VLC_FOURCC('I','4','2','0');
  824.                 p_pic->p_sys->p_buf[U_PLANE] = PdGetOffscreenContextPtr( p_pic->p_sys->p_ctx[U_PLANE] );
  825.                 p_pic->p_sys->p_buf[V_PLANE] = PdGetOffscreenContextPtr( p_pic->p_sys->p_ctx[V_PLANE] );
  827.                 if( p_pic->p_sys->p_buf[U_PLANE] == NULL ||
  828.                     p_pic->p_sys->p_buf[V_PLANE] == NULL )
  829.                 {
  830.                     msg_Err( p_vout, "unable to get video channel ctx ptr" );
  831.                     return( 1 );
  832.                 }
  834.                 p_pic->Y_PIXELS = p_pic->p_sys->p_buf[Y_PLANE];
  835.                 p_pic->p[Y_PLANE].i_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  836.                 p_pic->p[Y_PLANE].i_visible_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  837.                 p_pic->p[Y_PLANE].i_pitch = p_pic->p_sys->p_ctx[Y_PLANE]->pitch;
  838.                 p_pic->p[Y_PLANE].i_pixel_pitch = 1;
  839.                 p_pic->p[Y_PLANE].i_visible_pitch = p_pic->p[Y_PLANE].i_pitch;
  841.                 p_pic->U_PIXELS = p_pic->p_sys->p_buf[U_PLANE];
  842.                 p_pic->p[U_PLANE].i_lines = p_pic->p_sys->p_ctx[U_PLANE]->dim.h;
  843.                 p_pic->p[U_PLANE].i_visible_lines = p_pic->p_sys->p_ctx[U_PLANE]->dim.h;
  844.                 p_pic->p[U_PLANE].i_pitch = p_pic->p_sys->p_ctx[U_PLANE]->pitch;
  845.                 p_pic->p[U_PLANE].i_pixel_pitch = 1;
  846.                 p_pic->p[U_PLANE].i_visible_pitch = p_pic->p[U_PLANE].i_pitch;
  848.                 p_pic->V_PIXELS = p_pic->p_sys->p_buf[V_PLANE];
  849.                 p_pic->p[V_PLANE].i_lines = p_pic->p_sys->p_ctx[V_PLANE]->dim.h;
  850.                 p_pic->p[V_PLANE].i_visible_lines = p_pic->p_sys->p_ctx[V_PLANE]->dim.h;
  851.                 p_pic->p[V_PLANE].i_pitch = p_pic->p_sys->p_ctx[V_PLANE]->pitch;
  852.                 p_pic->p[V_PLANE].i_pixel_pitch = 1;
  853.                 p_pic->p[V_PLANE].i_visible_pitch = p_pic->p[V_PLANE].i_pitch;
  855.                 p_pic->i_planes = 3;
  856.                 break;
  858.             case Pg_VIDEO_FORMAT_YV12:
  859.                 p_vout->output.i_chroma = VLC_FOURCC('Y','V','1','2');
  861.                 p_pic->p_sys->p_buf[U_PLANE] = PdGetOffscreenContextPtr( p_pic->p_sys->p_ctx[U_PLANE] );
  862.                 p_pic->p_sys->p_buf[V_PLANE] = PdGetOffscreenContextPtr( p_pic->p_sys->p_ctx[V_PLANE] );
  864.                 if( p_pic->p_sys->p_buf[U_PLANE] == NULL ||
  865.                     p_pic->p_sys->p_buf[V_PLANE] == NULL )
  866.                 {
  867.                     msg_Err( p_vout, "unable to get video channel ctx ptr" );
  868.                     return( 1 );
  869.                 }
  871.                 p_pic->Y_PIXELS = p_pic->p_sys->p_buf[Y_PLANE];
  872.                 p_pic->p[Y_PLANE].i_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  873.                 p_pic->p[Y_PLANE].i_visible_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  874.                 p_pic->p[Y_PLANE].i_pitch = p_pic->p_sys->p_ctx[Y_PLANE]->pitch;
  875.                 p_pic->p[Y_PLANE].i_pixel_pitch = 1;
  876.                 p_pic->p[Y_PLANE].i_visible_pitch = p_pic->p[Y_PLANE].i_pitch;
  878.                 p_pic->U_PIXELS = p_pic->p_sys->p_buf[U_PLANE];
  879.                 p_pic->p[U_PLANE].i_lines = p_pic->p_sys->p_ctx[U_PLANE]->dim.h;
  880.                 p_pic->p[U_PLANE].i_visible_lines = p_pic->p_sys->p_ctx[U_PLANE]->dim.h;
  881.                 p_pic->p[U_PLANE].i_pitch = p_pic->p_sys->p_ctx[U_PLANE]->pitch;
  882.                 p_pic->p[U_PLANE].i_pixel_pitch = 1;
  883.                 p_pic->p[U_PLANE].i_visible_pitch = p_pic->p[U_PLANE].i_pitch;
  885.                 p_pic->V_PIXELS = p_pic->p_sys->p_buf[V_PLANE];
  886.                 p_pic->p[V_PLANE].i_lines = p_pic->p_sys->p_ctx[V_PLANE]->dim.h;
  887.                 p_pic->p[V_PLANE].i_visible_lines = p_pic->p_sys->p_ctx[V_PLANE]->dim.h;
  888.                 p_pic->p[V_PLANE].i_pitch = p_pic->p_sys->p_ctx[V_PLANE]->pitch;
  889.                 p_pic->p[V_PLANE].i_pixel_pitch = 1;
  890.                 p_pic->p[V_PLANE].i_visible_pitch = p_pic->p[V_PLANE].i_pitch;
  892.                 p_pic->i_planes = 3;
  893.                 break;
  895.             case Pg_VIDEO_FORMAT_UYVY:
  896.             case Pg_VIDEO_FORMAT_YUY2:
  897.                 if (p_vout->p_sys->i_vc_format == Pg_VIDEO_FORMAT_UYVY)
  898.                 {
  899.                     p_vout->output.i_chroma = VLC_FOURCC('U','Y','V','Y');
  900.                 }
  901.                 else
  902.                 {
  903.                     p_vout->output.i_chroma = VLC_FOURCC('Y','U','Y','2');
  904.                 }
  906.                 p_pic->p->p_pixels = p_pic->p_sys->p_buf[Y_PLANE];
  907.                 p_pic->p->i_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  908.                 p_pic->p->i_visible_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  909.                 p_pic->p->i_pitch = p_pic->p_sys->p_ctx[Y_PLANE]->pitch;
  910.                 p_pic->p->i_pixel_pitch = 4;
  911.                 p_pic->p->i_visible_pitch = p_pic->p->i_pitch;
  913.                 p_pic->i_planes = 1;
  914.                 break;
  916.             case Pg_VIDEO_FORMAT_RGB555:
  917.                 p_vout->output.i_chroma = VLC_FOURCC('R','V','1','5');
  918.                 p_vout->output.i_rmask = 0x001f;
  919.                 p_vout->output.i_gmask = 0x03e0;
  920.                 p_vout->output.i_bmask = 0x7c00;
  922.                 p_pic->p->p_pixels = p_pic->p_sys->p_buf[Y_PLANE];
  923.                 p_pic->p->i_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  924.                 p_pic->p->i_visible_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  925.                 p_pic->p->i_pitch = p_pic->p_sys->p_ctx[Y_PLANE]->pitch;
  926.                 p_pic->p->i_pixel_pitch = 2;
  927.                 p_pic->p->i_visible_pitch = 2 * p_pic->p_sys->p_ctx[Y_PLANE]->dim.w;
  929.                 p_pic->i_planes = 1;
  930.                 break;
  932.             case Pg_VIDEO_FORMAT_RGB565:
  933.                 p_vout->output.i_chroma = VLC_FOURCC('R','V','1','6');
  934.                 p_vout->output.i_rmask = 0x001f;
  935.                 p_vout->output.i_gmask = 0x07e0;
  936.                 p_vout->output.i_bmask = 0xf800;
  938.                 p_pic->p->p_pixels = p_pic->p_sys->p_buf[Y_PLANE];
  939.                 p_pic->p->i_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  940.                 p_pic->p->i_visible_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  941.                 p_pic->p->i_pitch = p_pic->p_sys->p_ctx[Y_PLANE]->pitch;
  942.                 p_pic->p->i_pixel_pitch = 4;
  943.                 p_pic->p->i_visible_pitch = 4 * p_pic->p_sys->p_ctx[Y_PLANE]->dim.w;
  945.                 p_pic->i_planes = 1;
  946.                 break;
  948.             case Pg_VIDEO_FORMAT_RGB8888:
  949.                 p_vout->output.i_chroma = VLC_FOURCC('R','V','3','2');
  950.                 p_vout->output.i_rmask = 0x000000ff;
  951.                 p_vout->output.i_gmask = 0x0000ff00;
  952.                 p_vout->output.i_bmask = 0x00ff0000;
  954.                 p_pic->p->p_pixels = p_pic->p_sys->p_buf[Y_PLANE];
  955.                 p_pic->p->i_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  956.                 p_pic->p->i_visible_lines = p_pic->p_sys->p_ctx[Y_PLANE]->dim.h;
  957.                 p_pic->p->i_pitch = p_pic->p_sys->p_ctx[Y_PLANE]->pitch;
  958.                 p_pic->p->i_pixel_pitch = 4;
  959.                 p_pic->p->i_visible_pitch = 4 * p_pic->p_sys->p_ctx[Y_PLANE]->dim.w;
  961.                 p_pic->i_planes = 1;
  962.                 break;
  963.         }
  965. #if 0
  966.     switch( p_vout->output.i_chroma )
  967.     {
  968. #ifdef MODULE_NAME_IS_xvideo
  969.         case VLC_FOURCC('Y','2','1','1'):
  971.             p_pic->p->p_pixels = p_pic->p_sys->p_image->data
  972.                                   + p_pic->p_sys->p_image->offsets[0];
  973.             p_pic->p->i_lines = p_vout->output.i_height;
  974.             p_pic->p->i_visible_lines = p_vout->output.i_height;
  975.             /* XXX: this just looks so plain wrong... check it out ! */
  976.             p_pic->p->i_pitch = p_pic->p_sys->p_image->pitches[0] / 4;
  977.             p_pic->p->i_pixel_pitch = 4;
  978.             p_pic->p->i_visible_pitch = p_pic->p->i_pitch;
  980.             p_pic->i_planes = 1;
  981.             break;
  982. #endif
  984. #endif
  986.     default:
  987.         /* This shouldn't happen ! */
  988.         break;
  989.     }
  991.     return 0;
  992. }
  994. /*****************************************************************************
  995.  * FreePicture: destroy a picture allocated with NewPicture
  996.  *****************************************************************************
  997.  * Destroy XImage AND associated data. If using Shm, detach shared memory
  998.  * segment from server and process, then free it. The XDestroyImage manpage
  999.  * says that both the image structure _and_ the data pointed to by the
  1000.  * image structure are freed, so no need to free p_image->data.
  1001.  *****************************************************************************/
  1002. static void FreePicture( vout_thread_t *p_vout, picture_t *p_pic )
  1003. {
  1004.     if( ( p_vout->p_sys->i_mode == MODE_NORMAL_MEM ||
  1005.         p_vout->p_sys->i_mode == MODE_SHARED_MEM ) &&
  1006.         p_pic->p_sys->p_image )
  1007.     {
  1008.         PhReleaseImage( p_pic->p_sys->p_image );
  1009.         free( p_pic->p_sys->p_image );
  1010.     }
  1011.     else if( p_vout->p_sys->i_mode == MODE_VIDEO_MEM &&
  1012.              p_pic->p_sys->p_ctx[0] )
  1013.     {
  1014.         PhDCRelease( p_pic->p_sys->p_ctx[0] );
  1015.     }
  1017.     free( p_pic->p_sys );
  1018. }
  1021. static int ResizeOverlayOutput(vout_thread_t *p_vout)
  1022. {
  1023.     int i_width, i_height, i_x, i_y;
  1024.     int i_ret;
  1025.     PgScalerProps_t props;
  1027.     props.size   = sizeof( props );
  1028.     props.format = p_vout->p_sys->i_vc_format;
  1029.     props.flags  = Pg_SCALER_PROP_SCALER_ENABLE |
  1030.                           Pg_SCALER_PROP_DOUBLE_BUFFER;
  1032.     /* enable chroma keying if available */
  1033.     if( p_vout->p_sys->i_vc_flags & Pg_SCALER_CAP_DST_CHROMA_KEY )
  1034.     {
  1035.         props.flags |= Pg_SCALER_PROP_CHROMA_ENABLE;
  1036.     }
  1038.     /* set viewport position */
  1039.     props.viewport.ul.x = p_vout->p_sys->pos.x;
  1040.     props.viewport.ul.y = p_vout->p_sys->pos.y;
  1041.     if( !p_vout->b_fullscreen )
  1042.     {
  1043.         props.viewport.ul.x += p_vout->p_sys->frame.ul.x;
  1044.         props.viewport.ul.y += p_vout->p_sys->frame.ul.y;
  1045.     }
  1047.     /* set viewport dimension */
  1048.     vout_PlacePicture( p_vout, p_vout->p_sys->dim.w,
  1049.                            p_vout->p_sys->dim.h,
  1050.                            &i_x, &i_y, &i_width, &i_height );
  1052.     props.viewport.ul.x += i_x;
  1053.     props.viewport.ul.y += i_y;
  1054.     props.viewport.lr.x = i_width + props.viewport.ul.x;
  1055.     props.viewport.lr.y = i_height + props.viewport.ul.y;
  1057.     /* set source dimension */
  1058.     props.src_dim.w = p_vout->output.i_width;
  1059.     props.src_dim.h = p_vout->output.i_height;
  1061.     /* configure scaler channel */
  1062.     i_ret = PgConfigScalerChannel( p_vout->p_sys->p_channel, &props );
  1064.     if( i_ret == -1 )
  1065.     {
  1066.         msg_Err( p_vout, "unable to configure video channel" );
  1067.         return( 1 );
  1068.     }
  1070.     return ( 0 );
  1071. }
  1074. /*****************************************************************************
  1075.  * SetPalette: sets an 8 bpp palette
  1076.  *****************************************************************************
  1077.  * This function sets the palette given as an argument. It does not return
  1078.  * anything, but could later send information on which colors it was unable
  1079.  * to set.
  1080.  *****************************************************************************/
  1081. static void SetPalette( vout_thread_t *p_vout,
  1082.                         uint16_t *red, uint16_t *green, uint16_t *blue )
  1083. {
  1084.     int i;
  1086.     /* allocate palette */
  1087.     for( i = 0; i < 255; i++ )
  1088.     {
  1089.         /* kludge: colors are indexed reversely because color 255 seems
  1090.          * to be reserved for black even if we try to set it to white */
  1091.         p_vout->p_sys->p_colors[ i ] = PgRGB( red[ i ] >> 8, green[ i ] >> 8, blue[ i ] >> 8 );
  1092.     }
  1093. }