开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
recognizer.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：12k
源码类别：

Symbian

开发平台：

Visual C++

recognizer.cpp：源码内容
  1. #include "ihxpckts.h"
  2. #include "hxbuffer.h"
  3. #include "hlxclib/ctype.h" /* for isspace() */
  4. #include "hxmarsh.h"      /* for getshort() */
  5. #include "recognizer.h"
  8. #define REALMEDIA_MIME_TYPE             "application/x-pn-realmedia"
  9. #define REALAUDIO_MIME_TYPE             "audio/x-pn-realaudio"
  10. #define FLASH_MIME_TYPE                 "application/x-shockwave-flash"
  11. #define REALAUDIO_METAFILE_MIME_TYPE    "audio/x-pn-realaudio"
  12. #define REALAUDIO_PLUGIN_MIME_TYPE      "audio/x-pn-realaudio-plugin"
  13. #define SMIL_MIME_TYPE                  "application/smil"
  16. // length of buffer read from file and passed to recognizer
  17. #if defined(_UNIX) && !defined(_MAC_UNIX)
  18. // we want a little more data, since we need to try to detect smil, ram and mp3
  19. #define RECOG_LEN 4096
  20. #else
  21. #define RECOG_LEN 512
  22. #endif
  23.  
  25. #if !defined (_SYMBIAN)
  26. HX_RESULT CHXFileRecognizer::GetMimeType(const char* pFileName, IHXBuffer* pBuffer, REF(IHXBuffer*) pMimeType)
  27. {
  28.     HX_RESULT res = HXR_FAIL;
  29.     const char* pMimeTypeStr = NULL;
  31. #if defined(_UNIX) && !defined(_MAC_UNIX)
  32.     do
  33.     {
  34. res = GetMimeTypeFromMagic(pBuffer, pMimeTypeStr);
  35. if (SUCCEEDED(res))
  36.     break;
  38. res = TestSMILFile(pBuffer, pFileName, pMimeTypeStr);
  39. if (SUCCEEDED(res))
  40.     break;
  42. res = TestRAMFile(pBuffer, pFileName, pMimeTypeStr);
  43. if (SUCCEEDED(res))
  44.     break;
  46. res = TestMP3File(pBuffer, pFileName, pMimeTypeStr);
  47.     }
  48.     while (0);
  50. #else // #if defined(_UNIX) && !defined(_MAC_UNIX)
  52.     if (IsSDPFile(pBuffer))
  53.     {
  54. pMimeTypeStr = "application/sdp";
  55. res = HXR_OK;
  56.     }
  58. #endif // #if defined(_UNIX) && !defined(_MAC_UNIX)
  60.     if (pMimeTypeStr)
  61.     {
  62.         // convert mime type to IHXBuffer
  63.         pMimeType = new CHXBuffer;
  64.         if (pMimeType)
  65.         {
  66.             pMimeType->AddRef();
  68.             int len = strlen(pMimeTypeStr);
  69.     res = pMimeType->Set((const UCHAR*)pMimeTypeStr, len + 1);
  70.     if (FAILED(res))
  71.     {
  72. HX_RELEASE(pMimeType);
  73.     }
  74.         }
  75. else
  76. {
  77.     res = HXR_OUTOFMEMORY;
  78. }
  79.     }
  81.     return res;
  82. }
  83. #endif
  86. #if defined(_UNIX) && !defined(_MAC_UNIX)
  89. HX_RESULT
  90. CHXFileRecognizer::GetMimeTypeFromMagic(IHXBuffer* pBuffer,
  91. REF(const char*) pMimeType)
  92. {
  93.     HX_RESULT res = HXR_FAIL;
  94.     pMimeType = NULL;
  95.     HX_ASSERT(pBuffer);
  97.     if (pBuffer && pBuffer->GetSize())
  98.     {
  99. UCHAR* pData = pBuffer->GetBuffer();
  100. UINT32 uLength = pBuffer->GetSize();
  102. // map magic data to a mime type
  103. typedef struct
  104. {
  105.     UINT32 uOffset;
  106.     const char* pMagic;
  107.     UINT32 uLength;
  108.     const char* pMimeType;
  109. } magic_data;
  111. // these are the magic tricks we know
  112. const magic_data kMagicMap[] =
  113.     {
  114. { 0, "v=",               2, "application/sdp" },
  115. { 0, ".RA ",             4, REALAUDIO_MIME_TYPE },
  116. { 0, ".RMF",             4, REALMEDIA_MIME_TYPE },
  117. { 0, ".RMS",             4, REALMEDIA_MIME_TYPE },
  118. { 0, "OggS",             4, "audio/x-ogg", },
  119. { 0, "#!AMR",            5, "audio/amr" },
  120. { 0, "WAVE",             4, "audio/x-wav" },
  121. { 0, "GIF89a",           6, "image/gif" },
  122. { 0, "GIF87a",           6, "image/gif" },
  123. { 0, "211PNG",          4, "image/png" },
  124. { 0, "377330377340", 4, "image/jpeg" },
  125. { 0, "BM",               2, "image/bmp" },
  126. { 0, "355253356333", 4, "application/x-rpm" },
  127. { 0, "FWS",              3, FLASH_MIME_TYPE },
  128. { 0, "CWS",              3, FLASH_MIME_TYPE },
  129. { 0, "#EXTM3U",          7, "audio/scpls" },
  130. { 0, NULL, 0, NULL } // null terminator
  131.     };
  133. // find a matching magic string
  134. for (const magic_data* pCursor = kMagicMap; pCursor->pMagic; ++pCursor)
  135. {
  136.     if (pCursor->uOffset + pCursor->uLength < uLength &&
  137. memcmp(pData + pCursor->uOffset, 
  138.        pCursor->pMagic, pCursor->uLength) == 0)
  139.     {
  140. pMimeType = pCursor->pMimeType;
  141. res = HXR_OK;
  142. break;
  143.     }
  144. }
  145.     }
  147.     return res;
  148. }
  150. HX_RESULT
  151. CHXFileRecognizer::TestMP3File(IHXBuffer* pBuffer,
  152.        const char* pFileName,
  153.        REF(const char*) pMimeType)
  154. {
  155.     HX_RESULT res = HXR_FAIL;
  156.     HX_ASSERT(pBuffer);
  158.     BOOL bMPA = FALSE;
  159.     BOOL bID3 = FALSE;
  161.     if (pBuffer->GetSize() >= 4)
  162.     {
  163. const char* pBegin = (const char*)pBuffer->GetBuffer();
  165. // XXXNH: I stole this from /usr/share/misc/magic and it seems to
  166. // do a good job of guessing mp3
  167. UINT16 uShort = getshort((UINT8*)pBegin);
  169. if ((uShort & 0xffe0) == 0xffe0 &&
  170.     (uShort & 0x0018) != 0x0008 &&
  171.     (uShort & 0x0006) != 0x0000)
  172. {
  173.     bMPA = TRUE;
  174. }
  176. else if (memcmp(pBegin, "ID303", 4) == 0)
  177. {
  178.     bID3 = TRUE;
  179. }
  180.     }
  182.     if (bMPA || bID3)
  183.     {
  184. res = HXR_OK;
  185. pMimeType = "audio/mp3";
  186.     }
  188.     return res;
  189. }
  192. HX_RESULT
  193. CHXFileRecognizer::TestSMILFile(IHXBuffer* pBuffer,
  194. const char* pFileName,
  195. REF(const char*) pMimeType)
  196. {
  197.     HX_RESULT res = HXR_FAIL;
  198.     HX_ASSERT(pBuffer);
  200.     const char* pExt = strrchr(pFileName, '.');
  201.     BOOL bValidExt = pExt && (strcasecmp(pExt, ".smi") == 0 ||
  202.       strcasecmp(pExt, ".smil") == 0);
  204.     const char* pBegin = (const char*)pBuffer->GetBuffer();
  205.     UINT32 uLen = pBuffer->GetSize();
  206.     const char* pEnd = (const char*)((UINT32)pBegin + uLen);
  208.     BOOL bSMILFound = FALSE;
  209.     BOOL bBodyFound = FALSE;
  210.     for (const char* pCursor = pBegin; 
  211.  (!bSMILFound || !bBodyFound) && pCursor && pCursor < pEnd; 
  212.  pCursor = strpbrk(pCursor+1, "nr")) // next line
  213.     {
  214. // eat whitespace
  215. while (isspace(*pCursor) && pCursor < pEnd)
  216.     ++pCursor;
  218. const char* pTag = strchr(pCursor, '<');
  219. while (pTag && (!bSMILFound || !bBodyFound))
  220. {
  221.     if (!bSMILFound && strncasecmp(pTag, "<smil", 5) == 0)
  222.     {
  223. bSMILFound = TRUE;
  224.     }
  225.     else if (!bBodyFound && strncasecmp(pTag, "<body", 5) == 0)
  226.     {
  227. bBodyFound = TRUE;
  228.     }
  229.     pTag = strchr(pTag+1, '<');
  230. }
  231.     }
  233.     if (bSMILFound && (bBodyFound || bValidExt))
  234.     {
  235. // very likely a SMIL file
  236. pMimeType = SMIL_MIME_TYPE;
  237. res = HXR_OK;
  238.     }
  240.     return res;
  241. }
  244. HX_RESULT
  245. CHXFileRecognizer::TestRAMFile(IHXBuffer* pBuffer,
  246.        const char* pFileName,
  247.        REF(const char*) pMimeType)
  248. {
  249.     HX_RESULT res = HXR_FAIL;
  250.     HX_ASSERT(pBuffer);
  252.     const char* pBegin = (const char*)pBuffer->GetBuffer();
  253.     UINT32 uLen = pBuffer->GetSize();
  254.     const char* pEnd = (const char*)((UINT32)pBegin + uLen);
  256.     BOOL bProtocolFound = FALSE;
  257.     BOOL bHTML = FALSE;
  258.     for (const char* pCursor = pBegin; pCursor && pCursor < pEnd; 
  259.  pCursor = strpbrk(pCursor+1, "nr")) // next line
  260.     {
  261. // eat whitespace
  262. while (isspace(*pCursor) && pCursor < pEnd)
  263.     ++pCursor;
  265. if (pCursor && pCursor < pEnd && *pCursor != '#') // skip comments
  266. {
  267.     // do we have an html tag?
  268.     const char* pTag = strchr(pCursor, '<');
  269.     if (pTag && strncasecmp(pCursor, "<html", 5) == 0)
  270.     {
  271. bHTML = TRUE;
  272. break;
  273.     }
  275.     // find a protocol?
  276.     if (strncasecmp(pCursor, "rtsp://", 7) == 0 ||
  277. strncasecmp(pCursor, "http://", 7) == 0 ||
  278. strncasecmp(pCursor, "file://", 7) == 0 ||
  279. strncasecmp(pCursor, "pnm://", 6) == 0)
  280.     {
  281. bProtocolFound = TRUE;
  282. break;
  283.     }
  284. }
  285.     }
  287.     if (!bHTML && bProtocolFound)
  288.     {
  289. // this is probably a RAM file
  290. const char* pExt = strrchr(pFileName, '.');
  291. if (pExt && strcasecmp(pExt, ".rpm") == 0)
  292. {
  293.     pMimeType = REALAUDIO_PLUGIN_MIME_TYPE;
  294. }
  295. else
  296. {
  297.     pMimeType = REALAUDIO_METAFILE_MIME_TYPE;
  298. }
  300. res = HXR_OK;
  301.     }
  303.     return res;
  304. }
  306. #else // #if defined(_UNIX) && !defined(_MAC_UNIX)
  310. BOOL
  311. CHXFileRecognizer::IsSDPFile(IHXBuffer* pBuffer)
  312. {
  313.     BOOL bResult = FALSE;
  315.     if (pBuffer && pBuffer->GetSize())
  316.     {
  317.         if (0 == strncmp((const char*)pBuffer->GetBuffer(), "v=", 2))
  318.         {
  319.             bResult = TRUE;
  320.         }
  321.     }
  323.     return bResult;
  324. }
  327. #endif // #if defined(_UNIX) && !defined(_MAC_UNIX)
  330. CHXFileRecognizer::CHXFileRecognizer()
  331.     : m_lRefCount(0),
  332.       m_pFile(NULL),
  333.       m_pResponse(NULL),
  334.       m_pBuffer(NULL),
  335.       m_bGetMimeTypeDone(FALSE)
  336. {
  337. }
  339. CHXFileRecognizer::~CHXFileRecognizer()
  340. {
  341.     HX_RELEASE(m_pBuffer);
  342.     HX_RELEASE(m_pResponse);
  343.     HX_RELEASE(m_pFile);
  344. }
  346. STDMETHODIMP CHXFileRecognizer::QueryInterface(REFIID riid, void** ppvObj)
  347. {
  348.     HX_RESULT ret = HXR_OK;
  350.     if (IsEqualIID(riid, IID_IHXFileRecognizer))
  351.     {
  352. AddRef();
  353. *ppvObj = (IHXFileRecognizer*)this;
  354.     }
  355.     else if (IsEqualIID(riid, IID_IHXFileResponse))
  356.     {
  357. AddRef();
  358. *ppvObj = (IHXFileResponse*)this;
  359.     }
  360.     else if (IsEqualIID(riid, IID_IUnknown))
  361.     {
  362. AddRef();
  363. *ppvObj = this;
  364.     }
  365.     else
  366.     {
  367. *ppvObj = NULL;
  368. ret = HXR_NOINTERFACE;
  369.     }
  371.     return ret;
  372. }
  374. STDMETHODIMP_(ULONG32) CHXFileRecognizer::AddRef()
  375. {
  376.     return InterlockedIncrement(&m_lRefCount);
  377. }
  379. STDMETHODIMP_(ULONG32) CHXFileRecognizer::Release()
  380. {
  381.     if (InterlockedDecrement(&m_lRefCount) > 0)
  382.     {
  383.         return m_lRefCount;
  384.     }
  386.     delete this;
  387.     return 0;
  388. }
  390. STDMETHODIMP CHXFileRecognizer::GetMimeType(IHXFileObject* /*IN*/ pFile, 
  391.     IHXFileRecognizerResponse* /*IN*/ pRecognizerResponse)
  392. {
  393.     HX_RESULT ret = HXR_FAIL;
  395.     if (pRecognizerResponse)
  396.     {
  397. m_pResponse = pRecognizerResponse;
  398. m_pResponse->AddRef();
  399.     }
  400.     
  401.     // get our own IHXFileResponse interface
  402.     IHXFileResponse* pFileResponse = NULL;
  403.     ret = QueryInterface(IID_IHXFileResponse, (void**) &pFileResponse);
  405.     if (SUCCEEDED(ret) && pFileResponse && pFile != NULL)
  406.     {
  407. m_pFile = pFile;
  408. m_pFile->AddRef();
  409.     
  410.         ret = m_pFile->Init(HX_FILE_READ | HX_FILE_BINARY, pFileResponse);
  411.     }
  413.     if (FAILED(ret) && m_pResponse)
  414.     {
  415. m_pResponse->GetMimeTypeDone(ret, NULL);
  416.     }
  417.     
  418.     HX_RELEASE(pFileResponse);
  420.     return ret;
  421. }
  423. STDMETHODIMP CHXFileRecognizer::InitDone(HX_RESULT status)
  424. {
  425.     if (SUCCEEDED(status))
  426.     {
  427. status = m_pFile->Read(RECOG_LEN);
  428.     }
  430.     if (FAILED(status) && m_pResponse)
  431.     {
  432. m_pResponse->GetMimeTypeDone(status, NULL);
  433.     }
  435.     return status;
  436. }
  438. STDMETHODIMP CHXFileRecognizer::SeekDone(HX_RESULT /* status */)
  439. {
  440.     if (!m_bGetMimeTypeDone)
  441.     {
  442.         DoFileRecognize();
  443.         HX_RELEASE(m_pBuffer);
  444.     }
  446.     return HXR_OK;
  447. }
  449. STDMETHODIMP CHXFileRecognizer::ReadDone(HX_RESULT status,
  450.  IHXBuffer* pBuffer)
  451. {
  452.     if (FAILED(status) && m_pResponse)
  453.     {
  454. m_pResponse->GetMimeTypeDone(HXR_FAIL, NULL);
  455.     }
  456.     else
  457.     {
  458.         HX_ASSERT(!m_pBuffer);
  460.         m_pBuffer = pBuffer;
  461.         HX_ADDREF(m_pBuffer);
  462.  
  463.          // seek back to the beginning of the file
  464.          // since the same file object will be passed to the file format
  465.         if (HXR_OK != m_pFile->Seek(0, FALSE) &&
  466.             !m_bGetMimeTypeDone)
  467.         {
  468.             DoFileRecognize();
  469.             HX_RELEASE(m_pBuffer);
  470.         }
  471.     }
  473.     return HXR_OK;
  474. }
  476. STDMETHODIMP CHXFileRecognizer::WriteDone(HX_RESULT /* status */)
  477. {
  478.     return HXR_OK;
  479. }
  481. STDMETHODIMP CHXFileRecognizer::CloseDone(HX_RESULT /* status */)
  482. {
  483.     return HXR_OK;
  484. }
  486. void
  487. CHXFileRecognizer::DoFileRecognize(void)
  488. {
  489.     HX_RESULT   ret = HXR_OK;
  490.     IHXBuffer*  pMimeType = NULL;
  491.     const char* pFileName = NULL;
  493.     m_bGetMimeTypeDone = TRUE;
  495.     if (m_pFile)
  496. m_pFile->GetFilename(pFileName);
  498.     ret = GetMimeType(pFileName, m_pBuffer, pMimeType);
  500.     if (SUCCEEDED(ret) && 
  501. pMimeType && 
  502. pMimeType->GetSize() > 0 && 
  503. m_pResponse)
  504.     {
  505. m_pResponse->GetMimeTypeDone(HXR_OK, pMimeType);
  506.     }
  507.     else
  508.     {
  509. m_pResponse->GetMimeTypeDone(HXR_FAIL, NULL);
  510.     }
  512.     HX_RELEASE(pMimeType);
  513. }