udf102fvd.cpp

It is for standalone platform executing DVD Burning function,it supports DVD+R/+RW Disc .

void SetISO9660_DR(RMuint32 loc, RMuint8 *pattern,RMuint8 type)//,Uint32 sector_addr[], Uint32 file_length[])
{

	ISODirRecord	DirRecord;
	typeUdfPath filename;
	RMuint16 i,file_num;
	typeICBDir *icbPtr=NULL;
      typeUdfFile *UdfNodePtr=NULL;
      RMuint32 startAddr,FileLength;
	RMMemcpy(&file_num,ICBFidPtr,2);
	RMMemset(buffer, 0x00, 2048);
	pbuf = buffer;
	
	SetFirstDir(&DirRecord, (loc+Offset_NWA));
	WriteDirectoryRecord(&DirRecord);

	SetFirstDir(&DirRecord, 259+Offset_NWA);
	DirRecord.name[0] = 0x01;	//DR€€ªº²Ä€Gµ§°O¿ý
	WriteDirectoryRecord(&DirRecord);

	for (i=0;i<file_num;i++)
       {
         icbPtr    = (typeICBDir *)(ICBFidPtr+2+i*sizeof(typeICBDir));
         UdfNodePtr= (typeUdfFile *)(pattern+20+i*sizeof(typeUdfFile));
         if ((icbPtr->attr)==type)  //找到該類型file,count &calculate it
           {
             
             RMCopyAscii(filename,UdfNodePtr->F_name); 
             startAddr=UdfNodePtr->FileAddr;
             FileLength=UdfNodePtr->F_Lengh;
             
             SetDirectoryRecord(&DirRecord, filename, startAddr, FileLength, ISO_FILE);
		WriteDirectoryRecord(&DirRecord);           
           }
       }
     RMMemcpy(udf_ptr+ loc*2048,buffer,2048);
     pbuf =NULL;

}


void set_root_dr(RMuint32 loc,RMuint8 *pattern1) //loc=259
{
	ISODirRecord	DirRecord;
	RMuint16 i,file_num;
	//typeICBDir *icbPtr=NULL;
      typeUdfFile *UdfNodePtr=NULL;
      
      RMuint32 startAddr,FileLength;
	RMMemcpy(&file_num,ICBFidPtr,2);
      /* ªì©l€Æ*/
      RMMemset(buffer,0x00,2048);
	RMMemset(&DirRecord, 0x00, sizeof(DirRecord));
	pbuf = buffer;
//²Ä€@µ§°O¿ýfor Current DIR
	SetFirstDir(&DirRecord, loc+Offset_NWA);
	WriteDirectoryRecord(&DirRecord);
//²Ä€Gµ§°O¿ý parent For Parent DIR
	SetFirstDir(&DirRecord, loc+Offset_NWA);
	DirRecord.name[0] = 0x01;	//DR€€ªº²Ä€Gµ§°O¿ý
	WriteDirectoryRecord(&DirRecord);

	/*SetDirectoryRecord(&DirRecord, "ITRI_JPEG", (loc+1+Offset_NWA), 2048, ISO_DIRECTORY);
	WriteDirectoryRecord(&DirRecord);

	SetDirectoryRecord(&DirRecord, "ITRI_MOVIES", (loc+2+Offset_NWA), 2048, ISO_DIRECTORY);
	WriteDirectoryRecord(&DirRecord);
	
	SetDirectoryRecord(&DirRecord, "ITRI_MP3", (loc+3+Offset_NWA), 2048, ISO_DIRECTORY);
	WriteDirectoryRecord(&DirRecord);
	*/
	SetDirectoryRecord(&DirRecord, "ALBUMS",(loc+1+Offset_NWA), 2048, ISO_DIRECTORY);
	WriteDirectoryRecord(&DirRecord);
	SetDirectoryRecord(&DirRecord, "ASSETS",(loc+2+Offset_NWA), 2048, ISO_DIRECTORY);
	WriteDirectoryRecord(&DirRecord);
//	printf("\n@@@@@@@@@@ set_root_dr():offset=%ld \n",loc+Offset_NWA);
//	printf("@@@@ file_num=%d @@@@@@@@@@\n",file_num);
	
	
	for (i=file_num-6;i<file_num;i++)
       	{
		UdfNodePtr= (typeUdfFile *)(pattern1+20+i*sizeof(typeUdfFile));
		if(RMCompareAsciiCaseInsensitively(UdfNodePtr->F_name, "PASSIDX.PVM"))
	  	{
			startAddr=UdfNodePtr->FileAddr;
             		FileLength=UdfNodePtr->F_Lengh;
			//printf("@@@@PASSIDX.PVM:startAddr:%ld \n",startAddr);
			SetDirectoryRecord(&DirRecord, UdfNodePtr->F_name, startAddr, FileLength, ISO_FILE);
			WriteDirectoryRecord(&DirRecord);      
		}
       
       
       	}
	
	
	
	//SetDirectoryRecord(&DirRecord, "PASSIDX.PVM", (loc+22+Offset_NWA), 2048, ISO_FILE);
	//WriteDirectoryRecord(&DirRecord);
	
	
	RMMemcpy(udf_ptr+ loc*2048,buffer,2048);
	
	pbuf=NULL;
//	return;
}
void WriteDirectoryRecord(ISODirRecord *pDR)
{
	memcpy(pbuf, pDR, 33 + pDR->lenFI);
	pbuf += 33 + pDR->lenFI;
	if (pDR->lenFI %2 == 0)
		*pbuf++ = 0x00;
	//RMMemcpy(pbuf, system_use, 14);
	//pbuf += 14;
}
void SetDirectoryRecord(ISODirRecord *pDR, const typeUdfPath name, const RMuint32 extent, const RMuint32 size, const RMint8 flags)
{
	Uint16 volumeSequenceNumber = 1;
	unsigned int len_FI = 0;
	unsigned int padding = 0;
	len_FI = strlen(name);
	if (len_FI %2 == 1)
		padding = 0;
	else 
		padding = 1;

	RMMemset(pDR, 0x00, sizeof(ISODirRecord));

	pDR->lenDR = 33 + len_FI + padding;// + 14;	//14¬°system use
	pDR->extAttrLength = 0x00;
	putInt32L((RMuint8 *)pDR->lExtent, extent);
	putInt32M((RMuint8 *)pDR->mExtent, extent);
	putInt32L((RMuint8 *)pDR->lSize, size);
	putInt32M((RMuint8 *)pDR->mSize, size);
	
	pDR->flags = flags;
	pDR->file_unit_size[0] = 0x00;
	pDR->interleave[0] = 0x00;
	putInt16L((RMuint8 *)&pDR->volumeSequenceNumber[0], volumeSequenceNumber);
	putInt16M((RMuint8 *)&pDR->volumeSequenceNumber[2], volumeSequenceNumber);
	pDR->lenFI = len_FI;
	RMMemcpy(pDR->name, name, len_FI);
}
void SetFirstDir(ISODirRecord *pDR, const RMuint32 extent)
{

	Uint16 volumeSequenceNumber = 01;
	Uint32 size = 2048;
	RMMemset(system_use,0x00,14);
	system_use[4] = 0x8d;	//Attributes //1000 1101
	system_use[5] = 0x55;	//0101 0101
	system_use[6] = 'X';
	system_use[7] = 'A';
	system_use[8] = 0x00;

	RMMemset(pDR, 0x00, sizeof(ISODirRecord));

	pDR->lenDR = 0x22;
	pDR->extAttrLength = 0x00;
	putInt32L((RMuint8 *)pDR->lExtent, extent);
	putInt32M((RMuint8 *)pDR->mExtent, extent);
	putInt32L((RMuint8 *)pDR->lSize, size);
	putInt32M((RMuint8 *)pDR->mSize, size);
	pDR->date[6] = 0x20;			//offset from Greenwich Mean Time
	pDR->flags = ISO_DIRECTORY;
	pDR->file_unit_size[0] = 0x00;
	pDR->interleave[0] = 0x00;
	putInt16L((RMuint8 *)&pDR->volumeSequenceNumber[0], volumeSequenceNumber);
	putInt16M((RMuint8 *)&pDR->volumeSequenceNumber[2], volumeSequenceNumber);
	pDR->lenFI = 1;
	pDR->name[0] = 0x00;
}

void WritePathTable(ISOPathTable *pt)
{
	memcpy(pbuf, pt, 8 + pt->Len_DI);
	pbuf += 8 + pt->Len_DI;
	if(pt->Len_DI %2)
		*pbuf++ = 0x00;
}
void SetLPathTable(ISOPathTable *pt, typeUdfPath pathname, const Uint32 extent, const RMuint16 parent)
{
	RMMemset(pt, 0x00, sizeof(ISOPathTable));	//Clear
	pt->Len_DI = strlen(pathname);
	pt->exAttrRecLen = 0;
	putInt32L((RMuint8 *)pt->extent, extent);
	putInt16L((RMuint8 *)pt->parent, parent);
	
	RMMemcpy(pt->name, pathname, pt->Len_DI);
}

void SetMPathTable(ISOPathTable *pt, typeUdfPath pathname, const Uint32 extent, const RMuint16 parent)
{
	RMMemset(pt, 0x00, sizeof(ISOPathTable));	//Clear
	pt->Len_DI = strlen(pathname);
	pt->exAttrRecLen = 0;
	putInt32M((RMuint8 *)pt->extent, extent);
	putInt16M((RMuint8 *)pt->parent, parent);
	RMMemcpy(pt->name, pathname, pt->Len_DI);
}
void fill_l_path_table(RMuint32 loc)
{
  
  ISOPathTable	Path_table;
  
  RMuint32 extent = 0;
  RMuint16 parent = 0;
  RMMemset(buffer,0x00,2048);
  pbuf = buffer;//buffer;	
  RMMemset(&Path_table, 0x00, sizeof(Path_table));
  Path_table.Len_DI = 1;
  Path_table.exAttrRecLen = 0;
  extent = (259+Offset_NWA);
  putInt32L((RMuint8 *)Path_table.extent, extent);
  parent = 1;
  putInt16L((RMuint8 *)Path_table.parent, parent);
  Path_table.name[0] = 0x00;
  WritePathTable(&Path_table);
  //	ITRI_JPEG
  SetLPathTable(&Path_table, "ITRI_JPEG", (260+Offset_NWA), 1);
  WritePathTable(&Path_table);
  //	ITRI_MOVIES
  SetLPathTable(&Path_table, "ITRI_MOVIES", (Offset_NWA+261), 1);
  WritePathTable(&Path_table);
  //	ITRI_MP3
  SetLPathTable(&Path_table, "ITRI_MP3", (Offset_NWA+262), 1);
  WritePathTable(&Path_table);
  RMMemcpy(udf_ptr+ loc*2048,buffer,2048);
  pbuf=NULL;

}
void fill_m_path_table(RMuint32 loc)  //258
{
      ISOPathTable	Path_table;
	RMuint32 extent = 0;
      RMuint16 parent = 0;
      RMMemset(buffer,0x00,2048);
      pbuf = buffer;//buffer;	
	RMMemset(&Path_table, 0x00, sizeof(Path_table));
//ROOT
	Path_table.Len_DI = 1;
	Path_table.exAttrRecLen = 0;
	extent = (Offset_NWA+259);
	putInt32M((RMuint8 *)Path_table.extent, extent);
	parent = 1;
	putInt16M((RMuint8 *)Path_table.parent, parent);
	Path_table.name[0] = 0x00;

	WritePathTable(&Path_table);
//	ITRI_JPEG
  SetMPathTable(&Path_table, "ITRI_JPEG", (Offset_NWA+260), 1);
  WritePathTable(&Path_table);
  //	ITRI_MOVIES
  SetMPathTable(&Path_table, "ITRI_MOVIES", (Offset_NWA+261), 1);
  WritePathTable(&Path_table);
  //	ITRI_MP3
  SetMPathTable(&Path_table, "ITRI_MP3", (Offset_NWA+262), 1);
  WritePathTable(&Path_table);
  RMMemcpy(udf_ptr+ loc*2048,buffer,2048);
  pbuf=NULL;


}
void fill_vdst(void)
{
	struct ISOPrimaryDescriptor VDST;	//Volume Descriptor Set Terminator
	
	RMMemset(buffer, 0x00, 2048);
	RMMemset(&VDST, 0x00, sizeof(VDST));
	VDST.type[0] = ISO_VD_END;
	//strncpy(VDST.id, ISO_STANDARD_ID, 5);
	RMMemcpy(VDST.id, ISO_STANDARD_ID, 5);
	VDST.version[0] = 0x01;
	
	RMMemcpy(buffer, &VDST, 2048);
	RMMemcpy(udf_ptr+ 17*2048,buffer,2048);
}

void SetRootDR(ISODirRecord *pDR)
{

	Uint16 volumeSequenceNumber = 01;
	Uint32 size = 2048;
	Uint32 extent = Offset_NWA+0x0103;//Offset_NWA

	RMMemset(pDR, 0x20, sizeof(ISODirRecord));

	pDR->lenDR = 0x22;
	pDR->extAttrLength = 0x00;
	putInt32L((RMuint8 *)pDR->lExtent, extent);
	putInt32M((RMuint8 *)pDR->mExtent, extent);
	putInt32L((RMuint8 *)pDR->lSize, size);
	putInt32M((RMuint8 *)pDR->mSize, size);
	
	
	pDR->flags = ISO_DIRECTORY;
	pDR->file_unit_size[0] = 0x00;
	pDR->interleave[0] = 0x00;
	putInt16L((RMuint8 *)&pDR->volumeSequenceNumber[0], volumeSequenceNumber);
	putInt16M((RMuint8 *)&pDR->volumeSequenceNumber[2], volumeSequenceNumber);
	pDR->lenFI = 1;
	pDR->name[0] = 0x00;
}
void fill_pvd(const Uint32 VolumeSpaceSize)
{
	struct ISOPrimaryDescriptor PVD;

	Uint16 VolumeSetSize = 1;		//cd-rom xa standard
	Uint16 volumeSequenceNumber = 1;//cd-rom xa standard
	Uint16 LogicalBlockSize = ISO_DEFAULT_BLOCK_SIZE;
	Uint32 PathTableSize;		//±qšä¥ŠŠa€è­pºâŠÓšÓ

	ISODirRecord root_DR;
//Offset_NWA
	RMMemset(buffer, 0x00, 2048);

      //³]©wroot dir recotd
	SetRootDR(&root_DR);
	RMMemset(&PVD, 0xFF, sizeof(PVD));	//0xFF¬°debug¥Î

	PVD.type[0] = ISO_VD_PRIMARY;
	RMMemcpy(PVD.id, ISO_STANDARD_ID, 5);
	PVD.version[0] = 0x01;
	PVD.unused1[0] = 0x00;
	RMMemset(PVD.systemID, 0x20, 32);
	
	RMMemset(PVD.volumeID, 0x20, 32);
	RMMemcpy(PVD.volumeID, "KODAK_VOLUME_DISC", strlen("KODAK_VOLUME_DISC"));
	
	RMMemset(PVD.unused2, 0x00, 8);

	putInt32L((RMuint8 *)PVD.lVolumeSpaceSize, VolumeSpaceSize);
	putInt32M((RMuint8 *)PVD.mVolumeSpaceSize, VolumeSpaceSize);

	RMMemset(&PVD.escapeSequences, 0x00, 32);

	putInt16L((RMuint8 *)PVD.lVolumeSetSize, VolumeSetSize);
	putInt16M((RMuint8 *)PVD.mVolumeSetSize, VolumeSetSize);
	putInt16L((RMuint8 *)&PVD.volumeSequenceNumber[0], volumeSequenceNumber);
	putInt16M((RMuint8 *)&PVD.volumeSequenceNumber[2], volumeSequenceNumber);

	putInt16L((RMuint8 *)PVD.lLogicalBlockSize, LogicalBlockSize);
	putInt16M((RMuint8 *)PVD.mLogicalBlockSize, LogicalBlockSize);

	PathTableSize=0x40;
	
	putInt32L((RMuint8 *)PVD.lPathTableSize, PathTableSize);
	putInt32M((RMuint8 *)PVD.mPathTableSize, PathTableSize);

	putInt32L((RMuint8 *)PVD.typeLPathTable, Offset_NWA+257);
	putInt32L((RMuint8 *)PVD.optTypeLPathTable, 0x00);
	putInt32M((RMuint8 *)PVD.typeMPathTable, Offset_NWA+258);
	putInt32M((RMuint8 *)PVD.optTypeMPathTable, 0x00);

	RMMemcpy(PVD.root, &root_DR, sizeof(root_DR));
	RMMemset(PVD.volumeSetID, 0x20, 128);
	RMMemset(PVD.publisherID, 0x20, 128);
	RMMemset(PVD.preparerID, 0x20, 128);
	RMMemset(PVD.applicationID, 0x20, 128);
	RMMemset(PVD.copyright_fileID, 0x20, 37);
	RMMemset(PVD.abstract_fileID, 0x20, 37);
	RMMemset(PVD.bibliographicFileID, 0x20, 37);

	PVD.creationDate[0] =  '0';
	PVD.creationDate[1] =  '0';
	PVD.creationDate[2] =  '0';
	PVD.creationDate[3] =  '0';
	PVD.creationDate[4] =  '0';
	PVD.creationDate[5] =  '0';
	PVD.creationDate[6] =  '0';
	PVD.creationDate[7] =  '0';
	PVD.creationDate[8] =  '0';
	PVD.creationDate[9] =  '0';
	PVD.creationDate[10] =  '0';