tsr.c

用来将电脑连接到电视荧幕, 并以15Khz输出的源码, 请只用在支援15Khz的荧幕上, 以免伤害荧幕

                        {
                                memcpy(MK_FP(TSR_SEG+(FP_SEG(&PROGRAM)-FP_SEG(int10h_proc)),FP_OFF(&PROGRAM)),&PROGRAM,sizeof(PROGRAM));
                                ShowOptions();
                        }
                }
                else    /* TSR is at the same offset, but failed the TSR flag, could be ours or someone elses */
                {
                        printf("Unable to unloaded.\n");
                }
                return;
        }

        /* TSR not loaded, lets do it! */

        /* Set default options first, before calling parse cmdline options */
        PROGRAM.psp=_psp;
        PROGRAM.loaded_flag=TSR_ID;

        PROGRAM.current_ticks=0;
        PROGRAM.unload=0;
        PROGRAM.enabled=1;
        PROGRAM.vidmem=0;
        PROGRAM.max_ticks=MODEX_DELAY; /* 18 = 1 second approx */

        PROGRAM.center_x=0;
        PROGRAM.center_y=0;
        PROGRAM.h_sync_delay=0;
        PROGRAM.h_disp_delay=0;

        PROGRAM.use_pm_interface = (own_pm_interface_supported() == 0) ? 0 : 1;
        PROGRAM.vga_hook_enabled = 1;
        PROGRAM.use_original_1024x768 = 1;
#ifdef SUPPORT_DBCS
        PROGRAM.use_dbcs = 0;
#endif
        /* Any user defined options?? */
        if(ParseOptions(argc-1, &argv[1])==0)
        {
                return; /* Help was shown don't do anything */
        }

        /* Set new interrupt vectors */
        asm cli
        set_old10h_proc( (DWORD)old_int10 );
        setvect(0x10, int10h_proc);

        old_int8 = getvect(0x08);
        setvect(0x08,int8h_proc);

        asm sti

        ShowOptions();

        // Terminate and Stay Resident
        tsr();
}

static void tsr()
{
        _DX=(_SS + ((_SP+16)/16) - _psp);
        _AH=0x31;
        _AL=1;
        asm { int 21h };
}

static void freetsr(unsigned int prog_seg)
{
        unsigned int seg;

        for ( seg = 0; ! IS_FIRST_ARENA_HEADER( seg ); seg++ );

        while ( ! IS_LAST_ARENA_HEADER( seg ) )
        {
                if (FAR_WORD(seg, 1) == prog_seg)
                {
                        /* DOS free segment */
                        _AX=seg+1;
                        _ES=_AX;
                        _AH=0x49;
                        asm     int 21h
                }
                seg = NEXT_ARENA_HEADER( seg );
        }
}


/* VESA helping functions */

static int DetectVESA()
{
        _ES=FP_SEG(&VESA);
        _DI=FP_OFF(&VESA);
        _AX=0x4f00;
        asm int 10h

        if(_AX!=0x004f || memcmp(VESA.sig,"VESA",4))       /* No VESA support */
                return 0;

        /*printf("Vesa BIOS extension found\n");
        printf("Version %d.%d\n",VESA.version >> 8,VESA.version & 0x00ff);
        printf("%s\n",VESA.oemstring);
        printf("%u kilobytes of memory on board\n",VESA.memory<<6);*/
        return 1;
}


/* Make a VESA mode list, all existing plus any custom */
static void VESA_MakeModeList()
{
        int index,index2;
        VIDEOMODE *ListPtr;
        index=0;
        index2=0;

        VESAmodes[0]=0xffff;
        ListPtr = &PROGRAM.VideoModes[0];
        if(PROGRAM.use_original_1024x768 == 0){
                ListPtr = &PROGRAM.VideoModes[PROGRAM.start_own_vesa_mode];
        }

        while(index < (MAXVIDEOMODES-1))        /* Add custom modes to list */
        {
                if( (ListPtr + index2)->index == 0xffff )
                {
                        break;
                }
                else
                {
                        VESAmodes[index]=(ListPtr + index2)->index;
                }
                index++;
                index2++;
        }
        VESAmodes[index]=0xffff;        /* Terminate List */
}



/* Returns a information about a VESA mode */
static WORD VESA_ModeInfo(unsigned int mode, WORD regtop)
{
        WORD pre_ax;
        WORD pre_cx;
        WORD pre_es;
        WORD pre_di;
        WORD reg_ax;
        WORD reg_cx;
        WORD reg_es;
        WORD reg_di;
        unsigned long d0;
        int index;
        VIDEOMODE *ListPtr;

        ListPtr = &PROGRAM.VideoModes[0];
        if(PROGRAM.use_original_1024x768 == 0){
                ListPtr = &PROGRAM.VideoModes[PROGRAM.start_own_vesa_mode];
        }

        index=0;

        while((ListPtr + index)->index != 0xFFFF && (ListPtr + index)->index != mode)
        {
                index++;
        }

        if( (ListPtr + index)->VESAmode != 0xFFFF ){
                reg_cx = (ListPtr + index)->VESAmode;
        }else{
                return 0xFFFF;          /* error */
        }

        /* Get information about the incoming VESA mode */
        /* and fills in our VESAbuffer block */
        reg_es = FP_SEG(&VESAbuffer);
        reg_di = FP_OFF(&VESAbuffer);
        reg_ax = 0x4f01;

        pre_ax = get_reg(regtop, ofsAX);
        pre_cx = get_reg(regtop, ofsCX);
        pre_es = get_reg(regtop, ofsES);
        pre_di = get_reg(regtop, ofsDI);

        set_reg(regtop, ofsAX, reg_ax);
        set_reg(regtop, ofsCX, reg_cx);
        set_reg(regtop, ofsES, reg_es);
        set_reg(regtop, ofsDI, reg_di);

        generic_oldint10h_for_c_code(regtop);

        set_reg(regtop, ofsAX, pre_ax);
        set_reg(regtop, ofsCX, pre_cx);
        set_reg(regtop, ofsES, pre_es);
        set_reg(regtop, ofsDI, pre_di);

        /* Update to new custom mode spec */
        /*
        /*  index >= CUSTOM_MODE    :   custom mode         */
        /*  index <  CUSTOM_MODE    :   original VESA mode  */

        if((ListPtr + index)->index >= CUSTOM_MODE)
        {
                VESAbuffer.bytesperline =
                        AdjustBytesPerLine((ListPtr + index)->bytesperline);
                VESAbuffer.height = (ListPtr + index)->height;
                VESAbuffer.width  = (ListPtr + index)->width;
                VESAbuffer.bpp    = (ListPtr + index)->bpp;
                d0 = (unsigned long)(PROGRAM.membytes / VESAbuffer.bytesperline);
                d0 = (d0 / VESAbuffer.height) - 1;
                if(d0 > 63) d0 = 63;
                VESAbuffer.imagepagecount = (unsigned char)d0;
        }

        return (ListPtr + index)->VESAmode;
}


/* --------- GENERIC MODE CODE --------- */

static void DisplayModes(void)
{
        VIDEOMODE *ListPtr;
        int idx;

        ListPtr = &PROGRAM.VideoModes[0];
        idx = 0;
        while(idx < (MAXVIDEOMODES-1))
        {
                if( (ListPtr + idx)->index == 0xFFFF )
                {
                        /* End of list */
                        break;
                }
                printf("\n\n");
                if( (ListPtr + idx)->index < CUSTOM_MODE ){
                    printf("original VESA mode %x [%d x %d]\n", (ListPtr + idx)->index, (ListPtr + idx)->width, (ListPtr + idx)->height);
                }else{
                    printf("Mon-ARC PLUS mode %x [%d x %d %d]\n", (ListPtr + idx)->index, (ListPtr + idx)->width, (ListPtr + idx)->height, (ListPtr + idx)->bpp);
/*                        printf("BytesPerLine. %d\n", (ListPtr + idx)->bytesperline);
                        printf("BPP.......... %d\n", (ListPtr + idx)->bpp);
                        printf("HTotal....... %d\n", (ListPtr + idx)->HTotal);
                        printf("HDispEnd..... %d\n", (ListPtr + idx)->HDisp);
                        printf("HBlankStart.. %d\n", (ListPtr + idx)->HBStart);
                        printf("HSyncStart... %d\n", (ListPtr + idx)->HSStart);
                        printf("HSyncEnd..... %d\n", (ListPtr + idx)->HSEnd);
                        printf("HBlankEnd.... %d\n", (ListPtr + idx)->HBEnd);
                        printf("VTotal....... %d\n", (ListPtr + idx)->VTotal);
                        printf("VDispEnd..... %d\n", (ListPtr + idx)->VDisp);
                        printf("VBlankStart.. %d\n", (ListPtr + idx)->VBStart);
                        printf("VSyncStart... %d\n", (ListPtr + idx)->VSStart);
                        printf("VSyncEnd..... %d\n", (ListPtr + idx)->VSEnd);
                        printf("VBlankEnd.... %d\n", (ListPtr + idx)->VBEnd);

                        printf("HPolarity.... %d\n", (ListPtr + idx)->hpolarity);
                        printf("VPolarity.... %d\n", (ListPtr + idx)->vpolarity);
                        printf("DoubleScan... %d\n", (ListPtr + idx)->doublescan);
                        printf("Interlace.... %d\n", (ListPtr + idx)->interlace);
                        printf("Interlace R.. %d\n", (ListPtr + idx)->interlaceratio);
                        printf("DotClockHZ... %lu\n",(ListPtr + idx)->dotclockHz);*/
                        printf("Horz HZ...... %lu\n",(ListPtr + idx)->horzHz);
                        printf("Vert HZ...... %lu\n",(ListPtr + idx)->vert001Hz);
                }
                idx ++;
                getch();
        }
        printf("\nFree space left for %d modes\n",((MAXVIDEOMODES-1)-idx)>>1);
        getch();
}

static void DisplayModeX(void)
{
        VIDEOMODE *ListPtr;

        ListPtr = &PROGRAM.VideoModes[MAXVIDEOMODES-1];

        printf("Last ModeX Mode Information\n");
        printf("Actual Width. %d\n", ListPtr->width);
        printf("Actual Height %d\n", ListPtr->height);
        printf("HTotal....... %d\n", ListPtr->HTotal);
        printf("HDispEnd..... %d\n", ListPtr->HDisp);
        printf("HBlankStart.. %d\n", ListPtr->HBStart);
        printf("HSyncStart... %d\n", ListPtr->HSStart);
        printf("HSyncEnd..... %d\n", ListPtr->HSEnd);
        printf("HBlankEnd.... %d\n", ListPtr->HBEnd);
        printf("VTotal....... %d\n", ListPtr->VTotal);
        printf("VDispEnd..... %d\n", ListPtr->VDisp);
        printf("VBlankStart.. %d\n", ListPtr->VBStart);
        printf("VSyncStart... %d\n", ListPtr->VSStart);
        printf("VSyncEnd..... %d\n", ListPtr->VSEnd);
        printf("VBlankEnd.... %d\n", ListPtr->VBEnd);

        printf("DoubleScan... %d\n", ListPtr->doublescan);
        printf("Interlace.... %d\n", ListPtr->interlace);
        printf("DotClockHZ... %lu\n",ListPtr->dotclockHz);
        printf("Horz HZ...... %lu\n",ListPtr->horzHz);
        printf("Vert HZ...... %lu\n",ListPtr->vert001Hz);
        getch();
}

static int AddMode(VIDEOMODE *newmode)
{
    VIDEOMODE *ListPtr;
    unsigned int idx8bpp;
    unsigned int idx16bpp;
    int idx;
    int bpp;

    idx8bpp  = 0xFFFF;
    idx16bpp = 0xFFFF;

    ListPtr = &PROGRAM.VideoModes[0];
    idx = 0;

    while(idx < (MAXVIDEOMODES-1) )
    {
        if( (ListPtr + idx)->index == 0xFFFF )
        {
            /* Mode not found add to the end then */
            if(idx8bpp == 0xFFFF){
                idx8bpp = idx;
                idx += 1;
            }
            if(idx16bpp == 0xFFFF){
                idx16bpp = idx;
            }
            break;
        }
        else if( (ListPtr + idx)->index  >= CUSTOM_MODE    &&   /*  for to ignore original VESA mode  */
                 (ListPtr + idx)->width  == newmode->width &&
                 (ListPtr + idx)->height == newmode->height )
        {
            bpp = (ListPtr + idx)->bpp;
            if(bpp == 8){
                if(idx8bpp == 0xFFFF) idx8bpp = idx;
            }else if(bpp == 16 || bpp == 15){
                if(idx16bpp == 0xFFFF) idx16bpp = idx;
            }
        }
        idx ++;
    }
    if(idx >= (MAXVIDEOMODES-1) ) return 0;

    /* Create 8bit version */
    if(idx8bpp != 0xFFFF){
        if(idx8bpp >= (MAXVIDEOMODES-1) ) return 0;
        bpp = GetAvailableBpp(8);
        *(ListPtr + idx8bpp) = *newmode;
        (ListPtr + idx8bpp)->index        = CUSTOM_MODE + idx8bpp;
        (ListPtr + idx8bpp)->bpp          = bpp;
        (ListPtr + idx8bpp)->bytesperline = AdjustBytesPerLine(newmode->width);
        (ListPtr + idx8bpp)->VESAmode     = GetActualVesaMode(newmode->width,
                                                          newmode->height, bpp);
    }
    /* Create 16 bit version */
    if(idx16bpp != 0xFFFF){
        if(idx16bpp >= (MAXVIDEOMODES-1) ) return 0;
        bpp = GetAvailableBpp(16);
        *(ListPtr + idx16bpp) = *newmode;
        (ListPtr + idx16bpp)->index        = CUSTOM_MODE + idx16bpp;
        (ListPtr + idx16bpp)->bpp          = bpp;
        (ListPtr + idx16bpp)->bytesperline = AdjustBytesPerLine(newmode->width << 1);
        (ListPtr + idx16bpp)->VESAmode     = GetActualVesaMode(newmode->width,
                                                          newmode->height, bpp);
    }
    return 1;
}