ForHosting KIT · Imágenes

Calculadora de píxeles de pantalla

Calcule los píxeles y la memoria gráfica de una resolución: 1920 por 1080 a 32 bits por píxel son 2.073.600 píxeles, unos 2,07 megapíxeles, y 8.294.400 bytes por fotograma. Los tamaños salen también en KiB, MiB, GiB y MB decimales. Gratis en su navegador.

Gratis
Funciona en su navegador
Sin registro
Sus datos no salen de su equipo

Ejecutar — gratis Cómo funciona y API

Úselo desde WebAPIEmailTelegramApp pronto

Ejemplo resuelto

Si escribe

Ancho: 1 920
Altura: 1 080
Profundidad de color: 32

Obtiene

Resolución: 1920×1080 @ 32 bpp
Píxeles totales: 2 073 600
Megapíxeles: 2,0736
Bytes por píxel: 4

La planificación de memoria gráfica empieza con tres cifras: cuán ancha es la pantalla en píxeles, cuán alta es y cuántos bits almacena cada píxel. Multiplique el ancho por el alto y obtendrá el recuento bruto de píxeles; divídalo entre un millón para la cifra comercial de megapíxeles; multiplique por bits por píxel y divida entre ocho para el tamaño del framebuffer en bytes. Motores de juego, equipos de UI embebida, diseñadores de kioscos y flotas de renderizado en la nube necesitan la misma respuesta determinista al dimensionar VRAM, elegir un panel o comparar Full HD con 4K y 8K. Esta calculadora de píxeles de resolución de pantalla acepta ancho, alto y profundidad de color, y devuelve total de píxeles, megapíxeles, bytes por píxel y tamaños de framebuffer en bytes, kibibytes, mebibytes, gibibytes y megabytes decimales, más una etiqueta compacta de resolución. Cuando la profundidad de color es un entero entre uno y cuarenta y ocho, también indica cuántos colores distintos puede direccionar esa profundidad.

Cómo se relacionan píxeles totales, megapíxeles y memoria de framebuffer

Una pantalla digital es una cuadrícula rectangular de muestras direccionables. El ancho es el número de columnas; el alto, el de filas; su producto es el recuento total de píxeles de un fotograma completo. El marketing del sector suele citar ese producto en megapíxeles dividiendo entre un millón, de modo que un panel 1920 por 1080 ronda 2.07 megapíxeles y un panel UHD 3840 por 2160 ronda 8.29 megapíxeles.

La profundidad de color, en bits por píxel (bpp), indica cuánta información lleva cada muestra: ocho bpp es habitual en datos indexados o de un solo canal, dieciséis bpp en high-color o buffers de profundidad, veinticuatro bpp en RGB888 empaquetado y treinta y dos bpp en RGBA8888 con alfa. La memoria del framebuffer en bytes es el total de píxeles por bits por píxel dividido entre ocho, porque ocho bits forman un byte.

A partir de ese total en bytes puede informar kibibytes (divida entre 1024), mebibytes (entre 1024 al cuadrado), gibibytes (entre 1024 al cubo) o megabytes decimales (entre un millón), según hable con tablas de páginas del kernel, hojas de datos de GPU o textos de producto. Esta calculadora deriva siempre todos los campos de tamaño de las mismas tres entradas, para que no mezcle una cifra comercial de megapíxeles con un bpp incorrecto al estimar VRAM para UI con doble buffer o varias capas.

El campo opcional colors es dos elevado a la profundidad entera cuando el exponente es seguro, lo que coincide con la tabla clásica de «cuántos colores ofrece este modo» sin reclamar más precisión de la que permite el entero de profundidad.

Cuándo sirve calcular píxeles y memoria

Planificadores de displays y señalización digital convierten las hojas de datos del panel en megapíxeles y presupuestos de RAM para reproductores que deben mantener uno o más buffers de fotograma completo residentes. Flotas de renderizado en la nube y escritorio remoto estiman el coste de framebuffer por sesión al asignar rebanadas de GPU o fotogramas por software en CPU.

Quienes enseñan gráficos por computador pueden mostrar que «4K es cuatro veces Full HD» en píxeles y que treinta y dos bpp son cuatro bytes por píxel sin errores de aritmética manual. La validación fallida no consume saldo. Mantenga las peticiones pequeñas, fije en pruebas los campos numéricos limpios y obtendrá dimensionado reproducible para BOM de hardware, planificadores de capacidad y demos de aula sin montar su propia pila gráfica.

Qué puede hacer con ella

Presupuesto de GPU y VRAM

Estime los bytes de framebuffer de una sola capa para una resolución y bpp objetivo antes de elegir una GPU o SoC con memoria gráfica suficiente para UI con doble buffer.

Planificación de displays y señalización

Convierta el ancho × alto del panel y el formato de píxel en megapíxeles y necesidades de RAM para reproductores, kioscos y muros de vídeo multipantalla.

Clase de gráficos y documentación

Muestre a estudiantes y lectores de documentación el total de píxeles, megapíxeles y bytes por fotograma en modos habituales (HD, FHD, 4K) con un oráculo determinista.

Preguntas frecuentes

¿Cómo calculo el total de píxeles y los megapíxeles a partir de la resolución?

Ejemplo: 1920×1080 → 2,073,600 píxeles ≈ 2.0736 MP.

¿Incluye esto el doble buffer o varias capas?

No. El resultado dimensiona un solo almacén de fotograma completo.

¿Cuánta memoria ocupa un fotograma de 1920 por 1080?

A 32 bits por píxel ocupa 8.294.400 bytes, unos 7,91 MiB u 8,29 megabytes decimales. La regla es el total de píxeles por los bits por píxel, dividido entre los ocho bits de cada byte.

¿Por qué no coinciden MiB y MB?

Un mebibyte divide los bytes entre 1024 dos veces, mientras que un megabyte decimal los divide entre un millón. Las tablas de páginas del núcleo y las hojas técnicas de GPU suelen usar el primero y los textos comerciales el segundo, así que se dan ambos.

¿Cuántos colores permite una profundidad de color?

Dos elevado a la profundidad de color, que se indica cuando es un número entero entre 1 y 48. Con 32 bits hay 4.294.967.296 valores posibles, y 24 bits es el RGB empaquetado habitual.

Herramientas relacionadas

Para desarrolladores — acceso por API

Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.

Endpoint de API

POSThttps://api.kit.forhosting.com/dev/screen-pixels

¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.

Llámela desde su stack

curl -X POST https://api.kit.forhosting.com/dev/screen-pixels \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"width":1920,"height":1080,"color_depth":32}'

const res = await fetch("https://api.kit.forhosting.com/dev/screen-pixels", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "width": 1920,
    "height": 1080,
    "color_depth": 32
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/screen-pixels",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "width": 1920,
    "height": 1080,
    "color_depth": 32
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/screen-pixels", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"width":1920,"height":1080,"color_depth":32}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"width":1920,"height":1080,"color_depth":32}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/screen-pixels", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Ejemplo de solicitud

{
  "width": 1920,
  "height": 1080,
  "color_depth": 32
}

Ejemplo de respuesta

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.screen_pixels",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.

Precio

Por solicitud$0.002

Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.

Errores

HTTP	Código	Significado
`401`	`unauthorized`	API key ausente o inválida.
`402`	`insufficient_balance`	El saldo no cubre el precio de la tarea.
`404`	`unknown_type`	El tipo de tarea no existe.
`429`	`rate_limited`	Demasiadas peticiones. Use el webhook en vez de sondear.

Notas técnicas

La ruta gratuita del navegador y la API de pago comparten el mismo módulo puro, de modo que demos educativas y scripts de producción nunca discrepan en una cifra 1920×1080 a treinta y dos bits.

Contrato de entrada, forma de la respuesta y reglas de validación

Dimensiones irrealmente enormes por encima de mil millones de píxeles por lado o profundidades por encima de ciento veintiocho bpp se rechazan para que un error tipográfico no fuerce productos flotantes absurdos. Envíe por POST un cuerpo JSON con tres números finitos positivos obligatorios: width (píxeles de ancho), height (píxeles de alto) y color_depth (bits por píxel). Se aceptan alias para que los scripts puedan enviar w o width_px, h o height_px, y bpp, bits_per_pixel, bit_depth o depth para la profundidad de color. Campos ausentes, cadenas vacías, NaN, Infinity, cero y valores negativos fallan con invalid_input nombrando el campo; esos fallos no se facturan. En éxito el cuerpo devuelve el width, height y color_depth limpios; una cadena de resolución como 1920×1080 @ 32 bpp; total_pixels; megapixels; bytes_per_pixel; framebuffer_bits; framebuffer_bytes; framebuffer_kib; framebuffer_mib; framebuffer_gib; framebuffer_mb; y una fórmula breve que reescribe las identidades. Cuando color_depth es un entero de uno a cuarenta y ocho, se incluye colors como dos elevado a esa potencia; en profundidades fraccionarias o fuera de rango ese campo se omite en lugar de devolver null. Ejemplo: width 1920, height 1080, color_depth 32 produce total_pixels 2073600, megapixels 2.0736, bytes_per_pixel 4 y framebuffer_bytes 8294400 (unos 7.91 MiB por una capa). Combine las cifras con su propio multiplicador de varios buffers si usa doble buffer o texturas offscreen; este endpoint dimensiona solo un almacén de fotograma completo.

Dónde aporta valor una API de píxeles de pantalla y framebuffer

Equipos embebidos y de juegos dimensionan la memoria de GPU y de sistema antes de fijar resolución y formato de píxel, y una API diminuta y determinista evita el desvío de hojas de cálculo al comparar 720p a dieciséis bits con 1080p a treinta y dos bits y tuberías 4K a diez bits. Como la implementación es parse puro de nivel A, cada llamada correcta cuesta el precio base publicado $0.002, sin tokens de modelo ni red saliente.

Preguntas técnicas

¿Cómo se calcula la memoria del framebuffer?

framebuffer_bytes = total_pixels × color_depth / 8, porque color_depth son bits por píxel. La API también devuelve KiB, MiB, GiB (binarios) y MB decimal para hojas de planificación.

¿Qué valores de color_depth (bpp) debo usar?

Valores habituales son 8, 16, 24 y 32 bpp. Use los bits por píxel de su formato (por ejemplo RGBA8888 es 32). La profundidad debe ser un número finito positivo hasta 128.

¿Cuánto cuesta la calculadora de píxeles de resolución de pantalla?

La herramienta en el navegador es gratuita. Las peticiones API usan saldo prepago KIT a $0.002 por llamada correcta; la entrada inválida no se factura.

Ver la documentación completa del KIT →

Ejecutar — gratis