k9copy/libk9copy/k9ifo2.cpp

/***************************************************************************
 *   Copyright (C) 2005 by Jean-Michel Petit                               *
 *   jm_petit@laposte.net                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
 ***************************************************************************/
#include "k9ifo2.h"
#include "bswap.h"
#include "dvdread.h"


k9Ifo2::k9Ifo2(k9DVDRead *_dvdread)
        : TQObject(NULL,"") {
    _ifo=NULL;
    m_dvd=_dvdread;
}


k9Ifo2::~k9Ifo2() {
    closeIFO();


}

/*!
    \fn k9Ifo2::setDevice(TQString &_device)
 */
void k9Ifo2::setDevice(TQString &_device) {
    device=_device;
}


/*!
    \fn k9Ifo2::setOutput(TQString &_output)
 */
void k9Ifo2::setOutput(TQString &_output) {
    output=_output;
}


/*!
    \fn k9Ifo2::openIFO(int _num)
 */
ifo_handle_t * k9Ifo2::openIFO(int _num) {
    _ifo = ifoOpen(m_dvd->getDvd(), _num);
    numIfo=_num;
    return _ifo;

}


/*!
    \fn k9Ifo2::IFOClose( ifo_handle_t* _ifo)
 */
void k9Ifo2::closeIFO() {
    if(_ifo!=NULL) {
        ifoClose(_ifo);
        _ifo=NULL;
    }
}

ifo_handle_t * k9Ifo2::getIFO() {
    return _ifo;
}

/*!
    \fn k9Ifo2::saveIFO(ifo_handle_t* _ifo)
 */
void k9Ifo2::saveIFO() {
    uint32_t size;
    /* DVD handler */
    k9DVDFile *dvdfile;
    bool mainIfo = (numIfo==0);

    TQString filename,filename2;
    if (mainIfo) {
        filename="/VIDEO_TS/VIDEO_TS.IFO";
    } else {
        filename.sprintf("/VIDEO_TS/VTS_%02d_0.IFO",numIfo);
    }
    if (numIfo==0) 
	size=_ifo->vmgi_mat->vmgi_last_sector +1;
    else
	size=_ifo->vtsi_mat->vtsi_last_sector +1;

    size*=DVD_BLOCK_LEN;
 //   if (k9UDFFindFile(dvd,(char*) filename.latin1(), &size)) {
    if (size > 0) {
        uchar *buffer ;
        buffer=new uchar[size];
        bufCopy=new uchar[size];
        m_buffer=new uchar[size*2];
        memset(buffer,0,size);
        memset(bufCopy,0,size);
	memset(m_buffer,0,size*2);
        //Lecture du fichier IFO original et sauvegarde dans buffer
        if ((dvdfile = m_dvd->openIfo(numIfo))== 0) {
            fprintf(stderr, "Failed opening IFO for titleset %d\n", 0);
            free(buffer);
            return;
        }

        /*	 if(DVDFileSeek(dvd_file, 0)!=0) {
            	return;
          	}
        */

        if (dvdfile->readBytes(buffer,size) != size) {
            fprintf(stderr, "Error reading IFO for titleset %d\n", 0);
            free(buffer);
            dvdfile->close();
            return;
        }

        memcpy(bufCopy,buffer,size);
        bufCopySize=size;
        dvdfile->close();
        if (mainIfo) {
            m_position=0;
            updateVMG(buffer);
	    m_position=1024; //sizeof(vmgi_mat_t);    
            updateFP_PGC(buffer);
            _ifo->vmgi_mat->vmgi_last_byte=m_position -1;

            updateTT_SRPT(buffer);
            updatePGCI_UT(buffer);

            updateVTS_ATRT(buffer);
            updateTXTDT_MGI(buffer);
            updateC_ADT(buffer,true);
            updateVOBU_ADMAP(buffer,true);
            
            updateVMG(buffer);

        } else {
            m_position=0;
            updateVTS(buffer);
            m_position=sizeof(vtsi_mat_t);
	    //_ifo->vtsi_mat->vtsi_last_byte=m_position -1;
            updateVTS_PTT_SRPT(buffer);
            updatePGCIT(buffer);
            updatePGCI_UT(buffer);
            updateVTS_TMAPT(buffer);
            updateC_ADT(buffer,true);
            updateVOBU_ADMAP(buffer,true);
            updateC_ADT(buffer, false);
            updateVOBU_ADMAP(buffer,false);
            updateVTS(buffer);
        }
	m_position=round(m_position);

        //sauvegarder buffer dans fichier
        if (mainIfo) {
            filename=output + "/VIDEO_TS.IFO";
            filename2=output + "/VIDEO_TS.BUP";
        } else {
            filename.sprintf("/VTS_%02d_0.IFO",numIfo);
            filename=output + filename;

            filename2.sprintf("/VTS_%02d_0.BUP",numIfo);
            filename2=output + filename2;
        }

        TQFile ifofile (filename);
        ifofile.open(IO_WriteOnly);
        if (ifofile.writeBlock((char*)m_buffer,m_position) == -1) {
            TQString sError("erreur");
        }
        ifofile.close();

        TQFile ifofile2 (filename2);
        ifofile2.open(IO_WriteOnly);
        if (ifofile2.writeBlock((char*)m_buffer,m_position) == -1) {
            TQString sError("erreur");
        }
        ifofile2.close();


        delete buffer;
        delete bufCopy;
        delete m_buffer;
    }
}


/*!
    \fn k9Ifo2::updateVMG(uchar * _buffer)
 */
void k9Ifo2::updateVMG(uchar * _buffer) {
    vmgi_mat_t vmgi_mat;
    memcpy(&vmgi_mat,_ifo->vmgi_mat,sizeof(vmgi_mat_t));
    uint32_t lastSector=vmgi_mat.vmgi_last_sector;
    uint32_t lastByte=vmgi_mat.vmgi_last_byte;
    //JMP : à vérifier
    if (m_position !=0) {
	lastSector=(round(m_position) - DVD_BLOCK_LEN) / DVD_BLOCK_LEN;
	//lastByte=vmgi_mat.vmgi_last_sector * DVD_BLOCK_LEN +DVD_BLOCK_LEN -1;
	vmgi_mat.vmg_last_sector+=2*(lastSector-vmgi_mat.vmgi_last_sector);
    }
    
    vmgi_mat.vmgi_last_sector=lastSector;
    if (vmgi_mat.vmgm_vobs !=0)
    	vmgi_mat.vmgm_vobs=vmgi_mat.vmgi_last_sector +1;
    
    B2N_32(vmgi_mat.vmg_last_sector);
    B2N_32(vmgi_mat.vmgi_last_sector);
    B2N_32(vmgi_mat.vmg_category);
    B2N_16(vmgi_mat.vmg_nr_of_volumes);
    B2N_16(vmgi_mat.vmg_this_volume_nr);
    B2N_16(vmgi_mat.vmg_nr_of_title_sets);
    B2N_64(vmgi_mat.vmg_pos_code);
    B2N_32(vmgi_mat.vmgi_last_byte);
    B2N_32(vmgi_mat.first_play_pgc);
    B2N_32(vmgi_mat.vmgm_vobs);
    B2N_32(vmgi_mat.tt_srpt);
    B2N_32(vmgi_mat.vmgm_pgci_ut);
    B2N_32(vmgi_mat.ptl_mait);
    B2N_32(vmgi_mat.vts_atrt);
    B2N_32(vmgi_mat.txtdt_mgi);
    B2N_32(vmgi_mat.vmgm_c_adt);
    B2N_32(vmgi_mat.vmgm_vobu_admap);
    B2N_16(vmgi_mat.vmgm_audio_attr.lang_code);
    B2N_16(vmgi_mat.vmgm_subp_attr.lang_code);

    memcpy(m_buffer,&vmgi_mat,sizeof(vmgi_mat_t));
}


/*!
    \fn k9Ifo2::updateFP_PGC(uchar * _buffer)
 */
void k9Ifo2::updateFP_PGC(uchar * _buffer) {
    //int offset=_ifo->vmgi_mat->first_play_pgc;
    _ifo->vmgi_mat->first_play_pgc=m_position;
    return updatePGC(_buffer,_ifo->first_play_pgc,m_position);


}

/*!
    \fn k9Ifo2::updatePGC(uchar *_buffer,pgc_t *_pgc,int _offset)
 */
void k9Ifo2::updatePGC(uchar *_buffer,pgc_t *_pgc,int _offset) {
    pgc_t pgc;
    memcpy(&pgc,_pgc,sizeof(pgc_t));
    uint start=m_position;
    m_position+=PGC_SIZE;
    
    if(pgc.command_tbl_offset != 0) {
        pgc.command_tbl_offset=PGC_SIZE;
        updatePGC_COMMAND_TBL(_buffer ,pgc.command_tbl  ,m_position);
    }
    if(pgc.program_map_offset != 0) {
        pgc.program_map_offset=m_position-start;
        updatePGC_PROGRAM_MAP(_buffer, pgc.program_map,pgc.nr_of_programs ,m_position);
    }
    if(pgc.cell_playback_offset != 0) {
        pgc.cell_playback_offset=m_position-start;
        updatePGC_CELL_PLAYBACK_TBL(_buffer ,pgc.cell_playback,pgc.nr_of_cells,m_position);
    }

    if(pgc.cell_position_offset != 0) {
        pgc.cell_position_offset=m_position-start;
        updatePGC_CELL_POSITION_TBL(_buffer,pgc.cell_position,pgc.nr_of_cells,m_position);
    }
    
    B2N_16(pgc.command_tbl_offset);
    B2N_16(pgc.next_pgc_nr);
    B2N_16(pgc.prev_pgc_nr);
    B2N_16(pgc.goup_pgc_nr);
    B2N_16(pgc.program_map_offset);
    B2N_16(pgc.cell_playback_offset);
    B2N_16(pgc.cell_position_offset);

    int i;
    for(i = 0; i < 8; i++)
        B2N_16(pgc.audio_control[i]);
    for(i = 0; i < 32; i++)
        B2N_32(pgc.subp_control[i]);
    for(i = 0; i < 16; i++)
        B2N_32(pgc.palette[i]);

    memcpy(m_buffer+_offset,&pgc,PGC_SIZE);
}



/*!
    \fn k9Ifo2::updatePGC_COMMAND_TBL(uchar  *_buffer,pgc_command_tbl_t *_cmd_tbl,int offset)
 */
void k9Ifo2::updatePGC_COMMAND_TBL(uchar  *_buffer,pgc_command_tbl_t *_cmd_tbl,int _offset) {
    struct {
        uint16_t nr_of_pre;
        uint16_t nr_of_post;
        uint16_t nr_of_cell;
        uint16_t last_byte;
    }
    ATTRIBUTE_PACKED cmd_tbl;

    memcpy(&cmd_tbl,_cmd_tbl,sizeof(cmd_tbl));

    //moves the offset to save vm_cmd
    m_position+=sizeof(cmd_tbl);

    if(_cmd_tbl->nr_of_pre != 0) {
        unsigned int pre_cmds_size  = _cmd_tbl->nr_of_pre * COMMAND_DATA_SIZE;
        memcpy(m_buffer + m_position,_cmd_tbl->pre_cmds,pre_cmds_size);
        m_position+=pre_cmds_size;
    }
    if(_cmd_tbl->nr_of_post != 0) {
        unsigned int post_cmds_size = _cmd_tbl->nr_of_post * COMMAND_DATA_SIZE;
        memcpy(m_buffer + m_position,_cmd_tbl->post_cmds,post_cmds_size);
        m_position+=post_cmds_size;
    }
    if(_cmd_tbl->nr_of_cell != 0) {
        unsigned int cell_cmds_size = _cmd_tbl->nr_of_cell * COMMAND_DATA_SIZE;
        memcpy(m_buffer +m_position,_cmd_tbl->cell_cmds,cell_cmds_size);
        m_position+=cell_cmds_size;
    }
    B2N_16(cmd_tbl.nr_of_pre);
    B2N_16(cmd_tbl.nr_of_post);
    B2N_16(cmd_tbl.nr_of_cell);
    cmd_tbl.last_byte=m_position-_offset-1;
    B2N_16(cmd_tbl.last_byte);
    memcpy(m_buffer+_offset,&cmd_tbl,sizeof(cmd_tbl));


}


/*!
    \fn k9Ifo2::updatePGC_PROGRAM_MAP(uchar *_buffer, pgc_program_map_t *_program_map, int _nr, int_offset
 */
void k9Ifo2::updatePGC_PROGRAM_MAP(uchar *_buffer, pgc_program_map_t *_program_map, int _nr, int _offset) {
    int size = _nr * sizeof(pgc_program_map_t);
    memcpy(m_buffer+_offset, _program_map, size);
    // pad to word boundary
    size += size % 2;
    m_position += size;
}


/*!
    \fn k9Ifo2::updatePGC_CELL_PLAYBACK_TBL(uchar *_buffer, cell_playback_t *_cell_playback,int _nr, int _offset)
 */
void k9Ifo2::updatePGC_CELL_PLAYBACK_TBL(uchar *_buffer, cell_playback_t *_cell_playback,int _nr, int _offset) {
    cell_playback_t *cell_playback;
    int size = _nr * sizeof(cell_playback_t);
    cell_playback=(cell_playback_t*) malloc(size);
    memcpy(cell_playback,_cell_playback,size);

    for( int i = 0; i < _nr; i++) {
        B2N_32(cell_playback[i].first_sector);
        B2N_32(cell_playback[i].first_ilvu_end_sector);
        B2N_32(cell_playback[i].last_vobu_start_sector);
        B2N_32(cell_playback[i].last_sector);
    }

    memcpy(m_buffer + _offset,cell_playback,size);
    m_position+=size;

    free(cell_playback);
}


/*!
    \fn k9Ifo2::updatePGC_CELL_POSITION_TBL(uchar *_buffer,cell_position_t *_cell_position,int _nr, int _offset)
 */
void k9Ifo2::updatePGC_CELL_POSITION_TBL(uchar *_buffer,cell_position_t *_cell_position,int _nr, int _offset) {
    cell_position_t * cell_position;
    int size = _nr * sizeof(cell_position_t);
    cell_position=(cell_position_t*)malloc(size);
    memcpy(cell_position,_cell_position,size);
    for( int i = 0; i < _nr; i++) {
        B2N_16(cell_position[i].vob_id_nr);
    }
    memcpy(m_buffer + _offset,cell_position,size);
    m_position+=size;
    free(cell_position);
}

int k9Ifo2::round(int _value) {
   return ((_value-1)|(DVD_BLOCK_LEN-1))+1; // DVD_BLOCK_LEN-1 = 0x7FF
}

/*!
    \fn k9Ifo2::updateTT_SRPT(uchar *_buffer)
 */
void k9Ifo2::updateTT_SRPT(uchar *_buffer) {
    if(_ifo->vmgi_mat->tt_srpt != 0) {
        tt_srpt_t * tt_srpt;
        tt_srpt=(tt_srpt_t*) malloc(sizeof(tt_srpt_t));
      //  int offset= _ifo->vmgi_mat->tt_srpt * DVD_BLOCK_LEN;
         
         m_position=round(m_position);
        int offset=m_position;
        _ifo->vmgi_mat->tt_srpt=m_position/DVD_BLOCK_LEN;
        
        memcpy (tt_srpt,_ifo->tt_srpt,sizeof(tt_srpt_t));


        int  info_length = tt_srpt->last_byte + 1 - TT_SRPT_SIZE;
        title_info_t * title_info;
        title_info =(title_info_t*) malloc(info_length);
        memcpy(title_info, tt_srpt->title,info_length);
	
        for(int i =  0; i < tt_srpt->nr_of_srpts; i++) {
            B2N_16(title_info[i].nr_of_ptts);
            B2N_16(title_info[i].parental_id);
            B2N_32(title_info[i].title_set_sector);
        }
        memcpy(m_buffer+offset+TT_SRPT_SIZE,title_info,info_length);

        free(title_info);
	m_position +=info_length;

        B2N_16(tt_srpt->nr_of_srpts);
        B2N_32(tt_srpt->last_byte);
        memcpy(m_buffer+offset,tt_srpt,TT_SRPT_SIZE);
        free (tt_srpt);
    }

}


void k9Ifo2::updatePGCI_UT(uchar *_buffer) {
    int sector,sector2;
    if(_ifo->vmgi_mat) {
        if(_ifo->vmgi_mat->vmgm_pgci_ut == 0)
            return;
        m_position=round(m_position);
        _ifo->vmgi_mat->vmgm_pgci_ut=m_position/DVD_BLOCK_LEN;
    } else if(_ifo->vtsi_mat) {
        if(_ifo->vtsi_mat->vtsm_pgci_ut == 0)
            return;
        m_position=round(m_position);
        _ifo->vtsi_mat->vtsm_pgci_ut=m_position/DVD_BLOCK_LEN;
    } else {
        return;
    }
    
    
    sector2=sector=m_position;
    if (_ifo->pgci_ut !=NULL) {
	pgci_ut_t * pgci_ut;
	pgci_ut = (pgci_ut_t*) malloc( sizeof(pgci_ut_t));
	memcpy (pgci_ut,_ifo->pgci_ut,sizeof(pgci_ut_t));
	m_position+=PGCI_UT_SIZE;
	sector2=m_position;
	
	pgci_lu_t pgci_lu[_ifo->pgci_ut->nr_of_lus];
	m_position+=_ifo->pgci_ut->nr_of_lus*PGCI_LU_SIZE;
	memcpy(pgci_lu,_ifo->pgci_ut->lu,_ifo->pgci_ut->nr_of_lus*sizeof(pgci_lu_t));
	
	for(int i = 0; i < _ifo->pgci_ut->nr_of_lus; i++) {
		B2N_16(pgci_lu[i].lang_code);
		pgci_lu[i].lang_start_byte=m_position - sector;
		B2N_32(pgci_lu[i].lang_start_byte);
		updatePGCIT_internal(_buffer,_ifo->pgci_ut->lu[i].pgcit,m_position);	
	}
	for (int i=0;i <_ifo->pgci_ut->nr_of_lus;i++)
		memcpy(m_buffer+sector2+i*PGCI_LU_SIZE ,&(pgci_lu[i]),PGCI_LU_SIZE);
		
    	B2N_16(pgci_ut->nr_of_lus);
    	pgci_ut->last_byte=m_position-sector-1;
	B2N_32(pgci_ut->last_byte);
	memcpy(m_buffer+sector,pgci_ut,PGCI_UT_SIZE);
	free(pgci_ut);
	

    }

}

void k9Ifo2::updatePGCIT(uchar *_buffer) {
    if(!_ifo->vtsi_mat)
        return ;

    if(_ifo->vtsi_mat->vts_pgcit == 0) /* mandatory */
        return ;
    m_position=round(m_position);
    _ifo->vtsi_mat->vts_pgcit=m_position / DVD_BLOCK_LEN;
    updatePGCIT_internal(_buffer,_ifo->vts_pgcit,_ifo->vtsi_mat->vts_pgcit * DVD_BLOCK_LEN);
}


void k9Ifo2::updatePGCIT_internal(uchar *_buffer, pgcit_t *_pgcit, int _offset) {
    pgcit_t * pgcit;
    pgcit=(pgcit_t*)malloc(sizeof(pgcit_t));
    memcpy(pgcit,_pgcit,sizeof(pgcit_t));

    int offset=m_position+PGCIT_SIZE;
    m_position+=PGCIT_SIZE;

    pgci_srp_t pgci_srp[_pgcit->nr_of_pgci_srp];
    memcpy(pgci_srp,_pgcit->pgci_srp,sizeof(pgci_srp_t)*_pgcit->nr_of_pgci_srp);
    
    m_position+=_pgcit->nr_of_pgci_srp*PGCI_SRP_SIZE;

    for(int i = 0; i < _pgcit->nr_of_pgci_srp; i++) {
        B2N_16(pgci_srp[i].ptl_id_mask);
        pgci_srp[i].pgc_start_byte=m_position-_offset;
        B2N_32(pgci_srp[i].pgc_start_byte); //JMP:faux
        updatePGC(_buffer,_pgcit->pgci_srp[i].pgc,m_position);
    }

    for(int i = 0; i < _pgcit->nr_of_pgci_srp; i++) 
        memcpy(m_buffer+offset+i*PGCI_SRP_SIZE,&(pgci_srp[i]),PGCI_SRP_SIZE);
    
    B2N_16(pgcit->nr_of_pgci_srp);
    pgcit->last_byte=m_position-_offset-1;
    B2N_32(pgcit->last_byte);
    memcpy(m_buffer+_offset ,pgcit,PGCIT_SIZE);
    free(pgcit);

}


void k9Ifo2::updatePTL_MAIT(uchar *_buffer) {
    if(!_ifo->vmgi_mat)
        return;

    _ifo->vmgi_mat->ptl_mait = 0;
     return;
}

void k9Ifo2::updateVTS_ATRT(uchar *_buffer) {
    if(_ifo->vmgi_mat->vts_atrt == 0)
        return;
    uint32_t orig=_ifo->vmgi_mat->vts_atrt * DVD_BLOCK_LEN;
    m_position=round(m_position);
   _ifo->vmgi_mat->vts_atrt=m_position/DVD_BLOCK_LEN;
   
    memcpy(m_buffer+m_position,_buffer+orig,_ifo->vts_atrt->last_byte+1);
   
    m_position+=_ifo->vts_atrt->last_byte+1;
    /*
    int sector = _ifo->vmgi_mat->vts_atrt * DVD_BLOCK_LEN;
    vts_atrt_t *vts_atrt;
    vts_atrt = (vts_atrt_t*)malloc(sizeof(vts_atrt_t));
    memcpy(vts_atrt,_ifo->vts_atrt,VTS_ATRT_SIZE);
    B2N_16(vts_atrt->nr_of_vtss);
    B2N_32(vts_atrt->last_byte);
    memcpy(m_buffer+sector,vts_atrt,VTS_ATRT_SIZE);
    free(vts_atrt);
    m_position+=VTS_ATRT_SIZE;

    sector += VTS_ATRT_SIZE;
        
    memcpy(m_buffer+sector,_buffer +orig+VTS_ATRT_SIZE ,VTS_ATTRIBUTES_SIZE*_ifo->vts_atrt->nr_of_vtss);
    
    m_position+=VTS_ATTRIBUTES_SIZE*_ifo->vts_atrt->nr_of_vtss;
    */
}

void k9Ifo2::updateTXTDT_MGI(uchar * _buffer) {
    if(_ifo->vmgi_mat->txtdt_mgi == 0)
        return;
    
   struct  {
     char disc_name[15];
     char nr_of_language_units; 
     uint32_t last_byte;
     txtdt_lu_t *lu;
  } ATTRIBUTE_PACKED txtdtmgi;    
    
    
    m_position=round(m_position);
    int orig=_ifo->vmgi_mat->txtdt_mgi*DVD_BLOCK_LEN;
    int offset=m_position;
    _ifo->vmgi_mat->txtdt_mgi =m_position/ DVD_BLOCK_LEN;
    memcpy(&txtdtmgi,_buffer+orig,sizeof(txtdtmgi));
    
    B2N_32(txtdtmgi.last_byte);
    memcpy(m_buffer+offset,_buffer+orig ,txtdtmgi.last_byte+1);
    m_position+=txtdtmgi.last_byte+1;
}

void k9Ifo2::updateC_ADT(uchar * _buffer, bool _isMenu) {
    if(_ifo->vmgi_mat) {
        if(_ifo->vmgi_mat->vmgm_c_adt != 0) {
            m_position =round(m_position); //
            _ifo->vmgi_mat->vmgm_c_adt=m_position/ DVD_BLOCK_LEN;
            updateC_ADT_Internal(_buffer,_ifo->menu_c_adt,m_position);
        }
    } else if(_ifo->vtsi_mat) {
        if(_ifo->vtsi_mat->vtsm_c_adt != 0 && _isMenu) {
            m_position=round(m_position); //sector =
            _ifo->vtsi_mat->vtsm_c_adt=m_position / DVD_BLOCK_LEN;
            updateC_ADT_Internal(_buffer,_ifo->menu_c_adt,m_position);
        }
        if (_ifo->vtsi_mat->vts_c_adt !=0 && !_isMenu) {
            m_position=round(m_position); //sector = 
            _ifo->vtsi_mat->vts_c_adt=m_position / DVD_BLOCK_LEN;
            updateC_ADT_Internal(_buffer,_ifo->vts_c_adt,m_position);
        }
    } else {
        return ;
    }

}

void k9Ifo2::updateC_ADT_Internal(uchar *_buffer,c_adt_t *_c_adt,int _sector) {
    c_adt_t * c_adt;
    c_adt =(c_adt_t*) malloc (sizeof(c_adt_t));
    memcpy(c_adt,_c_adt,sizeof(c_adt_t));


    int offset =_sector + C_ADT_SIZE;
    m_position+=C_ADT_SIZE;
    
    int info_length = _c_adt->last_byte + 1 - C_ADT_SIZE;

    cell_adr_t *cell_adr,*ptr;
    cell_adr=(cell_adr_t*) malloc(sizeof(cell_adr_t));

    ptr= _c_adt->cell_adr_table;
    for(int i = 0; i < info_length/sizeof(cell_adr_t); i++) {
        memcpy(cell_adr,&(ptr[i]),sizeof(cell_adr_t));
        B2N_16(cell_adr->vob_id);
        B2N_32(cell_adr->start_sector);
        B2N_32(cell_adr->last_sector);
        memcpy(m_buffer+offset,cell_adr,sizeof(cell_adr_t));
        offset+=sizeof(cell_adr_t);
        //ptr+=sizeof(cell_adr_t);
    }
    
    m_position+=info_length;
    free(cell_adr);
    
    B2N_16(c_adt->nr_of_vobs);
    c_adt->last_byte=m_position-_sector-1;
    B2N_32(c_adt->last_byte);
    memcpy(m_buffer+_sector,c_adt,C_ADT_SIZE);
    free(c_adt);
}

void k9Ifo2::updateVOBU_ADMAP(uchar * _buffer, bool _isMenu) {
    int sector;
    if(_ifo->vmgi_mat) {

        if(_ifo->vmgi_mat->vmgm_vobu_admap == 0)
            return ;
        sector = m_position=round(m_position);//_ifo->vmgi_mat->vmgm_vobu_admap * DVD_BLOCK_LEN;
        _ifo->vmgi_mat->vmgm_vobu_admap=m_position/DVD_BLOCK_LEN;
        updateVOBU_ADMAP_Internal(_buffer,_ifo->menu_vobu_admap,sector);

    } else if(_ifo->vtsi_mat) {

        if(_ifo->vtsi_mat->vtsm_vobu_admap != 0 && _isMenu) {
            sector = m_position=round(m_position);//sector = _ifo->vtsi_mat->vtsm_vobu_admap * DVD_BLOCK_LEN;
            _ifo->vtsi_mat->vtsm_vobu_admap=m_position/DVD_BLOCK_LEN;
            updateVOBU_ADMAP_Internal(_buffer,_ifo->menu_vobu_admap,sector);
        }
        if (_ifo->vtsi_mat->vts_vobu_admap !=0 && !_isMenu) {
            sector = m_position=round(m_position);//sector = _ifo->vtsi_mat->vts_vobu_admap * DVD_BLOCK_LEN;
            _ifo->vtsi_mat->vts_vobu_admap=m_position/DVD_BLOCK_LEN;
            updateVOBU_ADMAP_Internal(_buffer,_ifo->vts_vobu_admap,sector);
        }
    } else {
        return ;
    }
}

void k9Ifo2::updateVOBU_ADMAP_Internal(uchar *_buffer,vobu_admap_t *_vobu_admap,int _sector) {
    vobu_admap_t *vobu_admap;
    vobu_admap=(vobu_admap_t*)malloc(sizeof(vobu_admap_t));
    memcpy(vobu_admap,_vobu_admap,sizeof(vobu_admap_t));

    int offset = _sector + VOBU_ADMAP_SIZE;
    m_position+=VOBU_ADMAP_SIZE;
    
    int info_length = _vobu_admap->last_byte + 1 - VOBU_ADMAP_SIZE;
    uint32_t *vobu_start_sectors;
    vobu_start_sectors=(uint32_t*)malloc(info_length);
    memcpy(vobu_start_sectors,_vobu_admap->vobu_start_sectors,info_length);

    for(int i = 0; i < info_length/sizeof(uint32_t); i++)
        B2N_32(vobu_start_sectors[i]);

    memcpy(m_buffer+offset,vobu_start_sectors,info_length);
    
    m_position+=info_length;
    free(vobu_start_sectors);
    vobu_admap->last_byte=m_position-_sector-1;
    B2N_32(vobu_admap->last_byte);
    memcpy(m_buffer+_sector,vobu_admap,VOBU_ADMAP_SIZE);
    free(vobu_admap);

}

void k9Ifo2::updateVTS(uchar *_buffer) {
    vtsi_mat_t *vtsi_mat;
    vtsi_mat = (vtsi_mat_t *)malloc(sizeof(vtsi_mat_t));
    memcpy(vtsi_mat,_ifo->vtsi_mat,sizeof(vtsi_mat_t));

    uint32_t lastSector=vtsi_mat->vtsi_last_sector;
    //uint32_t lastByte=vtsi_mat->vtsi_last_byte;
    //JMP : à vérifier
    if (m_position >0) {
	lastSector=(round(m_position)-DVD_BLOCK_LEN) /DVD_BLOCK_LEN;
	//lastByte=vtsi_mat->vtsi_last_sector*DVD_BLOCK_LEN +DVD_BLOCK_LEN-1;
	vtsi_mat->vts_last_sector+=2*(lastSector-vtsi_mat->vtsi_last_sector);
	vtsi_mat->vtstt_vobs+=lastSector-vtsi_mat->vtsi_last_sector;
    }      
    
    vtsi_mat->vtsi_last_sector=lastSector;
    //vtsi_mat->vtsi_last_byte=lastByte;
    if (vtsi_mat->vtsm_vobs !=0)
    	vtsi_mat->vtsm_vobs= vtsi_mat->vtsi_last_sector +1 ;
      
    B2N_32(vtsi_mat->vts_last_sector);
    B2N_32(vtsi_mat->vtsi_last_sector);
    B2N_32(vtsi_mat->vts_category);
  
    B2N_32(vtsi_mat->vtsi_last_byte);
    B2N_32(vtsi_mat->vtsm_vobs);
    B2N_32(vtsi_mat->vtstt_vobs);
    B2N_32(vtsi_mat->vts_ptt_srpt);
    B2N_32(vtsi_mat->vts_pgcit);
    B2N_32(vtsi_mat->vtsm_pgci_ut);
    B2N_32(vtsi_mat->vts_tmapt);
    B2N_32(vtsi_mat->vtsm_c_adt);
    B2N_32(vtsi_mat->vtsm_vobu_admap);
    B2N_32(vtsi_mat->vts_c_adt);
    B2N_32(vtsi_mat->vts_vobu_admap);
    B2N_16(vtsi_mat->vtsm_audio_attr.lang_code);
    B2N_16(vtsi_mat->vtsm_subp_attr.lang_code);
    for(int i = 0; i < 8; i++)
        B2N_16(vtsi_mat->vts_audio_attr[i].lang_code);
    for(int i = 0; i < 32; i++)
        B2N_16(vtsi_mat->vts_subp_attr[i].lang_code);

    memcpy(m_buffer,vtsi_mat,sizeof(vtsi_mat_t));
    
    free(vtsi_mat);
}

void k9Ifo2::updateVTS_PTT_SRPT(uchar *_buffer) {
    if(!_ifo->vtsi_mat)
        return ;

    if(_ifo->vtsi_mat->vts_ptt_srpt == 0) /* mandatory */
        return ;

    vts_ptt_srpt_t * vts_ptt_srpt;
    vts_ptt_srpt = (vts_ptt_srpt_t *)malloc(sizeof(vts_ptt_srpt_t));
    memcpy(vts_ptt_srpt,_ifo->vts_ptt_srpt,sizeof(vts_ptt_srpt_t));
    int orig=_ifo->vtsi_mat->vts_ptt_srpt * DVD_BLOCK_LEN;
    int offset = m_position=round(m_position);//_ifo->vtsi_mat->vts_ptt_srpt * DVD_BLOCK_LEN;
    _ifo->vtsi_mat->vts_ptt_srpt=m_position/DVD_BLOCK_LEN;

    B2N_16(vts_ptt_srpt->nr_of_srpts);
    B2N_32(vts_ptt_srpt->last_byte);

    memcpy(m_buffer+offset,vts_ptt_srpt,VTS_PTT_SRPT_SIZE);
    free(vts_ptt_srpt);
    m_position+=VTS_PTT_SRPT_SIZE;
    
    int info_length = _ifo->vts_ptt_srpt->last_byte + 1 - VTS_PTT_SRPT_SIZE;

    memcpy(m_buffer+m_position,_buffer+orig+VTS_PTT_SRPT_SIZE, info_length);
    m_position+=info_length;
}


/*!
    \fn k9Ifo2::checkBuffer()
 */


void k9Ifo2::updateVTS_TMAPT(uchar *_buffer) {
    if(!_ifo->vtsi_mat)
        return ;

    if(_ifo->vtsi_mat->vts_tmapt == 0) { /* optional(?) */
        return ;
    }

    vts_tmapt_t *vts_tmapt1,*vts_tmapt;
    vts_tmapt=_ifo->vts_tmapt;
    int info_length = vts_tmapt->nr_of_tmaps * 4;
  
    uint32_t  offsets[vts_tmapt->nr_of_tmaps];
    
    vts_tmapt1 = (vts_tmapt_t *)malloc(VTS_TMAPT_SIZE);
    memcpy(vts_tmapt1,_ifo->vts_tmapt,VTS_TMAPT_SIZE);
    uint32_t offset = m_position=round(m_position);
    
    _ifo->vtsi_mat->vts_tmapt =m_position / DVD_BLOCK_LEN;
    
    int offset0=offset;
    offset+=VTS_TMAPT_SIZE;
    m_position +=VTS_TMAPT_SIZE;

    
    offset += info_length;
    m_position+=info_length;

    info_length=0;
    vts_tmap_t *tmap=vts_tmapt->tmap;
    //loop on tmaps to compute total size
    for (int i=0;i <vts_tmapt->nr_of_tmaps;i++) {
         int tmapSize=VTS_TMAP_SIZE+tmap[i].nr_of_entries*sizeof(map_ent_t);
         info_length+=tmapSize+4;
    }

    tmap = (vts_tmap_t *)malloc(sizeof(vts_tmap_t)* vts_tmapt->nr_of_tmaps);
    memcpy(tmap,vts_tmapt->tmap,sizeof(vts_tmap_t)* vts_tmapt->nr_of_tmaps);
    
    vts_tmapt1->last_byte=VTS_TMAPT_SIZE+info_length-1;
    for(int i = 0; i < vts_tmapt->nr_of_tmaps; i++) {
        int tmapSize=VTS_TMAP_SIZE+tmap[i].nr_of_entries*sizeof(map_ent_t);
        int nr_map_ent=tmap[i].nr_of_entries;
        B2N_16(tmap[i].nr_of_entries);
        offsets[i]=m_position-offset0;
        B2N_32(offsets[i]);
        memcpy(m_buffer+m_position,&(tmap[i]),VTS_TMAP_SIZE);
	m_position+=VTS_TMAP_SIZE;
        offset+=VTS_TMAP_SIZE;
        
        if(nr_map_ent == 0) { // Early out if zero entries
            continue;
        }
        int info_length2 = tmapSize-VTS_TMAP_SIZE;
        map_ent_t *map_ent = (map_ent_t *)malloc(info_length2);
        memcpy(map_ent,tmap[i].map_ent,info_length2);
        for(int j = 0; j < nr_map_ent; j++) {
            B2N_32(map_ent[j]);
            memcpy(m_buffer+m_position,&(map_ent[j]),sizeof(map_ent_t));
            offset+=sizeof(map_ent_t);
            m_position+=sizeof(map_ent_t);
        }
        free(map_ent);
    }

    free(tmap);
    B2N_16(vts_tmapt1->nr_of_tmaps);
    B2N_32(vts_tmapt1->last_byte);
    memcpy(m_buffer+offset0,vts_tmapt1,VTS_TMAPT_SIZE);
    memcpy(m_buffer+offset0+VTS_TMAPT_SIZE,offsets,vts_tmapt->nr_of_tmaps*4);
    free(vts_tmapt1);


}
void k9Ifo2::checkBuffer(TQString lib,uchar* _buffer) {
    /*     for (int j=0;j<bufCopySize;j++) {
           uchar *c,*c2;
    c=(uchar*) (_buffer+j);
    c2=(uchar*)(bufCopy+j);
    if (*c!=*c2) {
      return;
    }
       }
    */
    return;
    if (memcmp(bufCopy,_buffer,bufCopySize)!=0) {
        TQString c;
        c="Buffer de sortie altéré: " +lib;
        tqDebug(c.latin1());
    }
}

void k9Ifo2::navRead_PCI(pci_t *pci, uchar *buffer) {
  int i, j;

  memcpy(pci, buffer, sizeof(pci_t));

  /* Endian conversions  */

  /* pci pci_gi */
  B2N_32(pci->pci_gi.nv_pck_lbn);
  B2N_16(pci->pci_gi.vobu_cat);
  B2N_32(pci->pci_gi.vobu_s_ptm);
  B2N_32(pci->pci_gi.vobu_e_ptm);
  B2N_32(pci->pci_gi.vobu_se_e_ptm);

  /* pci nsml_agli */
  for(i = 0; i < 9; i++)
    B2N_32(pci->nsml_agli.nsml_agl_dsta[i]);

  /* pci hli hli_gi */
  B2N_16(pci->hli.hl_gi.hli_ss);
  B2N_32(pci->hli.hl_gi.hli_s_ptm);
  B2N_32(pci->hli.hl_gi.hli_e_ptm);
  B2N_32(pci->hli.hl_gi.btn_se_e_ptm);

  /* pci hli btn_colit */
  for(i = 0; i < 3; i++)
    for(j = 0; j < 2; j++)
      B2N_32(pci->hli.btn_colit.btn_coli[i][j]);

  /* NOTE: I've had to change the structure from the disk layout to get
   * the packing to work with Sun's Forte C compiler. */
  
  /* pci hli btni */
  for(i = 0; i < 36; i++) {
    char tmp[sizeof(pci->hli.btnit[i])], swap;
    memcpy(tmp, &(pci->hli.btnit[i]), sizeof(pci->hli.btnit[i]));
    /* Byte 4 to 7 are 'rotated' was: ABCD EFGH IJ is: ABCG DEFH IJ */
    swap   = tmp[6]; 
    tmp[6] = tmp[5];
    tmp[5] = tmp[4];
    tmp[4] = tmp[3];
    tmp[3] = swap;
    
    /* Then there are the two B2N_24(..) calls */
#ifndef WORDS_BIGENDIAN
    swap = tmp[0];
    tmp[0] = tmp[2];
    tmp[2] = swap;
    
    swap = tmp[4];
    tmp[4] = tmp[6];
    tmp[6] = swap;
#endif
    memcpy(&(pci->hli.btnit[i]), tmp, sizeof(pci->hli.btnit[i]));
  }

}