//

//  TPCircularBuffer.c

//  Circular/Ring buffer implementation

//

//  https://github.com/michaeltyson/TPCircularBuffer

//

//  Created by Michael Tyson on 10/12/2011.

//

//  Copyright (C) 2012-2013 A Tasty Pixel

//

//  This software is provided 'as-is', without any express or implied

//  warranty.  In no event will the authors be held liable for any damages

//  arising from the use of this software.

//

//  Permission is granted to anyone to use this software for any purpose,

//  including commercial applications, and to alter it and redistribute it

//  freely, subject to the following restrictions:

//

//  1. The origin of this software must not be misrepresented; you must not

//     claim that you wrote the original software. If you use this software

//     in a product, an acknowledgment in the product documentation would be

//     appreciated but is not required.

//

//  2. Altered source versions must be plainly marked as such, and must not be

//     misrepresented as being the original software.

//

//  3. This notice may not be removed or altered from any source distribution.

//

#include <winpr/wlog.h>

#include "TPCircularBuffer.h"

#include "rdpsnd_main.h"

#include <mach/mach.h>

#include <stdio.h>

#define reportResult(result, operation) (_reportResult((result), (operation), __FILE__, __LINE__))

static inline bool _reportResult(kern_return_t result, const char* operation, const char* file,

                                 int line)

{

	if (result != ERR_SUCCESS)

	{

		WLog_DBG(TAG, "%s:%d: %s: %s\n", file, line, operation, mach_error_string(result));

		return false;

	}

	return true;

}

bool TPCircularBufferInit(TPCircularBuffer* buffer, int length)

{

	// Keep trying until we get our buffer, needed to handle race conditions

	int retries = 3;

	while (true)

	{

		buffer->length = round_page(length); // We need whole page sizes

		// Temporarily allocate twice the length, so we have the contiguous address space to

		// support a second instance of the buffer directly after

		vm_address_t bufferAddress;

		kern_return_t result = vm_allocate(mach_task_self(), &bufferAddress, buffer->length * 2,

		                                   VM_FLAGS_ANYWHERE); // allocate anywhere it'll fit

		if (result != ERR_SUCCESS)

		{

			if (retries-- == 0)

			{

				reportResult(result, "Buffer allocation");

				return false;

			}

			// Try again if we fail

			continue;

		}

		// Now replace the second half of the allocation with a virtual copy of the first half.

		// Deallocate the second half...

		result = vm_deallocate(mach_task_self(), bufferAddress + buffer->length, buffer->length);

		if (result != ERR_SUCCESS)

		{

			if (retries-- == 0)

			{

				reportResult(result, "Buffer deallocation");

				return false;

			}

			// If this fails somehow, deallocate the whole region and try again

			vm_deallocate(mach_task_self(), bufferAddress, buffer->length);

			continue;

		}

		// Re-map the buffer to the address space immediately after the buffer

		vm_address_t virtualAddress = bufferAddress + buffer->length;

		vm_prot_t cur_prot, max_prot;

		result = vm_remap(mach_task_self(),

		                  &virtualAddress,  // mirror target

		                  buffer->length,   // size of mirror

		                  0,                // auto alignment

		                  0,                // force remapping to virtualAddress

		                  mach_task_self(), // same task

		                  bufferAddress,    // mirror source

		                  0,                // MAP READ-WRITE, NOT COPY

		                  &cur_prot,        // unused protection struct

		                  &max_prot,        // unused protection struct

		                  VM_INHERIT_DEFAULT);

		if (result != ERR_SUCCESS)

		{

			if (retries-- == 0)

			{

				reportResult(result, "Remap buffer memory");

				return false;

			}

			// If this remap failed, we hit a race condition, so deallocate and try again

			vm_deallocate(mach_task_self(), bufferAddress, buffer->length);

			continue;

		}

		if (virtualAddress != bufferAddress + buffer->length)

		{

			// If the memory is not contiguous, clean up both allocated buffers and try again

			if (retries-- == 0)

			{

				WLog_DBG(TAG, "Couldn't map buffer memory to end of buffer");

				return false;

			}

			vm_deallocate(mach_task_self(), virtualAddress, buffer->length);

			vm_deallocate(mach_task_self(), bufferAddress, buffer->length);

			continue;

		}

		buffer->buffer = (void*)bufferAddress;

		buffer->fillCount = 0;

		buffer->head = buffer->tail = 0;

		return true;

	}

	return false;

}

void TPCircularBufferCleanup(TPCircularBuffer* buffer)

{

	vm_deallocate(mach_task_self(), (vm_address_t)buffer->buffer, buffer->length * 2);

	memset(buffer, 0, sizeof(TPCircularBuffer));

}

void TPCircularBufferClear(TPCircularBuffer* buffer)

{

	int32_t fillCount;

	if (TPCircularBufferTail(buffer, &fillCount))

	{

		TPCircularBufferConsume(buffer, fillCount);

	}

}