Microsoft Media Foundation官方文档翻译（15）《Picture Aspect Ratio》

 1 MFVideoArea MakeArea(float x, float y, DWORD width, DWORD height);
 2 
 3 HRESULT GetVideoDisplayArea(IMFMediaType *pType, MFVideoArea *pArea)
 4 {
 5     HRESULT hr = S_OK;
 6     BOOL bPanScan = FALSE;
 7     UINT32 width = 0, height = 0;
 8 
 9     bPanScan = MFGetAttributeUINT32(pType, MF_MT_PAN_SCAN_ENABLED, FALSE);
10 
11     // In pan-and-scan mode, try to get the pan-and-scan region.
12     if (bPanScan)
13     {
14         hr = pType->GetBlob(MF_MT_PAN_SCAN_APERTURE, (UINT8*)pArea, 
15             sizeof(MFVideoArea), NULL);
16     }
17 
18     // If not in pan-and-scan mode, or the pan-and-scan region is not set, 
19     // get the minimimum display aperture.
20 
21     if (!bPanScan || hr == MF_E_ATTRIBUTENOTFOUND)
22     {
23         hr = pType->GetBlob(MF_MT_MINIMUM_DISPLAY_APERTURE, (UINT8*)pArea, 
24             sizeof(MFVideoArea), NULL);
25 
26         if (hr == MF_E_ATTRIBUTENOTFOUND)
27         {
28             // Minimum display aperture is not set.
29 
30             // For backward compatibility with some components, 
31             // check for a geometric aperture. 
32 
33             hr = pType->GetBlob(MF_MT_GEOMETRIC_APERTURE, (UINT8*)pArea, 
34                 sizeof(MFVideoArea), NULL);
35         }
36 
37         // Default: Use the entire video area.
38 
39         if (hr == MF_E_ATTRIBUTENOTFOUND)
40         {
41             hr = MFGetAttributeSize(pType, MF_MT_FRAME_SIZE, &width, &height);
42 
43             if (SUCCEEDED(hr))
44             {
45                 *pArea = MakeArea(0.0, 0.0, width, height);
46             }
47         }
48     }
49     return hr;
50 }
51 
52  
53 
54  
55 
56 MFOffset MakeOffset(float v)
57 {
58     MFOffset offset;
59     offset.value = short(v);
60     offset.fract = WORD(65536 * (v-offset.value));
61     return offset;
62 }
63 
64  
65 
66 MFVideoArea MakeArea(float x, float y, DWORD width, DWORD height)
67 {
68     MFVideoArea area;
69     area.OffsetX = MakeOffset(x);
70     area.OffsetY = MakeOffset(y);
71     area.Area.cx = width;
72     area.Area.cy = height;
73     return area;
74 }

 1 //-----------------------------------------------------------------------------
 2 // Converts a rectangle from one pixel aspect ratio (PAR) to another PAR.
 3 // Returns the corrected rectangle.
 4 //
 5 // For example, a 720 x 486 rect with a PAR of 9:10, when converted to 1x1 PAR,
 6 // must be stretched to 720 x 540.
 7 //-----------------------------------------------------------------------------
 8 
 9 RECT CorrectAspectRatio(const RECT& src, const MFRatio& srcPAR, const MFRatio& destPAR)
10 {
11     // Start with a rectangle the same size as src, but offset to (0,0).
12     RECT rc = {0, 0, src.right - src.left, src.bottom - src.top};
13 
14     // If the source and destination have the same PAR, there is nothing to do.
15     // Otherwise, adjust the image size, in two steps:
16     //  1. Transform from source PAR to 1:1
17     //  2. Transform from 1:1 to destination PAR.
18 
19     if ((srcPAR.Numerator != destPAR.Numerator) || 
20         (srcPAR.Denominator != destPAR.Denominator))
21     {
22         // Correct for the source‘s PAR.
23 
24         if (srcPAR.Numerator > srcPAR.Denominator)
25         {
26             // The source has "wide" pixels, so stretch the width.
27             rc.right = MulDiv(rc.right, srcPAR.Numerator, srcPAR.Denominator);
28         }
29         else if (srcPAR.Numerator < srcPAR.Denominator)
30         {
31             // The source has "tall" pixels, so stretch the height.
32             rc.bottom = MulDiv(rc.bottom, srcPAR.Denominator, srcPAR.Numerator);
33         }
34         // else: PAR is 1:1, which is a no-op.
35 
36         // Next, correct for the target‘s PAR. This is the inverse operation of 
37         // the previous.
38 
39         if (destPAR.Numerator > destPAR.Denominator)
40         {
41             // The destination has "wide" pixels, so stretch the height.
42             rc.bottom = MulDiv(rc.bottom, destPAR.Numerator, destPAR.Denominator);
43         }
44         else if (destPAR.Numerator < destPAR.Denominator)
45         {
46             // The destination has "tall" pixels, so stretch the width.
47             rc.right = MulDiv(rc.right, destPAR.Denominator, destPAR.Numerator);
48         }
49         // else: PAR is 1:1, which is a no-op.
50     }
51     return rc;
52 }

 1 RECT LetterBoxRect(const RECT& rcSrc, const RECT& rcDst)
 2 {
 3     // Compute source/destination ratios.
 4     int iSrcWidth  = rcSrc.right - rcSrc.left;
 5     int iSrcHeight = rcSrc.bottom - rcSrc.top;
 6 
 7     int iDstWidth  = rcDst.right - rcDst.left;
 8     int iDstHeight = rcDst.bottom - rcDst.top;
 9 
10     int iDstLBWidth;
11     int iDstLBHeight;
12 
13     if (MulDiv(iSrcWidth, iDstHeight, iSrcHeight) <= iDstWidth) 
14     {
15         // Column letterboxing ("pillar box")
16         iDstLBWidth  = MulDiv(iDstHeight, iSrcWidth, iSrcHeight);
17         iDstLBHeight = iDstHeight;
18     }
19     else 
20     {
21         // Row letterboxing.
22         iDstLBWidth  = iDstWidth;
23         iDstLBHeight = MulDiv(iDstWidth, iSrcHeight, iSrcWidth);
24     }
25 
26     // Create a centered rectangle within the current destination rect
27 
28     LONG left = rcDst.left + ((iDstWidth - iDstLBWidth) / 2);
29     LONG top = rcDst.top + ((iDstHeight - iDstLBHeight) / 2);
30 
31     RECT rc;
32     SetRect(&rc, left, top, left + iDstLBWidth, top + iDstLBHeight);
33     return rc;
34 }