10600061635

Committed 28 Aug 2024 03:47PM UTC coverage: 97.089% (-0.003%) from 97.092%

Build # 10600061635

Build Type

Pull #2229

github

Committed by

web-flow

Commit Message

Merge 6a3f2c97a into bc67986e9

Pull Request Pull Request #2229: Implement own custom `Error`: `ParseError`

Run Details

1345 of 1513 branches covered (88.9%)

Branch coverage included in aggregate %.

121 of 151 new or added lines in 29 files covered. (80.13%)

1 existing line in 1 file now uncovered.

11594 of 11814 relevant lines covered (98.14%)

16181.49 hits per line

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

89.45

/lib/dsdiff/DsdiffParser.ts

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

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

import { ChunkHeader64, type IChunkHeader64 } from './DsdiffToken.js';
import { ParseError, } from '../ParseError.js';

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

/**
 * DSDIFF - Direct Stream Digital Interchange File Format (Phillips)
 *
 * Ref:
 * - http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
 */
export class DsdiffParser extends BasicParser {

  public async parse(): Promise<void> {

    const header = await this.tokenizer.readToken<IChunkHeader64>(ChunkHeader64);
    if (header.chunkID !== 'FRM8') throw new ParseError('Unexpected chunk-ID');

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

      case 'DSD':
        this.metadata.setFormat('container', `DSDIFF/${type}`);
        this.metadata.setFormat('lossless', true);
        return this.readFmt8Chunks(header.chunkSize - BigInt(FourCcToken.len));

      default:
        throw new ParseError(`Unsupported DSDIFF type: ${type}`);
    }
  }

  private async readFmt8Chunks(remainingSize: bigint): Promise<void> {

    while (remainingSize >= ChunkHeader64.len) {
      const chunkHeader = await this.tokenizer.readToken<IChunkHeader64>(ChunkHeader64);

      //  If the data is an odd number of bytes in length, a pad byte must be added at the end
      debug(`Chunk id=${chunkHeader.chunkID}`);
      await this.readData(chunkHeader);
      remainingSize -= (BigInt(ChunkHeader64.len) + chunkHeader.chunkSize);
    }
  }

  private async readData(header: IChunkHeader64): Promise<void> {
    debug(`Reading data of chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
    const p0 = this.tokenizer.position;
    switch (header.chunkID.trim()) {

      case 'FVER': { // 3.1 FORMAT VERSION CHUNK
        const version = await this.tokenizer.readToken<number>(Token.UINT32_LE);
        debug(`DSDIFF version=${version}`);
        break;
      }

      case 'PROP': { // 3.2 PROPERTY CHUNK
        const propType = await this.tokenizer.readToken(FourCcToken);
        if (propType !== 'SND ') throw new ParseError('Unexpected PROP-chunk ID');
        await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));
        break;
      }

      case 'ID3': { // Unofficial ID3 tag support
        const id3_data = await this.tokenizer.readToken<Uint8Array>(new Token.Uint8ArrayType(Number(header.chunkSize)));
        const rst = strtok3.fromBuffer(id3_data);
        await new ID3v2Parser().parse(this.metadata, rst, this.options);
        break;
      }

      case 'DSD':
        if (this.metadata.format.numberOfChannels) {
          this.metadata.setFormat('numberOfSamples', Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));
        }
        if (this.metadata.format.numberOfSamples && this.metadata.format.sampleRate) {
          this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
        }
        break;

      default:
        debug(`Ignore chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
        break;

    }
    const remaining = header.chunkSize - BigInt(this.tokenizer.position - p0);
    if (remaining > 0) {
      debug(`After Parsing chunk, remaining ${remaining} bytes`);
      await this.tokenizer.ignore(Number(remaining));
    }
  }

  private async handleSoundPropertyChunks(remainingSize: bigint): Promise<void> {
    debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
    while (remainingSize > 0) {
      const sndPropHeader = await this.tokenizer.readToken<IChunkHeader64>(ChunkHeader64);
      debug(`Sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
      const p0 = this.tokenizer.position;
      switch (sndPropHeader.chunkID.trim()) {

        case 'FS': { // 3.2.1 Sample Rate Chunk
          const sampleRate = await this.tokenizer.readToken<number>(Token.UINT32_BE);
          this.metadata.setFormat('sampleRate', sampleRate);
          break;
        }

        case 'CHNL': { // 3.2.2 Channels Chunk
          const numChannels = await this.tokenizer.readToken<number>(Token.UINT16_BE);
          this.metadata.setFormat('numberOfChannels', numChannels);
          await this.handleChannelChunks(sndPropHeader.chunkSize - BigInt(Token.UINT16_BE.len));
          break;
        }

        case 'CMPR': { // 3.2.3 Compression Type Chunk
          const compressionIdCode = (await this.tokenizer.readToken<string>(FourCcToken)).trim();
          const count = await this.tokenizer.readToken<number>(Token.UINT8);
          const compressionName = await this.tokenizer.readToken<string>(new Token.StringType(count, 'ascii'));
          if (compressionIdCode === 'DSD') {
            this.metadata.setFormat('lossless', true);
            this.metadata.setFormat('bitsPerSample', 1);
          }
          this.metadata.setFormat('codec', `${compressionIdCode} (${compressionName})`);
          break;
        }

        case 'ABSS': { // 3.2.4 Absolute Start Time Chunk
          const hours = await this.tokenizer.readToken<number>(Token.UINT16_BE);
          const minutes = await this.tokenizer.readToken<number>(Token.UINT8);
          const seconds = await this.tokenizer.readToken<number>(Token.UINT8);
          const samples = await this.tokenizer.readToken<number>(Token.UINT32_BE);
          debug(`ABSS ${hours}:${minutes}:${seconds}.${samples}`);
          break;
        }

        case 'LSCO': { // 3.2.5 Loudspeaker Configuration Chunk
          const lsConfig = await this.tokenizer.readToken<number>(Token.UINT16_BE);
          debug(`LSCO lsConfig=${lsConfig}`);
          break;
        }
        default:
          debug(`Unknown sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
          await this.tokenizer.ignore(Number(sndPropHeader.chunkSize));
      }
      const remaining = sndPropHeader.chunkSize - BigInt(this.tokenizer.position - p0);
      if (remaining > 0) {
        debug(`After Parsing sound-property-chunk ${sndPropHeader.chunkSize}, remaining ${remaining} bytes`);
        await this.tokenizer.ignore(Number(remaining));
      }
      remainingSize -= BigInt(ChunkHeader64.len) + sndPropHeader.chunkSize;
      debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
    }
    if (this.metadata.format.lossless && this.metadata.format.sampleRate && this.metadata.format.numberOfChannels && this.metadata.format.bitsPerSample) {
      const bitrate = this.metadata.format.sampleRate * this.metadata.format.numberOfChannels * this.metadata.format.bitsPerSample;
      this.metadata.setFormat('bitrate', bitrate);
    }
  }

  private async handleChannelChunks(remainingSize: bigint): Promise<string[]> {
    debug(`Parsing channel-chunks, remainingSize=${remainingSize}`);
    const channels: string[] = [];
    while (remainingSize >= FourCcToken.len) {
      const channelId = await this.tokenizer.readToken<string>(FourCcToken);
      debug(`Channel[ID=${channelId}]`);
      channels.push(channelId);
      remainingSize -= BigInt(FourCcToken.len);
    }
    debug(`Channels: ${channels.join(', ')}`);
    return channels;
  }
}

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 { FourCcToken } from '../common/FourCC.js';	4✔
6	import { BasicParser } from '../common/BasicParser.js';	4✔
7	import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';	4✔
8		4✔
9	import { ChunkHeader64, type IChunkHeader64 } from './DsdiffToken.js';	4✔
10	import { ParseError, } from '../ParseError.js';	4✔
11		4✔
12	const debug = initDebug('music-metadata:parser:aiff');	4✔
13		4✔
14	/**	4✔
15	* DSDIFF - Direct Stream Digital Interchange File Format (Phillips)	4✔
16	*	4✔
17	* Ref:	4✔
18	* - http://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf	4✔
19	*/	4✔
20	export class DsdiffParser extends BasicParser {	4✔
21		4✔
22	public async parse(): Promise<void> {	4✔
23		4✔
24	const header = await this.tokenizer.readToken<IChunkHeader64>(ChunkHeader64);	4✔
25	if (header.chunkID !== 'FRM8') throw new ParseError('Unexpected chunk-ID');	4!
26		4✔
27	const type = (await this.tokenizer.readToken<string>(FourCcToken)).trim();	4✔
28	switch (type) {	4✔
29		4✔
30	case 'DSD':	4✔
31	this.metadata.setFormat('container', `DSDIFF/${type}`);	4✔
32	this.metadata.setFormat('lossless', true);	4✔
33	return this.readFmt8Chunks(header.chunkSize - BigInt(FourCcToken.len));	4✔
34		4✔
35	default:	4!
NEW 36	throw new ParseError(`Unsupported DSDIFF type: ${type}`);	×
37	}	4✔
38	}	4✔
39		4✔
40	private async readFmt8Chunks(remainingSize: bigint): Promise<void> {	4✔
41		4✔
42	while (remainingSize >= ChunkHeader64.len) {	4✔
43	const chunkHeader = await this.tokenizer.readToken<IChunkHeader64>(ChunkHeader64);	20✔
44		20✔
45	// If the data is an odd number of bytes in length, a pad byte must be added at the end	20✔
46	debug(`Chunk id=${chunkHeader.chunkID}`);	20✔
47	await this.readData(chunkHeader);	20✔
48	remainingSize -= (BigInt(ChunkHeader64.len) + chunkHeader.chunkSize);	20✔
49	}	20✔
50	}	4✔
51		4✔
52	private async readData(header: IChunkHeader64): Promise<void> {	4✔
53	debug(`Reading data of chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);	20✔
54	const p0 = this.tokenizer.position;	20✔
55	switch (header.chunkID.trim()) {	20✔
56		20✔
57	case 'FVER': { // 3.1 FORMAT VERSION CHUNK	20✔
58	const version = await this.tokenizer.readToken<number>(Token.UINT32_LE);	4✔
59	debug(`DSDIFF version=${version}`);	4✔
60	break;	4✔
61	}	4✔
62		20✔
63	case 'PROP': { // 3.2 PROPERTY CHUNK	20✔
64	const propType = await this.tokenizer.readToken(FourCcToken);	4✔
65	if (propType !== 'SND ') throw new ParseError('Unexpected PROP-chunk ID');	4!
66	await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));	4✔
67	break;	4✔
68	}	4✔
69		20✔
70	case 'ID3': { // Unofficial ID3 tag support	20✔
71	const id3_data = await this.tokenizer.readToken<Uint8Array>(new Token.Uint8ArrayType(Number(header.chunkSize)));	4✔
72	const rst = strtok3.fromBuffer(id3_data);	4✔
73	await new ID3v2Parser().parse(this.metadata, rst, this.options);	4✔
74	break;	4✔
75	}	4✔
76		20✔
77	case 'DSD':	20✔
78	if (this.metadata.format.numberOfChannels) {	4✔
79	this.metadata.setFormat('numberOfSamples', Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));	4✔
80	}	4✔
81	if (this.metadata.format.numberOfSamples && this.metadata.format.sampleRate) {	4✔
82	this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);	4✔
83	}	4✔
84	break;	4✔
85		20✔
86	default:	20✔
87	debug(`Ignore chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);	4✔
88	break;	4✔
89		20✔
90	}	20✔
91	const remaining = header.chunkSize - BigInt(this.tokenizer.position - p0);	20✔
92	if (remaining > 0) {	20✔
93	debug(`After Parsing chunk, remaining ${remaining} bytes`);	8✔
94	await this.tokenizer.ignore(Number(remaining));	8✔
95	}	8✔
96	}	20✔
97		4✔
98	private async handleSoundPropertyChunks(remainingSize: bigint): Promise<void> {	4✔
99	debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);	4✔
100	while (remainingSize > 0) {	4✔
101	const sndPropHeader = await this.tokenizer.readToken<IChunkHeader64>(ChunkHeader64);	12✔
102	debug(`Sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);	12✔
103	const p0 = this.tokenizer.position;	12✔
104	switch (sndPropHeader.chunkID.trim()) {	12✔
105		12✔
106	case 'FS': { // 3.2.1 Sample Rate Chunk	12✔
107	const sampleRate = await this.tokenizer.readToken<number>(Token.UINT32_BE);	4✔
108	this.metadata.setFormat('sampleRate', sampleRate);	4✔
109	break;	4✔
110	}	4✔
111		12✔
112	case 'CHNL': { // 3.2.2 Channels Chunk	12✔
113	const numChannels = await this.tokenizer.readToken<number>(Token.UINT16_BE);	4✔
114	this.metadata.setFormat('numberOfChannels', numChannels);	4✔
115	await this.handleChannelChunks(sndPropHeader.chunkSize - BigInt(Token.UINT16_BE.len));	4✔
116	break;	4✔
117	}	4✔
118		12✔
119	case 'CMPR': { // 3.2.3 Compression Type Chunk	12✔
120	const compressionIdCode = (await this.tokenizer.readToken<string>(FourCcToken)).trim();	4✔
121	const count = await this.tokenizer.readToken<number>(Token.UINT8);	4✔
122	const compressionName = await this.tokenizer.readToken<string>(new Token.StringType(count, 'ascii'));	4✔
123	if (compressionIdCode === 'DSD') {	4✔
124	this.metadata.setFormat('lossless', true);	4✔
125	this.metadata.setFormat('bitsPerSample', 1);	4✔
126	}	4✔
127	this.metadata.setFormat('codec', `${compressionIdCode} (${compressionName})`);	4✔
128	break;	4✔
129	}	4✔
130		12✔
131	case 'ABSS': { // 3.2.4 Absolute Start Time Chunk	12!
132	const hours = await this.tokenizer.readToken<number>(Token.UINT16_BE);	×
133	const minutes = await this.tokenizer.readToken<number>(Token.UINT8);	×
134	const seconds = await this.tokenizer.readToken<number>(Token.UINT8);	×
135	const samples = await this.tokenizer.readToken<number>(Token.UINT32_BE);	×
136	debug(`ABSS ${hours}:${minutes}:${seconds}.${samples}`);	×
137	break;	×
138	}	×
139		12✔
140	case 'LSCO': { // 3.2.5 Loudspeaker Configuration Chunk	12!
141	const lsConfig = await this.tokenizer.readToken<number>(Token.UINT16_BE);	×
142	debug(`LSCO lsConfig=${lsConfig}`);	×
143	break;	×
144	}	×
145	default:	12!
146	debug(`Unknown sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);	×
147	await this.tokenizer.ignore(Number(sndPropHeader.chunkSize));	×
148	}	×
149	const remaining = sndPropHeader.chunkSize - BigInt(this.tokenizer.position - p0);	12✔
150	if (remaining > 0) {	12✔
151	debug(`After Parsing sound-property-chunk ${sndPropHeader.chunkSize}, remaining ${remaining} bytes`);	4✔
152	await this.tokenizer.ignore(Number(remaining));	4✔
153	}	4✔
154	remainingSize -= BigInt(ChunkHeader64.len) + sndPropHeader.chunkSize;	12✔
155	debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);	12✔
156	}	12✔
157	if (this.metadata.format.lossless && this.metadata.format.sampleRate && this.metadata.format.numberOfChannels && this.metadata.format.bitsPerSample) {	4✔
158	const bitrate = this.metadata.format.sampleRate * this.metadata.format.numberOfChannels * this.metadata.format.bitsPerSample;	4✔
159	this.metadata.setFormat('bitrate', bitrate);	4✔
160	}	4✔
161	}	4✔
162		4✔
163	private async handleChannelChunks(remainingSize: bigint): Promise<string[]> {	4✔
164	debug(`Parsing channel-chunks, remainingSize=${remainingSize}`);	4✔
165	const channels: string[] = [];	4✔
166	while (remainingSize >= FourCcToken.len) {	4✔
167	const channelId = await this.tokenizer.readToken<string>(FourCcToken);	8✔
168	debug(`Channel[ID=${channelId}]`);	8✔
169	channels.push(channelId);	8✔
170	remainingSize -= BigInt(FourCcToken.len);	8✔
171	}	8✔
172	debug(`Channels: ${channels.join(', ')}`);	4✔
173	return channels;	4✔
174	}	4✔
175	}	4✔

Borewit / music-metadata / 10600061635

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