skl_drv_x11.cpp

mpeg4编解码器

/********************************************************
 * Some code. Copyright (C) 2003 by Pascal Massimino.   *
 * All Rights Reserved.      (http://skal.planet-d.net) *
 * For Educational/Academic use ONLY. See 'LICENSE.TXT'.*
 ********************************************************/
/*
 * skl_drv_x11.cpp
 *
 * X11 (/SHM) video main driver
 ********************************************************/

#include "skl_video.h"

#ifndef SKL_NO_VIDEO
#ifdef SKL_USE_X11

#include "skl_syst/skl_dyn_load.h"
#include "./skl_drv_x11.h"

#if defined(__IRIX__)
// #define COMPLETION_BUG
#endif

#if defined(__SUN__) || defined(__IRIX__)
#define DONT_DETACH_FIRST
#endif

//////////////////////////////////////////////////////////
// SKL_X11_VIDEO_I
//////////////////////////////////////////////////////////

SKL_X11_VIDEO_I::SKL_X11_VIDEO_I(SKL_MEM_I *Mem,
                                 SKL_CST_STRING Name,
                                 SKL_CST_STRING Dsp_Name)
  : SKL_VIDEO_I(Mem, Name)
  , _Screen(-1)
  , _XDisplay(0)
  , _Display_Name(Dsp_Name)
  , _Use_Shm(0), _Use_DGA(0)
  , _Has_Shm(0), _Has_DGA(0)
  , _VSync(1)
{ 
  _Caps = (CAPS)( HAS_BACKBUFFER );

#if defined(SKL_USE_SHM)
  Set_Param(USE_SHM, 0, 1);
#endif

#if defined(SKL_USE_DGA)
  Set_Param(USE_DGA, 0, 1);
  _Caps = (CAPS)(_Caps|HAS_FULLSCREEN);
#endif

  Ping();
}

SKL_X11_VIDEO_I::~SKL_X11_VIDEO_I()
{
  Cleanup();
}

void SKL_X11_VIDEO_I::Cleanup()
{
  Clear_Modes();
  if (_XDisplay!=0) XCloseDisplay(_XDisplay);  
  _Screen = -1;
  _XDisplay = 0;
  Set_Not_Ok();
}

//////////////////////////////////////////////////////////

SKL_FORMAT SKL_X11_VIDEO_I::Get_Visual_Format(XVisualInfo *Info) const
{
  int Dsp_Depth;
  SKL_FORMAT Fmt;
  Visual *v = Info->visual;

    // Ackward method to get the exact Pixel_Depth of display

  XImage *XImg = XCreateImage( _XDisplay, v, Info->depth, 
                               ZPixmap, 0, 0,
                               16, 16,
                               BitmapPad(_XDisplay), 0 );
  if (XImg!=0) {
    Dsp_Depth = XImg->bytes_per_line / 16;
    XDestroyImage( XImg );
  }
  else {
    Dsp_Depth = (Info->depth+7)/8; // geee!!! finger crossing
  }

  if (v->c_class==PseudoColor) 
    Fmt = 0x00000 | (Dsp_Depth<<16);  // cmapped format
  else
    Fmt = SKL_FORMAT(v->red_mask, v->green_mask, v->blue_mask, 0, Dsp_Depth);
  return Fmt;
}

int SKL_X11_VIDEO_I::Scan_Modes(SKL_FORMAT Fmt)
{
  int Nb_Modes;
  XVisualInfo Template;
  Template.screen = DefaultScreen(_XDisplay); // _Screen;
  Template.c_class = TrueColor;

  XVisualInfo *Info = XGetVisualInfo( _XDisplay,      
                                      VisualClassMask | VisualScreenMask,
                                      &Template, &Nb_Modes );
  if (Info==0) {
    fprintf( stderr, "Can't get X visual\n" );
    return 0;
  }

  int Depth = -1;
  if (Fmt.Raw_Depth()!=0) Depth = 8 * Fmt.Raw_Depth();
  int Nb=0;

  for( int i=0; i<Nb_Modes; i++)
  {
    // Get rid of Visual with depth<8 and skip bad visuals
    if (Depth!=-1 && Info[i].depth!=Depth) continue;
    else if (Info[i].depth<8) continue;
    else if ( Info[i].c_class==StaticColor ||
              Info[i].c_class==StaticGray ||
              Info[i].c_class==GrayScale )
      continue;  
    SKL_X11_WIN *Mode = new (Get_Mem()) SKL_X11_WIN(this);
    Mode->Init( &Info[i] );
    if (Fmt.Bits()==0x0 || Mode->Format().Bits()==Fmt.Bits()) {
      Add_Mode( Mode );
      Nb++;
    }
    else delete Mode;
  }
  XFree( Info );

  return Nb;
}

int SKL_X11_VIDEO_I::Ping()
{
  Cleanup();
  if (_Display_Name==0) _Display_Name = XDisplayName(0);
  _XDisplay = XOpenDisplay(_Display_Name);
  if (_XDisplay==0) return 0;
  _Screen = DefaultScreen(_XDisplay); // TODO: should it be an option?

  _Has_Shm = 0;
#ifdef SKL_USE_SHM
  if ( (XShmQueryExtension(_XDisplay)!=0) && (_Display_Name[0]!=':'))
    fprintf( stderr, "Can't use SHM when display is redirected.\n" );
  else
    _Has_Shm = 1;
#endif

  _Has_DGA = 0;
#ifdef SKL_USE_DGA
  _Has_DGA = _DGA_Infos.Init(_XDisplay, _Screen);
#endif

  Clear_Modes();
  Scan_Modes();

  Set_Ok();
  return 1;
}

//////////////////////////////////////////////////////////
// Params
//////////////////////////////////////////////////////////

int SKL_X11_VIDEO_I::Set_Param(PARAM Opt, 
                               SKL_CST_STRING SValue,
                               int IValue)
{
  switch(Opt) {
    case USE_DISPLAY: _Display_Name = SValue; return Ping();
    case USE_SHM: _Use_Shm = (IValue!=0); break;
    case USE_DGA: _Use_DGA = (IValue!=0); break;
    case VSYNC:   _VSync = (IValue!=0);    break;
    default: return 0;
  }
  return 1;
}

int SKL_X11_VIDEO_I::Get_Param(PARAM Opt, 
                               SKL_CST_STRING *SValue,
                               int *IValue) const
{
  switch(Opt) {
    case USE_DISPLAY: *SValue = _Display_Name; return 1;
    case USE_SHM: *IValue = ((_Has_Shm&_Use_Shm)!=0); return 1;
    case USE_DGA: *IValue = ((_Has_DGA&_Use_DGA)!=0); return 1;
    case VSYNC:   *IValue = _VSync; return 1;
    default: break;
  }
  return 0;
}

//////////////////////////////////////////////////////////
// Fullscreen API
//////////////////////////////////////////////////////////

SKL_WINDOW *SKL_X11_VIDEO_I::Set_Fullscreen_Mode(const SKL_BTM *FMode,
                                                 int Show)
{
  const SKL_X11_WIN *Mode = (const SKL_X11_WIN *)FMode;

  SKL_X11_RAW_WIN *Win;
#ifdef SKL_USE_SHM
  if (_Has_Shm & _Use_Shm) {
    Win = new (Get_Mem()) SKL_X11_SHM_WIN( Mode );
  }
  else 
#endif
    Win = new (Get_Mem()) SKL_X11_RAW_WIN( Mode );

  if (!Win->Create_Window(Show)) {
    delete Win; // Argh!
    return 0;
  } 
  return Win;
}

void SKL_X11_VIDEO_I::Shutdown_Fullscreen() {
}

//////////////////////////////////////////////////////////
// Window API
//////////////////////////////////////////////////////////

SKL_WINDOW *SKL_X11_VIDEO_I::Open_Window(int W, int H, SKL_FORMAT Fmt,
                                         int With_Backbuffer,
                                         int Show)
{
  const SKL_X11_WIN *Mode = (const SKL_X11_WIN *)Get_Fullscreen_Mode();
  if (!Is_Fullscreen())
    Mode = (const SKL_X11_WIN *)Get_Mode_Infos(Search_Best_Mode(W, H, Fmt));

  SKL_X11_RAW_WIN *Win;
#ifdef SKL_USE_SHM
  if (_Has_Shm&_Use_Shm) {
    Win = new (Get_Mem()) SKL_X11_SHM_WIN( Mode, W, H );
  }
  else 
#endif
    Win = new (Get_Mem()) SKL_X11_RAW_WIN( Mode, W, H );

  if (!Win->Create_Window(Show))
  {
    delete Win;  // Argh!
    return 0;
  }
  return Win;
}

int SKL_X11_VIDEO_I::Needs_Conversion(const SKL_WINDOW *Win,
                                      SKL_FORMAT Fmt) const
{
  SKL_ASSERT(Win!=0);
  return !Win->Format().Is_Compatible_With(Fmt);
}

//////////////////////////////////////////////////////////
// -- external symbol exported
//////////////////////////////////////////////////////////

#include "skl_syst/skl_dyn_load.h"
SKL_DYN_FACTORY(SKL_X11_VIDEO_I) {
  return (SKL_ANY)::new SKL_X11_VIDEO_I(SKL_MEM, "Drv X11");
}

//////////////////////////////////////////////////////////
// SKL_X11_WIN
//////////////////////////////////////////////////////////

SKL_X11_WIN::SKL_X11_WIN(SKL_X11_VIDEO_I *Drv)
  : SKL_WINDOW(Drv->Get_Mem())
  , _Drv(Drv)
  , _Depth(0)
  , _Visual(0)
{}

SKL_X11_WIN::~SKL_X11_WIN() {
  SKL_ASSERT(_Drv!=0);
}

void SKL_X11_WIN::Init(XVisualInfo *Info)
{
  Display *Dsp = Get_XDisplay();
  int Screen = Get_Screen();

  _Depth = Info->depth;
  _Visual = Info->visual;

  SKL_FORMAT Fmt = _Drv->Get_Visual_Format(Info);
  int W = DisplayWidth( Dsp, Screen );
  int H = DisplayHeight( Dsp, Screen );
  Set_Virtual( W, H, Fmt );
}

void SKL_X11_WIN::Print_Infos() const
{
  SKL_BTM::Print_Infos();
  printf( "  [Depth=%d Q=%d Visual=0x%8p]", _Depth, Quantum(), (SKL_BYTE*)_Visual );
  if (_Visual)
    printf( " (id=%d c=%d cmapsize=%d b/rgb=%d)",
       (int)_Visual->visualid, 
       (int)_Visual->c_class, 
       (int)_Visual->map_entries, 
       (int)_Visual->bits_per_rgb );
  printf( "\n");
}

//////////////////////////////////////////////////////////
// -- Raw X11 calls. It's time for the Real Stuff :) -- //
//////////////////////////////////////////////////////////

#define X11_MASKS   StructureNotifyMask| ExposureMask |    \
 KeyReleaseMask | KeyPressMask  |       \
 ButtonPressMask | ButtonReleaseMask |  \
 ButtonMotionMask | PointerMotionMask

//////////////////////////////////////////////////////////
// SKL_X11_RAW_WIN
//////////////////////////////////////////////////////////

SKL_X11_RAW_WIN::SKL_X11_RAW_WIN(const SKL_X11_WIN *w, 
                                 int W, int H)
  : SKL_X11_WIN(w->Drv())
  , _XImg(0)
  , _Win(0)
  , _Pixels(0)
  , _XCMap(None)
  , _Root_CMap(None)
  , _Cells(0)
{
  _Depth = w->Get_Depth();
  _Visual = w->Get_Visual();
  if (W==0) W = w->Width();
  if (H==0) H = w->Height();
  int BpS = ( W*w->Quantum() + 7) & ~7;  // pad to 8
  Set_Virtual( W, H, w->Format(), 0, BpS, 0);

//  Display *Dsp = Get_XDisplay();
//  int Screen = Get_Screen();
//  _XCMap = (Colormap)DefaultColormap( Dsp, Screen );

}

SKL_X11_RAW_WIN::~SKL_X11_RAW_WIN()
{
  Hide();
  Cleanup();
}

void SKL_X11_RAW_WIN::Cleanup()
{
  Display *Dsp = Get_XDisplay();
  if ( _XImg!=0 ) {
    XDestroyImage( _XImg );
    _XImg = 0;
  }
  if (_Root_CMap!=None) {
    XFreeColormap( Dsp, _Root_CMap );
    _Root_CMap = None;
  }
  if ( _Win!=(Window)0 )
  {
    if (_Cells) XFreeColors( Dsp, _XCMap, _Pixels, 256, 0 );
    if (_XCMap!=None) XFreeColormap( Dsp, _XCMap );
    if (_Pixels) Get_Mem()->Delete( _Pixels, 256*sizeof(*_Pixels) );
    XFreeGC( Dsp, _GC );
    XDestroyWindow( Dsp, _Win );
    _Win = (Window)0;
    _XCMap = None;
    _Cells = 0;
    _Pixels = 0;
  }
}

void SKL_X11_RAW_WIN::Set_Name(SKL_CST_STRING Name) {
  SKL_WINDOW::Set_Name( Name );
  if (_Win!=0 && _Drv!=0)
    XStoreName( _Drv->Get_XDisplay(), _Win, Name );
}

//////////////////////////////////////////////////////////

int SKL_X11_RAW_WIN::Create_XCMap()
{
  SKL_ASSERT( _XCMap == (Colormap)None && _Pixels == 0 );
  Display *Dsp = Get_XDisplay();
  if ( Format().Depth()==1 )
  {   
    _Pixels = (unsigned long*)Get_Mem()->New( 256*sizeof(unsigned long) );
    _XCMap = XCreateColormap( Dsp, _Win, _Visual, AllocNone );
    if (_Visual->c_class==PseudoColor) {
      _Cells = XAllocColorCells( Dsp, _XCMap, 0, 0, 0, _Pixels, 256 );
      if ( _Cells==0 ) return 0;