void AppMain::OnUpdate()

in Tools/StreamerVLC/AppMain.cpp [66:198]
99 lines of code
9 McCabe index (conditional complexity)

    void AppMain::OnUpdate(
        _In_ Windows::Graphics::Holographic::HolographicFrame^ holographicFrame,
        _In_ const Graphics::StepTimer& stepTimer)
    {
        dbg::TimerGuard timerGuard(
            L"AppMain::OnUpdate",
            30.0 /* minimum_time_elapsed_in_milliseconds */);

		HoloLensForCV::SensorType renderSensorType = HoloLensForCV::SensorType::VisibleLightLeftFront;

        //
        // Update scene objects.
        //
        // Put time-based updates here. By default this code will run once per frame,
        // but if you change the StepTimer to use a fixed time step this code will
        // run as many times as needed to get to the current step.
        //
        _slateRenderer->Update(
            stepTimer);

        if (!_holoLensMediaFrameSourceGroupStarted)
        {
            return;
        }

        HoloLensForCV::SensorFrame^ latestCameraPreviewFrame;
        Windows::Graphics::Imaging::BitmapPixelFormat cameraPreviewExpectedBitmapPixelFormat;
        DXGI_FORMAT cameraPreviewTextureFormat;
        int32_t cameraPreviewPixelStride;

		{
			latestCameraPreviewFrame =
				_holoLensMediaFrameSourceGroup->GetLatestSensorFrame(
					renderSensorType);

			if ((HoloLensForCV::SensorType::ShortThrowToFDepth == renderSensorType) ||
				(HoloLensForCV::SensorType::ShortThrowToFReflectivity == renderSensorType) ||
				(HoloLensForCV::SensorType::LongThrowToFDepth == renderSensorType) ||
				(HoloLensForCV::SensorType::LongThrowToFReflectivity == renderSensorType))
			{
				cameraPreviewExpectedBitmapPixelFormat =
					Windows::Graphics::Imaging::BitmapPixelFormat::Gray8;

				cameraPreviewTextureFormat =
					DXGI_FORMAT_R8_UNORM;

				cameraPreviewPixelStride =
					1;
			}
			else
			{
				cameraPreviewExpectedBitmapPixelFormat =
					Windows::Graphics::Imaging::BitmapPixelFormat::Bgra8;

				cameraPreviewTextureFormat =
					DXGI_FORMAT_B8G8R8A8_UNORM;

				cameraPreviewPixelStride =
					4;
			}
		}

        if (nullptr == latestCameraPreviewFrame)
        {
            return;
        }

        if (_cameraPreviewTimestamp.UniversalTime == latestCameraPreviewFrame->Timestamp.UniversalTime)
        {
            return;
        }

        _cameraPreviewTimestamp = latestCameraPreviewFrame->Timestamp;

        if (nullptr == _cameraPreviewTexture)
        {
#if 0
            dbg::trace(
                L"latestCameraPreviewFrame->SoftwareBitmap->PixelWidth=0x%08x, latestCameraPreviewFrame->SoftwareBitmap->PixelHeight=0x%08x",
                latestCameraPreviewFrame->SoftwareBitmap->PixelWidth, latestCameraPreviewFrame->SoftwareBitmap->PixelHeight);
#endif

            _cameraPreviewTexture =
                std::make_shared<Rendering::Texture2D>(
                    _deviceResources,
                    latestCameraPreviewFrame->SoftwareBitmap->PixelWidth,
                    latestCameraPreviewFrame->SoftwareBitmap->PixelHeight,
                    cameraPreviewTextureFormat);
        }

        {
            void* mappedTexture =
                _cameraPreviewTexture->MapCPUTexture<void>(
                    D3D11_MAP_WRITE /* mapType */);

            Windows::Graphics::Imaging::SoftwareBitmap^ bitmap =
                latestCameraPreviewFrame->SoftwareBitmap;

#if 0
            dbg::trace(
                L"cameraPreviewExpectedBitmapPixelFormat=0x%08x, bitmap->BitmapPixelFormat=0x%08x",
                cameraPreviewExpectedBitmapPixelFormat, bitmap->BitmapPixelFormat);
#endif

            REQUIRES(cameraPreviewExpectedBitmapPixelFormat == bitmap->BitmapPixelFormat);

            Windows::Graphics::Imaging::BitmapBuffer^ bitmapBuffer =
                bitmap->LockBuffer(
                    Windows::Graphics::Imaging::BitmapBufferAccessMode::Read);

            uint32_t pixelBufferDataLength = 0;

            uint8_t* pixelBufferData =
                Io::GetTypedPointerToMemoryBuffer<uint8_t>(
                    bitmapBuffer->CreateReference(),
                    pixelBufferDataLength);

            const int32_t bytesToCopy =
                _cameraPreviewTexture->GetWidth() * _cameraPreviewTexture->GetHeight() * cameraPreviewPixelStride;

            ASSERT(static_cast<uint32_t>(bytesToCopy) == pixelBufferDataLength);

            ASSERT(0 == memcpy_s(
                mappedTexture,
                bytesToCopy,
                pixelBufferData,
                pixelBufferDataLength));

            _cameraPreviewTexture->UnmapCPUTexture();
        }

        _cameraPreviewTexture->CopyCPU2GPU();
    }