How can I get the number bytes to write per row for FrameBuffer?

Question

Goal: I'm writing a very simple image viewer for framebuffer /dev/fb0 (something like fbi).

Current state:

1. My software takes the pixel resolution from /sys/class/graphics/fb0/virtual_size (such as 1920,1080).
2. And then (for each row) it will write 4 bytes (BGRA) for each 1920 row-pixels (total 4x1920=7680 bytes) to /dev/fb0. This works perfectly fine on my one laptop with a 1920x1080 resolution.
3. More precisely: setting a pixel at y-row x-col => arr[y * 1920 * 4 + x * 4 + channel] where the value channel is 0,1,2,3 (for B, G, R, and A, respectively).

Problem:

When I try the same software on my old laptop with (/sys/.../virtual_size -> 1366,768 resolution), the image is not shown correctly (bit skewed). So I played around the pixel-width value and found out the value was 1376 (not 1366).

Questions:

1. Where do these 10 extra bytes come from?
2. And, how can I get this value of 10 extra bytes on different machines (automatically, not manually tuning it)?
3. Why do some machines need these extra 10 bytes, when some machines don't need them?

Answer 1

Programmatically, to retrieve information about a framebuffer you should use the FBIOGET_FSCREENINFO and FBIOGET_VSCREENINFO ioctls:

#include <fcntl.h>
#include <linux/fb.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>

int main(int argc, char **argv) {
  struct fb_fix_screeninfo fix;
  struct fb_var_screeninfo var;

  int fb = open("/dev/fb0", O_RDWR);
  if (fb < 0) {
    perror("Opening fb0");
    exit(1);
  }

  if (ioctl(fb, FBIOGET_FSCREENINFO, &fix) != 0) {
    perror("FSCREENINFO");
    exit(1);
  }

  if (ioctl(fb, FBIOGET_VSCREENINFO, &var) != 0) {
    perror("VSCREENINFO");
    exit(1);
  }

  printf("Line length: %ld\n", fix.line_length);
  printf("Visible resolution: %ldx%ld\n", var.xres, var.yres);
  printf("Virtual resolution: %ldx%ld\n", var.xres_virtual, var.yres_virtual);
}

line_length gives you the line stride.

Answer 2

The row stride does not have to be the same as the width; on your 1920-wide screen your software just worked "by accident" (not much of an accident, strides are typically chosen for hardware alignment requirements, and 1920 is already divisible by 16, which is a common alignment requirement).

Not being familiar with the good ole Linux framebuffer infrastructure, I can't directly tell you how to do it, but you will need to figure out the stride.

Either Linux just documents that rows are aligned by multiples of 16, do that you always need to round up your width to the next multiple of that, or /sys/class/graphics/fb0/ contains a different virtual file that defined the stride, or the row alignment.