overlay_base.c

来自「betaplayer_0.096源码 tcpmp老版本」· C语言 代码 · 共 647 行 · 第 1/2 页

			// portrait?
			if (r.Width < r.Height)
			{
				p->PreRotate = 1;
				if (p->InputDirection & DIR_SWAPXY)
					p->InputDirection ^= DIR_SWAPXY | DIR_MIRRORLEFTRIGHT;
				else
					p->InputDirection ^= DIR_SWAPXY | DIR_MIRRORUPDOWN;
			}
		}

		if (Update)
			OvlUpdateFX(p,0);
	}
	return ERR_NONE;
}

static void Done(overlay_base* p)
{
	if (p->Inited)
	{
		if (p->Show)
		{
			bool_t Old = p->Visible;
			p->Visible = 0;
			p->Show = 0;
			if (p->UpdateShow)
				p->UpdateShow(p); // maybe calls OvlUpdateShow
			p->Visible = Old;
		}
		p->Done(p);
		BlitRelease(p->Soft);
		p->Soft = NULL;
		p->Inited = 0;
		memset(&p->GUIAlignedRect,0,sizeof(rect));

		if (p->Primary)
			OvlInvalidate(p,&p->Viewport,1);
	}
}

int OvlUpdateShow(overlay_base* p,bool_t Temp)
{
	bool_t Show = !p->Disabled && p->Visible && (p->ColorKey != -1 || !p->Clipping || !p->Primary);
	if (!p->Updating && p->Show != Show)
	{
		p->Show = Show;
		p->Dirty = 1;
		p->LastTime = -1;

		if (p->Inited && !Temp)
		{
			if (p->UpdateShow)
				p->UpdateShow(p);

			if (p->Primary && !p->Overlay)
			{
				if (p->Show)
				{
					OvlInvalidate(p,&p->Viewport,1); // redraw border (zoom may have changed)
					OvlValidate(p,&p->GUIAlignedRect);
				}
				else
				{
					OvlInvalidate(p,&p->Viewport,0); // redraw other windows
					OvlValidate(p,&p->Viewport); // own window is fine
				}
			}
		}
	}
	return ERR_NONE;
}

static int Updating(overlay_base* p)
{
	if (!p->Updating)
	{
		UpdateInputDirection(p,0);
		OvlUpdateFX(p,p->ViewportChanged);
		OvlUpdateShow(p,0);
		p->ViewportChanged = 0;
	}
	return ERR_NONE;
}

static int Init(overlay_base* p)
{
	memset(&p->FX,0,sizeof(blitfx));
	memset(&p->Output,0,sizeof(video));
	memset(&p->DstAlignedRect,0,sizeof(rect));
	memset(&p->SrcAlignedRect,0,sizeof(rect));
	memset(&p->GUIAlignedRect,0,sizeof(rect));

	p->Disabled = 0;
	p->Updating = 0;
	p->Show = 0;
	p->Dirty = 1;
	p->LastTime = -1;
	p->ColorKey = -1;
	p->SetFX = 0;
	p->ClearFX = 0;
	p->InputHintDir = p->Input.Direction; // default: suggest no input direction change
	p->Caps = -1;

	if (p->Input.Pixel.Flags)
	{
		int Result;
		
		if (!p->Wnd)
			return ERR_INVALID_PARAM;

		if (Compressed(&p->Input.Pixel))
			return ERR_INVALID_DATA;

		if (p->Input.Width<=0) 
		{
			p->Disabled = 1;
			p->Input.Width = 2;
		}

		if (p->Input.Height<=0) 
		{
			p->Disabled = 1;
			p->Input.Height = 2;
		}

		Result = p->Init(p);

		if (Result != ERR_NONE)
		{
			if (Result == ERR_DEVICE_ERROR)
				NodeError((node*)p,ERR_ID,ERR_DEVICE_ERROR);
			return Result;
		}

		p->Inited = 1;
			
		UpdateInputDirection(p,0);
		OvlUpdateFX(p,1);
		OvlUpdateShow(p,0);

		if (p->Primary)
			OvlInvalidate(p,&p->Viewport,1);
	}
	return ERR_NONE;
}

int OvlBlitImage(overlay_base* p, const planes Data, const planes DataLast )
{
	planes Planes;
	int Result = p->Lock(p,Planes,1);
	if (Result==ERR_NONE)
	{
		BlitImage(p->Soft,Planes,Data,DataLast,-1,-1);
		p->Unlock(p);
	}
	return Result;
}

int OvlBlit(overlay_base* p,const planes Data,const planes LastData)
{
	int Result = ERR_NONE;

	if (p->Soft && p->Inited && p->Show)
	{
		if (p->Dirty)
			LastData = NULL;

		Result = p->Blit(p,Data,LastData);
		
		if (Result == ERR_NONE)
			p->Dirty = 0;
	}

	return Result;
}

void OvlAdjustOrientation(overlay_base* p, bool_t Combine)
{
	int Width = GetSystemMetrics(SM_CXSCREEN);
	int Height = GetSystemMetrics(SM_CYSCREEN);
	int Orientation;
	rect Virt;

	p->DisableOrientation = 1;

	if ((Width == p->Output.Width*2 && Height == p->Output.Height*2) || 
		(Width == p->Output.Height*2 && Height == p->Output.Width*2))
		p->Output.Pixel.Flags |= PF_PIXELDOUBLE;

	Orientation = QueryOrientation();

	if (Combine)
		p->Output.Direction = CombineDir(0,p->Output.Direction,Orientation);

	// still rotated? 
	PhyToVirt(NULL,&Virt,&p->Output);
	if (Width != Height && Virt.Width == Height && Virt.Height == Width)
	{
		if (Orientation & DIR_MIRRORLEFTRIGHT)
			p->Output.Direction ^= DIR_SWAPXY | DIR_MIRRORLEFTRIGHT;
		else
			p->Output.Direction ^= DIR_SWAPXY | DIR_MIRRORUPDOWN;
	}

	p->DisableOrientation = 0;
}

bool_t OvlTiming( overlay_base* p, const packet* Packet )
{
	if (Packet->CurrTime >= 0)
	{
		if (!p->Play && Packet->CurrTime == p->LastTime)
			return 0;

		if (Packet->RefTime >= (Packet->CurrTime + SHOWAHEAD))
			return 0;

		p->LastTime = Packet->CurrTime;
	}
	else
		p->LastTime = Packet->RefTime;

	//DEBUG_MSG2(-1,T("OvlTiming %d,%d"),Packet->CurrTime,Packet->RefTime);

	p->CurrTime = Packet->CurrTime;
	return 1;
}

int OvlSet(overlay_base* p,int No,const void* Data,int Size)
{
	int Result = ERR_INVALID_PARAM;
	switch (No)
	{
	case VOUT_WND:
		if (Size == sizeof(HWND))
		{
			p->Wnd = *(HWND*)Data;
			if (p->UpdateWnd)
				p->UpdateWnd(p);
			Result =ERR_NONE;
		}
		break;

	case VOUT_INPUT:
		if (Size == sizeof(packet))
		{
			const packet* Packet = (const packet*)Data;
			if (OvlTiming(p,Packet))
				Result = OvlBlit(p,Packet->Data,Packet->LastData);
			else
				Result = ERR_BUFFER_FULL;
		}
		break;

	case VOUT_INPUT | PACKET_FORMAT:
		if (!Size || Size == sizeof(video))
		{
			if (Size && p->Inited)
			{
				video Tmp = *(video*)Data;
				Tmp.Pitch = p->Input.Pitch;
				if ((p->Input.Direction ^ Tmp.Direction) & DIR_SWAPXY)
					SwapInt(&Tmp.Width,&Tmp.Height);
				Tmp.Direction = p->Input.Direction;
				if (EqVideo(&Tmp,&p->Input))
				{
					p->Input = *(video*)Data;
					UpdateInputDirection(p,0);
					OvlUpdateFX(p,1);
					Result = ERR_NONE;
					break;
				}
			}
			Done(p);
			if (Size)
				p->Input = *(video*)Data;
			else
				memset(&p->Input,0,sizeof(video));
			Result = Init(p);
		}
		break;

	case VOUT_PLAY: SETVALUE(p->Play,bool_t,ERR_NONE); break;
	case VOUT_DIRTY: SETVALUE(p->Dirty,bool_t,ERR_NONE); break;

	case VOUT_UPDATING: SETVALUECMP(p->Updating,bool_t,Updating(p),EqBool); break;
	case VOUT_CLIPPING: SETVALUE(p->Clipping,bool_t,OvlUpdateShow(p,0)); break;
	case VOUT_VISIBLE: SETVALUE(p->Visible,bool_t,OvlUpdateShow(p,0)); break;
	case VOUT_AUTOPREROTATE: SETVALUE(p->AutoPrerotate,bool_t,UpdateInputDirection(p,1)); break;
	case VOUT_ASPECT: SETVALUECMP(p->Aspect,fraction,OvlUpdateFX(p,0),EqFrac); break;
	case VOUT_FX: SETVALUE(p->OrigFX,blitfx,OvlUpdateFX(p,0)); break;
	case VOUT_VIEWPORT:
		if (Size == sizeof(rect))
		{
			Result = ERR_NONE;
			if (!EqRect(&p->Viewport,(const rect*)Data))
			{
				p->Viewport = *(const rect*)Data;
				if (p->Updating)
					p->ViewportChanged = 1;
				if (p->Inited)
					OvlUpdateFX(p,1);
			}
		}
		break;

	case VOUT_RESET:
		if (p->Inited && p->Reset)
		{
			p->Reset(p);
			p->Update(p);
			p->Dirty = 1;
			p->LastTime = -1;
		}
		Result = ERR_NONE;
		break;
	}
	return Result;
}

#endif