view release on metacpan or  search on metacpan

src/Source/LibJXR/image/encode/strenc_x86.c  view on Meta::CPAN

        pxor xmm2, xmm2
        pxor xmm6, xmm6
        psubd xmm1, xmm7    // g -= offset
        psubd xmm5, xmm7
        psubd xmm2, xmm0    // r = -r
        psubd xmm6, xmm4

        movntdq [edi + 32], xmm1
        movntdq [edi + 48], xmm5
        movntdq [edi + ebx + 32], xmm2
        movntdq [edi + ebx + 48], xmm6

        //================
        add edi, 256                    // pbYCoCg += 256
        add ebp, 12                     // pbRGB += 12
        jnz Loop1

        //================
        add dword ptr [esp + 8], 64     // pbYCoCg += 64
        sub dword ptr [esp + 12], 1     // --cLoop0
        mov [esp + 4], esi              // pbRGB += cbRGB * 4
        jnz Loop0

        //================
        mov esp, [esp + 20]
        pop edi
        pop esi
        pop ebx
        pop ebp
        ret 20
    }
}

Int inputMBRow_RGB24_6(CWMImageStrCodec* pSC)
{
    const U8* const pbRGB = (U8*)pSC->WMIBI.pv;
    const size_t cbRGB = pSC->WMIBI.cbStride;

    U8* const pbY = (U8*)pSC->p1MBbuffer[0];
    U8* const pbU = (U8*)pSC->p1MBbuffer[1];
    // U8* const pbV = (U8*)pSC->p1MBbuffer[2];

    const size_t cmbColumn = (pSC->WMII.cWidth + 15) / 16;

    assert(BD_8 == pSC->WMII.bdBitDepth);
    assert(CF_RGB == pSC->WMII.cfColorFormat);
    assert(24 == pSC->WMII.cBitsPerUnit);
    assert(pSC->WMII.bRGB);
    assert(pSC->m_param.bScaledArith);
    assert(pbU - pbY == pbV - pbU);

    RGB24_6(pbRGB + cbRGB * 0, cbRGB, pbY, pbU - pbY, cmbColumn);
    return ICERR_OK;
}
#endif

//================================
#if defined(WMP_OPT_QT)
#if 0
Int quantizeMacroblock(CWMImageStrCodec* pSC)
{
    assert(BD_8 == pSC->WMII.bdBitDepth);
    assert(YUV_444 == pSC->m_param.cfColorFormat);
    assert(pSC->m_param.bScaledArith);
    assert(3 == pSC->m_param.cNumChannels);
    assert(SB_ALL == pSC->WMISCP.sbSubband);

    CWMITile* pTile = pSC->pTile + pSC->cTileColumn;
    CWMIMBInfo* pMBInfo = &pSC->MBInfo;
    int iChannel, i, j;

    __m128 owQT[2];

    

    for (iChannel = 0; iChannel < 3; iChannel ++) {
        CWMIQuantizer* pQPDC = pTile->pQuantizerDC[iChannel];
        CWMIQuantizer* pQPLP = pTile->pQuantizerLP[iChannel] + pMBInfo->iQIndexLP;
        CWMIQuantizer* pQPHP = pTile->pQuantizerHP[iChannel] + pMBInfo->iQIndexHP;

        __m128 owQT[4] = {
            {pQPDC->f1_QP, pQPHP->f1_QP, pQPHP->f1_QP, pQPHP->f1_QP,},
            {pQPLP->f1_QP, pQPHP->f1_QP, pQPHP->f1_QP, pQPHP->f1_QP,},
        };

        owQT[0].m128_f32[0] = pQPDC->f1_QP;
        owQT[0].m128_f32[1] = pQPHP->f1_QP;
        owQT[0].m128_f32[2] = pQPHP->f1_QP;
        owQT[0].m128_f32[3] = pQPHP->f1_QP;
        owQT[1].m128_f32[0] = pQPDC->f1_QP;
        owQT[1].m128_f32[1] = pQPHP->f1_QP;
        owQT[1].m128_f32[2] = pQPHP->f1_QP;
        owQT[1].m128_f32[3] = pQPHP->f1_QP;
        
        
        

        for(j = 0; j < 16; j ++){
            PixelI* pData = pSC->pPlane[iChannel] + blkOffset[j];

            if(j == 0) // DC
                pData[0] = (pQPDC->iMan == 0 ? QUANT_Mulless(pData[0], pQPDC->iOffset, pQPDC->iExp) : QUANT(pData[0], pQPDC->iOffset, pQPDC->iMan, pQPDC->iExp));
            else // LP
                pData[0] = (pQPLP->iMan == 0 ? QUANT_Mulless(pData[0], pQPLP->iOffset, pQPLP->iExp) : QUANT(pData[0], pQPLP->iOffset, pQPLP->iMan, pQPLP->iExp));

            // quantize HP
            for(i = 1; i < 16; i ++)
                pData[i] = (pQPHP->iMan == 0 ? QUANT_Mulless(pData[i], pQPHP->iOffset, pQPHP->iExp) : QUANT(pData[i], pQPHP->iOffset, pQPHP->iMan, pQPHP->iExp));
        }
    }
    
    for (iChannel = 0; iChannel < 3; iChannel ++) {
        I32* pDC = pSC->MBInfo.iBlockDC[iChannel];
        PixelI* pData = pSC->pPlane[iChannel];

        for(i = 0; i < 16; i ++){
            pDC[i] = pData[dctIndex[2][i]];
        }
    }