10325410889

Committed 09 Aug 2024 08:35PM UTC coverage: 97.081% (-0.1%) from 97.22%

Build # 10325410889

Build Type

Pull #2205

github

Committed by

Borewit

Commit Message

Enable TypeScript options `strict` & `verbatimModuleSyntax`

Pull Request Pull Request #2205: Enable TypeScript options `strict` & `verbatimModuleSyntax`

Run Details

1312 of 1483 branches covered (88.47%)

Branch coverage included in aggregate %.

236 of 242 new or added lines in 25 files covered. (97.52%)

6 existing lines in 3 files now uncovered.

11326 of 11535 relevant lines covered (98.19%)

16378.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.29

/lib/aiff/AiffParser.ts

import * as Token from 'token-types';
import initDebug from 'debug';
import * as strtok3 from 'strtok3';

import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
import { FourCcToken } from '../common/FourCC.js';
import { BasicParser } from '../common/BasicParser.js';

import * as AiffToken from './AiffToken.js';
import * as iff from '../iff/index.js';
import { type CompressionTypeCode, compressionTypes } from './AiffToken.js';

const debug = initDebug('music-metadata:parser:aiff');

/**
 * AIFF - Audio Interchange File Format
 *
 * Ref:
 * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/AIFF.html
 * - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/Docs/AIFF-1.3.pdf
 */
export class AIFFParser extends BasicParser {

  private isCompressed: boolean | null = null;

  public async parse(): Promise<void> {

    const header = await this.tokenizer.readToken<iff.IChunkHeader>(iff.Header);
    if (header.chunkID !== 'FORM')
      throw new Error('Invalid Chunk-ID, expected \'FORM\''); // Not AIFF format

    const type = await this.tokenizer.readToken<string>(FourCcToken);
    switch (type) {

      case 'AIFF':
        this.metadata.setFormat('container', type);
        this.isCompressed = false;
        break;

      case 'AIFC':
        this.metadata.setFormat('container', 'AIFF-C');
        this.isCompressed = true;
        break;

      default:
        throw new Error(`Unsupported AIFF type: ${type}`);
    }
    this.metadata.setFormat('lossless', !this.isCompressed);

    try {
      while (!this.tokenizer.fileInfo.size || this.tokenizer.fileInfo.size - this.tokenizer.position >= iff.Header.len) {
        debug(`Reading AIFF chunk at offset=${this.tokenizer.position}`);
        const chunkHeader = await this.tokenizer.readToken<iff.IChunkHeader>(iff.Header);

        const nextChunk = 2 * Math.round(chunkHeader.chunkSize / 2);
        const bytesRead = await this.readData(chunkHeader);
        await this.tokenizer.ignore(nextChunk - bytesRead);
      }
    } catch (err) {
      if (err instanceof strtok3.EndOfStreamError) {
        debug("End-of-stream");
      } else {
        throw err;
      }
    }
  }

  public async readData(header: iff.IChunkHeader): Promise<number> {
    switch (header.chunkID) {

      case 'COMM': { // The Common Chunk
        if (this.isCompressed === null) {
          throw new Error('Failed to parse AIFF.COMM chunk when compression type is unknown');
        }
        const common = await this.tokenizer.readToken<AiffToken.ICommon>(new AiffToken.Common(header, this.isCompressed));
        this.metadata.setFormat('bitsPerSample', common.sampleSize);
        this.metadata.setFormat('sampleRate', common.sampleRate);
        this.metadata.setFormat('numberOfChannels', common.numChannels);
        this.metadata.setFormat('numberOfSamples', common.numSampleFrames);
        this.metadata.setFormat('duration', common.numSampleFrames / common.sampleRate);
        if (common.compressionName || common.compressionType) {
          this.metadata.setFormat('codec', common.compressionName ?? compressionTypes[common.compressionType as CompressionTypeCode]);
        }
        return header.chunkSize;
      }

      case 'ID3 ': { // ID3-meta-data
        const id3_data = await this.tokenizer.readToken<Uint8Array>(new Token.Uint8ArrayType(header.chunkSize));
        const rst = strtok3.fromBuffer(id3_data);
        await new ID3v2Parser().parse(this.metadata, rst, this.options);
        return header.chunkSize;
      }

      case 'SSND': // Sound Data Chunk
        if (this.metadata.format.duration) {
          this.metadata.setFormat('bitrate', 8 * header.chunkSize / this.metadata.format.duration);
        }
        return 0;

      case 'NAME': // Sample name chunk
      case 'AUTH': // Author chunk
      case '(c) ': // Copyright chunk
      case 'ANNO': // Annotation chunk
        return this.readTextChunk(header);

      default:
        debug(`Ignore chunk id=${header.chunkID}, size=${header.chunkSize}`);
        return 0;
    }
  }

  public async readTextChunk(header: iff.IChunkHeader): Promise<number> {
    const value = await this.tokenizer.readToken(new Token.StringType(header.chunkSize, 'ascii'));
    const values = value.split('\0').map(v => v.trim()).filter(v => v?.length);
    await Promise.all(values.map(v => this.metadata.addTag('AIFF', header.chunkID, v)));
    return header.chunkSize;
  }

}

1	import * as Token from 'token-types';	4✔
2	import initDebug from 'debug';	4✔
3	import * as strtok3 from 'strtok3';	4✔
4		4✔
5	import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';	4✔
6	import { FourCcToken } from '../common/FourCC.js';	4✔
7	import { BasicParser } from '../common/BasicParser.js';	4✔
8		4✔
9	import * as AiffToken from './AiffToken.js';	4✔
10	import * as iff from '../iff/index.js';	4✔
11	import { type CompressionTypeCode, compressionTypes } from './AiffToken.js';	4✔
12		4✔
13	const debug = initDebug('music-metadata:parser:aiff');	4✔
14		4✔
15	/**	4✔
16	* AIFF - Audio Interchange File Format	4✔
17	*	4✔
18	* Ref:	4✔
19	* - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/AIFF.html	4✔
20	* - http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/AIFF/Docs/AIFF-1.3.pdf	4✔
21	*/	4✔
22	export class AIFFParser extends BasicParser {	140✔
23		140✔
24	private isCompressed: boolean \| null = null;	140✔
25		140✔
26	public async parse(): Promise<void> {	140✔
27		140✔
28	const header = await this.tokenizer.readToken<iff.IChunkHeader>(iff.Header);	140✔
29	if (header.chunkID !== 'FORM')	140✔
30	throw new Error('Invalid Chunk-ID, expected \'FORM\''); // Not AIFF format	140!
31		140✔
32	const type = await this.tokenizer.readToken<string>(FourCcToken);	140✔
33	switch (type) {	140✔
34		140✔
35	case 'AIFF':	140✔
36	this.metadata.setFormat('container', type);	34✔
37	this.isCompressed = false;	34✔
38	break;	34✔
39		140✔
40	case 'AIFC':	140✔
41	this.metadata.setFormat('container', 'AIFF-C');	106✔
42	this.isCompressed = true;	106✔
43	break;	106✔
44		140✔
45	default:	140!
46	throw new Error(`Unsupported AIFF type: ${type}`);	×
47	}	140✔
48	this.metadata.setFormat('lossless', !this.isCompressed);	140✔
49		140✔
50	try {	140✔
51	while (!this.tokenizer.fileInfo.size \|\| this.tokenizer.fileInfo.size - this.tokenizer.position >= iff.Header.len) {	140✔
52	debug(`Reading AIFF chunk at offset=${this.tokenizer.position}`);	468✔
53	const chunkHeader = await this.tokenizer.readToken<iff.IChunkHeader>(iff.Header);	468✔
54		468✔
55	const nextChunk = 2 * Math.round(chunkHeader.chunkSize / 2);	468✔
56	const bytesRead = await this.readData(chunkHeader);	468✔
57	await this.tokenizer.ignore(nextChunk - bytesRead);	468✔
58	}	456✔
59	} catch (err) {	140✔
60	if (err instanceof strtok3.EndOfStreamError) {	12✔
61	debug("End-of-stream");	12✔
62	} else {	12!
63	throw err;	×
64	}	×
65	}	12✔
66	}	140✔
67		140✔
68	public async readData(header: iff.IChunkHeader): Promise<number> {	140✔
69	switch (header.chunkID) {	468✔
70		468✔
71	case 'COMM': { // The Common Chunk	468✔
72	if (this.isCompressed === null) {	140!
NEW 73	throw new Error('Failed to parse AIFF.COMM chunk when compression type is unknown');	×
NEW 74	}	×
75	const common = await this.tokenizer.readToken<AiffToken.ICommon>(new AiffToken.Common(header, this.isCompressed));	140✔
76	this.metadata.setFormat('bitsPerSample', common.sampleSize);	140✔
77	this.metadata.setFormat('sampleRate', common.sampleRate);	140✔
78	this.metadata.setFormat('numberOfChannels', common.numChannels);	140✔
79	this.metadata.setFormat('numberOfSamples', common.numSampleFrames);	140✔
80	this.metadata.setFormat('duration', common.numSampleFrames / common.sampleRate);	140✔
81	if (common.compressionName \|\| common.compressionType) {	140✔
82	this.metadata.setFormat('codec', common.compressionName ?? compressionTypes[common.compressionType as CompressionTypeCode]);	140✔
83	}	140✔
84	return header.chunkSize;	140✔
85	}	140✔
86		468✔
87	case 'ID3 ': { // ID3-meta-data	468✔
88	const id3_data = await this.tokenizer.readToken<Uint8Array>(new Token.Uint8ArrayType(header.chunkSize));	20✔
89	const rst = strtok3.fromBuffer(id3_data);	20✔
90	await new ID3v2Parser().parse(this.metadata, rst, this.options);	20✔
91	return header.chunkSize;	20✔
92	}	20✔
93		468✔
94	case 'SSND': // Sound Data Chunk	468✔
95	if (this.metadata.format.duration) {	126✔
96	this.metadata.setFormat('bitrate', 8 * header.chunkSize / this.metadata.format.duration);	112✔
97	}	112✔
98	return 0;	126✔
99		468✔
100	case 'NAME': // Sample name chunk	468✔
101	case 'AUTH': // Author chunk	468✔
102	case '(c) ': // Copyright chunk	468✔
103	case 'ANNO': // Annotation chunk	468✔
104	return this.readTextChunk(header);	44✔
105		468✔
106	default:	468✔
107	debug(`Ignore chunk id=${header.chunkID}, size=${header.chunkSize}`);	138✔
108	return 0;	138✔
109	}	468✔
110	}	468✔
111		140✔
112	public async readTextChunk(header: iff.IChunkHeader): Promise<number> {	140✔
113	const value = await this.tokenizer.readToken(new Token.StringType(header.chunkSize, 'ascii'));	44✔
114	const values = value.split('\0').map(v => v.trim()).filter(v => v?.length);	44!
115	await Promise.all(values.map(v => this.metadata.addTag('AIFF', header.chunkID, v)));	44✔
116	return header.chunkSize;	44✔
117	}	44✔
118		140✔
119	}	140✔

Borewit / music-metadata / 10325410889

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous