Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

DVDContainerFile.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: DVDContianerFile.cpp                                          *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi 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., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#ifndef WIN32

#include "DVDContainerFile.hpp"
#include "ContainerInfo.hpp"
#include "ESInfo.hpp"
#include "debug.hpp"
#include "VideoESInfo.hpp"
#include "AudioESInfo.hpp"

#include <stdio.h>
#include <string.h>




/* handles info for one vts */
struct vts_info_s {
                u32 nr_audio_streams;
                u32 nr_sub_streams;
                ifo_handle_t *ifo_handle;
};

/* open dvd */
dvd_handle_t * DVDContainerFile::openDVD(const char *file){
        assert(file);
        if(!file)
                return NULL;
        /* create new instance to handle a dvd */
        dvd_handle_t *dvd_handle = new dvd_handle_t();
        
        /* set filename */
        dprintf_full("============================================================\n");
        dprintf_full("DVDContainerFile::openDVD:\n");
        dprintf_full("Checking filename\n");
        strcpy(dvd_handle->filename,file);
        
        /* open dvd */
        dprintf_full("Using libdvdread to open DVD\n");
        if(!(dvd_handle->dvd_reader = DVDOpen(file))) {
                delete dvd_handle;
                return NULL;
        }
        /* get number of video title sets */
        ifo_handle_t *ifo_handle=NULL;
        ifo_handle = ifoOpenVMGI(dvd_handle->dvd_reader);
        if(ifo_handle==NULL) {
                delete dvd_handle;
                return NULL;
        }
        dprintf_full("Setting number of VTS\n");
        dvd_handle->nr_vts = ifo_handle->vmgi_mat->vmg_nr_of_title_sets;
        ifoClose(ifo_handle);
        
        /* check main title */
        u32 i;
        u32 mainsize = 0;
        dvd_handle->main_title_no = 0;
        dvd_file_t *dvd_file=NULL;
        dprintf_full("Checking for main title\n");
        for(i = 1; i <= dvd_handle->nr_vts; i++){
                dvd_file = DVDOpenFile( dvd_handle->dvd_reader, i, DVD_READ_TITLE_VOBS );
                u32 actsize = DVDFileSize( dvd_file );
                DVDCloseFile( dvd_file );
                if(mainsize < actsize){
                        dvd_handle->main_title_no = i;
                        mainsize = actsize;
                }
        };
        
        return dvd_handle;
};

/* close dvd */
void DVDContainerFile::closeDVD(dvd_handle_t *dvd_handle){
        
        dprintf_full("============================================================\n");
        dprintf_full("DVDContainerFile::closeDVD:\n");
        dprintf_full("Using libdvdread to close DVD and clean up\n");
        
        /* close dvd_reader */
        if(dvd_handle->dvd_reader)
                DVDClose(dvd_handle->dvd_reader);
        
        /* free the handle */
        delete dvd_handle;
};

/* get number of video title sets */
u32 DVDContainerFile::getNrOfVTS(dvd_handle_t *dvd_handle){
        
        return dvd_handle->nr_vts;
};

/* get filename of selected dvd */
char * DVDContainerFile::getFileName(dvd_handle_t *dvd_handle){
        
        return dvd_handle->filename;
}

/* get suggested main title number */
u32 DVDContainerFile::getMainTitleNo(dvd_handle_t *dvd_handle){
        
        return dvd_handle->main_title_no;
}

/* set custom main title */
void DVDContainerFile::setMainTileNo(dvd_handle_t *dvd_handle, u32 main_title_no){
        dvd_handle->main_title_no = main_title_no;
}

/* set target name */
void DVDContainerFile::setTargetName(dvd_handle_t *dvd_handle, char *target){
        
        dvd_handle->target = target;
}

/* get target name */
char * DVDContainerFile::getTargetName(dvd_handle_t *dvd_handle){
        
        return dvd_handle->target;
}

/* load container information for selected vts */
ContainerInfo * DVDContainerFile::loadContainerInfo(dvd_handle_t *dvd_handle, u32 vts_nr){
        
        /* url is set to NULL */
        const char *nourl = NULL;
        
        /* create new containerinfo (filename will be deep-copied) */
        ContainerInfo *container = new ContainerInfo(nourl, dvd_handle->filename, ContainerInfo::DVD);
        
        /* get basic vts information */
        dprintf_full("============================================================\n");
        dprintf_full("DVDContainerFile::loadContainerInfo:\n");
        dprintf_full("Getting VTS information\n");
        vts_info_t *vts_info = DVDContainerFile::getVTSInfo(dvd_handle, vts_nr);
        
        /* get video stream info and add to container */
        dprintf_full("\nDVDContainerFile::loadContainerInfo:\n");       
        dprintf_full("Getting video information\n");
        ESInfo *es_info = DVDContainerFile::getVideoInfo(vts_info, container);
        container->addESInfo(es_info);
                
        u32 i;
        /* get audio streams and add to container */
        for(i = 0; i < vts_info->nr_audio_streams; i++){
                dprintf_full("\nDVDContainerFile::loadContainerInfo:\n");
                dprintf_full("Getting audio information for stream %i\n",i);
                es_info = DVDContainerFile::getAudioInfo(vts_info, i, container);
                container->addESInfo(es_info);
        }
        
        /* get subpicture streams and add to container */
        for(i = 0; i < vts_info->nr_sub_streams; i++){
                dprintf_full("\nDVDContainerFile::loadContainerInfo:\n");
                dprintf_full("Getting subpicture information for stream %i\n",i);
                es_info = DVDContainerFile::getSubInfo(vts_info, i, container);
                container->addESInfo(es_info);
        }
        
        dprintf_full("\nDVDContainerFile::loadContainerInfo:\n");
        dprintf_full("All information added to ContainerInfo\n\n");
        return container;
};

/* get basic vts information */
vts_info_t * DVDContainerFile::getVTSInfo(dvd_handle_t *dvd_handle, u32 vts_nr){

        vts_info_t *vts_info = new vts_info_t();
        
        /* open ifo file for selected vts and get handle*/
        dprintf_full("============================================================\n");
        dprintf_full("DVDContainerFile::getVTSInfo:\n");
        dprintf_full("Using libdvdread to open IFO file\n");
        vts_info->ifo_handle = ifoOpen(dvd_handle->dvd_reader,vts_nr);
        
        /* get number of audio streams */
        vts_info->nr_audio_streams = vts_info->ifo_handle->vtsi_mat->nr_of_vts_audio_streams;
        dprintf_full("VTS %i has %i audio streams\n",vts_nr, vts_info->nr_audio_streams);
        
        /* get number of subpicture streams */
        vts_info->nr_sub_streams = vts_info->ifo_handle->vtsi_mat->nr_of_vts_subp_streams;
        dprintf_full("VTS %i has %i subpicture streams\n",vts_nr, vts_info->nr_sub_streams);
        
        return vts_info;
}

/* get video stream esinfo */
ESInfo * DVDContainerFile::getVideoInfo(vts_info_t *vts_info, ContainerInfo *container){
        
        dprintf_full("========================================\n");
        dprintf_full("DVDContainerFile::getVideoInfo:\n");
        /* beautifier */
        vtsi_mat_t *vtsi_mat = vts_info->ifo_handle->vtsi_mat;
        //pgcit_t *pgcit = vts_info->ifo_handle->vts_pgcit;
        
        /* get dvd values */
        /* mpeg version */
        u32 mpeg_version = (vtsi_mat->vts_video_attr.mpeg_version) ? MPEG2 : MPEG1;
        /* print value (currently for devolpment and presentation) */
        if (mpeg_version) {
                dprintf_full("Videoinfo - MPEGversion = MPEG2\n");
        }
        else {
                dprintf_full("Videoinfo - MPEGversion = MPEG1\n");
        }
        
        /* video format */
        u32 video_format = (vtsi_mat->vts_video_attr.video_format) ? PAL : NTSC;
        /* print value (currently for devolpment and presentation) */
        if (video_format) {
                dprintf_full("Videoinfo - Videoformat = PAL\n");
        }
        else {
                dprintf_full("Videoinfo - Videoformat = NTSC\n");
        }
        
        // frame rate, needed for time_increment
        u32 fps = (video_format == PAL) ? 25 : 30;
        
        /* display aspect ratio */
        u32 dar = (vtsi_mat->vts_video_attr.display_aspect_ratio) ? WIDE : NORM;
        /* print value (currently for devolpment and presentation) */
        if (dar) {
                dprintf_full("Videoinfo - Aspect ratio = 16:9\n");
        }
        else {
                dprintf_full("Videoinfo - Aspect ratio = 4:3\n");
        }
        
        /* letterboxed flag */
        u32 letterboxed = (vtsi_mat->vts_video_attr.letterboxed) ? LETTERBOXED : NOTLETTERBOXED;
        /* print value (currently for devolpment and presentation) */
        if (letterboxed) {
                dprintf_full("Videoinfo - Letterboxed = yes\n")
        }
        else {
                dprintf_full("Videoinfo - Letterboxed = no\n");
        }
        
        /* bit rate */
        u32 bitrate = (vtsi_mat->vts_video_attr.bit_rate) ? CBR : VBR;
        /* print value (currently for devolpment and presentation) */
        if (bitrate) {
                dprintf_full("Videoinfo - Bitrate = CBR\n");
        }
        else {
                dprintf_full("Videoinfo - Bitrate = VBR\n");
        }
        
        /* vertical resolution */
        u32 vres = (vtsi_mat->vts_video_attr.video_format) ? 576 : 480;
        /* print value (currently for devolpment and presentation) */
        dprintf_full("Videoinfo - Vertical resolution = %i\n", vres);
                
        /* horizontal resolution */
        u32 hres;
        switch(vtsi_mat->vts_video_attr.picture_size) {
                case 0:
                        hres = 720;
                        break;
                case 1:
                        hres = 704;
                        break;
                case 2:
                        hres = 352;
                        break;
                case 3:
                        hres = 352;
                        vres /= 2;      // half format
                        break;
                default:
                        return 0;
        }
        /* print value (currently for devolpment and presentation) */
        dprintf_full("Videoinfo - Horizontal resolution = %i\n", hres);
        
        /* set vitooki values */        // not finished yet
        u32 stream_id = 480; // always the id of first videostream on a dvd video!!
        u32 stream_type = 0;    // check for universal or dvd video stream type 
        u32 time_increment = 90000/fps; // not yet set
        u32 obj_type = 0;       // not yet set - unimportant?
        u32 buffer_size = 0;    // not yet set
        u32 avg_bw = 0; // not yet set
        u32 max_bw = 0; // not yet set
        u32 time_scale = 90000; // FAKED VALUE ??!!!!!
        u32 size = 0;   // not yet set
        u32 height = vres;
        u32 width = hres;
        u64 duration = 972000000;       // FIXME: 3 hours hard-coded
        bool color_video = true;        // check if possible to get real value from ifo
        bool complete = true;   // check this value
        float quality = 1.0;
        float aspect_ratio = (dar) ? ( 16.0/9.0 ) : ( 4.0/3.0 );
        CodecID codec_id =  (video_format) ? CODEC_ID_MPEG2VIDEO : CODEC_ID_MPEG1VIDEO; // check values reagarding avcodec.h
        
        VideoESInfo *video_info = new VideoESInfo(stream_id, stream_type, container, time_increment, 0, obj_type, buffer_size, avg_bw, max_bw, time_scale, duration, size, width, height, color_video, complete, codec_id, quality, aspect_ratio, 0, 0);
        
        return video_info;
}

/* get audio stream esinfo */
ESInfo * DVDContainerFile::getAudioInfo(vts_info_t *vts_info, u32 stream_nr, ContainerInfo *container){
        
        dprintf_full("========================================\n");
        dprintf_full("DVDContainerFile::getAudioInfo:\n");
        
        /* check if stream exists */
        if(stream_nr < 0 || stream_nr >= vts_info->nr_audio_streams)
                return 0;
        
        /* beautifier */
        vtsi_mat_t *vtsi_mat = vts_info->ifo_handle->vtsi_mat;
        pgcit_t *pgcit = vts_info->ifo_handle->vts_pgcit;
        u32 i = stream_nr;
                
        /* get dvd values */
        /* audio format */
        u32 audio_format;
        switch(vtsi_mat->vts_audio_attr[i].audio_format){
                case 0:
                        audio_format = AC3;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Audioformat = Dolby Digital AC3\n");
                        break;
                case 2:
                        audio_format = MPEG1A;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Audioformat = MPEG1 audio\n");
                        break;
                case 3:
                        audio_format = MPEG2EXT;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Audioformat = MPEG2 extended audio\n");
                        break;
                case 4:
                        audio_format = LPCM;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Audioformat = Linear Pulse Code Modulation LPCM\n");
                        break;
                case 6:
                        audio_format = DTS_AUDIO;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Audioformat = Digital Theater System DTS\n");
                        break;
                default:
                        return 0;
        }
        
        /* multichannel extension */
        u32 multichannel_extension = (vtsi_mat->vts_audio_attr[i].multichannel_extension) ? MULTI : NOMULTI;
        /* print value (currently for devolpment and presentation) */
        if (multichannel_extension) {
                dprintf_full("Audioinfo - Multichannel extension = yes\n");
        }
        else {
                dprintf_full("Audioinfo - Multichannel extension = no\n");
        }
        
        /* application mode */
        u32 application_mode;
        switch(vtsi_mat->vts_audio_attr[i].application_mode){
                case 0:
                        application_mode = NOSPECAM;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Application mode = none\n");
                        break;
                case 1:
                        application_mode = KARAOKE;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Application mode = Karaoke\n");
                        break;
                case 2:
                        application_mode = SURROUND;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Application mode = Surround\n");
                        break;
                default:
                        return 0;
        }
        
        /* quantization */
        u32 quantization;
        switch(vtsi_mat->vts_audio_attr[i].quantization){
                case 0:
                        quantization = BIT16;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Quantization = 16Bit\n");
                        break;
                case 1:
                        quantization = BIT20;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Quantization = 20Bit\n");
                        break;
                case 2:
                        quantization = BIT24;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Quantization = 24Bit\n");
                        break;
                case 3:
                        quantization = DRC;
                        /* print value (currently for devolpment and presentation) */
                        dprintf_full("Audioinfo - Quantization = Dynamic Range Control DRC\n");
                        break;
                default:
                        return 0;
        }
                
        /* sample frequency */
        u32 sample_frequency = (vtsi_mat->vts_audio_attr[i].sample_frequency) ? UNKNOWNSF : KHZ48;
        if (sample_frequency) {
                dprintf_full("Audioinfo - Sample frequency = unknown\n");
        }
        else {
                dprintf_full("Audioinfo - Sample frequency = 48KHz\n");
        }
        
        /* code extension */
        u32 code_extension;
        switch(vtsi_mat->vts_audio_attr[i].code_extension){
                case 0:
                        code_extension = NOSPECCE;
                        break;
                case 1:
                        code_extension = NORMCAP;
                        break;
                case 2:
                        code_extension = VIMP;
                        break;
                case 3:
                        code_extension = DIRCOMM1;
                        break;
                case 4:
                        code_extension = DIRCOMM2;
                        break;
                default:
                        return 0;
        }
        
        /* dolby encoded flag */
        u32 dolby_encoded = (application_mode == SURROUND && vtsi_mat->vts_audio_attr[i].app_info.surround.dolby_encoded) ? DOLBY : NODOLBY;
        if (dolby_encoded) {
                dprintf_full("Audioinfo - Dolby encoded = yes\n");
        }
        else {
                dprintf_full("Audioinfo - Dolby encoded = no\n");
        }
        
        /* number of audio channels */
        u32 channels = vtsi_mat->vts_audio_attr[i].channels +1;
        /* print value (currently for devolpment and presentation) */
        dprintf_full("Audioinfo - Number of audio channels = %i\n",channels);
        
        /* language */
        char language[2];
        language[0] = vtsi_mat->vts_audio_attr[i].lang_code>>8;
        language[1] = vtsi_mat->vts_audio_attr[i].lang_code & 0xff;
        /* print value (currently for devolpment and presentation) */
        dprintf_full("Audioinfo - Language = %s\n",language);
        
        /*
        HACK FROM OGLE PLAYER! to get streamid
                file: ogle/vmg/vm.c:
                function: int vm_get_audio_stream(int audioN):
                code:   if(state.pgc->audio_control[audioN] & (1<<15)) {
        streamN = (state.pgc->audio_control[audioN] >> 8) & 0x07;}
        ... modified to work for vitooki
        currently only dd and dts are supported by this ugly hack!!
        */
        u32      si = pgcit->pgci_srp->pgc->audio_control[i] >> 8;
        if (audio_format == DTS_AUDIO)
                si += 8;
        dprintf_full("Audioinfo - StreamID = %i\n", si);
        
        /* set vitooki values */        // not finished yet
        u32 stream_id = si;
        u32 stream_type = 0;    // check for universal or dvd audio stream type 
        u32 time_increment = 0; // not yet set
        u32 obj_type = 0;       // not yet set - unimportant?
        u32 buffer_size = 0;    // not yet set
        u32 avg_bw = 0; // not yet set
        u32 max_bw = 0; // not yet set
        u32 time_scale = 90000; // FAKED VALUE ??!!!
        u32 size = 0;   // not yet set
        u32 sample_rate = (sample_frequency) ? 0 : 48000;       // 0 means unknown
        u32 num_audio_channels = channels;
        u64 duration = 0;       // not yet set
        bool complete = true;   // check this value
        float quality = 1.0;
        CodecID codec_id;
        switch(audio_format){
                case 0:
                        codec_id = CODEC_ID_AC3;
                        break;
                case 2:
                        codec_id = CODEC_ID_NONE;       // check for mpeg1audio ??
                        break;
                case 3:
                        codec_id = CODEC_ID_NONE;       // check for mpeg2extendedaudio ??
                        break;
                case 4:
                        codec_id = CODEC_ID_NONE;       // check for correct lpcm codek ??
                        break;
                case 6:
                        codec_id = CODEC_ID_NONE;       //check for dts codec ??
                        break;
                default:
                        return 0;       // error that should never happen!!
        }
        
        AudioESInfo *audio_info = new AudioESInfo(stream_id, stream_type, container, time_increment, NULL, obj_type, buffer_size, avg_bw, max_bw, time_scale, duration, size, sample_rate, num_audio_channels, complete, codec_id, quality);
        
        return audio_info;
}
        
/* get subpicture stream esinfo */
ESInfo * DVDContainerFile::getSubInfo(vts_info_t *vts_info, u32 stream_nr, ContainerInfo *container){
        
        dprintf_full("========================================\n");
        dprintf_full("DVDContainerFile::getSubInfo:\n");
        
        /* check if stream exists */
        if(stream_nr < 0 || stream_nr >= vts_info->nr_sub_streams)
                return 0;
        
        /* beautifier */
        vtsi_mat_t *vtsi_mat = vts_info->ifo_handle->vtsi_mat;
        //      pgcit_t *pgcit = vts_info->ifo_handle->vts_pgcit;
        u32 i = stream_nr;
        
        /* get dvd values */
        /* coding mode */
        u32 code_mode = (vtsi_mat->vts_subp_attr[i].code_mode) ? CMEXT : RLE;
        if (code_mode) {
                dprintf_full("Subpictureinfo - Code mode = Code mode extended\n");
        }
        else {
                dprintf_full("Subpictureinfo - Code mode = Run-Length encoded\n");
        }
        /* language */
        char language[2];
        if(vtsi_mat->vts_subp_attr[i].type == 1){
                if(isalpha((int)(vtsi_mat->vts_subp_attr[i].lang_code>>8)) && isalpha((int)(vtsi_mat->vts_subp_attr[i].lang_code & 0xff))){
                                language[0] = vtsi_mat->vts_subp_attr[i].lang_code>>8;
                                language[1] = vtsi_mat->vts_subp_attr[i].lang_code & 0xff;
                }
                else {
                        language[0] = '1';      // check mysterious hex stuff from dvdread
                        language[1] = '1';      // and adapt here (TODO)
                }
        }
        else {
                language[0] = '0';      // no language
                language[1] = '0';      // --"--
        }
        /* print value (currently for devolpment and presentation) */
        dprintf_full("Subpictureinfo - Language = %s\n",language);
        
        /* set vitooki values */        // not finished yet
        u32 stream_id = stream_nr + vts_info->nr_audio_streams + 2;
        u32 stream_type = 0;    // check for universal or dvd subpicture stream type 
        u32 time_increment = 0; // not yet set
        u32 obj_type = 0;       // not yet set - unimportant?
        u32 buffer_size = 0;    // not yet set
        u32 avg_bw = 0; // not yet set
        u32 max_bw = 0; // not yet set
        u32 time_scale = 1;     // not yet set - FAKED VALUE!!!
        u32 size = 0;   // not yet set
        u32 sample_rate = 0;    //not yet set (n/a for subpicture)
        u32 num_audio_channels = 0;     // not yet set (n/a for subpicture)
        u64 duration = 0;       // not yet set
        bool complete = true;   // check this value
        float quality = 1.0;
        CodecID codec_id = CODEC_ID_NONE;       // check for subpicture codec ??
        
        // THIS IS CURRENTLY  A FAKE BECAUSE NO SUB_INFO EXISTS
        AudioESInfo *sub_info = new AudioESInfo(stream_id, stream_type, container, time_increment, NULL, obj_type, buffer_size, avg_bw, max_bw, time_scale, duration, size, sample_rate, num_audio_channels, complete, codec_id, quality);
        
        return sub_info;
}

u32 DVDContainerFile::copyMain(dvd_handle_t *dvd_handle, u32 percentage){
        
        dprintf_full("============================================================\n");
        dprintf_full("DVDContainerFile::copyMain:\n"); 
        
        /* buffer */
        unsigned char *buffer;
        unsigned char charbuf;
        u32 buffersize = 512;
        
        /* File Handler */
        int streamout;
        char * target = dvd_handle->target;
        
        /* open dvdfile */
        dvd_file_t *dvd_file;
        dvd_file = DVDOpenFile( dvd_handle->dvd_reader, dvd_handle->main_title_no, DVD_READ_TITLE_VOBS);
        
        /* get mem for buffer */
        buffer = (unsigned char *)malloc(buffersize * 2048 * sizeof(charbuf));
        
        /* open output file */
        if( (streamout = open(target, O_WRONLY | O_CREAT, 0644)) == -1){
                dprintf_full("Error opening outputfile!\n");
                return 1;
        }
        
        /* rip maintitle */
        int offset = 0;
        u32 ripsize = DVDFileSize(dvd_file);
        if (percentage > 0 && percentage < 100){
                dprintf_full("Ripping %i%% of main title...\n", percentage);
                ripsize *= (int)round(percentage/100.00);
        }
        else{
                dprintf_full("Ripping main title...\n");
        }
        int size = ripsize;
        
        while (ripsize > 0) {
                
                dprintf_full("Ripping Blocks: %.2f %%",(100.00-((float)ripsize/(float)size)*100.00));
                dprintf_full("\r");
                 
                if (buffersize > ripsize)
                        buffersize = ripsize;
                
                /* read blocks from dvd */
                if( (DVDReadBlocks(dvd_file,offset,buffersize, buffer)) == -1){
                        dprintf_full("\nError reading blocks!!\n");
                        return 1;
                }
                
                /* write to outputfile */
                if (write(streamout,buffer,buffersize *  2048) == -1){
                        dprintf_full("\nError writing blocks!!\n");
                        return 1;
                }
                
                ripsize -= buffersize;
                offset += buffersize;
        }
        dprintf_full("Ripping Blocks: 100%% complete\n");
        free(buffer);
        close(streamout);
        
        return 0;
}


#endif /* WIN32 */

© ViTooKi 2003 :: [Lite version] Created with Doxygen