श्रृंखला के अनुवादित भागों की सूची:

1. खाना पकाने
2. Emscripten के साथ संकलन
3. कन्वर्ट AVI करने के लिए mp4 (आप यहाँ हैं)

इस भाग में, हम विश्लेषण करेंगे:

1. अनुकूलित तर्कों के साथ FFmpeg लाइब्रेरी का संकलन।
2. Emscripten फ़ाइल सिस्टम प्रबंधन।
3. Ffmpeg.js v0.1.0 और वीडियो रूपांतरण का विकास।

अनुकूलित तर्कों के साथ FFmpeg लाइब्रेरी को संकलित करना

हालाँकि इस भाग का अंतिम लक्ष्य mp4 को avi में परिवर्तित करने के लिए ffmpeg.js v0.1.0 बनाना है, पिछले भाग में हमने FFmpeg का केवल "नंगे" संस्करण बनाया है, जो कई मापदंडों के साथ अनुकूलित करना अच्छा होगा।

1. -ओज़ : कोड को ऑप्टिमाइज़ करें और उसका आकार कम करें (30 से 15 एमबी तक)
2. -o जावास्क्रिप्ट / ffmpeg-core.js : जावास्क्रिप्ट निर्देशिका के लिए js और wasm फ़ाइलों को सहेजें। (जहां से हम ffmpeg-core.js को ffmpeg.js रैपर लाइब्रेरी से कॉल करेंगे, जो एक अच्छा एपीआई प्रदान करता है)
3. -s MODULARIZE = 1 : कमांड लाइन उपयोगिता के बजाय एक पुस्तकालय बनाएं (आपको स्रोतों को संशोधित करने की आवश्यकता होगी, नीचे विवरण)
4. -s EXPORTED_FUNCTIONS = "[_ ffmpeg]" : ffmpeg C फ़ंक्शन को जावास्क्रिप्ट दुनिया में निर्यात करें
5. -s EXTRA_EXPORTED_RUNTIME_METHODS = "[cwrap, FS, getValue, setValue]" : फाइल सिस्टम और बिंदुओं के साथ काम करने के लिए अतिरिक्त कार्य, विवरण कोड के साथ बातचीत करते हुए लेख में पाया जा सकता है।
6. -s ALLOW_MEMORY_GROWTH = 1 : भस्म मेमोरी पर सीमा हटा दें
7. -थोड़ा : हटा दिया क्योंकि हम अपने खुद के कार्यकर्ता बनाने की योजना है। (यह प्रकाशनों के चौथे भाग के लिए एक बैकलॉग है)

प्रत्येक तर्कों के बारे में अधिक विवरण src / settings.js में github रिपॉजिटरी एम्सस्क्रिप्टेन में पाया जा सकता है।

जब -s MODULARIZE = 1 को जोड़ते समय , हमें मॉड्युलरिटी की आवश्यकताओं को पूरा करने के लिए सोर्स कोड को संशोधित करना होगा (वास्तव में, मुख्य () फ़ंक्शन से छुटकारा पाने के लिए)। आपको केवल तीन पंक्तियों को बदलना होगा।

1. fftools / ffmpeg.c : नाम बदलकर ffmpeg

- int main(int argc, char **argv) + int ffmpeg(int argc, char **argv) 

2. fftools / ffmpeg.h : फ़ंक्शन को निर्यात करने के लिए फ़ाइल के अंत में ffmpeg जोड़ें

 + int ffmpeg(int argc, char** argv); #endif /* FFTOOLS_FFMPEG_H */ 

3. fftools / cmdutils.c : बाहर निकलें ( रिट ) टिप्पणी करें ताकि हमारी लाइब्रेरी हमारे लिए रनटाइम से बाहर न निकले (हम बाद में इस बिंदु में सुधार करेंगे)।

 void exit_program(int ret){ if (program_exit) program_exit(ret); - exit(ret); + // exit(ret); } 

संकलन स्क्रिप्ट का हमारा नया संस्करण:

 emcc \ -Llibavcodec -Llibavdevice -Llibavfilter -Llibavformat -Llibavresample -Llibavutil -Llibpostproc -Llibswscale -Llibswresample \ -Qunused-arguments -Oz \ -o javascript/ffmpeg-core.js fftools/ffmpeg_opt.o fftools/ffmpeg_filter.o fftools/ffmpeg_hw.o fftools/cmdutils.o fftools/ffmpeg.o \ -lavdevice -lavfilter -lavformat -lavcodec -lswresample -lswscale -lavutil -lm \ -s MODULARIZE=1 \ -s EXPORTED_FUNCTIONS="[_ffmpeg]" \ -s EXTRA_EXPORTED_RUNTIME_METHODS="[cwrap, FS, getValue, setValue]" \ -s TOTAL_MEMORY=33554432 \ -s ALLOW_MEMORY_GROWTH=1 

ffmpeg-core.js तैयार है!

यदि आपके पास ffmpeg का अनुभव है, तो आप पहले से ही जानते हैं कि एक सामान्य कमांड कैसा दिखता है:

 $ ffmpeg -i input.avi output.mp4 

और चूंकि हम मुख्य के बजाय ffmpeg फ़ंक्शन का उपयोग करते हैं, कमांड कॉल इस तरह दिखाई देगी:

 const args = ['./ffmpeg', '-i', 'input.avi', 'output.mp4']; ffmpeg(args.length, args); 

बेशक, सब कुछ इतना सरल नहीं है, हमें जावास्क्रिप्ट और सी की दुनिया के बीच एक पुल बनाने की आवश्यकता होगी, तो आइए आइम्स्क्रिप्टेन फ़ाइल सिस्टम के साथ शुरू करें।

Emscripten फ़ाइल सिस्टम प्रबंधन

Emscripten में C से पढ़ने / लिखने का समर्थन करने के लिए एक वर्चुअल फ़ाइल सिस्टम है, जो वीडियो फ़ाइलों के लिए काम करने के लिए ffmpeg-core.js का उपयोग करता है।

फाइल सिस्टम एपीआई में इसके बारे में और पढ़ें।

सब कुछ काम करने के लिए, हम एफएस एपीआई को एम्सस्क्रिप्ट से निर्यात करते हैं, जो उपरोक्त पैरामीटर के कारण है:

 -s EXTRA_EXPORTED_RUNTIME_METHODS="[cwrap, FS, getValue, setValue]" 

फ़ाइल को सहेजने के लिए, आपको Node.js के वातावरण में Uint8Array प्रारूप में सरणी तैयार करने की आवश्यकता है, जिसे कुछ इस तरह किया जा सकता है:

 const fs = require('fs'); const data = new Uint8Array(fs.readFileSync('./input.avi')); 

और FS.writeFile () का उपयोग करके इसे emscripten फ़ाइल सिस्टम में सहेजें:

 require('./ffmpeg-core.js)() .then(Module => { Module.FS.writeFile('input.avi', data); }); 

और फ़ाइल को ईमस्क्रिप्ट से डाउनलोड करने के लिए:

 require('./ffmpeg-core.js)() .then(Module => { const data = Module.FS.readFile('output.mp4'); }); 

आइए एक सुंदर एपीआई के पीछे इन जटिलताओं को छिपाने के लिए ffmpeg.js विकसित करना शुरू करें।

विकास ffmpeg.js v0.1.0 और वीडियो रूपांतरण

Ffmpeg.js का विकास तुच्छ नहीं है, क्योंकि आपको लगातार जावास्क्रिप्ट और सी की दुनिया के बीच स्विच करने की आवश्यकता है, लेकिन यदि आप संकेत से परिचित हैं, तो यह समझना बहुत आसान होगा कि यहां क्या हो रहा है।

हमारा काम इस तरह ffmpeg.js विकसित करना है:

 const fs = require('fs'); const ffmpeg = require('@ffmpeg/ffmpeg'); (async () => { await ffmpeg.load(); const data = ffmpeg.transcode('./input.avi', 'mp4'); fs.writeFileSync('./output.mp4', data); })(); 

सबसे पहले, ffmpeg-core.js डाउनलोड करें, जो परंपरागत रूप से अतुल्यकालिक रूप से किया जाता है ताकि मुख्य धागे को अवरुद्ध न करें।

यहाँ यह कैसा दिखता है:

 const { setModule } = require('./util/module'); const FFmpegCore = require('./ffmpeg-core'); module.exports = () => ( new Promise((resolve, reject) => { FFmpegCore() .then((Module) => { setModule(Module); resolve(); }); }) ); 

यह अजीब लग सकता है कि हम एक वादे को दूसरे में लपेटते हैं, ऐसा इसलिए है क्योंकि FFmpegCore () एक वास्तविक वादा नहीं है, लेकिन सिर्फ एक फ़ंक्शन है जो वादा एपीआई का अनुकरण करता है।

अगला कदम cwrap फ़ंक्शन का उपयोग करके ffmpeg फ़ंक्शन प्राप्त करने के लिए मॉड्यूल का उपयोग करना है:

 // int ffmpeg(int argc, char **argv) const ffmpeg = Module.cwrap('ffmpeg', 'number', ['number', 'number']); 

क्रैप करने के लिए पहला तर्क फ़ंक्शन का नाम है (जो पिछले अंडरस्कोर के साथ EXPORTED_FUNCTIONS में होना चाहिए), दूसरा रिटर्न मान का प्रकार है, तीसरा फ़ंक्शन के तर्क का प्रकार है (int argc और char ** argv)।

यह स्पष्ट है कि argc एक संख्या क्यों है, लेकिन argv एक संख्या भी क्यों है? argv एक पॉइंटर है, और पॉइंटर मेमोरी (टाइप 0xfffffff) में एड्रेस को स्टोर करता है, इसलिए पॉइंटर टाइप WebAssembly में 32 बिट अहस्ताक्षरित है। यही कारण है कि हम संख्या को argv प्रकार के रूप में निर्दिष्ट करते हैं।

Ffmpeg () को कॉल करने के लिए, पहला तर्क जावास्क्रिप्ट में एक नियमित संख्या होगी, लेकिन दूसरा तर्क वर्णों की एक सरणी (जावास्क्रिप्ट में Uint8) का सूचक होना चाहिए।

हम इस कार्य को 2 उप-प्रकारों में विभाजित करते हैं:

1. पात्रों की एक सरणी के लिए एक पॉइंटर कैसे बनाएं?
2. पॉइंटर्स की एक सरणी के लिए एक पॉइंटर कैसे बनाएं?

हम str2ptr उपयोगिता बनाकर पहली समस्या को हल करेंगे:

 const { getModule } = require('./module'); module.exports = (s) => { const Module = getModule(); const ptr = Module._malloc((s.length+1)*Uint8Array.BYTES_PER_ELEMENT); for (let i = 0; i < s.length; i++) { Module.setValue(ptr+i, s.charCodeAt(i), 'i8'); } Module.setValue(ptr+s.length, 0, 'i8'); return ptr; }; 

मॉड्यूल._मल्लोक () सी में मॉलोक () के समान है, यह ढेर पर स्मृति का एक हिस्सा आवंटित करता है। Module.setValue () सूचक द्वारा विशिष्ट मान सेट करता है।

अप्रत्याशित स्थितियों से बचने के लिए वर्ण सरणी के अंत में 0 जोड़ना याद रखें।

पहले सबटैक से निपटा, दूसरे को हल करने के लिए strList2ptr बनाएं:

 const { getModule } = require('./module'); const str2ptr = require('./str2ptr'); module.exports = (strList) => { const Module = getModule(); const listPtr = Module._malloc(strList.length*Uint32Array.BYTES_PER_ELEMENT); strList.forEach((s, idx) => { const strPtr = str2ptr(s); Module.setValue(listPtr + (4*idx), strPtr, 'i32'); }); return listPtr; }; 

यहां समझने वाली मुख्य बात यह है कि सूचक जावास्क्रिप्ट के अंदर एक यूइंट 32 मूल्य है, इसलिए सूचीप्रोट एक यूइंट 32 सरणी के लिए एक संकेतक है जो एक यूइंट 8 सरणी के लिए संकेत संग्रहीत करता है।

यह सब एक साथ रखने से हमें ffmepg.transcode () का निम्नलिखित कार्यान्वयन मिलता है:

 const fs = require('fs'); const { getModule } = require('./util/module'); const strList2ptr = require('./util/strList2ptr'); module.exports = (inputPath, outputExt) => { const Module = getModule(); const data = new Uint8Array(fs.readFileSync(inputPath)); const ffmpeg = Module.cwrap('ffmpeg', 'number', ['number', 'number']); const args = ['./ffmpeg', '-i', 'input.avi', `output.${outputExt}`]; Module.FS.writeFile('input.avi', data); ffmpeg(args.length, strList2ptr(args)); return Buffer.from(Module.FS.readFile(`output.${outputExt}`)); }; 

हो गया! अब हमारे पास fimpeg.js v0.1.0 है जो AVI को mp4 में परिवर्तित करने के लिए है।

आप लाइब्रेरी स्थापित करके परिणाम का स्वयं परीक्षण कर सकते हैं:

 $ npm install @ffmpeg/ffmpeg@0.1.0 

और फ़ाइल को इस तरह परिवर्तित करना:

 const fs = require('fs'); const ffmpeg = require('@ffmpeg/ffmpeg'); (async () => { await ffmpeg.load(); const data = ffmpeg.transcode('./input.avi', 'mp4'); fs.writeFileSync('./output.mp4', data); })(); 

बस ध्यान रखें कि अभी तक लाइब्रेरी केवल Node.js के लिए काम करती है, लेकिन अगले भाग में हम वेब-वर्कर (और Node.js में child_process) के लिए समर्थन जोड़ देंगे।

स्रोत कोड:

• ffmpeg-core.js
• ffmpeg.js