////////////////////////////////////////////////////////////////////////////// /// /// Get the operation /// ////////////////////////////////////////////////////////////////////////////// Operation controller::getOperation(unsigned char* ptr) { unsigned char operation = ptr[getOperationPosition(ptr)]; if (operation == '+') { if (GetVerbose()) SpacePrint("Addition detected!\n"); return ADD; } if (operation == '-') { if (GetVerbose()) SpacePrint("Subtraction detected!\n"); return SUBTRACTION; } if ((operation == '*') || (operation == 'x') || (operation == 'X')) { if (GetVerbose()) SpacePrint("Multiplication detected!\n"); return MULTIPLY; } if (operation == 'z') { if (GetVerbose()) SpacePrint("Multiplication Matrix detected!\n"); return MATRIXMUL; } if (GetVerbose()) SpacePrint("Division detected!\n"); return DIVIDE; }
////////////////////////////////////////////////////////////////////////////// /// /// Delegate the operation /// ////////////////////////////////////////////////////////////////////////////// long controller::delegateOperation(Operation operation, long operand1, long operand2) { long result; switch (operation) { case ADD: { sendAdditionOperand(operand1); sendAdditionOperand(operand2); result = readAdditionResult(); SpacePrint("%d + %d = %d\n", operand1, operand2, result); break; } case SUBTRACTION: { sendSubtractionOperand(operand1); sendSubtractionOperand(operand2); result = readSubtractionResult(); SpacePrint("%d - %d = %d\n", operand1, operand2, result); break; } case MULTIPLY: { sendMultiplicationOperand(operand1); sendMultiplicationOperand(operand2); result = readMultiplicationResult(); SpacePrint("%d * %d = %d\n", operand1, operand2, result); break; } case DIVIDE: { sendDivisionOperand(operand1); sendDivisionOperand(operand2); result = readDivisionResult(); SpacePrint("%d / %d = %d\n", operand1, operand2, result); break; } case MULTIPLY_MAT: { sendMultiplicationMatOperand(operand1); sendMultiplicationMatOperand(operand2); unsigned int *result = new unsigned int[200 * 200]; readMultiplicationMatResult(result); sc_stop(); break; } } return result; }
////////////////////////////////////////////////////////////////////////////// /// /// Send result to output /// ////////////////////////////////////////////////////////////////////////////// void controller::sendResult(long data) { if (GetVerbose()) SpacePrint("Result:%d\n", data); int i; unsigned long power; unsigned int digit; // Negative number if (data < 0) { sendCharacter('-'); data *= -1; } for(i=getOrder(data);i>=0;i--) { power = pow(10, i); digit = data/power; data -= digit*power; sendCharacter(itoa(digit)); } sendCharacter(0xD); }
void EXTR::launch_face_detection(void) { if (GetVerbose()) SpacePrint("EXTR: Launching Face Detection\n"); if (++m_currentBitmapImage > MAX_NB_IMAGE) m_currentBitmapImage = 1; JMSG messageToFace; messageToFace.command = SCMD_BEGIN_FACE_DETECTION; messageToFace.param0 = m_decompressedImageAddr[m_currentBitmapImage-1]; messageToFace.param1 = m_currentJPEGImageNo; computeFor(1); ModuleWrite(FACEDETECT_ID, SPACE_BLOCKING, &messageToFace); if (GetVerbose()) SpacePrint("EXTR: Returned from launch face detection for image #%d\n", m_currentBitmapImage); }
////////////////////////////////////////////////////////////////////////////// /// /// Get the first operand /// ////////////////////////////////////////////////////////////////////////////// long controller::getFirstOperand(unsigned char* ptr) { unsigned char length = getOperationPosition(ptr); unsigned char* trimPtr = trimSpaces(ptr, &length); long number = convertCharacterToNumber(trimPtr, length); if (GetVerbose()) SpacePrint("First operand:%d\n", number); return number; }
void matrix_mul::thread(void) { unsigned int result[3 * 3]; unsigned int operand1[3 * 3]; unsigned int operand2[3 * 3]; while(1) { // Add your code here... readOperand(operand1); readOperand(operand2); multMatrix(operand1, operand2, result); sendResult(result); SpacePrint( "matrix_mul executing...\n" ); } }
/*采用队列式的层次遍历方法和中序遍历方法 由于是显示所有节点,故该函数的要求并不紧急 时间开销是2n,两次遍历*/ void BiSortTree::GraphShow()//图形显示二叉树结构 { BiTree *p=root; if(root==NULL) return ; {//这里添加大括号目的是限制stack生命期 BiTree* stack[MAXSTACK]; int top=-1,lcou=0; do{ if(p!=NULL){ stack[++top]=p; p=p->left; } else if(top>=0){ p=stack[top--]; p->num=lcou; lcou++; p=p->right; } else break; }while(true); }//释放stack栈区,节省空间 int head=0,tail=0,last=0;//层次遍历 BiTree *que[MAXQUEUE],*endl; que[tail++]=root; endl=root; while(tail>head) { p=que[head]; if(p->left!=NULL) que[tail++]=p->left;//左节点入队 if(p->right!=NULL) que[tail++]=p->right;//右节点入队 SpacePrint((p->num-last)*KEYPRINT); last=p->num+1; printf("%-2d",p->value->key); head++; if(p==endl){ if(tail==head) break; cout<<"\n"; last=0; endl=que[tail-1]; } } printf("\n"); }
////////////////////////////////////////////////////////////////////////////// /// /// Delegate the operation /// ////////////////////////////////////////////////////////////////////////////// long controller::delegateOperation(Operation operation, long operand1, long operand2) { SpacePrint("+++delegateOperation\n"); long result; unsigned int *resultMatrix = new unsigned int [200 * 200]; switch (operation) { case ADD: { sendAdditionOperand(operand1); sendAdditionOperand(operand2); result = readAdditionResult(); SpacePrint("%d + %d = %d\n", operand1, operand2, result); break; } case SUBTRACTION: { sendSubtractionOperand(operand1); sendSubtractionOperand(operand2); result = readSubtractionResult(); SpacePrint("%d - %d = %d\n", operand1, operand2, result); break; } case MULTIPLY: { sendMultiplicationOperand(operand1); sendMultiplicationOperand(operand2); result = readMultiplicationResult(); SpacePrint("%d * %d = %d\n", operand1, operand2, result); break; } case DIVIDE: { sendDivisionOperand(operand1); sendDivisionOperand(operand2); result = readDivisionResult(); SpacePrint("%d / %d = %d\n", operand1, operand2, result); break; } case MATRIXMUL: { sendMatrixMulOperand(matrix_data[operand1]); sendMatrixMulOperand(matrix_data[operand2]); readMatrixMulRes(resultMatrix); //printing the values for (int i = 0; i < 200; i++) { for (int j = 0; j < 200; j++) { SpacePrint("%u ", resultMatrix[i * 200 + j]); } SpacePrint("\n"); } break; } } SpacePrint("---delegateOperation\n"); sc_stop(); return result; }
// // 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; } }
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 }
////////////////////////////////////////////////////////////////////////////// /// /// Delegate the operation /// ////////////////////////////////////////////////////////////////////////////// long controller::delegateOperation(Operation operation, long operand1, long operand2) { long result; switch (operation) { case ADD: { sendAdditionOperand(operand1); sendAdditionOperand(operand2); result = readAdditionResult(); SpacePrint("%d + %d = %d\n", operand1, operand2, result); break; } case SUBTRACTION: { sendSubtractionOperand(operand1); sendSubtractionOperand(operand2); result = readSubtractionResult(); SpacePrint("%d - %d = %d\n", operand1, operand2, result); break; } case MULTIPLY: { sendMultiplicationOperand(operand1); sendMultiplicationOperand(operand2); result = readMultiplicationResult(); SpacePrint("%d * %d = %d\n", operand1, operand2, result); break; } case DIVIDE: { sendDivisionOperand(operand1); sendDivisionOperand(operand2); result = readDivisionResult(); SpacePrint("%d / %d = %d\n", operand1, operand2, result); break; } case MULTIPLY_MAT: { sendMultiplicationMatOperand(operand1); sendMultiplicationMatOperand(operand2); long result [30 * 30]; readMultiplicationMatResult(result); SpacePrint("%d z %d = \n", operand1, operand2); for(unsigned int i = 0; i < 30 * 30; i++) { SpacePrint("%d\n", result[i]); } break; } } return result; }
////////////////////////////////////////////////////////////////////////////// /// /// Send the result /// ////////////////////////////////////////////////////////////////////////////// void matrix_mul::sendResult() { SpacePrint("%d z %d = %d and %d \n", m_operand1[0], m_operand2[0],m_result[0], m_result[100 * 100 - 1]); ModuleWrite(1, SPACE_BLOCKING, m_result, 100 * 100); }