rfreeimage 0.1.0

data/vendor/FreeImage/Source/LibJXR/image/decode/decode.c

@@ -0,0 +1,200 @@
+//*@@@+++@@@@******************************************************************
+//
+// Copyright � Microsoft Corp.
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+// � Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// � Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+//*@@@---@@@@******************************************************************
+/******************************************************************************
+
+Module Name:
+    decode.c 
+    
+Abstract:    
+    Defines the entry point for the console application.
+
+Author:
+
+Revision History:
+*******************************************************************************/
+#include "strcodec.h"
+#include "decode.h"
+
+#ifdef MEM_TRACE
+#define TRACE_MALLOC    1
+#define TRACE_NEW       0
+#define TRACE_HEAP      0
+#include "memtrace.h"
+#endif
+
+/******************************************************************
+Free Adaptive Huffman Table
+******************************************************************/
+static Void CleanAH(CAdaptiveHuffman **ppAdHuff)
+{
+    CAdaptiveHuffman *pAdHuff;
+    
+    if (NULL != ppAdHuff) {
+        pAdHuff = *ppAdHuff;
+        if (NULL != pAdHuff) {
+            free(pAdHuff);
+        }
+        *ppAdHuff = NULL;
+    }
+}
+
+static Void CleanAHDec(CCodingContext * pSC)
+{
+    Int kk;
+
+    for (kk = 0; kk < NUMVLCTABLES; kk++) {
+        CleanAH(&(pSC->m_pAHexpt[kk]));
+    }
+    CleanAH(&(pSC->m_pAdaptHuffCBPCY));
+    CleanAH(&(pSC->m_pAdaptHuffCBPCY1));
+}
+
+/*************************************************************************
+    Initialize an adaptive huffman table
+*************************************************************************/
+static Int InitializeAH(CAdaptiveHuffman **ppAdHuff, Int iSym)
+{
+    Int iMemStatus = 0;
+
+    CAdaptiveHuffman *pAdHuff = Allocate(iSym, DECODER);
+    if (pAdHuff == NULL) {
+        iMemStatus = -1;    // out of memory
+        goto ErrorExit;
+    }
+
+    //Adapt(pAdHuff, bFixedTables);
+    //InitHuffman(pAdHuff->m_pHuffman);
+    //if (ICERR_OK != initHuff(pAdHuff->m_pHuffman, 1, pAdHuff->m_pTable, NULL)) {
+    //    goto ErrorExit;
+    //}
+    *ppAdHuff = pAdHuff;
+    return ICERR_OK;
+
+ErrorExit:
+    if (pAdHuff) {
+        free(pAdHuff);
+    }
+    *ppAdHuff = NULL;
+    if (-1 == iMemStatus) {
+        printf("Insufficient memory to init decoder.\n");
+    }
+    return ICERR_ERROR;
+}
+
+
+/*************************************************************************
+    Context allocation
+*************************************************************************/
+Int AllocateCodingContextDec(CWMImageStrCodec *pSC, Int iNumContexts)
+{
+    Int i, iCBPSize, k;
+    static const Int aAlphabet[] = {5,4,8,7,7,  12,6,6,12,6,6,7,7,  12,6,6,12,6,6,7,7};
+
+    if (iNumContexts > MAX_TILES || iNumContexts < 1)  // only between 1 and MAX_TILES allowed
+        return ICERR_ERROR;
+
+    if (pSC == NULL)
+        return ICERR_ERROR;
+
+    pSC->m_pCodingContext = malloc (iNumContexts * sizeof (CCodingContext));
+    if (pSC->m_pCodingContext == NULL) {
+        pSC->cNumCodingContext = 0;
+        return ICERR_ERROR;
+    }
+    memset (pSC->m_pCodingContext, 0, iNumContexts * sizeof (CCodingContext));
+
+    pSC->cNumCodingContext = iNumContexts;
+    iCBPSize = (pSC->m_param.cfColorFormat == Y_ONLY || pSC->m_param.cfColorFormat == NCOMPONENT
+        || pSC->m_param.cfColorFormat == CMYK) ? 5 : 9;
+
+    /** allocate / initialize members **/
+    for (i = 0; i < iNumContexts; i++) {
+        CCodingContext *pContext = &(pSC->m_pCodingContext[i]);
+
+        /** allocate adaptive Huffman encoder **/    
+        if (InitializeAH(&pContext->m_pAdaptHuffCBPCY, iCBPSize) != ICERR_OK) {
+            return ICERR_ERROR;
+        }
+        if (InitializeAH(&pContext->m_pAdaptHuffCBPCY1, 5) != ICERR_OK) {
+            return ICERR_ERROR;
+        }
+
+        for(k = 0; k < NUMVLCTABLES; k ++){
+            if (InitializeAH(&pContext->m_pAHexpt[k], aAlphabet[k]) != ICERR_OK) {
+                return ICERR_ERROR;
+            }
+        }
+
+        ResetCodingContextDec(pContext);
+    }
+
+    return ICERR_OK;
+}
+
+/*************************************************************************
+    Context reset on encoder
+*************************************************************************/
+Void ResetCodingContextDec(CCodingContext *pContext)
+{
+    Int k;
+    /** set flags **/
+    pContext->m_pAdaptHuffCBPCY->m_bInitialize = FALSE;
+    pContext->m_pAdaptHuffCBPCY1->m_bInitialize = FALSE;
+    for(k = 0; k < NUMVLCTABLES; k ++)
+        pContext->m_pAHexpt[k]->m_bInitialize = FALSE;
+
+    // reset VLC tables
+    AdaptLowpassDec (pContext);
+    AdaptHighpassDec (pContext);
+
+    // reset zigzag patterns, totals
+    InitZigzagScan(pContext);
+    // reset bit reduction and cbp models
+    ResetCodingContext(pContext);
+}
+
+/*************************************************************************
+    Context deletion
+*************************************************************************/
+Void FreeCodingContextDec(CWMImageStrCodec *pSC)
+{
+    Int iContexts = (Int)(pSC->cNumCodingContext), i, k;
+
+    if (iContexts > 0 && pSC->m_pCodingContext) {
+
+        for (i = 0; i < iContexts; i++) {
+            CCodingContext *pContext = &(pSC->m_pCodingContext[i]);
+            CleanAH (&pContext->m_pAdaptHuffCBPCY);
+            CleanAH (&pContext->m_pAdaptHuffCBPCY1);
+            for (k = 0; k < NUMVLCTABLES; k++)
+                CleanAH (&pContext->m_pAHexpt[k]);
+        }
+        free (pSC->m_pCodingContext);
+    }
+}
+

data/vendor/FreeImage/Source/LibJXR/image/decode/decode.h

@@ -0,0 +1,143 @@
+//*@@@+++@@@@******************************************************************
+//
+// Copyright � Microsoft Corp.
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+// � Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// � Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+//*@@@---@@@@******************************************************************
+
+#ifndef WMI_DECODE_H
+#define WMI_DECODE_H
+
+typedef struct CWMDecoderParameters {
+    /** ROI decode **/
+    Bool bDecodeFullFrame;
+    Bool bDecodeFullWidth;
+
+    /** thumbnail decode **/
+    Bool bSkipFlexbits;
+    size_t cThumbnailScale;    // 1: cThumbnailScale thumbnail, only supports cThumbnailScale = 2^m for now
+    Bool bDecodeHP;
+    Bool bDecodeLP;
+
+    // Region of interest decoding
+    size_t cROILeftX;
+    size_t cROIRightX;
+    size_t cROITopY;
+    size_t cROIBottomY;
+
+    // table lookups for rotation and flip
+    size_t * pOffsetX;
+    size_t * pOffsetY;
+} CWMDecoderParameters;
+
+Void predCBPDec(CWMImageStrCodec *, CCodingContext *);
+Void predDCACDec(CWMImageStrCodec *);
+Void predACDec(CWMImageStrCodec *);
+
+Int dequantizeMacroblock(CWMImageStrCodec *);
+Int invTransformMacroblock(CWMImageStrCodec * pSC);
+Int invTransformMacroblock_alteredOperators_hard(CWMImageStrCodec * pSC);
+
+Int DecodeMacroblockDC(CWMImageStrCodec * pSC, CCodingContext *pContext, Int iMBX, Int iMBY);
+Int DecodeMacroblockLowpass(CWMImageStrCodec * pSC, CCodingContext *pContext, Int iMBX, Int iMBY);
+Int DecodeMacroblockHighpass(CWMImageStrCodec * pSC, CCodingContext *pContext, Int iMBX, Int iMBY);
+
+Int AdaptLowpassDec(struct CCodingContext *);
+Int AdaptHighpassDec(struct CCodingContext *);
+
+Void ResetCodingContextDec(CCodingContext *pContext);
+Void FreeCodingContextDec(struct CWMImageStrCodec *pSC);
+
+/*************************************************************************/
+// Inverse transform functions
+// 2-point post filter for boundaries (only used in 420 UV DC subband)
+Void strPost2(PixelI *, PixelI *);
+
+// 2x2 post filter (only used in 420 UV DC subband)
+Void strPost2x2(PixelI *, PixelI *, PixelI *, PixelI *);
+
+/** 4-point post filter for boundaries **/
+Void strPost4(PixelI *, PixelI *, PixelI *, PixelI *);
+
+/** data allocation in working buffer (first stage) **/
+
+/** Y, 444 U and V **/
+/**  0  1  2  3 **/
+/** 32 33 34 35 **/
+/** 64 65 66 67 **/
+/** 96 97 98 99 **/
+
+/** 420 U and V **/
+/**   0   2   4   6 **/
+/**  64  66  68  70 **/
+/** 128 130 132 134 **/
+/** 192 194 196 198 **/
+
+/** 4x4 inverse DCT for first stage **/
+Void strIDCT4x4FirstStage(PixelI *);
+Void strIDCT4x4Stage1(PixelI*);
+Void strIDCT4x4FirstStage420UV(PixelI *);
+
+/** 4x4 post filter for first stage **/
+Void strPost4x4FirstStage(PixelI *);
+Void strPost4x4Stage1Split(PixelI*, PixelI*, Int, Int, Bool);
+Void strPost4x4Stage1(PixelI*, Int, Int, Bool);
+Void strPost4x4Stage1Split_alternate(PixelI*, PixelI*, Int);
+Void strPost4x4Stage1_alternate(PixelI*, Int);
+//Void strPost4x4Stage1Split_420(PixelI*, PixelI*);
+//Void strPost4x4Stage1_420(PixelI*);
+
+Void strPost4x4FirstStage420UV(PixelI *);
+
+/** data allocation in working buffer (second stage)**/
+
+/** Y, 444 U and V **/
+/**   0   4   8  12 **/
+/** 128 132 136 140 **/
+/** 256 260 264 268 **/
+/** 384 388 392 396 **/
+
+/** 420 U and V **/
+/**   0   8 **/
+/** 256 264 **/
+
+/** 4x4 invesr DCT for second stage **/
+//Void strIDCT4x4SecondStage(PixelI *);
+Void strIDCT4x4Stage2(PixelI*);
+Void strNormalizeDec(PixelI*, Bool);
+Void strDCT2x2dnDec(PixelI *, PixelI *, PixelI *, PixelI *);
+
+/** 4x4 post filter for second stage **/
+Void strPost4x4SecondStage(PixelI *);
+Void strPost4x4Stage2Split(PixelI*, PixelI*);
+Void strPost4x4Stage2Split_alternate(PixelI*, PixelI*);
+
+/** Huffman decode related defines **/
+#define HUFFMAN_DECODE_ROOT_BITS_LOG    3
+#define HUFFMAN_DECODE_ROOT_BITS    (5)   
+
+Int getHuff(const short *pDecodeTable, BitIOInfo* pIO);
+
+#endif // WMI_DECODE_H
+

data/vendor/FreeImage/Source/LibJXR/image/decode/postprocess.c

@@ -0,0 +1,288 @@
+//*@@@+++@@@@******************************************************************
+//
+// Copyright � Microsoft Corp.
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+// � Redistributions of source code must retain the above copyright notice,
+//   this list of conditions and the following disclaimer.
+// � Redistributions in binary form must reproduce the above copyright notice,
+//   this list of conditions and the following disclaimer in the documentation
+//   and/or other materials provided with the distribution.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+//
+//*@@@---@@@@******************************************************************
+
+#include "windowsmediaphoto.h"
+#include "strcodec.h"
+
+Void smoothMB(PixelI * p1, PixelI * p0, PixelI * q0, PixelI * q1)
+{
+    //  p1 p0 | q0 q1
+    PixelI delta = ((((*q0 - *p0) << 2) + (*p1 - *q1)) >> 3);
+    
+    *q0 -= delta;
+    *p0 += delta;
+}
+
+Void smooth(PixelI * p2, PixelI * p1, PixelI * p0, PixelI * q0, PixelI * q1, PixelI * q2)
+{
+    //    p2 p1 p0 | q0 q1 q2
+    PixelI delta = ((((*q0 - *p0) << 2) + (*p1 - *q1)) >> 3);
+
+    *q0 -= delta;
+    *p0 += delta;
+
+    *p1 = (*p1 >> 1) + ((*p0 + *p2) >> 2);
+    *q1 = (*q1 >> 1) + ((*q0 + *q2) >> 2);
+}
+
+Int initPostProc(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], size_t mbWidth, size_t iNumChannels)
+{
+    size_t i, j, k, l;
+    Bool b32bit = sizeof(int) == 4;
+    
+    for(j = 0; j < iNumChannels; j ++){
+        for(i = 0; i < 2; i ++){
+            // 2 more are allocated to avoid boundary check
+            if(b32bit) // integer overlow/underflow check for 32-bit system
+                if((((mbWidth + 2) >> 16) * sizeof(struct tagPostProcInfo)) & 0xffff0000)
+                    return ICERR_ERROR;
+            strPostProcInfo[j][i] = (struct tagPostProcInfo *)malloc((mbWidth + 2) * sizeof(struct tagPostProcInfo));
+            assert(strPostProcInfo[j][i] != NULL);
+            if(strPostProcInfo[j][i] == NULL){
+                return ICERR_ERROR;
+            }
+            strPostProcInfo[j][i] ++;
+            
+            // initialize out-of-bound MBs as bumpy (no post at all) to avoid boundary check
+            // left boundary
+            strPostProcInfo[j][i][-1].ucMBTexture = 3;
+            for(l = 0; l < 4; l ++){
+                for(k = 0; k < 4; k ++){
+                    strPostProcInfo[j][i][-1].ucBlockTexture[l][k] = 3;
+                }
+            }
+            // right boundary
+            strPostProcInfo[j][i][mbWidth] = strPostProcInfo[j][i][-1];
+        }
+    }
+
+    return ICERR_OK;
+}
+
+Void termPostProc(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], size_t iNumChannels)
+{
+    size_t i, j;
+
+    for(j = 0; j < iNumChannels; j ++){
+        for(i = 0; i < 2; i ++){
+            if(strPostProcInfo[j][i] != NULL){
+                free(strPostProcInfo[j][i] - 1);
+            }
+        }
+    }
+}
+
+Void slideOneMBRow(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], size_t iNumChannels, size_t mbWidth, Bool top, Bool bottom)
+{
+    size_t i, j;
+    struct tagPostProcInfo * bar;
+
+    for(i = 0; i < iNumChannels; i ++){
+        // swap previous row and current row
+        bar = strPostProcInfo[i][0];
+        strPostProcInfo[i][0] = strPostProcInfo[i][1];
+        strPostProcInfo[i][1] = bar;
+
+        if(top){ // if top row, previous row is out of boundary
+            for(j = 0; j < mbWidth; j ++){
+                strPostProcInfo[i][0][j] = strPostProcInfo[i][0][-1]; // set as bumpy
+            }
+        }
+        
+        if(bottom){ // if bottom bottom row, set current row of MBs (out of boundary) as bumpy
+            for(j = 0; j < mbWidth; j ++){
+                strPostProcInfo[i][1][j] = strPostProcInfo[i][1][-1]; // set as bumpy
+            }
+        }
+    }
+}
+
+// get DC and texture infomation right before transform
+Void updatePostProcInfo(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], PixelI * pMB, size_t mbX, size_t cc)
+{
+    size_t i, j;
+    struct tagPostProcInfo * pMBInfo = strPostProcInfo[cc][1] + mbX;
+
+    // DC of MB
+    pMBInfo->iMBDC = pMB[0];
+
+    // texture of MB
+    pMBInfo->ucMBTexture = 0; // smooth
+    for(i = 16; i < 256; i += 16){
+        if(pMB[i] != 0){
+            pMBInfo->ucMBTexture = 3; // bumpy
+            break;
+        }
+    }
+
+    // DCs of blocks not available yet, will collect after demacroblocking
+
+    // textures of blocks
+    for(j = 0; j < 4; j ++)
+        for(i = 0; i < 4; i ++){
+            PixelI * p = pMB + i * 64 + j * 16;
+            size_t k;
+
+            for(k = 1, pMBInfo->ucBlockTexture[j][i] = 0; k < 16; k ++){
+                if(p[k] != 0){
+                    pMBInfo->ucBlockTexture[j][i] = 3;
+                    break;
+                }
+            }
+        }
+}
+
+// demacroblock critirion: two MBs have same texture other than bumpy and DCs differ less than 1
+#define DMB(a, b) (a->ucMBTexture + b->ucMBTexture == 0) && (abs(a->iMBDC - b->iMBDC) <= threshold)
+
+// demacroblock and get DCs of blocks
+Void postProcMB(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], PixelI * p0, PixelI * p1, size_t mbX, size_t cc, Int threshold)
+{
+    /* 4 MBs involved, current MB is d, we have 4 2-pixel boundary segments */
+    /*    |     */
+    /*  a | b   */
+    /* - - + +  */
+    /*  c ! d   */
+    /*    !     */
+    struct tagPostProcInfo * pMBb = strPostProcInfo[cc][0] + mbX, * pMBa = pMBb - 1, * pMBd = strPostProcInfo[cc][1] + mbX, * pMBc = pMBd - 1;
+
+    // demacroblock segment --
+   if(DMB(pMBa, pMBc)){
+        smoothMB(p0 - 256 + 10 * 16, p0 - 256 + 11 * 16, p1 - 256 +  8 * 16, p1 - 256 +  9 * 16);
+        smoothMB(p0 - 256 + 14 * 16, p0 - 256 + 15 * 16, p1 - 256 + 12 * 16, p1 - 256 + 13 * 16);
+    }
+
+    // demacroblock segment ++
+    if(DMB(pMBb, pMBd)){
+        smoothMB(p0 + 2 * 16, p0 + 3 * 16, p1 + 0 * 16, p1 + 1 * 16);
+        smoothMB(p0 + 6 * 16, p0 + 7 * 16, p1 + 4 * 16, p1 + 5 * 16);
+    }
+
+    // demacroblock segment |
+    if(DMB(pMBa, pMBb)){
+        smoothMB(p0 - 256 + 10 * 16, p0 - 256 + 14 * 16, p0 + 2 * 16, p0 + 6 * 16);
+        smoothMB(p0 - 256 + 11 * 16, p0 - 256 + 15 * 16, p0 + 3 * 16, p0 + 7 * 16);
+    }
+
+    // demacroblock segment !
+    if(DMB(pMBc, pMBd)){
+        smoothMB(p1 - 256 + 8 * 16, p1 - 256 + 12 * 16, p1 + 0 * 16, p1 + 4 * 16);
+        smoothMB(p1 - 256 + 9 * 16, p1 - 256 + 13 * 16, p1 + 1 * 16, p1 + 5 * 16);
+    }
+
+    /* update DCs of blocks */
+    // MB d 
+    pMBd->iBlockDC[0][0] = p1[0 * 16];
+    pMBd->iBlockDC[0][1] = p1[4 * 16];
+    pMBd->iBlockDC[1][0] = p1[1 * 16];
+    pMBd->iBlockDC[1][1] = p1[5 * 16];
+    
+    // MB b
+    pMBb->iBlockDC[2][0] = p0[2 * 16];
+    pMBb->iBlockDC[2][1] = p0[6 * 16];
+    pMBb->iBlockDC[3][0] = p0[3 * 16];
+    pMBb->iBlockDC[3][1] = p0[7 * 16];
+
+    // MB c
+    pMBc->iBlockDC[0][2] = p1[ 8 * 16 - 256];
+    pMBc->iBlockDC[0][3] = p1[12 * 16 - 256];
+    pMBc->iBlockDC[1][2] = p1[ 9 * 16 - 256];
+    pMBc->iBlockDC[1][3] = p1[13 * 16 - 256];
+
+    // MB a
+    pMBa->iBlockDC[2][2] = p0[10 * 16 - 256];
+    pMBa->iBlockDC[2][3] = p0[14 * 16 - 256];
+    pMBa->iBlockDC[3][2] = p0[11 * 16 - 256];
+    pMBa->iBlockDC[3][3] = p0[15 * 16 - 256];
+}
+
+/* deblock and destair blocks */
+/* 4 MBs involved, need to process 16 blocks of a */
+/*    |     */
+/*  a | b   */
+/* - - - -  */
+/*  c | d   */
+/*    |     */
+Void postProcBlock(struct tagPostProcInfo * strPostProcInfo[MAX_CHANNELS][2], PixelI * p0, PixelI * p1, size_t mbX, size_t cc, Int threshold)
+{
+    size_t i, j, k;
+    Int dc[5][5];
+    U8 texture[5][5];
+    struct tagPostProcInfo * pMBb = strPostProcInfo[cc][0] + mbX, * pMBa = pMBb - 1, * pMBd = strPostProcInfo[cc][1] + mbX, * pMBc = pMBd - 1;
+    PixelI * pc, * pt;
+
+    /* copy DC and Texture info, can be optimized out */
+    for(j = 0; j < 4; j ++){
+        // from MB a
+        for(i = 0; i < 4; i ++){
+            dc[j][i] = pMBa->iBlockDC[j][i];
+            texture[j][i] = pMBa->ucBlockTexture[j][i];
+        }
+        
+        // 4 blocks from MB c
+        dc[4][j] = pMBc->iBlockDC[0][j];
+        texture[4][j] = pMBc->ucBlockTexture[0][j];
+
+        // 4 blocks from MB b
+        dc[j][4] = pMBb->iBlockDC[j][0];
+        texture[j][4] = pMBb->ucBlockTexture[j][0];
+    }
+    // 1 block from MB d
+    dc[4][4] = pMBd->iBlockDC[0][0];
+    texture[4][4] = pMBd->ucBlockTexture[0][0];
+
+    /* block boundaries */
+    /*     | */
+    /*     | */
+    /*  ---  */
+
+    for(j = 0; j < 4; j ++){
+        for(i = 0; i < 4; i ++){
+            pc = p0 - 256 + i * 64 + j * 16;
+
+            // deblock
+            if(texture[j][i] + texture[j + 1][i] < 3 && abs(dc[j][i] - dc[j + 1][i]) <= threshold){
+                // smooth horizontal boundary ----
+                pt = (j < 3 ? pc + 16 : p1 - 256 + i * 64);
+                for(k = 0; k < 4; k ++){
+                    smooth(pc + idxCC[1][k], pc + idxCC[2][k], pc + idxCC[3][k], pt + idxCC[0][k], pt + idxCC[1][k], pt + idxCC[2][k]);
+                }
+            }
+
+            // two horizontally adjacent blocks have same texture and similiar DCs
+            if(texture[j][i] + texture[j][i + 1] < 3 && abs(dc[j][i] - dc[j][i + 1]) <= threshold){
+                // smooth vertical boundary |
+                pt = pc + 64;
+                for(k = 0; k < 4; k ++){
+                    smooth(pc + idxCC[k][1], pc + idxCC[k][2], pc + idxCC[k][3], pt + idxCC[k][0], pt + idxCC[k][1], pt + idxCC[k][2]);
+                }
+            }
+        }
+    }
+}
+