如何在不牺牲功能的情况下将此功能分解为更小的功能？

Question

我从here得到了MJPEG解码的代码，我试图将IDCT的代码拆分为更小的函数。

在原始代码中的IDCT函数如下：功能

void IDCT(int32_t *input, uint8_t *output) { 
    int32_t Y[64]; 
    int32_t k, l; 

    for (k = 0; k < 8; k++) { 
     for (l = 0; l < 8; l++) Y(k, l) = SCALE(input[(k << 3) + l], S_BITS); 
     idct_1d(&Y(k, 0)); 
    } 

    for (l = 0; l < 8; l++) { 
     int32_t Yc[8]; 

     for (k = 0; k < 8; k++) Yc[k] = Y(k, l); 

     idct_1d(Yc); 

     for (k = 0; k < 8; k++) { 
      int32_t r = 128 + DESCALE(Yc[k], S_BITS + 3); 
      r = r > 0 ? (r < 255 ? r : 255) : 0; 
      X(k, l) = r; 
     } 
    } 
} 

更多细节可以在this链路中找到。

我能够进一步通过以下方式分解这个代码：

在X方向：

void IDCTforX(int32_t *input, uint8_t *output) { 

    int32_t Y[64]; 
    int32_t k, l; 
    int32_t Yc[8]; 

    for (k = 0; k < 8; k++) { 
     for (l = 0; l < 8; l++) 
     { 
      Y(k, l) = SCALE(input[(k << 3) + l], S_BITS); 
     } 
    } 
} 

void IDCTfor1dim(int32_t *input, uint8_t *output) 
{ 
int32_t Y[64]; 
    int32_t k, l; 
    int32_t Yc[8]; 

    for (k= 0; k < 8; k++) 
    { 
     idct_1d(&Y(k, 0)); 
    } 
} 

在Y方向：

代码对于DESCALE如下：

static inline int32_t DESCALE (int32_t x, int32_t n) 
{ 
    return (x + (1 << (n - 1)) - (x < 0)) >> n; 
} 

以上面显示的方式重新组织IDCT会给我与原始代码相同的输出。然而，在下面的方式重新组织为IDCTforY代码后，我得到了一个模糊的图像：

void IDCTforY(int32_t *input, uint8_t *output) { 

int32_t Y[64]; 
    int32_t k, l; 
int32_t Yc[8]; 

    for (l = 0; l < 8; l++) { 

    for (k = 0; k < 8; k++) 
    { 
    Yc[k] = Y(k, l); 
    } 

    idct_1d(Yc); 
    } 
    //Running the loop for de-scaling separately.... 

    for (l = 0; l < 8; l++) { 
    for (k = 0; k < 8; k++) { 
    int32_t r = 128 + DESCALE(Yc[k], S_BITS + 3); 
    r = r > 0 ? (r < 255 ? r : 255) : 0; 
    X(k, l) = r; 
    } 
    } 
} 

我的输出帧看起来像这样与上面的代码：

是什么JPEG解码中模糊图像的含义？

如何分割IDCTforY以使我的代码的性质不会受到影响？

Answer 1

函数IDCT（）声明了通过所有for循环传输数据的数组Y []。在你重构的代码中，每个函数声明它自己的Y []数组。与Yc []数组相同的错误。使数组全局并查看代码是否运行。

编辑2017_08-28

给YC []一个额外的维度：

void IDCTforY(int32_t *input, uint8_t *output) 
{ 
    int32_t Y[64]; 
    int32_t k, l; 
    int32_t Yc[8][8]; 

    for (l = 0; l < 8; l++) 
    { 
     for (k = 0; k < 8; k++) 
      Yc[l][k] = Y(k, l); 
     idct_1d(Yc[l]); 
    } 

    //Running the loop for de-scaling separately.... 

    for (l = 0; l < 8; l++) 
    { 
     for (k = 0; k < 8; k++) 
     { 
      int32_t r = 128 + DESCALE(Yc[l][k], S_BITS + 3); 
      r = r > 0 ? (r < 255 ? r : 255) : 0; 
      X(k, l) = r; 
     } 
    } 
} 

编辑2017年8月29日

我无法解释的光学效果，但你打破了数据流。原来的代码是这样的：

for (l = 0; l < 8; l++) 
{ 
    int32_t Yc[8]; 

    Fill(Yc); 

    idct_1d(Yc); 

    Descale_and_WriteOut(Yc); 
} 

你用它制成的：

int32_t Yc[8]; 
for (l = 0; l < 8; l++) 
{ 
    Fill(Yc); 
    idct_1d(Yc); 
} 
for (l = 0; l < 8; l++) 
{ 
    Descale_and_WriteOut(Yc); 
} 

你看，只有输入和处理循环的最后一次迭代的结果传递给输出回路。我在Yc [] []中给出了每个I-iteration自己的内存。