diff --git a/samples/sample_common/include/sample_utils.h b/samples/sample_common/include/sample_utils.h index 77147b4320..a3afc167c9 100644 --- a/samples/sample_common/include/sample_utils.h +++ b/samples/sample_common/include/sample_utils.h @@ -127,7 +127,7 @@ public : std::vector m_files; - bool shouldShiftP010High; + bool shouldShift10BitsHigh; bool m_bInited; }; diff --git a/samples/sample_common/src/sample_utils.cpp b/samples/sample_common/src/sample_utils.cpp index fb52f6a415..0c954be006 100644 --- a/samples/sample_common/src/sample_utils.cpp +++ b/samples/sample_common/src/sample_utils.cpp @@ -71,11 +71,12 @@ mfxStatus CopyBitstream2(mfxBitstream *dest, mfxBitstream *src) CSmplYUVReader::CSmplYUVReader() { m_bInited = false; - m_ColorFormat = MFX_FOURCC_YV12; - shouldShiftP010High = false; + m_ColorFormat + = MFX_FOURCC_YV12; + shouldShift10BitsHigh = false; } -mfxStatus CSmplYUVReader::Init(std::list inputs, mfxU32 ColorFormat, bool shouldShiftP010) +mfxStatus CSmplYUVReader::Init(std::list inputs, mfxU32 ColorFormat, bool enableShifting) { Close(); @@ -86,14 +87,21 @@ mfxStatus CSmplYUVReader::Init(std::list inputs, mfxU32 ColorFormat MFX_FOURCC_RGB4 != ColorFormat && MFX_FOURCC_BGR4 != ColorFormat && MFX_FOURCC_P010 != ColorFormat && - MFX_FOURCC_P210 != ColorFormat) + MFX_FOURCC_P210 != ColorFormat && + MFX_FOURCC_AYUV != ColorFormat && + MFX_FOURCC_A2RGB10 != ColorFormat +#if (MFX_VERSION >= 1027) + && MFX_FOURCC_Y210 != ColorFormat + && MFX_FOURCC_Y410 != ColorFormat +#endif + ) { return MFX_ERR_UNSUPPORTED; } - if(MFX_FOURCC_P010 == ColorFormat) + if(MFX_FOURCC_P010 == ColorFormat || MFX_FOURCC_P210 == ColorFormat || MFX_FOURCC_Y210 == ColorFormat) { - shouldShiftP010High = shouldShiftP010; + shouldShift10BitsHigh = enableShifting; } if (!inputs.size()) @@ -170,16 +178,19 @@ mfxStatus CSmplYUVReader::LoadNextFrame(mfxFrameSurface1* pSurface) h = pInfo.Height; } - mfxU32 nBytesPerPixel = (pInfo.FourCC == MFX_FOURCC_P010 || pInfo.FourCC == MFX_FOURCC_P210) ? 2 : 1; + mfxU32 nBytesPerPixel = (pInfo.FourCC == MFX_FOURCC_P010 || pInfo.FourCC == MFX_FOURCC_P210 ) ? 2 : 1; - if (MFX_FOURCC_YUY2 == pInfo.FourCC || MFX_FOURCC_RGB4 == pInfo.FourCC || MFX_FOURCC_BGR4 == pInfo.FourCC) + if (MFX_FOURCC_YUY2 == pInfo.FourCC || MFX_FOURCC_RGB4 == pInfo.FourCC || MFX_FOURCC_BGR4 == pInfo.FourCC +#if (MFX_VERSION >= 1027) + || pInfo.FourCC == MFX_FOURCC_Y210 || pInfo.FourCC == MFX_FOURCC_Y410 +#endif + ) { //Packed format: Luminance and chrominance are on the same plane switch (m_ColorFormat) { case MFX_FOURCC_RGB4: case MFX_FOURCC_BGR4: - pitch = pData.Pitch; ptr = MSDK_MIN( MSDK_MIN(pData.R, pData.G), pData.B); ptr = ptr + pInfo.CropX + pInfo.CropY * pData.Pitch; @@ -208,7 +219,49 @@ mfxStatus CSmplYUVReader::LoadNextFrame(mfxFrameSurface1* pSurface) } } break; - default: + case MFX_FOURCC_AYUV: + pitch = pData.Pitch; + ptr = pData.Y + pInfo.CropX*4 + pInfo.CropY * pData.Pitch; + + for (i = 0; i < h; i++) + { + nBytesRead = (mfxU32)fread(ptr + i * pitch, 4, w, m_files[vid]); + + if ((mfxU32)w != nBytesRead) + { + return MFX_ERR_MORE_DATA; + } + } + break; + +#if (MFX_VERSION >= 1027) + case MFX_FOURCC_Y210: + case MFX_FOURCC_Y410: + pitch = pData.Pitch; + ptr = ((pInfo.FourCC== MFX_FOURCC_Y210) ? pData.Y : (mfxU8*)pData.Y410) + pInfo.CropX*4 + pInfo.CropY * pData.Pitch; + + for (i = 0; i < h; i++) + { + nBytesRead = (mfxU32)fread(ptr + i * pitch, 1, 4 * w, m_files[vid]); + + if ((mfxU32)4 * w != nBytesRead) + { + return MFX_ERR_MORE_DATA; + } + + if (MFX_FOURCC_Y210 == pInfo.FourCC && shouldShift10BitsHigh) + { + mfxU16* shortPtr = (mfxU16*)(ptr + i * pitch); + for (int idx = 0; idx < w*2; idx++) + { + shortPtr[idx] <<= 6; + } + } + + } + break; +#endif + default: return MFX_ERR_UNSUPPORTED; } } @@ -228,7 +281,7 @@ mfxStatus CSmplYUVReader::LoadNextFrame(mfxFrameSurface1* pSurface) } // Shifting data if required - if((MFX_FOURCC_P010 == pInfo.FourCC || MFX_FOURCC_P210 == pInfo.FourCC) && shouldShiftP010High) + if((MFX_FOURCC_P010 == pInfo.FourCC || MFX_FOURCC_P210 == pInfo.FourCC) && shouldShift10BitsHigh) { mfxU16* shortPtr = (mfxU16*)(ptr + i * pitch); for(int idx = 0; idx < w; idx++) @@ -351,7 +404,7 @@ mfxStatus CSmplYUVReader::LoadNextFrame(mfxFrameSurface1* pSurface) } // Shifting data if required - if((MFX_FOURCC_P010 == pInfo.FourCC || MFX_FOURCC_P210 == pInfo.FourCC) && shouldShiftP010High) + if((MFX_FOURCC_P010 == pInfo.FourCC || MFX_FOURCC_P210 == pInfo.FourCC) && shouldShift10BitsHigh) { mfxU16* shortPtr = (mfxU16*)(ptr + i * pitch); for(int idx = 0; idx < w; idx++) @@ -774,175 +827,225 @@ void CSmplYUVWriter::Close() mfxStatus CSmplYUVWriter::WriteNextFrame(mfxFrameSurface1 *pSurface) { - MSDK_CHECK_ERROR(m_bInited, false, MFX_ERR_NOT_INITIALIZED); - MSDK_CHECK_POINTER(pSurface, MFX_ERR_NULL_PTR); - - mfxFrameInfo &pInfo = pSurface->Info; - mfxFrameData &pData = pSurface->Data; - - mfxU32 i, h, w; - mfxU32 vid = pInfo.FrameId.ViewId; - - // Temporary buffer to convert MS-P010 to P010 - std::vector tmp; - - if (!m_bIsMultiView) - { - MSDK_CHECK_POINTER(m_fDest, MFX_ERR_NULL_PTR); - } - else - { - MSDK_CHECK_POINTER(m_fDestMVC, MFX_ERR_NULL_PTR); - MSDK_CHECK_POINTER(m_fDestMVC[vid], MFX_ERR_NULL_PTR); - } - - FILE* dstFile = m_bIsMultiView ? m_fDestMVC[vid] : m_fDest; - - switch (pInfo.FourCC) - { - case MFX_FOURCC_YV12: - case MFX_FOURCC_NV12: - for (i = 0; i < pInfo.CropH; i++) - { - MSDK_CHECK_NOT_EQUAL( - fwrite(pData.Y + (pInfo.CropY * pData.Pitch + pInfo.CropX)+ i * pData.Pitch, 1, pInfo.CropW, dstFile), - pInfo.CropW, MFX_ERR_UNDEFINED_BEHAVIOR); - } - break; - case MFX_FOURCC_P010: - case MFX_FOURCC_P210: - { - for (i = 0; i < pInfo.CropH; i++) - { - mfxU16* shortPtr = (mfxU16*)(pData.Y + (pInfo.CropY * pData.Pitch + pInfo.CropX) + i * pData.Pitch); - if (pInfo.Shift) - { - // Convert MS-P010 to P010 and write - tmp.resize(pData.Pitch); - - for (int idx = 0; idx < pInfo.CropW; idx++) - { - tmp[idx] = shortPtr[idx] >> 6; - } - - MSDK_CHECK_NOT_EQUAL( - fwrite(&tmp[0], 1, (mfxU32)pInfo.CropW * 2, dstFile), - (mfxU32)pInfo.CropW * 2, MFX_ERR_UNDEFINED_BEHAVIOR); - - } - else - { - MSDK_CHECK_NOT_EQUAL( - fwrite(shortPtr, 1, (mfxU32)pInfo.CropW * 2, dstFile), - (mfxU32)pInfo.CropW * 2, MFX_ERR_UNDEFINED_BEHAVIOR); - } - } - - break; - } - case MFX_FOURCC_RGB4: - case 100: //DXGI_FORMAT_AYUV - case MFX_FOURCC_A2RGB10: - // Implementation for RGB4 and A2RGB10 in the next switch below - break; - - default: - return MFX_ERR_UNSUPPORTED; - } - switch (pInfo.FourCC) - { - case MFX_FOURCC_YV12: - { - for (i = 0; i < (mfxU32) pInfo.CropH/2; i++) - { - MSDK_CHECK_NOT_EQUAL( - fwrite(pData.V + (pInfo.CropY * pData.Pitch / 2 + pInfo.CropX / 2)+ i * pData.Pitch, 1, pInfo.CropW, dstFile), - (mfxU32)pInfo.CropW/2, MFX_ERR_UNDEFINED_BEHAVIOR); - } - for (i = 0; i < (mfxU32)pInfo.CropH/2; i++) - { - MSDK_CHECK_NOT_EQUAL( - fwrite(pData.U + (pInfo.CropY * pData.Pitch / 2 + pInfo.CropX / 2)+ i * pData.Pitch / 2, 1, pInfo.CropW/2, dstFile), - (mfxU32)pInfo.CropW/2, MFX_ERR_UNDEFINED_BEHAVIOR); - } - break; - } - case MFX_FOURCC_NV12: - { - for (i = 0; i < (mfxU32) pInfo.CropH/2; i++) - { - MSDK_CHECK_NOT_EQUAL( - fwrite(pData.UV + (pInfo.CropY * pData.Pitch / 2 + pInfo.CropX / 2) + i * pData.Pitch, 1, pInfo.CropW, dstFile), - pInfo.CropW, MFX_ERR_UNDEFINED_BEHAVIOR); - } - break; - } - case MFX_FOURCC_P010: - case MFX_FOURCC_P210: - { - mfxU32 height = pInfo.FourCC == MFX_FOURCC_P010 ? (mfxU32)pInfo.CropH / 2 : (mfxU32)pInfo.CropH; - - for (i = 0; i < height; i++) - { - mfxU16* shortPtr = (mfxU16*)(pData.UV + (pInfo.CropY * pData.Pitch / 2 + pInfo.CropX) + i * pData.Pitch); - if (pInfo.Shift) - { - // Convert MS-P010 to P010 and write - tmp.resize(pData.Pitch); - - for (int idx = 0; idx < pInfo.CropW; idx++) - { - tmp[idx] = shortPtr[idx] >> 6; - } - - MSDK_CHECK_NOT_EQUAL( - fwrite(&tmp[0], 1, (mfxU32)pInfo.CropW * 2, dstFile), - (mfxU32)pInfo.CropW * 2, MFX_ERR_UNDEFINED_BEHAVIOR); - - } - else - { - MSDK_CHECK_NOT_EQUAL( - fwrite(shortPtr, 1, (mfxU32)pInfo.CropW * 2, dstFile), - (mfxU32)pInfo.CropW * 2, MFX_ERR_UNDEFINED_BEHAVIOR); - } - } - break; - } - - case MFX_FOURCC_RGB4: - case 100: //DXGI_FORMAT_AYUV - case MFX_FOURCC_A2RGB10: - { - mfxU8* ptr; - - if (pInfo.CropH > 0 && pInfo.CropW > 0) - { - w = pInfo.CropW; - h = pInfo.CropH; - } - else - { - w = pInfo.Width; - h = pInfo.Height; - } - - ptr = MSDK_MIN( MSDK_MIN(pData.R, pData.G), pData.B); - ptr = ptr + pInfo.CropX + pInfo.CropY * pData.Pitch; - - for(i = 0; i < h; i++) - { - MSDK_CHECK_NOT_EQUAL(fwrite(ptr + i * pData.Pitch, 1, 4*w, dstFile), 4*w, MFX_ERR_UNDEFINED_BEHAVIOR); - } - fflush(dstFile); - break; - } - - default: - return MFX_ERR_UNSUPPORTED; - } - - return MFX_ERR_NONE; + MSDK_CHECK_ERROR(m_bInited, false, MFX_ERR_NOT_INITIALIZED); + MSDK_CHECK_POINTER(pSurface, MFX_ERR_NULL_PTR); + + mfxFrameInfo &pInfo = pSurface->Info; + mfxFrameData &pData = pSurface->Data; + + mfxU32 i, h, w; + mfxU32 vid = pInfo.FrameId.ViewId; + + // Temporary buffer to convert MS-P010 to P010 + std::vector tmp; + + if (!m_bIsMultiView) + { + MSDK_CHECK_POINTER(m_fDest, MFX_ERR_NULL_PTR); + } + else + { + MSDK_CHECK_POINTER(m_fDestMVC, MFX_ERR_NULL_PTR); + MSDK_CHECK_POINTER(m_fDestMVC[vid], MFX_ERR_NULL_PTR); + } + + FILE* dstFile = m_bIsMultiView ? m_fDestMVC[vid] : m_fDest; + + switch (pInfo.FourCC) + { + case MFX_FOURCC_YV12: + case MFX_FOURCC_NV12: + for (i = 0; i < pInfo.CropH; i++) + { + MSDK_CHECK_NOT_EQUAL( + fwrite(pData.Y + (pInfo.CropY * pData.Pitch + pInfo.CropX) + i * pData.Pitch, 1, pInfo.CropW, dstFile), + pInfo.CropW, MFX_ERR_UNDEFINED_BEHAVIOR); + } + break; +#if (MFX_VERSION >= 1027) + case MFX_FOURCC_Y210: + { + for (i = 0; i < pInfo.CropH; i++) + { + mfxU8* pBuffer = ((mfxU8*)pData.Y) + (pInfo.CropY * pData.Pitch + pInfo.CropX * 4) + i * pData.Pitch; + if (pInfo.Shift) + { + tmp.resize(pInfo.CropW * 2); + + for (int idx = 0; idx < pInfo.CropW*2; idx++) + { + tmp[idx] = ((mfxU16*)pBuffer)[idx] >> 6; + } + + MSDK_CHECK_NOT_EQUAL( + fwrite(((const mfxU8*)tmp.data()), 4, pInfo.CropW, dstFile), + pInfo.CropW, MFX_ERR_UNDEFINED_BEHAVIOR); + } + else + { + MSDK_CHECK_NOT_EQUAL( + fwrite(pBuffer, 4, pInfo.CropW, dstFile), + pInfo.CropW, MFX_ERR_UNDEFINED_BEHAVIOR); + } + } + return MFX_ERR_NONE; + } + break; + + case MFX_FOURCC_Y410: +#if (MFX_VERSION >= MFX_VERSION_NEXT) + case MFX_FOURCC_Y216: +#endif + { + mfxU8* pBuffer = pInfo.FourCC == MFX_FOURCC_Y410 ? (mfxU8*)pData.Y410 : (mfxU8*)pData.Y; + for (i = 0; i < pInfo.CropH; i++) + { + MSDK_CHECK_NOT_EQUAL( + fwrite(pBuffer + (pInfo.CropY * pData.Pitch + pInfo.CropX * 4) + i * pData.Pitch, 4, pInfo.CropW, dstFile), + pInfo.CropW, MFX_ERR_UNDEFINED_BEHAVIOR); + } + return MFX_ERR_NONE; + } + break; +#endif + case MFX_FOURCC_P010: + case MFX_FOURCC_P210: + { + for (i = 0; i < pInfo.CropH; i++) + { + mfxU16* shortPtr = (mfxU16*)(pData.Y + (pInfo.CropY * pData.Pitch + pInfo.CropX) + i * pData.Pitch); + if (pInfo.Shift) + { + // Convert MS-P010 to P010 and write + tmp.resize(pData.Pitch); + + for (int idx = 0; idx < pInfo.CropW; idx++) + { + tmp[idx] = shortPtr[idx] >> 6; + } + + MSDK_CHECK_NOT_EQUAL( + fwrite(&tmp[0], 1, (mfxU32)pInfo.CropW * 2, dstFile), + (mfxU32)pInfo.CropW * 2, MFX_ERR_UNDEFINED_BEHAVIOR); + + } + else + { + MSDK_CHECK_NOT_EQUAL( + fwrite(shortPtr, 1, (mfxU32)pInfo.CropW * 2, dstFile), + (mfxU32)pInfo.CropW * 2, MFX_ERR_UNDEFINED_BEHAVIOR); + } + } + + break; + } + case MFX_FOURCC_RGB4: + case 100: //DXGI_FORMAT_AYUV + case MFX_FOURCC_AYUV: + case MFX_FOURCC_A2RGB10: + case MFX_FOURCC_YUY2: + // Implementation for these formats is in the next switch below + break; + + default: + return MFX_ERR_UNSUPPORTED; + } + switch (pInfo.FourCC) + { + case MFX_FOURCC_YV12: + { + for (i = 0; i < (mfxU32)pInfo.CropH / 2; i++) + { + MSDK_CHECK_NOT_EQUAL( + fwrite(pData.V + (pInfo.CropY * pData.Pitch / 2 + pInfo.CropX / 2) + i * pData.Pitch, 1, pInfo.CropW, dstFile), + (mfxU32)pInfo.CropW / 2, MFX_ERR_UNDEFINED_BEHAVIOR); + } + for (i = 0; i < (mfxU32)pInfo.CropH / 2; i++) + { + MSDK_CHECK_NOT_EQUAL( + fwrite(pData.U + (pInfo.CropY * pData.Pitch / 2 + pInfo.CropX / 2) + i * pData.Pitch / 2, 1, pInfo.CropW / 2, dstFile), + (mfxU32)pInfo.CropW / 2, MFX_ERR_UNDEFINED_BEHAVIOR); + } + break; + } + case MFX_FOURCC_NV12: + { + for (i = 0; i < (mfxU32)pInfo.CropH / 2; i++) + { + MSDK_CHECK_NOT_EQUAL( + fwrite(pData.UV + (pInfo.CropY * pData.Pitch + pInfo.CropX) + i * pData.Pitch, 1, pInfo.CropW, dstFile), + pInfo.CropW, MFX_ERR_UNDEFINED_BEHAVIOR); + } + break; + } + case MFX_FOURCC_P010: + case MFX_FOURCC_P210: + { + mfxU32 height = pInfo.FourCC == MFX_FOURCC_P010 ? (mfxU32)pInfo.CropH / 2 : (mfxU32)pInfo.CropH; + + for (i = 0; i < height; i++) + { + mfxU16* shortPtr = (mfxU16*)(pData.UV + (pInfo.CropY * pData.Pitch + pInfo.CropX*2) + i * pData.Pitch); + if (pInfo.Shift) + { + // Convert MS-P010 to P010 and write + tmp.resize(pData.Pitch); + + for (int idx = 0; idx < pInfo.CropW; idx++) + { + tmp[idx] = shortPtr[idx] >> 6; + } + + MSDK_CHECK_NOT_EQUAL( + fwrite(&tmp[0], 1, (mfxU32)pInfo.CropW * 2, dstFile), + (mfxU32)pInfo.CropW * 2, MFX_ERR_UNDEFINED_BEHAVIOR); + + } + else + { + MSDK_CHECK_NOT_EQUAL( + fwrite(shortPtr, 1, (mfxU32)pInfo.CropW * 2, dstFile), + (mfxU32)pInfo.CropW * 2, MFX_ERR_UNDEFINED_BEHAVIOR); + } + } + break; + } + + case MFX_FOURCC_RGB4: + case 100: //DXGI_FORMAT_AYUV + case MFX_FOURCC_AYUV: + case MFX_FOURCC_YUY2: + case MFX_FOURCC_A2RGB10: + { + mfxU8* ptr; + + if (pInfo.CropH > 0 && pInfo.CropW > 0) + { + w = pInfo.FourCC==MFX_FOURCC_YUY2 ? pInfo.CropW/2 : pInfo.CropW; + h = pInfo.CropH; + } + else + { + w = pInfo.FourCC == MFX_FOURCC_YUY2 ? pInfo.Width / 2 : pInfo.Width; + h = pInfo.Height; + } + + ptr = MSDK_MIN(MSDK_MIN(pData.R, pData.G), pData.B); + ptr = ptr + pInfo.CropX + pInfo.CropY * pData.Pitch; + + for (i = 0; i < h; i++) + { + MSDK_CHECK_NOT_EQUAL(fwrite(ptr + i * pData.Pitch, 1, 4 * w, dstFile), 4 * w, MFX_ERR_UNDEFINED_BEHAVIOR); + } + fflush(dstFile); + break; + } + + default: + return MFX_ERR_UNSUPPORTED; + } + + return MFX_ERR_NONE; } mfxStatus CSmplYUVWriter::WriteNextFrameI420(mfxFrameSurface1 *pSurface) @@ -1450,7 +1553,15 @@ const msdk_char* ColorFormatToStr(mfxU32 format) return MSDK_STRING("UYVY"); case MFX_FOURCC_P010: return MSDK_STRING("P010"); - default: + case MFX_FOURCC_P210: + return MSDK_STRING("P210"); +#if (MFX_VERSION >= 1027) + case MFX_FOURCC_Y210: + return MSDK_STRING("Y210"); + case MFX_FOURCC_Y410: + return MSDK_STRING("Y410"); +#endif + default: return MSDK_STRING("unsupported"); } } @@ -1958,6 +2069,7 @@ bool IsEncodeCodecSupported(mfxU32 codecFormat) case CODEC_MVC: case MFX_CODEC_VP8: case MFX_CODEC_JPEG: + case MFX_CODEC_VP9: break; default: return false; diff --git a/samples/sample_decode/src/pipeline_decode.cpp b/samples/sample_decode/src/pipeline_decode.cpp index e59443a4d0..2e8a7ba750 100644 --- a/samples/sample_decode/src/pipeline_decode.cpp +++ b/samples/sample_decode/src/pipeline_decode.cpp @@ -467,9 +467,9 @@ bool CDecodingPipeline::IsVppRequired(sInputParams *pParams) bool bVppIsUsed = false; /* Re-size */ if ( (m_mfxVideoParams.mfx.FrameInfo.CropW != pParams->Width) || - (m_mfxVideoParams.mfx.FrameInfo.CropH != pParams->Height) ) + (m_mfxVideoParams.mfx.FrameInfo.CropH != pParams->Height)) { - bVppIsUsed |= pParams->Width && pParams->Height; + bVppIsUsed = pParams->Width && pParams->Height; #if MFX_VERSION >= 1022 if ((MODE_DECODER_POSTPROC_AUTO == pParams->nDecoderPostProcessing) || (MODE_DECODER_POSTPROC_FORCE == pParams->nDecoderPostProcessing) ) @@ -479,6 +479,7 @@ bool CDecodingPipeline::IsVppRequired(sInputParams *pParams) } #endif //MFX_VERSION >= 1022 } + // JPEG and Capture decoders can provide output in nv12 and rgb4 formats if (pParams->videoType == MFX_CODEC_JPEG ) { @@ -615,6 +616,7 @@ mfxStatus CDecodingPipeline::InitMfxParams(sInputParams *pParams) // parse bit stream and fill mfx params sts = m_pmfxDEC->DecodeHeader(&m_mfxBS, &m_mfxVideoParams); #endif + if (!sts) { m_bVppIsUsed = IsVppRequired(pParams); @@ -912,9 +914,13 @@ mfxStatus CDecodingPipeline::InitVppParams() } // P010 video surfaces should be shifted - if (m_mfxVppVideoParams.vpp.Out.FourCC == MFX_FOURCC_P010 && m_memType != SYSTEM_MEMORY) + if ((m_mfxVppVideoParams.vpp.Out.FourCC == MFX_FOURCC_P010 +#if (MFX_VERSION >= 1027) + || m_mfxVppVideoParams.vpp.Out.FourCC == MFX_FOURCC_Y210 +#endif + )&& m_memType != SYSTEM_MEMORY) { - m_mfxVppVideoParams.vpp.Out.Shift = 1; + m_mfxVppVideoParams.vpp.Out.Shift = 1; } return MFX_ERR_NONE; @@ -994,8 +1000,9 @@ mfxStatus CDecodingPipeline::AllocFrames() mfxU16 nSurfNum = 0; // number of surfaces for decoder mfxU16 nVppSurfNum = 0; // number of surfaces for vpp - + MSDK_ZERO_MEMORY(Request); + MSDK_ZERO_MEMORY(VppRequest[0]); MSDK_ZERO_MEMORY(VppRequest[1]); @@ -1003,6 +1010,16 @@ mfxStatus CDecodingPipeline::AllocFrames() MSDK_IGNORE_MFX_STS(sts, MFX_WRN_INCOMPATIBLE_VIDEO_PARAM); MSDK_CHECK_STATUS(sts, "m_pmfxDEC->Query failed"); + // Workaround for VP9 codec + if ((m_mfxVideoParams.mfx.FrameInfo.FourCC == MFX_FOURCC_P010 +#if (MFX_VERSION >= 1027) + || m_mfxVideoParams.mfx.FrameInfo.FourCC == MFX_FOURCC_Y210 +#endif + ) && m_mfxVideoParams.mfx.CodecId==MFX_CODEC_VP9) + { + m_mfxVideoParams.mfx.FrameInfo.Shift = 1; + } + // calculate number of surfaces required for decoder sts = m_pmfxDEC->QueryIOSurf(&m_mfxVideoParams, &Request); if (MFX_WRN_PARTIAL_ACCELERATION == sts) diff --git a/samples/sample_decode/src/sample_decode.cpp b/samples/sample_decode/src/sample_decode.cpp index ef3808a754..201d9292eb 100644 --- a/samples/sample_decode/src/sample_decode.cpp +++ b/samples/sample_decode/src/sample_decode.cpp @@ -41,7 +41,7 @@ void PrintHelp(msdk_char *strAppName, const msdk_char *strErrorMessage) msdk_printf(MSDK_STRING(" or: %s [] -i InputBitstream -o OutputYUVFile\n"), strAppName); msdk_printf(MSDK_STRING("\n")); msdk_printf(MSDK_STRING("Supported codecs ():\n")); - msdk_printf(MSDK_STRING(" =h264|mpeg2|vc1|mvc|jpeg - built-in Media SDK codecs\n")); + msdk_printf(MSDK_STRING(" =h264|mpeg2|vc1|mvc|jpeg|vp9 - built-in Media SDK codecs\n")); msdk_printf(MSDK_STRING(" =h265|vp9|capture - in-box Media SDK plugins (may require separate downloading and installation)\n")); msdk_printf(MSDK_STRING("\n")); msdk_printf(MSDK_STRING("Work models:\n")); diff --git a/samples/sample_encode/include/pipeline_encode.h b/samples/sample_encode/include/pipeline_encode.h index 256f0cccff..cc48285857 100644 --- a/samples/sample_encode/include/pipeline_encode.h +++ b/samples/sample_encode/include/pipeline_encode.h @@ -168,8 +168,9 @@ struct sInputParams mfxU16 IntRefCycleDist; bool bUncut; - bool shouldUseShiftedP010Enc; - bool shouldUseShiftedP010VPP; + bool shouldUseShifted10BitEnc; + bool shouldUseShifted10BitVPP; + bool IsSourceMSB; msdk_char *RoundingOffsetFile; msdk_char DumpFileName[MSDK_MAX_FILENAME_LEN]; diff --git a/samples/sample_encode/src/pipeline_encode.cpp b/samples/sample_encode/src/pipeline_encode.cpp index 325a3c80e3..8c9c4fda78 100644 --- a/samples/sample_encode/src/pipeline_encode.cpp +++ b/samples/sample_encode/src/pipeline_encode.cpp @@ -447,7 +447,7 @@ mfxStatus CEncodingPipeline::InitMfxEncParams(sInputParams *pInParams) m_mfxEncParams.mfx.FrameInfo.FourCC = pInParams->EncodeFourCC; m_mfxEncParams.mfx.FrameInfo.ChromaFormat = FourCCToChroma(pInParams->EncodeFourCC); m_mfxEncParams.mfx.FrameInfo.PicStruct = pInParams->nPicStruct; - m_mfxEncParams.mfx.FrameInfo.Shift = pInParams->shouldUseShiftedP010Enc; + m_mfxEncParams.mfx.FrameInfo.Shift = pInParams->shouldUseShifted10BitEnc; // width must be a multiple of 16 // height must be a multiple of 16 in case of frame picture and a multiple of 32 in case of field picture @@ -696,8 +696,8 @@ mfxStatus CEncodingPipeline::InitMfxVppParams(sInputParams *pInParams) m_mfxVppParams.vpp.Out.ChromaFormat = FourCCToChroma(m_mfxVppParams.vpp.Out.FourCC); // Fill Shift bit - m_mfxVppParams.vpp.In.Shift = pInParams->shouldUseShiftedP010VPP; - m_mfxVppParams.vpp.Out.Shift = pInParams->shouldUseShiftedP010Enc; // This output should correspond to Encoder settings + m_mfxVppParams.vpp.In.Shift = pInParams->shouldUseShifted10BitVPP; + m_mfxVppParams.vpp.Out.Shift = pInParams->shouldUseShifted10BitEnc; // This output should correspond to Encoder settings // input frame info #if defined (ENABLE_V4L2_SUPPORT) @@ -1358,24 +1358,38 @@ mfxStatus CEncodingPipeline::Init(sInputParams *pParams) if (bVpp) { + msdk_printf(MSDK_STRING("Note: VPP is enabled.\n")); m_pmfxVPP = new MFXVideoVPP(m_mfxSession); MSDK_CHECK_POINTER(m_pmfxVPP, MFX_ERR_MEMORY_ALLOC); } // Determine if we should shift P010 surfaces - pParams->shouldUseShiftedP010VPP = m_pmfxVPP && pParams->memType != SYSTEM_MEMORY && - pParams->FileInputFourCC == MFX_FOURCC_P010; + bool readerShift = false; + if (pParams->FileInputFourCC == MFX_FOURCC_P010 || pParams->FileInputFourCC == MFX_FOURCC_P210 +#if (MFX_VERSION >= 1027) + || pParams->FileInputFourCC == MFX_FOURCC_Y210 +#endif + ) + { + if (pParams->IsSourceMSB) + { + pParams->shouldUseShifted10BitVPP = true; + pParams->shouldUseShifted10BitEnc = true; + } + else + { + pParams->shouldUseShifted10BitVPP = m_pmfxVPP && pParams->memType != SYSTEM_MEMORY; - pParams->shouldUseShiftedP010Enc = pParams->memType != SYSTEM_MEMORY && - pParams->FileInputFourCC == MFX_FOURCC_P010 && - AreGuidsEqual(pParams->pluginParams.pluginGuid, MFX_PLUGINID_HEVCE_HW); - bool readerShift = m_pmfxVPP ? pParams->shouldUseShiftedP010VPP : pParams->shouldUseShiftedP010Enc; + pParams->shouldUseShifted10BitEnc = (pParams->memType != SYSTEM_MEMORY && AreGuidsEqual(pParams->pluginParams.pluginGuid, MFX_PLUGINID_HEVCE_HW)) || pParams->CodecId == MFX_CODEC_VP9; + readerShift = m_pmfxVPP ? pParams->shouldUseShifted10BitVPP : pParams->shouldUseShifted10BitEnc; + } + } if(readerShift) { - msdk_printf(MSDK_STRING("\nP010 frames data will be shifted to MSB area to be compatible with HEVC HW input format\n")); + msdk_printf(MSDK_STRING("\n10-bit frames data will be shifted to MSB area to be compatible with MSDK 10-bit input format\n")); } - if(m_pmfxVPP && pParams->shouldUseShiftedP010VPP && !pParams->shouldUseShiftedP010Enc && pParams->bUseHWLib) + if(m_pmfxVPP && pParams->shouldUseShifted10BitVPP && !pParams->shouldUseShifted10BitEnc && pParams->bUseHWLib) { msdk_printf(MSDK_STRING("ERROR: Encoder requires P010 LSB format. VPP currently supports only MSB encoding for P010 format.\nSample cannot combine both of them in one pipeline.\n")); return MFX_ERR_UNSUPPORTED; diff --git a/samples/sample_encode/src/sample_encode.cpp b/samples/sample_encode/src/sample_encode.cpp index d79e792879..9a5cdc4816 100644 --- a/samples/sample_encode/src/sample_encode.cpp +++ b/samples/sample_encode/src/sample_encode.cpp @@ -59,10 +59,11 @@ void PrintHelp(msdk_char *strAppName, const msdk_char *strErrorMessage, ...) msdk_printf(MSDK_STRING("\n")); msdk_printf(MSDK_STRING("Supported codecs, :\n")); msdk_printf(MSDK_STRING(" =h264|mpeg2|vc1|mvc|jpeg - built-in Media SDK codecs\n")); - msdk_printf(MSDK_STRING(" =h265 - in-box Media SDK plugins (may require separate downloading and installation)\n")); + msdk_printf(MSDK_STRING(" =h265|vp9 - in-box Media SDK plugins (may require separate downloading and installation)\n")); msdk_printf(MSDK_STRING(" If codecid is jpeg, -q option is mandatory.)\n")); msdk_printf(MSDK_STRING("Options: \n")); - msdk_printf(MSDK_STRING(" [-nv12|yuy2|p010|rgb4] - input color format (by default YUV420 is expected). YUY2 is for JPEG encode only.\n")); + msdk_printf(MSDK_STRING(" [-nv12|yuy2|ayuv|rgb4|p010|y210|y410|a2rgb10] - input color format (by default YUV420 is expected).\n")); + msdk_printf(MSDK_STRING(" [-msb10] - 10-bit color format is expected to have data in Most Significant Bits of words.\n (LSB data placement is expected by default).\n This option also disables data shifting during file reading.\n")); msdk_printf(MSDK_STRING(" [-ec::p010] - force usage of P010 surfaces for encoder (conversion will be made if necessary). Use for 10 bit HEVC encoding\n")); msdk_printf(MSDK_STRING(" [-tff|bff] - input stream is interlaced, top|bottom fielf first, if not specified progressive is expected\n")); msdk_printf(MSDK_STRING(" [-bref] - arrange B frames in B pyramid reference structure\n")); @@ -138,7 +139,7 @@ void PrintHelp(msdk_char *strAppName, const msdk_char *strErrorMessage, ...) msdk_printf(MSDK_STRING(" [-usei] - insert user data unregistered SEI. eg: 7fc92488825d11e7bb31be2e44b06b34:0:MSDK (uuid:type<0-preifx/1-suffix>:message)\n")); msdk_printf(MSDK_STRING(" the suffix SEI for HEVCe can be inserted when CQP used or HRD disabled\n")); #if (MFX_VERSION >= 1024) - msdk_printf(MSDK_STRING(" [-extbrc:] - External BRC for AVC and HEVC encoders")); + msdk_printf(MSDK_STRING(" [-extbrc:] - External BRC for AVC and HEVC encoders\n")); #endif #if (MFX_VERSION >= 1026) msdk_printf(MSDK_STRING(" [-ExtBrcAdaptiveLTR:] - Set AdaptiveLTR for implicit extbrc")); @@ -277,7 +278,34 @@ mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* p pParams->FileInputFourCC = MFX_FOURCC_P010; pParams->EncodeFourCC = MFX_FOURCC_P010; } - else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ec::p010"))) + else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ayuv"))) + { + pParams->FileInputFourCC = MFX_FOURCC_AYUV; + pParams->EncodeFourCC = MFX_FOURCC_AYUV; + } + else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-yuy2"))) + { + pParams->FileInputFourCC = MFX_FOURCC_YUY2; + pParams->EncodeFourCC = MFX_FOURCC_YUY2; + } +#if (MFX_VERSION >= 1027) + else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-y210"))) + { + pParams->FileInputFourCC = MFX_FOURCC_Y210; + pParams->EncodeFourCC = MFX_FOURCC_Y210; + } + else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-y410"))) + { + pParams->FileInputFourCC = MFX_FOURCC_Y410; + pParams->EncodeFourCC = MFX_FOURCC_Y410; + } +#endif + else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-a2rgb10"))) + { + pParams->FileInputFourCC = MFX_FOURCC_A2RGB10; + pParams->EncodeFourCC = MFX_FOURCC_A2RGB10; + } + else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-ec::p010"))) { pParams->EncodeFourCC = MFX_FOURCC_P010; } @@ -305,6 +333,10 @@ mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* p return MFX_ERR_UNSUPPORTED; } } + else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-msb10"))) + { + pParams->IsSourceMSB = true; + } else if (0 == msdk_strcmp(strInput[i], MSDK_STRING("-angle"))) { VAL_CHECK(i+1 >= nArgNum, i, strInput[i]); @@ -943,23 +975,24 @@ mfxStatus ParseInputString(msdk_char* strInput[], mfxU8 nArgNum, sInputParams* p if (MFX_CODEC_MPEG2 != pParams->CodecId && MFX_CODEC_AVC != pParams->CodecId && MFX_CODEC_JPEG != pParams->CodecId && - MFX_CODEC_HEVC != pParams->CodecId) + MFX_CODEC_HEVC != pParams->CodecId && + MFX_CODEC_VP9 != pParams->CodecId) { PrintHelp(strInput[0], MSDK_STRING("Unknown codec")); return MFX_ERR_UNSUPPORTED; } - if (MFX_CODEC_JPEG != pParams->CodecId && + if (MFX_CODEC_JPEG != pParams->CodecId && MFX_CODEC_HEVC != pParams->CodecId && pParams->FileInputFourCC == MFX_FOURCC_YUY2 && !pParams->isV4L2InputEnabled) { - PrintHelp(strInput[0], MSDK_STRING("-yuy2 option is supported only for JPEG encoder")); + PrintHelp(strInput[0], MSDK_STRING("-yuy2 option is supported only for JPEG or HEVC encoder")); return MFX_ERR_UNSUPPORTED; } - if (MFX_CODEC_HEVC != pParams->CodecId && (pParams->EncodeFourCC == MFX_FOURCC_P010) ) + if (MFX_CODEC_HEVC != pParams->CodecId && MFX_CODEC_VP9 != pParams->CodecId && (pParams->EncodeFourCC == MFX_FOURCC_P010) ) { - PrintHelp(strInput[0], MSDK_STRING("P010 surfaces are supported only for HEVC encoder")); + PrintHelp(strInput[0], MSDK_STRING("P010 surfaces are supported only for HEVC and VP9 encoder")); return MFX_ERR_UNSUPPORTED; }