quant_matrix.c

基于Linux的ffmepg decoder

#include "quant_matrix.h"

#define FIX(X) (1 << 16) / (X) + 1
#define FIX1(X) (((((1 << 17) / (X) + 1) & 0x1FFFF) << 8) | X)

/*****************************************************************************
 * Local data
 ****************************************************************************/

/* ToDo : remove all this local to make this module thread safe */
uint8_t custom_intra_matrix = 0;
uint8_t custom_inter_matrix = 0;


int16_t intra_matrix[64] = {
	8, 17, 18, 19, 21, 23, 25, 27,
	17, 18, 19, 21, 23, 25, 27, 28,
	20, 21, 22, 23, 24, 26, 28, 30,
	21, 22, 23, 24, 26, 28, 30, 32,
	22, 23, 24, 26, 28, 30, 32, 35,
	23, 24, 26, 28, 30, 32, 35, 38,
	25, 26, 28, 30, 32, 35, 38, 41,
	27, 28, 30, 32, 35, 38, 41, 45
};

int16_t intra_matrix_fix[64] = {
	FIX(8), FIX(17), FIX(18), FIX(19), FIX(21), FIX(23), FIX(25), FIX(27),
	FIX(17), FIX(18), FIX(19), FIX(21), FIX(23), FIX(25), FIX(27), FIX(28),
	FIX(20), FIX(21), FIX(22), FIX(23), FIX(24), FIX(26), FIX(28), FIX(30),
	FIX(21), FIX(22), FIX(23), FIX(24), FIX(26), FIX(28), FIX(30), FIX(32),
	FIX(22), FIX(23), FIX(24), FIX(26), FIX(28), FIX(30), FIX(32), FIX(35),
	FIX(23), FIX(24), FIX(26), FIX(28), FIX(30), FIX(32), FIX(35), FIX(38),
	FIX(25), FIX(26), FIX(28), FIX(30), FIX(32), FIX(35), FIX(38), FIX(41),
	FIX(27), FIX(28), FIX(30), FIX(32), FIX(35), FIX(38), FIX(41), FIX(45)
};


int16_t inter_matrix[64] = {
	16, 17, 18, 19, 20, 21, 22, 23,
	17, 18, 19, 20, 21, 22, 23, 24,
	18, 19, 20, 21, 22, 23, 24, 25,
	19, 20, 21, 22, 23, 24, 26, 27,
	20, 21, 22, 23, 25, 26, 27, 28,
	21, 22, 23, 24, 26, 27, 28, 30,
	22, 23, 24, 26, 27, 28, 30, 31,
	23, 24, 25, 27, 28, 30, 31, 33
};

int16_t inter_matrix_fix[64] = {
	FIX(16), FIX(17), FIX(18), FIX(19), FIX(20), FIX(21), FIX(22), FIX(23),
	FIX(17), FIX(18), FIX(19), FIX(20), FIX(21), FIX(22), FIX(23), FIX(24),
	FIX(18), FIX(19), FIX(20), FIX(21), FIX(22), FIX(23), FIX(24), FIX(25),
	FIX(19), FIX(20), FIX(21), FIX(22), FIX(23), FIX(24), FIX(26), FIX(27),
	FIX(20), FIX(21), FIX(22), FIX(23), FIX(25), FIX(26), FIX(27), FIX(28),
	FIX(21), FIX(22), FIX(23), FIX(24), FIX(26), FIX(27), FIX(28), FIX(30),
	FIX(22), FIX(23), FIX(24), FIX(26), FIX(27), FIX(28), FIX(30), FIX(31),
	FIX(23), FIX(24), FIX(25), FIX(27), FIX(28), FIX(30), FIX(31), FIX(33)
};

uint8_t default_intra_matrix[64] = {
	8, 17, 18, 19, 21, 23, 25, 27,
	17, 18, 19, 21, 23, 25, 27, 28,
	20, 21, 22, 23, 24, 26, 28, 30,
	21, 22, 23, 24, 26, 28, 30, 32,
	22, 23, 24, 26, 28, 30, 32, 35,
	23, 24, 26, 28, 30, 32, 35, 38,
	25, 26, 28, 30, 32, 35, 38, 41,
	27, 28, 30, 32, 35, 38, 41, 45
};
uint8_t default_inter_matrix[64] = {
	16, 17, 18, 19, 20, 21, 22, 23,
	17, 18, 19, 20, 21, 22, 23, 24,
	18, 19, 20, 21, 22, 23, 24, 25,
	19, 20, 21, 22, 23, 24, 26, 27,
	20, 21, 22, 23, 25, 26, 27, 28,
	21, 22, 23, 24, 26, 27, 28, 30,
	22, 23, 24, 26, 27, 28, 30, 31,
	23, 24, 25, 27, 28, 30, 31, 33
};

uint32_t intra_matrix_fix_hw[64] = {
	FIX1(8), FIX1(17), FIX1(18), FIX1(19), FIX1(21), FIX1(23), FIX1(25), FIX1(27),
	FIX1(17), FIX1(18), FIX1(19), FIX1(21), FIX1(23), FIX1(25), FIX1(27), FIX1(28),
	FIX1(20), FIX1(21), FIX1(22), FIX1(23), FIX1(24), FIX1(26), FIX1(28), FIX1(30),
	FIX1(21), FIX1(22), FIX1(23), FIX1(24), FIX1(26), FIX1(28), FIX1(30), FIX1(32),
	FIX1(22), FIX1(23), FIX1(24), FIX1(26), FIX1(28), FIX1(30), FIX1(32), FIX1(35),
	FIX1(23), FIX1(24), FIX1(26), FIX1(28), FIX1(30), FIX1(32), FIX1(35), FIX1(38),
	FIX1(25), FIX1(26), FIX1(28), FIX1(30), FIX1(32), FIX1(35), FIX1(38), FIX1(41),
	FIX1(27), FIX1(28), FIX1(30), FIX1(32), FIX1(35), FIX1(38), FIX1(41), FIX1(45)
};

uint32_t inter_matrix_fix_hw[64] = {
	FIX1(16), FIX1(17), FIX1(18), FIX1(19), FIX1(20), FIX1(21), FIX1(22), FIX1(23),
	FIX1(17), FIX1(18), FIX1(19), FIX1(20), FIX1(21), FIX1(22), FIX1(23), FIX1(24),
	FIX1(18), FIX1(19), FIX1(20), FIX1(21), FIX1(22), FIX1(23), FIX1(24), FIX1(25),
	FIX1(19), FIX1(20), FIX1(21), FIX1(22), FIX1(23), FIX1(24), FIX1(26), FIX1(27),
	FIX1(20), FIX1(21), FIX1(22), FIX1(23), FIX1(25), FIX1(26), FIX1(27), FIX1(28),
	FIX1(21), FIX1(22), FIX1(23), FIX1(24), FIX1(26), FIX1(27), FIX1(28), FIX1(30),
	FIX1(22), FIX1(23), FIX1(24), FIX1(26), FIX1(27), FIX1(28), FIX1(30), FIX1(31),
	FIX1(23), FIX1(24), FIX1(25), FIX1(27), FIX1(28), FIX1(30), FIX1(31), FIX1(33)
};

// added for transposed matrix convenience
const int transposed_order[64] = {
  0,  8, 16, 24, 32, 40, 48, 56,
  1,  9, 17, 25, 33, 41, 49, 57,
  2, 10, 18, 26, 34, 42, 50, 58,
  3, 11, 19, 27, 35, 43, 51, 59,
  4, 12, 20, 28, 36, 44, 52, 60,
  5, 13, 21, 29, 37, 45, 53, 61,
  6, 14, 22, 30, 38, 46, 54, 62,
  7, 15, 23, 31, 39, 47, 55, 63
};

/*****************************************************************************
 * Functions
 ****************************************************************************/

uint8_t
get_intra_matrix_status(void)
{
	return custom_intra_matrix;
}

uint8_t
get_inter_matrix_status(void)
{
	return custom_inter_matrix;
}

int16_t *
get_intra_matrix(void)
{
	return intra_matrix;
}

int16_t *
get_inter_matrix(void)
{
	return inter_matrix;
}

uint8_t *
get_default_intra_matrix(void)
{
	return default_intra_matrix;
}

uint8_t *
get_default_inter_matrix(void)
{
	return default_inter_matrix;
}

uint8_t
set_intra_matrix(uint8_t * matrix,FTMCP100_CODEC *pCodec)
{
	int i, change = 0;
	uint32_t *local_mem = (uint32_t *) (INTRA_QUANT_TABLE_ADDR + pCodec->pCoreBaseAddr);

	custom_intra_matrix = 0;

	for (i = 0; i < 64; i++) {
		if ((int16_t) default_intra_matrix[i] != matrix[i])
			custom_intra_matrix = 1;
		if (intra_matrix[i] != matrix[i])
			change = 1;
			
		// Roger did not transpose the matrix for hardware's convenience, so we
		// transpose it ....
		  local_mem[transposed_order[i]] = (uint32_t) intra_matrix_fix_hw[i];
        //*local_mem++ = (uint32_t) intra_matrix_fix_hw[i];
		
		intra_matrix[i] = (int16_t) matrix[i];
		intra_matrix_fix[i] = FIX(intra_matrix[i]);
	}
	return /*custom_intra_matrix |*/ change;
}


uint8_t
set_inter_matrix(uint8_t * matrix,FTMCP100_CODEC *pCodec)
{
	int i, change = 0;

	uint32_t *local_mem = (uint32_t *) (INTER_QUANT_TABLE_ADDR + pCodec->pCoreBaseAddr);

	custom_inter_matrix = 0;

	for (i = 0; i < 64; i++) {
		if ((int16_t) default_inter_matrix[i] != matrix[i])
			custom_inter_matrix = 1;
		if (inter_matrix[i] != matrix[i])
			change = 1;

		// Roger did not transpose the matrix for hardware's convenience, so we
		// transpose it ....
		local_mem[transposed_order[i]] = (uint32_t) inter_matrix_fix_hw[i];
        //*local_mem++ = (uint32_t) inter_matrix_fix_hw[i];
        
		inter_matrix[i] = (int16_t) matrix[i];
		inter_matrix_fix[i] = FIX(inter_matrix[i]);
	}
	return /*custom_inter_matrix |*/ change;
}