Question

我正在通过将每个图像下载到文件系统到tmp文件夹中的节点中的远程文件创建GIF。

我想绕过将图像保存到tmp文件夹并保存在内存中。这可能吗？

如您所见，我的AWS类中有一个下载函数，该函数保存到tmp文件夹：

download(key){
    return new Promise((resolve, reject) => {
      request.head(`${this.base_url}/${this.bucket}/${key}`, (err, res, body) => {
        request(`${this.base_url}/${this.bucket}/${key}`)
            .pipe(fs.createWriteStream(`tmp/${key}`)).on('close', resolve )
      })
    })
};

一旦他们全部下载了，我在我的GifService类中有一个createGif函数，它将每个文件路径添加为gm的自定义参数，添加50ms的延迟，然后调整输出作为缓冲区，然后我上传到AWS s3。

import gm from 'gm';

...

constructor(){
    this.gm = gm()
}

generateGif(images, prefix){

    return new Promise((resolve, reject) => {

        // for each image we want in array, we pass to gm
        images.forEach(image => {
            this.gm.in(`tmp/${image.Key}`)
        })

        // Now we create the gif with 50sec delay between images, sized to 600px x 2
        this.gm
            .delay(50)
            .resize(600,600)
            .toBuffer('gif', async (err, buffer) => {
        if (err) reject(err)

        const params = {
                ACL: 'public-read',
                Bucket: config.aws_bucket,
                ContentType: 'image/gif',
                Key: `${prefix}/${uuid()}.gif`,
                Body: buffer
              }

              try{
                // uplaod to S3
            const upload = await this.aws.upload(params)

            // resolve s3 URL
            resolve(upload)

              }catch(err) {
                console.log('err', err)
                reject(err)
              }

      });
    })

}

理想情况下，如果我可以将远程文件流作为自定义参数传递，或者将缓冲区作为自定义参数传递，而不是我当前传入tmp文件路径的方式：

images.forEach(image => {
    this.gm.in(`tmp/${image.Key}`)
})

Answer 1

我设法通过首先将图像转换为streams并将它们连接成单个流，仅使用miff使其工作。然后使用buffer再次将stream或gm传递到delay就可以了。

您需要安装concat-stream npm才能实现此目的。

对于混合的ES5代码感到抱歉。

import gm from 'gm';
var concat = require('concat-stream');
...

constructor() {
    this.gm = gm()
}

start() {

    return getYourReadAbleStreamsSomehow().then(streams => {

        return generateGif(streams);

    }).then(gifBuffer => {

        return uploadToAWS(gifBuffer, prefix);

    }).catch(err => {
        console.log(err)
    })

}

uploadToAWS(buffer, prefix) {
    const params = {
        ACL: 'public-read',
        Bucket: config.aws_bucket,
        ContentType: 'image/gif',
        Key: `${prefix}/${uuid()}.gif`,
        Body: buffer
    }

    try {
        // uplaod to S3
        const upload = await this.aws.upload(params)

        // resolve s3 URL
        resolve(upload)

    } catch (err) {
        console.log('err', err)
        reject(err)
    }
}

generateGif(imageStreams, delay) {

    return new Promise((resolve, reject) => {

        var write = concat(function(buffer) {
            gm(buffer)
                .delay(delay)
                .toBuffer('gif', function(err, buffer) {

                    if (err) 
                        reject(err);

                    resolve(buffer);

                })
        })

        //Convert to miff and concat streams
        var i = 0;
        var streamHandler = function() {

            gm(imageStreams[i])
                .resize('600', '600')
                .stream('miff', function(err, stdout, stderr) {
                    if (err)
                        reject(err)

                    var lastOne = i === streams.length - 1;

                    if (!lastOne)
                        stdout.once('end', streamHandler)

                    stdout.pipe(write, {
                        end: lastOne
                    });

                    i++;

                });
        }

        streamHandler();

    })

}

在graphicsmagick中从远程流创建GIF

1 个答案: