/*
 * drivers/amlogic/media/enhancement/amvecm/amcsc.c
 *
 * Copyright (C) 2017 Amlogic, Inc. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 */

/* Standard Linux headers */
#include <linux/types.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/debugfs.h>
#include <linux/uaccess.h>
#include <linux/amlogic/media/vout/vout_notify.h>
#include <linux/amlogic/media/vfm/vframe_provider.h>
#include <linux/amlogic/media/vfm/vframe_receiver.h>

#include "am_hdr10_plus.h"

uint debug_hdr;
#define pr_hdr(fmt, args...)\
	do {\
		if (debug_hdr)\
			pr_info(fmt, ## args);\
	} while (0)

#define HDR10_PLUS_VERSION  "hdr10_plus v1_20181024"

struct hdr_plus_bits_s sei_md_bits = {
	.len_itu_t_t35_country_code = 8,
	.len_itu_t_t35_terminal_provider_code = 16,
	.len_itu_t_t35_terminal_provider_oriented_code = 16,
	.len_application_identifier = 8,
	.len_application_version = 8,
	.len_num_windows = 2,
	.len_window_upper_left_corner_x = 16,
	.len_window_upper_left_corner_y = 16,
	.len_window_lower_right_corner_x = 16,
	.len_window_lower_right_corner_y = 16,
	.len_center_of_ellipse_x = 16,
	.len_center_of_ellipse_y = 16,
	.len_rotation_angle = 8,
	.len_semimajor_axis_internal_ellipse = 16,
	.len_semimajor_axis_external_ellipse = 16,
	.len_semiminor_axis_external_ellipse = 16,
	.len_overlap_process_option = 1,
	.len_tgt_sys_disp_max_lumi = 27,
	.len_tgt_sys_disp_act_pk_lumi_flag = 1,
	.len_num_rows_tgt_sys_disp_act_pk_lumi = 5,
	.len_num_cols_tgt_sys_disp_act_pk_lumi = 5,
	.len_tgt_sys_disp_act_pk_lumi = 4,
	.len_maxscl = 17,
	.len_average_maxrgb = 17,
	.len_num_distribution_maxrgb_percentiles = 4,
	.len_distribution_maxrgb_percentages = 7,
	.len_distribution_maxrgb_percentiles = 17,
	.len_fraction_bright_pixels = 10,
	.len_mast_disp_act_pk_lumi_flag = 1,
	.len_num_rows_mast_disp_act_pk_lumi = 5,
	.len_num_cols_mast_disp_act_pk_lumi = 5,
	.len_mast_disp_act_pk_lumi = 4,
	.len_tone_mapping_flag = 1,
	.len_knee_point_x = 12,
	.len_knee_point_y = 12,
	.len_num_bezier_curve_anchors = 4,
	.len_bezier_curve_anchors = 10,
	.len_color_saturation_mapping_flag = 1,
	.len_color_saturation_weight = 6
};

struct vframe_hdr_plus_sei_s hdr_plus_sei;
#define NAL_UNIT_SEI 39
#define NAL_UNIT_SEI_SUFFIX 40

int GetBits(char buffer[], int totbitoffset, int *info, int bytecount,
	int numbits)
{
	int inf;
	int  bitoffset  = (totbitoffset & 0x07);/*bit from start of byte*/
	long byteoffset = (totbitoffset >> 3);/*byte from start of buffer*/
	int  bitcounter = numbits;
	static char *curbyte;

	if ((byteoffset) + ((numbits + bitoffset) >> 3) > bytecount)
		return -1;

	curbyte = &(buffer[byteoffset]);
	bitoffset = 7 - bitoffset;
	inf = 0;

	while (numbits--) {
		inf <<= 1;
		inf |= ((*curbyte) >> (bitoffset--)) & 0x01;

		if (bitoffset < 0) {
			curbyte++;
			bitoffset = 7;
		}
	/*curbyte   -= (bitoffset >> 3);*/
	/*bitoffset &= 0x07;*/
	/*curbyte   += (bitoffset == 7);*/
	}

	*info = inf;
	return bitcounter;
}

void parser_hdr10_plus_medata(char *metadata, uint32_t size)
{
	int totbitoffset = 0;
	int value = 0;
	int i = 0;
	int j = 0;
	int num_win;
	unsigned int num_col_tsdapl = 0, num_row_tsdapl = 0;
	unsigned int tar_sys_disp_act_pk_lumi_flag = 0;
	unsigned int num_d_m_p = 0;
	unsigned int m_d_a_p_l_flag = 0;
	unsigned int num_row_m_d_a_p_l = 0, num_col_m_d_a_p_l = 0;
	unsigned int tone_mapping_flag = 0;
	unsigned int num_bezier_curve_anchors = 0;
	unsigned int color_saturation_mapping_flag = 0;

	GetBits(metadata, totbitoffset,
		&value, size, sei_md_bits.len_itu_t_t35_country_code);
	hdr_plus_sei.itu_t_t35_country_code = (u16)value;
	totbitoffset += sei_md_bits.len_itu_t_t35_country_code;

	GetBits(metadata, totbitoffset,
		&value, size, sei_md_bits.len_itu_t_t35_terminal_provider_code);
	hdr_plus_sei.itu_t_t35_terminal_provider_code = (u16)value;
	totbitoffset += sei_md_bits.len_itu_t_t35_terminal_provider_code;

	GetBits(metadata, totbitoffset,
		&value, size,
		sei_md_bits.len_itu_t_t35_terminal_provider_oriented_code);
	hdr_plus_sei.itu_t_t35_terminal_provider_oriented_code =
		(u16)value;
	totbitoffset +=
		sei_md_bits.len_itu_t_t35_terminal_provider_oriented_code;

	GetBits(metadata, totbitoffset,
		&value, size,
		sei_md_bits.len_application_identifier);
	hdr_plus_sei.application_identifier = (u16)value;
	totbitoffset += sei_md_bits.len_application_identifier;

	GetBits(metadata, totbitoffset,
		&value, size,
		sei_md_bits.len_application_version);
	hdr_plus_sei.application_version = (u16)value;
	totbitoffset += sei_md_bits.len_application_version;

	GetBits(metadata, totbitoffset,
		&value, size,
		sei_md_bits.len_num_windows);
	hdr_plus_sei.num_windows = (u16)value;
	totbitoffset += sei_md_bits.len_num_windows;

	num_win = value;

	if (value > 1) {
		for (i = 1; i < num_win; i++) {
			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_window_upper_left_corner_x);
			hdr_plus_sei.window_upper_left_corner_x[i] = (u16)value;
			totbitoffset +=
				sei_md_bits.len_window_upper_left_corner_x;

			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_window_upper_left_corner_y);
			hdr_plus_sei.window_upper_left_corner_y[i] = (u16)value;
			totbitoffset +=
				sei_md_bits.len_window_upper_left_corner_y;

			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_window_lower_right_corner_x);
			hdr_plus_sei.window_lower_right_corner_x[i]
				= (u16)value;
			totbitoffset +=
				sei_md_bits.len_window_lower_right_corner_x;

			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_window_lower_right_corner_y);
			hdr_plus_sei.window_lower_right_corner_y[i]
				= (u16)value;
			totbitoffset +=
				sei_md_bits.len_window_lower_right_corner_y;

			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_center_of_ellipse_x);
			hdr_plus_sei.center_of_ellipse_x[i] = (u16)value;
			totbitoffset += sei_md_bits.len_center_of_ellipse_x;

			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_center_of_ellipse_y);
			hdr_plus_sei.center_of_ellipse_y[i] = (u16)value;
			totbitoffset += sei_md_bits.len_center_of_ellipse_y;

			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_rotation_angle);
			hdr_plus_sei.rotation_angle[i] = (u16)value;
			totbitoffset += sei_md_bits.len_rotation_angle;

			GetBits(metadata, totbitoffset,
				&value, size,
			sei_md_bits.len_semimajor_axis_internal_ellipse);
			hdr_plus_sei.semimajor_axis_internal_ellipse[i]
				= (u16)value;
			totbitoffset +=
				sei_md_bits.len_semimajor_axis_internal_ellipse;

			GetBits(metadata, totbitoffset,
				&value, size,
			sei_md_bits.len_semimajor_axis_external_ellipse);
			hdr_plus_sei.semimajor_axis_external_ellipse[i]
				= (u16)value;
			totbitoffset +=
				sei_md_bits.len_semimajor_axis_external_ellipse;

			GetBits(metadata, totbitoffset,
				&value, size,
			sei_md_bits.len_semiminor_axis_external_ellipse);
			hdr_plus_sei.semiminor_axis_external_ellipse[i]
				= (u16)value;
			totbitoffset +=
				sei_md_bits.len_semiminor_axis_external_ellipse;

			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_overlap_process_option);
			hdr_plus_sei.overlap_process_option[i] = (u16)value;
			totbitoffset += sei_md_bits.len_overlap_process_option;
		}
	}

	GetBits(metadata, totbitoffset,
		&value, size,
		sei_md_bits.len_tgt_sys_disp_max_lumi);
		hdr_plus_sei.tgt_sys_disp_max_lumi = value;
	totbitoffset +=
		sei_md_bits.len_tgt_sys_disp_max_lumi;

	GetBits(metadata, totbitoffset,
		&value, size,
		sei_md_bits.len_tgt_sys_disp_act_pk_lumi_flag);
	hdr_plus_sei.tgt_sys_disp_act_pk_lumi_flag
		= (u16)value;
	totbitoffset +=
		sei_md_bits.len_tgt_sys_disp_act_pk_lumi_flag;

	tar_sys_disp_act_pk_lumi_flag = value;

	if (tar_sys_disp_act_pk_lumi_flag) {
		GetBits(metadata, totbitoffset,
			&value, size,
		sei_md_bits.len_num_rows_tgt_sys_disp_act_pk_lumi);
		hdr_plus_sei.num_rows_tgt_sys_disp_act_pk_lumi
			= (u16)value;
		totbitoffset +=
		sei_md_bits.len_num_rows_tgt_sys_disp_act_pk_lumi;

		num_row_tsdapl = value;

		GetBits(metadata, totbitoffset,
			&value, size,
		sei_md_bits.len_num_cols_tgt_sys_disp_act_pk_lumi);
		hdr_plus_sei.num_cols_tgt_sys_disp_act_pk_lumi
			= (u16)value;
		totbitoffset +=
		sei_md_bits.len_num_cols_tgt_sys_disp_act_pk_lumi;

		num_col_tsdapl = value;

		for (i = 0; i < num_row_tsdapl; i++) {
			for (j = 0; j < num_col_tsdapl; j++) {
				GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_tgt_sys_disp_act_pk_lumi);
				hdr_plus_sei.tgt_sys_disp_act_pk_lumi[i][j]
					= (u16)value;
				totbitoffset +=
				sei_md_bits.len_tgt_sys_disp_act_pk_lumi;
			}
		}
	}
	for (i = 0; i < num_win; i++) {
		for (j = 0; j < 3; j++) {
			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_maxscl);
			hdr_plus_sei.maxscl[i][j] = value;
			totbitoffset += sei_md_bits.len_maxscl;
		}
		GetBits(metadata, totbitoffset,
			&value, size,
			sei_md_bits.len_average_maxrgb);
		hdr_plus_sei.average_maxrgb[i] = value;
		totbitoffset += sei_md_bits.len_average_maxrgb;

		GetBits(metadata, totbitoffset,
			&value, size,
			sei_md_bits.len_num_distribution_maxrgb_percentiles);
		hdr_plus_sei.num_distribution_maxrgb_percentiles[i]
			= (u16)value;
		totbitoffset +=
			sei_md_bits.len_num_distribution_maxrgb_percentiles;

		num_d_m_p = value;
		for (j = 0; j < num_d_m_p; j++) {
			GetBits(metadata, totbitoffset,
			&value, size,
			sei_md_bits.len_distribution_maxrgb_percentages);
			hdr_plus_sei.distribution_maxrgb_percentages[i][j]
				= (u16)value;
			totbitoffset +=
				sei_md_bits.len_distribution_maxrgb_percentages;

			GetBits(metadata, totbitoffset,
			&value, size,
			sei_md_bits.len_distribution_maxrgb_percentiles);
			hdr_plus_sei.distribution_maxrgb_percentiles[i][j]
				= value;
			totbitoffset +=
				sei_md_bits.len_distribution_maxrgb_percentiles;
		}

		GetBits(metadata, totbitoffset,
			&value, size,
			sei_md_bits.len_fraction_bright_pixels);
		hdr_plus_sei.fraction_bright_pixels[i] = (u16)value;
		totbitoffset += sei_md_bits.len_fraction_bright_pixels;
	}

	GetBits(metadata, totbitoffset,
		&value, size,
		sei_md_bits.len_mast_disp_act_pk_lumi_flag);
	hdr_plus_sei.mast_disp_act_pk_lumi_flag
		= (u16)value;
	totbitoffset +=
		sei_md_bits.len_mast_disp_act_pk_lumi_flag;

	m_d_a_p_l_flag = value;
	if (m_d_a_p_l_flag) {
		GetBits(metadata, totbitoffset,
			&value, size,
		sei_md_bits.len_num_rows_mast_disp_act_pk_lumi);
		hdr_plus_sei.num_rows_mast_disp_act_pk_lumi
			= (u16)value;
		totbitoffset +=
			sei_md_bits.len_num_rows_mast_disp_act_pk_lumi;

		num_row_m_d_a_p_l = value;

		GetBits(metadata, totbitoffset,
			&value, size,
		sei_md_bits.len_num_cols_mast_disp_act_pk_lumi);
		hdr_plus_sei.num_cols_mast_disp_act_pk_lumi
			= (u16)value;
		totbitoffset +=
		sei_md_bits.len_num_cols_mast_disp_act_pk_lumi;

		num_col_m_d_a_p_l = value;

		for (i = 0; i < num_row_m_d_a_p_l; i++) {
			for (j = 0; j < num_col_m_d_a_p_l; j++) {
				GetBits(metadata, totbitoffset,
					&value, size,
				sei_md_bits.len_mast_disp_act_pk_lumi);
				hdr_plus_sei.mast_disp_act_pk_lumi[i][j]
					= (u16)value;
				totbitoffset +=
					sei_md_bits.len_mast_disp_act_pk_lumi;
			}
		}
	}

	for (i = 0; i < num_win; i++) {
		GetBits(metadata, totbitoffset,
			&value, size,
			sei_md_bits.len_tone_mapping_flag);
		hdr_plus_sei.tone_mapping_flag[i] = (u16)value;
		totbitoffset += sei_md_bits.len_tone_mapping_flag;

		tone_mapping_flag = value;

		if (tone_mapping_flag) {
			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_knee_point_x);
			hdr_plus_sei.knee_point_x[i] = (u16)value;
			totbitoffset += sei_md_bits.len_knee_point_x;

			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_knee_point_y);
			hdr_plus_sei.knee_point_y[i] = (u16)value;
			totbitoffset += sei_md_bits.len_knee_point_y;

			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_num_bezier_curve_anchors);
			hdr_plus_sei.num_bezier_curve_anchors[i] =
				(u16)value;
			totbitoffset +=
				sei_md_bits.len_num_bezier_curve_anchors;

			num_bezier_curve_anchors = value;

			for (j = 0; j < num_bezier_curve_anchors; j++) {
				GetBits(metadata, totbitoffset,
					&value, size,
					sei_md_bits.len_bezier_curve_anchors);
				hdr_plus_sei.bezier_curve_anchors[i][j] =
					(u16)value;
				totbitoffset +=
					sei_md_bits.len_bezier_curve_anchors;
			}
		}

		GetBits(metadata, totbitoffset,
			&value, size,
			sei_md_bits.len_color_saturation_mapping_flag);
		hdr_plus_sei.color_saturation_mapping_flag[i] =
			(u16)value;
		totbitoffset +=
			sei_md_bits.len_color_saturation_mapping_flag;

		color_saturation_mapping_flag = value;
		if (color_saturation_mapping_flag) {
			GetBits(metadata, totbitoffset,
				&value, size,
				sei_md_bits.len_color_saturation_weight);
			hdr_plus_sei.color_saturation_weight[i] =
				(u16)value;
			totbitoffset +=
				sei_md_bits.len_color_saturation_weight;
		}
	}
}

static int parse_sei(char *sei_buf, uint32_t size)
{
	char *p = sei_buf;
	char *p_sei;
	uint16_t header;
	uint8_t nal_unit_type;
	uint8_t payload_type, payload_size;

	if (size < 2)
		return 0;
	header = *p++;
	header <<= 8;
	header += *p++;
	nal_unit_type = header >> 9;
	if ((nal_unit_type != NAL_UNIT_SEI)
	&& (nal_unit_type != NAL_UNIT_SEI_SUFFIX))
		return 0;
	while (p+2 <= sei_buf+size) {
		payload_type = *p++;
		payload_size = *p++;
		if (p + payload_size <= sei_buf + size) {
			switch (payload_type) {
			case SEI_Syntax:
				p_sei = p;
				parser_hdr10_plus_medata(p_sei, payload_size);
				break;
			default:
				break;
			}
		}
		p += payload_size;
	}
	return 0;
}

void hdr10_plus_parser_metadata(struct vframe_s *vf)
{
	struct provider_aux_req_s req;
	char *p;
	unsigned int size = 0;
	unsigned int type = 0;

	req.vf = vf;
	req.bot_flag = 0;
	req.aux_buf = NULL;
	req.aux_size = 0;
	req.dv_enhance_exist = 0;
	req.low_latency = 0;

	vf_notify_provider_by_name("vdec.h265.00",
			VFRAME_EVENT_RECEIVER_GET_AUX_DATA,
			(void *)&req);

	if (req.aux_buf && req.aux_size) {
		p = req.aux_buf;
		while (p < req.aux_buf
			+ req.aux_size - 8) {
			size = *p++;
			size = (size << 8) | *p++;
			size = (size << 8) | *p++;
			size = (size << 8) | *p++;
			type = *p++;
			type = (type << 8) | *p++;
			type = (type << 8) | *p++;
			type = (type << 8) | *p++;
			if (type == 0x02000000)
				parse_sei(p, size);

			p += size;
		}

	}
}

struct hdr10plus_para dbg_hdr10plus_pkt;

void hdr10_plus_hdmitx_vsif_parser(
	struct hdr10plus_para *hdmitx_hdr10plus_param)
{
	int vsif_tds_max_l;
	int ave_maxrgb;
	int distribution_values[9];
	int i;
	int kpx, kpy;
	int bz_cur_anchors[9];

	hdmitx_hdr10plus_param->application_version =
		(u8)hdr_plus_sei.application_version;

	if (hdr_plus_sei.tgt_sys_disp_max_lumi < 1024) {
		vsif_tds_max_l =
			(hdr_plus_sei.tgt_sys_disp_max_lumi + (1 << 4)) >> 5;
		if (vsif_tds_max_l > 31)
			vsif_tds_max_l = 31;
	} else
		vsif_tds_max_l = 31;
	hdmitx_hdr10plus_param->targeted_max_lum = (u8)vsif_tds_max_l;

	ave_maxrgb = hdr_plus_sei.average_maxrgb[0] / 10;
	if (ave_maxrgb < (1 << 12)) {
		ave_maxrgb = (ave_maxrgb + (1 << 3)) >> 4;
		if (ave_maxrgb > 255)
			ave_maxrgb = 255;
	} else
		ave_maxrgb = 255;
	hdmitx_hdr10plus_param->average_maxrgb = (u8)ave_maxrgb;

	for (i = 0; i < 9; i++) {
		if (i == 2) {
			distribution_values[i] =
			hdr_plus_sei.distribution_maxrgb_percentiles[0][i];
			hdmitx_hdr10plus_param->distribution_values[i] =
				(u8)distribution_values[i];
			continue;
		}
		distribution_values[i] =
			hdr_plus_sei.distribution_maxrgb_percentiles[0][i];
		if (distribution_values[i] < (1 << 12)) {
			distribution_values[i] =
				(distribution_values[i] + (1 << 3)) >> 4;
			if (distribution_values[i] > 255)
				distribution_values[i] = 255;
		} else
			distribution_values[i] = 255;
		hdmitx_hdr10plus_param->distribution_values[i] =
			(u8)distribution_values[i];
	}

	if (hdr_plus_sei.tone_mapping_flag[0] == 0) {
		hdmitx_hdr10plus_param->num_bezier_curve_anchors = 0;
		hdmitx_hdr10plus_param->knee_point_x = 0;
		hdmitx_hdr10plus_param->knee_point_y = 0;
		for (i = 0; i < 9; i++)
			hdmitx_hdr10plus_param->bezier_curve_anchors[0] = 0;
	} else {
		hdmitx_hdr10plus_param->num_bezier_curve_anchors =
			(u8)hdr_plus_sei.num_bezier_curve_anchors[0];

		kpx = hdr_plus_sei.knee_point_x[0];
		kpx = (kpx + (1 << 1)) >> 2;
		if (kpx > 1023)
			kpx = 1023;
		hdmitx_hdr10plus_param->knee_point_x = kpx;

		kpy = hdr_plus_sei.knee_point_y[0];
		kpy = (kpy + (1 << 1)) >> 2;
		if (kpy > 1023)
			kpy = 1023;
		hdmitx_hdr10plus_param->knee_point_y = kpy;

		for (i = 0; i < 9; i++) {
			bz_cur_anchors[i] =
				hdr_plus_sei.bezier_curve_anchors[0][i];

			bz_cur_anchors[i] = (bz_cur_anchors[i] + (1 << 1)) >> 2;
			if (bz_cur_anchors[i] > 255)
				bz_cur_anchors[i] = 255;
			hdmitx_hdr10plus_param->bezier_curve_anchors[i] =
				(u8)bz_cur_anchors[i];
		}
	}
	/*only video, don't include graphic*/
	hdmitx_hdr10plus_param->graphics_overlay_flag = 0;
	/*metadata and video have no delay*/
	hdmitx_hdr10plus_param->no_delay_flag = 1;

	memcpy(&dbg_hdr10plus_pkt, hdmitx_hdr10plus_param,
		sizeof(struct hdr10plus_para));
}

void hdr10_plus_process(struct vframe_s *vf)
{
	if (!vf)
		return;
}

void hdr10_plus_debug(void)
{
	int i = 0;
	int j = 0;

	pr_hdr("itu_t_t35_country_code = 0x%x\n",
		hdr_plus_sei.itu_t_t35_country_code);
	pr_hdr("itu_t_t35_terminal_provider_code = 0x%x\n",
		hdr_plus_sei.itu_t_t35_terminal_provider_code);
	pr_hdr("itu_t_t35_terminal_provider_oriented_code = 0x%x\n",
		hdr_plus_sei.itu_t_t35_terminal_provider_oriented_code);
	pr_hdr("application_identifier = 0x%x\n",
		hdr_plus_sei.application_identifier);
	pr_hdr("application_version = 0x%x\n",
		hdr_plus_sei.application_version);
	pr_hdr("num_windows = 0x%x\n",
		hdr_plus_sei.num_windows);
	for (i = 1; i < hdr_plus_sei.num_windows; i++) {
		pr_hdr("window_upper_left_corner_x[%d] = 0x%x\n",
			i, hdr_plus_sei.window_upper_left_corner_x[i]);
		pr_hdr("window_upper_left_corner_y[%d] = 0x%x\n",
			i, hdr_plus_sei.window_upper_left_corner_y[i]);
		pr_hdr("window_lower_right_corner_x[%d] = 0x%x\n",
			i, hdr_plus_sei.window_lower_right_corner_x[i]);
		pr_hdr("window_lower_right_corner_y[%d] = 0x%x\n",
			i, hdr_plus_sei.window_lower_right_corner_y[i]);
		pr_hdr("center_of_ellipse_x[%d] = 0x%x\n",
			i, hdr_plus_sei.center_of_ellipse_x[i]);
		pr_hdr("center_of_ellipse_y[%d] = 0x%x\n",
			i, hdr_plus_sei.center_of_ellipse_y[i]);
		pr_hdr("rotation_angle[%d] = 0x%x\n",
			i, hdr_plus_sei.rotation_angle[i]);
		pr_hdr("semimajor_axis_internal_ellipse[%d] = 0x%x\n",
			i, hdr_plus_sei.semimajor_axis_internal_ellipse[i]);
		pr_hdr("semimajor_axis_external_ellipse[%d] = 0x%x\n",
			i, hdr_plus_sei.semimajor_axis_external_ellipse[i]);
		pr_hdr("semiminor_axis_external_ellipse[%d] = 0x%x\n",
			i, hdr_plus_sei.semiminor_axis_external_ellipse[i]);
		pr_hdr("overlap_process_option[%d] = 0x%x\n",
			i, hdr_plus_sei.overlap_process_option[i]);
	}
	pr_hdr("targeted_system_display_maximum_luminance = 0x%x\n",
		hdr_plus_sei.tgt_sys_disp_max_lumi);
	pr_hdr("targeted_system_display_actual_peak_luminance_flag = 0x%x\n",
		hdr_plus_sei.tgt_sys_disp_act_pk_lumi_flag);
	if (hdr_plus_sei.tgt_sys_disp_act_pk_lumi_flag) {
		for (i = 0;
			i < hdr_plus_sei.num_rows_tgt_sys_disp_act_pk_lumi;
			i++) {
			for (j = 0;
			j < hdr_plus_sei.num_cols_tgt_sys_disp_act_pk_lumi;
			j++) {
				pr_hdr("tgt_sys_disp_act_pk_lumi");
				pr_hdr("[%d][%d] = 0x%x\n",
				i, j,
				hdr_plus_sei.tgt_sys_disp_act_pk_lumi[i][j]);
			}
		}
	}

	for (i = 0; i < hdr_plus_sei.num_windows; i++) {
		for (j = 0; j < 3; j++)
			pr_hdr("maxscl[%d][%d] = 0x%x\n",
				i, j, hdr_plus_sei.maxscl[i][j]);

		pr_hdr("average_maxrgb[%d] = 0x%x\n",
			i, hdr_plus_sei.average_maxrgb[i]);
		pr_hdr("num_distribution_maxrgb_percentiles[%d] = 0x%x\n",
			i, hdr_plus_sei.num_distribution_maxrgb_percentiles[i]);
		for (j = 0;
		j < hdr_plus_sei.num_distribution_maxrgb_percentiles[i];
		j++) {
			pr_hdr("distribution_maxrgb_pcntages[%d][%d] = 0x%x\n",
			i, j,
			hdr_plus_sei.distribution_maxrgb_percentages[i][j]);
			pr_hdr("distribution_maxrgb_pcntiles[%d][%d] = 0x%x\n",
			i, j,
			hdr_plus_sei.distribution_maxrgb_percentiles[i][j]);
		}
		pr_hdr("fraction_bright_pixels[%d] = 0x%x\n",
			i, hdr_plus_sei.fraction_bright_pixels[i]);
	}

	pr_hdr("mast_disp_act_pk_lumi_flag = 0x%x\n",
		hdr_plus_sei.mast_disp_act_pk_lumi_flag);
	if (hdr_plus_sei.mast_disp_act_pk_lumi_flag) {
		pr_hdr("num_rows_mast_disp_act_pk_lumi = 0x%x\n",
			hdr_plus_sei.num_rows_mast_disp_act_pk_lumi);
		pr_hdr("num_cols_mast_disp_act_pk_lumi = 0x%x\n",
			hdr_plus_sei.num_cols_mast_disp_act_pk_lumi);
		for (i = 0;
			i < hdr_plus_sei.num_rows_mast_disp_act_pk_lumi;
			i++) {
			for (j = 0;
				j < hdr_plus_sei.num_cols_mast_disp_act_pk_lumi;
				j++)
				pr_hdr("mast_disp_act_pk_lumi[%d][%d] = 0x%x\n",
				i, j, hdr_plus_sei.mast_disp_act_pk_lumi[i][j]);
		}
	}

	for (i = 0; i < hdr_plus_sei.num_windows; i++) {
		pr_hdr("tone_mapping_flag[%d] = 0x%x\n",
			i, hdr_plus_sei.tone_mapping_flag[i]);
		pr_hdr("knee_point_x[%d] = 0x%x\n",
			i, hdr_plus_sei.knee_point_x[i]);
		pr_hdr("knee_point_y[%d] = 0x%x\n",
			i, hdr_plus_sei.knee_point_y[i]);
		pr_hdr("num_bezier_curve_anchors[%d] = 0x%x\n",
			i, hdr_plus_sei.num_bezier_curve_anchors[i]);
		for (j = 0; j < hdr_plus_sei.num_bezier_curve_anchors[i]; j++)
			pr_hdr("bezier_curve_anchors[%d][%d] = 0x%x\n",
				i, j, hdr_plus_sei.bezier_curve_anchors[i][j]);

		pr_hdr("color_saturation_mapping_flag[%d] = 0x%x\n",
			i, hdr_plus_sei.color_saturation_mapping_flag[i]);
		pr_hdr("color_saturation_weight[%d] = 0x%x\n",
			i, hdr_plus_sei.color_saturation_weight[i]);
	}

	pr_hdr("\ntx vsif packet data print begin\n");
	pr_hdr("application_version = 0x%x\n",
		dbg_hdr10plus_pkt.application_version);
	pr_hdr("targeted_max_lum = 0x%x\n",
		dbg_hdr10plus_pkt.targeted_max_lum);
	pr_hdr("average_maxrgb = 0x%x\n",
		dbg_hdr10plus_pkt.average_maxrgb);
	for (i = 0; i < 9; i++)
		pr_hdr("distribution_values[%d] = 0x%x\n",
		i, dbg_hdr10plus_pkt.distribution_values[i]);
	pr_hdr("num_bezier_curve_anchors = 0x%x\n",
		dbg_hdr10plus_pkt.num_bezier_curve_anchors);
	pr_hdr("knee_point_x = 0x%x\n",
		dbg_hdr10plus_pkt.knee_point_x);
	pr_hdr("knee_point_y = 0x%x\n",
		dbg_hdr10plus_pkt.knee_point_y);

	for (i = 0; i < 9; i++)
		pr_hdr("bezier_curve_anchors[%d] = 0x%x\n",
		i, dbg_hdr10plus_pkt.bezier_curve_anchors[i]);
	pr_hdr("graphics_overlay_flag = 0x%x\n",
		dbg_hdr10plus_pkt.graphics_overlay_flag);
	pr_hdr("no_delay_flag = 0x%x\n",
		dbg_hdr10plus_pkt.no_delay_flag);
	pr_hdr("\ntx vsif packet data print end\n");

	pr_hdr(HDR10_PLUS_VERSION);
}