예제 #1
0
//////////////////////////////////////////////////////////////////////////////
///
///	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);
}
예제 #2
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read the substraction's result
///
//////////////////////////////////////////////////////////////////////////////
long controller::readSubtractionResult() {
 long data;

 ModuleRead(7, SPACE_BLOCKING, &data);

 return data;
}
예제 #3
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read the multiplication's result
///
//////////////////////////////////////////////////////////////////////////////
long controller::readMultiplicationResult() {
 long data;

 ModuleRead(5, SPACE_BLOCKING, &data);

 return data;
}
예제 #4
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read the division's result
///
//////////////////////////////////////////////////////////////////////////////
long controller::readDivisionResult() {
 long data;

 ModuleRead(2, SPACE_BLOCKING, &data);

 return data;
}
예제 #5
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read the addition's result
///
//////////////////////////////////////////////////////////////////////////////
long controller::readAdditionResult() {
 long data;

 ModuleRead(0, SPACE_BLOCKING, &data);

 return data;
}
예제 #6
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read data from input
///
//////////////////////////////////////////////////////////////////////////////
unsigned long controller::readInput() {
 unsigned long data;

 ModuleRead(3, SPACE_BLOCKING, &data);

 return data;
}
예제 #7
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read a character from the FIFO
///
//////////////////////////////////////////////////////////////////////////////
unsigned long output_writer::readFIFO()
{
 unsigned long data;

 ModuleRead(1, SPACE_BLOCKING, &data);

    return data;
}
예제 #8
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read an operand
///
//////////////////////////////////////////////////////////////////////////////
long adder::readOperand()
{
    long data;

    ModuleRead(CONTROLLER_ID, SPACE_BLOCKING, &data);

    return data;
}
예제 #9
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read an operand
///
//////////////////////////////////////////////////////////////////////////////
long multiplier::readOperand()
{
 long data;

 ModuleRead(1, SPACE_BLOCKING, &data);

    return data;
}
예제 #10
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read an operand
///
//////////////////////////////////////////////////////////////////////////////
long* matrix_mul::readOperand()
{
 long* data;

 ModuleRead(1, SPACE_BLOCKING, data);

    return data;
}
예제 #11
0
signed ReadParameters2 (struct plc * plc)

{
	return (ModuleRead (plc, &plc->pib, PLC_MOD_OP_READ_MEMORY, PLC_MODULEID_PARAMETERS, 0));
}
예제 #12
0
//////////////////////////////////////////////////////////////////////////////
///
///	read the result of mulMat
///
//////////////////////////////////////////////////////////////////////////////
void controller::readMatrixMulRes(unsigned int* data) {
 ModuleRead(4, SPACE_BLOCKING, data,
   200 * 200);
}
예제 #13
0
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;
}
예제 #14
0
void matrix_mul::readOperand(unsigned int *matrixOperand)
{
	ModuleRead(CONTROLLER_ID, SPACE_BLOCKING, matrixOperand, MATRIX_ROWS * MATRIX_COLUMNS);
}
예제 #15
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read the matrix multiplication's result
///
//////////////////////////////////////////////////////////////////////////////
void controller::readMultiplicationMatResult(long resultBuffer[])
{
 ModuleRead(4, SPACE_BLOCKING, resultBuffer, 30 * 30);
}
예제 #16
0
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
	
	
	
}
예제 #17
0
void matrix_mul::readOperand(unsigned int *matrixOperand)
{
 ModuleRead(1, SPACE_BLOCKING, matrixOperand, 300 * 300);
}
예제 #18
0
//////////////////////////////////////////////////////////////////////////////
///
///	Read the matrix multiplication's result
///
//////////////////////////////////////////////////////////////////////////////
void controller::readMultiplicationMatResult(unsigned int *resultBuffer)
{
 ModuleRead(21, SPACE_BLOCKING, resultBuffer, 300 * 300);
}
예제 #19
0
//
//  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;
}
예제 #20
0
//////////////////////////////////////////////////////////////////////////////
/// 
/// 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;	
	}
}