BOOL CBaseRecordsDlg::Create(CWnd* pParentWnd, CPoint ptWnd) { if (!CDialog::Create(IDD, pParentWnd)) return FALSE; CRect rectTemp; INT nFirstColumn; // Move window GetWindowRect(&rectTemp); rectTemp.MoveToXY(ptWnd); MoveWindow(&rectTemp); // Init m_gridRecord m_gridRecord.GetClientRect(rectTemp); nFirstColumn = (rectTemp.Width() - ::GetSystemMetrics(SM_CXVSCROLL)) - (COLUMN_COUNT - 1) * COLUMN_WHIDTH; for (INT i = 0; i < COLUMN_COUNT; i++) { m_gridRecord.InsertColumn(i, m_strColumns[i], LVCFMT_CENTER, i ? COLUMN_WHIDTH : nFirstColumn); } m_gridRecord.SetGridLines(TRUE, RGB(0, 0, 128)); m_gridRecord.SetResizing(FALSE); m_gridRecord.SetSortable(TRUE); m_gridRecord.SetShowSel(TRUE); // Init Filters SetFilters(FALSE); m_nFilterID = NO_FILTER_ID; // Show records ShowRecords(); // Show window ShowWindow(SW_SHOW); return TRUE; }
static void RunUI(Port &port, OperationEnvironment &env) { WriteMenu(); while (true) { fprintf(stdout, "> "); char in[20]; if (fgets(in, 20, stdin) == NULL || strlen(in) == 0) { fprintf(stdout, "Invalid input\n"); continue; } switch (in[0]) { case '?': case 'h': case 'H': WriteMenu(); break; case '1': SetMC(port, env); break; case '2': SetBallast(port, env); break; case '3': SetBugs(port, env); break; case '4': SetAltitudeOffset(port, env); break; case '5': SetQNH(port, env); break; case '6': SetVolume(port, env); break; case 'p': case 'P': SetPolar(port, env); break; case 'f': case 'F': SetFilters(port, env); break; case 's': case 'S': SetSCSettings(port, env); break; case 'q': case 'Q': fprintf(stdout, "Closing LX1600 Utils ...\n"); return; default: fprintf(stdout, "Invalid input\n"); break; } } }
void CBaseRecordsDlg::RemoveRecord() { int nInd = m_gridRecord.GetCurSel(); if (nInd == -1) return; if (IDNO == AfxMessageBox(IDS_PROMPT_REMOVE, MB_YESNO|MB_ICONQUESTION)) return; CFlashRecord* pRecord = (CFlashRecord*)m_gridRecord.GetItemData(nInd); m_database.RemoveRecord(pRecord); SetFilters(); ShowRecords(); delete pRecord; }
void MFolderFromProfile::RemoveFilter(const String& filter) { wxArrayString filters = GetFilters(); int n = filters.Index(filter); if ( n != wxNOT_FOUND ) { filters.RemoveAt(n); SetFilters(filters); } }
void CBaseRecordsDlg::EditRecord() { int nInd = m_gridRecord.GetCurSel(); if (nInd == -1) return; CFlashRecord* pRecord = (CFlashRecord*)m_gridRecord.GetItemData(nInd); CRecordEditDlg dlg(this, m_database, FALSE); dlg.m_FlashRecord.Copy(pRecord); if (IDOK != dlg.DoModal()) return; pRecord->Copy(&dlg.m_FlashRecord); SetFilters(); ShowRecords(); }
CFlashRecord* CBaseRecordsDlg::AddRecord(CFlashRecord* pRecord) { CRecordEditDlg dlg(this, m_database, TRUE); if (pRecord) dlg.m_FlashRecord.Copy(pRecord); if (IDOK != dlg.DoModal()) return NULL; CFlashRecord* pRecordNew = new CFlashRecord(m_database); pRecordNew->Copy(&dlg.m_FlashRecord); m_database.AddRecord(pRecordNew); SetFilters(); ShowRecords(); return pRecordNew; }
// init filter list from resource string BOOL CFileFilter::SetFilters(int nSize, const UINT *filters) { if(nSize<1) return FALSE; int ii, jj; CString *strings= new CString[nSize]; for(ii=0, jj=0; ii<nSize; ii++) { if(strings[jj].LoadString(filters[ii])) jj++; } SetFilters(jj, strings); delete[] strings; return (jj>0); }
DDE::DDE(HINSTANCE hInst, const char *server, const char *topic, DDECALLBACK CallBack, DWORD filters) : _idInst(0), _CallBack(NULL), _bResult(FALSE) { // Set callback function and filters from passed-in parameters if (!SetCallBack(hInst, CallBack)) return; SetFilters(filters); if (!Initialize()) // sets _bResult; { _idInst = 0; return; } _hServer = CreateStrHandle(server); _hTopic = CreateStrHandle(topic); }
BiQuadFilterBank::BiQuadFilterBank(const BiQuadFilterBank& obj) : nchannels(0) { // duplicate passed object include audio state SetChannels(obj.nchannels); SetFilters((uint_t)obj.filters.size()); uint_t i, j; for (i = 0; i < filters.size(); i++) { const FILTER& srcfilter = *obj.filters[i]; FILTER& dstfilter = *filters[i]; // copy filter coeffs and interpolation state dstfilter.coeffs = srcfilter.coeffs; for (j = 0; j < srcfilter.channels.size(); j++) { // copy audio state dstfilter.channels[j].CopyAudioState(srcfilter.channels[j]); } } }
int CDVDVideoCodecFFmpeg::Decode(uint8_t* pData, int iSize, double dts, double pts) { int iGotPicture = 0, len = 0; if (!m_pCodecContext) return VC_ERROR; if (pData) m_iLastKeyframe++; if (m_pHardware) { int result; if (pData || (m_codecControlFlags & DVD_CODEC_CTRL_DRAIN)) { result = m_pHardware->Check(m_pCodecContext); result &= ~VC_NOBUFFER; } else { result = m_pHardware->Decode(m_pCodecContext, nullptr); } if (result) return result; } if (!m_pHardware && pData) SetFilters(); if (m_pFilterGraph && !m_filterEof) { int result = 0; if (pData == NULL) result = FilterProcess(nullptr); if (m_codecControlFlags & DVD_CODEC_CTRL_DRAIN) { result &= VC_PICTURE; } if (result) return result; } m_dts = dts; m_pCodecContext->reordered_opaque = pts_dtoi(pts); AVPacket avpkt; av_init_packet(&avpkt); avpkt.data = pData; avpkt.size = iSize; avpkt.dts = (dts == DVD_NOPTS_VALUE) ? AV_NOPTS_VALUE : dts / DVD_TIME_BASE * AV_TIME_BASE; avpkt.pts = (pts == DVD_NOPTS_VALUE) ? AV_NOPTS_VALUE : pts / DVD_TIME_BASE * AV_TIME_BASE; /* We lie, but this flag is only used by pngdec.c. * Setting it correctly would allow CorePNG decoding. */ avpkt.flags = AV_PKT_FLAG_KEY; len = avcodec_decode_video2(m_pCodecContext, m_pDecodedFrame, &iGotPicture, &avpkt); if (m_decoderState == STATE_HW_FAILED && !m_pHardware) return VC_REOPEN; if(m_iLastKeyframe < m_pCodecContext->has_b_frames + 2) m_iLastKeyframe = m_pCodecContext->has_b_frames + 2; if (len < 0) { if(m_pHardware) { int result = m_pHardware->Check(m_pCodecContext); if (result & VC_NOBUFFER) { result = m_pHardware->Decode(m_pCodecContext, NULL); return result; } } CLog::Log(LOGERROR, "%s - avcodec_decode_video returned failure", __FUNCTION__); return VC_ERROR; } if (!iGotPicture) { if (pData && m_pCodecContext->skip_frame > AVDISCARD_DEFAULT) { m_droppedFrames++; if (m_interlaced) m_droppedFrames++; } if (m_pHardware && (m_codecControlFlags & DVD_CODEC_CTRL_DRAIN)) { int result; result = m_pHardware->Decode(m_pCodecContext, NULL); return result; } else return VC_BUFFER; } if (m_pDecodedFrame->key_frame) { m_started = true; m_iLastKeyframe = m_pCodecContext->has_b_frames + 2; } if (m_pDecodedFrame->interlaced_frame) m_interlaced = true; else m_interlaced = false; /* put a limit on convergence count to avoid huge mem usage on streams without keyframes */ if (m_iLastKeyframe > 300) m_iLastKeyframe = 300; /* h264 doesn't always have keyframes + won't output before first keyframe anyway */ if(m_pCodecContext->codec_id == AV_CODEC_ID_H264 || m_pCodecContext->codec_id == AV_CODEC_ID_SVQ3) m_started = true; if (m_pHardware == nullptr) { bool need_scale = std::find( m_formats.begin() , m_formats.end() , m_pCodecContext->pix_fmt) == m_formats.end(); bool need_reopen = false; if (m_filters != m_filters_next) need_reopen = true; if (!m_filters_next.empty() && m_filterEof) need_reopen = true; if (m_pFilterIn) { if (m_pFilterIn->outputs[0]->format != m_pCodecContext->pix_fmt || m_pFilterIn->outputs[0]->w != m_pCodecContext->width || m_pFilterIn->outputs[0]->h != m_pCodecContext->height) need_reopen = true; } // try to setup new filters if (need_reopen || (need_scale && m_pFilterGraph == nullptr)) { m_filters = m_filters_next; if (FilterOpen(m_filters, need_scale) < 0) FilterClose(); } } int result; if (m_pHardware) { av_frame_unref(m_pFrame); av_frame_move_ref(m_pFrame, m_pDecodedFrame); result = m_pHardware->Decode(m_pCodecContext, m_pFrame); } else if (m_pFilterGraph && !m_filterEof) { result = FilterProcess(m_pDecodedFrame); } else { av_frame_unref(m_pFrame); av_frame_move_ref(m_pFrame, m_pDecodedFrame); result = VC_PICTURE | VC_BUFFER; } if (m_codecControlFlags & DVD_CODEC_CTRL_DRAIN) result &= ~VC_BUFFER; if (result & VC_FLUSHED) Reset(); return result; }
int main(){ auto pLogger = CB::Log::CLogger::GetInstance(); pLogger->AddStream(CB::IO::File::Open(L"main.log", CB::IO::File::AccessType::WriteOnly, CB::IO::File::OpenAction::AlwaysCreate).Cast<CB::IO::IStream>()); pLogger->AddStream(CB::IO::Console::Create().Cast<CB::IO::IStream>(), CB::Log::CTextFormatter::Create(CB::String::Encoding::ANSI).Cast<CB::Log::IEntryFormatter>()); pLogger->SetDebugMode(true); try{ auto pWinDriver = CB::Window::LoadDriver(L"MSWindowDriver"); auto pGraphicDriver = CB::Graphic::LoadDriver(L"OGLGraphicDriver"); { auto pWinManager = pWinDriver->CreateManager(); auto pGraphicManager = pGraphicDriver->CreateManager(pWinManager); CB::Math::CSize outSize(640, 480); auto pWindow = pWinManager->CreateWindow(L"GraphicTest", CB::Window::Style::Single, outSize); auto pGraphicAdapter = pGraphicManager->GetDefaultAdapter(); CB::Graphic::CDisplayMode dispMode(pWindow->GetSize(), 0, CB::Graphic::BufferFormat::B8G8R8X8); CB::Graphic::CDeviceDesc devDesc(pWindow, dispMode, CB::Graphic::BufferFormat::D24S8, false); CB::Collection::CList<CB::Graphic::FeatureLevel> featureLevels; featureLevels.Add(CB::Graphic::FeatureLevel::Level_1); auto pGraphicDevice = pGraphicAdapter->CreateDevice(pWindow, devDesc, featureLevels); pWindow->OnClose += CB::Signals::CFunc<const bool, CB::CRefPtr<CB::Window::IWindow>>(CloseEvent); pWindow->SetVisible(true); CB::Graphic::CDepthStencilStateDesc depthDesc; depthDesc.bDepthTestEnabled = true; depthDesc.uDepthFunction = CB::Graphic::CompareFunc::LessEqual; auto pDepthState = pGraphicDevice->CreateState(depthDesc); pGraphicDevice->SetState(pDepthState.Cast<CB::Graphic::IDeviceState>()); CB::Graphic::CRasterizerStateDesc rastDesc; rastDesc.uCullMode = CB::Graphic::CullMode::None; auto pRastState = pGraphicDevice->CreateState(rastDesc); pGraphicDevice->SetState(pRastState.Cast<CB::Graphic::IDeviceState>()); CB::Graphic::CBlendStateDesc blendDesc; blendDesc.ColorBlend.uDestOperand = CB::Graphic::BlendOption::OneMinusSourceAlpha; blendDesc.ColorBlend.uSourceOperand = CB::Graphic::BlendOption::SourceAlpha; blendDesc.ColorBlend.uOperation = CB::Graphic::BlendOperation::Add; blendDesc.AlphaBlend.uDestOperand = CB::Graphic::BlendOption::OneMinusSourceAlpha; blendDesc.AlphaBlend.uSourceOperand = CB::Graphic::BlendOption::SourceAlpha; blendDesc.AlphaBlend.uOperation = CB::Graphic::BlendOperation::Add; blendDesc.bEnabled[0] = true; auto pBlendState = pGraphicDevice->CreateState(blendDesc); pGraphicDevice->SetState(pBlendState.Cast<CB::Graphic::IDeviceState>()); auto pFontManager = CB::Font::CManager::Create(); auto pFontStream = CB::IO::File::Open(L"Assets/font.ttf").Cast<CB::IO::IStream>(); auto pFont = pFontManager->Load(pFontStream); pFont->SelectFace(0); pFont->SetSize(24); CB::Collection::CList<CB::Tools::CFontCharDesc> charDescs; CB::Tools::CFontTextureGenerator fontGen(pGraphicDevice); fontGen.MaxTextureSize.Set(512, 512); auto pTexture = fontGen.Generate(pFont, charDescs); CB::Tools::CTextMeshGenerator textGen(charDescs); CB::Tools::CMeshRawIVT textMesh; textGen.Generate(L"Marek M³ynarski!", textMesh); CB::Collection::CList<CB::Graphic::CVertexElement> vEls; vEls.Add(CB::Graphic::CVertexElement(0, L"vinput.vPosition", CB::Graphic::VertexType::Float, 3, 0)); vEls.Add(CB::Graphic::CVertexElement(1, L"vinput.vTexCoord", CB::Graphic::VertexType::Float, 2, 0)); GraphicTest::CShaderLoader shaders(pGraphicDevice, L"Shaders/TextureShader.cg"); auto pTextDecl = pGraphicDevice->CreateVertexDeclaration(shaders.pVertexShader, vEls); auto pTextVertexBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Vertex, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.Vertices); auto pTextTCoordBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Vertex, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.TexCoords); auto pTextIndexBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Index, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.Indices); float32 fAspect = (float32)outSize.Width / (float32)outSize.Height; CB::Math::CMatrix mProj = CB::Math::CMatrix::GetPerspective(fAspect, 60.0f, 1.0f, 100.0f); CB::Math::CMatrix mView = CB::Math::CMatrix::GetTranslation(-4.0f, 0.0f, -3.4f); CB::Math::CMatrix mModel = CB::Math::CMatrix::GetIdentity(); shaders.pFragmentShader->SetSampler(L"texDiffuse", pTexture.Cast<CB::Graphic::IBaseTexture>()); pTexture->SetFilters(CB::Graphic::TextureFilter::Linear, CB::Graphic::TextureFilter::Linear, CB::Graphic::TextureFilter::Linear); pTexture->SetAnisotropy(8); //g_pTexture = texture.pTexture; while(g_bRun){ pGraphicDevice->Clear(1.0f, 1); pGraphicDevice->Clear(CB::Math::CColor(1.0f, 0.5f, 0.0f, 1.0f)); pGraphicDevice->BeginRender(); pGraphicDevice->SetShader(shaders.pVertexShader); pGraphicDevice->SetShader(shaders.pFragmentShader); static float32 fV = 0.0f; fV += 20 * g_Timer.GetTimeDelta(); mModel = CB::Math::CMatrix::GetRotation(CB::Math::AxisOrientation::AxisX, fV); shaders.pVertexShader->SetUniform(L"vinput.mProj", mProj); shaders.pVertexShader->SetUniform(L"vinput.mView", mView); shaders.pVertexShader->SetUniform(L"vinput.mModel", mModel); pGraphicDevice->SetVertexDeclaration(pTextDecl); pGraphicDevice->SetVertexBuffer(0, pTextVertexBuffer); pGraphicDevice->SetVertexBuffer(1, pTextTCoordBuffer); pGraphicDevice->SetIndexBuffer(pTextIndexBuffer); pGraphicDevice->RenderIndexed(textMesh.uNumberOfPolygons); pGraphicDevice->EndRender(); g_Timer.Update(); pWinManager->ProcessEvents(); float fFPS = 1.0f / (g_Timer.GetTimeDelta() == 0.0f ? 1.0f : g_Timer.GetTimeDelta()); uint32 uFPS = (uint32)fFPS; textMesh.Clear(); textGen.Generate(L"FPS: " + CB::String::ToString(uFPS), textMesh); pTextVertexBuffer->LoadData(textMesh.Vertices); pTextTCoordBuffer->LoadData(textMesh.TexCoords); pTextIndexBuffer->LoadData(textMesh.Indices); pGraphicDevice->Swap(); } g_pTexture.Release(); } } catch(CB::Exception::CException& Exception){ CB::Log::Write(Exception, CB::Log::LogLevel::Fatal); CB::Message::Show(Exception, CB::Message::Icon::Error); } return 0; }
CDVDVideoCodec::VCReturn CDVDVideoCodecFFmpeg::GetPicture(VideoPicture* pVideoPicture) { if (m_eof) { return VC_EOF; } // handle hw accelerators first, they may have frames ready if (m_pHardware) { int flags = m_codecControlFlags; flags &= ~DVD_CODEC_CTRL_DRAIN; m_pHardware->SetCodecControl(flags); CDVDVideoCodec::VCReturn ret = m_pHardware->Decode(m_pCodecContext, nullptr); if (ret == VC_PICTURE) { if (m_pHardware->GetPicture(m_pCodecContext, pVideoPicture)) return VC_PICTURE; else return VC_ERROR; } else if (ret == VC_BUFFER) ; else return ret; } else if (m_pFilterGraph && !m_filterEof) { CDVDVideoCodec::VCReturn ret = FilterProcess(nullptr); if (ret == VC_PICTURE) { if (!SetPictureParams(pVideoPicture)) return VC_ERROR; return VC_PICTURE; } else if (ret == VC_BUFFER) ; else return ret; } // process ffmpeg if (m_codecControlFlags & DVD_CODEC_CTRL_DRAIN) { AVPacket avpkt; av_init_packet(&avpkt); avpkt.data = nullptr; avpkt.size = 0; avpkt.dts = AV_NOPTS_VALUE; avpkt.pts = AV_NOPTS_VALUE; avcodec_send_packet(m_pCodecContext, &avpkt); } int ret = avcodec_receive_frame(m_pCodecContext, m_pDecodedFrame); if (m_decoderState == STATE_HW_FAILED && !m_pHardware) return VC_REOPEN; if(m_iLastKeyframe < m_pCodecContext->has_b_frames + 2) m_iLastKeyframe = m_pCodecContext->has_b_frames + 2; if (ret == AVERROR_EOF) { // next drain hw accel or filter if (m_pHardware) { int flags = m_codecControlFlags; flags |= DVD_CODEC_CTRL_DRAIN; m_pHardware->SetCodecControl(flags); int ret = m_pHardware->Decode(m_pCodecContext, nullptr); if (ret == VC_PICTURE) { if (m_pHardware->GetPicture(m_pCodecContext, pVideoPicture)) return VC_PICTURE; else return VC_ERROR; } else { m_eof = true; CLog::Log(LOGDEBUG, "CDVDVideoCodecFFmpeg::GetPicture - eof hw accel"); return VC_EOF; } } else if (m_pFilterGraph && !m_filterEof) { int ret = FilterProcess(nullptr); if (ret == VC_PICTURE) { if (!SetPictureParams(pVideoPicture)) return VC_ERROR; else return VC_PICTURE; } else { m_eof = true; CLog::Log(LOGDEBUG, "CDVDVideoCodecFFmpeg::GetPicture - eof filter"); return VC_EOF; } } else { m_eof = true; CLog::Log(LOGDEBUG, "CDVDVideoCodecFFmpeg::GetPicture - eof"); return VC_EOF; } } else if (ret == AVERROR(EAGAIN)) { return VC_BUFFER; } else if (ret) { CLog::Log(LOGERROR, "%s - avcodec_receive_frame returned failure", __FUNCTION__); return VC_ERROR; } // here we got a frame int64_t framePTS = m_pDecodedFrame->best_effort_timestamp; if (m_pCodecContext->skip_frame > AVDISCARD_DEFAULT) { if (m_dropCtrl.m_state == CDropControl::VALID && m_dropCtrl.m_lastPTS != AV_NOPTS_VALUE && framePTS != AV_NOPTS_VALUE && framePTS > (m_dropCtrl.m_lastPTS + m_dropCtrl.m_diffPTS * 1.5)) { m_droppedFrames++; if (m_interlaced) m_droppedFrames++; } } m_dropCtrl.Process(framePTS, m_pCodecContext->skip_frame > AVDISCARD_DEFAULT); if (m_pDecodedFrame->key_frame) { m_started = true; m_iLastKeyframe = m_pCodecContext->has_b_frames + 2; } if (m_pDecodedFrame->interlaced_frame) m_interlaced = true; else m_interlaced = false; if (!m_started) { int frames = 300; if (m_dropCtrl.m_state == CDropControl::VALID) frames = static_cast<int>(6000000 / m_dropCtrl.m_diffPTS); if (m_iLastKeyframe >= frames && m_pDecodedFrame->pict_type == AV_PICTURE_TYPE_I) { m_started = true; } else { av_frame_unref(m_pDecodedFrame); return VC_BUFFER; } } // push the frame to hw decoder for further processing if (m_pHardware) { av_frame_unref(m_pFrame); av_frame_move_ref(m_pFrame, m_pDecodedFrame); CDVDVideoCodec::VCReturn ret = m_pHardware->Decode(m_pCodecContext, m_pFrame); if (ret == VC_FLUSHED) { Reset(); return ret; } else if (ret == VC_FATAL) { m_decoderState = STATE_HW_FAILED; return VC_REOPEN; } else if (ret == VC_PICTURE) { if (m_pHardware->GetPicture(m_pCodecContext, pVideoPicture)) return VC_PICTURE; else return VC_ERROR; } return ret; } // process filters for sw decoding else { SetFilters(); bool need_scale = std::find(m_formats.begin(), m_formats.end(), m_pCodecContext->pix_fmt) == m_formats.end(); bool need_reopen = false; if (m_filters != m_filters_next) need_reopen = true; if (!m_filters_next.empty() && m_filterEof) need_reopen = true; if (m_pFilterIn) { if (m_pFilterIn->outputs[0]->format != m_pCodecContext->pix_fmt || m_pFilterIn->outputs[0]->w != m_pCodecContext->width || m_pFilterIn->outputs[0]->h != m_pCodecContext->height) need_reopen = true; } // try to setup new filters if (need_reopen || (need_scale && m_pFilterGraph == nullptr)) { m_filters = m_filters_next; if (FilterOpen(m_filters, need_scale) < 0) FilterClose(); } if (m_pFilterGraph && !m_filterEof) { CDVDVideoCodec::VCReturn ret = FilterProcess(m_pDecodedFrame); if (ret != VC_PICTURE) return VC_NONE; } else { av_frame_unref(m_pFrame); av_frame_move_ref(m_pFrame, m_pDecodedFrame); } if (!SetPictureParams(pVideoPicture)) return VC_ERROR; else return VC_PICTURE; } return VC_NONE; }
void MFolderFromProfile::AddFilter(const String& filter) { wxArrayString filters = GetFilters(); filters.Add(filter); SetFilters(filters); }
void MFolderFromProfile::PrependFilter(const String& filter) { wxArrayString filters = GetFilters(); filters.Insert(filter, 0); SetFilters(filters); }
BiQuadFilterBank::~BiQuadFilterBank() { // delete all filters SetFilters(0); }