static void caerVisualizerEventHandlerNeuronMonitor(caerVisualizerPublicState state, const sf::Event &event) { // This only works with actual hardware. const std::string moduleLibrary = sshsNodeGetStdString(state->eventSourceConfigNode, "moduleLibrary"); if (moduleLibrary != "caer_dynapse") { return; } // On release of left click. if (event.type == sf::Event::MouseButtonReleased && event.mouseButton.button == sf::Mouse::Button::Left) { float positionX = (float) event.mouseButton.x; float positionY = (float) event.mouseButton.y; // Adjust coordinates according to zoom factor. float currentZoomFactor = state->renderZoomFactor.load(); if (currentZoomFactor > 1.0f) { positionX = floorf(positionX / currentZoomFactor); positionY = floorf(positionY / currentZoomFactor); } else if (currentZoomFactor < 1.0f) { positionX = floorf(positionX * currentZoomFactor); positionY = floorf(positionY * currentZoomFactor); } // Transform into chip ID, core ID and neuron ID. const struct caer_spike_event val = caerDynapseSpikeEventFromXY(U16T(positionX), U16T(positionY)); uint8_t chipId = caerSpikeEventGetChipID(&val); uint8_t coreId = caerSpikeEventGetSourceCoreID(&val); uint32_t neuronId = caerSpikeEventGetNeuronID(&val); // Set value via SSHS. sshsNode neuronMonitorNode = sshsGetRelativeNode(state->eventSourceConfigNode, "NeuronMonitor/"); char monitorKey[] = "Ux_Cy"; monitorKey[1] = (char) (48 + chipId); monitorKey[4] = (char) (48 + coreId); sshsNodePutInt(neuronMonitorNode, monitorKey, I32T(neuronId)); caerLog(CAER_LOG_NOTICE, "Visualizer", "Monitoring neuron - chip ID: %d, core ID: %d, neuron ID: %d.", chipId, coreId, neuronId); } }
static inline bool caerFrameEventPNGCompress(uint8_t **outBuffer, size_t *outSize, uint16_t *inBuffer, int32_t xSize, int32_t ySize, enum caer_frame_event_color_channels channels) { png_structp png_ptr = NULL; png_infop info_ptr = NULL; png_byte **row_pointers = NULL; // Initialize the write struct. png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (png_ptr == NULL) { return (false); } // Initialize the info struct. info_ptr = png_create_info_struct(png_ptr); if (info_ptr == NULL) { png_destroy_write_struct(&png_ptr, NULL); return (false); } // Set up error handling. if (setjmp(png_jmpbuf(png_ptr))) { if (row_pointers != NULL) { png_free(png_ptr, row_pointers); } png_destroy_write_struct(&png_ptr, &info_ptr); return (false); } // Set image attributes. png_set_IHDR(png_ptr, info_ptr, (png_uint_32) xSize, (png_uint_32) ySize, 16, caerFrameEventColorToLibPNG(channels), PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); // Handle endianness of 16-bit depth pixels correctly. // PNG assumes big-endian, our Frame Event is always little-endian. png_set_swap(png_ptr); // Initialize rows of PNG. row_pointers = png_malloc(png_ptr, (size_t) ySize * sizeof(png_byte *)); if (row_pointers == NULL) { png_destroy_write_struct(&png_ptr, &info_ptr); return (false); } for (size_t y = 0; y < (size_t) ySize; y++) { row_pointers[y] = (png_byte *) &inBuffer[y * (size_t) xSize * channels]; } // Set write function to buffer one. struct mem_encode state = { .buffer = NULL, .size = 0 }; png_set_write_fn(png_ptr, &state, &caerLibPNGWriteBuffer, NULL); // Actually write the image data. png_set_rows(png_ptr, info_ptr, row_pointers); png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, NULL); // Free allocated memory for rows. png_free(png_ptr, row_pointers); // Destroy main structs. png_destroy_write_struct(&png_ptr, &info_ptr); // Pass out buffer with resulting PNG image. *outBuffer = state.buffer; *outSize = state.size; return (true); } #endif static size_t compressEventPacket(outputCommonState state, caerEventPacketHeader packet, size_t packetSize) { // Data compression technique 1: serialize timestamps for event types that tend to repeat them a lot. // Currently, this means polarity events. if ((state->format & 0x01) && caerEventPacketHeaderGetEventType(packet) == POLARITY_EVENT) { // Search for runs of at least 3 events with the same timestamp, and convert them to a special // sequence: leave first event unchanged, but mark its timestamp as special by setting the // highest bit (bit 31) to one (it is forbidden for timestamps in memory to have that bit set for // signed-integer-only language compatibility). Then, for the second event, change its timestamp // to a 4-byte integer saying how many more events will follow afterwards with this same timestamp // (this is used for decoding), so only their data portion will be given. Then follow with those // event's data, back to back, with their timestamps removed. // So let's assume there are 6 events with TS=1234. In memory this looks like this: // E1(data,ts), E2(data,ts), E3(data,ts), E4(data,ts), E5(data,ts), E6(data,ts) // After timestamp serialization compression step: // E1(data,ts|0x80000000), E2(data,4), E3(data), E4(data), E5(data), E5(data) // This change is only in the data itself, not in the packet headers, so that we can still use the // eventCapacity and eventSize fields to calculate memory allocation when doing decompression. // As such, to correctly interpret this data, the Format flags must be correctly set. All current // file or network formats do specify those as mandatory in their headers, so we can rely on that. // Also all event types where this kind of thing makes any sense do have the timestamp as their last // data member in their struct, so we can use that information, stored in tsOffset header field, // together with eventSize, to come up with a generic implementation applicable to all other event // types that satisfy this condition of TS-as-last-member (so we can use that offset as event size). // When this is enabled, it requires full iteration thorough the whole event packet, both at // compression and at decompression time. size_t currPacketOffset = CAER_EVENT_PACKET_HEADER_SIZE; // Start here, no change to header. int32_t eventSize = caerEventPacketHeaderGetEventSize(packet); int32_t eventTSOffset = caerEventPacketHeaderGetEventTSOffset(packet); int32_t lastTS = -1; int32_t currTS = -1; size_t tsRun = 0; bool doMemMove = false; // Initially don't move memory, until we actually shrink the size. for (int32_t caerIteratorCounter = 0; caerIteratorCounter <= caerEventPacketHeaderGetEventNumber(packet); caerIteratorCounter++) { // Iterate until one element past the end, to flush the last run. In that particular case, // we don't get a new element or TS, as we'd be past the end of the array. if (caerIteratorCounter < caerEventPacketHeaderGetEventNumber(packet)) { void *caerIteratorElement = caerGenericEventGetEvent(packet, caerIteratorCounter); currTS = caerGenericEventGetTimestamp(caerIteratorElement, packet); if (currTS == lastTS) { // Increase size of run of same TS events currently being seen. tsRun++; continue; } } // TS are different, at this point look if the last run was long enough // and if it makes sense to compress. It does starting with 3 events. if (tsRun >= 3) { // First event to remains there, we set its TS highest bit. uint8_t *firstEvent = caerGenericEventGetEvent(packet, caerIteratorCounter - (int32_t) tsRun--); caerGenericEventSetTimestamp(firstEvent, packet, caerGenericEventGetTimestamp(firstEvent, packet) | I32T(0x80000000)); // Now use second event's timestamp for storing how many further events. uint8_t *secondEvent = caerGenericEventGetEvent(packet, caerIteratorCounter - (int32_t) tsRun--); caerGenericEventSetTimestamp(secondEvent, packet, I32T(tsRun)); // Is at least 1. // Finally move modified memory where it needs to go. if (doMemMove) { memmove(((uint8_t *) packet) + currPacketOffset, firstEvent, (size_t) eventSize * 2); } else { doMemMove = true; // After first shrink always move memory. } currPacketOffset += (size_t) eventSize * 2; // Now go through remaining events and move their data close together. while (tsRun > 0) { uint8_t *thirdEvent = caerGenericEventGetEvent(packet, caerIteratorCounter - (int32_t) tsRun--); memmove(((uint8_t *) packet) + currPacketOffset, thirdEvent, (size_t) eventTSOffset); currPacketOffset += (size_t) eventTSOffset; } } else { // Just copy data unchanged if no compression is possible. if (doMemMove) { uint8_t *startEvent = caerGenericEventGetEvent(packet, caerIteratorCounter - (int32_t) tsRun); memmove(((uint8_t *) packet) + currPacketOffset, startEvent, (size_t) eventSize * tsRun); } currPacketOffset += (size_t) eventSize * tsRun; } // Reset values for next iteration. lastTS = currTS; tsRun = 1; } return (currPacketOffset); } #ifdef ENABLE_INOUT_PNG_COMPRESSION // Data compression technique 2: do PNG compression on frames, Grayscale and RGB(A). if ((state->format & 0x02) && caerEventPacketHeaderGetEventType(packet) == FRAME_EVENT) { size_t currPacketOffset = CAER_EVENT_PACKET_HEADER_SIZE; // Start here, no change to header. size_t frameHeaderSize = sizeof(struct caer_frame_event); CAER_FRAME_ITERATOR_ALL_START((caerFrameEventPacket) packet) size_t pixelSize = caerFrameEventGetPixelsSize(caerFrameIteratorElement); // Keep frame event header intact, compress image data, move memory close together. memmove(((uint8_t *) packet) + currPacketOffset, caerFrameIteratorElement, frameHeaderSize); currPacketOffset += frameHeaderSize; uint8_t *outBuffer; size_t outSize; if (!caerFrameEventPNGCompress(&outBuffer, &outSize, caerFrameEventGetPixelArrayUnsafe(caerFrameIteratorElement), caerFrameEventGetLengthX(caerFrameIteratorElement), caerFrameEventGetLengthY(caerFrameIteratorElement), caerFrameEventGetChannelNumber(caerFrameIteratorElement))) { // Failed to generate PNG. // Discard this frame event. currPacketOffset -= frameHeaderSize; continue; } // Check that the image didn't actually grow. // Add integer needed for storing PNG block length. if ((outSize + sizeof(int32_t)) > pixelSize) { caerLog(CAER_LOG_ERROR, state->parentModule->moduleSubSystemString, "Failed to compress frame event. " "Image actually grew by %zu bytes to a total of %zu bytes.", (outSize - pixelSize), outSize); free(outBuffer); currPacketOffset -= frameHeaderSize; continue; } // Store size of PNG image block as 4 byte integer. int32_t outSizeInt = I32T(outSize); memcpy(((uint8_t *) packet) + currPacketOffset, &outSizeInt, sizeof(int32_t)); currPacketOffset += sizeof(int32_t); memcpy(((uint8_t *) packet) + currPacketOffset, outBuffer, outSize); currPacketOffset += outSize; // Free allocated PNG block memory. free(outBuffer); } return (currPacketOffset); } #endif return (packetSize); }