static void *
testalloc(void)
{
void *v, *nv;
size_t size1, size2, align;
/* doesn't give an even bucket distribution, but ... */
size1 = random() % ((TEST_MAXALLOC-TEST_MINALLOC)+1) + TEST_MINALLOC;
align = random() % ((TEST_MAXALIGN-TEST_MINALIGN)+1) + TEST_MINALIGN;
v = bmk_memalloc(size1, 1<<align);
if (!v)
return NULL;
ASSERT(((uintptr_t)v & (align-1)) == 0);
memset(v, UNMAGIC, size1);
size2 = random() % ((TEST_MAXALLOC-TEST_MINALLOC)+1) + TEST_MINALLOC;
nv = memrealloc(v, size2);
if (nv) {
memset(nv, UNMAGIC2, size2);
return nv;
}
return size2 ? v : NULL;
}
void add_string(char ***opt, unsigned int *num, char const * option)
{
char ** temp;
unsigned int number = *num;
temp = memrealloc(*opt, (++number) * sizeof(char *));
*opt = temp;
temp[number-1] = copy_string_no_trailing_spaces(option);
*num = number;
}
/*
* funkcia ma dva parametre: aktualny znak a
* ukazatel na pocet nacitanych znakov.
* Funkcia realokuje pamat pre atribut tokenu a rozsiri ho
* o preve nacitany znak.
*/
static void expand_token(int c, int *i){
if((*i) > 0){
if((token.attribute = (char *) memrealloc(token.attribute, (*i) + 2))){
token.attribute[(*i) + 1] = '\0';
token.attribute[(*i)] = c;
(*i)++;
} else{
//memfree(token.attribute);
scaner_error = INTERN_ERR;
}
} else{
token.attribute[(*i) + 1] = '\0';
token.attribute[(*i)] = c;
(*i)++;
}
}
static TrieNode*
trienode_set_next(TrieNode* node, const TRIE_LETTER_TYPE letter, TrieNode* child) {
ASSERT(node);
ASSERT(child);
ASSERT(trienode_get_next(node, letter) == NULL);
const int n = node->n;
TrieNode** next = (TrieNode**)memrealloc(node->next, (n + 1) * sizeof(TrieNode*));
if (next) {
node->next = next;
node->next[n] = child;
node->n += 1;
return child;
}
else
return NULL;
}
/**********************************************************************
* array_push
*
* Add a new element onto the top of the array. If there is not room
* more room is made by "realloc"ing the array. This means that the
* new array location may change. All previous references to its old
* location may no longer be valid.
**********************************************************************/
ARRAY array_push(ARRAY array, void *value) {
if (array_count (array) == array_limit (array)) {
array = (ARRAY) memrealloc (array, (array_limit (array) * 2 - 2) *
sizeof (char *) +
sizeof (struct array_record),
(array_limit (array) -
2) * sizeof (char *) +
sizeof (struct array_record));
if (!array) {
cprintf ("error: Out of memory in array_push\n");
exit (1); //?err_exit ();
}
array_limit (array) *= 2;
}
array_count (array)++;
array_top (array) = value;
return (array);
}
Error MemoryPoolDynamicStatic::realloc(ID p_id, size_t p_amount) {
_THREAD_SAFE_METHOD_
Chunk *c = get_chunk(p_id);
ERR_FAIL_COND_V(!c, ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(c->lock > 0, ERR_LOCKED);
void *new_mem = memrealloc(c->mem, p_amount);
ERR_FAIL_COND_V(!new_mem, ERR_OUT_OF_MEMORY);
total_usage -= c->size;
c->mem = new_mem;
c->size = p_amount;
total_usage += c->size;
if (total_usage > max_usage)
max_usage = total_usage;
return OK;
}
void VideoStreamPlaybackWebm::update(float p_delta) {
if ((!playing || paused) || !video)
return;
time += p_delta;
if (time < video_pos) {
return;
}
bool audio_buffer_full = false;
if (samples_offset > -1) {
//Mix remaining samples
const int to_read = num_decoded_samples - samples_offset;
const int mixed = mix_callback(mix_udata, pcm + samples_offset * webm->getChannels(), to_read);
if (mixed != to_read) {
samples_offset += mixed;
audio_buffer_full = true;
} else {
samples_offset = -1;
}
}
const bool hasAudio = (audio && mix_callback);
while ((hasAudio && !audio_buffer_full && !has_enough_video_frames()) ||
(!hasAudio && video_frames_pos == 0)) {
if (hasAudio && !audio_buffer_full && audio_frame->isValid() &&
audio->getPCMF(*audio_frame, pcm, num_decoded_samples) && num_decoded_samples > 0) {
const int mixed = mix_callback(mix_udata, pcm, num_decoded_samples);
if (mixed != num_decoded_samples) {
samples_offset = mixed;
audio_buffer_full = true;
}
}
WebMFrame *video_frame;
if (video_frames_pos >= video_frames_capacity) {
WebMFrame **video_frames_new = (WebMFrame **)memrealloc(video_frames, ++video_frames_capacity * sizeof(void *));
ERR_FAIL_COND(!video_frames_new); //Out of memory
(video_frames = video_frames_new)[video_frames_capacity - 1] = memnew(WebMFrame);
}
video_frame = video_frames[video_frames_pos];
if (!webm->readFrame(video_frame, audio_frame)) //This will invalidate frames
break; //Can't demux, EOS?
if (video_frame->isValid())
++video_frames_pos;
};
bool video_frame_done = false;
while (video_frames_pos > 0 && !video_frame_done) {
WebMFrame *video_frame = video_frames[0];
// It seems VPXDecoder::decode has to be executed even though we might skip this frame
if (video->decode(*video_frame)) {
VPXDecoder::IMAGE_ERROR err;
VPXDecoder::Image image;
if (should_process(*video_frame)) {
if ((err = video->getImage(image)) != VPXDecoder::NO_FRAME) {
if (err == VPXDecoder::NO_ERROR && image.w == webm->getWidth() && image.h == webm->getHeight()) {
PoolVector<uint8_t>::Write w = frame_data.write();
bool converted = false;
if (image.chromaShiftW == 1 && image.chromaShiftH == 1) {
yuv420_2_rgb8888(w.ptr(), image.planes[0], image.planes[2], image.planes[1], image.w, image.h, image.linesize[0], image.linesize[1], image.w << 2, 0);
// libyuv::I420ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
converted = true;
} else if (image.chromaShiftW == 1 && image.chromaShiftH == 0) {
yuv422_2_rgb8888(w.ptr(), image.planes[0], image.planes[2], image.planes[1], image.w, image.h, image.linesize[0], image.linesize[1], image.w << 2, 0);
// libyuv::I422ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
converted = true;
} else if (image.chromaShiftW == 0 && image.chromaShiftH == 0) {
yuv444_2_rgb8888(w.ptr(), image.planes[0], image.planes[2], image.planes[1], image.w, image.h, image.linesize[0], image.linesize[1], image.w << 2, 0);
// libyuv::I444ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
converted = true;
} else if (image.chromaShiftW == 2 && image.chromaShiftH == 0) {
// libyuv::I411ToARGB(image.planes[0], image.linesize[0], image.planes[2], image.linesize[2], image.planes[1], image.linesize[1], w.ptr(), image.w << 2, image.w, image.h);
// converted = true;
}
if (converted) {
Ref<Image> img = memnew(Image(image.w, image.h, 0, Image::FORMAT_RGBA8, frame_data));
texture->set_data(img); //Zero copy send to visual server
video_frame_done = true;
}
}
}
}
}
video_pos = video_frame->time;
memmove(video_frames, video_frames + 1, (--video_frames_pos) * sizeof(void *));
video_frames[video_frames_pos] = video_frame;
}
if (video_frames_pos == 0 && webm->isEOS())
stop();
}
void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) {
// X11 functions don't know what const is
XKeyEvent *xkeyevent = p_event;
// This code was pretty difficult to write.
// The docs stink and every toolkit seems to
// do it in a different way.
/* Phase 1, obtain a proper keysym */
// This was also very difficult to figure out.
// You'd expect you could just use Keysym provided by
// XKeycodeToKeysym to obtain internationalized
// input.. WRONG!!
// you must use XLookupString (???) which not only wastes
// cycles generating an unnecesary string, but also
// still works in half the cases. (won't handle deadkeys)
// For more complex input methods (deadkeys and more advanced)
// you have to use XmbLookupString (??).
// So.. then you have to chosse which of both results
// you want to keep.
// This is a real bizarreness and cpu waster.
KeySym keysym_keycode=0; // keysym used to find a keycode
KeySym keysym_unicode=0; // keysym used to find unicode
int nbytes=0; // bytes the string takes
// XLookupString returns keysyms usable as nice scancodes/
char str[256+1];
nbytes=XLookupString(xkeyevent, str, 256, &keysym_keycode, NULL);
// Meanwhile, XLookupString returns keysyms useful for unicode.
if (!xmbstring) {
// keep a temporary buffer for the string
xmbstring=(char*)memalloc(sizeof(char)*8);
xmblen=8;
}
if (xkeyevent->type == KeyPress && xic) {
Status status;
do {
int mnbytes = XmbLookupString (xic, xkeyevent, xmbstring, xmblen - 1, &keysym_unicode, &status);
xmbstring[mnbytes] = '\0';
if (status == XBufferOverflow) {
xmblen = mnbytes + 1;
xmbstring = (char*)memrealloc (xmbstring, xmblen);
}
} while (status == XBufferOverflow);
}
/* Phase 2, obtain a pigui keycode from the keysym */
// KeyMappingX11 just translated the X11 keysym to a PIGUI
// keysym, so it works in all platforms the same.
unsigned int keycode = KeyMappingX11::get_keycode(keysym_keycode);
/* Phase 3, obtain an unicode character from the keysym */
// KeyMappingX11 also translates keysym to unicode.
// It does a binary search on a table to translate
// most properly.
//print_line("keysym_unicode: "+rtos(keysym_unicode));
unsigned int unicode = keysym_unicode>0? KeyMappingX11::get_unicode_from_keysym(keysym_unicode):0;
/* Phase 4, determine if event must be filtered */
// This seems to be a side-effect of using XIM.
// XEventFilter looks like a core X11 funciton,
// but it's actually just used to see if we must
// ignore a deadkey, or events XIM determines
// must not reach the actual gui.
// Guess it was a design problem of the extension
bool keypress = xkeyevent->type == KeyPress;
if (xkeyevent->type == KeyPress && xic) {
if (XFilterEvent((XEvent*)xkeyevent, x11_window))
return;
}
if (keycode==0 && unicode==0)
return;
/* Phase 5, determine modifier mask */
// No problems here, except I had no way to
// know Mod1 was ALT and Mod4 was META (applekey/winkey)
// just tried Mods until i found them.
//print_line("mod1: "+itos(xkeyevent->state&Mod1Mask)+" mod 5: "+itos(xkeyevent->state&Mod5Mask));
InputModifierState state = get_key_modifier_state(xkeyevent->state);
/* Phase 6, determine echo character */
// Echo characters in X11 are a keyrelease and a keypress
// one after the other with the (almot) same timestamp.
// To detect them, i use XPeekEvent and check that their
// difference in time is below a treshold.
if (xkeyevent->type != KeyPress) {
// make sure there are events pending,
// so this call won't block.
if (XPending(x11_display)>0) {
XEvent peek_event;
XPeekEvent(x11_display, &peek_event);
// I'm using a treshold of 5 msecs,
// since sometimes there seems to be a little
// jitter. I'm still not convinced that all this approach
// is correct, but the xorg developers are
// not very helpful today.
::Time tresh=ABS(peek_event.xkey.time-xkeyevent->time);
if (peek_event.type == KeyPress && tresh<5 ) {
KeySym rk;
nbytes=XLookupString((XKeyEvent*)&peek_event, str, 256, &rk, NULL);
if (rk==keysym_keycode) {
XEvent event;
XNextEvent(x11_display, &event); //erase next event
handle_key_event( (XKeyEvent*)&event,true );
return; //ignore current, echo next
}
}
// use the time from peek_event so it always works
}
// save the time to check for echo when keypress happens
}
/* Phase 7, send event to Window */
InputEvent event;
event.ID=++event_id;
event.type = InputEvent::KEY;
event.device=0;
event.key.mod=state;
event.key.pressed=keypress;
if (keycode>='a' && keycode<='z')
keycode-='a'-'A';
event.key.scancode=keycode;
event.key.unicode=unicode;
event.key.echo=p_echo;
if (event.key.scancode==KEY_BACKTAB) {
//make it consistent accross platforms.
event.key.scancode=KEY_TAB;
event.key.mod.shift=true;
}
//printf("key: %x\n",event.key.scancode);
input->parse_input_event( event);
}
void *speex_realloc (void *ptr, int size) {
return memrealloc(ptr,size);
}
void GDAPI *godot_realloc(void *p_ptr, int p_bytes) {
return memrealloc(p_ptr, p_bytes);
}
void *
realloc(void *cp, size_t nbytes)
{
return memrealloc(cp, nbytes);
}