invtelec.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

/* ***** BEGIN LICENSE BLOCK ***** 
 * Version: RCSL 1.0/RPSL 1.0 
 *  
 * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
 *      
 * The contents of this file, and the files included with this file, are 
 * subject to the current version of the RealNetworks Public Source License 
 * Version 1.0 (the "RPSL") available at 
 * http://www.helixcommunity.org/content/rpsl unless you have licensed 
 * the file under the RealNetworks Community Source License Version 1.0 
 * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
 * in which case the RCSL will apply. You may also obtain the license terms 
 * directly from RealNetworks.  You may not use this file except in 
 * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
 * applicable to this file, the RCSL.  Please see the applicable RPSL or 
 * RCSL for the rights, obligations and limitations governing use of the 
 * contents of the file.  
 *  
 * This file is part of the Helix DNA Technology. RealNetworks is the 
 * developer of the Original Code and owns the copyrights in the portions 
 * it created. 
 *  
 * This file, and the files included with this file, is distributed and made 
 * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
 * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
 * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
 * 
 * Technology Compatibility Kit Test Suite(s) Location: 
 *    http://www.helixcommunity.org/content/tck 
 * 
 * Contributor(s): 
 *  
 * ***** END LICENSE BLOCK ***** */ 




////////////////////////////////////////////////////////
//	include files
////////////////////////////////////////////////////////

#include "invtelec.h"
#include "hxtick.h"
#include "mmx_util.h"
#include "hlxclib/stdlib.h"
#include "hlxclib/string.h"
#include "hlxclib/math.h"

////////////////////////////////////////////////////////
//	internal prototypes
////////////////////////////////////////////////////////

static T_INVTELE_RESULT 
InvTelecineDetect(
	UCHAR *data, UCHAR *prevData, 
	double frameRate, 
	ULONG32 timestamp, 
	ULONG32 pels, ULONG32 lines,
	BOOL bDeInterlaced,
	T_INVTELE_STATE *state);

//#define CODEC_DEBUG_32PULLDOWN
#ifdef CODEC_DEBUG_32PULLDOWN
#include <stdio.h>
static FILE *fp_log = NULL;
#endif


const T_INVTELE_FLOAT inThresh[PULLDOWN_HIST_LEN+1] = {3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4};
const T_INVTELE_FLOAT outThresh[PULLDOWN_HIST_LEN+1] = {1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2};

#ifdef ALLOW_MMX_INVTELE

void
SumSqaredFrameDiff_MMX(
	unsigned char *frame, 
	unsigned char *prev_frame,
	int pels,
	int lines,
	int pitch,
	float *ssd_odd,
	float *ssd_even);

void
RestitchCheck_MMX(
	unsigned char *frame, 
	unsigned char *prev_frame,
	int pels,
	int lines,
	int pitch,
	float *ssd_new,
	float *ssd_old);

#endif

////////////////////////////////////////////////////////
//
//	InitInvTelecine
//
//	Allocates and initializes memory for state information
//
//	Parameters:
//		state:	Pointer to the allocated state pointer
//
////////////////////////////////////////////////////////

INT32
InitInvTelecine(T_INVTELE_STATE **state)
{
	T_INVTELE_STATE *new_state = 0;

	if (*state != 0)
		return 1;

	new_state = (T_INVTELE_STATE *)malloc(sizeof(T_INVTELE_STATE));

	if (new_state == 0)
	{
		return 1;
	}

	new_state->impl_id = INVTELE_IMPL_ID_C;
	new_state->firstFrame = TRUE;
	new_state->ulPulldownActiveTimerIntl = 0;
	new_state->ulPulldownActiveTimerProg = 0;
	new_state->lastRemovedTimestamp = 0;
	new_state->frameCountMod = 4;
	new_state->frameRemovalPattern = 4;
	new_state->NTSCTrackingFrameCounter = 500;
	new_state->interleaveEvenFlag = FALSE;
	new_state->interleaveOddFlag = FALSE;
	new_state->checkNextFrameForInterlace = FALSE;
	new_state->checkNextFrameForProgressive = FALSE;
	new_state->bProgressiveTelecineSeen = FALSE;
	new_state->bInterlacedTelecineSeen = FALSE;
	new_state->pulldownTimeBuffer = 0;

	for (int i = 0; i < PULLDOWN_HIST_LEN; i++)
	{
		new_state->pulldownSadHistEven[i] = UN_INIT_SAD;
		new_state->pulldownSadHistOdd[i] = UN_INIT_SAD;
		new_state->pulldownSadHistAll[i] = UN_INIT_SAD;
		new_state->pulldownTimeHist[i] = 0;
	}

#ifdef ALLOW_MMX_INVTELE
	// Check for MMx availability
    if (checkMmxAvailablity() & CPU_HAS_MMX)
		new_state->impl_id = INVTELE_IMPL_ID_MMX;
#endif

	*state = new_state;

	return 0;
}


////////////////////////////////////////////////////////
//
//	FreeInvTelecine
//
//	Frees memory for state information
//
//	Parameters:
//		state:	Pointer to the allocated state pointer
//
////////////////////////////////////////////////////////

void
FreeInvTelecine(T_INVTELE_STATE **state)
{
	if (*state != 0)
		free(*state);

	*state = 0;
}


////////////////////////////////////////////////////////
//
//	IsContentProgressiveTelecine
//
//	Returns TRUE if the telecine detector has seen 
//	  interlaced telecine content
//
//	Parameters:
//		state:	State pointer
//
////////////////////////////////////////////////////////

BOOL
IsContentProgressiveTelecine(T_INVTELE_STATE *state)
{
	if (state != 0)
		return (state->bProgressiveTelecineSeen)?(TRUE):(FALSE);

	return FALSE;
}


////////////////////////////////////////////////////////
//
//	IsContentInterlacedTelecine
//
//	Returns TRUE if the telecine detector has seen 
//	  progressive telecine content
//
//	Parameters:
//		state:	State pointer
//
////////////////////////////////////////////////////////

BOOL
IsContentInterlacedTelecine(T_INVTELE_STATE *state)
{
	if (state != 0)
		return (state->bInterlacedTelecineSeen)?(TRUE):(FALSE);

	return FALSE;
}


////////////////////////////////////////////////////////
//
//	GetTelecinePattern
//
//	Returns the frame modulo for the removal pattern
//
//	Parameters:
//		state:	State pointer
//
////////////////////////////////////////////////////////

UCHAR
GetTelecinePattern(T_INVTELE_STATE *state)
{
	INT32 pattern;

	if (state != 0)
		pattern = (state->frameRemovalPattern - state->frameCountMod) % 5;
	else
		pattern = 0;

	if (pattern < 0)
		pattern +=5;
		
	return (UCHAR)pattern;
}


////////////////////////////////////////////////////////
//
//	SetTelecinePattern
//
//	Sets the frame modulo for the removal pattern
//
//	Parameters:
//		state:	State pointer
//
////////////////////////////////////////////////////////

void
SetTelecinePattern(T_INVTELE_STATE *state, UCHAR telecine_pattern)
{
	if (state != 0)
		state->frameRemovalPattern = ((telecine_pattern + state->frameCountMod) % 5);
}



////////////////////////////////////////////////////////
//
//	DoInvTelecine
//
//	Performs inverse Telecine
//
//	Parameters:
//		data:			Pointer to the current planar frame.
//		prevData:		Pointer to the previous source frame.
//		frameRate:		The input frame rate.
//		timestamp:		The timestamp of the current frame.
//						This value will be adjusted to account
//						for the change to 24 fps
//		pels, lines:	Frame dimensions.
//		bDeInterlaced:	Should be set to TRUE if frame is known
//						to be progressive.
//		state:			State pointer
//
////////////////////////////////////////////////////////

T_INVTELE_RESULT
DoInvTelecine(
	UCHAR *data, 
	UCHAR *prevData, 
	double frameRate, 
	ULONG32 &timestamp, 
	ULONG32 pels, ULONG32 lines, 
	BOOL bDeInterlaced, 
	T_INVTELE_STATE *state)
{
	T_INVTELE_RESULT ret;

	if (frameRate < 25.5)
		return (INVTELE_RESULT_LOW_FRAMERATE);

#ifdef CODEC_DEBUG_32PULLDOWN
  if(fp_log == NULL)
	  fp_log = fopen("c:\\pulldown.log","w");
#endif

	ret = InvTelecineDetect(data, prevData, frameRate, timestamp, pels, lines, bDeInterlaced, state);

	// hack -- don't drop more than 1 out of every 5 progressive frames
	if ((state->pulldownTimeBuffer > 1) && 
		(bDeInterlaced || lines < 242) &&
		(ret == INVTELE_RESULT_DROP_FRAME))
	{
		ret = INVTELE_RESULT_FRAME_OK;
	}

	if (ret == INVTELE_RESULT_DROP_FRAME)
	{
		state->pulldownTimeBuffer = 33;
	}
	else
	{
		// adjust timestamp 
		// -- allowed offsets will be -33, -25, -17, -9, -1, 0
		timestamp -= state->pulldownTimeBuffer;

		if (state->pulldownTimeBuffer > 8)
		{
			state->pulldownTimeBuffer -= 8;
		}
		else
		{
			state->pulldownTimeBuffer = 0;
		}
	}

	return (ret);
}



////////////////////////////////////////////////////////
//
//	InvTelecineDetect
//
//	Performs detection of the inverse telecine pattern
//
//	Parameters:
//		data:			Pointer to the current planar frame.
//		prevData:		Pointer to the previous source frame.
//		frameRate:		The input frame rate.
//		timestamp:		The timestamp of the current frame.
//		pels, lines:	Frame dimensions.
//		bDeInterlaced:	Should be set to TRUE if frame is known
//						to be progressive.
//		state:			State pointer
//
////////////////////////////////////////////////////////

T_INVTELE_RESULT
InvTelecineDetect
(
	 UCHAR *data, 
	 UCHAR *prevData, 
	 double frameRate, 
	 ULONG32 timestamp, 
	 ULONG32 pels, ULONG32 lines,
	 BOOL bDeInterlaced,
	 T_INVTELE_STATE *state
)
{
	unsigned int i, j, k, ll;
	ULONG32 patternStart, histLength;
	LONG32 *pNew, *pOld;
	float temp;
	float sumEven = 0.0f, sumOdd = 0.0f;
	float sumOld = 0.0f, sumNew = 0.0f;
	float sumAll = 0.0f;

	float	inGroupMeanEven[5],outGroupMeanEven[5];
	float	inGroupStdEven[5],outGroupStdEven[5];
	ULONG32 inGroupCountEven,outGroupCountEven;
	float	outMinEven[5],outMaxEven[5];
	float	inMaxEven[5],inMinEven[5];
	BOOL	groupValidFlagEven[5];

	float	inGroupMeanOdd[5],outGroupMeanOdd[5];
	float	inGroupStdOdd[5],outGroupStdOdd[5];
	ULONG32	inGroupCountOdd,outGroupCountOdd;
	float	outMinOdd[5],outMaxOdd[5];
	float	inMaxOdd[5],inMinOdd[5];
	BOOL	groupValidFlagOdd[5];

	float	inGroupMean[5], outGroupMean[5];
	float	inGroupStd[5], outGroupStd[5];
	ULONG32 inGroupCount,outGroupCount;
	float	outMin[5],outMax[5],inMax[5];
	BOOL	groupValidFlag[5];

	ULONG32 timeSinceLastFrame;
	BOOL	obviousPatternFlag = FALSE;
	BOOL	sceneChangeFlag = FALSE;

	if (state->firstFrame == TRUE)
	{
		// Initialize history timestamps with this first timestamp