Базовые примитивы / Графика / Форум / Alikberov / GameDev.ru

− Скрыть

Потратил целые сутки на разработку этого алгоритма. Использование mmx-инструкций сократило число строк до 66, а в последствии - до 52. Чего не скажешь о количество времени, потраченного на разработку и отладку.
Итак, аналогично функции WinAPI-LineDDA, этот код генерирует POINT массив. Пример вызова функции представлен ниже.
К сожалению, mmx-командами балуюсь не так часто и практический опыт довольно мал. Потому, подозреваю, что на несколько инструкций код можно было бы сократить. Ну, это дело дальнейщей оптимизации...

+ LineToTable(...): No DIV instruction

+ Bitmap in four-sided polygon

− Скрыть

Sample

+ LineToPixel(...)

− Скрыть

//  Input:
//      bi - Bitmap Information structure
//      dst- Destination bitmap array of RGB-quad (32bpp)
//      x1,y1-x2,y2 - Line from x1,y1 to x2,y2
//      src- Source array of pixels
//      len  - Width of source line
//  Options:
//      len < 0: Write-back pixels from *dst to *src
//      bi.biClrUsed & 0xFF000000: Draw pixels with null-Alpha only
long    LineToPixel_mmx(BITMAPINFOHEADER *bi, int x1, int y1, int x2, int y2, Pixel32 *dst, Pixel32 *src, int len) {
_asm {
    movq    mm2,x2  //#1    mm2 = y2,x2
    psubd   mm2,x1  //      mm2 -= y1,x1
    pxor    mm0,mm0
    pcmpgtd mm0,mm2 //      y2,x2 < 0
    pxor    mm2,mm0
    psubd   mm2,mm0 //      mm2 = abs(y2-y1,x2-x1)
    pcmpeqd mm1,mm1
    pslld   mm0,1
    psubd   mm0,mm1 //      mm0 = sgn(y2-y1,x2-x1)
    movq    mm3,mm2
    psrlq   mm3,32
punpckldq   mm3,mm2
    movq    mm4,mm2
    pcmpgtd mm4,mm3
    movq    mm1,mm4
    pandn   mm1,mm0
    pand    mm0,mm4 //      mm0 = master direction, mm1 = slave direction
punpckldq   mm4,mm4
    pand    mm2,mm4
    pandn   mm4,mm3
    por     mm2,mm4 //#21   mm2 = line length : minimum
    movq    mm5,mm2
    psrlq   mm5,32
    movq    mm4,x1
    movq    mm3,mm5
    psrld   mm3,1
    movd    y1,mm2
    mov     edi,src
    mov     eax,len
    mov     ecx,eax
    neg     eax
    cmovs   eax,ecx
    xor     edx,edx
    div     y1
    mov     len,eax
    xor     eax,eax
    div     y1
    xchg    eax,bi
    mov     edx,0x80000000
    cmp     BITMAPINFOHEADER[eax.biClrUsed],0x01000000
    mov     esi,BITMAPINFOHEADER[eax.biWidth]
    mov     eax,BITMAPINFOHEADER[eax.biHeight]
    lea     eax,[eax+edx-1]
    mov     y2,eax
    lea     eax,[esi+edx-1]
    mov     x2,eax
    sbb     eax,eax
    and     eax,0xFF000000
    xor     eax,0xFF000000
    mov     x1,eax
    shl     esi,18
    add     esi,4
    shr     ecx,31
    shr     ecx,1
    jc      L2
    shl     len,2
    xchg    esi,edi
L1: pcmpeqd mm6,mm6 //#58
    pslld   mm6,31
    paddd   mm6,mm4
    pcmpgtd mm6,x2
    psrlq   mm6,16
    movd    ebx,mm6
    and     ebx,ebx
    movd    mm6,edi
    movq    mm7,mm4
packssdw    mm7,mm7
    pmaddwd mm7,mm6
    paddd   mm7,dst
    movd    ebx,mm7
    cmovne  ebx,src
    mov     eax,[ebx]
    test    eax,x1
    cmove   eax,[esi]
    mov     [ebx],eax
    add     edx,bi
    adc     esi,3
    and     esi,-4
    add     esi,len
    paddd   mm3,mm5
    movq    mm6,mm3
    pcmpgtd mm6,mm2
    movq    mm7,mm2
    pand    mm7,mm6
    psubd   mm3,mm7
punpckldq   mm6,mm6
    pand    mm6,mm1
    paddd   mm4,mm6
    paddd   mm4,mm0
    dec     y1
    jns     L1      //#91
    jmp     End
L2: pcmpeqd mm6,mm6 //#93
    pslld   mm6,31
    paddd   mm6,mm4
    pcmpgtd mm6,x2
    psrlq   mm6,16
    movd    ebx,mm6
    and     ebx,ebx
    movd    mm6,esi
    movq    mm7,mm4
packssdw    mm7,mm7
    pmaddwd mm7,mm6
    paddd   mm7,dst
    movd    ebx,mm7
    cmovne  ebx,src
    mov     eax,[ebx]
    add     edx,bi
    adc     ecx,len
    rep     stosd
    paddd   mm3,mm5
    movq    mm6,mm3
    pcmpgtd mm6,mm2
    movq    mm7,mm2
    pand    mm7,mm6
    psubd   mm3,mm7
punpckldq   mm6,mm6
    pand    mm6,mm1
    paddd   mm4,mm6
    paddd   mm4,mm0
    dec     y1
    jns     L2      //#122
End:emms            //#123
    }
    return 0;
}

− Скрыть

Написал-таки на ассемблере процедуру, которая из Bitmap-источника копирует пиксели в Bitmap-приёмник.
Копируются совершенно произвольные области (не только прямоугольники).
Внимание! Для временного хранения промежуточных данных (таблиц координат хода линии; копируемых пикселей) используется пространство стека. Как показала первая практика использования данного алгоритма, размера стека может не хватить! Необходимо принудительно установить достаточный размер стека. Функция использует величину в 32768 байт (перенос до 8192 пиксела за раз).

+ Аналог PlgBlt

+ Низкоуроувневый вариант

_asm {
  mov    stack,esp    //#1
  mov    ebx,dstl
  call  Len
  mov    dstl1,esp
  mov    dstle1,eax
  mov    ebx,dstr
  call  Len
  mov    dstl2,esp
  mov    dstle2,eax
  mov    ebx,srcl
  call  Len
  mov    srcl1,esp
  mov    srcle1,eax
  mov    ebx,srcr
  call  Len
  mov    srcl2,esp
  mov    srcle2,eax
  cmp    eax,srcle1
  cmovc  eax,srcle1
  cmp    eax,dstle2
  cmovc  eax,dstle2
  cmp    eax,dstle1
  cmovc  eax,dstle1
  mov    dim,eax
  lea    ecx,[eax-0]
  mov    cnt,ecx
L1:  mov    eax,pSrc    //#27
  mov    dst,eax
  mov    eax,srcle1
  mul    cnt
  cdq
  div    dim
  mov    ebx,srcl1
  lea    eax,[ebx+eax*8]
  push  [eax]
  push  [eax+4]
  pop    dword ptr x1+4
  pop    dword ptr x1
  mov    eax,srcle2
  mul    cnt
  cdq
  div    dim
  mov    ebx,srcl2
  lea    eax,[ebx+eax*8]
  push  [eax]
  push  [eax+4]
  pop    dword ptr x2+4
  pop    dword ptr x2
  mov    ebx,bis
  mov    src,esp
  mov    heap,esp
  pxor  mm0,mm0  //#82
  movd  mm7,BITMAPINFOHEADER[ebx.biHeight]
  psllq  mm7,32
  movq  mm6,mm7
  pcmpgtd  mm6,mm0
  pand  mm7,mm6
  movq  mm3,x1
  pxor  mm3,mm6
  paddd  mm3,mm7
  movq  mm2,x2  //#91  mm2 = y2,x2
  pxor  mm2,mm6
  paddd  mm2,mm7
  movq  mm6,mm3
  psubd  mm2,mm3  //    mm2 -= y1,x1
  pcmpgtd  mm0,mm2  //    y2,x2 < 0
  pxor  mm2,mm0
  psubd  mm2,mm0  //    mm2 = abs(y2-y1,x2-x1)
  pcmpeqd  mm1,mm1
  pslld  mm0,1
  psubd  mm0,mm1  //    mm0 = sgn(y2-y1,x2-x1)
  movq  mm3,mm2
  psrlq  mm3,32
punpckldq  mm3,mm2
  movq  mm4,mm2
  pcmpgtd  mm4,mm3
  movq  mm1,mm4
  pandn  mm1,mm0
  pand  mm0,mm4  //    mm0 = master direction, mm1 = slave direction
punpckldq  mm4,mm4
  pand  mm2,mm4
  pandn  mm4,mm3
  por    mm2,mm4  //#113  mm2 = line length : minimum
  movq  mm5,mm2
  psrlq  mm5,32
  movq  mm4,mm6
  movq  mm3,mm5
  psrld  mm3,1
  movd  len,mm2
  movd  dword ptr x1+4,mm2
  cmp    dword ptr x1+4,0
  je    Lex
  psrl  mm7,32
  mov    edx,0x80000000
  cmp    BITMAPINFOHEADER[ebx.biClrUsed],0x01000000
  mov    esi,BITMAPINFOHEADER[ebx.biWidth]
  mov    eax,BITMAPINFOHEADER[ebx.biHeight]
  neg    eax
  cmovs  eax,BITMAPINFOHEADER[ebx.biHeight]
  lea    eax,[eax+edx-1]
  mov    dword ptr x2+4,eax
  lea    eax,[esi+edx-1]
  mov    dword ptr x2,eax
  sbb    eax,eax
  and    eax,0xFF000000
  xor    eax,0xFF000000
  mov    dword ptr x1,eax
  shl    esi,18
  add    esi,4
Li1:movd  mm6,esi  //#188
  movq  mm7,mm4
packssdw  mm7,mm7
  pmaddwd  mm7,mm6
  paddd  mm7,dst
  pcmpeqd  mm6,mm6
  pslld  mm6,31
  paddd  mm6,mm4
  pcmpgtd  mm6,x2
packssdw  mm6,mm6
  pcmpeqd  mm6,mm5
punpckhwd  mm6,mm6
  pand  mm7,mm6
  pandn  mm6,src
  por    mm6,mm7
  movd  ebx,mm6
  mov    eax,[ebx]
  push  eax
  paddd  mm3,mm5
  movq  mm6,mm3
  pcmpgtd  mm6,mm2
  movq  mm7,mm2
  pand  mm7,mm6
  psubd  mm3,mm7
punpckldq  mm6,mm6
  pand  mm6,mm1
  paddd  mm4,mm6
  paddd  mm4,mm0
  dec    dword ptr x1+4
  jns    Li1    //#219
Lex:mov    eax,pDst
  mov    dst,eax
  mov    eax,dstle1
  mul    cnt
  cdq
  div    dim
  mov    ebx,dstl1
  lea    eax,[ebx+eax*8]
  push  [eax]
  push  [eax+4]
  pop    dword ptr x1+4
  pop    dword ptr x1
  mov    eax,dstle2
  mul    cnt
  cdq
  div    dim
  mov    ebx,dstl2
  lea    eax,[ebx+eax*8]
  push  [eax]
  push  [eax+4]
  pop    dword ptr x2+4
  pop    dword ptr x2
  mov    ebx,bid
  pxor  mm0,mm0  //#82
  movd  mm7,BITMAPINFOHEADER[ebx.biHeight]
  psllq  mm7,32
  movq  mm6,mm7
  pcmpgtd  mm6,mm0
  pand  mm7,mm6
  movq  mm3,x1
  pxor  mm3,mm6
  paddd  mm3,mm7
  movq  mm2,x2  //#91  mm2 = y2,x2
  pxor  mm2,mm6
  paddd  mm2,mm7
  movq  mm6,mm3
  psubd  mm2,mm3  //    mm2 -= y1,x1
  pcmpgtd  mm0,mm2  //    y2,x2 < 0
  pxor  mm2,mm0
  psubd  mm2,mm0  //    mm2 = abs(y2-y1,x2-x1)
  pcmpeqd  mm1,mm1
  pslld  mm0,1
  psubd  mm0,mm1  //    mm0 = sgn(y2-y1,x2-x1)
  movq  mm3,mm2
  psrlq  mm3,32
punpckldq  mm3,mm2
  movq  mm4,mm2
  pcmpgtd  mm4,mm3
  movq  mm1,mm4
  pandn  mm1,mm0
  pand  mm0,mm4  //    mm0 = master direction, mm1 = slave direction
punpckldq  mm4,mm4
  pand  mm2,mm4
  pandn  mm4,mm3
  por    mm2,mm4  //#113  mm2 = line length : minimum
  movq  mm5,mm2
  psrlq  mm5,32
  movq  mm4,mm6
  movq  mm3,mm5
  psrld  mm3,1
  movd  dword ptr x1+4,mm2
  cmp    dword ptr x1+4,0
  je    Ley
  psrl  mm7,32
  mov    eax,len
  mov    ecx,eax
  neg    eax
  cmovs  eax,ecx
  cdq
  div    dword ptr x1+4
  mov    len,eax
  xor    eax,eax
  div    dword ptr x1+4
  mov    bi,eax
  mov    edx,0x80000000
  cmp    BITMAPINFOHEADER[ebx.biClrUsed],0x01000000
  mov    esi,BITMAPINFOHEADER[ebx.biWidth]
  mov    eax,BITMAPINFOHEADER[ebx.biHeight]
  neg    eax
  cmovs  eax,BITMAPINFOHEADER[ebx.biHeight]
  lea    eax,[eax+edx-1]
  mov    dword ptr x2+4,eax
  lea    eax,[esi+edx-1]
  mov    dword ptr x2,eax
  sbb    eax,eax
  and    eax,0xFF000000
  xor    eax,0xFF000000
  mov    dword ptr x1,eax
  shl    esi,18
  add    esi,4
  shl    len,2
  xchg  esi,edi
Li2:movd  mm6,edi  //#153
  movq  mm7,mm4
packssdw  mm7,mm7
  pmaddwd  mm7,mm6
  paddd  mm7,dst
  pcmpeqd  mm6,mm6
  pslld  mm6,31
  paddd  mm6,mm4
  pcmpgtd  mm6,x2
  psrlq  mm6,16
  movd  ebx,mm6
  and    ebx,ebx
  movd  ebx,mm7
  cmovne  ebx,esp
  mov    eax,[ebx]
  test  eax,dword ptr x1
  cmove  eax,[esp]
  mov    [ebx],eax
  add    edx,bi
  adc    esp,3
  and    esp,-4
  add    esp,len
  paddd  mm3,mm5
  movq  mm6,mm3
  pcmpgtd  mm6,mm2
  movq  mm7,mm2
  pand  mm7,mm6
  psubd  mm3,mm7
punpckldq  mm6,mm6
  pand  mm6,mm1
  paddd  mm4,mm6
  paddd  mm4,mm0
  dec    dword ptr x1+4
  jns    Li2    //#186
Ley:mov    esp,heap
  dec    cnt
  jns    L1
  jmp    End  /////////////////////////////////////////////#81
Len:movq    mm2,RECT[ebx.right]  //#221  mm2 = y2,x2
  psubd    mm2,RECT[ebx.left]  //    mm2 -= y1,x1
  pxor    mm0,mm0
  pcmpgtd    mm0,mm2  //    y2,x2 < 0
  pxor    mm2,mm0
  psubd    mm2,mm0  //    mm2 = abs(y2-y1,x2-x1)
  pcmpeqd    mm1,mm1
  pslld    mm0,1
  psubd    mm0,mm1  //    mm0 = sgn(y2-y1,x2-x1)
  movq    mm3,mm2
  psrlq    mm3,32
punpckldq    mm3,mm2
  movq    mm4,mm2
  pcmpgtd    mm4,mm3
  movq    mm1,mm4
  pandn    mm1,mm0
  pand    mm0,mm4  //    mm0 = master direction, mm1 = slave direction
punpckldq    mm4,mm4
  pand    mm2,mm4
  pandn    mm4,mm3
  por      mm2,mm4  //#241  mm2 = line length : minimum
  movq    mm5,mm2
  psrlq    mm5,32
  movq    mm4,RECT[ebx.left]
  movq    mm3,mm5
  psrld    mm3,1
  movd    ecx,mm2
  mov      eax,ecx
  pop      edx
Le1:  sub    esp,8
    movq  [esp],mm4//#253
    paddd  mm3,mm5
    movq  mm6,mm3
    pcmpgtd  mm6,mm2
    movq  mm7,mm2
    pand  mm7,mm6
    psubd  mm3,mm7
  punpckldq  mm6,mm6
    pand  mm6,mm1
    paddd  mm4,mm6
    paddd  mm4,mm0
    dec    ecx
    jns    Le1    //#266
  push    edx
  ret
End:emms
  mov      esp,stack
  }
  return 0;
}

Пример вызова:

RECT dl, dr, sl, sr;
char        pBmiDmp[65536] = {0};
BITMAPINFO  *pBmi = (BITMAPINFO *)pBmiDmp;
HBITMAP     hBmp;
HDC         hBmpDC;
PDWORDpBmp;
   ...
    pBmi->bmiHeader.biSize = sizeof BITMAPINFOHEADER;
    pBmi->bmiHeader.biWidth = 1024;
    pBmi->bmiHeader.biHeight = -768; // Можно отрицательную или положительную. Мой алгоритм сам разбирётся... :)
    pBmi->bmiHeader.biPlanes =  1;
    pBmi->bmiHeader.biBitCount = 32;
    pBmi->bmiHeader.biCompression = BI_RGB;
    pBmi->bmiHeader.biSizeImage = pBmi->bmiHeader.biWidth * abs(pBmi->bmiHeader.biHeight) * 4;
    hBmp = CreateDIBSection(NULL, pBmi, DIB_RGB_COLORS, (void **)&pBmp, NULL, NULL);
    hBmpDC = CreateCompatibleDC(NULL); SelectObject(hBmpDC, hBmp);
    // Низкоуровневый вызов
    SetRect(&dl, 640, 0, 640, 480); // Первая и вторая точки четырёхугольника-приёмника
    SetRect(&dr, 1024, 0, 1024, 480); // Третья и четвёртая точки четырёхугольника-приёмника
    SetRect(&sl, 0, 0, 640, 480); // Первая и вторая точки четырёхугольника-источника
    SetRect(&sr, 640, 0, 0, 480); // Третья и четвёртая точки четырёхугольника-источника
    Banner_mmx((BITMAPINFOHEADER*)pBmi, pBmp, &dl, &dr, (BITMAPINFOHEADER*)pBmi, pBmp, &sl, &sr);
    // Или же высокоуровневый вариант:
    pt[0].x = 640, pt[0].y = 0;
    pt[1].x = 1024, pt[1].y = 0;
    pt[2].x = 640, pt[2].y = 480;
    pt[3].x = 1024, pt[3].y = 480;
    pt[4].x = 0, pt[4].y = 0;
    pt[5].x = 640, pt[5].y = 0;
    pt[6].x = 640, pt[6].y = 480;
    pt[7].x = 0, pt[7].y = 480;
    Banner(hBmp, &pt[0], hBmp, &pt[4]);

Suslik
Постоялец

#1
4:37, 13 мая 2014

картинка не соответствует коду. код выполняет только скейлинг, а на картинке - вообще не афинное преобразование. и, ясное дело, ассемблер тут ну никак не упёрся, потому что компилятор сгенерит код лучше(скорее всего хотя бы векторизует что-нибудь).

Alikberov
Постоялец

#2
7:59, 13 мая 2014

Эм...
Во-первых, эту тему я создал для себя в первую очередь. Так как с крахами систем потерял кучу полезного кода собственной разработки. Пусть будет тут как в облаке.
Во-вторых, пишу активно сейчас фильтр и наращиваю его мощь. Этот алгоритм - оттуда и используется в функции, которую отлаживаю:

+ фрагмент кода фильтра

− Скрыть

SQInteger  vdf_x86_QuadBlt(HSQUIRRELVM v) {
  filterData  *pfd = (filterData *)&mfd;
  PAMATEUR_STREAM  pas = &pfd->pad->Stream[0];
  int  x1, y1, x2, y2, x3, y3, x4, y4;
  int  x, y, w, h;
  SQFloat  dstBuffer, dstPart, srcBuffer, srcPart;

  sq_getinteger(v, 2, &x1); sq_getinteger(v, 3, &y1);
  sq_getinteger(v, 4, &x2); sq_getinteger(v, 5, &y2);
  sq_getinteger(v, 6, &x3); sq_getinteger(v, 7, &y3);
  sq_getinteger(v, 8, &x4); sq_getinteger(v, 9, &y4);
  sq_getfloat(v, 10, &dstPart);
  sq_getinteger(v, 11, &x); sq_getinteger(v, 12, &y);
  sq_getinteger(v, 13, &w); sq_getinteger(v, 14, &h);
  sq_getfloat(v, 15, &srcPart);
  dstPart = floor((dstPart - (dstBuffer = floor(dstPart))) * 10.0);
  srcPart = floor((srcPart - (srcBuffer = floor(srcPart))) * 10.0);
  
  PAMATEUR_STREAM  pas1 = &pfd->pad->Stream[(int)dstBuffer];
  PAMATEUR_STREAM  pas2 = &pfd->pad->Stream[(int)srcBuffer];
  Pixel32  *pDst = (Pixel32 *)&pas1->rgba + pas1->bih.biSizeImage / 4 * (int)dstPart;
  Pixel32  *pSrc = (Pixel32 *)&pas2->rgba + pas2->bih.biSizeImage / 4 * (int)srcPart;
  y1 = pas1->bih.biHeight - y1 - 1;
  y2 = pas1->bih.biHeight - y2 - 1;
  y3 = pas1->bih.biHeight - y3 - 1;
  y4 = pas1->bih.biHeight - y4 - 1;
  int  dx31 = x3 - x1, dy31 = y3 - y1;
  int  dx42 = x4 - x2, dy42 = y4 - y2;
  int  i, le;
  le = abs(dx31);
  if(le < abs(dy31))
    le = abs(dy31);
  if(le < abs(dx42))
    le = abs(dx42);
  if(le < abs(dy42))
    le = abs(dy42);
  try{
  for(i = 0; i < le; ++ i) {
    x86_Line(&pas1->bih, pDst,
      x1 + dx31 * i / le, y1 + dy31 * i / le, x2 + dx42 * i / le, y2 + dy42 * i / le,
      &pSrc[x + (y + h * i / le) * pas2->bih.biWidth], w);
  }
  } catch(...){}
  return 1;
}

Какрас делает то, что на картинке (натягивает видео другого потока на боковую стену в ортографической проекции.
До этого тупо использовал в цикле PlgBlt-GDI, но в режиме реального потока видео код сажал машину...
Заменил PlgBlt на свою x86_Line и дело исправилось...
Видео работы фильтра сейчас закачал.
Как видно, иногда происходит сбой и кадры видео исчезают с изображения. Я там запустил три фильма. На заднем плане - лестничная площадка (VirtualDub сутками пишет в режиме DVR через мой фильтр, который вверху ставит тайм-код. И выполняет пробные функции фильтрации Squirrel...)

Mikle
Модератор

#3
12:13, 13 мая 2014

Alikberov
> эту тему я создал для себя в первую очередь. Так как с крахами систем потерял
> кучу полезного кода собственной разработки. Пусть будет тут как в облаке.
Странная мотивация.
Suslik
> на картинке - вообще не афинное преобразование
Разве?

Suslik
Постоялец

#4
14:29, 13 мая 2014

Alikberov
мда, я не так прочитал. код явно выглядит слишком просто для произвольного неафинного преобразования одного четырёхугольника в другой. проблема в том, что преобразование выполняется обратное, а не прямое, поэтому и дыры в результирующем изображении, прямое преобразование более вычислительно затратно.

Alikberov
Постоялец

#5
2:54, 6 июля 2014

Mikle Странная мотивация.

Ну, как видите, на форуме, в отличие от облака, ТС можно и осудить. ;)

Suslik мда, я не так прочитал. код явно выглядит слишком просто для произвольного неафинного преобразования одного четырёхугольника в другой. проблема в том, что преобразование выполняется обратное, а не прямое, поэтому и дыры в результирующем изображении, прямое преобразование более вычислительно затратно.

Это понятно. Но подобных фильтров я не встречал. Вот и пишу. А дыры там или щели - уже дело второе. Мне сейчас главное - набить фильтр как следует.
Он делается прежде всего для линейного монтажа. А погрешности линейных эффектов даже по телевиденью видны в прямом эфире на фоне голубой стены (видео по каналу СГУ).
Мне главное, чтобы работало. Хоть и как попало (как попало - не значит крах при каждом чихе), но быстро (я не китаец, чтобы код построения линии весил гигабайт и требовал час).
P.S.: Эта функция построения линии содержит всего две метки, как видите. Лет 6 тому назад подобный алгоритм содержал десяток меток и не умел натягивать изображение. Вот что значит практика... Учусь тихонечко...
Алгоритм доработал и теперь исключений минимум. Соответственно, дыр минимум. Лищь щели между отдельными линиями изредка...
К тому же, длина одной линии в таких случаях не может достигать миллионов пикселей, а считанные тысячи. Что в последствии даст возможность сначала строить таблицу координат пикселей одной линии, а затем уже в другом цикле рисовать по тем координатам.

P.S.: Написал функцию на ассемблере, которая делает то, что Вы ожидали: Из произвольной области второго четырёхугольника копирует пиксели в другую произвольную область первого четырёхугольника. Дан пример вызова...