Ken Burns: la foto quieta que respira

Una capa de imagen puede acercarse o alejarse por DENTRO de su huella a
lo largo de su ventana: la capa no cambia de tamaño, respira su
contenido con el recorte centrado. Es el plano de archivo de toda la
vida, y el que pedía la tanda A de la nota de diseño.

Va con zoompan y no con keyframes de escala, y no es capricho: las
expresiones de `scale` están congeladas en el ffmpeg de hoy, y zoompan
es lo único que anima un tamaño de verdad. Como `s=` solo acepta
números, editar.py aprende a medir imágenes (`tamano_imagen`: PNG y
JPEG por cabecera, ffprobe de respaldo); una imagen que no se puede
medir se queda quieta en vez de tumbar el render. La imagen se escala
de más antes de recortar, que recortar de una imagen justa es inventar
píxeles, y el movimiento suave de la capa también suaviza el zoom.

La previa hace el mismo zoom con su marco recortado, y la ficha lo
ofrece en tres chips: Nada, Acercar, Alejar.

Verificado con render real sobre un patrón de tablero —el contenido
sale 1,6 veces más grande al final, huella intacta— y con la barra
viva: los chips leen y escriben el plan. 98 pruebas.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: k4ditano

plugins/Captura/CapasLienzo.qml

@@ -184,6 +184,23 @@ Item {
                 + (modelData.salida && modelData.salida.tipo === "deslizar"
                     ? 0.08 * (1 - rampaEfecto(modelData.salida, false)) : 0)
 
+            //  El Ken Burns de la previa: el mismo zoom por dentro que hace
+            //  zoompan en el render, con su recorte centrado y su misma
+            //  rampa. La capa no cambia de tamaño; respira su contenido.
+            readonly property real zoomKenburns: {
+                const kb = modelData.kenburns
+                if (!kb)
+                    return 1
+                const z0 = Math.max(1, Math.min(3, Number(kb.desde) || 1))
+                const z1 = Math.max(1, Math.min(3, Number(kb.hasta) || 1))
+                let u = (lienzo.segundos - modelData.t0)
+                    / Math.max(0.05, modelData.t1 - modelData.t0)
+                u = Math.max(0, Math.min(1, u))
+                if (modelData.suave)
+                    u = u * u * (3 - 2 * u)
+                return z0 + (z1 - z0) * u
+            }
+
             readonly property bool esTexto: modelData.tipo === "texto"
             readonly property bool esPip: modelData.tipo === "video"
             readonly property bool esZona: modelData.tipo === "zona"
@@ -419,18 +436,27 @@ Item {
                 }
             }
 
-            Image {
-                id: imagen
+            //  Con marco recortado: el zoom del Ken Burns agranda la imagen
+            //  por dentro y lo que se sale por los bordes no se ve, igual
+            //  que hace zoompan con su ventana.
+            Item {
                 anchors.fill: parent
+                clip: true
                 visible: !capa.esTexto && !capa.esPip && !capa.esZona
-                source: !capa.esTexto && !capa.esPip && capa.modelData.ruta
-                    ? "file://" + capa.modelData.ruta : ""
-                fillMode: Image.Stretch
-                // El PNG llega a menudo mucho más grande que el hueco; sin esto
-                // se guarda en memoria a tamaño completo por cada capa.
-                sourceSize.width: Math.max(64, width)
-                smooth: true
-                asynchronous: true
+
+                Image {
+                    id: imagen
+                    anchors.fill: parent
+                    scale: capa.zoomKenburns
+                    source: !capa.esTexto && !capa.esPip && capa.modelData.ruta
+                        ? "file://" + capa.modelData.ruta : ""
+                    fillMode: Image.Stretch
+                    // El PNG llega a menudo mucho más grande que el hueco; sin esto
+                    // se guarda en memoria a tamaño completo por cada capa.
+                    sourceSize.width: Math.max(64, width)
+                    smooth: true
+                    asynchronous: true
+                }
             }
 
             // ── el rótulo ─────────────────────────────────────────

plugins/Captura/FichaCapa.qml

@@ -346,6 +346,70 @@ ColumnLayout {
         }
     }
 
+    //  El Ken Burns: la foto quieta que respira. Zoom por dentro de la
+    //  huella —la capa no cambia de tamaño— a lo largo de su ventana.
+    IslandLabel {
+        visible: Editor.capaSel && Editor.capaSel.tipo === "imagen"
+        text: Idioma.t("Ken Burns")
+        color: Theme.dim
+        font.pixelSize: 9
+        font.capitalization: Font.AllUppercase
+        font.weight: Font.DemiBold
+    }
+
+    RowLayout {
+        visible: Editor.capaSel && Editor.capaSel.tipo === "imagen"
+        Layout.fillWidth: true
+        spacing: 3
+
+        Repeater {
+            model: [
+                { id: "",        nombre: Idioma.t("Nada") },
+                { id: "acercar", nombre: Idioma.t("Acercar") },
+                { id: "alejar",  nombre: Idioma.t("Alejar") }
+            ]
+
+            delegate: Rectangle {
+                id: chipKb
+                required property var modelData
+
+                readonly property var kb: Editor.capaSel
+                    ? Editor.capaSel.kenburns : null
+                readonly property string puestoId: !kb ? ""
+                    : (Number(kb.hasta) > Number(kb.desde) ? "acercar"
+                                                           : "alejar")
+                readonly property bool puesta: puestoId === chipKb.modelData.id
+
+                Layout.fillWidth: true
+                Layout.preferredHeight: 24
+                radius: 12
+                color: chipKb.puesta ? Theme.blue
+                     : kbRaton.containsMouse ? Theme.surfaceHi : Theme.surface
+
+                IslandLabel {
+                    anchors.centerIn: parent
+                    text: chipKb.modelData.nombre
+                    color: chipKb.puesta ? "#ffffff" : Theme.muted
+                    font.pixelSize: 10
+                    font.weight: chipKb.puesta ? Font.DemiBold : Font.Normal
+                }
+
+                MouseArea {
+                    id: kbRaton
+                    anchors.fill: parent
+                    hoverEnabled: true
+                    cursorShape: Qt.PointingHandCursor
+                    onClicked: Editor.fijarCapa(Editor.idSel, {
+                        kenburns: chipKb.modelData.id === "" ? null
+                            : chipKb.modelData.id === "acercar"
+                            ? { desde: 1.0, hasta: 1.25 }
+                            : { desde: 1.25, hasta: 1.0 }
+                    })
+                }
+            }
+        }
+    }
+
     // Inspector numérico: permite repetir posiciones y
     // tamaños con precisión, sin depender del ratón.
     GridLayout {

tools/editar.py

@@ -736,9 +736,10 @@ def efecto_de(capa, cual):
 
 
 def capa_animada(capa):
-    """Si los filtros de la capa dependen del tiempo: claves o efectos."""
+    """Si los filtros de la capa dependen del tiempo: claves, efectos o
+    Ken Burns."""
     return bool(capa.get("keyframes")) or bool(efecto_de(capa, "entrada")) \
-        or bool(efecto_de(capa, "salida"))
+        or bool(efecto_de(capa, "salida")) or bool(kenburns_de(capa))
 
 
 #  Cuánto empuja «deslizar», en fracción del alto del fotograma.
@@ -773,6 +774,66 @@ def efectos_video(capa):
     return fades, dys
 
 
+def tamano_imagen(ruta):
+    """(ancho, alto) leídos de la cabecera del fichero, o None.
+
+    PNG y JPEG a mano —es leer unos bytes— y ffprobe de respaldo para lo
+    demás. Hace falta para el Ken Burns: `zoompan` exige el tamaño de salida
+    en números de verdad, no en expresiones.
+    """
+    try:
+        with open(ruta, "rb") as f:
+            cab = f.read(24)
+            if cab[:8] == b"\x89PNG\r\n\x1a\n" and len(cab) >= 24:
+                return (int.from_bytes(cab[16:20], "big"),
+                        int.from_bytes(cab[20:24], "big"))
+            if cab[:2] == b"\xff\xd8":
+                #  JPEG: saltar de marca en marca hasta el SOF, que es quien
+                #  lleva el tamaño. C4, C8 y CC parecen SOF y no lo son.
+                f.seek(2)
+                while True:
+                    marca = f.read(4)
+                    if len(marca) < 4 or marca[0] != 0xFF:
+                        break
+                    tipo = marca[1]
+                    largo = int.from_bytes(marca[2:4], "big")
+                    if 0xC0 <= tipo <= 0xCF and tipo not in (0xC4, 0xC8, 0xCC):
+                        datos = f.read(5)
+                        if len(datos) < 5:
+                            break
+                        return (int.from_bytes(datos[3:5], "big"),
+                                int.from_bytes(datos[1:3], "big"))
+                    f.seek(largo - 2, 1)
+    except OSError:
+        return None
+    p = subprocess.run(
+        ["ffprobe", "-v", "error", "-select_streams", "v:0",
+         "-show_entries", "stream=width,height", "-of", "csv=p=0", ruta],
+        capture_output=True, text=True)
+    partes = p.stdout.strip().split(",")
+    if len(partes) == 2 and partes[0].isdigit() and partes[1].isdigit():
+        return (int(partes[0]), int(partes[1]))
+    return None
+
+
+def kenburns_de(capa):
+    """El Ken Burns de una capa de imagen, normalizado, o None.
+
+    {desde, hasta}: cuánto zoom al empezar y al acabar su ventana, por DENTRO
+    de la huella —la capa no cambia de tamaño, respira el contenido—. Acotado
+    a 1..3: por debajo de 1 zoompan no sabe alejarse y por encima de 3 una
+    foto normal ya es papilla.
+    """
+    kb = capa.get("kenburns") or {}
+    if capa.get("tipo") != "imagen":
+        return None
+    z0 = encaja(float(kb.get("desde", 1.0) or 1.0), 1.0, 3.0)
+    z1 = encaja(float(kb.get("hasta", 1.0) or 1.0), 1.0, 3.0)
+    if abs(z1 - z0) < 0.01:
+        return None
+    return {"desde": z0, "hasta": z1}
+
+
 def alfa_texto(capa):
     """La expresión de alfa de un rótulo con efectos, o None.
 
@@ -978,7 +1039,31 @@ def rama_capa(n, idx, capa, ancho, alto, entra):
                            expresion_animada(capa, "rotacion", rotacion))
         else:
             filtros.append("rotate=%.6f*PI/180:fillcolor=none" % rotacion)
-    if capa.get("keyframes"):
+    #  El Ken Burns: zoom por DENTRO de la huella, con zoompan, que es el
+    #  único camino que de verdad anima un tamaño —las expresiones de `scale`
+    #  están congeladas, ver arriba—. La capa no cambia de medida: se acerca
+    #  su contenido, con el recorte centrado. Exige saber cuánto mide la
+    #  imagen, porque `s=` solo acepta números; si no se puede medir, la capa
+    #  se queda quieta y ya.
+    kb = kenburns_de(capa)
+    dim = tamano_imagen(capa.get("ruta", "")) if kb else None
+    if kb and dim:
+        iw, ih = dim
+        hf = max(2, int(round(ancho_capa * ih / max(1, iw))))
+        zmax = max(kb["desde"], kb["hasta"])
+        t0, t1 = float(capa.get("t0", 0.0)), float(capa.get("t1", 0.0))
+        progreso = "clip((it-%.4f)/%.4f,0,1)" % (t0, max(0.05, t1 - t0))
+        if capa.get("suave"):
+            progreso = "%s*%s*(3-2*%s)" % (progreso, progreso, progreso)
+        #  Se escala ANTES a lo que pide el zoom máximo: zoompan recorta de su
+        #  entrada, y recortar de una imagen justa es inventar píxeles.
+        filtros.append("scale=%d:-1" % int(round(ancho_capa * zmax + 2)))
+        filtros.append(
+            "zoompan=z='%.4f+%.4f*%s':x='iw/2-iw/zoom/2':"
+            "y='ih/2-ih/zoom/2':d=1:s=%dx%d:fps=25"
+            % (kb["desde"], kb["hasta"] - kb["desde"], progreso,
+               ancho_capa, hf))
+    elif capa.get("keyframes"):
         filtros.append("scale=w='round(%d*%s)':h=-1:eval=frame" % (ancho, escala_expr))
     else:
         filtros.append("scale=%d:-1" % ancho_capa)

tools/prueba_editar.py

@@ -1169,6 +1169,64 @@ def prueba_efecto_no_toca_una_capa_quieta():
     igual("la escala sigue siendo un número", "scale=480:-1" in texto, True)
 
 
+def png_de_prueba(nombre, ancho, alto):
+    """Un PNG mínimo de verdad, para lo que necesita leer cabeceras."""
+    import struct, zlib
+    def bloque(tipo, datos):
+        return (struct.pack(">I", len(datos)) + tipo + datos
+                + struct.pack(">I", zlib.crc32(tipo + datos)))
+    ihdr = struct.pack(">IIBBBBB", ancho, alto, 8, 2, 0, 0, 0)
+    idat = zlib.compress((b"\x00" + b"\x7f\x7f\x7f" * ancho) * alto)
+    ruta = os.path.join(BORRADOR, nombre)
+    with open(ruta, "wb") as f:
+        f.write(b"\x89PNG\r\n\x1a\n" + bloque(b"IHDR", ihdr)
+                + bloque(b"IDAT", idat) + bloque(b"IEND", b""))
+    return ruta
+
+
+def prueba_tamano_imagen():
+    ruta = png_de_prueba("medible.png", 200, 100)
+    igual("el PNG se mide por su cabecera",
+          editar.tamano_imagen(ruta), (200, 100))
+    igual("un fichero vacío no es una imagen",
+          editar.tamano_imagen(fichero("vacio.bin")), None)
+
+
+def prueba_kenburns_mete_zoompan():
+    """El zoom por dentro va con zoompan, que es lo único que anima un tamaño
+    de verdad; conserva la huella (s=an×al de la capa) y su rampa recorre la
+    ventana."""
+    ruta = png_de_prueba("kb.png", 200, 100)
+    texto, _ = editar.grafo(con_capas(
+        [capa(ruta=ruta, kenburns={"desde": 1.0, "hasta": 1.25})]))
+    igual("zoompan con la rampa de la ventana",
+          "zoompan=z='1.0000+0.2500*clip((it-2.0000)/2.0000,0,1)'" in texto,
+          True)
+    igual("la huella no cambia: 480×240 de un PNG 2:1",
+          "s=480x240" in texto, True)
+    igual("y se escala de más antes de recortar", "scale=602:-1" in texto, True)
+
+
+def prueba_kenburns_sin_tamano_se_queda_quieto():
+    """Una imagen que no se puede medir no puede respirar: capa quieta, y el
+    render sale igual que siempre en vez de caerse."""
+    texto, _ = editar.grafo(con_capas(
+        [capa(kenburns={"desde": 1.0, "hasta": 1.25})]))
+    #  Ojo: el zoompan de la CÁMARA siempre está; lo que no puede aparecer es
+    #  el del Ken Burns, que se reconoce por su rampa con `it`.
+    igual("sin tamaño no hay zoompan de capa", "*clip((it-" in texto, False)
+    igual("la escala de siempre", "scale=480:-1" in texto, True)
+
+
+def prueba_kenburns_suave_lleva_smoothstep():
+    ruta = png_de_prueba("kb2.png", 100, 100)
+    texto, _ = editar.grafo(con_capas(
+        [capa(ruta=ruta, suave=True,
+              kenburns={"desde": 1.25, "hasta": 1.0})]))
+    igual("la rampa del zoom también se suaviza",
+          "*(3-2*clip((it-2.0000)/2.0000,0,1))'" in texto, True)
+
+
 def prueba_keyframes_suaves():
     """`suave: true` mete la smoothstep u²(3−2u) en la expresión; sin él la
     recta de siempre, intacta."""