udf102fvd.cpp

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

}
void GetAssetInfo(RMuint8 *pattern_info,typeUdfFile *file_node)
{
  RMuint16 file_num;
  RMMemcpy(&file_num,pattern_info+10,2);
  RMMemcpy(file_node,pattern_info+20+(file_num-4)*60,60);


}
void GetPicturesInfo(RMuint8 *pattern_info,typeUdfFile *file_node)
{
  RMuint16 file_num;
  RMMemcpy(&file_num,pattern_info+10,2);
  RMMemcpy(file_node,pattern_info+20+(file_num-3)*60,60);

}


void GetAudioInfo(RMuint8 *pattern_info,typeUdfFile *file_node)
{
  RMuint16 file_num;
  RMMemcpy(&file_num,pattern_info+10,2);
  RMMemcpy(file_node,pattern_info+20+(file_num-2)*60,60);

}
void GetMoviesInfo(RMuint8 *pattern_info,typeUdfFile *file_node)
{
  RMuint16 file_num;
  RMMemcpy(&file_num,pattern_info+10,2);
  RMMemcpy(file_node,pattern_info+20+(file_num-1)*60,60);

}
   
void Calculate_JPEG_Info(RMuint8 *pattern_info1)
{
  RMuint16 i,file_num,jpg_num=0,mp3_num=0,wmv_num=0;
  RMuint32 NWA;
  typeUdfFile file_node;//=NULL;
  RMuint8 *pattern_info=NULL;
  
  typeUdfPath  F_name;
  RMuint32 icb;
  
  RMuint32 FileAddr;
  typeICBDir fid_node;
  RMuint32 F_Lengh;//,tmp;//,FID_JPG=40,FID_MP3=40,FID_WMV=40; 
  RMuint64  tmp;
  RMuint8  Attribute;
  pattern_info=CurPtr;
  
  RMMemset(&F_name,0x00,sizeof(typeUdfPath));
  RMMemcpy(&file_num,pattern_info+10,2);
  RMMemcpy(&NWA,pattern_info+12,4);
  
  //Allocate buffer
  
  //ICBFidPtr=pattern;//(RMuint8 *)malloc(2+file_num*sizeof(typeICBDir)+5);
  
  
  RMMemset(ICBFidPtr,0x00,2048*6);//2+file_num*sizeof(typeICBDir));
  RMMemcpy(ICBFidPtr,&file_num,2);
  
  icb=44;//320-276=44;24;//10;
  jpgFid=40;  mp3Fid=40;   wmvFid=40;
  for (i=0;i<file_num;i++)
  {
    RMMemcpy(&file_node,pattern_info+20+i*60,60);
    RMMemset(F_name,0x00,sizeof(typeUdfPath));
    RMMemset(&fid_node,0x00,sizeof(typeICBDir));
    RMMemcpy(F_name,(file_node.F_name),strlen(file_node.F_name));
    RMMemcpy(&FileAddr,&(file_node.FileAddr),4);
    RMMemcpy(&F_Lengh,&(file_node.F_Lengh),4);
    
    Attribute=file_node.Attribute;
    
    switch (Attribute)
    {
      case 1:
          jpg_num++;
          fid_node.icb=icb+ i;
          //fid_node.icb=icb+ 1;
          fid_node.attr=Attribute;
          #if 1 //ccc
          if((38+(strlen(F_name))+1)%4)
          	tmp=(38+(strlen(F_name)+1)+4)/4 *4;
          else
          	tmp=(38+(strlen(F_name)+1))/4 *4;
          #else
		  tmp=(42+(strlen(F_name)))/4 *4;
          #endif
          fid_node.fid_length=tmp;// Allocate FID Length    strlen(F_name)+1;
          //printf("%d ,icb=%ld ,fid_length:%ld \n",i+1,fid_node.icb,fid_node.fid_length);
          RMMemcpy(ICBFidPtr+2+i*sizeof(typeICBDir),&fid_node,sizeof(typeICBDir));
          jpgFid=jpgFid+tmp;
          break;
      case 2:
          mp3_num++;
          fid_node.icb=icb+ i;
          //fid_node.icb=icb+ 1;
          fid_node.attr=Attribute;
          #if 1 //ccc
          if((38+(strlen(F_name))+1)%4)
          	tmp=(38+(strlen(F_name)+1)+4)/4 *4;
          else
          	tmp=(38+(strlen(F_name)+1))/4 *4;
          #else
		  tmp=(42+(strlen(F_name)+1))/4 *4;
          #endif
          
          
          fid_node.fid_length=tmp;
//          printf("%d ,icb=%ld ,fid_length:%ld \n",i+1,fid_node.icb,fid_node.fid_length);
          
          RMMemcpy(ICBFidPtr+2+i*sizeof(typeICBDir),&fid_node,sizeof(typeICBDir));
          mp3Fid=mp3Fid+tmp;
        
        break;
      case 3:
          wmv_num++;
          fid_node.icb=icb+ i;
          //fid_node.icb=icb+ 1;
          fid_node.attr=Attribute;
          #if 1 //ccc
          if((38+(strlen(F_name))+1)%4)
          	tmp=(38+(strlen(F_name)+1)+4)/4 *4;
          else
          	tmp=(38+(strlen(F_name)+1))/4 *4;
          #else
		  tmp=(42+(strlen(F_name)+1))/4 *4;
          #endif
          fid_node.fid_length=tmp;
//          printf("%d ,icb=%ld ,fid_length:%ld \n",i+1,fid_node.icb,fid_node.fid_length);
          RMMemcpy(ICBFidPtr+2+i*sizeof(typeICBDir),&fid_node,sizeof(typeICBDir));
          wmvFid=wmvFid+tmp;
        
        break;
     case 4:
          //fid_node.icb=4;
   
         break;
    
    } 
    
  
  }
 
  printf("\n\nTotal Num:jpg:%d ,mp3:%d ,wmv:%d \n",jpg_num,mp3_num,wmv_num);
}

//part0start,tag_serial_num,16,17,jpgFid+pass_pvm_len,0x00);  //JPG
void write_FileICB(int sloc, int snum,Uint32 icb,Uint32 position,Uint64 length,Uint8 attr)
{
   struct FileEntry *fe;
   ///6,7,wmvFid,0x00	 
   size_t totsize;
   Uint32 leattr = 0;
   Uint32 ladesc1 = 8;
   
   Uint8 type;
   Uint16 flags;
    struct short_ad *sad;
    struct ExtendedAttrHeaderDesc *eahd;
    struct ImpUseExtendedAttr *iuea;
    struct DVDCopyrightImpUse *dciu;
    
      leattr =132;
    	totsize = 177 - 1 + leattr + ladesc1;
	fe =(struct FileEntry *) calloc(1, totsize+5);
	RMMemset(buffer,0x00,2048);

	fe->uid = ULONG_MAX;
	fe->gid = ULONG_MAX; 
	fe->fileLinkCount =0;//1;// count_dir(fr->dirlist);
	fe->recordFormat = 0;
	fe->recordDisplayAttr = 0;
	fe->recordLength = 0;
	fe->informationLength = length;//fr->length;
	fe->logicalBlocksRecorded = (length+2048-1)/2048;//(fr->length + opt.blocksize - 1) / opt.blocksize;
	//fe->attrTime = fe->modificationTime = fe->accessTime = fr->time;
	fe->checkpoint = 1;
	fe->extendedAttrICB.extLength = 0;
	fe->extendedAttrICB.extLocation.logicalBlockNum = 0;
	fe->extendedAttrICB.extLocation.partitionReferenceNum = 0;
	//改寫
	
	RMMemcpy(buffer+36 ,&(fe->uid),4 );
	RMMemcpy(buffer+40 ,&(fe->gid),4 );
	RMMemcpy(buffer+48 ,&(fe->fileLinkCount) ,2 );
	RMMemcpy(buffer+50 ,&(fe->recordFormat) ,1 );
	RMMemcpy(buffer+51 ,&(fe->recordDisplayAttr) ,1 );
	RMMemcpy(buffer+52, &(fe->recordLength) ,4 );
	RMMemcpy(buffer+56 ,&(fe->informationLength) ,8 );
	RMMemcpy(buffer+64 ,&(fe->logicalBlocksRecorded) ,8 );
	RMMemcpy(buffer+108 ,&(fe->checkpoint) ,4 );
	RMMemcpy(buffer+112 ,&(fe->extendedAttrICB.extLength) ,4 );
	RMMemcpy(buffer+116 ,&(fe->extendedAttrICB.extLocation.logicalBlockNum) ,4 );
	RMMemcpy(buffer+120 ,&(fe->extendedAttrICB.extLocation.partitionReferenceNum) ,2 );

	fe->impIdent.flags = 0;
	RMMemcpy(fe->impIdent.ident, UDF_ID_DEVELOPER,strlen(UDF_ID_DEVELOPER));
	fe->impIdent.identSuffix[0] = os_class;
	fe->impIdent.identSuffix[1] = os_id;
      fe->uniqueID = 0;//fr->unique_id;
	fe->lengthExtendedAttr = leattr;//0x84
	fe->lengthAllocDescs = ladesc1; //0x08

      RMMemcpy(buffer+128 ,&(fe->impIdent.flags) , 1);
	RMMemcpy(buffer+129 ,&(fe->impIdent.ident) , strlen(UDF_ID_DEVELOPER));
	RMMemcpy(buffer+152 ,&(fe->impIdent.identSuffix) ,8 );
	RMMemcpy(buffer+160 ,&(fe->uniqueID) ,8 );
	RMMemcpy(buffer+168 ,&(fe->lengthExtendedAttr),4);  //fe->lengthExtendedAttr
	RMMemcpy(buffer+172 ,&(fe->lengthAllocDescs),4);
	
    eahd = (struct ExtendedAttrHeaderDesc *)fe->extendedAttr;
    eahd->impAttrLocation = 24;//sizeof(struct ExtendedAttrHeaderDesc);
    eahd->appAttrLocation = udf_version > 0x102 ? ULONG_MAX : leattr;
    RMMemcpy(buffer+16+176 ,&(eahd->impAttrLocation) ,4);
    RMMemcpy(buffer+20+176 ,&(eahd->appAttrLocation) ,4);
    eahd->descTag = get_tag(TID_EXTENDED_ATTRI_HEADER_DESC, desc_version, snum, icb, buffer+176, 24);//sizeof(struct ExtendedAttrHeaderDesc));
    RMMemcpy(buffer+176 ,&(eahd->descTag.tagIdent),2);
	RMMemcpy(buffer+2+176 ,&(eahd->descTag.descVersion),2);
	RMMemcpy(buffer+4+176 ,&(eahd->descTag.tagChecksum),1);
	RMMemcpy(buffer+5+176 ,&(eahd->descTag.reserved),1);
	RMMemcpy(buffer+6 +176,&(eahd->descTag.tagSerialNum),2);
	RMMemcpy(buffer+8+176 ,&(eahd->descTag.descCRC),2);
	RMMemcpy(buffer+10+176 ,&(eahd->descTag.descCRCLength),2);
	RMMemcpy(buffer+12+176 ,&(eahd->descTag.tagLocation),4);
   
	
    iuea = (struct ImpUseExtendedAttr *)&fe->extendedAttr[eahd->impAttrLocation];
    iuea->attrType = EXTATTR_IMP_USE;
    iuea->attrSubtype = 1;
    iuea->impUseLength = 8;
    iuea->attrLength = 48 + 8;
    iuea->impIdent.flags = 0;
    RMMemcpy(iuea->impIdent.ident, UDF_ID_FREE_EA, strlen(UDF_ID_FREE_EA));
    ((Uint16 *)iuea->impIdent.identSuffix)[0] = udf_version;
    iuea->impIdent.identSuffix[2] = os_class;
    iuea->impIdent.identSuffix[3] = os_id;
   
   RMMemcpy(buffer+200 ,&(iuea->attrType) ,4);
   RMMemcpy(buffer+204 ,&(iuea->attrSubtype) ,1);
   RMMemcpy(buffer+208 ,&(iuea->attrLength) ,4);
   RMMemcpy(buffer+212 ,&(iuea->impUseLength) ,4);
   RMMemcpy(buffer+216 ,&(iuea->impIdent.flags) ,1);
   RMMemcpy(buffer+217 ,iuea->impIdent.ident ,strlen(UDF_ID_DVD_CGMS));
   RMMemcpy(buffer+ 240,iuea->impIdent.identSuffix ,8);
    
   ((struct FreeEASpace *)iuea->impUse)->headerChecksum = ComputeEAChecksum((RMint8 *)buffer+200);
    //改寫
   
   RMMemcpy(buffer+ 248,&(((struct FreeEASpace *)iuea->impUse)->headerChecksum),4);
   
   
    iuea = (struct ImpUseExtendedAttr *)&fe->extendedAttr[eahd->impAttrLocation + iuea->attrLength];
    iuea->attrType = EXTATTR_IMP_USE;
    iuea->attrSubtype = 1;
    iuea->impUseLength = 8;
    iuea->attrLength = 48 + 8;
    iuea->impIdent.flags = 0;
    RMMemcpy(iuea->impIdent.ident, UDF_ID_DVD_CGMS, strlen(UDF_ID_DVD_CGMS));
    ((Uint16 *)iuea->impIdent.identSuffix)[0] = udf_version;
    iuea->impIdent.identSuffix[2] = os_class;
    iuea->impIdent.identSuffix[3] = os_id;
    //改寫
   RMMemcpy(buffer+252 ,&(iuea->attrType) ,4);
   RMMemcpy(buffer+256 ,&(iuea->attrSubtype) ,1);
   RMMemcpy(buffer+260 ,&(iuea->attrLength) ,4);
   RMMemcpy(buffer+264 ,&(iuea->impUseLength) ,4);
   RMMemcpy(buffer+268 ,&(iuea->impIdent.flags) ,1);
   RMMemcpy(buffer+269 ,iuea->impIdent.ident ,strlen(UDF_ID_DVD_CGMS));
   RMMemcpy(buffer+ 292,iuea->impIdent.identSuffix ,8);
    
      
    
    dciu = (struct DVDCopyrightImpUse *)iuea->impUse;
    dciu->headerChecksum = ComputeEAChecksum((RMint8 *)buffer+252);
    dciu->CGMSInfo = 0;
    dciu->dataType = 0;
    dciu->protectionSystemInfo[0] = 0;
   //改寫
   RMMemcpy(buffer+300 ,&(dciu->headerChecksum) ,2);
   RMMemcpy(buffer+302 ,&(dciu->CGMSInfo) ,1);
   RMMemcpy(buffer+303 ,&(dciu->dataType) ,1);
   //RMMemcpy(buffer+304 ,dciu->protectionSystemInfo ,4);
   
    sad = (struct short_ad *)&(fe->allocDescs[leattr]);
    //sad->extLength = length;//fr->length;
    putInt64L((RMuint8 *)&(sad->extLength),length);

    fe->permissions = PERM_U_READ|PERM_G_READ|PERM_O_READ;
    putInt32L((RMuint8 *)&fe->permissions,fe->permissions);
    putInt32L((RMuint8 *)&sad->extPosition,position);
        
    if ((attr==0x01)||(attr==0x02)||(attr==0x03)||(attr==0x04))
	{
		//sad->extPosition = fr->position;
        type = ICB_FILE_TYPE_REGULAR;
	}
     
	else  //DIR
	{
	    type = ICB_FILE_TYPE_DIRECTORY;
	    fe->permissions |= PERM_U_EXEC|PERM_G_EXEC|PERM_O_EXEC;
	}
    
        
      flags = ICB_FLAG_AD_SHORT;

    if (access_type == PARTITION_ACCESS_R)
        flags |= ICB_FLAG_CONTIGUOUS|ICB_FLAG_NONRELOCATABLE;
    else
        fe->permissions |= PERM_U_WRITE|PERM_U_CHATTR|PERM_U_DELETE|
                           PERM_G_WRITE|PERM_G_CHATTR|PERM_G_DELETE|
                           PERM_O_WRITE|PERM_O_CHATTR|PERM_O_DELETE;
//改寫
   RMMemcpy(buffer+308 ,&(sad->extLength) ,4);
   RMMemcpy(buffer+312 ,&(sad->extPosition) ,4);
   RMMemcpy(buffer+44 ,&(fe->permissions) ,4);
   
   
	fe->icbTag = get_icbtag(0, icb_strategy, 0, 1, type, 0, 0, flags);
	
	RMMemcpy(buffer+16,&(fe->icbTag.priorRecordedNumDirectEntries),4);
	RMMemcpy(buffer+20,&(fe->icbTag.strategyType) ,2);
	RMMemcpy(buffer+22,&(fe->icbTag.strategyParameter) ,2);
	RMMemcpy(buffer+24,&(fe->icbTag.numEntries) ,2);
	RMMemcpy(buffer+26,&(fe->icbTag.reserved ),1);
	RMMemcpy(buffer+27,&(fe->icbTag.fileType) ,1);
	RMMemcpy(buffer+28,&(fe->icbTag.parentICBLocation.logicalBlockNum) ,4);
	RMMemcpy(buffer+32,&(fe->icbTag.parentICBLocation.partitionReferenceNum)  ,2);
	RMMemcpy(buffer+34,&(fe->icbTag.flags) ,2);
	
	fe->descTag = get_tag(TID_FILE_ENTRY, desc_version, snum, icb, buffer, totsize);
	
	
	
	RMMemcpy(buffer , &(fe->descTag.tagIdent),2);
	RMMemcpy(buffer+2 ,&(fe->descTag.descVersion),2);
	RMMemcpy(buffer+4 ,&(fe->descTag.tagChecksum),1);
	RMMemcpy(buffer+5 ,&(fe->descTag.reserved),1);
	RMMemcpy(buffer+6 ,&(fe->descTag.tagSerialNum),2);
	RMMemcpy(buffer+8 ,&(fe->descTag.descCRC),2);
	RMMemcpy(buffer+10 ,&(fe->descTag.descCRCLength),2);
	RMMemcpy(buffer+12 ,&(fe->descTag.tagLocation),4);
		
	
	memcpy(udf_ptr+(sloc + icb)*2048,buffer,2048);	
	sad=NULL;eahd=NULL; iuea=NULL; dciu=NULL;
    
	free(fe);
	//return 0;
}

void writeRootDIR(int sloc, int snum)
{
   
   #define assets    "ASSETS"
   #define albums    "ALBUMS"
   #define passidx   "PASSIDX.PVM"
   int fidsize, size=0;
   struct FileIdentDesc *fid, *fid1;
   RMint8 name[20];
  size_t totsize=188;//40+48;
  fid1 = fid =(struct FileIdentDesc *) buffer1;//calloc(1, totsize+5);
  struct ustr instr1;
  RMMemset(buffer,0x00,2048);RMMemset(fid1,0x00,2048);
  
  //Pa