chaing typing to snake_style

Author: facruzso

modules/compression/src/compile_run_at.sh modules/compression/compile_run_at.shmodules/compression/src/compile_run_at.sh renamed to modules/compression/compile_run_at.sh

@@ -3,9 +3,9 @@ echo 'Compiling *.c *cpp files'
 rm -rf ips_jpg.o
 export SYSTEMC_HOME=/usr/local/systemc-2.3.3/
 export OPENCV_H_DIR=/usr/local/include/opencv4/
-export OPENCV_L_DIR=/usr/local/lib/
+export OPENCV_SO_DIR=/usr/local/lib/
 export LD_LIBRARY_PATH=$SYSTEMC_HOME/lib-linux64
-g++ -I$SYSTEMC_HOME/include -I$OPENCV_H_DIR -L$SYSTEMC_HOME/lib-linux64 -L$OPENCV_L_DIR ips_jpg_at_testbench.cpp ips_jpg_at_model.cpp  -lsystemc -lm -o ips_jpg.o
+g++ -I$SYSTEMC_HOME/include -I$OPENCV_H_DIR -Iinclude/ -L$SYSTEMC_HOME/lib-linux64 -L$OPENCV_SO_DIR src/ips_jpg_at_testbench.hpp include/ips_jpg_at_model.cpp  -lsystemc -lm -o ips_jpg.o
 echo 'Simulation Started'
 ./ips_jpg.o
 echo 'Simulation Ended'

modules/compression/src/compile_run_lt.sh modules/compression/compile_run_lt.shmodules/compression/src/compile_run_lt.sh renamed to modules/compression/compile_run_lt.sh

@@ -3,9 +3,9 @@ echo 'Compiling *.c *cpp files'
 rm -rf ips_jpg.o
 export SYSTEMC_HOME=/usr/local/systemc-2.3.3/
 export OPENCV_H_DIR=/usr/local/include/opencv4/
-export OPENCV_L_DIR=/usr/local/lib/
+export OPENCV_SO_DIR=/usr/local/lib/
 export LD_LIBRARY_PATH=$SYSTEMC_HOME/lib-linux64
-g++ -I$SYSTEMC_HOME/include -I$OPENCV_H_DIR -L$SYSTEMC_HOME/lib-linux64 -L$OPENCV_L_DIR ips_jpg_lt_testbench.cpp ips_jpg_lt_model.cpp  -lsystemc -lm -o ips_jpg.o
+g++ -I$SYSTEMC_HOME/include -I$OPENCV_H_DIR -Iinclude/ -L$SYSTEMC_HOME/lib-linux64 -L$OPENCV_SO_DIR src/ips_jpg_lt_testbench.cpp include/ips_jpg_lt_model.hpp  -lsystemc -lm -o ips_jpg.o
 echo 'Simulation Started'
 ./ips_jpg.o
 echo 'Simulation Ended'

modules/compression/src/compile_run_pv.sh modules/compression/compile_run_pv.shmodules/compression/src/compile_run_pv.sh renamed to modules/compression/compile_run_pv.sh

@@ -3,9 +3,9 @@ echo 'Compiling *.c *cpp files'
 rm -rf ips_jpg.o
 export SYSTEMC_HOME=/usr/local/systemc-2.3.3/
 export OPENCV_H_DIR=/usr/local/include/opencv4/
-export OPENCV_L_DIR=/usr/local/lib/
+export OPENCV_SO_DIR=/usr/local/lib/
 export LD_LIBRARY_PATH=$SYSTEMC_HOME/lib-linux64
-g++ -I$SYSTEMC_HOME/include -I$OPENCV_H_DIR -L$SYSTEMC_HOME/lib-linux64 -L$OPENCV_L_DIR ips_jpg_pv_testbench.cpp ips_jpg_pv_model.cpp  -lsystemc -lm -o ips_jpg.o
+g++ -I$SYSTEMC_HOME/include -I$OPENCV_H_DIR -Iinclude/ -L$SYSTEMC_HOME/lib-linux64 -L$OPENCV_SO_DIR src/ips_jpg_pv_testbench.cpp include/ips_jpg_pv_model.hpp  -lsystemc -lm -o ips_jpg.o
 echo 'Simulation Started'
 ./ips_jpg.o
 echo 'Simulation Ended'

modules/compression/include/ips_jpg_at_model.hpp

@@ -11,18 +11,18 @@
  * *5. Entropy compression by variable length encoding (huffman). Used to maximize compression. Not implemented here.
  */
 #define PI 3.1415926535897932384626433832795
-#define Block_rows 8
-#define Block_cols 8
+#define BLOCK_ROWS 8
+#define BLOCK_COLS 8
 
 SC_MODULE (jpg_output) {
 
   //input signals
-  sc_in<sc_int<32> > PixelValue_signal;
+  sc_in<sc_int<32> > pixel_value_signal;
   sc_in<sc_int<32> > row_signal;
   sc_in<sc_int<32> > col_signal;
 
   //output signals
-  sc_out<sc_int<8> > Element_signal;
+  sc_out<sc_int<8> > element_signal;
   sc_in<sc_int<32> > index_signal;
 
   //compression signals
@@ -34,7 +34,7 @@ SC_MODULE (jpg_output) {
   double* image;
   int image_rows = 480;
   int image_cols = 640;
-  signed char EOB = 127; // end of block
+  signed char eob = 127; // end of block
 
   int quantificator[8][8] = { // quantization table
   {16,11,10,16,24,40,51,61},
@@ -84,24 +84,24 @@ SC_MODULE (jpg_output) {
 	  while(true) {
 		wait(starter_event);
         int im_rows = row_signal.read();
-	    if(im_rows%Block_rows==0) {image_rows=im_rows;}
-        else {image_rows=(im_rows/Block_rows+1)*Block_rows;}
+	    if(im_rows%BLOCK_ROWS==0) {image_rows=im_rows;}
+        else {image_rows=(im_rows/BLOCK_ROWS+1)*BLOCK_ROWS;}
 		wait(4, SC_NS);
 		int im_cols = col_signal.read();
-        if(im_cols%Block_cols==0) {image_cols=im_cols;}
-        else {image_cols=(im_cols/Block_cols+1)*Block_cols;}
+        if(im_cols%BLOCK_COLS==0) {image_cols=im_cols;}
+        else {image_cols=(im_cols/BLOCK_COLS+1)*BLOCK_COLS;}
 	  }
   }
 
-  void InputPixel() {
+  void input_pixel() {
 	input_event.notify(8, SC_NS);
   }
 
   void input_operation(){
 	  while(true) {
 		wait(input_event);
 		double* i_row = &image[row_signal.read() * image_cols];
-		i_row[col_signal.read()] = double(PixelValue_signal.read());
+		i_row[col_signal.read()] = double(pixel_value_signal.read());
 	  }
   }
 
@@ -110,18 +110,18 @@ SC_MODULE (jpg_output) {
   //  *Pixel = int(i_row[col]);
   //}
 
-  void OutputByte() {
+  void output_byte() {
 	output_event.notify(8, SC_NS);
   }
 
   void output_operation(){
 	  while(true) {
 		wait(output_event);
-        Element_signal = image[index_signal.read()];
+        element_signal = image[index_signal.read()];
 	  }
   }
 
-  void JPEG_compression() {
+  void jpeg_compression() {
 	  compression_event.notify(100, SC_NS);
   }
 
@@ -134,48 +134,48 @@ SC_MODULE (jpg_output) {
 			image[i]=image[i]-128;
 		}
 		wait(100, SC_NS);
-		int Number_of_blocks = image_rows*image_cols/(Block_rows*Block_cols);
-		int block_output[Number_of_blocks][Block_rows*Block_cols] = {0};
-		int block_output_size[Number_of_blocks] = {0};
+		int number_of_blocks = image_rows*image_cols/(BLOCK_ROWS*BLOCK_COLS);
+		int block_output[number_of_blocks][BLOCK_ROWS*BLOCK_COLS] = {0};
+		int block_output_size[number_of_blocks] = {0};
 		int block_counter = 0;
 		output_size = 0;
-		for(int row=0; row<image_rows; row+=Block_rows)	{
+		for(int row=0; row<image_rows; row+=BLOCK_ROWS)	{
 		  double* i_row = &image[row * image_cols];
-		  for(int col=0; col<image_cols; col+=Block_cols) { //Divided the image in 8×8 blocks
-			DCT(row,col);
-			Quantization(row,col);
-			ZigZag(row,col,&block_output_size[block_counter],block_output[block_counter]);
+		  for(int col=0; col<image_cols; col+=BLOCK_COLS) { //Divided the image in 8×8 blocks
+			dct(row,col);
+			quantization(row,col);
+			zigzag(row,col,&block_output_size[block_counter],block_output[block_counter]);
 			output_size += block_output_size[block_counter]+1;
 			block_counter++;
 		  }
 		}
 		int output_counter = 0;
-		for(int block_index=0;block_index<Number_of_blocks;block_index++){
+		for(int block_index=0;block_index<number_of_blocks;block_index++){
 		  for(int out_index=0; out_index<block_output_size[block_index];out_index++){
 			image[output_counter]=block_output[block_index][out_index];
 			output_counter++;
 		  }
-		  image[output_counter]=EOB;
+		  image[output_counter]=eob;
 		  output_counter++;
 		}
 		output_size_signal = output_size;
 	}
   }  
 
-  void DCT(int row_offset, int col_offset) {
+  void dct(int row_offset, int col_offset) {
     wait(400, SC_NS);
-	double cos_table[Block_rows][Block_cols];
-	for (int row = 0; row < Block_rows; row++) //make the cosine table
+	double cos_table[BLOCK_ROWS][BLOCK_COLS];
+	for (int row = 0; row < BLOCK_ROWS; row++) //make the cosine table
 	{
-      for (int col = 0; col < Block_cols; col++) {
+      for (int col = 0; col < BLOCK_COLS; col++) {
         cos_table[row][col] = cos((((2*row)+1)*col*PI)/16);
 	  }
 	}
     double temp;
-	for(int row=row_offset; row<row_offset+Block_rows; row++)
+	for(int row=row_offset; row<row_offset+BLOCK_ROWS; row++)
 	{
  	  double* i_row = &image[row * image_cols];
-	  for(int col=col_offset; col<col_offset+Block_cols; col++) {
+	  for(int col=col_offset; col<col_offset+BLOCK_COLS; col++) {
 		//i_row[col] = cos_table[row-row_offset][col-col_offset];
 		temp = 0.0;
     	for (int x = 0; x < 8; x++){
@@ -198,24 +198,24 @@ SC_MODULE (jpg_output) {
 	}
   }
 
-  void Quantization(int row_offset, int col_offset) {
+  void quantization(int row_offset, int col_offset) {
     wait(100, SC_NS);
-	for(int row=row_offset; row<row_offset+Block_rows; row++)
+	for(int row=row_offset; row<row_offset+BLOCK_ROWS; row++)
 	{
       double* i_row = &image[row * image_cols];
- 	  for(int col=col_offset; col<col_offset+Block_cols; col++) {
+ 	  for(int col=col_offset; col<col_offset+BLOCK_COLS; col++) {
 		i_row[col] = round(i_row[col]/quantificator[row-row_offset][col-col_offset]);
 	  }
 	}
   }
 
-  void ZigZag(int row_offset, int col_offset, int *block_output_size, int *block_output) {
+  void zigzag(int row_offset, int col_offset, int *block_output_size, int *block_output) {
     wait(200, SC_NS);
 	int index_last_non_zero_value = 0; // index to last non-zero in a block zigzag array
-    for(int row=row_offset; row<row_offset+Block_rows; row++)
+    for(int row=row_offset; row<row_offset+BLOCK_ROWS; row++)
 	{
       double* i_row = &image[row * image_cols];
- 	  for(int col=col_offset; col<col_offset+Block_cols; col++) {
+ 	  for(int col=col_offset; col<col_offset+BLOCK_COLS; col++) {
 		int temp_index = zigzag_index[(row-row_offset)*8+(col-col_offset)];
 		block_output[temp_index]=i_row[col];
 	    if(i_row[col] !=0 && temp_index>index_last_non_zero_value) {index_last_non_zero_value = temp_index+1;}