avi_handler.cpp

flash xmp sdk,flash官方SDK

		if ( altTimecodeString.size() != 0 ) {
			RewriteChunk ( fileRef, riffState, myAltTimeChunk, myTimeList, altTimecodeString.c_str() );
		}

		// Always rewrite the reel strings, even if empty, so the user can erase them.
		RewriteChunk ( fileRef, riffState, myOrgReelChunk, myTimeList, orgReelString.c_str() );
		RewriteChunk ( fileRef, riffState, myAltReelChunk, myTimeList, altReelString.c_str() );

	} else {
	
		ok = MakeChunk ( fileRef, riffState, formtypeAVI, PR_AVI_TIMELEN );
		if ( ! ok ) return; // If there's an error making a chunk, bail

		RIFF_Support::ltag listtag;
		listtag.id = MakeUns32LE ( FOURCC_LIST );
		listtag.len = MakeUns32LE ( PR_AVI_TIMELEN - 8 );
		listtag.subid = MakeUns32LE ( myTimeList );
		LFA_Write(fileRef, &listtag, 12);

		RIFF_Support::WriteChunk ( fileRef, myOrgTimeChunk, startTimecodeString.c_str(), TIMELEN );
		RIFF_Support::WriteChunk ( fileRef, myAltTimeChunk, altTimecodeString.c_str(), TIMELEN );
		RIFF_Support::WriteChunk ( fileRef, myOrgReelChunk, orgReelString.c_str(), REELLEN );
		RIFF_Support::WriteChunk ( fileRef, myAltReelChunk, altReelString.c_str(), REELLEN );

	}

	this->needsUpdate = false;

}	// AVI_MetaHandler::UpdateFile

// =================================================================================================
// AVI_MetaHandler::WriteFile
// ==========================

void AVI_MetaHandler::WriteFile ( LFA_FileRef         sourceRef,
								  const std::string & sourcePath )
{
	IgnoreParam(sourceRef); IgnoreParam(sourcePath);
	
	XMP_Throw ( "AVI_MetaHandler::WriteFile: Not supported", kXMPErr_Unavailable );

}	// AVI_MetaHandler::WriteFile

// =================================================================================================
// AVI_MetaHandler::CacheFileData
// ==============================

void AVI_MetaHandler::CacheFileData()
{
	bool ok;
	
	this->containsXMP = false;
	
	LFA_FileRef fileRef ( this->parent->fileRef );
	if ( fileRef == 0 ) return;

	RIFF_Support::RiffState riffState;
	long numTags = RIFF_Support::OpenRIFF ( fileRef, riffState );
	if ( numTags == 0 ) return;

	// Determine the size of the metadata
	unsigned long bufferSize(0);
	ok = RIFF_Support::GetRIFFChunk ( fileRef, riffState, kXMPUserDataType, 0, 0, 0, &bufferSize );

	if ( ! ok ) {

		packetInfo.writeable = true;	// If no packet found, created packets will be writeable.

	} else if ( bufferSize > 0 ) {

		// Size and clear the buffer
		this->xmpPacket.reserve ( bufferSize );
		this->xmpPacket.assign ( bufferSize, ' ' );

		// Get the metadata
		ok = RIFF_Support::GetRIFFChunk ( fileRef, riffState, kXMPUserDataType, 0, 0, (char*)this->xmpPacket.c_str(), &bufferSize );
		if ( ok ) {
			this->packetInfo.offset = kXMPFiles_UnknownOffset;
			this->packetInfo.length = bufferSize;
			this->xmpObj.ParseFromBuffer ( this->xmpPacket.c_str(), this->xmpPacket.size() );
			this->containsXMP = true;
		}

	}


	// Reconcile legacy metadata.
	
	std::string aviTimeString, orgTimeString, altTimeString;
	unsigned long aviTimeSize, orgTimeSize, altTimeSize;
	
	ok = RIFF_Support::GetRIFFChunk ( fileRef, riffState, aviTimeChunk, avihdrlChunk, 0, 0, &aviTimeSize );
	if ( ok ) {
		aviTimeString.reserve ( aviTimeSize );
		aviTimeString.assign ( aviTimeSize, ' ' );
		RIFF_Support::GetRIFFChunk ( fileRef, riffState, aviTimeChunk, avihdrlChunk, 0, (char*)aviTimeString.c_str(), &aviTimeSize );
	}

	ok = RIFF_Support::GetRIFFChunk ( fileRef, riffState, myOrgTimeChunk, myTimeList, 0, 0, &orgTimeSize );
	if ( ok ) {
		orgTimeString.reserve ( orgTimeSize );
		orgTimeString.assign ( orgTimeSize, ' ' );
		RIFF_Support::GetRIFFChunk ( fileRef, riffState, myOrgTimeChunk, myTimeList, 0, (char*)orgTimeString.c_str(), &orgTimeSize );
	}

	ok = RIFF_Support::GetRIFFChunk ( fileRef, riffState, myAltTimeChunk, myTimeList, 0, 0, &altTimeSize );
	if ( ok ) {
		altTimeString.reserve ( altTimeSize );
		altTimeString.assign ( altTimeSize, ' ' );
		RIFF_Support::GetRIFFChunk ( fileRef, riffState, myAltTimeChunk, myTimeList, 0, (char*)altTimeString.c_str(), &altTimeSize );
	}

	if ( (! aviTimeString.empty()) && orgTimeString.empty() && (altTimeString.empty()) ) {

		// If we have an avi time, and not the org or alt, use the avi. I suspect this is for some earlier backwards compatibility.

		std::string xmpString;
		this->xmpObj.GetStructField ( kXMP_NS_DM, kStartTimecode, kXMP_NS_DM, kTimeValue, &xmpString, 0 );
		if ( xmpString.compare ( 0, REALTIMELEN, aviTimeString, 0, REALTIMELEN ) ) {
			this->xmpObj.SetStructField ( kXMP_NS_DM, kStartTimecode, kXMP_NS_DM, kTimeValue, aviTimeString, 0 );
			this->containsXMP = true;
		}

	} else {

		// Otherwise, check the original and alt timecodes.

		if ( ! orgTimeString.empty() ) {
			std::string xmpString;
			this->xmpObj.GetStructField ( kXMP_NS_DM, kStartTimecode, kXMP_NS_DM, kTimeValue, &xmpString, 0 );
			if (xmpString.compare ( 0, REALTIMELEN, orgTimeString, 0, REALTIMELEN ) ) {
				this->xmpObj.SetStructField ( kXMP_NS_DM, kStartTimecode, kXMP_NS_DM, kTimeValue, orgTimeString, 0 );
				this->containsXMP = true;
			}
		}

		if ( ! altTimeString.empty() ) {
			std::string xmpString;
			this->xmpObj.GetStructField ( kXMP_NS_DM, kAltTimecode, kXMP_NS_DM, kTimeValue, &xmpString, 0 );
			if ( xmpString.compare ( 0, REALTIMELEN, altTimeString, 0, REALTIMELEN ) ) {
				this->xmpObj.SetStructField ( kXMP_NS_DM, kAltTimecode, kXMP_NS_DM, kTimeValue, altTimeString, 0 );
				this->containsXMP = true;
			}
		}

	}

	unsigned long orgReelSize;
	ok = RIFF_Support::GetRIFFChunk ( fileRef, riffState, myOrgReelChunk, myTimeList, 0, 0, &orgReelSize );
	if ( ok ) {

		std::string orgReelString;
		orgReelString.reserve ( orgReelSize );
		orgReelString.assign ( orgReelSize, ' ' );
		RIFF_Support::GetRIFFChunk ( fileRef, riffState, myOrgReelChunk, myTimeList, 0, (char*)orgReelString.c_str(), &orgReelSize );

		if ( ! orgReelString.empty() ) {
			std::string xmpString;
			this->xmpObj.GetProperty ( kXMP_NS_DM, kTapeName, &xmpString, 0 );
			if ( xmpString.compare ( 0, REELLEN, orgReelString, 0, REELLEN ) ) {
				this->xmpObj.SetProperty ( kXMP_NS_DM, kTapeName, orgReelString, 0 );
				this->containsXMP = true;
			}
		}

	}

	unsigned long altReelSize;
	ok = RIFF_Support::GetRIFFChunk ( fileRef, riffState, myAltReelChunk, myTimeList, 0, 0, &altReelSize );
	if ( ok ) {

		std::string altReelString;
		altReelString.reserve ( altReelSize );
		altReelString.assign ( altReelSize, ' ' );
		RIFF_Support::GetRIFFChunk ( fileRef, riffState, myAltReelChunk, myTimeList, 0, (char*)altReelString.c_str(), &altReelSize );

		if ( ! altReelString.empty() ) {
			std::string xmpString;
			this->xmpObj.GetProperty ( kXMP_NS_DM, kAltTapeName, &xmpString, 0 );
			if ( xmpString.compare ( 0, REELLEN, altReelString, 0, REELLEN ) ) {
				this->xmpObj.SetProperty ( kXMP_NS_DM, kAltTapeName, altReelString, 0 );
				this->containsXMP = true;
			}
		}

	}

	unsigned long logCommentSize;
	ok = RIFF_Support::GetRIFFChunk ( fileRef, riffState, myCommentChunk, myCommentList, 0, 0, &logCommentSize );
	if ( ok ) {

		std::string logCommentString;
		logCommentString.reserve ( logCommentSize );
		logCommentString.assign ( logCommentSize, ' ' );
		RIFF_Support::GetRIFFChunk ( fileRef, riffState, myCommentChunk, myCommentList, 0, (char*)logCommentString.c_str(), &logCommentSize );

		if ( ! logCommentString.empty() ) {
			std::string xmpString;
			this->xmpObj.GetProperty ( kXMP_NS_DM, kLogComment, &xmpString, 0 );
			if ( xmpString.compare ( logCommentString ) ) {
				this->xmpObj.SetProperty ( kXMP_NS_DM, kLogComment, logCommentString, 0 );
				this->containsXMP = true;
			}
		}

	}

	// Update the xmpPacket, as the xmpObj might have been updated with legacy info.
	this->xmpObj.SerializeToBuffer ( &this->xmpPacket, kXMP_UseCompactFormat );
	this->packetInfo.offset = kXMPFiles_UnknownOffset;
	this->packetInfo.length = this->xmpPacket.size();

	this->processedXMP = this->containsXMP;
	
}	// AVI_MetaHandler::CacheFileData