public void CopyFrom(MFVideoNormalizedRect from)
{
left = from.left;
top = from.top;
right = from.right;
bottom = from.bottom;
}
public override bool Equals(object obj)
{
if (obj is MFVideoNormalizedRect)
{
MFVideoNormalizedRect cmp = (MFVideoNormalizedRect)obj;
return(right == cmp.right && bottom == cmp.bottom && left == cmp.left && top == cmp.top);
}
return(false);
}
protected int m_TokenCounter; // Counter. Incremented whenever we create new samples.
#endregion Fields
#region Constructors
/// <summary>
/// Constructor
/// </summary>
public EVRCustomPresenter()
{
if (System.Threading.Thread.CurrentThread.GetApartmentState() != System.Threading.ApartmentState.MTA)
{
throw new Exception("Unsupported theading model");
}
m_iDiscarded = 0;
m_pClock = null;
m_pMixer = null;
m_pMediaEventSink = null;
m_h2 = null;
m_pMediaType = null;
m_bSampleNotify = false;
m_bRepaint = false;
m_bEndStreaming = false;
m_bPrerolled = false;
m_RenderState = RenderState.Shutdown;
m_fRate = 1.0f;
m_TokenCounter = 0;
m_pD3DPresentEngine = new D3DPresentEngine();
m_FrameStep = new FrameStep(); // Frame-stepping information.
m_nrcSource = new MFVideoNormalizedRect(0.0f, 0.0f, 1.0f, 1.0f);
m_scheduler = new Scheduler(D3DPresentEngine.PRESENTER_BUFFER_COUNT, m_pD3DPresentEngine); // Manages scheduling of samples.
m_SamplePool = new SamplePool(D3DPresentEngine.PRESENTER_BUFFER_COUNT); // Pool of allocated samples.
// Force load of mf.dll now, rather than when we try to start streaming
DllCanUnloadNow();
}
public int GetVideoPosition(MFVideoNormalizedRect pnrcSource, MFRect prcDest)
{
// Make sure we *never* leave this entry point with an exception
try
{
lock (this)
{
if (pnrcSource == null || prcDest == null)
{
throw new COMException("EVRCustomPresenter::GetVideoPosition", E_Pointer);
}
pnrcSource.CopyFrom(m_nrcSource);
prcDest.CopyFrom(m_pD3DPresentEngine.GetDestinationRect());
}
return S_Ok;
}
catch (Exception e)
{
return Marshal.GetHRForException(e);
}
}
protected void SetMixerSourceRect(IMFTransform pMixer, MFVideoNormalizedRect nrcSource)
{
if (pMixer == null)
{
throw new COMException("SetMixerSourceRect", E_Pointer);
}
int hr;
IMFAttributes pAttributes = null;
hr = pMixer.GetAttributes(out pAttributes);
MFError.ThrowExceptionForHR(hr);
Utils.MFSetBlob(pAttributes, MFAttributesClsid.VIDEO_ZOOM_RECT, nrcSource);
SafeRelease(pAttributes); pAttributes = null;
}
public int SetVideoPosition(MFVideoNormalizedRect pnrcSource, MFRect prcDest)
{
// Make sure we *never* leave this entry point with an exception
try
{
lock (this)
{
// Validate parameters.
// One parameter can be NULL, but not both.
if (pnrcSource == null && prcDest == null)
{
throw new COMException("EVRCustomPresenter::SetVideoPosition", E_Pointer);
}
// Validate the rectangles.
if (pnrcSource != null)
{
// The source rectangle cannot be flipped.
if ((pnrcSource.left > pnrcSource.right) ||
(pnrcSource.top > pnrcSource.bottom))
{
throw new COMException("Bad source", E_InvalidArgument);
}
// The source rectangle has range (0..1)
if ((pnrcSource.left < 0) || (pnrcSource.right > 1) ||
(pnrcSource.top < 0) || (pnrcSource.bottom > 1))
{
throw new COMException("source has invalid values", E_InvalidArgument);
}
}
if (prcDest != null)
{
// The destination rectangle cannot be flipped.
if ((prcDest.left > prcDest.right) ||
(prcDest.top > prcDest.bottom))
{
throw new COMException("bad destination", E_InvalidArgument);
}
}
// Update the source rectangle. Source clipping is performed by the mixer.
if (pnrcSource != null)
{
m_nrcSource.CopyFrom(pnrcSource);
if (m_pMixer != null)
{
SetMixerSourceRect(m_pMixer, m_nrcSource);
}
}
// Update the destination rectangle.
if (prcDest != null)
{
MFRect rcOldDest = m_pD3DPresentEngine.GetDestinationRect();
// Check if the destination rectangle changed.
if (!rcOldDest.Equals(prcDest))
{
m_pD3DPresentEngine.SetDestinationRect(prcDest);
// Set a new media type on the mixer.
if (m_pMixer != null)
{
try
{
RenegotiateMediaType();
}
catch (COMException e)
{
if (e.ErrorCode == MFError.MF_E_TRANSFORM_TYPE_NOT_SET)
{
// This error means that the mixer is not ready for the media type.
// Not a failure case -- the EVR will notify us when we need to set
// the type on the mixer.
}
else
{
throw;
}
}
// The media type changed. Request a repaint of the current frame.
m_bRepaint = true;
ProcessOutput(); // Ignore errors, the mixer might not have a video frame.
}
}
}
}
return S_Ok;
}
catch (Exception e)
{
return Marshal.GetHRForException(e);
}
}
void TestSetVideoPosition()
{
MFVideoNormalizedRect r1 = new MFVideoNormalizedRect();
MFRect r2 = new MFRect();
r1.bottom = 1.0f;
r1.right = 0.9f;
r2.bottom = 234;
r2.right = 345;
int hr = m_vdc.SetVideoPosition(r1, r2);
MFError.ThrowExceptionForHR(hr);
MFVideoNormalizedRect r3 = new MFVideoNormalizedRect();
MFRect r4 = new MFRect();
hr = m_vdc.GetVideoPosition(r3, r4);
MFError.ThrowExceptionForHR(hr);
}
internal float ChangeZoom(float adjustAmount)
{
if (evrDisplay != null)
{
zoomAmt += adjustAmount;
if (zoomAmt < 1.0f)
zoomAmt = 1.0f;
MFVideoNormalizedRect sRect = new MFVideoNormalizedRect();
if (zoomAmt == 1.0)
{
sRect.top = 0;
sRect.left = 0;
sRect.right = 1;
sRect.bottom = 1;
}
else
{
float fMargin = (0.5f - (0.5f / zoomAmt));
sRect.top = fMargin;
sRect.left = fMargin;
sRect.right = (1.0f - fMargin);
sRect.bottom = (1.0f - fMargin);
}
this.evrDisplay.SetVideoPosition(sRect, null);
}
return zoomAmt;
}
//protected virtual Rectangle GetInnerRectangle(Rectangle outerRectangle, double innerRatio)
//{
// Rectangle innerRectangle = outerRectangle;
// double outerRatio = (double)outerRectangle.Width / (double)outerRectangle.Height;
// if (outerRatio >= innerRatio)
// {
// innerRectangle.Width = (int)((double)outerRectangle.Height * innerRatio);
// innerRectangle.X = (int)((outerRectangle.Width - innerRectangle.Width) / 2.0);
// }
// else
// {
// innerRectangle.Height = (int)((double)outerRectangle.Width / innerRatio);
// innerRectangle.Y = (int)((outerRectangle.Height - innerRectangle.Height) / 2.0);
// }
// return innerRectangle;
//}
protected Rectangle[] GetBlackBands()
{
Rectangle outerRectangle = this.hostingControl.ClientRectangle;
DsRect innerDsRect = new DsRect();
int hr;
if (useEVR)
{
MFVideoNormalizedRect pnrcSource = new MFVideoNormalizedRect();
MediaFoundation.Misc.MFRect prcDest = new MediaFoundation.Misc.MFRect();
hr = evrVideoDisplayControl.GetVideoPosition(pnrcSource, prcDest);
innerDsRect = DsRect.FromRectangle((Rectangle)prcDest);
}
else
{
IVMRWindowlessControl9 vmrWindowlessControl9 = this.videoRenderer as IVMRWindowlessControl9;
hr = vmrWindowlessControl9.GetVideoPosition(null, innerDsRect);
}
Rectangle innerRectangle = innerDsRect.ToRectangle();
//Trace.WriteLineIf(trace.TraceVerbose, string.Format(("\tvideoRenderer.GetVideoPosition({0})"), innerRectangle.ToString()));
//Trace.WriteLineIf(trace.TraceVerbose, string.Format(("\thostingControl.ClientRectangle({0})"), outerRectangle.ToString()));
List<Rectangle> alRectangles = new List<Rectangle>();
if (innerRectangle.Top > outerRectangle.Top)
alRectangles.Add(new Rectangle(outerRectangle.Left, outerRectangle.Top, outerRectangle.Width - 1, innerRectangle.Top - 1));
if (innerRectangle.Bottom < outerRectangle.Bottom)
alRectangles.Add(new Rectangle(outerRectangle.Left, innerRectangle.Bottom, outerRectangle.Width - 1, outerRectangle.Height - (innerRectangle.Bottom + 1)));
if (innerRectangle.Left > outerRectangle.Left)
{
Rectangle rectangleLeft = new Rectangle(outerRectangle.Left, innerRectangle.Top, innerRectangle.Left - 1, innerRectangle.Height - 1);
rectangleLeft.Intersect(outerRectangle);
alRectangles.Add(rectangleLeft);
}
if (innerRectangle.Right < outerRectangle.Right)
{
Rectangle rectangleLeft = new Rectangle(innerRectangle.Right, innerRectangle.Top, outerRectangle.Width - (innerRectangle.Right + 1), innerRectangle.Height - 1);
rectangleLeft.Intersect(outerRectangle);
alRectangles.Add(rectangleLeft);
}
return alRectangles.ToArray();
}
public void CopyFrom(MFVideoNormalizedRect from)
{
left = from.left;
top = from.top;
right = from.right;
bottom = from.bottom;
}
/// <summary>
/// Resize video
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
/// <returns></returns>
public int ResizeVideo(short width, short height)
{
TRACE(string.Format("ResizeVideo: {0}x{1}", width, height));
int hr = S_Ok;
if (m_pVideoDisplay != null)
{
try
{
MFRect rcDest = new MFRect();
MFVideoNormalizedRect nRect = new MFVideoNormalizedRect();
nRect.left = 0;
nRect.right = 1;
nRect.top = 0;
nRect.bottom = 1;
rcDest.left = 0;
rcDest.top = 0;
rcDest.right = width;
rcDest.bottom = height;
m_pVideoDisplay.SetVideoPosition(nRect, rcDest);
}
catch (Exception e)
{
hr = Marshal.GetHRForException(e);
}
}
return hr;
}
public void Track(Point pt)
{
if (m_pMixer == null || m_pMapper == null)
{
throw new COMException("null mixer or mapper", MFError.MF_E_INVALIDREQUEST);
}
Rectangle r = m_hwndVideo.ClientRectangle;
MFRect rc = new MFRect(r.Left, r.Top, r.Right, r.Bottom);
// x, y: Mouse coordinates, normalized relative to the composition rectangle.
float x = (float)pt.X / rc.right;
float y = (float)pt.Y / rc.bottom;
// Map the mouse coordinates to the reference stream.
m_pMapper.MapOutputCoordinateToInputStream(
x, y, // Output coordinates
0, // Output stream (the mixer only has one)
0, // Input stream (0 = ref stream)
out x, out y // Receives the normalized input coordinates.
);
// Offset by the original hit point.
x -= m_ptHitTrack.X;
y -= m_ptHitTrack.Y;
float max_offset = 1.0f - m_fScale; // Maximum left and top positions for the substream.
MFVideoNormalizedRect nrcDest = new MFVideoNormalizedRect();
if (x < 0)
{
nrcDest.left = 0;
nrcDest.right = m_fScale;
}
else if (x > max_offset)
{
nrcDest.right = 1;
nrcDest.left = max_offset;
}
else
{
nrcDest.left = x;
nrcDest.right = x + m_fScale;
}
if (y < 0)
{
nrcDest.top = 0;
nrcDest.bottom = m_fScale;
}
else if (y > max_offset)
{
nrcDest.bottom = 1;
nrcDest.top = max_offset;
}
else
{
nrcDest.top = y;
nrcDest.bottom = y + m_fScale;
}
// Set the new position.
m_pMixer.SetStreamOutputRect(1, nrcDest);
}
public void SetScale(float fScale)
{
if (m_ImageHandlers == null || m_ImageHandlers.Length < 2)
{
return;
}
if (fScale < 0 || fScale > 1.0)
{
throw new COMException("Invalid scale", E_InvalidArgument);
}
if (fScale == m_fScale)
{
return; // no-op
}
if (m_pMixer == null)
{
throw new COMException("No mixer", E_InvalidArgument);
}
// Get the current position of the substream rectangle.
MFVideoNormalizedRect rect = new MFVideoNormalizedRect();
m_pMixer.GetStreamOutputRect(1, rect);
// When this method is called, the substream might be positioned anywhere
// within the composition rectangle. To resize it, first we scale the
// right/bottom edges up to the maximum, and then scale the left/top edges.
rect.right = Math.Min(rect.left + fScale, 1.0f);
rect.bottom = Math.Min(rect.top + fScale, 1.0f);
rect.left -= Math.Max(fScale - (rect.right - rect.left), 0.0f);
rect.top -= Math.Max(fScale - (rect.bottom - rect.top), 0.0f);
// Set the new position.
m_pMixer.SetStreamOutputRect(1, rect);
m_fScale = fScale;
}
private void MoveVideoWindow()
{
//int hr = 0;
// Track the movement of the container window and resize as needed
if (this.evrDisplay != null)
{
MFVideoNormalizedRect sRect = new MFVideoNormalizedRect();
sRect.top = 0;
sRect.left = 0;
sRect.right = 1;
sRect.bottom = 1;
MediaFoundation.Misc.MFRect dRect = new MediaFoundation.Misc.MFRect();
//dRect.top = 0;
//dRect.left = 0;
//dRect.right = ClientRectangle.Width;//this.Width;
//dRect.bottom = ClientRectangle.Height;//this.Height;
dRect.top = 0 - (ps.OverscanHeight / 2);
dRect.left = 0 - (ps.OverscanWidth / 2);
dRect.right = container.ClientRectangle.Width + (ps.OverscanWidth / 2);//this.Width;
dRect.bottom = container.ClientRectangle.Height + (ps.OverscanHeight / 2);//this.Height;
this.evrDisplay.SetVideoPosition(sRect, dRect);
}
}
private void menuItem14_Click(object sender, EventArgs e)
{
MFVideoAlphaBitmap alphaBmp = new MFVideoAlphaBitmap();
using (Bitmap alphaBitmap = new Bitmap("epsonproj.png"))
{
//alphaBitmap is a 32bit semitransparent Bitmap
Graphics g = Graphics.FromImage(alphaBitmap);
// get pointer to needed objects
IntPtr hdc = g.GetHdc();
IntPtr memDC = CreateCompatibleDC(hdc);
IntPtr hBitmap = alphaBitmap.GetHbitmap();
IntPtr hOld = SelectObject(memDC, hBitmap);
alphaBmp.GetBitmapFromDC = true;
alphaBmp.stru = memDC;
alphaBmp.paras = new MFVideoAlphaBitmapParams();
alphaBmp.paras.dwFlags = MFVideoAlphaBitmapFlags.Alpha | MFVideoAlphaBitmapFlags.DestRect;
// calculate destination rectangle
MFVideoNormalizedRect mfNRect = new MFVideoNormalizedRect();
//NormalizedRect nRect = GetDestRectangle(width, height, subtitleLines);
mfNRect.top = 0.5f;// nRect.top;
mfNRect.left = 0.5f;// nRect.left;
mfNRect.right = 1.0f;//nRect.right;
mfNRect.bottom = 1.0f;// nRect.bottom;
// used when viewing half side by side anaglyph video that is stretched to full width
//if (FrameMode == Mars.FrameMode.HalfSideBySide)
//{
// mfNRect.left /= 2;
// mfNRect.right /= 2;
//}
alphaBmp.paras.nrcDest = mfNRect;
// calculate source rectangle (full subtitle bitmap)
MFRect rcSrc = new MFRect();
rcSrc.bottom = alphaBitmap.Height;
rcSrc.right = alphaBitmap.Width;
rcSrc.top = 0;
rcSrc.left = 0;
alphaBmp.paras.rcSrc = rcSrc;
// apply 1-bit transparency
//System.Drawing.Color colorKey = System.Drawing.Color.White;
//alphaBmp.paras.clrSrcKey = ColorTranslator.ToWin32(colorKey);
// 90% visible
alphaBmp.paras.fAlpha = 0.5F;
// set the bitmap to the evr mixer
mixBmp.SetAlphaBitmap(alphaBmp);
// cleanup
SelectObject(memDC, hOld);
DeleteDC(memDC);
g.ReleaseHdc();
}
}
// Idea from Gabest (http://www.gabest.org) and modify by me
public virtual void VideoResizer(VideoSizeMode videoZoomMode, bool keepAspectRatio, PointF offset, double zoom, double aspectRatioFactor)
{
Trace.WriteLineIf(trace.TraceInfo, "VideoResizer(...)");
int hr = 0;
Rectangle windowRect = this.hostingControl.ClientRectangle;
currentVideoTargetRectangle = windowRect;
currentVideoSourceSize = new Size();
FilterState filterState = GetGraphState();
if (filterState == FilterState.Paused || filterState == FilterState.Running)
{
if (videoZoomMode != VideoSizeMode.StretchToWindow)
{
int arX, arY;
int arX2 = 0, arY2 = 0;
if (useEVR)
{
Size videoSize = new Size(), arVideoSize = new Size();
hr = evrVideoDisplayControl.GetNativeVideoSize(out videoSize, out arVideoSize);
//IMFVideoDisplayControlEx evrVideoDisplayControlPlus = evrVideoDisplayControl as IMFVideoDisplayControlEx;
//hr = evrVideoDisplayControlPlus.GetNativeVideoSize(out videoSize, out arVideoSize);
//hr = evrVideoDisplayControlPlus.GetIdealVideoSize(videoSize, arVideoSize);
arX = videoSize.Width;
arY = videoSize.Height;
arX2 = arVideoSize.Width;
arY2 = arVideoSize.Height;
Trace.WriteLineIf(trace.TraceVerbose, string.Format(("\tvideoRenderer.GetNativeVideoSize({0}, {1})"), videoSize.ToString(), arVideoSize.ToString()));
}
else
hr = (this.videoRenderer as IVMRWindowlessControl9).GetNativeVideoSize(out arX, out arY, out arX2, out arY2);
if (hr >= 0 && arY > 0)
{
//DsError.ThrowExceptionForHR(hr);
//Trace.WriteLineIf(trace.TraceVerbose, string.Format("\tGetNativeVideoSize(width: {0}, height: {1}, arX {2}, arY: {3}", arX, arY, arX2, arY2));
if (arX2 > 0 && arY2 > 0)
{
arX = arX2;
arY = arY2;
}
currentVideoSourceSize.Width = arX;
currentVideoSourceSize.Height = arY;
Size windowSize = windowRect.Size;
double newAspectRation = aspectRatioFactor * (double)arX / (double)arY * (this.useVideo169Mode ? 3.0 / 4.0 : 1.0);
int height = windowSize.Height;
int width = (int)((double)height * newAspectRation);
if (videoZoomMode == VideoSizeMode.FromInside || videoZoomMode == VideoSizeMode.FromOutside)
{
if (videoZoomMode == VideoSizeMode.FromInside && width > windowSize.Width
|| videoZoomMode == VideoSizeMode.FromOutside && width < windowSize.Width)
{
width = windowSize.Width;
height = (int)((double)width / newAspectRation);
}
}
Size size = new Size((int)(zoom * width), (int)(zoom * height));
Point pos = new Point(
(int)(offset.X * (windowRect.Width * 3 - size.Width) - windowRect.Width),
(int)(offset.Y * (windowRect.Height * 3 - size.Height) - windowRect.Height));
//Point pos = new Point(
// (int)(offset.X * (windowRect.Width - size.Width)),
// (int)(offset.Y * (windowRect.Height - size.Height)));
currentVideoTargetRectangle = new Rectangle(pos, size);
}
}
if (useEVR)
{
//hr = evrVideoDisplayControl.SetVideoWindow(this.hostingControl.Handle);
MFVideoNormalizedRect pnrcSource = new MFVideoNormalizedRect(0.0f, 0.0f, 1.0f, 1.0f);
hr = this.evrVideoDisplayControl.SetVideoPosition(pnrcSource, (MediaFoundation.Misc.MFRect)currentVideoTargetRectangle);
this.hostingControl.ModifyBlackBands(GetBlackBands(), Settings.VideoBackgroundColor);
}
else
hr = (this.videoRenderer as IVMRWindowlessControl9).SetVideoPosition(null, DsRect.FromRectangle(currentVideoTargetRectangle));
//Trace.WriteLineIf(trace.TraceVerbose, string.Format(("\tPos {0:F2} {1:F2}, Zoom {2:F2}, ARF {4:F2}, AR {4:F2}"), offset.X, offset.Y, zoom, aspectRatioFactor, (float)videoTargetRect.Width / videoTargetRect.Height));
Trace.WriteLineIf(trace.TraceVerbose, string.Format(("\tvideoRenderer.SetVideoPosition({0})"), currentVideoTargetRectangle.ToString()));
}
}
private void SetAspectRatio(Size? ratio = null, bool setVideoWindow = true)
{
int screenWidth;
int screenHeight;
if (m_graph == null)
return;
if (_isInExclusiveMode)
{
var size = System.Windows.Forms.Screen.FromControl(_hostForm).Bounds;
screenWidth = size.Width;
screenHeight = size.Height;
}
else
{
var hiddenWindowContentSize = _hostForm.Bounds;
screenWidth = hiddenWindowContentSize.Width;
screenHeight = hiddenWindowContentSize.Height;
}
// Set the display position to the entire window.
if (_mPDisplay != null)
{
MFRect dRect = new MFRect(0, 0, screenWidth, screenHeight);
MFSize vSize = new MFSize(), vAR = new MFSize();
double m_ZoomX = 1, m_ZoomY = 1, m_PosX = 0.5, m_PosY = 0.5;
MFVideoNormalizedRect sRect = new MFVideoNormalizedRect();
sRect.top = 0;
sRect.left = 0;
sRect.right = 1;
sRect.bottom = 1;
int hr = _mPDisplay.GetNativeVideoSize(vSize, vAR);
if (hr > -1)
{
double dVideoAR = (double)vSize.Width / vSize.Height;
double dWRWidth = screenWidth;
double dWRHeight = screenHeight;
double dVRWidth = dWRHeight * dVideoAR;
double dVRHeight;
_logger.Debug("Scale: {0} Video Width: {1} Video Height: {2} X-AR: {3} Y-AR: {4}", _iVideoScaling, vSize.Width, vSize.Height, vAR.cx, vAR.cy);
switch (_iVideoScaling)
{
case VideoScalingScheme.HALF:
dVRWidth = vSize.Width * 0.5;
dVRHeight = vSize.Height * 0.5;
break;
case VideoScalingScheme.NORMAL:
dVRWidth = vSize.Width;
dVRHeight = vSize.Height;
break;
case VideoScalingScheme.DOUBLE:
dVRWidth = vSize.Width * 2.0;
dVRHeight = vSize.Height * 2.0;
break;
case VideoScalingScheme.STRETCH:
dVRWidth = dWRWidth;
dVRHeight = dWRHeight;
break;
default:
//ASSERT(FALSE);
// Fallback to "Touch Window From Inside" if settings were corrupted.
case VideoScalingScheme.FROMINSIDE:
case VideoScalingScheme.FROMOUTSIDE:
if ((screenWidth < dVRWidth) != (_iVideoScaling == VideoScalingScheme.FROMOUTSIDE))
{
dVRWidth = dWRWidth;
dVRHeight = dVRWidth / dVideoAR;
}
else
{
dVRHeight = dWRHeight;
}
break;
case VideoScalingScheme.ZOOM1:
case VideoScalingScheme.ZOOM2:
{
double minw = dWRWidth < dVRWidth ? dWRWidth : dVRWidth;
double maxw = dWRWidth > dVRWidth ? dWRWidth : dVRWidth;
double scale = _iVideoScaling == VideoScalingScheme.ZOOM1 ? 1.0 / 3.0 : 2.0 / 3.0;
dVRWidth = minw + (maxw - minw) * scale;
dVRHeight = dVRWidth / dVideoAR;
break;
}
}
// Scale video frame
double dScaledVRWidth = m_ZoomX * dVRWidth;
double dScaledVRHeight = m_ZoomY * dVRHeight;
// Position video frame
// left and top parts are allowed to be negative
dRect.left = (int)Math.Round(m_PosX * (dWRWidth * 3.0 - dScaledVRWidth) - dWRWidth);
dRect.top = (int)Math.Round(m_PosY * (dWRHeight * 3.0 - dScaledVRHeight) - dWRHeight);
// right and bottom parts are always at picture center or beyond, so never negative
dRect.right = (int)Math.Round(dRect.left + dScaledVRWidth);
dRect.bottom = (int)Math.Round(dRect.top + dScaledVRHeight);
//apply overscan
//dRect.top = dRect.top - (ps.OverscanHeight / 2);
//dRect.left = dRect.left - (ps.OverscanWidth / 2);
//dRect.right = dRect.right + (ps.OverscanWidth / 2);//this.Width;
//dRect.bottom = dRect.bottom + (ps.OverscanHeight / 2);//this.Height;
}
_mPDisplay.SetVideoPosition(sRect, dRect);
}
// Get Aspect Ratio
int aspectX;
int aspectY;
if (ratio.HasValue)
{
aspectX = ratio.Value.Width;
aspectY = ratio.Value.Height;
}
else
{
var basicVideo2 = (IBasicVideo2)m_graph;
basicVideo2.GetPreferredAspectRatio(out aspectX, out aspectY);
var sourceHeight = 0;
var sourceWidth = 0;
_basicVideo.GetVideoSize(out sourceWidth, out sourceHeight);
if (aspectX == 0 || aspectY == 0 || sourceWidth > 0 || sourceHeight > 0)
{
aspectX = sourceWidth;
aspectY = sourceHeight;
}
}
// Adjust Video Size
var iAdjustedHeight = 0;
if (aspectX > 0 && aspectY > 0)
{
double adjustedHeight = aspectY * screenWidth;
adjustedHeight /= aspectX;
iAdjustedHeight = Convert.ToInt32(Math.Round(adjustedHeight));
}
if (screenHeight > iAdjustedHeight && iAdjustedHeight > 0)
{
double totalMargin = (screenHeight - iAdjustedHeight);
var topMargin = Convert.ToInt32(Math.Round(totalMargin / 2));
_basicVideo.SetDestinationPosition(0, topMargin, screenWidth, iAdjustedHeight);
}
else if (iAdjustedHeight > 0)
{
double adjustedWidth = aspectX * screenHeight;
adjustedWidth /= aspectY;
var iAdjustedWidth = Convert.ToInt32(Math.Round(adjustedWidth));
double totalMargin = (screenWidth - iAdjustedWidth);
var leftMargin = Convert.ToInt32(Math.Round(totalMargin / 2));
_basicVideo.SetDestinationPosition(leftMargin, 0, iAdjustedWidth, screenHeight);
}
if (setVideoWindow)
{
_videoWindow.SetWindowPosition(0, 0, screenWidth, screenHeight);
}
}
private void MoveVideoWindow()
{
int hr = 0;
try
{
// Track the movement of the container window and resize as needed
if (this.evrDisplay != null)
{
MFVideoNormalizedRect sRect = new MFVideoNormalizedRect();
sRect.top = 0;
sRect.left = 0;
sRect.right = 1;
sRect.bottom = 1;
MediaFoundation.Misc.MFRect dRect = new MediaFoundation.Misc.MFRect();
MFSize vSize = new MFSize(), vAR = new MFSize();
double m_ZoomX = 1, m_ZoomY = 1, m_PosX = 0.5, m_PosY = 0.5;
//dRect.top = 0;
//dRect.left = 0;
//dRect.right = ClientRectangle.Width;//this.Width;
//dRect.bottom = ClientRectangle.Height;//this.Height;
//dRect.top = 0 - (ps.OverscanHeight / 2);
//dRect.left = 0 - (ps.OverscanWidth / 2);
//dRect.right = ClientRectangle.Width + (ps.OverscanWidth / 2);//this.Width;
//dRect.bottom = ClientRectangle.Height + (ps.OverscanHeight / 2);//this.Height;
hr = evrDisplay.GetNativeVideoSize(vSize, vAR);
DsError.ThrowExceptionForHR(hr);
double dVideoAR = (double)vSize.Width / vSize.Height;
double dWRWidth = ClientRectangle.Width;
double dWRHeight = ClientRectangle.Height;
double dVRWidth = dWRHeight * dVideoAR;
double dVRHeight;
switch (iVideoScaling)
{
case dvstype.HALF:
dVRWidth = vSize.Width * 0.5;
dVRHeight = vSize.Height * 0.5;
break;
case dvstype.NORMAL:
dVRWidth = vSize.Width;
dVRHeight = vSize.Height;
break;
case dvstype.DOUBLE:
dVRWidth = vSize.Width * 2.0;
dVRHeight = vSize.Height * 2.0;
break;
case dvstype.STRETCH:
dVRWidth = dWRWidth;
dVRHeight = dWRHeight;
break;
default:
//ASSERT(FALSE);
// Fallback to "Touch Window From Inside" if settings were corrupted.
case dvstype.FROMINSIDE:
case dvstype.FROMOUTSIDE:
if ((ClientRectangle.Width < dVRWidth) != (iVideoScaling == dvstype.FROMOUTSIDE))
{
dVRWidth = dWRWidth;
dVRHeight = dVRWidth / dVideoAR;
}
else
{
dVRHeight = dWRHeight;
}
break;
case dvstype.ZOOM1:
case dvstype.ZOOM2:
{
double minw = dWRWidth < dVRWidth ? dWRWidth : dVRWidth;
double maxw = dWRWidth > dVRWidth ? dWRWidth : dVRWidth;
double scale = iVideoScaling == dvstype.ZOOM1 ? 1.0 / 3.0 : 2.0 / 3.0;
dVRWidth = minw + (maxw - minw) * scale;
dVRHeight = dVRWidth / dVideoAR;
break;
}
}
// Scale video frame
double dScaledVRWidth = m_ZoomX * dVRWidth;
double dScaledVRHeight = m_ZoomY * dVRHeight;
// Position video frame
// left and top parts are allowed to be negative
dRect.left = (int)Math.Round(m_PosX * (dWRWidth * 3.0 - dScaledVRWidth) - dWRWidth);
dRect.top = (int)Math.Round(m_PosY * (dWRHeight * 3.0 - dScaledVRHeight) - dWRHeight);
// right and bottom parts are always at picture center or beyond, so never negative
dRect.right = (int)Math.Round(dRect.left + dScaledVRWidth);
dRect.bottom = (int)Math.Round(dRect.top + dScaledVRHeight);
//apply overscan
dRect.top = dRect.top - (ps.OverscanHeight / 2);
dRect.left = dRect.left - (ps.OverscanWidth / 2);
dRect.right = dRect.right + (ps.OverscanWidth / 2);//this.Width;
dRect.bottom = dRect.bottom + (ps.OverscanHeight / 2);//this.Height;
this.evrDisplay.SetVideoPosition(sRect, dRect);
Debug.Print("t: {0} l: {1} r:{2} b:{3}", dRect.top, dRect.left, dRect.right, dRect.bottom);
}
}
catch (Exception ex)
{
FileLogger.Log("MoveVideoWindow Error: {0}", ex.Message);
}
}
