udf102fvd.cpp

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

// udf102fvd.cpp : Defines the entry point for the console application.

#include <stdio.h>
#include "udf.h"
#include <stdio.h>
#include "udflib.h"
#include "myISO.h"
#include <malloc.h>

#define min(a,b)    (((a) < (b)) ? (a) : (b))
#define  ULONG_MAX  0xffffffffUL

struct udf_options opt = { 0,0,  11, {0}, {0}, {0}, {0}, 0, 0, 0, 0,0, PT_NORMAL, {0} };
typedef RMascii typeUdfPath[48];

typedef struct
{
	typeUdfPath  F_name;
	RMuint32     FileAddr;
	RMuint32     F_Lengh; 
	RMuint8      Attribute;	//1:jpeg  2:mp3  3:wmv
}typeUdfFile;

typedef struct
{
  RMuint32 icb;
  RMuint32 fid_length;
  RMuint8  attr;

}typeICBDir;
const RMuint32 access_type = PARTITION_ACCESS_R;
const RMuint16 udf_version = 0x0102, desc_version = 2, icb_strategy = 4, packet_length = 16, tag_serial_num = 0;
RMuint8 os_class = UDF_OS_CLASS_UNDEF, os_id = UDF_OS_ID_UNDEF;
RMuint32 pvd, pvd_len, rvd, rvd_len, snum, lvd, lvd_len, start;
RMuint32 min_blocks = 262, part0start = 257;
RMuint32 filesetpart = 0, filesetblock = 0;
RMuint32 sparstart = 0, spartable1 = 0, spartable2 = 0, sparnum = 0;
struct timestamp crtime;
void Initialize(void);
void write_vrs(int start);//typeUdfPath  F_name;
void write_anchor(int loc, int start, int len, int rstart, int rlen);
struct tag get_tag(RMuint16 Ident, RMuint16 descVersion, RMuint16 SerialNum, RMuint32 Location, void *ptr, size_t len);
void write_primaryvoldesc(int loc, int snum);
void write_impusevoldesc(int loc, int snum);
void write_partitionvoldesc(int loc, int snum, int start, int end);
void write_logicalvoldesc(int loc, int snum, int start, int len, int filesetpart, int filesetblock, int spartable1, int spartable2, int sparnum);
void SetISO9660_JPG_DR(RMuint32 loc, RMuint8 *pattern);
void   SetISO9660_Movies_DR(RMuint32 loc, RMuint8 *pattern);
void    SetISO9660_Audio_DR(RMuint32 loc, RMuint8 *pattern);
void write_unallocatedspacedesc(int loc, int snum, int start, int end);
void write_termvoldesc(int loc, int sloc);
void write_logicalvolintdesc(int loc, int part0start, int spaceused);
void write_RootICB(int sloc, int snum);
void writeRootDIR(int sloc, int snum);
void writeFolderDIR(int sloc, int snum,RMuint32 parent,RMuint32 pos);
void write_PVM_ICB(int sloc, int snum,Uint32 icb,Uint32 position,Uint64 length,Uint8 attr);
void SetISO9660_Assets_DR(RMuint32 loc, RMuint8 *pattern);
void write_FileICB(int sloc, int snum,Uint32 icb,Uint32 position,Uint64 length,Uint8 attr);
void Calculate_JPEG_Info(RMuint8 *pattern_info);
void putInt64M(RMuint8 b[8], const RMuint64 a);
void putInt64L(RMuint8 b[4], const RMuint64 a);
void putInt32M(RMuint8 b[4], const RMuint32 a);
void putInt32L(RMuint8 b[4], const RMuint32 a);
void putInt16M(RMuint8 b[2], const RMuint16 a);
void putInt16L(RMuint8 b[2], const RMuint8 a);
void write_DirFIDs(int sloc, int snum,RMuint32 parent,RMuint32 offset,RMuint8 *pattern1,RMuint8 type);

struct icbtag get_icbtag(Uint32 priorEntries, Uint16 strategyType, Uint16 strategyParm,Uint16 numEntries, Uint8 fileType, Uint32 parBlockNum, Uint16 parRefNum, Uint16 flags);
Uint16 ComputeEAChecksum(RMint8 *data);
void write_filesetdesc(int loc, int sloc, int snum, int rootpart, int rootblock);
RMuint16 cksum(register RMuint8 *s, register RMint16 n);
void fill_pvd(const Uint32 VolumeSpaceSize);
void fill_vdst(void);
void fill_l_path_table(RMuint32 loc);
void SetISO9660_Album_DR(RMuint32 loc, RMuint8 *pattern);
void fill_m_path_table(RMuint32 loc);
void SetLPathTable(ISOPathTable *pt, typeUdfPath pathname, const Uint32 extent, const RMuint16 parent);
void SetMPathTable(ISOPathTable *pt, typeUdfPath pathname, const Uint32 extent, const RMuint16 parent);
void SetFirstDir(ISODirRecord *pDR, const RMuint32 extent);
void set_root_dr(RMuint32 loc,RMuint8 *pattern);
void SetDirectoryRecord(ISODirRecord *pDR, const typeUdfPath name, const RMuint32 extent, const RMuint32 size, const RMint8 flags);
void WriteDirectoryRecord(ISODirRecord *pDR);
void SetISO9660_DR(RMuint32 loc, RMuint8 *pattern,RMuint8 type);//,Uint32 sector_addr[], Uint32 file_length[])
//void write_FolderICB(int sloc, int snum,Uint32 icb,Uint32 position);
void write_FolderICB(int sloc, int snum,RMuint8 isDir,Uint32 icb,Uint32 position);
int ustr_to_dchars(Uint8 *dest, const struct ustr *src, int strlen);
int ustr_to_char(Uint8 *dest, const struct ustr *src, int strlen);
int char_to_ustr(struct ustr *dest, const Uint8 *src, int strlen);
int ustr_to_dstring(dstring *dest, const struct ustr *src, int dlength);
RMstatus  UDF102_FS_Create(RMuint8 isMultiSession,RMuint8 *pattern_info,RMuint32 offset_lba);
RMstatus  UDF102_File_ICB_Create(RMuint8 *pattern);
void GetPVMInfo(RMuint8 *pattern_info,typeUdfFile *file_node);
void GetAssetInfo(RMuint8 *pattern_info,typeUdfFile *file_node);
void writeAlbumsDIR(int sloc, int snum,RMuint32 parent,RMuint32 pos);
void write_ITRI_ICB(int sloc, int snum,Uint32 icb,Uint32 position,Uint64 length,Uint8 attr);
void GetAlbumInfo(RMuint8 *pattern_info,typeUdfFile *file_node);
void GetPicturesInfo(RMuint8 *pattern_info,typeUdfFile *file_node);
void GetAudioInfo(RMuint8 *pattern_info,typeUdfFile *file_node);
void GetMoviesInfo(RMuint8 *pattern_info,typeUdfFile *file_node);
//Global Number
static RMuint8 *pbuf = NULL;
RMuint8 isMultiFlag,system_use[14];
RMuint32 Offset_NWA;
struct ustr instr;
RMuint8 *udf_ptr=NULL;
RMuint64 jpgFid=40,mp3Fid=40,wmvFid=40;
RMuint8 buffer1[2048],buffer[4096];//2048*6
extern RMuint8 *pattern;//10 sectors
extern RMuint8 *buf_ptr;//6 sectors
extern RMuint8 *ICBFidPtr;//=NULL;
extern RMuint8 *CurPtr;
RMstatus  UDF102_File_ICB_Create(RMuint8 *pattern2)
{
  
  RMuint32 icb;
  RMuint32     FileAddr;
  RMuint32     F_Lengh;
  RMuint8  attr;
  RMuint16 i,file_num;
  typeICBDir *icbPtr=NULL;//printf("\n\nTotal Num:jpg:%d ,mp3:%d ,wmv:%d \n",jpg_num,mp3_num,wmv_num);
  typeUdfFile *UdfNodePtr=NULL;
  pattern2=CurPtr;
  //Allocate ICB Buffer
  
  RMMemset(udf_ptr,0x00,819200);
  RMMemcpy(&file_num,ICBFidPtr,2);
  printf("UDF102_File_ICB_Create():file_num=%d \n",file_num);
  for (i=0;i<file_num;i++)
  {
   icbPtr    = (typeICBDir *)(ICBFidPtr+2+i*12);
   UdfNodePtr= (typeUdfFile *)(pattern2+20+i*60);
   RMMemcpy(&icb,&(icbPtr->icb),4);
   RMMemcpy(&FileAddr,&(UdfNodePtr->FileAddr),4);
   RMMemcpy(&F_Lengh,&(UdfNodePtr->F_Lengh),4);
   RMMemcpy(&attr,&(icbPtr->attr),1);
//   printf("%d name=%s ,icb=%ld ,pos=%ld ,len=%ld\n",i,UdfNodePtr->F_name,icb,FileAddr,F_Lengh);
   write_ITRI_ICB(part0start,tag_serial_num,icb,FileAddr-276,(RMuint64)F_Lengh,attr);
 
  }
  icbPtr=NULL; UdfNodePtr=NULL;
  
  
   ICBFidPtr=NULL;  
  return RM_OK;
} 

RMstatus  UDF102_FS_Create(RMuint8 isMultiSession,RMuint8 *pattern_info,RMuint32 offset_lba)
{
 
 RMuint32 tmp_size;//icb,
 int logical_blk;
 typeUdfFile file_node;
 //RMuint8 *pattern_info=NULL;
  
 isMultiFlag=isMultiSession;
 if (isMultiFlag==1)
   printf("This is DVD+R Multi Session Burned:ISO9660 Only \n");
 else
   printf("This is UDF102/ISO9660 Fil System \n");  
 Offset_NWA=offset_lba;
 Initialize();
 RMMemset(udf_ptr,0x00,400*2048);
// pattern_info=CurPtr; 
 //****************  Begin 測試區 **********************************
 //*************************************************************************
 RMMemcpy(&opt.blocks,pattern_info+16,4);
  tmp_size=(opt.blocks+Offset_NWA);
  fill_pvd(tmp_size); //lsn=16
 
  fill_vdst();   //lsn=17
  start+=2;
      
   write_vrs(start);
   write_anchor(256, pvd, pvd_len, rvd, rvd_len);
   snum = 0; 
   write_primaryvoldesc(pvd, snum++);
   write_impusevoldesc(pvd+1, snum++);
   write_partitionvoldesc(pvd+2, snum++, part0start, opt.blocks-1 - 288);
   write_logicalvoldesc(pvd+3, snum++, lvd, lvd_len, filesetpart, filesetblock, spartable1, spartable2, sparnum);
   write_unallocatedspacedesc(pvd+4, snum++, 0x80, 0xFF);
   write_termvoldesc(pvd+5, 0);
   snum = 0;
   write_primaryvoldesc(rvd, snum++);
   write_impusevoldesc(rvd+1, snum++);
   write_partitionvoldesc(rvd+2, snum++, part0start, opt.blocks-1 - 288);
   write_logicalvoldesc(rvd+3, snum++, lvd, lvd_len, filesetpart, 0,0,0,0);//filesetblock, spartable1, spartable2, sparnum);
   write_unallocatedspacedesc(rvd+4, snum++, 0x80, 0xFF);
   write_termvoldesc(rvd+5, 0);  
   
   logical_blk=opt.blocks-288-276;//263;//257;
   write_logicalvolintdesc(lvd, part0start, logical_blk);
   write_termvoldesc(lvd+1, 0);
  
    //257:L-Path Table
   fill_l_path_table(257);
   //258: M-Path Table
   fill_m_path_table(258);
    //259:Root DR
    
    Calculate_JPEG_Info(pattern_info );
    set_root_dr(259,pattern_info);
   
   
   SetISO9660_Album_DR(260,pattern_info); 
   SetISO9660_Assets_DR(261,pattern_info);
   SetISO9660_JPG_DR(262 ,pattern_info);
   SetISO9660_Movies_DR(268,pattern_info);
   SetISO9660_Audio_DR(270,pattern_info);
   
   write_filesetdesc(filesetblock, part0start, tag_serial_num, 0, 2);
   write_termvoldesc(filesetblock+1, part0start);
   write_RootICB(part0start,tag_serial_num);
   
   writeRootDIR(part0start,tag_serial_num);
   
   //PASSIDX.PVM ICB
//   void GetPVMInfo(RMuint8 *pattern_info,typeUdfFile *file_node)
/*
 typedef struct
{
	typeUdfPath  F_name;
	RMuint32     FileAddr;
	RMuint32     F_Lengh; 
	RMuint8      Attribute;	//1:jpeg  2:mp3  3:wmv
}typeUdfFile;
 
 */
 
 
   //PASSIDX.PVM ICB=4 ,POS=file_node.FileAddr-276
   GetPVMInfo(pattern_info,&file_node);
   //printf("++ F_name:%s ,attribute:%d \n",file_node.F_name,file_node.Attribute);
   write_PVM_ICB(part0start,tag_serial_num,4,file_node.FileAddr-276,(RMuint64)file_node.F_Lengh,file_node.Attribute);

   
   //ALBUMS ICB &FID  void write_FolderICB(int sloc, int snum,RMuint8 isDir,Uint32 icb,Uint32 position)
   //填入Albums ICB &FID
   write_FolderICB(part0start,tag_serial_num,0x01,6,7);  //ALBUMS
   writeAlbumsDIR(part0start,tag_serial_num,2,7);
   
   //寫入Albums.pvm ICB
   RMMemset(&file_node,0x00,60);
   GetAlbumInfo(pattern_info,&file_node);
  // printf("ALBUM.PVM:name:%s \n",file_node.F_name);
   write_PVM_ICB(part0start,tag_serial_num,35,file_node.FileAddr-276,(RMuint64)file_node.F_Lengh,file_node.Attribute);

   
   //填入Asset List ICB &FID
   write_FolderICB(part0start,tag_serial_num,0x01,14,15); //ASSETS
   writeFolderDIR(part0start,tag_serial_num,2,15);
   
   RMMemset(&file_node,0x00,60);
   GetAssetInfo(pattern_info,&file_node);
  // printf("Asset_List.PVM:name:%s \n",file_node.F_name);
   write_PVM_ICB(part0start,tag_serial_num,36,file_node.FileAddr-276,(RMuint64)file_node.F_Lengh,file_node.Attribute);
   
   Uint64 pass_pvm_len;
   pass_pvm_len=((39-1+strlen("PASS_PICTURES.PVM")+1+3)/4)*4;
   //printf("pass_picture len:%ld ,pass_pvm_len=%ld\n",strlen("PASS_PICTURES.PVM"),(Uint32)pass_pvm_len);
   	
   write_FileICB(part0start,tag_serial_num,16,17,jpgFid+pass_pvm_len,0x00);  //JPG
   
   
   pass_pvm_len=((39-1+strlen("PASS_MOVIES.PVM")+1+3)/4)*4;
   write_FileICB(part0start,tag_serial_num,23,24,wmvFid+pass_pvm_len,0x00);  ////WMV
   pass_pvm_len=((39-1+strlen("PASS_AUDIO.PVM")+1+3)/4)*4;
   write_FileICB(part0start,tag_serial_num,28,29,mp3Fid+pass_pvm_len,0x00);  //MP3
   
   write_DirFIDs(part0start,tag_serial_num,14,17,pattern_info,0x01);//JPG FID
   write_DirFIDs(part0start,tag_serial_num,14,24,pattern_info,0x03);//MOVIES FID
   write_DirFIDs(part0start,tag_serial_num,14,29,pattern_info,0x02);//AUDIO FID
   

   RMMemset(&file_node,0x00,60);
   //GetAssetInfo(pattern_info,&file_node);
   GetPicturesInfo(pattern_info,&file_node);
   //GetAudioInfo(pattern_info,&file_node);
   //GetMoviesInfo(pattern_info,&file_node);
  // printf("Pictures.PVM:name:%s \n",file_node.F_name);
   write_PVM_ICB(part0start,tag_serial_num,37,file_node.FileAddr-276,(RMuint64)file_node.F_Lengh,file_node.Attribute);
   
   
   
   RMMemset(&file_node,0x00,60);
   //GetAssetInfo(pattern_info,&file_node);
   //GetPicturesInfo(pattern_info,&file_node);
   GetAudioInfo(pattern_info,&file_node);
   //GetMoviesInfo(pattern_info,&file_node);
//   printf("Audio.PVM:name:%s \n",file_node.F_name);
   write_PVM_ICB(part0start,tag_serial_num,38,file_node.FileAddr-276,(RMuint64)file_node.F_Lengh,file_node.Attribute);

   RMMemset(&file_node,0x00,60);
   //GetAssetInfo(pattern_info,&file_node);
   //GetPicturesInfo(pattern_info,&file_node);
   //GetAudioInfo(pattern_info,&file_node);
   GetMoviesInfo(pattern_info,&file_node);
   printf("Movies.PVM:name:%s \n",file_node.F_name);
   write_PVM_ICB(part0start,tag_serial_num,39,file_node.FileAddr-276,(RMuint64)file_node.F_Lengh,file_node.Attribute);

   
     
   
  //*******************************************************************************************
 
  return RM_OK;

}
//write_ITRI_ICB(part0start,tag_serial_num,icb,FileAddr-276,(RMuint64)F_Lengh,attr);
void write_ITRI_ICB(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 *) buffer1;//calloc(1, totsize+5);
	RMMemset(fe,0x00,totsize);
	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;