Annotation of quake2/linux/snd_mixa.s, revision 1.1.1.1

1.1       root        1: //
                      2: // snd_mixa.s
                      3: // x86 assembly-language sound code
                      4: //
                      5: 
                      6: #include "qasm.h"
                      7: 
                      8: #if    id386
                      9: 
                     10:        .text
                     11: 
                     12: //----------------------------------------------------------------------
                     13: // 8-bit sound-mixing code
                     14: //----------------------------------------------------------------------
                     15: 
                     16: #define ch             4+16
                     17: #define sc             8+16
                     18: #define count  12+16
                     19: 
                     20: .globl C(S_PaintChannelFrom8)
                     21: C(S_PaintChannelFrom8):
                     22:        pushl   %esi                            // preserve register variables
                     23:        pushl   %edi
                     24:        pushl   %ebx
                     25:        pushl   %ebp
                     26: 
                     27: //     int     data;
                     28: //     short   *lscale, *rscale;
                     29: //     unsigned char *sfx;
                     30: //     int             i;
                     31: 
                     32:        movl    ch(%esp),%ebx
                     33:        movl    sc(%esp),%esi
                     34: 
                     35: //     if (ch->leftvol > 255)
                     36: //             ch->leftvol = 255;
                     37: //     if (ch->rightvol > 255)
                     38: //             ch->rightvol = 255;
                     39:        movl    ch_leftvol(%ebx),%eax
                     40:        movl    ch_rightvol(%ebx),%edx
                     41:        cmpl    $255,%eax
                     42:        jna             LLeftSet
                     43:        movl    $255,%eax
                     44: LLeftSet:
                     45:        cmpl    $255,%edx
                     46:        jna             LRightSet
                     47:        movl    $255,%edx
                     48: LRightSet:
                     49: 
                     50: //     lscale = snd_scaletable[ch->leftvol >> 3];
                     51: //     rscale = snd_scaletable[ch->rightvol >> 3];
                     52: //     sfx = (signed char *)sc->data + ch->pos;
                     53: //     ch->pos += count;
                     54:        andl    $0xF8,%eax
                     55:        addl    $(sfxc_data),%esi
                     56:        andl    $0xF8,%edx
                     57:        movl    ch_pos(%ebx),%edi
                     58:        movl    count(%esp),%ecx
                     59:        addl    %edi,%esi
                     60:        shll    $7,%eax
                     61:        addl    %ecx,%edi
                     62:        shll    $7,%edx
                     63:        movl    %edi,ch_pos(%ebx)
                     64:        addl    $(C(snd_scaletable)),%eax
                     65:        addl    $(C(snd_scaletable)),%edx
                     66:        subl    %ebx,%ebx
                     67:        movb    -1(%esi,%ecx,1),%bl
                     68: 
                     69:        testl   $1,%ecx
                     70:        jz              LMix8Loop
                     71: 
                     72:        movl    (%eax,%ebx,4),%edi
                     73:        movl    (%edx,%ebx,4),%ebp
                     74:        addl    C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size),%edi
                     75:        addl    C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size),%ebp
                     76:        movl    %edi,C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size)
                     77:        movl    %ebp,C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size)
                     78:        movb    -2(%esi,%ecx,1),%bl
                     79: 
                     80:        decl    %ecx
                     81:        jz              LDone
                     82: 
                     83: //     for (i=0 ; i<count ; i++)
                     84: //     {
                     85: LMix8Loop:
                     86: 
                     87: //             data = sfx[i];
                     88: //             paintbuffer[i].left += lscale[data];
                     89: //             paintbuffer[i].right += rscale[data];
                     90:        movl    (%eax,%ebx,4),%edi
                     91:        movl    (%edx,%ebx,4),%ebp
                     92:        addl    C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size),%edi
                     93:        addl    C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size),%ebp
                     94:        movb    -2(%esi,%ecx,1),%bl
                     95:        movl    %edi,C(paintbuffer)+psp_left-psp_size(,%ecx,psp_size)
                     96:        movl    %ebp,C(paintbuffer)+psp_right-psp_size(,%ecx,psp_size)
                     97: 
                     98:        movl    (%eax,%ebx,4),%edi
                     99:        movl    (%edx,%ebx,4),%ebp
                    100:        movb    -3(%esi,%ecx,1),%bl
                    101:        addl    C(paintbuffer)+psp_left-psp_size*2(,%ecx,psp_size),%edi
                    102:        addl    C(paintbuffer)+psp_right-psp_size*2(,%ecx,psp_size),%ebp
                    103:        movl    %edi,C(paintbuffer)+psp_left-psp_size*2(,%ecx,psp_size)
                    104:        movl    %ebp,C(paintbuffer)+psp_right-psp_size*2(,%ecx,psp_size)
                    105: 
                    106: //     }
                    107:        subl    $2,%ecx
                    108:        jnz             LMix8Loop
                    109: 
                    110: LDone:
                    111:        popl    %ebp
                    112:        popl    %ebx
                    113:        popl    %edi
                    114:        popl    %esi
                    115: 
                    116:        ret
                    117: 
                    118: 
                    119: //----------------------------------------------------------------------
                    120: // Transfer of stereo buffer to 16-bit DMA buffer code
                    121: //----------------------------------------------------------------------
                    122: 
                    123: .globl C(S_WriteLinearBlastStereo16)
                    124: C(S_WriteLinearBlastStereo16):
                    125:        pushl   %edi
                    126:        pushl   %ebx
                    127: 
                    128: //     int             i;
                    129: //     int             val;
                    130:        movl    C(snd_linear_count),%ecx
                    131:        movl    C(snd_p),%ebx
                    132:        movl    C(snd_out),%edi
                    133: 
                    134: //     for (i=0 ; i<snd_linear_count ; i+=2)
                    135: //     {
                    136: LWLBLoopTop:
                    137: 
                    138: //             val = (snd_p[i]*snd_vol)>>8;
                    139: //             if (val > 0x7fff)
                    140: //                     snd_out[i] = 0x7fff;
                    141: //             else if (val < (short)0x8000)
                    142: //                     snd_out[i] = (short)0x8000;
                    143: //             else
                    144: //                     snd_out[i] = val;
                    145:        movl    -8(%ebx,%ecx,4),%eax
                    146:        sarl    $8,%eax
                    147:        cmpl    $0x7FFF,%eax
                    148:        jg              LClampHigh
                    149:        cmpl    $0xFFFF8000,%eax
                    150:        jnl             LClampDone
                    151:        movl    $0xFFFF8000,%eax
                    152:        jmp             LClampDone
                    153: LClampHigh:
                    154:        movl    $0x7FFF,%eax
                    155: LClampDone:
                    156: 
                    157: //             val = (snd_p[i+1]*snd_vol)>>8;
                    158: //             if (val > 0x7fff)
                    159: //                     snd_out[i+1] = 0x7fff;
                    160: //             else if (val < (short)0x8000)
                    161: //                     snd_out[i+1] = (short)0x8000;
                    162: //             else
                    163: //                     snd_out[i+1] = val;
                    164:        movl    -4(%ebx,%ecx,4),%edx
                    165:        sarl    $8,%edx
                    166:        cmpl    $0x7FFF,%edx
                    167:        jg              LClampHigh2
                    168:        cmpl    $0xFFFF8000,%edx
                    169:        jnl             LClampDone2
                    170:        movl    $0xFFFF8000,%edx
                    171:        jmp             LClampDone2
                    172: LClampHigh2:
                    173:        movl    $0x7FFF,%edx
                    174: LClampDone2:
                    175:        shll    $16,%edx
                    176:        andl    $0xFFFF,%eax
                    177:        orl             %eax,%edx
                    178:        movl    %edx,-4(%edi,%ecx,2)
                    179: 
                    180: //     }
                    181:        subl    $2,%ecx
                    182:        jnz             LWLBLoopTop
                    183: 
                    184: //     snd_p += snd_linear_count;
                    185: 
                    186:        popl    %ebx
                    187:        popl    %edi
                    188: 
                    189:        ret
                    190: 
                    191: 
                    192: #endif // id386
                    193: 

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.