Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

740 lines
19 KiB

  1. //+---------------------------------------------------------------------------
  2. //
  3. // Microsoft Windows
  4. // Copyright (C) Microsoft Corporation, 1992 - 1995.
  5. //
  6. // File: CCodeFt.cxx
  7. //
  8. // Contents:
  9. //
  10. // Classes:
  11. //
  12. // Functions:
  13. //
  14. // History: 04-29-97 DanpoZ (Danpo Zhang) Created
  15. //
  16. //----------------------------------------------------------------------------
  17. #include <eapp.h>
  18. PerfDbgTag(tagDft, "Pluggable MF", "Log CDataFt", DEB_PROT)
  19. DbgTag(tagDftErr, "Pluggable MF", "Log CDataFtErrors", DEB_PROT|DEB_ERROR)
  20. #define SZDFILTERROOT "PROTOCOLS\\Filter\\Data Filter\\"
  21. //+---------------------------------------------------------------------------
  22. //
  23. // Method: CStdZFilter::QueryInterface
  24. //
  25. // Synopsis:
  26. //
  27. // Arguments:
  28. //
  29. // Returns:
  30. //
  31. // History: 06-26-97 DanpoZ (Danpo Zhang) Created
  32. //
  33. // Notes:
  34. //
  35. //----------------------------------------------------------------------------
  36. STDMETHODIMP
  37. CStdZFilter::QueryInterface(REFIID riid, void **ppvObj)
  38. {
  39. PerfDbgLog(tagDft, this, "+CStdFilter::QueryInterface");
  40. VDATEPTROUT(ppvObj, void*);
  41. VDATETHIS(this);
  42. HRESULT hr = NOERROR;
  43. if( riid == IID_IUnknown ||
  44. riid == IID_IDataFilter )
  45. {
  46. *ppvObj = this;
  47. AddRef();
  48. }
  49. else
  50. hr = E_NOINTERFACE;
  51. PerfDbgLog1(
  52. tagDft, this, "-CStdZFilter::QueryInterface(hr:%1x)", hr);
  53. return hr;
  54. }
  55. //+---------------------------------------------------------------------------
  56. //
  57. // Method: CStdZFilter::AddRef
  58. //
  59. // Synopsis:
  60. //
  61. // Arguments:
  62. //
  63. // Returns:
  64. //
  65. // History: 06-26-97 DanpoZ (Danpo Zhang) Created
  66. //
  67. // Notes:
  68. //
  69. //----------------------------------------------------------------------------
  70. STDMETHODIMP_(ULONG)
  71. CStdZFilter::AddRef()
  72. {
  73. PerfDbgLog(tagDft, this, "+CStdZFilter::AddRef");
  74. LONG lRet = ++_CRefs;
  75. DllAddRef();
  76. PerfDbgLog1(tagDft, this, "-CStdZFilter::AddRef(cRef:%1d)", lRet);
  77. return lRet;
  78. }
  79. //+---------------------------------------------------------------------------
  80. //
  81. // Method: CStdZFilter::Release
  82. //
  83. // Synopsis:
  84. //
  85. // Arguments:
  86. //
  87. // Returns:
  88. //
  89. // History: 06-26-97 DanpoZ (Danpo Zhang) Created
  90. //
  91. // Notes:
  92. //
  93. //----------------------------------------------------------------------------
  94. STDMETHODIMP_(ULONG)
  95. CStdZFilter::Release()
  96. {
  97. PerfDbgLog(tagDft, this, "+CStdZFilter::Release");
  98. LONG lRet = --_CRefs;
  99. if(!lRet)
  100. delete this;
  101. DllRelease();
  102. PerfDbgLog1(tagDft, this, "-CStdZFilter::Release(cRef:%1d)", lRet);
  103. return lRet;
  104. }
  105. //+---------------------------------------------------------------------------
  106. //
  107. // Method: CStdZFilter::DoEncode
  108. //
  109. // Synopsis:
  110. //
  111. // Arguments: [dwFlags] - flags
  112. // [lInBufferSize] - Input Buffer Size
  113. // [pbInBuffer] - Input Buffer
  114. // [lOutBufferSize] - Output Buffer Size
  115. // [pbOutBuffer] - Output Buffer
  116. // [lInBytesAvailable] - Data available in Input Buffer
  117. // [plInBytesRead] - Total data read from input buffer
  118. // [plOutBytesWritten] - Total data written to output buffer
  119. // [dwReserved] - currently not used
  120. //
  121. // Returns: NOERROR or E_FAIL
  122. //
  123. // History: 06-27-97 DanpoZ (Danpo Zhang) Created
  124. //
  125. // Notes:
  126. //
  127. //----------------------------------------------------------------------------
  128. STDMETHODIMP
  129. CStdZFilter::DoEncode(
  130. DWORD dwFlags,
  131. LONG lInBufferSize,
  132. BYTE* pbInBuffer,
  133. LONG lOutBufferSize,
  134. BYTE* pbOutBuffer,
  135. LONG lInBytesAvailable,
  136. LONG* plInBytesRead,
  137. LONG* plOutBytesWritten,
  138. DWORD dwReserved
  139. )
  140. {
  141. PerfDbgLog(tagDft, this, "+CStdZFilter::DoEncode");
  142. HRESULT hr = NOERROR;
  143. if( !_pEncodeCtx )
  144. hr = CreateCompression(&_pEncodeCtx, _ulSchema);
  145. if( _pEncodeCtx && !FAILED(hr) )
  146. {
  147. PProtAssert( pbInBuffer && pbOutBuffer &&
  148. plInBytesRead && plOutBytesWritten);
  149. hr = Compress(
  150. _pEncodeCtx,
  151. pbInBuffer,
  152. lInBytesAvailable,
  153. pbOutBuffer,
  154. lOutBufferSize,
  155. plInBytesRead,
  156. plOutBytesWritten,
  157. _cEncLevel
  158. );
  159. }
  160. PerfDbgLog1(tagDft, this, "-CStdZFilter::DoEncode(hr:%1x)", hr);
  161. return hr;
  162. }
  163. //+---------------------------------------------------------------------------
  164. //
  165. // Method: CStdZFilter::DoDecode
  166. //
  167. // Synopsis:
  168. //
  169. // Arguments: [dwFlags] - flags
  170. // [lInBufferSize] - Input Buffer Size
  171. // [pbInBuffer] - Input Buffer
  172. // [lOutBufferSize] - Output Buffer Size
  173. // [pbOutBuffer] - Output Buffer
  174. // [lInBytesAvailable] - Data available in Input Buffer
  175. // [plInBytesRead] - Total data read from input buffer
  176. // [plOutBytesWritten] - Total data written to output buffer
  177. // [dwReserved] - reserved
  178. //
  179. // Returns: NOERROR or E_FAIL
  180. //
  181. // History: 06-27-97 DanpoZ (Danpo Zhang) Created
  182. //
  183. // Notes:
  184. //
  185. //----------------------------------------------------------------------------
  186. STDMETHODIMP
  187. CStdZFilter::DoDecode(
  188. DWORD dwFlags,
  189. LONG lInBufferSize,
  190. BYTE* pbInBuffer,
  191. LONG lOutBufferSize,
  192. BYTE* pbOutBuffer,
  193. LONG lInBytesAvailable,
  194. LONG* plInBytesRead,
  195. LONG* plOutBytesWritten,
  196. DWORD dwReserved
  197. )
  198. {
  199. PerfDbgLog(tagDft, this, "+CStdZFilter::DoDecode");
  200. HRESULT hr = NOERROR;
  201. if( !_pDecodeCtx )
  202. hr = CreateDecompression(&_pDecodeCtx, _ulSchema);
  203. if( _pDecodeCtx && !FAILED(hr) )
  204. {
  205. PProtAssert( pbInBuffer && pbOutBuffer &&
  206. plInBytesRead && plOutBytesWritten);
  207. hr = Decompress(
  208. _pDecodeCtx,
  209. pbInBuffer,
  210. lInBytesAvailable,
  211. pbOutBuffer,
  212. lOutBufferSize,
  213. plInBytesRead,
  214. plOutBytesWritten
  215. );
  216. }
  217. PerfDbgLog1(tagDft, this, "-CStdZFilter::DoDecode(hr:%1x)", hr);
  218. return hr;
  219. }
  220. //+---------------------------------------------------------------------------
  221. //
  222. // Method: CStdZFilter::SetEncodingLevel
  223. //
  224. // Synopsis:
  225. //
  226. // Arguments: [cEncLevel] - encoding level (between 1-100)
  227. //
  228. // Returns: NOERROR or E_FAIL
  229. //
  230. // History: 06-27-97 DanpoZ (Danpo Zhang) Created
  231. //
  232. // Notes:
  233. //
  234. //----------------------------------------------------------------------------
  235. STDMETHODIMP
  236. CStdZFilter::SetEncodingLevel(DWORD dwEncLevel)
  237. {
  238. PerfDbgLog(tagDft, this, "+CStdZFilter::SetEncodingLevel");
  239. HRESULT hr = NOERROR;
  240. if( dwEncLevel >= 1 && dwEncLevel <= 100 )
  241. {
  242. // input value should be between 1 - 100]
  243. // our formula is _cEncLevel = dwEncLevel * 10 / 100
  244. _cEncLevel = (dwEncLevel * 10) / 100;
  245. if( !_cEncLevel )
  246. ++_cEncLevel;
  247. }
  248. else
  249. hr = E_INVALIDARG;
  250. PerfDbgLog1(
  251. tagDft, this, "-CStdZFilter::SetEncodingLevel(hr:%1x)", hr);
  252. return hr;
  253. }
  254. //+---------------------------------------------------------------------------
  255. //
  256. // Method: CStdZFilter::InitFilter
  257. //
  258. // Synopsis:
  259. //
  260. // Arguments:
  261. //
  262. // Returns: NOERROR or E_FAIL (dll init failed)
  263. //
  264. // History: 06-27-97 DanpoZ (Danpo Zhang) Created
  265. //
  266. // Notes:
  267. //
  268. //----------------------------------------------------------------------------
  269. HRESULT
  270. CStdZFilter::InitFilter()
  271. {
  272. PerfDbgLog(tagDft, this, "+CStdZFilter::InitFilter");
  273. HRESULT hr = NOERROR;
  274. // init the compressor
  275. if (FAILED(InitCompression()))
  276. hr = E_FAIL;
  277. // init the decompressor
  278. if (FAILED(InitDecompression()))
  279. hr = E_FAIL;
  280. PerfDbgLog(tagDft, this, "-CStdZFilter::InitFilter");
  281. return hr;
  282. }
  283. //+---------------------------------------------------------------------------
  284. //
  285. // Method: CStdZFilter::CStdZFilter
  286. //
  287. // Synopsis:
  288. //
  289. // Arguments:
  290. //
  291. // Returns:
  292. //
  293. // History: 06-26-97 DanpoZ (Danpo Zhang) Created
  294. //
  295. // Notes:
  296. //
  297. //----------------------------------------------------------------------------
  298. CStdZFilter::CStdZFilter(ULONG ulSchema)
  299. : _CRefs()
  300. {
  301. PerfDbgLog(tagDft, this, "+CStdZFilter::CStdZFilter");
  302. _pEncodeCtx = NULL;
  303. _pDecodeCtx = NULL;
  304. // accepts the number between 1[fastest] - 10[most compres]
  305. // the formula is _cEncLevel/10 = 50/100
  306. _cEncLevel= 5;
  307. _ulSchema = ulSchema;
  308. PerfDbgLog(tagDft, this, "-CStdZFilter::CStdZFilter");
  309. }
  310. //+---------------------------------------------------------------------------
  311. //
  312. // Method: CStdZFilter::~CStdZFilter
  313. //
  314. // Synopsis:
  315. //
  316. // Arguments:
  317. //
  318. // Returns:
  319. //
  320. // History: 06-26-97 DanpoZ (Danpo Zhang) Created
  321. //
  322. // Notes:
  323. //
  324. //----------------------------------------------------------------------------
  325. CStdZFilter::~CStdZFilter()
  326. {
  327. PerfDbgLog(tagDft, this, "+CStdZFilter::~CStdZFilter");
  328. if( _pEncodeCtx )
  329. DestroyCompression(_pEncodeCtx);
  330. if( _pDecodeCtx )
  331. DestroyDecompression(_pDecodeCtx);
  332. PerfDbgLog(tagDft, this, "-CStdZFilter::~CStdZFilter");
  333. }
  334. //+---------------------------------------------------------------------------
  335. //
  336. // Method: CEncodingFilterFactory::QueryInterface
  337. //
  338. // Synopsis:
  339. //
  340. // Arguments:
  341. //
  342. // Returns:
  343. //
  344. // History: 04-29-97 DanpoZ (Danpo Zhang) Created
  345. //
  346. // Notes:
  347. //
  348. //----------------------------------------------------------------------------
  349. STDMETHODIMP
  350. CEncodingFilterFactory::QueryInterface(REFIID riid, void **ppvObj)
  351. {
  352. PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::QueryInterface");
  353. VDATEPTROUT(ppvObj, void*);
  354. VDATETHIS(this);
  355. HRESULT hr = NOERROR;
  356. if( riid == IID_IUnknown ||
  357. riid == IID_IEncodingFilterFactory )
  358. {
  359. *ppvObj = this;
  360. AddRef();
  361. }
  362. else
  363. hr = E_NOINTERFACE;
  364. PerfDbgLog1(
  365. tagDft, this, "-CEncodingFilterFactory::QueryInterface(hr:%1x)", hr);
  366. return hr;
  367. }
  368. //+---------------------------------------------------------------------------
  369. //
  370. // Method: CEncodingFilterFactory::AddRef
  371. //
  372. // Synopsis:
  373. //
  374. // Arguments:
  375. //
  376. // Returns:
  377. //
  378. // History: 04-29-97 DanpoZ (Danpo Zhang) Created
  379. //
  380. // Notes:
  381. //
  382. //----------------------------------------------------------------------------
  383. STDMETHODIMP_(ULONG)
  384. CEncodingFilterFactory::AddRef()
  385. {
  386. PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::AddRef");
  387. LONG lRet = ++_CRefs;
  388. PerfDbgLog1(
  389. tagDft, this, "-CEncodingFilterFactory::AddRef(cRef:%1d)", lRet);
  390. return lRet;
  391. }
  392. //+---------------------------------------------------------------------------
  393. //
  394. // Method: CEncodingFilterFactory::Release
  395. //
  396. // Synopsis:
  397. //
  398. // Arguments:
  399. //
  400. // Returns:
  401. //
  402. // History: 04-29-97 DanpoZ (Danpo Zhang) Created
  403. //
  404. // Notes:
  405. //
  406. //----------------------------------------------------------------------------
  407. STDMETHODIMP_(ULONG)
  408. CEncodingFilterFactory::Release()
  409. {
  410. PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::Release");
  411. LONG lRet = --_CRefs;
  412. if(!lRet)
  413. delete this;
  414. PerfDbgLog1(
  415. tagDft, this, "-CEncodingFilterFactory::Release(cRef:%1d)", lRet);
  416. return lRet;
  417. }
  418. //+---------------------------------------------------------------------------
  419. //
  420. // Method: CEncodingFilterFactory::FindBestFilter
  421. //
  422. // Synopsis:
  423. //
  424. // Arguments: [grfETYPEIn] - input encoding type
  425. // [grfETYPEOut] - output encoding type
  426. // [info] - DATAINFO (what the data looks like)
  427. // [ppDF] - output DataFilter pointer
  428. //
  429. // Returns:
  430. //
  431. // History: 04-29-97 DanpoZ (Danpo Zhang) Created
  432. //
  433. // Notes: currently it calls FindDefaultFilter()
  434. //
  435. //----------------------------------------------------------------------------
  436. STDMETHODIMP
  437. CEncodingFilterFactory::FindBestFilter(
  438. LPCWSTR pwzCodeIn,
  439. LPCWSTR pwzCodeOut,
  440. DATAINFO info,
  441. IDataFilter** ppDF
  442. )
  443. {
  444. PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::FindBestFilter");
  445. HRESULT hr = NOERROR;
  446. hr = GetDefaultFilter(pwzCodeIn, pwzCodeOut, ppDF);
  447. PerfDbgLog1(
  448. tagDft, this, "-CEncodingFilterFactory::FindBestFilter(hr:%1x)", hr);
  449. return hr;
  450. }
  451. //+---------------------------------------------------------------------------
  452. //
  453. // Method: CEncodingFilterFactory::GetDefaultFilter
  454. //
  455. // Synopsis:
  456. //
  457. // Arguments: [tIn] - input encoding type
  458. // [tOut] - output encoding type
  459. // [ppDF] - output DataFilter pointer
  460. //
  461. // Returns:
  462. //
  463. // History: 04-29-97 DanpoZ (Danpo Zhang) Created
  464. //
  465. // Notes:
  466. //
  467. //----------------------------------------------------------------------------
  468. STDMETHODIMP
  469. CEncodingFilterFactory::GetDefaultFilter(
  470. LPCWSTR pwzCodeIn,
  471. LPCWSTR pwzCodeOut,
  472. IDataFilter** ppDF
  473. )
  474. {
  475. PerfDbgLog(tagDft, this, "+CEncodingFilterFactory::GetDefaultFilter");
  476. VDATEPTROUT(ppDF, void*);
  477. *ppDF = NULL;
  478. HRESULT hr = E_FAIL;
  479. BOOL fBuiltIn = FALSE;
  480. if( (!_wcsicmp(pwzCodeIn, L"gzip") && !_wcsicmp(pwzCodeOut, L"text")) ||
  481. (!_wcsicmp(pwzCodeIn, L"text") && !_wcsicmp(pwzCodeOut, L"gzip") ) )
  482. {
  483. // GZIP
  484. *ppDF = new CStdZFilter(COMPRESSION_FLAG_GZIP);
  485. fBuiltIn = TRUE;
  486. if( !(*ppDF) )
  487. {
  488. hr = E_OUTOFMEMORY;
  489. }
  490. }
  491. else
  492. if((!_wcsicmp(pwzCodeIn, L"deflate") && !_wcsicmp(pwzCodeOut, L"text"))|| (!_wcsicmp(pwzCodeIn, L"text") && !_wcsicmp(pwzCodeOut, L"deflate")) )
  493. {
  494. // deflate
  495. *ppDF = new CStdZFilter(COMPRESSION_FLAG_DEFLATE);
  496. fBuiltIn = TRUE;
  497. if( !(*ppDF) )
  498. {
  499. hr = E_OUTOFMEMORY;
  500. }
  501. }
  502. else
  503. {
  504. // lookup reg to find out the class
  505. CLSID clsid = CLSID_NULL;
  506. hr = LookupClsIDFromReg(pwzCodeIn, pwzCodeOut, &clsid, 0);
  507. if( hr == NOERROR )
  508. { // Get Clsid
  509. IClassFactory* pCF = NULL;
  510. hr = CoGetClassObject(
  511. clsid, CLSCTX_INPROC_SERVER, NULL,
  512. IID_IClassFactory, (void**)&pCF );
  513. if( hr == NOERROR )
  514. { // Get Class Fac
  515. IUnknown* pUnk = NULL;
  516. hr = pCF->CreateInstance(NULL, IID_IUnknown, (void**)&pUnk);
  517. if( hr == NOERROR )
  518. { // Created Instance
  519. hr = pUnk->QueryInterface(IID_IDataFilter, (void**)ppDF);
  520. pUnk->Release();
  521. } // Created Instance
  522. pCF->Release();
  523. } // Get Class Fac
  524. } // Get Clsid
  525. } // lookup reg to find out the class
  526. // only do this for built-in filter (this is not universal)
  527. if( (*ppDF) && fBuiltIn )
  528. {
  529. hr = ((CStdZFilter*)(*ppDF))->InitFilter();
  530. }
  531. PerfDbgLog1(
  532. tagDft, this, "-CEncodingFilterFactory::GetDefaultFilter(hr:%1x)",hr);
  533. return hr;
  534. }
  535. //+---------------------------------------------------------------------------
  536. //
  537. // Method: CEncodingFilterFactory::LookupClsIDFromReg
  538. //
  539. // Synopsis:
  540. //
  541. // Arguments:
  542. //
  543. // Returns:
  544. //
  545. // History: 08-20-97 DanpoZ (Danpo Zhang) Created
  546. //
  547. // Notes:
  548. //
  549. //----------------------------------------------------------------------------
  550. STDMETHODIMP
  551. CEncodingFilterFactory::LookupClsIDFromReg(
  552. LPCWSTR pwzCodeIn,
  553. LPCWSTR pwzCodeOut,
  554. CLSID* pclsid,
  555. DWORD dwFlags
  556. )
  557. {
  558. HRESULT hr = E_FAIL;
  559. CHAR szCodeIn[ULPROTOCOLLEN];
  560. CHAR szCodeOut[ULPROTOCOLLEN];
  561. CHAR szCodeKey[2*ULPROTOCOLLEN+1];
  562. DWORD dwLen = 256;
  563. CHAR szDFilterKey[MAX_PATH];
  564. BOOL fFoundKey = FALSE;
  565. HKEY hDFKey = NULL;
  566. DWORD dwType;
  567. W2A(pwzCodeIn, szCodeIn, ULPROTOCOLLEN);
  568. W2A(pwzCodeOut, szCodeOut, ULPROTOCOLLEN);
  569. // check buffer overrun
  570. if( (strlen(szCodeIn) + strlen(szCodeOut) + 2)
  571. <= MAX_PATH )
  572. {
  573. // try key#1
  574. strcpy(szDFilterKey, SZDFILTERROOT);
  575. strcat(szDFilterKey, szCodeIn);
  576. strcat(szDFilterKey, "#");
  577. strcat(szDFilterKey, szCodeOut);
  578. if( RegOpenKeyEx(
  579. HKEY_CLASSES_ROOT, szDFilterKey, 0,
  580. KEY_QUERY_VALUE, &hDFKey ) == ERROR_SUCCESS)
  581. {
  582. if( RegQueryValueEx(
  583. hDFKey, SZCLASS, NULL, &dwType, (LPBYTE)szDFilterKey, &dwLen
  584. ) == ERROR_SUCCESS
  585. )
  586. {
  587. hr = CLSIDFromStringA(szDFilterKey, pclsid);
  588. fFoundKey = TRUE;
  589. }
  590. RegCloseKey(hDFKey);
  591. }
  592. // try key#2
  593. if( !fFoundKey )
  594. {
  595. strcpy(szDFilterKey, SZDFILTERROOT);
  596. strcat(szDFilterKey, szCodeOut);
  597. strcat(szDFilterKey, "#");
  598. strcat(szDFilterKey, szCodeIn);
  599. if( RegOpenKeyEx(
  600. HKEY_CLASSES_ROOT, szDFilterKey, 0,
  601. KEY_QUERY_VALUE, &hDFKey ) == ERROR_SUCCESS )
  602. {
  603. if( RegQueryValueEx(
  604. hDFKey, SZCLASS, NULL, &dwType,
  605. (LPBYTE)szDFilterKey, &dwLen
  606. ) == ERROR_SUCCESS
  607. )
  608. {
  609. hr = CLSIDFromStringA(szDFilterKey, pclsid);
  610. }
  611. RegCloseKey(hDFKey);
  612. }
  613. }
  614. }
  615. return hr;
  616. }
  617. //+---------------------------------------------------------------------------
  618. //
  619. // Method: CEncodingFilterFactory::CEncodingFilterFactory
  620. //
  621. // Synopsis:
  622. //
  623. // Arguments:
  624. //
  625. // Returns:
  626. //
  627. // History: 04-29-97 DanpoZ (Danpo Zhang) Created
  628. //
  629. // Notes:
  630. //
  631. //----------------------------------------------------------------------------
  632. CEncodingFilterFactory::CEncodingFilterFactory()
  633. : _CRefs()
  634. {
  635. PerfDbgLog(
  636. tagDft, this, "+CEncodingFilterFactory::CEncodingFilterFactory");
  637. PerfDbgLog(
  638. tagDft, this, "-CEncodingFilterFactory::CEncodingFilterFactory");
  639. }
  640. //+---------------------------------------------------------------------------
  641. //
  642. // Method: CEncodingFilterFactory::~CEncodingFilterFactory
  643. //
  644. // Synopsis:
  645. //
  646. // Arguments:
  647. //
  648. // Returns:
  649. //
  650. // History: 04-29-97 DanpoZ (Danpo Zhang) Created
  651. //
  652. // Notes:
  653. //
  654. //----------------------------------------------------------------------------
  655. CEncodingFilterFactory::~CEncodingFilterFactory()
  656. {
  657. PerfDbgLog(
  658. tagDft, this, "+CEncodingFilterFactory::~CEncodingFilterFactory");
  659. PerfDbgLog(
  660. tagDft, this, "-CEncodingFilterFactory::~CEncodingFilterFactory");
  661. }