我带来的最佳解决方案：
由于fluent-ffmpeg不提供任何内置的方法来裁剪和缩放视频，这就是为什么我们需要自己实现它。
第一步：
我们需要计算一个中间裁剪分辨率，以通过裁剪多余部分（横向到纵向）或添加黑条（纵向到横向）来实现目标纵横比，以避免视频的挤压或拉伸。
注：
我们也可以添加一个很好的模糊效果的情况下，肖像景观，但这将增加一个额外的步骤（ffmpeg模糊过滤器所需）。
第二步：
我们将简单地缩放到目标分辨率。
代码看起来太长了，但是相信我，它很简单，并且被分成了方法。从底层开始理解它。
如果您想要JavaScript版本，请忽略types。
只需运行此代码，它将为您裁剪/缩放单个视频。

import * as FFmpeg from "fluent-ffmpeg";

function resizingFFmpeg(
  video: string,
  width: number,
  height: number,
  tempFile: string,
  autoPad?: boolean,
  padColor?: string
): Promise<string> {
  return new Promise((res, rej) => {
    let ff = FFmpeg().input(video).size(`${width}x${height}`);
    autoPad ? (ff = ff.autoPad(autoPad, padColor)) : null;
    ff.output(tempFile)
      .on("start", function (commandLine) {
        console.log("Spawned FFmpeg with command: " + commandLine);
        console.log("Start resizingFFmpeg:", video);
      })
      // .on("progress", function(progress) {
      //   console.log(progress);
      // })
      .on("error", function (err) {
        console.log("Problem performing ffmpeg function");
        rej(err);
      })
      .on("end", function () {
        console.log("End resizingFFmpeg:", tempFile);
        res(tempFile);
      })
      .run();
  });
}

function videoCropCenterFFmpeg(
  video: string,
  w: number,
  h: number,
  tempFile: string
): Promise<string> {
  return new Promise((res, rej) => {
    FFmpeg()
      .input(video)
      .videoFilters([
        {
          filter: "crop",
          options: {
            w,
            h,
          },
        },
      ])
      .output(tempFile)
      .on("start", function (commandLine) {
        console.log("Spawned FFmpeg with command: " + commandLine);
        console.log("Start videoCropCenterFFmpeg:", video);
      })
      // .on("progress", function(progress) {
      //   console.log(progress);
      // })
      .on("error", function (err) {
        console.log("Problem performing ffmpeg function");
        rej(err);
      })
      .on("end", function () {
        console.log("End videoCropCenterFFmpeg:", tempFile);
        res(tempFile);
      })
      .run();
  });
}

function getDimentions(media: string) {
  console.log("Getting Dimentions from:", media);
  return new Promise<{ width: number; height: number }>((res, rej) => {
    FFmpeg.ffprobe(media, async function (err, metadata) {
      if (err) {
        console.log("Error occured while getting dimensions of:", media);
        rej(err);
      }
      res({
        width: metadata.streams[0].width,
        height: metadata.streams[0].height,
      });
    });
  });
}

async function videoScale(video: string, newWidth: number, newHeight: number) {
  const output = "scaledOutput.mp4";
  const { width, height } = await getDimentions(video);
  if ((width / height).toFixed(2) > (newWidth / newHeight).toFixed(2)) {
    // y=0 case
    // landscape to potrait case
    const x = width - (newWidth / newHeight) * height;
    console.log(`New Intrim Res: ${width - x}x${height}`);
    const cropping = "tempCropped-" + output;
    let cropped = await videoCropCenterFFmpeg(
      video,
      width - x,
      height,
      cropping
    );
    let resized = await resizingFFmpeg(cropped, newWidth, newHeight, output);
    // unlink temp cropping file
    // fs.unlink(cropping, (err) => {
    //   if (err) console.log(err);
    //   console.log(`Temp file ${cropping} deleted Successfuly...`);
    // });
    return resized;
  } else if ((width / height).toFixed(2) < (newWidth / newHeight).toFixed(2)) {
    // x=0 case
    // potrait to landscape case
    // calculate crop or resize with padding or blur sides
    // or just return with black bars on the side
    return await resizingFFmpeg(video, newWidth, newHeight, output, true);
  } else {
    console.log("Same Aspect Ratio forward for resizing");
    return await resizingFFmpeg(video, newWidth, newHeight, output);
  }
}

videoScale("./path-to-some-video.mp4", 270, 480);

添加到上面的解决方案，我不是一个巨大的风扇。
下面的例程尝试模拟 object-fit：contain CSS裁剪和调整大小。这首先计算出中间调整大小步骤需要什么大小来保持纵横比并提供必要的宽度和高度来裁剪到所需的输出，然后对结果运行视频过滤器裁剪，只拉取所需的输出尺寸。
我还使用temp npm包在系统临时文件夹中生成空文件，这些文件将用作ffmpeg的输出文件目的地。

import FFMpeg from 'fluent-ffmpeg';
import temp from 'temp-write';

function getDimensions(media) {
    return new Promise((resolve, reject) => {
        FFMpeg.ffprobe(media, async (err, metadata) => {
            if (err) {
                reject(err);
                return;
            }
            resolve({
                mediaWidth: metadata.streams[0].width,
                mediaHeight: metadata.streams[0].height,
            });
        });
    });
}

function FFMpegPromisify(routine, output) {
    return new Promise((resolve, reject) => {
        routine
            .on('error', (err) => {
                reject(err);
            })
            .on('end', () => {
                resolve();
            })
            .save(output);
    });
}

module.exports = {
    resize: async ({ data, width, height }) => {
        let path = temp.sync(data);
        const { mediaWidth, mediaHeight } = await getDimensions(path);
        let mediaAspectRatio = mediaWidth / mediaHeight;
        let widthResizeRatio = width / mediaWidth;
        let heightResizeRatio = height / mediaHeight;
        let maxAdjustedWidth = Math.round(Math.max(mediaWidth * widthResizeRatio, height * mediaAspectRatio));
        let maxAdjustedHeight = Math.round(Math.max(mediaHeight * heightResizeRatio, width / mediaAspectRatio));

        let tempResizePath = temp.sync('', 'file.mp4');
        await FFMpegPromisify(FFMpeg(path).format('mp4').size(`${maxAdjustedWidth}x${maxAdjustedHeight}`), tempResizePath);

        let tempCropPath = temp.sync('', 'file.mp4');
        let cropX = (maxAdjustedWidth - width) / 2;
        let cropY = (maxAdjustedHeight - height) / 2;
        await FFMpegPromisify(FFMpeg(tempResizePath).format('mp4').videoFilter([
            {
                filter: "crop",
                options: {
                    w: width,
                    h: height,
                    x: cropX,
                    y: cropY
                },
            }
        ]), tempCropPath);

        return tempCropPath; // contains the final, cropped result
    }
}

let file = require('fs').readFileSync('C:\\FFMpeg\\sample.mp4');

module.exports.resize({ data: file, width: 320, height: 1080 });

我觉得其他的答案让事情变得比需要的更复杂。
正如其他人所说，没有办法只直接输入高宽比，所以你应该在裁剪前找到想要的尺寸。
下面的代码使用ffprobe获取视频尺寸，并找到具有所需纵横比的选定视频的最大可能大小。
在本例中，它将获得6：9纵横比的最大文件尺寸。

const ffmpeg = require('fluent-ffmpeg');
ffmpeg.ffprobe(`./Videos/video.mp4`, function (err, metadata) {
if (err) {
    console.error(err);
} else {

    let mediaWidth = metadata.streams[0].width;
    let mediaHeight = metadata.streams[0].height;
    let widthAspectRatio = 6;
    let heightAspectRation = 9;
    let newWidth = 1;
    let newHeight = 1;

    while (newWidth < mediaWidth && newHeight < mediaHeight) {
        newWidth += widthAspectRatio;
        newHeight += heightAspectRation;
    }
    newHeight -= widthAspectRatio;
    newHeight -= heightAspectRation;

    console.log("Original dimensions:", mediaWidth, mediaHeight);
    console.log("New dimensions:", newWidth, newHeight);

}
});

输出：

Original dimensions: 2560 1440
New dimensions: 961 1426

之后，只需将视频裁剪为您获得的尺寸。