Subversion Repositories pentevo

#include "std.h"

#include "emul.h"

#include "vars.h"

#include "draw.h"

#include "drawnomc.h"

#include "dx.h"

#include "dxr_text.h"

#include "dxr_rsm.h"

#include "dxr_advm.h"

#include "memory.h"

#include "config.h"

#include "util.h"

#ifdef CACHE_ALIGNED

CACHE_ALIGNED unsigned char rbuf[sizeof_rbuf];

#else // __declspec(align) not available, force QWORD align with old method

__int64 rbuf__[sizeof_rbuf/sizeof(__int64)];

unsigned char * const rbuf = (unsigned char*)rbuf__;

#endif

unsigned char * const rbuf_s = rbuf + rb2_offs; // frames to mix with noflic and resampler filters

unsigned char * const save_buf = rbuf_s + rb2_offs*MAX_BUFFERS; // used in monitor

T t;

videopoint *vcurr; // Óêàçàòåëü íà òåêóùèé ýëåìåíò èç video[]

// Ìàññèâ âèäåîñòðîê âêëþ÷àÿ áîðäþð

// video[i] - íà÷àëî ñòðîêè (èñïîëüçóåòñÿ òîëüêî next_t)

// video[i+1] - êîíåö ñòðîêè  (èñïîëüçóþòñÿ âñå ïàðàìåòðû)

videopoint video[4*MAX_HEIGHT];

unsigned vmode;  // what are drawing: 0-not visible, 1-border, 2-screen

unsigned prev_t; // òàêò íà êîòîðîì áûë îòðèñîâàí ïîñëåäíèé ïèêñåëü

unsigned *atrtab;

unsigned char colortab[0x100];// map zx attributes to pc attributes

// colortab shifted to 8 and 24

unsigned colortab_s8[0x100];

unsigned colortab_s24[0x100];

/*

#include "drawnomc.cpp"

#include "draw_384.cpp"

*/

PALETTEENTRY pal0[0x100]; // emulator palette

void AtmVideoController::PrepareFrameATM2(int VideoMode)

{

    for (int y=0; y<256; y++)

    {

        if ( VideoMode == 6 )

        {

            // ñìåùåíèÿ â òåêñòîâîì âèäåîðåæèìå

            Scanlines[y].Offset = 64*(y/8);

        } else {

            // ñìåùåíèÿ â ðàñòðîâîì âèäåîðåæèìå

            Scanlines[y].Offset = (y<56) ? 0 : 40*(y-56);

        }

        Scanlines[y].VideoMode = VideoMode;

    }

    CurrentRayLine = 0;

    IncCounter_InRaster = 0;

    IncCounter_InBorder = 0;

}

void AtmVideoController::PrepareFrameATM1(int VideoMode)

{

    for (int y=56; y<256; y++)

    {

        Scanlines[y].Offset = 40*(y-56);

        Scanlines[y].VideoMode = VideoMode;

    }

}

AtmVideoController AtmVideoCtrl;

void video_permanent_tables()

{

   // pixel doubling table

   unsigned i; //Alone Coder 0.36.7

   for (/*unsigned*/ i = 0; i < 0x100; i++) {

      unsigned res = 0;

      for (int j = 0x80; j; j/=2) {

         res <<= 2; if (i & j) res |= 3;

      }

      t.dbl[i] = res;

   }

   for (i = 0; i < 0x100; i++) {

      unsigned r1 = 0, r2 = 0;

      if (i & 0x01) r1++,        r2 += 1;

      if (i & 0x02) r1++,        r2 += 1;

      if (i & 0x04) r1++,        r2 += 0x100;

      if (i & 0x08) r1++,        r2 += 0x100;

      if (i & 0x10) r1 += 0x100, r2 += 0x10000;

      if (i & 0x20) r1 += 0x100, r2 += 0x10000;

      if (i & 0x40) r1 += 0x100, r2 += 0x1000000;

      if (i & 0x80) r1 += 0x100, r2 += 0x1000000;

      // low byte of settab - number of pixels in low nibble of i

      // high byte of low word of settab - number of pixels in high nibble of i

      t.settab[i] = r1;

      t.settab2[i] = r2*4; // *4 - convert square 2x2 to 4x4

   }

   i = 0; // calc screen addresses

   for (int p = 0; p < 4; p++)

      for (int y = 0; y < 8; y++)

         for (int o = 0; o < 8; o++, i++)

            t.scrtab[i] = p*0x800 + y*0x20 + o*0x100,

            t.atrtab_hwmc[i] = t.scrtab[i] + 0x2000,

            t.atrtab[i] = 0x1800 + (p*8+y)*32;

   // alco table

   static unsigned disp_0[] = { 0x0018, 0x2000, 0x2008, 0x2010, 0x2018, 0x0008 };

   static unsigned base_s[] = { 0x10000, 0x14000, 0x14800, 0x15000, 0x11800 };

   static unsigned base_a[] = { 0x11000, 0x15800, 0x15900, 0x15A00, 0x11300 };

   for (unsigned y = 0; y < 304; y++)

      for (unsigned x = 0; x < 6; x++) {

         unsigned disp = disp_0[x] + (y & 0x38)*4;

         ::t.alco[y][x].a = memory + base_a[y/64] + disp;

         ::t.alco[y][x].s = memory + base_s[y/64] + disp + (y & 7)*0x100;

      }

   #ifdef MOD_VID_VD

   // this code is only for ygrbYGRB palette

   for (unsigned byte = 0; byte < 0x100; byte++)

      for (int bit = 0; bit < 8; bit++)

         t.vdtab[0][0][byte].m64_u8[7-bit] = (byte & (1 << bit))? 0x11 : 0;

   for (int pl = 1; pl < 4; pl++)

      for (unsigned byte = 0; byte < 0x100; byte++)

         t.vdtab[0][pl][byte] = _mm_slli_pi32(t.vdtab[0][0][byte], pl);

   for (i = 0; i < sizeof t.vdtab[0]; i++)

      ((unsigned char*)t.vdtab[1])[i] = ((unsigned char*)t.vdtab[0])[i] & 0x0F;

   _mm_empty();

   #endif

   temp.offset_vscroll_prev = 0;

   temp.offset_vscroll = 0;

   temp.offset_hscroll_prev = 0;

   temp.offset_hscroll = 0;

}

unsigned getYUY2(unsigned r, unsigned g, unsigned b)

{

   int y = (int)(0.29*r + 0.59*g + 0.14*b);

   int u = (int)(128.0 - 0.14*r - 0.29*g + 0.43*b);

   int v = (int)(128.0 + 0.36*r - 0.29*g - 0.07*b);

   if (y < 0) y = 0; if (y > 255) y = 255;

   if (u < 0) u = 0; if (u > 255) u = 255;

   if (v < 0) v = 0; if (v > 255) v = 255;

   return WORD4(y,u,y,v);

}

void create_palette()

{

   if ((temp.rflags & RF_8BPCH) && temp.obpp == 8) temp.rflags |= RF_GRAY, conf.flashcolor = 0;

   PALETTE_OPTIONS *pl = &pals[conf.pal];

   unsigned char brights[4] = { u8(pl->ZZ), u8(pl->ZN), u8(pl->NN), u8(pl->BB) };

   unsigned char brtab[16] =

      {  //  ZZ          NN          ZZ          BB

        u8(pl->ZZ), u8(pl->ZN), u8(pl->ZZ), u8(pl->ZB),    // ZZ

        u8(pl->ZN), u8(pl->NN), u8(pl->ZN), u8(pl->NB),    // NN

        u8(pl->ZZ), u8(pl->ZN), u8(pl->ZZ), u8(pl->ZB),    // ZZ (bright=1,ink=0)

        u8(pl->ZB), u8(pl->NB), u8(pl->ZB), u8(pl->BB)     // BB

      };

   for (unsigned i = 0; i < 0x100; i++) {

      unsigned r0, g0, b0;

      if (temp.rflags & RF_GRAY) { // grayscale palette

         r0 = g0 = b0 = i;

      } else if (temp.rflags & RF_PALB) { // palette index: gg0rr0bb

         b0 = brights[i & 3];

         r0 = brights[(i >> 3) & 3];

         g0 = brights[(i >> 6) & 3];

      } else { // palette index: ygrbYGRB

         b0 = brtab[((i>>0)&1)+((i>>2)&2)+((i>>2)&4)+((i>>4)&8)]; // brtab[ybYB]

         r0 = brtab[((i>>1)&1)+((i>>2)&2)+((i>>3)&4)+((i>>4)&8)]; // brtab[yrYR]

         g0 = brtab[((i>>2)&1)+((i>>2)&2)+((i>>4)&4)+((i>>4)&8)]; // brtab[ygYG]

      }

      // transform with current settings

      unsigned r = 0xFF & ((r0 * pl->r11 + g0 * pl->r12 + b0 * pl->r13) / 0x100);

      unsigned g = 0xFF & ((r0 * pl->r21 + g0 * pl->r22 + b0 * pl->r23) / 0x100);

      unsigned b = 0xFF & ((r0 * pl->r31 + g0 * pl->r32 + b0 * pl->r33) / 0x100);

      // prepare palette in bitmap header for GDI renderer

      gdibmp.header.bmiColors[i].rgbRed   = pal0[i].peRed   = r;

      gdibmp.header.bmiColors[i].rgbGreen = pal0[i].peGreen = g;

      gdibmp.header.bmiColors[i].rgbBlue  = pal0[i].peBlue  = b;

   }

   memcpy(syspalette + 10, pal0 + 10, (246-9) * sizeof *syspalette);

}

void atm_zc_tables();//forward

// make colortab: zx-attr -> pc-attr

void make_colortab(char flash_active)

{

   if (conf.flashcolor)

       flash_active = 0;

   for (unsigned a = 0; a < 0x100; a++)

   {

      unsigned char ink = a & 7;

      unsigned char paper = (a >> 3) & 7;

      unsigned char bright = (a >> 6) & 1;

      unsigned char flash = (a >> 7) & 1;

      if((conf.flashcolor && ink) || !conf.flashcolor)

          ink |= bright << 3;

      if((conf.flashcolor && paper) || !conf.flashcolor)

          paper |= (conf.flashcolor ? flash : bright) << 3;

      if (flash_active && flash)

      {

          unsigned char t = ink;

          ink = paper;

          paper = t;

      }

      u8 color = (paper << 4) | ink;

      colortab[a] = color;

      colortab_s8[a] = color << 8;

      colortab_s24[a] = color << 24;

   }

   if (conf.mem_model == MM_ATM710 || conf.mem_model == MM_ATM3 || conf.mem_model == MM_ATM450)

       atm_zc_tables(); // update with new flash bit

}

// make attrtab: pc-attr + 0x100*pixel -> palette index

void attr_tables()

{

   unsigned char flashcolor = (temp.rflags & RF_MON)? 0 : conf.flashcolor;

   for (unsigned a = 0; a < 0x100; a++)

   {

      unsigned char ink = (a & 0x0F), paper = (a >> 4);

      if (flashcolor)

          paper = (paper & 7) + (ink & 8); // paper_bright from ink

      if (temp.rflags & RF_GRAY)

      { // grayscale palette

         t.attrtab[a] = paper*16;

         t.attrtab[a+0x100] = ink*16;

      }

      else if (temp.rflags & RF_COMPPAL)

      { //------ for ATM palette - direct values from palette registers

         t.attrtab[a] = comp.comp_pal[a >> 4];

         t.attrtab[a+0x100] = comp.comp_pal[a & 0x0F];

      }

      else if (temp.rflags & RF_PALB)

      { //----------------------------- for bilinear

         unsigned char b0,b1, r0,r1, g0,g1;

         b0 = (paper >> 0) & 1, r0 = (paper >> 1) & 1, g0 = (paper >> 2) & 1;

         b1 = (ink >> 0) & 1, r1 = (ink >> 1) & 1, g1 = (ink >> 2) & 1;

         if (flashcolor && (a & 0x80))

         {

            b1 += b0, r1 += r0, g1 += g0;

            r0 = b0 = g0 = 0;

         }

         else

         {

            b0 *= 2, r0 *= 2, g0 *=2,

            b1 *= 2, r1 *= 2, g1 *=2;

         }

         unsigned char br1 = (ink >> 3) & 1;

         if (r1) r1 += br1;

         if (g1) g1 += br1;

         if (b1) b1 += br1;

         unsigned char br0 = (paper >> 3) & 1;

         if (r0) r0 += br0;

         if (g0) g0 += br0;

         if (b0) b0 += br0;

         // palette index: gg0rr0bb

         t.attrtab[a+0x100]  = (g1 << 6) + (r1 << 3) + b1;

         t.attrtab[a]        = (g0 << 6) + (r0 << 3) + b0;

      }

      else //------------------------------------ all others

      {

         // palette index: ygrbYGRB

         if (flashcolor && (a & 0x80))

         {

             t.attrtab[a] = 0;

             t.attrtab[a+0x100] = ink+(paper<<4);

         }

         else

         {

             t.attrtab[a] = paper * 0x11;

             t.attrtab[a+0x100] = ink * 0x11;

         }

      }

   }

}

void p4bpp_tables()

{

   for (unsigned pass = 0; pass < 2; pass++) {

      for (unsigned bt = 0; bt < 0x100; bt++) {

         unsigned lf = ((bt >> 3) & 7) + ((bt >> 4) & 8);

         unsigned rt = (bt & 7) + ((bt >> 3) & 8);

         if (temp.obpp == 8) {

            t.p4bpp8[pass][bt] = (t.sctab8[pass][0x0F+0x10*rt] & 0xFFFF) +

                                   (t.sctab8[pass][0x0F+0x10*lf] & 0xFFFF0000);

         } else if (temp.obpp == 16) {

            t.p4bpp16[pass][bt*2+0] = t.sctab16[pass][0x03+4*rt],

            t.p4bpp16[pass][bt*2+1] = t.sctab16[pass][0x03+4*lf];

         } else /* if (temp.obpp == 32) */ {

            t.p4bpp32[pass][bt*2+0] = t.sctab32[pass][0x100+rt],

            t.p4bpp32[pass][bt*2+1] = t.sctab32[pass][0x100+lf];

         }

      }

   }

}

void atm_zc_tables() // atm,profi screens (use normal zx-flash)

{

   for (unsigned pass = 0; pass < 2; pass++) {

      for (unsigned at = 0; at < 0x100; at++) {

         unsigned pc_attr = colortab[at];

         if (temp.obpp == 8)

            for (unsigned j = 0; j < 4; j++)

               t.zctab8ad[pass][at*4+j] = t.sctab8d[pass][pc_attr*4+j];

         else if (temp.obpp == 16)

            t.zctab16ad[pass][at] = t.sctab16d[pass][pc_attr],

            t.zctab16ad[pass][at+0x100] = t.sctab16d[pass][pc_attr+0x100];

         else /* if (temp.obpp == 32) */

            t.zctab32ad[pass][at] = t.sctab32[pass][pc_attr],

            t.zctab32ad[pass][at+0x100] = t.sctab32[pass][pc_attr+0x100];

      }

   }

   // atm palette mapping (port out to palette index)

   for (unsigned i = 0; i < 0x100; i++) {

      unsigned v = i ^ 0xFF, dst;

      if (conf.mem_model == MM_ATM450)

         dst = // ATM1: --grbGRB => Gg0Rr0Bb

               ((v & 0x20) << 1) | // g

               ((v & 0x10) >> 1) | // r

               ((v & 0x08) >> 3) | // b

               ((v & 0x04) << 5) | // G

               ((v & 0x02) << 3) | // R

               ((v & 0x01) << 1);  // B

      else

         dst = // ATM2: grbG--RB => Gg0Rr0Bb

               ((v & 0x80) >> 1) | // g

               ((v & 0x40) >> 3) | // r

               ((v & 0x20) >> 5) | // b

               ((v & 0x10) << 3) | // G

               ((v & 0x02) << 3) | // R

               ((v & 0x01) << 1);  // B

      t.atm_pal_map[i] = dst;

   }

}

void hires_sc_tables()  // atm,profi screens (use zx-attributes & flash -> paper_bright)

{

   for (unsigned pass = 0; pass < 2; pass++) {

      for (unsigned at = 0; at < 0x100; at++) {

         unsigned pc_attr = (at & 0x80) + (at & 0x38)*2 + (at & 0x40)/8 + (at & 7);

         if (temp.obpp == 8)

            for (unsigned j = 0; j < 16; j++)

               t.zctab8[pass][at*0x10+j] = t.sctab8[pass][pc_attr*0x10+j];

         else if (temp.obpp == 16)

            for (unsigned j = 0; j < 4; j++)

               t.zctab16[pass][at*4+j] = t.sctab16[pass][pc_attr*4+j];

         else /* if (temp.obpp == 32) */

            for (unsigned j = 0; j < 2; j++)

               t.zctab32[pass][at+0x100*j] = t.sctab32[pass][pc_attr+0x100*j];

      }

   }

}

void calc_noflic_16_32()

{

   unsigned at, pass;

   if (temp.obpp == 16) {

      for (pass = 0; pass < 2; pass++) {

         for (at = 0; at < 2*0x100; at++)

            t.sctab16d_nf[pass][at] = (t.sctab16d[pass][at] & temp.shift_mask)/2;

         for (at = 0; at < 4*0x100; at++)

            t.sctab16_nf[pass][at] = (t.sctab16[pass][at] & temp.shift_mask)/2;

         for (at = 0; at < 2*0x100; at++)

            t.p4bpp16_nf[pass][at] = (t.p4bpp16[pass][at] & temp.shift_mask)/2;

      }

   }

   if (temp.obpp == 32) {

      unsigned shift_mask = 0xFEFEFEFE;

      for (pass = 0; pass < 2; pass++) {

         for (at = 0; at < 2*0x100; at++)

            t.sctab32_nf[pass][at] = (t.sctab32[pass][at] & shift_mask)/2;

         for (at = 0; at < 2*0x100; at++)

            t.p4bpp32_nf[pass][at] = (t.p4bpp32[pass][at] & shift_mask)/2;

      }

   }

}

// pal.index => raw video data, shadowed with current scanline pass

unsigned raw_data(unsigned index, unsigned pass, unsigned bpp)

{

   if (bpp == 8)

   {

      if (pass)

      {

         if (!conf.scanbright)

             return 0;

         // palette too small to realize noflic/atari with shaded scanlines

         if (conf.scanbright < 100 && !conf.noflic && !conf.atariset[0])

         {

            if (temp.rflags & RF_PALB)

                index = (index & (index << 1) & 0x92) | ((index ^ 0xFF) & (index >> 1) & 0x49);

            else

                index &= 0x0F;

         }

      }

      return index * 0x01010101;

   }

   unsigned r = pal0[index].peRed, g = pal0[index].peGreen, b = pal0[index].peBlue;

   if (pass)

   {

       r = r * conf.scanbright / 100;

       g = g * conf.scanbright / 100;

       b = b * conf.scanbright / 100;

   }

   if (bpp == 32)

       return WORD4(b,g,r,0);

   // else (bpp == 16)

   if (temp.hi15==0)

       return ((b/8) + ((g/4)<<5) + ((r/8)<<11)) * 0x10001;

   if (temp.hi15==1)

       return ((b/8) + ((g/8)<<5) + ((r/8)<<10)) * 0x10001;

   if (temp.hi15==2)

       return getYUY2(r,g,b);

   return 0;

}

unsigned atari_to_raw(unsigned at, unsigned pass)

{

   unsigned c1 = at/0x10, c2 = at & 0x0F;

   unsigned raw0 = raw_data(t.attrtab[c1+0x100], pass, temp.obpp);

   unsigned raw1 = raw_data(t.attrtab[c2+0x100], pass, temp.obpp);

   if (raw0 == raw1) return raw1;

   if (temp.obpp == 8)

      return (temp.rflags & RF_PALB)? (0x49494949 & ((raw0&raw1)^((raw0^raw1)>>1))) |

                                      (0x92929292 & ((raw0&raw1)|((raw0|raw1)&((raw0&raw1)<<1))))

                                    : (0x0F0F0F0F & raw0) | (0xF0F0F0F0 & raw1);

   return (raw0 & temp.shift_mask)/2 + (raw1 & temp.shift_mask)/2;

}

void pixel_tables()

{

   attr_tables();

   for (unsigned pass = 0; pass < 2; pass++)

   {

      for (unsigned at = 0; at < 0x100; at++)

      {

         unsigned px0 = t.attrtab[at];

         unsigned px1 = t.attrtab[at+0x100];

         unsigned p0 = raw_data(px0, pass, temp.obpp);

         unsigned p1 = raw_data(px1, pass, temp.obpp);

         // sctab32 required for frame resampler in 16-bit mode, so temp.obpp=16 here

         t.sctab32[pass][at] = raw_data(px0, pass, 32);

         t.sctab32[pass][at+0x100] = raw_data(px1, pass, 32);

         // 8 bit

         unsigned j;

         for (j = 0; j < 0x10; j++)

         {

            unsigned mask = (j >> 3)*0xFF + (j & 0x04)*(0xFF00/4) +

                            (j & 0x02)*(0xFF0000/2) + (j & 1)*0xFF000000;

            t.sctab8[pass][j + at*0x10] = (mask & p1) + (~mask & p0);

         }

         for (j = 0; j < 4; j++)

         {

            unsigned mask = (j >> 1)*0xFFFF + (j & 1)*0xFFFF0000;

            t.sctab8d[pass][j+at*4] = (mask & p1) + (~mask & p0);

         }

         t.sctab8q[at] = p0, t.sctab8q[at+0x100] = p1;

         // 16 bit

         for (j = 0; j < 4; j++)

         {

            unsigned mask = (j >> 1)*0xFFFF + (j & 1)*0xFFFF0000;

            t.sctab16[pass][j+at*4] = (mask & p1) + (~mask & p0);

         }

         t.sctab16d[pass][at] = p0, t.sctab16d[pass][at+0x100] = p1;

         unsigned atarimode;

         if (!(temp.rflags & RF_MON) && (atarimode = temp.ataricolors[at]))

         {

            unsigned rawdata[4], i;

            for (i = 0; i < 4; i++) rawdata[i] = atari_to_raw((atarimode >> (8*i)) & 0xFF, pass);

            for (i = 0; i < 16; i++) t.sctab8[pass][at*0x10+i] = rawdata[i/4] + 16*rawdata[i & 3];

            for (i = 0; i < 4; i++) t.sctab8d[pass][at*4+i] = rawdata[i];

            for (i = 0; i < 4; i++) t.sctab16[pass][at*4+i] = rawdata[i];

         }

      }

   }

   p4bpp_tables(); // used for ATM2+ mode0 and Pentagon-4bpp

   if (temp.obpp > 8 && conf.noflic) calc_noflic_16_32();

   if ((temp.rflags & (RF_DRIVER|RF_2X|RF_USEFONT))==(RF_DRIVER|RF_2X) && // render="double"

       (conf.mem_model == MM_ATM450 || conf.mem_model == MM_ATM710 || conf.mem_model == MM_ATM3 || conf.mem_model == MM_PROFI))

      hires_sc_tables();

}

void video_color_tables()

{

   temp.shift_mask = 0xFEFEFEFE; // 32bit, 16bit YUY2

   if (temp.obpp == 16 && temp.hi15==0) temp.shift_mask = 0xF7DEF7DE;

   if (temp.obpp == 16 && temp.hi15==1) temp.shift_mask = 0x7BDE7BDE;

   create_palette();

   pixel_tables();

   make_colortab(0);

   if (temp.rflags & (RF_USEC32 | RF_USE32AS16)) {

      for (unsigned at = 0; at < 0x100; at++) {

         for (unsigned vl = 0; vl <= 0x10; vl++) {

            unsigned br = (at & 0x40) ? 0xFF : 0xBF;

            unsigned c1, c2, res;

            c1 = (at & 1) >> 0, c2 = (at & 0x08) >> 3;

            unsigned b = (c1*vl + c2*(0x10-vl))*br/0x10;

            c1 = (at & 2) >> 1, c2 = (at & 0x10) >> 4;

            unsigned r = (c1*vl + c2*(0x10-vl))*br/0x10;

            c1 = (at & 4) >> 2, c2 = (at & 0x20) >> 5;

            unsigned g = (c1*vl + c2*(0x10-vl))*br/0x10;

            if (temp.rflags & RF_USE32AS16) {

               if (temp.hi15==0) res = (b/8) + ((g/4)<<5) + ((r/8)<<11);

               if (temp.hi15==1) res = (b/8) + ((g/8)<<5) + ((r/8)<<10);

               if (temp.hi15==2) res = getYUY2(r,g,b);

               else res *= 0x10001; // for hi15=0,1

            } else res =  WORD4(b,g,r,0);

            t.c32tab[at][vl] = res;

         }

      }

   }

   setpal(0);

}

void video_timing_tables()

{

   if (conf.frame < 2000)

   {

       conf.frame = 2000;

       cpu.SetTpi(conf.frame);

   }

   if (conf.t_line < 128) conf.t_line = 128;

   conf.nopaper &= 1;

   atrtab = (comp.pEFF7 & EFF7_HWMC) ? t.atrtab_hwmc : t.atrtab;

//   conf.bordersize=2;

//   temp.scx = 384, temp.scy = 300;

   #define p2cc(p) ((p)/4) // Ïåðåâîä âåëè÷èíû â ïèêñåëÿõ â ÷èñëî çíàêîìåñò ñ ó÷åòîì àòðèáóòîâ (êàæäîå çíàêîìåñòî çàíèìàåò 2 áàéòà, áàéò äàííûõ è áàéò àòðèáóòîâ)

   const unsigned width = p2cc(temp.scx); // Øèðèíà ýêðàíà â çíàêîìåñòàõ * 2 (ò.ê. èñïîëüçóþòñÿ ïèêñåëè è àòðèáóòû íà 1 çíàêîìåñòî)

   //temp.vidbufsize = temp.scx*temp.scy/4;

   // make video table

   unsigned mid_lines = 192; // ×èñëî ñòðîê â öåíòðàëüíîé ÷àñòè ýêðàíà (áåç áîðäþðà)

   const unsigned buf_mid = 256; // ×èñëî ïèêñåëåé â öåíòðàëüíîé ÷àñòè ýêðàíà (áåç áîðäþðà)

   // Ðàñ÷åò ðàçìåð áîðäþðà â ïèêñåëÿõ (1 ïèêñåëü = 2 òàêòà)

   temp.b_bottom = temp.b_top = conf.b_top_small, temp.b_left = conf.b_left_small; // border small

   if (conf.bordersize==0) temp.b_top = temp.b_left = 0; // border none

   if (conf.bordersize==2) { temp.b_top = conf.b_top_full; temp.b_left = conf.b_left_full; } // border full