Remove ICodec_* Interfaces.

core/fxcodec/codec/fx_codec_progress.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
-#include "core/fxcodec/codec/fx_codec_progress.h"
+#include "core/fxcodec/codec/include/ccodec_progressivedecoder.h"
 
 #include "core/fxcodec/include/fx_codec.h"
 #include "core/fxge/include/fx_dib.h"
 
-void CFXCODEC_WeightTable::Calc(int dest_len,
-                                int dest_min,
-                                int dest_max,
-                                int src_len,
-                                int src_min,
-                                int src_max,
-                                FX_BOOL bInterpol) {
+namespace {
+
+#define FXCODEC_BLOCK_SIZE 4096

[Tom Sepez, 2016/04/11 17:16:21]

namespaces don't affect #defines, and would be empty otherwise.

[dsinclair, 2016/04/11 20:40:40]

Yea, I'd moved stuff in here, then had to move it out to the header.

+#define FXCODEC_PNG_GAMMA 2.2
+
+#if _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_
+#undef FXCODEC_PNG_GAMMA
+#define FXCODEC_PNG_GAMMA 1.7
+#endif
+
+}  // namespace
+
+void CCodec_ProgressiveDecoder::CFXCODEC_WeightTable::Calc(int dest_len,
+                                                           int dest_min,
+                                                           int dest_max,
+                                                           int src_len,
+                                                           int src_min,
+                                                           int src_max,
+                                                           FX_BOOL bInterpol) {
   if (m_pWeightTables) {
     FX_Free(m_pWeightTables);
   }
   double scale, base;
   scale = (FX_FLOAT)src_len / (FX_FLOAT)dest_len;
   if (dest_len < 0) {
     base = (FX_FLOAT)(src_len);
   } else {
     base = 0.0f;
   }
@@ skipping 77 matching lines @@
       double weight = area_start >= area_end ? 0.0f : area_end - area_start;
       if (weight == 0 && j == end_i) {
         pixel_weights.m_SrcEnd--;
         break;
       }
       pixel_weights.m_Weights[j - start_i] =
           FXSYS_round((FX_FLOAT)(weight * 65536));
     }
   }
 }
-void CFXCODEC_HorzTable::Calc(int dest_len, int src_len, FX_BOOL bInterpol) {
+void CCodec_ProgressiveDecoder::CFXCODEC_HorzTable::Calc(int dest_len,
+                                                         int src_len,
+                                                         FX_BOOL bInterpol) {
   if (m_pWeightTables) {
     FX_Free(m_pWeightTables);
   }
   double scale = (double)dest_len / (double)src_len;
   m_ItemSize = sizeof(int) * 4;
   int size = dest_len * m_ItemSize + 4;
   m_pWeightTables = FX_Alloc(uint8_t, size);
   if (m_pWeightTables == NULL) {
     return;
   }
@@ skipping 39 matching lines @@
   for (int des_col = 0; des_col < dest_len; des_col++) {
     double src_col_f = des_col / scale;
     int src_col = FXSYS_round((FX_FLOAT)src_col_f);
     PixelWeight* pWeight =
         (PixelWeight*)(m_pWeightTables + des_col * m_ItemSize);
     pWeight->m_SrcStart = pWeight->m_SrcEnd = src_col;
     pWeight->m_Weights[0] = 65536;
     pWeight->m_Weights[1] = 0;
   }
 }
-void CFXCODEC_VertTable::Calc(int dest_len, int src_len) {
+void CCodec_ProgressiveDecoder::CFXCODEC_VertTable::Calc(int dest_len,
+                                                         int src_len) {
   if (m_pWeightTables) {
     FX_Free(m_pWeightTables);
   }
   double scale = (double)dest_len / (double)src_len;
   m_ItemSize = sizeof(int) * 4;
   int size = dest_len * m_ItemSize + 4;
   m_pWeightTables = FX_Alloc(uint8_t, size);
   if (m_pWeightTables == NULL) {
     return;
   }
@@ skipping 100 matching lines @@
     m_pCodecMgr->GetBmpModule()->Finish(m_pBmpContext);
   }
   if (m_pTiffContext) {
     m_pCodecMgr->GetTiffModule()->DestroyDecoder(m_pTiffContext);
   }
   FX_Free(m_pSrcBuf);
   FX_Free(m_pDecodeBuf);
   FX_Free(m_pSrcPalette);
 }
 FX_BOOL CCodec_ProgressiveDecoder::JpegReadMoreData(
-    ICodec_JpegModule* pJpegModule,
+    CCodec_JpegModule* pJpegModule,
     FXCODEC_STATUS& err_status) {
   uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
     return FALSE;
   }
   dwSize = dwSize - m_offSet;
   uint32_t dwAvail = pJpegModule->GetAvailInput(m_pJpegContext, NULL);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
@@ skipping 237 matching lines @@
                                      pCodec->m_SrcFormat);
     if (pCodec->m_SrcPassNumber == 1 && scale_y > 1.0) {
       pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
       return;
     }
     if (pass == 6 && scale_y > 1.0) {
       pCodec->ResampleVert(pDIBitmap, scale_y, des_row);
     }
   }
 }
-FX_BOOL CCodec_ProgressiveDecoder::GifReadMoreData(ICodec_GifModule* pGifModule,
+FX_BOOL CCodec_ProgressiveDecoder::GifReadMoreData(CCodec_GifModule* pGifModule,
                                                    FXCODEC_STATUS& err_status) {
   uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
     return FALSE;
   }
   dwSize = dwSize - m_offSet;
   uint32_t dwAvail = pGifModule->GetAvailInput(m_pGifContext, NULL);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
@@ skipping 261 matching lines @@
           return;
       }
     }
   }
   int des_bottom = des_top + m_sizeY - 1;
   if (des_row + (int)(2 * scale_y) >= des_bottom &&
       des_row + (int)scale_y < des_bottom) {
     GifDoubleLineResampleVert(pDeviceBitmap, scale_y, des_row + (int)scale_y);
   }
 }
-FX_BOOL CCodec_ProgressiveDecoder::BmpReadMoreData(ICodec_BmpModule* pBmpModule,
+FX_BOOL CCodec_ProgressiveDecoder::BmpReadMoreData(CCodec_BmpModule* pBmpModule,
                                                    FXCODEC_STATUS& err_status) {
   uint32_t dwSize = (uint32_t)m_pFile->GetSize();
   if (dwSize <= m_offSet) {
     return FALSE;
   }
   dwSize = dwSize - m_offSet;
   uint32_t dwAvail = pBmpModule->GetAvailInput(m_pBmpContext, NULL);
   if (dwAvail == m_SrcSize) {
     if (dwSize > FXCODEC_BLOCK_SIZE) {
       dwSize = FXCODEC_BLOCK_SIZE;
@@ skipping 153 matching lines @@
   uint32_t size = (uint32_t)m_pFile->GetSize();
   if (size > FXCODEC_BLOCK_SIZE) {
     size = FXCODEC_BLOCK_SIZE;
   }
   FX_Free(m_pSrcBuf);
   m_pSrcBuf = FX_Alloc(uint8_t, size);
   FXSYS_memset(m_pSrcBuf, 0, size);
   m_SrcSize = size;
   switch (imageType) {
     case FXCODEC_IMAGE_BMP: {
-      ICodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
+      CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
       if (pBmpModule == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pBmpModule->InputImagePositionBufCallback =
           BmpInputImagePositionBufCallback;
       pBmpModule->ReadScanlineCallback = BmpReadScanlineCallback;
       m_pBmpContext = pBmpModule->Start((void*)this);
       if (m_pBmpContext == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
@@ skipping 34 matching lines @@
         return TRUE;
       }
       if (m_pBmpContext) {
         pBmpModule->Finish(m_pBmpContext);
         m_pBmpContext = NULL;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_JPG: {
-      ICodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
+      CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
       if (pJpegModule == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       m_pJpegContext = pJpegModule->Start();
       if (m_pJpegContext == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       FX_BOOL bResult = m_pFile->ReadBlock(m_pSrcBuf, 0, size);
@@ skipping 22 matching lines @@
         return TRUE;
       }
       if (m_pJpegContext) {
         pJpegModule->Finish(m_pJpegContext);
         m_pJpegContext = NULL;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_PNG: {
-      ICodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
+      CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
       if (pPngModule == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pPngModule->ReadHeaderCallback =
           CCodec_ProgressiveDecoder::PngReadHeaderFunc;
       pPngModule->AskScanlineBufCallback =
           CCodec_ProgressiveDecoder::PngAskScanlineBufFunc;
       pPngModule->FillScanlineBufCompletedCallback =
           CCodec_ProgressiveDecoder::PngFillScanlineBufCompletedFunc;
@@ skipping 40 matching lines @@
       if (m_pPngContext) {
         pPngModule->Finish(m_pPngContext);
         m_pPngContext = NULL;
       }
       if (m_SrcPassNumber == 0) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
     } break;
     case FXCODEC_IMAGE_GIF: {
-      ICodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
+      CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
       if (pGifModule == NULL) {
         m_status = FXCODEC_STATUS_ERR_MEMORY;
         return FALSE;
       }
       pGifModule->RecordCurrentPositionCallback =
           CCodec_ProgressiveDecoder::GifRecordCurrentPositionCallback;
       pGifModule->AskLocalPaletteBufCallback =
           CCodec_ProgressiveDecoder::GifAskLocalPaletteBufCallback;
       pGifModule->InputRecordPositionBufCallback =
           CCodec_ProgressiveDecoder::GifInputRecordPositionBufCallback;
@@ skipping 31 matching lines @@
         return TRUE;
       }
       if (m_pGifContext) {
         pGifModule->Finish(m_pGifContext);
         m_pGifContext = NULL;
       }
       m_status = FXCODEC_STATUS_ERR_FORMAT;
       return FALSE;
     } break;
     case FXCODEC_IMAGE_TIF: {
-      ICodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
+      CCodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
       if (pTiffModule == NULL) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
       m_pTiffContext = pTiffModule->CreateDecoder(m_pFile);
       if (m_pTiffContext == NULL) {
         m_status = FXCODEC_STATUS_ERR_FORMAT;
         return FALSE;
       }
       int32_t frames = 0;
@@ skipping 559 matching lines @@
     return FXCODEC_STATUS_ERROR;
   }
   switch (m_imagType) {
     case FXCODEC_IMAGE_BMP:
     case FXCODEC_IMAGE_JPG:
     case FXCODEC_IMAGE_PNG:
     case FXCODEC_IMAGE_TIF:
       frames = m_FrameNumber = 1;
       return m_status = FXCODEC_STATUS_DECODE_READY;
     case FXCODEC_IMAGE_GIF: {
-      ICodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
+      CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
       while (TRUE) {
         int32_t readResult =
             pGifModule->LoadFrameInfo(m_pGifContext, &m_FrameNumber);
         while (readResult == 2) {
           FXCODEC_STATUS error_status = FXCODEC_STATUS_ERR_READ;
           if (!GifReadMoreData(pGifModule, error_status)) {
             return error_status;
           }
           if (pPause && pPause->NeedToPauseNow()) {
             return m_status = FXCODEC_STATUS_FRAME_TOBECONTINUE;
@@ skipping 68 matching lines @@
     }
     if (out_range_y > 0) {
       m_clipBox.bottom -= (int32_t)FXSYS_floor((FX_FLOAT)out_range_y * scaleY);
     }
   }
   if (m_clipBox.IsEmpty()) {
     return FXCODEC_STATUS_ERR_PARAMS;
   }
   switch (m_imagType) {
     case FXCODEC_IMAGE_JPG: {
-      ICodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
+      CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
       int down_scale = 1;
       GetDownScale(down_scale);
       FX_BOOL bStart = pJpegModule->StartScanline(m_pJpegContext, down_scale);
       while (!bStart) {
         FXCODEC_STATUS error_status = FXCODEC_STATUS_ERROR;
         if (!JpegReadMoreData(pJpegModule, error_status)) {
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = error_status;
         }
@@ skipping 15 matching lines @@
           m_SrcFormat = FXCodec_Rgb;
           break;
         case 4:
           m_SrcFormat = FXCodec_Cmyk;
           break;
       }
       GetTransMethod(pDIBitmap->GetFormat(), m_SrcFormat);
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     } break;
     case FXCODEC_IMAGE_PNG: {
-      ICodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
+      CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
       if (pPngModule == NULL) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       if (m_pPngContext) {
         pPngModule->Finish(m_pPngContext);
         m_pPngContext = NULL;
       }
       m_pPngContext = pPngModule->Start((void*)this);
@@ skipping 27 matching lines @@
       GetTransMethod(m_pDeviceBitmap->GetFormat(), m_SrcFormat);
       int scanline_size = (m_SrcWidth * m_SrcComponents + 3) / 4 * 4;
       FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size);
       FXSYS_memset(m_pDecodeBuf, 0, scanline_size);
       m_WeightHorzOO.Calc(m_sizeX, m_clipBox.Width(), m_bInterpol);
       m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     } break;
     case FXCODEC_IMAGE_GIF: {
-      ICodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
+      CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
       if (pGifModule == NULL) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       m_SrcFormat = FXCodec_8bppRgb;
       GetTransMethod(m_pDeviceBitmap->GetFormat(), m_SrcFormat);
       int scanline_size = (m_SrcWidth + 3) / 4 * 4;
       FX_Free(m_pDecodeBuf);
       m_pDecodeBuf = FX_Alloc(uint8_t, scanline_size);
       FXSYS_memset(m_pDecodeBuf, 0, scanline_size);
       m_WeightHorz.Calc(m_sizeX, 0, m_sizeX, m_clipBox.Width(), 0,
                         m_clipBox.Width(), m_bInterpol);
       m_WeightVert.Calc(m_sizeY, m_clipBox.Height());
       m_FrameCur = frames;
       return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     } break;
     case FXCODEC_IMAGE_BMP: {
-      ICodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
+      CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
       if (pBmpModule == NULL) {
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERR_MEMORY;
       }
       switch (m_SrcComponents) {
         case 1:
           m_SrcFormat = FXCodec_8bppRgb;
           break;
         case 3:
@@ skipping 19 matching lines @@
       break;
   }
   return FXCODEC_STATUS_ERROR;
 }
 FXCODEC_STATUS CCodec_ProgressiveDecoder::ContinueDecode(IFX_Pause* pPause) {
   if (m_status != FXCODEC_STATUS_DECODE_TOBECONTINUE) {
     return FXCODEC_STATUS_ERROR;
   }
   switch (m_imagType) {
     case FXCODEC_IMAGE_JPG: {
-      ICodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
+      CCodec_JpegModule* pJpegModule = m_pCodecMgr->GetJpegModule();
       while (TRUE) {
         FX_BOOL readRes =
             pJpegModule->ReadScanline(m_pJpegContext, m_pDecodeBuf);
         while (!readRes) {
           FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
           if (!JpegReadMoreData(pJpegModule, error_status)) {
             m_pDeviceBitmap = NULL;
             m_pFile = NULL;
             return m_status = error_status;
           }
           readRes = pJpegModule->ReadScanline(m_pJpegContext, m_pDecodeBuf);
         }
         if (m_SrcFormat == FXCodec_Rgb) {
           int src_Bpp = (m_SrcFormat & 0xff) >> 3;
           _RGB2BGR(m_pDecodeBuf + m_clipBox.left * src_Bpp, m_clipBox.Width());
         }
         if (m_SrcRow >= m_clipBox.bottom) {
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_DECODE_FINISH;
         }
         Resample(m_pDeviceBitmap, m_SrcRow, m_pDecodeBuf, m_SrcFormat);
         m_SrcRow++;
         if (pPause && pPause->NeedToPauseNow()) {
           return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
         }
       }
     } break;
     case FXCODEC_IMAGE_PNG: {
-      ICodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
+      CCodec_PngModule* pPngModule = m_pCodecMgr->GetPngModule();
       while (TRUE) {
         uint32_t remain_size = (uint32_t)m_pFile->GetSize() - m_offSet;
         uint32_t input_size =
             remain_size > FXCODEC_BLOCK_SIZE ? FXCODEC_BLOCK_SIZE : remain_size;
         if (input_size == 0) {
           if (m_pPngContext) {
             pPngModule->Finish(m_pPngContext);
           }
           m_pPngContext = NULL;
           m_pDeviceBitmap = NULL;
@@ skipping 19 matching lines @@
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_ERROR;
         }
         if (pPause && pPause->NeedToPauseNow()) {
           return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
         }
       }
     } break;
     case FXCODEC_IMAGE_GIF: {
-      ICodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
+      CCodec_GifModule* pGifModule = m_pCodecMgr->GetGifModule();
       while (TRUE) {
         int32_t readRes =
             pGifModule->LoadFrame(m_pGifContext, m_FrameCur, nullptr);
         while (readRes == 2) {
           FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
           if (!GifReadMoreData(pGifModule, error_status)) {
             m_pDeviceBitmap = NULL;
             m_pFile = NULL;
             return m_status = error_status;
           }
           if (pPause && pPause->NeedToPauseNow()) {
             return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
           }
           readRes = pGifModule->LoadFrame(m_pGifContext, m_FrameCur, nullptr);
         }
         if (readRes == 1) {
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_DECODE_FINISH;
         }
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERROR;
       }
     } break;
     case FXCODEC_IMAGE_BMP: {
-      ICodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
+      CCodec_BmpModule* pBmpModule = m_pCodecMgr->GetBmpModule();
       while (TRUE) {
         int32_t readRes = pBmpModule->LoadImage(m_pBmpContext);
         while (readRes == 2) {
           FXCODEC_STATUS error_status = FXCODEC_STATUS_DECODE_FINISH;
           if (!BmpReadMoreData(pBmpModule, error_status)) {
             m_pDeviceBitmap = NULL;
             m_pFile = NULL;
             return m_status = error_status;
           }
           if (pPause && pPause->NeedToPauseNow()) {
             return m_status = FXCODEC_STATUS_DECODE_TOBECONTINUE;
           }
           readRes = pBmpModule->LoadImage(m_pBmpContext);
         }
         if (readRes == 1) {
           m_pDeviceBitmap = NULL;
           m_pFile = NULL;
           return m_status = FXCODEC_STATUS_DECODE_FINISH;
         }
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_ERROR;
       }
     } break;
     case FXCODEC_IMAGE_TIF: {
-      ICodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
+      CCodec_TiffModule* pTiffModule = m_pCodecMgr->GetTiffModule();
       FX_BOOL ret = FALSE;
       if (m_pDeviceBitmap->GetBPP() == 32 &&
           m_pDeviceBitmap->GetWidth() == m_SrcWidth && m_SrcWidth == m_sizeX &&
           m_pDeviceBitmap->GetHeight() == m_SrcHeight &&
           m_SrcHeight == m_sizeY && m_startX == 0 && m_startY == 0 &&
           m_clipBox.left == 0 && m_clipBox.top == 0 &&
           m_clipBox.right == m_SrcWidth && m_clipBox.bottom == m_SrcHeight) {
         ret = pTiffModule->Decode(m_pTiffContext, m_pDeviceBitmap);
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
@@ skipping 121 matching lines @@
         m_pDeviceBitmap = NULL;
         m_pFile = NULL;
         return m_status = FXCODEC_STATUS_DECODE_FINISH;
       }
     } break;
     default:
       break;
   }
   return FXCODEC_STATUS_ERROR;
 }
-ICodec_ProgressiveDecoder* CCodec_ModuleMgr::CreateProgressiveDecoder() {
+CCodec_ProgressiveDecoder* CCodec_ModuleMgr::CreateProgressiveDecoder() {
   return new CCodec_ProgressiveDecoder(this);
 }