// @pymethod |PyIFilter|GetValue|Description of GetValue. PyObject *PyIFilter::GetValue(PyObject *self, PyObject *args) { IFilter *pIF = GetI(self); if ( pIF == NULL ) return NULL; if ( !PyArg_ParseTuple(args, ":GetValue") ) return NULL; HRESULT hr; PROPVARIANT * pPropValue = 0; PY_INTERFACE_PRECALL; hr = pIF->GetValue(&pPropValue ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ){ return PyCom_BuildPyException(hr, pIF, IID_IFilter ); } if (pPropValue){ PyObject *obRet = PyObject_FromPROPVARIANT(pPropValue); PropVariantClear(pPropValue); CoTaskMemFree(pPropValue); return obRet; } Py_INCREF(Py_None); return Py_None; }
// @pymethod |PyIFilter|GetText|Description of GetText. PyObject *PyIFilter::GetText(PyObject *self, PyObject *args) { IFilter *pIF = GetI(self); if ( pIF == NULL ) return NULL; // @pyparm <int>|nBufSize|size of text buffer to create ULONG nBufSize = 0; if ( !PyArg_ParseTuple(args, "|i:GetText", &nBufSize) ) return NULL; HRESULT hr; if (nBufSize == 0) nBufSize = 8192; // 8k default WCHAR *wBuffer = (WCHAR *)PyMem_Malloc((nBufSize+1)*sizeof(WCHAR)); if (!wBuffer){ PyErr_SetString(PyExc_MemoryError, "getting text"); return NULL; } PY_INTERFACE_PRECALL; hr = pIF->GetText( &nBufSize, wBuffer ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) { PyMem_Free(wBuffer); return PyCom_BuildPyException(hr, pIF, IID_IFilter ); } PyObject *obRet = PyWinObject_FromWCHAR(wBuffer, nBufSize); PyMem_Free(wBuffer); return obRet; }
// Launch filter test. Tbool testFilter(IFilter& a_crFilter, IReaderWriter& a_crStream) { CALL CString buffer(STR("The quick brown fox jumps over the lazy dog")); // Open filter for writing. UT_ASSERT(a_crFilter.open(IStream::e_OPEN_WRITE)); UT_ASSERT(a_crFilter.isOpened()); UT_ASSERT(a_crStream.isOpened()); // Write into the filter. UT_ASSERT(a_crFilter.write(buffer).getFirst()); // Close filter. UT_ASSERT(a_crFilter.close()); UT_ASSERT(!a_crFilter.isOpened()); UT_ASSERT(!a_crStream.isOpened()); // Open filter for reading. UT_ASSERT(a_crFilter.open(IStream::e_OPEN_READ)); UT_ASSERT(a_crFilter.isOpened()); UT_ASSERT(a_crStream.isOpened()); // Read from the filter. CString read_buffer; UT_ASSERT(a_crFilter.read(read_buffer).getFirst()); // Close filter. UT_ASSERT(a_crFilter.close()); UT_ASSERT(!a_crFilter.isOpened()); UT_ASSERT(!a_crStream.isOpened()); // Compare strings. return (read_buffer == buffer); }
IFilter* cAudioEffects::createFilter() { cAudioMutexBasicLock lock(Mutex); IFilter* filter = CAUDIO_NEW cFilter(&EFXInterface); if(filter && filter->isValid()) return filter; return NULL; }
void TestSuite::run_suite( const IFilter& filter, ITestListener& test_listener, TestResult& test_suite_result, TestResult& cumulated_result) const { TestResult local_cumulated_result(cumulated_result); local_cumulated_result.merge(test_suite_result); bool has_begun_suite = false; for (size_t i = 0; i < impl->m_factories.size(); ++i) { ITestCaseFactory& factory = *impl->m_factories[i]; // Skip test cases that aren't let through by the filter. if (!filter.accepts(factory.get_name())) continue; if (!has_begun_suite) { // Tell the listener that a test suite is about to be executed. test_listener.begin_suite(*this); test_suite_result.signal_suite_execution(); has_begun_suite = true; } // Tell the listener that a test case is about to be executed. test_listener.begin_case(*this, factory.get_name()); // Instantiate and run the test case. TestResult test_case_result; run_case(factory, test_listener, test_case_result); // Accumulate the test results. test_suite_result.merge(test_case_result); local_cumulated_result.merge(test_case_result); // Tell the listener that the test case execution has ended. test_listener.end_case( *this, factory.get_name(), test_suite_result, test_case_result, local_cumulated_result); } if (has_begun_suite) { // Report a test suite failure if one or more test cases failed. if (test_suite_result.get_case_failure_count() > 0) test_suite_result.signal_suite_failure(); // Tell the listener that the test suite execution has ended. test_listener.end_suite( *this, test_suite_result, cumulated_result); } }
// @pymethod |PyIFilter|GetChunk|Description of GetChunk. PyObject *PyIFilter::GetChunk(PyObject *self, PyObject *args) { IFilter *pIF = GetI(self); if ( pIF == NULL ) return NULL; if ( !PyArg_ParseTuple(args, ":GetChunk") ) return NULL; HRESULT hr; STAT_CHUNK stat; PY_INTERFACE_PRECALL; hr = pIF->GetChunk( &stat ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIF, IID_IFilter ); PyObject * obProp; if (stat.attribute.psProperty.ulKind == PRSPEC_LPWSTR){ obProp = PyWinObject_FromWCHAR(stat.attribute.psProperty.lpwstr); } else { obProp = Py_BuildValue("i", stat.attribute.psProperty.propid); } PyObject * obAttr = Py_BuildValue("NN", PyWinObject_FromIID(stat.attribute.guidPropSet), obProp); return Py_BuildValue("iiiiNiii", stat.idChunk, stat.breakType, stat.flags, stat.locale, obAttr, stat.idChunkSource, stat.cwcStartSource, stat.cwcLenSource); }
// Run those test suites whose name pass a given filter. void TestSuiteRepository::run( const IFilter& filter, ITestListener& test_listener, TestResult& cumulated_result) const { for (size_t i = 0; i < impl->m_suites.size(); ++i) { TestSuite& test_suite = *impl->m_suites[i]; if (filter.accepts(test_suite.get_name())) test_suite.run(test_listener, cumulated_result); else test_suite.run(filter, test_listener, cumulated_result); } }
// // TODO: I don't support passing in a FULLPROPSEC array yet // PyObject *PyIFilter::Init(PyObject *self, PyObject *args) { IFilter *pIF = GetI(self); if ( pIF == NULL ) return NULL; const FULLPROPSPEC * aAttributes=NULL; ULONG cAttributes=0; ULONG grfFlags=0; ULONG flags = 0; if ( !PyArg_ParseTuple(args, "l:Init", &grfFlags) ) return NULL; HRESULT hr; PY_INTERFACE_PRECALL; hr = pIF->Init( grfFlags, cAttributes, aAttributes, &flags ); PY_INTERFACE_POSTCALL; if ( FAILED(hr) ) return PyCom_BuildPyException(hr, pIF, IID_IFilter ); return Py_BuildValue("l", flags); }
void BenchmarkSuiteRepository::run( const IFilter& filter, BenchmarkResult& result) const { for (size_t i = 0; i < impl->m_suites.size(); ++i) { BenchmarkSuite& suite = *impl->m_suites[i]; // Create a benchmark result for this benchmark suite. BenchmarkResult suite_result; suite_result.add_listeners(result); // Run the benchmark suite. if (filter.accepts(suite.get_name())) suite.run(suite_result); else suite.run(filter, suite_result); // Merge the benchmark suite result into the final benchmark result. result.merge(suite_result); } }
HRESULT Analyze(wchar_t* szPath) { HRESULT hr = S_OK; // Load the IFilter associated with the specified file IFilter* pFilter; hr = LoadIFilter(szPath, NULL, (void**)&pFilter); if (SUCCEEDED(hr)) { // Initialize the IFilter DWORD dwFlags = 0; hr = pFilter->Init(FILTER_INIT_OPTIONS,0,NULL,&dwFlags); if (SUCCEEDED(hr)) { wchar_t szBuffer[BUFLEN]; ULONG ulSize; STAT_CHUNK ps; while (SUCCEEDED(hr)) { // Retrieve the next chunk in the document hr = pFilter->GetChunk(&ps); if ( (FILTER_E_EMBEDDING_UNAVAILABLE == hr) || (FILTER_E_LINK_UNAVAILABLE == hr) ) { hr = S_OK; continue; } else if (FILTER_E_END_OF_CHUNKS == hr) { hr = S_OK; break; } while(SUCCEEDED(hr)) { // Retrieve the next block of text in the current chunk ulSize = BUFLEN; hr = pFilter->GetText(&ulSize, szBuffer); if ( (FILTER_E_NO_TEXT == hr) || (FILTER_E_NO_MORE_TEXT == hr) ) { hr = S_OK; break; } if (SUCCEEDED(hr) && (0 < ulSize)) { szBuffer[ulSize] = '\0'; // Convert to UTF8 unsigned int cbMultiByte = WideCharToMultiByte(CP_UTF8, NULL, szBuffer, -1, NULL, 0, NULL, NULL); if (0 == cbMultiByte) { hr = E_FAIL; tcerr << "WideCharToMultiByte#1 invocation failed" << endl; errorMessagePrinted = true; } else { char* pchMultiByte = new char[cbMultiByte]; if (NULL == pchMultiByte) { hr = E_OUTOFMEMORY; } else { if (0 == WideCharToMultiByte(CP_UTF8, NULL, szBuffer, -1, pchMultiByte, cbMultiByte, NULL, NULL)) { hr = E_FAIL; tcerr << "WideCharToMultiByte#2 invocation failed" << endl; errorMessagePrinted = true; } else { // Write the UTF8 text to stdout if (cbMultiByte > fwrite(pchMultiByte, 1, cbMultiByte, stdout)) { hr = E_FAIL; tcerr << "Unable to write converted bytes to output" << endl; errorMessagePrinted = true; } } delete[] pchMultiByte; } } } } } } else { tcerr << "IFilter initialization failed with HRESULT " << hr << endl; errorMessagePrinted = true; } pFilter->Release(); } else { tcerr << "IFilter loading failed with HRESULT " << hr << endl; errorMessagePrinted = true; } return hr; }
void BenchmarkSuite::run( const IFilter& filter, BenchmarkResult& suite_result) const { BenchmarkingThreadContext benchmarking_context; bool has_begun_suite = false; for (size_t i = 0; i < impl->m_factories.size(); ++i) { IBenchmarkCaseFactory* factory = impl->m_factories[i]; // Skip benchmark cases that aren't let through by the filter. if (!filter.accepts(factory->get_name())) continue; if (!has_begun_suite) { // Tell the listeners that a benchmark suite is about to be executed. suite_result.begin_suite(*this); suite_result.signal_suite_execution(); has_begun_suite = true; } // Instantiate the benchmark case. auto_ptr<IBenchmarkCase> benchmark(factory->create()); // Recreate the stopwatch (and the underlying timer) for every benchmark // case, since the CPU frequency will fluctuate quite a bit depending on // the CPU load. We need an up-to-date frequency estimation in order to // compute accurate call rates. Impl::StopwatchType stopwatch(100000); // Tell the listeners that a benchmark case is about to be executed. suite_result.begin_case(*this, *benchmark.get()); #ifdef NDEBUG try #endif { suite_result.signal_case_execution(); // Estimate benchmarking parameters. Impl::BenchmarkParams params; Impl::estimate_benchmark_params( benchmark.get(), stopwatch, params); // Measure the overhead of calling IBenchmarkCase::run(). const double overhead = Impl::measure_call_overhead(stopwatch, params); // Run the benchmark case. const double execution_time = Impl::measure_iteration_runtime( benchmark.get(), stopwatch, params); // Gather the timing results. TimingResult timing_result; timing_result.m_iteration_count = params.m_iteration_count; timing_result.m_measurement_count = params.m_measurement_count; timing_result.m_frequency = static_cast<double>(stopwatch.get_timer().frequency()); timing_result.m_ticks = execution_time > overhead ? execution_time - overhead : 0.0; // Post the timing result. suite_result.write( *this, *benchmark.get(), __FILE__, __LINE__, timing_result); } #ifdef NDEBUG catch (const exception& e) { suite_result.write( *this, *benchmark.get(), __FILE__, __LINE__, "an unexpected exception was caught: %s.", e.what()); suite_result.signal_case_failure(); } catch (...) { suite_result.write( *this, *benchmark.get(), __FILE__, __LINE__, "an unexpected exception was caught (no details available)."); suite_result.signal_case_failure(); } #endif // Tell the listeners that the benchmark case execution has ended. suite_result.end_case(*this, *benchmark.get()); } if (has_begun_suite) { // Report a benchmark suite failure if one or more benchmark cases failed. if (suite_result.get_case_failure_count() > 0) suite_result.signal_suite_failure(); // Tell the listeners that the benchmark suite execution has ended. suite_result.end_suite(*this); } }
void Video::play( char *fileName, DWORD ) { WCHAR wPath[100]; HRESULT hr; IMediaControl *pMC; if(!init_success) return; MultiByteToWideChar( CP_ACP, 0, fileName, -1, wPath, 100 ); if( (hr = pGraph->RenderFile(wPath, NULL)) == 0) { // use full screen video interface // try to change display mode IVideoWindow *iVideoWindow = NULL; if( (hr = pGraph->QueryInterface(IID_IVideoWindow, (void **) &iVideoWindow)) == 0) { #ifdef CREATE_DUMMY_WINDOW if(hwnd) { HRESULT hr2 = iVideoWindow->put_MessageDrain((OAHWND) hwnd); hr2 = 0; } #endif #ifdef FULL_SCREEN_VIDEO IFilter *iFilter; if( pGraph->FindFilterByName(L"Video Renderer", &iFilter) == 0) { IBasicVideo *iBasicVideo; if( iFilter->QueryInterface(IID_IBasicVideo, (void **)&iBasicVideo) == 0) { IFullScreenVideo *iFullScreenVideo; IDirectDrawVideo *iDirectDrawVideo; if( iFilter->QueryInterface(IID_IFullScreenVideo, (void **)&iFullScreenVideo) == 0) { iFullScreenVideo->Release(); } else if( iFilter->QueryInterface(IID_IDirectDrawVideo, (void **)&iDirectDrawVideo) == 0) { HRESULT hr2; hr2 = iDirectDrawVideo->UseWhenFullScreen(OATRUE); iDirectDrawVideo->Release(); } iBasicVideo->Release(); } iFilter->Release(); } hr=iVideoWindow->put_FullScreenMode(OATRUE); #endif /* // code to find all filter in the filter graph { IEnumFilters *iEnumFilters; pGraph->EnumFilters(&iEnumFilters); ULONG filterCount = 16; IFilter *iFilters[16]; iEnumFilters->Next(filterCount, iFilters, &filterCount); for( ULONG j = 0; j < filterCount; ++j ) { FILTER_INFO filterInfo; iFilters[j]->QueryFilterInfo(&filterInfo); filterInfo.pGraph->Release(); iFilters[j]->Release(); } iEnumFilters->Release(); }*/ iVideoWindow->HideCursor(OATRUE); iVideoWindow->put_Visible( OAFALSE ); iVideoWindow->put_AutoShow( OAFALSE ); LONG windowStyle; iVideoWindow->get_WindowStyle( &windowStyle); windowStyle &= ~WS_BORDER & ~WS_CAPTION & ~WS_SIZEBOX & ~WS_THICKFRAME & ~WS_HSCROLL & ~WS_VSCROLL & ~WS_VISIBLE; iVideoWindow->put_WindowStyle( windowStyle); } else iVideoWindow = NULL; if( (hr = pGraph->QueryInterface(IID_IMediaControl, (void **) &pMC)) == 0) { pMC->Run(); // sometimes it returns 1, but still ok state = PLAYING; pMC->Release(); } if( iVideoWindow ) { iVideoWindow->put_Visible( OAFALSE ); LONG windowStyle; iVideoWindow->get_WindowStyle( &windowStyle); windowStyle &= ~WS_BORDER & ~WS_CAPTION & ~WS_SIZEBOX & ~WS_THICKFRAME & ~WS_HSCROLL & ~WS_VSCROLL & ~WS_VISIBLE; iVideoWindow->put_WindowStyle( windowStyle); LONG maxWidth; LONG maxHeight; hr=iVideoWindow->GetMaxIdealImageSize( &maxWidth, &maxHeight); #ifdef FULL_SCREEN_VIDEO #else iVideoWindow->put_BorderColor( RGB(0,0,0) ); iVideoWindow->put_WindowState(SW_MAXIMIZE); IBaseFilter *iFilter; if( pGraph->FindFilterByName((const WCHAR *)L"Video Renderer", &iFilter) == 0) { IBasicVideo *iBasicVideo; if( iFilter->QueryInterface(IID_IBasicVideo, (void **)&iBasicVideo) == 0) { LONG screenWidth; LONG screenHeight; LONG videoWidth; LONG videoHeight; if( iVideoWindow->get_Width(&screenWidth) == 0 && iVideoWindow->get_Height(&screenHeight) == 0 && iBasicVideo->GetVideoSize(&videoWidth, &videoHeight) == 0) { // zoom in by 2 if possible if( screenWidth >= videoWidth * 2 && screenHeight >= videoHeight * 2) { videoWidth *= 2; videoHeight *= 2; } // center the video client area iBasicVideo->SetDestinationPosition( (screenWidth-videoWidth)/2, (screenHeight-videoHeight)/2, videoWidth, videoHeight); } iBasicVideo->Release(); } iFilter->Release(); } #endif iVideoWindow->HideCursor(OATRUE); iVideoWindow->SetWindowForeground(OATRUE); } if(iVideoWindow) { iVideoWindow->Release(); iVideoWindow = NULL; } } if( hr && !skip_on_fail_flag) err.run("video.play error %d", hr ); }
void BenchmarkSuite::run( const IFilter& filter, BenchmarkResult& suite_result) const { BenchmarkingThreadContext benchmarking_context; bool has_begun_suite = false; for (size_t i = 0; i < impl->m_factories.size(); ++i) { IBenchmarkCaseFactory* factory = impl->m_factories[i]; // Skip benchmark cases that aren't let through by the filter. if (!filter.accepts(factory->get_name())) continue; if (!has_begun_suite) { // Tell the listeners that a benchmark suite is about to be executed. suite_result.begin_suite(*this); suite_result.signal_suite_execution(); has_begun_suite = true; } // Instantiate the benchmark case. unique_ptr<IBenchmarkCase> benchmark(factory->create()); // Recreate the stopwatch (and the underlying timer) for every benchmark // case, since the CPU frequency will fluctuate quite a bit depending on // the CPU load. We need an up-to-date frequency estimation in order to // compute accurate call rates. Impl::StopwatchType stopwatch(100000); // Tell the listeners that a benchmark case is about to be executed. suite_result.begin_case(*this, *benchmark.get()); #ifdef NDEBUG try #endif { suite_result.signal_case_execution(); // Estimate benchmarking parameters. const size_t measurement_count = Impl::compute_measurement_count(benchmark.get(), stopwatch); // Measure the overhead of calling IBenchmarkCase::run(). const double overhead_ticks = Impl::measure_call_overhead_ticks(stopwatch, measurement_count); // Run the benchmark case. const double runtime_ticks = Impl::measure_runtime( benchmark.get(), stopwatch, BenchmarkSuite::Impl::measure_runtime_ticks, measurement_count); #ifdef GENERATE_BENCHMARK_PLOTS vector<Vector2d> points; for (size_t j = 0; j < 100; ++j) { const double ticks = Impl::measure_runtime( benchmark.get(), stopwatch, BenchmarkSuite::Impl::measure_runtime_ticks, max<size_t>(1, measurement_count / 100)); points.emplace_back( static_cast<double>(j), ticks > overhead_ticks ? ticks - overhead_ticks : 0.0); } stringstream sstr; sstr << "unit benchmarks/plots/"; sstr << get_name() << "_" << benchmark->get_name(); sstr << ".gnuplot"; GnuplotFile plotfile; plotfile.new_plot().set_points(points); plotfile.write(sstr.str()); #endif // Gather the timing results. TimingResult timing_result; timing_result.m_iteration_count = 1; timing_result.m_measurement_count = measurement_count; timing_result.m_frequency = static_cast<double>(stopwatch.get_timer().frequency()); timing_result.m_ticks = runtime_ticks > overhead_ticks ? runtime_ticks - overhead_ticks : 0.0; // Post the timing result. suite_result.write( *this, *benchmark.get(), __FILE__, __LINE__, timing_result); } #ifdef NDEBUG catch (const exception& e) { if (e.what()[0] != '\0') { suite_result.write( *this, *benchmark.get(), __FILE__, __LINE__, "an unexpected exception was caught: %s", e.what()); } else { suite_result.write( *this, *benchmark.get(), __FILE__, __LINE__, "an unexpected exception was caught (no details available)."); } suite_result.signal_case_failure(); } catch (...) { suite_result.write( *this, *benchmark.get(), __FILE__, __LINE__, "an unexpected exception was caught (no details available)."); suite_result.signal_case_failure(); } #endif // Tell the listeners that the benchmark case execution has ended. suite_result.end_case(*this, *benchmark.get()); } if (has_begun_suite) { // Report a benchmark suite failure if one or more benchmark cases failed. if (suite_result.get_case_failure_count() > 0) suite_result.signal_suite_failure(); // Tell the listeners that the benchmark suite execution has ended. suite_result.end_suite(*this); } }
void run_test(IFilter &test, bool is_multi = true) { test.insert(Criterion(BY_USERNAME, "4478901234568")); test.insert(Criterion(BY_IMEI, "1234567890123456")); test.insert(Criterion(BY_IMSI, "12345678901234")); test.insert(Criterion(BY_MSISDN, "4478901234567")); test.insert(Criterion(BY_MSISDN, "4478901234567")); (void) is_multi; // release builds keep compiler happy assert( false == test.contains(Criterion(BY_MSISDN, "NOT ME"))); assert( false == test.contains(Criterion(BY_IMEI, "4478901234567"))); assert( false == test.contains(Criterion(BY_IMSI, "4478901234567"))); assert( false == test.contains(Criterion(BY_USERNAME, "4478901234567"))); assert( true == test.contains(Criterion(BY_IMEI, "1234567890123456"))); assert( true == test.contains(Criterion(BY_IMSI, "12345678901234"))); assert( false == test.contains(Criterion(BY_IMEI, "12345678901234"))); assert( false == test.contains(Criterion(BY_IMSI, "1234567890123456"))); assert( true == test.contains(Criterion(BY_USERNAME, "4478901234568"))); assert( false == test.contains(Criterion(BY_MSISDN, "4478901234568"))); assert( true == test.contains(Criterion(BY_MSISDN, "4478901234567"))); assert( true == test.remove(Criterion(BY_MSISDN, "4478901234567"))); assert( is_multi == test.contains(Criterion(BY_MSISDN, "4478901234567"))); assert( is_multi == test.remove(Criterion(BY_MSISDN, "4478901234567"))); assert( false == test.contains(Criterion(BY_MSISDN, "4478901234567"))); }
signed char IFilterEndAnalyzer::analyze(AnalysisResult& idx, InputStream *in) { const string& filename = idx.fileName(); int p = filename.find_last_of('.'); if (p < 0 || extensions.find(filename.substr(p)) == extensions.end()) { return -1; } string filepath; bool fileisondisk = checkForFile(idx.depth(), filename); if (fileisondisk) { filepath = filename; } else { int p = filename.find_last_of("."); if ( p > 0 ){ string ext = filename.substr(p).c_str(); strlwr((char*)ext.c_str()); p = ext.find_first_not_of("._abcdefghijklmnopqrstuvwxyz0123456789"); if ( p >= 0 ) filepath = writeToTempFile(in, ""); else filepath = writeToTempFile(in, ext.c_str()); }else filepath = writeToTempFile(in, ""); } if (filepath.length() > 0) { IFilter* filter = NULL; void* pvfilter=NULL; wchar_t tmp[MAX_PATH]; _cpycharToWide(tmp,filepath.c_str(),MAX_PATH); HRESULT hr = LoadIFilter(tmp,NULL,&pvfilter); if (hr == S_OK) { filter = (IFilter*)pvfilter; ULONG __i=0; hr = filter->Init(IFILTER_INIT_APPLY_INDEX_ATTRIBUTES,0,NULL,&__i); if (FAILED( hr )) { if (!fileisondisk) unlink(filepath.c_str()); return -1; } const int sbBufferLen = 1024; wchar_t sbBuffer[sbBufferLen]; STAT_CHUNK ps; hr = filter->GetChunk(&ps); while ( SUCCEEDED(hr) ) { if (ps.flags == CHUNK_TEXT) { int resultText = 0; while ( resultText >= 0 ) { ULONG sizeBuffer=sbBufferLen; resultText = filter->GetText(&sizeBuffer, sbBuffer); if (sizeBuffer > 0 ) { string str = wchartoutf8(sbBuffer,sbBuffer+sizeBuffer); idx.addText(str.c_str(),str.length()); } } } else if ( ps.flags == CHUNK_VALUE ) { PROPVARIANT *pVar; while ( SUCCEEDED( hr = filter->GetValue( &pVar ) ) ) { //printf("propid: %d\nkind:%d\n",ps.attribute.psProperty.propid,ps.attribute.psProperty.ulKind); if ( ps.attribute.psProperty.propid == 2 && ps.attribute.psProperty.ulKind == 1 && pVar->vt == VT_LPWSTR ) { string str = wchartoutf8(pVar->pwszVal,pVar->pwszVal+wcslen(pVar->pwszVal)); idx.addValue("title", str ); } PropVariantClear( pVar ); CoTaskMemFree( pVar ); } } else { printf("other flag %d\n",ps.flags); } hr = filter->GetChunk(&ps); } filter->Release(); if (!fileisondisk) unlink(filepath.c_str()); return 0; } DWORD dw = GetLastError(); if ( dw != 0 ) { LPVOID lpMsgBuf; FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL ); wprintf(L"%s\n", lpMsgBuf); LocalFree(lpMsgBuf); } } if (!fileisondisk && filepath.length()>0) { unlink(filepath.c_str()); } return -1; }