ircommand.cpp

pci 底层驱动

#include "common.h"
#include "ircommand.h"
#include "hid_commands.h"


//Command table for RC5 command codes
const IR_Command::KEY_INFO IR_Command::_s_rc5_table[] =
{
    //command_code  key_code    
    //------------  ----------- 
    {0,             KEYBOARD_0},
    {1,             KEYBOARD_1},
    {2,             KEYBOARD_2},
    {3,             KEYBOARD_3},
    {4,             KEYBOARD_4},
    {5,             KEYBOARD_5},
    {6,             KEYBOARD_6},
    {7,             KEYBOARD_7},
    {8,             KEYBOARD_8},
    {9,             KEYBOARD_9},

    {13,            VOLUME_MUTE},
    {16,            VOLUME_UP},
    {17,            VOLUME_DOWN},

    {32,            CHANNEL_UP},
    {33,            CHANNEL_DOWN},

    {53,            PVR_PLAY},
    {55,            PVR_RECORD},
    {48,            PVR_PAUSE},
    {54,            PVR_STOP}
};

//Command table for commands from customer's remote (NEC standard)
const IR_Command::KEY_INFO IR_Command::_s_cust_table[] =
{
    //command_code  key_code    
    //------------  ----------- 
    {0,             KEYBOARD_0},
    {1,             KEYBOARD_1},
    {2,             KEYBOARD_2},
    {3,             KEYBOARD_3},
    {4,             KEYBOARD_4},
    {5,             KEYBOARD_5},
    {6,             KEYBOARD_6},
    {7,             KEYBOARD_7},
    {8,             KEYBOARD_8},
    {9,             KEYBOARD_9},

    {0x11,          VOLUME_MUTE},
    {0xE,           VOLUME_UP},
    {0xF,           VOLUME_DOWN},

    {0xC,           CHANNEL_UP},
    {0xD,           CHANNEL_DOWN},

    {0x14,          KEYBOARD_UP},
    {0x15,          KEYBOARD_DOWN},
    {0x16,          KEYBOARD_LEFT},
    {0x17,          KEYBOARD_RIGHT},

    {0xB,           KEYBOARD_ENTER},
    {0xA,           KEYBOARD_BACK}
};

//Command table for commands from small gray remote (NEC standard)
const IR_Command::KEY_INFO IR_Command::_s_small_remote_table[] =
{
    //command_code  key_code    
    //------------  ----------- 
    {0x02,          KEYBOARD_0},
    {0x01,          KEYBOARD_1},
    {0x0B,          KEYBOARD_2},
    {0x1B,          KEYBOARD_3},
    {0x05,          KEYBOARD_4},
    {0x09,          KEYBOARD_5},
    {0x15,          KEYBOARD_6},
    {0x06,          KEYBOARD_7},
    {0x0A,          KEYBOARD_8},
    {0x12,          KEYBOARD_9},

    {0x18,          VOLUME_MUTE},
    {0x16,          VOLUME_UP},
    {0x14,          VOLUME_DOWN},

    {0x1F,          CHANNEL_UP},
    {0x17,          CHANNEL_DOWN},

    {0x11,          PVR_PLAY},
    {0x00,          PVR_RECORD},
    {0x08,          PVR_STOP},

    {0x13,          KEYBOARD_ENTER}
};


//The index of the table in use comes from the registry.
const IR_Command::KEY_TABLE  IR_Command::_s_key_tables[] =
{
    {
        sizeof(_s_rc5_table)/sizeof(KEY_INFO),  
        (PKEY_INFO)_s_rc5_table
    },
    {
        sizeof(_s_cust_table)/sizeof(KEY_INFO),  
        (PKEY_INFO)_s_cust_table
    },
    {
        sizeof(_s_small_remote_table)/sizeof(KEY_INFO),  
        (PKEY_INFO)_s_small_remote_table
    }
};


/////////////////////////////////////////////////////////////////////////////////////////
//RC5Command::fillConsumerUsageReport
//
// If the keystroke is to be reported as an APPCOMMAND, call this function to fill in the
// consumer usage report.
//
VOID IR_Command::fillConsumerUsageReport()
{
    _report.consumer_report.report_id = REPORT_ID_CONSUMER;

    
    DWORD key_flag = _key_code & 0xFF00;
    BYTE consumer_flag = (BYTE) (_key_code & 0xFF);

    switch(key_flag)
    {
    case VOLUME_KEY:
        _report.consumer_report.volume = consumer_flag;
        break;
    case CHANNEL_KEY:
        _report.consumer_report.channel = consumer_flag;
        break;
    case PVR_KEY:
        _report.consumer_report.pvr = consumer_flag;
        break;
    }
}

BOOLEAN IR_Command::isAutoRepeatKey()
{
    return 
        ((_key_code == VOLUME_UP) ||
        (_key_code == VOLUME_DOWN) ||
        (_key_code == CHANNEL_UP) ||
        (_key_code == CHANNEL_DOWN) ||
        (_key_code == KEYBOARD_UP) ||
        (_key_code == KEYBOARD_DOWN) ||
        (_key_code == KEYBOARD_LEFT) ||
        (_key_code == KEYBOARD_RIGHT)); 
}


VOID IR_Command::fillKeyboardUsageReport()
{
    _report.keyboard_report.report_id = REPORT_ID_KEYBOARD;
 
    BYTE hid_key_usage = (BYTE) (_key_code & 0xFF);
    _report.keyboard_report.keystroke[0] = hid_key_usage;
}

VOID IR_Command::initialize(ULONG command)
{
    dbgLogInfo(("IR_Command::initialize, command = 0x%x\n", command));

    _key_code = 0;

    //Look up the key code
    for(int i = 0; i < _s_key_tables[_table_index].num_key_codes; i++)
    {
        if(_s_key_tables[_table_index].p_key_codes[i].command_code == command)
        {
            _key_code = _s_key_tables[_table_index].p_key_codes[i].key_code;
            break;
        }
    }

    RtlZeroMemory(&_report, sizeof(_report));

    if(isKeyboardKey())
    {
        fillKeyboardUsageReport();
    }
    else
    {
        fillConsumerUsageReport();
    }
}

IR_Command::IR_Command(BYTE command_table_index):
_table_index(command_table_index),
_key_code(0)
{
}