mcarman
/
Wappler_Access
1
0
Креирај огранак 0
Код Дискусије 1 Захтеви за спајање 0 Издања 0 Вики Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
33 Комити
1 Грана
10 MiB
 
 
 
Дрво: 14fcc36eef
Гране Ознаке
${ item.name }
Create branch ${ searchTerm }
from '14fcc36eef'
${ noResults }
Wappler_Access/lib/modules/metadata.js

484 lines
16 KiB
Датотека Blame Историја 

  1. const fs = require('fs-extra');

  2. 

  3. const imageTypes = ['PNG', 'GIF', 'BMP', 'JPEG', 'TIFF'];

  4. const videoTypes = ['AVI', 'MP4', 'MOV', 'MKV', 'WEBM', 'OGV'];

  5. const soundTypes = ['OGG', 'WAV', 'MP3', 'FLAC'];

  6. 

  7. const read = async (path, offset, length) => {

  8.     const fp = await fs.open(path);

  9.     const buff = Buffer.alloc(length);

  10.     

  11.     await fs.read(fd, buff, 0, length, offset);

  12.     await fs.close();

  13. 

  14.     return buff;

  15. };

  16. 

  17. 

  18. const parser = {

  19. 

  20.     PNG: async (path, result) => {

  21.         const buff = await read(path, 18, 6);

  22.         result.width = buff.readUInt16BE(0);

  23.         result.height = buff.readUInt16BE(4);

  24.     },

  25. 

  26.     GIF: async (path, result) => {

  27.         const buff = await read(path, 6, 4);

  28.         result.width = buff.readUInt16LE(0);

  29.         result.height = buff.readUInt16LE(2);

  30.     },

  31. 

  32.     BMP: async (path, result) => {

  33.         const buff = await read(path, 18, 8);

  34.         result.width = buff.readUInt32LE(0);

  35.         result.height = buff.readUInt32LE(4);

  36.     },

  37. 

  38.     JPEG: async (path, result) => {

  39.         const sof = [0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xde];

  40.         const buff = await read(path, 2, 64000);

  41.         

  42.         let pos = 0;

  43. 

  44.         while (buff[pos++] == 0xff) {

  45.             let marker = buff[pos++];

  46.             let size = buff.readUInt16BE(pos);

  47. 

  48.             if (marker == 0xda) break;

  49. 

  50.             if (sof.includes(marker)) {

  51.                 result.height = buff.readUInt16BE(pos + 3);

  52.                 result.width = buff.readUInt16BE(pos + 5);

  53.                 break;

  54.             }

  55. 

  56.             pos += size;

  57.         }

  58.     },

  59. 

  60.     TIFF: async (path, result) => {

  61.         const buff = await read(path, 0, 64000);

  62.         const le = buff.toString('ascii', 0, 2) == 'II';

  63.         let pos = 0;

  64.         const readUInt16 = () => { pos += 2; return buff[le ? 'readUInt16LE' : 'readUInt16BE'](pos - 2); }

  65.         const readUInt32 = () => { pos += 4; return buff[le ? 'readUInt32LE' : 'readUInt32BE'](pos - 4); }

  66. 

  67.         let offset = readUInt32();

  68.         

  69.         while (pos < buff.length && offset > 0) {

  70.             let entries = readUInt16(offset);

  71.             let start = pos;

  72. 

  73.             for (let i = 0; i < entries; i++) {

  74.                 let tag = readUInt16();

  75.                 let type = readUInt16();

  76.                 let length = readUInt32();

  77.                 let data = (type == 3) ? readUInt16() : readUInt32();

  78.                 if (type == 3) pos += 2;

  79. 

  80.                 if (tag == 256) {

  81.                     result.width = data;

  82.                 } else if (tag == 257) {

  83.                     result.height = data;

  84.                 }

  85. 

  86.                 if (result.width > 0 && result.height > 0) {

  87.                     return;

  88.                 }

  89.             }

  90. 

  91.             offset = readUInt32();

  92.             pos += offset;

  93.         }

  94.     },

  95. 

  96.     AVI: async (path, result) => {

  97.         const buff = await read(path, 0, 144);

  98.         result.width = buff.readUInt32LE(64);

  99.         result.height = buff.readUInt32LE(68);

  100.         result.duration = ~~(buff.readUInt32LE(128) / buff.readUInt32LE(132) * buff.readUInt32LE(140));

  101.     },

  102. 

  103.     MP4: async (path, result) => {

  104.         return parser.MOV(path, result);

  105.     },

  106. 

  107.     MOV: async (path, result, pos = 0) => {

  108.         const buff = await read(path, 0, 64000);

  109. 

  110.         while (pos < buff.length) {

  111.             let size = buff.readUInt32BE(pos);

  112.             let name = buff.toString('ascii', pos + 4, 4);

  113. 

  114.             if (name == 'mvhd') {

  115.                 let scale = buff.readUInt32BE(pos + 20);

  116.                 let duration = buff.readUInt32BE(pos + 24);

  117.                 result.duration = ~~(duration / scale);

  118.             }

  119. 

  120.             if (name == 'tkhd') {

  121.                 let m0 = buff.readUInt32BE(pos + 48);

  122.                 let m4 = buff.readUInt32BE(pos + 64);

  123.                 let w = buff.readUInt32BE(pos + 84);

  124.                 let h = buff.readUInt32BE(pos + 88);

  125.                 if (w > 0 && h > 0) {

  126.                     result.width = w / m0;

  127.                     result.height = h / m4;

  128.                     return;

  129.                 }

  130.             }

  131. 

  132.             if (name == 'moov' || name == 'trak') {

  133.                 await parser.MOV(path, pos + 8);

  134.             }

  135. 

  136.             pos += size;

  137.         }

  138.     },

  139. 

  140.     WEBM: async (path, result) => {

  141.         return parser.EBML(path, result);

  142.     },

  143. 

  144.     MKV: async (path, result) => {

  145.         return parser.EBML(path, result);

  146.     },

  147. 

  148.     EBML: async (path, result) => {

  149.         const containers = ['\x1a\x45\xdf\xa3', '\x18\x53\x80\x67', '\x15\x49\xa9\x66', '\x16\x54\xae\x6b', '\xae', '\xe0'];

  150.         const buff = await read(path, 0, 64000);

  151. 

  152.         // TODO parse EBML

  153.     },

  154. 

  155.     OGV: async (path, result) => {

  156.         return parser.OGG(path, result);

  157.     },

  158. 

  159.     OGG: async (path, result) => {

  160.         const buff = await read(apth, 0, 64000);

  161.         let pos = 0, vorbis;

  162. 

  163.         while (buff.toString('ascii', pos, pos + 4) == 'OggS') {

  164.             let version = buff[pos + 4];

  165.             let b = buff[pos + 5];

  166.             let continuation = !!(b & 0x01);

  167.             let bos = !!(b & 0x02);

  168.             let eos = !!(b & 0x04);

  169.             let position = Number(buff.readBigUInt64LE(pos + 6));

  170.             let serial = buff.readUInt32LE(pos + 14);

  171.             let pageNumber = buff.readUInt32LE(pos + 18);

  172.             let checksum = buff.readUInt32LE(pos + 22);

  173.             let pageSegments = buff[path + 26];

  174.             let lacing = buff.slice(pos + 27, pos + 27 + pageSegments);

  175.             let pageSize = lacing.reduce((p, v) => p + v, 0);

  176.             let start = pos + 27 + pageSegments;

  177.             let pageHeader = buff.slice(start, start + 7);

  178. 

  179.             if (pageHeader.compare(Buffer.from([0x01, 'v', 'o', 'r', 'b', 'i', 's']))) {

  180.                 vorbis = { serial, sampleRate: buff.readUInt32LE(start + 12) };

  181.             }

  182. 

  183.             if (pageHeader.compare(Buffer.from([0x80, 't', 'h', 'e', 'o', 'r', 'a']))) {

  184.                 let version = buff.slice(start + 7, start + 10);

  185.                 result.width = buff.readUInt16BE(start + 10) << 4;

  186.                 result.height = buff.readUInt16BE(start + 12) << 4;

  187. 

  188.                 if (version >= 0x030200) {

  189.                     let width = buff.slice(start + 14, start + 17);

  190.                     let height = buff.slice(start + 17, start + 20);

  191. 

  192.                     if (width <= result.width && width > result.width - 16 && height <= result.height && height > result.height - 16) {

  193.                         result.width = width;

  194.                         result.height = height;

  195.                     }

  196.                 }

  197.             }

  198. 

  199.             if (eos && vorbis && serail == vorbis.serial) {

  200.                 result.duration = ~~(position / vorbis.sampleRate);

  201.             }

  202. 

  203.             pos = start + pageSize;

  204.         }

  205.     },

  206. 

  207.     WAV: async (path, result) => {

  208.         const buff = await read(path, 0, 32);

  209.         let size = buff.readUInt32LE(4);

  210.         let rate = buff.readUInt32LE(28);

  211.         result.duration = ~~(size / rate);

  212.     },

  213. 

  214.     MP3: async (path, result) => {

  215.         const versions = [2.5, 0, 2, 1];

  216.         const layers = [0, 3, 2, 1];

  217.         const bitrates = [

  218.             [ // version 2.5

  219.                 [0, 0, 0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0], // reserved

  220.                 [0, 8,16,24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160], // layer 3

  221.                 [0, 8,16,24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160], // layer 2

  222.                 [0,32,48,56, 64, 80, 96,112,128,144,160,176,192,224,256]  // layer 1

  223.             ],

  224.             [ // reserved

  225.                 [0, 0, 0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0], // reserved

  226.                 [0, 0, 0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0], // reserved

  227.                 [0, 0, 0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0], // reserved

  228.                 [0, 0, 0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]  // reserved

  229.             ],

  230.             [ // version 2

  231.                 [0, 0, 0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0], // reserved

  232.                 [0, 8,16,24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160], // layer 3

  233.                 [0, 8,16,24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160], // layer 2

  234.                 [0,32,48,56, 64, 80, 96,112,128,144,160,176,192,224,256]  // layer 1

  235.             ],

  236.             [ // version 1

  237.                 [0, 0, 0, 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0], // reserved

  238.                 [0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320], // layer 3

  239.                 [0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384], // layer 2

  240.                 [0,32,64,96,128,160,192,224,256,288,320,352,384,416,448]  // layer 1

  241.             ]

  242.         ]

  243.         const srates = [

  244.             [11025, 12000,  8000, 0], // mpeg 2.5

  245.             [    0,     0,     0, 0], // reserved

  246.             [22050, 24000, 16000, 0], // mpeg 2

  247.             [44100, 48000, 32000, 0]  // mpeg 1

  248.         ]

  249.         const tsamples = [

  250.             [0,  576, 1152, 384], // mpeg 2.5

  251.             [0,    0,    0,   0], // reserved

  252.             [0,  576, 1152, 384], // mpeg 2

  253.             [0, 1152, 1152, 384]  // mpeg 1

  254.         ];

  255.         const slotSizes = [0, 1, 1, 4];

  256.         const modes = ['stereo', 'joint_stereo', 'dual_channel', 'mono'];

  257.         const buff = await read(path, 0, 64000);

  258. 

  259.         let duration = 0;

  260.         let count = 0;

  261.         let skip = 0;

  262.         let pos = 0;

  263. 

  264.         while (pos < buff.length) {

  265.             let start = pos;

  266. 

  267.             if (buff.toString('ascii', pos, 4) == 'TAG+') {

  268.                 skip += 227;

  269.                 pos += 227;

  270.             } else if (buff.toString('ascii', pos, 3) == 'TAG') {

  271.                 skip += 128;

  272.                 pos += 128;

  273.             } else if (buff.toString('ascii', pos, 3) == 'ID3') {

  274.                 let bytes = buff.readUInt32BE(pos + 6);

  275.                 let size = 10 + (bytes[0] << 21 | bytes[1] << 14 | bytes[2] << 7 | bytes[3]);

  276.                 skip += size;

  277.                 pos += size;

  278.             } else {

  279.                 let hdr = buff.slice(pos, pos + 4);

  280. 

  281.                 while (pos < buff.length && !(hdr[0] == 0xff && (hdr[1] & 0xe0) == 0xe0)) {

  282.                     pos++;

  283.                     hdr = buff.slice(pos, pos + 4);

  284.                 }

  285. 

  286.                 let ver = (hdr[1] & 0x18) >> 3;

  287.                 let lyr = (hdr[1] & 0x06) >> 1;

  288.                 let pad = (hdr[2] & 0x02) >> 1;

  289.                 let brx = (hdr[2] & 0xf0) >> 4;

  290.                 let srx = (hdr[2] & 0x0c) >> 2;

  291.                 let mdx = (hdr[3] & 0xc0) >> 6;

  292. 

  293.                 let version = versions[ver];

  294.                 let layer = layers[lyr];

  295.                 let bitrate = bitrates[ver][lyr][brx] * 1000;

  296.                 let samprate = srates[ver][srx];

  297.                 let samples = tsamples[ver][lyr];

  298.                 let slotSize = slotSizes[lyr];

  299.                 let mode = modes[mdx];

  300.                 let fsize = ~~(((samples / 8 * bitrate) / samprate) + (pad ? slotSize : 0));

  301. 

  302.                 count++;

  303. 

  304.                 if (count == 1) {

  305.                     if (layer != 3) {

  306.                         pos += 2;

  307.                     } else {

  308.                         if (mode != 'mono') {

  309.                             if (version == 1) {

  310.                                 pos += 32;

  311.                             } else {

  312.                                 pos += 17;

  313.                             }

  314.                         } else {

  315.                             if (version == 1) {

  316.                                 pos += 17;

  317.                             } else {

  318.                                 pos += 9;

  319.                             }

  320.                         }

  321.                     }

  322. 

  323.                     if (buff.toString('ascii', pos, pos + 4) == 'Xing' && (buff.readUInt32BE(pos + 4) & 0x0001) == 0x0001) {

  324.                         let totalFrames = buff.readUInt32BE(pos + 8);

  325.                         duration = totalFrames * samples / samprate;

  326.                         break;

  327.                     }

  328.                 }

  329. 

  330.                 if (fsize < 1) break;

  331. 

  332.                 pos = start + fsize;

  333. 

  334.                 duration += (samples / samprate);

  335.             }

  336.         }

  337.         

  338.         result.duration = ~~duration;

  339.     },

  340. 

  341.     FLAC: async (path, result) => {

  342.         const buff = await read(path, 18, 8);

  343.         let rate = (buff[0] << 12) | (buff[1] << 4) | ((buff[2] & 0xf0) >> 4);

  344.         let size = ((buff[3] & 0x0f) << 32) | (buff[4] << 24) | (buff[5] << 16) | (buff[6] << 8) | buff[7];

  345.         result.duration = ~~(size / rate);

  346.     },

  347. 

  348. };

  349. 

  350. async function detect(path) {

  351.     const buff = await read(path, 0, 12);

  352. 

  353.     if (buff.slice(0, 8).compare(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {

  354.         return 'PNG';

  355.     }

  356. 

  357.     if (buff.toString('ascii', 0, 3) == 'GIF') {

  358.         return 'GIF';

  359.     }

  360. 

  361.     if (buff.toString('ascii', 0, 2) == 'BM') {

  362.         return 'BMP';

  363.     }

  364. 

  365.     if (buff.slice(0, 2).compare(Buffer.from([0xff, 0xd8]))) {

  366.         return 'JPEG';

  367.     }

  368. 

  369.     if (buff.toString('ascii', 0, 2) == 'II' && buff.readUInt16LE(2) == 42) {

  370.         return 'TIFF';

  371.     }

  372. 

  373.     if (buff.toString('ascii', 0, 2) == 'MM' && buff.readUInt16BE(2) == 42) {

  374.         return 'TIFF';

  375.     }

  376. 

  377.     if (buff.toString('ascii', 0, 4) == 'RIFF' && buff.toString('ascii', 8, 4) == 'AVI ') {

  378.         return 'AVI';

  379.     }

  380. 

  381.     if (buff.toString('ascii', 4, 4) == 'ftyp') {

  382.         return 'MP4';

  383.     }

  384. 

  385.     if (buff.toString('ascii', 4, 4) == 'moov') {

  386.         return 'MOV';

  387.     }

  388. 

  389.     if (buff.slice(0, 4).compare(Buffer.from([0x1a, 0x45, 0xdf, 0xa3]))) {

  390.         // TODO detect MKV

  391. 

  392.         return 'EBML';

  393.     }

  394. 

  395.     if (buff.toString('ascii', 0, 4) == 'OggS') {

  396.         // TODO detect OGV

  397.         

  398.         return 'OGG'

  399.     }

  400. 

  401.     if (buff.toString('ascii', 0, 4) == 'RIFF', buff.toString('ascii', 8, 4) == 'WAVE') {

  402.         return 'WAV';

  403.     }

  404. 

  405.     if (buff.toString('ascii', 0, 3) == 'ID3' || (buf[0] == 0xff && (buff[1] & 0xe0))) {

  406.         return 'MP3';

  407.     }

  408. 

  409.     if (buff.toString('ascii', 0, 4) == 'fLaC') {

  410.         return 'FLAC';

  411.     }

  412. 

  413.     return null

  414. }

  415. 

  416. module.exports = {

  417. 

  418.     detect: async function(options) {

  419.         let path = this.parseRequired(options.path, 'string', 'metadata.detect: path is required.');

  420. 

  421.         return detect(path);

  422.     },

  423. 

  424.     isImage: async function(options) {

  425.         let path = this.parseRequired(options.path, 'string', 'metadata.isImage: path is required.');

  426.         let type = await detect(path);

  427.         let cond = imageTypes.includes(type);

  428.         

  429.         if (cond) {

  430.             if (options.then) {

  431.                 await this.exec(options.then, true);

  432.             }

  433.         } else if (options.else) {

  434.             await this.exec(options.else, true);

  435.         }

  436. 

  437.         return cond;

  438.     },

  439. 

  440.     isVideo: async function(options) {

  441.         let path = this.parseRequired(options.path, 'string', 'metadata.isVideo: path is required.');

  442.         let type = await detect(path);

  443.         let cond = videoTypes.includes(type);

  444.         

  445.         if (cond) {

  446.             if (options.then) {

  447.                 await this.exec(options.then, true);

  448.             }

  449.         } else if (options.else) {

  450.             await this.exec(options.else, true);

  451.         }

  452. 

  453.         return cond;

  454.     },

  455. 

  456.     isSound: async function(options) {

  457.         let path = this.parseRequired(options.path, 'string', 'metadata.isSound: path is required.');

  458.         let type = await detect(path);

  459.         let cond = soundTypes.includes(type);

  460.         

  461.         if (cond) {

  462.             if (options.then) {

  463.                 await this.exec(options.then, true);

  464.             }

  465.         } else if (options.else) {

  466.             await this.exec(options.else, true);

  467.         }

  468. 

  469.         return cond;

  470.     },

  471. 

  472.     fileinfo: async function(options) {

  473.         let path = this.parseRequired(options.path, 'string', 'metadata.fileinfo: path is required.');

  474.         let type = await detect(path);

  475.         let result = { type, width: null, height: null, duration: null };

  476. 

  477.         if (parser[type]) {

  478.             await parser[type](path, result);

  479.         }

  480. 

  481.         return result;

  482.     },

  483. 

  484. };