src/utils/mbtransquant.c

/*****************************************************************************
 *
 *  XVID MPEG-4 VIDEO CODEC
 *  - MacroBlock transfer and quantization -
 *
 *  Copyright(C) 2002-2001 Michael Militzer <isibaar@xvid.org>
 *               2002-2001 Peter Ross <pross@xvid.org>
 *
 *  This program is an implementation of a part of one or more MPEG-4
 *  Video tools as specified in ISO/IEC 14496-2 standard.  Those intending
 *  to use this software module in hardware or software products are
 *  advised that its use may infringe existing patents or copyrights, and
 *  any such use would be at such party's own risk.  The original
 *  developer of this software module and his/her company, and subsequent
 *  editors and their companies, will have no liability for use of this
 *  software or modifications or derivatives thereof.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 * $Id: mbtransquant.c,v 1.15 2002/10/07 08:11:48 chl Exp $
 *
 ****************************************************************************/

#include <string.h>

#include "../portab.h"
#include "mbfunctions.h"

#include "../global.h"
#include "mem_transfer.h"
#include "timer.h"
#include "../dct/fdct.h"
#include "../dct/idct.h"
#include "../quant/quant_mpeg4.h"
#include "../quant/quant_h263.h"
#include "../encoder.h"

#define MIN(X, Y) ((X)<(Y)?(X):(Y))
#define MAX(X, Y) ((X)>(Y)?(X):(Y))

#define TOOSMALL_LIMIT 3                /* skip blocks having a coefficient sum below this value */

/* this isnt pretty, but its better than 20 ifdefs */

void
MBTransQuantIntra(const MBParam * pParam,
                                  FRAMEINFO * frame,
                                  MACROBLOCK * pMB,
                                  const uint32_t x_pos,
                                  const uint32_t y_pos,
                                  int16_t data[6 * 64],
                                  int16_t qcoeff[6 * 64])
{

        uint32_t stride = pParam->edged_width;
        uint32_t stride2 = stride / 2;
        uint32_t next_block = stride * 8;
        uint32_t i;
        uint32_t iQuant = frame->quant;
        uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
        IMAGE *pCurrent = &frame->image;

        pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
        pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
        pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);

        start_timer();
        transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
        transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
        transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
        transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
        transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
        transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
        stop_transfer_timer();

        start_timer();
        pMB->field_dct = 0;
        if ((frame->global_flags & XVID_INTERLACING) &&
                (x_pos>0) && (x_pos<pParam->mb_width-1) &&
                (y_pos>0) && (y_pos<pParam->mb_height-1)) {
                pMB->field_dct = MBDecideFieldDCT(data);
        }
        stop_interlacing_timer();

        for (i = 0; i < 6; i++) {
                uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);

                start_timer();
                fdct(&data[i * 64]);
                stop_dct_timer();

                if (pParam->m_quant_type == H263_QUANT) {
                        start_timer();
                        quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
                        stop_quant_timer();

                        start_timer();
                        dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
                        stop_iquant_timer();
                } else {
                        start_timer();
                        quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
                        stop_quant_timer();

                        start_timer();
                        dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
                        stop_iquant_timer();
                }

                start_timer();
                idct(&data[i * 64]);
                stop_idct_timer();
        }

        if (pMB->field_dct) {
                next_block = stride;
                stride *= 2;
        }

        start_timer();
        transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
        transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
        transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
        transfer_16to8copy(pY_Cur + next_block + 8, &data[3 * 64], stride);
        transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
        transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
        stop_transfer_timer();

}


uint8_t
MBTransQuantInter(const MBParam * pParam,
                                  FRAMEINFO * frame,
                                  MACROBLOCK * pMB,
                                  const uint32_t x_pos,
                                  const uint32_t y_pos,
                                  int16_t data[6 * 64],
                                  int16_t qcoeff[6 * 64])
{

        uint32_t stride = pParam->edged_width;
        uint32_t stride2 = stride / 2;
        uint32_t next_block = stride * 8;
        uint32_t i;
        uint32_t iQuant = frame->quant;
        uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
        uint8_t cbp = 0;
        uint32_t sum;
        IMAGE *pCurrent = &frame->image;

        pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
        pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
        pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);

        start_timer();
        pMB->field_dct = 0;
        if ((frame->global_flags & XVID_INTERLACING) &&
                (x_pos>0) && (x_pos<pParam->mb_width-1) &&
                (y_pos>0) && (y_pos<pParam->mb_height-1)) {
                pMB->field_dct = MBDecideFieldDCT(data);
        }
        stop_interlacing_timer();

        for (i = 0; i < 6; i++) {
                /* 
                 *  no need to transfer 8->16-bit
                 * (this is performed already in motion compensation) 
                 */
                start_timer();
                fdct(&data[i * 64]);
                stop_dct_timer();

                if (pParam->m_quant_type == 0) {
                        start_timer();
                        sum = quant_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
                        stop_quant_timer();
                } else {
                        start_timer();
                        sum = quant4_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
                        stop_quant_timer();
                }

                if ((sum >= TOOSMALL_LIMIT) || (qcoeff[i*64] != 0) ||
                        (qcoeff[i*64+1] != 0) || (qcoeff[i*64+8] != 0)) {

                        if (pParam->m_quant_type == H263_QUANT) {
                                start_timer();
                                dequant_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
                                stop_iquant_timer();
                        } else {
                                start_timer();
                                dequant4_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
                                stop_iquant_timer();
                        }

                        cbp |= 1 << (5 - i);

                        start_timer();
                        idct(&data[i * 64]);
                        stop_idct_timer();
                }
        }

        if (pMB->field_dct) {
                next_block = stride;
                stride *= 2;
        }

        start_timer();
        if (cbp & 32)
                transfer_16to8add(pY_Cur, &data[0 * 64], stride);
        if (cbp & 16)
                transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
        if (cbp & 8)
                transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
        if (cbp & 4)
                transfer_16to8add(pY_Cur + next_block + 8, &data[3 * 64], stride);
        if (cbp & 2)
                transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
        if (cbp & 1)
                transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
        stop_transfer_timer();

        return cbp;

}

void 
MBTransQuantIntra2(const MBParam * pParam,
                                  FRAMEINFO * frame,
                                  MACROBLOCK * pMB,
                                  const uint32_t x_pos,
                                  const uint32_t y_pos,
                                  int16_t data[6 * 64],
                                  int16_t qcoeff[6 * 64])
{
        MBTrans(pParam,frame,pMB,x_pos,y_pos,data);
        MBfDCT(pParam,frame,pMB,data);
        MBQuantIntra(pParam,frame,pMB,data,qcoeff);
        MBDeQuantIntra(pParam,frame->quant,data,qcoeff);
        MBiDCT(data,0x3F);
        MBTransAdd(pParam,frame,pMB,x_pos,y_pos,data,0x3F);
}


uint8_t
MBTransQuantInter2(const MBParam * pParam,
                                  FRAMEINFO * frame,
                                  MACROBLOCK * pMB,
                                  const uint32_t x_pos,
                                  const uint32_t y_pos,
                                  int16_t data[6 * 64],
                                  int16_t qcoeff[6 * 64])
{
        uint8_t cbp;
        
/* there is no MBTrans for Inter block, that's done in motion compensation already */

        MBfDCT(pParam,frame,pMB,data);
        cbp = MBQuantInter(pParam,frame->quant,data,qcoeff);
        MBDeQuantInter(pParam,frame->quant,data,qcoeff,cbp);
        MBiDCT(data,cbp);
        MBTransAdd(pParam,frame,pMB,x_pos,y_pos,data,cbp);
        
        return cbp;
}

uint8_t
MBTransQuantInterBVOP(const MBParam * pParam,
                                  FRAMEINFO * frame,
                                  MACROBLOCK * pMB,
                                  int16_t data[6 * 64],
                                  int16_t qcoeff[6 * 64])
{
        uint8_t cbp;
        
/* there is no MBTrans for Inter block, that's done in motion compensation already */

        MBfDCT(pParam,frame,pMB,data);
        cbp = MBQuantInter(pParam,frame->quant,data,qcoeff);

/* we don't have to DeQuant, iDCT and Transfer back data for B-frames */

        return cbp;
}


void
MBfDCT(const MBParam * pParam,
                                  FRAMEINFO * frame,
                                  MACROBLOCK * pMB,
                                  int16_t data[6 * 64])
{       
        int i;

        start_timer();
        pMB->field_dct = 0;
        if ((frame->global_flags & XVID_INTERLACING)) {
                pMB->field_dct = MBDecideFieldDCT(data);
        }
        stop_interlacing_timer();

        for (i = 0; i < 6; i++) {
                start_timer();
                fdct(&data[i * 64]);
                stop_dct_timer();
        }
}

void
MBQuantDeQuantIntra(const MBParam * pParam,
                                        FRAMEINFO * frame,
                                        MACROBLOCK * pMB,
                                        int16_t qcoeff[6 * 64],
                                        int16_t data[6*64])
{
        int i;
        int iQuant = frame->quant;

        start_timer();
        pMB->field_dct = 0;
        if ((frame->global_flags & XVID_INTERLACING)) {
                pMB->field_dct = MBDecideFieldDCT(data);
        }
        stop_interlacing_timer();

        for (i = 0; i < 6; i++) {
                uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);

                if (pParam->m_quant_type == H263_QUANT) {
                        start_timer();
                        quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
                        stop_quant_timer();

                        start_timer();
                        dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
                        stop_iquant_timer();
                } else {
                        start_timer();
                        quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
                        stop_quant_timer();

                        start_timer();
                        dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
                        stop_iquant_timer();
                }
        }
}

void
MBQuantIntra(const MBParam * pParam,
                         FRAMEINFO * frame,
                         MACROBLOCK *pMB,
                         int16_t data[6 * 64],
                     int16_t qcoeff[6 * 64])
{
        int i;
        int iQuant = frame->quant;

        start_timer();
        pMB->field_dct = 0;
        if ((frame->global_flags & XVID_INTERLACING)) {
                pMB->field_dct = MBDecideFieldDCT(data);
        }
        stop_interlacing_timer();

        for (i = 0; i < 6; i++) {
                uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);

                if (pParam->m_quant_type == H263_QUANT) {
                        start_timer();
                        quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
                        stop_quant_timer();
                } else {
                        start_timer();
                        quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
                        stop_quant_timer();
                }
        }
}

void
MBDeQuantIntra(const MBParam * pParam,
                           const int iQuant,
                                  int16_t qcoeff[6 * 64],
                                  int16_t data[6*64])
{
        int i;

        for (i = 0; i < 6; i++) {
                uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);

                if (pParam->m_quant_type == H263_QUANT) {
                        start_timer();
                        dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
                        stop_iquant_timer();
                } else {
                        start_timer();
                        dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
                        stop_iquant_timer();
                }
        }
}

uint8_t
MBQuantInter(const MBParam * pParam,
                         const int iQuant,
                                  int16_t data[6 * 64],
                                  int16_t qcoeff[6 * 64])
{

        int i;
        uint8_t cbp = 0;
        int sum;

        for (i = 0; i < 6; i++) {
        
                if (pParam->m_quant_type == 0) {
                        start_timer();
                        sum = quant_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
                        stop_quant_timer();
                } else {
                        start_timer();
                        sum = quant4_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
                        stop_quant_timer();
                }

                if (sum >= TOOSMALL_LIMIT) {    // skip block ?
                        cbp |= 1 << (5 - i);
                }
        }
        return cbp;
}

void 
MBDeQuantInter( const MBParam * pParam,
                                const int iQuant,
                                  int16_t data[6 * 64],
                                  int16_t qcoeff[6 * 64],
                                  const uint8_t cbp)
{
        int i;

        for (i = 0; i < 6; i++) {
                if (cbp & (1 << (5 - i)))
                {       
                        if (pParam->m_quant_type == H263_QUANT) {
                                start_timer();
                                dequant_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
                                stop_iquant_timer();
                        } else {
                                start_timer();
                                dequant4_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
                                stop_iquant_timer();
                        }
                }
        }
}

void
MBiDCT( int16_t data[6 * 64],
                const uint8_t cbp)
{
        int i;

        for (i = 0; i < 6; i++) {
                if (cbp & (1 << (5 - i)))
                {       
                        start_timer();
                        idct(&data[i * 64]);
                        stop_idct_timer();
                
                }
        }
}


void
MBTrans(const MBParam * pParam,
                                  FRAMEINFO * frame,
                                  MACROBLOCK * pMB,
                                  const uint32_t x_pos,
                                  const uint32_t y_pos,
                                  int16_t data[6 * 64])
{
        uint32_t stride = pParam->edged_width;
        uint32_t stride2 = stride / 2;
        uint32_t next_block = stride * 8;
        uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
        IMAGE *pCurrent = &frame->image;

        pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
        pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
        pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);

        start_timer();
        transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
        transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
        transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
        transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
        transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
        transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
        stop_transfer_timer();
}
        
void
MBTransAdd(const MBParam * pParam,
                                  FRAMEINFO * frame,
                                  MACROBLOCK * pMB,
                                  const uint32_t x_pos,
                                  const uint32_t y_pos,
                                  int16_t data[6 * 64],
                                  const uint8_t cbp)
{
        uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
        uint32_t stride = pParam->edged_width;
        uint32_t stride2 = stride / 2;
        uint32_t next_block = stride * 8;
        IMAGE *pCurrent = &frame->image;

        pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
        pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
        pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);

        if (pMB->field_dct) {
                next_block = stride;
                stride *= 2;
        }

        start_timer();
        if (cbp & 32)
                transfer_16to8add(pY_Cur, &data[0 * 64], stride);
        if (cbp & 16)
                transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
        if (cbp & 8)
                transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
        if (cbp & 4)
                transfer_16to8add(pY_Cur + next_block + 8, &data[3 * 64], stride);
        if (cbp & 2)
                transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
        if (cbp & 1)
                transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
        stop_transfer_timer();
}


/* if sum(diff between field lines) < sum(diff between frame lines), use field dct */


uint32_t
MBDecideFieldDCT(int16_t data[6 * 64])
{

        const uint8_t blocks[] =
                { 0 * 64, 0 * 64, 0 * 64, 0 * 64, 2 * 64, 2 * 64, 2 * 64, 2 * 64 };
        const uint8_t lines[] = { 0, 16, 32, 48, 0, 16, 32, 48 };

        int frame = 0, field = 0;
        int i, j;

        for (i = 0; i < 7; ++i) {
                for (j = 0; j < 8; ++j) {
                        frame +=
                                ABS(data[0 * 64 + (i + 1) * 8 + j] - data[0 * 64 + i * 8 + j]);
                        frame +=
                                ABS(data[1 * 64 + (i + 1) * 8 + j] - data[1 * 64 + i * 8 + j]);
                        frame +=
                                ABS(data[2 * 64 + (i + 1) * 8 + j] - data[2 * 64 + i * 8 + j]);
                        frame +=
                                ABS(data[3 * 64 + (i + 1) * 8 + j] - data[3 * 64 + i * 8 + j]);

                        field +=
                                ABS(data[blocks[i + 1] + lines[i + 1] + j] -
                                        data[blocks[i] + lines[i] + j]);
                        field +=
                                ABS(data[blocks[i + 1] + lines[i + 1] + 8 + j] -
                                        data[blocks[i] + lines[i] + 8 + j]);
                        field +=
                                ABS(data[blocks[i + 1] + 64 + lines[i + 1] + j] -
                                        data[blocks[i] + 64 + lines[i] + j]);
                        field +=
                                ABS(data[blocks[i + 1] + 64 + lines[i + 1] + 8 + j] -
                                        data[blocks[i] + 64 + lines[i] + 8 + j]);
                }
        }

        if (frame > field) {
                MBFrameToField(data);
        }

        return (frame > (field + 350));
}


/* deinterlace Y blocks vertically */

#define MOVLINE(X,Y) memcpy(X, Y, sizeof(tmp))
#define LINE(X,Y)    &data[X*64 + Y*8]

void
MBFrameToField(int16_t data[6 * 64])
{
        int16_t tmp[8];

        /* left blocks */

        // 1=2, 2=4, 4=8, 8=1
        MOVLINE(tmp, LINE(0, 1));
        MOVLINE(LINE(0, 1), LINE(0, 2));
        MOVLINE(LINE(0, 2), LINE(0, 4));
        MOVLINE(LINE(0, 4), LINE(2, 0));
        MOVLINE(LINE(2, 0), tmp);

        // 3=6, 6=12, 12=9, 9=3
        MOVLINE(tmp, LINE(0, 3));
        MOVLINE(LINE(0, 3), LINE(0, 6));
        MOVLINE(LINE(0, 6), LINE(2, 4));
        MOVLINE(LINE(2, 4), LINE(2, 1));
        MOVLINE(LINE(2, 1), tmp);

        // 5=10, 10=5
        MOVLINE(tmp, LINE(0, 5));
        MOVLINE(LINE(0, 5), LINE(2, 2));
        MOVLINE(LINE(2, 2), tmp);

        // 7=14, 14=13, 13=11, 11=7
        MOVLINE(tmp, LINE(0, 7));
        MOVLINE(LINE(0, 7), LINE(2, 6));
        MOVLINE(LINE(2, 6), LINE(2, 5));
        MOVLINE(LINE(2, 5), LINE(2, 3));
        MOVLINE(LINE(2, 3), tmp);

        /* right blocks */

        // 1=2, 2=4, 4=8, 8=1
        MOVLINE(tmp, LINE(1, 1));
        MOVLINE(LINE(1, 1), LINE(1, 2));
        MOVLINE(LINE(1, 2), LINE(1, 4));
        MOVLINE(LINE(1, 4), LINE(3, 0));
        MOVLINE(LINE(3, 0), tmp);

        // 3=6, 6=12, 12=9, 9=3
        MOVLINE(tmp, LINE(1, 3));
        MOVLINE(LINE(1, 3), LINE(1, 6));
        MOVLINE(LINE(1, 6), LINE(3, 4));
        MOVLINE(LINE(3, 4), LINE(3, 1));
        MOVLINE(LINE(3, 1), tmp);

        // 5=10, 10=5
        MOVLINE(tmp, LINE(1, 5));
        MOVLINE(LINE(1, 5), LINE(3, 2));
        MOVLINE(LINE(3, 2), tmp);

        // 7=14, 14=13, 13=11, 11=7
        MOVLINE(tmp, LINE(1, 7));
        MOVLINE(LINE(1, 7), LINE(3, 6));
        MOVLINE(LINE(3, 6), LINE(3, 5));
        MOVLINE(LINE(3, 5), LINE(3, 3));
        MOVLINE(LINE(3, 3), tmp);
}
Revision:	1.16
Committed:	Wed Oct 9 22:51:42 2002 UTC (22 years ago) by edgomez
Content type:	text/plain
Branch:	MAIN
Changes since 1.15:	+2 -3 lines
Log Message:	- Removed a stupid ')' squatting the previous gruel's patch :-) (did you ever check the code compiled ?)
#	User	Rev	Content
1	edgomez	1.12	/*****************************************************************************
2			*
3			* XVID MPEG-4 VIDEO CODEC
4			* - MacroBlock transfer and quantization -
5			*
6			* Copyright(C) 2002-2001 Michael Militzer <isibaar@xvid.org>
7	suxen_drol	1.13	* 2002-2001 Peter Ross <pross@xvid.org>
8	edgomez	1.12	*
9			* This program is an implementation of a part of one or more MPEG-4
10			* Video tools as specified in ISO/IEC 14496-2 standard. Those intending
11			* to use this software module in hardware or software products are
12			* advised that its use may infringe existing patents or copyrights, and
13			* any such use would be at such party's own risk. The original
14			* developer of this software module and his/her company, and subsequent
15			* editors and their companies, will have no liability for use of this
16			* software or modifications or derivatives thereof.
17			*
18			* This program is free software; you can redistribute it and/or modify
19			* it under the terms of the GNU General Public License as published by
20			* the Free Software Foundation; either version 2 of the License, or
21			* (at your option) any later version.
22			*
23			* This program is distributed in the hope that it will be useful,
24			* but WITHOUT ANY WARRANTY; without even the implied warranty of
25			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26			* GNU General Public License for more details.
27			*
28			* You should have received a copy of the GNU General Public License
29			* along with this program; if not, write to the Free Software
30			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31			*
32	edgomez	1.16	* $Id: mbtransquant.c,v 1.15 2002/10/07 08:11:48 chl Exp $
33	edgomez	1.12	*
34			****************************************************************************/
35	Isibaar	1.1
36	edgomez	1.3	#include <string.h>
37
38	Isibaar	1.1	#include "../portab.h"
39			#include "mbfunctions.h"
40
41			#include "../global.h"
42			#include "mem_transfer.h"
43			#include "timer.h"
44			#include "../dct/fdct.h"
45			#include "../dct/idct.h"
46			#include "../quant/quant_mpeg4.h"
47			#include "../quant/quant_h263.h"
48			#include "../encoder.h"
49
50			#define MIN(X, Y) ((X)<(Y)?(X):(Y))
51			#define MAX(X, Y) ((X)>(Y)?(X):(Y))
52
53	Isibaar	1.9	#define TOOSMALL_LIMIT 3 /* skip blocks having a coefficient sum below this value */
54	Isibaar	1.1
55			/* this isnt pretty, but its better than 20 ifdefs */
56
57	edgomez	1.7	void
58			MBTransQuantIntra(const MBParam * pParam,
59			FRAMEINFO * frame,
60			MACROBLOCK * pMB,
61			const uint32_t x_pos,
62			const uint32_t y_pos,
63			int16_t data[6 * 64],
64			int16_t qcoeff[6 * 64])
65	Isibaar	1.1	{
66	edgomez	1.3
67	h	1.4	uint32_t stride = pParam->edged_width;
68			uint32_t stride2 = stride / 2;
69			uint32_t next_block = stride * 8;
70	Isibaar	1.1	uint32_t i;
71	suxen_drol	1.6	uint32_t iQuant = frame->quant;
72	Isibaar	1.1	uint8_t pY_Cur, pU_Cur, *pV_Cur;
73	edgomez	1.7	IMAGE *pCurrent = &frame->image;
74	Isibaar	1.1
75	edgomez	1.3	pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
76	h	1.4	pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
77			pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
78	h	1.2
79			start_timer();
80	edgomez	1.7	transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
81			transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
82			transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
83			transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
84			transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
85			transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
86	h	1.2	stop_transfer_timer();
87
88			start_timer();
89			pMB->field_dct = 0;
90	h	1.11	if ((frame->global_flags & XVID_INTERLACING) &&
91			(x_pos>0) && (x_pos<pParam->mb_width-1) &&
92			(y_pos>0) && (y_pos<pParam->mb_height-1)) {
93	h	1.2	pMB->field_dct = MBDecideFieldDCT(data);
94			}
95			stop_interlacing_timer();
96
97	edgomez	1.7	for (i = 0; i < 6; i++) {
98	Isibaar	1.1	uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
99
100			start_timer();
101	edgomez	1.7	fdct(&data[i * 64]);
102	Isibaar	1.1	stop_dct_timer();
103
104	edgomez	1.7	if (pParam->m_quant_type == H263_QUANT) {
105	Isibaar	1.1	start_timer();
106	edgomez	1.7	quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
107	Isibaar	1.1	stop_quant_timer();
108
109			start_timer();
110	edgomez	1.7	dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
111	Isibaar	1.1	stop_iquant_timer();
112	edgomez	1.7	} else {
113	Isibaar	1.1	start_timer();
114	edgomez	1.7	quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
115	Isibaar	1.1	stop_quant_timer();
116
117			start_timer();
118	edgomez	1.7	dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
119	Isibaar	1.1	stop_iquant_timer();
120			}
121
122			start_timer();
123	edgomez	1.7	idct(&data[i * 64]);
124	Isibaar	1.1	stop_idct_timer();
125	edgomez	1.3	}
126	h	1.2
127	edgomez	1.7	if (pMB->field_dct) {
128	h	1.4	next_block = stride;
129			stride *= 2;
130	h	1.2	}
131	Isibaar	1.1
132	h	1.2	start_timer();
133	edgomez	1.7	transfer_16to8copy(pY_Cur, &data[0 * 64], stride);
134			transfer_16to8copy(pY_Cur + 8, &data[1 * 64], stride);
135			transfer_16to8copy(pY_Cur + next_block, &data[2 * 64], stride);
136			transfer_16to8copy(pY_Cur + next_block + 8, &data[3 * 64], stride);
137			transfer_16to8copy(pU_Cur, &data[4 * 64], stride2);
138			transfer_16to8copy(pV_Cur, &data[5 * 64], stride2);
139	h	1.2	stop_transfer_timer();
140	edgomez	1.3
141	Isibaar	1.1	}
142
143
144	edgomez	1.7	uint8_t
145			MBTransQuantInter(const MBParam * pParam,
146			FRAMEINFO * frame,
147			MACROBLOCK * pMB,
148			const uint32_t x_pos,
149			const uint32_t y_pos,
150			int16_t data[6 * 64],
151			int16_t qcoeff[6 * 64])
152	Isibaar	1.1	{
153	edgomez	1.3
154	h	1.4	uint32_t stride = pParam->edged_width;
155			uint32_t stride2 = stride / 2;
156			uint32_t next_block = stride * 8;
157	edgomez	1.3	uint32_t i;
158	suxen_drol	1.6	uint32_t iQuant = frame->quant;
159	Isibaar	1.1	uint8_t pY_Cur, pU_Cur, *pV_Cur;
160	edgomez	1.3	uint8_t cbp = 0;
161	Isibaar	1.1	uint32_t sum;
162	edgomez	1.7	IMAGE *pCurrent = &frame->image;
163
164	edgomez	1.3	pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
165	h	1.4	pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
166			pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
167	Isibaar	1.1
168	h	1.2	start_timer();
169			pMB->field_dct = 0;
170	h	1.11	if ((frame->global_flags & XVID_INTERLACING) &&
171			(x_pos>0) && (x_pos<pParam->mb_width-1) &&
172			(y_pos>0) && (y_pos<pParam->mb_height-1)) {
173	h	1.2	pMB->field_dct = MBDecideFieldDCT(data);
174			}
175			stop_interlacing_timer();
176
177	edgomez	1.7	for (i = 0; i < 6; i++) {
178	Isibaar	1.1	/*
179	edgomez	1.3	* no need to transfer 8->16-bit
180			* (this is performed already in motion compensation)
181			*/
182	Isibaar	1.1	start_timer();
183	edgomez	1.7	fdct(&data[i * 64]);
184	Isibaar	1.1	stop_dct_timer();
185
186	edgomez	1.7	if (pParam->m_quant_type == 0) {
187	Isibaar	1.1	start_timer();
188	edgomez	1.7	sum = quant_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
189	Isibaar	1.1	stop_quant_timer();
190	edgomez	1.7	} else {
191	Isibaar	1.1	start_timer();
192	edgomez	1.7	sum = quant4_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
193	Isibaar	1.1	stop_quant_timer();
194			}
195
196	Isibaar	1.9	if ((sum >= TOOSMALL_LIMIT) \|\| (qcoeff[i*64] != 0) \|\|
197			(qcoeff[i64+1] != 0) \|\| (qcoeff[i64+8] != 0)) {
198	Isibaar	1.1
199	edgomez	1.7	if (pParam->m_quant_type == H263_QUANT) {
200	Isibaar	1.1	start_timer();
201	edgomez	1.7	dequant_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
202	Isibaar	1.1	stop_iquant_timer();
203	edgomez	1.7	} else {
204	Isibaar	1.1	start_timer();
205	edgomez	1.7	dequant4_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
206	Isibaar	1.1	stop_iquant_timer();
207			}
208
209			cbp \|= 1 << (5 - i);
210
211			start_timer();
212	edgomez	1.7	idct(&data[i * 64]);
213	Isibaar	1.1	stop_idct_timer();
214	h	1.2	}
215			}
216
217	edgomez	1.7	if (pMB->field_dct) {
218	h	1.4	next_block = stride;
219			stride *= 2;
220	h	1.2	}
221
222			start_timer();
223			if (cbp & 32)
224	edgomez	1.7	transfer_16to8add(pY_Cur, &data[0 * 64], stride);
225	h	1.2	if (cbp & 16)
226	edgomez	1.7	transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
227	h	1.2	if (cbp & 8)
228	edgomez	1.7	transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
229	h	1.2	if (cbp & 4)
230	edgomez	1.7	transfer_16to8add(pY_Cur + next_block + 8, &data[3 * 64], stride);
231	h	1.2	if (cbp & 2)
232	edgomez	1.7	transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
233	h	1.2	if (cbp & 1)
234	edgomez	1.7	transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
235	h	1.2	stop_transfer_timer();
236
237	edgomez	1.3	return cbp;
238
239	h	1.2	}
240
241	chl	1.8	void
242			MBTransQuantIntra2(const MBParam * pParam,
243			FRAMEINFO * frame,
244			MACROBLOCK * pMB,
245			const uint32_t x_pos,
246			const uint32_t y_pos,
247			int16_t data[6 * 64],
248			int16_t qcoeff[6 * 64])
249			{
250			MBTrans(pParam,frame,pMB,x_pos,y_pos,data);
251			MBfDCT(pParam,frame,pMB,data);
252			MBQuantIntra(pParam,frame,pMB,data,qcoeff);
253			MBDeQuantIntra(pParam,frame->quant,data,qcoeff);
254			MBiDCT(data,0x3F);
255			MBTransAdd(pParam,frame,pMB,x_pos,y_pos,data,0x3F);
256			}
257
258
259			uint8_t
260			MBTransQuantInter2(const MBParam * pParam,
261			FRAMEINFO * frame,
262			MACROBLOCK * pMB,
263			const uint32_t x_pos,
264			const uint32_t y_pos,
265			int16_t data[6 * 64],
266			int16_t qcoeff[6 * 64])
267			{
268			uint8_t cbp;
269
270			/* there is no MBTrans for Inter block, that's done in motion compensation already */
271
272			MBfDCT(pParam,frame,pMB,data);
273			cbp = MBQuantInter(pParam,frame->quant,data,qcoeff);
274			MBDeQuantInter(pParam,frame->quant,data,qcoeff,cbp);
275			MBiDCT(data,cbp);
276			MBTransAdd(pParam,frame,pMB,x_pos,y_pos,data,cbp);
277
278			return cbp;
279			}
280
281			uint8_t
282			MBTransQuantInterBVOP(const MBParam * pParam,
283			FRAMEINFO * frame,
284			MACROBLOCK * pMB,
285			int16_t data[6 * 64],
286			int16_t qcoeff[6 * 64])
287			{
288			uint8_t cbp;
289
290			/* there is no MBTrans for Inter block, that's done in motion compensation already */
291
292			MBfDCT(pParam,frame,pMB,data);
293			cbp = MBQuantInter(pParam,frame->quant,data,qcoeff);
294
295			/* we don't have to DeQuant, iDCT and Transfer back data for B-frames */
296
297			return cbp;
298			}
299
300
301			void
302			MBfDCT(const MBParam * pParam,
303			FRAMEINFO * frame,
304			MACROBLOCK * pMB,
305			int16_t data[6 * 64])
306			{
307			int i;
308
309			start_timer();
310			pMB->field_dct = 0;
311			if ((frame->global_flags & XVID_INTERLACING)) {
312			pMB->field_dct = MBDecideFieldDCT(data);
313			}
314			stop_interlacing_timer();
315
316			for (i = 0; i < 6; i++) {
317			start_timer();
318			fdct(&data[i * 64]);
319			stop_dct_timer();
320			}
321			}
322
323			void
324			MBQuantDeQuantIntra(const MBParam * pParam,
325			FRAMEINFO * frame,
326			MACROBLOCK * pMB,
327			int16_t qcoeff[6 * 64],
328			int16_t data[6*64])
329			{
330			int i;
331			int iQuant = frame->quant;
332
333			start_timer();
334			pMB->field_dct = 0;
335			if ((frame->global_flags & XVID_INTERLACING)) {
336			pMB->field_dct = MBDecideFieldDCT(data);
337			}
338			stop_interlacing_timer();
339
340			for (i = 0; i < 6; i++) {
341			uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
342
343			if (pParam->m_quant_type == H263_QUANT) {
344			start_timer();
345			quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
346			stop_quant_timer();
347
348			start_timer();
349			dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
350			stop_iquant_timer();
351			} else {
352			start_timer();
353			quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
354			stop_quant_timer();
355
356			start_timer();
357			dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
358			stop_iquant_timer();
359			}
360			}
361			}
362
363			void
364			MBQuantIntra(const MBParam * pParam,
365			FRAMEINFO * frame,
366			MACROBLOCK *pMB,
367	edgomez	1.16	int16_t data[6 * 64],
368	chl	1.15	int16_t qcoeff[6 * 64])
369	chl	1.8	{
370			int i;
371			int iQuant = frame->quant;
372
373			start_timer();
374			pMB->field_dct = 0;
375			if ((frame->global_flags & XVID_INTERLACING)) {
376			pMB->field_dct = MBDecideFieldDCT(data);
377			}
378			stop_interlacing_timer();
379
380			for (i = 0; i < 6; i++) {
381			uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
382
383			if (pParam->m_quant_type == H263_QUANT) {
384			start_timer();
385			quant_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
386			stop_quant_timer();
387			} else {
388			start_timer();
389			quant4_intra(&qcoeff[i * 64], &data[i * 64], iQuant, iDcScaler);
390			stop_quant_timer();
391			}
392			}
393			}
394
395			void
396			MBDeQuantIntra(const MBParam * pParam,
397			const int iQuant,
398			int16_t qcoeff[6 * 64],
399			int16_t data[6*64])
400			{
401			int i;
402
403			for (i = 0; i < 6; i++) {
404			uint32_t iDcScaler = get_dc_scaler(iQuant, i < 4);
405
406			if (pParam->m_quant_type == H263_QUANT) {
407			start_timer();
408			dequant_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
409			stop_iquant_timer();
410			} else {
411			start_timer();
412			dequant4_intra(&data[i * 64], &qcoeff[i * 64], iQuant, iDcScaler);
413			stop_iquant_timer();
414			}
415			}
416			}
417
418			uint8_t
419			MBQuantInter(const MBParam * pParam,
420			const int iQuant,
421			int16_t data[6 * 64],
422			int16_t qcoeff[6 * 64])
423			{
424
425			int i;
426			uint8_t cbp = 0;
427			int sum;
428
429			for (i = 0; i < 6; i++) {
430
431			if (pParam->m_quant_type == 0) {
432			start_timer();
433			sum = quant_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
434			stop_quant_timer();
435			} else {
436			start_timer();
437			sum = quant4_inter(&qcoeff[i * 64], &data[i * 64], iQuant);
438			stop_quant_timer();
439			}
440
441			if (sum >= TOOSMALL_LIMIT) { // skip block ?
442			cbp \|= 1 << (5 - i);
443			}
444			}
445			return cbp;
446			}
447
448			void
449			MBDeQuantInter( const MBParam * pParam,
450			const int iQuant,
451			int16_t data[6 * 64],
452			int16_t qcoeff[6 * 64],
453			const uint8_t cbp)
454			{
455			int i;
456
457			for (i = 0; i < 6; i++) {
458			if (cbp & (1 << (5 - i)))
459			{
460			if (pParam->m_quant_type == H263_QUANT) {
461			start_timer();
462			dequant_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
463			stop_iquant_timer();
464			} else {
465			start_timer();
466			dequant4_inter(&data[i * 64], &qcoeff[i * 64], iQuant);
467			stop_iquant_timer();
468			}
469			}
470			}
471			}
472
473			void
474			MBiDCT( int16_t data[6 * 64],
475			const uint8_t cbp)
476			{
477			int i;
478
479			for (i = 0; i < 6; i++) {
480			if (cbp & (1 << (5 - i)))
481			{
482			start_timer();
483			idct(&data[i * 64]);
484			stop_idct_timer();
485
486			}
487			}
488			}
489
490
491			void
492			MBTrans(const MBParam * pParam,
493			FRAMEINFO * frame,
494			MACROBLOCK * pMB,
495			const uint32_t x_pos,
496			const uint32_t y_pos,
497			int16_t data[6 * 64])
498			{
499			uint32_t stride = pParam->edged_width;
500			uint32_t stride2 = stride / 2;
501			uint32_t next_block = stride * 8;
502			uint8_t pY_Cur, pU_Cur, *pV_Cur;
503			IMAGE *pCurrent = &frame->image;
504
505			pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
506			pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
507			pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
508
509			start_timer();
510			transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
511			transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
512			transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
513			transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
514			transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
515			transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
516			stop_transfer_timer();
517			}
518
519			void
520			MBTransAdd(const MBParam * pParam,
521			FRAMEINFO * frame,
522			MACROBLOCK * pMB,
523			const uint32_t x_pos,
524			const uint32_t y_pos,
525			int16_t data[6 * 64],
526			const uint8_t cbp)
527			{
528			uint8_t pY_Cur, pU_Cur, *pV_Cur;
529			uint32_t stride = pParam->edged_width;
530			uint32_t stride2 = stride / 2;
531			uint32_t next_block = stride * 8;
532			IMAGE *pCurrent = &frame->image;
533
534			pY_Cur = pCurrent->y + (y_pos << 4) * stride + (x_pos << 4);
535			pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
536			pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
537
538			if (pMB->field_dct) {
539			next_block = stride;
540			stride *= 2;
541			}
542
543			start_timer();
544			if (cbp & 32)
545			transfer_16to8add(pY_Cur, &data[0 * 64], stride);
546			if (cbp & 16)
547			transfer_16to8add(pY_Cur + 8, &data[1 * 64], stride);
548			if (cbp & 8)
549			transfer_16to8add(pY_Cur + next_block, &data[2 * 64], stride);
550			if (cbp & 4)
551			transfer_16to8add(pY_Cur + next_block + 8, &data[3 * 64], stride);
552			if (cbp & 2)
553			transfer_16to8add(pU_Cur, &data[4 * 64], stride2);
554			if (cbp & 1)
555			transfer_16to8add(pV_Cur, &data[5 * 64], stride2);
556			stop_transfer_timer();
557			}
558
559
560	h	1.2
561			/* if sum(diff between field lines) < sum(diff between frame lines), use field dct */
562
563	Isibaar	1.1
564	edgomez	1.7	uint32_t
565			MBDecideFieldDCT(int16_t data[6 * 64])
566	h	1.2	{
567	edgomez	1.3
568	edgomez	1.7	const uint8_t blocks[] =
569			{ 0 * 64, 0 * 64, 0 * 64, 0 * 64, 2 * 64, 2 * 64, 2 * 64, 2 * 64 };
570			const uint8_t lines[] = { 0, 16, 32, 48, 0, 16, 32, 48 };
571	h	1.2
572			int frame = 0, field = 0;
573			int i, j;
574
575	edgomez	1.7	for (i = 0; i < 7; ++i) {
576			for (j = 0; j < 8; ++j) {
577			frame +=
578			ABS(data[0 * 64 + (i + 1) * 8 + j] - data[0 * 64 + i * 8 + j]);
579			frame +=
580			ABS(data[1 * 64 + (i + 1) * 8 + j] - data[1 * 64 + i * 8 + j]);
581			frame +=
582			ABS(data[2 * 64 + (i + 1) * 8 + j] - data[2 * 64 + i * 8 + j]);
583			frame +=
584			ABS(data[3 * 64 + (i + 1) * 8 + j] - data[3 * 64 + i * 8 + j]);
585
586			field +=
587			ABS(data[blocks[i + 1] + lines[i + 1] + j] -
588			data[blocks[i] + lines[i] + j]);
589			field +=
590			ABS(data[blocks[i + 1] + lines[i + 1] + 8 + j] -
591			data[blocks[i] + lines[i] + 8 + j]);
592			field +=
593			ABS(data[blocks[i + 1] + 64 + lines[i + 1] + j] -
594			data[blocks[i] + 64 + lines[i] + j]);
595			field +=
596			ABS(data[blocks[i + 1] + 64 + lines[i + 1] + 8 + j] -
597			data[blocks[i] + 64 + lines[i] + 8 + j]);
598	Isibaar	1.1	}
599			}
600	h	1.2
601	edgomez	1.7	if (frame > field) {
602	h	1.2	MBFrameToField(data);
603			}
604
605	h	1.14	return (frame > (field + 350));
606	h	1.2	}
607
608
609			/* deinterlace Y blocks vertically */
610
611			#define MOVLINE(X,Y) memcpy(X, Y, sizeof(tmp))
612	edgomez	1.3	#define LINE(X,Y) &data[X64 + Y8]
613	h	1.2
614	edgomez	1.7	void
615			MBFrameToField(int16_t data[6 * 64])
616	h	1.2	{
617			int16_t tmp[8];
618
619			/* left blocks */
620
621			// 1=2, 2=4, 4=8, 8=1
622	edgomez	1.7	MOVLINE(tmp, LINE(0, 1));
623			MOVLINE(LINE(0, 1), LINE(0, 2));
624			MOVLINE(LINE(0, 2), LINE(0, 4));
625			MOVLINE(LINE(0, 4), LINE(2, 0));
626			MOVLINE(LINE(2, 0), tmp);
627	h	1.2
628			// 3=6, 6=12, 12=9, 9=3
629	edgomez	1.7	MOVLINE(tmp, LINE(0, 3));
630			MOVLINE(LINE(0, 3), LINE(0, 6));
631			MOVLINE(LINE(0, 6), LINE(2, 4));
632			MOVLINE(LINE(2, 4), LINE(2, 1));
633			MOVLINE(LINE(2, 1), tmp);
634	h	1.2
635			// 5=10, 10=5
636	edgomez	1.7	MOVLINE(tmp, LINE(0, 5));
637			MOVLINE(LINE(0, 5), LINE(2, 2));
638			MOVLINE(LINE(2, 2), tmp);
639	h	1.2
640			// 7=14, 14=13, 13=11, 11=7
641	edgomez	1.7	MOVLINE(tmp, LINE(0, 7));
642			MOVLINE(LINE(0, 7), LINE(2, 6));
643			MOVLINE(LINE(2, 6), LINE(2, 5));
644			MOVLINE(LINE(2, 5), LINE(2, 3));
645			MOVLINE(LINE(2, 3), tmp);
646	h	1.2
647			/* right blocks */
648
649			// 1=2, 2=4, 4=8, 8=1
650	edgomez	1.7	MOVLINE(tmp, LINE(1, 1));
651			MOVLINE(LINE(1, 1), LINE(1, 2));
652			MOVLINE(LINE(1, 2), LINE(1, 4));
653			MOVLINE(LINE(1, 4), LINE(3, 0));
654			MOVLINE(LINE(3, 0), tmp);
655	h	1.2
656			// 3=6, 6=12, 12=9, 9=3
657	edgomez	1.7	MOVLINE(tmp, LINE(1, 3));
658			MOVLINE(LINE(1, 3), LINE(1, 6));
659			MOVLINE(LINE(1, 6), LINE(3, 4));
660			MOVLINE(LINE(3, 4), LINE(3, 1));
661			MOVLINE(LINE(3, 1), tmp);
662	h	1.2
663			// 5=10, 10=5
664	edgomez	1.7	MOVLINE(tmp, LINE(1, 5));
665			MOVLINE(LINE(1, 5), LINE(3, 2));
666			MOVLINE(LINE(3, 2), tmp);
667	h	1.2
668			// 7=14, 14=13, 13=11, 11=7
669	edgomez	1.7	MOVLINE(tmp, LINE(1, 7));
670			MOVLINE(LINE(1, 7), LINE(3, 6));
671			MOVLINE(LINE(3, 6), LINE(3, 5));
672			MOVLINE(LINE(3, 5), LINE(3, 3));
673			MOVLINE(LINE(3, 3), tmp);
674	Isibaar	1.1	}