vof.cpp

djgpp bt878 capture for DOS

#include "vof.h"

/*******************************************************************************
    Start the Odd Risc Program.
    both_fields == TRUE - Enable both fields.
                == FALSE - Enable odd field only.
*******************************************************************************/
void VIDEO_ODD_FIELD::RunRisc( int both_fields )
{
    DWORD value1;
    DWORD value2;
    
    WriteLocalDWORD( 0x100, 0x000C0000 );
    
    value1 = ReadLocalDWORD( 0x10C ) & 0xFFFFFFFC;
    if( both_fields == TRUE )
        value2 = ReadLocalDWORD( 0x0DC ) | 0x03;
    else
        value2 = ReadLocalDWORD( 0x0DC ) | 0x02;
    
    WriteLocalDWORD( 0x114, RiscDMA->GetPhysicalAddress()); /* RISC STARTING ADDRESS */
    WriteLocalDWORD( 0x10C, value1 | 0x01 );    /* FIFO ENABLE */
    WriteLocalDWORD( 0x0DC, value2 );           /* CAPTURE CONTROL */
    WriteLocalDWORD( 0x10C, value1 | 0x03);     /* RISC/FIFO ENABLE */
}

/*******************************************************************************
    Halt the Odd/Both Risc Program.
    both_fields == TRUE - Halt both fields.
                == FALSE - Halt odd field only.
*******************************************************************************/
int VIDEO_ODD_FIELD::HaltRisc( int both_fields )
{
    DWORD value1;
    DWORD value2;
    
    value1 = ReadLocalDWORD( 0x10C ) & 0xFFFFFFFC;
    if( both_fields == TRUE )
        value2 = ReadLocalDWORD( 0x0DC ) & 0xFFFFFFFC;
    else
        value2 = ReadLocalDWORD( 0x0DC ) & 0xFFFFFFFD;
    
    WriteLocalDWORD( 0x10C, value1 | 0x01);     /* RISC/FIFO ENABLE */
    WriteLocalDWORD( 0x0DC, value2 );           /* CAPTURE CONTROL */
    WriteLocalDWORD( 0x10C, value1 | 0x00 );    /* FIFO ENABLE */
}

/*******************************************************************************
    Set the Odd Vertical Delay (O_VDELAY).
*******************************************************************************/
void VIDEO_ODD_FIELD::SetVDelay( int vdelay )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x08C );
    value = ( value & 0x3F ) | ( ( vdelay & 0x300 ) >> 2);
    WriteLocalDWORD( 0x08C, value );    // MSB
    
    WriteLocalDWORD( 0x090, vdelay&0xFF );  // LSB
}

/*******************************************************************************
    Get the Odd Vertical Delay (O_VDELAY).
*******************************************************************************/
int VIDEO_ODD_FIELD::GetVDelay( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x08C ) & 0xC0) << 2;  // MSB
    value |= ReadLocalDWORD( 0x090 ) & 0xFF;        // LSB

    return value;   
}
        
/*******************************************************************************
    Set the Odd Vertical Active (O_VACTIVE).
*******************************************************************************/
void VIDEO_ODD_FIELD::SetVActive( int vactive )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x8C );
    value = ( value & 0xCF ) | ( ( vactive & 0x300 ) >> 4);
    WriteLocalDWORD( 0x08C, value );    // MSB
    
    WriteLocalDWORD( 0x094, vactive&0xFF ); // LSB
}

/*******************************************************************************
    Get the Odd Vertical Active (O_VACTIVE).
*******************************************************************************/
int VIDEO_ODD_FIELD::GetVActive( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x08C ) & 0x30) << 4;  // MSB
    value |= ReadLocalDWORD( 0x094 ) & 0xFF;        // LSB

    return value;   
}
                
/*******************************************************************************
    Set the Odd Horizontal Delay (O_HDELAY).
*******************************************************************************/
void VIDEO_ODD_FIELD::SetHDelay( int hdelay )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x08C );
    value = ( value & 0xF3 ) | ( ( hdelay & 0x300 ) >> 6);
    WriteLocalDWORD( 0x08C, value );    // MSB
    
    WriteLocalDWORD( 0x098, hdelay&0xFF );  // LSB
}

/*******************************************************************************
    Get the Odd Horizontal Delay (O_HDELAY).
*******************************************************************************/
int VIDEO_ODD_FIELD::GetHDelay( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x08C ) & 0x0C) << 6;  // MSB
    value |= ReadLocalDWORD( 0x098 ) & 0xFF;        // LSB

    return value;   
}
                
/*******************************************************************************
    Set the Odd Horizontal Active (O_HACTIVE).
*******************************************************************************/
void VIDEO_ODD_FIELD::SetHActive( int hactive )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x08C );
    value = ( value & 0xFC ) | ( ( hactive & 0x300 ) >> 8);
    WriteLocalDWORD( 0x08C, value );    // MSB
    
    WriteLocalDWORD( 0x09C, hactive&0xFF ); // LSB
}

/*******************************************************************************
    Set the Odd Horizontal Active (O_HACTIVE).
*******************************************************************************/
int VIDEO_ODD_FIELD::GetHActive( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x08C ) & 0x03) << 8;  // MSB
    value |= ReadLocalDWORD( 0x09C ) & 0xFF;        // LSB

    return value;   
}
                
/*******************************************************************************
    Set the Odd Horizontal Scaling (O_HSCALE).
*******************************************************************************/
void VIDEO_ODD_FIELD::SetHScale( int hscale )
{
    WriteLocalDWORD( 0x0A0, (hscale>>8)&0xFF ); // MSB
    WriteLocalDWORD( 0x0A4, hscale&0xFF );  // LSB
}

/*******************************************************************************
    Get the Odd Horizontal Scaling (O_HSCALE).
*******************************************************************************/
int VIDEO_ODD_FIELD::GetHScale( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x0A0 ) & 0xFF) << 8;  // MSB
    value |= ReadLocalDWORD( 0x0A4 ) & 0xFF;        // LSB

    return value;   
}
                
/*******************************************************************************
    Set the Odd Vertical Scaling (O_VSCALE).
*******************************************************************************/
void VIDEO_ODD_FIELD::SetVScale( int vscale )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x0CC );
    value = ( value & 0xE0 ) | ( ( vscale & 0x1F00 ) >> 8);
    WriteLocalDWORD( 0x0CC, value );    // MSB
    
    WriteLocalDWORD( 0x0D0, vscale&0xFF );  // LSB
}

/*******************************************************************************
    Get the Odd Vertical Scaling (O_VSCALE).
*******************************************************************************/
int VIDEO_ODD_FIELD::GetVScale( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x0CC ) & 0x1F) << 8;  // MSB
    value |= ReadLocalDWORD( 0x0D0 ) & 0xFF;        // LSB

    return value;   
}

/*******************************************************************************
    Turn the Odd Luma Comb Filter on/off
    on = 1;
    off = 0;
*******************************************************************************/
void VIDEO_ODD_FIELD::SetLumaComb( int ycomb )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x0CC ) & 0x7F;
    value = value | ( (ycomb&1) << 7 );
    
    WriteLocalDWORD( 0xCC, value );
}

/*******************************************************************************
    Get the current Odd Luma Comb Filter setting.
*******************************************************************************/
int VIDEO_ODD_FIELD::GetLumaComb( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x0CC ) & 0x80);

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

/*******************************************************************************
    Turn the Odd Chroma Comb Filter on/off
    on = 1;
    off = 0;
*******************************************************************************/
void VIDEO_ODD_FIELD::SetChromaComb( int ccomb )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x0CC ) & 0xBF;
    value = value | ( (ccomb&1) << 6 );
    
    WriteLocalDWORD( 0xCC, value );
}

/*******************************************************************************
    Get the current Odd Luma Comb Filter setting.
*******************************************************************************/
int VIDEO_ODD_FIELD::GetChromaComb( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x0CC ) & 0x40);

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


/*******************************************************************************
    Set Odd Field as Interlaced.
    0 = Non-Interlaced;
    1 = Interlaced;
*******************************************************************************/
void VIDEO_ODD_FIELD::SetInterlaced( int interlaced )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x0CC ) & 0xDF;
    value = value | ( (interlaced&1) << 5 );
    
    WriteLocalDWORD( 0xCC, value );
}

/*******************************************************************************
    Get Odd Field Interlaced setting.
    0 = Non-Interlaced;
    1 = Interlaced;
*******************************************************************************/
int VIDEO_ODD_FIELD::GetInterlaced( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x0CC ) & 0x20);

    return( (value) ? Interlaced : NonInterlaced );
}

/*******************************************************************************
    Set Odd Field Horizontal Low-Pass Filter.
*******************************************************************************/
void VIDEO_ODD_FIELD::SetHorizontalFilter( int hfilter )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x0C0 ) & 0xF3;
    value = value | ( (hfilter&3) << 2 );
    
    WriteLocalDWORD( 0xC0, value );
}

/*******************************************************************************
    Get current Odd Field Horizontal Low-Pass Filter setting.
*******************************************************************************/
int VIDEO_ODD_FIELD::GetHorizontalFilter( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x0C0 ) & 0x0C) >> 2;

    return( value );
}
        
/*******************************************************************************
    Set Odd Field Vertical Scaling Filter.
*******************************************************************************/
void VIDEO_ODD_FIELD::SetVerticalFilter( int vfilter )
{
    DWORD value;
    
    value = ReadLocalDWORD( 0x0EC ) & 0xFC;
    value = value | (vfilter&3);
    
    WriteLocalDWORD( 0x0EC, value );
}

/*******************************************************************************
    Get current Odd Field Vertical Scaling Filter setting.
*******************************************************************************/
int VIDEO_ODD_FIELD::GetVerticalFilter( void )
{
    DWORD value;
    
    value = (ReadLocalDWORD( 0x0EC ) & 0x03);

    return( value );
}
        
/*******************************************************************************
    Set the Output color format for the Odd Field.
*******************************************************************************/
void VIDEO_ODD_FIELD::SetColorFormat( int color_format )
{
    DWORD value;

    value = ReadLocalDWORD( 0x0D4 ) & 0x0F;

    value = value | ((color_format&0xF) << 4);

    WriteLocalDWORD( 0x0D4, value );
}

/*******************************************************************************
    Get the Output color format for the Odd Field.
*******************************************************************************/
int VIDEO_ODD_FIELD::GetColorFormat( void )
{
    DWORD value;

    value = (ReadLocalDWORD( 0x0D4 ) & 0xF0) >> 4;

    return( value );
}