# HG changeset patch # User jcdutton # Date 1018117910 0 # Node ID 5f319e02e333394b34b45ff8178eb2cb27e27906 # Parent c1b55dc1bfed964a13b05518624057f0476616a6 Some cleaning up. changed exit(1) to assert(0) so they actually get seen by the user so that it helps developers more. diff -r c1b55dc1bfed -r 5f319e02e333 decoder.c --- a/decoder.c Tue Apr 02 22:25:21 2002 +0000 +++ b/decoder.c Sat Apr 06 18:31:50 2002 +0000 @@ -30,6 +30,7 @@ #include #include /* For memset */ #include /* vm_cmd_t */ +#include #include "vmcmd.h" #include "decoder.h" @@ -349,7 +350,7 @@ data2 = bits(5, 4, 4); if(bits(5, 0, 1)) { fprintf(stderr, "Detected SetGPRMMD Counter!! This is unsupported.\n"); - /* exit(-1); */ + assert(0); } else { ; } @@ -459,7 +460,7 @@ res = eval_special_instruction(cond); if(res == -1) { fprintf(stderr, "Unknown Instruction!\n"); - /* exit(0); */ + assert(0); } break; case 1: /* Link/jump instructions */ diff -r c1b55dc1bfed -r 5f319e02e333 dvdnav.c --- a/dvdnav.c Tue Apr 02 22:25:21 2002 +0000 +++ b/dvdnav.c Sat Apr 06 18:31:50 2002 +0000 @@ -553,7 +553,8 @@ return S_OK; } - if(self->expecting_nav_packet) { + if(self->expecting_nav_packet || + (self->jumping) ) { dvdnav_nav_packet_event_t nav_event; /* Perform the jump if necessary (this is always a @@ -986,6 +987,10 @@ /* * $Log$ + * Revision 1.4 2002/04/06 18:31:50 jcdutton + * Some cleaning up. + * changed exit(1) to assert(0) so they actually get seen by the user so that it helps developers more. + * * Revision 1.3 2002/04/02 18:22:27 richwareham * Added reset patch from Kees Cook * diff -r c1b55dc1bfed -r 5f319e02e333 vm.c --- a/vm.c Tue Apr 02 22:25:21 2002 +0000 +++ b/vm.c Sat Apr 06 18:31:50 2002 +0000 @@ -43,31 +43,31 @@ /* Local prototypes */ -static void saveRSMinfo(vm_t *self,int cellN, int blockN); -static int set_PGN(vm_t *self); -static link_t play_PGC(vm_t *self); -static link_t play_PG(vm_t *self); -static link_t play_Cell(vm_t *self); -static link_t play_Cell_post(vm_t *self); -static link_t play_PGC_post(vm_t *self); -static link_t process_command(vm_t *self,link_t link_values); +static void saveRSMinfo(vm_t *vm,int cellN, int blockN); +static int set_PGN(vm_t *vm); +static link_t play_PGC(vm_t *vm); +static link_t play_PG(vm_t *vm); +static link_t play_Cell(vm_t *vm); +static link_t play_Cell_post(vm_t *vm); +static link_t play_PGC_post(vm_t *vm); +static link_t process_command(vm_t *vm,link_t link_values); -static void ifoOpenNewVTSI(vm_t *self,dvd_reader_t *dvd, int vtsN); -static pgcit_t* get_PGCIT(vm_t *self); -static int get_video_aspect(vm_t *self); +static void ifoOpenNewVTSI(vm_t *vm,dvd_reader_t *dvd, int vtsN); +static pgcit_t* get_PGCIT(vm_t *vm); +static int get_video_aspect(vm_t *vm); /* Can only be called when in VTS_DOMAIN */ -static int get_TT(vm_t *self,int tt); -static int get_VTS_TT(vm_t *self,int vtsN, int vts_ttn); -static int get_VTS_PTT(vm_t *self,int vtsN, int vts_ttn, int part); +static int get_TT(vm_t *vm,int tt); +static int get_VTS_TT(vm_t *vm,int vtsN, int vts_ttn); +static int get_VTS_PTT(vm_t *vm,int vtsN, int vts_ttn, int part); -static int get_MENU(vm_t *self,int menu); /* VTSM & VMGM */ -static int get_FP_PGC(vm_t *self); /* FP */ +static int get_MENU(vm_t *vm,int menu); /* VTSM & VMGM */ +static int get_FP_PGC(vm_t *vm); /* FP */ /* Called in any domain */ -static int get_ID(vm_t *self,int id); -static int get_PGC(vm_t *self,int pgcN); -static int get_PGCN(vm_t *self); +static int get_ID(vm_t *vm,int id); +static int get_PGC(vm_t *vm,int pgcN); +static int get_PGCN(vm_t *vm); /* Initialisation */ @@ -77,8 +77,8 @@ return vm; } -static void vm_print_current_domain_state(vm_t *self) { - switch((self->state).domain) { +static void vm_print_current_domain_state(vm_t *vm) { + switch((vm->state).domain) { case VTS_DOMAIN: fprintf(stderr, "Video Title Domain: -\n"); break; @@ -100,139 +100,139 @@ break; } fprintf(stderr, "VTS:%d PG:%u CELL:%u BLOCK:%u VTS_TTN:%u TTN:%u TT_PGCN:%u\n", - (self->state).vtsN, - (self->state).pgN, - (self->state).cellN, - (self->state).blockN, - (self->state).VTS_TTN_REG, - (self->state).TTN_REG, - (self->state).TT_PGCN_REG); + (vm->state).vtsN, + (vm->state).pgN, + (vm->state).cellN, + (vm->state).blockN, + (vm->state).VTS_TTN_REG, + (vm->state).TTN_REG, + (vm->state).TT_PGCN_REG); } -void vm_stop(vm_t *self) { - if(!self) +void vm_stop(vm_t *vm) { + if(!vm) return; - if(self->vmgi) { - ifoClose(self->vmgi); - self->vmgi=NULL; + if(vm->vmgi) { + ifoClose(vm->vmgi); + vm->vmgi=NULL; } - if(self->vtsi) { - ifoClose(self->vtsi); - self->vmgi=NULL; + if(vm->vtsi) { + ifoClose(vm->vtsi); + vm->vmgi=NULL; } - if(self->dvd) { - DVDClose(self->dvd); - self->dvd=NULL; + if(vm->dvd) { + DVDClose(vm->dvd); + vm->dvd=NULL; } } -void vm_free_vm(vm_t *self) { - if(self) { - vm_stop(self); - free(self); +void vm_free_vm(vm_t *vm) { + if(vm) { + vm_stop(vm); + free(vm); } } /* IFO Access */ -ifo_handle_t *vm_get_vmgi(vm_t *self) { - if(!self) +ifo_handle_t *vm_get_vmgi(vm_t *vm) { + if(!vm) return NULL; - return self->vmgi; + return vm->vmgi; } -ifo_handle_t *vm_get_vtsi(vm_t *self) { - if(!self) +ifo_handle_t *vm_get_vtsi(vm_t *vm) { + if(!vm) return NULL; - return self->vtsi; + return vm->vtsi; } /* Reader Access */ -dvd_reader_t *vm_get_dvd_reader(vm_t *self) { - if(!self) +dvd_reader_t *vm_get_dvd_reader(vm_t *vm) { + if(!vm) return NULL; - return self->dvd; + return vm->dvd; } -int vm_reset(vm_t *self, char *dvdroot) /* , register_t regs) */ { +int vm_reset(vm_t *vm, char *dvdroot) /* , register_t regs) */ { /* Setup State */ - memset((self->state).registers.SPRM, 0, sizeof(uint16_t)*24); - memset((self->state).registers.GPRM, 0, sizeof((self->state).registers.GPRM)); - (self->state).registers.SPRM[0] = ('e'<<8)|'n'; /* Player Menu Languange code */ - (self->state).AST_REG = 15; /* 15 why? */ - (self->state).SPST_REG = 62; /* 62 why? */ - (self->state).AGL_REG = 1; - (self->state).TTN_REG = 1; - (self->state).VTS_TTN_REG = 1; - /* (self->state).TT_PGCN_REG = 0 */ - (self->state).PTTN_REG = 1; - (self->state).HL_BTNN_REG = 1 << 10; + memset((vm->state).registers.SPRM, 0, sizeof(uint16_t)*24); + memset((vm->state).registers.GPRM, 0, sizeof((vm->state).registers.GPRM)); + (vm->state).registers.SPRM[0] = ('e'<<8)|'n'; /* Player Menu Languange code */ + (vm->state).AST_REG = 15; /* 15 why? */ + (vm->state).SPST_REG = 62; /* 62 why? */ + (vm->state).AGL_REG = 1; + (vm->state).TTN_REG = 1; + (vm->state).VTS_TTN_REG = 1; + /* (vm->state).TT_PGCN_REG = 0 */ + (vm->state).PTTN_REG = 1; + (vm->state).HL_BTNN_REG = 1 << 10; - (self->state).PTL_REG = 15; /* Parental Level */ - (self->state).registers.SPRM[12] = ('U'<<8)|'S'; /* Parental Management Country Code */ - (self->state).registers.SPRM[16] = ('e'<<8)|'n'; /* Initial Language Code for Audio */ - (self->state).registers.SPRM[18] = ('e'<<8)|'n'; /* Initial Language Code for Spu */ + (vm->state).PTL_REG = 15; /* Parental Level */ + (vm->state).registers.SPRM[12] = ('U'<<8)|'S'; /* Parental Management Country Code */ + (vm->state).registers.SPRM[16] = ('e'<<8)|'n'; /* Initial Language Code for Audio */ + (vm->state).registers.SPRM[18] = ('e'<<8)|'n'; /* Initial Language Code for Spu */ /* Player Regional Code Mask. * bit0 = Region 1 * bit1 = Region 2 */ - (self->state).registers.SPRM[20] = 0x1; /* Player Regional Code Mask. Region free! */ - (self->state).registers.SPRM[14] = 0x100; /* Try Pan&Scan */ + (vm->state).registers.SPRM[20] = 0x1; /* Player Regional Code Mask. Region free! */ + (vm->state).registers.SPRM[14] = 0x100; /* Try Pan&Scan */ - (self->state).pgN = 0; - (self->state).cellN = 0; + (vm->state).pgN = 0; + (vm->state).cellN = 0; - (self->state).domain = FP_DOMAIN; - (self->state).rsm_vtsN = 0; - (self->state).rsm_cellN = 0; - (self->state).rsm_blockN = 0; + (vm->state).domain = FP_DOMAIN; + (vm->state).rsm_vtsN = 0; + (vm->state).rsm_cellN = 0; + (vm->state).rsm_blockN = 0; - (self->state).vtsN = -1; + (vm->state).vtsN = -1; - if (self->dvd && dvdroot) { + if (vm->dvd && dvdroot) { // a new dvd device has been requested - vm_stop(self); + vm_stop(vm); } - if (!self->dvd) { - self->dvd = DVDOpen(dvdroot); - if(!self->dvd) { + if (!vm->dvd) { + vm->dvd = DVDOpen(dvdroot); + if(!vm->dvd) { fprintf(stderr, "vm: faild to open/read the DVD\n"); return -1; } - self->vmgi = ifoOpenVMGI(self->dvd); - if(!self->vmgi) { + vm->vmgi = ifoOpenVMGI(vm->dvd); + if(!vm->vmgi) { fprintf(stderr, "vm: faild to read VIDEO_TS.IFO\n"); return -1; } - if(!ifoRead_FP_PGC(self->vmgi)) { + if(!ifoRead_FP_PGC(vm->vmgi)) { fprintf(stderr, "vm: ifoRead_FP_PGC failed\n"); return -1; } - if(!ifoRead_TT_SRPT(self->vmgi)) { + if(!ifoRead_TT_SRPT(vm->vmgi)) { fprintf(stderr, "vm: ifoRead_TT_SRPT failed\n"); return -1; } - if(!ifoRead_PGCI_UT(self->vmgi)) { + if(!ifoRead_PGCI_UT(vm->vmgi)) { fprintf(stderr, "vm: ifoRead_PGCI_UT failed\n"); return -1; } - if(!ifoRead_PTL_MAIT(self->vmgi)) { + if(!ifoRead_PTL_MAIT(vm->vmgi)) { fprintf(stderr, "vm: ifoRead_PTL_MAIT failed\n"); ; /* return -1; Not really used for now.. */ } - if(!ifoRead_VTS_ATRT(self->vmgi)) { + if(!ifoRead_VTS_ATRT(vm->vmgi)) { fprintf(stderr, "vm: ifoRead_VTS_ATRT failed\n"); ; /* return -1; Not really used for now.. */ } - if(!ifoRead_VOBU_ADMAP(self->vmgi)) { + if(!ifoRead_VOBU_ADMAP(vm->vmgi)) { fprintf(stderr, "vm: ifoRead_VOBU_ADMAP vgmi failed\n"); ; /* return -1; Not really used for now.. */ } @@ -244,114 +244,114 @@ } /* FIXME TODO XXX $$$ Handle error condition too... */ -int vm_start(vm_t *self) +int vm_start(vm_t *vm) { link_t link_values; /* Set pgc to FP pgc */ - get_FP_PGC(self); - link_values = play_PGC(self); - link_values = process_command(self,link_values); + get_FP_PGC(vm); + link_values = play_PGC(vm); + link_values = process_command(vm,link_values); assert(link_values.command == PlayThis); - (self->state).blockN = link_values.data1; + (vm->state).blockN = link_values.data1; return 0; /* ?? */ } -int vm_start_title(vm_t *self, int tt) { +int vm_start_title(vm_t *vm, int tt) { link_t link_values; - get_TT(self, tt); - link_values = play_PGC(self); - link_values = process_command(self, link_values); + get_TT(vm, tt); + link_values = play_PGC(vm); + link_values = process_command(vm, link_values); assert(link_values.command == PlayThis); - (self->state).blockN = link_values.data1; + (vm->state).blockN = link_values.data1; return 0; /* ?? */ } -int vm_jump_prog(vm_t *self, int pr) { +int vm_jump_prog(vm_t *vm, int pr) { link_t link_values; - (self->state).pgN = pr; /* ?? */ + (vm->state).pgN = pr; /* ?? */ - get_PGC(self, get_PGCN(self)); - link_values = play_PG(self); - link_values = process_command(self, link_values); + get_PGC(vm, get_PGCN(vm)); + link_values = play_PG(vm); + link_values = process_command(vm, link_values); assert(link_values.command == PlayThis); - (self->state).blockN = link_values.data1; + (vm->state).blockN = link_values.data1; return 0; /* ?? */ } -int vm_eval_cmd(vm_t *self, vm_cmd_t *cmd) +int vm_eval_cmd(vm_t *vm, vm_cmd_t *cmd) { link_t link_values; - if(vmEval_CMD(cmd, 1, &(self->state).registers, &link_values)) { - link_values = process_command(self, link_values); + if(vmEval_CMD(cmd, 1, &(vm->state).registers, &link_values)) { + link_values = process_command(vm, link_values); assert(link_values.command == PlayThis); - (self->state).blockN = link_values.data1; + (vm->state).blockN = link_values.data1; return 1; /* Something changed, Jump */ } else { return 0; /* It updated some state thats all... */ } } -int vm_get_next_cell(vm_t *self) +int vm_get_next_cell(vm_t *vm) { link_t link_values; - link_values = play_Cell_post(self); - link_values = process_command(self,link_values); + link_values = play_Cell_post(vm); + link_values = process_command(vm,link_values); assert(link_values.command == PlayThis); - (self->state).blockN = link_values.data1; + (vm->state).blockN = link_values.data1; return 0; /* ?? */ } -int vm_top_pg(vm_t *self) +int vm_top_pg(vm_t *vm) { link_t link_values; - link_values = play_PG(self); - link_values = process_command(self,link_values); + link_values = play_PG(vm); + link_values = process_command(vm,link_values); assert(link_values.command == PlayThis); - (self->state).blockN = link_values.data1; + (vm->state).blockN = link_values.data1; return 1; /* Jump */ } -int vm_go_up(vm_t *self) +int vm_go_up(vm_t *vm) { link_t link_values; - if(get_PGC(self, (self->state).pgc->goup_pgc_nr)) + if(get_PGC(vm, (vm->state).pgc->goup_pgc_nr)) assert(0); - link_values = play_PGC(self); - link_values = process_command(self,link_values); + link_values = play_PGC(vm); + link_values = process_command(vm,link_values); assert(link_values.command == PlayThis); - (self->state).blockN = link_values.data1; + (vm->state).blockN = link_values.data1; return 1; /* Jump */ } -int vm_next_pg(vm_t *self) +int vm_next_pg(vm_t *vm) { /* Do we need to get a updated pgN value first? */ - (self->state).pgN += 1; - return vm_top_pg(self); + (vm->state).pgN += 1; + return vm_top_pg(vm); } -int vm_prev_pg(vm_t *self) +int vm_prev_pg(vm_t *vm) { /* Do we need to get a updated pgN value first? */ - (self->state).pgN -= 1; - if((self->state).pgN == 0) { + (vm->state).pgN -= 1; + if((vm->state).pgN == 0) { /* Check for previous PGCN ? */ - (self->state).pgN = 1; + (vm->state).pgN = 1; /* return 0; */ } - return vm_top_pg(self); + return vm_top_pg(vm); } @@ -375,7 +375,7 @@ return result; } -int vm_menu_call(vm_t *self, DVDMenuID_t menuid, int block) +int vm_menu_call(vm_t *vm, DVDMenuID_t menuid, int block) { domain_t old_domain; link_t link_values; @@ -386,23 +386,23 @@ /* FIXME XXX $$$ How much state needs to be restored * when we fail to find a menu? */ - old_domain = (self->state).domain; + old_domain = (vm->state).domain; - switch((self->state).domain) { + switch((vm->state).domain) { case VTS_DOMAIN: - saveRSMinfo(self, 0, block); + saveRSMinfo(vm, 0, block); /* FALL THROUGH */ case VTSM_DOMAIN: case VMGM_DOMAIN: - (self->state).domain = menuid2domain(menuid); - if(get_PGCIT(self) != NULL && get_MENU(self, menuid) != -1) { - link_values = play_PGC(self); - link_values = process_command(self, link_values); + (vm->state).domain = menuid2domain(menuid); + if(get_PGCIT(vm) != NULL && get_MENU(vm, menuid) != -1) { + link_values = play_PGC(vm); + link_values = process_command(vm, link_values); assert(link_values.command == PlayThis); - (self->state).blockN = link_values.data1; + (vm->state).blockN = link_values.data1; return 1; /* Jump */ } else { - (self->state).domain = old_domain; + (vm->state).domain = old_domain; } break; case FP_DOMAIN: /* FIXME XXX $$$ What should we do here? */ @@ -413,43 +413,43 @@ } -int vm_resume(vm_t *self) +int vm_resume(vm_t *vm) { int i; link_t link_values; /* Check and see if there is any rsm info!! */ - if((self->state).rsm_vtsN == 0) { + if((vm->state).rsm_vtsN == 0) { return 0; } - (self->state).domain = VTS_DOMAIN; - ifoOpenNewVTSI(self, self->dvd, (self->state).rsm_vtsN); - get_PGC(self, (self->state).rsm_pgcN); + (vm->state).domain = VTS_DOMAIN; + ifoOpenNewVTSI(vm, vm->dvd, (vm->state).rsm_vtsN); + get_PGC(vm, (vm->state).rsm_pgcN); /* These should never be set in SystemSpace and/or MenuSpace */ - /* (self->state).TTN_REG = (self->state).rsm_tt; */ - /* (self->state).TT_PGCN_REG = (self->state).rsm_pgcN; */ - /* (self->state).HL_BTNN_REG = (self->state).rsm_btnn; */ + /* (vm->state).TTN_REG = (vm->state).rsm_tt; */ + /* (vm->state).TT_PGCN_REG = (vm->state).rsm_pgcN; */ + /* (vm->state).HL_BTNN_REG = (vm->state).rsm_btnn; */ for(i = 0; i < 5; i++) { - (self->state).registers.SPRM[4 + i] = (self->state).rsm_regs[i]; + (vm->state).registers.SPRM[4 + i] = (vm->state).rsm_regs[i]; } - if((self->state).rsm_cellN == 0) { - assert((self->state).cellN); /* Checking if this ever happens */ - (self->state).pgN = 1; - link_values = play_PG(self); - link_values = process_command(self, link_values); + if((vm->state).rsm_cellN == 0) { + assert((vm->state).cellN); /* Checking if this ever happens */ + (vm->state).pgN = 1; + link_values = play_PG(vm); + link_values = process_command(vm, link_values); assert(link_values.command == PlayThis); - (self->state).blockN = link_values.data1; + (vm->state).blockN = link_values.data1; } else { - (self->state).cellN = (self->state).rsm_cellN; - (self->state).blockN = (self->state).rsm_blockN; - /* (self->state).pgN = ?? does this gets the righ value in play_Cell, no! */ - if(set_PGN(self)) { + (vm->state).cellN = (vm->state).rsm_cellN; + (vm->state).blockN = (vm->state).rsm_blockN; + /* (vm->state).pgN = ?? does this gets the righ value in play_Cell, no! */ + if(set_PGN(vm)) { /* Were at or past the end of the PGC, should not happen for a RSM */ assert(0); - play_PGC_post(self); + play_PGC_post(vm); } } @@ -460,26 +460,26 @@ * Return the substream id for 'logical' audio stream audioN. * 0 <= audioN < 8 */ -int vm_get_audio_stream(vm_t *self, int audioN) +int vm_get_audio_stream(vm_t *vm, int audioN) { int streamN = -1; fprintf(stderr,"dvdnav:vm.c:get_audio_stream audioN=%d\n",audioN); - if((self->state).domain == VTSM_DOMAIN - || (self->state).domain == VMGM_DOMAIN - || (self->state).domain == FP_DOMAIN) { + if((vm->state).domain == VTSM_DOMAIN + || (vm->state).domain == VMGM_DOMAIN + || (vm->state).domain == FP_DOMAIN) { audioN = 0; } if(audioN < 8) { /* Is there any contol info for this logical stream */ - if((self->state).pgc->audio_control[audioN] & (1<<15)) { - streamN = ((self->state).pgc->audio_control[audioN] >> 8) & 0x07; + if((vm->state).pgc->audio_control[audioN] & (1<<15)) { + streamN = ((vm->state).pgc->audio_control[audioN] >> 8) & 0x07; } } - if((self->state).domain == VTSM_DOMAIN - || (self->state).domain == VMGM_DOMAIN - || (self->state).domain == FP_DOMAIN) { + if((vm->state).domain == VTSM_DOMAIN + || (vm->state).domain == VMGM_DOMAIN + || (vm->state).domain == FP_DOMAIN) { if(streamN == -1) streamN = 0; } @@ -493,32 +493,32 @@ * Return the substream id for 'logical' subpicture stream subpN. * 0 <= subpN < 32 */ -int vm_get_subp_stream(vm_t *self, int subpN) +int vm_get_subp_stream(vm_t *vm, int subpN) { int streamN = -1; - int source_aspect = get_video_aspect(self); + int source_aspect = get_video_aspect(vm); - if((self->state).domain == VTSM_DOMAIN - || (self->state).domain == VMGM_DOMAIN - || (self->state).domain == FP_DOMAIN) { + if((vm->state).domain == VTSM_DOMAIN + || (vm->state).domain == VMGM_DOMAIN + || (vm->state).domain == FP_DOMAIN) { subpN = 0; } if(subpN < 32) { /* a valid logical stream */ /* Is this logical stream present */ - if((self->state).pgc->subp_control[subpN] & (1<<31)) { + if((vm->state).pgc->subp_control[subpN] & (1<<31)) { if(source_aspect == 0) /* 4:3 */ - streamN = ((self->state).pgc->subp_control[subpN] >> 24) & 0x1f; + streamN = ((vm->state).pgc->subp_control[subpN] >> 24) & 0x1f; if(source_aspect == 3) /* 16:9 */ - streamN = ((self->state).pgc->subp_control[subpN] >> 16) & 0x1f; + streamN = ((vm->state).pgc->subp_control[subpN] >> 16) & 0x1f; } } /* Paranoia.. if no stream select 0 anyway */ /* I am not paranoid */ -/* if((self->state).domain == VTSM_DOMAIN - || (self->state).domain == VMGM_DOMAIN - || (self->state).domain == FP_DOMAIN) { +/* if((vm->state).domain == VTSM_DOMAIN + || (vm->state).domain == VMGM_DOMAIN + || (vm->state).domain == FP_DOMAIN) { if(streamN == -1) streamN = 0; } @@ -527,19 +527,19 @@ return streamN; } -int vm_get_subp_active_stream(vm_t *self) +int vm_get_subp_active_stream(vm_t *vm) { int subpN; int streamN; - subpN = (self->state).SPST_REG & ~0x40; - streamN = vm_get_subp_stream(self, subpN); + subpN = (vm->state).SPST_REG & ~0x40; + streamN = vm_get_subp_stream(vm, subpN); /* If no such stream, then select the first one that exists. */ if(streamN == -1) { for(subpN = 0; subpN < 32; subpN++) { - if((self->state).pgc->subp_control[subpN] & (1<<31)) { + if((vm->state).pgc->subp_control[subpN] & (1<<31)) { - streamN = vm_get_subp_stream(self, subpN); + streamN = vm_get_subp_stream(vm, subpN); break; } } @@ -547,7 +547,7 @@ /* We should instead send the on/off status to the spudecoder / mixer */ /* If we are in the title domain see if the spu mixing is on */ - if((self->state).domain == VTS_DOMAIN && !((self->state).SPST_REG & 0x40)) { + if((vm->state).domain == VTS_DOMAIN && !((vm->state).SPST_REG & 0x40)) { /* Bit 7 set means hide, and only let Forced display show */ return (streamN | 0x80); } else { @@ -555,18 +555,18 @@ } } -int vm_get_audio_active_stream(vm_t *self) +int vm_get_audio_active_stream(vm_t *vm) { int audioN; int streamN; - audioN = (self->state).AST_REG ; - streamN = vm_get_audio_stream(self, audioN); + audioN = (vm->state).AST_REG ; + streamN = vm_get_audio_stream(vm, audioN); /* If no such stream, then select the first one that exists. */ if(streamN == -1) { for(audioN = 0; audioN < 8; audioN++) { - if((self->state).pgc->audio_control[audioN] & (1<<15)) { - streamN = vm_get_audio_stream(self, audioN); + if((vm->state).pgc->audio_control[audioN] & (1<<15)) { + streamN = vm_get_audio_stream(vm, audioN); break; } } @@ -576,103 +576,103 @@ } -void vm_get_angle_info(vm_t *self, int *num_avail, int *current) +void vm_get_angle_info(vm_t *vm, int *num_avail, int *current) { *num_avail = 1; *current = 1; - if((self->state).domain == VTS_DOMAIN) { + if((vm->state).domain == VTS_DOMAIN) { /* TTN_REG does not allways point to the correct title.. */ title_info_t *title; - if((self->state).TTN_REG > self->vmgi->tt_srpt->nr_of_srpts) + if((vm->state).TTN_REG > vm->vmgi->tt_srpt->nr_of_srpts) return; - title = &self->vmgi->tt_srpt->title[(self->state).TTN_REG - 1]; - if(title->title_set_nr != (self->state).vtsN || - title->vts_ttn != (self->state).VTS_TTN_REG) + title = &vm->vmgi->tt_srpt->title[(vm->state).TTN_REG - 1]; + if(title->title_set_nr != (vm->state).vtsN || + title->vts_ttn != (vm->state).VTS_TTN_REG) return; *num_avail = title->nr_of_angles; - *current = (self->state).AGL_REG; + *current = (vm->state).AGL_REG; if(*current > *num_avail) /* Is this really a good idea? */ *current = *num_avail; } } -void vm_get_audio_info(vm_t *self, int *num_avail, int *current) +void vm_get_audio_info(vm_t *vm, int *num_avail, int *current) { - if((self->state).domain == VTS_DOMAIN) { - *num_avail = self->vtsi->vtsi_mat->nr_of_vts_audio_streams; - *current = (self->state).AST_REG; - } else if((self->state).domain == VTSM_DOMAIN) { - *num_avail = self->vtsi->vtsi_mat->nr_of_vtsm_audio_streams; /* 1 */ + if((vm->state).domain == VTS_DOMAIN) { + *num_avail = vm->vtsi->vtsi_mat->nr_of_vts_audio_streams; + *current = (vm->state).AST_REG; + } else if((vm->state).domain == VTSM_DOMAIN) { + *num_avail = vm->vtsi->vtsi_mat->nr_of_vtsm_audio_streams; /* 1 */ *current = 1; - } else if((self->state).domain == VMGM_DOMAIN || (self->state).domain == FP_DOMAIN) { - *num_avail = self->vmgi->vmgi_mat->nr_of_vmgm_audio_streams; /* 1 */ + } else if((vm->state).domain == VMGM_DOMAIN || (vm->state).domain == FP_DOMAIN) { + *num_avail = vm->vmgi->vmgi_mat->nr_of_vmgm_audio_streams; /* 1 */ *current = 1; } } -void vm_get_subp_info(vm_t *self, int *num_avail, int *current) +void vm_get_subp_info(vm_t *vm, int *num_avail, int *current) { - if((self->state).domain == VTS_DOMAIN) { - *num_avail = self->vtsi->vtsi_mat->nr_of_vts_subp_streams; - *current = (self->state).SPST_REG; - } else if((self->state).domain == VTSM_DOMAIN) { - *num_avail = self->vtsi->vtsi_mat->nr_of_vtsm_subp_streams; /* 1 */ + if((vm->state).domain == VTS_DOMAIN) { + *num_avail = vm->vtsi->vtsi_mat->nr_of_vts_subp_streams; + *current = (vm->state).SPST_REG; + } else if((vm->state).domain == VTSM_DOMAIN) { + *num_avail = vm->vtsi->vtsi_mat->nr_of_vtsm_subp_streams; /* 1 */ *current = 0x41; - } else if((self->state).domain == VMGM_DOMAIN || (self->state).domain == FP_DOMAIN) { - *num_avail = self->vmgi->vmgi_mat->nr_of_vmgm_subp_streams; /* 1 */ + } else if((vm->state).domain == VMGM_DOMAIN || (vm->state).domain == FP_DOMAIN) { + *num_avail = vm->vmgi->vmgi_mat->nr_of_vmgm_subp_streams; /* 1 */ *current = 0x41; } } -subp_attr_t vm_get_subp_attr(vm_t *self, int streamN) +subp_attr_t vm_get_subp_attr(vm_t *vm, int streamN) { subp_attr_t attr; - if((self->state).domain == VTS_DOMAIN) { - attr = self->vtsi->vtsi_mat->vts_subp_attr[streamN]; - } else if((self->state).domain == VTSM_DOMAIN) { - attr = self->vtsi->vtsi_mat->vtsm_subp_attr; - } else if((self->state).domain == VMGM_DOMAIN || (self->state).domain == FP_DOMAIN) { - attr = self->vmgi->vmgi_mat->vmgm_subp_attr; + if((vm->state).domain == VTS_DOMAIN) { + attr = vm->vtsi->vtsi_mat->vts_subp_attr[streamN]; + } else if((vm->state).domain == VTSM_DOMAIN) { + attr = vm->vtsi->vtsi_mat->vtsm_subp_attr; + } else if((vm->state).domain == VMGM_DOMAIN || (vm->state).domain == FP_DOMAIN) { + attr = vm->vmgi->vmgi_mat->vmgm_subp_attr; } return attr; } -audio_attr_t vm_get_audio_attr(vm_t *self, int streamN) +audio_attr_t vm_get_audio_attr(vm_t *vm, int streamN) { audio_attr_t attr; - if((self->state).domain == VTS_DOMAIN) { - attr = self->vtsi->vtsi_mat->vts_audio_attr[streamN]; - } else if((self->state).domain == VTSM_DOMAIN) { - attr = self->vtsi->vtsi_mat->vtsm_audio_attr; - } else if((self->state).domain == VMGM_DOMAIN || (self->state).domain == FP_DOMAIN) { - attr = self->vmgi->vmgi_mat->vmgm_audio_attr; + if((vm->state).domain == VTS_DOMAIN) { + attr = vm->vtsi->vtsi_mat->vts_audio_attr[streamN]; + } else if((vm->state).domain == VTSM_DOMAIN) { + attr = vm->vtsi->vtsi_mat->vtsm_audio_attr; + } else if((vm->state).domain == VMGM_DOMAIN || (vm->state).domain == FP_DOMAIN) { + attr = vm->vmgi->vmgi_mat->vmgm_audio_attr; } return attr; } -video_attr_t vm_get_video_attr(vm_t *self) +video_attr_t vm_get_video_attr(vm_t *vm) { video_attr_t attr; - if((self->state).domain == VTS_DOMAIN) { - attr = self->vtsi->vtsi_mat->vts_video_attr; - } else if((self->state).domain == VTSM_DOMAIN) { - attr = self->vtsi->vtsi_mat->vtsm_video_attr; - } else if((self->state).domain == VMGM_DOMAIN || (self->state).domain == FP_DOMAIN) { - attr = self->vmgi->vmgi_mat->vmgm_video_attr; + if((vm->state).domain == VTS_DOMAIN) { + attr = vm->vtsi->vtsi_mat->vts_video_attr; + } else if((vm->state).domain == VTSM_DOMAIN) { + attr = vm->vtsi->vtsi_mat->vtsm_video_attr; + } else if((vm->state).domain == VMGM_DOMAIN || (vm->state).domain == FP_DOMAIN) { + attr = vm->vmgi->vmgi_mat->vmgm_video_attr; } return attr; } -void vm_get_video_res(vm_t *self, int *width, int *height) +void vm_get_video_res(vm_t *vm, int *width, int *height) { video_attr_t attr; - attr = vm_get_video_attr(self); + attr = vm_get_video_attr(vm); if(attr.video_format != 0) *height = 576; @@ -696,56 +696,56 @@ } /* Must be called before domain is changed (get_PGCN()) */ -static void saveRSMinfo(vm_t *self, int cellN, int blockN) +static void saveRSMinfo(vm_t *vm, int cellN, int blockN) { int i; if(cellN != 0) { - (self->state).rsm_cellN = cellN; - (self->state).rsm_blockN = 0; + (vm->state).rsm_cellN = cellN; + (vm->state).rsm_blockN = 0; } else { - (self->state).rsm_cellN = (self->state).cellN; - (self->state).rsm_blockN = blockN; + (vm->state).rsm_cellN = (vm->state).cellN; + (vm->state).rsm_blockN = blockN; } - (self->state).rsm_vtsN = (self->state).vtsN; - (self->state).rsm_pgcN = get_PGCN(self); + (vm->state).rsm_vtsN = (vm->state).vtsN; + (vm->state).rsm_pgcN = get_PGCN(vm); - /* assert((self->state).rsm_pgcN == (self->state).TT_PGCN_REG); // for VTS_DOMAIN */ + /* assert((vm->state).rsm_pgcN == (vm->state).TT_PGCN_REG); // for VTS_DOMAIN */ for(i = 0; i < 5; i++) { - (self->state).rsm_regs[i] = (self->state).registers.SPRM[4 + i]; + (vm->state).rsm_regs[i] = (vm->state).registers.SPRM[4 + i]; } } -/* Figure out the correct pgN from the cell and update (self->state). */ -static int set_PGN(vm_t *self) { +/* Figure out the correct pgN from the cell and update (vm->state). */ +static int set_PGN(vm_t *vm) { int new_pgN = 0; - while(new_pgN < (self->state).pgc->nr_of_programs - && (self->state).cellN >= (self->state).pgc->program_map[new_pgN]) + while(new_pgN < (vm->state).pgc->nr_of_programs + && (vm->state).cellN >= (vm->state).pgc->program_map[new_pgN]) new_pgN++; - if(new_pgN == (self->state).pgc->nr_of_programs) /* We are at the last program */ - if((self->state).cellN > (self->state).pgc->nr_of_cells) + if(new_pgN == (vm->state).pgc->nr_of_programs) /* We are at the last program */ + if((vm->state).cellN > (vm->state).pgc->nr_of_cells) return 1; /* We are past the last cell */ - (self->state).pgN = new_pgN; + (vm->state).pgN = new_pgN; - if((self->state).domain == VTS_DOMAIN) { + if((vm->state).domain == VTS_DOMAIN) { playback_type_t *pb_ty; - if((self->state).TTN_REG > self->vmgi->tt_srpt->nr_of_srpts) + if((vm->state).TTN_REG > vm->vmgi->tt_srpt->nr_of_srpts) return 0; /* ?? */ - pb_ty = &self->vmgi->tt_srpt->title[(self->state).TTN_REG - 1].pb_ty; + pb_ty = &vm->vmgi->tt_srpt->title[(vm->state).TTN_REG - 1].pb_ty; if(pb_ty->multi_or_random_pgc_title == /* One_Sequential_PGC_Title */ 0) { #if 0 /* TTN_REG can't be trusted to have a correct value here... */ vts_ptt_srpt_t *ptt_srpt = vtsi->vts_ptt_srpt; - assert((self->state).VTS_TTN_REG <= ptt_srpt->nr_of_srpts); - assert(get_PGCN() == ptt_srpt->title[(self->state).VTS_TTN_REG - 1].ptt[0].pgcn); - assert(1 == ptt_srpt->title[(self->state).VTS_TTN_REG - 1].ptt[0].pgn); + assert((vm->state).VTS_TTN_REG <= ptt_srpt->nr_of_srpts); + assert(get_PGCN() == ptt_srpt->title[(vm->state).VTS_TTN_REG - 1].ptt[0].pgcn); + assert(1 == ptt_srpt->title[(vm->state).VTS_TTN_REG - 1].ptt[0].pgn); #endif - (self->state).PTTN_REG = (self->state).pgN; + (vm->state).PTTN_REG = (vm->state).pgN; } } @@ -756,93 +756,93 @@ -static link_t play_PGC(vm_t *self) +static link_t play_PGC(vm_t *vm) { link_t link_values; fprintf(stderr, "vm: play_PGC:"); - if((self->state).domain != FP_DOMAIN) - fprintf(stderr, " (self->state).pgcN (%i)\n", get_PGCN(self)); + if((vm->state).domain != FP_DOMAIN) + fprintf(stderr, " (vm->state).pgcN (%i)\n", get_PGCN(vm)); else fprintf(stderr, " first_play_pgc\n"); /* This must be set before the pre-commands are executed because they */ /* might contain a CallSS that will save resume state */ - (self->state).pgN = 1; - (self->state).cellN = 0; + (vm->state).pgN = 1; + (vm->state).cellN = 0; /* eval -> updates the state and returns either - some kind of jump (Jump(TT/SS/VTS_TTN/CallSS/link C/PG/PGC/PTTN) - just play video i.e first PG (This is what happens if you fall of the end of the pre_cmds) - or a error (are there more cases?) */ - if((self->state).pgc->command_tbl && (self->state).pgc->command_tbl->nr_of_pre) { - if(vmEval_CMD((self->state).pgc->command_tbl->pre_cmds, - (self->state).pgc->command_tbl->nr_of_pre, - &(self->state).registers, &link_values)) { + if((vm->state).pgc->command_tbl && (vm->state).pgc->command_tbl->nr_of_pre) { + if(vmEval_CMD((vm->state).pgc->command_tbl->pre_cmds, + (vm->state).pgc->command_tbl->nr_of_pre, + &(vm->state).registers, &link_values)) { /* link_values contains the 'jump' return value */ return link_values; } else { fprintf(stderr, "PGC pre commands didn't do a Jump, Link or Call\n"); } } - return play_PG(self); + return play_PG(vm); } -static link_t play_PG(vm_t *self) +static link_t play_PG(vm_t *vm) { - fprintf(stderr, "play_PG: (self->state).pgN (%i)\n", (self->state).pgN); + fprintf(stderr, "play_PG: (vm->state).pgN (%i)\n", (vm->state).pgN); - assert((self->state).pgN > 0); - if((self->state).pgN > (self->state).pgc->nr_of_programs) { - fprintf(stderr, "(self->state).pgN (%i) == pgc->nr_of_programs + 1 (%i)\n", - (self->state).pgN, (self->state).pgc->nr_of_programs + 1); - assert((self->state).pgN == (self->state).pgc->nr_of_programs + 1); - return play_PGC_post(self); + assert((vm->state).pgN > 0); + if((vm->state).pgN > (vm->state).pgc->nr_of_programs) { + fprintf(stderr, "(vm->state).pgN (%i) == pgc->nr_of_programs + 1 (%i)\n", + (vm->state).pgN, (vm->state).pgc->nr_of_programs + 1); + assert((vm->state).pgN == (vm->state).pgc->nr_of_programs + 1); + return play_PGC_post(vm); } - (self->state).cellN = (self->state).pgc->program_map[(self->state).pgN - 1]; + (vm->state).cellN = (vm->state).pgc->program_map[(vm->state).pgN - 1]; - return play_Cell(self); + return play_Cell(vm); } -static link_t play_Cell(vm_t *self) +static link_t play_Cell(vm_t *vm) { - fprintf(stderr, "play_Cell: (self->state).cellN (%i)\n", (self->state).cellN); + fprintf(stderr, "play_Cell: (vm->state).cellN (%i)\n", (vm->state).cellN); - assert((self->state).cellN > 0); - if((self->state).cellN > (self->state).pgc->nr_of_cells) { - fprintf(stderr, "(self->state).cellN (%i) == pgc->nr_of_cells + 1 (%i)\n", - (self->state).cellN, (self->state).pgc->nr_of_cells + 1); - assert((self->state).cellN == (self->state).pgc->nr_of_cells + 1); - return play_PGC_post(self); + assert((vm->state).cellN > 0); + if((vm->state).cellN > (vm->state).pgc->nr_of_cells) { + fprintf(stderr, "(vm->state).cellN (%i) == pgc->nr_of_cells + 1 (%i)\n", + (vm->state).cellN, (vm->state).pgc->nr_of_cells + 1); + assert((vm->state).cellN == (vm->state).pgc->nr_of_cells + 1); + return play_PGC_post(vm); } /* Multi angle/Interleaved */ - switch((self->state).pgc->cell_playback[(self->state).cellN - 1].block_mode) { + switch((vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_mode) { case 0: /* Normal */ - assert((self->state).pgc->cell_playback[(self->state).cellN - 1].block_type == 0); + assert((vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_type == 0); break; case 1: /* The first cell in the block */ - switch((self->state).pgc->cell_playback[(self->state).cellN - 1].block_type) { + switch((vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_type) { case 0: /* Not part of a block */ assert(0); case 1: /* Angle block */ /* Loop and check each cell instead? So we don't get outsid the block. */ - (self->state).cellN += (self->state).AGL_REG - 1; - assert((self->state).cellN <= (self->state).pgc->nr_of_cells); - assert((self->state).pgc->cell_playback[(self->state).cellN - 1].block_mode != 0); - assert((self->state).pgc->cell_playback[(self->state).cellN - 1].block_type == 1); + (vm->state).cellN += (vm->state).AGL_REG - 1; + assert((vm->state).cellN <= (vm->state).pgc->nr_of_cells); + assert((vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_mode != 0); + assert((vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_type == 1); break; case 2: /* ?? */ case 3: /* ?? */ default: fprintf(stderr, "Invalid? Cell block_mode (%d), block_type (%d)\n", - (self->state).pgc->cell_playback[(self->state).cellN - 1].block_mode, - (self->state).pgc->cell_playback[(self->state).cellN - 1].block_type); + (vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_mode, + (vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_type); } break; case 2: /* Cell in the block */ @@ -852,8 +852,8 @@ fprintf(stderr, "Cell is in block but did not enter at first cell!\n"); } - /* Updates (self->state).pgN and PTTN_REG */ - if(set_PGN(self)) { + /* Updates (vm->state).pgN and PTTN_REG */ + if(set_PGN(vm)) { /* Should not happen */ link_t tmp = {LinkTailPGC, /* No Button */ 0, 0, 0}; assert(0); @@ -867,13 +867,13 @@ } -static link_t play_Cell_post(vm_t *self) +static link_t play_Cell_post(vm_t *vm) { cell_playback_t *cell; - fprintf(stderr, "play_Cell_post: (self->state).cellN (%i)\n", (self->state).cellN); + fprintf(stderr, "play_Cell_post: (vm->state).cellN (%i)\n", (vm->state).cellN); - cell = &(self->state).pgc->cell_playback[(self->state).cellN - 1]; + cell = &(vm->state).pgc->cell_playback[(vm->state).cellN - 1]; /* Still time is already taken care of before we get called. */ @@ -881,11 +881,11 @@ if(cell->cell_cmd_nr != 0) { link_t link_values; - assert((self->state).pgc->command_tbl != NULL); - assert((self->state).pgc->command_tbl->nr_of_cell >= cell->cell_cmd_nr); + assert((vm->state).pgc->command_tbl != NULL); + assert((vm->state).pgc->command_tbl->nr_of_cell >= cell->cell_cmd_nr); fprintf(stderr, "Cell command pressent, executing\n"); - if(vmEval_CMD(&(self->state).pgc->command_tbl->cell_cmds[cell->cell_cmd_nr - 1], 1, - &(self->state).registers, &link_values)) { + if(vmEval_CMD(&(vm->state).pgc->command_tbl->cell_cmds[cell->cell_cmd_nr - 1], 1, + &(vm->state).registers, &link_values)) { return link_values; } else { fprintf(stderr, "Cell command didn't do a Jump, Link or Call\n"); @@ -896,63 +896,63 @@ /* Where to continue after playing the cell... */ /* Multi angle/Interleaved */ - switch((self->state).pgc->cell_playback[(self->state).cellN - 1].block_mode) { + switch((vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_mode) { case 0: /* Normal */ - assert((self->state).pgc->cell_playback[(self->state).cellN - 1].block_type == 0); - (self->state).cellN++; + assert((vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_type == 0); + (vm->state).cellN++; break; case 1: /* The first cell in the block */ case 2: /* A cell in the block */ case 3: /* The last cell in the block */ default: - switch((self->state).pgc->cell_playback[(self->state).cellN - 1].block_type) { + switch((vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_type) { case 0: /* Not part of a block */ assert(0); case 1: /* Angle block */ /* Skip the 'other' angles */ - (self->state).cellN++; - while((self->state).cellN <= (self->state).pgc->nr_of_cells - && (self->state).pgc->cell_playback[(self->state).cellN - 1].block_mode >= 2) { - (self->state).cellN++; + (vm->state).cellN++; + while((vm->state).cellN <= (vm->state).pgc->nr_of_cells + && (vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_mode >= 2) { + (vm->state).cellN++; } break; case 2: /* ?? */ case 3: /* ?? */ default: fprintf(stderr, "Invalid? Cell block_mode (%d), block_type (%d)\n", - (self->state).pgc->cell_playback[(self->state).cellN - 1].block_mode, - (self->state).pgc->cell_playback[(self->state).cellN - 1].block_type); + (vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_mode, + (vm->state).pgc->cell_playback[(vm->state).cellN - 1].block_type); } break; } /* Figure out the correct pgN for the new cell */ - if(set_PGN(self)) { + if(set_PGN(vm)) { fprintf(stderr, "last cell in this PGC\n"); - return play_PGC_post(self); + return play_PGC_post(vm); } - return play_Cell(self); + return play_Cell(vm); } -static link_t play_PGC_post(vm_t *self) +static link_t play_PGC_post(vm_t *vm) { link_t link_values; fprintf(stderr, "play_PGC_post:\n"); - assert((self->state).pgc->still_time == 0); /* FIXME $$$ */ + assert((vm->state).pgc->still_time == 0); /* FIXME $$$ */ /* eval -> updates the state and returns either - some kind of jump (Jump(TT/SS/VTS_TTN/CallSS/link C/PG/PGC/PTTN) - or a error (are there more cases?) - if you got to the end of the post_cmds, then what ?? */ - if((self->state).pgc->command_tbl && - vmEval_CMD((self->state).pgc->command_tbl->post_cmds, - (self->state).pgc->command_tbl->nr_of_post, - &(self->state).registers, &link_values)) { + if((vm->state).pgc->command_tbl && + vmEval_CMD((vm->state).pgc->command_tbl->post_cmds, + (vm->state).pgc->command_tbl->nr_of_post, + &(vm->state).registers, &link_values)) { return link_values; } @@ -960,17 +960,17 @@ { link_t link_next_pgc = {LinkNextPGC, 0, 0, 0}; fprintf(stderr, "** Fell of the end of the pgc, continuing in NextPGC\n"); - assert((self->state).pgc->next_pgc_nr != 0); + assert((vm->state).pgc->next_pgc_nr != 0); return link_next_pgc; } } -static link_t process_command(vm_t *self, link_t link_values) +static link_t process_command(vm_t *vm, link_t link_values) { /* FIXME $$$ Move this to a separate function? */ - self->badness_counter++; - if (self->badness_counter > 1) fprintf(stderr, "**** process_command re-entered %d*****\n",self->badness_counter); + vm->badness_counter++; + if (vm->badness_counter > 1) fprintf(stderr, "**** process_command re-entered %d*****\n",vm->badness_counter); while(link_values.command != PlayThis) { vmPrint_LINK(link_values); @@ -979,98 +979,99 @@ link_values.data1, link_values.data2, link_values.data3); fprintf(stderr, "Before:"); - vm_print_current_domain_state(self); + vm_print_current_domain_state(vm); switch(link_values.command) { case LinkNoLink: /* No Link */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; - exit(1); + (vm->state).HL_BTNN_REG = link_values.data1 << 10; + fprintf(stderr, "libdvdnav in trouble...LinkNoLink - CRASHING!!!\n"); + assert(0); case LinkTopC: /* Link to Top?? Cell */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; - link_values = play_Cell(self); + (vm->state).HL_BTNN_REG = link_values.data1 << 10; + link_values = play_Cell(vm); break; case LinkNextC: /* Link to Next Cell */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; - (self->state).cellN += 1; /* FIXME: What if cellN becomes > nr_of_cells? */ - link_values = play_Cell(self); + (vm->state).HL_BTNN_REG = link_values.data1 << 10; + (vm->state).cellN += 1; /* FIXME: What if cellN becomes > nr_of_cells? */ + link_values = play_Cell(vm); break; case LinkPrevC: /* Link to Previous Cell */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; - (self->state).cellN -= 1; /* FIXME: What if cellN becomes < 1? */ - link_values = play_Cell(self); + (vm->state).HL_BTNN_REG = link_values.data1 << 10; + (vm->state).cellN -= 1; /* FIXME: What if cellN becomes < 1? */ + link_values = play_Cell(vm); break; case LinkTopPG: /* Link to Top Program */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; + (vm->state).HL_BTNN_REG = link_values.data1 << 10; /* Does pgN always contain the current value? */ - link_values = play_PG(self); + link_values = play_PG(vm); break; case LinkNextPG: /* Link to Next Program */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; + (vm->state).HL_BTNN_REG = link_values.data1 << 10; /* Does pgN always contain the current value? */ - (self->state).pgN += 1; /* FIXME: What if pgN becomes > pgc.nr_of_programs? */ - link_values = play_PG(self); + (vm->state).pgN += 1; /* FIXME: What if pgN becomes > pgc.nr_of_programs? */ + link_values = play_PG(vm); break; case LinkPrevPG: /* Link to Previous Program */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; + (vm->state).HL_BTNN_REG = link_values.data1 << 10; /* Does pgN always contain the current value? */ - (self->state).pgN -= 1; /* FIXME: What if pgN becomes < 1? */ - link_values = play_PG(self); + (vm->state).pgN -= 1; /* FIXME: What if pgN becomes < 1? */ + link_values = play_PG(vm); break; case LinkTopPGC: /* Link to Top Program Chain */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; - link_values = play_PGC(self); + (vm->state).HL_BTNN_REG = link_values.data1 << 10; + link_values = play_PGC(vm); break; case LinkNextPGC: /* Link to Next Program Chain */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; - assert((self->state).pgc->next_pgc_nr != 0); - if(get_PGC(self, (self->state).pgc->next_pgc_nr)) + (vm->state).HL_BTNN_REG = link_values.data1 << 10; + assert((vm->state).pgc->next_pgc_nr != 0); + if(get_PGC(vm, (vm->state).pgc->next_pgc_nr)) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case LinkPrevPGC: /* Link to Previous Program Chain */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; - assert((self->state).pgc->prev_pgc_nr != 0); - if(get_PGC(self, (self->state).pgc->prev_pgc_nr)) + (vm->state).HL_BTNN_REG = link_values.data1 << 10; + assert((vm->state).pgc->prev_pgc_nr != 0); + if(get_PGC(vm, (vm->state).pgc->prev_pgc_nr)) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case LinkGoUpPGC: /* Link to GoUp??? Program Chain */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; - assert((self->state).pgc->goup_pgc_nr != 0); - if(get_PGC(self, (self->state).pgc->goup_pgc_nr)) + (vm->state).HL_BTNN_REG = link_values.data1 << 10; + assert((vm->state).pgc->goup_pgc_nr != 0); + if(get_PGC(vm, (vm->state).pgc->goup_pgc_nr)) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case LinkTailPGC: /* Link to Tail??? Program Chain */ if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; - link_values = play_PGC_post(self); + (vm->state).HL_BTNN_REG = link_values.data1 << 10; + link_values = play_PGC_post(vm); break; case LinkRSM: @@ -1078,33 +1079,33 @@ /* Link to Resume */ int i; /* Check and see if there is any rsm info!! */ - (self->state).domain = VTS_DOMAIN; - ifoOpenNewVTSI(self, self->dvd, (self->state).rsm_vtsN); - get_PGC(self, (self->state).rsm_pgcN); + (vm->state).domain = VTS_DOMAIN; + ifoOpenNewVTSI(vm, vm->dvd, (vm->state).rsm_vtsN); + get_PGC(vm, (vm->state).rsm_pgcN); /* These should never be set in SystemSpace and/or MenuSpace */ - /* (self->state).TTN_REG = rsm_tt; ?? */ - /* (self->state).TT_PGCN_REG = (self->state).rsm_pgcN; ?? */ + /* (vm->state).TTN_REG = rsm_tt; ?? */ + /* (vm->state).TT_PGCN_REG = (vm->state).rsm_pgcN; ?? */ for(i = 0; i < 5; i++) { - (self->state).registers.SPRM[4 + i] = (self->state).rsm_regs[i]; + (vm->state).registers.SPRM[4 + i] = (vm->state).rsm_regs[i]; } if(link_values.data1 != 0) - (self->state).HL_BTNN_REG = link_values.data1 << 10; + (vm->state).HL_BTNN_REG = link_values.data1 << 10; - if((self->state).rsm_cellN == 0) { - assert((self->state).cellN); /* Checking if this ever happens */ + if((vm->state).rsm_cellN == 0) { + assert((vm->state).cellN); /* Checking if this ever happens */ /* assert( time/block/vobu is 0 ); */ - (self->state).pgN = 1; - link_values = play_PG(self); + (vm->state).pgN = 1; + link_values = play_PG(vm); } else { /* assert( time/block/vobu is _not_ 0 ); */ /* play_Cell_at_time */ - /* (self->state).pgN = ?? this gets the righ value in play_Cell */ - (self->state).cellN = (self->state).rsm_cellN; + /* (vm->state).pgN = ?? this gets the righ value in play_Cell */ + (vm->state).cellN = (vm->state).rsm_cellN; link_values.command = PlayThis; - link_values.data1 = (self->state).rsm_blockN; - if(set_PGN(self)) { + link_values.data1 = (vm->state).rsm_blockN; + if(set_PGN(vm)) { /* Were at the end of the PGC, should not happen for a RSM */ assert(0); link_values.command = LinkTailPGC; @@ -1115,87 +1116,88 @@ break; case LinkPGCN: /* Link to Program Chain Number:data1 */ - if(get_PGC(self, link_values.data1)) + if(get_PGC(vm, link_values.data1)) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case LinkPTTN: /* Link to Part of this Title Number:data1 */ - assert((self->state).domain == VTS_DOMAIN); + assert((vm->state).domain == VTS_DOMAIN); if(link_values.data2 != 0) - (self->state).HL_BTNN_REG = link_values.data2 << 10; - if(get_VTS_PTT(self, (self->state).vtsN, (self->state).VTS_TTN_REG, link_values.data1) == -1) + (vm->state).HL_BTNN_REG = link_values.data2 << 10; + if(get_VTS_PTT(vm, (vm->state).vtsN, (vm->state).VTS_TTN_REG, link_values.data1) == -1) assert(0); - link_values = play_PG(self); + link_values = play_PG(vm); break; case LinkPGN: /* Link to Program Number:data1 */ if(link_values.data2 != 0) - (self->state).HL_BTNN_REG = link_values.data2 << 10; + (vm->state).HL_BTNN_REG = link_values.data2 << 10; /* Update any other state, PTTN perhaps? */ - (self->state).pgN = link_values.data1; - link_values = play_PG(self); + (vm->state).pgN = link_values.data1; + link_values = play_PG(vm); break; case LinkCN: /* Link to Cell Number:data1 */ if(link_values.data2 != 0) - (self->state).HL_BTNN_REG = link_values.data2 << 10; + (vm->state).HL_BTNN_REG = link_values.data2 << 10; /* Update any other state, pgN, PTTN perhaps? */ - (self->state).cellN = link_values.data1; - link_values = play_Cell(self); + (vm->state).cellN = link_values.data1; + link_values = play_Cell(vm); break; case Exit: - exit(1); /* What should we do here?? */ + fprintf(stderr, "libdvdnav in trouble...Link Exit - CRASHING!!!\n"); + assert(0); /* What should we do here?? */ case JumpTT: /* Jump to VTS Title Domain */ /* Only allowed from the First Play domain(PGC) */ /* or the Video Manager domain (VMG) */ //fprintf(stderr,"****** JumpTT is Broken, please fix me!!! ****\n"); - assert((self->state).domain == VMGM_DOMAIN || (self->state).domain == FP_DOMAIN); /* ?? */ - if(get_TT(self,link_values.data1) == -1) + assert((vm->state).domain == VMGM_DOMAIN || (vm->state).domain == FP_DOMAIN); /* ?? */ + if(get_TT(vm,link_values.data1) == -1) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case JumpVTS_TT: /* Jump to Title:data1 in same VTS Title Domain */ /* Only allowed from the VTS Menu Domain(VTSM) */ /* or the Video Title Set Domain(VTS) */ - assert((self->state).domain == VTSM_DOMAIN || (self->state).domain == VTS_DOMAIN); /* ?? */ + assert((vm->state).domain == VTSM_DOMAIN || (vm->state).domain == VTS_DOMAIN); /* ?? */ /* FIXME: Should be able to use get_VTS_PTT here */ - if(get_VTS_TT(self,(self->state).vtsN, link_values.data1) == -1) + if(get_VTS_TT(vm,(vm->state).vtsN, link_values.data1) == -1) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case JumpVTS_PTT: /* Jump to Part:data2 of Title:data1 in same VTS Title Domain */ /* Only allowed from the VTS Menu Domain(VTSM) */ /* or the Video Title Set Domain(VTS) */ - assert((self->state).domain == VTSM_DOMAIN || (self->state).domain == VTS_DOMAIN); /* ?? */ - if(get_VTS_PTT(self,(self->state).vtsN, link_values.data1, link_values.data2) == -1) + assert((vm->state).domain == VTSM_DOMAIN || (vm->state).domain == VTS_DOMAIN); /* ?? */ + if(get_VTS_PTT(vm,(vm->state).vtsN, link_values.data1, link_values.data2) == -1) assert(0); - link_values = play_PG(self); + link_values = play_PG(vm); break; case JumpSS_FP: /* Jump to First Play Domain */ /* Only allowed from the VTS Menu Domain(VTSM) */ /* or the Video Manager domain (VMG) */ - assert((self->state).domain == VMGM_DOMAIN || (self->state).domain == VTSM_DOMAIN); /* ?? */ - get_FP_PGC(self); - link_values = play_PGC(self); + assert((vm->state).domain == VMGM_DOMAIN || (vm->state).domain == VTSM_DOMAIN); /* ?? */ + get_FP_PGC(vm); + link_values = play_PGC(vm); break; case JumpSS_VMGM_MENU: /* Jump to Video Manger domain - Title Menu:data1 or any PGC in VMG */ /* Allowed from anywhere except the VTS Title domain */ - assert((self->state).domain == VMGM_DOMAIN || - (self->state).domain == VTSM_DOMAIN || - (self->state).domain == FP_DOMAIN); /* ?? */ - (self->state).domain = VMGM_DOMAIN; - if(get_MENU(self,link_values.data1) == -1) + assert((vm->state).domain == VMGM_DOMAIN || + (vm->state).domain == VTSM_DOMAIN || + (vm->state).domain == FP_DOMAIN); /* ?? */ + (vm->state).domain = VMGM_DOMAIN; + if(get_MENU(vm,link_values.data1) == -1) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case JumpSS_VTSM: /* Jump to a menu in Video Title domain, */ @@ -1211,162 +1213,162 @@ fprintf(stderr, "dvdnav: *******************************************************************\n"); if(link_values.data1 !=0) { - assert((self->state).domain == VMGM_DOMAIN || (self->state).domain == FP_DOMAIN); /* ?? */ - (self->state).domain = VTSM_DOMAIN; - ifoOpenNewVTSI(self, self->dvd, link_values.data1); /* Also sets (self->state).vtsN */ + assert((vm->state).domain == VMGM_DOMAIN || (vm->state).domain == FP_DOMAIN); /* ?? */ + (vm->state).domain = VTSM_DOMAIN; + ifoOpenNewVTSI(vm, vm->dvd, link_values.data1); /* Also sets (vm->state).vtsN */ } else { /* This happens on 'The Fifth Element' region 2. */ - assert((self->state).domain == VTSM_DOMAIN); + assert((vm->state).domain == VTSM_DOMAIN); } /* I don't know what title is supposed to be used for. */ /* Alien or Aliens has this != 1, I think. */ /* assert(link_values.data2 == 1); */ - (self->state).VTS_TTN_REG = link_values.data2; - if(get_MENU(self, link_values.data3) == -1) + (vm->state).VTS_TTN_REG = link_values.data2; + if(get_MENU(vm, link_values.data3) == -1) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case JumpSS_VMGM_PGC: - assert((self->state).domain == VMGM_DOMAIN || - (self->state).domain == VTSM_DOMAIN || - (self->state).domain == FP_DOMAIN); /* ?? */ - (self->state).domain = VMGM_DOMAIN; - if(get_PGC(self,link_values.data1) == -1) + assert((vm->state).domain == VMGM_DOMAIN || + (vm->state).domain == VTSM_DOMAIN || + (vm->state).domain == FP_DOMAIN); /* ?? */ + (vm->state).domain = VMGM_DOMAIN; + if(get_PGC(vm,link_values.data1) == -1) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case CallSS_FP: - assert((self->state).domain == VTS_DOMAIN); /* ?? */ + assert((vm->state).domain == VTS_DOMAIN); /* ?? */ /* Must be called before domain is changed */ - saveRSMinfo(self, link_values.data1, /* We dont have block info */ 0); - get_FP_PGC(self); - link_values = play_PGC(self); + saveRSMinfo(vm, link_values.data1, /* We dont have block info */ 0); + get_FP_PGC(vm); + link_values = play_PGC(vm); break; case CallSS_VMGM_MENU: - assert((self->state).domain == VTS_DOMAIN); /* ?? */ + assert((vm->state).domain == VTS_DOMAIN); /* ?? */ /* Must be called before domain is changed */ - saveRSMinfo(self,link_values.data2, /* We dont have block info */ 0); - (self->state).domain = VMGM_DOMAIN; - if(get_MENU(self,link_values.data1) == -1) + saveRSMinfo(vm,link_values.data2, /* We dont have block info */ 0); + (vm->state).domain = VMGM_DOMAIN; + if(get_MENU(vm,link_values.data1) == -1) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case CallSS_VTSM: - assert((self->state).domain == VTS_DOMAIN); /* ?? */ + assert((vm->state).domain == VTS_DOMAIN); /* ?? */ /* Must be called before domain is changed */ - saveRSMinfo(self,link_values.data2, /* We dont have block info */ 0); - (self->state).domain = VTSM_DOMAIN; - if(get_MENU(self,link_values.data1) == -1) + saveRSMinfo(vm,link_values.data2, /* We dont have block info */ 0); + (vm->state).domain = VTSM_DOMAIN; + if(get_MENU(vm,link_values.data1) == -1) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case CallSS_VMGM_PGC: - assert((self->state).domain == VTS_DOMAIN); /* ?? */ + assert((vm->state).domain == VTS_DOMAIN); /* ?? */ /* Must be called before domain is changed */ - saveRSMinfo(self,link_values.data2, /* We dont have block info */ 0); - (self->state).domain = VMGM_DOMAIN; - if(get_PGC(self,link_values.data1) == -1) + saveRSMinfo(vm,link_values.data2, /* We dont have block info */ 0); + (vm->state).domain = VMGM_DOMAIN; + if(get_PGC(vm,link_values.data1) == -1) assert(0); - link_values = play_PGC(self); + link_values = play_PGC(vm); break; case PlayThis: /* Should never happen. */ break; } fprintf(stderr, "After:"); - vm_print_current_domain_state(self); + vm_print_current_domain_state(vm); } - self->badness_counter--; + vm->badness_counter--; return link_values; } -static int get_TT(vm_t *self, int tt) +static int get_TT(vm_t *vm, int tt) { //fprintf(stderr,"****** get_TT is Broken, please fix me!!! ****\n"); - assert(tt <= self->vmgi->tt_srpt->nr_of_srpts); + assert(tt <= vm->vmgi->tt_srpt->nr_of_srpts); - (self->state).TTN_REG = tt; + (vm->state).TTN_REG = tt; - return get_VTS_TT(self, self->vmgi->tt_srpt->title[tt - 1].title_set_nr, - self->vmgi->tt_srpt->title[tt - 1].vts_ttn); + return get_VTS_TT(vm, vm->vmgi->tt_srpt->title[tt - 1].title_set_nr, + vm->vmgi->tt_srpt->title[tt - 1].vts_ttn); } -static int get_VTS_TT(vm_t *self, int vtsN, int vts_ttn) +static int get_VTS_TT(vm_t *vm, int vtsN, int vts_ttn) { int pgcN; //fprintf(stderr,"****** get_VTS_TT is Broken, please fix me!!! ****\n"); fprintf(stderr,"title_set_nr=%d\n", vtsN); fprintf(stderr,"vts_ttn=%d\n", vts_ttn); - (self->state).domain = VTS_DOMAIN; - if(vtsN != (self->state).vtsN) { + (vm->state).domain = VTS_DOMAIN; + if(vtsN != (vm->state).vtsN) { fprintf(stderr,"****** opening new VTSI ****\n"); - ifoOpenNewVTSI(self, self->dvd, vtsN); /* Also sets (self->state).vtsN */ + ifoOpenNewVTSI(vm, vm->dvd, vtsN); /* Also sets (vm->state).vtsN */ fprintf(stderr,"****** opened VTSI ****\n"); } - pgcN = get_ID(self, vts_ttn); /* This might return -1 */ + pgcN = get_ID(vm, vts_ttn); /* This might return -1 */ assert(pgcN != -1); - /* (self->state).TTN_REG = ?? Must search tt_srpt for a matching entry... */ - (self->state).VTS_TTN_REG = vts_ttn; + /* (vm->state).TTN_REG = ?? Must search tt_srpt for a matching entry... */ + (vm->state).VTS_TTN_REG = vts_ttn; /* Any other registers? */ - return get_PGC(self, pgcN); + return get_PGC(vm, pgcN); } -static int get_VTS_PTT(vm_t *self, int vtsN, int /* is this really */ vts_ttn, int part) +static int get_VTS_PTT(vm_t *vm, int vtsN, int /* is this really */ vts_ttn, int part) { int pgcN, pgN; - (self->state).domain = VTS_DOMAIN; - if(vtsN != (self->state).vtsN) - ifoOpenNewVTSI(self, self->dvd, vtsN); /* Also sets (self->state).vtsN */ + (vm->state).domain = VTS_DOMAIN; + if(vtsN != (vm->state).vtsN) + ifoOpenNewVTSI(vm, vm->dvd, vtsN); /* Also sets (vm->state).vtsN */ - assert(vts_ttn <= self->vtsi->vts_ptt_srpt->nr_of_srpts); - assert(part <= self->vtsi->vts_ptt_srpt->title[vts_ttn - 1].nr_of_ptts); + assert(vts_ttn <= vm->vtsi->vts_ptt_srpt->nr_of_srpts); + assert(part <= vm->vtsi->vts_ptt_srpt->title[vts_ttn - 1].nr_of_ptts); - pgcN = self->vtsi->vts_ptt_srpt->title[vts_ttn - 1].ptt[part - 1].pgcn; - pgN = self->vtsi->vts_ptt_srpt->title[vts_ttn - 1].ptt[part - 1].pgn; + pgcN = vm->vtsi->vts_ptt_srpt->title[vts_ttn - 1].ptt[part - 1].pgcn; + pgN = vm->vtsi->vts_ptt_srpt->title[vts_ttn - 1].ptt[part - 1].pgn; - /* (self->state).TTN_REG = ?? Must search tt_srpt for a matchhing entry... */ - (self->state).VTS_TTN_REG = vts_ttn; + /* (vm->state).TTN_REG = ?? Must search tt_srpt for a matchhing entry... */ + (vm->state).VTS_TTN_REG = vts_ttn; /* Any other registers? */ - (self->state).pgN = pgN; /* ?? */ + (vm->state).pgN = pgN; /* ?? */ - return get_PGC(self, pgcN); + return get_PGC(vm, pgcN); } -static int get_FP_PGC(vm_t *self) +static int get_FP_PGC(vm_t *vm) { - (self->state).domain = FP_DOMAIN; + (vm->state).domain = FP_DOMAIN; - (self->state).pgc = self->vmgi->first_play_pgc; + (vm->state).pgc = vm->vmgi->first_play_pgc; return 0; } -static int get_MENU(vm_t *self, int menu) +static int get_MENU(vm_t *vm, int menu) { - assert((self->state).domain == VMGM_DOMAIN || (self->state).domain == VTSM_DOMAIN); - return get_PGC(self, get_ID(self, menu)); + assert((vm->state).domain == VMGM_DOMAIN || (vm->state).domain == VTSM_DOMAIN); + return get_PGC(vm, get_ID(vm, menu)); } -static int get_ID(vm_t *self, int id) +static int get_ID(vm_t *vm, int id) { int pgcN, i; pgcit_t *pgcit; /* Relies on state to get the correct pgcit. */ - pgcit = get_PGCIT(self); + pgcit = get_PGCIT(vm); assert(pgcit != NULL); /* Get menu/title */ @@ -1383,12 +1385,12 @@ -static int get_PGC(vm_t *self, int pgcN) +static int get_PGC(vm_t *vm, int pgcN) { /* FIXME: Keep this up to date with the ogle people */ pgcit_t *pgcit; - pgcit = get_PGCIT(self); + pgcit = get_PGCIT(vm); assert(pgcit != NULL); /* ?? Make this return -1 instead */ if(pgcN < 1 || pgcN > pgcit->nr_of_pgci_srp) { @@ -1397,26 +1399,26 @@ /* pgcN = 1; */ } - /* (self->state).pgcN = pgcN; */ - (self->state).pgc = pgcit->pgci_srp[pgcN - 1].pgc; + /* (vm->state).pgcN = pgcN; */ + (vm->state).pgc = pgcit->pgci_srp[pgcN - 1].pgc; - if((self->state).domain == VTS_DOMAIN) - (self->state).TT_PGCN_REG = pgcN; + if((vm->state).domain == VTS_DOMAIN) + (vm->state).TT_PGCN_REG = pgcN; return 0; } -static int get_PGCN(vm_t *self) +static int get_PGCN(vm_t *vm) { pgcit_t *pgcit; int pgcN = 1; - pgcit = get_PGCIT(self); + pgcit = get_PGCIT(vm); assert(pgcit != NULL); while(pgcN <= pgcit->nr_of_pgci_srp) { - if(pgcit->pgci_srp[pgcN - 1].pgc == (self->state).pgc) + if(pgcit->pgci_srp[pgcN - 1].pgc == (vm->state).pgc) return pgcN; pgcN++; } @@ -1425,21 +1427,21 @@ } -static int get_video_aspect(vm_t *self) +static int get_video_aspect(vm_t *vm) { int aspect = 0; - if((self->state).domain == VTS_DOMAIN) { - aspect = self->vtsi->vtsi_mat->vts_video_attr.display_aspect_ratio; - } else if((self->state).domain == VTSM_DOMAIN) { - aspect = self->vtsi->vtsi_mat->vtsm_video_attr.display_aspect_ratio; - } else if((self->state).domain == VMGM_DOMAIN) { - aspect = self->vmgi->vmgi_mat->vmgm_video_attr.display_aspect_ratio; + if((vm->state).domain == VTS_DOMAIN) { + aspect = vm->vtsi->vtsi_mat->vts_video_attr.display_aspect_ratio; + } else if((vm->state).domain == VTSM_DOMAIN) { + aspect = vm->vtsi->vtsi_mat->vtsm_video_attr.display_aspect_ratio; + } else if((vm->state).domain == VMGM_DOMAIN) { + aspect = vm->vmgi->vmgi_mat->vmgm_video_attr.display_aspect_ratio; } fprintf(stderr, "dvdnav:get_video_aspect:aspect=%d\n",aspect); assert(aspect == 0 || aspect == 3); - (self->state).registers.SPRM[14] &= ~(0x3 << 10); - (self->state).registers.SPRM[14] |= aspect << 10; + (vm->state).registers.SPRM[14] &= ~(0x3 << 10); + (vm->state).registers.SPRM[14] |= aspect << 10; return aspect; } @@ -1449,47 +1451,47 @@ -static void ifoOpenNewVTSI(vm_t *self, dvd_reader_t *dvd, int vtsN) +static void ifoOpenNewVTSI(vm_t *vm, dvd_reader_t *dvd, int vtsN) { - if((self->state).vtsN == vtsN) { + if((vm->state).vtsN == vtsN) { return; /* We alread have it */ } - if(self->vtsi != NULL) - ifoClose(self->vtsi); + if(vm->vtsi != NULL) + ifoClose(vm->vtsi); - self->vtsi = ifoOpenVTSI(dvd, vtsN); - if(self->vtsi == NULL) { - fprintf(stderr, "ifoOpenVTSI failed\n"); - exit(1); + vm->vtsi = ifoOpenVTSI(dvd, vtsN); + if(vm->vtsi == NULL) { + fprintf(stderr, "ifoOpenVTSI failed - CRASHING!!!\n"); + assert(0); } - if(!ifoRead_VTS_PTT_SRPT(self->vtsi)) { - fprintf(stderr, "ifoRead_VTS_PTT_SRPT failed\n"); - exit(1); + if(!ifoRead_VTS_PTT_SRPT(vm->vtsi)) { + fprintf(stderr, "ifoRead_VTS_PTT_SRPT failed - CRASHING!!!\n"); + assert(0); } - if(!ifoRead_PGCIT(self->vtsi)) { - fprintf(stderr, "ifoRead_PGCIT failed\n"); - exit(1); + if(!ifoRead_PGCIT(vm->vtsi)) { + fprintf(stderr, "ifoRead_PGCIT failed - CRASHING!!!\n"); + assert(0); } - if(!ifoRead_PGCI_UT(self->vtsi)) { - fprintf(stderr, "ifoRead_PGCI_UT failed\n"); - exit(1); + if(!ifoRead_PGCI_UT(vm->vtsi)) { + fprintf(stderr, "ifoRead_PGCI_UT failed - CRASHING!!!\n"); + assert(0); } - if(!ifoRead_VOBU_ADMAP(self->vtsi)) { - fprintf(stderr, "ifoRead_VOBU_ADMAP vtsi failed\n"); - exit(1); + if(!ifoRead_VOBU_ADMAP(vm->vtsi)) { + fprintf(stderr, "ifoRead_VOBU_ADMAP vtsi failed - CRASHING\n"); + assert(0); } - if(!ifoRead_TITLE_VOBU_ADMAP(self->vtsi)) { - fprintf(stderr, "ifoRead_TITLE_VOBU_ADMAP vtsi failed\n"); - exit(1); + if(!ifoRead_TITLE_VOBU_ADMAP(vm->vtsi)) { + fprintf(stderr, "ifoRead_TITLE_VOBU_ADMAP vtsi failed - CRASHING\n"); + assert(0); } - (self->state).vtsN = vtsN; + (vm->state).vtsN = vtsN; } -static pgcit_t* get_MENU_PGCIT(vm_t *self, ifo_handle_t *h, uint16_t lang) +static pgcit_t* get_MENU_PGCIT(vm_t *vm, ifo_handle_t *h, uint16_t lang) { int i; @@ -1514,15 +1516,15 @@ } /* Uses state to decide what to return */ -static pgcit_t* get_PGCIT(vm_t *self) { +static pgcit_t* get_PGCIT(vm_t *vm) { pgcit_t *pgcit; - if((self->state).domain == VTS_DOMAIN) { - pgcit = self->vtsi->vts_pgcit; - } else if((self->state).domain == VTSM_DOMAIN) { - pgcit = get_MENU_PGCIT(self, self->vtsi, (self->state).registers.SPRM[0]); - } else if((self->state).domain == VMGM_DOMAIN) { - pgcit = get_MENU_PGCIT(self, self->vmgi, (self->state).registers.SPRM[0]); + if((vm->state).domain == VTS_DOMAIN) { + pgcit = vm->vtsi->vts_pgcit; + } else if((vm->state).domain == VTSM_DOMAIN) { + pgcit = get_MENU_PGCIT(vm, vm->vtsi, (vm->state).registers.SPRM[0]); + } else if((vm->state).domain == VMGM_DOMAIN) { + pgcit = get_MENU_PGCIT(vm, vm->vmgi, (vm->state).registers.SPRM[0]); } else { pgcit = NULL; /* Should never hapen */ } @@ -1532,6 +1534,10 @@ /* * $Log$ + * Revision 1.4 2002/04/06 18:31:50 jcdutton + * Some cleaning up. + * changed exit(1) to assert(0) so they actually get seen by the user so that it helps developers more. + * * Revision 1.3 2002/04/02 18:22:27 richwareham * Added reset patch from Kees Cook * @@ -1543,7 +1549,7 @@ * * Revision 1.18 2002/01/22 16:56:49 jcdutton * Fix clut after seeking. - * Add a few virtual machine debug messages, to help diagnose problems with "Deep Purple - Total Abandon" DVD as I don't have the DVD itself. + * Add a few virtual machine debug messages, to help diagnose problems with "Deep Purple - Total Abandon" DVD as I don't have the DVD itvm. * Fix a few debug messages, so they do not say FIXME. * Move the FIXME debug messages to comments in the code. * diff -r c1b55dc1bfed -r 5f319e02e333 vm.h --- a/vm.h Tue Apr 02 22:25:21 2002 +0000 +++ b/vm.h Sat Apr 06 18:31:50 2002 +0000 @@ -91,40 +91,40 @@ /* Initialisation & destruction */ vm_t* vm_new_vm(); -void vm_free_vm(vm_t *self); +void vm_free_vm(vm_t *vm); /* IFO access */ -ifo_handle_t *vm_get_vmgi(vm_t *self); -ifo_handle_t *vm_get_vtsi(vm_t *self); +ifo_handle_t *vm_get_vmgi(vm_t *vm); +ifo_handle_t *vm_get_vtsi(vm_t *vm); /* Reader Access */ -dvd_reader_t *vm_get_dvd_reader(vm_t *self); +dvd_reader_t *vm_get_dvd_reader(vm_t *vm); /* Jumping */ -int vm_start_title(vm_t *self, int tt); -int vm_jump_prog(vm_t *self, int pr); +int vm_start_title(vm_t *vm, int tt); +int vm_jump_prog(vm_t *vm, int pr); /* Other calls */ -int vm_reset(vm_t *self, char *dvdroot); /* , register_t regs); */ -int vm_start(vm_t *self); -int vm_eval_cmd(vm_t *self, vm_cmd_t *cmd); -int vm_get_next_cell(vm_t *self); -int vm_menu_call(vm_t *self, DVDMenuID_t menuid, int block); -int vm_resume(vm_t *self); -int vm_go_up(vm_t *self); -int vm_top_pg(vm_t *self); -int vm_next_pg(vm_t *self); -int vm_prev_pg(vm_t *self); -int vm_get_audio_stream(vm_t *self, int audioN); -int vm_get_audio_active_stream(vm_t *self); -int vm_get_subp_stream(vm_t *self, int subpN); -int vm_get_subp_active_stream(vm_t *self); -void vm_get_angle_info(vm_t *self, int *num_avail, int *current); -void vm_get_audio_info(vm_t *self, int *num_avail, int *current); -void vm_get_subp_info(vm_t *self, int *num_avail, int *current); -subp_attr_t vm_get_subp_attr(vm_t *self, int streamN); -audio_attr_t vm_get_audio_attr(vm_t *self, int streamN); -void vm_get_video_res(vm_t *self, int *width, int *height); +int vm_reset(vm_t *vm, char *dvdroot); /* , register_t regs); */ +int vm_start(vm_t *vm); +int vm_eval_cmd(vm_t *vm, vm_cmd_t *cmd); +int vm_get_next_cell(vm_t *vm); +int vm_menu_call(vm_t *vm, DVDMenuID_t menuid, int block); +int vm_resume(vm_t *vm); +int vm_go_up(vm_t *vm); +int vm_top_pg(vm_t *vm); +int vm_next_pg(vm_t *vm); +int vm_prev_pg(vm_t *vm); +int vm_get_audio_stream(vm_t *vm, int audioN); +int vm_get_audio_active_stream(vm_t *vm); +int vm_get_subp_stream(vm_t *vm, int subpN); +int vm_get_subp_active_stream(vm_t *vm); +void vm_get_angle_info(vm_t *vm, int *num_avail, int *current); +void vm_get_audio_info(vm_t *vm, int *num_avail, int *current); +void vm_get_subp_info(vm_t *vm, int *num_avail, int *current); +subp_attr_t vm_get_subp_attr(vm_t *vm, int streamN); +audio_attr_t vm_get_audio_attr(vm_t *vm, int streamN); +void vm_get_video_res(vm_t *vm, int *width, int *height); #endif /* VM_HV_INCLUDED */