- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
- 09
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
// TODO: use Virtual memory instead of heap!
#ifndef __CHUNK_H__
#define __CHUNK_H__
#include <windows.h>
#include "../JuceLibraryCode/JuceHeader.h"
class Chunk {
public:
enum CHUNK_DIRECTION {CHUNK_UNKNOWN = 0, CHUNK_IN, CHUNK_OUT};
Chunk (DWORD ChunkSize, WORD id, CHUNK_DIRECTION chunkDirection);
~Chunk ();
// override
virtual void eventChunkIsEmpty () {
Logger::outputDebugString(T("empty"));
}
virtual void eventChunkIsFull () {
Logger::outputDebugString(T("full"));
}
virtual void eventChunkOverrun () {
Logger::outputDebugString(T("overrun"));
}
DWORD getData (WORD *data, DWORD size) {
if (data == 0) return 0;
if (cs.tryEnter ()) { // if it's true, we locked.. (TODO: check, i'm not sure about that)
if (((size + nReadCounter) > nWriteCounter) || size == 0) { cs.exit(); return 0; }
memcpy (data, pBuffer + nReadCounter, size*sizeof(WORD));
nReadCounter += size;
if (nReadCounter == nWriteCounter) { eventChunkIsEmpty() ; nWriteCounter = 0; nReadCounter = 0; }
cs.exit ();
return size;
}
return 0;
}
DWORD putData (WORD *data, DWORD size) {
if (data == 0) return 0;
if (cs.tryEnter ()) { // if it's true, we locked.. (TODO: check, i'm not sure about that)
if ((size + nWriteCounter) > nSize) { eventChunkOverrun(); cs.exit (); return 0; }
memcpy (pBuffer + nWriteCounter, data, size*sizeof(WORD));
nWriteCounter += size;
if (nWriteCounter == nSize ) eventChunkIsFull();
cs.exit ();
return size;
}
return 0;
}
inline DWORD getSize () {
return nSize;
}
// TODO: add check for nWriteCounter?
inline bool setSize (DWORD ChunkSize) {
if (bExchangeIsActive) return false;
nSize = ChunkSize;
// TODO: add result check.
pBuffer = (WORD*) realloc ((void*)pBuffer, ChunkSize*sizeof(WORD));
if (pBuffer) return true;
return false;
}
inline DWORD getReadCounter () { return nReadCounter; }
inline DWORD getWriteCounter () { return nWriteCounter; }
juce_UseDebuggingNewOperator
protected:
bool bExchangeIsActive;
CHUNK_DIRECTION cdDirection;
DWORD nSize;
DWORD nWriteCounter;
DWORD nReadCounter;
WORD nChunkId;
WORD *pBuffer;
CriticalSection cs;
};
#endif
// EOF
#include "Chunk.h"
Chunk::Chunk (DWORD ChunkSize, WORD id, CHUNK_DIRECTION chunkDirection) {
bExchangeIsActive = false;
cdDirection = chunkDirection;
nSize = ChunkSize;
nWriteCounter = 0;
nReadCounter = 0;
nChunkId = id;
pBuffer = (WORD*) malloc (ChunkSize*sizeof(WORD));
zeromem (pBuffer, ChunkSize*sizeof(WORD));
}
Chunk::~Chunk () {
if (pBuffer) free (pBuffer);
}
// EOF
Посвящается всем изобретателям велосипедов и просто неудачникам.. :(
Follow us!