No. Ifar.
Veamos, esto es lo primero que has de entender. El getline que estas usando no es leer lineas que entendamos nosotros, en modo plano. No es lineas hasta salto de linea o fin de archivo, como seria el getline de c# o java o php.
El getline que estas usando se basa en que el final delimitador de la linea es por defecto el \0 o el caracter que hayas puesto.
Estas con c++... eso significa que las apis más básicas están a un nivel muy básico. Casi a lenguaje máquina.
Leer cadenas de un archivo es algo muy fácil. Lo primero que se necesitan son las estructuras de datos (te copio un ejemplo de internet, mediante bmp, simplifica el ejemplo)
Esto es el header. La cabecera de la imagen. Muchos archivos tienen mas o menos la misma estructura en los ficheros y comprobando ciertos puntos aquí es fácil saber si es un BMP o no
Código:
#pragma pack(push, 1)
typedef struct tagBITMAPFILEHEADER
{
    WORD bfType;  //specifies the file type
    DWORD bfSize;  //specifies the size in bytes of the bitmap file
    WORD bfReserved1;  //reserved; must be 0
    WORD bfReserved2;  //reserved; must be 0
    DWORD bOffBits;  //species the offset in bytes from the bitmapfileheader to the bitmap bits
}BITMAPFILEHEADER;
#pragma pack(pop)
Esto es el header del bmp. Ancho, alto, colores, etc.
Código:
#pragma pack(push, 1)
typedef struct tagBITMAPINFOHEADER
{
    DWORD biSize;  //specifies the number of bytes required by the struct
    LONG biWidth;  //specifies width in pixels
    LONG biHeight;  //species height in pixels
    WORD biPlanes; //specifies the number of color planes, must be 1
    WORD biBitCount; //specifies the number of bit per pixel
    DWORD biCompression;//spcifies the type of compression
    DWORD biSizeImage;  //size of image in bytes
    LONG biXPelsPerMeter;  //number of pixels per meter in x axis
    LONG biYPelsPerMeter;  //number of pixels per meter in y axis
    DWORD biClrUsed;  //number of colors used by th ebitmap
    DWORD biClrImportant;  //number of colors that are important
}BITMAPINFOHEADER;
#pragma pack(pop)
El código para pillar el fichero.
Pasos
1. Leer header
2. Verificar header. Si no es un bmp... fin
3. Leer header BMP
4. Ir a la posicion de datos iniciales del BMP, en el fichero
5. Conseguirse memoria dinámica para trabajar
6. Conseguirse los datos (en este caso todos... cosa que es algo bestia, pero en un BMP esos datos son exactamente la imagen, siempre que sea una imagen de 24 bits sin compresión, como sobreentiende el ejemplo que he copiado
7. Hacer trabajo extra para conseguir el resultado necesario. en este caso girar unos bytes para tener un formato compatible en pantallas.
Código:
unsigned char *LoadBitmapFile(char *filename, BITMAPINFOHEADER *bitmapInfoHeader)
{
    FILE *filePtr; //our file pointer
    BITMAPFILEHEADER bitmapFileHeader; //our bitmap file header
    unsigned char *bitmapImage;  //store image data
    int imageIdx=0;  //image index counter
    unsigned char tempRGB;  //our swap variable
    //open filename in read binary mode
    filePtr = fopen(filename,"rb");
    if (filePtr == NULL)
        return NULL;
    //read the bitmap file header
    fread(&bitmapFileHeader, sizeof(BITMAPFILEHEADER,1,filePtr);
    //verify that this is a bmp file by check bitmap id
    if (bitmapFileHeader.bfType !=0x4D42)
    {
        fclose(filePtr);
        return NULL;
    }
    //read the bitmap info header
    fread(bitmapInfoHeader, sizeof(BITMAPINFOHEADER),1,filePtr);
    //move file point to the begging of bitmap data
    fseek(filePtr, bitmapFileHeader.bfOffBits, SEEK_SET);
    //allocate enough memory for the bitmap image data
    bitmapImage = (unsigned char*)malloc(bitmapInfoHeader->biSizeImage);
    //verify memory allocation
    if (!bitmapImage)
    {
        free(bitmapImage);
        fclose(filePtr);
        return NULL;
    }
    //read in the bitmap image data
    fread(bitmapImage,bitmapInfoHeader->biSizeImage,filePtr);
    //make sure bitmap image data was read
    if (bitmapImage == NULL)
    {
        fclose(filePtr);
        return NULL;
    }
    //swap the r and b values to get RGB (bitmap is BGR)
    for (imageIdx = 0,imageIdx < bitmapInfoHeader->biSizeImage;imageIdx+=3)
    {
        tempRGB = bitmapImage[imageIdx];
        bitmapImage[imageIdx] = bitmapImage[imageIdx + 2];
        bitmapImage[imageIdx + 2] = tempRGB;
    }
    //close file and return bitmap iamge data
    fclose(filePtr);
    return bitmapImage;
}
Total, la base de leer datos de un fichero es muy fácil. Solo necesitas la documentación de la estructura en cuestión, y hacer el struct correcto...
Pero también necesitas controlar la memoria y hacer un buen uso de ella. El ejemplo puesto es muy bestia, en la mayoria de casos (por ejemplo, no cargaras un video completo en memoria, y la estructura de datos de un video puede ser mucho más compleja)
En fin, me he explicado fatal...
Pero el dia que te toque reorganizar la estructura de un video porque el programa que codifica los videos hace el trabajo a un nivel extremadamente básico y pobre, me lo agradecerás
![[Imagen: ifar.png]](https://card.psnprofiles.com/2/ifar.png)
