/******************************************************************************
|
*
|
* 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
|
