nasm prints a warning if the colon is missing.
Signed-off-by: Mans Rullgard <mans@mansr.com>
%endif
pxor mm7, mm7
movq mm6, [pw_4]
-.nextrow
+.nextrow:
movd mm0, [lum_m4q]
movd mm1, [lum_m3q]
movd mm2, [lum_m2q]
cglobal vector_fmul_reverse, 4,4,2, dst, src0, src1, len
lea lenq, [lend*4 - 2*mmsize]
ALIGN 16
-.loop
+.loop:
%if cpuflag(avx)
vmovaps xmm0, [src1q + 16]
vinsertf128 m0, m0, [src1q], 1
cglobal vector_fmul_add, 5,5,2, dst, src0, src1, src2, len
lea lenq, [lend*4 - 2*mmsize]
ALIGN 16
-.loop
+.loop:
mova m0, [src0q + lenq]
mova m1, [src0q + lenq + mmsize]
mulps m0, m0, [src1q + lenq]
add r0, 4
dec r2
jnz .loop2
-.end
+.end:
RET
; %1 = aligned/unaligned
call hadamard8x8_diff_%1
add r5d, eax
-.done
+.done:
mov eax, r5d
%ifndef m8
ADD rsp, pad
pxor m0, m0 ; mm0 = 0
pxor m7, m7 ; mm7 holds the sum
-.next2lines ; FIXME why are these unaligned movs? pix1[] is aligned
+.next2lines: ; FIXME why are these unaligned movs? pix1[] is aligned
movu m1, [r1 ] ; mm1 = pix1[0][0-15]
movu m2, [r2 ] ; mm2 = pix2[0][0-15]
movu m3, [r1+r3] ; mm3 = pix1[1][0-15]
add rcx, 3
shl r2, cl
sub r4, r2
-.loop
+.loop:
%if mmsize == 8
PSWAPD m0, [r4 + r2 + 4]
mova [r4 + r2 + 4], m0
mov src1q, [srcq+gprsize]
mov srcq, [srcq ]
sub src1q, srcq
-.loop
+.loop:
MOVPS m0, [srcq ]
MOVPS m1, [srcq+src1q ]
MOVPS m3, [srcq +mmsize]
%macro mv0_pixels_mc8 0
lea r4, [r2*2 ]
-.next4rows
+.next4rows:
movq mm0, [r1 ]
movq mm1, [r1+r2]
add r1, r4
mv0_pixels_mc8
REP_RET
-.at_least_one_non_zero
+.at_least_one_non_zero:
%ifidn %2, rv40
%if ARCH_X86_64
mov r7, r5
test r4d, r4d
mov r6, r2 ; dxy = x ? 1 : stride
jne .both_non_zero
-.my_is_zero
+.my_is_zero:
; mx == 0 XOR my == 0 - 1 dimensional filter only
or r4d, r5d ; x + y
pxor m7, m7
psubw m4, m5 ; mm4 = A = 8-x
-.next1drow
+.next1drow:
movq m0, [r1 ] ; mm0 = src[0..7]
movq m2, [r1+r6] ; mm1 = src[1..8]
jne .next1drow
REP_RET
-.both_non_zero ; general case, bilinear
+.both_non_zero: ; general case, bilinear
movd m4, r4d ; x
movd m6, r5d ; y
%ifidn %2, rv40
movq m0, [r1 ] ; mm0 = src[0..7]
movq m1, [r1+1] ; mm1 = src[1..8]
-.next2drow
+.next2drow:
add r1, r2
movq m2, m0
pmullw m6, m2
paddw m6, m0
-.next2rows
+.next2rows:
movd m0, [r1 ]
movd m1, [r1+1]
add r1, r2
punpcklbw m2, m7
pshufw m2, m2, 0x94 ; mm0 = src[0,1,1,2]
-.nextrow
+.nextrow:
add r1, r2
movq m1, m2
pmaddwd m1, m5 ; mm1 = A * src[0,1] + B * src[1,2]
mv0_pixels_mc8
REP_RET
-.at_least_one_non_zero
+.at_least_one_non_zero:
test r5d, r5d
je .my_is_zero
test r4d, r4d
movlhps m7, m7
movlhps m6, m6
-.next2rows
+.next2rows:
movq m1, [r1+r2*1 ]
movq m2, [r1+r2*1+1]
movq m3, [r1+r2*2 ]
jg .next2rows
REP_RET
-.my_is_zero
+.my_is_zero:
mov r5d, r4d
shl r4d, 8
add r4, 8
pshuflw m7, m7, 0
movlhps m7, m7
-.next2xrows
+.next2xrows:
movq m0, [r1 ]
movq m1, [r1 +1]
movq m2, [r1+r2 ]
jg .next2xrows
REP_RET
-.mx_is_zero
+.mx_is_zero:
mov r4d, r5d
shl r5d, 8
add r5, 8
pshuflw m7, m7, 0
movlhps m7, m7
-.next2yrows
+.next2yrows:
movq m0, [r1 ]
movq m1, [r1+r2 ]
movdqa m2, m1
punpcklbw m0, [r1+1]
pshufw m6, m6, 0
-.next2rows
+.next2rows:
movd m1, [r1+r2*1 ]
movd m3, [r1+r2*2 ]
punpcklbw m1, [r1+r2*1+1]
%macro MV0_PIXELS_MC8 0
lea r4, [r2*3 ]
lea r5, [r2*4 ]
-.next4rows
+.next4rows:
movu m0, [r1 ]
movu m1, [r1+r2 ]
CHROMAMC_AVG m0, [r0 ]
MV0_PIXELS_MC8
REP_RET
-.at_least_one_non_zero
+.at_least_one_non_zero:
mov r6d, 2
test r5d, r5d
je .x_interpolation
mov r6, r2 ; dxy = x ? 1 : stride
test r4d, r4d
jne .xy_interpolation
-.x_interpolation
+.x_interpolation:
; mx == 0 XOR my == 0 - 1 dimensional filter only
or r4d, r5d ; x + y
movd m5, r4d
SPLATW m5, m5 ; mm5 = B = x
psubw m4, m5 ; mm4 = A = 8-x
-.next1drow
+.next1drow:
movu m0, [r1 ] ; mm0 = src[0..7]
movu m2, [r1+r6] ; mm2 = src[1..8]
jne .next1drow
REP_RET
-.xy_interpolation ; general case, bilinear
+.xy_interpolation: ; general case, bilinear
movd m4, r4m ; x
movd m6, r5m ; y
movu m0, [r1 ] ; mm0 = src[0..7]
movu m1, [r1+2] ; mm1 = src[1..8]
-.next2drow
+.next2drow:
add r1, r2
pmullw m2, m0, m4
pmullw m6, m2
paddw m6, m0
-.next2rows
+.next2rows:
MC4_OP m0, m6
MC4_OP m6, m0
sub r3d, 2
pxor m7, m7
pshufw m2, [r1], 0x94 ; mm0 = src[0,1,1,2]
-.nextrow
+.nextrow:
add r1, r2
movq m1, m2
pmaddwd m1, m5 ; mm1 = A * src[0,1] + B * src[1,2]
shl r2d, 2
shl r3d, 2
LOAD_AB aa, bb, r2d, r3d
-.loop
+.loop:
mova p2, [r4+r1]
mova p1, [r4+2*r1]
mova p0, [r4+r5]
mova m0, [pw_2]
shl r2d, 2
shl r3d, 2
-.loop
+.loop:
movu q3, [r0-8]
movu q2, [r0+r1-8]
movu q1, [r0+r1*2-8]
%ifdef PIC
lea picregq, [scan8_mem]
%endif
-.nextblock
+.nextblock:
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6]
IDCT4_ADD r6, r2, r3
-.skipblock
+.skipblock:
inc r5
add r2, 32
cmp r5, 16
%ifdef PIC
lea picregq, [scan8_mem]
%endif
-.nextblock
+.nextblock:
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6+4]
IDCT8_ADD_MMX_END r6 , rsp+8, r3
-.skipblock
+.skipblock:
add r5, 4
add r2, 128
cmp r5, 16
%ifdef PIC
lea picregq, [scan8_mem]
%endif
-.nextblock
+.nextblock:
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
cmp r5, 16
jl .nextblock
REP_RET
-.no_dc
+.no_dc:
mov r6d, dword [r1+r5*4]
add r6, r0
IDCT4_ADD r6, r2, r3
-.skipblock
+.skipblock:
inc r5
add r2, 32
cmp r5, 16
%ifdef PIC
lea picregq, [scan8_mem]
%endif
-.nextblock
+.nextblock:
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
or r6w, word [r2]
mov r6d, dword [r1+r5*4]
add r6, r0
IDCT4_ADD r6, r2, r3
-.skipblock
+.skipblock:
inc r5
add r2, 32
cmp r5, 16
%ifdef PIC
lea picregq, [scan8_mem]
%endif
-.nextblock
+.nextblock:
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
cmp r5, 16
jl .nextblock
REP_RET
-.try_dc
+.try_dc:
movsx r6, word [r2]
test r6, r6
jz .skipblock
%if ARCH_X86_64 == 0
mov r1, r1m
%endif
-.skipblock
+.skipblock:
inc r5
add r2, 32
cmp r5, 16
%ifdef PIC
lea picregq, [scan8_mem]
%endif
-.nextblock
+.nextblock:
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
ADD rsp, pad
RET
-.no_dc
+.no_dc:
mov r6d, dword [r1+r5*4]
add r6, r0
add word [r2], 32
mov r6d, dword [r1+r5*4]
lea r6, [r0+r6+4]
IDCT8_ADD_MMX_END r6 , rsp+8, r3
-.skipblock
+.skipblock:
add r5, 4
add r2, 128
cmp r5, 16
%ifdef PIC
lea picregq, [scan8_mem]
%endif
-.nextblock
+.nextblock:
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
cmp r5, 16
jl .nextblock
REP_RET
-.no_dc
+.no_dc:
INIT_XMM
mov dst2d, dword [r1+r5*4]
add dst2q, r0
%if ARCH_X86_64 == 0
mov r1, r1m
%endif
-.skipblock
+.skipblock:
add r5, 4
add r2, 128
cmp r5, 16
INIT_MMX
h264_idct_add8_mmx_plane:
-.nextblock
+.nextblock:
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
or r6w, word [r2]
add r0, dword [r1+r5*4]
%endif
IDCT4_ADD r0, r2, r3
-.skipblock
+.skipblock:
inc r5
add r2, 32
test r5, 3
call h264_idct_add8_mmx_plane
RET
-h264_idct_add8_mmx2_plane
-.nextblock
+h264_idct_add8_mmx2_plane:
+.nextblock:
movzx r6, byte [scan8+r5]
movzx r6, byte [r4+r6]
test r6, r6
test r5, 3
jnz .nextblock
rep ret
-.try_dc
+.try_dc:
movsx r6, word [r2]
test r6, r6
jz .skipblock
add r0, dword [r1+r5*4]
%endif
DC_ADD_MMX2_OP movh, r0, r3, r6
-.skipblock
+.skipblock:
inc r5
add r2, 32
test r5, 3
add r0, r0m
%endif
call h264_add8x4_idct_sse2
-.cycle%1end
+.cycle%1end:
%if %1 < 7
add r2, 64
%endif
%endif
call h264_add8x4_idct_sse2
jmp .cycle%1end
-.try%1dc
+.try%1dc:
movsx r0, word [r2 ]
or r0w, word [r2+32]
jz .cycle%1end
add r0, r0m
%endif
call h264_idct_dc_add8_mmx2
-.cycle%1end
+.cycle%1end:
%if %1 < 7
add r2, 64
%endif
%endif
call h264_add8x4_idct_sse2
jmp .cycle%1end
-.try%1dc
+.try%1dc:
movsx r0, word [r2 ]
or r0w, word [r2+32]
jz .cycle%1end
add r0, dword [r1+(%1&1)*8+64*(1+(%1>>1))]
%endif
call h264_idct_dc_add8_mmx2
-.cycle%1end
+.cycle%1end:
%if %1 == 1
add r2, 384+64
%elif %1 < 3
; h264_idct_add16intra(pixel *dst, const int *block_offset, dctcoef *block, int stride, const uint8_t nnzc[6*8])
;-----------------------------------------------------------------------------
%macro AC 1
-.ac%1
+.ac%1:
mov r5d, [r1+(%1+0)*4]
call add4x4_idct %+ SUFFIX
mov r5d, [r1+(%1+1)*4]
%endif
mov r4, 8
-.loop
+.loop:
mova m3, m0 ; b[0..7]
mova m4, m2 ; b[8..15]
psraw m3, 5
mov r4, 4
ALIGN 16
-.loop
+.loop:
%if mmsize == 16
mova m3, m0 ; b[0..7]
paddw m0, m1
psrlq mm5, 56
psllq mm5, 56
pxor mm1, mm5
-.body
+.body:
PRED4x4_LOWPASS mm0, mm2, mm1, mm3, mm5
psadbw mm7, mm0
paddw mm7, [pw_4]
jz .fix_lt_2
test r2, r2
jz .fix_tr_1
-.body
+.body:
lea r1, [r0+r3*2]
PRED4x4_LOWPASS mm6, mm2, mm1, mm3, mm5
pxor mm0, mm0
psrlq mm5, 56
psllq mm5, 56
pxor mm1, mm5
-.body
+.body:
PRED4x4_LOWPASS mm0, mm2, mm1, mm3, mm5
%rep 3
movq [r0+r3*1], mm0
psllq mm5, 56
pxor mm1, mm5
jmp .do_top
-.body
+.body:
lea r1, [r0+r3*2]
movq mm1, mm7
movq mm7, mm5
jz .fix_lt_2
test r2, r2
jz .fix_tr_1
-.do_top
+.do_top:
PRED4x4_LOWPASS mm6, mm2, mm1, mm3, mm5
lea r1, [r0+r3*2]
movq mm2, mm6
jz .fix_lt_2
test r2, r2
jz .fix_tr_1
-.do_top
+.do_top:
PRED4x4_LOWPASS mm6, mm2, mm1, mm3, mm5
lea r1, [r0+r3*2]
movq2dq xmm4, mm6
%else
%define p16 [pw_16]
%endif
-.nextrow
+.nextrow:
%if %0 == 4
movu m2, [r1-4]
movu m3, [r1-2]
%macro MC10 3-4
cglobal_mc %1, %2, mc10, %3, 3,5,9
mov r4, r1
-.body
+.body:
mov r3d, %3
mova m1, [pw_pixel_max]
%if num_mmregs > 8
%else
%define p16 [pw_16]
%endif
-.nextrow
+.nextrow:
%if %0 == 4
movu m2, [r1-4]
movu m3, [r1-2]
%macro MC01 3
cglobal_mc %1, %2, mc01, %3, 3,5,8
mov r4, r1
-.body
+.body:
PRELOAD_V
sub r4, r2
; this REALLY needs x86_64
cglobal_mc %1, %2, mc11, %3, 3,6,8
mov r4, r1
-.body
+.body:
PRELOAD_V
sub r0, r2
call put_hv%3_10_%1
xor r4d, r4d
-.body
+.body:
mov r3d, %3
pxor m0, m0
mova m7, [pw_pixel_max]
mov r3d, %2
xor r4d, r4d
mova m6, [pad20]
-.nextrow
+.nextrow:
movu m2, [r5-4]
movu m3, [r5-2]
movu m4, [r5+0]
%macro MC21 3
cglobal_mc %1, %2, mc21, %3, 3,7,12
mov r5, r1
-.body
+.body:
%define PAD mmsize*8*3*2 ; SIZE*16*4*sizeof(pixel)
mov r6, rsp ; backup stack pointer
and rsp, ~(mmsize-1) ; align stack
INIT_MMX
cglobal h264_weight_16_mmx2, 6, 6, 0
WEIGHT_SETUP
-.nextrow
+.nextrow:
WEIGHT_OP 0, 4
mova [r0 ], m0
WEIGHT_OP 8, 12
%macro WEIGHT_FUNC_MM 3
cglobal h264_weight_%1_%3, 6, 6, %2
WEIGHT_SETUP
-.nextrow
+.nextrow:
WEIGHT_OP 0, mmsize/2
mova [r0], m0
add r0, r1
WEIGHT_SETUP
sar r2d, 1
lea r3, [r1*2]
-.nextrow
+.nextrow:
WEIGHT_OP 0, r1
movh [r0], m0
%if mmsize == 16
cglobal h264_biweight_16_mmx2, 7, 8, 0
BIWEIGHT_SETUP
movifnidn r3d, r3m
-.nextrow
+.nextrow:
BIWEIGHT_STEPA 0, 1, 0
BIWEIGHT_STEPA 1, 2, 4
BIWEIGHT_STEPB
cglobal h264_biweight_%1_%3, 7, 8, %2
BIWEIGHT_SETUP
movifnidn r3d, r3m
-.nextrow
+.nextrow:
BIWEIGHT_STEPA 0, 1, 0
BIWEIGHT_STEPA 1, 2, mmsize/2
BIWEIGHT_STEPB
movifnidn r3d, r3m
sar r3, 1
lea r4, [r2*2]
-.nextrow
+.nextrow:
BIWEIGHT_STEPA 0, 1, 0
BIWEIGHT_STEPA 1, 2, r2
BIWEIGHT_STEPB
BIWEIGHT_SSSE3_SETUP
movifnidn r3d, r3m
-.nextrow
+.nextrow:
movh m0, [r0]
movh m2, [r0+8]
movh m3, [r1+8]
sar r3, 1
lea r4, [r2*2]
-.nextrow
+.nextrow:
movh m0, [r0]
movh m1, [r1]
movh m2, [r0+r2]
; int weight, int offset);
;-----------------------------------------------------------------------------
%macro WEIGHT_PROLOGUE 0
-.prologue
+.prologue:
PROLOGUE 0,6,8
movifnidn r0, r0mp
movifnidn r1d, r1m
cglobal h264_weight_16_10_%1
WEIGHT_PROLOGUE
WEIGHT_SETUP %1
-.nextrow
+.nextrow:
WEIGHT_OP %1, 0
mova [r0 ], m5
WEIGHT_OP %1, 16
cglobal h264_weight_8_10_%1
WEIGHT_PROLOGUE
WEIGHT_SETUP %1
-.nextrow
+.nextrow:
WEIGHT_OP %1, 0
mova [r0], m5
add r0, r1
sar r2d, 1
WEIGHT_SETUP %1
lea r3, [r1*2]
-.nextrow
+.nextrow:
WEIGHT_OP %1, 0, r1
movh [r0], m5
movhps [r0+r1], m5
%endif
%macro BIWEIGHT_PROLOGUE 0
-.prologue
+.prologue:
PROLOGUE 0,8,8
movifnidn r0, r0mp
movifnidn r1, r1mp
cglobal h264_biweight_16_10_%1
BIWEIGHT_PROLOGUE
BIWEIGHT_SETUP %1
-.nextrow
+.nextrow:
BIWEIGHT %1, 0
mova [r0 ], m0
BIWEIGHT %1, 16
cglobal h264_biweight_8_10_%1
BIWEIGHT_PROLOGUE
BIWEIGHT_SETUP %1
-.nextrow
+.nextrow:
BIWEIGHT %1, 0
mova [r0], m0
add r0, r2
BIWEIGHT_SETUP %1
sar r3d, 1
lea r4, [r2*2]
-.nextrow
+.nextrow:
BIWEIGHT %1, 0, r2
movh [r0 ], m0
movhps [r0+r2], m0
mov r3, rsp
mov r6, 11
-.nextrow
+.nextrow:
DIAG4 r1, -1, 0, 1, 2, r3
add r3, 8
add r1, r2
lea r3, [rsp+8]
mov r6, 8
-.nextcol
+.nextcol:
DIAG4 r3, -8, 0, 8, 16, r0
add r3, 8
add r0, r2
mova m6, [sixtap_filter_hb+mxq*8-32]
mova m7, [sixtap_filter_hb+mxq*8-16]
-.nextrow
+.nextrow:
movu m0, [srcq-2]
mova m1, m0
mova m2, m0
mova m5, [fourtap_filter_hb+mxq-16] ; set up 4tap filter in bytes
mova m6, [fourtap_filter_hb+mxq]
-.nextrow
+.nextrow:
movu m0, [srcq-1]
mova m1, m0
pshufb m0, m3
movh m2, [srcq+2*srcstrideq]
add srcq, srcstrideq
-.nextrow
+.nextrow:
movh m3, [srcq+2*srcstrideq] ; read new row
mova m4, m0
mova m0, m1
movh m3, [srcq]
movh m4, [srcq+srcstrideq]
-.nextrow
+.nextrow:
movh m5, [srcq+2*srcstrideq] ; read new row
mova m6, m0
punpcklbw m6, m5
movq mm7, [pw_64]
pxor mm6, mm6
-.nextrow
+.nextrow:
movq mm1, [srcq-1] ; (ABCDEFGH) load 8 horizontal pixels
; first set of 2 pixels
movq mm7, [pw_64]
pxor mm3, mm3
-.nextrow
+.nextrow:
movq mm1, [srcq-2] ; (ABCDEFGH) load 8 horizontal pixels
; first set of 2 pixels
mova m8, [mxq+32]
mova m9, [mxq+48]
%endif
-.nextrow
+.nextrow:
movq m0, [srcq-1]
movq m1, [srcq-0]
movq m2, [srcq+1]
mova m12, [mxq+64]
mova m13, [mxq+80]
%endif
-.nextrow
+.nextrow:
movq m0, [srcq-2]
movq m1, [srcq-1]
movq m2, [srcq-0]
punpcklbw m1, m7
punpcklbw m2, m7
-.nextrow
+.nextrow:
; first calculate negative taps (to prevent losing positive overflows)
movh m4, [srcq+2*srcstrideq] ; read new row
punpcklbw m4, m7
punpcklbw m3, m7
punpcklbw m4, m7
-.nextrow
+.nextrow:
; first calculate negative taps (to prevent losing positive overflows)
mova m5, m1
pmullw m5, [myq+16]
mova m5, [bilinear_filter_vw+myq-1*16]
neg myq
mova m4, [bilinear_filter_vw+myq+7*16]
-.nextrow
+.nextrow:
movh m0, [srcq+srcstrideq*0]
movh m1, [srcq+srcstrideq*1]
movh m3, [srcq+srcstrideq*2]
mova m5, [bilinear_filter_vw+mxq-1*16]
neg mxq
mova m4, [bilinear_filter_vw+mxq+7*16]
-.nextrow
+.nextrow:
movh m0, [srcq+srcstrideq*0+0]
movh m1, [srcq+srcstrideq*0+1]
movh m2, [srcq+srcstrideq*1+0]
%endif
pxor m4, m4
mova m3, [bilinear_filter_vb+myq-16]
-.nextrow
+.nextrow:
movh m0, [srcq+srcstrideq*0]
movh m1, [srcq+srcstrideq*1]
movh m2, [srcq+srcstrideq*2]
pxor m4, m4
mova m2, [filter_h2_shuf]
mova m3, [bilinear_filter_vb+mxq-16]
-.nextrow
+.nextrow:
movu m0, [srcq+srcstrideq*0]
movu m1, [srcq+srcstrideq*1]
pshufb m0, m2
%endif
%if mmsize == 8 ; mmx / mmxext
-.next8px
+.next8px:
%endif
%ifidn %1, v
; read 4 half/full rows of pixels
mov src0q, [src0q]
add src0q, lenq
neg lenq
-.loop
+.loop:
; for x86-32 with 7-8 channels we do not have enough gp registers for all src
; pointers, so we have to load some of them from the stack each time
%define copy_src_from_stack ARCH_X86_32 && in_channels >= 7 && %%i >= 5
cglobal vector_fmul, 4,4,2, dst, src0, src1, len
lea lenq, [lend*4 - 2*mmsize]
ALIGN 16
-.loop
+.loop:
mova m0, [src0q + lenq]
mova m1, [src0q + lenq + mmsize]
mulps m0, m0, [src1q + lenq]
%endif
%endif
lea lenq, [lend*4-2*mmsize]
-.loop
+.loop:
mulps m1, m0, [srcq+lenq ]
mulps m2, m0, [srcq+lenq+mmsize]
addps m1, m1, [dstq+lenq ]