Use nullptr instead of NULL whenever possible.

Microsoft recommends to avoid using NULL or zero (0) as a null pointer constant since nullptr is less vulnerable to misuse and works better in most situations.

Also fix some cases where NULL was used instead of 0 or FALSE.

10 files changed, 227 insertions, 227 deletions

diff --git a/src/filters/transform/MPCVideoDec/DXVADecoder.cpp b/src/filters/transform/MPCVideoDec/DXVADecoder.cpp
index 23b07dcba..3b343921b 100644
--- a/src/filters/transform/MPCVideoDec/DXVADecoder.cpp
+++ b/src/filters/transform/MPCVideoDec/DXVADecoder.cpp
@@ -117,7 +117,7 @@ void CDXVADecoder::Flush()
         m_pPictureStore[i].bRefPicture    = false;

         m_pPictureStore[i].bInUse         = false;

         m_pPictureStore[i].bDisplayed     = false;

-        m_pPictureStore[i].pSample        = NULL;

+        m_pPictureStore[i].pSample        = nullptr;

         m_pPictureStore[i].nCodecSpecific = -1;

         m_pPictureStore[i].dwDisplayCount = 0;

     }

@@ -126,7 +126,7 @@ void CDXVADecoder::Flush()
     m_bFlushed       = true;

     m_nFieldSurface  = -1;

     m_dwDisplayCount = 1;

-    m_pFieldSample   = NULL;

+    m_pFieldSample   = nullptr;

 }

 

 HRESULT CDXVADecoder::ConfigureDXVA1()

@@ -142,7 +142,7 @@ HRESULT CDXVADecoder::ConfigureDXVA1()
         ConfigRequested.bConfigBitstreamRaw           = 2;

 

         writeDXVA_QueryOrReplyFunc(&ConfigRequested.dwFunction, DXVA_QUERYORREPLYFUNCFLAG_DECODER_PROBE_QUERY, DXVA_PICTURE_DECODING_FUNCTION);

-        hr = m_pAMVideoAccelerator->Execute(ConfigRequested.dwFunction, &ConfigRequested, sizeof(DXVA_ConfigPictureDecode), &m_DXVA1Config, sizeof(DXVA_ConfigPictureDecode), 0, NULL);

+        hr = m_pAMVideoAccelerator->Execute(ConfigRequested.dwFunction, &ConfigRequested, sizeof(DXVA_ConfigPictureDecode), &m_DXVA1Config, sizeof(DXVA_ConfigPictureDecode), 0, nullptr);

 

         // Copy to DXVA2 structure (simplify code based on accelerator config)

         m_DXVA2Config.guidConfigBitstreamEncryption = m_DXVA1Config.guidConfigBitstreamEncryption;

@@ -163,7 +163,7 @@ HRESULT CDXVADecoder::ConfigureDXVA1()
 

         if (SUCCEEDED(hr)) {

             writeDXVA_QueryOrReplyFunc(&m_DXVA1Config.dwFunction, DXVA_QUERYORREPLYFUNCFLAG_DECODER_LOCK_QUERY, DXVA_PICTURE_DECODING_FUNCTION);

-            hr = m_pAMVideoAccelerator->Execute(m_DXVA1Config.dwFunction, &m_DXVA1Config, sizeof(DXVA_ConfigPictureDecode), &ConfigRequested, sizeof(DXVA_ConfigPictureDecode), 0, NULL);

+            hr = m_pAMVideoAccelerator->Execute(m_DXVA1Config.dwFunction, &m_DXVA1Config, sizeof(DXVA_ConfigPictureDecode), &ConfigRequested, sizeof(DXVA_ConfigPictureDecode), 0, nullptr);

 

             // TODO : check config!

             //ASSERT (ConfigRequested.bConfigBitstreamRaw == 2);

@@ -181,7 +181,7 @@ HRESULT CDXVADecoder::ConfigureDXVA1()
 

 CDXVADecoder* CDXVADecoder::CreateDecoder(CMPCVideoDecFilter* pFilter, IAMVideoAccelerator* pAMVideoAccelerator, const GUID* guidDecoder, int nPicEntryNumber)

 {

-    CDXVADecoder* pDecoder = NULL;

+    CDXVADecoder* pDecoder = nullptr;

 

     if ((*guidDecoder == DXVA2_ModeH264_E) || (*guidDecoder == DXVA2_ModeH264_F) || (*guidDecoder == DXVA_Intel_H264_ClearVideo)) {

         pDecoder = DEBUG_NEW CDXVADecoderH264(pFilter, pAMVideoAccelerator, H264_VLD, nPicEntryNumber);

@@ -198,7 +198,7 @@ CDXVADecoder* CDXVADecoder::CreateDecoder(CMPCVideoDecFilter* pFilter, IAMVideoA
 

 CDXVADecoder* CDXVADecoder::CreateDecoder(CMPCVideoDecFilter* pFilter, IDirectXVideoDecoder* pDirectXVideoDec, const GUID* guidDecoder, int nPicEntryNumber, DXVA2_ConfigPictureDecode* pDXVA2Config)

 {

-    CDXVADecoder* pDecoder = NULL;

+    CDXVADecoder* pDecoder = nullptr;

 

     if ((*guidDecoder == DXVA2_ModeH264_E) || (*guidDecoder == DXVA2_ModeH264_F) || (*guidDecoder == DXVA_Intel_H264_ClearVideo)) {

         pDecoder = DEBUG_NEW CDXVADecoderH264(pFilter, pDirectXVideoDec, H264_VLD, nPicEntryNumber, pDXVA2Config);

@@ -299,7 +299,7 @@ HRESULT CDXVADecoder::GetDeliveryBuffer(REFERENCE_TIME rtStart, REFERENCE_TIME r
 

     if (SUCCEEDED(hr)) {

         pNewSample->SetTime(&rtStart, &rtStop);

-        pNewSample->SetMediaTime(NULL, NULL);

+        pNewSample->SetMediaTime(nullptr, nullptr);

         *ppSampleToDeliver = pNewSample.Detach();

     }

     return hr;

@@ -315,7 +315,7 @@ HRESULT CDXVADecoder::Execute()
             HRESULT hr2;

 

             //writeDXVA_QueryOrReplyFunc(&dwFunction, DXVA_QUERYORREPLYFUNCFLAG_DECODER_LOCK_QUERY, DXVA_PICTURE_DECODING_FUNCTION);

-            //hr = m_pAMVideoAccelerator->Execute (dwFunction, &m_DXVA1Config, sizeof(DXVA_ConfigPictureDecode), NULL, 0, m_dwNumBuffersInfo, m_DXVA1BufferInfo);

+            //hr = m_pAMVideoAccelerator->Execute (dwFunction, &m_DXVA1Config, sizeof(DXVA_ConfigPictureDecode), nullptr, 0, m_dwNumBuffersInfo, m_DXVA1BufferInfo);

 

             DWORD dwResult;

             dwFunction = 0x01000000;

@@ -356,7 +356,7 @@ HRESULT CDXVADecoder::QueryStatus(PVOID LPDXVAStatus, UINT nSize)
 

     switch (m_nEngine) {

         case ENGINE_DXVA1:

-            hr = m_pAMVideoAccelerator->Execute(dwFunction, NULL, 0, LPDXVAStatus, nSize, 0, NULL);

+            hr = m_pAMVideoAccelerator->Execute(dwFunction, nullptr, 0, LPDXVAStatus, nSize, 0, nullptr);

             break;

 

         case ENGINE_DXVA2:

@@ -420,7 +420,7 @@ HRESULT CDXVADecoder::BeginFrame(int nSurfaceIndex, IMediaSample* pSampleToDeliv
                 BeginFrameInfo.dwSizeInputData = sizeof(nSurfaceIndex);

                 BeginFrameInfo.pInputData = &nSurfaceIndex;

                 BeginFrameInfo.dwSizeOutputData = 0;

-                BeginFrameInfo.pOutputData = NULL;

+                BeginFrameInfo.pOutputData = nullptr;

 

                 DO_DXVA_PENDING_LOOP(m_pAMVideoAccelerator->BeginFrame(&BeginFrameInfo));

 

@@ -437,7 +437,7 @@ HRESULT CDXVADecoder::BeginFrame(int nSurfaceIndex, IMediaSample* pSampleToDeliv
                 if (pSampleService) {

                     hr = pSampleService->GetService(MR_BUFFER_SERVICE, __uuidof(IDirect3DSurface9), (void**) &pDecoderRenderTarget);

                     if (SUCCEEDED(hr)) {

-                        DO_DXVA_PENDING_LOOP(m_pDirectXVideoDec->BeginFrame(pDecoderRenderTarget, NULL));

+                        DO_DXVA_PENDING_LOOP(m_pDirectXVideoDec->BeginFrame(pDecoderRenderTarget, nullptr));

                     }

                 }

             }

@@ -473,7 +473,7 @@ HRESULT CDXVADecoder::EndFrame(int nSurfaceIndex)
             break;

 

         case ENGINE_DXVA2:

-            hr = m_pDirectXVideoDec->EndFrame(NULL);

+            hr = m_pDirectXVideoDec->EndFrame(nullptr);

             break;

         default:

             ASSERT(FALSE);

@@ -499,9 +499,9 @@ bool CDXVADecoder::AddToStore(int nSurfaceIndex, IMediaSample* pSample, bool bRe
     } else {

         //TRACE(_T("Add Stor: [%10I64d - %10I64d], Ind = %d, Codec=%d\n"), rtStart, rtStop, nSurfaceIndex, nCodecSpecific);

         /*

-        ASSERT(m_pPictureStore[nSurfaceIndex].pSample == NULL);

+        ASSERT(m_pPictureStore[nSurfaceIndex].pSample == nullptr);

         ASSERT(!m_pPictureStore[nSurfaceIndex].bInUse);

-        ASSERT((nSurfaceIndex < m_nPicEntryNumber) && (m_pPictureStore[nSurfaceIndex].pSample == NULL));

+        ASSERT((nSurfaceIndex < m_nPicEntryNumber) && (m_pPictureStore[nSurfaceIndex].pSample == nullptr));

         */

 

         m_pPictureStore[nSurfaceIndex].bRefPicture      = bRefPicture;

@@ -707,7 +707,7 @@ void CDXVADecoder::FreePictureSlot(int nSurfaceIndex)
     m_pPictureStore[nSurfaceIndex].dwDisplayCount   = m_dwDisplayCount++;

     m_pPictureStore[nSurfaceIndex].bInUse           = false;

     m_pPictureStore[nSurfaceIndex].bDisplayed       = false;

-    m_pPictureStore[nSurfaceIndex].pSample          = NULL;

+    m_pPictureStore[nSurfaceIndex].pSample          = nullptr;

     m_pPictureStore[nSurfaceIndex].nCodecSpecific   = -1;

     m_nWaitingPics--;

 }

diff --git a/src/filters/transform/MPCVideoDec/DXVADecoderH264.cpp b/src/filters/transform/MPCVideoDec/DXVADecoderH264.cpp
index 68c40d362..71ffbe82a 100644
--- a/src/filters/transform/MPCVideoDec/DXVADecoderH264.cpp
+++ b/src/filters/transform/MPCVideoDec/DXVADecoderH264.cpp
@@ -1,5 +1,5 @@
 /*

- * (C) 2007-2012 see Authors.txt

+ * (C) 2007-2013 see Authors.txt

  *

  * This file is part of MPC-HC.

  *

@@ -335,7 +335,7 @@ void CDXVADecoderH264::SetExtraData(BYTE* pDataIn, UINT nSize)
     AVCodecContext* pAVCtx = m_pFilter->GetAVCtx();

     m_nNALLength = pAVCtx->nal_length_size;

 

-    FFH264DecodeBuffer(pAVCtx, pDataIn, nSize, NULL, NULL, NULL);

+    FFH264DecodeBuffer(pAVCtx, pDataIn, nSize, nullptr, nullptr, nullptr);

     FFH264SetDxvaSliceLong(pAVCtx, m_pSliceLong);

 }

 

diff --git a/src/filters/transform/MPCVideoDec/DXVADecoderMpeg2.cpp b/src/filters/transform/MPCVideoDec/DXVADecoderMpeg2.cpp
index 6037452c2..286ba9d0c 100644
--- a/src/filters/transform/MPCVideoDec/DXVADecoderMpeg2.cpp
+++ b/src/filters/transform/MPCVideoDec/DXVADecoderMpeg2.cpp
@@ -91,7 +91,7 @@ HRESULT CDXVADecoderMpeg2::DecodeFrame(BYTE* pDataIn, UINT nSize, REFERENCE_TIME
         if (!m_PictureParams.bSecondField) {

             m_rtStart = rtStart;

             m_rtStop  = rtStop;

-            m_pSampleToDeliver = NULL;

+            m_pSampleToDeliver = nullptr;

             hr = GetFreeSurfaceIndex(m_nSurfaceIndex, &m_pSampleToDeliver, rtStart, rtStop);

             if (FAILED(hr)) {

                 ASSERT(hr == VFW_E_NOT_COMMITTED);      // Normal when stop playing

@@ -101,7 +101,7 @@ HRESULT CDXVADecoderMpeg2::DecodeFrame(BYTE* pDataIn, UINT nSize, REFERENCE_TIME
     } else {

         m_rtStart = rtStart;

         m_rtStop  = rtStop;

-        m_pSampleToDeliver = NULL;

+        m_pSampleToDeliver = nullptr;

         hr = GetFreeSurfaceIndex(m_nSurfaceIndex, &m_pSampleToDeliver, rtStart, rtStop);

         if (FAILED(hr)) {

             ASSERT(hr == VFW_E_NOT_COMMITTED);      // Normal when stop playing

@@ -110,7 +110,7 @@ HRESULT CDXVADecoderMpeg2::DecodeFrame(BYTE* pDataIn, UINT nSize, REFERENCE_TIME
     }

 

     // m_pSampleToDeliver is unused for DXVA1

-    if (GetEngine() == ENGINE_DXVA2 && m_pSampleToDeliver == NULL) {

+    if (GetEngine() == ENGINE_DXVA2 && m_pSampleToDeliver == nullptr) {

         return S_FALSE;

     }

 

@@ -236,7 +236,7 @@ void CDXVADecoderMpeg2::Flush()
     m_wRefPictureIndex[1] = NO_REF_FRAME;

 

     m_nSurfaceIndex = 0;

-    m_pSampleToDeliver = NULL;

+    m_pSampleToDeliver = nullptr;

     m_bSecondField = false;

 

     m_rtStart = _I64_MIN;

diff --git a/src/filters/transform/MPCVideoDec/DXVADecoderVC1.cpp b/src/filters/transform/MPCVideoDec/DXVADecoderVC1.cpp
index 3e2bc0aed..a08b414b1 100644
--- a/src/filters/transform/MPCVideoDec/DXVADecoderVC1.cpp
+++ b/src/filters/transform/MPCVideoDec/DXVADecoderVC1.cpp
@@ -1,5 +1,5 @@
 /*

- * (C) 2007-2012 see Authors.txt

+ * (C) 2007-2013 see Authors.txt

  *

  * This file is part of MPC-HC.

  *

@@ -142,7 +142,7 @@ HRESULT CDXVADecoderVC1::DecodeFrame(BYTE* pDataIn, UINT nSize, REFERENCE_TIME r
 

     // ***************

     if (nFrameSize) { // Decoding Second Field

-        FFVC1UpdatePictureParam(&m_PictureParams, m_pFilter->GetAVCtx(), NULL, NULL, pDataIn, nSize, NULL, TRUE, &m_bFrame_repeat_pict);

+        FFVC1UpdatePictureParam(&m_PictureParams, m_pFilter->GetAVCtx(), nullptr, nullptr, pDataIn, nSize, nullptr, TRUE, &m_bFrame_repeat_pict);

 

         CHECK_HR_TRACE(BeginFrame(nSurfaceIndex, pSampleToDeliver));

 

@@ -250,7 +250,7 @@ BYTE* CDXVADecoderVC1::FindNextStartCode(BYTE* pBuffer, UINT nSize, UINT& nPacke
 

     ASSERT(FALSE);      // Should never happen!

 

-    return NULL;

+    return nullptr;

 }

 

 void CDXVADecoderVC1::CopyBitstream(BYTE* pDXVABuffer, BYTE* pBuffer, UINT& nSize)

diff --git a/src/filters/transform/MPCVideoDec/FfmpegContext.cpp b/src/filters/transform/MPCVideoDec/FfmpegContext.cpp
index a5cd1877e..ee09201da 100644
--- a/src/filters/transform/MPCVideoDec/FfmpegContext.cpp
+++ b/src/filters/transform/MPCVideoDec/FfmpegContext.cpp
@@ -154,7 +154,7 @@ bool CheckPCID(WORD pcid, const WORD* pPCIDs, size_t len)
 inline MpegEncContext* GetMpegEncContext(struct AVCodecContext* pAVCtx)

 {

     Mpeg1Context* s1;

-    MpegEncContext* s = NULL;

+    MpegEncContext* s = nullptr;

 

     switch (pAVCtx->codec_id) {

         case AV_CODEC_ID_VC1:

@@ -177,11 +177,11 @@ int FFH264DecodeBuffer(struct AVCodecContext* pAVCtx,
                        REFERENCE_TIME* pOutrtStart)

 {

     int result = -1;

-    if (pBuffer != NULL) {

+    if (pBuffer != nullptr) {

         H264Context* h = (H264Context*) pAVCtx->priv_data;

         result = av_h264_decode_frame(pAVCtx, pOutPOC, pOutrtStart, pBuffer, nSize);

 

-        if (result != -1 && h->s.current_picture_ptr != NULL && pFramePOC) {

+        if (result != -1 && h->s.current_picture_ptr != nullptr && pFramePOC) {

             *pFramePOC = h->s.current_picture_ptr->poc;

         }

     }

@@ -228,14 +228,14 @@ int FFH264CheckCompatibility(int nWidth,
     int profile_higher_than_high = 0;

     int max_ref_frames_dpb41 = min(11, 8388608 / (nWidth * nHeight));

 

-    if (pBuffer != NULL) {

-        av_h264_decode_frame(pAVCtx, NULL, NULL, pBuffer, nSize);

+    if (pBuffer != nullptr) {

+        av_h264_decode_frame(pAVCtx, nullptr, nullptr, pBuffer, nSize);

     }

 

     cur_sps = pContext->sps_buffers[0];

     cur_pps = pContext->pps_buffers[0];

 

-    if (cur_sps != NULL) {

+    if (cur_sps != nullptr) {

         int max_ref_frames = 0;

 

         if (cur_sps->bit_depth_luma > 8 || cur_sps->chroma_format_idc > 1) {

@@ -470,14 +470,14 @@ void FFH264UpdateRefFramesList(DXVA_PicParams_H264* pDXVAPicParams, struct AVCod
             AssociatedFlag = pic->long_ref != 0;

         } else {

             // Long list reference frames

-            pic = NULL;

+            pic = nullptr;

             while (!pic && j < h->short_ref_count + 16) {

                 pic = h->long_ref[j++ - h->short_ref_count];

             }

             AssociatedFlag = 1;

         }

 

-        if (pic != NULL) {

+        if (pic != nullptr) {

             pDXVAPicParams->FrameNumList[i] = pic->long_ref ? pic->pic_id : pic->frame_num;

             pDXVAPicParams->FieldOrderCntList[i][0] = 0;

             pDXVAPicParams->FieldOrderCntList[i][1] = 0;

@@ -833,7 +833,7 @@ unsigned long FFGetMBNumber(struct AVCodecContext* pAVCtx)
 {

     MpegEncContext* s = GetMpegEncContext(pAVCtx);

 

-    return (s != NULL) ? s->mb_num : 0;

+    return (s != nullptr) ? s->mb_num : 0;

 }

 

 int FFIsSkipped(struct AVCodecContext* pAVCtx)

@@ -888,14 +888,14 @@ int FFGetCodedPicture(struct AVCodecContext* pAVCtx)
 {

     MpegEncContext* s = GetMpegEncContext(pAVCtx);

 

-    return (s != NULL) ? s->current_picture.f.coded_picture_number : 0;

+    return (s != nullptr) ? s->current_picture.f.coded_picture_number : 0;

 }

 

 BOOL FFGetAlternateScan(struct AVCodecContext* pAVCtx)

 {

     MpegEncContext* s = GetMpegEncContext(pAVCtx);

 

-    return (s != NULL) ? s->alternate_scan : 0;

+    return (s != nullptr) ? s->alternate_scan : 0;

 }

 

 BOOL DXVACheckFramesize(int width, int height, DWORD nPCIVendor, DWORD nPCIDevice)

diff --git a/src/filters/transform/MPCVideoDec/MPCFfmpegDec.cpp b/src/filters/transform/MPCVideoDec/MPCFfmpegDec.cpp
index b10403b6c..4528621d3 100644
--- a/src/filters/transform/MPCVideoDec/MPCFfmpegDec.cpp
+++ b/src/filters/transform/MPCVideoDec/MPCFfmpegDec.cpp
@@ -26,8 +26,8 @@
 

 // Workaround: graphedit crashes when a filter exposes more than 115 input MediaTypes!

 const AMOVIESETUP_PIN sudpPinsVideoDec[] = {

-    {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, NULL, CMPCVideoDecFilter::sudPinTypesInCount > 115 ? 115 : CMPCVideoDecFilter::sudPinTypesInCount,  CMPCVideoDecFilter::sudPinTypesIn},

-    {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, NULL, CMPCVideoDecFilter::sudPinTypesOutCount, CMPCVideoDecFilter::sudPinTypesOut}

+    {L"Input", FALSE, FALSE, FALSE, FALSE, &CLSID_NULL, nullptr, CMPCVideoDecFilter::sudPinTypesInCount > 115 ? 115 : CMPCVideoDecFilter::sudPinTypesInCount,  CMPCVideoDecFilter::sudPinTypesIn},

+    {L"Output", FALSE, TRUE, FALSE, FALSE, &CLSID_NULL, nullptr, CMPCVideoDecFilter::sudPinTypesOutCount, CMPCVideoDecFilter::sudPinTypesOut}

 };

 

 const AMOVIESETUP_FILTER sudFilters[] = {

@@ -35,7 +35,7 @@ const AMOVIESETUP_FILTER sudFilters[] = {
 };

 

 CFactoryTemplate g_Templates[] = {

-    {sudFilters[0].strName, &__uuidof(CMPCVideoDecFilter), CreateInstance<CMPCVideoDecFilter>, NULL, &sudFilters[0]},

+    {sudFilters[0].strName, &__uuidof(CMPCVideoDecFilter), CreateInstance<CMPCVideoDecFilter>, nullptr, &sudFilters[0]},

     {L"CMPCVideoDecPropertyPage", &__uuidof(CMPCVideoDecSettingsWnd), CreateInstance<CInternalPropertyPageTempl<CMPCVideoDecSettingsWnd>>},

     {L"CMPCVideoDecPropertyPage2", &__uuidof(CMPCVideoDecCodecWnd), CreateInstance<CInternalPropertyPageTempl<CMPCVideoDecCodecWnd>>},

 };

diff --git a/src/filters/transform/MPCVideoDec/MPCVideoDecFilter.cpp b/src/filters/transform/MPCVideoDec/MPCVideoDecFilter.cpp
index 2ef06fb4b..853401ffc 100644
--- a/src/filters/transform/MPCVideoDec/MPCVideoDecFilter.cpp
+++ b/src/filters/transform/MPCVideoDec/MPCVideoDecFilter.cpp
@@ -114,51 +114,51 @@ DXVA_PARAMS DXVA_VC1 = {
 FFMPEG_CODECS ffCodecs[] = {

 #if HAS_FFMPEG_VIDEO_DECODERS

     // Flash video

-    { &MEDIASUBTYPE_FLV1, AV_CODEC_ID_FLV1, NULL },

-    { &MEDIASUBTYPE_flv1, AV_CODEC_ID_FLV1, NULL },

-    { &MEDIASUBTYPE_FLV4, AV_CODEC_ID_VP6F, NULL },

-    { &MEDIASUBTYPE_flv4, AV_CODEC_ID_VP6F, NULL },

-    { &MEDIASUBTYPE_VP6F, AV_CODEC_ID_VP6F, NULL },

-    { &MEDIASUBTYPE_vp6f, AV_CODEC_ID_VP6F, NULL },

+    { &MEDIASUBTYPE_FLV1, AV_CODEC_ID_FLV1, nullptr },

+    { &MEDIASUBTYPE_flv1, AV_CODEC_ID_FLV1, nullptr },

+    { &MEDIASUBTYPE_FLV4, AV_CODEC_ID_VP6F, nullptr },

+    { &MEDIASUBTYPE_flv4, AV_CODEC_ID_VP6F, nullptr },

+    { &MEDIASUBTYPE_VP6F, AV_CODEC_ID_VP6F, nullptr },

+    { &MEDIASUBTYPE_vp6f, AV_CODEC_ID_VP6F, nullptr },

 

     // VP3

-    { &MEDIASUBTYPE_VP30, AV_CODEC_ID_VP3,  NULL },

-    { &MEDIASUBTYPE_VP31, AV_CODEC_ID_VP3,  NULL },

+    { &MEDIASUBTYPE_VP30, AV_CODEC_ID_VP3,  nullptr },

+    { &MEDIASUBTYPE_VP31, AV_CODEC_ID_VP3,  nullptr },

 

     // VP5

-    { &MEDIASUBTYPE_VP50, AV_CODEC_ID_VP5,  NULL },

-    { &MEDIASUBTYPE_vp50, AV_CODEC_ID_VP5,  NULL },

+    { &MEDIASUBTYPE_VP50, AV_CODEC_ID_VP5,  nullptr },

+    { &MEDIASUBTYPE_vp50, AV_CODEC_ID_VP5,  nullptr },

 

     // VP6

-    { &MEDIASUBTYPE_VP60, AV_CODEC_ID_VP6,  NULL },

-    { &MEDIASUBTYPE_vp60, AV_CODEC_ID_VP6,  NULL },

-    { &MEDIASUBTYPE_VP61, AV_CODEC_ID_VP6,  NULL },

-    { &MEDIASUBTYPE_vp61, AV_CODEC_ID_VP6,  NULL },

-    { &MEDIASUBTYPE_VP62, AV_CODEC_ID_VP6,  NULL },

-    { &MEDIASUBTYPE_vp62, AV_CODEC_ID_VP6,  NULL },

-    { &MEDIASUBTYPE_VP6A, AV_CODEC_ID_VP6A, NULL },

-    { &MEDIASUBTYPE_vp6a, AV_CODEC_ID_VP6A, NULL },

+    { &MEDIASUBTYPE_VP60, AV_CODEC_ID_VP6,  nullptr },

+    { &MEDIASUBTYPE_vp60, AV_CODEC_ID_VP6,  nullptr },

+    { &MEDIASUBTYPE_VP61, AV_CODEC_ID_VP6,  nullptr },

+    { &MEDIASUBTYPE_vp61, AV_CODEC_ID_VP6,  nullptr },

+    { &MEDIASUBTYPE_VP62, AV_CODEC_ID_VP6,  nullptr },

+    { &MEDIASUBTYPE_vp62, AV_CODEC_ID_VP6,  nullptr },

+    { &MEDIASUBTYPE_VP6A, AV_CODEC_ID_VP6A, nullptr },

+    { &MEDIASUBTYPE_vp6a, AV_CODEC_ID_VP6A, nullptr },

 

     // VP8

-    { &MEDIASUBTYPE_VP80, AV_CODEC_ID_VP8, NULL },

+    { &MEDIASUBTYPE_VP80, AV_CODEC_ID_VP8, nullptr },

 

     // Xvid

-    { &MEDIASUBTYPE_XVID, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_xvid, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_XVIX, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_xvix, AV_CODEC_ID_MPEG4, NULL },

+    { &MEDIASUBTYPE_XVID, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_xvid, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_XVIX, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_xvix, AV_CODEC_ID_MPEG4, nullptr },

 

     // DivX

-    { &MEDIASUBTYPE_DX50, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_dx50, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_DIVX, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_divx, AV_CODEC_ID_MPEG4, NULL },

+    { &MEDIASUBTYPE_DX50, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_dx50, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_DIVX, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_divx, AV_CODEC_ID_MPEG4, nullptr },

 

     // WMV1/2/3

-    { &MEDIASUBTYPE_WMV1, AV_CODEC_ID_WMV1, NULL },

-    { &MEDIASUBTYPE_wmv1, AV_CODEC_ID_WMV1, NULL },

-    { &MEDIASUBTYPE_WMV2, AV_CODEC_ID_WMV2, NULL },

-    { &MEDIASUBTYPE_wmv2, AV_CODEC_ID_WMV2, NULL },

+    { &MEDIASUBTYPE_WMV1, AV_CODEC_ID_WMV1, nullptr },

+    { &MEDIASUBTYPE_wmv1, AV_CODEC_ID_WMV1, nullptr },

+    { &MEDIASUBTYPE_WMV2, AV_CODEC_ID_WMV2, nullptr },

+    { &MEDIASUBTYPE_wmv2, AV_CODEC_ID_WMV2, nullptr },

     { &MEDIASUBTYPE_WMV3, AV_CODEC_ID_WMV3, &DXVA_VC1 },

     { &MEDIASUBTYPE_wmv3, AV_CODEC_ID_WMV3, &DXVA_VC1 },

 

@@ -167,52 +167,52 @@ FFMPEG_CODECS ffCodecs[] = {
     { &MEDIASUBTYPE_MPG2,        AV_CODEC_ID_MPEG2VIDEO, &DXVA_Mpeg2 },

 

     // MSMPEG-4

-    { &MEDIASUBTYPE_DIV3, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_div3, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_DVX3, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_dvx3, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_MP43, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_mp43, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_COL1, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_col1, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_DIV4, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_div4, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_DIV5, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_div5, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_DIV6, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_div6, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_AP41, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_ap41, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_MPG3, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_mpg3, AV_CODEC_ID_MSMPEG4V3, NULL },

-    { &MEDIASUBTYPE_DIV2, AV_CODEC_ID_MSMPEG4V2, NULL },

-    { &MEDIASUBTYPE_div2, AV_CODEC_ID_MSMPEG4V2, NULL },

-    { &MEDIASUBTYPE_MP42, AV_CODEC_ID_MSMPEG4V2, NULL },

-    { &MEDIASUBTYPE_mp42, AV_CODEC_ID_MSMPEG4V2, NULL },

-    { &MEDIASUBTYPE_MPG4, AV_CODEC_ID_MSMPEG4V1, NULL },

-    { &MEDIASUBTYPE_mpg4, AV_CODEC_ID_MSMPEG4V1, NULL },

-    { &MEDIASUBTYPE_DIV1, AV_CODEC_ID_MSMPEG4V1, NULL },

-    { &MEDIASUBTYPE_div1, AV_CODEC_ID_MSMPEG4V1, NULL },

-    { &MEDIASUBTYPE_MP41, AV_CODEC_ID_MSMPEG4V1, NULL },

-    { &MEDIASUBTYPE_mp41, AV_CODEC_ID_MSMPEG4V1, NULL },

+    { &MEDIASUBTYPE_DIV3, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_div3, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_DVX3, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_dvx3, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_MP43, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_mp43, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_COL1, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_col1, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_DIV4, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_div4, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_DIV5, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_div5, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_DIV6, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_div6, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_AP41, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_ap41, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_MPG3, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_mpg3, AV_CODEC_ID_MSMPEG4V3, nullptr },

+    { &MEDIASUBTYPE_DIV2, AV_CODEC_ID_MSMPEG4V2, nullptr },

+    { &MEDIASUBTYPE_div2, AV_CODEC_ID_MSMPEG4V2, nullptr },

+    { &MEDIASUBTYPE_MP42, AV_CODEC_ID_MSMPEG4V2, nullptr },

+    { &MEDIASUBTYPE_mp42, AV_CODEC_ID_MSMPEG4V2, nullptr },

+    { &MEDIASUBTYPE_MPG4, AV_CODEC_ID_MSMPEG4V1, nullptr },

+    { &MEDIASUBTYPE_mpg4, AV_CODEC_ID_MSMPEG4V1, nullptr },

+    { &MEDIASUBTYPE_DIV1, AV_CODEC_ID_MSMPEG4V1, nullptr },

+    { &MEDIASUBTYPE_div1, AV_CODEC_ID_MSMPEG4V1, nullptr },

+    { &MEDIASUBTYPE_MP41, AV_CODEC_ID_MSMPEG4V1, nullptr },

+    { &MEDIASUBTYPE_mp41, AV_CODEC_ID_MSMPEG4V1, nullptr },

 

     // AMV Video

-    { &MEDIASUBTYPE_AMVV, AV_CODEC_ID_AMV, NULL },

+    { &MEDIASUBTYPE_AMVV, AV_CODEC_ID_AMV, nullptr },

 

     // MJPEG

-    { &MEDIASUBTYPE_MJPG,   AV_CODEC_ID_MJPEG,  NULL },

-    { &MEDIASUBTYPE_QTJpeg, AV_CODEC_ID_MJPEG,  NULL },

-    { &MEDIASUBTYPE_MJPA,   AV_CODEC_ID_MJPEG,  NULL },

-    { &MEDIASUBTYPE_MJPB,   AV_CODEC_ID_MJPEGB, NULL },

+    { &MEDIASUBTYPE_MJPG,   AV_CODEC_ID_MJPEG,  nullptr },

+    { &MEDIASUBTYPE_QTJpeg, AV_CODEC_ID_MJPEG,  nullptr },

+    { &MEDIASUBTYPE_MJPA,   AV_CODEC_ID_MJPEG,  nullptr },

+    { &MEDIASUBTYPE_MJPB,   AV_CODEC_ID_MJPEGB, nullptr },

 

     // TSCC

-    { &MEDIASUBTYPE_TSCC,   AV_CODEC_ID_TSCC, NULL },

+    { &MEDIASUBTYPE_TSCC,   AV_CODEC_ID_TSCC, nullptr },

 

     // Indeo 3/4/5

-    { &MEDIASUBTYPE_IV31,   AV_CODEC_ID_INDEO3, NULL },

-    { &MEDIASUBTYPE_IV32,   AV_CODEC_ID_INDEO3, NULL },

-    { &MEDIASUBTYPE_IV41,   AV_CODEC_ID_INDEO4, NULL },

-    { &MEDIASUBTYPE_IV50,   AV_CODEC_ID_INDEO5, NULL },

+    { &MEDIASUBTYPE_IV31,   AV_CODEC_ID_INDEO3, nullptr },

+    { &MEDIASUBTYPE_IV32,   AV_CODEC_ID_INDEO3, nullptr },

+    { &MEDIASUBTYPE_IV41,   AV_CODEC_ID_INDEO4, nullptr },

+    { &MEDIASUBTYPE_IV50,   AV_CODEC_ID_INDEO5, nullptr },

 #endif /* HAS_FFMPEG_VIDEO_DECODERS */

 

     // H264/AVC

@@ -232,27 +232,27 @@ FFMPEG_CODECS ffCodecs[] = {
 

 #if HAS_FFMPEG_VIDEO_DECODERS

     // SVQ3

-    { &MEDIASUBTYPE_SVQ3, AV_CODEC_ID_SVQ3, NULL },

+    { &MEDIASUBTYPE_SVQ3, AV_CODEC_ID_SVQ3, nullptr },

 

     // SVQ1

-    { &MEDIASUBTYPE_SVQ1, AV_CODEC_ID_SVQ1, NULL },

+    { &MEDIASUBTYPE_SVQ1, AV_CODEC_ID_SVQ1, nullptr },

 

     // H263

-    { &MEDIASUBTYPE_H263, AV_CODEC_ID_H263, NULL },

-    { &MEDIASUBTYPE_h263, AV_CODEC_ID_H263, NULL },

+    { &MEDIASUBTYPE_H263, AV_CODEC_ID_H263, nullptr },

+    { &MEDIASUBTYPE_h263, AV_CODEC_ID_H263, nullptr },

 

-    { &MEDIASUBTYPE_S263, AV_CODEC_ID_H263, NULL },

-    { &MEDIASUBTYPE_s263, AV_CODEC_ID_H263, NULL },

+    { &MEDIASUBTYPE_S263, AV_CODEC_ID_H263, nullptr },

+    { &MEDIASUBTYPE_s263, AV_CODEC_ID_H263, nullptr },

 

     // Real Video

-    { &MEDIASUBTYPE_RV10, AV_CODEC_ID_RV10, NULL },

-    { &MEDIASUBTYPE_RV20, AV_CODEC_ID_RV20, NULL },

-    { &MEDIASUBTYPE_RV30, AV_CODEC_ID_RV30, NULL },

-    { &MEDIASUBTYPE_RV40, AV_CODEC_ID_RV40, NULL },

+    { &MEDIASUBTYPE_RV10, AV_CODEC_ID_RV10, nullptr },

+    { &MEDIASUBTYPE_RV20, AV_CODEC_ID_RV20, nullptr },

+    { &MEDIASUBTYPE_RV30, AV_CODEC_ID_RV30, nullptr },

+    { &MEDIASUBTYPE_RV40, AV_CODEC_ID_RV40, nullptr },

 

     // Theora

-    { &MEDIASUBTYPE_THEORA, AV_CODEC_ID_THEORA, NULL },

-    { &MEDIASUBTYPE_theora, AV_CODEC_ID_THEORA, NULL },

+    { &MEDIASUBTYPE_THEORA, AV_CODEC_ID_THEORA, nullptr },

+    { &MEDIASUBTYPE_theora, AV_CODEC_ID_THEORA, nullptr },

 #endif /* HAS_FFMPEG_VIDEO_DECODERS */

 

     // WVC1

@@ -261,46 +261,46 @@ FFMPEG_CODECS ffCodecs[] = {
 

 #if HAS_FFMPEG_VIDEO_DECODERS

     // Other MPEG-4

-    { &MEDIASUBTYPE_MP4V, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_mp4v, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_M4S2, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_m4s2, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_MP4S, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_mp4s, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_3IV1, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_3iv1, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_3IV2, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_3iv2, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_3IVX, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_3ivx, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_BLZ0, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_blz0, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_DM4V, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_dm4v, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_FFDS, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_ffds, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_FVFW, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_fvfw, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_DXGM, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_dxgm, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_FMP4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_fmp4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_HDX4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_hdx4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_LMP4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_lmp4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_NDIG, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_ndig, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_RMP4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_rmp4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_SMP4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_smp4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_SEDG, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_sedg, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_UMP4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_ump4, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_WV1F, AV_CODEC_ID_MPEG4, NULL },

-    { &MEDIASUBTYPE_wv1f, AV_CODEC_ID_MPEG4, NULL }

+    { &MEDIASUBTYPE_MP4V, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_mp4v, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_M4S2, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_m4s2, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_MP4S, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_mp4s, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_3IV1, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_3iv1, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_3IV2, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_3iv2, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_3IVX, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_3ivx, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_BLZ0, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_blz0, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_DM4V, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_dm4v, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_FFDS, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_ffds, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_FVFW, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_fvfw, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_DXGM, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_dxgm, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_FMP4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_fmp4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_HDX4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_hdx4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_LMP4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_lmp4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_NDIG, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_ndig, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_RMP4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_rmp4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_SMP4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_smp4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_SEDG, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_sedg, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_UMP4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_ump4, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_WV1F, AV_CODEC_ID_MPEG4, nullptr },

+    { &MEDIASUBTYPE_wv1f, AV_CODEC_ID_MPEG4, nullptr }

 #endif /* HAS_FFMPEG_VIDEO_DECODERS */

 };

 

@@ -526,7 +526,7 @@ BOOL CALLBACK EnumFindProcessWnd(HWND hwnd, LPARAM lParam)
 CMPCVideoDecFilter::CMPCVideoDecFilter(LPUNKNOWN lpunk, HRESULT* phr)

     : CBaseVideoFilter(MPCVideoDecName, lpunk, phr, __uuidof(this))

 {

-    HWND hWnd = NULL;

+    HWND hWnd = nullptr;

 

     if (SysVersion::IsVistaOrLater()) {

         for (int i = 0; i < _countof(ffCodecs); i++) {

@@ -549,9 +549,9 @@ CMPCVideoDecFilter::CMPCVideoDecFilter(LPUNKNOWN lpunk, HRESULT* phr)
     }

 

     m_pCpuId = DEBUG_NEW CCpuId();

-    m_pAVCodec = NULL;

-    m_pAVCtx = NULL;

-    m_pFrame = NULL;

+    m_pAVCodec = nullptr;

+    m_pAVCtx = nullptr;

+    m_pFrame = nullptr;

     m_nCodecNb = -1;

     m_nCodecId = AV_CODEC_ID_NONE;

     m_bReorderBFrame = true;

@@ -573,22 +573,22 @@ CMPCVideoDecFilter::CMPCVideoDecFilter(LPUNKNOWN lpunk, HRESULT* phr)
     m_nThreadNumber = 0;

     m_nDiscardMode = AVDISCARD_DEFAULT;

     m_bDXVACompatible = true;

-    m_pFFBuffer = NULL;

+    m_pFFBuffer = nullptr;

     m_nFFBufferSize = 0;

-    m_pAlignedFFBuffer = NULL;

+    m_pAlignedFFBuffer = nullptr;

     m_nAlignedFFBufferSize = 0;

     ResetBuffer();

 

     m_nWidth = 0;

     m_nHeight = 0;

-    m_pSwsContext = NULL;

+    m_pSwsContext = nullptr;

 

     m_bUseDXVA = true;

     m_bUseFFmpeg = true;

 

     m_nDXVAMode = MODE_SOFTWARE;

-    m_pDXVADecoder = NULL;

-    m_pVideoOutputFormat = NULL;

+    m_pDXVADecoder = nullptr;

+    m_pVideoOutputFormat = nullptr;

     m_nVideoOutputCount = 0;

     m_hDevice = INVALID_HANDLE_VALUE;

 

@@ -950,14 +950,14 @@ void CMPCVideoDecFilter::Cleanup()
 #if HAS_FFMPEG_VIDEO_DECODERS

     if (m_pSwsContext) {

         sws_freeContext(m_pSwsContext);

-        m_pSwsContext = NULL;

+        m_pSwsContext = nullptr;

     }

 #endif /* HAS_FFMPEG_VIDEO_DECODERS */

 

-    m_pAVCodec      = NULL;

-    m_pAVCtx        = NULL;

-    m_pFrame        = NULL;

-    m_pFFBuffer     = NULL;

+    m_pAVCodec      = nullptr;

+    m_pAVCtx        = nullptr;

+    m_pFrame        = nullptr;

+    m_pFFBuffer     = nullptr;

     m_nFFBufferSize = 0;

     m_nFFBufferPos  = 0;

     m_nFFPicEnd     = INT_MIN;

@@ -971,9 +971,9 @@ void CMPCVideoDecFilter::Cleanup()
         m_hDevice = INVALID_HANDLE_VALUE;

     }

 

-    m_pDeviceManager        = NULL;

-    m_pDecoderService       = NULL;

-    m_pDecoderRenderTarget  = NULL;

+    m_pDeviceManager        = nullptr;

+    m_pDecoderService       = nullptr;

+    m_pDecoderRenderTarget  = nullptr;

 }

 

 void CMPCVideoDecFilter::CalcAvgTimePerFrame()

@@ -1059,7 +1059,7 @@ CString CMPCVideoDecFilter::GetFileExtension()
     BeginEnumFilters(m_pGraph, pEF, pBF) {

         CComQIPtr<IFileSourceFilter> pFSF = pBF;

         if (pFSF) {

-            LPOLESTR pFN = NULL;

+            LPOLESTR pFN = nullptr;

             AM_MEDIA_TYPE mt;

             if (SUCCEEDED(pFSF->GetCurFile(&pFN, &mt)) && pFN && *pFN) {

                 ext = CPath(CStringW(pFN)).GetExtension();

@@ -1141,7 +1141,7 @@ HRESULT CMPCVideoDecFilter::SetMediaType(PIN_DIRECTION direction, const CMediaTy
                 m_pAVCtx->codec_tag = mpg2v->hdr.bmiHeader.biCompression;

                 m_pAVCtx->bits_per_coded_sample = mpg2v->hdr.bmiHeader.biBitCount;

 

-                if (mpg2v->hdr.bmiHeader.biCompression == NULL) {

+                if (mpg2v->hdr.bmiHeader.biCompression == 0) {

                     m_pAVCtx->codec_tag = pmt->subtype.Data1;

                 } else if ((m_pAVCtx->codec_tag == MAKEFOURCC('a', 'v', 'c', '1')) || (m_pAVCtx->codec_tag == MAKEFOURCC('A', 'V', 'C', '1'))) {

                     m_pAVCtx->nal_length_size = mpg2v->dwFlags;

@@ -1184,7 +1184,7 @@ HRESULT CMPCVideoDecFilter::SetMediaType(PIN_DIRECTION direction, const CMediaTy
             ConnectTo(m_pAVCtx);

             CalcAvgTimePerFrame();

 

-            if (avcodec_open2(m_pAVCtx, m_pAVCodec, NULL) < 0) {

+            if (avcodec_open2(m_pAVCtx, m_pAVCodec, nullptr) < 0) {

                 return VFW_E_INVALIDMEDIATYPE;

             }

 

@@ -1234,7 +1234,7 @@ HRESULT CMPCVideoDecFilter::SetMediaType(PIN_DIRECTION direction, const CMediaTy
                 if ((nThreadNumber > 1) && IsMultiThreadSupported(m_nCodecId)) {

                     FFSetThreadNumber(m_pAVCtx, m_nCodecId, nThreadNumber);

                 }

-                if (avcodec_open2(m_pAVCtx, m_pAVCodec, NULL) < 0) {

+                if (avcodec_open2(m_pAVCtx, m_pAVCodec, nullptr) < 0) {

                     return VFW_E_INVALIDMEDIATYPE;

                 }

             }

@@ -1280,7 +1280,7 @@ bool CMPCVideoDecFilter::IsDXVASupported()
 {

     if (m_nCodecNb != -1) {

         // Does the codec suppport DXVA ?

-        if (ffCodecs[m_nCodecNb].DXVAModes != NULL) {

+        if (ffCodecs[m_nCodecNb].DXVAModes != nullptr) {

             // Enabled by user ?

             if (m_bUseDXVA) {

                 // is the file compatible ?

@@ -1349,9 +1349,9 @@ void CMPCVideoDecFilter::AllocExtradata(AVCodecContext* pAVCtx, const CMediaType
 {

     // code from LAV ...

     // Process Extradata

-    BYTE* extra = NULL;

+    BYTE* extra = nullptr;

     unsigned int extralen = 0;

-    getExtraData((const BYTE*)pmt->Format(), pmt->FormatType(), pmt->FormatLength(), NULL, &extralen);

+    getExtraData((const BYTE*)pmt->Format(), pmt->FormatType(), pmt->FormatLength(), nullptr, &extralen);

 

     BOOL bH264avc = FALSE;

     if (extralen > 0) {

@@ -1402,7 +1402,7 @@ void CMPCVideoDecFilter::AllocExtradata(AVCodecContext* pAVCtx, const CMediaType
         } else {

             // Just copy extradata for other formats

             extra = (uint8_t*)av_mallocz(extralen + FF_INPUT_BUFFER_PADDING_SIZE);

-            getExtraData((const BYTE*)pmt->Format(), pmt->FormatType(), pmt->FormatLength(), extra, NULL);

+            getExtraData((const BYTE*)pmt->Format(), pmt->FormatType(), pmt->FormatLength(), extra, nullptr);

         }

         // Hack to discard invalid MP4 metadata with AnnexB style video

         if (m_nCodecId == AV_CODEC_ID_H264 && !bH264avc && extra[0] == 1) {

@@ -1515,7 +1515,7 @@ HRESULT CMPCVideoDecFilter::EndOfStream()
 #if HAS_FFMPEG_VIDEO_DECODERS

     if (m_nDXVAMode == MODE_SOFTWARE) {

         REFERENCE_TIME rtStart = 0, rtStop = 0;

-        SoftwareDecode(NULL, NULL, 0, rtStart, rtStop);

+        SoftwareDecode(nullptr, nullptr, 0, rtStart, rtStop);

     } else

 #endif

         if (m_nDXVAMode == MODE_DXVA2) { // TODO - need to check DXVA1 on WinXP

@@ -1592,7 +1592,7 @@ unsigned __int64 CMPCVideoDecFilter::GetCspFromMediaType(GUID& subtype)
 

 void CMPCVideoDecFilter::InitSwscale()

 {

-    if (m_pSwsContext == NULL) {

+    if (m_pSwsContext == nullptr) {

         BITMAPINFOHEADER bihOut;

         ExtractBIH(&m_pOutput->CurrentMediaType(), &bihOut);

 

@@ -1606,7 +1606,7 @@ void CMPCVideoDecFilter::InitSwscale()
         }

 

         m_pSwsContext = sws_getCachedContext(

-                            NULL,

+                            nullptr,

                             m_pAVCtx->width,

                             m_pAVCtx->height,

                             pix_fmt,

@@ -1614,15 +1614,15 @@ void CMPCVideoDecFilter::InitSwscale()
                             m_pAVCtx->height,

                             csp_ffdshow2lavc(m_nOutCsp),

                             sws_Flags | SWS_PRINT_INFO,

-                            NULL,

-                            NULL,

-                            NULL);

+                            nullptr,

+                            nullptr,

+                            nullptr);

 

         m_nSwOutBpp = bihOut.biBitCount;

         m_pOutSize.cx = bihOut.biWidth;

         m_pOutSize.cy = abs(bihOut.biHeight);

 

-        int* inv_tbl = NULL, *tbl = NULL;

+        int* inv_tbl = nullptr, *tbl = nullptr;

         int srcRange, dstRange, brightness, contrast, saturation;

         int ret = sws_getColorspaceDetails(m_pSwsContext, &inv_tbl, &srcRange, &tbl, &dstRange, &brightness, &contrast, &saturation);

         if (ret >= 0) {

@@ -1709,7 +1709,7 @@ HRESULT CMPCVideoDecFilter::SoftwareDecode(IMediaSample* pIn, BYTE* pDataIn, int
     HRESULT hr = S_OK;

     int got_picture;

     int used_bytes;

-    BOOL bFlush = (pDataIn == NULL);

+    BOOL bFlush = (pDataIn == nullptr);

 

     AVPacket avpkt;

     av_init_packet(&avpkt);

@@ -1745,7 +1745,7 @@ HRESULT CMPCVideoDecFilter::SoftwareDecode(IMediaSample* pIn, BYTE* pDataIn, int
             avpkt.dts  = rtStop;

             avpkt.flags = AV_PKT_FLAG_KEY;

         } else {

-            avpkt.data = NULL;

+            avpkt.data = nullptr;

             avpkt.size = 0;

         }

         used_bytes = avcodec_decode_video2(m_pAVCtx, m_pFrame, &got_picture, &avpkt);

@@ -1791,7 +1791,7 @@ HRESULT CMPCVideoDecFilter::SoftwareDecode(IMediaSample* pIn, BYTE* pDataIn, int
         }

 

         CComPtr<IMediaSample> pOut;

-        BYTE* pDataOut = NULL;

+        BYTE* pDataOut = nullptr;

 

         UpdateAspectRatio();

         if (FAILED(hr = GetDeliveryBuffer(m_pAVCtx->width, m_pAVCtx->height, &pOut)) || FAILED(hr = pOut->GetPointer(&pDataOut))) {

@@ -1817,12 +1817,12 @@ HRESULT CMPCVideoDecFilter::SoftwareDecode(IMediaSample* pIn, BYTE* pDataIn, int
         ReorderBFrames(rtStart, rtStop);

 

         pOut->SetTime(&rtStart, &rtStop);

-        pOut->SetMediaTime(NULL, NULL);

+        pOut->SetMediaTime(nullptr, nullptr);

 

-        if (m_pSwsContext == NULL) {

+        if (m_pSwsContext == nullptr) {

             InitSwscale();

         }

-        if (m_pSwsContext != NULL) {

+        if (m_pSwsContext != nullptr) {

 

             int outStride = m_pOutSize.cx;

             BYTE* outData = pDataOut;

@@ -1840,7 +1840,7 @@ HRESULT CMPCVideoDecFilter::SoftwareDecode(IMediaSample* pIn, BYTE* pDataIn, int
                 outData = m_pAlignedFFBuffer;

             }

 

-            uint8_t* dst[4] = {NULL, NULL, NULL, NULL};

+            uint8_t* dst[4] = {nullptr, nullptr, nullptr, nullptr};

             stride_t dstStride[4] = {0, 0, 0, 0};

             const TcspInfo* outcspInfo = csp_getInfo(m_nOutCsp);

 

@@ -2142,8 +2142,8 @@ HRESULT CMPCVideoDecFilter::FindDXVA2DecoderConfiguration(IDirectXVideoDecoderSe
     UINT cConfigurations = 0;

     bool bIsPrefered = false;

 

-    D3DFORMAT* pFormats = NULL;                 // size = cFormats

-    DXVA2_ConfigPictureDecode* pConfig = NULL;  // size = cConfigurations

+    D3DFORMAT* pFormats = nullptr;                 // size = cFormats

+    DXVA2_ConfigPictureDecode* pConfig = nullptr;  // size = cConfigurations

 

     // Find the valid render target formats for this decoder GUID.

     hr = pDecoderService->GetDecoderRenderTargets(guidDecoder, &cFormats, &pFormats);

@@ -2159,7 +2159,7 @@ HRESULT CMPCVideoDecFilter::FindDXVA2DecoderConfiguration(IDirectXVideoDecoderSe
             m_VideoDesc.Format = pFormats[iFormat];

 

             // Get the available configurations.

-            hr = pDecoderService->GetDecoderConfigurations(guidDecoder, &m_VideoDesc, NULL, &cConfigurations, &pConfig);

+            hr = pDecoderService->GetDecoderConfigurations(guidDecoder, &m_VideoDesc, nullptr, &cConfigurations, &pConfig);

 

             if (FAILED(hr)) {

                 continue;

@@ -2204,7 +2204,7 @@ HRESULT CMPCVideoDecFilter::ConfigureDXVA2(IPin* pPin)
     CComPtr<IMFGetService> pGetService;

     CComPtr<IDirect3DDeviceManager9> pDeviceManager;

     CComPtr<IDirectXVideoDecoderService> pDecoderService;

-    GUID* pDecoderGuids = NULL;

+    GUID* pDecoderGuids = nullptr;

     HANDLE hDevice = INVALID_HANDLE_VALUE;

 

     // Query the pin for IMFGetService.

@@ -2353,10 +2353,10 @@ HRESULT CMPCVideoDecFilter::CreateDXVA2Decoder(UINT nNumRenderTargets, IDirect3D
     HRESULT hr;

     CComPtr<IDirectXVideoDecoder> pDirectXVideoDec;

 

-    m_pDecoderRenderTarget = NULL;

+    m_pDecoderRenderTarget = nullptr;

 

     if (m_pDXVADecoder) {

-        m_pDXVADecoder->SetDirectXVideoDec(NULL);

+        m_pDXVADecoder->SetDirectXVideoDec(nullptr);

     }

 

     hr = m_pDecoderService->CreateVideoDecoder(m_DXVADecoderGUID, &m_VideoDesc, &m_DXVA2Config,

@@ -2384,10 +2384,10 @@ HRESULT CMPCVideoDecFilter::FindDXVA1DecoderConfiguration(IAMVideoAccelerator* p
 {

     HRESULT hr = E_FAIL;

     DWORD dwFormats = 0;

-    DDPIXELFORMAT* pPixelFormats = NULL;

+    DDPIXELFORMAT* pPixelFormats = nullptr;

 

 

-    pAMVideoAccelerator->GetUncompFormatsSupported(guidDecoder, &dwFormats, NULL);

+    pAMVideoAccelerator->GetUncompFormatsSupported(guidDecoder, &dwFormats, nullptr);

     if (dwFormats > 0) {

         // Find the valid render target formats for this decoder GUID.

         pPixelFormats = DEBUG_NEW DDPIXELFORMAT[dwFormats];

@@ -2478,7 +2478,7 @@ STDMETHODIMP CMPCVideoDecFilter::GetPages(CAUUID* pPages)
 #endif

 

     pPages->pElems = (GUID*)CoTaskMemAlloc(sizeof(GUID) * pPages->cElems);

-    if (pPages->pElems != NULL) {

+    if (pPages->pElems != nullptr) {

         pPages->pElems[0] = __uuidof(CMPCVideoDecSettingsWnd);

         if (pPages->cElems > 1) {

             pPages->pElems[1] = __uuidof(CMPCVideoDecCodecWnd);

@@ -2494,16 +2494,16 @@ STDMETHODIMP CMPCVideoDecFilter::CreatePage(const GUID& guid, IPropertyPage** pp
 {

     CheckPointer(ppPage, E_POINTER);

 

-    if (*ppPage != NULL) {

+    if (*ppPage != nullptr) {

         return E_INVALIDARG;

     }

 

     HRESULT hr;

 

     if (guid == __uuidof(CMPCVideoDecSettingsWnd)) {

-        (*ppPage = DEBUG_NEW CInternalPropertyPageTempl<CMPCVideoDecSettingsWnd>(NULL, &hr))->AddRef();

+        (*ppPage = DEBUG_NEW CInternalPropertyPageTempl<CMPCVideoDecSettingsWnd>(nullptr, &hr))->AddRef();

     } else if (guid == __uuidof(CMPCVideoDecCodecWnd)) {

-        (*ppPage = DEBUG_NEW CInternalPropertyPageTempl<CMPCVideoDecCodecWnd>(NULL, &hr))->AddRef();

+        (*ppPage = DEBUG_NEW CInternalPropertyPageTempl<CMPCVideoDecCodecWnd>(nullptr, &hr))->AddRef();

     }

 

     return *ppPage ? S_OK : E_FAIL;

@@ -2570,8 +2570,8 @@ STDMETHODIMP_(int) CMPCVideoDecFilter::GetDiscardMode()
 

 STDMETHODIMP_(GUID*) CMPCVideoDecFilter::GetDXVADecoderGuid()

 {

-    if (m_pGraph == NULL) {

-        return NULL;

+    if (m_pGraph == nullptr) {

+        return nullptr;

     } else {

         return &m_DXVADecoderGUID;

     }

diff --git a/src/filters/transform/MPCVideoDec/MPCVideoDecSettingsWnd.cpp b/src/filters/transform/MPCVideoDec/MPCVideoDecSettingsWnd.cpp
index 71bbb0056..dfe2fb24b 100644
--- a/src/filters/transform/MPCVideoDec/MPCVideoDecSettingsWnd.cpp
+++ b/src/filters/transform/MPCVideoDec/MPCVideoDecSettingsWnd.cpp
@@ -101,7 +101,7 @@ bool CMPCVideoDecSettingsWnd::OnActivate()
     const int h25 = IPP_SCALE(25);

     DWORD dwStyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP;

     CPoint p(10, 10);

-    GUID* DxvaGui = NULL;

+    GUID* DxvaGui = nullptr;

 

 #if HAS_FFMPEG_VIDEO_DECODERS

     m_grpFFMpeg.Create(ResStr(IDS_VDF_FFSETTINGS), WS_VISIBLE | WS_CHILD | BS_GROUPBOX, CRect(p + CPoint(-5, 0), CSize(IPP_SCALE(350), h20 + h25 * 3 + h20)), this, (UINT)IDC_STATIC);

@@ -174,7 +174,7 @@ bool CMPCVideoDecSettingsWnd::OnActivate()
     m_edtVideoCardDescription.SetWindowText(m_pMDF->GetVideoCardDescription());

 

     DxvaGui = m_pMDF->GetDXVADecoderGuid();

-    if (DxvaGui != NULL) {

+    if (DxvaGui != nullptr) {

         CString DXVAMode = GetDXVAMode(DxvaGui);

         m_edtDXVAMode.SetWindowText(DXVAMode);

     } else {

diff --git a/src/filters/transform/MPCVideoDec/VideoDecDXVAAllocator.cpp b/src/filters/transform/MPCVideoDec/VideoDecDXVAAllocator.cpp
index 759380dc1..1d450ae1f 100644
--- a/src/filters/transform/MPCVideoDec/VideoDecDXVAAllocator.cpp
+++ b/src/filters/transform/MPCVideoDec/VideoDecDXVAAllocator.cpp
@@ -28,7 +28,7 @@
 

 

 CDXVA2Sample::CDXVA2Sample(CVideoDecDXVAAllocator* pAlloc, HRESULT* phr)

-    : CMediaSample(NAME("CDXVA2Sample"), (CBaseAllocator*)pAlloc, phr, NULL, 0)

+    : CMediaSample(NAME("CDXVA2Sample"), (CBaseAllocator*)pAlloc, phr, nullptr, 0)

     , m_dwSurfaceId(0)

 {

 }

@@ -68,7 +68,7 @@ STDMETHODIMP CDXVA2Sample::GetService(REFGUID guidService, REFIID riid, LPVOID*
 {

     if (guidService != MR_BUFFER_SERVICE) {

         return MF_E_UNSUPPORTED_SERVICE;

-    } else if (m_pSurface == NULL) {

+    } else if (m_pSurface == nullptr) {

         return E_NOINTERFACE;

     } else {

         return m_pSurface->QueryInterface(riid, ppv);

@@ -95,9 +95,9 @@ STDMETHODIMP_(int) CDXVA2Sample::GetDXSurfaceId()
 }

 

 CVideoDecDXVAAllocator::CVideoDecDXVAAllocator(CMPCVideoDecFilter* pVideoDecFilter,  HRESULT* phr)

-    : CBaseAllocator(NAME("CVideoDecDXVAAllocator"), NULL, phr)

+    : CBaseAllocator(NAME("CVideoDecDXVAAllocator"), nullptr, phr)

     , m_pVideoDecFilter(pVideoDecFilter)

-    , m_ppRTSurfaceArray(NULL)

+    , m_ppRTSurfaceArray(nullptr)

     , m_nSurfaceArrayCount(0)

 {

 }

@@ -127,7 +127,7 @@ HRESULT CVideoDecDXVAAllocator::Alloc()
 

         // Allocate a new array of pointers.

         m_ppRTSurfaceArray = DEBUG_NEW IDirect3DSurface9 * [m_lCount];

-        if (m_ppRTSurfaceArray == NULL) {

+        if (m_ppRTSurfaceArray == nullptr) {

             hr = E_OUTOFMEMORY;

         } else {

             ZeroMemory(m_ppRTSurfaceArray, sizeof(IDirect3DSurface9*) * m_lCount);

@@ -146,7 +146,7 @@ HRESULT CVideoDecDXVAAllocator::Alloc()
                  0,

                  DXVA2_VideoDecoderRenderTarget,

                  m_ppRTSurfaceArray,

-                 NULL

+                 nullptr

              );

     }

 

@@ -154,7 +154,7 @@ HRESULT CVideoDecDXVAAllocator::Alloc()
         // Important : create samples in reverse order !

         for (m_lAllocated = m_lCount - 1; m_lAllocated >= 0; m_lAllocated--) {

             CDXVA2Sample* pSample = DEBUG_NEW CDXVA2Sample(this, &hr);

-            if (pSample == NULL) {

+            if (pSample == nullptr) {

                 hr = E_OUTOFMEMORY;

                 break;

             }

@@ -182,7 +182,7 @@ HRESULT CVideoDecDXVAAllocator::Alloc()
 

 void CVideoDecDXVAAllocator::Free()

 {

-    CMediaSample* pSample = NULL;

+    CMediaSample* pSample = nullptr;

 

     m_pVideoDecFilter->FlushDXVADecoder();

     //  m_FreeSurface.RemoveAll();

@@ -195,13 +195,13 @@ void CVideoDecDXVAAllocator::Free()
 

     if (m_ppRTSurfaceArray) {

         for (UINT i = 0; i < m_nSurfaceArrayCount; i++) {

-            if (m_ppRTSurfaceArray[i] != NULL) {

+            if (m_ppRTSurfaceArray[i] != nullptr) {

                 m_ppRTSurfaceArray[i]->Release();

             }

         }

 

         delete [] m_ppRTSurfaceArray;

-        m_ppRTSurfaceArray = NULL;

+        m_ppRTSurfaceArray = nullptr;

     }

     m_lAllocated         = 0;

     m_nSurfaceArrayCount = 0;

diff --git a/src/filters/transform/MPCVideoDec/VideoDecOutputPin.cpp b/src/filters/transform/MPCVideoDec/VideoDecOutputPin.cpp
index 2032731c3..9f38a7852 100644
--- a/src/filters/transform/MPCVideoDec/VideoDecOutputPin.cpp
+++ b/src/filters/transform/MPCVideoDec/VideoDecOutputPin.cpp
@@ -1,5 +1,5 @@
 /*

- * (C) 2007-2012 see Authors.txt

+ * (C) 2007-2013 see Authors.txt

  *

  * This file is part of MPC-HC.

  *

@@ -28,7 +28,7 @@ CVideoDecOutputPin::CVideoDecOutputPin(TCHAR* pObjectName, CBaseVideoFilter* pFi
     : CBaseVideoOutputPin(pObjectName, pFilter, phr, pName)

 {

     m_pVideoDecFilter = static_cast<CMPCVideoDecFilter*>(pFilter);

-    m_pDXVA2Allocator = NULL;

+    m_pDXVA2Allocator = nullptr;

     m_dwDXVA1SurfaceCount = 0;

     m_GuidDecoderDXVA1 = GUID_NULL;

     memset(&m_ddUncompPixelFormat, 0, sizeof(m_ddUncompPixelFormat));

@@ -115,7 +115,7 @@ STDMETHODIMP CVideoDecOutputPin::GetCreateVideoAcceleratorData(const GUID* pGuid
                 m_pVideoDecFilter->SetDXVA1Params(&m_GuidDecoderDXVA1, &m_ddUncompPixelFormat);

 

                 pConnectMode = (DXVA_ConnectMode*)CoTaskMemAlloc(sizeof(DXVA_ConnectMode));

-                if (pConnectMode != NULL) {

+                if (pConnectMode != nullptr) {

                     pConnectMode->guidMode = m_GuidDecoderDXVA1;

                     pConnectMode->wRestrictedMode = m_pVideoDecFilter->GetDXVA1RestrictedMode();

                     *pdwSizeMiscData = sizeof(DXVA_ConnectMode);