play_capture_hdmi.c

1. 8623L平台

		(pHDMI->zoom_x != x) || 
		(pHDMI->zoom_y != y) || 
		(pHDMI->zoom_w != w) || 
		(pHDMI->zoom_h != h)
	)) {
		if ((x == ZOOM_0) && (y == ZOOM_0) && (w == ZOOM_1) && (h == ZOOM_1)) {
			fprintf(stderr, "newavi - full screen zoom window\n");
		} else {
			fprintf(stderr, "newavi - zoom window: ");
			if (x >= ZOOM_0) {
				RMuint32 xx = (((x - ZOOM_0) * 10000) + ((ZOOM_1 - ZOOM_0) / 2)) / (ZOOM_1 - ZOOM_0);
				fprintf(stderr, "x=%ld.%02ld%% ", xx / 100, xx % 100);
			} else fprintf(stderr, "x=%ld ", x);
			if (y >= ZOOM_0) {
				RMuint32 yy = (((y - ZOOM_0) * 10000) + ((ZOOM_1 - ZOOM_0) / 2)) / (ZOOM_1 - ZOOM_0);
				fprintf(stderr, "y=%ld.%02ld%% ", yy / 100, yy % 100);
			} else fprintf(stderr, "y=%ld ", y);
			if (w >= ZOOM_0) {
				RMuint32 ww = (((w - ZOOM_0) * 10000) + ((ZOOM_1 - ZOOM_0) / 2)) / (ZOOM_1 - ZOOM_0);
				fprintf(stderr, "w=%ld.%02ld%% ", ww / 100, ww % 100);
			} else fprintf(stderr, "w=%ld ", w);
			if (h >= ZOOM_0) {
				RMuint32 hh = (((h - ZOOM_0) * 10000) + ((ZOOM_1 - ZOOM_0) / 2)) / (ZOOM_1 - ZOOM_0);
				fprintf(stderr, "h=%ld.%02ld%% ", hh / 100, hh % 100);
			} else fprintf(stderr, "h=%ld ", h);
			fprintf(stderr, "\n");
		}
		pHDMI->zoom_x = x;
		pHDMI->zoom_y = y;
		pHDMI->zoom_w = w;
		pHDMI->zoom_h = h;
		if (! update_mode) {
			// when update_mode, setup_input() is already performing set_scaler_source_zoom()
			set_scaler_source_zoom(dcc_info->pRUA, dcc_info->disp_info->osd_scaler[input], pHDMI->zoom_x, pHDMI->zoom_y, pHDMI->zoom_w, pHDMI->zoom_h);
		}
	}
	*/
	
	pHDMI->last_avi = *avi;
	
	/*
	// update capture, if neccessary
	if (update_mode) {
		fprintf(stderr, "newavi - updating capture mode\n");
		err = close_input(dcc_info, ppVideoSource, capture_opt, disp_opt, local_opt, input);
		if (RMFAILED(err)) RMDBGLOG((ENABLE, "Error closing capture!\n"));
		err = setup_input(dcc_info, ppVideoSource, capture_opt, disp_opt, audio_opt, local_opt, input);
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "FATAL: Error setting up capture!\n"));
			exit(1);
		}
		if (audio_opt->AudioIn) {
			fprintf(stderr, "AVI Video mode has changed, restarting audio\n");
			local_opt->restart_audio = TRUE;
		}
	}
	*/
	
	return RM_OK;
}

RMstatus capsam_hdmi_parse_spd_info_frame(
	struct capsam_hdmi_instance *pHDMI, 
	RMuint8 *header, 
	RMuint8 *data,  // spd_data[1] through spd_data[25] are used
	struct DH_SPDInfoFrame *pSPDInfo)
{
	RMascii Vendor[9], Product[17];
	enum DH_source_dev_info sdi;
	RMuint32 i;
	
	for (i = 0; i < 8; i++) Vendor[i] = (RMascii)data[i + 1];
	Vendor[8] = '\0';
	for (i = 0; i < 16; i++) Product[i] = (RMascii)data[i + 9];
	Product[16] = '\0';
	sdi = (enum DH_source_dev_info)data[25];
	
	fprintf(stderr, "[hdmi] SPD Info - Vendor: \"%s\", Product: \"%s\" - Category: %s (0x%02X)\n", 
		Vendor, Product, 
		(sdi == DH_source_dev_unknown) ? "unknown" : 
		(sdi == DH_source_dev_DigitalSTB) ? "DigitalSTB" : 
		(sdi == DH_source_dev_DVD) ? "DVD" : 
		(sdi == DH_source_dev_DVHS) ? "DVHS" : 
		(sdi == DH_source_dev_HDDVideo) ? "HDDVideo" : 
		(sdi == DH_source_dev_DVC) ? "DVC" : 
		(sdi == DH_source_dev_DSC) ? "DSC" : 
		(sdi == DH_source_dev_VideoCD) ? "VideoCD" : 
		(sdi == DH_source_dev_Game) ? "Game" : 
		(sdi == DH_source_dev_PC) ? "PC" : 
		(sdi == DH_source_dev_BluRay) ? "BluRay" : 
		(sdi == DH_source_dev_SACD) ? "SACD" : 
		"invalid value!", (RMuint8)sdi);
	
	if (pSPDInfo) {
		pSPDInfo->Version = header[1];
		if (pSPDInfo->VendorName) RMNCopyAscii(pSPDInfo->VendorName, Vendor, 9);
		if (pSPDInfo->ProductDescription) RMNCopyAscii(pSPDInfo->ProductDescription, Product, 17);
		pSPDInfo->SDI = sdi;
	}
	
	return RM_OK;
}

RMstatus capsam_hdmi_parse_audio_info_frame(
	struct capsam_hdmi_instance *pHDMI, 
	RMuint8 *header, 
	RMuint8 *data, 
	struct DH_AudioInfoFrame *pAudioInfo)
{
	struct DH_AudioInfoFrame aif;
	
	fprintf(stderr, "[hdmi] new Audio InfoFrame\n");
	
	aif.Version = header[1];
	aif.CodingType = (enum DH_AudioCodingType)RMunshiftBits(data[1], 4, 4);
	aif.ChannelCount = (enum DH_AudioChannelCount)RMunshiftBits(data[1], 3, 0);
	aif.SampleFrequency = (enum DH_AudioSampleFrequency)RMunshiftBits(data[2], 3, 2);
	aif.SampleSize = (enum DH_AudioSampleSize)RMunshiftBits(data[2], 2, 0);
	aif.LFE_Ch3_Enable = RMunshiftBool(data[4], 0);
	aif.FC_Ch4_Enable = RMunshiftBool(data[4], 1);
	aif.CA = (enum DH_Audio_ChannelAssignment)RMunshiftBits(data[4], 6, 2);
	aif.DownMixInhibit = RMunshiftBool(data[5], 7);
	aif.LevelShift = RMunshiftBits(data[5], 4, 3);
	aif.MaxBitRate = data[3];  // codec dependent
	
	fprintf(stderr, "[hdmi]  Audio Coding Type: ");
	switch (aif.CodingType) {
		case DH_AudioCodingType_FromStreamHeader: fprintf(stderr, "Refer to stream header\n"); break;
		case DH_AudioCodingType_PCM: fprintf(stderr, "IEC60958 PCM\n"); break;
		case DH_AudioCodingType_AC3: fprintf(stderr, "AC-3\n"); break;
		case DH_AudioCodingType_MPEG1_12: fprintf(stderr, "MPEG1 Layer 1/2\n"); break;
		case DH_AudioCodingType_MPEG1_3: fprintf(stderr, "MPEG1 Layer 3\n"); break;
		case DH_AudioCodingType_MPEG2: fprintf(stderr, "MPEG2\n"); break;
		case DH_AudioCodingType_AAC: fprintf(stderr, "AAC\n"); break;
		case DH_AudioCodingType_DTS: fprintf(stderr, "DTS\n"); break;
		case DH_AudioCodingType_ATRAC: fprintf(stderr, "ATRAC\n"); break;
		case DH_AudioCodingType_OneBit: fprintf(stderr, "One Bit Audio\n"); break;
		case DH_AudioCodingType_DDPlus: fprintf(stderr, "Dolby Digital +\n"); break;
		case DH_AudioCodingType_DTSHD: fprintf(stderr, "DTS-HD\n"); break;
		case DH_AudioCodingType_MLP: fprintf(stderr, "MAT (MLP)\n"); break;
		case DH_AudioCodingType_DST: fprintf(stderr, "DST\n"); break;
		case DH_AudioCodingType_WMAPro: fprintf(stderr, "WMA Pro\n"); break;
		default: fprintf(stderr, "Unknown!\n"); break;
	}
	fprintf(stderr, "[hdmi]  Audio Channel Count: ");
	switch (aif.ChannelCount) {
		case DH_AudioChannelCount_FromStreamHeader: fprintf(stderr, "Refer to stream header\n"); break;
		case DH_AudioChannelCount_2: 
		case DH_AudioChannelCount_3: 
		case DH_AudioChannelCount_4: 
		case DH_AudioChannelCount_5: 
		case DH_AudioChannelCount_6: 
		case DH_AudioChannelCount_7: 
		case DH_AudioChannelCount_8: 
			fprintf(stderr, "%u channel\n", 2 + (aif.ChannelCount - DH_AudioChannelCount_2)); 
			break;
		default: fprintf(stderr, "Unknown!\n"); break;
	}
	fprintf(stderr, "[hdmi]  Audio Sample Frequency: ");
	switch (aif.SampleFrequency) {
		case DH_AudioSampleFrequency_FromStreamHeader: fprintf(stderr, "Refer to stream header\n"); break;
		case DH_AudioSampleFrequency_32000: fprintf(stderr, "32 kHz\n"); break;
		case DH_AudioSampleFrequency_44100: fprintf(stderr, "44.1 kHz\n"); break;
		case DH_AudioSampleFrequency_48000: fprintf(stderr, "48 kHz\n"); break;
		case DH_AudioSampleFrequency_88200: fprintf(stderr, "88.2 kHz\n"); break;
		case DH_AudioSampleFrequency_96000: fprintf(stderr, "96 kHz\n"); break;
		case DH_AudioSampleFrequency_176400: fprintf(stderr, "176.4 kHz\n"); break;
		case DH_AudioSampleFrequency_192000: fprintf(stderr, "192 kHz\n"); break;
		default: fprintf(stderr, "Unknown!\n"); break;
	}
	fprintf(stderr, "[hdmi]  Audio Sample Size: ");
	switch (aif.SampleSize) {
		case DH_AudioSampleSize_FromStreamHeader: fprintf(stderr, "Refer to stream header\n"); break;
		case DH_AudioSampleSize_16: fprintf(stderr, "16 bit\n"); break;
		case DH_AudioSampleSize_20: fprintf(stderr, "20 bit\n"); break;
		case DH_AudioSampleSize_24: fprintf(stderr, "24 bit\n"); break;
		default: fprintf(stderr, "Unknown!\n"); break;
	}
	fprintf(stderr, "[hdmi]  Channel Assignment: ");
	switch (aif.CA) {
		case DH_Audio_CA_none: 
			fprintf(stderr, "--- --- -- --"); break;
		case DH_Audio_CA_RC5: 
			fprintf(stderr, "--- --- -- RC"); break;
		case DH_Audio_CA_RL5_RR6: 
			fprintf(stderr, "--- --- RR RL"); break;
		case DH_Audio_CA_RL5_RR6_RC7: 
			fprintf(stderr, "---  RC RR RL"); break;
		case DH_Audio_CA_RL5_RR6_RLC7_RRC8: 
			fprintf(stderr, "RRC RLC RR RL"); break;
		case DH_Audio_CA_FLC7_FRC8: 
			fprintf(stderr, "FRC FLC -- --"); break;
		case DH_Audio_CA_RC5_FLC7_FRC8: 
			fprintf(stderr, "FRC FLC -- RC"); break;
		case DH_Audio_CA_RL5_RR6_FLC7_FRC8: 
			fprintf(stderr, "FRC FLC RR RL"); break;
		default: 
			fprintf(stderr, "XXX XXX XX XX"); break;
	}
	fprintf(stderr, " %s %s FR FL\n", 
		aif.FC_Ch4_Enable ? "FC" : "--", 
		aif.LFE_Ch3_Enable ? "LFE" : "---");
	fprintf(stderr, "[hdmi]  Level Shift: %lu dB\n", aif.LevelShift);
	fprintf(stderr, "[hdmi]  Down Mix %s\n", aif.DownMixInhibit ? "Prohibited" : "Permitted");
	if ((aif.CodingType >= DH_AudioCodingType_AC3) && (aif.CodingType <= DH_AudioCodingType_ATRAC)) {
		fprintf(stderr, "[hdmi]  Maximum Bit Rate: %lu kHz\n", aif.MaxBitRate * 8);
	}
	
	if (pAudioInfo) RMMemcpy(pAudioInfo, &aif, sizeof(struct DH_AudioInfoFrame));
	
	return RM_OK;
}

RMstatus capsam_hdmi_parse_mpeg_info_frame(
	struct capsam_hdmi_instance *pHDMI, 
	RMuint8 *header, 
	RMuint8 *data, 
	struct DH_MPEGInfoFrame *pMPEGInfo)
{
	struct DH_MPEGInfoFrame mpeg;
	
	fprintf(stderr, "[hdmi] new MPEG InfoFrame\n");
	
	mpeg.Version = header[1];
	mpeg.BitRate = 0;
	RMinsShiftBits(&(mpeg.BitRate), data[1], 8,  0);
	RMinsShiftBits(&(mpeg.BitRate), data[2], 8,  8);
	RMinsShiftBits(&(mpeg.BitRate), data[3], 8, 16);
	RMinsShiftBits(&(mpeg.BitRate), data[4], 8, 24);
	mpeg.RepeatedField = RMunshiftBool(data[5], 4);
	mpeg.Frame = (enum DH_MPEG_Frame)RMunshiftBits(data[5], 2, 0);
	
	fprintf(stderr, "[hdmi]  MPEG Bit Rate: %lu Hz\n", mpeg.BitRate);
	fprintf(stderr, "[hdmi]  %s Field\n", mpeg.RepeatedField ? "Repeated" : "New");
	fprintf(stderr, "[hdmi]  MPEG Frame: %s\n", 
		(mpeg.Frame == DH_MPEG_Frame_unknown) ? "Unknown" : 
		(mpeg.Frame == DH_MPEG_Frame_I) ? "I Picture" : 
		(mpeg.Frame == DH_MPEG_Frame_B) ? "B Picture" : 
		(mpeg.Frame == DH_MPEG_Frame_P) ? "P Picture" : 
		"Invalid");
	
	if (pMPEGInfo) RMMemcpy(pMPEGInfo, &mpeg, sizeof(struct DH_MPEGInfoFrame));
	
	return RM_OK;
}



/*** Interrupt handling functions ***/

/* Returns RM_OK if capsam_hdmi_handle_int() needs to be called */
RMstatus capsam_hdmi_check_int(struct capsam_hdmi_instance *pHDMI)
{
	// Sanity checks
	if (pHDMI == NULL) return RM_FATALINVALIDPOINTER;
	
	switch (pHDMI->chip) {
	case capsam_chip_SiI9031:
		return capsam_SiI9031_check_int(pHDMI->pSiI9031);
	case capsam_chip_AD9380:
		return capsam_AD9380_check_int(pHDMI->pAD9380);
	default:
		return RM_ERROR;
	}
}

/* check and handle interrupts and/or other changes on the chip, 
   fill in update information to pUpdate */
RMstatus capsam_hdmi_handle_int(
	struct capsam_hdmi_instance *pHDMI, 
	struct capsam_update *pUpdate)
{
	RMstatus err;
	
	// Sanity checks
	if (pHDMI == NULL) return RM_FATALINVALIDPOINTER;
	
	switch (pHDMI->chip) {
	case capsam_chip_SiI9031:
		err = capsam_SiI9031_handle_int(pHDMI->pSiI9031, pUpdate, &(pHDMI->UpdateHDMI));
		break;
	case capsam_chip_AD9380:
		err = capsam_AD9380_handle_int(pHDMI->pAD9380, pUpdate, &(pHDMI->UpdateHDMI));
		break;
	default:
		err = RM_ERROR;
		break;
	}
	if (RMFAILED(err)) return err;
	
	if (pHDMI->UpdateHDMI.AudioCPPacketUpdate) {
		RMuint8 header[3], data[28];
		pHDMI->UpdateHDMI.AudioCPPacketUpdate = FALSE;
		err = capsam_hdmi_read_info_frame(pHDMI, 0x04, 0x00, header, data, sizeof(data) / sizeof(RMuint8), TRUE);
		if (RMFAILED(err)) return err;
		err = capsam_hdmi_parse_audio_cp_packet(pHDMI, header, data, NULL);
	}
	if (pHDMI->UpdateHDMI.ISRC1PacketUpdate) {
		RMuint8 header[3], data[28];
		pHDMI->UpdateHDMI.ISRC1PacketUpdate = FALSE;
		err = capsam_hdmi_read_info_frame(pHDMI, 0x05, 0x00, header, data, sizeof(data) / sizeof(RMuint8), TRUE);
		if (RMFAILED(err)) return err;
		err = capsam_hdmi_parse_isrc1_packet(pHDMI, header, data, NULL, NULL);
	}
	if (pHDMI->UpdateHDMI.ISRC2PacketUpdate) {
		RMuint8 header[3], data[28];
		pHDMI->UpdateHDMI.ISRC2PacketUpdate = FALSE;
		err = capsam_hdmi_read_info_frame(pHDMI, 0x06, 0x00, header, data, sizeof(data) / sizeof(RMuint8), TRUE);
		if (RMFAILED(err)) return err;
		err = capsam_hdmi_parse_isrc2_packet(pHDMI, header, data, NULL, NULL);
	}
	if (pHDMI->UpdateHDMI.GamutMetadataPacketUpdate) {
		RMuint8 header[3], data[28];
		pHDMI->UpdateHDMI.GamutMetadataPacketUpdate = FALSE;
		err = capsam_hdmi_read_info_frame(pHDMI, 0x0A, 0x00, header, data, sizeof(data) / sizeof(RMuint8), TRUE);
		if (RMFAILED(err)) return err;
		err = capsam_hdmi_parse_gamut_packet(pHDMI, header, data, NULL);
	}
	if (pHDMI->UpdateHDMI.VendorSpecificInfoFrameUpdate) {
		RMuint8 header[3], data[28];
		pHDMI->UpdateHDMI.VendorSpecificInfoFrameUpdate = FALSE;
		err = capsam_hdmi_read_info_frame(pHDMI, 0x81, 0x00, header, data, sizeof(data) / sizeof(RMuint8), TRUE);
		if (RMFAILED(err)) return err;
		err = capsam_hdmi_parse_vendor_info_frame(pHDMI, header, data, NULL, NULL, NULL);
	}
	if (pHDMI->UpdateHDMI.AVIInfoFrameInvalidate) {
		pHDMI->UpdateHDMI.AVIInfoFrameInvalidate = FALSE;
		pHDMI->last_avi.valid = FALSE;
	}
	if (pHDMI->UpdateHDMI.AVIInfoFrameUpdate) {
		RMuint8 header[3], data[16];
		struct capsam_hdmi_avi_info avi;
		pHDMI->UpdateHDMI.AVIInfoFrameUpdate = FALSE;
		err = capsam_hdmi_read_info_frame(pHDMI, 0x82, 0x00, header, data, sizeof(data) / sizeof(RMuint8), TRUE);
		if (RMFAILED(err)) return err;
		capsam_hdmi_parse_avi_struct(data, &avi);
		err = capsam_hdmi_handle_avi_info_frame(pHDMI, &avi, pUpdate);
	}
	if (pHDMI->UpdateHDMI.SPDInfoFrameUpdate) {
		RMuint8 header[3], data[28];
		pHDMI->UpdateHDMI.SPDInfoFrameUpdate = FALSE;
		err = capsam_hdmi_read_info_frame(pHDMI, 0x83, 0x00, header, data, sizeof(data) / sizeof(RMuint8), TRUE);
		if (RMFAILED(err)) return err;
		err = capsam_hdmi_parse_spd_info_frame(pHDMI, header, data, NULL);
	}
	if (pHDMI->UpdateHDMI.AudioInfoFrameUpdate) {
		RMuint8 header[3], data[28];
		pHDMI->UpdateHDMI.AudioInfoFrameUpdate = FALSE;
		err = capsam_hdmi_read_info_frame(pHDMI, 0x84, 0x00, header, data, sizeof(data) / sizeof(RMuint8), TRUE);
		if (RMFAILED(err)) return err;
		err = capsam_hdmi_parse_audio_info_frame(pHDMI, header, data, NULL);
	}
	if (pHDMI->UpdateHDMI.MPEGInfoFrameUpdate) {
		RMuint8 header[3], data[28];
		pHDMI->UpdateHDMI.MPEGInfoFrameUpdate = FALSE;
		err = capsam_hdmi_read_info_frame(pHDMI, 0x85, 0x00, header, data, sizeof(data) / sizeof(RMuint8), TRUE);
		if (RMFAILED(err)) return err;
		err = capsam_hdmi_parse_mpeg_info_frame(pHDMI, header, data, NULL);
	}
	
	return err;
}

// TODO has to go into main or common
/* helper function to deduct probablt picture aspect ratio from video standard */
void capsam_get_aspect_ratio_from_video_mode(
	enum EMhwlibTVStandard TVStandard, 
	struct EMhwlibTVFormatDigital *pTVFormat, 
	RMbool wide,  // ambiguous modes (SDTV,EDTV): FALSE=4:3, TRUE=16:9 anamorphic
	RMuint32 *asp_x, 
	RMuint32 *asp_y)
{
	if (!asp_x || !asp_y) return;
	
	// determine aspect ratio from video mode
	switch (TVStandard) {
	case EMhwlibTVStandard_Custom:
		if (pTVFormat) {
			*asp_x = pTVFormat->ActiveWidth;
			*asp_y = pTVFormat->ActiveHeight;
			capsam_reduce_aspect_rati