コード例 #1
0
ファイル: test_IT.c プロジェクト: KyOChiang/ImageCompressor
void test_DCT_and_IDCT_with_quantization_and_dequantization(){
  float imageMatrix[8][8] = {{139, 144, 149, 153, 155, 155, 155, 155}, 
                             {144, 151, 153, 156, 159, 156, 156, 156}, 
                             {150, 155, 160, 163, 158, 156, 156, 156},
                             {159, 161, 162, 160, 160, 159, 159, 159}, 
                             {159, 160, 161, 162, 162, 155, 155, 155}, 
                             {161, 161, 161, 161, 160, 157, 157, 157},
                             {162, 162, 161, 163, 162, 157, 157, 157}, 
                             {162, 162, 161, 161, 163, 158, 158, 158}};                       
  int size = 8;
  int i, j;

  normalizeMatrix(size, imageMatrix);
  
  twoD_DCT(size, imageMatrix);
  // dumpMatrix(size,imageMatrix);
  quantizationFunction50(size, imageMatrix);
  // dumpMatrix(size,imageMatrix);
  // printf("\n");
  dequantizationFunction50(size, imageMatrix);
  // dumpMatrix(size,imageMatrix);
  twoD_IDCT(size, imageMatrix);
  // dumpMatrix(size,imageMatrix);
  denormalizeMatrix(size, imageMatrix);
  
  // dumpMatrix(size, imageMatrix);
}
コード例 #2
0
ファイル: vglDeconv.cpp プロジェクト: mcanthony/visiongl
VglImage* vglColorDeconv(VglImage *imagevgl, double *mInitial, int find3rdColor /*=0*/)
{
  
  double *mNormal = (double *) malloc(9*sizeof(double));
  double *mInverse = (double *) malloc(9*sizeof(double));
  double log255 = log(255.0);
  
  if(find3rdColor != 0)
  {
    normalizeMatrix3x3(mInitial, mNormal);
    invertMatrix3x3(mNormal, mInverse);
  } else
    {
      normalizeMatrix(mInitial, mNormal);
      rightInverseMatrix2x3(mNormal, mInverse);
    }
  convertBGRToRGB(imagevgl);

  //vglPrintImageInfo(imagevgl);

  // Creation of structure for the new image
  VglImage *newimagevgl;
  newimagevgl = vglCreate3dImage(cvSize(imagevgl->shape[0], imagevgl->shape[1]), imagevgl->depth, imagevgl->nChannels, imagevgl->shape[2]);

  // Composition of the new image
  int nPixels = imagevgl->shape[0]*imagevgl->shape[1];
  for(int j = 0; j < nPixels; j++)
  {
    // log transform the RGB data
    unsigned char r = ((unsigned char *)imagevgl->ndarray)[j*3];
    unsigned char g = ((unsigned char *)imagevgl->ndarray)[j*3+1];
    unsigned char b = ((unsigned char *)imagevgl->ndarray)[j*3+2];
    double rLog = -((255.0 * log(((double)r+1)/255.0))/log255);
    double gLog = -((255.0 * log(((double)g+1)/255.0))/log255);
    double bLog = -((255.0 * log(((double)b+1)/255.0))/log255);
   
    for(int i = 0; i < 3; i++)
    { 
      double rScaled = rLog * mInverse[i*3];
      double gScaled = gLog * mInverse[i*3+1];
      double bScaled = bLog * mInverse[i*3+2];
      double output = exp(-((rScaled + gScaled + bScaled) - 255.0) * log255 / 255.0);
      if(output > 255) 
	output = 255;
      ((unsigned char *)newimagevgl->ndarray)[j*3+i] = (unsigned char)output;
    }
  }

  convertRGBToBGR(newimagevgl);
  return newimagevgl; 
}
コード例 #3
0
ファイル: vglDeconv.cpp プロジェクト: mcanthony/visiongl
/** Function to save three RGB images, one for each deconvolved color
 */
void vglSaveColorDeconv(VglImage *imagevgl, double *mInitial, char *outFilename, int find3rdColor /*=0*/)
{
  double *mNormal = (double *) malloc(9*sizeof(double));
  
  if(find3rdColor != 0)
    normalizeMatrix3x3(mInitial, mNormal);
  else
    normalizeMatrix(mInitial, mNormal);

  convertBGRToRGB(imagevgl);
  
  VglImage *newimagevgl[3];
  for(int i = 0; i < 3; i++)
    newimagevgl[i] = vglCreate3dImage(cvSize(imagevgl->shape[0], imagevgl->shape[1]), imagevgl->depth, imagevgl->nChannels, imagevgl->shape[2]);

  int nPixels = imagevgl->shape[0]*imagevgl->shape[1];
  for(int j = 0; j < nPixels; j++)
    for(int i = 0; i < 3; i++)
    { 
      unsigned char gray = ((unsigned char *)imagevgl->ndarray)[j*3+i];
      double rLut = 255.0 - ((255.0 - ((double)gray)) * mNormal[i]);
      double gLut = 255.0 - ((255.0 - ((double)gray)) * mNormal[i+3*1]);
      double bLut = 255.0 - ((255.0 - ((double)gray)) * mNormal[i+3*2]);
      ((unsigned char *)newimagevgl[i]->ndarray)[j*3] = ((unsigned char)rLut);
      ((unsigned char *)newimagevgl[i]->ndarray)[j*3+1] = ((unsigned char)gLut);
      ((unsigned char *)newimagevgl[i]->ndarray)[j*3+2] = ((unsigned char)bLut);
    }

  int lStart = 0;
  int lEnd = 0;
  for(int i = 0; i < 3; i++)
  {
    convertRGBToBGR(newimagevgl[i]);
    char outname[1024];
    sprintf(outname, outFilename, i);
    vglSave3dImage(newimagevgl[i], outname, lStart, lEnd);
  }  
}
コード例 #4
0
ファイル: test_IT.c プロジェクト: KyOChiang/ImageCompressor
void test_two_D_DCT_transform_array_of_8_elements_and_should_invert_back_to_original_by_IDCT_with_normalization(){
  float imageMatrix[8][8] = {{154, 123, 123, 123, 123, 123, 123, 136}, 
                             {192, 180, 136, 154, 154, 154, 136, 110}, 
                             {254, 198, 154, 154, 180, 154, 123, 123},
                             {239, 180, 136, 180, 180, 166, 123, 123}, 
                             {180, 154, 136, 167, 166, 149, 136, 136}, 
                             {128, 136, 123, 136, 154, 180, 198, 154},
                             {123, 105, 110, 149, 136, 136, 180, 166}, 
                             {110, 136, 123, 123, 123, 136, 154, 136}};
                             
  float expectMatrix[8][8] ={{154, 123, 123, 123, 123, 123, 123, 136}, 
                             {192, 180, 136, 154, 154, 154, 136, 110}, 
                             {254, 198, 154, 154, 180, 154, 123, 123},
                             {239, 180, 136, 180, 180, 166, 123, 123}, 
                             {180, 154, 136, 167, 166, 149, 136, 136}, 
                             {128, 136, 123, 136, 154, 180, 198, 154},
                             {123, 105, 110, 149, 136, 136, 180, 166}, 
                             {110, 136, 123, 123, 123, 136, 154, 136}};                            
                             
  int size = 8;
  int i, j;

  normalizeMatrix(size, imageMatrix);
  
  twoD_DCT(size, imageMatrix);
  
  // dumpMatrix(size,imageMatrix);
  // printf("\n");
  
  twoD_IDCT(size, imageMatrix);
  
  denormalizeMatrix(size, imageMatrix);
  
  // dumpMatrix(size, imageMatrix);
  
  TEST_ASSERT_EQUAL_MATRIX(expectMatrix, imageMatrix);
}
コード例 #5
0
MStatus sgHair_controlJoint::setOutput()
{
	MStatus status;

	m_vectorArrTransJoint.setLength( m_mtxArrGravityAdd.length() );
	m_vectorArrRotateJoint.setLength( m_mtxArrGravityAdd.length() );

	MMatrix mtxLocal;
	MMatrix parentInverse = m_mtxJointParentBase.inverse();

	MMatrixArray mtxArrInParent, mtxArrInParentNormalize;
	mtxArrInParent.setLength( m_mtxArrGravityAdd.length() );
	mtxArrInParentNormalize.setLength( m_mtxArrGravityAdd.length() );

	for( int i=0; i< m_mtxArrGravityAdd.length(); i++ )
	{
		mtxArrInParent[i] = m_mtxArrGravityAdd[i] * parentInverse;
		mtxArrInParentNormalize[i] = mtxArrInParent[i];
		normalizeMatrix( mtxArrInParentNormalize[i] );
	}

	MTransformationMatrix trMtx( mtxArrInParent[0] );
	m_vectorArrTransJoint[0] = trMtx.translation( MSpace::kTransform );
	m_vectorArrRotateJoint[0] = trMtx.eulerRotation().asVector();

	for( int i=1; i< m_mtxArrGravityAdd.length(); i++ )
	{
		mtxLocal = mtxArrInParent[i] * mtxArrInParentNormalize[i-1].inverse();

		MTransformationMatrix trMtx( mtxLocal );
		m_vectorArrTransJoint[i] = trMtx.translation( MSpace::kTransform );
		m_vectorArrRotateJoint[i] = trMtx.eulerRotation().asVector();
	}

	return MS::kSuccess;
}
コード例 #6
0
ファイル: test_IT.c プロジェクト: KyOChiang/ImageCompressor
void test_release_compression_logic(){
CEXCEPTION_T error;
  Stream *inStream = NULL;
  Stream *outStream = NULL;
  State yProgress = {.state = 0, .index = 0};
  State cbProgress = {.state = 0, .index = 0};
  State crProgress = {.state = 0, .index = 0};
  float inputMatrixA[8][8], inputMatrixB[8][8], inputMatrixC[8][8];
  short int outMatrixA[8][8], outMatrixB[8][8], outMatrixC[8][8];
  int size = 8; uint32 bytesToWrite;
  RGB colorRGB; YCbCr lumaChrom;

  uint8 R[8][8], G[8][8], B[8][8];
	uint8 Y[8][8], Cb[8][8], Cr[8][8];
  
  colorRGB.red = &R; colorRGB.green = &G; colorRGB.blue = &B;
  lumaChrom.Y = &Y; lumaChrom.Cb = &Cb; lumaChrom.Cr = &Cr;
	
	Try{
    inStream = openStream("test/Data/Water lilies.7z.010", "rb");
    outStream = openStream("test/Data/outputData.7z.010", "wb");
  }Catch(error){
    TEST_ASSERT_EQUAL(ERR_FILE_NOT_EXIST, error);
  }
  
  readFileToRGB(inStream,R,G,B);
  
  convertToLuma(&colorRGB, &lumaChrom);
  convertToChromaB(&colorRGB, &lumaChrom);
  convertToChromaR(&colorRGB, &lumaChrom);
  
  convertUINT8ToFloat(Y, inputMatrixA);
  convertUINT8ToFloat(Cb, inputMatrixB);
  convertUINT8ToFloat(Cr, inputMatrixC);
  
  normalizeMatrix(8,inputMatrixA);
  normalizeMatrix(8,inputMatrixB);
  normalizeMatrix(8,inputMatrixC);
  
  twoD_DCT(8,inputMatrixA);
  twoD_DCT(8,inputMatrixB);
  twoD_DCT(8,inputMatrixC);
  
  quantizationFunction50(8,inputMatrixA); //Y array
  quantizationFunction50(8,inputMatrixB); //Cb array
  quantizationFunction50(8,inputMatrixC); //Cr array
  
  convertToUINT16(inputMatrixA, outMatrixA);
  convertToUINT16(inputMatrixB, outMatrixB);
  convertToUINT16(inputMatrixC, outMatrixC);
  bytesToWrite = huffmanEncodePull(&yProgress, outMatrixA, dcLuminanceTable);
  write4Bytes(outStream, bytesToWrite);
  
  while(yProgress.index != 64){
    bytesToWrite = huffmanEncodePull(&yProgress, outMatrixA, acLuminanceTable);
    write4Bytes(outStream, bytesToWrite);
  }
  
  bytesToWrite = huffmanEncodePull(&cbProgress, outMatrixB, dcChrominanceTable);
  write4Bytes(outStream, bytesToWrite);
  
  while(cbProgress.index != 64){
    bytesToWrite = huffmanEncodePull(&cbProgress, outMatrixB, acChrominanceTable);
    write4Bytes(outStream, bytesToWrite);
  }
  
  bytesToWrite = huffmanEncodePull(&crProgress, outMatrixC, dcChrominanceTable);
  write4Bytes(outStream, bytesToWrite);
  
  while(crProgress.index != 64){
    bytesToWrite = huffmanEncodePull(&crProgress, outMatrixC, acChrominanceTable);
    write4Bytes(outStream, bytesToWrite);
  }
  
  //To Encoder..... can only detect state.index to stop when it is 64
  //To Byte Stuff, output to file in Y, Cb, Cr
  //Repeat process until (!feof(inStream))
  
  closeStream(inStream);
  closeStream(outStream);
}

// convertToLuma(&colorRGB, &lumaChrom); convertToChromaB(&colorRGB, &lumaChrom); convertToChromaR(&colorRGB, &lumaChrom);
// dumpMatrixUINT8(8,Y); dumpMatrixUINT8(8,Cb); dumpMatrixUINT8(8,Cr);
// dumpMatrixUINT8(8,R); dumpMatrixUINT8(8,G); dumpMatrixUINT8(8,B);

// printf("\n");
// convertToRed(&colorRGB, &lumaChrom); convertToBlue(&colorRGB, &lumaChrom); convertToGreen(&colorRGB, &lumaChrom);
// dumpMatrixUINT8(8,R); dumpMatrixUINT8(8,G); dumpMatrixUINT8(8,B);

// dumpMatrix(8, inputMatrixA);
// dumpMatrix(8, inputMatrixB);
// dumpMatrix(8, inputMatrixC);

void xtest_release_decompression_logic(){
  //Huffman decoder
  //To Run Length Decode
  //Loop 3 times to get Y Cb Cr arrays
  //De-Q - IDCT - Denormalization - Color Conversion back to RGB
  //Output to file again
}
コード例 #7
0
ファイル: test_IT.c プロジェクト: KyOChiang/ImageCompressor
/*
 *  Raw file                                          DCT output
 *   -----                                              -----
 *  |     |  read+chop                         write   |     |
 *  |     |    ---->   DCT ---->  Quantization  ---->  |     |
 *  |     |                                            |     |
 *   -----                                              -----
 *  DCT output                                           IDCT result
 *   -----                                                  -----
 *  |     |  read+chop                             write   |     |
 *  |     |    ---->  Dequantization  ---->  IDCT   ---->  |     |
 *  |     |                                                |     |
 *   -----                                                  -----
 */
void test_release2(){
  CEXCEPTION_T error;
  Stream *inStream = NULL;
  Stream *outStream = NULL;
  float inputMatrix[8][8];
  int size = 8, count = 0;
  
  Try{
    inStream = openStream("test/Data/Water lilies.7z.010", "rb");
    outStream = openStream("test/Data/Water lilies_RE2.7z.010", "wb");
  }Catch(error){
    TEST_ASSERT_EQUAL(ERR_END_OF_FILE, error);
  }
  Try{
  while(1){
    readBlock(inStream, size, inputMatrix);
    //printf("%.3f", inputMatrix[0][0]);
    normalizeMatrix(size, inputMatrix);
    // dumpMatrix(size, inputMatrix);
    twoD_DCT(size, inputMatrix);
    // printf("%.3f", inputMatrix[0][0]);
    // dumpMatrix(size, inputMatrix);
    quantizationFunction50(size, inputMatrix);
    // dumpMatrix(size, inputMatrix);
    writeBlock11Bit(outStream, size, inputMatrix);
    
    if( feof(inStream->file) )
      { 
          break ;
      }
  }
  }Catch(error){
  TEST_ASSERT_EQUAL(ERR_END_OF_FILE, error);
  }
  closeStream(inStream);
  closeStream(outStream);
  // printf("\n");
  Stream *inStream2 = NULL;
  Stream *outStream2 = NULL;
  count = 0;
  short int inputMatrixIDCT[8][8];
  
  Try{
    inStream2 = openStream("test/Data/Water lilies_RE2.7z.010", "rb");
    outStream2 = openStream("test/Data/Water lilies_RE2Out.7z.010", "wb");
  }Catch(error){
    TEST_ASSERT_EQUAL(ERR_END_OF_FILE, error);
  }
  Try{
  while(1){
    readBlock11Bit(inStream2, size, inputMatrixIDCT);
    // dumpMatrixInt(size, inputMatrixIDCT);
    convertToFloat(inputMatrixIDCT, inputMatrix);
    dequantizationFunction50(size, inputMatrix);
    //dumpMatrix(size, inputMatrix);
    twoD_IDCT(size, inputMatrix);
    denormalizeMatrix(size, inputMatrix);
    // dumpMatrix(size, inputMatrix);
    
    writeBlock(outStream2, size, inputMatrix);
    
   if( feof(inStream2->file) )
      { 
          break ;
      }
  }
  }Catch(error){
  TEST_ASSERT_EQUAL(ERR_END_OF_FILE, error);
  }
  closeStream(inStream2);
  closeStream(outStream2);
}
コード例 #8
0
/**
 * Check if connection is an anomaly
 */
void TfdAnomalyDetector::checkConnection(Connection* conn)
{
    uint32_t flowStartSec = 0;      // starttime of flow (seconds)
    uint64_t flowStartMillisec = 0; // starttime of flow (milliseconds)
    uint32_t host = 0;              // host in local network (srcIP or dstIP)
    string hostString;              // host displayed as string
    bool isSrc = false;
    float numFlowPackets;           // number of packets for current flow
    uint32_t srcIP;
    uint32_t dstIP;
    uint16_t srcPort;
    uint16_t dstPort;
    int odPair = 0;
    map<int, PortList>::iterator hostIt;
    
    // check if src or dst of current flow is local host
    if ((conn->srcIP & subnetmask) == subnet) {
        host = conn->srcIP;
        isSrc = true;
        
    } else if ((conn->dstIP & subnetmask) == subnet) {
        host = conn->dstIP;
        isSrc = false;
    } else {
        return;
    }
    
    // get number of packets for current flow
    numFlowPackets = ntohll(conn->srcPackets);
    
    // calc starttime for current flow
    flowStartMillisec = conn->srcTimeStart;
    flowStartSec = (flowStartMillisec + 500) / 1000; // srcTimeStart -rounded- to seconds
 
    // get appropriate timebin for array
    if (((flowStartSec - lastFlowStartSec) >= binSize) && lastFlowStartSec != 0) {  // todo: variable interval lengths (currently 1 sec) -> binSize
        timeBin++;      // next timebin
        if (timeBin >= TIMEBINS) {
        
          calculateEntropy();
          
          normalizeMatrix(srcIpEntropy, TIMEBINS);
          normalizeMatrix(dstIpEntropy, TIMEBINS);
          normalizeMatrix(srcPortEntropy, TIMEBINS);
          normalizeMatrix(dstPortEntropy, TIMEBINS);
                   
          calculateSingleWayMatrix();
          
          calculateExpectationMaximation();

          // restart calculation
          initTempArrays();   // init and delete IP/Port arrays
          timeBin = 0;        // set counter back
        }
        lastFlowStartSec = flowStartSec;
        lastFlowStartMilliSec = flowStartMillisec;
    }
         
    // get OD-value for array
    hostString = IPToString(host);
    int pos;
    for (int i = 0; i < 3; i++) {     // cut host into substrings, only use last part as index for array
      pos = hostString.find(".");
      hostString = hostString.substr(pos+1);
    }
    odPair = atoi(hostString.c_str()); // convert host-substring to int

    // save flowStart to calculate next timebin
    lastFlowStartSec = flowStartSec;
    
    
    // **** save number of packets to IP-Arrays
    if (isSrc) {
        srcIpPackets[timeBin][odPair] += numFlowPackets;
    } else {
        dstIpPackets[timeBin][odPair] += numFlowPackets;
    }
        
    // **** source port
    srcPort = ntohs(conn->srcPort);
    hostIt = srcPortMap.find(odPair);
    if(hostIt != srcPortMap.end()) {
        // host found in Map -> add port to vector
        PortListIterator portIt = find((hostIt->second).begin(), (hostIt->second).end(), srcPort);
        if (portIt != (hostIt->second).end()) {
        } else {
            (hostIt->second).push_back(srcPort);
            srcPortNum[timeBin][odPair] += 1;
        }
    } else {
        // host not yet in Map -> add it
        // create new port list
        PortList srcPortList(srcPort);
        srcPortMap.insert ( pair<int, PortList>(odPair, srcPortList) );
        srcPortNum[timeBin][odPair] = 1;
    }
    
    // **** destination port
    dstPort = ntohs(conn->dstPort);
    hostIt = dstPortMap.find(odPair);
    if(hostIt != dstPortMap.end()) {
        // host found in Map -> add port to vector
        PortListIterator portIt = find((hostIt->second).begin(), (hostIt->second).end(), dstPort);
        if (portIt != (hostIt->second).end()) {
        } else {
            (hostIt->second).push_back(dstPort);
            dstPortNum[timeBin][odPair] += 1;
        }
    } else {
        // host not yet in Map -> add it
        // create new port list
        PortList dstPortList(dstPort);
        dstPortMap.insert ( pair<int, PortList>(odPair, dstPortList) );
        dstPortNum[timeBin][odPair] = 1;
    }

}
コード例 #9
0
ファイル: test_IT.c プロジェクト: soofatt/ImageCompressor
void test_release_compression_logic(){
CEXCEPTION_T error;
  Stream *inStream = NULL;
  Stream *outStream = NULL;
  State yProgress = {.state = 0, .index = 0};
  State cbProgress = {.state = 0, .index = 0};
  State crProgress = {.state = 0, .index = 0};
  float inputMatrixA[8][8], inputMatrixB[8][8], inputMatrixC[8][8];
  short int outMatrixA[8][8], outMatrixB[8][8], outMatrixC[8][8];
  int size = 8; uint32 bytesToWrite;
  RGB colorRGB; YCbCr lumaChrom;

  uint8 R[8][8], G[8][8], B[8][8];
	uint8 Y[8][8], Cb[8][8], Cr[8][8];
  
  colorRGB.red = &R; colorRGB.green = &G; colorRGB.blue = &B;
  lumaChrom.Y = &Y; lumaChrom.Cb = &Cb; lumaChrom.Cr = &Cr;
	
	Try{
    inStream = openStream("test/Data/Water lilies.7z.010", "rb");
    outStream = openStream("test/Data/outputData.7z.010", "wb");
  }Catch(error){
    TEST_ASSERT_EQUAL(ERR_FILE_NOT_EXIST, error);
  }
  
  readFileToRGB(inStream,R,G,B);
  
  convertToLuma(&colorRGB, &lumaChrom);
  convertToChromaB(&colorRGB, &lumaChrom);
  convertToChromaR(&colorRGB, &lumaChrom);
  
  convertUINT8ToFloat(Y, inputMatrixA);
  convertUINT8ToFloat(Cb, inputMatrixB);
  convertUINT8ToFloat(Cr, inputMatrixC);
  
  normalizeMatrix(8,inputMatrixA);
  normalizeMatrix(8,inputMatrixB);
  normalizeMatrix(8,inputMatrixC);
  
  twoD_DCT(8,inputMatrixA);
  twoD_DCT(8,inputMatrixB);
  twoD_DCT(8,inputMatrixC);
  
  quantizationFunction50(8,inputMatrixA); //Y array
  quantizationFunction50(8,inputMatrixB); //Cb array
  quantizationFunction50(8,inputMatrixC); //Cr array
  
  convertToUINT16(inputMatrixA, outMatrixA);
  convertToUINT16(inputMatrixB, outMatrixB);
  convertToUINT16(inputMatrixC, outMatrixC);
  bytesToWrite = huffmanEncodePull(&yProgress, outMatrixA, dcLuminanceTable);
  write4Bytes(outStream, bytesToWrite);
  
  while(yProgress.index != 64){
    bytesToWrite = huffmanEncodePull(&yProgress, outMatrixA, acLuminanceTable);
    write4Bytes(outStream, bytesToWrite);
  }
  
  bytesToWrite = huffmanEncodePull(&cbProgress, outMatrixB, dcChrominanceTable);
  write4Bytes(outStream, bytesToWrite);
  
  while(cbProgress.index != 64){
    bytesToWrite = huffmanEncodePull(&cbProgress, outMatrixB, acChrominanceTable);
    write4Bytes(outStream, bytesToWrite);
  }
  
  bytesToWrite = huffmanEncodePull(&crProgress, outMatrixC, dcChrominanceTable);
  write4Bytes(outStream, bytesToWrite);
  
  while(crProgress.index != 64){
    bytesToWrite = huffmanEncodePull(&crProgress, outMatrixC, acChrominanceTable);
    write4Bytes(outStream, bytesToWrite);
  }
  
  //To Encoder..... can only detect state.index to stop when it is 64
  //To Byte Stuff, output to file in Y, Cb, Cr
  //Repeat process until (!feof(inStream))
  
  closeStream(inStream);
  closeStream(outStream);
}

// convertToLuma(&colorRGB, &lumaChrom); convertToChromaB(&colorRGB, &lumaChrom); convertToChromaR(&colorRGB, &lumaChrom);
// dumpMatrixUINT8(8,Y); dumpMatrixUINT8(8,Cb); dumpMatrixUINT8(8,Cr);
// dumpMatrixUINT8(8,R); dumpMatrixUINT8(8,G); dumpMatrixUINT8(8,B);

// printf("\n");
// convertToRed(&colorRGB, &lumaChrom); convertToBlue(&colorRGB, &lumaChrom); convertToGreen(&colorRGB, &lumaChrom);
// dumpMatrixUINT8(8,R); dumpMatrixUINT8(8,G); dumpMatrixUINT8(8,B);

// dumpMatrix(8, inputMatrixA);
// dumpMatrix(8, inputMatrixB);
// dumpMatrix(8, inputMatrixC);

void xtest_release_decompression_logic(){
  CEXCEPTION_T error;
  Stream *inStream = NULL;
  Stream *outStream = NULL;
  CodeTable *dcDecodeLumTable = createTable(DCLumTable, 0, sizeof(DCLumTable)/sizeof(RunSizeCode));
  CodeTable *dcDecodeChromTable = createTable(DCChromTable, 0, sizeof(DCChromTable)/sizeof(RunSizeCode));
  CodeTable *acDecodeLumTable = createTable(ACLumTable, 0, sizeof(ACLumTable)/sizeof(RunSizeCode));
  CodeTable *acDecodeChromTable = createTable(ACChromTable, 0, sizeof(ACChromTable)/sizeof(RunSizeCode));
  uint32 bytesToRead, catAndSymbol, runAndDecodedSymbol;
  uint16 codeWord, symbol, runLength, category;
  uint8 runAndSize;
  int16 valueDecodedSymbol;
  int count = 0;
  
  Try{
    inStream = openStream("test/Data/outputData.7z.010", "rb");
    outStream = openStream("test/Data/outputDataDecompress.7z.010", "wb");
  }Catch(error){
    TEST_ASSERT_EQUAL(ERR_FILE_NOT_EXIST, error);
  }
  
  /*bytesToRead = read4Bytes(inStream);
  
  codeWord = bytesToRead >> 16;
  symbol = bytesToRead & 0xffff;
  
  runAndSize = huffmanDecode(codeWord, dcDecodeLumTable);
  runLength = runAndSize >> 4;
  category = runAndSize & 0xf;
  
  catAndSymbol = category;
  catAndSymbol = (catAndSymbol << 16) | symbol;
  
  valueDecodedSymbol = valueDecoding(catAndSymbol);
  
  runAndDecodedSymbol = runLength;
  runAndDecodedSymbol = (runAndDecodedSymbol << 16) | valueDecodedSymbol;
  
  //runAndDecodedSymbol to run-length decode
  while(count < 63){
    bytesToRead = read4Bytes(inStream);
  
    codeWord = bytesToRead >> 16;
    symbol = bytesToRead & 0xffff;
    
    runAndSize = huffmanDecode(codeWord, acDecodeLumTable);
    runLength = runAndSize >> 4;
    category = runAndSize & 0xf;
    
    catAndSymbol = category;
    catAndSymbol = (catAndSymbol << 16) | symbol;
    
    valueDecodedSymbol = valueDecoding(catAndSymbol);
    
    runAndDecodedSymbol = runLength;
    runAndDecodedSymbol = (runAndDecodedSymbol << 16) | valueDecodedSymbol;
    //runAndDecodedSymbol to run-length decode
    
    count++;
  }
  
  bytesToRead = read4Bytes(inStream);
  
  codeWord = bytesToRead >> 16;
  symbol = bytesToRead & 0xffff;
  
  runAndSize = huffmanDecode(codeWord, dcDecodeChromTable);
  runLength = runAndSize >> 4;
  category = runAndSize & 0xf;
  
  catAndSymbol = category;
  catAndSymbol = (catAndSymbol << 16) | symbol;
  
  valueDecodedSymbol = valueDecoding(catAndSymbol);
  
  runAndDecodedSymbol = runLength;
  runAndDecodedSymbol = (runAndDecodedSymbol << 16) | valueDecodedSymbol;
  
  //runAndDecodedSymbol to run-length decode
  while(count < 63){
    bytesToRead = read4Bytes(inStream);
  
    codeWord = bytesToRead >> 16;
    symbol = bytesToRead & 0xffff;
    
    runAndSize = huffmanDecode(codeWord, acDecodeChromTable);
    runLength = runAndSize >> 4;
    category = runAndSize & 0xf;
    
    catAndSymbol = category;
    catAndSymbol = (catAndSymbol << 16) | symbol;
    
    valueDecodedSymbol = valueDecoding(catAndSymbol);
    
    runAndDecodedSymbol = runLength;
    runAndDecodedSymbol = (runAndDecodedSymbol << 16) | valueDecodedSymbol;
    //runAndDecodedSymbol to run-length decode
    
    count++;
  }
  
  bytesToRead = read4Bytes(inStream);
  
  codeWord = bytesToRead >> 16;
  symbol = bytesToRead & 0xffff;
  
  runAndSize = huffmanDecode(codeWord, dcDecodeChromTable);
  runLength = runAndSize >> 4;
  category = runAndSize & 0xf;
  
  catAndSymbol = category;
  catAndSymbol = (catAndSymbol << 16) | symbol;
  
  valueDecodedSymbol = valueDecoding(catAndSymbol);
  
  runAndDecodedSymbol = runLength;
  runAndDecodedSymbol = (runAndDecodedSymbol << 16) | valueDecodedSymbol;
  
  //runAndDecodedSymbol to run-length decode
  while(count < 63){
    bytesToRead = read4Bytes(inStream);
  
    codeWord = bytesToRead >> 16;
    symbol = bytesToRead & 0xffff;
    
    runAndSize = huffmanDecode(codeWord, acDecodeChromTable);
    runLength = runAndSize >> 4;
    category = runAndSize & 0xf;
    
    catAndSymbol = category;
    catAndSymbol = (catAndSymbol << 16) | symbol;
    
    valueDecodedSymbol = valueDecoding(catAndSymbol);
    
    runAndDecodedSymbol = runLength;
    runAndDecodedSymbol = (runAndDecodedSymbol << 16) | valueDecodedSymbol;
    //runAndDecodedSymbol to run-length decode

    
    count++;
  }*/
  
  closeStream(inStream);
  closeStream(outStream);
  //Huffman decoder
  //To Run Length Decode
  //Loop 3 times to get Y Cb Cr arrays
  //De-Q - IDCT - Denormalization - Color Conversion back to RGB
  //Output to file again
}