bool LumiaEffect::ProcessSample(_In_ const ComPtr<IMFSample>& inputSample, _In_ const ComPtr<IMFSample>& outputSample)
{
    // Get the input/output buffers
    ComPtr<IMFMediaBuffer> outputBuffer;
    ComPtr<IMFMediaBuffer> inputBuffer;
    CHK(inputSample->GetBufferByIndex(0, &inputBuffer));
    CHK(outputSample->GetBufferByIndex(0, &outputBuffer));

    // Copy sample time, duration, attributes
    long long time = 0;
    long long duration = 0;
    (void)inputSample->GetSampleTime(&time);
    (void)inputSample->GetSampleDuration(&duration);
    CHK(outputSample->SetSampleTime(time));
    CHK(outputSample->SetSampleDuration(duration));
    CHK(inputSample->CopyAllItems(outputSample.Get()));

    // Set output buffer length (work around SinkWriter bug)
    unsigned long length = 0;
    CHK(outputBuffer->GetMaxLength(&length));
    CHK(outputBuffer->SetCurrentLength(length));

	unsigned long cbInputData = 0;
	unsigned long cbOutputData = 0;
	byte* pInputData;
	byte* pOutputData;

	CHK(inputBuffer->Lock(&pInputData, NULL, &cbInputData));
	CHK(outputBuffer->Lock(&pOutputData, NULL, &cbOutputData));

	for (unsigned int y = 0; y < 480; y++)
	{
		for (unsigned int x = 0; x < (480 * 4); x += 4)
		{
			int pos = y * (480 * 4) + (x);
			int posInput = y * (640 * 4) + (x);

			int alpha = (*(m_pWatermark + pos + 3));
			if (alpha == 255)
			{
				//(*(pOutputData + cbOutputData - pos)) = (*(m_pWatermark + pos));
				//(*(pOutputData + cbOutputData - pos + 1)) = (*(m_pWatermark + pos + 1));
				//(*(pOutputData + cbOutputData - pos + 2)) = (*(m_pWatermark + pos + 2));
				//(*(pOutputData + cbOutputData - pos + 3)) = 255;

				pOutputData[pos] = m_pWatermark[pos];
				pOutputData[pos + 1] = m_pWatermark[pos + 1];
				pOutputData[pos + 2] = m_pWatermark[pos + 2];
				pOutputData[pos + 3] = 255;
			}
			else if (alpha == 0)
			{
				//(*(pOutputData + cbOutputData - pos)) = (*(pInputData + posInput));
				//(*(pOutputData + cbOutputData - pos + 1)) = (*(pInputData + posInput + 1));
				//(*(pOutputData + cbOutputData - pos + 2)) = (*(pInputData + posInput + 2));
				//(*(pOutputData + cbOutputData - pos + 3)) = (*(pInputData + posInput + 3));

				pOutputData[pos] = pInputData[posInput];
				pOutputData[pos + 1] = pInputData[posInput + 1];
				pOutputData[pos + 2] = pInputData[posInput + 2];
				pOutputData[pos + 3] = 255;
			}
		}
	}

	//unsigned long x = 0;

	//while (x < cbInputData)
	//{
	//	(*(pOutputData + x++)) = 0;
	//	(*(pOutputData + x++)) = 0;
	//	(*(pOutputData + x++)) = 255;
	//	(*(pOutputData + x++)) = 255;

	//	//Trace("B: %i", (*(pInputData + x++)));
	//	//Trace("\tG: %i", (*(pInputData + x++)));
	//	//Trace("\tR: %i", (*(pInputData + x++)));
	//	//Trace("\tA: %i\n", (*(pInputData + x++)));
	//}

	//for (unsigned int k = 0; k < 480; k++)
	//{
	//	for (unsigned int i = 0; i < (480 * 4); i += 4)
	//	{
	//		int posI = (k + 80) * (480 * 4) + (i);
	//		int posO = k * (480 * 4) + (i);
	//		(*(pOutputData + posO)) = (*(pInputData + posI));
	//		(*(pOutputData + posO + 1)) = (*(pInputData + posI + 1));
	//		(*(pOutputData + posO + 2)) = (*(pInputData + posI + 2));
	//		(*(pOutputData + posO + 3)) = (*(pInputData + posI + 3));
	//	}
	//}
	//CopyMemory(pInputData, pOutputData, cbInputData);

	//for (unsigned long x = 0; x < cbInputData; x += 4)
	//{
	//	if ((*(m_pWatermark + x + 3)) == 255)
	//	{
	//		(*(pOutputData + x)) = (*(m_pWatermark + x));
	//		(*(pOutputData + x + 1)) = (*(m_pWatermark + x + 1));
	//		(*(pOutputData + x + 2)) = (*(m_pWatermark + x + 2));
	//		(*(pOutputData + x + 3)) = (*(m_pWatermark + x + 3));
	//	}
	//}

	return true;

    // Create input/output IBuffer wrappers
    //ComPtr<WinRTBufferOnMF2DBuffer> outputWinRTBuffer;
    //ComPtr<WinRTBufferOnMF2DBuffer> inputWinRTBuffer;
    //CHK(MakeAndInitialize<WinRTBufferOnMF2DBuffer>(&outputWinRTBuffer, outputBuffer, MF2DBuffer_LockFlags_Write, _inputDefaultStride));
    //CHK(MakeAndInitialize<WinRTBufferOnMF2DBuffer>(&inputWinRTBuffer, inputBuffer, MF2DBuffer_LockFlags_Read, _inputDefaultStride));

    //// Create input/output bitmap wrappers
    //Size outputSize = { (float)_outputWidth, (float)_outputHeight };
    //Size inputSize = { (float)_inputWidth, (float)_inputHeight };
    //auto outputBitmap = ref new Bitmap(outputSize, ColorMode::Bgra8888, outputWinRTBuffer->GetStride(), outputWinRTBuffer->GetIBuffer());
    //auto inputBitmap = ref new Bitmap(inputSize, ColorMode::Bgra8888, inputWinRTBuffer->GetStride(), inputWinRTBuffer->GetIBuffer());

    //if (_bitmapEffect != nullptr)
    //{
    //    _bitmapEffect->Process(inputBitmap, outputBitmap, TimeSpan{ time });
    //}
    //else
    //{
    //    if (_animatedFilters != nullptr)
    //    {
    //        _animatedFilters->UpdateTime(TimeSpan{ time });
    //    }

    //    // Process the bitmap
    //    FilterEffect^ effect = ref new FilterEffect();
    //    effect->Filters = _filters != nullptr ? _filters : _animatedFilters->Filters;
    //    effect->Source = ref new BitmapImageSource(inputBitmap);
    //    auto renderer = ref new BitmapRenderer(effect, outputBitmap);
    //    create_task(renderer->RenderAsync()).get(); // Blocks for the duration of processing (must be called in MTA)
    //}

    //// Force MF buffer unlocking (race-condition refcount leak in effects? xVP cannot always lock the buffer afterward)
    //outputWinRTBuffer->Close();
    //inputWinRTBuffer->Close();

    //return true; // Always produces data
}