burn.cpp~

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

RMstatus ITRI_WriteCommand(RMuint8 *itri_buf,RMuint32 NWA,RMuint16 transferLen)
{
	RMstatus status;
	struct READ_BUF_CAPA bc;
	RMbool isDiscReady;
	RMuint8 b3,b2,b1,b0;
	RMuint32 BlankBufLen;
	struct timespec usleep_req={0,300000000};
	status=FVD_Write10(ITRI_context->disc,itri_buf,NWA,transferLen);
	while (status!=RM_OK)
			{
			
				status = RMFDiscIsReady (ITRI_context->disc, &isDiscReady);
          			while ((status!=RM_OK)||(!isDiscReady))
               				status = RMFDiscIsReady (ITRI_context->disc, &isDiscReady);
				
				
				FVD_ReadBufCapacity(ITRI_context->disc,(RMuint8 *)&bc,sizeof(struct READ_BUF_CAPA));
    				b3=bc.BlankBufLen[0];b2=bc.BlankBufLen[1];b1=bc.BlankBufLen[2];b0=bc.BlankBufLen[3];
    				BlankBufLen=b3*16777216+b2*65536+b1*256+b0;
    				while (BlankBufLen<128*2048)
                    		{
        				RMFDiscIsReady (ITRI_context->disc, &isDiscReady);
        				//FVD_SyncCache(ITRI_context->disc,0,0); 
        				nanosleep(&usleep_req,0);
        				FVD_ReadBufCapacity(ITRI_context->disc,(RMuint8 *)&bc,sizeof(struct READ_BUF_CAPA));
        				b3=bc.BlankBufLen[0];b2=bc.BlankBufLen[1];b1=bc.BlankBufLen[2];b0=bc.BlankBufLen[3];
        				BlankBufLen=b3*16777216+b2*65536+b1*256+b0;
                    		}
    				status=FVD_Write10(ITRI_context->disc,itri_buf,NWA,transferLen);
                    		//printf("@@@ Loop:%d ,retry=%ld @@@@\n",i,retry);
				
                   	}
		printf("ITRI_WriteCommand() ENTRY \n");
			return status;

}

RMstatus Type4WriteDisc(RMuint16 numofItems,RMuint8 type)
{
	RMuint8 b3,b2,b1,b0;
	RMuint8 itri_id[12],buf[128];
	RMuint32 next_lba;
	RMMemset(pattern,0x00,2048*3);
	RMMemset(buf,0x00,128);
	FVD_ReadTrackInfo(ITRI_context->disc,0x01,numofSessions-1,buf);
        b3=buf[8];b2=buf[8];b1=buf[10];b0=buf[11];
        next_lba=b3*16777216+b2*65536+b1*256+b0;
        printf("Prev. Session Next Writable Address=%ld \n",next_lba);
	
	PrevITRINWA=CurrentITRINWA;
	CurrentITRINWA=NextWriteAddr;
	
	
	
	
	
  	RMFDiscReadSector(ITRI_context->disc,(120+PrevITRINWA),3,2048,pattern);
        RMMemset(itri_id,0x00,12);
        RMMemcpy(itri_id,pattern,10);
        if (strcmp((char *)itri_id,ITRI_ID)==0)
        {
		ITRI_PatternedWriteSequence(numofItems,type);
	}
	else
	{
	
		ITRI_NO_PatternedWriteSequence(numofItems,type);
	}
	
	CloseDisc();
	
	
	return RM_OK;
}
RMstatus ITRI_NO_PatternedWriteSequence(RMuint16 numofItems,RMuint8 type)
{
	Type2WriteDisc(numofItems,type);
	return RM_OK;
}
RMstatus ITRI_PatternedWriteSequence(RMuint16 numofItems,RMuint8 type)
{
	RMstatus status;
	RMuint16 i,PrevNum,FileNum;
	RMuint8 isMultiFlag=0;
	RMascii fullpath[80];
	RMbool itri_pattern=TRUE;
	//struct timespec usleep_req={0,300000000};
	typeUdfFile udf_file;
	RMuint32 Vol_Blocks,FileBlks;
	RMuint8 *ptr1=NULL,*tmp_ptr=NULL;
	ptr1=buf_ptr;
  	tmp_ptr=CurPtr;
  	RMMemset(ptr1,0x00,2048*6);RMMemset(tmp_ptr,0x00,2048*12);
	RMMemcpy(&FileNum,pattern+10,2);//NextWriteAddr
        //RMMemcpy(&next_lba,pattern+12,4);
        RMMemcpy(&Vol_Blocks,pattern+16,4);
	global_blks=Vol_Blocks;
        PrevNum=FileNum-6;//
        FileNum=PrevNum+numofItems+6;  
        //tmp_nwa=NextWriteAddr+700;//next_lba;
	
	
	itri_NWA=NextWriteAddr+700;//UDF102_Reserved;
	ITRI_pnav->MyFavorfiletemp = ITRI_pnav->MyFavorfilefirst;
        //RMMemset(ptr1,0x00,numofItems*sizeof(typeUdfFile));
        for (i=0;i<numofItems;i++)//tmp_nwa
        { 
             
	     RMMemset(&udf_file,0x00,60);
	     RMCopyAscii(udf_file.F_name,ITRI_pnav->MyFavorfiletemp->name);
	     udf_file.FileAddr=itri_NWA;//
	     udf_file.F_Lengh=(RMuint32)ITRI_pnav->MyFavorfiletemp->size;
	     (udf_file.F_Lengh%2048==0)?(itri_NWA+=(udf_file.F_Lengh/2048)):(itri_NWA+=(udf_file.F_Lengh/2048+1));
	     FileBlks=((udf_file.F_Lengh%2048==0)?(udf_file.F_Lengh/2048):(udf_file.F_Lengh/2048+1));
	     udf_file.Attribute=type;
	     global_blks+=FileBlks;
	     RMMemcpy(tmp_ptr+20+(PrevNum+i)*60,&udf_file,60);
	     printf("%d th File=%s,NWA=%ld ,Length(Blks)=%ld \n",i,udf_file.F_name,udf_file.FileAddr,udf_file.F_Lengh);
	     ITRI_pnav->MyFavorfiletemp1 = ITRI_pnav->MyFavorfiletemp->next;
             ITRI_pnav->MyFavorfiletemp  = ITRI_pnav->MyFavorfiletemp1;
    
         }      
	 //?入?�已�?��	 RMMemcpy(tmp_ptr+20,pattern+20,PrevNum*60);    
	     
	 WriteKODAKPVMFile(itri_pattern,tmp_ptr,FileNum-6);  
         
	 
	 RMMemcpy(tmp_ptr,ITRI_ID,10);
         RMMemcpy(tmp_ptr+10,&FileNum,2);
         RMMemcpy(tmp_ptr+12,&itri_NWA,4);
         RMMemcpy(tmp_ptr+16,&global_blks,4);
	 isMultiFlag=0x01;
	 UDF102_FS_Create(isMultiFlag,tmp_ptr,NextWriteAddr);	
	 RMMemcpy(udf_ptr+120*2048,tmp_ptr,20+FileNum*60);  	
	 //?寫檔�系統	
	 itri_NWA=NextWriteAddr;	
	 printf("?寫檔�系統UDF 102 :%ld ~%ld \n",NextWriteAddr,NextWriteAddr+300);	
         for (i=0;i<10;i++)
	{
		
		//ITRI_WriteCommand(RMuint8 *itri_buf,RMuint32 NWA,RMuint16 transferLen)
		status=ITRI_WriteCommand(udf_ptr+61440*i,itri_NWA,30);
		if (status==RM_OK)
			itri_NWA+=30;
		
	}
	 
	 UDF102_File_ICB_Create(tmp_ptr);       
		
	 printf("?�寫UDF ICB :%ld ~%ld \n",NextWriteAddr+300,NextWriteAddr+700);	
	 for (i=0;i<13;i++)
	{
		status=ITRI_WriteCommand(udf_ptr+61440*i,itri_NWA,30);
		if (status==RM_OK)
			itri_NWA+=30;
	
	
	}
	status=ITRI_WriteCommand(udf_ptr+390*2048,itri_NWA,10);
	if (status==RM_OK)
	{	
		itri_NWA+=10;
		printf("ITRI_WriteCommand() successfully\n");
	}	
	
	 ITRI_pnav->MyFavorfiletemp = ITRI_pnav->MyFavorfilefirst;   
        for (i=0;i<numofItems;i++)//tmp_nwa
           {      
           
	   	RMMemset(fullpath,0x00,80);RMMemset(&udf_file,0x00,60);
           	RMCopyAscii(fullpath,ITRI_pnav->MyFavorfiletemp->path);
           	RMAppendAscii(fullpath,ITRI_pnav->MyFavorfiletemp->name);
           	RMMemcpy(&udf_file,tmp_ptr+20+(PrevNum+i)*60,60);
		FileBlks= (  (udf_file.F_Lengh%2048==0)?udf_file.F_Lengh/2048:udf_file.F_Lengh/2048+1);
		printf("%d Write AVP FIle:%s ,NWA=%ld ,Blks=%ld \n",i,udf_file.F_name,udf_file.FileAddr,FileBlks   );
	   	WriteSingleFile(fullpath,udf_file.FileAddr,udf_file.F_Lengh);
	   	ITRI_pnav->MyFavorfiletemp1 = ITRI_pnav->MyFavorfiletemp->next;
           	ITRI_pnav->MyFavorfiletemp  = ITRI_pnav->MyFavorfiletemp1;
            }   
	
	WriteKODAKPVMFile2(tmp_ptr,PrevNum+numofItems);       
	return RM_OK;
}
RMstatus  Compute_ITRI_ListInfo(RMuint16 numofItems,RMuint8 type)
{
  
  RMuint8 *ptr1=NULL,*tmp_ptr=NULL;
  RMuint32 next_lba,tmp_lba,tmp_nwa,BlankBufLen,tmp_blks=0;
  RMuint16 i,PrevNum,FileNum;
  long length;
  //RMstatus status;
  RMuint64 tmp_size;
  //RMuint32 retry=0;
  RMuint32 total_size,tmp_len,total_blk=0,Vol_Blocks;//tmp_lba,tmp_len,
  typeUdfFile udf_file;
  RMascii fullpath[80];
  RMuint8 itri_id[12],isMultiFlag=0;
   RMMemset(itri_id,0x00,12);
  AllocateBuffer();
  ptr1=buf_ptr;
  tmp_ptr=CurPtr;
  RMMemset(ptr1,0x00,2048*6);RMMemset(tmp_ptr,0x00,2048*12);
  
  //xxxxxxxxxxxxxxxx

  ITRI_Size=0;tmp_size=0;
  ITRI_pnav->MyFavorfiletemp = ITRI_pnav->MyFavorfilefirst;
  for (i=0;i<numofItems;i++){
  	tmp_size+=(RMuint64)ITRI_pnav->MyFavorfiletemp->size;
	
	//printf("%d name=%s ,size=%ld \n",i,ITRI_pnav->MyFavorfiletemp->name,(RMuint32)ITRI_pnav->MyFavorfiletemp->size);
	ITRI_pnav->MyFavorfiletemp1 = ITRI_pnav->MyFavorfiletemp->next;
        ITRI_pnav->MyFavorfiletemp  = ITRI_pnav->MyFavorfiletemp1;	
  }
  if ((tmp_size% 2048)==0)
  {
  	ITRI_Size=tmp_size/2048;
  
  }
  else
  {
  	ITRI_Size=(tmp_size/2048)+1;
  }
  printf("Total selected file=%d ,size=%ld,size(Blk):%ld \n",numofItems,(RMuint32)tmp_size,ITRI_Size);
		//end xxxxxxxxxxxxxxx
		
		
  
  Writed_Size=0;
 
  switch (ITRI_DISC_Flag)
   {
        case 1:
         
	  printf("Blank DVD+RW Disc\n");
          FileNum=numofItems+6;//1+1+1+3;//Add 1.PASSIDX.PVM   2.ALBUM.PVM 3.ASSET_LIST.PVM
                ITRI_pnav->MyFavorfiletemp = ITRI_pnav->MyFavorfilefirst;
                tmp_nwa=720;
                RMMemset(ptr1,0x00,numofItems * 60);
                for (i=0;i<numofItems;i++)//tmp_nwa
                     { 
                   RMMemset(fullpath,0x00,80);
                
                   RMCopyAscii(fullpath,ITRI_pnav->MyFavorfiletemp->path);
                   RMAppendAscii(fullpath,ITRI_pnav->MyFavorfiletemp->name);
                   
                   RMMemset(udf_file.F_name,0x00,sizeof(typeUdfPath));
                   RMCopyAscii(udf_file.F_name,ITRI_pnav->MyFavorfiletemp->name);
                   
                   udf_file.FileAddr=tmp_nwa;
                   udf_file.F_Lengh=(RMuint32)ITRI_pnav->MyFavorfiletemp->size;
                   udf_file.Attribute=type;
                   RMMemcpy(ptr1+i*60,&udf_file,60);
                   WriteSingleFile(fullpath,tmp_nwa,udf_file.F_Lengh);
                   
                   tmp_nwa=tmp_nwa+(udf_file.F_Lengh)/2048+1;
                   
                   ITRI_pnav->MyFavorfiletemp1 = ITRI_pnav->MyFavorfiletemp->next;
                   ITRI_pnav->MyFavorfiletemp  = ITRI_pnav->MyFavorfiletemp1;
                     }
                     /*
                 PASSIDX File
                   1. File name   2. File Addr  3.File Length   4.Attributes
                     */
                 RMMemset(fullpath,0x00,80);
                 RMCopyAscii(fullpath,"/tmp/itri_tmp.txt");
                 RMMemset(udf_file.F_name,0x00,sizeof(typeUdfPath));
                 RMCopyAscii(udf_file.F_name,"PASSIDX.PVM");
                 udf_file.FileAddr=tmp_nwa;
                 length=Write_PASS_PVM();
                 udf_file.F_Lengh=(RMuint32)length;
                 udf_file.Attribute=0x04;
                 RMMemcpy(ptr1+numofItems*60,&udf_file,60);
                 WriteSingleMPVFile(fullpath,tmp_nwa,udf_file.F_Lengh);
                 tmp_nwa=tmp_nwa+(udf_file.F_Lengh)/2048+1;
                    /*
                 ALBUM.PVM File
                   1. File name   2. File Addr  3.File Length   4.Attributes
                     */
                 RMMemset(fullpath,0x00,80);
                 RMCopyAscii(fullpath,"/tmp/itri_tmp.txt");
                 RMMemset(udf_file.F_name,0x00,sizeof(typeUdfPath));
                 RMCopyAscii(udf_file.F_name,"ALBUM.PVM");
                 udf_file.FileAddr=tmp_nwa;
                 length=Write_ALBUM_PVM(ptr1,FileNum);
		 //length=Write_ALBUM_PVM();
                 udf_file.F_Lengh=(RMuint32)length;
                 udf_file.Attribute=0x04;
                 RMMemcpy(ptr1+(numofItems+1)*60,&udf_file,60);
                 ITRI_context->gui->ITRI_Draw_Burn_Progress(99,udf_file.F_name);
		 //ITRI_context->gui->ITRI_Draw_Burn_Progress(99,udf_file.F_name);
		 WriteSingleMPVFile(fullpath,tmp_nwa,udf_file.F_Lengh);
                 tmp_nwa=tmp_nwa+(udf_file.F_Lengh)/2048+1; 
                 
                  /*
                 ASSET_LIST.PVM File
                   1. File name   2. File Addr  3.File Length   4.Attributes
                 */
             //Write_AssetList_PVM      Write_AssetList_PVM
                RMMemset(fullpath,0x00,80);
                 RMCopyAscii(fullpath,"/tmp/itri_tmp.txt");
                 RMMemset(udf_file.F_name,0x00,sizeof(typeUdfPath));
                 RMCopyAscii(udf_file.F_name,"ASSET_LIST.PVM"); 
                 udf_file.FileAddr=tmp_nwa;
                 length=Write_AssetList_PVM();
                 udf_file.F_Lengh=(RMuint32)length;
                 udf_file.Attribute=0x04;
                 RMMemcpy(ptr1+(numofItems+2)*60,&udf_file,60);
                 ITRI_context->gui->ITRI_Draw_Burn_Progress(99,udf_file.F_name);
		 WriteSingleMPVFile(fullpath,tmp_nwa,udf_file.F_Lengh);
                 tmp_nwa=tmp_nwa+(udf_file.F_Lengh)/2048+1;
          	 
		 /*
		 #define jpg_pvm  "PASS_PICTURES.PVM"
  		#define wmv_pvm  "PASS_MOVIES.PVM"
  		#define mp3_pvm  "PASS_AUDIO.PVM"
   
		 */
		 //Write_PASS_PICTURES.PVM ICB=37
		 RMMemset(fullpath,0x00,80);
                 RMCopyAscii(fullpath,"/tmp/itri_tmp.txt");
                 RMMemset(udf_file.F_name,0x00,sizeof(typeUdfPath));
                 RMCopyAscii(udf_file.F_name,"PASS_PICTURES.PVM"); 
                 udf_file.FileAddr=tmp_nwa;
                 length=Write_Pictures_PVM(ptr1,FileNum);//AssetList_PVM();Write_AssetList_PVM(
                 udf_file.F_Lengh=(RMuint32)length;
                 udf_file.Attribute=0x04;
                 RMMemcpy(ptr1+(numofItems+3)*60,&udf_file,60);
                 ITRI_context->gui->ITRI_Draw_Burn_Progress(99,udf_file.F_name);