[Helix-client-dev] Fixed audiohash generation bug [GMPMetaEditor]

Index: main.cpp
===================================================================
RCS file: /cvsroot/datatype/tools/dtdriver/apps/meta3gp/main.cpp,v
retrieving revision 1.7.2.6
diff -d -H -w -U 30 -r1.7.2.6 main.cpp
--- main.cpp	20 Jan 2010 20:00:58 -0000	1.7.2.6
+++ main.cpp	10 Feb 2010 09:27:40 -0000
@@ -38,61 +38,61 @@
  *  Includes
  */
 #include <stdlib.h>
 #include <stdarg.h>
 
 #include "hlxclib/time.h"
 #include "hlxclib/stdio.h"
 #include "hlxclib/wchar.h"
 #include "hxtypes.h"
 #include "hlxosstr.h"
 #include "ffdriver.h"
 #include "cstrmsrt.h"
 #include "hxmemprb.h"
 #include "hxtick.h"
 #include "chxpckts.h"
 #include "pckunpck.h"
 #include "dllpath.h"
 #include "filespecutils.h"
 #include "metainfokeys.h"
 #include "uniconv.h"
 #include "proptools.h"
 #include "dllacces.h"
 #include "ihxmetaeditor.h"
 #include "HXXmlInputParser.h"
 #include "metautil.h"
 
 #include "meta3gp.ver"
 
 #ifdef HELIX_FEATURE_METAEDIT_AUDIO_HASH
 #include "mycrypt.h"
-#endif
+#endif //HELIX_FEATURE_METAEDIT_AUDIO_HASH
 
 
 /****************************************************************************
  *  Meta-data command line editor.
  *  Build-time configuration options.
  */
 
 // environment variable name
 #define PLUGIN_PATH_ENV_VAR_NAME "META3GP_PLUGIN_PATH"
 
 
 /****************************************************************************
  *  Component operational modes
  */
 HXBOOL g_bUseDefaultMetaEditorProcessor = FALSE;
 HXBOOL g_bUseDTDriverSynchronousMode = TRUE;
 
 
 /****************************************************************************
  *  DLLAccessPath Variable
  */
 ENABLE_DLLACCESS_PATHS(g_Meta3GPAccessPath);
 
 
 /****************************************************************************
  *  Defines
  */
 #define PROGRAM_VENDOR_STRING       "RealNetworks"
 #define PROGRAM_NAME_STRING         PROGRAM_VENDOR_STRING" meta-data editor"
 #define PROGRAM_COPYRIGHT_STRING    "Copyright (c) "PROGRAM_VENDOR_STRING" 2010"
@@ -669,61 +669,61 @@
     }
 
     static void ClearAPICFrameArray(CHXPtrArray& a)
     {
         for(INT32 i = 0; i < a.GetSize(); i++)
         {
             delete (ID3Tools::APICFrame*)a[i];
         }
         a.RemoveAll();
     }
 
     // meta-data input params
     HXBOOL ClearMetaData;
     HXBOOL ClearKeywords;
     HXBOOL ClearPictures;
     HXBOOL GenerateHash;
     UINT32 InjectedMetaFlavors;
     MetaInfo InjectedMetaInfo;
     CHXPtrArray AddedKeywords; //EncodedString pointers
     CHXPtrArray RemovedKeywords; //EncodedString pointers
     CHXPtrArray AddedPictures; //ID3Tools::APICFrame pointers
     CHXPtrArray RemovedPictures; //Integers
 
     // meta-data output storage
     MetaInfo ExtractedMetaInfo;
     MetaInfo OutboundMetaInfo;
 
 #ifdef HELIX_FEATURE_METAEDIT_AUDIO_HASH
     unsigned char SHAHash[32];
     hash_state HashState;
-#endif
+#endif //HELIX_FEATURE_METAEDIT_AUDIO_HASH
 };
 
 struct InputOption
 {
     InputOption(const CHXString& optionName,
                 const EncodedString& optionValueUTF8 = EncodedString(),
                 const EncodedString& xmlOptionValueUTF8 = EncodedString())
         : OptionName(optionName)
         , OptionValueUTF8(optionValueUTF8)
         , XmlOptionValueUTF8(xmlOptionValueUTF8)
     {
     }
 
     // XML value has precedence over command-line value
     const EncodedString& GetEffectiveOptionValueUTF8() const
     {
         return XmlOptionValueUTF8.IsEmpty() ? OptionValueUTF8 : XmlOptionValueUTF8;
     }
 
     // XML value has precedence over command-line value
     CHXString GetEffectiveOptionValueCCP() const
     {
         const EncodedString& val = GetEffectiveOptionValueUTF8();
         return CHXString((const char*)CCPFromUTF8(val.GetData()));
     }
 
     CHXString OptionName;
     EncodedString OptionValueUTF8;
     EncodedString XmlOptionValueUTF8;
 };
@@ -1675,86 +1675,86 @@
 
         // transfer final item set to the inject sink
         if(SUCCEEDED(res))
         {
             res = mi.CopyToValues(m_pContext, pInjectSink, FALSE, METAINFO_SET_ALL);
         }
 
         return res;
     }
     STDMETHOD(OnOutboundMetaData)(IHXValues* pValues)
     {
         // keep outbound
         m_vars.OutboundMetaInfo.Clear();
         return m_vars.OutboundMetaInfo.CopyFromValues(pValues, FALSE, METAINFO_SET_ALL);
     }
 
     STDMETHOD(OnPacket)(IHXPacket* pPacket)
     {
         HX_RESULT res = HXR_OK;
 
 #ifdef HELIX_FEATURE_METAEDIT_AUDIO_HASH
         if(m_vars.GenerateHash && pPacket)
         {
             IHXBuffer* pBuffer1;
             pBuffer1 = pPacket->GetBuffer();
             if(pBuffer1 &&  pBuffer1->GetSize()!=0 && pBuffer1->GetBuffer())
             {
                 sha256_process(&m_vars.HashState, (unsigned char*)pBuffer1->GetBuffer(), (unsigned long)pBuffer1->GetSize());
             }
         }
-#endif
+#endif //HELIX_FEATURE_METAEDIT_AUDIO_HASH
         return res;
     }
 
     STDMETHOD(OnStreamHeader)(IHXValues* pValues)
     {
 #ifdef HELIX_FEATURE_METAEDIT_AUDIO_HASH
         if(m_vars.GenerateHash)
         {
              sha256_init(&m_vars.HashState);
              m_bHashGenerated = FALSE;
         }
-#endif
+#endif //HELIX_FEATURE_METAEDIT_AUDIO_HASH
         return HXR_OK;
     }
 
     STDMETHOD(OnStreamDone)(UINT16 unStreamNumber)
     {
 #ifdef HELIX_FEATURE_METAEDIT_AUDIO_HASH
         if(m_vars.GenerateHash && !m_bHashGenerated)
         {
              sha256_done(&m_vars.HashState, m_vars.SHAHash);
              // make sure, that even if there is more than one call to OnStreamDone, we execute sha finalizer just one time 
              m_bHashGenerated = TRUE;
         }
-#endif
+#endif //HELIX_FEATURE_METAEDIT_AUDIO_HASH
         return HXR_OK;
     }
 
 private:
     LONG32 m_lRefCount;
     MetaProcessorVars& m_vars;
     IUnknown* m_pContext;
     HXBOOL m_bHashGenerated;
 };
 
 
 /****************************************************************************
 *  Main entry point
 */
 int main(int argc, char* argv[])
 {
     // initialize variables
     HX_RESULT retVal = HXR_OK;
     int progRetCode = RC_SUCCESS;
 
     UINT32 startTime = 0;
     CHXFileSpecifier exeFileSpec;
     HXBOOL bUsingLog = FALSE;
 
     DLLAccess* pDLLAccess = 0;
     FPHXMEDIAPLATFORMOPEN fpHXMediaPlatformOpen = 0;
     FPHXCREATEMEDIAPLATFORM fpHXCreateMediaPlatform = 0;
     FPHXMEDIAPLATFORMCLOSE fpHXMediaPlatformClose = 0;
 
     IHXMediaPlatform* pMediaPlatform = 0;
@@ -1777,61 +1777,65 @@
     CHXString strMetaStyleName;
 
     HXBOOL bDisplayHelp = FALSE;
     HXBOOL bOverwriteFile = FALSE;
     HXBOOL bPrintMetaData = FALSE;
     HXBOOL bExtractPicturesToFiles = FALSE;
     HXBOOL bUTF16Output = FALSE;
     HXBOOL bUTF8Input = FALSE;
     UINT32 ulMetaDataID3VersionOutput = METADATAID3VERSION_240;
 
     MetaProcessorVars metaProcessorVars;
 
     // construct option registry
     OptionRegistry optionReg;
 
     optionReg.Add(new OptionDesc(OPTION_STRING_LOGFILE, "<filename>", "redirect console output to log file", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_INPUTFILE, "<filename>", "input file", 1, "/albums/album/track/mediaFile/fileName"));
     optionReg.Add(new OptionDesc(OPTION_STRING_OUTPUTFILE, "<filename>", "output file", 1, "/albums/album/track/outputFileName"));
     optionReg.Add(new OptionDesc(OPTION_STRING_XMLINPUTFILE, "<filename>", "XML file with input parameters", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_XMLOUTPUTFILE, "<filename>", "metadata output XML file", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_OVERWRITEFILE, 0, "overwrite output file if it exists", 0));
     optionReg.Add(new OptionDesc(OPTION_STRING_CLEARMETADATA, 0, "clear all extracted metadata before injection", 0));
     optionReg.Add(new OptionDesc(OPTION_STRING_METASTYLE, "<3GPP | iTunes>", "flavor of injected metadata", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_UTF16OUTPUT, 0, "use UTF16 format to store strings in output file", 0));
     optionReg.Add(new OptionDesc(OPTION_STRING_UTF8INPUT, 0, "parse command line as UTF8 strings", 0));
     optionReg.Add(new OptionDesc(OPTION_STRING_ID3V240OUTPUT, 0, "inject ID3v2 version 2.4.0, default", 0));
     optionReg.Add(new OptionDesc(OPTION_STRING_ID3V230OUTPUT, 0, "inject ID3v2 version 2.3.0", 0));
     optionReg.Add(new OptionDesc(OPTION_STRING_ID3V2NOOUTPUT, 0, "skip injecting ID3v2 tag", 0));
     optionReg.Add(new OptionDesc(OPTION_STRING_PRINTMETADATA, 0, "print updated metadata", 0));
     optionReg.Add(new OptionDesc(OPTION_STRING_PICTURE_EXTRACT, "[filename prefix]", "save extracted pictures", -1));
+
+#ifdef HELIX_FEATURE_METAEDIT_AUDIO_HASH
     optionReg.Add(new OptionDesc(OPTION_STRING_GENERATEHASH, 0, "generate hash", 0));
+#endif //HELIX_FEATURE_METAEDIT_AUDIO_HASH
+
     optionReg.Add(new OptionDesc());
     optionReg.Add(new OptionDesc(OPTION_STRING_TITLE, "<string>", "update title", 1, "/albums/album/track/name"));
     optionReg.Add(new OptionDesc(OPTION_STRING_ARTIST, "<string>", "update 3GPP performer, iTunes artist", 1, "/albums/album/track/artist/name"));
     optionReg.Add(new OptionDesc(OPTION_STRING_ALBUM, "<string>", "update album", 1, "/albums/album/name"));
     optionReg.Add(new OptionDesc(OPTION_STRING_GENRE, "<string>", "update genre", 1, "/albums/album/track/style/name"));
     optionReg.Add(new OptionDesc(OPTION_STRING_COMPOSER, "<string>", "update 3GPP author, iTunes composer", 1, "/albums/album/track/artist/composer"));
     optionReg.Add(new OptionDesc(OPTION_STRING_COMMENT, "<string>", "update 3GPP description, iTunes comment", 1, "/albums/album/pline"));
     optionReg.Add(new OptionDesc(OPTION_STRING_COPYRIGHT, "<string>", "update copyright", 1, "/albums/album/cline"));
     optionReg.Add(new OptionDesc(OPTION_STRING_TRACKNUMBER, "<integer 0..255>", "update track number", 1, "/albums/album/track/sequence"));
     optionReg.Add(new OptionDesc(OPTION_STRING_YEAR, "<integer 0..65536>", "update 3GPP recording year, iTunes release date", 1, "/albums/album/OrigReleaseYear"));
     {
         // Add picture
         CHXPtrArray* pPictureAddXPaths = new CHXPtrArray;
         pPictureAddXPaths->Add(new CHXString("/albums/album/image/fileName"));
         pPictureAddXPaths->Add(new CHXString("/albums/album/image/fileName2"));
 
         optionReg.Add(new OptionDesc(OPTION_STRING_PICTURE_ADD, "<filename>", "add picture", 1, 0, pPictureAddXPaths));
     }
     optionReg.Add(new OptionDesc(OPTION_STRING_PICTURE_REMOVE, "<APIC picture type>", "remove picture", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_PICTURE_CLEAR, 0, "clear all extracted pictures", 0));
     optionReg.Add(new OptionDesc(OPTION_STRING_UITS_INSERT, "<filename>", "insert UITS signature from file", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_UITS_EXTRACT, "<filename>", "extract UITS signature into file", 1));
     optionReg.Add(new OptionDesc());
     optionReg.Add(new OptionDesc(OPTION_STRING_SOFTWARE, "<string>", "update iTunes generator tool", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_ENCODEDBY, "<string>", "update iTunes encoded by", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_GROUPING, "<string>", "update iTunes grouping", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_ALBUMARTIST, "<string>", "update iTunes album artist", 1, "/albums/album/artist/name"));
     optionReg.Add(new OptionDesc(OPTION_STRING_LYRICS, "<string>", "update iTunes lyrics", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_SUBTITLE, "<string>", "update iTunes track subtitle", 1));
     optionReg.Add(new OptionDesc(OPTION_STRING_BPM, "<integer>", "update iTunes beats per minute", 1));
@@ -2217,64 +2221,68 @@
 #endif //_WINDOWS
 
             else if(strOption == OPTION_STRING_DEFMETAPROC)
             {
                 g_bUseDefaultMetaEditorProcessor = TRUE;
             }
             else if(strOption == OPTION_STRING_LOGFILE)
             {
                 // do nothing, already processed
             }
             else if(strOption == OPTION_STRING_INPUTFILE)
             {
                 strInputFileName = option->GetEffectiveOptionValueCCP();
             }
             else if(strOption == OPTION_STRING_OUTPUTFILE)
             {
                 strOutputFileName = option->GetEffectiveOptionValueCCP();
             }
             else if(strOption == OPTION_STRING_OVERWRITEFILE)
             {
                 bOverwriteFile = TRUE;
             }
             else if(strOption == OPTION_STRING_CLEARMETADATA)
             {
                 metaProcessorVars.ClearMetaData = TRUE;
             }
             else if(strOption == OPTION_STRING_PRINTMETADATA)
             {
                 bPrintMetaData = TRUE;
             }
+
+#ifdef HELIX_FEATURE_METAEDIT_AUDIO_HASH
             else if(strOption == OPTION_STRING_GENERATEHASH)
             {
                 metaProcessorVars.GenerateHash = TRUE;
             }
+#endif //HELIX_FEATURE_METAEDIT_AUDIO_HASH
+
             else if(strOption == OPTION_STRING_XMLINPUTFILE)
             {
                 // do nothing, already processed
             }
             else if(strOption == OPTION_STRING_XMLOUTPUTFILE)
             {
                 strOutputXMLFileName = option->GetEffectiveOptionValueCCP();
             }
             else if(strOption == OPTION_STRING_METASTYLE)
             {
                 strMetaStyleName = option->GetEffectiveOptionValueCCP();
 
                 if(clpp == CLPP_IndependentOptions)
                 {
                     if(SUCCEEDED(retVal) && !strMetaStyleName.IsEmpty())
                     {
                         if(!strMetaStyleName.CompareNoCase("3gpp"))
                         {
                             metaProcessorVars.InjectedMetaFlavors |= METADATA_FLAVOR_3GPP;
                         }
                         else if(!strMetaStyleName.CompareNoCase("itunes"))
                         {
                             metaProcessorVars.InjectedMetaFlavors |= METADATA_FLAVOR_ITUNES;
                         }
                         else
                         {
                             retVal = HXR_PARSE_ERROR;
                             progRetCode = RC_ERROR_BAD_COMMAND_LINE;
                             ReportInvalidValueForOption(OPTION_STRING_METASTYLE, option->GetEffectiveOptionValueUTF8());
                         }
@@ -2619,60 +2627,69 @@
         // writing to input file is not allowed
         if(SUCCEEDED(retVal) && (strInputFileName == strOutputFileName))
         {
             printf("File [%s] cannot be used for both input and output.\n", (const char*)strOutputFileName);
             retVal = HXR_FAIL;
             progRetCode = RC_ERROR_SAME_INPUT_OUTPUT_MEDIA_FILE;
         }
         // output file must not exist or overwrite must be specified
         if(SUCCEEDED(retVal) && NeedOverwriteConfirmation((const char*)strOutputFileName, bOverwriteFile))
         {
             retVal = HXR_FAIL;
             progRetCode = RC_ERROR_OUTPUT_MEDIA_FILE_EXISTS;
         }
     }
 
     if(FAILED(retVal))
     {
         goto cleanup;
     }
 
     // initialize options
     retVal = CreateInstanceCCF_QI(CLSID_IHXValues, IID_IHXValues,
                                     (void**)&pOptions, pCommonClassFactory);
     if(SUCCEEDED(retVal))
     {
         retVal = pOptions->SetPropertyULONG32(SYNCHRONOUS_OPTION_NAME, g_bUseDTDriverSynchronousMode ? 1 : 0);
     }
 
     if(SUCCEEDED(retVal))
     {
+        // suppress packet processing in pure extraction mode
+        if(strOutputFileName.IsEmpty() && !metaProcessorVars.GenerateHash)
+        {
+            retVal = pOptions->SetPropertyULONG32(TIMER_OPTION_NAME, 0);
+        }
+    }
+
+    if(SUCCEEDED(retVal))
+    {
         retVal = pOptions->SetPropertyULONG32(BLASTFILE_OPTION_NAME, bOverwriteFile ? 1 : 0);
     }
 
     if(SUCCEEDED(retVal))
     {
         retVal = pOptions->SetPropertyULONG32(UTF16OUTPUT_OPTION_NAME, bUTF16Output ? 1 : 0);
     }
 
     if(SUCCEEDED(retVal))
     {
         // Notify writer about the version of ID3 tag it should output.
         retVal = pOptions->SetPropertyULONG32(METADATAID3VERSION_OPTION_NAME, ulMetaDataID3VersionOutput);
     }
 
     if(SUCCEEDED(retVal))
     {
         // Notify meta-editor about the flavor of meta-data it should process.
         retVal = pOptions->SetPropertyULONG32(METADATAFLAVOR_OPTION_NAME, metaProcessorVars.InjectedMetaFlavors);
     }
 
     if(SUCCEEDED(retVal))
     {
         // Legacy ID32_BLOB property must not get in the way of newly defined properties.
         // Tell file-writer to ignore it.
         retVal = pOptions->SetPropertyULONG32(METADATAIGNORE_OPTION_NAME, METADATAIGNORE_ID32BLOB);
     }
 
     if(SUCCEEDED(retVal))
     {
         if(g_bUseDefaultMetaEditorProcessor)
@@ -2784,61 +2801,61 @@
         {
             retVal = pEditor->Drive((const char*)strInputFileName, (const char*)strOutputFileName,
                                     (IHXMetaDataProcessor*)pProcessor,
                                     pOptions, (IHXMetaDataEditorResponse*)pResponse);
 
             if(SUCCEEDED(retVal) && !g_bUseDTDriverSynchronousMode)
             {
                 WaitAsyncDriveEnd();
                 retVal = pResponse->GetTerminationStatus();
             }
         }
     }
 
     if(FAILED(retVal))
     {
         printf("Failed to process input file [%s].\n", (const char*)strInputFileName);
         progRetCode = RC_ERROR_PROCESSING_MEDIA_FILE;
         goto cleanup;
     }
 
 #ifdef HELIX_FEATURE_METAEDIT_AUDIO_HASH
     if(metaProcessorVars.GenerateHash)
     {
         printf("--- Generated hash ---\n");
         for (int i=0; i<32; i++)
         {
             printf("%x", metaProcessorVars.SHAHash[i]);
         }
         printf("\n\n");
     }
-#endif
+#endif //HELIX_FEATURE_METAEDIT_AUDIO_HASH
 
     // auto dump meta-data if extracting only
     if(strOutputFileName.IsEmpty() && !metaProcessorVars.GenerateHash)
     {
         bPrintMetaData = TRUE;
     }
 
     if(SUCCEEDED(retVal) && bPrintMetaData)
     {
         // dump extracted
         printf("--- Extracted meta-data ---\n");
         metaProcessorVars.ExtractedMetaInfo.Dump();
         printf("\n");
 
         // dump injected
         if(!g_bUseDefaultMetaEditorProcessor && !strOutputFileName.IsEmpty())
         {
             printf("--- Injected meta-data ---\n");
             metaProcessorVars.OutboundMetaInfo.Dump();
             printf("\n");
         }
     }
 
     // extract UITS data to file
     HXBOOL bErrorSavingUITSData = FALSE;
     if(SUCCEEDED(retVal) && !strUITSDataOutputFileName.IsEmpty())
     {
         EncodedString sUITSData;
         if(SUCCEEDED(metaProcessorVars.ExtractedMetaInfo.GetStringItem(MetaInfo::StringMetaItem_UITSData, sUITSData))
             && !sUITSData.IsEmpty())

Index: editor.cpp
===================================================================
RCS file: /cvsroot/datatype/tools/metaeditor/editor.cpp,v
retrieving revision 1.3
diff -d -H -w -U 30 -r1.3 editor.cpp
--- editor.cpp	1 Dec 2009 09:50:45 -0000	1.3
+++ editor.cpp	10 Feb 2010 09:23:28 -0000
@@ -315,66 +315,60 @@
         }
     }
 
     HX_RESULT retVal = HXR_OK;
 
     // make a private copy of options
     IHXValues* pPrivateOptions = 0;
     if(SUCCEEDED(retVal))
     {
         retVal = CreateInstanceCCF_QI(CLSID_IHXValues, IID_IHXValues,
                                      (void**)&pPrivateOptions, m_pContext);
         if(SUCCEEDED(retVal))
         {
             PropTools::CopyAllProperties(retVal, pPrivateOptions, pOptions);
         }
     }
     // modify options
     if(SUCCEEDED(retVal))
     {
         ULONG32 ulSynchronous = 0;
         pPrivateOptions->GetPropertyULONG32(SYNCHRONOUS_OPTION_NAME, ulSynchronous);
         m_bSynchronous = (ulSynchronous != 0) ? TRUE : FALSE;
 
         // suppress header output if not explicitly requested
         ULONG32 ulHeader = 0;
         pPrivateOptions->GetPropertyULONG32(HEADER_OPTION_NAME, ulHeader);
         if(!ulHeader)
         {
             retVal = pPrivateOptions->SetPropertyULONG32(HEADER_OPTION_NAME, 0);
         }
-
-        if(SUCCEEDED(retVal) && !bWritingFile)
-        {
-            // don't waste time reading packets in read mode
-            retVal = pPrivateOptions->SetPropertyULONG32(TIMER_OPTION_NAME, 0);
-        }
     }
 
     // create datatype driver
     HX_RELEASE(m_pDriver);
     if(SUCCEEDED(retVal))
     {
         retVal = CreateInstanceCCF_QI(CLSID_IHXDataTypeDriver, IID_IHXDataTypeDriver2,
                                          (void**)&m_pDriver, m_pContext);
     }
 
     // create meta-data source handler
     HX_RELEASE(m_pMetaDataSourceHandler);
     if(SUCCEEDED(retVal))
     {
         retVal = CreateInstanceCCF_QI(CLSID_IHXMetaDataSourceHandler, IID_IHXMetaDataSourceHandler,
                                     (void**)&m_pMetaDataSourceHandler, m_pContext);
     }
     if(SUCCEEDED(retVal))
     {
         retVal = m_pMetaDataSourceHandler->InitMetaDataSourceHandler(m_pContext);
     }
     if(SUCCEEDED(retVal))
     {
         retVal = m_pMetaDataSourceHandler->SetProcessor(pProcessor);
     }
 
     // obtain driver-response interface
     HX_RELEASE(m_pDriverResponse);
     if(SUCCEEDED(retVal))
     {