예제 #1
0
void TgenericFFV1page::cfg2dlg(void)
{
    cbxSetDataCurSel(IDC_CBX_FFV1_CSP, cfgGet(IDFF_enc_ffv1_csp));
    cbxSetCurSel(IDC_CBX_FFV1_CODER, cfgGet(IDFF_enc_ffv1_coder));
    cbxSetCurSel(IDC_CBX_FFV1_CONTEXT, cfgGet(IDFF_enc_ffv1_context));
    //SetDlgItemInt(m_hwnd,IDC_ED_FFV1_CONTEXT,cfgGet(IDFF_enc_ffv1_context),FALSE);
    SetDlgItemInt(m_hwnd, IDC_ED_MAXKEYINTERVAL, cfgGet(IDFF_enc_ffv1_key_interval), FALSE);
}
예제 #2
0
void TgenericHuffyuvPage::cfg2dlg(void)
{
    cbxSetCurSel(IDC_CBX_HUFFYUV_CSP, cfgGet(IDFF_enc_huffyuv_csp));
    cbxSetCurSel(IDC_CBX_HUFFYUV_PRED, cfgGet(IDFF_enc_huffyuv_pred));
    setCheck(IDC_CHB_HUFFYUV_CTX, cfgGet(IDFF_enc_huffyuv_ctx));
    setCheck(IDC_CHB_GRAY, cfgGet(IDFF_enc_gray));
    enable(0, IDC_CHB_GRAY);
}
예제 #3
0
void TbitmapPage::cfg2dlg(void)
{
    setDlgItemText(m_hwnd,IDC_ED_BITMAP_FLNM,cfgGetStr(IDFF_bitmapFlnm));
    pos2dlg();
    cbxSetCurSel(IDC_CBX_BITMAP_ALIGN,cfgGet(IDFF_bitmapAlign));
    cbxSetCurSel(IDC_CBX_BITMAP_MODE,cfgGet(IDFF_bitmapMode));
    opacity2dlg();
}
예제 #4
0
void TffdshowPageEnc::fourcc2dlg(void)
{
    FOURCC fourcc = cfgGet(IDFF_enc_fourcc);
    int cnt = cbxGetItemCount(IDC_CBX_FOURCC);
    for (int i = 0; i < cnt; i++)
        if ((FOURCC)cbxGetItemData(IDC_CBX_FOURCC, i) == fourcc) {
            cbxSetCurSel(IDC_CBX_FOURCC, i);
            return;
        }
    cbxSetCurSel(IDC_CBX_FOURCC, 0);
    cfgSet(IDFF_enc_fourcc, (int)cbxGetItemData(IDC_CBX_FOURCC, 0));
}
예제 #5
0
파일: Coutsfs.cpp 프로젝트: TheRyuu/ffdshow
void ToutsfsPage::connect2dlg(void)
{
    int connect = cfgGet(IDFF_aoutConnectTo);
    cbxSetCurSel(IDC_CBX_AOUT_CONNECTTO, connect);
    enable(connect > 0, IDC_CHB_AOUT_CONNECTTO_SPDIF);
    setCheck(IDC_CHB_AOUT_CONNECTTO_SPDIF, cfgGet(IDFF_aoutConnectToOnlySpdif));
}
예제 #6
0
파일: Cquant.cpp 프로젝트: TheRyuu/ffdshow
void TquantPage::qns2dlg(void)
{
    cbxSetCurSel(IDC_CBX_QNS, cfgGet(IDFF_enc_qns));
    int is = sup_qns(codecId);
    static const int idQns[] = {IDC_LBL_QNS, IDC_CBX_QNS, 0};
    enable(is, idQns);
}
예제 #7
0
void TdeinterlacePage::deint2dlg(void)
{
    setCheck(IDC_CHB_DEINTERLACEALWAYS, cfgGet(IDFF_deinterlaceAlways));
    setCheck(IDC_CHB_SWAP_FIELDS, cfgGet(IDFF_swapFields)); //enable(cfgGet(IDFF_isDeinterlace),IDC_CHB_SWAP_FIELDS);
deint2dlgAgain:
    int method = cfgGet(IDFF_deinterlaceMethod);
    if (panel) {
        delete panel;
    }
    panel = NULL;
    const TdeinterlaceSettings::TmethodProps &methodProps = TdeinterlaceSettings::getMethod(method);
    if (methodProps.id != TdeinterlaceSettings::DSCALER) {
        cbxSetDataCurSel(IDC_CBX_DEINT_METHOD, method);
        if (methodProps.create) {
            panel = methodProps.create(this);
        }
    } else {
        strings::const_iterator diflnm = std::find(diflnms.begin(), diflnms.end(), cfgGetStr(IDFF_dscalerDIflnm));
        if (diflnm != diflnms.end()) {
            cbxSetCurSel(IDC_CBX_DEINT_METHOD, int(diflnm - diflnms.begin() + dscalerstart));
            panel = new TdeinterlacePageDScaler(this, diflnm->c_str());
        } else {
            cfgSet(IDFF_deinterlaceMethod, 0);
            goto deint2dlgAgain;
        }
    }
    if (panel) {
        SetWindowPos(panel->m_hwnd, place, placer.left, placer.top, 0, 0, SWP_NOSIZE);
        panel->cfg2dlg();
    }
}
예제 #8
0
void TresizeSettingsPage::translate(void)
{
    TconfPageBase::translate();

    int selLuma = cbxGetCurSel(IDC_CBX_RESIZE_METHOD_LUMA), selChroma = cbxGetCurSel(IDC_CBX_RESIZE_METHOD_CHROMA);
    cbxClear(IDC_CBX_RESIZE_METHOD_LUMA);
    cbxClear(IDC_CBX_RESIZE_METHOD_CHROMA);
    for (int i = 0; TresizeAspectSettings::methodsOrder[i] != -1; i++) {
        int method = TresizeAspectSettings::methodsOrder[i];
        cbxAdd(IDC_CBX_RESIZE_METHOD_LUMA  , _(IDC_CBX_RESIZE_METHOD_LUMA, TresizeAspectSettings::methodsProps[method].name), TresizeAspectSettings::methodsProps[method].id);
        if (TresizeAspectSettings::methodsProps[method].library == TresizeAspectSettings::LIB_SWSCALER) {
            cbxAdd(IDC_CBX_RESIZE_METHOD_CHROMA, _(IDC_CBX_RESIZE_METHOD_CHROMA, TresizeAspectSettings::methodsProps[method].name), TresizeAspectSettings::methodsProps[method].id);
        }
    }
    cbxSetCurSel(IDC_CBX_RESIZE_METHOD_LUMA, selLuma);
    cbxSetCurSel(IDC_CBX_RESIZE_METHOD_CHROMA, selChroma);
}
예제 #9
0
void TQSdecoderOptionsPage::cfg2dlg(void)
{
    // Update GUI from config
    setCheck(IDC_QS_ENABLE_TS_CORR     , cfgGet(IDFF_QS_ENABLE_TS_CORR));
    setCheck(IDC_QS_FORCE_FIELD_ORDER  , cfgGet(IDFF_QS_FORCE_FIELD_ORDER));
    setCheck(IDC_QS_ENABLE_SW_EMULATION, cfgGet(IDFF_QS_ENABLE_SW_EMULATION));
    setCheck(IDC_QS_ENABLE_DVD_DECODE  , cfgGet(IDFF_QS_ENABLE_DVD_DECODE));
    setCheck(IDC_QS_ENABLE_DI          , cfgGet(IDFF_QS_ENABLE_DI));
    setCheck(IDC_QS_FORCE_DI           , cfgGet(IDFF_QS_FORCE_DI));
    setCheck(IDC_QS_ENABLE_FULL_RATE   , cfgGet(IDFF_QS_ENABLE_FULL_RATE));

    cbxSetCurSel(IDC_QS_ENABLE_MT  , cfgGet(IDFF_QS_ENABLE_MT));
    cbxSetCurSel(IDC_QS_FIELD_ORDER, cfgGet(IDFF_QS_FIELD_ORDER));

    detail2dlg();
    denoise2dlg();
}
예제 #10
0
void Twindow::cbxTranslate(int id,const char_t **list)
{
    int sel=cbxGetCurSel(id);
    cbxClear(id);
    for (int i=0; list[i]; i++) {
        cbxAdd(id,_(id,list[i]));
    }
    cbxSetCurSel(id,sel);
}
예제 #11
0
void ToutPage::out2dlg(void)
{
    setCheck(IDC_CHB_STORE_AVI,cfgGet(IDFF_enc_storeAVI));
    setCheck(IDC_CHB_STORE_EXTERNAL,cfgGet(IDFF_enc_storeExt));
    static const int idStoreExt[]= {IDC_CBX_MUXER,IDC_BT_STORE_EXTERNAL,IDC_ED_STORE_EXTERNAL,0};
    setDlgItemText(m_hwnd,IDC_ED_STORE_EXTERNAL,cfgGetStr(IDFF_enc_storeExtFlnm));
    cbxSetCurSel(IDC_CBX_MUXER,cfgGet(IDFF_enc_muxer));
    enable(cfgGet(IDFF_enc_storeExt),idStoreExt);
}
예제 #12
0
void TsubtitlesTextPage::split2dlg()
{
    int is=cfgGet(IDFF_fontSplitting);
    setCheck(IDC_CHB_SUB_SPLIT,is);
    SetDlgItemInt(m_hwnd,IDC_ED_SUB_SPLIT_BORDER,cfgGet(IDFF_subSplitBorder),FALSE);
    static const int idBorders[]= {IDC_LBL_SUB_SPLIT_BORDER,IDC_ED_SUB_SPLIT_BORDER,IDC_LBL_SUB_SPLIT_BORDER2,0};
    enable(is,idBorders);
    cbxSetCurSel(IDC_CBX_SUB_WORDWRAP,cfgGet(IDFF_subWordWrap));
    enable(is,IDC_CBX_SUB_WORDWRAP);
}
예제 #13
0
void TsubtitlesTextPage::fix2dlg()
{
    int fix=cfgGet(IDFF_subFix);
    setCheck(IDC_CHB_SUBFIX_AP,fix&TtextFixBase::fixAP);
    setCheck(IDC_CHB_SUBFIX_IL,fix&TtextFixBase::fixIl);
    cbxSetCurSel(IDC_CBX_SUBFIX_IL,cfgGet(IDFF_subFixLang));
    enable(fix&TtextFixBase::fixIl,IDC_CBX_SUBFIX_IL);
    setCheck(IDC_CHB_SUBFIX_PUNCTUATION,fix&TtextFixBase::fixPunctuation);
    setCheck(IDC_CHB_SUBFIX_ORTOGRAPHY,fix&TtextFixBase::fixOrtography);
    int ii=cbxFindItem(IDC_CBX_SUBFIX_ORTOGRAPHY,cfgGetStr(IDFF_subFixDict),true);
    if (ii==-1) {
        ii=0;
    }
    cbxSetCurSel(IDC_CBX_SUBFIX_ORTOGRAPHY,ii);
    enable(fix&TtextFixBase::fixOrtography,IDC_CBX_SUBFIX_ORTOGRAPHY);
    setCheck(IDC_CHB_SUBFIX_CAPITAL,fix&TtextFixBase::fixCapital);
    setCheck(IDC_CHB_SUBFIX_NUMBERS,fix&TtextFixBase::fixNumbers);
    setCheck(IDC_CHB_SUBFIX_HEARING,fix&TtextFixBase::fixHearingImpaired);
}
예제 #14
0
void TlevelsPage::cfg2dlg(void)
{
    repaint(GetDlgItem(m_hwnd,IDC_BMP_LEVELS_IN ));
    repaint(GetDlgItem(m_hwnd,IDC_BMP_LEVELS_OUT));
    setCheck(IDC_CHB_LEVELS_SHOW_HISTOGRAM,cfgGet(IDFF_buildHistogram));
    setCheck(IDC_CHB_LEVELS_SHOW_HISTOGRAM_FULL,cfgGet(IDFF_levelsFullY));
    cbxSetCurSel(IDC_CBX_LEVELS_MODE,cfgGet(IDFF_levelsMode));
    levels2dlg();
    setCheck(IDC_CHB_LEVELS_INPUT_AUTO,cfgGet(IDFF_levelsInAuto));
}
예제 #15
0
void TOSDpageDec::cfg2dlg(void)
{
    pos2dlg();
    osds2dlg();
    int format = cfgGet(IDFF_OSD_userformat);
    if (cbxSetDataCurSel(IDC_CBX_OSD_USERFORMAT, format) == CB_ERR) {
        format = (int)cbxGetItemData(IDC_CBX_OSD_USERFORMAT, 0);
        cfgSet(IDFF_OSD_userformat, format);
        cbxSetCurSel(IDC_CBX_OSD_USERFORMAT, 0);
    }
}
예제 #16
0
void TquantTablesPageBase::translate(void)
{
    Twindow::translate();

    int sel=cbxGetCurSel(IDC_CBX_QUANT_TABLE);
    cbxClear(IDC_CBX_QUANT_TABLE);
    for (int i=0; matrices[i]; i++) {
        cbxAdd(IDC_CBX_QUANT_TABLE,_(IDC_CBX_QUANT_TABLE,matrices[i]));
    }
    cbxSetCurSel(IDC_CBX_QUANT_TABLE,sel==CB_ERR?0:sel);
}
예제 #17
0
void TquantTablesPageBase::cfg2dlg(void)
{
    codecId=getCodecId();
    if (codecId==CODEC_ID_H264) {
        enable(1,IDC_CBX_QUANT_TABLE);
    } else {
        enable(0,IDC_CBX_QUANT_TABLE);
        cbxSetCurSel(IDC_CBX_QUANT_TABLE,0);
    }
    table2dlg();
}
예제 #18
0
void TffdshowPageDec::fillPresetsCbx(void)
{
    int sel = cbxGetCurSel(IDC_CBX_PRESETS);
    cbxClear(IDC_CBX_PRESETS);
    for (Tpresets::iterator i = localPresets->begin(); i != localPresets->end(); i++) {
        cbxAdd(IDC_CBX_PRESETS, (*i)->presetName);
    }
    char_t presetName[MAX_PATH];
    deciD->getActivePresetName(presetName, MAX_PATH);
    cbxSetCurSel(IDC_CBX_PRESETS, cbxFindItem(IDC_CBX_PRESETS, presetName, true));
}
예제 #19
0
void TdeinterlacePageYadif::init(void)
{
    translate();

    int sel=cbxGetCurSel(IDC_CBX_YADIF_PARITY);
    cbxClear(IDC_CBX_YADIF_PARITY);
    for (int i = 0 ; TdeinterlaceSettings::yadifParitySEs[i].name ; i++)
        cbxAdd(IDC_CBX_YADIF_PARITY,
               _(IDC_CBX_YADIF_PARITY,
                 TdeinterlaceSettings::yadifParitySEs[i].name),
               TdeinterlaceSettings::yadifParitySEs[i].id);
    cbxSetCurSel(IDC_CBX_YADIF_PARITY,sel);
}
예제 #20
0
void TinPage::translate(void)
{
    TconfPageEnc::translate();

    int ii=cbxGetCurSel(IDC_CBX_INCSP);
    cbxClear(IDC_CBX_INCSP);
    cbxAdd(IDC_CBX_INCSP,_(IDC_CBX_INCSP,_l("all YUV")),FOURCC_MASK_YUV);
    cbxAdd(IDC_CBX_INCSP,_(IDC_CBX_INCSP,_l("all RGB")),FOURCC_MASK_RGB);
    for (int i=0; cspFccs[i].name; i++) {
        cbxAdd(IDC_CBX_INCSP,cspFccs[i].name,cspFccs[i].fcc);
    }
    cbxSetCurSel(IDC_CBX_INCSP,ii);
}
예제 #21
0
void TavisynthPage::cfg2dlg(void)
{
    setCheck(IDC_CHB_AVISYNTH_FFDSHOW, cfgGet(IDFF_avisynthFfdshowSource));
    cbxSetCurSel(IDC_CBX_AVISYNTH_PULLDOWN, cfgGet(IDFF_avisynthApplyPulldown));
    setCheck(IDC_CHB_AVISYNTH_YV12 , cfgGet(IDFF_avisynthInYV12));
    setCheck(IDC_CHB_AVISYNTH_YUY2 , cfgGet(IDFF_avisynthInYUY2));
    setCheck(IDC_CHB_AVISYNTH_RGB32, cfgGet(IDFF_avisynthInRGB32));
    setCheck(IDC_CHB_AVISYNTH_RGB24, cfgGet(IDFF_avisynthInRGB24));
    setCheck(IDC_CHB_AVISYNTH_BUFFER, cfgGet(IDFF_avisynthEnableBuffering));
    SetDlgItemInt(m_hwnd, IDC_ED_AVISYNTH_BUF_BACK, cfgGet(IDFF_avisynthBufferBack), false);
    SetDlgItemInt(m_hwnd, IDC_ED_AVISYNTH_BUF_AHEAD, cfgGet(IDFF_avisynthBufferAhead), false);
    setDlgItemText(m_hwnd, IDC_ED_AVISYNTH, cfgGetStr(IDFF_avisynthScript));
    enable(getCheck(IDC_CHB_AVISYNTH_BUFFER), bufferControlIDs, false);
}
예제 #22
0
void TffdshowPageDec::selectPreset(const char_t *presetName)
{
    Tpreset *oldPreset;
    deciD->getPresetPtr(&oldPreset);
    for (Tpresets::iterator i = localPresets->begin(); i != localPresets->end(); i++)
        if (stricmp(presetName, (*i)->presetName) == 0 && *i != oldPreset) {
            deciD->setPresetPtr(*i);
            presetChanged(presetName);
            cbxSetCurSel(IDC_CBX_PRESETS, int(i - localPresets->begin()));
            if (page) {
                page->cfg2dlg();
            }
            return;
        }
}
예제 #23
0
void TdlgMiscPage::tray2dlg(void)
{
    int tray = cfgGet(IDFF_trayIcon);
    if (tray) {
        int trayType = cfgGet(IDFF_trayIconType);
        setCheck(IDC_RBT_ICON_MODERN, trayType == 1);
        setCheck(IDC_RBT_ICON_CLASSIC, trayType == 2);
    } else {
        setCheck(IDC_RBT_ICON_NONE, 1);
    }
    setCheck(IDC_CHB_TRAYICONEXT, cfgGet(IDFF_trayIconExt));
    enable(tray, IDC_CHB_TRAYICONEXT);
    setCheck(IDC_CHB_STREAMSMENU, cfgGet(IDFF_streamsOptionsMenu));
    enable((filterMode & (IDFF_FILTERMODE_ENC | IDFF_FILTERMODE_VFW)) == 0, IDC_CHB_STREAMSMENU);
    cbxSetCurSel(IDC_CBX_SUBFILES_MODE, cfgGet(IDFF_streamsSubFilesMode));
}
예제 #24
0
void TdecoderOptionsPage::cfg2dlg(void)
{
    setCheck(IDC_CHB_SOFT_TELECINE, cfgGet(IDFF_softTelecine));
    if (islavc) {
        cbxSetCurSel(IDC_CBX_IDCT, cfgGet(IDFF_idct));

        int bugs = cfgGet(IDFF_workaroundBugs);
        for (int i = 0; workarounds[i].ff_bug; i++) {
            setCheck(workarounds[i].idc_chb, bugs & workarounds[i].ff_bug);
        }
        SetDlgItemInt(m_hwnd, IDC_ED_NUMTHREADS, cfgGet(IDFF_numLAVCdecThreads), FALSE);
        setCheck(IDC_CHB_H264_SKIP_ON_DELAY, cfgGet(IDFF_h264skipOnDelay));
        SetDlgItemInt(m_hwnd, IDC_ED_H264SKIP_ON_DELAY_TIME, cfgGet(IDFF_h264skipOnDelayTime), FALSE);
    }
    setCheck(IDC_CHB_DROP_ON_DELAY, cfgGet(IDFF_dropOnDelay));
    SetDlgItemInt(m_hwnd, IDC_ED_DROP_ON_DELAY_TIME, cfgGet(IDFF_dropOnDelayTime), FALSE);
}
예제 #25
0
void TffdshowPageEnc::codec2dlg(void)
{
    codecId = (AVCodecID)cfgGet(IDFF_enc_codecId);
    SendDlgItemMessage(m_hwnd, IDC_CBX_FOURCC, CB_RESETCONTENT, 0, 0);
    int cnt = cbxGetItemCount(IDC_CBX_ENCODER);
    for (int i = 0; i < cnt; i++)
        if (((Tencoder*)cbxGetItemData(IDC_CBX_ENCODER, i))->id == codecId) {
            cbxSetCurSel(IDC_CBX_ENCODER, i);
            const Tencoder *enc;
            deciE->getEncoder(codecId, &enc);
            if (enc) {
                for (Tfourccs::const_iterator f = enc->fourccs.begin(); f != enc->fourccs.end(); f++) {
                    char fccs[5] = "1234";
                    memcpy(fccs, &*f, 4);
                    if (fccs[0]) {
                        cbxAdd(IDC_CBX_FOURCC, text<char_t>(fccs), *f);
                    }
                }
                static const int idFourcc[] = {IDC_LBL_FOURCC, IDC_CBX_FOURCC, 0};
                if (cbxGetItemCount(IDC_CBX_FOURCC) == 0) {
                    enable(false, idFourcc);
                } else {
                    enable(true, idFourcc);
                    fourcc2dlg();
                }
                SendDlgItemMessage(m_hwnd, IDC_CBX_MODES, CB_RESETCONTENT, 0, 0);
                if (sup_CBR(codecId) && codecId != AV_CODEC_ID_MJPEG) {
                    cbxAdd(IDC_CBX_MODES, _(IDC_CBX_MODES, encModeNames[ENC_MODE::CBR]), ENC_MODE::CBR);
                }
                if (sup_VBR_QUAL(codecId)) {
                    cbxAdd(IDC_CBX_MODES, _(IDC_CBX_MODES, encModeNames[ENC_MODE::VBR_QUAL]), ENC_MODE::VBR_QUAL);
                }
                if (sup_VBR_QUANT(codecId)) {
                    cbxAdd(IDC_CBX_MODES, _(IDC_CBX_MODES, encModeNames[ENC_MODE::VBR_QUANT]), ENC_MODE::VBR_QUANT);
                }
                static const int idModes[] = {IDC_LBL_MODES, IDC_CBX_MODES, 0};
                enable(cbxGetItemCount(IDC_CBX_MODES) != 0, idModes);
                qmin = TcoSettings::getMinMaxQuant(codecId).first;
                qmax = TcoSettings::getMinMaxQuant(codecId).second;
                quick2dlg(true);
            }
            return;
        }
}
예제 #26
0
void TsubtitlesTextPage::min2dlg()
{
    int ismin=cfgGet(IDFF_subIsMinDuration);
    setCheck(IDC_CHB_SUB_MINDURATION,ismin);
    static const int mins[]= {IDC_CBX_SUB_MINDURATION,IDC_LBL_SUB_MINDURATION,IDC_ED_SUB_MINDURATION,IDC_LBL_SUB_MINDURATION2,0};
    enable(ismin,mins);
    int mintype=cfgGet(IDFF_subMinDurationType);
    cbxSetCurSel(IDC_CBX_SUB_MINDURATION,mintype);
    switch (mintype) {
        case 0:
            SetDlgItemInt(m_hwnd,IDC_ED_SUB_MINDURATION,cfgGet(IDFF_subMinDurationSub ),FALSE);
            break;
        case 1:
            SetDlgItemInt(m_hwnd,IDC_ED_SUB_MINDURATION,cfgGet(IDFF_subMinDurationLine),FALSE);
            break;
        case 2:
            SetDlgItemInt(m_hwnd,IDC_ED_SUB_MINDURATION,cfgGet(IDFF_subMinDurationChar),FALSE);
            break;
    }
}
예제 #27
0
파일: Cquant.cpp 프로젝트: TheRyuu/ffdshow
void TquantPage::cfg2dlg(void)
{
    int is = deciE->isQuantControlActive();

    SetDlgItemInt(m_hwnd, IDC_ED_Q_I_MIN, cfgGet(IDFF_enc_q_i_min), FALSE);
    SetDlgItemInt(m_hwnd, IDC_ED_Q_I_MAX, cfgGet(IDFF_enc_q_i_max), FALSE);
    setText(IDC_ED_I_QUANTFACTOR, _l("%.2f"), float(cfgGet(IDFF_enc_i_quant_factor) / 100.0));
    setText(IDC_ED_I_QUANTOFFSET, _l("%.2f"), float(cfgGet(IDFF_enc_i_quant_offset) / 100.0));
    static const int idIquants[] = {IDC_LBL_Q_I, IDC_ED_Q_I_MIN, IDC_ED_Q_I_MAX, 0};
    setDlgItemText(m_hwnd, IDC_LBL_Q_P, _(IDC_LBL_Q_P, _l("P frames")));
    enable(is && 1, idIquants);
    static const int idIoffset[] = {IDC_LBL_I_QUANTFACTOR, IDC_LBL_I_QUANTOFFSET, IDC_ED_I_QUANTFACTOR, IDC_ED_I_QUANTOFFSET, 0};
    enable(lavc_codec(codecId) && codecId != AV_CODEC_ID_MJPEG, idIoffset);

    bias2dlg();

    static const int idDCT[] = {IDC_LBL_DCT_ALGO, IDC_CBX_DCT_ALGO, 0};
    cbxSetCurSel(IDC_CBX_DCT_ALGO, cfgGet(IDFF_enc_dct_algo));
    enable(sup_lavcQuant(codecId), idDCT);

    qns2dlg();
}
예제 #28
0
파일: Coutsfs.cpp 프로젝트: TheRyuu/ffdshow
void ToutsfsPage::cfg2dlg(void)
{
    setCheck(IDC_CHB_PASSTHROUGH_AC3  , cfgGet(IDFF_aoutpassthroughAC3) == 1);
    setCheck(IDC_CHB_PASSTHROUGH_DTS  , cfgGet(IDFF_aoutpassthroughDTS) == 1);
    setCheck(IDC_CHB_PASSTHROUGH_TRUEHD, cfgGet(IDFF_aoutpassthroughTRUEHD) == 1);
    setCheck(IDC_CHB_PASSTHROUGH_DTSHD, cfgGet(IDFF_aoutpassthroughDTSHD) == 1);
    setCheck(IDC_CHB_PASSTHROUGH_EAC3, cfgGet(IDFF_aoutpassthroughEAC3) == 1);
    int outsfs = cfgGet(IDFF_outsfs);
    ac32dlg(outsfs);
    setCheck(IDC_CHB_OUT_PCM16  , outsfs & TsampleFormat::SF_PCM16);
    setCheck(IDC_CHB_OUT_PCM24  , outsfs & TsampleFormat::SF_PCM24);
    setCheck(IDC_CHB_OUT_PCM32  , outsfs & TsampleFormat::SF_PCM32);
    setCheck(IDC_CHB_OUT_FLOAT32, outsfs & TsampleFormat::SF_FLOAT32);
    setCheck(IDC_CHB_OUT_LPCM   , outsfs & TsampleFormat::SF_LPCM16);

    setCheck(IDC_CHB_ALWAYEXTENSIBLE, !cfgGet(IDFF_alwaysextensible));
    setCheck(IDC_CHB_ALLOWOUTSTREAM, cfgGet(IDFF_allowOutStream));
    setCheck(IDC_CHB_PASSTHROUGH_PCM_CONNECT, cfgGet(IDFF_aoutpassthroughPCMConnection) == 1);
    cbxSetCurSel(IDC_CBX_OUT_PASSTHROUGH_DEVICEID, cfgGet(IDFF_aoutpassthroughDeviceId));
    SetDlgItemInt(m_hwnd, IDC_ED_AUDIO_DELAY, cfgGet(IDFF_audio_decoder_delay), TRUE);

    connect2dlg();
}
예제 #29
0
void TdeinterlacePage::fillDeinterlacers(void)
{
    int ii = cbxGetCurSel(IDC_CBX_DEINT_METHOD);
    cbxClear(IDC_CBX_DEINT_METHOD);

    int i;
    for (i = 0; TdeinterlaceSettings::methodProps[i].name; i++)
        if (!(TdeinterlaceSettings::methodProps[i].id == TdeinterlaceSettings::FRAMERATEDOUBLER && !(Tconfig::cpu_flags & FF_CPU_MMXEXT)) && TdeinterlaceSettings::methodProps[i].id != TdeinterlaceSettings::DSCALER) {
            cbxAdd(IDC_CBX_DEINT_METHOD, _(IDC_CBX_DEINT_METHOD, TdeinterlaceSettings::methodProps[i].name), TdeinterlaceSettings::methodProps[i].cfgId);
        }

    const char_t *dscalerDir = cfgGetStr(IDFF_dscalerPath);
    if (!dscalerDir || !dscalerDir[0]) {
        dscalerstart = 0;
        return;
    }
    char_t dsmask[MAX_PATH];
    _makepath_s(dsmask, MAX_PATH, NULL, dscalerDir, _l("DI_*"), _l("dll"));
    strings dis;
    findFiles(dsmask, dis, true);
    dscalerstart = i - 1;
    diflnms.clear();
    for (strings::const_iterator di = dis.begin(); di != dis.end(); di++) {
        char_t flnm[MAX_PATH];
        extractfilename(di->c_str(), flnm);
        if (stricmp(flnm, _l("DI_Adaptive.dll")) != 0) {
            char_t diname[256];
            Tdscaler_DI didll(di->c_str(), deci, true);
            if (didll.fm) {
                tsnprintf_s(diname, countof(diname), _TRUNCATE, _l("DScaler: %s"), (const char_t*)text<char_t>(didll.fm->szName));
                cbxAdd(IDC_CBX_DEINT_METHOD, diname, 9);
                diflnms.push_back(*di);
            }
        }
    }
    cbxSetCurSel(IDC_CBX_DEINT_METHOD, ii);
}
예제 #30
0
void TffdshowPageDec::onActivate(void)
{
    cbxSetDroppedWidth(IDC_CBX_PRESETS, 340);

    Tpresets *presets;
    deciD->getPresetsPtr(&presets);
    localPresets = presets->newPresets();
    deciD->getPresets(localPresets);
    deciD->getActivePresetName(oldActivePresetName, MAX_PATH);

    TreeView_SetIndent(htv, 24);
    //TreeView_SetItemHeight(htv,26);
    TreeView_Expand(htv, htiPresets, TVE_EXPAND);
    fillPresetsCbx();
    cbxSetCurSel(IDC_CBX_PRESETS, cbxFindItem(IDC_CBX_PRESETS, oldActivePresetName, true));
    selectPreset(oldActivePresetName);
    CRect rp;
    GetWindowRect(m_hwnd, &rp);
    CRect rc;
    GetWindowRect(htv, &rc);
    tvx = rc.left - rp.left;
    tvy = rc.top - rp.top;
    deciD->setOnNewFiltersMsg(m_hwnd, WM_FFONNEWFILTERS);
}