mulmocast 0.0.1 → 0.0.3

package/lib/actions/movie.js

@@ -1,51 +1,45 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import ffmpeg from "fluent-ffmpeg";
+import { GraphAILogger } from "graphai";
+import { MulmoScriptMethods } from "../methods/index.js";
+import { getAudioArtifactFilePath, getOutputVideoFilePath, writingMessage } from "../utils/file.js";
+const isMac = process.platform === "darwin";
+const videoCodec = isMac ? "h264_videotoolbox" : "libx264";
+export const getVideoPart = (inputIndex, mediaType, duration, canvasInfo) => {
+    const videoId = `v${inputIndex}`;
+    return {
+        videoId,
+        videoPart: `[${inputIndex}:v]` +
+            [
+                mediaType === "image" ? "loop=loop=-1:size=1:start=0" : "",
+                `trim=duration=${duration}`,
+                "fps=30",
+                "setpts=PTS-STARTPTS",
+                `scale=${canvasInfo.width}:${canvasInfo.height}`,
+                "setsar=1",
+                "format=yuv420p",
+            ]
+                .filter((a) => a)
+                .join(",") +
+            `[${videoId}]`,
+    };
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.movie = void 0;
-const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
-const methods_1 = require("../methods");
-const file_1 = require("../utils/file");
-const createVideo = (audioPath, outputVideoPath, studio) => {
-    const start = performance.now();
-    let command = (0, fluent_ffmpeg_1.default)();
-    if (studio.beats.some((beat) => !beat.imageFile)) {
-        console.error("beat.imageFile is not set. Please run `yarn run images ${file}` ");
-        return;
-    }
-    // Add each image input
-    studio.beats.forEach((beat) => {
-        command = command.input(beat.imageFile); // HACK
-    });
-    const imageCount = studio.beats.length;
-    const canvasInfo = methods_1.MulmoScriptMethods.getCanvasSize(studio.script);
-    const filterComplexParts = [];
-    studio.beats.forEach((beat, index) => {
-        // Resize background image to match canvas dimensions
-        const duration = beat.duration + (index === 0 ? methods_1.MulmoScriptMethods.getPadding(studio.script) / 1000 : 0);
-        const parts = `[${index}:v]loop=loop=-1:size=1:start=0,` +
-            `trim=duration=${duration},` +
-            `fps=30,` +
-            `setpts=PTS-STARTPTS,` +
-            `scale=${canvasInfo.width}:${canvasInfo.height},` +
-            `setsar=1,format=yuv420p` +
-            `[v${index}]`;
-        // console.log(parts);
-        filterComplexParts.push(parts);
-    });
-    // Concatenate the trimmed images
-    const concatInput = studio.beats.map((_, index) => `[v${index}]`).join("");
-    filterComplexParts.push(`${concatInput}concat=n=${imageCount}:v=1:a=0[v]`);
-    // Apply the filter complex for concatenation and map audio input
-    command
-        .complexFilter(filterComplexParts)
-        .input(audioPath) // Add audio input
-        .outputOptions([
+export const getAudioPart = (inputIndex, duration, delay) => {
+    const audioId = `a${inputIndex}`;
+    return {
+        audioId,
+        audioPart: `[${inputIndex}:a]` +
+            `atrim=duration=${duration},` + // Trim to beat duration
+            `adelay=${delay}|${delay},` +
+            `aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo` +
+            `[${audioId}]`,
+    };
+};
+const getOutputOption = (audioId) => {
+    return [
         "-preset veryfast", // Faster encoding
         "-map [v]", // Map the video stream
-        `-map ${imageCount /* + captionCount*/}:a`, // Map the audio stream (audio is the next input after all images)
-        "-c:v h264_videotoolbox", // Set video codec
+        `-map ${audioId}`, // Map the audio stream
+        `-c:v ${videoCodec}`, // Set video codec
         "-threads 8",
         "-filter_threads 8",
         "-b:v 5M", // bitrate (only for videotoolbox)
@@ -55,27 +49,92 @@ const createVideo = (audioPath, outputVideoPath, studio) => {
         "7M", // Maximum bitrate
         "-r 30", // Set frame rate
         "-pix_fmt yuv420p", // Set pixel format for better compatibility
-    ])
-        .on("start", (__cmdLine) => {
-        console.log("Started FFmpeg ..."); // with command:', cmdLine);
-    })
-        .on("error", (err, stdout, stderr) => {
-        console.error("Error occurred:", err);
-        console.error("FFmpeg stdout:", stdout);
-        console.error("FFmpeg stderr:", stderr);
-    })
-        .on("end", () => {
-        const end = performance.now();
-        console.log(`Video created successfully! ${Math.round(end - start) / 1000} sec`);
-    })
-        .output(outputVideoPath)
-        .run();
+    ];
+};
+const createVideo = (audioArtifactFilePath, outputVideoPath, studio) => {
+    return new Promise((resolve, reject) => {
+        const start = performance.now();
+        const ffmpegContext = {
+            command: ffmpeg(),
+            inputCount: 0,
+        };
+        function addInput(input) {
+            ffmpegContext.command = ffmpegContext.command.input(input);
+            ffmpegContext.inputCount++;
+            return ffmpegContext.inputCount - 1; // returned the index of the input
+        }
+        if (studio.beats.some((beat) => !beat.imageFile)) {
+            GraphAILogger.info("beat.imageFile is not set. Please run `yarn run images ${file}` ");
+            return;
+        }
+        const canvasInfo = MulmoScriptMethods.getCanvasSize(studio.script);
+        const padding = MulmoScriptMethods.getPadding(studio.script) / 1000;
+        // Add each image input
+        const filterComplexParts = [];
+        const filterComplexVideoIds = [];
+        const filterComplexAudioIds = [];
+        studio.beats.reduce((timestamp, beat, index) => {
+            if (!beat.imageFile || !beat.duration) {
+                throw new Error(`beat.imageFile is not set: index=${index}`);
+            }
+            const inputIndex = addInput(beat.imageFile);
+            const mediaType = MulmoScriptMethods.getImageType(studio.script, studio.script.beats[index]);
+            const headOrTail = index === 0 || index === studio.beats.length - 1;
+            const duration = beat.duration + (headOrTail ? padding : 0);
+            const { videoId, videoPart } = getVideoPart(inputIndex, mediaType, duration, canvasInfo);
+            filterComplexVideoIds.push(videoId);
+            filterComplexParts.push(videoPart);
+            if (mediaType === "movie") {
+                const { audioId, audioPart } = getAudioPart(inputIndex, duration, timestamp * 1000);
+                filterComplexAudioIds.push(audioId);
+                filterComplexParts.push(audioPart);
+            }
+            return timestamp + duration;
+        }, 0);
+        // console.log("*** images", images.audioIds);
+        // Concatenate the trimmed images
+        filterComplexParts.push(`${filterComplexVideoIds.map((id) => `[${id}]`).join("")}concat=n=${studio.beats.length}:v=1:a=0[v]`);
+        const audioIndex = addInput(audioArtifactFilePath); // Add audio input
+        const artifactAudioId = `${audioIndex}:a`;
+        const ffmpegContextAudioId = (() => {
+            if (filterComplexAudioIds.length > 0) {
+                const mainAudioId = "mainaudio";
+                const compositeAudioId = "composite";
+                const audioIds = filterComplexAudioIds.map((id) => `[${id}]`).join("");
+                filterComplexParts.push(`[${artifactAudioId}]aformat=sample_fmts=fltp:sample_rates=44100:channel_layouts=stereo[${mainAudioId}]`);
+                filterComplexParts.push(`[${mainAudioId}]${audioIds}amix=inputs=${filterComplexAudioIds.length + 1}:duration=first:dropout_transition=2[${compositeAudioId}]`);
+                return `[${compositeAudioId}]`; // notice that we need to use [mainaudio] instead of mainaudio
+            }
+            return artifactAudioId;
+        })();
+        // Apply the filter complex for concatenation and map audio input
+        ffmpegContext.command
+            .complexFilter(filterComplexParts)
+            .outputOptions(getOutputOption(ffmpegContextAudioId))
+            .on("start", (__cmdLine) => {
+            GraphAILogger.log("Started FFmpeg ..."); // with command:', cmdLine);
+        })
+            .on("error", (err, stdout, stderr) => {
+            GraphAILogger.error("Error occurred:", err);
+            GraphAILogger.error("FFmpeg stdout:", stdout);
+            GraphAILogger.error("FFmpeg stderr:", stderr);
+            GraphAILogger.info("Video creation failed. An unexpected error occurred.");
+            reject();
+        })
+            .on("end", () => {
+            const end = performance.now();
+            GraphAILogger.info(`Video created successfully! ${Math.round(end - start) / 1000} sec`);
+            resolve(0);
+        })
+            .output(outputVideoPath)
+            .run();
+    });
 };
-const movie = async (context) => {
+export const movie = async (context) => {
     const { studio, fileDirs } = context;
     const { outDirPath } = fileDirs;
-    const audioPath = (0, file_1.getOutputBGMFilePath)(outDirPath, studio.filename);
-    const outputVideoPath = (0, file_1.getOutputVideoFilePath)(outDirPath, studio.filename);
-    createVideo(audioPath, outputVideoPath, studio);
+    const audioArtifactFilePath = getAudioArtifactFilePath(outDirPath, studio.filename);
+    const outputVideoPath = getOutputVideoFilePath(outDirPath, studio.filename);
+    await createVideo(audioArtifactFilePath, outputVideoPath, studio);
+    writingMessage(outputVideoPath);
 };
-exports.movie = movie;

package/lib/actions/pdf.d.ts

@@ -0,0 +1,2 @@
+import { MulmoStudioContext, PDFMode, PDFSize } from "../types/index.js";
+export declare const pdf: (context: MulmoStudioContext, pdfMode: PDFMode, pdfSize: PDFSize) => Promise<void>;

package/lib/actions/pdf.js

@@ -0,0 +1,211 @@
+import fs from "fs";
+import path from "path";
+import { rgb, PDFDocument } from "pdf-lib";
+import fontkit from "@pdf-lib/fontkit";
+import { chunkArray, isHttp } from "../utils/utils.js";
+import { getOutputPdfFilePath, writingMessage } from "../utils/file.js";
+import { MulmoScriptMethods } from "../methods/index.js";
+import { fontSize, textMargin, drawSize, wrapText } from "../utils/pdf.js";
+const imagesPerPage = 4;
+const offset = 10;
+const handoutImageRatio = 0.5;
+const readImage = async (imagePath, pdfDoc) => {
+    const imageBytes = await (async () => {
+        if (isHttp(imagePath)) {
+            const res = await fetch(imagePath);
+            const arrayBuffer = await res.arrayBuffer();
+            return Buffer.from(arrayBuffer);
+        }
+        return fs.readFileSync(imagePath);
+    })();
+    const ext = path.extname(imagePath).toLowerCase();
+    return ext === ".jpg" || ext === ".jpeg" ? await pdfDoc.embedJpg(imageBytes) : await pdfDoc.embedPng(imageBytes);
+};
+const pdfSlide = async (pageWidth, pageHeight, imagePaths, pdfDoc) => {
+    const cellRatio = pageHeight / pageWidth;
+    for (const imagePath of imagePaths) {
+        const image = await readImage(imagePath, pdfDoc);
+        const { width: origWidth, height: origHeight } = image.scale(1);
+        const originalRatio = origHeight / origWidth;
+        const fitWidth = originalRatio / cellRatio < 1;
+        const { drawWidth, drawHeight } = drawSize(fitWidth, pageWidth, pageHeight, origWidth, origHeight);
+        const page = pdfDoc.addPage([pageWidth, pageHeight]);
+        page.drawImage(image, {
+            x: 0,
+            y: 0,
+            width: drawWidth,
+            height: drawHeight,
+        });
+    }
+};
+const pdfTalk = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc, font) => {
+    const imageRatio = 0.7;
+    const textMargin = 8;
+    const textY = pageHeight * (1 - imageRatio) - textMargin;
+    const targetWidth = pageWidth - offset;
+    const targetHeight = pageHeight * imageRatio - offset;
+    const cellRatio = targetHeight / targetWidth;
+    for (const [index, imagePath] of imagePaths.entries()) {
+        const text = texts[index];
+        const image = await readImage(imagePath, pdfDoc);
+        const { width: origWidth, height: origHeight } = image.scale(1);
+        const originalRatio = origHeight / origWidth;
+        const fitWidth = originalRatio / cellRatio < 1;
+        const { drawWidth, drawHeight } = drawSize(fitWidth, targetWidth, targetHeight, origWidth, origHeight);
+        const x = (pageWidth - drawWidth) / 2;
+        const y = pageHeight - drawHeight - offset;
+        const page = pdfDoc.addPage([pageWidth, pageHeight]);
+        const pos = {
+            x,
+            y,
+            width: drawWidth,
+            height: drawHeight,
+        };
+        page.drawImage(image, pos);
+        page.drawRectangle({
+            ...pos,
+            borderColor: rgb(0, 0, 0),
+            borderWidth: 1,
+        });
+        const lines = wrapText(text, font, fontSize, pageWidth - textMargin * 2);
+        for (const [index, line] of lines.entries()) {
+            page.drawText(line, {
+                x: textMargin,
+                y: textY - fontSize - (fontSize + 2) * index,
+                size: fontSize,
+                color: rgb(0, 0, 0),
+                maxWidth: pageWidth - 2 * textMargin,
+                font,
+            });
+        }
+    }
+};
+const pdfHandout = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc, font, isLandscapeImage) => {
+    const cellRatio = (pageHeight / imagesPerPage - offset) / (pageWidth * handoutImageRatio - offset);
+    let index = 0;
+    for (const chunkPaths of chunkArray(imagePaths, imagesPerPage)) {
+        const page = pdfDoc.addPage([pageWidth, pageHeight]);
+        for (let i = 0; i < chunkPaths.length; i++) {
+            const imagePath = chunkPaths[i];
+            const image = await readImage(imagePath, pdfDoc);
+            const { width: origWidth, height: origHeight } = image.scale(1);
+            const originalRatio = origHeight / origWidth;
+            const fitWidth = originalRatio / cellRatio < 1;
+            const pos = (() => {
+                if (isLandscapeImage) {
+                    const cellHeight = pageHeight / imagesPerPage - offset;
+                    const { drawWidth, drawHeight } = drawSize(fitWidth, (pageWidth - offset) * handoutImageRatio, cellHeight - offset, origWidth, origHeight);
+                    const x = offset;
+                    const y = pageHeight - (i + 1) * cellHeight + (cellHeight - drawHeight) * handoutImageRatio;
+                    return {
+                        x,
+                        y,
+                        width: drawWidth,
+                        height: drawHeight,
+                    };
+                }
+                else {
+                    const cellWidth = pageWidth / imagesPerPage;
+                    const { drawWidth, drawHeight } = drawSize(fitWidth, cellWidth - offset, (pageHeight - offset) * handoutImageRatio, origWidth, origHeight);
+                    const x = pageWidth - (imagesPerPage - i) * cellWidth + (cellWidth - drawWidth) * handoutImageRatio;
+                    const y = pageHeight - drawHeight - offset;
+                    return {
+                        x,
+                        y,
+                        width: drawWidth,
+                        height: drawHeight,
+                    };
+                }
+            })();
+            page.drawRectangle({
+                ...pos,
+                borderColor: rgb(0, 0, 0),
+                borderWidth: 1,
+            });
+            page.drawImage(image, pos);
+            if (isLandscapeImage) {
+                const lines = wrapText(texts[index], font, fontSize, pos.width - textMargin * 2);
+                for (const [index, line] of lines.entries()) {
+                    page.drawText(line, {
+                        ...pos,
+                        x: pos.x + pos.width + textMargin,
+                        y: pos.y + pos.height - fontSize - (fontSize + 2) * index,
+                        size: fontSize,
+                        font,
+                    });
+                }
+                /*
+                page.drawRectangle({
+                  ...pos,
+                  x: pos.x +  pos.width ,
+                  borderColor: rgb(0, 0, 0),
+                  borderWidth: 1,
+                  });
+                */
+            }
+            else {
+                const lines = wrapText(texts[index], font, fontSize, pos.width - textMargin * 2);
+                for (const [index, line] of lines.entries()) {
+                    page.drawText(line, {
+                        ...pos,
+                        x: pos.x,
+                        y: textMargin + pos.height - fontSize - (fontSize + textMargin) * index - 2 * textMargin,
+                        size: fontSize,
+                        font,
+                    });
+                }
+                /*
+                page.drawRectangle({
+                  ...pos,
+                  x: pos.x,
+                  y: textMargin,
+                  height: pos.height - 2 * textMargin,
+                  borderColor: rgb(0, 0, 0),
+                  borderWidth: 1,
+                });
+                */
+            }
+            index = index + 1;
+        }
+    }
+};
+const outputSize = (pdfSize, isLandscapeImage, isRotate) => {
+    if (pdfSize === "a4") {
+        if (isLandscapeImage !== isRotate) {
+            return { width: 841.89, height: 595.28 };
+        }
+        return { width: 595.28, height: 841.89 };
+    }
+    // letter
+    if (isLandscapeImage !== isRotate) {
+        return { width: 792, height: 612 };
+    }
+    return { width: 612, height: 792 };
+};
+export const pdf = async (context, pdfMode, pdfSize) => {
+    const { studio, fileDirs } = context;
+    const { outDirPath } = fileDirs;
+    const { width: imageWidth, height: imageHeight } = MulmoScriptMethods.getCanvasSize(studio.script);
+    const isLandscapeImage = imageWidth > imageHeight;
+    const isRotate = pdfMode === "handout";
+    const { width: pageWidth, height: pageHeight } = outputSize(pdfSize, isLandscapeImage, isRotate);
+    const imagePaths = studio.beats.map((beat) => beat.imageFile);
+    const texts = studio.script.beats.map((beat) => beat.text);
+    const outputPdfPath = getOutputPdfFilePath(outDirPath, studio.filename, pdfMode);
+    const pdfDoc = await PDFDocument.create();
+    pdfDoc.registerFontkit(fontkit);
+    const fontBytes = fs.readFileSync("assets/font/NotoSansJP-Regular.ttf");
+    const customFont = await pdfDoc.embedFont(fontBytes);
+    if (pdfMode === "handout") {
+        await pdfHandout(pageWidth, pageHeight, imagePaths, texts, pdfDoc, customFont, isLandscapeImage);
+    }
+    if (pdfMode === "slide") {
+        await pdfSlide(pageWidth, pageHeight, imagePaths, pdfDoc);
+    }
+    if (pdfMode === "talk") {
+        await pdfTalk(pageWidth, pageHeight, imagePaths, texts, pdfDoc, customFont);
+    }
+    const pdfBytes = await pdfDoc.save();
+    fs.writeFileSync(outputPdfPath, pdfBytes);
+    writingMessage(outputPdfPath);
+};

package/lib/actions/pdf2.d.ts

@@ -0,0 +1,2 @@
+import { MulmoStudioContext, PDFMode, PDFSize } from "../types/index.js";
+export declare const pdf: (context: MulmoStudioContext, pdfMode: PDFMode, pdfSize: PDFSize) => Promise<void>;

package/lib/actions/pdf2.js

@@ -0,0 +1,203 @@
+import fs from "fs";
+import path from "path";
+import { rgb, PDFDocument } from "pdf-lib";
+import { chunkArray, isHttp } from "../utils/utils.js";
+import { getOutputPdfFilePath, writingMessage } from "../utils/file.js";
+import { MulmoScriptMethods } from "../methods/index.js";
+const imagesPerPage = 4;
+const offset = 10;
+const handoutImageRatio = 0.5;
+const readImage = async (imagePath, pdfDoc) => {
+    const imageBytes = await (async () => {
+        if (isHttp(imagePath)) {
+            const res = await fetch(imagePath);
+            const arrayBuffer = await res.arrayBuffer();
+            return Buffer.from(arrayBuffer);
+        }
+        return fs.readFileSync(imagePath);
+    })();
+    const ext = path.extname(imagePath).toLowerCase();
+    return ext === ".jpg" || ext === ".jpeg" ? await pdfDoc.embedJpg(imageBytes) : await pdfDoc.embedPng(imageBytes);
+};
+const pdfSlide = async (pageWidth, pageHeight, imagePaths, pdfDoc) => {
+    const cellRatio = pageHeight / pageWidth;
+    for (const imagePath of imagePaths) {
+        const image = await readImage(imagePath, pdfDoc);
+        const { width: origWidth, height: origHeight } = image.scale(1);
+        const originalRatio = origHeight / origWidth;
+        const fitWidth = originalRatio / cellRatio < 1;
+        const { drawWidth, drawHeight } = drawSize(fitWidth, pageWidth, pageHeight, origWidth, origHeight);
+        const page = pdfDoc.addPage([pageWidth, pageHeight]);
+        page.drawImage(image, {
+            x: 0,
+            y: 0,
+            width: drawWidth,
+            height: drawHeight,
+        });
+    }
+};
+const pdfTalk = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc) => {
+    const imageRatio = 0.7;
+    const textMargin = 20;
+    const textY = textMargin + (pageHeight * (1 - imageRatio)) / 2;
+    const targetWidth = pageWidth - offset;
+    const targetHeight = pageHeight * imageRatio - offset;
+    const cellRatio = targetHeight / targetWidth;
+    for (const [index, imagePath] of imagePaths.entries()) {
+        const text = texts[index];
+        const image = await readImage(imagePath, pdfDoc);
+        const { width: origWidth, height: origHeight } = image.scale(1);
+        const originalRatio = origHeight / origWidth;
+        const fitWidth = originalRatio / cellRatio < 1;
+        const { drawWidth, drawHeight } = drawSize(fitWidth, targetWidth, targetHeight, origWidth, origHeight);
+        const x = (pageWidth - drawWidth) / 2;
+        const y = pageHeight - drawHeight - offset;
+        const page = pdfDoc.addPage([pageWidth, pageHeight]);
+        const pos = {
+            x,
+            y,
+            width: drawWidth,
+            height: drawHeight,
+        };
+        page.drawImage(image, pos);
+        page.drawRectangle({
+            ...pos,
+            borderColor: rgb(0, 0, 0),
+            borderWidth: 1,
+        });
+        page.drawText(text, {
+            x: textMargin,
+            y: textY,
+            size: 24,
+            color: rgb(0, 0, 0),
+            maxWidth: pageWidth - 2 * textMargin,
+        });
+    }
+};
+const drawSize = (fitWidth, expectWidth, expectHeight, origWidth, origHeight) => {
+    if (fitWidth) {
+        const drawWidth = expectWidth;
+        const scale = drawWidth / origWidth;
+        const drawHeight = origHeight * scale;
+        return {
+            drawWidth,
+            drawHeight,
+        };
+    }
+    const drawHeight = expectHeight;
+    const scale = drawHeight / origHeight;
+    const drawWidth = origWidth * scale;
+    return {
+        drawWidth,
+        drawHeight,
+    };
+};
+const pdfHandout = async (pageWidth, pageHeight, imagePaths, texts, pdfDoc, isLandscapeImage) => {
+    const cellRatio = (pageHeight / imagesPerPage - offset) / (pageWidth * handoutImageRatio - offset);
+    let i = 0;
+    for (const chunkPaths of chunkArray(imagePaths, imagesPerPage)) {
+        const page = pdfDoc.addPage([pageWidth, pageHeight]);
+        for (let i = 0; i < chunkPaths.length; i++) {
+            const imagePath = chunkPaths[i];
+            const image = await readImage(imagePath, pdfDoc);
+            const { width: origWidth, height: origHeight } = image.scale(1);
+            const originalRatio = origHeight / origWidth;
+            const fitWidth = originalRatio / cellRatio < 1;
+            // console.log({handoutImageRatio, cellRatio, ratio,  imageHeight, origHeight});
+            const pos = (() => {
+                if (isLandscapeImage) {
+                    const cellHeight = pageHeight / imagesPerPage - offset;
+                    const { drawWidth, drawHeight } = drawSize(fitWidth, (pageWidth - offset) * handoutImageRatio, cellHeight - offset, origWidth, origHeight);
+                    const x = offset;
+                    const y = pageHeight - (i + 1) * cellHeight + (cellHeight - drawHeight) * handoutImageRatio;
+                    return {
+                        x,
+                        y,
+                        width: drawWidth,
+                        height: drawHeight,
+                    };
+                }
+                else {
+                    const cellWidth = pageWidth / imagesPerPage;
+                    const { drawWidth, drawHeight } = drawSize(fitWidth, cellWidth - offset, (pageHeight - offset) * handoutImageRatio, origWidth, origHeight);
+                    const x = pageWidth - (imagesPerPage - i) * cellWidth + (cellWidth - drawWidth) * handoutImageRatio;
+                    const y = pageHeight - drawHeight - offset;
+                    return {
+                        x,
+                        y,
+                        width: drawWidth,
+                        height: drawHeight,
+                    };
+                }
+            })();
+            page.drawRectangle({
+                ...pos,
+                borderColor: rgb(0, 0, 0),
+                borderWidth: 1,
+            });
+            page.drawImage(image, pos);
+            const text = texts[i];
+            const textMargin = 20;
+            if (isLandscapeImage) {
+                const textX = pos.x + pos.width + textMargin; // 画像の右端より少し右
+                const textY = pos.y + pos.height - 12; // 画像の上に揃える or 必要に応じて調整
+                page.drawText(text, {
+                    x: textX,
+                    y: textY,
+                    size: 12,
+                    color: rgb(0, 0, 0),
+                    maxWidth: pageWidth - textX - textMargin,
+                });
+            }
+            else {
+                const textY = pos.y - textMargin - 12;
+                page.drawText(text, {
+                    x: pos.x,
+                    y: textY,
+                    size: 12,
+                    color: rgb(0, 0, 0),
+                    maxWidth: pos.width,
+                });
+            }
+            i++;
+        }
+    }
+};
+const outputSize = (pdfSize, isLandscapeImage, isRotate) => {
+    // console.log(pdfSize);
+    if (pdfSize === "a4") {
+        if (isLandscapeImage !== isRotate) {
+            return { width: 841.89, height: 595.28 };
+        }
+        return { width: 595.28, height: 841.89 };
+    }
+    // letter
+    if (isLandscapeImage !== isRotate) {
+        return { width: 792, height: 612 };
+    }
+    return { width: 612, height: 792 };
+};
+export const pdf = async (context, pdfMode, pdfSize) => {
+    const { studio, fileDirs } = context;
+    const { outDirPath } = fileDirs;
+    const { width: imageWidth, height: imageHeight } = MulmoScriptMethods.getCanvasSize(studio.script);
+    const isLandscapeImage = imageWidth > imageHeight;
+    const isRotate = pdfMode === "handout";
+    const { width: pageWidth, height: pageHeight } = outputSize(pdfSize, isLandscapeImage, isRotate);
+    const imagePaths = studio.beats.map((beat) => beat.imageFile);
+    const texts = studio.script.beats.map((beat) => beat.text);
+    const outputPdfPath = getOutputPdfFilePath(outDirPath, studio.filename, pdfMode);
+    const pdfDoc = await PDFDocument.create();
+    if (pdfMode === "handout") {
+        await pdfHandout(pageWidth, pageHeight, imagePaths, texts, pdfDoc, isLandscapeImage);
+    }
+    if (pdfMode === "slide") {
+        await pdfSlide(pageWidth, pageHeight, imagePaths, pdfDoc);
+    }
+    if (pdfMode === "talk") {
+        await pdfTalk(pageWidth, pageHeight, imagePaths, texts, pdfDoc);
+    }
+    const pdfBytes = await pdfDoc.save();
+    fs.writeFileSync(outputPdfPath, pdfBytes);
+    writingMessage(outputPdfPath);
+};

package/lib/actions/translate.d.ts

@@ -1,3 +1,3 @@
 import "dotenv/config";
-import { MulmoStudioContext } from "../types";
+import { MulmoStudioContext } from "../types/index.js";
 export declare const translate: (context: MulmoStudioContext) => Promise<void>;