Graphics: Low LevelGPU ArchitectureEasy

Compute a Pixel's Framebuffer Index

Master the fundamental concepts of gpu architecture through this focused micro-challenge.

~30 minutes GPU Architecture Ready to learn

Topic Overview

The Framebuffer Is a 1D Array

Screens are 2D, but memory is 1D. A framebuffer stores pixels row after row in row-major order. The pixel at coordinates (x, y) on a surface of width W lives at linear index y * W + x. With 4 bytes per pixel in RGBA8 format, the first byte of that pixel sits at byte offset (y * W + x) * 4.

For example, on an 800x600 display, the pixel at (3, 2) has index 2 * 800 + 3 = 1603 and byte offset 6412.

Why Row-Major Order Matters

Every rasterizer plot, every texture sample, every CUDA image kernel, and every Linux framebuffer console driver computes this same expression. GPU memory coalescing, covered later in this subtrack, is entirely about warps of threads reading consecutive values produced by this formula. Column-major layouts exist in linear algebra libraries, but framebuffers almost always use row-major indexing because scanlines are natural horizontal strips.

Row-major index: index = y * width + x
RGBA8 byte offset: byte = index * 4
Bounds check: valid when 0 <= x < width and 0 <= y < height

For This Exercise

This task asks you to read x, y, and width from stdin and print the linear index and RGBA8 byte offset. You will use this arithmetic in every rasterizer task that follows, from Bresenham line drawing through z-buffering. Getting the multiply order wrong is one of the most common off-by-one bugs when porting rendering code between APIs.

Implementation Task

Your Task

A framebuffer is a 2D image stored as one flat array, row after row (row-major). Every pixel write a GPU or rasterizer performs starts with the same calculation: turn (x, y) into an array index, then into a byte offset. Compute both for an RGBA8 framebuffer, which uses 4 bytes per pixel.

Input

Four integers: x y width height.

Rules

Index: y × width + x. Byte offset: index × 4.
A pixel is inside the framebuffer when 0 ≤ x < width and 0 ≤ y < height.
Width and height must be at least 1.

Output

Two lines, index N and byte M. For a pixel outside the framebuffer, print (x, y) is outside the WxH framebuffer instead. For malformed input or a non-positive size, print invalid input.

Example

Input:

c
Loading…

Output:

c
Loading…

Requirements

Check the bounds before computing the offset. An unchecked write at (width, 0) lands on the next row's first pixel, a classic off-by-one bug.
Use long: a 4K framebuffer is 33 million bytes, and bigger ones overflow a 32-bit int quickly.

Hidden tests cover the last pixel of a 4K frame and a zero-sized framebuffer.