pcivideo.cpp

djgpp bt878 capture for DOS

#include "pcivideo.h"
#include <stdio.h>

PCI_VIDEO::PCI_VIDEO(int funct_num, int bus_num)
{
    DWORD VideoBase;
    /* Make sure Video is function number #0 */
    pci.SetFunctionNumber( funct_num );
    pci.SetBusNumber( bus_num );

    /* Display some PCI info */
    printf( "Video PCI\n" );
    printf("  Device = %d  Vendor ID = 0x%04X\n", pci.GetDeviceID(), pci.GetVendorID());
    printf( "  Class Code = 0x%06X  Revision = 0x%02X\n", pci.GetClassCodeReg(), pci.GetRevisionID() );
    printf( "  Status = 0x%04X  Command = 0x%02X\n", pci.GetStatusReg(), pci.GetCommandReg() );
    printf( "  Base Address #0 = 0x%08X\n", pci.GetBaseAddress() );
    
    /* Get the Physical Address (Remove lower 4 info bits) */
    VideoBase = pci.GetBaseAddress( ) & 0xFFFFFFF0;
    
    /* Check for and invalid address */
    if( VideoBase == 0x0 ) {
        printf( "ERROR: Bad Video Address (0x0)\n" );
        exit( 10 );
    }
    
    /* Enable memory access if not enabled (some BIOS don't) */
    if( pci.IsMemoryAccess( ) == FALSE )
        pci.SetMemoryAccess( TRUE );
        
    virtual_mem.CreateVirtual( VideoBase, 4 * 1024 /*4K*/ );
    if(virtual_mem.status !=0) {
        printf("%s\n", virtual_mem.ErrString());
        exit(10);
    }

    Even = new VIDEO_EVEN_FIELD( funct_num, bus_num );
    Odd = new VIDEO_ODD_FIELD( funct_num, bus_num );
    
    Even->AllocateRiscMemory(4096);
    Odd->AllocateRiscMemory(4096);
    
    VFilterFlag_ = On;
}


PCI_VIDEO::~PCI_VIDEO()
{
    delete Even;
    delete Odd; 
}


DWORD PCI_VIDEO::ReadLocalDWORD( int reg )
{
    DWORD retDWORD;

    retDWORD = virtual_mem.Get( reg );

    return retDWORD;
}


int PCI_VIDEO::WriteLocalDWORD( int reg, DWORD writeDWORD )
{
    virtual_mem.Set( writeDWORD, reg );

    return 1;
}


int PCI_VIDEO::GetVideoFormat( void )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x04 );

    return ( value & 0x7 );
}


void PCI_VIDEO::SetVideoFormat( int vformat )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x04 );
    value = ( value & 0xF8 ) | ( vformat & 0x7 );
    WriteLocalDWORD( 0x04, value );
}


void PCI_VIDEO::SetAGCDelay( int agc_delay )
{
    WriteLocalDWORD( 0x060, agc_delay&0xFF );
}


int PCI_VIDEO::GetAGCDelay( void )
{
    return ( ReadLocalDWORD( 0x060 ) & 0xFF );
}


void PCI_VIDEO::SetBurstDelay( int burst_delay )
{
    WriteLocalDWORD( 0x064, burst_delay&0xFF );
}


DWORD PCI_VIDEO::GetRiscCounter(void)
{
    return ReadLocalDWORD( 0x120 ); 
}


void PCI_VIDEO::Reset( void )
{
    WriteLocalDWORD( 0x07C, 0xFF );
}


/*******************************************************************************
    Get current Video input mux setting.
*******************************************************************************/
int PCI_VIDEO::GetVideoInput( void )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x04 );

    return ( (value >> 5) & 0x3 );
}

/*******************************************************************************
    Set the Video input mux.
*******************************************************************************/
void PCI_VIDEO::SetVideoInput( int vinput )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x04 );
    value = ( value & 0x9F ) | ( ( vinput & 0x3 ) << 5 );
    WriteLocalDWORD( 0x04, value );

    // Make sure the ADC's that are used are on
    SetYADCSleep( Off );
    if( vinput == VideoInputSVideo )
    {
        SetCADCSleep( Off );
        SetYCVideo( On );
    }
    else
    {
        SetCADCSleep( On );
        SetYCVideo( Off );
    }
}


/*******************************************************************************
    Turn On/Off CADC Sleep Mode.
*******************************************************************************/
void PCI_VIDEO::SetCADCSleep( OnOff status )
{
    DWORD value;

    value = ReadLocalDWORD( 0x068 ) & 0xFD;

    if( status == On )
        value = value | 0x02;

    WriteLocalDWORD( 0x068, value );
}


/*******************************************************************************
    Get the current CADC Sleep mode setting.
*******************************************************************************/
OnOff PCI_VIDEO::GetCADCSleep( void )
{
    DWORD value;

    value = ReadLocalDWORD( 0x068 ) & 0x02;

    return( (value) ? On : Off );
}


/*******************************************************************************
    Turn On/Off YADC Sleep Mode.
*******************************************************************************/
void PCI_VIDEO::SetYADCSleep( OnOff status )
{
    DWORD value;

    value = ReadLocalDWORD( 0x068 ) & 0xFB;

    if( status == On )
        value = value | 0x04;

    WriteLocalDWORD( 0x068, value );
}


/*******************************************************************************
    Get the current YADC Sleep mode setting.
*******************************************************************************/
OnOff PCI_VIDEO::GetYADCSleep( void )
{
    DWORD value;

    value = ReadLocalDWORD( 0x068 ) & 0x04;

    return( (value) ? On : Off );
}


/*******************************************************************************
    Set Y/C Composite Video.
*******************************************************************************/
void PCI_VIDEO::SetYCVideo( OnOff stat )
{
    DWORD value1;
    DWORD value2;
    
    value1 = ReadLocalDWORD( 0x02C ) & 0xBF;
    value2 = ReadLocalDWORD( 0x0AC ) & 0xBF;
    
    if( stat == On )
    {
        value1 |= 0x40;
        value2 |= 0x40;
    }
    WriteLocalDWORD( 0x02C, value1 );
    WriteLocalDWORD( 0x0AC, value2 );
}


/*******************************************************************************
    Get Y/C Composite Video.
*******************************************************************************/
OnOff PCI_VIDEO::GetYCVideo( void )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x02C ) & 0x40;

    return( value ? On : Off );
}


/*******************************************************************************
    Set the Saturation using percent(%) (adjust chroma U and Chroma V).
    Input: saturation a range between 0 and 255 (100 = 100%);
*******************************************************************************/
void PCI_VIDEO::SetSaturation( UBYTE saturation )
{
    int nominal_u;
    int nominal_v;
    
    if( GetVideoFormat() == VideoFormatSECAM )
    {
        nominal_u = NominalUSECAM;
        nominal_v = NominalVSECAM;
    }
    else    // NTSC and PAL use same saturaiton values
    {
        nominal_u = NominalUNTSC;
        nominal_v = NominalVNTSC;
    }
    
    int value_u = ( nominal_u * saturation + 50 ) / 100;
    int value_v = ( nominal_v * saturation + 50 ) / 100;
    
    if( value_u >= 0x200 )
        value_u = 0x1FF;
        
    if( value_v >= 0x200 )
        value_v = 0x1FF;
        
    SetUSaturation( value_u );
    SetVSaturation( value_v );
}


/*******************************************************************************
    Get the Saturation setting in percent(%).
*******************************************************************************/
int PCI_VIDEO::GetSaturation( void )
{
    int nominal_u;
    int nominal_v;
    
    if( GetVideoFormat() == VideoFormatSECAM )
    {
        nominal_u = NominalUSECAM;
        nominal_v = NominalVSECAM;
    }
    else    // NTSC and PAL use same saturaiton values
    {
        nominal_u = NominalUNTSC;
        nominal_v = NominalVNTSC;
    }
    
    int saturation = (GetVSaturation() * 100 + nominal_v/2) / nominal_v;
    
    if( saturation > 0xFF )
        saturation = 0xFF;
        
    return saturation;
}


/*******************************************************************************
    Set the brightness.
*******************************************************************************/
void PCI_VIDEO::SetBrightness( int brightness )
{
    WriteLocalDWORD( 0x028, brightness&0xFF );
}

/*******************************************************************************
    Get current brightness setting.
*******************************************************************************/
int PCI_VIDEO::GetBrightness( void )
{
    return ( (char) (ReadLocalDWORD( 0x028 ) & 0xFF ) );
} 


/*******************************************************************************
    Set the Contrast.
*******************************************************************************/
void PCI_VIDEO::SetContrastReg( int contrast )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x02C );
    value = ( value & 0xFB ) | ( ( contrast & 0x100 ) >> 6);
    WriteLocalDWORD( 0x02C, value );    // MSB
    value = ReadLocalDWORD( 0x0AC );
    value = ( value & 0xFB ) | ( ( contrast & 0x100 ) >> 6);
    WriteLocalDWORD( 0x0AC, value );    // MSB
    
    WriteLocalDWORD( 0x030, contrast&0xFF );    // LSB
}


/*******************************************************************************
    Get the current Contrast setting.
*******************************************************************************/
int PCI_VIDEO::GetContrastReg( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x02C ) & 0x04) << 6;  // MSB (Even=Odd)
    value |= ReadLocalDWORD( 0x030 ) & 0xFF;        // LSB

    return value;   
}


/*******************************************************************************
    Set the Contrast using percent(%).
    Input: contrast % a range between 0 and 255 (100 = 100%);
*******************************************************************************/
void PCI_VIDEO::SetContrast( UBYTE contrast )
{
    int contrast_value = ( NominalContrast * contrast + 99 ) / 100;
    
    if( contrast_value >= 0x200 )
        contrast_value = 0x1FF;
        
    SetContrastReg( contrast_value );
}


/*******************************************************************************
    Set the Contrast using percent(%).
    Input: contrast % a range between 0 and 255 (100 = 100%);
*******************************************************************************/
int PCI_VIDEO::GetContrast( void )
{
    int contrast_value = GetContrastReg() * 100 / NominalContrast;
    
    if( contrast_value >= 0x100 )
        contrast_value = 0xFF;
        
    return contrast_value;
}


/*******************************************************************************
    Turn on/off White Crush.
*******************************************************************************/
void PCI_VIDEO::SetWhiteCrush( OnOff bit )
{
    DWORD value;

    value = ReadLocalDWORD( 0x068 ) & 0xFE;
    if( bit == On )
        value = value | 0x01;

    WriteLocalDWORD( 0x068, value );
}


/*******************************************************************************
    Get the current setting of White Crush.
*******************************************************************************/
OnOff PCI_VIDEO::GetWhiteCrush( void )
{
    DWORD value;

    value = (ReadLocalDWORD( 0x068 ) & 0x1);

    return( (value) ? On : Off );
}


/*******************************************************************************
    Turn On/Off Gamma correction.
*******************************************************************************/
void PCI_VIDEO::SetGammaCorrection( OnOff status )
{
    DWORD value;

    value = ReadLocalDWORD( 0x0D8 ) & 0xEF;

    if( status == Off )
        value = value | 0x10;

    WriteLocalDWORD( 0x0D8, value );
}


/*******************************************************************************
    Get the current Gamma Correction setting.
*******************************************************************************/
OnOff PCI_VIDEO::GetGammaCorrection( void )
{
    DWORD value;

    value = ReadLocalDWORD( 0x0D8 ) & 0x10;

    return( (value) ? Off : On );
}


/*******************************************************************************
    Set the Chroma Gain (U Saturation).
*******************************************************************************/
void PCI_VIDEO::SetUSaturation( int saturation )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x02C );
    value = ( value & 0xFD ) | ( ( saturation & 0x100 ) >> 7);
    WriteLocalDWORD( 0x02C, value );    // MSB
    value = ReadLocalDWORD( 0x0AC );
    value = ( value & 0xFD ) | ( ( saturation & 0x100 ) >> 7);
    WriteLocalDWORD( 0x0AC, value );    // MSB
    
    WriteLocalDWORD( 0x034, saturation&0xFF );  // LSB
}

/*******************************************************************************
    Get the current Chroma (U) Gain (U Saturation) setting.
*******************************************************************************/
int PCI_VIDEO::GetUSaturation( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x02C ) & 0x02) << 7;  // MSB (Even=Odd)
    value |= ReadLocalDWORD( 0x034 ) & 0xFF;        // LSB

    return value;   
}


/*******************************************************************************
    Set the Chroma (V) Gain (V Saturation).
*******************************************************************************/
void PCI_VIDEO::SetVSaturation( int saturation )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x02C );
    value = ( value & 0xFE ) | ( ( saturation & 0x100 ) >> 8);
    WriteLocalDWORD( 0x02C, value );    // MSB
    value = ReadLocalDWORD( 0x0AC );
    value = ( value & 0xFE ) | ( ( saturation & 0x100 ) >> 8);
    WriteLocalDWORD( 0x0AC, value );    // MSB
    
    WriteLocalDWORD( 0x038, saturation&0xFF );  // LSB
}


/*******************************************************************************
    Get the current Chroma (U) Gain (U Saturation) setting.
*******************************************************************************/
int PCI_VIDEO::GetVSaturation( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x02C ) & 0x01) << 8;  // MSB (Even=Odd)
    value |= ReadLocalDWORD( 0x038 ) & 0xFF;        // LSB

    return value;   
}


/*******************************************************************************
    Get Video Present status.
*******************************************************************************/
BOOL PCI_VIDEO::IsVideoPresent( void )
{
    DWORD value;