Untitled

There could be a few reasons why the message extraction isn't working with the previous code. Here are some potential issues and solutions:

### 1. **Incorrect Coefficient Modification During Embedding**
   - **Problem**: The previous embedding example used a simplistic approach by modifying DCT coefficients without preserving the exact bit pattern. This may have caused the extracted bits to be incorrect.
   - **Solution**: Ensure that you are embedding and extracting bits correctly. One common approach is to modify the least significant bit (LSB) of a DCT coefficient to match the bit of the message you want to hide.

### 2. **Loss of Data During Rounding**
   - **Problem**: During the DCT and inverse DCT transformations, precision loss or rounding can occur, affecting the exact values of the coefficients.
   - **Solution**: When embedding the message, you need to choose a method that is resilient to small changes. Instead of simply adjusting the coefficient by adding or subtracting `0.5`, you should adjust the coefficients in a way that minimizes the impact of rounding errors.

### 3. **DCT Coefficient Selection**
   - **Problem**: Not all DCT coefficients are suitable for embedding data. High-frequency coefficients (i.e., those that correspond to fine details in the image) are more likely to be zero or near zero, leading to loss of data when rounding occurs.
   - **Solution**: Use mid-range coefficients for embedding. Avoid the DC coefficient (`u=0, v=0`) and the highest frequency coefficients. For example, use coefficients from positions like `(1,2)` or `(2,1)`.

### 4. **Reading and Writing Image Data Correctly**
   - **Problem**: The way image data is read and written using `libpng` must be consistent. If the bit depth or color type is not handled correctly, it can lead to unexpected results.
   - **Solution**: Ensure that the image is read and written using the correct `libpng` functions, and that the format of the image (grayscale, RGB, RGBA, etc.) is correctly accounted for.

### Improved Approach to Embedding and Extraction

Here's a refined approach for embedding and extracting a message using the LSB of a mid-range DCT coefficient.

#### Embedding the Message
Adjusting the embedding process to use the LSB of a specific DCT coefficient:

```c
void embed_message(double dct_block[BLOCK_SIZE][BLOCK_SIZE], const char *message, int *msg_index, int *bit_index) {
    for (int u = 1; u < BLOCK_SIZE; ++u) {
        for (int v = 1; v < BLOCK_SIZE; ++v) {
            if (*msg_index < strlen(message)) {
                int bit = (message[*msg_index] >> *bit_index) & 1;
                
                // Embed the bit in the LSB of the selected coefficient
                if ((int)dct_block[u][v] % 2 != bit) {
                    if (dct_block[u][v] > 0) {
                        dct_block[u][v] += (bit == 1) ? 1 : -1;
                    } else {
                        dct_block[u][v] += (bit == 1) ? -1 : 1;
                    }
                }
                
                (*bit_index)++;
                if (*bit_index == 8) {
                    (*bit_index) = 0;
                    (*msg_index)++;
                }
            }
        }
    }
}
```

#### Extracting the Message
Adjust the extraction process to match the embedding process:

```c
void extract_message(double dct_block[BLOCK_SIZE][BLOCK_SIZE], char *message, int *msg_index, int *bit_index) {
    for (int u = 1; u < BLOCK_SIZE; ++u) {
        for (int v = 1; v < BLOCK_SIZE; ++v) {
            if (*msg_index < 1024) { // Assuming a maximum of 1024 characters for simplicity
                int bit = ((int)dct_block[u][v]) & 1; // Extract the LSB
                message[*msg_index] |= bit << (*bit_index);
                (*bit_index)++;
                if (*bit_index == 8) {
                    (*bit_index) = 0;
                    (*msg_index)++;
                }
            }
        }
    }
}
```

### 5. **Make Sure to Null-Terminate the Extracted Message**
Ensure that the extracted message is null-terminated to correctly handle string output:

```c
message[msg_index] = '\0';
```

### Summary of Improvements
- **Coefficient Selection**: Use mid-range coefficients for embedding to avoid the DC component and high-frequency coefficients which are prone to errors.
- **Bit Embedding**: Modify the LSB of coefficients to embed message bits in a more controlled manner.
- **Message Reconstruction**: Properly accumulate bits and reconstruct the message.

### Full Extraction Example
Here's how you might use these functions in the `process_image_for_extraction` function:

```c
void process_image_for_extraction(const char *input_file) {
    // (The code for reading the image remains the same)

    char message[1024] = {0}; // Buffer for the message
    int msg_index = 0;
    int bit_index = 0;

    // Process each 8x8 block
    for (int i = 0; i < height; i += BLOCK_SIZE) {
        for (int j = 0; j < width; j += BLOCK_SIZE) {
            double block[BLOCK_SIZE][BLOCK_SIZE];
            for (int x = 0; x < BLOCK_SIZE; ++x) {
                for (int y = 0; y < BLOCK_SIZE; ++y) {
                    if (i + x < height && j + y < width) {
                        block[x][y] = row_pointers[i + x][j + y];
                    } else {
                        block[x][y] = 0; // Zero-padding for edge cases
                    }
                }
            }
            perform_dct(block);
            extract_message(block, message, &msg_index, &bit_index);
        }
    }

    // Null-terminate the extracted message
    message[msg_index] = '\0';
    printf("Extracted message: %s\n", message);

    // (Free memory and cleanup code remains the same)
}
```

### Conclusion
Ensure that the embedding and extraction processes match precisely and handle the coefficients in a way that reduces the impact of rounding errors. By adjusting the approach to embedding and extracting bits using the LSB of DCT coefficients, the extracted message should match the embedded one more reliably.