decoder/impeg2d_debug.c

/******************************************************************************
 *
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *****************************************************************************
 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
#include <string.h>
#include <stdio.h>

#include "iv_datatypedef.h"
#include "iv.h"
#include "ivd.h"
#include "impeg2d.h"

#include "impeg2_buf_mgr.h"
#include "impeg2_disp_mgr.h"
#include "impeg2_macros.h"
#include "impeg2_defs.h"
#include "impeg2_platform_macros.h"
#include "impeg2_inter_pred.h"
#include "impeg2_idct.h"
#include "impeg2_format_conv.h"
#include "impeg2_mem_func.h"
#include "impeg2_globals.h"

#include "impeg2d_bitstream.h"
#include "impeg2d_api.h"
#include "impeg2d_structs.h"
#include "impeg2d_debug.h"

#if STATISTICS
WORD32 gai4_impeg2d_idct_inp_last_nonzero_histogram[64] = {0};
WORD32 gai4_impeg2d_idct_inp_num_nonzero_histogram[64] = {0};
WORD32 gai4_impeg2d_idct_inp_last_non_zero_row_histogram[8] = {0};

WORD32 gai4_impeg2d_iqnt_inp_last_nonzero_histogram[64] = {0};
WORD32 gai4_impeg2d_iqnt_inp_num_nonzero_histogram[64] = {0};
WORD32 gai4_impeg2d_iqnt_inp_last_non_zero_row_histogram[8] = {0};

WORD32 gi4_impeg2d_idct_inp_only_first_coeff = 0;
WORD32 gi4_impeg2d_idct_inp_only_last_coeff = 0;
WORD32 gi4_impeg2d_idct_inp_only_first_n_last_coeff = 0;
WORD32 gi4_impeg2d_idct_cnt = 0;


WORD32 gi4_impeg2d_iqnt_inp_only_first_coeff = 0;
WORD32 gi4_impeg2d_iqnt_inp_only_last_coeff = 0;
WORD32 gi4_impeg2d_iqnt_inp_only_first_n_last_coeff = 0;
WORD32 gi4_impeg2d_iqnt_cnt = 0;


void impeg2d_iqnt_inp_statistics(WORD16 *pi2_iqnt_inp,
                                 WORD32 i4_non_zero_cols,
                                 WORD32 i4_non_zero_rows)
{
    WORD32 i, j;
    WORD32 i4_last_row = 0, i4_last_col = 0;
    WORD32 i4_num_non_zero = 0;
    WORD32 i4_non_zero_cols_computed = 0;
    WORD32 i4_non_zero_rows_computed = 0;

    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            if(pi2_iqnt_inp[i * 8 + j])
            {
                i4_non_zero_cols_computed |= (1 << j);
                i4_non_zero_rows_computed |= (1 << i);
            }
        }
    }

    if(i4_non_zero_cols_computed != i4_non_zero_cols)
    {
        printf("IQ Input: Invalid non_zero_cols 0x%x non_zero_cols_computed 0x%x\n", i4_non_zero_cols, i4_non_zero_cols_computed);
    }
    if(i4_non_zero_rows_computed != i4_non_zero_rows)
    {
        printf("IQ Input: Invalid non_zero_rows 0x%x non_zero_rows_computed 0x%x\n", i4_non_zero_rows, i4_non_zero_rows_computed);
    }
    {
        WORD32 last_non_zero_row = 32 - CLZ(i4_non_zero_rows);
        gai4_impeg2d_iqnt_inp_last_non_zero_row_histogram[last_non_zero_row - 1]++;
    }
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            if(pi2_iqnt_inp[i * 8 + j])
            {
                i4_last_col = MAX(i4_last_col, j);
                i4_last_row = MAX(i4_last_row, i);
                i4_num_non_zero++;
            }
        }
    }
    gai4_impeg2d_iqnt_inp_last_nonzero_histogram[i4_last_row * 8 + i4_last_col]++;
    gai4_impeg2d_iqnt_inp_num_nonzero_histogram[i4_num_non_zero]++;
    gi4_impeg2d_iqnt_cnt++;
    /* Check if only (0,0) and (7,7) are non zero */
    if(i4_num_non_zero == 1)
    {
        if(pi2_iqnt_inp[7 * 8 + 7])
            gi4_impeg2d_iqnt_inp_only_last_coeff++;
    }
    if(i4_num_non_zero == 1)
    {
        if(pi2_iqnt_inp[0])
            gi4_impeg2d_iqnt_inp_only_first_coeff++;
    }

    if(i4_num_non_zero == 2)
    {
        if((pi2_iqnt_inp[0]) && (1 == pi2_iqnt_inp[7 * 8 + 7]))
            gi4_impeg2d_iqnt_inp_only_first_n_last_coeff++;
    }
}

void impeg2d_idct_inp_statistics(WORD16 *pi2_idct_inp,
                                 WORD32 i4_non_zero_cols,
                                 WORD32 i4_non_zero_rows)
{
    WORD32 i, j;
    WORD32 i4_last_row = 0, i4_last_col = 0;
    WORD32 i4_num_non_zero = 0;
    WORD32 i4_non_zero_cols_computed = 0;
    WORD32 i4_non_zero_rows_computed = 0;

    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            if(pi2_idct_inp[i * 8 + j])
            {
                i4_non_zero_cols_computed |= (1 << j);
                i4_non_zero_rows_computed |= (1 << i);
            }
        }
    }

    if(i4_non_zero_cols_computed != i4_non_zero_cols)
    {
        printf("IDCT Input: Invalid non_zero_cols 0x%x non_zero_cols_computed 0x%x\n", i4_non_zero_cols, i4_non_zero_cols_computed);
    }
    if(i4_non_zero_rows_computed != i4_non_zero_rows)
    {
        printf("IDCT Input: Invalid non_zero_rows 0x%x non_zero_rows_computed 0x%x\n", i4_non_zero_rows, i4_non_zero_rows_computed);
    }

    {
        WORD32 last_non_zero_row = 32 - CLZ(i4_non_zero_rows);
        gai4_impeg2d_idct_inp_last_non_zero_row_histogram[last_non_zero_row - 1]++;
    }

    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            if(pi2_idct_inp[i * 8 + j])
            {
                i4_last_col = MAX(i4_last_col, j);
                i4_last_row = MAX(i4_last_row, i);
                i4_num_non_zero++;
            }
        }
    }
    gai4_impeg2d_idct_inp_last_nonzero_histogram[i4_last_row * 8 + i4_last_col]++;
    gai4_impeg2d_idct_inp_num_nonzero_histogram[i4_num_non_zero]++;
    gi4_impeg2d_idct_cnt++;
    /* Check if only (0,0) and (7,7) are non zero */
    if(i4_num_non_zero == 1)
    {
        if(pi2_idct_inp[7 * 8 + 7])
            gi4_impeg2d_idct_inp_only_last_coeff++;
    }
    if(i4_num_non_zero == 1)
    {
        if(pi2_idct_inp[0])
            gi4_impeg2d_idct_inp_only_first_coeff++;
    }

    if(i4_num_non_zero == 2)
    {
        if((pi2_idct_inp[0]) && (1 == pi2_idct_inp[7 * 8 + 7]))
            gi4_impeg2d_idct_inp_only_first_n_last_coeff++;
    }
}
void impeg2d_print_idct_inp_statistics()
{
    WORD32 i, j;
    WORD32 i4_sum;
    WORD32 i4_accumulator;
    i4_sum = 0;
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            i4_sum += gai4_impeg2d_idct_inp_last_nonzero_histogram[i * 8 + j];
        }
    }
    printf("IDCT input : Only last coeff non-zero %8.2f\n", (gi4_impeg2d_idct_inp_only_last_coeff * 100.0) / gi4_impeg2d_idct_cnt);
    printf("IDCT input : Only first coeff non-zero (Includes DC + mismatch) %8.2f\n", (gi4_impeg2d_idct_inp_only_first_coeff * 100.0) / gi4_impeg2d_idct_cnt);

    printf("IDCT input : Last non-zero coeff histogram\n");
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            double val = gai4_impeg2d_idct_inp_last_nonzero_histogram[i * 8 + j] * 100.0 / i4_sum;
            printf("%8.2f \t", val);

        }
        printf("\n");
    }

    printf("IDCT input : Cumulative Last non-zero coeff histogram\n");
    i4_accumulator = 0;
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            double val;
            i4_accumulator += gai4_impeg2d_idct_inp_last_nonzero_histogram[i * 8 + j];
            val = i4_accumulator * 100.0 / i4_sum;

            printf("%8.2f \t", val);

        }
        printf("\n");
    }



    printf("IDCT input : Number of non-zero coeff histogram\n");
    i4_sum = 0;
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            i4_sum += gai4_impeg2d_idct_inp_num_nonzero_histogram[i * 8 + j];
        }
    }
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            double val = gai4_impeg2d_idct_inp_num_nonzero_histogram[i * 8 + j] * 100.0 / i4_sum;
            printf("%8.2f \t", val);

        }
        printf("\n");
    }

    printf("IDCT input : Cumulative number of non-zero coeffs histogram\n");
    i4_accumulator = 0;
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            double val;
            i4_accumulator += gai4_impeg2d_idct_inp_num_nonzero_histogram[i * 8 + j];
            val = i4_accumulator * 100.0 / i4_sum;
            printf("%8.2f \t", val);

        }
        printf("\n");
    }

    printf("IDCT input : Last non-zero row histogram\n");


    {
        i4_accumulator = 0;
        for(i = 0; i < 8; i++)
        {
            i4_accumulator += gai4_impeg2d_idct_inp_last_non_zero_row_histogram[i];
        }
        for(i = 0; i < 8; i++)
        {
            double val = gai4_impeg2d_idct_inp_last_non_zero_row_histogram[i] * 100.0 / i4_accumulator;
            printf("%8.2f \t", val);
        }
        printf("\n");
    }




}

void impeg2d_print_iqnt_inp_statistics()
{
    WORD32 i, j;
    WORD32 i4_sum;
    WORD32 i4_accumulator;
    i4_sum = 0;
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            i4_sum += gai4_impeg2d_iqnt_inp_last_nonzero_histogram[i * 8 + j];
        }
    }
    printf("IQnt input : Only last coeff non-zero %8.2f\n", (gi4_impeg2d_iqnt_inp_only_last_coeff * 100.0) / gi4_impeg2d_iqnt_cnt);
    printf("IQnt input : Only first coeff non-zero (Includes DC + mismatch) %8.2f\n", (gi4_impeg2d_iqnt_inp_only_first_coeff * 100.0) / gi4_impeg2d_idct_cnt);

    printf("IQnt input : Last non-zero coeff histogram\n");
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            double val = gai4_impeg2d_iqnt_inp_last_nonzero_histogram[i * 8 + j] * 100.0 / i4_sum;
            printf("%8.2f \t", val);

        }
        printf("\n");
    }

    printf("IQnt input : Cumulative Last non-zero coeff histogram\n");
    i4_accumulator = 0;
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            double val;
            i4_accumulator += gai4_impeg2d_iqnt_inp_last_nonzero_histogram[i * 8 + j];
            val = i4_accumulator * 100.0 / i4_sum;

            printf("%8.2f \t", val);

        }
        printf("\n");
    }



    printf("IQnt input : Number of non-zero coeff histogram\n");
    i4_sum = 0;
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            i4_sum += gai4_impeg2d_iqnt_inp_num_nonzero_histogram[i * 8 + j];
        }
    }
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            double val = gai4_impeg2d_iqnt_inp_num_nonzero_histogram[i * 8 + j] * 100.0 / i4_sum;
            printf("%8.2f \t", val);

        }
        printf("\n");
    }

    printf("IQnt input : Cumulative number of non-zero coeffs histogram\n");
    i4_accumulator = 0;
    for(i = 0; i < 8; i++)
    {
        for(j = 0; j < 8; j++)
        {
            double val;
            i4_accumulator += gai4_impeg2d_iqnt_inp_num_nonzero_histogram[i * 8 + j];
            val = i4_accumulator * 100.0 / i4_sum;
            printf("%8.2f \t", val);

        }
        printf("\n");
    }

    printf("IQnt input : Last non-zero row histogram\n");


    {
        i4_accumulator = 0;
        for(i = 0; i < 8; i++)
        {
            i4_accumulator += gai4_impeg2d_iqnt_inp_last_non_zero_row_histogram[i];
        }
        for(i = 0; i < 8; i++)
        {
            double val = gai4_impeg2d_iqnt_inp_last_non_zero_row_histogram[i] * 100.0 / i4_accumulator;
            printf("%8.2f \t", val);
        }
        printf("\n");
    }

}

void impeg2d_print_statistics()
{
    impeg2d_print_idct_inp_statistics();
    impeg2d_print_iqnt_inp_statistics();
}


#endif

#if DEBUG_MB

static UWORD32  u4_debug_frm = 12;
static UWORD32  u4_debug_mb_x = 3;
static UWORD32  u4_debug_mb_y = 0;

static UWORD32  u4_debug_frm_num = 0;

/*****************************************************************************/
/*                                                                           */
/*  Function Name : example_of_a_function                                    */
/*                                                                           */
/*  Description   : This function illustrates the use of C coding standards. */
/*                  switch/case, if, for, block comments have been shown     */
/*                  here.                                                    */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         13 07 2002   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/
void impeg2d_trace_mb_start(UWORD32 u4_mb_x, UWORD32 u4_mb_y)
{
    UWORD32 u4_frm_num = impeg2d_frm_num_get();

   if(u4_frm_num == u4_debug_frm && u4_mb_x == u4_debug_mb_x &&  u4_mb_y == u4_debug_mb_y)
   {
//       printf("");
   }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : example_of_a_function                                    */
/*                                                                           */
/*  Description   : This function illustrates the use of C coding standards. */
/*                  switch/case, if, for, block comments have been shown     */
/*                  here.                                                    */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         13 07 2002   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/
void impeg2d_frm_num_set(void)
{
    u4_debug_frm_num++;
}


/*****************************************************************************/
/*                                                                           */
/*  Function Name : example_of_a_function                                    */
/*                                                                           */
/*  Description   : This function illustrates the use of C coding standards. */
/*                  switch/case, if, for, block comments have been shown     */
/*                  here.                                                    */
/*  Inputs        : <What inputs does the function take?>                    */
/*  Globals       : <Does it use any global variables?>                      */
/*  Processing    : <Describe how the function operates - include algorithm  */
/*                  description>                                             */
/*  Outputs       : <What does the function produce?>                        */
/*  Returns       : <What does the function return?>                         */
/*                                                                           */
/*  Issues        : <List any issues or problems with this function>         */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         13 07 2002   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/
UWORD32 impeg2d_frm_num_get(void)
{
    return(u4_debug_frm_num);
}

#endif