udf102fvd.cpp

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

	PVD.creationDate[11] =  '0';
	PVD.creationDate[12] =  '0';
	PVD.creationDate[13] =  '0';
	PVD.creationDate[14] = '0';
	PVD.creationDate[15] = '0';
	PVD.creationDate[16] = 0x20;
	RMMemcpy(PVD.modificationDate, PVD.creationDate, 17);
	RMMemset(PVD.expirationDate, '0', 17);
	PVD.expirationDate[16] = 0x00;		//not specified
	RMMemset(PVD.effectiveDate, '0', 17);
	PVD.effectiveDate[16] = 0x00;		//not specified

	PVD.fileStructureVersion[0] = 0x01;
	PVD.unused4[0] = 0x00;
	RMMemset(PVD.applicationData, 0x00, 512);
	
	RMMemcpy(&PVD.applicationData[141], "CD-XA001", strlen("CD-XA001"));
	RMMemset(&PVD.unused5, 0x00, 653);

	RMMemcpy(buffer, &PVD, 2048);buffer[129]=0x08;
	RMMemcpy(udf_ptr+ 16*2048,buffer,2048);
}


//part0start,tag_serial_num,14,17,pattern_info,0x01);//JPG FID
void write_DirFIDs(int sloc, int snum,RMuint32 parent,RMuint32 offset,RMuint8 *pattern1,RMuint8 type)
{
  #define jpg_pvm  "PASS_PICTURES.PVM"
  #define wmv_pvm  "PASS_MOVIES.PVM"
  #define mp3_pvm  "PASS_AUDIO.PVM"
   
  RMuint16 fileVersionNum;
  RMuint8  fileCharacteristics;
  RMuint8  lengthFileIdent;
  RMuint32 extLength;
  RMuint32 logicalBlockNum;
  RMuint16 partitionReferenceNum,lengthOfImpUse;
  RMint8  buffer2[12288],fileIdent[48];
  RMuint16 i,File_num;
  size_t totsize=0,tmp=0;
  RMuint32 icb;
  int fidsize, size=0;
  struct ustr instr1;
  struct FileIdentDesc *fid, *fid1;
  typeICBDir *icbPtr=NULL;
  typeUdfFile *UdfNodePtr=NULL;
  RMint8 name[20];
  //RMMemset(buffer,0x00,2048);
  
  RMuint8 *buffer1=buf_ptr;//(RMuint8 *)malloc(15+12288);//2048*6
  RMMemset(buffer1, 0x00, 12288);
  RMMemset(buffer2, 0x00, 12288);	 
  /*
  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;
  */
  switch (type)
  {
    case 1:
      
      /*if((38+(strlen(jpg_pvm))+1)%4)
      	tmp=(38+(strlen(jpg_pvm)+1)+4)/4 *4;
      else
       	tmp=(38+(strlen(jpg_pvm)+1))/4 *4;
      */
      tmp=((39-1+18+3)/4)*4;
      totsize=(size_t)jpgFid;
      totsize+=tmp;
      break;
    case 3:
     /*if((38+(strlen(wmv_pvm))+1)%4)
      	tmp=(38+(strlen(wmv_pvm)+1)+4)/4 *4;
      else
       	tmp=(38+(strlen(wmv_pvm)+1))/4 *4;
      */
      tmp=((39-1+16+3)/4)*4;
      
      totsize=(size_t)wmvFid;
      totsize+=tmp;
      break;
    case 2:
      /*if((38+      (strlen(mp3_pvm)    )+1)%4)
      	tmp=(38+(strlen(mp3_pvm)+1)+4)/4 *4;
      else
       	tmp=(38+(strlen(mp3_pvm)+1))/4 *4;
     */
     tmp=((39-1+15+3)/4)*4;
      totsize=(size_t)mp3Fid;
      totsize+=tmp;
      break;
  
  }
  if ((totsize>8192) && (type==3))
  {
   printf("Generate UDF FID Sector error!\n");
  
   
   return;
  }
  else if (totsize>12288)
  {   printf("12288:Generate UDF FID Sector error!\n");
     
   return;
   }
  //printf("\nTotal size=%ld \n",totsize);
  fid1 = fid =(struct FileIdentDesc *) buffer2;//2048*6 malloc(totsize+5);//(struct FileIdentDesc *) calloc(1, totsize+5);
  RMMemset(fid1,0x00,totsize);	
 
  //Parent FID
  fid1->fileVersionNum = 1;
  fid1->lengthFileIdent =0;
  fid1->fileCharacteristics = 0x0a;
  
  fid1->icb.extLength = 2048;//opt.blocksize;
  fid1->icb.extLocation.logicalBlockNum = parent;//2;  //point to root icb
  fid1->icb.extLocation.partitionReferenceNum = 0;
  *((Uint32*)((struct ADImpUse*)fid1->icb.impUse)->impUse) = 0;
  fid1->lengthOfImpUse = 0;
  fidsize = 40;
  
  RMMemcpy(buffer1+16 ,&(fid1->fileVersionNum) ,2);
  RMMemcpy(buffer1+18 , &(fid1->fileCharacteristics) ,1);
  RMMemcpy(buffer1+19 , &(fid1->lengthFileIdent) ,1);
  RMMemcpy(buffer1+20 , &(fid1->icb.extLength) ,4);
  RMMemcpy(buffer1+24 , &(fid1->icb.extLocation.logicalBlockNum) ,4);
  RMMemcpy(buffer1+28 , &(fid1->icb.extLocation.partitionReferenceNum) ,2);
  
  fid1->descTag = get_tag(TID_FILE_IDENT_DESC, desc_version, snum, offset, buffer1, fidsize);
 
	RMMemcpy(buffer1 , &(fid1->descTag.tagIdent),2);
	RMMemcpy(buffer1+2 ,&(fid1->descTag.descVersion),2);
	RMMemcpy(buffer1+4 ,&(fid1->descTag.tagChecksum),1);
	RMMemcpy(buffer1+5 ,&(fid1->descTag.reserved),1);
	RMMemcpy(buffer1+6 ,&(fid1->descTag.tagSerialNum),2);
	RMMemcpy(buffer1+8 ,&(fid1->descTag.descCRC),2);
	RMMemcpy(buffer1+10 ,&(fid1->descTag.descCRCLength),2);
	RMMemcpy(buffer1+12 ,&(fid1->descTag.tagLocation),4);
  
  //fid1 = (struct FileIdentDesc *)((RMuint8 *)buffer + fidsize);
  fid1 = (struct FileIdentDesc *)((RMuint8 *)fid1 + fidsize);
  size += fidsize;//pattern1=CurPtr;
  
  if (type==1)  //jpg fid
  {
  	//++++++++++++++++++++++
	//Define PASS_Pictures.pvm
	//jpg_pvm 
   	//wmv_pvm
  	//mp3_pvm
  
  	RMMemset(name,0x00,20);
 
  	fid1->fileVersionNum = 1;
  	fid1->fileCharacteristics = 0;
  	RMMemcpy(name,jpg_pvm,strlen(jpg_pvm));
  	fid1->lengthFileIdent =(strlen(jpg_pvm)+1);//(strlen(name)+1);
  	char_to_ustr(&instr1, ( const RMint8 *)name, strlen(jpg_pvm));
  	ustr_to_dchars(fid1->fileIdent, &instr1, 255);
  	fid1->icb.extLength = 2048;
  	fid1->icb.extLocation.logicalBlockNum = 37;//icb=35
  	fid1->icb.extLocation.partitionReferenceNum = 0;
  	*((Uint32*)((struct ADImpUse*)fid1->icb.impUse)->impUse) = 0;
  	fid1->lengthOfImpUse = 0;
  	fidsize = (39 - 1 + fid1->lengthFileIdent + 3) / 4 * 4;
  	RMMemcpy(buffer1+16+size ,&(fid1->fileVersionNum) ,2);
  	RMMemcpy(buffer1+18+size , &(fid1->fileCharacteristics) ,1);
  	RMMemcpy(buffer1+19+size , &(fid1->lengthFileIdent) ,1);
  	RMMemcpy(buffer1+20+size , &(fid1->icb.extLength) ,4);
  	RMMemcpy(buffer1+24+size , &(fid1->icb.extLocation.logicalBlockNum) ,4);
  	RMMemcpy(buffer1+28+size , &(fid1->icb.extLocation.partitionReferenceNum) ,2);
  	RMMemcpy(buffer1+36+size , &(fid1->lengthOfImpUse),2);
  	RMMemcpy(buffer1+38+size , fid1->fileIdent,fid1->lengthFileIdent); 
  
  	fid1->descTag = get_tag(TID_FILE_IDENT_DESC, desc_version, snum, offset, buffer1+size, fidsize);
  	//改寫
	RMMemcpy(buffer1+size , &(fid1->descTag.tagIdent),2);
	RMMemcpy(buffer1+2+size ,&(fid1->descTag.descVersion),2);
	RMMemcpy(buffer1+4+size ,&(fid1->descTag.tagChecksum),1);
	RMMemcpy(buffer1+5+size ,&(fid1->descTag.reserved),1);
	RMMemcpy(buffer1+6+size ,&(fid1->descTag.tagSerialNum),2);
	RMMemcpy(buffer1+8+size ,&(fid1->descTag.descCRC),2);
	RMMemcpy(buffer1+10+size ,&(fid1->descTag.descCRCLength),2);
	RMMemcpy(buffer1+12+size ,&(fid1->descTag.tagLocation),4);
  	size += fidsize;
  	fid1 = (struct FileIdentDesc *)((RMuint8 *)buffer1 + size);
	//++++++++++++++++++++++++++
  
  }//end jpg fid
  
  else if (type==2) //audio fid
  {
  	//++++++++++++++++++++++
	//Define PASS_Pictures.pvm
	//jpg_pvm 
   	//wmv_pvm
  	//mp3_pvm
  
  	RMMemset(name,0x00,20);
 
  	fid1->fileVersionNum = 1;
  	fid1->fileCharacteristics = 0;
  	RMMemcpy(name,mp3_pvm,strlen(mp3_pvm));
  	fid1->lengthFileIdent =(strlen(mp3_pvm)+1);//(strlen(name)+1);
  	char_to_ustr(&instr1, ( const RMint8 *)name, strlen(mp3_pvm));
  	ustr_to_dchars(fid1->fileIdent, &instr1, 255);
  	fid1->icb.extLength = 2048;
  	fid1->icb.extLocation.logicalBlockNum = 38;//icb=35
  	fid1->icb.extLocation.partitionReferenceNum = 0;
  	*((Uint32*)((struct ADImpUse*)fid1->icb.impUse)->impUse) = 0;
  	fid1->lengthOfImpUse = 0;
  	fidsize = (39 - 1 + fid1->lengthFileIdent + 3) / 4 * 4;
  	RMMemcpy(buffer1+16+size ,&(fid1->fileVersionNum) ,2);
  	RMMemcpy(buffer1+18+size , &(fid1->fileCharacteristics) ,1);
  	RMMemcpy(buffer1+19+size , &(fid1->lengthFileIdent) ,1);
  	RMMemcpy(buffer1+20+size , &(fid1->icb.extLength) ,4);
  	RMMemcpy(buffer1+24+size , &(fid1->icb.extLocation.logicalBlockNum) ,4);
  	RMMemcpy(buffer1+28+size , &(fid1->icb.extLocation.partitionReferenceNum) ,2);
  	RMMemcpy(buffer1+36+size , &(fid1->lengthOfImpUse),2);
  	RMMemcpy(buffer1+38+size , fid1->fileIdent,fid1->lengthFileIdent); 
  
  	fid1->descTag = get_tag(TID_FILE_IDENT_DESC, desc_version, snum, offset, buffer1+size, fidsize);
  	//改寫
	RMMemcpy(buffer1+size , &(fid1->descTag.tagIdent),2);
	RMMemcpy(buffer1+2+size ,&(fid1->descTag.descVersion),2);
	RMMemcpy(buffer1+4+size ,&(fid1->descTag.tagChecksum),1);
	RMMemcpy(buffer1+5+size ,&(fid1->descTag.reserved),1);
	RMMemcpy(buffer1+6+size ,&(fid1->descTag.tagSerialNum),2);
	RMMemcpy(buffer1+8+size ,&(fid1->descTag.descCRC),2);
	RMMemcpy(buffer1+10+size ,&(fid1->descTag.descCRCLength),2);
	RMMemcpy(buffer1+12+size ,&(fid1->descTag.tagLocation),4);
  	size += fidsize;
  	fid1 = (struct FileIdentDesc *)((RMuint8 *)buffer1 + size);
	//++++++++++++++++++++++++++
  
  }//end audio fid
  else if (type==3)  //wmv fid
  {
  	//++++++++++++++++++++++
	//Define PASS_Pictures.pvm
	//jpg_pvm 
   	//wmv_pvm
  	//mp3_pvm
  
  	RMMemset(name,0x00,20);
 
  	fid1->fileVersionNum = 1;
  	fid1->fileCharacteristics = 0;
  	RMMemcpy(name,wmv_pvm,strlen(wmv_pvm));
  	fid1->lengthFileIdent =(strlen(wmv_pvm)+1);//(strlen(name)+1);
  	char_to_ustr(&instr1, ( const RMint8 *)name, strlen(wmv_pvm));
  	ustr_to_dchars(fid1->fileIdent, &instr1, 255);
  	fid1->icb.extLength = 2048;
  	fid1->icb.extLocation.logicalBlockNum = 39;//icb=35
  	fid1->icb.extLocation.partitionReferenceNum = 0;
  	*((Uint32*)((struct ADImpUse*)fid1->icb.impUse)->impUse) = 0;
  	fid1->lengthOfImpUse = 0;
  	fidsize = (39 - 1 + fid1->lengthFileIdent + 3) / 4 * 4;
  	RMMemcpy(buffer1+16+size ,&(fid1->fileVersionNum) ,2);
  	RMMemcpy(buffer1+18+size , &(fid1->fileCharacteristics) ,1);
  	RMMemcpy(buffer1+19+size , &(fid1->lengthFileIdent) ,1);
  	RMMemcpy(buffer1+20+size , &(fid1->icb.extLength) ,4);
  	RMMemcpy(buffer1+24+size , &(fid1->icb.extLocation.logicalBlockNum) ,4);
  	RMMemcpy(buffer1+28+size , &(fid1->icb.extLocation.partitionReferenceNum) ,2);
  	RMMemcpy(buffer1+36+size , &(fid1->lengthOfImpUse),2);
  	RMMemcpy(buffer1+38+size , fid1->fileIdent,fid1->lengthFileIdent); 
  
  	fid1->descTag = get_tag(TID_FILE_IDENT_DESC, desc_version, snum, offset, buffer1+size, fidsize);
  	//改寫
	RMMemcpy(buffer1+size , &(fid1->descTag.tagIdent),2);
	RMMemcpy(buffer1+2+size ,&(fid1->descTag.descVersion),2);
	RMMemcpy(buffer1+4+size ,&(fid1->descTag.tagChecksum),1);
	RMMemcpy(buffer1+5+size ,&(fid1->descTag.reserved),1);
	RMMemcpy(buffer1+6+size ,&(fid1->descTag.tagSerialNum),2);
	RMMemcpy(buffer1+8+size ,&(fid1->descTag.descCRC),2);
	RMMemcpy(buffer1+10+size ,&(fid1->descTag.descCRCLength),2);
	RMMemcpy(buffer1+12+size ,&(fid1->descTag.tagLocation),4);
  	size += fidsize;
  	fid1 = (struct FileIdentDesc *)((RMuint8 *)buffer1 + size);
	//++++++++++++++++++++++++++
  
  }//end emv fid
  
 
    
  
  RMMemcpy(&File_num,pattern1+10,2);
 // printf("Total File_num=%d \n",File_num);
  for (i=0;i<File_num;i++)
  {
    icbPtr    = (typeICBDir *)(ICBFidPtr+2+i*12);
    UdfNodePtr= (typeUdfFile *)(pattern1+20+i*60);
    if ((icbPtr->attr)==type)  //
     {
    
     fileVersionNum = 1;
     fileCharacteristics = 0x00;
     lengthFileIdent =strlen(UdfNodePtr->F_name)+1;
     char_to_ustr(&instr1, (const RMint8 *)UdfNodePtr->F_name, lengthFileIdent);
     RMMemset(fileIdent,0x00,48);
     
     ustr_to_dchars(fileIdent, &instr1, 255);
#if 1 //ccc
     extLength = 2048;   //ccc
#else
     if (type==3) 
         extLength=8192;//fid1->icb.extLength = 8192;//2048*4;
     else
        extLength = 12288;//fid1->icb.extLength = 12288;//2048;
#endif
     RMMemcpy(&icb,&(icbPtr->icb),4);
     logicalBlockNum = icb;
     partitionReferenceNum = 0;
     *((Uint32*)((struct ADImpUse*)fid1->icb.impUse)->impUse) = 0;
     lengthOfImpUse = 0;
     fidsize = icbPtr->fid_length;
     
     RMMemcpy(buffer1+16+size ,&fileVersionNum ,2);
    RMMemcpy(buffer1+18+size , &fileCharacteristics ,1);
    RMMemcpy(buffer1+19+size , &lengthFileIdent ,1);
    RMMemcpy(buffer1+20+size , &extLength,4);
    RMMemcpy(buffer1+24+size , &logicalBlockNum ,4);
    RMMemcpy(buffer1+28+size , &partitionReferenceNum ,2);
    RMMemcpy(buffer1+36+size , &lengthOfImpUse,2);
        
    RMMemcpy(buffer1+38+size , fileIdent,lengthFileIdent); 
    fid1->descTag = get_tag(TID_FILE_IDENT_DESC, desc_version, snum, offset, buffer1+size, fidsize);
   
	RMMemcpy(buffer1+size , &(fid1->descTag.tagIdent),2);
	RMMemcpy(buffer1+2+size ,&(fid1->descTag.descVersion),2);
	RMMemcpy(buffer1+4+size ,&(fid1->descTag.tagChecksum),1);
	RMMemcpy(buffer1+5+size ,&(fid1->descTag.reserved),1);
	RMMemcpy(buffer1+6+size ,&(fid1->descTag.tagSerialNum),2);
	RMMemcpy(buffer1+8+size ,&(fid1->descTag.descCRC),2);
	RMMemcpy(buffer1+10+size ,&(fid1->descTag.descCRCLength),2);
	RMMemcpy(buffer1+12+size ,&(fid1->descTag.tagLocation),4);
    
    size += fidsize;
    
    fid1 = (struct FileIdentDesc *)((RMint8 *)fid1 +size);

     
     }
    else  //bypass it
     {
      //printf("%d th File Type error:Type=%x\n",i+1,icbPtr->attr);
      }
  
  }
  
  
  memcpy(udf_ptr+ (sloc+offset)*2048,buffer1,totsize);
}


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


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