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);
}
