LambdaでKinesis Video Streamsの音声ストリームをパースしてステレオ音声化する

const AWS = require('aws-sdk');
const ebml = require('ebml');
const fs = require('fs');
const { execSync } = require('child_process');
const region = 'ap-northeast-1';
const bucketName = 'ステレオ音声の保存先を指定';

var start = new Date();

exports.handler = async (event) => {
    const streamName = "ストリーム名を指定";
    const fragmentNumber = "StartFragmentNumberを指定";
    
    const s3 = new S3(AWS, region);
    const raws = await getMedia(streamName, fragmentNumber);
    fs.writeFileSync("/tmp/from.wav", Converter.createWav(raws.from, 8000));
    fs.writeFileSync("/tmp/to.wav", Converter.createWav(raws.to, 8000));

    execSync('/opt/bin/ffmpeg -i /tmp/from.wav -i /tmp/to.wav -filter_complex "[0:a][1:a]join=inputs=2:channel_layout=stereo[a]" -map "[a]" /tmp/mixed.wav');

    await s3.put(bucketName, "mixed.wav", fs.readFileSync("/tmp/mixed.wav"));
    
    const response = {
        statusCode: 200,
        body: JSON.stringify('End Stream Parse!'),
    };
    return response;
};

class S3 {
    constructor(AWS, region){
        this._s3 = new AWS.S3({region:region});
    }
    async get(bucketName, key){
        const params = {
            Bucket: bucketName,
            Key: key
        };
        return await this._s3.getObject(params).promise();
    }
 
    async put(bucketName, key, body,) {
        const params = {
            Bucket: bucketName,
            Key: key,
            Body: body
        };
        return  await this._s3.putObject(params).promise();
    }
 
}
 
async function getMedia(streamName, fragmentNumber) {
    // Endpointの取得
    const kinesisvideo = new AWS.KinesisVideo({region: region});
    var params = {
        APIName: "GET_MEDIA",
        StreamName: streamName
    };
    const end = await kinesisvideo.getDataEndpoint(params).promise();
 
    // RAWデータの取得
    const kinesisvideomedia = new AWS.KinesisVideoMedia({endpoint: end.DataEndpoint, region:region});
    params = {
        StartSelector: { 
            StartSelectorType: "FRAGMENT_NUMBER",
            AfterFragmentNumber:fragmentNumber,
        },
        StreamName: streamName
    };
    const data = await kinesisvideomedia.getMedia(params).promise();

    const decoder = new ebml.Decoder();
    const arraySize = 8 * 1024 * 1024;
    let audioFromCustomer = new Uint8Array(0);
    let audioToCustomer = new Uint8Array(0);
    let fromLength = 0;
    let toLength = 0;
    let fromCurrentLength = 0;
    let toCurrentLength = 0;
    decoder.on('data', chunk => {
        const name = chunk[1].name;
        const payload = chunk[1].payload;
        if (name == "SimpleBlock") {
            const track = chunk[1].track;
            if (track == 1 ) {
                let nextLength = toCurrentLength + payload.length;
                if (nextLength > toLength) {
                    toLength += arraySize;
                    let tmpAry = audioToCustomer;
                    audioToCustomer = new (tmpAry.constructor)(toLength);
                    audioToCustomer.set(tmpAry, 0);
                }
                audioToCustomer.set(payload, toCurrentLength);
                toCurrentLength += payload.length;
            } else if (track == 2) {
                let nextLength = fromCurrentLength + payload.length;
                if (nextLength > fromLength) {
                    fromLength += arraySize;
                    let tmpAry = audioFromCustomer;
                    audioFromCustomer = new (tmpAry.constructor)(fromLength);
                    audioFromCustomer.set(tmpAry, 0);
                }
                audioFromCustomer.set(payload, fromCurrentLength);
                fromCurrentLength += payload.length;
            }
        }
    });
    decoder.write(data["Payload"]);
     
    return {
        from: audioFromCustomer.slice(0, fromCurrentLength).buffer,
        to: audioToCustomer.slice(0, toCurrentLength).buffer
    };
}

class Converter {
    // WAVファイルの生成
    static createWav(samples, sampleRate) {
        const len = samples.byteLength;
        const view = new DataView(new ArrayBuffer(44 + len));
        this._writeString(view, 0, 'RIFF');
        view.setUint32(4, 32 + len, true);
        this._writeString(view, 8, 'WAVE');
        this._writeString(view, 12, 'fmt ');
        view.setUint32(16, 16, true);
        view.setUint16(20, 1, true); // リニアPCM
        view.setUint16(22, 1, true); // モノラル
        view.setUint32(24, sampleRate, true); 
        view.setUint32(28, sampleRate * 2, true);
        view.setUint16(32, 2, true);
        view.setUint16(34, 16, true);
        this._writeString(view, 36, 'data');
        view.setUint32(40, len, true);
        let offset = 44;
        const srcView = new DataView(samples);
        for (var i = 0; i < len; i+=4, offset+=4) {
            view.setInt32(offset, srcView.getUint32(i));
        }
        return view;
    }
     
    static _writeString(view, offset, string) {
        for (var i = 0; i < string.length; i++) {
          view.setUint8(offset + i, string.charCodeAt(i));
        }
    }
}

ffmpeg -i left.mp3 -i right.mp3 -filter_complex "[0:a][1:a]join=inputs=2:channel_layout=stereo[a]" -map "[a]" output.mp3