[C++] 24-битные BMP

#include <iostream> 
#include <fstream> 
#include <cstdio>
#include <windows.h>
#include <cstring>
 
using namespace std; 
 
int main(int argc, char *argv[]) 
{ 
    setlocale(LC_ALL, "Russian");
    
    if(argc!=2) { //Если более двух аргументов командной строки
        cout << "Используй: next <имя-файла>, будь мужиком!\n"; 
    } 
 
    fstream in(argv[1], ios::in | ios::out | ios::binary); 
    if(!in) { 
        cout << "Невозможно открыть файл.\n";
    } 
  
    BITMAPFILEHEADER bmpFileHeader; //Создание bmpFileHeader
    BITMAPINFOHEADER bmpInfoHeader; //Создание bmpInfoHeader
    
    in.read( (char*)&bmpFileHeader, sizeof( bmpFileHeader ) ); //Считывание данных 
    in.read( (char*)&bmpInfoHeader, sizeof( bmpInfoHeader ) ); //в структуры
    
    const int Height = bmpInfoHeader.biHeight, //Создание констант
              Width = bmpInfoHeader.biWidth,
              BpP = bmpInfoHeader.biBitCount,
              ImageSize = bmpFileHeader.bfSize;
    
    const int RowSize = BpP / 8 * Width ;
    int padding; //Паддинг - ненужное пространсво в массиве пикселей
    
    if (BpP == 8)
        padding = (3 * Width) % 4;
    else if (BpP == 16)
        padding = (2 * Width) % 4;
    else if (BpP == 24)
        padding = Width % 4;
        
    char pixels_orig[Height][RowSize]; //Массив пикселей
    
    in.seekg(bmpFileHeader.bfOffBits, ios::beg); //Перескакиваем в начало массива пикселей
    
    for (int i = 0; i < Height; i++) {
        in.read(pixels_orig[i], (RowSize * (BpP / 8))); //Заполнение одного рядка
        in.seekg(padding, ios::cur); //Проскакиваем паддинг
    }
    
    cout << "Данные " << argv[1] << ":\n"
                 << "\tРазмер файла: " << ImageSize << " байтов = " << (double)ImageSize / 1024 << " килобайтов;\n"
                 << "\tШирина изображения: " << Width << " пикселей;\n"
                 << "\tВысота изображения: " << Height << " пикселей;\n"
                 << "\tБитность: " << BpP << " битов на пиксель.\n";
 
    char temp;
    
    char pixels_crypted[Height][RowSize];
    
    const int code = 10;
    
    for (int i = 0; i < RowSize; i++)
        for (int j = 0; j < Height; j++)
            pixels_crypted[j][i] = pixels_orig[j][i];
    
    //////////////////////  
    //////////////////////      
    ////Новый алгоритм////
    //////////////////////
    //////////////////////
    
    char pattern_1[10][10],
         pattern_2[10][10];
    
    for (int i = 0; i < (Height - Height % 10) / 2 ; i += 10)
        for (int j = 0; j < RowSize - RowSize % 10; j += 20) {
            for (int i_mod_1 = 0; i_mod_1 < 10; i_mod_1++)
                for (int j_mod_1 = 0; j_mod_1 < 10; j_mod_1++) {
                    pattern_1[i_mod_1][j_mod_1] = pixels_crypted[i + i_mod_1][j + j_mod_1];
                    pattern_2[i_mod_1][j_mod_1] = pixels_crypted[Height - Height % 10 - 10 - i + i_mod_1][j + j_mod_1];
                }
                
            for (int i_mod_2 = 0; i_mod_2 < 10; i_mod_2++)  
                for (int j_mod_2 = 0; j_mod_2 < 10; j_mod_2++) {
                    pixels_crypted[i + i_mod_2][j + j_mod_2] = pattern_2[i_mod_2][j_mod_2];
                    pixels_crypted[Height - Height % 10 - 10 - i + i_mod_2][j + j_mod_2] = pattern_1[i_mod_2][j_mod_2];
                }
        }   
    
    for (int i = 0; i < Height - Height % 10 ; i += 20)
        for (int j = 0; j < (RowSize - RowSize % 10) / 2; j += 10) {
            for (int i_mod_1 = 0; i_mod_1 < 10; i_mod_1++)
                for (int j_mod_1 = 0; j_mod_1 < 10; j_mod_1++) {
                    pattern_1[i_mod_1][j_mod_1] = pixels_crypted[i + i_mod_1][j + j_mod_1];
                    pattern_2[i_mod_1][j_mod_1] = pixels_crypted[i + i_mod_1][RowSize - RowSize % 10 - 10 - j + j_mod_1];
                }
                
            for (int i_mod_2 = 0; i_mod_2 < 10; i_mod_2++)  
                for (int j_mod_2 = 0; j_mod_2 < 10; j_mod_2++) {
                    pixels_crypted[i + i_mod_2][j + j_mod_2] = pattern_2[i_mod_2][j_mod_2];
                    pixels_crypted[i + i_mod_2][RowSize - RowSize % 10 - 10 - j + j_mod_2] = pattern_1[i_mod_2][j_mod_2];
                }
        }   
        
    //Создаем файл out.bmp
    fstream out_create("out.bmp", ios::out); 
    out_create.close();
    fstream out("out.bmp", ios::in | ios::out | ios::binary); 
    
    //Начинается запись в файл out.bmp
     
    in.seekg(0, ios::beg);
    
    char ch;
    for (int i = 1; i <= bmpFileHeader.bfOffBits; i++) {
        in.read(&ch, 1);
        out.write(&ch, 1);
    }
    
    in.close();
    
    for (int i = 0; i < Height; i++) {
        out.write(pixels_crypted[i], RowSize); //Заполнение одного рядка
        for (int j = 1; j <= padding; j++)
            out.put(0); //Заполняем паддинг
    }
    
    out.close();
    
    return 0; 
}

        in.read( (char*)&bmpFileHeader, sizeof( bmpFileHeader ) ); //Считывание данных 
        in.read( (char*)&bmpInfoHeader, sizeof( bmpInfoHeader ) ); //в структуры

in.seekg(bmpFileHeader.bfOffBits, ios::beg); //Перескакиваем в начало массива пикселей