diff --git a/src/index.html b/src/index.html index 5e3eb5f..5067c6c 100644 --- a/src/index.html +++ b/src/index.html @@ -22,6 +22,7 @@ + diff --git a/src/libav-6.5.7.1-all.js b/src/libav-6.5.7.1-all.js new file mode 100644 index 0000000..12d1433 --- /dev/null +++ b/src/libav-6.5.7.1-all.js @@ -0,0 +1 @@ +(function(){function isWebAssemblySupported(module){module=module||[0,97,115,109,1,0,0,0];if(typeof WebAssembly!=="object"||typeof WebAssembly.instantiate!=="function")return false;try{var module=new WebAssembly.Module(new Uint8Array(module));if(module instanceof WebAssembly.Module)return new WebAssembly.Instance(module)instanceof WebAssembly.Instance}catch(e){}return false}function isThreadingSupported(){try{var mem=new WebAssembly.Memory({initial:1,maximum:1,shared:true});if(!(mem.buffer instanceof SharedArrayBuffer))return false;return true}catch(e){}return false}var libav;var nodejs=typeof process!=="undefined";if(typeof LibAV==="undefined")LibAV={};libav=LibAV;if(!libav.base){if(typeof __dirname==="string"){libav.base=__dirname}else{if(typeof document!=="undefined"&&document&&document.currentScript)libav.base=document.currentScript.src;else if(typeof self!=="undefined"&&self&&self.location)libav.base=self.location.href;else libav.base="./.";libav.base=libav.base.replace(/\/[^\/]*$/,"")}}libav.isWebAssemblySupported=isWebAssemblySupported;libav.isThreadingSupported=isThreadingSupported;function target(opts){opts=opts||{};var wasm=!opts.nowasm&&isWebAssemblySupported();var thr=opts.yesthreads&&wasm&&!opts.nothreads&&isThreadingSupported();if(!wasm)return"asm";else if(thr)return"thr";else return"wasm"}libav.target=target;libav.VER="6.5.7.1";libav.CONFIG="all";libav.DBG="";libav.factories={};var libavStatics={};libavStatics.i64tof64=function(lo,hi){if(!hi&&lo>=0)return lo;if(hi===-1&&lo<0)return lo;return hi*4294967296+lo+(lo<0?4294967296:0)};libavStatics.f64toi64=function(val){return[~~val,Math.floor(val/4294967296)]};libavStatics.i64ToBigInt=function(lo,hi){var dv=new DataView(new ArrayBuffer(8));dv.setInt32(0,lo,true);dv.setInt32(4,hi,true);return dv.getBigInt64(0,true)};libavStatics.bigIntToi64=function(val){var dv=new DataView(new ArrayBuffer(8));dv.setBigInt64(0,val,true);return[dv.getInt32(0,true),dv.getInt32(4,true)]};libavStatics.ff_channel_layout=function(frame){if(frame.channel_layout)return frame.channel_layout;else if(frame.channels&&frame.channels!==1)return(1<>=1}return channels}else{return 1}};function enume(vals,first){if(typeof first===undefined)first=0;var i=first;vals.forEach((function(val){libavStatics[val]=i++}))}libavStatics.AV_TIME_BASE=1e6;libavStatics.AV_OPT_SEARCH_CHILDREN=1;enume(["AVMEDIA_TYPE_UNKNOWN","AVMEDIA_TYPE_VIDEO","AVMEDIA_TYPE_AUDIO","AVMEDIA_TYPE_DATA","AVMEDIA_TYPE_SUBTITLE","AVMEDIA_TYPE_ATTACHMENT"],-1);enume(["AV_SAMPLE_FMT_NONE","AV_SAMPLE_FMT_U8","AV_SAMPLE_FMT_S16","AV_SAMPLE_FMT_S32","AV_SAMPLE_FMT_FLT","AV_SAMPLE_FMT_DBL","AV_SAMPLE_FMT_U8P","AV_SAMPLE_FMT_S16P","AV_SAMPLE_FMT_S32P","AV_SAMPLE_FMT_FLTP","AV_SAMPLE_FMT_DBLP","AV_SAMPLE_FMT_S64","AV_SAMPLE_FMT_S64P","AV_SAMPLE_FMT_NB"],-1);enume(["AV_PIX_FMT_NONE","AV_PIX_FMT_YUV420P","AV_PIX_FMT_YUYV422","AV_PIX_FMT_RGB24","AV_PIX_FMT_BGR24","AV_PIX_FMT_YUV422P","AV_PIX_FMT_YUV444P","AV_PIX_FMT_YUV410P","AV_PIX_FMT_YUV411P","AV_PIX_FMT_GRAY8","AV_PIX_FMT_MONOWHITE","AV_PIX_FMT_MONOBLACK","AV_PIX_FMT_PAL8","AV_PIX_FMT_YUVJ420P","AV_PIX_FMT_YUVJ422P","AV_PIX_FMT_YUVJ444P","AV_PIX_FMT_UYVY422","AV_PIX_FMT_UYYVYY411","AV_PIX_FMT_BGR8","AV_PIX_FMT_BGR4","AV_PIX_FMT_BGR4_BYTE","AV_PIX_FMT_RGB8","AV_PIX_FMT_RGB4","AV_PIX_FMT_RGB4_BYTE","AV_PIX_FMT_NV12","AV_PIX_FMT_NV21","AV_PIX_FMT_ARGB","AV_PIX_FMT_RGBA","AV_PIX_FMT_ABGR","AV_PIX_FMT_BGRA","AV_PIX_FMT_GRAY16BE","AV_PIX_FMT_GRAY16LE","AV_PIX_FMT_YUV440P","AV_PIX_FMT_YUVJ440P","AV_PIX_FMT_YUVA420P","AV_PIX_FMT_RGB48BE","AV_PIX_FMT_RGB48LE","AV_PIX_FMT_RGB565BE","AV_PIX_FMT_RGB565LE","AV_PIX_FMT_RGB555BE","AV_PIX_FMT_RGB555LE","AV_PIX_FMT_BGR565BE","AV_PIX_FMT_BGR565LE","AV_PIX_FMT_BGR555BE","AV_PIX_FMT_BGR555LE"],-1);libavStatics.AVIO_FLAG_READ=1;libavStatics.AVIO_FLAG_WRITE=2;libavStatics.AVIO_FLAG_READ_WRITE=3;libavStatics.AVIO_FLAG_NONBLOCK=8;libavStatics.AVIO_FLAG_DIRECT=32768;libavStatics.AVFMT_FLAG_NOBUFFER=64;libavStatics.AVFMT_FLAG_FLUSH_PACKETS=512;libavStatics.AVSEEK_FLAG_BACKWARD=1;libavStatics.AVSEEK_FLAG_BYTE=2;libavStatics.AVSEEK_FLAG_ANY=4;libavStatics.AVSEEK_FLAG_FRAME=8;libavStatics.AVDISCARD_NONE=-16;libavStatics.AVDISCARD_DEFAULT=0;libavStatics.AVDISCARD_NONREF=8;libavStatics.AVDISCARD_BIDIR=16;libavStatics.AVDISCARD_NONINTRA=24;libavStatics.AVDISCARD_NONKEY=32;libavStatics.AVDISCARD_ALL=48;libavStatics.AV_LOG_QUIET=-8;libavStatics.AV_LOG_PANIC=0;libavStatics.AV_LOG_FATAL=8;libavStatics.AV_LOG_ERROR=16;libavStatics.AV_LOG_WARNING=24;libavStatics.AV_LOG_INFO=32;libavStatics.AV_LOG_VERBOSE=40;libavStatics.AV_LOG_DEBUG=48;libavStatics.AV_LOG_TRACE=56;libavStatics.AV_PKT_FLAG_KEY=1;libavStatics.AV_PKT_FLAG_CORRUPT=2;libavStatics.AV_PKT_FLAG_DISCARD=4;libavStatics.AV_PKT_FLAG_TRUSTED=8;libavStatics.AV_PKT_FLAG_DISPOSABLE=16;enume(["E2BIG","EPERM","EADDRINUSE","EADDRNOTAVAIL","EAFNOSUPPORT","EAGAIN","EALREADY","EBADF","EBADMSG","EBUSY","ECANCELED","ECHILD","ECONNABORTED","ECONNREFUSED","ECONNRESET","EDEADLOCK","EDESTADDRREQ","EDOM","EDQUOT","EEXIST","EFAULT","EFBIG","EHOSTUNREACH","EIDRM","EILSEQ","EINPROGRESS","EINTR","EINVAL","EIO","EISCONN","EISDIR","ELOOP","EMFILE","EMLINK","EMSGSIZE","EMULTIHOP","ENAMETOOLONG","ENETDOWN","ENETRESET","ENETUNREACH","ENFILE","ENOBUFS","ENODEV","ENOENT"],1);libavStatics.AVERROR_EOF=-541478725;Object.assign(libav,libavStatics);libav.LibAV=function(opts){opts=opts||{};var base=opts.base||libav.base;var t=target(opts);var variant="all";if(t==="asm"){variant=opts.variant||libav.variant||"all"}var toImport=opts.toImport||libav.toImport||base+"/libav-6.5.7.1-"+variant+"."+t+"."+"js";var ret;var mode="direct";if(t==="thr")mode="threads";else if(!nodejs&&!opts.noworker&&typeof Worker!=="undefined")mode="worker";return Promise.all([]).then((function(){if(opts.factory||libav.factory)return opts.factory||libav.factory;if(libav.factories[toImport])return libav.factories[toImport];if(mode==="worker"){}else if(nodejs){return libav.factories[toImport]=require(toImport)}else if(typeof importScripts!=="undefined"){importScripts(toImport);return libav.factories[toImport]=LibAVFactory}else{return new Promise((function(res,rej){var scr=document.createElement("script");scr.src=toImport;scr.addEventListener("load",res);scr.addEventListener("error",rej);scr.async=true;document.body.appendChild(scr)})).then((function(){return libav.factories[toImport]=LibAVFactory}))}})).then((function(factory){if(mode==="worker"){ret={};ret.worker=new Worker(toImport);ret.worker.postMessage({config:{variant:opts.variant||libav.variant,wasmurl:opts.wasmurl||libav.wasmurl}});return new Promise((function(res,rej){ret.on=1;ret.handlers={onready:[function(){res()},null],onwrite:[function(args){if(ret.onwrite)ret.onwrite.apply(ret,args)},null],onread:[function(args){try{var rr=null;if(ret.onread)rr=ret.onread.apply(ret,args);if(rr&&rr.then&&rr.catch){rr.catch((function(ex){ret.ff_reader_dev_send(args[0],null,{error:ex})}))}}catch(ex){ret.ff_reader_dev_send(args[0],null,{error:ex})}},null],onblockread:[function(args){try{var brr=null;if(ret.onblockread)brr=ret.onblockread.apply(ret,args);if(brr&&brr.then&&brr.catch){brr.catch((function(ex){ret.ff_block_reader_dev_send(args[0],args[1],null,{error:ex})}))}}catch(ex){ret.ff_block_reader_dev_send(args[0],args[1],null,{error:ex})}},null]};ret.c=function(){var msg=Array.prototype.slice.call(arguments);var transfer=[];for(var i=0;i + * Copyright (C) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Also add information on how to contact you by electronic and paper mail. + * + * You should also get your employer (if you work as a programmer) or your + * school, if any, to sign a "copyright disclaimer" for the library, if + * necessary. Here is a sample; alter the names: + * + * Yoyodyne, Inc., hereby disclaims all copyright interest in the + * library `Frob' (a library for tweaking knobs) written by James Random Hacker. + * + * , 1 April 1990 + * Ty Coon, President of Vice + * + * That's all there is to it! + * + * + * --- + * + * ffmpeg oggdec: + * + * Copyright (C) 2005 Michael Ahlberg, Måns Rullgård + * Copyright (C) 2005 Matthieu CASTET, Alex Beregszaszi + * Copyright (C) 2008 Reimar Döffinger + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * + * --- + * + * opus: + * + * Copyright 2001-2011 Xiph.Org, Skype Limited, Octasic, + * Jean-Marc Valin, Timothy B. Terriberry, + * CSIRO, Gregory Maxwell, Mark Borgerding, + * Erik de Castro Lopo + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * - Neither the name of Internet Society, IETF or IETF Trust, nor the names of + * specific contributors, may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS + * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Opus is subject to the royalty-free patent licenses which are specified at: + * + * Xiph.Org Foundation: + * https://datatracker.ietf.org/ipr/1524/ + * + * Microsoft Corporation: + * https://datatracker.ietf.org/ipr/1914/ + * + * Broadcom Corporation: + * https://datatracker.ietf.org/ipr/1526/ + * + * + * --- + * + * libvorbis, libogg: + * + * Copyright (c) 2002-2020 Xiph.org Foundation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * - Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * - Neither the name of the Xiph.org Foundation nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS + * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * + * --- + * + * lame: + * + * Copyright (C) 1999-2017 The L.A.M.E. project + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this library; if not, write to the + * Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + * + * + * --- + * + * libvpx: + * + * Copyright (c) 2010, The WebM Project authors. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * * Neither the name of Google, nor the WebM Project, nor the names + * of its contributors may be used to endorse or promote products + * derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * + * --- + * + * libaom: + * + * Copyright (c) 2016, Alliance for Open Media. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN + * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + * + * --- + * + * libopenh264: + * + * Copyright (c) 2013, Cisco Systems + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright notice, this + * list of conditions and the following disclaimer in the documentation and/or + * other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * + * + * + * --- + * + * jrevdct.c: + * + * This file is part of the Independent JPEG Group's software. + * + * The authors make NO WARRANTY or representation, either express or implied, + * with respect to this software, its quality, accuracy, merchantability, or + * fitness for a particular purpose. This software is provided "AS IS", and + * you, its user, assume the entire risk as to its quality and accuracy. + * + * This software is copyright (C) 1991, 1992, Thomas G. Lane. + * All Rights Reserved except as specified below. + * + * Permission is hereby granted to use, copy, modify, and distribute this + * software (or portions thereof) for any purpose, without fee, subject to + * these conditions: + * (1) If any part of the source code for this software is distributed, then + * this README file must be included, with this copyright and no-warranty + * notice unaltered; and any additions, deletions, or changes to the original + * files must be clearly indicated in accompanying documentation. + * (2) If only executable code is distributed, then the accompanying + * documentation must state that "this software is based in part on the work + * of the Independent JPEG Group". + * (3) Permission for use of this software is granted only if the user accepts + * full responsibility for any undesirable consequences; the authors accept + * NO LIABILITY for damages of any kind. + * + * These conditions apply to any software derived from or based on the IJG + * code, not just to the unmodified library. If you use our work, you ought + * to acknowledge us. + * + * Permission is NOT granted for the use of any IJG author's name or company + * name in advertising or publicity relating to this software or products + * derived from it. This software may be referred to only as "the Independent + * JPEG Group's software". + * + * + * --- + * + * zlib: + * + * (C) 1995-2022 Jean-loup Gailly and Mark Adler + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * 3. This notice may not be removed or altered from any source distribution. + * + * Jean-loup Gailly Mark Adler + * jloup@gzip.org madler@alumni.caltech.edu + * + * + * --- + * + * jrevdct.c: + * + * This file is part of the Independent JPEG Group's software. + * + * The authors make NO WARRANTY or representation, either express or implied, + * with respect to this software, its quality, accuracy, merchantability, or + * fitness for a particular purpose. This software is provided "AS IS", and + * you, its user, assume the entire risk as to its quality and accuracy. + * + * This software is copyright (C) 1991, 1992, Thomas G. Lane. + * All Rights Reserved except as specified below. + * + * Permission is hereby granted to use, copy, modify, and distribute this + * software (or portions thereof) for any purpose, without fee, subject to + * these conditions: + * (1) If any part of the source code for this software is distributed, then + * this README file must be included, with this copyright and no-warranty + * notice unaltered; and any additions, deletions, or changes to the original + * files must be clearly indicated in accompanying documentation. + * (2) If only executable code is distributed, then the accompanying + * documentation must state that "this software is based in part on the work + * of the Independent JPEG Group". + * (3) Permission for use of this software is granted only if the user accepts + * full responsibility for any undesirable consequences; the authors accept + * NO LIABILITY for damages of any kind. + * + * These conditions apply to any software derived from or based on the IJG + * code, not just to the unmodified library. If you use our work, you ought + * to acknowledge us. + * + * Permission is NOT granted for the use of any IJG author's name or company + * name in advertising or publicity relating to this software or products + * derived from it. This software may be referred to only as "the Independent + * JPEG Group's software". + * + * + * --- + * + * jfdctfst.c: + * + * This file is part of the Independent JPEG Group's software. + * + * The authors make NO WARRANTY or representation, either express or implied, + * with respect to this software, its quality, accuracy, merchantability, or + * fitness for a particular purpose. This software is provided "AS IS", and + * you, its user, assume the entire risk as to its quality and accuracy. + * + * This software is copyright (C) 1994-1996, Thomas G. Lane. + * All Rights Reserved except as specified below. + * + * Permission is hereby granted to use, copy, modify, and distribute this + * software (or portions thereof) for any purpose, without fee, subject to + * these conditions: + * (1) If any part of the source code for this software is distributed, then + * this README file must be included, with this copyright and no-warranty + * notice unaltered; and any additions, deletions, or changes to the original + * files must be clearly indicated in accompanying documentation. + * (2) If only executable code is distributed, then the accompanying + * documentation must state that "this software is based in part on the work + * of the Independent JPEG Group". + * (3) Permission for use of this software is granted only if the user accepts + * full responsibility for any undesirable consequences; the authors accept + * NO LIABILITY for damages of any kind. + * + * These conditions apply to any software derived from or based on the IJG + * code, not just to the unmodified library. If you use our work, you ought + * to acknowledge us. + * + * Permission is NOT granted for the use of any IJG author's name or company + * name in advertising or publicity relating to this software or products + * derived from it. This software may be referred to only as "the Independent + * JPEG Group's software". + * + * + * --- + * + * emscripten and musl: + * + * Copyright (c) 2010-2024 Emscripten authors, see AUTHORS file. + * Copyright © 2005-2024 Rich Felker, et al. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 4.0.0 (97c7c2adab1791b9487d1f376934a3bdc28f8a67) + * + */ +var LibAVFactory = (() => { + var _scriptName = typeof document != 'undefined' ? document.currentScript?.src : undefined; + if (typeof __filename != 'undefined') _scriptName = _scriptName || __filename; + return ( +async function(moduleArg = {}) { + var moduleRtn; + +var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;var readyPromise=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof WorkerGlobalScope!="undefined";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string"&&process.type!="renderer";if(ENVIRONMENT_IS_NODE){}if(typeof _scriptName==="undefined"){if(typeof LibAV==="object"&&LibAV&&LibAV.base)_scriptName=LibAV.base+"/libav-6.5.7.1-all.wasm.js";else if(typeof self==="object"&&self&&self.location)_scriptName=self.location.href}Module.locateFile=function(path,prefix){if(path.lastIndexOf(".wasm")===path.length-5&&path.indexOf("libav-")!==-1){if(Module.wasmurl)return Module.wasmurl;if(Module.variant)return prefix+"libav-6.5.7.1-"+Module.variant+".wasm.wasm"}return prefix+path};var moduleOverrides=Object.assign({},Module);var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");var nodePath=require("path");scriptDirectory=__dirname+"/";readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(!Module["thisProgram"]&&process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(_scriptName){scriptDirectory=_scriptName}if(scriptDirectory.startsWith("blob:")){scriptDirectory=""}else{scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{if(isFileURI(url)){return new Promise((resolve,reject)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){resolve(xhr.response);return}reject(xhr.status)};xhr.onerror=reject;xhr.send(null)})}var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.error.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];var wasmBinary=Module["wasmBinary"];var wasmMemory;var ABORT=false;var EXITSTATUS;var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAP64,HEAPU64,HEAPF64;var runtimeInitialized=false;var dataURIPrefix="data:application/octet-stream;base64,";var isDataURI=filename=>filename.startsWith(dataURIPrefix);var isFileURI=filename=>filename.startsWith("file://");function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b);Module["HEAP64"]=HEAP64=new BigInt64Array(b);Module["HEAPU64"]=HEAPU64=new BigUint64Array(b)}var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function initRuntime(){runtimeInitialized=true;if(!Module["noFSInit"]&&!FS.initialized)FS.init();FS.ignorePermissions=false;TTY.init();callRuntimeCallbacks(__ATINIT__)}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnInit(cb){__ATINIT__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var runDependencies=0;var dependenciesFulfilled=null;function getUniqueRunDependency(id){return id}function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var wasmBinaryFile;function findWasmBinary(){var f="libav-6.5.7.1-all.wasm.wasm";if(!isDataURI(f)){return locateFile(f)}return f}function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(binaryFile)&&!isFileURI(binaryFile)&&!ENVIRONMENT_IS_NODE){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){return{a:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmExports=Asyncify.instrumentWasmExports(wasmExports);wasmMemory=wasmExports["na"];updateMemoryViews();wasmTable=wasmExports["Wf"];addOnInit(wasmExports["oa"]);removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err(`Module.instantiateWasm callback failed with error: ${e}`);readyPromiseReject(e)}}wasmBinaryFile??=findWasmBinary();try{var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}catch(e){readyPromiseReject(e);return Promise.reject(e)}}var ASM_CONSTS={2245414:()=>{Fibers.trampolineRunning=false}};function writeoutEmscriptenOOM(){throw new Error("Out of memory")}function libavjs_wait_reader(fd){return Asyncify.handleAsync(function(){return new Promise(function(res){var name=Module.fdName(fd);var waiters=Module.ff_reader_dev_waiters[name];if(!waiters)waiters=Module.ff_reader_dev_waiters[name]=[];waiters.push(res)})})}function jsfetch_open_js(url){return Asyncify.handleAsync(function(){return Promise.all([]).then(function(){url=UTF8ToString(url);if(url.slice(0,8)==="jsfetch:")return fetch(url.slice(8));else return fetch(url)}).then(function(response){if(!Module.libavjsJSFetch)Module.libavjsJSFetch={ctr:1,fetches:{}};var jsf=Module.libavjsJSFetch;var idx=jsf.ctr++;var reader=response.body.getReader();var jsfo=jsf.fetches[idx]={url,response,reader,next:reader.read().then(function(res){jsfo.buf=res}).catch(function(rej){jsfo.rej=rej}),buf:null,rej:null};return idx}).catch(function(ex){Module.fsThrownError=ex;console.error(ex);return-11})})}function jsfetch_read_js(idx,toBuf,size){var jsfo=Module.libavjsJSFetch.fetches[idx];return Asyncify.handleAsync(function(){return Promise.all([]).then(function(){if(jsfo.buf||jsfo.rej){var fromBuf=jsfo.buf;var rej=jsfo.rej;if(fromBuf){if(fromBuf.done){return-541478725}if(fromBuf.value.length>size){Module.HEAPU8.set(fromBuf.value.subarray(0,size),toBuf);fromBuf.value=fromBuf.value.subarray(size);return size}var ret=fromBuf.value.length;Module.HEAPU8.set(fromBuf.value,toBuf);jsfo.buf=jsfo.rej=null;jsfo.next=jsfo.reader.read().then(function(res){jsfo.buf=res}).catch(function(rej){jsfo.rej=rej});return ret}Module.fsThrownError=rej;console.error(rej);return-11}return Promise.race([jsfo.next,new Promise(function(res){setTimeout(res,100)})]).then(function(){return-6})})})}function jsfetch_close_js(idx){var jsfo=Module.libavjsJSFetch.fetches[idx];if(jsfo){try{jsfo.reader.cancel()}catch(ex){}delete Module.libavjsJSFetch.fetches[idx]}}function emfiberthreads_pthread_mutex_timedwait_setTimeout(cond,thr,timeoutReached,sec,nsec){Module.HEAPU32[timeoutReached/4]=0;var wait=sec*1e3+nsec/1e6-(new Date).getTime();return setTimeout(function(){Module.HEAPU32[timeoutReached/4]=1;Module.ccall("emfiberthreads_timeout_expiry",null,["number","number"],[cond,thr])},wait)}function emfiberthreads_pthread_mutex_timedwait_clearTimeout(timeout){clearTimeout(timeout)}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var noExitRuntime=Module["noExitRuntime"]||true;var stackRestore=val=>__emscripten_stack_restore(val);var stackSave=()=>_emscripten_stack_get_current();var UTF8Decoder=typeof TextDecoder!="undefined"?new TextDecoder:undefined;var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead=NaN)=>{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var ___assert_fail=(condition,filename,line,func)=>abort(`Assertion failed: ${UTF8ToString(condition)}, at: `+[filename?UTF8ToString(filename):"unknown filename",line,func?UTF8ToString(func):"unknown function"]);var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(parts,allowAboveRoot)=>{var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up;up--){parts.unshift("..")}}return parts},normalize:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.substr(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.substr(0,dir.length-1)}return root+dir},basename:path=>path&&path.match(/([^\/]+|\/)\/*$/)[1],join:(...paths)=>PATH.normalize(paths.join("/")),join2:(l,r)=>PATH.normalize(l+"/"+r)};var initRandomFill=()=>{if(ENVIRONMENT_IS_NODE){var nodeCrypto=require("crypto");return view=>nodeCrypto.randomFillSync(view)}return view=>crypto.getRandomValues(view)};var randomFill=view=>{(randomFill=initRandomFill())(view)};var PATH_FS={resolve:(...args)=>{var resolvedPath="",resolvedAbsolute=false;for(var i=args.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?args[i]:FS.cwd();if(typeof path!="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).substr(1);to=PATH_FS.resolve(to).substr(1);function trim(arr){var start=0;for(;start=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i{var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx};function intArrayFromString(stringy,dontAddNull,length){var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array}var FS_stdin_getChar=()=>{if(!FS_stdin_getChar_buffer.length){var result=null;if(ENVIRONMENT_IS_NODE){var BUFSIZE=256;var buf=Buffer.alloc(BUFSIZE);var bytesRead=0;var fd=process.stdin.fd;try{bytesRead=fs.readSync(fd,buf,0,BUFSIZE)}catch(e){if(e.toString().includes("EOF"))bytesRead=0;else throw e}if(bytesRead>0){result=buf.slice(0,bytesRead).toString("utf-8")}}else if(typeof window!="undefined"&&typeof window.prompt=="function"){result=window.prompt("Input: ");if(result!==null){result+="\n"}}else{}if(!result){return null}FS_stdin_getChar_buffer=intArrayFromString(result,true)}return FS_stdin_getChar_buffer.shift()};var TTY={ttys:[],init(){},shutdown(){},register(dev,ops){TTY.ttys[dev]={input:[],output:[],ops};FS.registerDevice(dev,TTY.stream_ops)},stream_ops:{open(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(43)}stream.tty=tty;stream.seekable=false},close(stream){stream.tty.ops.fsync(stream.tty)},fsync(stream){stream.tty.ops.fsync(stream.tty)},read(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i0){out(UTF8ArrayToString(tty.output));tty.output=[]}},ioctl_tcgets(tty){return{c_iflag:25856,c_oflag:5,c_cflag:191,c_lflag:35387,c_cc:[3,28,127,21,4,0,1,0,17,19,26,0,18,15,23,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]}},ioctl_tcsets(tty,optional_actions,data){return 0},ioctl_tiocgwinsz(tty){return[24,80]}},default_tty1_ops:{put_char(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output&&tty.output.length>0){err(UTF8ArrayToString(tty.output));tty.output=[]}}}};var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var mmapAlloc=size=>{abort()};var MEMFS={ops_table:null,mount(mount){return MEMFS.createNode(null,"/",16895,0)},createNode(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(63)}MEMFS.ops_table||={dir:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,lookup:MEMFS.node_ops.lookup,mknod:MEMFS.node_ops.mknod,rename:MEMFS.node_ops.rename,unlink:MEMFS.node_ops.unlink,rmdir:MEMFS.node_ops.rmdir,readdir:MEMFS.node_ops.readdir,symlink:MEMFS.node_ops.symlink},stream:{llseek:MEMFS.stream_ops.llseek}},file:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:{llseek:MEMFS.stream_ops.llseek,read:MEMFS.stream_ops.read,write:MEMFS.stream_ops.write,allocate:MEMFS.stream_ops.allocate,mmap:MEMFS.stream_ops.mmap,msync:MEMFS.stream_ops.msync}},link:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr,readlink:MEMFS.node_ops.readlink},stream:{}},chrdev:{node:{getattr:MEMFS.node_ops.getattr,setattr:MEMFS.node_ops.setattr},stream:FS.chrdev_stream_ops}};var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={}}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=null}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream}node.atime=node.mtime=node.ctime=Date.now();if(parent){parent.contents[name]=node;parent.atime=parent.mtime=parent.ctime=node.atime}return node},getFileDataAsTypedArray(node){if(!node.contents)return new Uint8Array(0);if(node.contents.subarray)return node.contents.subarray(0,node.usedBytes);return new Uint8Array(node.contents)},expandFileStorage(node,newCapacity){var prevCapacity=node.contents?node.contents.length:0;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity>>0);if(prevCapacity!=0)newCapacity=Math.max(newCapacity,256);var oldContents=node.contents;node.contents=new Uint8Array(newCapacity);if(node.usedBytes>0)node.contents.set(oldContents.subarray(0,node.usedBytes),0)},resizeFileStorage(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{var oldContents=node.contents;node.contents=new Uint8Array(newSize);if(oldContents){node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)))}node.usedBytes=newSize}},node_ops:{getattr(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096}else if(FS.isFile(node.mode)){attr.size=node.usedBytes}else if(FS.isLink(node.mode)){attr.size=node.link.length}else{attr.size=0}attr.atime=new Date(node.atime);attr.mtime=new Date(node.mtime);attr.ctime=new Date(node.ctime);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr(node,attr){for(const key of["mode","atime","mtime","ctime"]){if(attr[key]!=null){node[key]=attr[key]}}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size)}},lookup(parent,name){throw MEMFS.doesNotExistError},mknod(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename(old_node,new_dir,new_name){var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(new_node){if(FS.isDir(old_node.mode)){for(var i in new_node.contents){throw new FS.ErrnoError(55)}}FS.hashRemoveNode(new_node)}delete old_node.parent.contents[old_node.name];new_dir.contents[new_name]=old_node;old_node.name=new_name;new_dir.ctime=new_dir.mtime=old_node.parent.ctime=old_node.parent.mtime=Date.now()},unlink(parent,name){delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},rmdir(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},readdir(node){return[".","..",...Object.keys(node.contents)]},symlink(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(28)}return node.link}},stream_ops:{read(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i0||position+length{var arrayBuffer=await readAsync(url);return new Uint8Array(arrayBuffer)};asyncLoad.isAsync=true;var FS_createDataFile=(parent,name,fileData,canRead,canWrite,canOwn)=>{FS.createDataFile(parent,name,fileData,canRead,canWrite,canOwn)};var preloadPlugins=Module["preloadPlugins"]||[];var FS_handledByPreloadPlugin=(byteArray,fullname,finish,onerror)=>{if(typeof Browser!="undefined")Browser.init();var handled=false;preloadPlugins.forEach(plugin=>{if(handled)return;if(plugin["canHandle"](fullname)){plugin["handle"](byteArray,fullname,finish,onerror);handled=true}});return handled};var FS_createPreloadedFile=(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish)=>{var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency(`cp ${fullname}`);function processData(byteArray){function finish(byteArray){preFinish?.();if(!dontCreateFile){FS_createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}onload?.();removeRunDependency(dep)}if(FS_handledByPreloadPlugin(byteArray,fullname,finish,()=>{onerror?.();removeRunDependency(dep)})){return}finish(byteArray)}addRunDependency(dep);if(typeof url=="string"){asyncLoad(url).then(processData,onerror)}else{processData(url)}};var FS_modeStringToFlags=str=>{var flagModes={r:0,"r+":2,w:512|64|1,"w+":512|64|2,a:1024|64|1,"a+":1024|64|2};var flags=flagModes[str];if(typeof flags=="undefined"){throw new Error(`Unknown file open mode: ${str}`)}return flags};var FS_getMode=(canRead,canWrite)=>{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:class{name="ErrnoError";constructor(errno){this.errno=errno}},filesystems:null,syncFSRequests:0,readFiles:{},FSStream:class{shared={};get object(){return this.node}set object(val){this.node=val}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(val){this.shared.flags=val}get position(){return this.shared.position}set position(val){this.shared.position=val}},FSNode:class{node_ops={};stream_ops={};readMode=292|73;writeMode=146;mounted=null;constructor(parent,name,mode,rdev){if(!parent){parent=this}this.parent=parent;this.mount=parent.mount;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.rdev=rdev;this.atime=this.mtime=this.ctime=Date.now()}get read(){return(this.mode&this.readMode)===this.readMode}set read(val){val?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(val){val?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return FS.isDir(this.mode)}get isDevice(){return FS.isChrdev(this.mode)}},lookupPath(path,opts={}){if(!path){throw new FS.ErrnoError(44)}opts.follow_mount??=true;if(!PATH.isAbs(path)){path=FS.cwd()+"/"+path}linkloop:for(var nlinks=0;nlinks<40;nlinks++){var parts=path.split("/").filter(p=>!!p);var current=FS.root;var current_path="/";for(var i=0;i>>0)%FS.nameTable.length},hashAddNode(node){var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode(node){var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode(parent,name){var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode(parent,name,mode,rdev){var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode(node){FS.hashRemoveNode(node)},isRoot(node){return node===node.parent},isMountpoint(node){return!!node.mounted},isFile(mode){return(mode&61440)===32768},isDir(mode){return(mode&61440)===16384},isLink(mode){return(mode&61440)===40960},isChrdev(mode){return(mode&61440)===8192},isBlkdev(mode){return(mode&61440)===24576},isFIFO(mode){return(mode&61440)===4096},isSocket(mode){return(mode&49152)===49152},flagsToPermissionString(flag){var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions(node,perms){if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup(dir){if(!FS.isDir(dir.mode))return 54;var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate(dir,name){if(!FS.isDir(dir.mode)){return 54}try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete(dir,name,isdir){var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen(node,flags){if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&(512|64)){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},checkOpExists(op,err){if(!op){throw new FS.ErrnoError(err)}return op},MAX_OPEN_FDS:4096,nextfd(){for(var fd=0;fd<=FS.MAX_OPEN_FDS;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStreamChecked(fd){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}return stream},getStream:fd=>FS.streams[fd],createStream(stream,fd=-1){stream=Object.assign(new FS.FSStream,stream);if(fd==-1){fd=FS.nextfd()}stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream(fd){FS.streams[fd]=null},dupStream(origStream,fd=-1){var stream=FS.createStream(origStream,fd);stream.stream_ops?.dup?.(stream);return stream},chrdev_stream_ops:{open(stream){var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;stream.stream_ops.open?.(stream)},llseek(){throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice(dev,ops){FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts(mount){var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push(...m.mounts)}return mounts},syncfs(populate,callback){if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`)}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}mounts.forEach(mount=>{if(!mount.type.syncfs){return done(null)}mount.type.syncfs(mount,populate,done)})},mount(type,opts,mountpoint){var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}var mount={type,opts,mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount)}}return mountRoot},unmount(mountpoint){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);Object.keys(FS.nameTable).forEach(hash=>{var current=FS.nameTable[hash];while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}});node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup(parent,name){return parent.node_ops.lookup(parent,name)},mknod(path,mode,dev){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name){throw new FS.ErrnoError(28)}if(name==="."||name===".."){throw new FS.ErrnoError(20)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},statfs(path){var rtn={bsize:4096,frsize:4096,blocks:1e6,bfree:5e5,bavail:5e5,files:FS.nextInode,ffree:FS.nextInode-1,fsid:42,flags:2,namelen:255};var parent=FS.lookupPath(path,{follow:true}).node;if(parent?.node_ops.statfs){Object.assign(rtn,parent.node_ops.statfs(parent.mount.opts.root))}return rtn},create(path,mode=438){mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir(path,mode=511){mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree(path,mode){var dirs=path.split("/");var d="";for(var i=0;iFS.currentPath,chdir(path){var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories(){FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices(){FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length,llseek:()=>0});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var randomBuffer=new Uint8Array(1024),randomLeft=0;var randomByte=()=>{if(randomLeft===0){randomFill(randomBuffer);randomLeft=randomBuffer.byteLength}return randomBuffer[--randomLeft]};FS.createDevice("/dev","random",randomByte);FS.createDevice("/dev","urandom",randomByte);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories(){FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount(){var node=FS.createNode(proc_self,"fd",16895,73);node.stream_ops={llseek:MEMFS.stream_ops.llseek};node.node_ops={lookup(parent,name){var fd=+name;var stream=FS.getStreamChecked(fd);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path},id:fd+1};ret.parent=ret;return ret},readdir(){return Array.from(FS.streams.entries()).filter(([k,v])=>v).map(([k,v])=>k.toString())}};return node}},{},"/proc/self/fd")},createStandardStreams(input,output,error){if(input){FS.createDevice("/dev","stdin",input)}else{FS.symlink("/dev/tty","/dev/stdin")}if(output){FS.createDevice("/dev","stdout",null,output)}else{FS.symlink("/dev/tty","/dev/stdout")}if(error){FS.createDevice("/dev","stderr",null,error)}else{FS.symlink("/dev/tty1","/dev/stderr")}var stdin=FS.open("/dev/stdin",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1)},staticInit(){FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={MEMFS}},init(input,output,error){FS.initialized=true;input??=Module["stdin"];output??=Module["stdout"];error??=Module["stderr"];FS.createStandardStreams(input,output,error)},quit(){FS.initialized=false;for(var i=0;ithis.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]}setDataGetter(getter){this.getter=getter}cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(from,to)=>{if(from>to)throw new Error("invalid range ("+from+", "+to+") or no bytes requested!");if(to>datalength-1)throw new Error("only "+datalength+" bytes available! programmer error!");var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range","bytes="+from+"-"+to);xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined")}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}return intArrayFromString(xhr.responseText||"",true)};var lazyArray=this;lazyArray.setDataGetter(chunkNum=>{var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]=="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end)}if(typeof lazyArray.chunks[chunkNum]=="undefined")throw new Error("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed")}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true}get length(){if(!this.lengthKnown){this.cacheLength()}return this._length}get chunkSize(){if(!this.lengthKnown){this.cacheLength()}return this._chunkSize}}if(typeof XMLHttpRequest!="undefined"){if(!ENVIRONMENT_IS_WORKER)throw"Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var lazyArray=new LazyUint8Array;var properties={isDevice:false,contents:lazyArray}}else{var properties={isDevice:false,url}}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents}else if(properties.url){node.contents=null;node.url=properties.url}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};var keys=Object.keys(node.stream_ops);keys.forEach(key=>{var fn=node.stream_ops[key];stream_ops[key]=(...args)=>{FS.forceLoadFile(node);return fn(...args)}});function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,HEAP8,ptr,length,position);return{ptr,allocated:true}};node.stream_ops=stream_ops;return node}};var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return dir+"/"+path},writeStat(buf,stat){HEAP32[buf>>2]=stat.dev;HEAP32[buf+4>>2]=stat.mode;HEAPU32[buf+8>>2]=stat.nlink;HEAP32[buf+12>>2]=stat.uid;HEAP32[buf+16>>2]=stat.gid;HEAP32[buf+20>>2]=stat.rdev;HEAP64[buf+24>>3]=BigInt(stat.size);HEAP32[buf+32>>2]=4096;HEAP32[buf+36>>2]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();HEAP64[buf+40>>3]=BigInt(Math.floor(atime/1e3));HEAPU32[buf+48>>2]=atime%1e3*1e3*1e3;HEAP64[buf+56>>3]=BigInt(Math.floor(mtime/1e3));HEAPU32[buf+64>>2]=mtime%1e3*1e3*1e3;HEAP64[buf+72>>3]=BigInt(Math.floor(ctime/1e3));HEAPU32[buf+80>>2]=ctime%1e3*1e3*1e3;HEAP64[buf+88>>3]=BigInt(stat.ino);return 0},doMsync(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=HEAPU8.slice(addr,addr+len);FS.msync(stream,buffer,offset,len,flags)},getStreamFromFD(fd){var stream=FS.getStreamChecked(fd);return stream},varargs:undefined,getStr(ptr){var ret=UTF8ToString(ptr);return ret}};var ___syscall__newselect=function(nfds,readfds,writefds,exceptfds,timeout){try{var total=0;var srcReadLow=readfds?HEAP32[readfds>>2]:0,srcReadHigh=readfds?HEAP32[readfds+4>>2]:0;var srcWriteLow=writefds?HEAP32[writefds>>2]:0,srcWriteHigh=writefds?HEAP32[writefds+4>>2]:0;var srcExceptLow=exceptfds?HEAP32[exceptfds>>2]:0,srcExceptHigh=exceptfds?HEAP32[exceptfds+4>>2]:0;var dstReadLow=0,dstReadHigh=0;var dstWriteLow=0,dstWriteHigh=0;var dstExceptLow=0,dstExceptHigh=0;var allLow=(readfds?HEAP32[readfds>>2]:0)|(writefds?HEAP32[writefds>>2]:0)|(exceptfds?HEAP32[exceptfds>>2]:0);var allHigh=(readfds?HEAP32[readfds+4>>2]:0)|(writefds?HEAP32[writefds+4>>2]:0)|(exceptfds?HEAP32[exceptfds+4>>2]:0);var check=(fd,low,high,val)=>fd<32?low&val:high&val;for(var fd=0;fd>2]:0,tv_usec=readfds?HEAP32[timeout+4>>2]:0;timeoutInMillis=(tv_sec+tv_usec/1e6)*1e3}flags=stream.stream_ops.poll(stream,timeoutInMillis)}if(flags&1&&check(fd,srcReadLow,srcReadHigh,mask)){fd<32?dstReadLow=dstReadLow|mask:dstReadHigh=dstReadHigh|mask;total++}if(flags&4&&check(fd,srcWriteLow,srcWriteHigh,mask)){fd<32?dstWriteLow=dstWriteLow|mask:dstWriteHigh=dstWriteHigh|mask;total++}if(flags&2&&check(fd,srcExceptLow,srcExceptHigh,mask)){fd<32?dstExceptLow=dstExceptLow|mask:dstExceptHigh=dstExceptHigh|mask;total++}}if(readfds){HEAP32[readfds>>2]=dstReadLow;HEAP32[readfds+4>>2]=dstReadHigh}if(writefds){HEAP32[writefds>>2]=dstWriteLow;HEAP32[writefds+4>>2]=dstWriteHigh}if(exceptfds){HEAP32[exceptfds>>2]=dstExceptLow;HEAP32[exceptfds+4>>2]=dstExceptHigh}return total}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}};function ___syscall_dup3(fd,newfd,flags){try{var old=SYSCALLS.getStreamFromFD(fd);if(old.fd===newfd)return-28;if(newfd<0||newfd>=FS.MAX_OPEN_FDS)return-8;var existing=FS.getStream(newfd);if(existing)FS.close(existing);return FS.dupStream(old,newfd).fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_faccessat(dirfd,path,amode,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(amode&~7){return-28}var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node){return-44}var perms="";if(amode&4)perms+="r";if(amode&2)perms+="w";if(amode&1)perms+="x";if(perms&&FS.nodePermissions(node,perms)){return-2}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var syscallGetVarargI=()=>{var ret=HEAP32[+SYSCALLS.varargs>>2];SYSCALLS.varargs+=4;return ret};var syscallGetVarargP=syscallGetVarargI;function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=syscallGetVarargI();if(arg<0){return-28}while(FS.streams[arg]){arg++}var newStream;newStream=FS.dupStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=syscallGetVarargI();stream.flags|=arg;return 0}case 12:{var arg=syscallGetVarargP();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 13:case 14:return 0}return-28}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_fstat64(fd,buf){try{var stream=SYSCALLS.getStreamFromFD(fd);return SYSCALLS.writeStat(buf,FS.stat(stream.path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);function ___syscall_getdents64(fd,dirp,count){try{var stream=SYSCALLS.getStreamFromFD(fd);stream.getdents||=FS.readdir(stream.path);var struct_size=280;var pos=0;var off=FS.llseek(stream,0,1);var startIdx=Math.floor(off/struct_size);var endIdx=Math.min(stream.getdents.length,startIdx+Math.floor(count/struct_size));for(var idx=startIdx;idx>3]=BigInt(id);HEAP64[dirp+pos+8>>3]=BigInt((idx+1)*struct_size);HEAP16[dirp+pos+16>>1]=280;HEAP8[dirp+pos+18]=type;stringToUTF8(name,dirp+pos+19,256);pos+=struct_size}FS.llseek(stream,idx*struct_size,0);return pos}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_ioctl(fd,op,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(op){case 21509:{if(!stream.tty)return-59;return 0}case 21505:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcgets){var termios=stream.tty.ops.ioctl_tcgets(stream);var argp=syscallGetVarargP();HEAP32[argp>>2]=termios.c_iflag||0;HEAP32[argp+4>>2]=termios.c_oflag||0;HEAP32[argp+8>>2]=termios.c_cflag||0;HEAP32[argp+12>>2]=termios.c_lflag||0;for(var i=0;i<32;i++){HEAP8[argp+i+17]=termios.c_cc[i]||0}return 0}return 0}case 21510:case 21511:case 21512:{if(!stream.tty)return-59;return 0}case 21506:case 21507:case 21508:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcsets){var argp=syscallGetVarargP();var c_iflag=HEAP32[argp>>2];var c_oflag=HEAP32[argp+4>>2];var c_cflag=HEAP32[argp+8>>2];var c_lflag=HEAP32[argp+12>>2];var c_cc=[];for(var i=0;i<32;i++){c_cc.push(HEAP8[argp+i+17])}return stream.tty.ops.ioctl_tcsets(stream.tty,op,{c_iflag,c_oflag,c_cflag,c_lflag,c_cc})}return 0}case 21519:{if(!stream.tty)return-59;var argp=syscallGetVarargP();HEAP32[argp>>2]=0;return 0}case 21520:{if(!stream.tty)return-59;return-28}case 21531:{var argp=syscallGetVarargP();return FS.ioctl(stream,op,argp)}case 21523:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tiocgwinsz){var winsize=stream.tty.ops.ioctl_tiocgwinsz(stream.tty);var argp=syscallGetVarargP();HEAP16[argp>>1]=winsize[0];HEAP16[argp+2>>1]=winsize[1]}return 0}case 21524:{if(!stream.tty)return-59;return 0}case 21515:{if(!stream.tty)return-59;return 0}default:return-28}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_lstat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.writeStat(buf,FS.lstat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_mkdirat(dirfd,path,mode){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);FS.mkdir(path,mode,0);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_newfstatat(dirfd,path,buf,flags){try{path=SYSCALLS.getStr(path);var nofollow=flags&256;var allowEmpty=flags&4096;flags=flags&~6400;path=SYSCALLS.calculateAt(dirfd,path,allowEmpty);return SYSCALLS.writeStat(buf,nofollow?FS.lstat(path):FS.stat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?syscallGetVarargI():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_renameat(olddirfd,oldpath,newdirfd,newpath){try{oldpath=SYSCALLS.getStr(oldpath);newpath=SYSCALLS.getStr(newpath);oldpath=SYSCALLS.calculateAt(olddirfd,oldpath);newpath=SYSCALLS.calculateAt(newdirfd,newpath);FS.rename(oldpath,newpath);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_rmdir(path){try{path=SYSCALLS.getStr(path);FS.rmdir(path);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_stat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.writeStat(buf,FS.stat(path))}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_unlinkat(dirfd,path,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(flags===0){FS.unlink(path)}else if(flags===512){FS.rmdir(path)}else{abort("Invalid flags passed to unlinkat")}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var __abort_js=()=>abort("");var __emscripten_throw_longjmp=()=>{throw Infinity};var INT53_MAX=9007199254740992;var INT53_MIN=-9007199254740992;var bigintToI53Checked=num=>numINT53_MAX?NaN:Number(num);function __gmtime_js(time,tmPtr){time=bigintToI53Checked(time);var date=new Date(time*1e3);HEAP32[tmPtr>>2]=date.getUTCSeconds();HEAP32[tmPtr+4>>2]=date.getUTCMinutes();HEAP32[tmPtr+8>>2]=date.getUTCHours();HEAP32[tmPtr+12>>2]=date.getUTCDate();HEAP32[tmPtr+16>>2]=date.getUTCMonth();HEAP32[tmPtr+20>>2]=date.getUTCFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getUTCDay();var start=Date.UTC(date.getUTCFullYear(),0,1,0,0,0,0);var yday=(date.getTime()-start)/(1e3*60*60*24)|0;HEAP32[tmPtr+28>>2]=yday}var isLeapYear=year=>year%4===0&&(year%100!==0||year%400===0);var MONTH_DAYS_LEAP_CUMULATIVE=[0,31,60,91,121,152,182,213,244,274,305,335];var MONTH_DAYS_REGULAR_CUMULATIVE=[0,31,59,90,120,151,181,212,243,273,304,334];var ydayFromDate=date=>{var leap=isLeapYear(date.getFullYear());var monthDaysCumulative=leap?MONTH_DAYS_LEAP_CUMULATIVE:MONTH_DAYS_REGULAR_CUMULATIVE;var yday=monthDaysCumulative[date.getMonth()]+date.getDate()-1;return yday};function __localtime_js(time,tmPtr){time=bigintToI53Checked(time);var date=new Date(time*1e3);HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getDay();var yday=ydayFromDate(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr+36>>2]=-(date.getTimezoneOffset()*60);var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dst=(summerOffset!=winterOffset&&date.getTimezoneOffset()==Math.min(winterOffset,summerOffset))|0;HEAP32[tmPtr+32>>2]=dst}var __mktime_js=function(tmPtr){var ret=(()=>{var date=new Date(HEAP32[tmPtr+20>>2]+1900,HEAP32[tmPtr+16>>2],HEAP32[tmPtr+12>>2],HEAP32[tmPtr+8>>2],HEAP32[tmPtr+4>>2],HEAP32[tmPtr>>2],0);var dst=HEAP32[tmPtr+32>>2];var guessedOffset=date.getTimezoneOffset();var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dstOffset=Math.min(winterOffset,summerOffset);if(dst<0){HEAP32[tmPtr+32>>2]=Number(summerOffset!=winterOffset&&dstOffset==guessedOffset)}else if(dst>0!=(dstOffset==guessedOffset)){var nonDstOffset=Math.max(winterOffset,summerOffset);var trueOffset=dst>0?dstOffset:nonDstOffset;date.setTime(date.getTime()+(trueOffset-guessedOffset)*6e4)}HEAP32[tmPtr+24>>2]=date.getDay();var yday=ydayFromDate(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getYear();var timeMs=date.getTime();if(isNaN(timeMs)){return-1}return timeMs/1e3})();return BigInt(ret)};var __tzset_js=(timezone,daylight,std_name,dst_name)=>{var currentYear=(new Date).getFullYear();var winter=new Date(currentYear,0,1);var summer=new Date(currentYear,6,1);var winterOffset=winter.getTimezoneOffset();var summerOffset=summer.getTimezoneOffset();var stdTimezoneOffset=Math.max(winterOffset,summerOffset);HEAPU32[timezone>>2]=stdTimezoneOffset*60;HEAP32[daylight>>2]=Number(winterOffset!=summerOffset);var extractZone=timezoneOffset=>{var sign=timezoneOffset>=0?"-":"+";var absOffset=Math.abs(timezoneOffset);var hours=String(Math.floor(absOffset/60)).padStart(2,"0");var minutes=String(absOffset%60).padStart(2,"0");return`UTC${sign}${hours}${minutes}`};var winterName=extractZone(winterOffset);var summerName=extractZone(summerOffset);if(summerOffsetperformance.now();var _emscripten_date_now=()=>Date.now();var nowIsMonotonic=1;var checkWasiClock=clock_id=>clock_id>=0&&clock_id<=3;function _clock_time_get(clk_id,ignored_precision,ptime){ignored_precision=bigintToI53Checked(ignored_precision);if(!checkWasiClock(clk_id)){return 28}var now;if(clk_id===0){now=_emscripten_date_now()}else if(nowIsMonotonic){now=_emscripten_get_now()}else{return 52}var nsec=Math.round(now*1e3*1e3);HEAP64[ptime>>3]=BigInt(nsec);return 0}var readEmAsmArgsArray=[];var readEmAsmArgs=(sigPtr,buf)=>{readEmAsmArgsArray.length=0;var ch;while(ch=HEAPU8[sigPtr++]){var wide=ch!=105;wide&=ch!=112;buf+=wide&&buf%8?4:0;readEmAsmArgsArray.push(ch==112?HEAPU32[buf>>2]:ch==106?HEAP64[buf>>3]:ch==105?HEAP32[buf>>2]:HEAPF64[buf>>3]);buf+=wide?8:4}return readEmAsmArgsArray};var runEmAsmFunction=(code,sigPtr,argbuf)=>{var args=readEmAsmArgs(sigPtr,argbuf);return ASM_CONSTS[code](...args)};var _emscripten_asm_const_int=(code,sigPtr,argbuf)=>runEmAsmFunction(code,sigPtr,argbuf);var runAndAbortIfError=func=>{try{return func()}catch(e){abort(e)}};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var runtimeKeepaliveCounter=0;var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))};var exitJS=(status,implicit)=>{EXITSTATUS=status;_proc_exit(status)};var _exit=exitJS;var maybeExit=()=>{if(!keepRuntimeAlive()){try{_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(ABORT){return}try{func();maybeExit()}catch(e){handleException(e)}};var runtimeKeepalivePush=()=>{runtimeKeepaliveCounter+=1};var runtimeKeepalivePop=()=>{runtimeKeepaliveCounter-=1};var Asyncify={instrumentWasmImports(imports){var importPattern=/^(libavjs_wait_reader|invoke_.*|__asyncjs__.*)$/;for(let[x,original]of Object.entries(imports)){if(typeof original=="function"){let isAsyncifyImport=original.isAsync||importPattern.test(x)}}},instrumentWasmExports(exports){var ret={};for(let[x,original]of Object.entries(exports)){if(typeof original=="function"){ret[x]=(...args)=>{Asyncify.exportCallStack.push(x);try{return original(...args)}finally{if(!ABORT){var y=Asyncify.exportCallStack.pop();Asyncify.maybeStopUnwind()}}}}else{ret[x]=original}}return ret},State:{Normal:0,Unwinding:1,Rewinding:2,Disabled:3},state:0,StackSize:4096,currData:null,handleSleepReturnValue:0,exportCallStack:[],callStackNameToId:{},callStackIdToName:{},callStackId:0,asyncPromiseHandlers:null,sleepCallbacks:[],getCallStackId(funcName){var id=Asyncify.callStackNameToId[funcName];if(id===undefined){id=Asyncify.callStackId++;Asyncify.callStackNameToId[funcName]=id;Asyncify.callStackIdToName[id]=funcName}return id},maybeStopUnwind(){if(Asyncify.currData&&Asyncify.state===Asyncify.State.Unwinding&&Asyncify.exportCallStack.length===0){Asyncify.state=Asyncify.State.Normal;runAndAbortIfError(_asyncify_stop_unwind);if(typeof Fibers!="undefined"){Fibers.trampoline()}}},whenDone(){return new Promise((resolve,reject)=>{Asyncify.asyncPromiseHandlers={resolve,reject}})},allocateData(){var ptr=_malloc(12+Asyncify.StackSize);Asyncify.setDataHeader(ptr,ptr+12,Asyncify.StackSize);Asyncify.setDataRewindFunc(ptr);return ptr},setDataHeader(ptr,stack,stackSize){HEAPU32[ptr>>2]=stack;HEAPU32[ptr+4>>2]=stack+stackSize},setDataRewindFunc(ptr){var bottomOfCallStack=Asyncify.exportCallStack[0];var rewindId=Asyncify.getCallStackId(bottomOfCallStack);HEAP32[ptr+8>>2]=rewindId},getDataRewindFuncName(ptr){var id=HEAP32[ptr+8>>2];var name=Asyncify.callStackIdToName[id];return name},getDataRewindFunc(name){var func=wasmExports[name];return func},doRewind(ptr){var name=Asyncify.getDataRewindFuncName(ptr);var func=Asyncify.getDataRewindFunc(name);return func()},handleSleep(startAsync){if(ABORT)return;if(Asyncify.state===Asyncify.State.Normal){var reachedCallback=false;var reachedAfterCallback=false;startAsync((handleSleepReturnValue=0)=>{if(ABORT)return;Asyncify.handleSleepReturnValue=handleSleepReturnValue;reachedCallback=true;if(!reachedAfterCallback){return}Asyncify.state=Asyncify.State.Rewinding;runAndAbortIfError(()=>_asyncify_start_rewind(Asyncify.currData));if(typeof MainLoop!="undefined"&&MainLoop.func){MainLoop.resume()}var asyncWasmReturnValue,isError=false;try{asyncWasmReturnValue=Asyncify.doRewind(Asyncify.currData)}catch(err){asyncWasmReturnValue=err;isError=true}var handled=false;if(!Asyncify.currData){var asyncPromiseHandlers=Asyncify.asyncPromiseHandlers;if(asyncPromiseHandlers){Asyncify.asyncPromiseHandlers=null;(isError?asyncPromiseHandlers.reject:asyncPromiseHandlers.resolve)(asyncWasmReturnValue);handled=true}}if(isError&&!handled){throw asyncWasmReturnValue}});reachedAfterCallback=true;if(!reachedCallback){Asyncify.state=Asyncify.State.Unwinding;Asyncify.currData=Asyncify.allocateData();if(typeof MainLoop!="undefined"&&MainLoop.func){MainLoop.pause()}runAndAbortIfError(()=>_asyncify_start_unwind(Asyncify.currData))}}else if(Asyncify.state===Asyncify.State.Rewinding){Asyncify.state=Asyncify.State.Normal;runAndAbortIfError(_asyncify_stop_rewind);_free(Asyncify.currData);Asyncify.currData=null;Asyncify.sleepCallbacks.forEach(callUserCallback)}else{abort(`invalid state: ${Asyncify.state}`)}return Asyncify.handleSleepReturnValue},handleAsync(startAsync){return Asyncify.handleSleep(wakeUp=>{startAsync().then(wakeUp)})}};var Fibers={nextFiber:0,trampolineRunning:false,trampoline(){if(!Fibers.trampolineRunning&&Fibers.nextFiber){Fibers.trampolineRunning=true;do{var fiber=Fibers.nextFiber;Fibers.nextFiber=0;Fibers.finishContextSwitch(fiber)}while(Fibers.nextFiber);Fibers.trampolineRunning=false}},finishContextSwitch(newFiber){var stack_base=HEAPU32[newFiber>>2];var stack_max=HEAPU32[newFiber+4>>2];_emscripten_stack_set_limits(stack_base,stack_max);stackRestore(HEAPU32[newFiber+8>>2]);var entryPoint=HEAPU32[newFiber+12>>2];if(entryPoint!==0){Asyncify.currData=null;HEAPU32[newFiber+12>>2]=0;var userData=HEAPU32[newFiber+16>>2];(a1=>dynCall_vi(entryPoint,a1))(userData)}else{var asyncifyData=newFiber+20;Asyncify.currData=asyncifyData;Asyncify.state=Asyncify.State.Rewinding;_asyncify_start_rewind(asyncifyData);Asyncify.doRewind(asyncifyData)}}};var _emscripten_fiber_swap=(oldFiber,newFiber)=>{if(ABORT)return;if(Asyncify.state===Asyncify.State.Normal){Asyncify.state=Asyncify.State.Unwinding;var asyncifyData=oldFiber+20;Asyncify.setDataRewindFunc(asyncifyData);Asyncify.currData=asyncifyData;_asyncify_start_unwind(asyncifyData);var stackTop=stackSave();HEAPU32[oldFiber+8>>2]=stackTop;Fibers.nextFiber=newFiber}else{Asyncify.state=Asyncify.State.Normal;_asyncify_stop_rewind();Asyncify.currData=null}};_emscripten_fiber_swap.isAsync=true;var getHeapMax=()=>2147483648;var _emscripten_get_heap_max=()=>getHeapMax();var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var ENV={};var getExecutableName=()=>thisProgram||"./this.program";var getEnvStrings=()=>{if(!getEnvStrings.strings){var lang=(typeof navigator=="object"&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8";var env={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:lang,_:getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(`${x}=${env[x]}`)}getEnvStrings.strings=strings}return getEnvStrings.strings};var stringToAscii=(str,buffer)=>{for(var i=0;i{var bufSize=0;getEnvStrings().forEach((string,i)=>{var ptr=environ_buf+bufSize;HEAPU32[__environ+i*4>>2]=ptr;stringToAscii(string,ptr);bufSize+=string.length+1});return 0};var _environ_sizes_get=(penviron_count,penviron_buf_size)=>{var strings=getEnvStrings();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;strings.forEach(string=>bufSize+=string.length+1);HEAPU32[penviron_buf_size>>2]=bufSize;return 0};function _fd_close(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_fdstat_get(fd,pbuf){try{var rightsBase=0;var rightsInheriting=0;var flags=0;{var stream=SYSCALLS.getStreamFromFD(fd);var type=stream.tty?2:FS.isDir(stream.mode)?3:FS.isLink(stream.mode)?7:4}HEAP8[pbuf]=type;HEAP16[pbuf+2>>1]=flags;HEAP64[pbuf+8>>3]=BigInt(rightsBase);HEAP64[pbuf+16>>3]=BigInt(rightsInheriting);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doReadv=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_seek(fd,offset,whence,newOffset){offset=bigintToI53Checked(offset);try{if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);HEAP64[newOffset>>3]=BigInt(stream.position);if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doWritev=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var wasmTable;var getCFunc=ident=>{var func=Module["_"+ident];return func};var writeArrayToMemory=(array,buffer)=>{HEAP8.set(array,buffer)};var stackAlloc=sz=>__emscripten_stack_alloc(sz);var stringToUTF8OnStack=str=>{var size=lengthBytesUTF8(str)+1;var ret=stackAlloc(size);stringToUTF8(str,ret,size);return ret};var ccall=(ident,returnType,argTypes,args,opts)=>{var toC={string:str=>{var ret=0;if(str!==null&&str!==undefined&&str!==0){ret=stringToUTF8OnStack(str)}return ret},array:arr=>{var ret=stackAlloc(arr.length);writeArrayToMemory(arr,ret);return ret}};function convertReturnValue(ret){if(returnType==="string"){return UTF8ToString(ret)}if(returnType==="boolean")return Boolean(ret);return ret}var func=getCFunc(ident);var cArgs=[];var stack=0;if(args){for(var i=0;i{var numericArgs=!argTypes||argTypes.every(type=>type==="number"||type==="boolean");var numericRet=returnType!=="string";if(numericRet&&numericArgs&&!opts){return getCFunc(ident)}return(...args)=>ccall(ident,returnType,argTypes,args,opts)};FS.createPreloadedFile=FS_createPreloadedFile;FS.staticInit();MEMFS.doesNotExistError=new FS.ErrnoError(44);MEMFS.doesNotExistError.stack="";var wasmImports={a:___assert_fail,F:___syscall__newselect,A:___syscall_dup3,X:___syscall_faccessat,q:___syscall_fcntl64,V:___syscall_fstat64,I:___syscall_getdents64,p:___syscall_ioctl,S:___syscall_lstat64,N:___syscall_mkdirat,T:___syscall_newfstatat,w:___syscall_openat,H:___syscall_renameat,G:___syscall_rmdir,U:___syscall_stat64,D:___syscall_unlinkat,Z:__abort_js,B:__emscripten_throw_longjmp,J:__gmtime_js,K:__localtime_js,L:__mktime_js,M:__tzset_js,W:_clock_time_get,$:emfiberthreads_pthread_mutex_timedwait_clearTimeout,aa:emfiberthreads_pthread_mutex_timedwait_setTimeout,_:_emscripten_asm_const_int,x:_emscripten_date_now,ba:_emscripten_fiber_swap,E:_emscripten_get_heap_max,u:_emscripten_get_now,C:_emscripten_resize_heap,Q:_environ_get,R:_environ_sizes_get,i:_exit,l:_fd_close,v:_fd_fdstat_get,y:_fd_read,O:_fd_seek,o:_fd_write,s:invoke_i,e:invoke_ii,c:invoke_iii,k:invoke_iiii,j:invoke_iiiii,ja:invoke_iiiiii,la:invoke_iiiiiiiii,z:invoke_iiiiiiiiii,ea:invoke_iiiiiiiiiii,fa:invoke_iiiiiiiiiiii,t:invoke_iiiijj,n:invoke_jij,d:invoke_vi,f:invoke_vii,g:invoke_viii,ka:invoke_viiid,b:invoke_viiii,h:invoke_viiiii,ha:invoke_viiiiii,m:invoke_viiiiiii,r:invoke_viiiiiiii,ga:invoke_viiiiiiiii,da:invoke_viiiiiiiiiii,P:jsfetch_close_js,ca:jsfetch_open_js,Y:jsfetch_read_js,ia:libavjs_wait_reader,ma:writeoutEmscriptenOOM};var wasmExports=await createWasm();var ___wasm_call_ctors=wasmExports["oa"];var _ff_nothing=Module["_ff_nothing"]=wasmExports["pa"];var _AVFrame_crop_bottom=Module["_AVFrame_crop_bottom"]=wasmExports["qa"];var _AVFrame_crop_bottom_s=Module["_AVFrame_crop_bottom_s"]=wasmExports["ra"];var _AVFrame_crop_left=Module["_AVFrame_crop_left"]=wasmExports["sa"];var _AVFrame_crop_left_s=Module["_AVFrame_crop_left_s"]=wasmExports["ta"];var _AVFrame_crop_right=Module["_AVFrame_crop_right"]=wasmExports["ua"];var _AVFrame_crop_right_s=Module["_AVFrame_crop_right_s"]=wasmExports["va"];var _AVFrame_crop_top=Module["_AVFrame_crop_top"]=wasmExports["wa"];var _AVFrame_crop_top_s=Module["_AVFrame_crop_top_s"]=wasmExports["xa"];var _AVFrame_data_a=Module["_AVFrame_data_a"]=wasmExports["ya"];var _AVFrame_data_a_s=Module["_AVFrame_data_a_s"]=wasmExports["za"];var _AVFrame_format=Module["_AVFrame_format"]=wasmExports["Aa"];var _AVFrame_format_s=Module["_AVFrame_format_s"]=wasmExports["Ba"];var _AVFrame_height=Module["_AVFrame_height"]=wasmExports["Ca"];var _AVFrame_height_s=Module["_AVFrame_height_s"]=wasmExports["Da"];var _AVFrame_key_frame=Module["_AVFrame_key_frame"]=wasmExports["Ea"];var _AVFrame_key_frame_s=Module["_AVFrame_key_frame_s"]=wasmExports["Fa"];var _AVFrame_linesize_a=Module["_AVFrame_linesize_a"]=wasmExports["Ga"];var _AVFrame_linesize_a_s=Module["_AVFrame_linesize_a_s"]=wasmExports["Ha"];var _AVFrame_nb_samples=Module["_AVFrame_nb_samples"]=wasmExports["Ia"];var _AVFrame_nb_samples_s=Module["_AVFrame_nb_samples_s"]=wasmExports["Ja"];var _AVFrame_pict_type=Module["_AVFrame_pict_type"]=wasmExports["Ka"];var _AVFrame_pict_type_s=Module["_AVFrame_pict_type_s"]=wasmExports["La"];var _AVFrame_pts=Module["_AVFrame_pts"]=wasmExports["Ma"];var _AVFrame_ptshi=Module["_AVFrame_ptshi"]=wasmExports["Na"];var _AVFrame_pts_s=Module["_AVFrame_pts_s"]=wasmExports["Oa"];var _AVFrame_ptshi_s=Module["_AVFrame_ptshi_s"]=wasmExports["Pa"];var _AVFrame_sample_rate=Module["_AVFrame_sample_rate"]=wasmExports["Qa"];var _AVFrame_sample_rate_s=Module["_AVFrame_sample_rate_s"]=wasmExports["Ra"];var _AVFrame_width=Module["_AVFrame_width"]=wasmExports["Sa"];var _AVFrame_width_s=Module["_AVFrame_width_s"]=wasmExports["Ta"];var _AVFrame_sample_aspect_ratio_num=Module["_AVFrame_sample_aspect_ratio_num"]=wasmExports["Ua"];var _AVFrame_sample_aspect_ratio_den=Module["_AVFrame_sample_aspect_ratio_den"]=wasmExports["Va"];var _AVFrame_sample_aspect_ratio_num_s=Module["_AVFrame_sample_aspect_ratio_num_s"]=wasmExports["Wa"];var _AVFrame_sample_aspect_ratio_den_s=Module["_AVFrame_sample_aspect_ratio_den_s"]=wasmExports["Xa"];var _AVFrame_sample_aspect_ratio_s=Module["_AVFrame_sample_aspect_ratio_s"]=wasmExports["Ya"];var _AVFrame_time_base_num=Module["_AVFrame_time_base_num"]=wasmExports["Za"];var _AVFrame_time_base_den=Module["_AVFrame_time_base_den"]=wasmExports["_a"];var _AVFrame_time_base_num_s=Module["_AVFrame_time_base_num_s"]=wasmExports["$a"];var _AVFrame_time_base_den_s=Module["_AVFrame_time_base_den_s"]=wasmExports["ab"];var _AVFrame_time_base_s=Module["_AVFrame_time_base_s"]=wasmExports["bb"];var _AVFrame_channel_layoutmask_s=Module["_AVFrame_channel_layoutmask_s"]=wasmExports["cb"];var _AVFrame_channel_layoutmask=Module["_AVFrame_channel_layoutmask"]=wasmExports["db"];var _AVFrame_channels=Module["_AVFrame_channels"]=wasmExports["eb"];var _AVFrame_channels_s=Module["_AVFrame_channels_s"]=wasmExports["fb"];var _AVFrame_ch_layout_nb_channels=Module["_AVFrame_ch_layout_nb_channels"]=wasmExports["gb"];var _AVFrame_ch_layout_nb_channels_s=Module["_AVFrame_ch_layout_nb_channels_s"]=wasmExports["hb"];var _AVFrame_channel_layout=Module["_AVFrame_channel_layout"]=wasmExports["ib"];var _AVFrame_channel_layouthi=Module["_AVFrame_channel_layouthi"]=wasmExports["jb"];var _AVFrame_channel_layout_s=Module["_AVFrame_channel_layout_s"]=wasmExports["kb"];var _AVFrame_channel_layouthi_s=Module["_AVFrame_channel_layouthi_s"]=wasmExports["lb"];var _ff_frame_rescale_ts_js=Module["_ff_frame_rescale_ts_js"]=wasmExports["mb"];var _AVPixFmtDescriptor_flags=Module["_AVPixFmtDescriptor_flags"]=wasmExports["nb"];var _AVPixFmtDescriptor_flags_s=Module["_AVPixFmtDescriptor_flags_s"]=wasmExports["ob"];var _AVPixFmtDescriptor_nb_components=Module["_AVPixFmtDescriptor_nb_components"]=wasmExports["pb"];var _AVPixFmtDescriptor_nb_components_s=Module["_AVPixFmtDescriptor_nb_components_s"]=wasmExports["qb"];var _AVPixFmtDescriptor_log2_chroma_h=Module["_AVPixFmtDescriptor_log2_chroma_h"]=wasmExports["rb"];var _AVPixFmtDescriptor_log2_chroma_h_s=Module["_AVPixFmtDescriptor_log2_chroma_h_s"]=wasmExports["sb"];var _AVPixFmtDescriptor_log2_chroma_w=Module["_AVPixFmtDescriptor_log2_chroma_w"]=wasmExports["tb"];var _AVPixFmtDescriptor_log2_chroma_w_s=Module["_AVPixFmtDescriptor_log2_chroma_w_s"]=wasmExports["ub"];var _AVPixFmtDescriptor_comp_depth=Module["_AVPixFmtDescriptor_comp_depth"]=wasmExports["vb"];var _av_opt_set_int_list_js=Module["_av_opt_set_int_list_js"]=wasmExports["wb"];var _AVCodec_name=Module["_AVCodec_name"]=wasmExports["xb"];var _AVCodec_sample_fmts=Module["_AVCodec_sample_fmts"]=wasmExports["yb"];var _AVCodec_sample_fmts_s=Module["_AVCodec_sample_fmts_s"]=wasmExports["zb"];var _AVCodec_sample_fmts_a=Module["_AVCodec_sample_fmts_a"]=wasmExports["Ab"];var _AVCodec_sample_fmts_a_s=Module["_AVCodec_sample_fmts_a_s"]=wasmExports["Bb"];var _AVCodec_supported_samplerates=Module["_AVCodec_supported_samplerates"]=wasmExports["Cb"];var _AVCodec_supported_samplerates_s=Module["_AVCodec_supported_samplerates_s"]=wasmExports["Db"];var _AVCodec_supported_samplerates_a=Module["_AVCodec_supported_samplerates_a"]=wasmExports["Eb"];var _AVCodec_supported_samplerates_a_s=Module["_AVCodec_supported_samplerates_a_s"]=wasmExports["Fb"];var _AVCodec_type=Module["_AVCodec_type"]=wasmExports["Gb"];var _AVCodec_type_s=Module["_AVCodec_type_s"]=wasmExports["Hb"];var _AVCodecContext_codec_id=Module["_AVCodecContext_codec_id"]=wasmExports["Ib"];var _AVCodecContext_codec_id_s=Module["_AVCodecContext_codec_id_s"]=wasmExports["Jb"];var _AVCodecContext_codec_type=Module["_AVCodecContext_codec_type"]=wasmExports["Kb"];var _AVCodecContext_codec_type_s=Module["_AVCodecContext_codec_type_s"]=wasmExports["Lb"];var _AVCodecContext_bit_rate=Module["_AVCodecContext_bit_rate"]=wasmExports["Mb"];var _AVCodecContext_bit_ratehi=Module["_AVCodecContext_bit_ratehi"]=wasmExports["Nb"];var _AVCodecContext_bit_rate_s=Module["_AVCodecContext_bit_rate_s"]=wasmExports["Ob"];var _AVCodecContext_bit_ratehi_s=Module["_AVCodecContext_bit_ratehi_s"]=wasmExports["Pb"];var _AVCodecContext_extradata=Module["_AVCodecContext_extradata"]=wasmExports["Qb"];var _AVCodecContext_extradata_s=Module["_AVCodecContext_extradata_s"]=wasmExports["Rb"];var _AVCodecContext_extradata_size=Module["_AVCodecContext_extradata_size"]=wasmExports["Sb"];var _AVCodecContext_extradata_size_s=Module["_AVCodecContext_extradata_size_s"]=wasmExports["Tb"];var _AVCodecContext_frame_size=Module["_AVCodecContext_frame_size"]=wasmExports["Ub"];var _AVCodecContext_frame_size_s=Module["_AVCodecContext_frame_size_s"]=wasmExports["Vb"];var _AVCodecContext_gop_size=Module["_AVCodecContext_gop_size"]=wasmExports["Wb"];var _AVCodecContext_gop_size_s=Module["_AVCodecContext_gop_size_s"]=wasmExports["Xb"];var _AVCodecContext_height=Module["_AVCodecContext_height"]=wasmExports["Yb"];var _AVCodecContext_height_s=Module["_AVCodecContext_height_s"]=wasmExports["Zb"];var _AVCodecContext_keyint_min=Module["_AVCodecContext_keyint_min"]=wasmExports["_b"];var _AVCodecContext_keyint_min_s=Module["_AVCodecContext_keyint_min_s"]=wasmExports["$b"];var _AVCodecContext_level=Module["_AVCodecContext_level"]=wasmExports["ac"];var _AVCodecContext_level_s=Module["_AVCodecContext_level_s"]=wasmExports["bc"];var _AVCodecContext_max_b_frames=Module["_AVCodecContext_max_b_frames"]=wasmExports["cc"];var _AVCodecContext_max_b_frames_s=Module["_AVCodecContext_max_b_frames_s"]=wasmExports["dc"];var _AVCodecContext_pix_fmt=Module["_AVCodecContext_pix_fmt"]=wasmExports["ec"];var _AVCodecContext_pix_fmt_s=Module["_AVCodecContext_pix_fmt_s"]=wasmExports["fc"];var _AVCodecContext_profile=Module["_AVCodecContext_profile"]=wasmExports["gc"];var _AVCodecContext_profile_s=Module["_AVCodecContext_profile_s"]=wasmExports["hc"];var _AVCodecContext_rc_max_rate=Module["_AVCodecContext_rc_max_rate"]=wasmExports["ic"];var _AVCodecContext_rc_max_ratehi=Module["_AVCodecContext_rc_max_ratehi"]=wasmExports["jc"];var _AVCodecContext_rc_max_rate_s=Module["_AVCodecContext_rc_max_rate_s"]=wasmExports["kc"];var _AVCodecContext_rc_max_ratehi_s=Module["_AVCodecContext_rc_max_ratehi_s"]=wasmExports["lc"];var _AVCodecContext_rc_min_rate=Module["_AVCodecContext_rc_min_rate"]=wasmExports["mc"];var _AVCodecContext_rc_min_ratehi=Module["_AVCodecContext_rc_min_ratehi"]=wasmExports["nc"];var _AVCodecContext_rc_min_rate_s=Module["_AVCodecContext_rc_min_rate_s"]=wasmExports["oc"];var _AVCodecContext_rc_min_ratehi_s=Module["_AVCodecContext_rc_min_ratehi_s"]=wasmExports["pc"];var _AVCodecContext_sample_fmt=Module["_AVCodecContext_sample_fmt"]=wasmExports["qc"];var _AVCodecContext_sample_fmt_s=Module["_AVCodecContext_sample_fmt_s"]=wasmExports["rc"];var _AVCodecContext_sample_rate=Module["_AVCodecContext_sample_rate"]=wasmExports["sc"];var _AVCodecContext_sample_rate_s=Module["_AVCodecContext_sample_rate_s"]=wasmExports["tc"];var _AVCodecContext_qmax=Module["_AVCodecContext_qmax"]=wasmExports["uc"];var _AVCodecContext_qmax_s=Module["_AVCodecContext_qmax_s"]=wasmExports["vc"];var _AVCodecContext_qmin=Module["_AVCodecContext_qmin"]=wasmExports["wc"];var _AVCodecContext_qmin_s=Module["_AVCodecContext_qmin_s"]=wasmExports["xc"];var _AVCodecContext_width=Module["_AVCodecContext_width"]=wasmExports["yc"];var _AVCodecContext_width_s=Module["_AVCodecContext_width_s"]=wasmExports["zc"];var _AVCodecContext_framerate_num=Module["_AVCodecContext_framerate_num"]=wasmExports["Ac"];var _AVCodecContext_framerate_den=Module["_AVCodecContext_framerate_den"]=wasmExports["Bc"];var _AVCodecContext_framerate_num_s=Module["_AVCodecContext_framerate_num_s"]=wasmExports["Cc"];var _AVCodecContext_framerate_den_s=Module["_AVCodecContext_framerate_den_s"]=wasmExports["Dc"];var _AVCodecContext_framerate_s=Module["_AVCodecContext_framerate_s"]=wasmExports["Ec"];var _AVCodecContext_sample_aspect_ratio_num=Module["_AVCodecContext_sample_aspect_ratio_num"]=wasmExports["Fc"];var _AVCodecContext_sample_aspect_ratio_den=Module["_AVCodecContext_sample_aspect_ratio_den"]=wasmExports["Gc"];var _AVCodecContext_sample_aspect_ratio_num_s=Module["_AVCodecContext_sample_aspect_ratio_num_s"]=wasmExports["Hc"];var _AVCodecContext_sample_aspect_ratio_den_s=Module["_AVCodecContext_sample_aspect_ratio_den_s"]=wasmExports["Ic"];var _AVCodecContext_sample_aspect_ratio_s=Module["_AVCodecContext_sample_aspect_ratio_s"]=wasmExports["Jc"];var _AVCodecContext_time_base_num=Module["_AVCodecContext_time_base_num"]=wasmExports["Kc"];var _AVCodecContext_time_base_den=Module["_AVCodecContext_time_base_den"]=wasmExports["Lc"];var _AVCodecContext_time_base_num_s=Module["_AVCodecContext_time_base_num_s"]=wasmExports["Mc"];var _AVCodecContext_time_base_den_s=Module["_AVCodecContext_time_base_den_s"]=wasmExports["Nc"];var _AVCodecContext_time_base_s=Module["_AVCodecContext_time_base_s"]=wasmExports["Oc"];var _AVCodecContext_channel_layoutmask_s=Module["_AVCodecContext_channel_layoutmask_s"]=wasmExports["Pc"];var _AVCodecContext_channel_layoutmask=Module["_AVCodecContext_channel_layoutmask"]=wasmExports["Qc"];var _AVCodecContext_channels=Module["_AVCodecContext_channels"]=wasmExports["Rc"];var _AVCodecContext_channels_s=Module["_AVCodecContext_channels_s"]=wasmExports["Sc"];var _AVCodecContext_ch_layout_nb_channels=Module["_AVCodecContext_ch_layout_nb_channels"]=wasmExports["Tc"];var _AVCodecContext_ch_layout_nb_channels_s=Module["_AVCodecContext_ch_layout_nb_channels_s"]=wasmExports["Uc"];var _AVCodecContext_channel_layout=Module["_AVCodecContext_channel_layout"]=wasmExports["Vc"];var _AVCodecContext_channel_layouthi=Module["_AVCodecContext_channel_layouthi"]=wasmExports["Wc"];var _AVCodecContext_channel_layout_s=Module["_AVCodecContext_channel_layout_s"]=wasmExports["Xc"];var _AVCodecContext_channel_layouthi_s=Module["_AVCodecContext_channel_layouthi_s"]=wasmExports["Yc"];var _AVCodecDescriptor_id=Module["_AVCodecDescriptor_id"]=wasmExports["Zc"];var _AVCodecDescriptor_id_s=Module["_AVCodecDescriptor_id_s"]=wasmExports["_c"];var _AVCodecDescriptor_long_name=Module["_AVCodecDescriptor_long_name"]=wasmExports["$c"];var _AVCodecDescriptor_long_name_s=Module["_AVCodecDescriptor_long_name_s"]=wasmExports["ad"];var _AVCodecDescriptor_mime_types_a=Module["_AVCodecDescriptor_mime_types_a"]=wasmExports["bd"];var _AVCodecDescriptor_mime_types_a_s=Module["_AVCodecDescriptor_mime_types_a_s"]=wasmExports["cd"];var _AVCodecDescriptor_name=Module["_AVCodecDescriptor_name"]=wasmExports["dd"];var _AVCodecDescriptor_name_s=Module["_AVCodecDescriptor_name_s"]=wasmExports["ed"];var _AVCodecDescriptor_props=Module["_AVCodecDescriptor_props"]=wasmExports["fd"];var _AVCodecDescriptor_props_s=Module["_AVCodecDescriptor_props_s"]=wasmExports["gd"];var _AVCodecDescriptor_type=Module["_AVCodecDescriptor_type"]=wasmExports["hd"];var _AVCodecDescriptor_type_s=Module["_AVCodecDescriptor_type_s"]=wasmExports["id"];var _AVCodecParameters_codec_id=Module["_AVCodecParameters_codec_id"]=wasmExports["jd"];var _AVCodecParameters_codec_id_s=Module["_AVCodecParameters_codec_id_s"]=wasmExports["kd"];var _AVCodecParameters_codec_tag=Module["_AVCodecParameters_codec_tag"]=wasmExports["ld"];var _AVCodecParameters_codec_tag_s=Module["_AVCodecParameters_codec_tag_s"]=wasmExports["md"];var _AVCodecParameters_codec_type=Module["_AVCodecParameters_codec_type"]=wasmExports["nd"];var _AVCodecParameters_codec_type_s=Module["_AVCodecParameters_codec_type_s"]=wasmExports["od"];var _AVCodecParameters_extradata=Module["_AVCodecParameters_extradata"]=wasmExports["pd"];var _AVCodecParameters_extradata_s=Module["_AVCodecParameters_extradata_s"]=wasmExports["qd"];var _AVCodecParameters_extradata_size=Module["_AVCodecParameters_extradata_size"]=wasmExports["rd"];var _AVCodecParameters_extradata_size_s=Module["_AVCodecParameters_extradata_size_s"]=wasmExports["sd"];var _AVCodecParameters_format=Module["_AVCodecParameters_format"]=wasmExports["td"];var _AVCodecParameters_format_s=Module["_AVCodecParameters_format_s"]=wasmExports["ud"];var _AVCodecParameters_bit_rate=Module["_AVCodecParameters_bit_rate"]=wasmExports["vd"];var _AVCodecParameters_bit_rate_s=Module["_AVCodecParameters_bit_rate_s"]=wasmExports["wd"];var _AVCodecParameters_profile=Module["_AVCodecParameters_profile"]=wasmExports["xd"];var _AVCodecParameters_profile_s=Module["_AVCodecParameters_profile_s"]=wasmExports["yd"];var _AVCodecParameters_level=Module["_AVCodecParameters_level"]=wasmExports["zd"];var _AVCodecParameters_level_s=Module["_AVCodecParameters_level_s"]=wasmExports["Ad"];var _AVCodecParameters_width=Module["_AVCodecParameters_width"]=wasmExports["Bd"];var _AVCodecParameters_width_s=Module["_AVCodecParameters_width_s"]=wasmExports["Cd"];var _AVCodecParameters_height=Module["_AVCodecParameters_height"]=wasmExports["Dd"];var _AVCodecParameters_height_s=Module["_AVCodecParameters_height_s"]=wasmExports["Ed"];var _AVCodecParameters_color_range=Module["_AVCodecParameters_color_range"]=wasmExports["Fd"];var _AVCodecParameters_color_range_s=Module["_AVCodecParameters_color_range_s"]=wasmExports["Gd"];var _AVCodecParameters_color_primaries=Module["_AVCodecParameters_color_primaries"]=wasmExports["Hd"];var _AVCodecParameters_color_primaries_s=Module["_AVCodecParameters_color_primaries_s"]=wasmExports["Id"];var _AVCodecParameters_color_trc=Module["_AVCodecParameters_color_trc"]=wasmExports["Jd"];var _AVCodecParameters_color_trc_s=Module["_AVCodecParameters_color_trc_s"]=wasmExports["Kd"];var _AVCodecParameters_color_space=Module["_AVCodecParameters_color_space"]=wasmExports["Ld"];var _AVCodecParameters_color_space_s=Module["_AVCodecParameters_color_space_s"]=wasmExports["Md"];var _AVCodecParameters_chroma_location=Module["_AVCodecParameters_chroma_location"]=wasmExports["Nd"];var _AVCodecParameters_chroma_location_s=Module["_AVCodecParameters_chroma_location_s"]=wasmExports["Od"];var _AVCodecParameters_sample_rate=Module["_AVCodecParameters_sample_rate"]=wasmExports["Pd"];var _AVCodecParameters_sample_rate_s=Module["_AVCodecParameters_sample_rate_s"]=wasmExports["Qd"];var _AVCodecParameters_framerate_num=Module["_AVCodecParameters_framerate_num"]=wasmExports["Rd"];var _AVCodecParameters_framerate_den=Module["_AVCodecParameters_framerate_den"]=wasmExports["Sd"];var _AVCodecParameters_framerate_num_s=Module["_AVCodecParameters_framerate_num_s"]=wasmExports["Td"];var _AVCodecParameters_framerate_den_s=Module["_AVCodecParameters_framerate_den_s"]=wasmExports["Ud"];var _AVCodecParameters_framerate_s=Module["_AVCodecParameters_framerate_s"]=wasmExports["Vd"];var _AVCodecParameters_channel_layoutmask_s=Module["_AVCodecParameters_channel_layoutmask_s"]=wasmExports["Wd"];var _AVCodecParameters_channel_layoutmask=Module["_AVCodecParameters_channel_layoutmask"]=wasmExports["Xd"];var _AVCodecParameters_channels=Module["_AVCodecParameters_channels"]=wasmExports["Yd"];var _AVCodecParameters_channels_s=Module["_AVCodecParameters_channels_s"]=wasmExports["Zd"];var _AVCodecParameters_ch_layout_nb_channels=Module["_AVCodecParameters_ch_layout_nb_channels"]=wasmExports["_d"];var _AVCodecParameters_ch_layout_nb_channels_s=Module["_AVCodecParameters_ch_layout_nb_channels_s"]=wasmExports["$d"];var _AVPacket_data=Module["_AVPacket_data"]=wasmExports["ae"];var _AVPacket_data_s=Module["_AVPacket_data_s"]=wasmExports["be"];var _AVPacket_dts=Module["_AVPacket_dts"]=wasmExports["ce"];var _AVPacket_dtshi=Module["_AVPacket_dtshi"]=wasmExports["de"];var _AVPacket_dts_s=Module["_AVPacket_dts_s"]=wasmExports["ee"];var _AVPacket_dtshi_s=Module["_AVPacket_dtshi_s"]=wasmExports["fe"];var _AVPacket_duration=Module["_AVPacket_duration"]=wasmExports["ge"];var _AVPacket_durationhi=Module["_AVPacket_durationhi"]=wasmExports["he"];var _AVPacket_duration_s=Module["_AVPacket_duration_s"]=wasmExports["ie"];var _AVPacket_durationhi_s=Module["_AVPacket_durationhi_s"]=wasmExports["je"];var _AVPacket_flags=Module["_AVPacket_flags"]=wasmExports["ke"];var _AVPacket_flags_s=Module["_AVPacket_flags_s"]=wasmExports["le"];var _AVPacket_pos=Module["_AVPacket_pos"]=wasmExports["me"];var _AVPacket_poshi=Module["_AVPacket_poshi"]=wasmExports["ne"];var _AVPacket_pos_s=Module["_AVPacket_pos_s"]=wasmExports["oe"];var _AVPacket_poshi_s=Module["_AVPacket_poshi_s"]=wasmExports["pe"];var _AVPacket_pts=Module["_AVPacket_pts"]=wasmExports["qe"];var _AVPacket_ptshi=Module["_AVPacket_ptshi"]=wasmExports["re"];var _AVPacket_pts_s=Module["_AVPacket_pts_s"]=wasmExports["se"];var _AVPacket_ptshi_s=Module["_AVPacket_ptshi_s"]=wasmExports["te"];var _AVPacket_side_data=Module["_AVPacket_side_data"]=wasmExports["ue"];var _AVPacket_side_data_s=Module["_AVPacket_side_data_s"]=wasmExports["ve"];var _AVPacket_side_data_elems=Module["_AVPacket_side_data_elems"]=wasmExports["we"];var _AVPacket_side_data_elems_s=Module["_AVPacket_side_data_elems_s"]=wasmExports["xe"];var _AVPacket_size=Module["_AVPacket_size"]=wasmExports["ye"];var _AVPacket_size_s=Module["_AVPacket_size_s"]=wasmExports["ze"];var _AVPacket_stream_index=Module["_AVPacket_stream_index"]=wasmExports["Ae"];var _AVPacket_stream_index_s=Module["_AVPacket_stream_index_s"]=wasmExports["Be"];var _AVPacket_time_base_num=Module["_AVPacket_time_base_num"]=wasmExports["Ce"];var _AVPacket_time_base_den=Module["_AVPacket_time_base_den"]=wasmExports["De"];var _AVPacket_time_base_num_s=Module["_AVPacket_time_base_num_s"]=wasmExports["Ee"];var _AVPacket_time_base_den_s=Module["_AVPacket_time_base_den_s"]=wasmExports["Fe"];var _AVPacket_time_base_s=Module["_AVPacket_time_base_s"]=wasmExports["Ge"];var _AVPacketSideData_data=Module["_AVPacketSideData_data"]=wasmExports["He"];var _AVPacketSideData_size=Module["_AVPacketSideData_size"]=wasmExports["Ie"];var _AVPacketSideData_type=Module["_AVPacketSideData_type"]=wasmExports["Je"];var _avcodec_open2_js=Module["_avcodec_open2_js"]=wasmExports["Ke"];var _avcodec_open2=Module["_avcodec_open2"]=wasmExports["Le"];var _av_packet_rescale_ts_js=Module["_av_packet_rescale_ts_js"]=wasmExports["Me"];var _AVFormatContext_duration=Module["_AVFormatContext_duration"]=wasmExports["Ne"];var _AVFormatContext_durationhi=Module["_AVFormatContext_durationhi"]=wasmExports["Oe"];var _AVFormatContext_duration_s=Module["_AVFormatContext_duration_s"]=wasmExports["Pe"];var _AVFormatContext_durationhi_s=Module["_AVFormatContext_durationhi_s"]=wasmExports["Qe"];var _AVFormatContext_flags=Module["_AVFormatContext_flags"]=wasmExports["Re"];var _AVFormatContext_flags_s=Module["_AVFormatContext_flags_s"]=wasmExports["Se"];var _AVFormatContext_nb_streams=Module["_AVFormatContext_nb_streams"]=wasmExports["Te"];var _AVFormatContext_nb_streams_s=Module["_AVFormatContext_nb_streams_s"]=wasmExports["Ue"];var _AVFormatContext_oformat=Module["_AVFormatContext_oformat"]=wasmExports["Ve"];var _AVFormatContext_oformat_s=Module["_AVFormatContext_oformat_s"]=wasmExports["We"];var _AVFormatContext_pb=Module["_AVFormatContext_pb"]=wasmExports["Xe"];var _AVFormatContext_pb_s=Module["_AVFormatContext_pb_s"]=wasmExports["Ye"];var _AVFormatContext_start_time=Module["_AVFormatContext_start_time"]=wasmExports["Ze"];var _AVFormatContext_start_timehi=Module["_AVFormatContext_start_timehi"]=wasmExports["_e"];var _AVFormatContext_start_time_s=Module["_AVFormatContext_start_time_s"]=wasmExports["$e"];var _AVFormatContext_start_timehi_s=Module["_AVFormatContext_start_timehi_s"]=wasmExports["af"];var _AVFormatContext_streams_a=Module["_AVFormatContext_streams_a"]=wasmExports["bf"];var _AVFormatContext_streams_a_s=Module["_AVFormatContext_streams_a_s"]=wasmExports["cf"];var _AVStream_codecpar=Module["_AVStream_codecpar"]=wasmExports["df"];var _AVStream_codecpar_s=Module["_AVStream_codecpar_s"]=wasmExports["ef"];var _AVStream_discard=Module["_AVStream_discard"]=wasmExports["ff"];var _AVStream_discard_s=Module["_AVStream_discard_s"]=wasmExports["gf"];var _AVStream_duration=Module["_AVStream_duration"]=wasmExports["hf"];var _AVStream_durationhi=Module["_AVStream_durationhi"]=wasmExports["jf"];var _AVStream_duration_s=Module["_AVStream_duration_s"]=wasmExports["kf"];var _AVStream_durationhi_s=Module["_AVStream_durationhi_s"]=wasmExports["lf"];var _AVStream_time_base_num=Module["_AVStream_time_base_num"]=wasmExports["mf"];var _AVStream_time_base_den=Module["_AVStream_time_base_den"]=wasmExports["nf"];var _AVStream_time_base_num_s=Module["_AVStream_time_base_num_s"]=wasmExports["of"];var _AVStream_time_base_den_s=Module["_AVStream_time_base_den_s"]=wasmExports["pf"];var _AVStream_time_base_s=Module["_AVStream_time_base_s"]=wasmExports["qf"];var _avformat_seek_file_min=Module["_avformat_seek_file_min"]=wasmExports["rf"];var _avformat_seek_file=Module["_avformat_seek_file"]=wasmExports["sf"];var _avformat_seek_file_max=Module["_avformat_seek_file_max"]=wasmExports["tf"];var _avformat_seek_file_approx=Module["_avformat_seek_file_approx"]=wasmExports["uf"];var _AVFilterInOut_filter_ctx=Module["_AVFilterInOut_filter_ctx"]=wasmExports["vf"];var _AVFilterInOut_filter_ctx_s=Module["_AVFilterInOut_filter_ctx_s"]=wasmExports["wf"];var _AVFilterInOut_name=Module["_AVFilterInOut_name"]=wasmExports["xf"];var _AVFilterInOut_name_s=Module["_AVFilterInOut_name_s"]=wasmExports["yf"];var _AVFilterInOut_next=Module["_AVFilterInOut_next"]=wasmExports["zf"];var _AVFilterInOut_next_s=Module["_AVFilterInOut_next_s"]=wasmExports["Af"];var _AVFilterInOut_pad_idx=Module["_AVFilterInOut_pad_idx"]=wasmExports["Bf"];var _AVFilterInOut_pad_idx_s=Module["_AVFilterInOut_pad_idx_s"]=wasmExports["Cf"];var _av_buffersink_get_time_base_num=Module["_av_buffersink_get_time_base_num"]=wasmExports["Df"];var _av_buffersink_get_time_base_den=Module["_av_buffersink_get_time_base_den"]=wasmExports["Ef"];var _ff_buffersink_set_ch_layout=Module["_ff_buffersink_set_ch_layout"]=wasmExports["Ff"];var _av_opt_set=Module["_av_opt_set"]=wasmExports["Gf"];var _libavjs_with_swscale=Module["_libavjs_with_swscale"]=wasmExports["Hf"];var _libavjs_create_main_thread=Module["_libavjs_create_main_thread"]=wasmExports["If"];var _avformat_alloc_output_context2_js=Module["_avformat_alloc_output_context2_js"]=wasmExports["Jf"];var _avformat_open_input_js=Module["_avformat_open_input_js"]=wasmExports["Kf"];var _avformat_open_input=Module["_avformat_open_input"]=wasmExports["Lf"];var _avio_open2_js=Module["_avio_open2_js"]=wasmExports["Mf"];var _avfilter_graph_create_filter_js=Module["_avfilter_graph_create_filter_js"]=wasmExports["Nf"];var _av_dict_copy_js=Module["_av_dict_copy_js"]=wasmExports["Of"];var _av_dict_set_js=Module["_av_dict_set_js"]=wasmExports["Pf"];var _av_compare_ts_js=Module["_av_compare_ts_js"]=wasmExports["Qf"];var _ff_error=Module["_ff_error"]=wasmExports["Rf"];var _mallinfo_uordblks=Module["_mallinfo_uordblks"]=wasmExports["Sf"];var _av_dict_free=Module["_av_dict_free"]=wasmExports["Tf"];var _av_log_set_level=Module["_av_log_set_level"]=wasmExports["Uf"];var _av_strdup=Module["_av_strdup"]=wasmExports["Vf"];var _avcodec_free_context=Module["_avcodec_free_context"]=wasmExports["Xf"];var _av_frame_free=Module["_av_frame_free"]=wasmExports["Yf"];var _av_packet_free=Module["_av_packet_free"]=wasmExports["Zf"];var _av_frame_alloc=Module["_av_frame_alloc"]=wasmExports["_f"];var _av_packet_alloc=Module["_av_packet_alloc"]=wasmExports["$f"];var _avcodec_alloc_context3=Module["_avcodec_alloc_context3"]=wasmExports["ag"];var _avcodec_parameters_to_context=Module["_avcodec_parameters_to_context"]=wasmExports["bg"];var _avcodec_find_decoder_by_name=Module["_avcodec_find_decoder_by_name"]=wasmExports["cg"];var _avcodec_find_decoder=Module["_avcodec_find_decoder"]=wasmExports["dg"];var _avcodec_descriptor_get=Module["_avcodec_descriptor_get"]=wasmExports["eg"];var _av_frame_unref=Module["_av_frame_unref"]=wasmExports["fg"];var _avcodec_send_packet=Module["_avcodec_send_packet"]=wasmExports["gg"];var _avcodec_receive_frame=Module["_avcodec_receive_frame"]=wasmExports["hg"];var _av_frame_ref=Module["_av_frame_ref"]=wasmExports["ig"];var _av_packet_unref=Module["_av_packet_unref"]=wasmExports["jg"];var _avcodec_flush_buffers=Module["_avcodec_flush_buffers"]=wasmExports["kg"];var _av_pix_fmt_desc_get=Module["_av_pix_fmt_desc_get"]=wasmExports["lg"];var _avformat_close_input=Module["_avformat_close_input"]=wasmExports["mg"];var _avcodec_parameters_free=Module["_avcodec_parameters_free"]=wasmExports["ng"];var _avcodec_get_name=Module["_avcodec_get_name"]=wasmExports["og"];var _av_find_input_format=Module["_av_find_input_format"]=wasmExports["pg"];var _avformat_alloc_context=Module["_avformat_alloc_context"]=wasmExports["qg"];var _avformat_free_context=Module["_avformat_free_context"]=wasmExports["rg"];var _avformat_find_stream_info=Module["_avformat_find_stream_info"]=wasmExports["sg"];var _avio_close=Module["_avio_close"]=wasmExports["tg"];var _avcodec_parameters_alloc=Module["_avcodec_parameters_alloc"]=wasmExports["ug"];var _avcodec_parameters_copy=Module["_avcodec_parameters_copy"]=wasmExports["vg"];var _av_read_frame=Module["_av_read_frame"]=wasmExports["wg"];var _av_get_bytes_per_sample=Module["_av_get_bytes_per_sample"]=wasmExports["xg"];var _avcodec_parameters_from_context=Module["_avcodec_parameters_from_context"]=wasmExports["yg"];var _avio_flush=Module["_avio_flush"]=wasmExports["zg"];var _av_shrink_packet=Module["_av_shrink_packet"]=wasmExports["Ag"];var _avcodec_send_frame=Module["_avcodec_send_frame"]=wasmExports["Bg"];var _avcodec_receive_packet=Module["_avcodec_receive_packet"]=wasmExports["Cg"];var _avfilter_graph_alloc=Module["_avfilter_graph_alloc"]=wasmExports["Dg"];var _avfilter_inout_free=Module["_avfilter_inout_free"]=wasmExports["Eg"];var _avfilter_graph_free=Module["_avfilter_graph_free"]=wasmExports["Fg"];var _av_get_sample_fmt_name=Module["_av_get_sample_fmt_name"]=wasmExports["Gg"];var _av_buffersrc_add_frame_flags=Module["_av_buffersrc_add_frame_flags"]=wasmExports["Hg"];var _avfilter_get_by_name=Module["_avfilter_get_by_name"]=wasmExports["Ig"];var _avfilter_link=Module["_avfilter_link"]=wasmExports["Jg"];var _avfilter_graph_config=Module["_avfilter_graph_config"]=wasmExports["Kg"];var _av_frame_get_buffer=Module["_av_frame_get_buffer"]=wasmExports["Lg"];var _avcodec_find_encoder=Module["_avcodec_find_encoder"]=wasmExports["Mg"];var _avformat_new_stream=Module["_avformat_new_stream"]=wasmExports["Ng"];var _strerror=Module["_strerror"]=wasmExports["Og"];var _avformat_write_header=Module["_avformat_write_header"]=wasmExports["Pg"];var _av_write_trailer=Module["_av_write_trailer"]=wasmExports["Qg"];var _av_interleaved_write_frame=Module["_av_interleaved_write_frame"]=wasmExports["Rg"];var _ffmpeg_main=Module["_ffmpeg_main"]=wasmExports["Sg"];var _av_log_get_level=Module["_av_log_get_level"]=wasmExports["Tg"];var _avcodec_find_encoder_by_name=Module["_avcodec_find_encoder_by_name"]=wasmExports["Ug"];var _avcodec_descriptor_get_by_name=Module["_avcodec_descriptor_get_by_name"]=wasmExports["Vg"];var _av_packet_ref=Module["_av_packet_ref"]=wasmExports["Wg"];var _ffprobe_main=Module["_ffprobe_main"]=wasmExports["Xg"];var _avcodec_descriptor_next=Module["_avcodec_descriptor_next"]=wasmExports["Yg"];var _av_frame_clone=Module["_av_frame_clone"]=wasmExports["Zg"];var _av_frame_make_writable=Module["_av_frame_make_writable"]=wasmExports["_g"];var _free=Module["_free"]=wasmExports["$g"];var _open=Module["_open"]=wasmExports["ah"];var _av_find_best_stream=Module["_av_find_best_stream"]=wasmExports["bh"];var _av_packet_new_side_data=Module["_av_packet_new_side_data"]=wasmExports["ch"];var _av_packet_clone=Module["_av_packet_clone"]=wasmExports["dh"];var _av_write_frame=Module["_av_write_frame"]=wasmExports["eh"];var _av_grow_packet=Module["_av_grow_packet"]=wasmExports["fh"];var _av_packet_make_writable=Module["_av_packet_make_writable"]=wasmExports["gh"];var _close=Module["_close"]=wasmExports["hh"];var _av_seek_frame=Module["_av_seek_frame"]=wasmExports["ih"];var _avformat_flush=Module["_avformat_flush"]=wasmExports["jh"];var _avcodec_close=Module["_avcodec_close"]=wasmExports["kh"];var _avfilter_free=Module["_avfilter_free"]=wasmExports["lh"];var _av_buffersink_get_frame=Module["_av_buffersink_get_frame"]=wasmExports["mh"];var _av_buffersink_set_frame_size=Module["_av_buffersink_set_frame_size"]=wasmExports["nh"];var _avfilter_inout_alloc=Module["_avfilter_inout_alloc"]=wasmExports["oh"];var _avfilter_graph_parse=Module["_avfilter_graph_parse"]=wasmExports["ph"];var _sws_freeContext=Module["_sws_freeContext"]=wasmExports["qh"];var _sws_scale_frame=Module["_sws_scale_frame"]=wasmExports["rh"];var _sws_getContext=Module["_sws_getContext"]=wasmExports["sh"];var _malloc=Module["_malloc"]=wasmExports["th"];var _calloc=Module["_calloc"]=wasmExports["uh"];var _emfiberthreads_timeout_expiry=Module["_emfiberthreads_timeout_expiry"]=wasmExports["vh"];var _dup2=Module["_dup2"]=wasmExports["wh"];var _setThrew=wasmExports["xh"];var _emscripten_stack_set_limits=wasmExports["yh"];var __emscripten_stack_restore=wasmExports["zh"];var __emscripten_stack_alloc=wasmExports["Ah"];var _emscripten_stack_get_current=wasmExports["Bh"];var dynCall_iiii=Module["dynCall_iiii"]=wasmExports["Ch"];var dynCall_ii=Module["dynCall_ii"]=wasmExports["Dh"];var dynCall_iii=Module["dynCall_iii"]=wasmExports["Eh"];var dynCall_vii=Module["dynCall_vii"]=wasmExports["Fh"];var dynCall_vi=Module["dynCall_vi"]=wasmExports["Gh"];var dynCall_viii=Module["dynCall_viii"]=wasmExports["Hh"];var dynCall_iiiii=Module["dynCall_iiiii"]=wasmExports["Ih"];var dynCall_i=Module["dynCall_i"]=wasmExports["Jh"];var dynCall_viiii=Module["dynCall_viiii"]=wasmExports["Kh"];var dynCall_viiiiii=Module["dynCall_viiiiii"]=wasmExports["Lh"];var dynCall_iiiiii=Module["dynCall_iiiiii"]=wasmExports["Mh"];var dynCall_viiiii=Module["dynCall_viiiii"]=wasmExports["Nh"];var dynCall_viiiiiiiii=Module["dynCall_viiiiiiiii"]=wasmExports["Oh"];var dynCall_viiiiiiii=Module["dynCall_viiiiiiii"]=wasmExports["Ph"];var dynCall_viiiiiii=Module["dynCall_viiiiiii"]=wasmExports["Qh"];var dynCall_viiiiiiiiiii=Module["dynCall_viiiiiiiiiii"]=wasmExports["Rh"];var dynCall_iiiiiiiii=Module["dynCall_iiiiiiiii"]=wasmExports["Sh"];var dynCall_jij=Module["dynCall_jij"]=wasmExports["Th"];var dynCall_iiiijj=Module["dynCall_iiiijj"]=wasmExports["Uh"];var dynCall_iiiiiiiiiii=Module["dynCall_iiiiiiiiiii"]=wasmExports["Vh"];var dynCall_viiid=Module["dynCall_viiid"]=wasmExports["Wh"];var dynCall_iiiiiiiiii=Module["dynCall_iiiiiiiiii"]=wasmExports["Xh"];var dynCall_iiiiiiiiiiii=Module["dynCall_iiiiiiiiiiii"]=wasmExports["Yh"];var _asyncify_start_unwind=wasmExports["Zh"];var _asyncify_stop_unwind=wasmExports["_h"];var _asyncify_start_rewind=wasmExports["$h"];var _asyncify_stop_rewind=wasmExports["ai"];var _ff_h264_cabac_tables=Module["_ff_h264_cabac_tables"]=689196;function invoke_iiiii(index,a1,a2,a3,a4){var sp=stackSave();try{return dynCall_iiiii(index,a1,a2,a3,a4)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_vii(index,a1,a2){var sp=stackSave();try{dynCall_vii(index,a1,a2)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iii(index,a1,a2){var sp=stackSave();try{return dynCall_iii(index,a1,a2)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viiii(index,a1,a2,a3,a4){var sp=stackSave();try{dynCall_viiii(index,a1,a2,a3,a4)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iiiijj(index,a1,a2,a3,a4,a5){var sp=stackSave();try{return dynCall_iiiijj(index,a1,a2,a3,a4,a5)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8){var sp=stackSave();try{return dynCall_iiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viii(index,a1,a2,a3){var sp=stackSave();try{dynCall_viii(index,a1,a2,a3)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_ii(index,a1){var sp=stackSave();try{return dynCall_ii(index,a1)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_vi(index,a1){var sp=stackSave();try{dynCall_vi(index,a1)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viiid(index,a1,a2,a3,a4){var sp=stackSave();try{dynCall_viiid(index,a1,a2,a3,a4)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iiiiii(index,a1,a2,a3,a4,a5){var sp=stackSave();try{return dynCall_iiiiii(index,a1,a2,a3,a4,a5)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iiii(index,a1,a2,a3){var sp=stackSave();try{return dynCall_iiii(index,a1,a2,a3)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_i(index){var sp=stackSave();try{return dynCall_i(index)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9){var sp=stackSave();try{return dynCall_iiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_jij(index,a1,a2){var sp=stackSave();try{return dynCall_jij(index,a1,a2)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0);return 0n}}function invoke_viiiii(index,a1,a2,a3,a4,a5){var sp=stackSave();try{dynCall_viiiii(index,a1,a2,a3,a4,a5)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8){var sp=stackSave();try{dynCall_viiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viiiiiii(index,a1,a2,a3,a4,a5,a6,a7){var sp=stackSave();try{dynCall_viiiiiii(index,a1,a2,a3,a4,a5,a6,a7)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viiiiii(index,a1,a2,a3,a4,a5,a6){var sp=stackSave();try{dynCall_viiiiii(index,a1,a2,a3,a4,a5,a6)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9){var sp=stackSave();try{dynCall_viiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11){var sp=stackSave();try{return dynCall_iiiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_iiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10){var sp=stackSave();try{return dynCall_iiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}function invoke_viiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11){var sp=stackSave();try{dynCall_viiiiiiiiiii(index,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11)}catch(e){stackRestore(sp);if(e!==e+0)throw e;_setThrew(1,0)}}Module["ccall"]=ccall;Module["cwrap"]=cwrap;function run(){if(runDependencies>0){dependenciesFulfilled=run;return}preRun();if(runDependencies>0){dependenciesFulfilled=run;return}function doRun(){Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}run();var serializationPromise=null;function serially(f){var p;if(serializationPromise){p=serializationPromise.catch(function(){}).then(function(){return f()})}else{p=f()}serializationPromise=p=p.finally(function(){if(serializationPromise===p)serializationPromise=null});return p}Module.fsThrownError=null;var ERRNO_CODES={EPERM:1,EIO:5,EAGAIN:6,ECANCELED:11,ESPIPE:29};var readerCallbacks={open:function(stream){if(stream.flags&3){throw new FS.ErrnoError(ERRNO_CODES.EPERM)}},close:function(){},read:function(stream,buffer,offset,length,position){var data=Module.readBuffers[stream.node.name];if(!data||data.buf.length===0&&!data.eof){if(Module.onread){try{var rr=Module.onread(stream.node.name,position,length);if(rr&&rr.then&&rr.catch){rr.catch(function(ex){ff_reader_dev_send(stream.node.name,null,{error:ex})})}}catch(ex){ff_reader_dev_send(stream.node.name,null,{error:ex})}}data=Module.readBuffers[stream.node.name]}if(!data)throw new FS.ErrnoError(ERRNO_CODES.EAGAIN);if(data.error){Module.fsThrownError=data.error;throw new FS.ErrnoError(ERRNO_CODES.ECANCELED)}if(data.errorCode)throw new FS.ErrnoError(data.errorCode);if(data.buf.length===0){if(data.eof){return 0}else{data.ready=false;throw new FS.ErrnoError(ERRNO_CODES.EAGAIN)}}var ret;if(length=bufMax){if(position>=stream.node.ff_block_reader_dev_size)return 0;if(!Module.onblockread)throw new FS.ErrnoError(ERRNO_CODES.EIO);try{var brr=Module.onblockread(stream.node.name,position,length);if(brr&&brr.then&&brr.catch){brr.catch(function(ex){ff_block_reader_dev_send(stream.node.name,position,null,{error:ex})})}}catch(ex){Module.fsThrownError=ex;throw new FS.ErrnoError(ERRNO_CODES.ECANCELED)}bufMin=data.position;bufMax=data.position+data.buf.length;if(position=bufMax){data.ready=false;throw new FS.ErrnoError(ERRNO_CODES.EAGAIN)}}var bufPos=position-bufMin;var ret;if(bufPos+lengthdata.length)av_shrink_packet(pkt,data.length)}var ptr=AVPacket_data(pkt);Module.HEAPU8.set(data,ptr)};var ff_init_muxer=Module.ff_init_muxer=function(opts,streamCtxs){var oformat=opts.oformat?opts.oformat:0;var format_name=opts.format_name?opts.format_name:null;var filename=opts.filename?opts.filename:null;var oc=avformat_alloc_output_context2_js(oformat,format_name,filename);if(oc===0)throw new Error("Failed to allocate output context");var fmt=AVFormatContext_oformat(oc);var sts=[];streamCtxs.forEach(function(ctx){var st=avformat_new_stream(oc,0);if(st===0)throw new Error("Could not allocate stream");sts.push(st);var codecpar=AVStream_codecpar(st);var ret;if(opts.codecpars){ret=avcodec_parameters_copy(codecpar,ctx[0]);AVCodecParameters_codec_tag_s(codecpar,0)}else{ret=avcodec_parameters_from_context(codecpar,ctx[0])}if(ret<0)throw new Error("Could not copy the stream parameters: "+ff_error(ret));AVStream_time_base_s(st,ctx[1],ctx[2])});if(opts.device)FS.mkdev(opts.filename,511,writerDev);var pb=null;if(opts.open){pb=avio_open2_js(opts.filename,2,0,0);if(pb===0)throw new Error("Could not open file");AVFormatContext_pb_s(oc,pb)}return[oc,fmt,pb,sts]};var ff_free_muxer=Module.ff_free_muxer=function(oc,pb){avformat_free_context(oc);if(pb)avio_close(pb)};function ff_init_demuxer_file(filename,fmt){var fmt_ctx;return avformat_open_input_js(filename,fmt?fmt:null,null).then(function(ret){fmt_ctx=ret;if(fmt_ctx===0)throw new Error("Could not open source file");return avformat_find_stream_info(fmt_ctx,0)}).then(function(){var nb_streams=AVFormatContext_nb_streams(fmt_ctx);var streams=[];for(var i=0;i=opts.limit)return[-6,outPackets];return Promise.all([]).then(step)})}return step()}Module.ff_read_frame_multi=function(){var args=arguments;return serially(function(){return ff_read_frame_multi.apply(void 0,args)})};Module.ff_read_multi=function(fmt_ctx,pkt,devfile,opts){console.log("[libav.js] ff_read_multi is deprecated. Use ff_read_frame_multi.");return Module.ff_read_frame_multi(fmt_ctx,pkt,opts)};var ff_init_filter_graph=Module.ff_init_filter_graph=function(filters_descr,input,output){var buffersrc,abuffersrc,buffersink,abuffersink,filter_graph,tmp_src_ctx,tmp_sink_ctx,src_ctxs,sink_ctxs,io_outputs,io_inputs,int32s;var instr,outstr;var multiple_inputs=!!input.length;if(!multiple_inputs)input=[input];var multiple_outputs=!!output.length;if(!multiple_outputs)output=[output];src_ctxs=[];sink_ctxs=[];try{buffersrc=avfilter_get_by_name("buffer");abuffersrc=avfilter_get_by_name("abuffer");buffersink=avfilter_get_by_name("buffersink");abuffersink=avfilter_get_by_name("abuffersink");filter_graph=avfilter_graph_alloc();if(filter_graph===0)throw new Error("Failed to allocate filter graph");io_outputs=0;var ii=0;input.forEach(function(input){var next_io_outputs=avfilter_inout_alloc();if(next_io_outputs===0)throw new Error("Failed to allocate outputs");AVFilterInOut_next_s(next_io_outputs,io_outputs);io_outputs=next_io_outputs;var nm="in"+(multiple_inputs?ii:"");if(input.type===0){if(buffersrc===0)throw new Error("Failed to load buffer filter");var frame_rate=input.frame_rate;var time_base=input.time_base;if(typeof frame_rate==="undefined")frame_rate=30;if(typeof time_base==="undefined")time_base=[1,frame_rate];tmp_src_ctx=avfilter_graph_create_filter_js(buffersrc,nm,"time_base="+time_base[0]+"/"+time_base[1]+":frame_rate="+frame_rate+":pix_fmt="+(input.pix_fmt?input.pix_fmt:0)+":width="+(input.width?input.width:640)+":height="+(input.height?input.height:360),null,filter_graph)}else{if(abuffersrc===0)throw new Error("Failed to load abuffer filter");var sample_rate=input.sample_rate;var time_base=input.time_base;if(typeof sample_rate==="undefined")sample_rate=48e3;if(typeof time_base==="undefined")time_base=[1,sample_rate];tmp_src_ctx=avfilter_graph_create_filter_js(abuffersrc,nm,"time_base="+time_base[0]+"/"+time_base[1]+":sample_rate="+sample_rate+":sample_fmt="+(input.sample_fmt?input.sample_fmt:3)+":channel_layout=0x"+(input.channel_layout?input.channel_layout:4).toString(16),null,filter_graph)}if(tmp_src_ctx===0)throw new Error("Cannot create buffer source");src_ctxs.push(tmp_src_ctx);instr=av_strdup(nm);if(instr===0)throw new Error("Failed to allocate output");AVFilterInOut_name_s(io_outputs,instr);instr=0;AVFilterInOut_filter_ctx_s(io_outputs,tmp_src_ctx);tmp_src_ctx=0;AVFilterInOut_pad_idx_s(io_outputs,0);ii++});io_inputs=0;var oi=0;output.forEach(function(output){var next_io_inputs=avfilter_inout_alloc();if(next_io_inputs===0)throw new Error("Failed to allocate inputs");AVFilterInOut_next_s(next_io_inputs,io_inputs);io_inputs=next_io_inputs;var nm="out"+(multiple_outputs?oi:"");if(output.type===0){if(buffersink===0)throw new Error("Failed to load buffersink filter");tmp_sink_ctx=avfilter_graph_create_filter_js(buffersink,nm,null,null,filter_graph)}else{tmp_sink_ctx=avfilter_graph_create_filter_js(abuffersink,nm,null,null,filter_graph)}if(tmp_sink_ctx===0)throw new Error("Cannot create buffer sink");sink_ctxs.push(tmp_sink_ctx);if(output.type===0){int32s=ff_malloc_int32_list([output.pix_fmt?output.pix_fmt:0,-1]);if(int32s===0)throw new Error("Failed to transfer parameters");if(av_opt_set_int_list_js(tmp_sink_ctx,"pix_fmts",4,int32s,-1,1)<0){throw new Error("Failed to set filter parameters")}free(int32s);int32s=0}else{int32s=ff_malloc_int32_list([output.sample_fmt?output.sample_fmt:3,-1,output.sample_rate?output.sample_rate:48e3,-1]);if(int32s===0)throw new Error("Failed to transfer parameters");var ch_layout=output.channel_layout?output.channel_layout:4;var ch_layout_i64=[~~ch_layout,Math.floor(ch_layout/4294967296)];if(av_opt_set_int_list_js(tmp_sink_ctx,"sample_fmts",4,int32s,-1,1)<0||ff_buffersink_set_ch_layout(tmp_sink_ctx,ch_layout_i64[0],ch_layout_i64[1])<0||av_opt_set_int_list_js(tmp_sink_ctx,"sample_rates",4,int32s+8,-1,1)<0){throw new Error("Failed to set filter parameters")}free(int32s);int32s=0}outstr=av_strdup(nm);if(outstr===0)throw new Error("Failed to transfer parameters");AVFilterInOut_name_s(io_inputs,outstr);outstr=0;AVFilterInOut_filter_ctx_s(io_inputs,tmp_sink_ctx);tmp_sink_ctx=0;AVFilterInOut_pad_idx_s(io_inputs,0);oi++});var ret=avfilter_graph_parse(filter_graph,filters_descr,io_inputs,io_outputs,0);if(ret<0)throw new Error("Failed to initialize filters: "+ff_error(ret));io_inputs=io_outputs=0;var oi=0;output.forEach(function(output){if(output.frame_size)av_buffersink_set_frame_size(sink_ctxs[oi],output.frame_size);oi++});ret=avfilter_graph_config(filter_graph,0);if(ret<0)throw new Error("Failed to configure filter graph: "+ff_error(ret))}catch(ex){if(io_outputs)avfilter_inout_free(io_outputs);if(io_inputs)avfilter_inout_free(io_inputs);if(filter_graph)avfilter_graph_free(filter_graph);if(tmp_src_ctx)avfilter_free(tmp_src_ctx);if(tmp_sink_ctx)avfilter_free(tmp_sink_ctx);if(int32s)free(int32s);if(instr)free(instr);if(outstr)free(outstr);throw ex}return[filter_graph,multiple_inputs?src_ctxs:src_ctxs[0],multiple_outputs?sink_ctxs:sink_ctxs[0]]};var ff_filter_multi=Module.ff_filter_multi=function(srcs,buffersink_ctx,framePtr,inFrames,config){var outFrames=[];var transfer=[];var tbNum=-1,tbDen=-1;if(!srcs.length){srcs=[srcs];inFrames=[inFrames];config=[config]}config=config.map(function(config){if(config===true)return{fin:true};return config||{}});var max=inFrames.map(function(srcFrames){return srcFrames.length}).reduce(function(a,b){return Math.max(a,b)});function handleFrame(buffersrc_ctx,inFrame,copyoutFrame,config){if(inFrame!==null)ff_copyin_frame(framePtr,inFrame);var ret=av_buffersrc_add_frame_flags(buffersrc_ctx,inFrame?framePtr:0,8);if(ret<0)throw new Error("Error while feeding the audio filtergraph: "+ff_error(ret));av_frame_unref(framePtr);while(true){ret=av_buffersink_get_frame(buffersink_ctx,framePtr);if(ret===-6||ret===-541478725)break;if(ret<0)throw new Error("Error while receiving a frame from the filtergraph: "+ff_error(ret));if(tbNum<0){tbNum=av_buffersink_get_time_base_num(buffersink_ctx);tbDen=av_buffersink_get_time_base_den(buffersink_ctx)}var outFrame=copyoutFrame(framePtr);if(tbNum&&!config.ignoreSinkTimebase){if(typeof outFrame==="number"){AVFrame_time_base_s(outFrame,tbNum,tbDen)}else if(outFrame){outFrame.time_base_num=tbNum;outFrame.time_base_den=tbDen}}if(outFrame&&outFrame.libavjsTransfer&&outFrame.libavjsTransfer.length)transfer.push.apply(transfer,outFrame.libavjsTransfer);outFrames.push(outFrame);av_frame_unref(framePtr)}}var copyoutFrames=[];for(var ti=0;ti=5){var data=[];for(var ci=0;ci>=log2ch;plane+=linesize*h;if(plane>dataHi)dataHi=plane}outFrame.data=Module.HEAPU8.slice(dataLo,dataHi);transfer.push(outFrame.data.buffer);for(var p=0;p<8;p++){var linesize=AVFrame_linesize_a(frame,p);if(!linesize)break;var plane=AVFrame_data_a(frame,p);layout.push({offset:plane-dataLo,stride:linesize})}return outFrame};var ff_frame_video_packed_size=Module.ff_frame_video_packed_size=function(frame){var width=AVFrame_width(frame);var height=AVFrame_height(frame);var format=AVFrame_format(frame);var desc=av_pix_fmt_desc_get(format);var bpp=1;if(!(AVPixFmtDescriptor_flags(desc)&16))bpp*=AVPixFmtDescriptor_nb_components(desc);var dataSz=0;for(var i=0;i<8;i++){var linesize=AVFrame_linesize_a(frame,i);if(!linesize)break;var w=width*bpp;var h=height;if(i===1||i===2){w>>=AVPixFmtDescriptor_log2_chroma_w(desc);h>>=AVPixFmtDescriptor_log2_chroma_h(desc)}dataSz+=w*h}return dataSz};function ff_copyout_frame_data_packed(data,layout,frame){var width=AVFrame_width(frame);var height=AVFrame_height(frame);var format=AVFrame_format(frame);var desc=av_pix_fmt_desc_get(format);var bpp=1;if(!(AVPixFmtDescriptor_flags(desc)&16))bpp*=AVPixFmtDescriptor_nb_components(desc);var dIdx=0;for(var i=0;i<8;i++){var linesize=AVFrame_linesize_a(frame,i);if(!linesize)break;var inData=AVFrame_data_a(frame,i);var w=width*bpp;var h=height;if(i===1||i===2){w>>=AVPixFmtDescriptor_log2_chroma_w(desc);h>>=AVPixFmtDescriptor_log2_chroma_h(desc)}layout.push({offset:dIdx,stride:w});for(var y=0;y>>=1}}["channel_layout","channels","format","pts","ptshi","sample_rate","time_base_num","time_base_den"].forEach(function(key){if(key in frame)CAccessors["AVFrame_"+key+"_s"](framePtr,frame[key])});var nb_samples;if(format>=5){nb_samples=frame.data[0].length}else{nb_samples=frame.data.length/channels}AVFrame_nb_samples_s(framePtr,nb_samples);if(av_frame_make_writable(framePtr)<0){var ret=av_frame_get_buffer(framePtr,0);if(ret<0)throw new Error("Failed to allocate frame buffers: "+ff_error(ret))}if(format>=5){for(var ci=0;ci>=log2cw;h>>=log2ch}layout.push({offset:off,stride:w*bpp});off+=w*h*bpp}}for(var p=0;p>=log2ch;var ioff=lplane.offset;var ooff=0;var stride=Math.min(lplane.stride,linesize);for(var y=0;y LibAVFactory); +/* + * Copyright (C) 2019-2024 Yahweasel + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +if (/* We're in a worker */ + typeof importScripts !== "undefined" && + /* We're not being loaded with noworker from the main code */ + typeof LibAV === "undefined" && + /* We're not being loaded as a thread */ + ( + (typeof self === "undefined" && typeof Module === "undefined") || + (typeof self !== "undefined" && self.name !== "em-pthread") + ) + ) (function() { + var libav; + + Promise.all([]).then(function() { + /* We're the primary code for this worker. The host should ask us to + * load immediately. */ + return new Promise(function(res, rej) { + onmessage = function(e) { + if (e && e.data && e.data.config) { + LibAVFactory({ + wasmurl: e.data.config.wasmurl, + variant: e.data.config.variant + }).then(res).catch(rej); + } + }; + }); + + }).then(function(lib) { + libav = lib; + + // Now we're ready for normal messages + onmessage = function(e) { + var id = e.data[0]; + var fun = e.data[1]; + var args = e.data.slice(2); + var ret = void 0; + var succ = true; + + function reply() { + var transfer = []; + if (ret && ret.libavjsTransfer) + transfer = ret.libavjsTransfer + try { + postMessage([id, fun, succ, ret], transfer); + } catch (ex) { + try { + ret = JSON.parse(JSON.stringify( + ret, function(k, v) { return v; } + )); + postMessage([id, fun, succ, ret], transfer); + } catch (ex) { + postMessage([id, fun, succ, "" + ret]); + } + } + } + + try { + ret = libav[fun].apply(libav, args); + } catch (ex) { + succ = false; + ret = ex; + } + if (succ && ret && ret.then) { + // Let the promise resolve + ret.then(function(res) { + ret = res; + }).catch(function(ex) { + succ = false; + ret = ex; + }).then(reply); + + } else reply(); + }; + + libav.onwrite = function(name, pos, buf) { + /* We have to buf.slice(0) so we don't duplicate the entire heap just + * to get one part of it in postMessage */ + buf = buf.slice(0); + postMessage(["onwrite", "onwrite", true, [name, pos, buf]], [buf.buffer]); + }; + + libav.onread = function(name, pos, len) { + postMessage(["onread", "onread", true, [name, pos, len]]); + }; + + libav.onblockread = function(name, pos, len) { + postMessage(["onblockread", "onblockread", true, [name, pos, len]]); + }; + + postMessage(["onready", "onready", true, null]); + + }).catch(function(ex) { + console.log("Loading LibAV failed\n" + ex + "\n" + ex.stack); + }); +})(); diff --git a/src/libav-6.5.7.1-all.wasm.wasm b/src/libav-6.5.7.1-all.wasm.wasm new file mode 100644 index 0000000..6533249 Binary files /dev/null and b/src/libav-6.5.7.1-all.wasm.wasm differ diff --git a/src/libavjs-webcodecs-polyfill.js b/src/libavjs-webcodecs-polyfill.js index 88861e2..9549965 100644 --- a/src/libavjs-webcodecs-polyfill.js +++ b/src/libavjs-webcodecs-polyfill.js @@ -623,7 +623,8 @@ ["libvorbis", "vorbis"], ["libaom-av1", "av01"], ["libvpx-vp9", "vp09"], - ["libvpx", "vp8"] + ["libvpx", "vp8"], + ["libopenh264", "avc"] ]) { if (encoders) { if (yield libav.avcodec_find_encoder_by_name(avname)) @@ -807,6 +808,14 @@ options["cpu-used"] = "8"; } break; + case "h264": + video = true; + outCodec = "libopenh264"; + if (config.latencyMode === "realtime") { + options.quality = "realtime"; + options["cpu-used"] = "8"; + } + break; // Unsupported case "mp3": case "mp4a": diff --git a/src/main.js b/src/main.js index 542f40b..d61fdfe 100644 --- a/src/main.js +++ b/src/main.js @@ -5205,30 +5205,120 @@ async function render() { selection: [], shapeselection: [], }; + const oldContext = context; + context = exportContext; + + const oldRootFrame = root.currentFrameNum + let currentFrame = 0; + const bitrate = 1e6 + const frameTimeMicroseconds = parseInt(1_000_000 / config.framerate) + let target; + let muxer; + let videoEncoder; switch (ext) { case "mp4": - exportMp4(path) + // exportMp4(path) + createProgressModal(); + + // Store the original context + + await LibAVWebCodecs.load() + console.log("Codecs loaded") + target = new Mp4Muxer.ArrayBufferTarget() + muxer = new Mp4Muxer.Muxer({ + target: target, + video: { + codec: 'avc', + width: config.fileWidth, + height: config.fileHeight, + frameRate: config.framerate, + }, + fastStart: 'in-memory', + firstTimestampBehavior: 'offset', + }) + videoEncoder = new VideoEncoder({ + output: (chunk, meta) => muxer.addVideoChunk(chunk, meta, undefined, undefined, frameTimeMicroseconds),//, currentFrame * frameTimeMicroseconds), + error: (e) => console.error(e), + }) + + videoEncoder.configure({ + codec: 'avc1.42001f', + width: 1280, + height: 720, + bitrate: 1e6 + }); + + async function finishMp4Encoding() { + const progressText = document.getElementById('progressText'); + progressText.innerText = 'Finalizing...'; + const progressBar = document.getElementById('progressBar'); + progressBar.value = 100; + await videoEncoder.flush() + muxer.finalize() + await writeFile( + path, + new Uint8Array(target.buffer), + ); + const modal = document.getElementById('progressModal'); + modal.style.display = 'none'; + document.querySelector("body").style.cursor = "default"; + } + + const processMp4Frame = async () => { + if (currentFrame < root.maxFrame) { + // Update progress bar + const progressText = document.getElementById('progressText'); + progressText.innerText = `Rendering frame ${currentFrame + 1} of ${root.maxFrame}`; + const progressBar = document.getElementById('progressBar'); + const progress = Math.round(((currentFrame + 1) / root.maxFrame) * 100); + progressBar.value = progress; + + root.setFrameNum(currentFrame) + exportContext.ctx.fillStyle = "white"; + exportContext.ctx.rect(0, 0, config.fileWidth, config.fileHeight); + exportContext.ctx.fill(); + root.draw(exportContext.ctx); + const frame = new VideoFrame( + await LibAVWebCodecs.createImageBitmap(canvas), + { timestamp: currentFrame * frameTimeMicroseconds } + ); + + async function encodeFrame(frame) { + // const keyFrame = true + const keyFrame = currentFrame % 60 === 0 + videoEncoder.encode(frame, { keyFrame }) + frame.close() + } + + await encodeFrame(frame) + + frame.close() + + + currentFrame++; + setTimeout(processMp4Frame, 4); + } else { + // Once all frames are processed, reset context and export + context = oldContext; + root.setFrameNum(oldRootFrame) + finishMp4Encoding() + } + }; + + processMp4Frame(); return break case "webm": createProgressModal(); - // Store the original context - const oldContext = context; - context = exportContext; - - const oldRootFrame = root.currentFrameNum - let currentFrame = 0; - const bitrate = 1e6 - const frameTimeMicroseconds = parseInt(1_000_000 / config.framerate) await LibAVWebCodecs.load() console.log("Codecs loaded") - const target = new WebMMuxer.ArrayBufferTarget() - const muxer = new WebMMuxer.Muxer({ + target = new WebMMuxer.ArrayBufferTarget() + muxer = new WebMMuxer.Muxer({ target: target, video: { codec: 'V_VP9', @@ -5238,7 +5328,7 @@ async function render() { }, firstTimestampBehavior: 'offset', }) - let videoEncoder = new VideoEncoder({ + videoEncoder = new VideoEncoder({ output: (chunk, meta) => muxer.addVideoChunk(chunk, meta),//, currentFrame * frameTimeMicroseconds), error: (e) => console.error(e), }) diff --git a/src/mp4-muxer.js b/src/mp4-muxer.js new file mode 100644 index 0000000..3447ac5 --- /dev/null +++ b/src/mp4-muxer.js @@ -0,0 +1,1908 @@ +"use strict"; +var Mp4Muxer = (() => { + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); + }; + var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; + }; + var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + var __accessCheck = (obj, member, msg) => { + if (!member.has(obj)) + throw TypeError("Cannot " + msg); + }; + var __privateGet = (obj, member, getter) => { + __accessCheck(obj, member, "read from private field"); + return getter ? getter.call(obj) : member.get(obj); + }; + var __privateAdd = (obj, member, value) => { + if (member.has(obj)) + throw TypeError("Cannot add the same private member more than once"); + member instanceof WeakSet ? member.add(obj) : member.set(obj, value); + }; + var __privateSet = (obj, member, value, setter) => { + __accessCheck(obj, member, "write to private field"); + setter ? setter.call(obj, value) : member.set(obj, value); + return value; + }; + var __privateWrapper = (obj, member, setter, getter) => ({ + set _(value) { + __privateSet(obj, member, value, setter); + }, + get _() { + return __privateGet(obj, member, getter); + } + }); + var __privateMethod = (obj, member, method) => { + __accessCheck(obj, member, "access private method"); + return method; + }; + + // src/index.ts + var src_exports = {}; + __export(src_exports, { + ArrayBufferTarget: () => ArrayBufferTarget, + FileSystemWritableFileStreamTarget: () => FileSystemWritableFileStreamTarget, + Muxer: () => Muxer, + StreamTarget: () => StreamTarget + }); + + // src/misc.ts + var bytes = new Uint8Array(8); + var view = new DataView(bytes.buffer); + var u8 = (value) => { + return [(value % 256 + 256) % 256]; + }; + var u16 = (value) => { + view.setUint16(0, value, false); + return [bytes[0], bytes[1]]; + }; + var i16 = (value) => { + view.setInt16(0, value, false); + return [bytes[0], bytes[1]]; + }; + var u24 = (value) => { + view.setUint32(0, value, false); + return [bytes[1], bytes[2], bytes[3]]; + }; + var u32 = (value) => { + view.setUint32(0, value, false); + return [bytes[0], bytes[1], bytes[2], bytes[3]]; + }; + var i32 = (value) => { + view.setInt32(0, value, false); + return [bytes[0], bytes[1], bytes[2], bytes[3]]; + }; + var u64 = (value) => { + view.setUint32(0, Math.floor(value / 2 ** 32), false); + view.setUint32(4, value, false); + return [bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]]; + }; + var fixed_8_8 = (value) => { + view.setInt16(0, 2 ** 8 * value, false); + return [bytes[0], bytes[1]]; + }; + var fixed_16_16 = (value) => { + view.setInt32(0, 2 ** 16 * value, false); + return [bytes[0], bytes[1], bytes[2], bytes[3]]; + }; + var fixed_2_30 = (value) => { + view.setInt32(0, 2 ** 30 * value, false); + return [bytes[0], bytes[1], bytes[2], bytes[3]]; + }; + var ascii = (text, nullTerminated = false) => { + let bytes2 = Array(text.length).fill(null).map((_, i) => text.charCodeAt(i)); + if (nullTerminated) + bytes2.push(0); + return bytes2; + }; + var last = (arr) => { + return arr && arr[arr.length - 1]; + }; + var lastPresentedSample = (samples) => { + let result = void 0; + for (let sample of samples) { + if (!result || sample.presentationTimestamp > result.presentationTimestamp) { + result = sample; + } + } + return result; + }; + var intoTimescale = (timeInSeconds, timescale, round = true) => { + let value = timeInSeconds * timescale; + return round ? Math.round(value) : value; + }; + var rotationMatrix = (rotationInDegrees) => { + let theta = rotationInDegrees * (Math.PI / 180); + let cosTheta = Math.cos(theta); + let sinTheta = Math.sin(theta); + return [ + cosTheta, + sinTheta, + 0, + -sinTheta, + cosTheta, + 0, + 0, + 0, + 1 + ]; + }; + var IDENTITY_MATRIX = rotationMatrix(0); + var matrixToBytes = (matrix) => { + return [ + fixed_16_16(matrix[0]), + fixed_16_16(matrix[1]), + fixed_2_30(matrix[2]), + fixed_16_16(matrix[3]), + fixed_16_16(matrix[4]), + fixed_2_30(matrix[5]), + fixed_16_16(matrix[6]), + fixed_16_16(matrix[7]), + fixed_2_30(matrix[8]) + ]; + }; + var deepClone = (x) => { + if (!x) + return x; + if (typeof x !== "object") + return x; + if (Array.isArray(x)) + return x.map(deepClone); + return Object.fromEntries(Object.entries(x).map(([key, value]) => [key, deepClone(value)])); + }; + var isU32 = (value) => { + return value >= 0 && value < 2 ** 32; + }; + + // src/box.ts + var box = (type, contents, children) => ({ + type, + contents: contents && new Uint8Array(contents.flat(10)), + children + }); + var fullBox = (type, version, flags, contents, children) => box( + type, + [u8(version), u24(flags), contents ?? []], + children + ); + var ftyp = (details) => { + let minorVersion = 512; + if (details.fragmented) + return box("ftyp", [ + ascii("iso5"), + // Major brand + u32(minorVersion), + // Minor version + // Compatible brands + ascii("iso5"), + ascii("iso6"), + ascii("mp41") + ]); + return box("ftyp", [ + ascii("isom"), + // Major brand + u32(minorVersion), + // Minor version + // Compatible brands + ascii("isom"), + details.holdsAvc ? ascii("avc1") : [], + ascii("mp41") + ]); + }; + var mdat = (reserveLargeSize) => ({ type: "mdat", largeSize: reserveLargeSize }); + var free = (size) => ({ type: "free", size }); + var moov = (tracks, creationTime, fragmented = false) => box("moov", null, [ + mvhd(creationTime, tracks), + ...tracks.map((x) => trak(x, creationTime)), + fragmented ? mvex(tracks) : null + ]); + var mvhd = (creationTime, tracks) => { + let duration = intoTimescale(Math.max( + 0, + ...tracks.filter((x) => x.samples.length > 0).map((x) => { + const lastSample = lastPresentedSample(x.samples); + return lastSample.presentationTimestamp + lastSample.duration; + }) + ), GLOBAL_TIMESCALE); + let nextTrackId = Math.max(...tracks.map((x) => x.id)) + 1; + let needsU64 = !isU32(creationTime) || !isU32(duration); + let u32OrU64 = needsU64 ? u64 : u32; + return fullBox("mvhd", +needsU64, 0, [ + u32OrU64(creationTime), + // Creation time + u32OrU64(creationTime), + // Modification time + u32(GLOBAL_TIMESCALE), + // Timescale + u32OrU64(duration), + // Duration + fixed_16_16(1), + // Preferred rate + fixed_8_8(1), + // Preferred volume + Array(10).fill(0), + // Reserved + matrixToBytes(IDENTITY_MATRIX), + // Matrix + Array(24).fill(0), + // Pre-defined + u32(nextTrackId) + // Next track ID + ]); + }; + var trak = (track, creationTime) => box("trak", null, [ + tkhd(track, creationTime), + mdia(track, creationTime) + ]); + var tkhd = (track, creationTime) => { + let lastSample = lastPresentedSample(track.samples); + let durationInGlobalTimescale = intoTimescale( + lastSample ? lastSample.presentationTimestamp + lastSample.duration : 0, + GLOBAL_TIMESCALE + ); + let needsU64 = !isU32(creationTime) || !isU32(durationInGlobalTimescale); + let u32OrU64 = needsU64 ? u64 : u32; + let matrix; + if (track.info.type === "video") { + matrix = typeof track.info.rotation === "number" ? rotationMatrix(track.info.rotation) : track.info.rotation; + } else { + matrix = IDENTITY_MATRIX; + } + return fullBox("tkhd", +needsU64, 3, [ + u32OrU64(creationTime), + // Creation time + u32OrU64(creationTime), + // Modification time + u32(track.id), + // Track ID + u32(0), + // Reserved + u32OrU64(durationInGlobalTimescale), + // Duration + Array(8).fill(0), + // Reserved + u16(0), + // Layer + u16(0), + // Alternate group + fixed_8_8(track.info.type === "audio" ? 1 : 0), + // Volume + u16(0), + // Reserved + matrixToBytes(matrix), + // Matrix + fixed_16_16(track.info.type === "video" ? track.info.width : 0), + // Track width + fixed_16_16(track.info.type === "video" ? track.info.height : 0) + // Track height + ]); + }; + var mdia = (track, creationTime) => box("mdia", null, [ + mdhd(track, creationTime), + hdlr(track.info.type === "video" ? "vide" : "soun"), + minf(track) + ]); + var mdhd = (track, creationTime) => { + let lastSample = lastPresentedSample(track.samples); + let localDuration = intoTimescale( + lastSample ? lastSample.presentationTimestamp + lastSample.duration : 0, + track.timescale + ); + let needsU64 = !isU32(creationTime) || !isU32(localDuration); + let u32OrU64 = needsU64 ? u64 : u32; + return fullBox("mdhd", +needsU64, 0, [ + u32OrU64(creationTime), + // Creation time + u32OrU64(creationTime), + // Modification time + u32(track.timescale), + // Timescale + u32OrU64(localDuration), + // Duration + u16(21956), + // Language ("und", undetermined) + u16(0) + // Quality + ]); + }; + var hdlr = (componentSubtype) => fullBox("hdlr", 0, 0, [ + ascii("mhlr"), + // Component type + ascii(componentSubtype), + // Component subtype + u32(0), + // Component manufacturer + u32(0), + // Component flags + u32(0), + // Component flags mask + ascii("mp4-muxer-hdlr", true) + // Component name + ]); + var minf = (track) => box("minf", null, [ + track.info.type === "video" ? vmhd() : smhd(), + dinf(), + stbl(track) + ]); + var vmhd = () => fullBox("vmhd", 0, 1, [ + u16(0), + // Graphics mode + u16(0), + // Opcolor R + u16(0), + // Opcolor G + u16(0) + // Opcolor B + ]); + var smhd = () => fullBox("smhd", 0, 0, [ + u16(0), + // Balance + u16(0) + // Reserved + ]); + var dinf = () => box("dinf", null, [ + dref() + ]); + var dref = () => fullBox("dref", 0, 0, [ + u32(1) + // Entry count + ], [ + url() + ]); + var url = () => fullBox("url ", 0, 1); + var stbl = (track) => { + const needsCtts = track.compositionTimeOffsetTable.length > 1 || track.compositionTimeOffsetTable.some((x) => x.sampleCompositionTimeOffset !== 0); + return box("stbl", null, [ + stsd(track), + stts(track), + stss(track), + stsc(track), + stsz(track), + stco(track), + needsCtts ? ctts(track) : null + ]); + }; + var stsd = (track) => fullBox("stsd", 0, 0, [ + u32(1) + // Entry count + ], [ + track.info.type === "video" ? videoSampleDescription( + VIDEO_CODEC_TO_BOX_NAME[track.info.codec], + track + ) : soundSampleDescription( + AUDIO_CODEC_TO_BOX_NAME[track.info.codec], + track + ) + ]); + var videoSampleDescription = (compressionType, track) => box(compressionType, [ + Array(6).fill(0), + // Reserved + u16(1), + // Data reference index + u16(0), + // Pre-defined + u16(0), + // Reserved + Array(12).fill(0), + // Pre-defined + u16(track.info.width), + // Width + u16(track.info.height), + // Height + u32(4718592), + // Horizontal resolution + u32(4718592), + // Vertical resolution + u32(0), + // Reserved + u16(1), + // Frame count + Array(32).fill(0), + // Compressor name + u16(24), + // Depth + i16(65535) + // Pre-defined + ], [ + VIDEO_CODEC_TO_CONFIGURATION_BOX[track.info.codec](track), + track.info.decoderConfig.colorSpace ? colr(track) : null + ]); + var COLOR_PRIMARIES_MAP = { + "bt709": 1, + // ITU-R BT.709 + "bt470bg": 5, + // ITU-R BT.470BG + "smpte170m": 6 + // ITU-R BT.601 525 - SMPTE 170M + }; + var TRANSFER_CHARACTERISTICS_MAP = { + "bt709": 1, + // ITU-R BT.709 + "smpte170m": 6, + // SMPTE 170M + "iec61966-2-1": 13 + // IEC 61966-2-1 + }; + var MATRIX_COEFFICIENTS_MAP = { + "rgb": 0, + // Identity + "bt709": 1, + // ITU-R BT.709 + "bt470bg": 5, + // ITU-R BT.470BG + "smpte170m": 6 + // SMPTE 170M + }; + var colr = (track) => box("colr", [ + ascii("nclx"), + // Colour type + u16(COLOR_PRIMARIES_MAP[track.info.decoderConfig.colorSpace.primaries]), + // Colour primaries + u16(TRANSFER_CHARACTERISTICS_MAP[track.info.decoderConfig.colorSpace.transfer]), + // Transfer characteristics + u16(MATRIX_COEFFICIENTS_MAP[track.info.decoderConfig.colorSpace.matrix]), + // Matrix coefficients + u8((track.info.decoderConfig.colorSpace.fullRange ? 1 : 0) << 7) + // Full range flag + ]); + var avcC = (track) => track.info.decoderConfig && box("avcC", [ + // For AVC, description is an AVCDecoderConfigurationRecord, so nothing else to do here + ...new Uint8Array(track.info.decoderConfig.description) + ]); + var hvcC = (track) => track.info.decoderConfig && box("hvcC", [ + // For HEVC, description is a HEVCDecoderConfigurationRecord, so nothing else to do here + ...new Uint8Array(track.info.decoderConfig.description) + ]); + var vpcC = (track) => { + if (!track.info.decoderConfig) { + return null; + } + let decoderConfig = track.info.decoderConfig; + if (!decoderConfig.colorSpace) { + throw new Error(`'colorSpace' is required in the decoder config for VP9.`); + } + let parts = decoderConfig.codec.split("."); + let profile = Number(parts[1]); + let level = Number(parts[2]); + let bitDepth = Number(parts[3]); + let chromaSubsampling = 0; + let thirdByte = (bitDepth << 4) + (chromaSubsampling << 1) + Number(decoderConfig.colorSpace.fullRange); + let colourPrimaries = 2; + let transferCharacteristics = 2; + let matrixCoefficients = 2; + return fullBox("vpcC", 1, 0, [ + u8(profile), + // Profile + u8(level), + // Level + u8(thirdByte), + // Bit depth, chroma subsampling, full range + u8(colourPrimaries), + // Colour primaries + u8(transferCharacteristics), + // Transfer characteristics + u8(matrixCoefficients), + // Matrix coefficients + u16(0) + // Codec initialization data size + ]); + }; + var av1C = () => { + let marker = 1; + let version = 1; + let firstByte = (marker << 7) + version; + return box("av1C", [ + firstByte, + 0, + 0, + 0 + ]); + }; + var soundSampleDescription = (compressionType, track) => box(compressionType, [ + Array(6).fill(0), + // Reserved + u16(1), + // Data reference index + u16(0), + // Version + u16(0), + // Revision level + u32(0), + // Vendor + u16(track.info.numberOfChannels), + // Number of channels + u16(16), + // Sample size (bits) + u16(0), + // Compression ID + u16(0), + // Packet size + fixed_16_16(track.info.sampleRate) + // Sample rate + ], [ + AUDIO_CODEC_TO_CONFIGURATION_BOX[track.info.codec](track) + ]); + var esds = (track) => { + let description = new Uint8Array(track.info.decoderConfig.description); + return fullBox("esds", 0, 0, [ + // https://stackoverflow.com/a/54803118 + u32(58753152), + // TAG(3) = Object Descriptor ([2]) + u8(32 + description.byteLength), + // length of this OD (which includes the next 2 tags) + u16(1), + // ES_ID = 1 + u8(0), + // flags etc = 0 + u32(75530368), + // TAG(4) = ES Descriptor ([2]) embedded in above OD + u8(18 + description.byteLength), + // length of this ESD + u8(64), + // MPEG-4 Audio + u8(21), + // stream type(6bits)=5 audio, flags(2bits)=1 + u24(0), + // 24bit buffer size + u32(130071), + // max bitrate + u32(130071), + // avg bitrate + u32(92307584), + // TAG(5) = ASC ([2],[3]) embedded in above OD + u8(description.byteLength), + // length + ...description, + u32(109084800), + // TAG(6) + u8(1), + // length + u8(2) + // data + ]); + }; + var dOps = (track) => { + let preskip = 3840; + let gain = 0; + const description = track.info.decoderConfig?.description; + if (description) { + if (description.byteLength < 18) { + throw new TypeError("Invalid decoder description provided for Opus; must be at least 18 bytes long."); + } + const view2 = ArrayBuffer.isView(description) ? new DataView(description.buffer, description.byteOffset, description.byteLength) : new DataView(description); + preskip = view2.getUint16(10, true); + gain = view2.getInt16(14, true); + } + return box("dOps", [ + u8(0), + // Version + u8(track.info.numberOfChannels), + // OutputChannelCount + u16(preskip), + u32(track.info.sampleRate), + // InputSampleRate + fixed_8_8(gain), + // OutputGain + u8(0) + // ChannelMappingFamily + ]); + }; + var stts = (track) => { + return fullBox("stts", 0, 0, [ + u32(track.timeToSampleTable.length), + // Number of entries + track.timeToSampleTable.map((x) => [ + // Time-to-sample table + u32(x.sampleCount), + // Sample count + u32(x.sampleDelta) + // Sample duration + ]) + ]); + }; + var stss = (track) => { + if (track.samples.every((x) => x.type === "key")) + return null; + let keySamples = [...track.samples.entries()].filter(([, sample]) => sample.type === "key"); + return fullBox("stss", 0, 0, [ + u32(keySamples.length), + // Number of entries + keySamples.map(([index]) => u32(index + 1)) + // Sync sample table + ]); + }; + var stsc = (track) => { + return fullBox("stsc", 0, 0, [ + u32(track.compactlyCodedChunkTable.length), + // Number of entries + track.compactlyCodedChunkTable.map((x) => [ + // Sample-to-chunk table + u32(x.firstChunk), + // First chunk + u32(x.samplesPerChunk), + // Samples per chunk + u32(1) + // Sample description index + ]) + ]); + }; + var stsz = (track) => fullBox("stsz", 0, 0, [ + u32(0), + // Sample size (0 means non-constant size) + u32(track.samples.length), + // Number of entries + track.samples.map((x) => u32(x.size)) + // Sample size table + ]); + var stco = (track) => { + if (track.finalizedChunks.length > 0 && last(track.finalizedChunks).offset >= 2 ** 32) { + return fullBox("co64", 0, 0, [ + u32(track.finalizedChunks.length), + // Number of entries + track.finalizedChunks.map((x) => u64(x.offset)) + // Chunk offset table + ]); + } + return fullBox("stco", 0, 0, [ + u32(track.finalizedChunks.length), + // Number of entries + track.finalizedChunks.map((x) => u32(x.offset)) + // Chunk offset table + ]); + }; + var ctts = (track) => { + return fullBox("ctts", 0, 0, [ + u32(track.compositionTimeOffsetTable.length), + // Number of entries + track.compositionTimeOffsetTable.map((x) => [ + // Time-to-sample table + u32(x.sampleCount), + // Sample count + u32(x.sampleCompositionTimeOffset) + // Sample offset + ]) + ]); + }; + var mvex = (tracks) => { + return box("mvex", null, tracks.map(trex)); + }; + var trex = (track) => { + return fullBox("trex", 0, 0, [ + u32(track.id), + // Track ID + u32(1), + // Default sample description index + u32(0), + // Default sample duration + u32(0), + // Default sample size + u32(0) + // Default sample flags + ]); + }; + var moof = (sequenceNumber, tracks) => { + return box("moof", null, [ + mfhd(sequenceNumber), + ...tracks.map(traf) + ]); + }; + var mfhd = (sequenceNumber) => { + return fullBox("mfhd", 0, 0, [ + u32(sequenceNumber) + // Sequence number + ]); + }; + var fragmentSampleFlags = (sample) => { + let byte1 = 0; + let byte2 = 0; + let byte3 = 0; + let byte4 = 0; + let sampleIsDifferenceSample = sample.type === "delta"; + byte2 |= +sampleIsDifferenceSample; + if (sampleIsDifferenceSample) { + byte1 |= 1; + } else { + byte1 |= 2; + } + return byte1 << 24 | byte2 << 16 | byte3 << 8 | byte4; + }; + var traf = (track) => { + return box("traf", null, [ + tfhd(track), + tfdt(track), + trun(track) + ]); + }; + var tfhd = (track) => { + let tfFlags = 0; + tfFlags |= 8; + tfFlags |= 16; + tfFlags |= 32; + tfFlags |= 131072; + let referenceSample = track.currentChunk.samples[1] ?? track.currentChunk.samples[0]; + let referenceSampleInfo = { + duration: referenceSample.timescaleUnitsToNextSample, + size: referenceSample.size, + flags: fragmentSampleFlags(referenceSample) + }; + return fullBox("tfhd", 0, tfFlags, [ + u32(track.id), + // Track ID + u32(referenceSampleInfo.duration), + // Default sample duration + u32(referenceSampleInfo.size), + // Default sample size + u32(referenceSampleInfo.flags) + // Default sample flags + ]); + }; + var tfdt = (track) => { + return fullBox("tfdt", 1, 0, [ + u64(intoTimescale(track.currentChunk.startTimestamp, track.timescale)) + // Base Media Decode Time + ]); + }; + var trun = (track) => { + let allSampleDurations = track.currentChunk.samples.map((x) => x.timescaleUnitsToNextSample); + let allSampleSizes = track.currentChunk.samples.map((x) => x.size); + let allSampleFlags = track.currentChunk.samples.map(fragmentSampleFlags); + let allSampleCompositionTimeOffsets = track.currentChunk.samples.map((x) => intoTimescale(x.presentationTimestamp - x.decodeTimestamp, track.timescale)); + let uniqueSampleDurations = new Set(allSampleDurations); + let uniqueSampleSizes = new Set(allSampleSizes); + let uniqueSampleFlags = new Set(allSampleFlags); + let uniqueSampleCompositionTimeOffsets = new Set(allSampleCompositionTimeOffsets); + let firstSampleFlagsPresent = uniqueSampleFlags.size === 2 && allSampleFlags[0] !== allSampleFlags[1]; + let sampleDurationPresent = uniqueSampleDurations.size > 1; + let sampleSizePresent = uniqueSampleSizes.size > 1; + let sampleFlagsPresent = !firstSampleFlagsPresent && uniqueSampleFlags.size > 1; + let sampleCompositionTimeOffsetsPresent = uniqueSampleCompositionTimeOffsets.size > 1 || [...uniqueSampleCompositionTimeOffsets].some((x) => x !== 0); + let flags = 0; + flags |= 1; + flags |= 4 * +firstSampleFlagsPresent; + flags |= 256 * +sampleDurationPresent; + flags |= 512 * +sampleSizePresent; + flags |= 1024 * +sampleFlagsPresent; + flags |= 2048 * +sampleCompositionTimeOffsetsPresent; + return fullBox("trun", 1, flags, [ + u32(track.currentChunk.samples.length), + // Sample count + u32(track.currentChunk.offset - track.currentChunk.moofOffset || 0), + // Data offset + firstSampleFlagsPresent ? u32(allSampleFlags[0]) : [], + track.currentChunk.samples.map((_, i) => [ + sampleDurationPresent ? u32(allSampleDurations[i]) : [], + // Sample duration + sampleSizePresent ? u32(allSampleSizes[i]) : [], + // Sample size + sampleFlagsPresent ? u32(allSampleFlags[i]) : [], + // Sample flags + // Sample composition time offsets + sampleCompositionTimeOffsetsPresent ? i32(allSampleCompositionTimeOffsets[i]) : [] + ]) + ]); + }; + var mfra = (tracks) => { + return box("mfra", null, [ + ...tracks.map(tfra), + mfro() + ]); + }; + var tfra = (track, trackIndex) => { + let version = 1; + return fullBox("tfra", version, 0, [ + u32(track.id), + // Track ID + u32(63), + // This specifies that traf number, trun number and sample number are 32-bit ints + u32(track.finalizedChunks.length), + // Number of entries + track.finalizedChunks.map((chunk) => [ + u64(intoTimescale(chunk.startTimestamp, track.timescale)), + // Time + u64(chunk.moofOffset), + // moof offset + u32(trackIndex + 1), + // traf number + u32(1), + // trun number + u32(1) + // Sample number + ]) + ]); + }; + var mfro = () => { + return fullBox("mfro", 0, 0, [ + // This value needs to be overwritten manually from the outside, where the actual size of the enclosing mfra box + // is known + u32(0) + // Size + ]); + }; + var VIDEO_CODEC_TO_BOX_NAME = { + "avc": "avc1", + "hevc": "hvc1", + "vp9": "vp09", + "av1": "av01" + }; + var VIDEO_CODEC_TO_CONFIGURATION_BOX = { + "avc": avcC, + "hevc": hvcC, + "vp9": vpcC, + "av1": av1C + }; + var AUDIO_CODEC_TO_BOX_NAME = { + "aac": "mp4a", + "opus": "Opus" + }; + var AUDIO_CODEC_TO_CONFIGURATION_BOX = { + "aac": esds, + "opus": dOps + }; + + // src/target.ts + var isTarget = Symbol("isTarget"); + var Target = class { + }; + isTarget; + var ArrayBufferTarget = class extends Target { + constructor() { + super(...arguments); + this.buffer = null; + } + }; + var StreamTarget = class extends Target { + constructor(options) { + super(); + this.options = options; + if (typeof options !== "object") { + throw new TypeError("StreamTarget requires an options object to be passed to its constructor."); + } + if (options.onData) { + if (typeof options.onData !== "function") { + throw new TypeError("options.onData, when provided, must be a function."); + } + if (options.onData.length < 2) { + throw new TypeError( + "options.onData, when provided, must be a function that takes in at least two arguments (data and position). Ignoring the position argument, which specifies the byte offset at which the data is to be written, can lead to broken outputs." + ); + } + } + if (options.chunked !== void 0 && typeof options.chunked !== "boolean") { + throw new TypeError("options.chunked, when provided, must be a boolean."); + } + if (options.chunkSize !== void 0 && (!Number.isInteger(options.chunkSize) || options.chunkSize <= 0)) { + throw new TypeError("options.chunkSize, when provided, must be a positive integer."); + } + } + }; + var FileSystemWritableFileStreamTarget = class extends Target { + constructor(stream, options) { + super(); + this.stream = stream; + this.options = options; + if (!(stream instanceof FileSystemWritableFileStream)) { + throw new TypeError("FileSystemWritableFileStreamTarget requires a FileSystemWritableFileStream instance."); + } + if (options !== void 0 && typeof options !== "object") { + throw new TypeError("FileSystemWritableFileStreamTarget's options, when provided, must be an object."); + } + if (options) { + if (options.chunkSize !== void 0 && (!Number.isInteger(options.chunkSize) || options.chunkSize <= 0)) { + throw new TypeError("options.chunkSize, when provided, must be a positive integer"); + } + } + } + }; + + // src/writer.ts + var _helper, _helperView; + var Writer = class { + constructor() { + this.pos = 0; + __privateAdd(this, _helper, new Uint8Array(8)); + __privateAdd(this, _helperView, new DataView(__privateGet(this, _helper).buffer)); + /** + * Stores the position from the start of the file to where boxes elements have been written. This is used to + * rewrite/edit elements that were already added before, and to measure sizes of things. + */ + this.offsets = /* @__PURE__ */ new WeakMap(); + } + /** Sets the current position for future writes to a new one. */ + seek(newPos) { + this.pos = newPos; + } + writeU32(value) { + __privateGet(this, _helperView).setUint32(0, value, false); + this.write(__privateGet(this, _helper).subarray(0, 4)); + } + writeU64(value) { + __privateGet(this, _helperView).setUint32(0, Math.floor(value / 2 ** 32), false); + __privateGet(this, _helperView).setUint32(4, value, false); + this.write(__privateGet(this, _helper).subarray(0, 8)); + } + writeAscii(text) { + for (let i = 0; i < text.length; i++) { + __privateGet(this, _helperView).setUint8(i % 8, text.charCodeAt(i)); + if (i % 8 === 7) + this.write(__privateGet(this, _helper)); + } + if (text.length % 8 !== 0) { + this.write(__privateGet(this, _helper).subarray(0, text.length % 8)); + } + } + writeBox(box2) { + this.offsets.set(box2, this.pos); + if (box2.contents && !box2.children) { + this.writeBoxHeader(box2, box2.size ?? box2.contents.byteLength + 8); + this.write(box2.contents); + } else { + let startPos = this.pos; + this.writeBoxHeader(box2, 0); + if (box2.contents) + this.write(box2.contents); + if (box2.children) { + for (let child of box2.children) + if (child) + this.writeBox(child); + } + let endPos = this.pos; + let size = box2.size ?? endPos - startPos; + this.seek(startPos); + this.writeBoxHeader(box2, size); + this.seek(endPos); + } + } + writeBoxHeader(box2, size) { + this.writeU32(box2.largeSize ? 1 : size); + this.writeAscii(box2.type); + if (box2.largeSize) + this.writeU64(size); + } + measureBoxHeader(box2) { + return 8 + (box2.largeSize ? 8 : 0); + } + patchBox(box2) { + let endPos = this.pos; + this.seek(this.offsets.get(box2)); + this.writeBox(box2); + this.seek(endPos); + } + measureBox(box2) { + if (box2.contents && !box2.children) { + let headerSize = this.measureBoxHeader(box2); + return headerSize + box2.contents.byteLength; + } else { + let result = this.measureBoxHeader(box2); + if (box2.contents) + result += box2.contents.byteLength; + if (box2.children) { + for (let child of box2.children) + if (child) + result += this.measureBox(child); + } + return result; + } + } + }; + _helper = new WeakMap(); + _helperView = new WeakMap(); + var _target, _buffer, _bytes, _maxPos, _ensureSize, ensureSize_fn; + var ArrayBufferTargetWriter = class extends Writer { + constructor(target) { + super(); + __privateAdd(this, _ensureSize); + __privateAdd(this, _target, void 0); + __privateAdd(this, _buffer, new ArrayBuffer(2 ** 16)); + __privateAdd(this, _bytes, new Uint8Array(__privateGet(this, _buffer))); + __privateAdd(this, _maxPos, 0); + __privateSet(this, _target, target); + } + write(data) { + __privateMethod(this, _ensureSize, ensureSize_fn).call(this, this.pos + data.byteLength); + __privateGet(this, _bytes).set(data, this.pos); + this.pos += data.byteLength; + __privateSet(this, _maxPos, Math.max(__privateGet(this, _maxPos), this.pos)); + } + finalize() { + __privateMethod(this, _ensureSize, ensureSize_fn).call(this, this.pos); + __privateGet(this, _target).buffer = __privateGet(this, _buffer).slice(0, Math.max(__privateGet(this, _maxPos), this.pos)); + } + }; + _target = new WeakMap(); + _buffer = new WeakMap(); + _bytes = new WeakMap(); + _maxPos = new WeakMap(); + _ensureSize = new WeakSet(); + ensureSize_fn = function(size) { + let newLength = __privateGet(this, _buffer).byteLength; + while (newLength < size) + newLength *= 2; + if (newLength === __privateGet(this, _buffer).byteLength) + return; + let newBuffer = new ArrayBuffer(newLength); + let newBytes = new Uint8Array(newBuffer); + newBytes.set(__privateGet(this, _bytes), 0); + __privateSet(this, _buffer, newBuffer); + __privateSet(this, _bytes, newBytes); + }; + var _target2, _sections; + var StreamTargetWriter = class extends Writer { + constructor(target) { + super(); + __privateAdd(this, _target2, void 0); + __privateAdd(this, _sections, []); + __privateSet(this, _target2, target); + } + write(data) { + __privateGet(this, _sections).push({ + data: data.slice(), + start: this.pos + }); + this.pos += data.byteLength; + } + flush() { + if (__privateGet(this, _sections).length === 0) + return; + let chunks = []; + let sorted = [...__privateGet(this, _sections)].sort((a, b) => a.start - b.start); + chunks.push({ + start: sorted[0].start, + size: sorted[0].data.byteLength + }); + for (let i = 1; i < sorted.length; i++) { + let lastChunk = chunks[chunks.length - 1]; + let section = sorted[i]; + if (section.start <= lastChunk.start + lastChunk.size) { + lastChunk.size = Math.max(lastChunk.size, section.start + section.data.byteLength - lastChunk.start); + } else { + chunks.push({ + start: section.start, + size: section.data.byteLength + }); + } + } + for (let chunk of chunks) { + chunk.data = new Uint8Array(chunk.size); + for (let section of __privateGet(this, _sections)) { + if (chunk.start <= section.start && section.start < chunk.start + chunk.size) { + chunk.data.set(section.data, section.start - chunk.start); + } + } + __privateGet(this, _target2).options.onData?.(chunk.data, chunk.start); + } + __privateGet(this, _sections).length = 0; + } + finalize() { + } + }; + _target2 = new WeakMap(); + _sections = new WeakMap(); + var DEFAULT_CHUNK_SIZE = 2 ** 24; + var MAX_CHUNKS_AT_ONCE = 2; + var _target3, _chunkSize, _chunks, _writeDataIntoChunks, writeDataIntoChunks_fn, _insertSectionIntoChunk, insertSectionIntoChunk_fn, _createChunk, createChunk_fn, _flushChunks, flushChunks_fn; + var ChunkedStreamTargetWriter = class extends Writer { + constructor(target) { + super(); + __privateAdd(this, _writeDataIntoChunks); + __privateAdd(this, _insertSectionIntoChunk); + __privateAdd(this, _createChunk); + __privateAdd(this, _flushChunks); + __privateAdd(this, _target3, void 0); + __privateAdd(this, _chunkSize, void 0); + /** + * The data is divided up into fixed-size chunks, whose contents are first filled in RAM and then flushed out. + * A chunk is flushed if all of its contents have been written. + */ + __privateAdd(this, _chunks, []); + __privateSet(this, _target3, target); + __privateSet(this, _chunkSize, target.options?.chunkSize ?? DEFAULT_CHUNK_SIZE); + if (!Number.isInteger(__privateGet(this, _chunkSize)) || __privateGet(this, _chunkSize) < 2 ** 10) { + throw new Error("Invalid StreamTarget options: chunkSize must be an integer not smaller than 1024."); + } + } + write(data) { + __privateMethod(this, _writeDataIntoChunks, writeDataIntoChunks_fn).call(this, data, this.pos); + __privateMethod(this, _flushChunks, flushChunks_fn).call(this); + this.pos += data.byteLength; + } + finalize() { + __privateMethod(this, _flushChunks, flushChunks_fn).call(this, true); + } + }; + _target3 = new WeakMap(); + _chunkSize = new WeakMap(); + _chunks = new WeakMap(); + _writeDataIntoChunks = new WeakSet(); + writeDataIntoChunks_fn = function(data, position) { + let chunkIndex = __privateGet(this, _chunks).findIndex((x) => x.start <= position && position < x.start + __privateGet(this, _chunkSize)); + if (chunkIndex === -1) + chunkIndex = __privateMethod(this, _createChunk, createChunk_fn).call(this, position); + let chunk = __privateGet(this, _chunks)[chunkIndex]; + let relativePosition = position - chunk.start; + let toWrite = data.subarray(0, Math.min(__privateGet(this, _chunkSize) - relativePosition, data.byteLength)); + chunk.data.set(toWrite, relativePosition); + let section = { + start: relativePosition, + end: relativePosition + toWrite.byteLength + }; + __privateMethod(this, _insertSectionIntoChunk, insertSectionIntoChunk_fn).call(this, chunk, section); + if (chunk.written[0].start === 0 && chunk.written[0].end === __privateGet(this, _chunkSize)) { + chunk.shouldFlush = true; + } + if (__privateGet(this, _chunks).length > MAX_CHUNKS_AT_ONCE) { + for (let i = 0; i < __privateGet(this, _chunks).length - 1; i++) { + __privateGet(this, _chunks)[i].shouldFlush = true; + } + __privateMethod(this, _flushChunks, flushChunks_fn).call(this); + } + if (toWrite.byteLength < data.byteLength) { + __privateMethod(this, _writeDataIntoChunks, writeDataIntoChunks_fn).call(this, data.subarray(toWrite.byteLength), position + toWrite.byteLength); + } + }; + _insertSectionIntoChunk = new WeakSet(); + insertSectionIntoChunk_fn = function(chunk, section) { + let low = 0; + let high = chunk.written.length - 1; + let index = -1; + while (low <= high) { + let mid = Math.floor(low + (high - low + 1) / 2); + if (chunk.written[mid].start <= section.start) { + low = mid + 1; + index = mid; + } else { + high = mid - 1; + } + } + chunk.written.splice(index + 1, 0, section); + if (index === -1 || chunk.written[index].end < section.start) + index++; + while (index < chunk.written.length - 1 && chunk.written[index].end >= chunk.written[index + 1].start) { + chunk.written[index].end = Math.max(chunk.written[index].end, chunk.written[index + 1].end); + chunk.written.splice(index + 1, 1); + } + }; + _createChunk = new WeakSet(); + createChunk_fn = function(includesPosition) { + let start = Math.floor(includesPosition / __privateGet(this, _chunkSize)) * __privateGet(this, _chunkSize); + let chunk = { + start, + data: new Uint8Array(__privateGet(this, _chunkSize)), + written: [], + shouldFlush: false + }; + __privateGet(this, _chunks).push(chunk); + __privateGet(this, _chunks).sort((a, b) => a.start - b.start); + return __privateGet(this, _chunks).indexOf(chunk); + }; + _flushChunks = new WeakSet(); + flushChunks_fn = function(force = false) { + for (let i = 0; i < __privateGet(this, _chunks).length; i++) { + let chunk = __privateGet(this, _chunks)[i]; + if (!chunk.shouldFlush && !force) + continue; + for (let section of chunk.written) { + __privateGet(this, _target3).options.onData?.( + chunk.data.subarray(section.start, section.end), + chunk.start + section.start + ); + } + __privateGet(this, _chunks).splice(i--, 1); + } + }; + var FileSystemWritableFileStreamTargetWriter = class extends ChunkedStreamTargetWriter { + constructor(target) { + super(new StreamTarget({ + onData: (data, position) => target.stream.write({ + type: "write", + data, + position + }), + chunkSize: target.options?.chunkSize + })); + } + }; + + // src/muxer.ts + var GLOBAL_TIMESCALE = 1e3; + var SUPPORTED_VIDEO_CODECS = ["avc", "hevc", "vp9", "av1"]; + var SUPPORTED_AUDIO_CODECS = ["aac", "opus"]; + var TIMESTAMP_OFFSET = 2082844800; + var FIRST_TIMESTAMP_BEHAVIORS = ["strict", "offset", "cross-track-offset"]; + var _options, _writer, _ftypSize, _mdat, _videoTrack, _audioTrack, _creationTime, _finalizedChunks, _nextFragmentNumber, _videoSampleQueue, _audioSampleQueue, _finalized, _validateOptions, validateOptions_fn, _writeHeader, writeHeader_fn, _computeMoovSizeUpperBound, computeMoovSizeUpperBound_fn, _prepareTracks, prepareTracks_fn, _generateMpeg4AudioSpecificConfig, generateMpeg4AudioSpecificConfig_fn, _createSampleForTrack, createSampleForTrack_fn, _addSampleToTrack, addSampleToTrack_fn, _validateTimestamp, validateTimestamp_fn, _finalizeCurrentChunk, finalizeCurrentChunk_fn, _finalizeFragment, finalizeFragment_fn, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn, _ensureNotFinalized, ensureNotFinalized_fn; + var Muxer = class { + constructor(options) { + __privateAdd(this, _validateOptions); + __privateAdd(this, _writeHeader); + __privateAdd(this, _computeMoovSizeUpperBound); + __privateAdd(this, _prepareTracks); + // https://wiki.multimedia.cx/index.php/MPEG-4_Audio + __privateAdd(this, _generateMpeg4AudioSpecificConfig); + __privateAdd(this, _createSampleForTrack); + __privateAdd(this, _addSampleToTrack); + __privateAdd(this, _validateTimestamp); + __privateAdd(this, _finalizeCurrentChunk); + __privateAdd(this, _finalizeFragment); + __privateAdd(this, _maybeFlushStreamingTargetWriter); + __privateAdd(this, _ensureNotFinalized); + __privateAdd(this, _options, void 0); + __privateAdd(this, _writer, void 0); + __privateAdd(this, _ftypSize, void 0); + __privateAdd(this, _mdat, void 0); + __privateAdd(this, _videoTrack, null); + __privateAdd(this, _audioTrack, null); + __privateAdd(this, _creationTime, Math.floor(Date.now() / 1e3) + TIMESTAMP_OFFSET); + __privateAdd(this, _finalizedChunks, []); + // Fields for fragmented MP4: + __privateAdd(this, _nextFragmentNumber, 1); + __privateAdd(this, _videoSampleQueue, []); + __privateAdd(this, _audioSampleQueue, []); + __privateAdd(this, _finalized, false); + __privateMethod(this, _validateOptions, validateOptions_fn).call(this, options); + options.video = deepClone(options.video); + options.audio = deepClone(options.audio); + options.fastStart = deepClone(options.fastStart); + this.target = options.target; + __privateSet(this, _options, { + firstTimestampBehavior: "strict", + ...options + }); + if (options.target instanceof ArrayBufferTarget) { + __privateSet(this, _writer, new ArrayBufferTargetWriter(options.target)); + } else if (options.target instanceof StreamTarget) { + __privateSet(this, _writer, options.target.options?.chunked ? new ChunkedStreamTargetWriter(options.target) : new StreamTargetWriter(options.target)); + } else if (options.target instanceof FileSystemWritableFileStreamTarget) { + __privateSet(this, _writer, new FileSystemWritableFileStreamTargetWriter(options.target)); + } else { + throw new Error(`Invalid target: ${options.target}`); + } + __privateMethod(this, _prepareTracks, prepareTracks_fn).call(this); + __privateMethod(this, _writeHeader, writeHeader_fn).call(this); + } + addVideoChunk(sample, meta, timestamp, compositionTimeOffset, duration) { + if (!(sample instanceof EncodedVideoChunk)) { + throw new TypeError("addVideoChunk's first argument (sample) must be of type EncodedVideoChunk."); + } + if (meta && typeof meta !== "object") { + throw new TypeError("addVideoChunk's second argument (meta), when provided, must be an object."); + } + if (timestamp !== void 0 && (!Number.isFinite(timestamp) || timestamp < 0)) { + throw new TypeError( + "addVideoChunk's third argument (timestamp), when provided, must be a non-negative real number." + ); + } + if (compositionTimeOffset !== void 0 && !Number.isFinite(compositionTimeOffset)) { + throw new TypeError( + "addVideoChunk's fourth argument (compositionTimeOffset), when provided, must be a real number." + ); + } + let data = new Uint8Array(sample.byteLength); + sample.copyTo(data); + this.addVideoChunkRaw( + data, + sample.type, + timestamp ?? sample.timestamp, + duration ?? sample.duration, + meta, + compositionTimeOffset + ); + } + addVideoChunkRaw(data, type, timestamp, duration, meta, compositionTimeOffset) { + if (!(data instanceof Uint8Array)) { + throw new TypeError("addVideoChunkRaw's first argument (data) must be an instance of Uint8Array."); + } + if (type !== "key" && type !== "delta") { + throw new TypeError("addVideoChunkRaw's second argument (type) must be either 'key' or 'delta'."); + } + if (!Number.isFinite(timestamp) || timestamp < 0) { + throw new TypeError("addVideoChunkRaw's third argument (timestamp) must be a non-negative real number."); + } + if (!Number.isFinite(duration) || duration < 0) { + throw new TypeError("addVideoChunkRaw's fourth argument (duration) must be a non-negative real number."); + } + if (meta && typeof meta !== "object") { + throw new TypeError("addVideoChunkRaw's fifth argument (meta), when provided, must be an object."); + } + if (compositionTimeOffset !== void 0 && !Number.isFinite(compositionTimeOffset)) { + throw new TypeError( + "addVideoChunkRaw's sixth argument (compositionTimeOffset), when provided, must be a real number." + ); + } + __privateMethod(this, _ensureNotFinalized, ensureNotFinalized_fn).call(this); + if (!__privateGet(this, _options).video) + throw new Error("No video track declared."); + if (typeof __privateGet(this, _options).fastStart === "object" && __privateGet(this, _videoTrack).samples.length === __privateGet(this, _options).fastStart.expectedVideoChunks) { + throw new Error(`Cannot add more video chunks than specified in 'fastStart' (${__privateGet(this, _options).fastStart.expectedVideoChunks}).`); + } + let videoSample = __privateMethod(this, _createSampleForTrack, createSampleForTrack_fn).call(this, __privateGet(this, _videoTrack), data, type, timestamp, duration, meta, compositionTimeOffset); + if (__privateGet(this, _options).fastStart === "fragmented" && __privateGet(this, _audioTrack)) { + while (__privateGet(this, _audioSampleQueue).length > 0 && __privateGet(this, _audioSampleQueue)[0].decodeTimestamp <= videoSample.decodeTimestamp) { + let audioSample = __privateGet(this, _audioSampleQueue).shift(); + __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample); + } + if (videoSample.decodeTimestamp <= __privateGet(this, _audioTrack).lastDecodeTimestamp) { + __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample); + } else { + __privateGet(this, _videoSampleQueue).push(videoSample); + } + } else { + __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample); + } + } + addAudioChunk(sample, meta, timestamp) { + if (!(sample instanceof EncodedAudioChunk)) { + throw new TypeError("addAudioChunk's first argument (sample) must be of type EncodedAudioChunk."); + } + if (meta && typeof meta !== "object") { + throw new TypeError("addAudioChunk's second argument (meta), when provided, must be an object."); + } + if (timestamp !== void 0 && (!Number.isFinite(timestamp) || timestamp < 0)) { + throw new TypeError( + "addAudioChunk's third argument (timestamp), when provided, must be a non-negative real number." + ); + } + let data = new Uint8Array(sample.byteLength); + sample.copyTo(data); + this.addAudioChunkRaw(data, sample.type, timestamp ?? sample.timestamp, sample.duration, meta); + } + addAudioChunkRaw(data, type, timestamp, duration, meta) { + if (!(data instanceof Uint8Array)) { + throw new TypeError("addAudioChunkRaw's first argument (data) must be an instance of Uint8Array."); + } + if (type !== "key" && type !== "delta") { + throw new TypeError("addAudioChunkRaw's second argument (type) must be either 'key' or 'delta'."); + } + if (!Number.isFinite(timestamp) || timestamp < 0) { + throw new TypeError("addAudioChunkRaw's third argument (timestamp) must be a non-negative real number."); + } + if (!Number.isFinite(duration) || duration < 0) { + throw new TypeError("addAudioChunkRaw's fourth argument (duration) must be a non-negative real number."); + } + if (meta && typeof meta !== "object") { + throw new TypeError("addAudioChunkRaw's fifth argument (meta), when provided, must be an object."); + } + __privateMethod(this, _ensureNotFinalized, ensureNotFinalized_fn).call(this); + if (!__privateGet(this, _options).audio) + throw new Error("No audio track declared."); + if (typeof __privateGet(this, _options).fastStart === "object" && __privateGet(this, _audioTrack).samples.length === __privateGet(this, _options).fastStart.expectedAudioChunks) { + throw new Error(`Cannot add more audio chunks than specified in 'fastStart' (${__privateGet(this, _options).fastStart.expectedAudioChunks}).`); + } + let audioSample = __privateMethod(this, _createSampleForTrack, createSampleForTrack_fn).call(this, __privateGet(this, _audioTrack), data, type, timestamp, duration, meta); + if (__privateGet(this, _options).fastStart === "fragmented" && __privateGet(this, _videoTrack)) { + while (__privateGet(this, _videoSampleQueue).length > 0 && __privateGet(this, _videoSampleQueue)[0].decodeTimestamp <= audioSample.decodeTimestamp) { + let videoSample = __privateGet(this, _videoSampleQueue).shift(); + __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample); + } + if (audioSample.decodeTimestamp <= __privateGet(this, _videoTrack).lastDecodeTimestamp) { + __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample); + } else { + __privateGet(this, _audioSampleQueue).push(audioSample); + } + } else { + __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample); + } + } + /** Finalizes the file, making it ready for use. Must be called after all video and audio chunks have been added. */ + finalize() { + if (__privateGet(this, _finalized)) { + throw new Error("Cannot finalize a muxer more than once."); + } + if (__privateGet(this, _options).fastStart === "fragmented") { + for (let videoSample of __privateGet(this, _videoSampleQueue)) + __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample); + for (let audioSample of __privateGet(this, _audioSampleQueue)) + __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample); + __privateMethod(this, _finalizeFragment, finalizeFragment_fn).call(this, false); + } else { + if (__privateGet(this, _videoTrack)) + __privateMethod(this, _finalizeCurrentChunk, finalizeCurrentChunk_fn).call(this, __privateGet(this, _videoTrack)); + if (__privateGet(this, _audioTrack)) + __privateMethod(this, _finalizeCurrentChunk, finalizeCurrentChunk_fn).call(this, __privateGet(this, _audioTrack)); + } + let tracks = [__privateGet(this, _videoTrack), __privateGet(this, _audioTrack)].filter(Boolean); + if (__privateGet(this, _options).fastStart === "in-memory") { + let mdatSize; + for (let i = 0; i < 2; i++) { + let movieBox2 = moov(tracks, __privateGet(this, _creationTime)); + let movieBoxSize = __privateGet(this, _writer).measureBox(movieBox2); + mdatSize = __privateGet(this, _writer).measureBox(__privateGet(this, _mdat)); + let currentChunkPos = __privateGet(this, _writer).pos + movieBoxSize + mdatSize; + for (let chunk of __privateGet(this, _finalizedChunks)) { + chunk.offset = currentChunkPos; + for (let { data } of chunk.samples) { + currentChunkPos += data.byteLength; + mdatSize += data.byteLength; + } + } + if (currentChunkPos < 2 ** 32) + break; + if (mdatSize >= 2 ** 32) + __privateGet(this, _mdat).largeSize = true; + } + let movieBox = moov(tracks, __privateGet(this, _creationTime)); + __privateGet(this, _writer).writeBox(movieBox); + __privateGet(this, _mdat).size = mdatSize; + __privateGet(this, _writer).writeBox(__privateGet(this, _mdat)); + for (let chunk of __privateGet(this, _finalizedChunks)) { + for (let sample of chunk.samples) { + __privateGet(this, _writer).write(sample.data); + sample.data = null; + } + } + } else if (__privateGet(this, _options).fastStart === "fragmented") { + let startPos = __privateGet(this, _writer).pos; + let mfraBox = mfra(tracks); + __privateGet(this, _writer).writeBox(mfraBox); + let mfraBoxSize = __privateGet(this, _writer).pos - startPos; + __privateGet(this, _writer).seek(__privateGet(this, _writer).pos - 4); + __privateGet(this, _writer).writeU32(mfraBoxSize); + } else { + let mdatPos = __privateGet(this, _writer).offsets.get(__privateGet(this, _mdat)); + let mdatSize = __privateGet(this, _writer).pos - mdatPos; + __privateGet(this, _mdat).size = mdatSize; + __privateGet(this, _mdat).largeSize = mdatSize >= 2 ** 32; + __privateGet(this, _writer).patchBox(__privateGet(this, _mdat)); + let movieBox = moov(tracks, __privateGet(this, _creationTime)); + if (typeof __privateGet(this, _options).fastStart === "object") { + __privateGet(this, _writer).seek(__privateGet(this, _ftypSize)); + __privateGet(this, _writer).writeBox(movieBox); + let remainingBytes = mdatPos - __privateGet(this, _writer).pos; + __privateGet(this, _writer).writeBox(free(remainingBytes)); + } else { + __privateGet(this, _writer).writeBox(movieBox); + } + } + __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this); + __privateGet(this, _writer).finalize(); + __privateSet(this, _finalized, true); + } + }; + _options = new WeakMap(); + _writer = new WeakMap(); + _ftypSize = new WeakMap(); + _mdat = new WeakMap(); + _videoTrack = new WeakMap(); + _audioTrack = new WeakMap(); + _creationTime = new WeakMap(); + _finalizedChunks = new WeakMap(); + _nextFragmentNumber = new WeakMap(); + _videoSampleQueue = new WeakMap(); + _audioSampleQueue = new WeakMap(); + _finalized = new WeakMap(); + _validateOptions = new WeakSet(); + validateOptions_fn = function(options) { + if (typeof options !== "object") { + throw new TypeError("The muxer requires an options object to be passed to its constructor."); + } + if (!(options.target instanceof Target)) { + throw new TypeError("The target must be provided and an instance of Target."); + } + if (options.video) { + if (!SUPPORTED_VIDEO_CODECS.includes(options.video.codec)) { + throw new TypeError(`Unsupported video codec: ${options.video.codec}`); + } + if (!Number.isInteger(options.video.width) || options.video.width <= 0) { + throw new TypeError(`Invalid video width: ${options.video.width}. Must be a positive integer.`); + } + if (!Number.isInteger(options.video.height) || options.video.height <= 0) { + throw new TypeError(`Invalid video height: ${options.video.height}. Must be a positive integer.`); + } + const videoRotation = options.video.rotation; + if (typeof videoRotation === "number" && ![0, 90, 180, 270].includes(videoRotation)) { + throw new TypeError(`Invalid video rotation: ${videoRotation}. Has to be 0, 90, 180 or 270.`); + } else if (Array.isArray(videoRotation) && (videoRotation.length !== 9 || videoRotation.some((value) => typeof value !== "number"))) { + throw new TypeError(`Invalid video transformation matrix: ${videoRotation.join()}`); + } + if (options.video.frameRate !== void 0 && (!Number.isInteger(options.video.frameRate) || options.video.frameRate <= 0)) { + throw new TypeError( + `Invalid video frame rate: ${options.video.frameRate}. Must be a positive integer.` + ); + } + } + if (options.audio) { + if (!SUPPORTED_AUDIO_CODECS.includes(options.audio.codec)) { + throw new TypeError(`Unsupported audio codec: ${options.audio.codec}`); + } + if (!Number.isInteger(options.audio.numberOfChannels) || options.audio.numberOfChannels <= 0) { + throw new TypeError( + `Invalid number of audio channels: ${options.audio.numberOfChannels}. Must be a positive integer.` + ); + } + if (!Number.isInteger(options.audio.sampleRate) || options.audio.sampleRate <= 0) { + throw new TypeError( + `Invalid audio sample rate: ${options.audio.sampleRate}. Must be a positive integer.` + ); + } + } + if (options.firstTimestampBehavior && !FIRST_TIMESTAMP_BEHAVIORS.includes(options.firstTimestampBehavior)) { + throw new TypeError(`Invalid first timestamp behavior: ${options.firstTimestampBehavior}`); + } + if (typeof options.fastStart === "object") { + if (options.video) { + if (options.fastStart.expectedVideoChunks === void 0) { + throw new TypeError(`'fastStart' is an object but is missing property 'expectedVideoChunks'.`); + } else if (!Number.isInteger(options.fastStart.expectedVideoChunks) || options.fastStart.expectedVideoChunks < 0) { + throw new TypeError(`'expectedVideoChunks' must be a non-negative integer.`); + } + } + if (options.audio) { + if (options.fastStart.expectedAudioChunks === void 0) { + throw new TypeError(`'fastStart' is an object but is missing property 'expectedAudioChunks'.`); + } else if (!Number.isInteger(options.fastStart.expectedAudioChunks) || options.fastStart.expectedAudioChunks < 0) { + throw new TypeError(`'expectedAudioChunks' must be a non-negative integer.`); + } + } + } else if (![false, "in-memory", "fragmented"].includes(options.fastStart)) { + throw new TypeError(`'fastStart' option must be false, 'in-memory', 'fragmented' or an object.`); + } + }; + _writeHeader = new WeakSet(); + writeHeader_fn = function() { + __privateGet(this, _writer).writeBox(ftyp({ + holdsAvc: __privateGet(this, _options).video?.codec === "avc", + fragmented: __privateGet(this, _options).fastStart === "fragmented" + })); + __privateSet(this, _ftypSize, __privateGet(this, _writer).pos); + if (__privateGet(this, _options).fastStart === "in-memory") { + __privateSet(this, _mdat, mdat(false)); + } else if (__privateGet(this, _options).fastStart === "fragmented") { + } else { + if (typeof __privateGet(this, _options).fastStart === "object") { + let moovSizeUpperBound = __privateMethod(this, _computeMoovSizeUpperBound, computeMoovSizeUpperBound_fn).call(this); + __privateGet(this, _writer).seek(__privateGet(this, _writer).pos + moovSizeUpperBound); + } + __privateSet(this, _mdat, mdat(true)); + __privateGet(this, _writer).writeBox(__privateGet(this, _mdat)); + } + __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this); + }; + _computeMoovSizeUpperBound = new WeakSet(); + computeMoovSizeUpperBound_fn = function() { + if (typeof __privateGet(this, _options).fastStart !== "object") + return; + let upperBound = 0; + let sampleCounts = [ + __privateGet(this, _options).fastStart.expectedVideoChunks, + __privateGet(this, _options).fastStart.expectedAudioChunks + ]; + for (let n of sampleCounts) { + if (!n) + continue; + upperBound += (4 + 4) * Math.ceil(2 / 3 * n); + upperBound += 4 * n; + upperBound += (4 + 4 + 4) * Math.ceil(2 / 3 * n); + upperBound += 4 * n; + upperBound += 8 * n; + } + upperBound += 4096; + return upperBound; + }; + _prepareTracks = new WeakSet(); + prepareTracks_fn = function() { + if (__privateGet(this, _options).video) { + __privateSet(this, _videoTrack, { + id: 1, + info: { + type: "video", + codec: __privateGet(this, _options).video.codec, + width: __privateGet(this, _options).video.width, + height: __privateGet(this, _options).video.height, + rotation: __privateGet(this, _options).video.rotation ?? 0, + decoderConfig: null + }, + // The fallback contains many common frame rates as factors + timescale: __privateGet(this, _options).video.frameRate ?? 57600, + samples: [], + finalizedChunks: [], + currentChunk: null, + firstDecodeTimestamp: void 0, + lastDecodeTimestamp: -1, + timeToSampleTable: [], + compositionTimeOffsetTable: [], + lastTimescaleUnits: null, + lastSample: null, + compactlyCodedChunkTable: [] + }); + } + if (__privateGet(this, _options).audio) { + __privateSet(this, _audioTrack, { + id: __privateGet(this, _options).video ? 2 : 1, + info: { + type: "audio", + codec: __privateGet(this, _options).audio.codec, + numberOfChannels: __privateGet(this, _options).audio.numberOfChannels, + sampleRate: __privateGet(this, _options).audio.sampleRate, + decoderConfig: null + }, + timescale: __privateGet(this, _options).audio.sampleRate, + samples: [], + finalizedChunks: [], + currentChunk: null, + firstDecodeTimestamp: void 0, + lastDecodeTimestamp: -1, + timeToSampleTable: [], + compositionTimeOffsetTable: [], + lastTimescaleUnits: null, + lastSample: null, + compactlyCodedChunkTable: [] + }); + if (__privateGet(this, _options).audio.codec === "aac") { + let guessedCodecPrivate = __privateMethod(this, _generateMpeg4AudioSpecificConfig, generateMpeg4AudioSpecificConfig_fn).call( + this, + 2, + // Object type for AAC-LC, since it's the most common + __privateGet(this, _options).audio.sampleRate, + __privateGet(this, _options).audio.numberOfChannels + ); + __privateGet(this, _audioTrack).info.decoderConfig = { + codec: __privateGet(this, _options).audio.codec, + description: guessedCodecPrivate, + numberOfChannels: __privateGet(this, _options).audio.numberOfChannels, + sampleRate: __privateGet(this, _options).audio.sampleRate + }; + } + } + }; + _generateMpeg4AudioSpecificConfig = new WeakSet(); + generateMpeg4AudioSpecificConfig_fn = function(objectType, sampleRate, numberOfChannels) { + let frequencyIndices = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350]; + let frequencyIndex = frequencyIndices.indexOf(sampleRate); + let channelConfig = numberOfChannels; + let configBits = ""; + configBits += objectType.toString(2).padStart(5, "0"); + configBits += frequencyIndex.toString(2).padStart(4, "0"); + if (frequencyIndex === 15) + configBits += sampleRate.toString(2).padStart(24, "0"); + configBits += channelConfig.toString(2).padStart(4, "0"); + let paddingLength = Math.ceil(configBits.length / 8) * 8; + configBits = configBits.padEnd(paddingLength, "0"); + let configBytes = new Uint8Array(configBits.length / 8); + for (let i = 0; i < configBits.length; i += 8) { + configBytes[i / 8] = parseInt(configBits.slice(i, i + 8), 2); + } + return configBytes; + }; + _createSampleForTrack = new WeakSet(); + createSampleForTrack_fn = function(track, data, type, timestamp, duration, meta, compositionTimeOffset) { + let presentationTimestampInSeconds = timestamp / 1e6; + let decodeTimestampInSeconds = (timestamp - (compositionTimeOffset ?? 0)) / 1e6; + let durationInSeconds = duration / 1e6; + let adjusted = __privateMethod(this, _validateTimestamp, validateTimestamp_fn).call(this, presentationTimestampInSeconds, decodeTimestampInSeconds, track); + presentationTimestampInSeconds = adjusted.presentationTimestamp; + decodeTimestampInSeconds = adjusted.decodeTimestamp; + if (meta?.decoderConfig) { + if (track.info.decoderConfig === null) { + track.info.decoderConfig = meta.decoderConfig; + } else { + Object.assign(track.info.decoderConfig, meta.decoderConfig); + } + } + let sample = { + presentationTimestamp: presentationTimestampInSeconds, + decodeTimestamp: decodeTimestampInSeconds, + duration: durationInSeconds, + data, + size: data.byteLength, + type, + // Will be refined once the next sample comes in + timescaleUnitsToNextSample: intoTimescale(durationInSeconds, track.timescale) + }; + return sample; + }; + _addSampleToTrack = new WeakSet(); + addSampleToTrack_fn = function(track, sample) { + if (__privateGet(this, _options).fastStart !== "fragmented") { + track.samples.push(sample); + } + const sampleCompositionTimeOffset = intoTimescale(sample.presentationTimestamp - sample.decodeTimestamp, track.timescale); + if (track.lastTimescaleUnits !== null) { + let timescaleUnits = intoTimescale(sample.decodeTimestamp, track.timescale, false); + let delta = Math.round(timescaleUnits - track.lastTimescaleUnits); + track.lastTimescaleUnits += delta; + track.lastSample.timescaleUnitsToNextSample = delta; + if (__privateGet(this, _options).fastStart !== "fragmented") { + let lastTableEntry = last(track.timeToSampleTable); + if (lastTableEntry.sampleCount === 1) { + lastTableEntry.sampleDelta = delta; + lastTableEntry.sampleCount++; + } else if (lastTableEntry.sampleDelta === delta) { + lastTableEntry.sampleCount++; + } else { + lastTableEntry.sampleCount--; + track.timeToSampleTable.push({ + sampleCount: 2, + sampleDelta: delta + }); + } + const lastCompositionTimeOffsetTableEntry = last(track.compositionTimeOffsetTable); + if (lastCompositionTimeOffsetTableEntry.sampleCompositionTimeOffset === sampleCompositionTimeOffset) { + lastCompositionTimeOffsetTableEntry.sampleCount++; + } else { + track.compositionTimeOffsetTable.push({ + sampleCount: 1, + sampleCompositionTimeOffset + }); + } + } + } else { + track.lastTimescaleUnits = 0; + if (__privateGet(this, _options).fastStart !== "fragmented") { + track.timeToSampleTable.push({ + sampleCount: 1, + sampleDelta: intoTimescale(sample.duration, track.timescale) + }); + track.compositionTimeOffsetTable.push({ + sampleCount: 1, + sampleCompositionTimeOffset + }); + } + } + track.lastSample = sample; + let beginNewChunk = false; + if (!track.currentChunk) { + beginNewChunk = true; + } else { + let currentChunkDuration = sample.presentationTimestamp - track.currentChunk.startTimestamp; + if (__privateGet(this, _options).fastStart === "fragmented") { + let mostImportantTrack = __privateGet(this, _videoTrack) ?? __privateGet(this, _audioTrack); + if (track === mostImportantTrack && sample.type === "key" && currentChunkDuration >= 1) { + beginNewChunk = true; + __privateMethod(this, _finalizeFragment, finalizeFragment_fn).call(this); + } + } else { + beginNewChunk = currentChunkDuration >= 0.5; + } + } + if (beginNewChunk) { + if (track.currentChunk) { + __privateMethod(this, _finalizeCurrentChunk, finalizeCurrentChunk_fn).call(this, track); + } + track.currentChunk = { + startTimestamp: sample.presentationTimestamp, + samples: [] + }; + } + track.currentChunk.samples.push(sample); + }; + _validateTimestamp = new WeakSet(); + validateTimestamp_fn = function(presentationTimestamp, decodeTimestamp, track) { + const strictTimestampBehavior = __privateGet(this, _options).firstTimestampBehavior === "strict"; + const noLastDecodeTimestamp = track.lastDecodeTimestamp === -1; + const timestampNonZero = decodeTimestamp !== 0; + if (strictTimestampBehavior && noLastDecodeTimestamp && timestampNonZero) { + throw new Error( + `The first chunk for your media track must have a timestamp of 0 (received DTS=${decodeTimestamp}).Non-zero first timestamps are often caused by directly piping frames or audio data from a MediaStreamTrack into the encoder. Their timestamps are typically relative to the age of thedocument, which is probably what you want. + +If you want to offset all timestamps of a track such that the first one is zero, set firstTimestampBehavior: 'offset' in the options. +` + ); + } else if (__privateGet(this, _options).firstTimestampBehavior === "offset" || __privateGet(this, _options).firstTimestampBehavior === "cross-track-offset") { + if (track.firstDecodeTimestamp === void 0) { + track.firstDecodeTimestamp = decodeTimestamp; + } + let baseDecodeTimestamp; + if (__privateGet(this, _options).firstTimestampBehavior === "offset") { + baseDecodeTimestamp = track.firstDecodeTimestamp; + } else { + baseDecodeTimestamp = Math.min( + __privateGet(this, _videoTrack)?.firstDecodeTimestamp ?? Infinity, + __privateGet(this, _audioTrack)?.firstDecodeTimestamp ?? Infinity + ); + } + decodeTimestamp -= baseDecodeTimestamp; + presentationTimestamp -= baseDecodeTimestamp; + } + if (decodeTimestamp < track.lastDecodeTimestamp) { + throw new Error( + `Timestamps must be monotonically increasing (DTS went from ${track.lastDecodeTimestamp * 1e6} to ${decodeTimestamp * 1e6}).` + ); + } + track.lastDecodeTimestamp = decodeTimestamp; + return { presentationTimestamp, decodeTimestamp }; + }; + _finalizeCurrentChunk = new WeakSet(); + finalizeCurrentChunk_fn = function(track) { + if (__privateGet(this, _options).fastStart === "fragmented") { + throw new Error("Can't finalize individual chunks if 'fastStart' is set to 'fragmented'."); + } + if (!track.currentChunk) + return; + track.finalizedChunks.push(track.currentChunk); + __privateGet(this, _finalizedChunks).push(track.currentChunk); + if (track.compactlyCodedChunkTable.length === 0 || last(track.compactlyCodedChunkTable).samplesPerChunk !== track.currentChunk.samples.length) { + track.compactlyCodedChunkTable.push({ + firstChunk: track.finalizedChunks.length, + // 1-indexed + samplesPerChunk: track.currentChunk.samples.length + }); + } + if (__privateGet(this, _options).fastStart === "in-memory") { + track.currentChunk.offset = 0; + return; + } + track.currentChunk.offset = __privateGet(this, _writer).pos; + for (let sample of track.currentChunk.samples) { + __privateGet(this, _writer).write(sample.data); + sample.data = null; + } + __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this); + }; + _finalizeFragment = new WeakSet(); + finalizeFragment_fn = function(flushStreamingWriter = true) { + if (__privateGet(this, _options).fastStart !== "fragmented") { + throw new Error("Can't finalize a fragment unless 'fastStart' is set to 'fragmented'."); + } + let tracks = [__privateGet(this, _videoTrack), __privateGet(this, _audioTrack)].filter((track) => track && track.currentChunk); + if (tracks.length === 0) + return; + let fragmentNumber = __privateWrapper(this, _nextFragmentNumber)._++; + if (fragmentNumber === 1) { + let movieBox = moov(tracks, __privateGet(this, _creationTime), true); + __privateGet(this, _writer).writeBox(movieBox); + } + let moofOffset = __privateGet(this, _writer).pos; + let moofBox = moof(fragmentNumber, tracks); + __privateGet(this, _writer).writeBox(moofBox); + { + let mdatBox = mdat(false); + let totalTrackSampleSize = 0; + for (let track of tracks) { + for (let sample of track.currentChunk.samples) { + totalTrackSampleSize += sample.size; + } + } + let mdatSize = __privateGet(this, _writer).measureBox(mdatBox) + totalTrackSampleSize; + if (mdatSize >= 2 ** 32) { + mdatBox.largeSize = true; + mdatSize = __privateGet(this, _writer).measureBox(mdatBox) + totalTrackSampleSize; + } + mdatBox.size = mdatSize; + __privateGet(this, _writer).writeBox(mdatBox); + } + for (let track of tracks) { + track.currentChunk.offset = __privateGet(this, _writer).pos; + track.currentChunk.moofOffset = moofOffset; + for (let sample of track.currentChunk.samples) { + __privateGet(this, _writer).write(sample.data); + sample.data = null; + } + } + let endPos = __privateGet(this, _writer).pos; + __privateGet(this, _writer).seek(__privateGet(this, _writer).offsets.get(moofBox)); + let newMoofBox = moof(fragmentNumber, tracks); + __privateGet(this, _writer).writeBox(newMoofBox); + __privateGet(this, _writer).seek(endPos); + for (let track of tracks) { + track.finalizedChunks.push(track.currentChunk); + __privateGet(this, _finalizedChunks).push(track.currentChunk); + track.currentChunk = null; + } + if (flushStreamingWriter) { + __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this); + } + }; + _maybeFlushStreamingTargetWriter = new WeakSet(); + maybeFlushStreamingTargetWriter_fn = function() { + if (__privateGet(this, _writer) instanceof StreamTargetWriter) { + __privateGet(this, _writer).flush(); + } + }; + _ensureNotFinalized = new WeakSet(); + ensureNotFinalized_fn = function() { + if (__privateGet(this, _finalized)) { + throw new Error("Cannot add new video or audio chunks after the file has been finalized."); + } + }; + return __toCommonJS(src_exports); +})(); +if (typeof module === "object" && typeof module.exports === "object") Object.assign(module.exports, Mp4Muxer)