C++ CAAFBuiltinDefs::cdInterpolationDefinition方法代码示例

IAAFInterpolationDef *AAFDomainUtils::CreateInterpolationDefinition(IAAFDictionary *dict, aafUID_t interpolationDefID)
{
    IAAFInterpolationDef	*interpDef;
    AAFRESULT				rc;

    CAAFBuiltinDefs defs (dict);

    rc = dict->LookupInterpolationDef(interpolationDefID,&interpDef);
    if(rc == AAFRESULT_SUCCESS && interpDef != NULL)
        return interpDef;

//	dprintf("AEffect::CreateInterpolationDefinition()\n");	//JeffB:

    (void)(defs.cdInterpolationDefinition()->
           CreateInstance(IID_IAAFInterpolationDef,
                          (IUnknown **)&interpDef));
    if(memcmp(&interpolationDefID, &LinearInterpolator, sizeof(aafUID_t)) == 0)
    {
        (void)(interpDef->Initialize(interpolationDefID, L"LinearInterp", L"Linear keyframe interpolation"));
        dict->RegisterInterpolationDef(interpDef);
    }
    else
    {
        interpDef->Release();
        interpDef = NULL;
    }

//cleanup:
    return(interpDef);
}

static HRESULT RegisterDefs (IAAFDictionary * pDict)
{
  assert (pDict);

  CAAFBuiltinDefs defs (pDict);

  
//  IAAFTypeDefSP pTypeUInt8;
//  checkResult(pDict->LookupTypeDef(kAAFTypeID_UInt8, &pTypeUInt8));
  { // Create an opaque type and register it in the dictionary.
    IAAFTypeDefSP pOpaqueType;
    IAAFTypeDefRenameSP pOpaqueTestType;
	  checkResult(pDict->CreateMetaInstance(AUID_AAFTypeDefRename, IID_IAAFTypeDefRename, (IUnknown **)&pOpaqueTestType));
    checkResult(pOpaqueTestType->Initialize(kTestTypeID, defs.tdUInt8(), L"TestUInt8"));
    checkResult(pOpaqueTestType->QueryInterface(IID_IAAFTypeDef, (void **)&pOpaqueType));
    checkResult(pDict->RegisterOpaqueTypeDef(pOpaqueType));
  }

  RegisterOneMetaDef (/* dictionary*/      pDict,
				  /* def object's class id */      AUID_AAFTypeDefRename,
				  /* IID of def to pass to Init */ IID_IAAFTypeDefRename,
				  /* SP of def to use with Init */ IAAFTypeDefRenameSP,
				  /* Init() invocation */
				  Initialize (kTestTypeID, defs.tdUInt8(), L"TestUInt8"),
				  /* IID of type to QI */          IID_IAAFMetaDefinition,
				  /* SP for type to QI */          IAAFMetaDefinitionSP,
				  /* IID of def to register */     IID_IAAFTypeDef,
				  /* SP for def to register */     IAAFTypeDefSP,
				  /* reg method on pDict */        RegisterTypeDef);

  { // Make sure that "TestUInt8" is no longer opaque.
    IAAFTypeDefSP pOpaqueTestType;
    checkExpression(FAILED(pDict->LookupOpaqueTypeDef(kTestTypeID, &pOpaqueTestType)),
                    AAFRESULT_TEST_FAILED);
  }

    
  RegisterOneDef (/* dictionary*/                  pDict,
				  /* def object's class */         defs.cdDataDef(),
				  /* IID of def to pass to Init */ IID_IAAFDataDef,
				  /* SP of def to use with Init */ IAAFDataDefSP,
				  /* Init() invocation */
				  Initialize (kTestDataDefID, L"TestDataDef", L"Desc"),
				  /* IID of type to QI */          IID_IAAFDefObject,
				  /* SP for type to QI */          IAAFDefObjectSP,
				  /* IID of def to register */     IID_IAAFDataDef,
				  /* SP for def to register */     IAAFDataDefSP,
				  /* reg method on pDict */        RegisterDataDef);
  
  RegisterOneDef (/* dictionary*/                  pDict,
				  /* def object's class */         defs.cdOperationDef(),
				  /* IID of def to pass to Init */ IID_IAAFOperationDef,
				  /* SP of def to use with Init */ IAAFOperationDefSP,
				  /* Init() invocation */
				  Initialize (kTestOperationDefID, L"TestOperationDef", L"Desc"),
				  /* IID of type to QI */          IID_IAAFDefObject,
				  /* SP for type to QI */          IAAFDefObjectSP,
				  /* IID of def to register */     IID_IAAFOperationDef,
				  /* SP for def to register */     IAAFOperationDefSP,
				  /* reg method on pDict */        RegisterOperationDef);

  // Hack!
  {
	IAAFOperationDefSP od;
	checkResult (pDict->LookupOperationDef (kTestOperationDefID,
										    &od));
	checkResult (od->SetDataDef (defs.ddkAAFMatte()));
  }  
  
  RegisterOneDef (/* dictionary*/                  pDict,
				  /* def object's class */         defs.cdParameterDef(),
				  /* IID of def to pass to Init */ IID_IAAFParameterDef,
				  /* SP of def to use with Init */ IAAFParameterDefSP,
				  /* Init() invocation */
				  Initialize (kTestParameterDefID, L"TestParameterDef", L"Desc", defs.tdRational()),
				  /* IID of type to QI */          IID_IAAFDefObject,
				  /* SP for type to QI */          IAAFDefObjectSP,
				  /* IID of def to register */     IID_IAAFParameterDef,
				  /* SP for def to register */     IAAFParameterDefSP,
				  /* reg method on pDict */        RegisterParameterDef);

				  RegisterOneDef (/* dictionary*/                  pDict,
				  /* def object's class */         defs.cdCodecDef(),
				  /* IID of def to pass to Init */ IID_IAAFCodecDef,
				  /* SP of def to use with Init */ IAAFCodecDefSP,
				  /* Init() invocation */
				  Initialize (kTestCodecDefID, L"TestCodecDef", L"Desc"),
				  /* IID of type to QI */          IID_IAAFDefObject,
				  /* SP for type to QI */          IAAFDefObjectSP,
				  /* IID of def to register */     IID_IAAFCodecDef,
				  /* SP for def to register */     IAAFCodecDefSP,
				  /* reg method on pDict */        RegisterCodecDef);

  // Hack! Codec defs must have at least one data def appended in
  // order to be saved correctly...
  {
	IAAFCodecDefSP cd;
	IAAFClassDefSP pClassDef;
	checkResult (pDict->LookupCodecDef (kTestCodecDefID,
										&cd));
//.........这里部分代码省略.........

static HRESULT CreateAAFFile(
    aafWChar * pFileName,
    aafUID_constref fileKind,
    testRawStorageType_t rawStorageType,
    aafProductIdentification_constref productID)
{
	IAAFFile*			pFile = NULL;
	IAAFHeader *		pHeader = NULL;
	IAAFDictionary*		pDictionary = NULL;
	IAAFDefObject*		pDef = NULL;
	IAAFInterpolationDef*	pInterpolationDef = NULL;
	bool				bFileOpen = false;
	HRESULT				hr = S_OK;
/*	long				test;
*/

  try
  {
    // Remove the previous test file if any.
    RemoveTestFile(pFileName);


	// Create the AAF file
	checkResult(CreateTestFile( pFileName, fileKind, rawStorageType, productID, &pFile ));
	bFileOpen = true;

	// We can't really do anthing in AAF without the header.
	checkResult(pFile->GetHeader(&pHeader));

    // Get the AAF Dictionary so that we can create valid AAF objects.
    checkResult(pHeader->GetDictionary(&pDictionary));
	CAAFBuiltinDefs defs (pDictionary);
    
	checkResult(defs.cdInterpolationDefinition()->
				CreateInstance(IID_IAAFInterpolationDef, 
							   (IUnknown **)&pInterpolationDef));
    
	checkResult(pInterpolationDef->QueryInterface (IID_IAAFDefObject,
                                          (void **)&pDef));

	checkResult(pInterpolationDef->Initialize(InterpDef1, sName1, sDescription1));
	checkResult(pDictionary->RegisterInterpolationDef(pInterpolationDef));
	pDef->Release();
	pDef = NULL;
	pInterpolationDef->Release();
	pInterpolationDef = NULL;
	checkResult(defs.cdInterpolationDefinition()->
				CreateInstance(IID_IAAFInterpolationDef, 
							   (IUnknown **)&pInterpolationDef));
    
	checkResult(pInterpolationDef->QueryInterface (IID_IAAFDefObject,
                                          (void **)&pDef));

	checkResult(pInterpolationDef->Initialize(InterpDef2, sName2, sDescription2));

	checkResult(pDictionary->RegisterInterpolationDef(pInterpolationDef));
  }
  catch (HRESULT& rResult)
  {
    hr = rResult;
  }


  // Cleanup and return
  if (pDef)
    pDef->Release();

  if (pInterpolationDef)
    pInterpolationDef->Release();

  if (pDictionary)
    pDictionary->Release();

  if (pHeader)
    pHeader->Release();
      
  if (pFile)
  {  // Close file
    if (bFileOpen)
	{
		pFile->Save();
		pFile->Close();
	}
     pFile->Release();
  }

  return hr;
}