BonTuner.cpp

// BonTuner.cpp: CBonTuner クラスのインプリメンテーション
//   (DT300用)
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include <SetupApi.h>
#include <Malloc.h>
#include <InitGuid.h>
#include <Math.h>
#include <cstdio>
#include <io.h>
#include "Resource.h"
#include "BonTuner.h"


#pragma comment(lib, "SetupApi.lib")


using namespace std ;

//////////////////////////////////////////////////////////////////////
// 定数定義
//////////////////////////////////////////////////////////////////////

// 受信サイズ（FX側の設定）
DWORD TSDATASIZE        =   65536UL ;       // TSデータのサイズ
DWORD TSQUEUENUM        =   16UL    ;       // TSデータの環状ストック数
BOOL  BCASENABLED       =   TRUE    ;       // BCASデータ受信スレッドの有効化
DWORD BCASDATASIZE      =   4096UL  ;       // BCASデータのサイズ
DWORD BCASQUEUENUM      =   1UL     ;       // BCASデータの環状ストック数

// FIFOバッファ設定
DWORD ASYNCTSQUEUENUM   =   512UL   ;       // 非同期TSデータの環状ストック数

// 電源設定
BOOL AUTOPOWERON   = TRUE ;
BOOL AUTOPOWEROFF  = TRUE ;
DWORD U3BSFIXTUNE  = 0 ;
DWORD U3BSFIXWAIT  = 15500 ;
DWORD U3BSFIXCH    = 0 ;
BOOL AUTOTUNEBACKTONHK = FALSE ;

// エンドポイントインデックス
#define EPINDEX_IN          0UL
#define EPINDEX_OUT         1UL

// コマンド
#define CMD_EP6IN_START     0x50U   //
#define CMD_EP6IN_STOP      0x51U   //
#define CMD_EP2OUT_START    0x52U   //
#define CMD_EP2OUT_STOP     0x53U   //
#define CMD_PORT_CFG        0x54U   //addr_mask, out_pins
#define CMD_REG_READ        0x55U   //addr  (return 1byte)
#define CMD_REG_WRITE       0x56U   //addr, value
#define CMD_PORT_READ       0x57U   //(return 1byte)
#define CMD_PORT_WRITE      0x58U   //value
#define CMD_IFCONFIG        0x59U   //value
#define CMD_MODE_IDLE       0x5AU
#define CMD_EP4IN_START     0x5BU   // B-CAS
#define CMD_EP4IN_STOP      0x5CU   // B-CAS
#define CMD_IR_CODE         0x5DU   //val_l, val_h (0x0000:RBUF capture 0xffff:BWUF output)
#define CMD_IR_WBUF         0x5EU   //ofs(0 or 64 or 128 or 192), len(max 64), data, ....
#define CMD_IR_RBUF         0x5FU   //ofs(0 or 64 or 128 or 192) (return 64byte)
#define CMD_TSBCAS_INIT     0x70U   // TS - BCAS シンクロスタート
#define CMD_TSBCAS_START    0x71U   // TS - BCAS シンクロスタート
#define CMD_TSBCAS_END      0x72U   // TS - BCAS 終了

#define PIO_START           0x20
#define PIO_IR_OUT          0x10
#define PIO_IR_IN           0x08
#define PIO_TS_BACK         0x04

// チューナーのリモコン番号
DWORD IRNUMBER = 1UL ; // 1, 2 or 3

// ウェイト
  // 追加: ButtonPressTimes,ButtonReleaseTimes,ButtonInterimWait @ 2013/06/03
  //       (最新ファームでも発生するBSチャンネルスキャニングバグ対策用)
DWORD COMMANDSENDTIMES   = 1 ; //2 ;
DWORD COMMANDSENDWAIT    = 100 ;
DWORD CHANNELCHANGEWAIT  = 500 ;
DWORD BUTTONPRESSTIMES   = 2 ;
DWORD BUTTONPRESSWAIT    = 300 ;
DWORD BUTTONINTERIMWAIT  = 100 ;
DWORD BUTTONRELEASETIMES = 2  ;
DWORD BUTTONRELEASEWAIT  = 300 ;
DWORD BUTTONSPACEWAIT    = 500 ;
DWORD BUTTONPOWERWAIT    = 4000 ;
BOOL REDUCESPACECHANGE   = TRUE ;

//リモコンのコマンド下二桁．0x04NN
#define REMOCON_POWERON     0x8BU
#define REMOCON_POWEROFF    0x8CU

#define REMOCON_CHIDEJI     0xD6U
#define REMOCON_BS          0xE2U
#define REMOCON_CS          0xE3U

#define REMOCON_3DIGITS     0xD8U

#define REMOCON_NUMBER_0    0x80U   //10と一緒
#define REMOCON_NUMBER_1    0x81U
#define REMOCON_NUMBER_2    0x82U
#define REMOCON_NUMBER_3    0x83U
#define REMOCON_NUMBER_4    0x84U
#define REMOCON_NUMBER_5    0x85U
#define REMOCON_NUMBER_6    0x86U
#define REMOCON_NUMBER_7    0x87U
#define REMOCON_NUMBER_8    0x88U
#define REMOCON_NUMBER_9    0x89U
#define REMOCON_NUMBER_10   0x80U
#define REMOCON_NUMBER_11   0xD1U
#define REMOCON_NUMBER_12   0xD2U

#define REMOCON_MENU        0x8FU
#define REMOCON_UP          0x91U
#define REMOCON_DOWN        0x92U
#define REMOCON_LEFT        0x93U
#define REMOCON_RIGHT       0x94U
#define REMOCON_ENTER       0x95U
#define REMOCON_BACK        0x96U


// FX2ファームウェア
static const BYTE abyFirmWare[] =
#include "Fw.inc"

// FX2ファームウェア(sea)
static const BYTE abyFirmWare_sea[] =
#include "Fw_sea.inc"


//////////////////////////////////////////////////////////////////////
// チャンネル定義テーブル
//////////////////////////////////////////////////////////////////////

const struct {
    LPCTSTR pszSpace ;
    LPCTSTR pszChName ;
    const char* pszRCode ;
} asChTbl[] = {
    { TEXT("地デジ"), TEXT("リモコン 1"),              "X1" },
    { TEXT("地デジ"), TEXT("リモコン 2"),              "X2" },
    { TEXT("地デジ"), TEXT("リモコン 3"),              "X3" },
    { TEXT("地デジ"), TEXT("リモコン 4"),              "X4" },
    { TEXT("地デジ"), TEXT("リモコン 5"),              "X5" },
    { TEXT("地デジ"), TEXT("リモコン 6"),              "X6" },
    { TEXT("地デジ"), TEXT("リモコン 7"),              "X7" },
    { TEXT("地デジ"), TEXT("リモコン 8"),              "X8" },
    { TEXT("地デジ"), TEXT("リモコン 9"),              "X9" },
    { TEXT("地デジ"), TEXT("リモコン 10"),             "XA" },
    { TEXT("地デジ"), TEXT("リモコン 11"),             "XB" },
    { TEXT("地デジ"), TEXT("リモコン 12"),             "XC" },
    { TEXT("BS"),     TEXT("BS1/TS0 BS朝日"),          "YD151" },
    { TEXT("BS"),     TEXT("BS1/TS1 BS-i"),            "YD161" },
    { TEXT("BS"),     TEXT("BS3/TS0 WOWOW"),           "YD191" },
    { TEXT("BS"),     TEXT("BS3/TS1 BSジャパン"),      "YD171" },
    { TEXT("BS"),     TEXT("BS9/TS0 BS11"),            "YD211" },
    { TEXT("BS"),     TEXT("BS9/TS1 Star Channel HV"), "YD200" },
    { TEXT("BS"),     TEXT("BS9/TS2 TwellV"),          "YD222" },
    { TEXT("BS"),     TEXT("BS13/TS0 BS日テレ"),       "YD141" },
    { TEXT("BS"),     TEXT("BS13/TS1 BSフジ"),         "YD181" },
    { TEXT("BS"),     TEXT("BS15/TS1 NHK BS1/2"),      "YD101" },
    { TEXT("BS"),     TEXT("BS15/TS2 NHK BS-hi"),      "YD103" },
    { TEXT("110CS"),  TEXT("ND2 110CS #1"),            "ZD239" },
    { TEXT("110CS"),  TEXT("ND4 110CS #2"),            "ZD194" },
    { TEXT("110CS"),  TEXT("ND6 110CS #3"),            "ZD310" },
    { TEXT("110CS"),  TEXT("ND8 110CS #4"),            "ZD055" },
    { TEXT("110CS"),  TEXT("ND10 110CS #5"),           "ZD228" },
    { TEXT("110CS"),  TEXT("ND12 110CS #6"),           "ZD323" },
    { TEXT("110CS"),  TEXT("ND14 110CS #7"),           "ZD251" },
    { TEXT("110CS"),  TEXT("ND16 110CS #8"),           "ZD342" },
    { TEXT("110CS"),  TEXT("ND18 110CS #9"),           "ZD314" },
    { TEXT("110CS"),  TEXT("ND20 110CS #10"),          "ZD340" },
    { TEXT("110CS"),  TEXT("ND22 110CS #11"),          "ZD330" },
    { TEXT("110CS"),  TEXT("ND24 110CS #12"),          "ZD321" },
} ;

//////////////////////////////////////////////////////////////////////
// ユーティリティ
//////////////////////////////////////////////////////////////////////

static string trim(string str)
{
  string str2 = "" ;
  for(string::size_type i=0;i<str.size();i++) {
    if(BYTE(str[i])>0x20) {
      str2 = str.substr(i,str.size()-i) ;
      break ;
    }
  }
  if(str2=="") return "" ;
  for(string::size_type i=str2.size();i>0;i--) {
    if(BYTE(str2[i-1])>0x20) {
      return str2.substr(0,i) ;
    }
  }
  return "" ;
}

static wstring mbcs2wcs(string src)
{
    wchar_t *wcs = new wchar_t[src.length()*2 + 1];
    size_t wLen = 0;
    setlocale(LC_ALL,"japanese");
    mbstowcs_s(&wLen, wcs, src.length()*2 , src.c_str(), _TRUNCATE);
    wstring result = wcs;
    delete [] wcs;
    return result ;
}

//////////////////////////////////////////////////////////////////////
// インスタンス生成メソッド
//////////////////////////////////////////////////////////////////////

#pragma warning( disable : 4273 )

extern "C" __declspec(dllexport) IBonDriver * CreateBonDriver()
{
    // スタンス生成(既存の場合はインスタンスのポインタを返す)
    return (CBonTuner::m_pThis)? CBonTuner::m_pThis : ((IBonDriver *) new CBonTuner);
}

#pragma warning( default : 4273 )


//////////////////////////////////////////////////////////////////////
// 構築/消滅
//////////////////////////////////////////////////////////////////////

// 静的メンバ初期化
CBonTuner * CBonTuner::m_pThis = NULL;
HINSTANCE CBonTuner::m_hModule = NULL;

CBonTuner::CBonTuner()
    : m_pUsbFx2Driver(NULL)
    , m_hOnStreamEvent(NULL)
    , m_dwCurSpace(0)
    , m_cLastSpace(0xFF)
    , m_dwCurChannel(50)
    , m_pEcm(NULL)
    , m_bU3BSFixDone(FALSE)
{
    m_pEcm = new CEcmDat() ;
    m_pEcm->SetDiag(FALSE);
    m_pThis = this;
    m_bytesProceeded = 0 ;
    m_tickProceeding = GetTickCount() ;
    InitTunerProperty() ;
}

CBonTuner::~CBonTuner()
{
    // 開かれてる場合は閉じる
    CloseTuner();

    if (m_pEcm) {
        m_pEcm->exit();
        delete m_pEcm;
        m_pEcm = NULL ;
    }

    m_pThis = NULL;
}

const BOOL CBonTuner::OpenTuner()
{
    // 一旦クローズ
    CloseTuner();

    is_channel_valid = FALSE;

    m_cLastSpace = 0xFF ;

    m_bU3BSFixDone = FALSE ;

    // カメレオンUSB FX2のドライバインスタンス生成
    m_pUsbFx2Driver = new CUsbFx2Driver(this);
    if(!m_pUsbFx2Driver)return false;

    // FX2の初期化シーケンス
    try{
        // FIFOバッファ確保
        AllocFifoBuff();

        // イベント作成
        if(!(m_hOnStreamEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL)))throw 0UL;

        // ドライバオープン
        if(BCASENABLED) {
          if(!m_pUsbFx2Driver->OpenDriver( m_yFx2Id, abyFirmWare_sea, sizeof(abyFirmWare_sea), "FX2_FIFO_SEA"))throw 0UL;
        }else {
          if(!m_pUsbFx2Driver->OpenDriver( m_yFx2Id, abyFirmWare, sizeof(abyFirmWare),"FX2_FIFO"))throw 0UL;
        }

        // エンドポイント追加
        if(!m_pUsbFx2Driver->AddEndPoint(0x81U))throw 1UL;  // EPINDEX_IN
        if(!m_pUsbFx2Driver->AddEndPoint(0x01U))throw 2UL;  // EPINDEX_OUT

        // FX2 I/Oポート設定　＆　MAX2初期パラメータ設定 ＆ MAX2リセット
        if(!m_pUsbFx2Driver->TransmitFormatedData(EPINDEX_OUT, 6UL, CMD_PORT_CFG, 0x00U, PIO_START | PIO_IR_OUT | PIO_TS_BACK, CMD_MODE_IDLE, CMD_IFCONFIG, 0xE3U))throw 3UL;

        // スレッド起動
        if(!m_pUsbFx2Driver->CreateFifoThread(0x86U, &m_dwFifoThreadIndex, TSDATASIZE, TSQUEUENUM ))throw 4UL;
        if(BCASENABLED) {
          if(!m_pUsbFx2Driver->CreateFifoThread(0x84U, &m_dwFifoBcasThreadIndex, BCASDATASIZE, BCASQUEUENUM ))throw 4UL;
          // 開始コマンド送信
          if(!m_pUsbFx2Driver->TransmitFormatedData(EPINDEX_OUT, 4UL, CMD_TSBCAS_INIT, CMD_TSBCAS_START, CMD_PORT_WRITE, PIO_START | PIO_IR_OUT | PIO_TS_BACK))throw 3UL;
        }else {
          m_dwFifoBcasThreadIndex = 0xFFFFFFFF ;
          // 開始コマンド送信
          if(!m_pUsbFx2Driver->TransmitFormatedData(EPINDEX_OUT, 3UL, CMD_EP6IN_START, CMD_PORT_WRITE, PIO_START | PIO_IR_OUT | PIO_TS_BACK))throw 3UL;
        }

        // リモコンベースコード決定
        m_wIRBase = WORD(max(min(IRNUMBER,3UL),1UL)-1UL) * 0x80U ;

        // 成功
        if(AUTOPOWERON)
          IRCodeTX(REMOCON_POWERON);    //電源を入れる

        // DT-300 古いファームウェアの BS チューニングバグ対策 Method #1
        if(U3BSFIXTUNE) {
          if(U3BSFIXTUNE==1)
            m_bU3BSFixDone = U3BSFixTune() ;
          IRCodeTX(REMOCON_CHIDEJI) ;
        }

        return TRUE;
        }
    catch(DWORD dwErrorStep){
        // エラー発生
        dwErrorStep += 0 ; // to avoid warnning4101
        CloseTuner();

        return FALSE;
        }

}

void CBonTuner::CloseTuner()
{
    // ドライバを閉じる
    if(m_pUsbFx2Driver){

        // 次回起動時BS復元処理用にBSのチャンネルを戻しておく設定
        // (起動直後はBSチャンネルを認識しないのでこのタイミングで設定しておく)
        if(U3BSFIXTUNE) {
          if(m_bU3BSFixDone&&U3BSFIXCH) {
            U3BSFixResetChannel() ;
          }
        }

        // 終了時にNHKにチャンネルを戻すかどうか
        if(AUTOTUNEBACKTONHK) {
          Sleep(COMMANDSENDWAIT) ;
          IRCodeTX(REMOCON_CHIDEJI) ;
          IRCodeTX(REMOCON_NUMBER_1) ;
        }

        if(BCASENABLED) {
          m_pUsbFx2Driver->TransmitFormatedData(EPINDEX_OUT, 3UL,
            CMD_PORT_WRITE, PIO_IR_OUT|PIO_TS_BACK,
            CMD_TSBCAS_END ) ;
        }

        if(AUTOPOWEROFF) {
          Sleep(COMMANDSENDWAIT) ;
          IRCodeTX(REMOCON_POWEROFF);   //電源を切る
        }

        m_pUsbFx2Driver->CloseDriver();
        delete m_pUsbFx2Driver;
        m_pUsbFx2Driver = NULL;
        }

    // ハンドルを閉じる
    if(m_hOnStreamEvent){
        ::CloseHandle(m_hOnStreamEvent);
        m_hOnStreamEvent = NULL;
        }

    // バッファ開放
    FreeFifoBuff();
    // その他初期化
    m_dwCurSpace = 0 ;
    m_dwCurChannel = 50 ;
}

BOOL CBonTuner::U3BSFixTune()
{
  Sleep(COMMANDSENDWAIT) ;
  if(
    !IRCodeTX(REMOCON_BS)    ||
    !IRCodeTX(REMOCON_MENU)  ||
    !IRCodeTX(REMOCON_DOWN)  ||
    !IRCodeTX(REMOCON_ENTER) ||
    !IRCodeTX(REMOCON_ENTER)    )  return FALSE ;
  Sleep(U3BSFIXWAIT) ;  // BS-Digital 検出まで約14-5秒くらいかかる
  if(!IRCodeTX(REMOCON_MENU)) return FALSE ;
  Sleep(BUTTONSPACEWAIT) ;
  return TRUE ;
}

BOOL CBonTuner::U3BSFixResetChannel()
{
  Sleep(COMMANDSENDWAIT) ;
  if(
    !IRCodeTX(REMOCON_BS) ||
    !IRCodeTX(REMOCON_3DIGITS) ||
    !IRCodeTX(REMOCON_NUMBER_0+(U3BSFIXCH/100U)%10U) ||
    !IRCodeTX(REMOCON_NUMBER_0+(U3BSFIXCH/10U)%10U) ||
    !IRCodeTX(REMOCON_NUMBER_0+U3BSFIXCH%10U) ) return FALSE ;
  return TRUE ;
}

const BOOL CBonTuner::SetChannel(const BYTE bCh)
{

    //とりあえずストリームをとめる
    is_channel_valid = FALSE;


    // TSデータパージ
    PurgeTsStream();

    if(bCh < 0 || bCh >= m_Channels.size()){
        return FALSE;
    }

    //念のため２回送る
    for(size_t j = 0; j < COMMANDSENDTIMES; j++){
        //１個ずつ送る
        Sleep(COMMANDSENDWAIT) ;
        #if 0 // 元ソース
        for(i = 0; i < REMOCON_CMD_LEN; i++){
            if('\0' == m_Channels[bCh].rcode[i]){
                break;
            }
            if(!IRButtonTX(m_Channels[bCh].rcode[i])){
               return FALSE ;
            }
        }
        #else // mod5 rev 修正版
        for(size_t i = 0; i < min<size_t>(m_Channels[bCh].rcode.size(),REMOCON_CMD_LEN); i++){
            if(!IRButtonTX(m_Channels[bCh].rcode[i])){
               return FALSE ;
            }
        }
        #endif
    }

    Sleep(CHANNELCHANGEWAIT) ;

    //ストリーム送る
    is_channel_valid = TRUE;
    return TRUE;
}


const float CBonTuner::GetSignalLevel(void)
{
    #if 0
    // FIFOバッファのFullnessを返す
    return ((float)m_FifoBuffer.size() / (float)ASYNCTSQUEUENUM * 100.0f);
    #else
    // 実際に処理したストリームの転送量 Mbps を返す
    DWORD tick = GetTickCount() ;
    float duration ;
    if(tick>=m_tickProceeding) {
      duration = float( tick -  m_tickProceeding + 1 ) ;
    }else {
      duration = float( 0xFFFFFFFF - m_tickProceeding + tick + 1 ) ;
    }
    duration /= 1000.f ;
    float result = (float)m_bytesProceeded*8.f / duration / 1024.f / 1024.f ;
    m_tickProceeding = tick ;
    m_bytesProceeded = 0 ;
    if(result>100.f) result = 0.f ;
    return result ;
    #endif
}

const DWORD CBonTuner::WaitTsStream(const DWORD dwTimeOut)
{


    // 終了チェック
    if(!m_pUsbFx2Driver)return WAIT_ABANDONED;

    // イベントがシグナル状態になるのを待つ
    const DWORD dwRet = ::WaitForSingleObject(m_hOnStreamEvent, (dwTimeOut)? dwTimeOut : INFINITE);

    switch(dwRet){
        case WAIT_ABANDONED :
            // チューナが閉じられた
            return WAIT_ABANDONED;

        case WAIT_OBJECT_0 :
        case WAIT_TIMEOUT :
            // ストリーム取得可能 or チューナが閉じられた
            return (m_pUsbFx2Driver)? dwRet : WAIT_ABANDONED;

        case WAIT_FAILED :
        default:
            // 例外
            return WAIT_FAILED;
        }
}

const DWORD CBonTuner::GetReadyCount()
{
    // 取り出し可能TSデータ数を取得する
    return m_FifoBuffer.size();
}

const BOOL CBonTuner::GetTsStream(BYTE *pDst, DWORD *pdwSize, DWORD *pdwRemain)
{
    // TSデータをバッファから取り出す
    BYTE *pSrc = NULL;

    if(GetTsStream(&pSrc, pdwSize, pdwRemain)){
        if(*pdwSize){
            CopyMemory(pDst, pSrc, *pdwSize);
            }

        return TRUE;
        }

    return FALSE;
}

const BOOL CBonTuner::GetTsStream(BYTE **ppDst, DWORD *pdwSize, DWORD *pdwRemain)
{
    CBlockLock Lock(&m_CriticalLock);

    if(!m_pUsbFx2Driver)return FALSE;

    // TSデータをバッファから取り出す
    if(m_FifoBuffer.size()){
        // データコピー
        *pdwSize = m_FifoBuffer.front().second; // TSDATASIZE;
        *ppDst = m_FifoBuffer.front().first;
        m_FifoBuffer.pop();
        *pdwRemain = m_FifoBuffer.size() ;

        return TRUE;
        }
    else{
        // 取り出し可能なデータがない
        *pdwSize = 0;
        *pdwRemain = 0;

        return TRUE;
        }
}

void CBonTuner::PurgeTsStream()
{
    // バッファから取り出し可能データをパージする
    CBlockLock Lock(&m_CriticalLock);

    // 未処理のデータをパージする
    while(!m_FifoBuffer.empty()){
        m_FifoBuffer.pop();
        }
}

void CBonTuner::Release()
{
    // インスタンス開放
    delete this;
}

const bool CBonTuner::OnRecvFifoData(const DWORD dwThreadIndex, const BYTE *pData, const DWORD dwLen, CUsbFx2Driver *pDriver)
{
    if (dwThreadIndex == m_dwFifoThreadIndex) {
        CBlockLock Lock(&m_CriticalLock);
        //有効なチャンネルが選択されている時に限って
        if(is_channel_valid){
            // FIFOバッファにプッシュ
            PushFifoBuff(pData,dwLen);
            m_bytesProceeded+=dwLen ;
        }
        // イベントセット
        ::SetEvent(m_hOnStreamEvent);
    }
    else if (dwThreadIndex == m_dwFifoBcasThreadIndex) {
        if(m_pEcm) m_pEcm->set(pData, dwLen);
        m_bytesProceeded+=dwLen ;
    }

    return true;
}

void CBonTuner::AllocFifoBuff(void)
{
    // FIFOバッファをパージする
    PurgeTsStream();

    // バッファプールを確保する
    m_BufferPool.resize(ASYNCTSQUEUENUM);

    for(DWORD dwPos = 0UL ; dwPos < ASYNCTSQUEUENUM ; dwPos++){
        m_BufferPool[dwPos].resize(TSDATASIZE);
        }

    m_dwEmptyFifoPos = 0UL;
}

void CBonTuner::FreeFifoBuff(void)
{
    // FIFOバッファをパージする
    PurgeTsStream();

    // バッファプールを開放する
    m_BufferPool.clear();
}

void CBonTuner::PushFifoBuff(const BYTE *pData, DWORD dwLen)
{
    // バッファプールの最大数を超える場合は最後尾を切り捨てる
    while(m_FifoBuffer.size() >= ASYNCTSQUEUENUM){
        m_FifoBuffer.pop();
        }

    // バッファプールにデータコピー
    m_BufferPool[m_dwEmptyFifoPos].resize(dwLen) ;
    BYTE *pWritePointer = static_cast<BYTE*>(m_BufferPool[m_dwEmptyFifoPos].top()) ;
    CopyMemory(pWritePointer, pData, dwLen );

    // FIFOバッファにプッシュ
    m_FifoBuffer.push(make_pair(pWritePointer,dwLen));

    // バッファプール位置更新
    if(++m_dwEmptyFifoPos >= ASYNCTSQUEUENUM)m_dwEmptyFifoPos = 0UL;
}

// 0x04NNを送信
BOOL CBonTuner::IRCodeTX(BYTE code)
{
    BYTE cmd[3];
    DWORD len = 0;

    switch(code) {
      //チューナースペース切り替えが省略可能な場合は何もしない
      case REMOCON_CHIDEJI:
      case REMOCON_BS:
      case REMOCON_CS:
        if(REDUCESPACECHANGE && code==m_cLastSpace) {
          return TRUE ;
        }
        break ;
    }

    for(int i=0;i<BUTTONPRESSTIMES;i++) {
      cmd[len++] = CMD_IR_CODE;
      cmd[len++] = code;
      cmd[len++] = 0x04U;
      *LPWORD(&cmd[1]) += m_wIRBase ;
      if(!m_pUsbFx2Driver->TransmitData(EPINDEX_OUT,cmd,len)){
          return FALSE;
      }
      len = 0;
      Sleep(BUTTONPRESSWAIT);
    }

    Sleep(BUTTONINTERIMWAIT);

    //cap_stsからそのままパクる．詳細不明．
    for(int i=0;i<BUTTONRELEASETIMES;i++) {
      cmd[len++] = CMD_IR_CODE;
      cmd[len++] = 0;
      cmd[len++] = 0;
      if(!m_pUsbFx2Driver->TransmitData(EPINDEX_OUT,cmd,len)){
          return FALSE;
      }
      len = 0;
      Sleep(BUTTONRELEASEWAIT);
    }

    switch(code) {
      //チューナースペース切り替え直後は反応が悪いので待つ
      case REMOCON_CHIDEJI:
      case REMOCON_BS:
      case REMOCON_CS:
        if(m_cLastSpace!=code) {
          m_cLastSpace = code ;
          Sleep(BUTTONSPACEWAIT) ;
        }
        break ;
      //電源をON/OFF直後はリモコン反応しないので．反応するようになるまで４秒待つ．
      case REMOCON_POWERON:
      case REMOCON_POWEROFF:
        Sleep(BUTTONPOWERWAIT);
        break ;
    }
    return TRUE;
}

// 自分の名前からチューナータイプとIDを決定
BOOL CBonTuner::InitTunerProperty(void)
{
    //自分の名前を取得
    char szMyPath[_MAX_PATH] ;
    GetModuleFileNameA( m_hModule, szMyPath, _MAX_PATH ) ;
    char szMyDrive[_MAX_FNAME] ;
    char szMyDir[_MAX_FNAME] ;
    char szMyName[_MAX_FNAME] ;
    _splitpath_s( szMyPath, szMyDrive, _MAX_FNAME,szMyDir, _MAX_FNAME, szMyName, _MAX_FNAME, NULL, 0 ) ;
    _strupr_s( szMyName, sizeof(szMyName) ) ;
    //バンド数とFX2IDを取得
    int nNumBands = 3, nFx2Id = 0 ;
    sscanf_s( szMyName, "BONDRIVER_U%1dID%1d", &nNumBands, &nFx2Id ) ;
    LPCTSTR pszTunerName ;
    m_Channels.clear() ;
    int numChannels = (sizeof(asChTbl)/sizeof(asChTbl[0])) ;
    string strUnitedPrefix ;
    if ( nNumBands == 3 ) {
      pszTunerName = TEXT("ユニデン３波") ;
      strUnitedPrefix = "BonDriver_U3" ;
    }
    else {
      pszTunerName = TEXT("ユニデン地デジ") ;
      numChannels = 12 ;
      strUnitedPrefix = "BonDriver_U1" ;
    }
    m_yFx2Id = BYTE(nFx2Id) ;
    //チューナー名を決定
    _stprintf_s( m_szTunerName, 100, TEXT("%s(ID=%d)"), pszTunerName, nFx2Id ) ;
    for(int i=0;i<numChannels;i++) {
      m_Channels.push_back(CHANNEL(asChTbl[i].pszSpace,asChTbl[i].pszChName,asChTbl[i].pszRCode)) ;
    }
    //Iniファイルのロード
    #if 0
    if(!LoadIniFile(string(szMyDrive)+string(szMyDir)+string(szMyName)+".ini"))
      LoadIniFile(string(szMyDrive)+string(szMyDir)+strUnitedPrefix+".ini") ;
    #else
    LoadIniFile(string(szMyDrive)+string(szMyDir)+strUnitedPrefix+".ini") ;
    LoadIniFile(string(szMyDrive)+string(szMyDir)+string(szMyName)+".ini") ;
    #endif
    //チャンネルファイルのロード
    DBGOUT("Channel File Try Loading...\r\n") ;
    if(!LoadChannelFile(string(szMyDrive)+string(szMyDir)+string(szMyName)+".ch.txt"))
      LoadChannelFile(string(szMyDrive)+string(szMyDir)+strUnitedPrefix+".ch.txt") ;
    return TRUE ;
}

bool CBonTuner::LoadIniFile(string strIniFileName)
{
  if(_access(strIniFileName.c_str(), 0)) return false ;
  DBGOUT("Loading Ini \"%s\"...\n",strIniFileName.c_str()) ;
  #define LOADINT(key) do { \
      key = GetPrivateProfileIntA("BonTuner",#key, \
        key,strIniFileName.c_str()) ; \
      DBGOUT("%s = %d\n",#key,key) ; \
    }while(0)
  LOADINT(TSDATASIZE) ;
  LOADINT(TSQUEUENUM) ;
  LOADINT(BCASENABLED) ;
  LOADINT(BCASDATASIZE) ;
  LOADINT(BCASQUEUENUM) ;
  LOADINT(ASYNCTSQUEUENUM) ;
  LOADINT(AUTOPOWERON) ;
  LOADINT(AUTOPOWEROFF) ;
  LOADINT(U3BSFIXTUNE) ;
  LOADINT(U3BSFIXWAIT) ;
  LOADINT(U3BSFIXCH) ;
  LOADINT(AUTOTUNEBACKTONHK) ;
  LOADINT(IRNUMBER) ;
  LOADINT(COMMANDSENDTIMES) ;
  LOADINT(COMMANDSENDWAIT) ;
  LOADINT(CHANNELCHANGEWAIT) ;
  LOADINT(BUTTONPRESSTIMES) ;
  LOADINT(BUTTONPRESSWAIT) ;
  LOADINT(BUTTONINTERIMWAIT) ;
  LOADINT(BUTTONRELEASETIMES) ;
  LOADINT(BUTTONRELEASEWAIT) ;
  LOADINT(BUTTONSPACEWAIT) ;
  LOADINT(BUTTONPOWERWAIT) ;
  LOADINT(REDUCESPACECHANGE) ;
  #undef LOADINT
  if(m_pEcm) m_pEcm->LoadIniFile(strIniFileName) ;
  return true ;
}

bool CBonTuner::LoadChannelFile(string strChannelFileName)
{
  FILE *st=NULL ;
  fopen_s(&st,strChannelFileName.c_str(),"rt") ;
  if(!st) return false;
  char s[512] ;
  m_Channels.clear() ;
  while(!feof(st)) {
    s[0]='\0' ;
    fgets(s,512,st) ;
    int t=0 ;
    string params[3] ;
    params[0] = params[1] = params[2] = "" ;
    for(int i=0;s[i];i++) {
      if(s[i]==';') break ;
      else if(s[i]==',') {
        t++ ; if(t==3) break ;
      }else params[t] += s[i] ;
    }
    if(t>=2) {
      DBGOUT("Channel(%d)= %s, %s, %s\r\n",m_Channels.size(),trim(params[0]).c_str(),trim(params[1]).c_str(),trim(params[2]).c_str()) ;
      m_Channels.push_back(
        CHANNEL(mbcs2wcs(trim(params[0])),mbcs2wcs(trim(params[1])),trim(params[2])) ) ;
    }
  }
  DBGOUT("Channel File Loaded. (Total %d Channels)\r\n",m_Channels.size()) ;
  fclose(st) ;
  return true ;
}


BYTE CBonTuner::ConvButtonToCode(BYTE button)
{
    switch(button){
        case 'X':
            return REMOCON_CHIDEJI;
        case 'Y':
            return REMOCON_BS;
        case 'Z':
            return REMOCON_CS;
        case 'D' :
            return REMOCON_3DIGITS;

        case '0':
            return REMOCON_NUMBER_0;    //Aと一緒なわけですが
        case '1':
            return REMOCON_NUMBER_1;
        case '2':
            return REMOCON_NUMBER_2;
        case '3':
            return REMOCON_NUMBER_3;
        case '4':
            return REMOCON_NUMBER_4;
        case '5':
            return REMOCON_NUMBER_5;
        case '6':
            return REMOCON_NUMBER_6;
        case '7':
            return REMOCON_NUMBER_7;
        case '8':
            return REMOCON_NUMBER_8;
        case '9':
            return REMOCON_NUMBER_9;
        case 'A':
            return REMOCON_NUMBER_10;
        case 'B':
            return REMOCON_NUMBER_11;
        case 'C':
            return REMOCON_NUMBER_12;

        case 'P':
            return REMOCON_POWERON;
        case 'Q':
            return REMOCON_POWEROFF;

        default:
            return 0;
    }
}

BOOL CBonTuner::IRButtonTX(BYTE button)
{
  BYTE code = ConvButtonToCode(button) ;

  // DT-300 古いファームウェアの BS チューニングバグ対策 Method #2
  if( U3BSFIXTUNE==2 && !m_bU3BSFixDone && code==REMOCON_BS ) {
    return m_bU3BSFixDone = U3BSFixTune() ;
  }

  return IRCodeTX(code) ;
}

LPCTSTR CBonTuner::GetTunerName(void)
{
    // チューナ名を返す
    return m_szTunerName ;
}

const BOOL CBonTuner::IsTunerOpening(void)
{
    // チューナの使用中の有無を返す(全プロセスを通して)
    if( m_pUsbFx2Driver != NULL ){
        return TRUE;
    }else{
        return FALSE;
    }
}

LPCTSTR CBonTuner::EnumTuningSpace(const DWORD dwSpace)
{
    // 0は最初の空間を返す
    if ( dwSpace == 0 ) return m_Channels[0].c_space() ;
    // 次の空間名を探す
    DWORD dwSpcIdx = 0 ;
    int nIdx0 = 0 ;
    for ( CHANNELS::size_type nIdx = 0 ; nIdx < m_Channels.size() ; nIdx++ ) {
        if ( m_Channels[nIdx0].space == m_Channels[nIdx].space ) continue ;
        nIdx0 = nIdx ;
        dwSpcIdx++ ;
        if ( dwSpace == dwSpcIdx ) return m_Channels[nIdx].c_space() ;
    }
    return NULL ;
}

LPCTSTR CBonTuner::EnumChannelName(const DWORD dwSpace, const DWORD dwChannel)
{
    // 空間名を取得する
    LPCTSTR pszSpace = EnumTuningSpace( dwSpace ) ;
    if ( !pszSpace ) return NULL ;
    wstring space = wstring(pszSpace) ;
    // 空間名の一致するチャンネルを探す
    DWORD dwChIdx = 0 ;
    for ( CHANNELS::size_type nIdx = 0 ; nIdx < m_Channels.size() ; nIdx++ ) {
        if ( space != m_Channels[nIdx].space ) continue ;
        if ( dwChIdx == dwChannel ) return m_Channels[nIdx].c_name() ;
        dwChIdx++ ;
    }
    return NULL ;
}

const BOOL CBonTuner::SetChannel(const DWORD dwSpace, const DWORD dwChannel)
{
    // 空間名を取得する
    LPCTSTR pszSpace = EnumTuningSpace( dwSpace ) ;
    if ( !pszSpace ) return FALSE ;
    wstring space = wstring(pszSpace) ;
    // 空間名の一致するチャンネルを探す
    DWORD dwChIdx = 0 ;
    for ( CHANNELS::size_type nIdx = 0 ; nIdx < m_Channels.size() ; nIdx++ ) {
        if ( space != m_Channels[nIdx].space ) continue ;
        if ( dwChIdx == dwChannel ) {
            // チャンネルを設定する
            if( SetChannel((BYTE)nIdx) == TRUE ){
                m_dwCurSpace = dwSpace;
                m_dwCurChannel = dwChannel;
                return TRUE;
            }else{
                return FALSE;
            }
        }
        dwChIdx++ ;
    }
    return FALSE ;
}

const DWORD CBonTuner::GetCurSpace(void)
{
    // 現在のチューニング空間を返す
    return m_dwCurSpace;
}

const DWORD CBonTuner::GetCurChannel(void)
{
    // 現在のチャンネルを返す
    return m_dwCurChannel;
}