windows-server-2003/drivers/wdm/capture/mini/bt848/device.cpp

// $Header: G:/SwDev/WDM/Video/bt848/rcs/Device.cpp 1.18 1998/05/13 14:44:33 tomz Exp $

#include "device.h"
#include "capmain.h"

const I2C_Offset = 0x110;
const GPIO_Cntl_Offset  = 0x10D;
const GPIO_OutputOffset = 0x118;
const GPIO_DataOffset   = 0x200;


// Global functions/data exposing public class info to the "C" modules

PsDevice *gpPsDevice = NULL;
BYTE     *gpjBaseAddr = NULL;
VOID     *gpHwDeviceExtension = NULL;

DWORD GetSizeHwDeviceExtension( )
{
   return ( sizeof( HW_DEVICE_EXTENSION ) + sizeof( PsDevice ));
}

DWORD GetSizeStreamEx( )
{
   // return the size of the largest possible channel object

   DWORD dwMax = sizeof( VBIChannel );
   dwMax = max( dwMax, sizeof( AlterVideoChannel<VBIChannel> )); 
   dwMax = max( dwMax, sizeof( InterVideoChannel )); 

   DWORD dwReq = 2 * dwMax;   // paired stuff has two of them together

   dwReq += sizeof( STREAMEX );
   return ( dwReq );
}

/* Function: GetDeviceExt
 * Purpose: Used in creation of risc programs to obtain physical addresses
*/
PsDevice *GetCurrentDevice()
{
   // This is only used for I2C stuff.  Remove this ASAP.
   return gpPsDevice;
}

/* Function: SetCurrentDevice
 * Purpose: Remembers the currently active device
 * Input: PsDevice *
 * Output: None
 */
void SetCurrentDevice( PsDevice *dev )
{
   // This is only used for I2C stuff.  Remove this ASAP.
   gpPsDevice = dev;
}

/* Function: GetBase
 * Purpose: Returns the base address of the currently active device
 * Input: None
 * Output: LPBYTE
 */
BYTE *GetBase()
{
   return gpjBaseAddr;
}

/* Function: SetBase
 * Purpose: Remembers the base address of the currently active device
 * Input: None
 * Output: LPBYTE
 */
void SetBase(BYTE *base)
{
   gpjBaseAddr = base;
}





PsDevice::PsDevice( DWORD dwBase ) : 
   BaseAddress_( (LPBYTE)dwBase ),
   LastFreq_( 0 ),
   dwCurCookie_( 0 ), 
   I2CAddr_( 0 ), 
   xBar( PinTypes_ ), 
   CaptureContrll_( xtals_ )
{
   SetCurrentDevice ( this );

   for ( int i = 0; i < (sizeof(videochannels)/sizeof(videochannels[0])); i++ ) {
      videochannels [i] = 0;
   }
   I2CIsInitOK();
#ifdef   HARDWAREI2C
   I2CInitHWMode( 100000 );    // assume frequency = 100Khz
#else
   I2CInitSWMode( 100000 );    // assume frequency = 100Khz
   I2CSWStart();
   I2CSWStop();
#endif
   GPIOIsInitOK();
   DebugOut((0, "*** Base Address = %x\n", BaseAddress_));
}

PsDevice::~PsDevice()
{
   for ( int i = 0; i < (sizeof(videochannels)/sizeof(videochannels[0])); i++ ) {
      VideoChannel *pvcTemp = videochannels [i];
      videochannels [i] = NULL;
      delete pvcTemp;
   }
}

/* Method: PsDevice::AddBuf
 * Purpose: Adds next buffer to be used to the queue
 * Input: VideoChan: VxDVideoChannel &
 *   pBufAddr: PVOID - address of the next buffer
 * Output: None
 */
void PsDevice::AddBuffer( VideoChannel &VideoChan, PHW_STREAM_REQUEST_BLOCK pSrb )
{
   // bogus channel, bye-bye
   if ( !IsOurChannel( VideoChan ) ) {
      DebugOut((0, "PsDevice::Addbuffer - not our channel (pSrb=%x) (&VideoChan=%x)\n", pSrb, &VideoChan ) );
      return;
   }
   DebugOut((1, "PsDevice::Addbuffer - adding (pSrb=%x) (&VideoChan=%x)\n", pSrb, &VideoChan ) );
   VideoChan.AddSRB( pSrb );
}

void PsDevice::Start( VideoChannel &VidChan )
{
   VidChan.Start();
}

void PsDevice::Pause( VideoChannel &VidChan )
{
   *(DWORD*)(gpjBaseAddr+0x10c) &= ~3;    // disable interrupts   [TMZ] [!!!]

   // [TMZ] [!!!]
   for ( int i = 0; i < (sizeof(videochannels)/sizeof(videochannels[0])); i++ )
   {
      if ( videochannels[i] == &VidChan )
      {
         DebugOut((1, "'PsDevice::Pause called on videochannels[%d]\n", i));
      }
   }
   VidChan.Pause();
}

/* Method: PsDevice::Create
 * Purpose: Calls into the channel ( stream ) to create RISC programs for it.
 * Input: VideoChan: VxDVideoChannel &
 *   Parms: StartParms &, parameters to create stream with
 * Output: ErrorCode
 */
ErrorCode PsDevice::Create( VideoChannel &VidChan )
{
   return VidChan.Create();
}

/* Method: PsDevice::Stop
 * Purpose: Adds next buffer to be used to the queue
 * Input: VideoChan: VxDVideoChannel &
 * Output: None
 */
void PsDevice::Stop( VideoChannel &VidChan )
{
   *(DWORD*)(gpjBaseAddr+0x10c) &= ~3;    // disable interrupts   [TMZ] [!!!]

   VidChan.Stop();
}

#if NEED_CLIPPING
/* Method: PsDevice::SetClipping
 * Purpose: Propagates the call down a video channel
 * Input: VideoChan: VxDVideoChannel & - reference
 *   dwData: DWORD - a pointer to RGNDATA in reality
 * Output: None
 */
void PsDevice::SetClipping( VideoChannel &VidChan, const RGNDATA & rgnData )
{
   if ( !rgnData.rdh.nCount )
      return;

   if ( FullSizeChannel_ ) {
      // have to decrese hight of all rectangles in half and decrease top in half

      unsigned i;
      for ( i = 0; i < rgnData.rdh.nCount; i++ ) {
         TRect *lpR = (TRect *)rgnData.Buffer + i;

         // make all even
         lpR->top++;
         lpR->top &= ~1;

         lpR->bottom++;
         lpR->bottom &= ~1;

         lpR->top    /= 2;
         lpR->bottom /= 2;
      }
      FullSizeChannel_->SetClipping( rgnData );
      SlaveChannel_   ->SetClipping( rgnData );
   } else
      VidChan.SetClipping( rgnData );
}
#endif

/* Method: PsDevice::IsVideoChannel
 * Purpose:
 */
bool PsDevice::IsVideoChannel( VideoChannel &aChan )
{
   return bool( &aChan == videochannels [VS_Field1] || &aChan == videochannels [VS_Field2] );
}

/* Method: PsDevice::IsVBIChannel
 * Purpose:
 */
bool PsDevice::IsVBIChannel( VideoChannel &aChan )
{
   return bool( &aChan == videochannels [VS_VBI1] || &aChan == videochannels [VS_VBI2] );
}

/* Method: PsDevice::IsOurChannel
 * Purpose: Verifies the channel
 * Input: aChan: VideoChannel &, reference to a channel
 * Output: true if our, false otherwise
 */
bool PsDevice::IsOurChannel( VideoChannel &aChan )
{
   return IsVideoChannel( aChan ) || IsVBIChannel( aChan );
}

/* Method: PsDevice::DoOpen
 * Purpose: This function performs opening of a video channel
 * Input: st: VideoStream, stream to open
 * Output: ErrorCode
 */
ErrorCode PsDevice::DoOpen( VideoStream st )
{
   DebugOut((1, "PsDevice::DoOpen(%d)\n", st));

   if ( !videochannels [st] )
   {
      DebugOut((1, "   PsDevice::DoOpen(%d) failed - videochannel not created\n", st));
      return Fail;
   }
   videochannels [st]->Init( &CaptureContrll_ );
   if ( videochannels [st]->OpenChannel() != Success ) {
      DebugOut((1, "   PsDevice::DoOpen(%d) failed - videochannel open failed\n", st));
      VideoChannel *pvcTemp = videochannels [st];
      videochannels [st] = NULL;
      delete pvcTemp;
      return Fail;
   }
   return Success;
}

/* Method: PsDevice::OpenChannel
 * Purpose: This function opens a channel requested by the capture driver
 * Input: hVM: VMHANDLE - handle of the VM making a call
 *   pRegs: CLIENT_STRUCT * - pointer to the structure with VM's registers
 * Output: None
 */
ErrorCode PsDevice::OpenChannel( PVOID pStrmEx, VideoStream st )
{
   PVOID addr = &((PSTREAMEX)pStrmEx)->videochannelmem[0];
   ((PSTREAMEX)pStrmEx)->videochannel = addr;

   DebugOut((1, "PsDevice::OpenChannel(%x,%d)\n", addr, st));
   if ( videochannels [st] )
   {
      DebugOut((1, "   PsDevice::OpenChannel(%x,%d) failed - already open\n", addr, st));
      return Fail;
   }
   videochannels[st] = new( addr ) VideoChannel( st );
   videochannels[st]->SetStrmEx( pStrmEx ) ;

   DebugOut((1, "   PsDevice::OpenChannel(%x,%d), videochannels[%d] = %x\n", addr, st, st, videochannels[st]));

   return DoOpen( st );
}

/* Method: PsDevice::OpenInterChannel
 * Purpose: This function opens video channel that produces interleaved fields
 * Input: addr: PVOID, address for the palcement new
 *   st: VideoStream, stream to open ( VBI or video )
 * Output: None
 */
ErrorCode PsDevice::OpenInterChannel( PVOID pStrmEx, VideoStream st )
{
   PVOID addr = &((PSTREAMEX)pStrmEx)->videochannelmem[0];
   ((PSTREAMEX)pStrmEx)->videochannel = addr;

   DebugOut((1, "PsDevice::OpenInterChannel(%x,%d)\n", addr, st));
   // only odd channel can be paired
   if ( !( st & 1 ) || videochannels [st] || videochannels [st-1] )
   {
      DebugOut((1, "   PsDevice::OpenInterChannel(%x,%d) failed - stream not odd or already open\n", addr, st));
      return Fail;
   }
   if ( OpenChannel( (PBYTE)addr + sizeof( InterVideoChannel ), VideoStream( st - 1 ) ) == Success )
   {
      videochannels[st] = new( addr ) InterVideoChannel( st, *videochannels [st-1] );
      videochannels[st]->SetStrmEx( pStrmEx ) ;

      if ( DoOpen( st ) != Success )
      {
         DebugOut((1, "   PsDevice::OpenInterChannel(%x,%d) failed - DoOpen failed\n", addr, st));
         CloseChannel( videochannels [st-1] );
         return Fail;
      }
   }
   else
   {
      DebugOut((1, "   PsDevice::OpenInterChannel(%x,%d) failed - OpenChannel failed\n", addr, st));
      return Fail;
   }
   return Success;
}

/* Method: PsDevice::OpenAlterChannel
 * Purpose: This function opens video channel that produces alternating fields
 * Input: addr: PVOID, address for the palcement new
 *   st: VideoStream, stream to open ( VBI or video )
 * Output: None
 */
ErrorCode PsDevice::OpenAlterChannel( PVOID pStrmEx, VideoStream st )
{
   PVOID addr = &((PSTREAMEX)pStrmEx)->videochannelmem[0];
   ((PSTREAMEX)pStrmEx)->videochannel = addr;

   DebugOut((1, "PsDevice::OpenAlterChannel(%x,%d)\n", addr, st));
   // only odd channel can be paired
   if ( !( st & 1 ) || videochannels [st] || videochannels [st-1] )
   {
      DebugOut((1, "   PsDevice::OpenAlterChannel(%x,%d) failed - stream not odd or already open\n", addr, st));
      return Fail;
   }
   if ( OpenChannel( (PBYTE)addr + sizeof( AlterVideoChannel<VideoChannel> ), VideoStream( st -1 ) ) == Success )
   {
      videochannels[st] = new( addr ) AlterVideoChannel<VideoChannel>( st, *videochannels [st-1] );
      videochannels[st]->SetStrmEx( pStrmEx ) ;
      videochannels[st-1]->SetStrmEx( pStrmEx ) ;

      if ( DoOpen( st ) != Success )
      {
         DebugOut((1, "   PsDevice::OpenAlterChannel(%x,%d) failed - DoOpen failed\n", addr, st));
         CloseChannel( videochannels [st-1] );
         return Fail;
      }
   }
   else
   {
      DebugOut((1, "   PsDevice::OpenAlterChannel(%x,%d) failed - OpenChannel failed\n", addr, st));
      return Fail;
   }
   return Success;
}

/* Method: PsDevice::OpenVBIChannel
 * Purpose: This function opens video channel that produces alternating fields
 * Input: addr: PVOID, address for the palcement new
 *   st: VideoStream, stream to open ( VBI or video )
 * Output: None
 */
ErrorCode PsDevice::OpenVBIChannel( PVOID pStrmEx )
{
   PVOID addr = &((PSTREAMEX)pStrmEx)->videochannelmem[0];
   ((PSTREAMEX)pStrmEx)->videochannel = addr;

   DebugOut((1, "PsDevice::OpenVBIChannel(%x)\n", addr));
   if ( videochannels [VS_VBI1] || videochannels [VS_VBI2] )
   {
      DebugOut((1, "   PsDevice::OpenVBIChannel(%x) failed - already open\n", addr));
      return Fail;
   }

   VBIChannel *tmp = new( (PBYTE)addr + sizeof( VBIAlterChannel ) ) VBIChannel( VS_VBI1 );
   videochannels [VS_VBI1] = tmp;
   DebugOut((1, "   PsDevice::OpenVBIChannel(%x), videochannels[VS_VBI1(%d)] = %x\n", addr, VS_VBI1, videochannels[VS_VBI1]));

   if ( !tmp )
   {
      DebugOut((1, "   PsDevice::OpenVBIChannel(%x) failed - new VBIChannel failed\n", addr));
      return Fail;
   }

   if ( DoOpen( VS_VBI1 ) != Success )
   {
      DebugOut((1, "   PsDevice::OpenVBIChannel(%x) failed - DoOpen(VS_VBI1) failed\n", addr));
      return Fail;
   }

   videochannels [VS_VBI2] = new( addr ) VBIAlterChannel( VS_VBI2, *tmp );
   DebugOut((1, "   PsDevice::OpenVBIChannel(%x), videochannels[VS_VBI2(%d)] = %x\n", addr, VS_VBI2, videochannels[VS_VBI2]));

   if (!videochannels [VS_VBI2])
   {
      DebugOut((1, "   PsDevice::OpenVBIChannel(%x) failed - new VBIAlterChannel failed\n", addr));
      return Fail;
   }

   if ( DoOpen( VS_VBI2 ) != Success )
   {
     DebugOut((1, "   PsDevice::OpenVBIChannel(%x) failed - DoOpen(VS_VBI1) failed\n", addr));
     CloseChannel( videochannels [VS_VBI1] );
     return Fail;
   }

   videochannels[VS_VBI1]->SetStrmEx( pStrmEx ) ;
   videochannels[VS_VBI2]->SetStrmEx( pStrmEx ) ;

   return Success;
}

/* Method: PsDevice::CloseChannel
 * Purpose: Closes a video channel
 * Input: ToClose: VideoChannel *
 * Output: None
 */
void PsDevice::CloseChannel( VideoChannel *ToClose )
{
   *(DWORD*)(gpjBaseAddr+0x10c) &= ~3;    // disable interrupts   [TMZ] [!!!]

   DebugOut((1, "PsDevice::CloseChannel(%x)\n", ToClose));

   if ( IsOurChannel( *ToClose ) )
   {
      // this is a bit ugly solution to make CLOSE_STREAM SRB clean
      if ( ToClose->GetStreamType() == Single )
      {
         VideoStream st = ToClose->GetStreamID();
         DebugOut((1, "   PsDevice::CloseChannel(%x) - closing single channel (stream == %d)\n", ToClose, st));
         VideoChannel * pvcTemp = videochannels [st];
         videochannels [st] = NULL;
         delete pvcTemp;
      }
      else
      {
         DebugOut((1, "   PsDevice::CloseChannel(%x) - closing paired channel\n", ToClose));
         ClosePairedChannel( ToClose );
      }
   }
   else
   {
      DebugOut((1, "   PsDevice::CloseChannel(%x) ignored - not our channel\n", ToClose));
   }
}

/* Method: PsDevice::ClosePairedChannel
 * Purpose: This function opens a channel requested by the capture driver
 * Input: hVM: VMHANDLE - handle of the VM making a call
 *   pRegs: CLIENT_STRUCT * - pointer to the structure with VM's registers
 * Output: None
 */
void PsDevice::ClosePairedChannel( VideoChannel *ToClose )
{
   *(DWORD*)(gpjBaseAddr+0x10c) &= ~3;    // disable interrupts   [TMZ] [!!!]

   DebugOut((1, "PsDevice::ClosePairedChannel(%x)\n", ToClose));

   if ( IsOurChannel( *ToClose ) )
   {
      VideoStream st = ToClose->GetStreamID();
      DebugOut((1, "   PsDevice::ClosePairedChannel(%x) - closing paired channel (stream == %d)\n", ToClose, st));
      DebugOut((1, "   PsDevice::ClosePairedChannel(%x) - streams[%d] = %x\n", ToClose, st, videochannels[st]));
      DebugOut((1, "   PsDevice::ClosePairedChannel(%x) - streams[%d] = %x\n", ToClose, st-1, videochannels[st-1]));

      VideoChannel *pvcTemp;
      
      pvcTemp = videochannels [st];
      videochannels [st] = NULL;
      delete pvcTemp;

      pvcTemp = videochannels [st-1];
      videochannels [st-1] = NULL;
      delete pvcTemp;
   }
   else
   {
      DebugOut((1, "   PsDevice::ClosePairedChannel(%x) ignored - not our channel\n", ToClose));
   }
}

/* Method: PsDevice::SetSaturation
 * Purpose:
 * Input:
 * Output: None
 */
void PsDevice::SetSaturation( LONG Data )
{
   CaptureContrll_.SetSaturation( Data );
}

/* Method: PsDevice::SetHue
 * Purpose:
 * Input:
 * Output: None
 */
void PsDevice::SetHue( LONG Data )
{
   CaptureContrll_.SetHue( Data );
}

/* Method: PsDevice::SetBrightness
 * Purpose:
 * Input:
 * Output: None
 */
void PsDevice::SetBrightness( LONG Data )
{
   CaptureContrll_.SetBrightness( Data );
}

/* Method: PsDevice::SetSVideo
 * Purpose:
 * Input:
 * Output: None
 */
void PsDevice::SetSVideo( LONG Data )
{
   CaptureContrll_.SetSVideo( Data );
}

/* Method: PsDevice::SetContrast
 * Purpose:
 * Input:
 * Output: None
 */
void PsDevice::SetContrast( LONG Data )
{
   CaptureContrll_.SetContrast( Data );
}

/* Method: PsDevice::SetFormat
 * Purpose:
 * Input:
 * Output: None
 */
void PsDevice::SetFormat( LONG Data )
{
   CaptureContrll_.SetFormat( Data );
   // notify all video channels that video timing has changed
   LONG time = Data == KS_AnalogVideo_NTSC_M ? 333667 : 400000;
   for ( int i = 0; i < (sizeof(videochannels)/sizeof(videochannels[0])); i++ )
   {
      if ( videochannels [i] )
      {
         DebugOut((1, "PsDevice::SetFormat(%d) SetTimePerFrame on videochannels[%d]\n", Data, i));
         videochannels [i]->SetTimePerFrame( time );
      }
   }
}

/* Method: PsDevice::SetConnector
 * Purpose:
 * Input:
 * Output: None
 */
void PsDevice::SetConnector( LONG Data )
{
   CaptureContrll_.SetConnector( Data );
}

/* Method: PsDevice::GetSaturation
 * Purpose:
 * Input: pData: PLONG
 * Output: None
 */
LONG PsDevice::GetSaturation()
{
   return CaptureContrll_.GetSaturation();
}

/* Method: PsDevice::GetHue
 * Purpose:
 * Input: pData: PLONG
 * Output: None
 */
LONG PsDevice::GetHue()
{
   return CaptureContrll_.GetHue();
}

/* Method: PsDevice::GetBrightness
 * Purpose:
 * Input: pData: PLONG
 * Output: None
 */
LONG PsDevice::GetBrightness()
{
   return CaptureContrll_.GetBrightness();
}

/* Method: PsDevice::GetSVideo
 * Purpose:
 * Input: pData: PLONG
 * Output: None
 */
LONG PsDevice::GetSVideo()
{
   return CaptureContrll_.GetSVideo();
}

/* Method: PsDevice::GetContrast
 * Purpose:
 * Input: pData: PLONG
 * Output: None
 */
LONG PsDevice::GetContrast()
{
   return CaptureContrll_.GetContrast();
}

/* Method: PsDevice::GetFormat
 * Purpose:
 * Input: pData: PLONG
 * Output: None
 */
LONG PsDevice::GetFormat()
{
   return CaptureContrll_.GetFormat();
}

/* Method: PsDevice::GetConnector
 * Purpose:
 * Input: pData: PLONG
 * Output: None
 */
LONG PsDevice::GetConnector()
{
   return CaptureContrll_.GetConnector();
}

/* Method: PsDevice::ChangeNotifyChannels
 * Purpose: Invoked to notify channels of some global changes
 */                         
void PsDevice::ChangeNotifyChannels( IN PHW_STREAM_REQUEST_BLOCK pSrb )
{
   // We should only do this once per "system" stream.
   // Video streams don't seem to care.
   // That just leaves one VBI notification required
   
   videochannels [VS_VBI1]->ChangeNotification( pSrb );
}

/* Method: PsDevice::GetSupportedStandards
 * Purpose: Obtains video standards device can support
 * Input: None
 * Output: LONG
 */
LONG PsDevice::GetSupportedStandards()
{
   return CaptureContrll_.GetSupportedStandards();
}

bool PsDevice::InitOK()
{
   return CaptureContrll_.InitOK();
}

#ifndef	HARDWAREI2C

//===========================================================================
// Bt848 software I2C stuff
//===========================================================================

/*
 * If we build with software I2C then these routines fake the Hardware I2C routines
 * so the tuner code keeps working
 */

ErrorCode PsDevice::I2CHWRead( BYTE address, BYTE *value )
{
    ErrorCode error;

    error = I2CSWStart();
    if(error) {
        return error;
    }
    
    error = I2CSWWrite( address | 0x01 );
    if(error) {
        return error;
    }

    error = I2CSWRead( value );
    if(error) {
       return error;
    }
        
   	error = I2CSWSendNACK();
   	if(error) {
       	return error;
    }

   	error = I2CSWStop();

   	return error;
}


ErrorCode PsDevice::I2CHWWrite3( BYTE address, BYTE value1, BYTE value2 )
{
    ErrorCode error;

    error = I2CSWStart();
    if(error) {
        return error;
    }
    
    error = I2CSWWrite( address );
    if(error) {
        return error;
    }

    error = I2CSWWrite( value1 );
    if(error) {
        return error;
    }

    error = I2CSWWrite( value2 );
    if(error) {
        return error;
    }
    
   	error = I2CSWStop();
   	return error;
}

#endif



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


#ifdef __cplusplus
extern "C" {
#endif

   #include <stdarg.h>

#ifdef __cplusplus
}
#endif

// #include "capdebug.h"

#define  DEBUG_PRINT_PREFIX   "   ---: "
// #define  DEBUG_PRINT_PREFIX   "bt848wdm: "

long DebugLevel = 0;
BOOL bNewLine = TRUE;

extern "C" void MyDebugPrint(long DebugPrintLevel, char * DebugMessage, ... )
{
   if (DebugPrintLevel <= DebugLevel)
   {
       char debugPrintBuffer[256] ;

       va_list marker;
       va_start( marker, DebugMessage );     // Initialize variable arguments.
       vsprintf( debugPrintBuffer,
                 DebugMessage,
                 marker );

       if( bNewLine )
       {
          DbgPrint(("%s", DEBUG_PRINT_PREFIX));
       }
       
       DbgPrint((debugPrintBuffer));

       if( debugPrintBuffer[strlen(debugPrintBuffer)-1] == '\n')
       {
          bNewLine = TRUE;
       }
       else
       {
          bNewLine = FALSE;
       }

       va_end( marker );                     // Reset variable arguments.
   }
}

#if TRACE_CALLS
   #define MAX_TRACE_DEPTH 10
   unsigned long ulTraceDepth = 0;
   char achIndentBuffer[100];

   char * IndentStr( )
   {
      unsigned long ul = ulTraceDepth < MAX_TRACE_DEPTH ? ulTraceDepth : MAX_TRACE_DEPTH;
      unsigned long x;
      char * lpszBuf = achIndentBuffer;
      for( x = 0; x < ul; x++)
      {
         // indent two spaces per depth increment
         *lpszBuf++ = ' ';
         *lpszBuf++ = ' ';
      }
      sprintf (lpszBuf, "[%lu]", ulTraceDepth);
      return( achIndentBuffer );

   }

   Trace::Trace(char *pszFunc)
   {
      psz = pszFunc;
      DebugOut((0, "%s %s\n", IndentStr(), psz));
      ulTraceDepth++;
   }
   Trace::~Trace()
   {
      ulTraceDepth--;
      // DebugOut((0, "%s %s\n", IndentStr(), psz));
   }

#endif