HRESULT CKCamStream::CheckMediaType(const CMediaType *pMediaType) { // The CheckMediaType method determines if the pin accepts a specific media type. // MSDN says to "Only accept the preferred media type (See SetFormat for more information)" // but there applications that call CheckMediaType with a different media type than they call SetFormat (e.g. Flash in Chrome) // => we just check some crucial parameters of the requested media type match with something we offer DbgLog((LOG_TRACE, 1, "CheckMediaType")); if (!m_device) return E_FAIL; DECLARE_PTR(VIDEOINFOHEADER, f_pvi, pMediaType->pbFormat); DbgLog((LOG_TRACE, 1, "... CheckMediaType (%dx%dx%d)", f_pvi->bmiHeader.biWidth, f_pvi->bmiHeader.biHeight, f_pvi->bmiHeader.biBitCount)); CAutoLock f_lock(m_pFilter->pStateLock()); // XXX not needed anymore ? bool f_ok = false; for (int f_idx = 0; !f_ok && f_idx < m_device->video_resolution_count(); ++f_idx) { auto f_res = m_device->video_resolution(f_idx); f_ok = (f_res.m_width == f_pvi->bmiHeader.biWidth && f_res.m_height == abs(f_pvi->bmiHeader.biHeight) && f_res.m_bits_per_pixel == f_pvi->bmiHeader.biBitCount && CompressionFromPixelFormat(f_res.m_pixel_format) == f_pvi->bmiHeader.biCompression); } DbgLog((LOG_TRACE, 1, "... CheckMediaType (%s)", (f_ok) ? "OK" : "NOK")); return (f_ok) ? S_OK : E_INVALIDARG; }
virtual void OnDisable() override { if (f != nullptr) { std::lock_guard<std::mutex> f_lock(m_file); fflush(f); fclose(f); f = nullptr; } }
virtual void OnEnable() override { if (f == nullptr) { std::lock_guard<std::mutex> f_lock(m_file); f = fopen("soundmem.log", "w"); if (f == nullptr) { Warning("Failed to open soundmem.log: errno = %d:\n%s\n", errno, strerror(errno)); } else { Msg("Opened soundmem.log\n"); } } }
/// Lockt #mtx und #file_mtx und löscht dann den Inhalt von #file void reset() { lock_guard lock ( mtx ); file_mtx_lock f_lock ( file_mtx ); alle_nutzer.clear(); file.remove(); }
/// Lockt #mtx und #file_mtx, ruft einlesen() auf und gibt dann *this zurück NutzerVerwaltung& aktualisieren() { lock_guard lock ( mtx ); sharable_file_mtx_lock f_lock ( file_mtx ); einlesen(); return *this; }
int LargeTableBase::RefreshNearest(int colid, int value, bool top) { SQLiteValuePair constrain; set<string> results; SQLiteValuePair returnResults; int currentTable; int save_currentTable = -1; int save_currentIndex = -1; bool found = false; int left, right; int leftindex, rightindex, saveleft, saveright; if(colid >= m_colnum) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest invalid colid."); return -1; } const SQLiteColumn &col = m_col[colid]; if(col.GetType() != ENUM_SQLite_COLUMN_INTEGER) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest col must be integer."); return -1; } results.clear(); file_lock f_lock(m_file_lock.c_str()); scoped_lock<file_lock> e_lock(f_lock); if(m_schemaColNum < m_maxrownum) { if(m_maxrownum - m_schemaColNum < LARGE_TABLE_OVERHEAD) { int tmpIndex = LARGE_TABLE_OVERHEAD - (m_maxrownum - m_schemaColNum); leftindex = tmpIndex % m_unitrownum; left = tmpIndex / m_unitrownum; } else { left = 0; leftindex = 0; } right = m_schemaCurrentTable; rightindex = m_schemaCurrentIndex; } else { left = m_schemaCurrentTable; leftindex = m_schemaCurrentIndex; leftindex += LARGE_TABLE_OVERHEAD; left += (leftindex / m_unitrownum); leftindex %= m_unitrownum; if(left >= m_tablenum) { left -= m_tablenum; } right = m_schemaCurrentTable; rightindex = m_schemaCurrentIndex; } saveleft = left; saveright = right; m_values.clear(); while(!found) { if(left <= right) { currentTable = (left + right) / 2; } else { int distance = m_tablenum - (left - right); currentTable = right - (distance / 2); if(currentTable < 0) { currentTable += m_tablenum; } } LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest left %d, right %d, current %d.", left, right, currentTable); SQLiteTable table(GetExactDbFullName(currentTable), m_tableName + numToString<int>(currentTable), m_unitrownum); SetTable(table); if(table.Open() < 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest open table failed."); return -1; } constrain.clear(); constrain.insert(SQLiteValuePair::value_type(col.GetHead(), value)); if(m_schemaColNum >= m_maxrownum) { if((top) && (currentTable == saveright)) { constrain.insert(SQLiteValuePair::value_type(LARGE_TABLE_COL_INDEX, rightindex)); } else if((!top) && (currentTable == saveleft)) { constrain.insert(SQLiteValuePair::value_type(LARGE_TABLE_COL_INDEX, leftindex)); } } int ret = table.QueryNearest(LARGE_TABLE_COL_INDEX, constrain, results, returnResults, top); table.Close(); if(ret < 0) { if(top) { if(left == currentTable) { if(m_values.size()) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest value found 1."); found = true; break; } else { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest reach left and no value found."); break; } } right = currentTable - 1; if(right < 0) { right = m_tablenum - 1; } } else { if(right == currentTable) { if(m_values.size()) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest value found 2."); found = true; break; } else { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest reach right and no value found."); break; } } left = currentTable + 1; if(left >= m_tablenum) { left = 0; } } } else { int index = GetSQLiteValueInt(returnResults[LARGE_TABLE_COL_INDEX]); m_values = returnResults; save_currentTable = currentTable; save_currentIndex = index; if(top) { if(index >= (m_unitrownum - 1)) { if(right == currentTable) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest value found 3."); found = true; break; } left = currentTable + 1; if(left >= m_tablenum) { left = 0; } } else { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest value found 4."); found = true; break; } } else { if(index <= 0) { if(left == currentTable) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest value found 5."); found = true; break; } right = currentTable - 1; if(right < 0) { right = m_tablenum - 1; } } else { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest value found 6."); found = true; break; } } } } if(!found) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest find nothing."); return -1; } if(top) { if((saveleft == save_currentTable) && (save_currentIndex < leftindex)) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest left side beyond the overhead."); return -1; } if((saveright == save_currentTable) && (save_currentIndex > rightindex)) { LogUtility::Log(LOG_LEVEL_INFO, "LargeTableBase::RefreshNearest align the right index."); save_currentIndex = rightindex; } if(m_schemaColNum < m_maxrownum) { if(m_maxrownum - m_schemaColNum < LARGE_TABLE_OVERHEAD) { int tmpIndex = LARGE_TABLE_OVERHEAD - (m_maxrownum - m_schemaColNum); m_queryCurrentIndex = tmpIndex % m_unitrownum; m_queryCurrentTable = tmpIndex / m_unitrownum; } else { m_queryCurrentIndex = 0; m_queryCurrentTable = 0; } } else { m_queryCurrentTable = m_schemaCurrentTable; m_queryCurrentIndex = m_schemaCurrentIndex; m_queryCurrentIndex += LARGE_TABLE_OVERHEAD; m_queryCurrentTable += (m_queryCurrentIndex / m_unitrownum); m_queryCurrentIndex %= m_unitrownum; if(m_queryCurrentTable >= m_tablenum) { m_queryCurrentTable -= m_tablenum; } } } else { if((saveleft == save_currentTable) && (save_currentIndex < leftindex)) { LogUtility::Log(LOG_LEVEL_INFO, "LargeTableBase::RefreshNearest align the left index."); save_currentIndex = leftindex; } if((saveright == save_currentTable) && (save_currentIndex > rightindex)) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshNearest right side beyond the overhead."); return -1; } m_queryCurrentTable = m_schemaCurrentTable; m_queryCurrentIndex = m_schemaCurrentIndex; } return save_currentTable * m_unitrownum + save_currentIndex; }
int LargeTableBase::RefreshPrevious(int nowIndex, int topIndex) { set<string> results; int currentTable; int currentIndex; int min, max; bool invalid_flag = false; file_lock f_lock(m_file_lock.c_str()); scoped_lock<file_lock> e_lock(f_lock); if(m_schemaColNum < m_maxrownum) { if(topIndex > nowIndex) { invalid_flag = true; } } else { if((topIndex > nowIndex) && (topIndex < m_schemaCurrentTable * m_unitrownum + m_schemaCurrentIndex)) { invalid_flag = true; } else if((topIndex < m_schemaCurrentTable * m_unitrownum + m_schemaCurrentIndex) && (nowIndex > m_schemaCurrentTable * m_unitrownum + m_schemaCurrentIndex)) { invalid_flag = true; } } if(invalid_flag) { LogUtility::Log(LOG_LEVEL_INFO, "LargeTableBase::RefreshPrevious invalid topindex(%d, %d, %d, %d).", topIndex, nowIndex, m_schemaCurrentTable, m_schemaCurrentIndex); return -1; } currentTable = nowIndex / m_unitrownum; currentIndex = nowIndex % m_unitrownum; if((currentTable == m_queryCurrentTable) && (currentIndex == m_queryCurrentIndex)) { LogUtility::Log(LOG_LEVEL_INFO, "LargeTableBase::RefreshPrevious query results end(%d, %d, %d, %d).", currentTable, currentIndex, m_queryCurrentTable, m_queryCurrentIndex); return -1; } if(currentIndex > 0) { currentIndex --; } else { currentIndex = m_unitrownum - 1; if(currentTable > 0) { currentTable --; } else { currentTable = m_tablenum - 1; } } if(m_schemaColNum < m_maxrownum) { if((currentTable * m_unitrownum + currentIndex) > (m_schemaCurrentTable * m_unitrownum + m_schemaCurrentIndex)) { LogUtility::Log(LOG_LEVEL_INFO, "LargeTableBase::RefreshPrevious index beyond table end(%d, %d, %d, %d).", currentTable, currentIndex, m_schemaCurrentTable, m_schemaCurrentIndex); return -1; } } max = currentIndex; if(topIndex >= currentTable * m_unitrownum) { min = topIndex - currentTable * m_unitrownum; } else { min = 0; } if(min >= m_unitrownum) { min = 0; } else if(min > max) { LogUtility::Log(LOG_LEVEL_INFO, "LargeTableBase::RefreshPrevious min exceed max(%d, %d).", min, max); return -1; } SQLiteTable table(GetExactDbFullName(currentTable), m_tableName + numToString<int>(currentTable), m_unitrownum); SetTable(table); if(table.Open() < 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshPrevious open table failed."); return -1; } m_values.clear(); results.clear(); m_returnResults.clear(); if(table.QueryBetween(LARGE_TABLE_COL_INDEX, min, max, results, m_returnResults, false)) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshPrevious query failed."); table.Close(); return -1; } table.Close(); if(m_returnResults.size() <= 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshPrevious query results invalid."); return -1; } return currentTable * m_unitrownum + min; }
int LargeTableBase::RefreshPrevious(int nowIndex) { SQLiteValuePair constrain; set<string> results; set<SQLiteValuePair> returnResults; int currentTable; int currentIndex; file_lock f_lock(m_file_lock.c_str()); scoped_lock<file_lock> e_lock(f_lock); currentTable = nowIndex / m_unitrownum; currentIndex = nowIndex % m_unitrownum; if((currentTable == m_queryCurrentTable) && (currentIndex == m_queryCurrentIndex)) { LogUtility::Log(LOG_LEVEL_INFO, "LargeTableBase::RefreshPrevious query results end(%d, %d, %d, %d).", currentTable, currentIndex, m_queryCurrentTable, m_queryCurrentIndex); return -1; } if(currentIndex > 0) { currentIndex --; } else { currentIndex = m_unitrownum - 1; if(currentTable > 0) { currentTable --; } else { currentTable = m_tablenum - 1; } } if(m_schemaColNum < m_maxrownum) { if((currentTable * m_unitrownum + currentIndex) > (m_schemaCurrentTable * m_unitrownum + m_schemaCurrentIndex)) { LogUtility::Log(LOG_LEVEL_INFO, "LargeTableBase::RefreshPrevious index beyond table end(%d, %d, %d, %d).", currentTable, currentIndex, m_schemaCurrentTable, m_schemaCurrentIndex); return -1; } } SQLiteTable table(GetExactDbFullName(currentTable), m_tableName + numToString<int>(currentTable), m_unitrownum); SetTable(table); if(table.Open() < 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshPrevious open table failed."); return -1; } m_values.clear(); results.clear(); constrain[LARGE_TABLE_COL_INDEX] = SQLiteValue(currentIndex); if(table.Query(constrain, results, returnResults) < 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshPrevious query failed."); table.Close(); return -1; } table.Close(); if(returnResults.size() != 1) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshPrevious query results invalid."); return -1; } m_values = *(returnResults.begin()); return currentTable * m_unitrownum + currentIndex; }
int LargeTableBase::RefreshBottom(int count) { SQLiteValuePair constrain; set<string> results; int currentTable; int currentIndex; int min, max; file_lock f_lock(m_file_lock.c_str()); scoped_lock<file_lock> e_lock(f_lock); if(count > m_schemaColNum) { count = m_schemaColNum; } currentTable = m_schemaCurrentTable; currentIndex = m_schemaCurrentIndex; m_returnResults.clear(); while((int)m_returnResults.size() < count) { int countleft = count - m_returnResults.size(); SQLiteTable table(GetExactDbFullName(currentTable), m_tableName + numToString<int>(currentTable), m_unitrownum); SetTable(table); if(table.Open() < 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshBottom open table failed."); return -1; } max = currentIndex; min = 0; if(currentIndex > countleft) { min = currentIndex - countleft + 1; } results.clear(); if(table.QueryBetween(LARGE_TABLE_COL_INDEX, min, max, results, m_returnResults, false)) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshBottom query failed."); table.Close(); return -1; } table.Close(); if(m_schemaColNum < m_maxrownum) { if(currentTable <= 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshBottom reach top."); break; } currentIndex = m_unitrownum - 1; currentTable --; } else { currentIndex = m_unitrownum - 1; currentTable --; if(currentTable < 0) { currentTable = m_tablenum - 1; } } } return 0; }
int LargeTableBase::RefreshBottom() { SQLiteValuePair constrain; set<string> results; set<SQLiteValuePair> returnResults; int currentTable; int currentIndex; file_lock f_lock(m_file_lock.c_str()); scoped_lock<file_lock> e_lock(f_lock); currentTable = m_schemaCurrentTable; currentIndex = m_schemaCurrentIndex; SQLiteTable table(GetExactDbFullName(currentTable), m_tableName + numToString<int>(currentTable), m_unitrownum); SetTable(table); if(table.Open() < 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshBottom open table failed."); return -1; } m_values.clear(); results.clear(); constrain[LARGE_TABLE_COL_INDEX] = SQLiteValue(currentIndex); if(table.Query(constrain, results, returnResults)) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshBottom query failed."); table.Close(); return -1; } table.Close(); if(returnResults.size() != 1) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::RefreshBottom query results invalid."); return -1; } m_values = *(returnResults.begin()); if(m_schemaColNum < m_maxrownum) { if(m_maxrownum - m_schemaColNum < LARGE_TABLE_OVERHEAD) { int tmpIndex = LARGE_TABLE_OVERHEAD - (m_maxrownum - m_schemaColNum); m_queryCurrentIndex = tmpIndex % m_unitrownum; m_queryCurrentTable = tmpIndex / m_unitrownum; } else { m_queryCurrentIndex = 0; m_queryCurrentTable = 0; } } else { m_queryCurrentTable = m_schemaCurrentTable; m_queryCurrentIndex = m_schemaCurrentIndex; m_queryCurrentIndex += LARGE_TABLE_OVERHEAD; m_queryCurrentTable += (m_queryCurrentIndex / m_unitrownum); m_queryCurrentIndex %= m_unitrownum; if(m_queryCurrentTable >= m_tablenum) { m_queryCurrentTable -= m_tablenum; } } return currentTable * m_unitrownum + currentIndex; }
int LargeTableBase::Add() { SQLiteValuePair constrain; SQLiteValuePair pairs; set<string> results; set<SQLiteValuePair> returnResults; bool needAdd = false; int currentTable; int currentIndex; file_lock f_lock(m_file_lock.c_str()); scoped_lock<file_lock> e_lock(f_lock); if(m_schemaColNum <= 0) { currentTable = 0; currentIndex = 0; } else { currentTable = m_schemaCurrentTable; currentIndex = m_schemaCurrentIndex; currentIndex ++; if(currentIndex >= m_unitrownum) { currentIndex = 0; currentTable ++; } if(currentTable >= m_tablenum) { currentTable = 0; } } SQLiteTable table(GetExactDbFullName(currentTable), m_tableName + numToString<int>(currentTable), m_unitrownum); SetTable(table); if(m_schemaColNum < m_maxrownum) { needAdd = true; } if(table.Open() < 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::Add open table failed."); return -1; } constrain.clear(); results.clear(); returnResults.clear(); pairs.clear(); for(int i = 0; i < m_colnum; i ++) { if(m_dirty[i] == false) { continue; } const SQLiteColumn col = m_col[i]; pairs[col.GetHead()] = m_values[col.GetHead()]; } if(needAdd) { pairs[LARGE_TABLE_COL_INDEX] = SQLiteValue(currentIndex); if(table.Add(pairs) < 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::Add failed to add."); needAdd = false; } } if(!needAdd) { constrain[LARGE_TABLE_COL_INDEX] = SQLiteValue(currentIndex); if(table.Modify(constrain, pairs) < 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::Add failed to modify."); table.Close(); return -1; } } for(int i = 0; i < m_colnum; i ++) { m_dirty[i] = false; } table.Close(); m_schemaCurrentTable = currentTable; m_schemaCurrentIndex = currentIndex; if(m_schemaColNum < m_maxrownum) { m_schemaColNum ++; } if(UpdateSchema() < 0) { LogUtility::Log(LOG_LEVEL_ERROR, "LargeTableBase::Add failed to update schema."); return -1; } return 0; }