//////////////////////////////////////////////////////////////////////////////
///
/// Read an operand
///
//////////////////////////////////////////////////////////////////////////////
void matrix_mul::readOperand() {
int r = 0;
r++;
int j = r;
ModuleRead(1, SPACE_BLOCKING, m_operand1, 100 * 100);
ModuleRead(1, SPACE_BLOCKING, m_operand2, 100 * 100);
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read the substraction's result
///
//////////////////////////////////////////////////////////////////////////////
long controller::readSubtractionResult() {
long data;
ModuleRead(7, SPACE_BLOCKING, &data);
return data;
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read the multiplication's result
///
//////////////////////////////////////////////////////////////////////////////
long controller::readMultiplicationResult() {
long data;
ModuleRead(5, SPACE_BLOCKING, &data);
return data;
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read the division's result
///
//////////////////////////////////////////////////////////////////////////////
long controller::readDivisionResult() {
long data;
ModuleRead(2, SPACE_BLOCKING, &data);
return data;
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read the addition's result
///
//////////////////////////////////////////////////////////////////////////////
long controller::readAdditionResult() {
long data;
ModuleRead(0, SPACE_BLOCKING, &data);
return data;
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read data from input
///
//////////////////////////////////////////////////////////////////////////////
unsigned long controller::readInput() {
unsigned long data;
ModuleRead(3, SPACE_BLOCKING, &data);
return data;
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read a character from the FIFO
///
//////////////////////////////////////////////////////////////////////////////
unsigned long output_writer::readFIFO()
{
unsigned long data;
ModuleRead(1, SPACE_BLOCKING, &data);
return data;
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read an operand
///
//////////////////////////////////////////////////////////////////////////////
long adder::readOperand()
{
long data;
ModuleRead(CONTROLLER_ID, SPACE_BLOCKING, &data);
return data;
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read an operand
///
//////////////////////////////////////////////////////////////////////////////
long multiplier::readOperand()
{
long data;
ModuleRead(1, SPACE_BLOCKING, &data);
return data;
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read an operand
///
//////////////////////////////////////////////////////////////////////////////
long* matrix_mul::readOperand()
{
long* data;
ModuleRead(1, SPACE_BLOCKING, data);
return data;
}
signed ReadParameters2 (struct plc * plc)
{
return (ModuleRead (plc, &plc->pib, PLC_MOD_OP_READ_MEMORY, PLC_MODULEID_PARAMETERS, 0));
}
//////////////////////////////////////////////////////////////////////////////
///
/// read the result of mulMat
///
//////////////////////////////////////////////////////////////////////////////
void controller::readMatrixMulRes(unsigned int* data) {
ModuleRead(4, SPACE_BLOCKING, data,
200 * 200);
}
static void manager (struct plc * plc, signed count, signed pause)
{
while (count--)
{
if (_anyset (plc->flags, PLC_VERSION))
{
VersionInfo2 (plc);
}
if (_anyset (plc->flags, PLC_ATTRIBUTES))
{
Attributes2 (plc);
}
if (_anyset (plc->flags, PLC_WATCHDOG_REPORT))
{
WatchdogReport (plc);
}
if (_anyset (plc->flags, PLC_NVRAM_INFO))
{
NVRAMInfo (plc);
}
if (_anyset (plc->flags, PLC_READ_IDENTITY))
{
Identity2 (plc);
}
if (_anyset (plc->flags, PLC_REMOTEHOSTS))
{
RemoteHosts (plc);
}
if (_anyset (plc->flags, PLC_NETWORK))
{
NetInfo2 (plc);
}
if (_anyset (plc->flags, PLC_READ_PIB))
{
ModuleRead (plc, &plc->pib, PLC_MOD_OP_READ_MEMORY, PLC_MODULEID_PARAMETERS, 0);
}
if (_anyset (plc->flags, PLC_READ_MAC))
{
ModuleRead (plc, &plc->nvm, PLC_MOD_OP_READ_MEMORY, PLC_MODULEID_FIRMWARE, 0);
}
if (_anyset (plc->flags, PLC_HOST_ACTION))
{
HostActionResponse (plc);
}
if (_anyset (plc->flags, PLC_PUSH_BUTTON))
{
PushButton (plc);
}
if (_anyset (plc->flags, PLC_FACTORY_DEFAULTS))
{
FactoryDefaults (plc);
}
if (_anyset (plc->flags, (PLC_SETLOCALKEY | PLC_SETREMOTEKEY)))
{
SetNMK (plc);
}
if (_anyset (plc->flags, PLC_FLASH_DEVICE))
{
FlashDevice2 (plc);
}
if (_anyset (plc->flags, PLC_RESET_DEVICE))
{
ResetDevice (plc);
}
sleep (pause);
}
return;
}
void matrix_mul::readOperand(unsigned int *matrixOperand)
{
ModuleRead(CONTROLLER_ID, SPACE_BLOCKING, matrixOperand, MATRIX_ROWS * MATRIX_COLUMNS);
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read the matrix multiplication's result
///
//////////////////////////////////////////////////////////////////////////////
void controller::readMultiplicationMatResult(long resultBuffer[])
{
ModuleRead(4, SPACE_BLOCKING, resultBuffer, 30 * 30);
}
void EXTR::thread_extract_jpeg() {
UINT8 last_marker;
UINT8 last_returned;
bool end_of_jpeg;
bool has_at_least_one_jpeg_succeeded;
JMSG outmsg;
JMSG inmsg;
m_currentJPEGImageNo = 0;
m_currentBitmapImage = 0;
m_bufferValid = false;
// represents the distance between each jpeg image
m_jpegDist = JPEG_IMAGE_SPACER;
has_at_least_one_jpeg_succeeded = false;
// reset to 0 structures and data related to jpeg decompression
initialize();
while(1) {
end_of_jpeg = false;
//
// selection of jpeg preloop - sets pointer on proper image
//
m_currentJPEGImageNo++;
if (m_currentJPEGImageNo > MAX_NB_IMAGE)
{
// either we stop when we finish processing the images...
launch_face_detection();
sc_stop();
// ...or we loop forever (comment out the previous line)
m_currentJPEGImageNo = 1;
if (has_at_least_one_jpeg_succeeded == false)
{
SpacePrint("........................................................\n");
SpacePrint("JPEG DECODER : ALL IMAGES SET FOR DECOMPRESSION\n");
SpacePrint("HAVE FAILED -- STOPPING\n");
SpacePrint("........................................................\n");
sc_stop();
}
}
m_infoImageHeaderAdd = (m_currentJPEGImageNo-1) * m_jpegDist;
m_inputAdd = m_infoImageHeaderAdd + INFO_IMAGE_HEADER;
m_bufferValid = false;
computeFor(1);
if (GetVerbose())
{
SpacePrint("EXTR: ********************************************** \n");
SpacePrint("EXTR: Decompressing JPEG IMAGE no %d\n", m_currentJPEGImageNo);
SpacePrint("EXTR: Input Address: 0x%x\n", m_inputAdd);
SpacePrint("EXTR: ********************************************** \n");
}
else
{
SpacePrint("***JPEG %d\n",m_currentJPEGImageNo);
}
//
// decode jpeg!
//
while (!end_of_jpeg)
{
//
// JPEG information is stored in between MARKERS. Each marker tells about
// the upcoming information to be read from the data
//
// this section scans markers and execute appropriate code according
// to last marker read
last_marker = read_next_marker();
computeFor(1);
switch (last_marker)
{
//
// START OF FRAME MARKER
//
case SOF0:
case SOF1:
case SOF2:
has_at_least_one_jpeg_succeeded = true;
m_jpeg_decoder_structure.sof = last_marker;
last_returned = read_sof_marker ();
if (last_returned != SUCCESS)
{
SpacePrint("----------------------------------------\n");
SpacePrint("EXTRACTOR: JPEG SOF DECODING ERROR no %d - skipping JPEG\n", last_returned); //, this->name(), last_returned);
initialize();
end_of_jpeg = true;
}
// write image header into memory
// WORD 1 is X width
// WORD 2 is Y height
DeviceWrite(JPEGRAM_ID, m_infoImageHeaderAdd, &m_jpeg_decoder_structure.number_of_samples_per_line);
DeviceWrite(JPEGRAM_ID, m_infoImageHeaderAdd+0x4ul, &m_jpeg_decoder_structure.number_of_lines);
if (GetVerbose())
{
SpacePrint("EXTR: JPEG STARTING DECOMPRESSION OF IMAGE no%d\n", m_currentJPEGImageNo);
SpacePrint("EXTR: Image size: %dx%d\n",
m_jpeg_decoder_structure.number_of_samples_per_line,
m_jpeg_decoder_structure.number_of_lines);
}
else
{
SpacePrint("EXTR:JPEG%d\n", m_currentJPEGImageNo);
}
communicate_IJPEG(SCMD_NEW_IMAGE);
//}
break;
//
// START OF HUFFMAN TABLE MARKER AT 0xffc0
//
case DHT:
outmsg.command = SCMD_HUFFMAN_DHT;
outmsg.param0 = m_inputAdd;
if (GetVerbose())
SpacePrint("EXTR: Huffman Table found; sending address to HUFF module\n");
ModuleWrite(HUFF_ID, SPACE_BLOCKING, &outmsg);
computeFor(1);
// wait for acknowledgement
ModuleRead(HUFF_ID, SPACE_BLOCKING, &inmsg);
if (GetVerbose())
SpacePrint("EXTR: Return from blocking read - waiting Huffman ACK\n");
// ack received with update with memory pointer
if (inmsg.command == SCMD_ACK)
{
m_inputAdd = inmsg.param0;
m_bufferValid = false;
}
else
{
SpacePrint("----------------------------------------\n");
SpacePrint("EXTRACTOR: JPEG DHT DECODING ERROR no %d - skipping JPEG\n", inmsg.param0); //this->name(), inmsg.param0);
initialize();
end_of_jpeg = true;
}
break;
//
// START OF SCAN MARKER (DATA) AT 0xffda
//
case SOS:
skip_marker ();
// extract file information
/*
last_returned = read_sos_marker ();
if (last_returned != SUCCESS)
{
SpacePrint("----------------------------------------\n");
SpacePrint("EXTRACTOR: JPEG SOS DECODING ERROR no %d - skipping JPEG\n", last_returned); //this->name(), last_returned);
initialize();
end_of_jpeg = true;
}
*/
// this flys through the MCU and keep tracks of the current type of
// block being processed - for HUffman_thread. This should be
// optimised since it is always 4Y+CB+CR- TODO
if (GetVerbose())
SpacePrint("EXTR: Start of Scan Marker found... interleaving scan decoding can start\n");
decode_interleaved_scan ();
if (GetVerbose())
{
SpacePrint("EXTR: End of Scan Marker... waiting for other modules to finish\n");
}
// This is the end of the file, we terminate
communicate_IJPEG(SCMD_END_IMAGE);
// reinitialize buffers for jpeg decompression
initialize();
// we get off this loop and prepare for next image
end_of_jpeg = true;
// we launch execution of face detection -
// which emulates somne filters to render
// new images
launch_face_detection();
computeFor(1);
break;
//
// START OF QUANTIZATION TABLE MARKER AT 0xffdb
//
case DQT:
// ack received with update with memory pointer
if (read_dqt_marker() != SUCCESS)
{
SpacePrint("----------------------------------------\n");
SpacePrint("EXTRACTOR: IQTZ DQT DECODING ERROR no %d - skipping JPEG\n", inmsg.param0); //this->name(), inmsg.param0);
initialize();
end_of_jpeg = true;
}
break;
//
// START OF IMAGE && END OF IMAGE MARKERS
//
case SOI:
if (GetVerbose())
SpacePrint("EXTR: START OF IMAGE marker detected - reading image\n");
break;
//
// START OF DEFINE RESTORE INTERVAL TABLE MARKER AT 0xffdb
//
/*
case DRI:
last_returned = read_dri_marker (); // read info and skip
if (last_returned != SUCCESS)
{
SpacePrint("----------------------------------------\n");
SpacePrint("EXTRACTOR: JPEG DRI DECODING ERROR no %d - skipping JPEG\n", last_returned); //this->name(), last_returned);
initialize();
end_of_jpeg = true;
}
break;
*/
//
// END OF IMAGE MARKER - nothing to do
//
case MARKER_EOI: // END OF IMAGE MARKER
break;
//
// MARKERS WE SKIP
//
case APP0: case APP1: case APP2: case APP3: case APP4:
case APP5: case APP6: case APP7: case APP8: case APP9:
case APP10: case APP11: case APP12: case APP13: case APP14:
case APP15: case COM: case DRI:
skip_marker ();
break;
//
// ALL OTHER MARKERS ARE UNSUPPORTED BY THIS APPLICATION
//
default:
SpacePrint("----------------------------------------\n");
SpacePrint("EXTRACTOR: JPEG DECODING UNDEFINED MARKER %d - skipping JPEG\n", last_marker); //this->name(), last_marker);
initialize();
end_of_jpeg = true;
break;
} // switch case
}// while end of jpeg
} // while 1
}
void matrix_mul::readOperand(unsigned int *matrixOperand)
{
ModuleRead(1, SPACE_BLOCKING, matrixOperand, 300 * 300);
}
//////////////////////////////////////////////////////////////////////////////
///
/// Read the matrix multiplication's result
///
//////////////////////////////////////////////////////////////////////////////
void controller::readMultiplicationMatResult(unsigned int *resultBuffer)
{
ModuleRead(21, SPACE_BLOCKING, resultBuffer, 300 * 300);
}
//
// EXTR::decode_interleaved_scan
//////////////////////////////////////////////////////////////////////////////
///
/// This is the loop that extracts the jpeg data
///
///
/// @return => UINT16 : SUCCESS (always)
///
/// @note =>
//////////////////////////////////////////////////////////////////////////////
UINT16 EXTR::decode_interleaved_scan() {
UINT16 i, j, horizontal_mcus, vertical_mcus;
space_uint2 k, number_of_image_components_in_frame;
space_uint4 l, m, horizontal_sampling_factor, vertical_sampling_factor;
JMSG msg;
// use these shortcuts
horizontal_mcus = m_jpeg_decoder_structure.horizontal_mcus;
vertical_mcus = m_jpeg_decoder_structure.vertical_mcus;
number_of_image_components_in_frame = m_jpeg_decoder_structure.number_of_image_components_in_frame;
//
// The jpeg image is stored in minimal component units or mcu. Each unit represents
// a luminance block (Y) or a chrominance block (C). Since this decoder only supports
// files that are encoded in the YUV 4:2:0 format, MCUs are stored in groups of 6.
// The four first MCUs are luminance component. The two lasts are chrominance Cb and Cr
// that are colour information for the 4 previous luminance blocks.
// This can be seen as follow:
//
// _____________
// | | |
// | Y1 | Y2 |
// | ___|___ |
// | | | | |
// |--|Cb | Cr|--|
// | |___|___| |
// | | |
// | Y3 | Y4 |
// |______|______|
//
// we scan all the vertical & horizontal mcus
for (i=1; i<=vertical_mcus; i++)
//for (i=1; i<=vertical_mcus/2; i++)
{
for (j=1; j<=horizontal_mcus;j++)
//for (j=1; j<=horizontal_mcus/4;j++)
{
// every mcu is composed of 3 components Y, Cb and Cr
for (k=0; k<number_of_image_components_in_frame; k ++)
{
vertical_sampling_factor = m_jpeg_decoder_structure.vertical_sampling_factor [k];
horizontal_sampling_factor = m_jpeg_decoder_structure.horizontal_sampling_factor [k];
computeFor(1);
for (l=0; l<vertical_sampling_factor; l++)
{
for (m=0; m<horizontal_sampling_factor; m++)
{
// triggers a notification to huffman thread to start Huffman decoding
m_currentHuffmanComponent = k;
// send information to HUFF module
msg.command = SCMD_HUFFMAN_MCU;
msg.param0 = m_currentHuffmanComponent;
msg.param1 = m_inputAdd;
computeFor(1);
// send over request to huffman module
ModuleWrite(HUFF_ID, SPACE_BLOCKING, &msg);
computeFor(1);
ModuleRead(HUFF_ID, SPACE_BLOCKING, &msg);
if (GetVerbose())
{
static int roulette = 1;
switch (roulette)
{
case 1: //[
case 5:
SpacePrint("|\b");
break;
case 2:
case 7:
SpacePrint("/\b");
break;
case 3:
case 6:
SpacePrint("-\b");
break;
case 4:
case 8:
SpacePrint("\\\b");
break;
}
if (++roulette > 8) roulette = 1;
}
if (GetVerbose())
SpacePrint("EXTR: decode_interleave_scan returned i:%d j:%d k:%d l:%d m:%d\n", i, j, k, l, m);
if (msg.command != SCMD_ACK)
{
SpacePrint("EXTRACTOR ERROR : decode_interleaved has received a FAIL %d from HUFFMAN module\n", msg.param0); //this->name(), msg.param0);
sc_stop();
}
else
{
m_inputAdd = msg.param0;
m_bufferValid = false;
}
}
}
}
}
}
// (.)(.)
// <
// ____
// \/ \/
// when we get here, it's the end of the image!
if (GetVerbose())
SpacePrint("\n");
return SUCCESS;
}
//////////////////////////////////////////////////////////////////////////////
///
/// Transmission of New Image command to IQTZ - wait for acknowledgement before
/// continuing
///
//////////////////////////////////////////////////////////////////////////////
void EXTR::communicate_IJPEG(unsigned short command) {
JMSG newimage_message;
switch (command)
{
case SCMD_NEW_IMAGE:
if (GetVerbose())
SpacePrint("EXTR: Sending NEW_IMAGE command to IQTZ - waiting for ACK\n");
newimage_message.command = SCMD_NEW_IMAGE;
newimage_message.param1 = m_currentJPEGImageNo; // current image number
newimage_message.param0 = m_infoImageHeaderAdd; // current image info header
computeFor(1);
// transmitting request for decompressing new jpeg image -
// paramete is address of jpeg iomage to decompress
ModuleWrite(IQTZ_ID, SPACE_BLOCKING, &newimage_message);
computeFor(1);
// waiting for acknowledgement with a blocking read
// parameter is address of decompressed-YUV data
ModuleRead(IQTZ_ID, SPACE_BLOCKING, &newimage_message);
computeFor(1);
if (newimage_message.command == SCMD_NEW_IMAGE_ACK) // collect address of bitmap
{
m_decompressedImageAddr[m_currentJPEGImageNo-1] = newimage_message.param0;
//m_decompressedImageAddr[m_currentJPEGImageNo-1][VALID] = FALSE; // image data not valid while decompressing
}
if (GetVerbose())
SpacePrint("EXTR: Return of ACK from IQTZ imageno:%d; address:%d\n", newimage_message.param0, m_decompressedImageAddr[m_currentJPEGImageNo-1]);
computeFor(1);
break;
case SCMD_END_IMAGE:
if (GetVerbose())
SpacePrint("EXTR: END_IMAGE command to send to IQTZ\n");
newimage_message.command = SCMD_END_IMAGE;
newimage_message.param1 = m_currentJPEGImageNo;
computeFor(1);
// transmitting end of request decompressing jpeg image -
// this tells the IJPEG module it will receive no more data
ModuleWrite(HUFF_ID, SPACE_BLOCKING, &newimage_message);
computeFor(1);
// waiting for acknowledgement with a blocking read
// parameter is address of decompressed-YUV data
ModuleRead(IQTZ_ID, SPACE_BLOCKING, &newimage_message);
computeFor(1);
if (GetVerbose())
SpacePrint("EXTR: Return of ACK for END_IMAGE command sent\n");
break;
}
}
