10619659649

Committed 29 Aug 2024 05:18PM UTC coverage: 97.055% (-0.02%) from 97.078%

Build # 10619659649

Build Type

push

github

Committed by

Borewit

Commit Message

Dynamic import parsers

Run Details

1311 of 1481 branches covered (88.52%)

Branch coverage included in aggregate %.

306 of 318 new or added lines in 15 files covered. (96.23%)

1 existing line in 1 file now uncovered.

11806 of 12034 relevant lines covered (98.11%)

15892.07 hits per line

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

91.01

/lib/ParserFactory.ts

import { fileTypeFromBuffer } from 'file-type';
import ContentType from 'content-type';
import { type MediaType, parse as mimeTypeParse } from 'media-typer';
import initDebug from 'debug';

import { type INativeMetadataCollector, MetadataCollector } from './common/MetadataCollector.js';

import type { IAudioMetadata, IOptions, ParserType } from './type.js';
import type { ITokenizer } from 'strtok3';
import { mpegParserLoader } from './mpeg/MpegLoader.js';
import { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
import { apeParserLoader } from './apev2/Apev2Loader.js';
import { asfParserLoader } from './asf/AsfLoader.js';
import { dsdiffParserLoader } from './dsdiff/DsdiffLoader.js';
import { aiffParserLoader } from './aiff/AiffLoader.js';
import { dsfParserLoader } from './dsf/DsfLoader.js';
import { flacParserLoader } from './flac/FlacLoader.js';
import { matroskaParserLoader } from './matroska/MatroskaLoader.js';
import { mp4ParserLoader } from './mp4/Mp4Loader.js';
import { musepackParserLoader } from './musepack/MusepackLoader.js';
import { oggParserLoader } from './ogg/OggLoader.js';
import { wavpackParserLoader } from './wavpack/WavPackLoader.js';
import { riffParserLoader } from './wav/WaveLoader.js';

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

export interface IParserLoader {
  /**
   * Returns a list of supported file extensions
   */
  extensions: string[]

  parserType: ParserType;

  /**
   * Lazy load the parser
   */
  load(): Promise<ITokenParser>
}

export interface ITokenParser {

  /**
   * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
   * @param metadata - Output
   * @param tokenizer - Input
   * @param options - Parsing options
   */
  init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;

  /**
   * Parse audio track.
   * Called after init(...).
   * @returns Promise
   */
  parse(): Promise<void>;
}

interface IContentType extends MediaType {
  parameters: { [id: string]: string; };
}

export function parseHttpContentType(contentType: string): IContentType {
  const type = ContentType.parse(contentType);
  const mime = mimeTypeParse(type.type);
  return {
    type: mime.type,
    subtype: mime.subtype,
    suffix: mime.suffix,
    parameters: type.parameters
  } as IContentType;
}

export class ParserFactory {

  parsers: IParserLoader[] = [];

  constructor() {
    [
      flacParserLoader,
      mpegParserLoader,
      apeParserLoader,
      mp4ParserLoader,
      matroskaParserLoader,
      riffParserLoader,
      oggParserLoader,
      asfParserLoader,
      aiffParserLoader,
      wavpackParserLoader,
      musepackParserLoader,
      dsfParserLoader,
      dsdiffParserLoader
    ].forEach(parser => this.registerParser(parser));
  }

  registerParser(parser: IParserLoader): void {
    this.parsers.push(parser);
  }

  async parse(tokenizer: ITokenizer, parserLoader: IParserLoader | undefined, opts?: IOptions): Promise<IAudioMetadata> {

    if (!parserLoader) {
      const buf = new Uint8Array(4100);
      if (tokenizer.fileInfo.mimeType) {
        parserLoader = this.findLoaderForType(getParserIdForMimeType(tokenizer.fileInfo.mimeType));
      }
      if (!parserLoader && tokenizer.fileInfo.path) {
        parserLoader = this.findLoaderForExtension(tokenizer.fileInfo.path);
      }
      if (!parserLoader) {
        // Parser could not be determined on MIME-type or extension
        debug('Guess parser on content...');
        await tokenizer.peekBuffer(buf, {mayBeLess: true});

        const guessedType = await fileTypeFromBuffer(buf);
        if (!guessedType || !guessedType.mime) {
          throw new CouldNotDetermineFileTypeError('Failed to determine audio format');
        }
        debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);
        parserLoader = this.findLoaderForType(getParserIdForMimeType(guessedType.mime));
        if (!parserLoader) {
          throw new UnsupportedFileTypeError(`Guessed MIME-type not supported: ${guessedType.mime}`);
        }
      }
    }
    // Parser found, execute parser
    debug(`Loading ${parserLoader.parserType} parser...`);
    const parser = await parserLoader.load();
    debug(`Parser ${parserLoader.parserType} loaded`);
    const metadata = new MetadataCollector(opts);
    await parser.init(metadata, tokenizer, opts ?? {}).parse();
    return metadata.toCommonMetadata();
  }

  /**
   * Parse metadata from tokenizer
   * @param tokenizer - Tokenizer
   * @param opts - Options
   * @returns Native metadata
   */
  async parseOnContentType(tokenizer: ITokenizer, opts?: IOptions): Promise<IAudioMetadata> {

    const { mimeType, path, url } = tokenizer.fileInfo;

    // Resolve parser based on MIME-type or file extension
    const parserLoader = this.findLoaderForType(getParserIdForMimeType(mimeType)) || this.findLoaderForExtension(path) || this.findLoaderForExtension(url);

    if (!parserLoader) {
      debug(`No parser found for MIME-type / extension: ${mimeType}`);
      throw new Error('No suitable parser found');
    }

    return this.parse(tokenizer, parserLoader, opts);
  }

  /**
   * @param filePath - Path, filename or extension to audio file
   * @return Parser submodule name
   */
 findLoaderForExtension(filePath: string | undefined): IParserLoader | undefined {
    if (!filePath)
      return;

    const extension = getExtension(filePath).toLocaleLowerCase() || filePath;

    return this.parsers.find(parser => parser.extensions.indexOf(extension) !== -1);

    // switch (extension) {
    //
    //   case '.mp2':
    //   case '.mp3':
    //   case '.m2a':
    //   case '.aac': // Assume it is ADTS-container
    //     return 'mpeg';
    //
    //   case '.ape':
    //     return 'apev2';
    //
    //   case '.mp4':
    //   case '.m4a':
    //   case '.m4b':
    //   case '.m4pa':
    //   case '.m4v':
    //   case '.m4r':
    //   case '.3gp':
    //     return 'mp4';
    //
    //   case '.wma':
    //   case '.wmv':
    //   case '.asf':
    //     return 'asf';
    //
    //   case '.flac':
    //     return 'flac';
    //
    //   case '.ogg':
    //   case '.ogv':
    //   case '.oga':
    //   case '.ogm':
    //   case '.ogx':
    //   case '.opus': // recommended filename extension for Ogg Opus
    //   case '.spx': // recommended filename extension for Ogg Speex
    //     return 'ogg';
    //
    //   case '.aif':
    //   case '.aiff':
    //   case '.aifc':
    //     return 'aiff';
    //
    //   case '.wav':
    //   case '.bwf': // Broadcast Wave Format
    //     return 'riff';
    //
    //   case '.wv':
    //   case '.wvp':
    //     return 'wavpack';
    //
    //   case '.mpc':
    //     return 'musepack';
    //
    //   case '.dsf':
    //     return 'dsf';
    //
    //   case '.dff':
    //     return 'dsdiff';
    //
    //   case '.mka':
    //   case '.mkv':
    //   case '.mk3d':
    //   case '.mks':
    //   case '.webm':
    //     return 'matroska';
    // }
  }

  findLoaderForType(moduleName: ParserType| undefined): IParserLoader | undefined {
    // switch (moduleName) {
    //   case 'aiff': return new AIFFParser();
    //   case 'adts':
    //   case 'mpeg':
    //     return new MpegParser();
    //   case 'apev2': return new APEv2Parser();
    //   case 'asf': return new AsfParser();
    //   case 'dsf': return new DsfParser();
    //   case 'dsdiff': return new DsdiffParser();
    //   case 'flac': return new FlacParser();
    //   case 'mp4': return new MP4Parser();
    //   case 'musepack': return new MusepackParser();
    //   case 'ogg': return new OggParser();
    //   case 'riff': return new WaveParser();
    //   case 'wavpack': return new WavPackParser();
    //   case 'matroska': return new MatroskaParser();
    //   default:
    //     throw new Error(`Unknown parser type: ${moduleName}`);
    // }
    return moduleName ? this.parsers.find(parser => parser.parserType === moduleName) : undefined;
  }
}

function getExtension(fname: string): string {
  const i = fname.lastIndexOf('.');
  return i === -1 ? '' : fname.slice(i);
}

/**
 * @param httpContentType - HTTP Content-Type, extension, path or filename
 * @returns Parser submodule name
 */
function getParserIdForMimeType(httpContentType: string | undefined): ParserType | undefined {

  let mime: IContentType;
  if (!httpContentType) return;
  try {
    mime = parseHttpContentType(httpContentType);
  } catch (err) {
    debug(`Invalid HTTP Content-Type header value: ${httpContentType}`);
    return;
  }

  const subType = mime.subtype.indexOf('x-') === 0 ? mime.subtype.substring(2) : mime.subtype;

  switch (mime.type) {

    case 'audio':
      switch (subType) {

        case 'mp3': // Incorrect MIME-type, Chrome, in Web API File object
        case 'mpeg':
          return 'mpeg';

        case 'aac':
        case 'aacp':
          return 'mpeg'; // adts

        case 'flac':
          return 'flac';

        case 'ape':
        case 'monkeys-audio':
          return 'apev2';

        case 'mp4':
        case 'm4a':
          return 'mp4';

        case 'ogg': // RFC 7845
        case 'opus': // RFC 6716
        case 'speex': // RFC 5574
          return 'ogg';

        case 'ms-wma':
        case 'ms-wmv':
        case 'ms-asf':
          return 'asf';

        case 'aiff':
        case 'aif':
        case 'aifc':
          return 'aiff';

        case 'vnd.wave':
        case 'wav':
        case 'wave':
          return 'riff';

        case 'wavpack':
          return 'wavpack';

        case 'musepack':
          return 'musepack';

        case 'matroska':
        case 'webm':
          return 'matroska';

        case 'dsf':
          return 'dsf';
      }
      break;

    case 'video':
      switch (subType) {

        case 'ms-asf':
        case 'ms-wmv':
          return 'asf';

        case 'm4v':
        case 'mp4':
          return 'mp4';

        case 'ogg':
          return 'ogg';

        case 'matroska':
        case 'webm':
          return 'matroska';
      }
      break;

    case 'application':
      switch (subType) {

        case 'vnd.ms-asf':
          return 'asf';

        case 'ogg':
          return 'ogg';
      }
      break;
  }
}

1	import { fileTypeFromBuffer } from 'file-type';	4✔
2	import ContentType from 'content-type';	4✔
3	import { type MediaType, parse as mimeTypeParse } from 'media-typer';	4✔
4	import initDebug from 'debug';	4✔
5		4✔
6	import { type INativeMetadataCollector, MetadataCollector } from './common/MetadataCollector.js';	4✔
7		4✔
8	import type { IAudioMetadata, IOptions, ParserType } from './type.js';	4✔
9	import type { ITokenizer } from 'strtok3';	4✔
10	import { mpegParserLoader } from './mpeg/MpegLoader.js';	4✔
11	import { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';	4✔
12	import { apeParserLoader } from './apev2/Apev2Loader.js';	4✔
13	import { asfParserLoader } from './asf/AsfLoader.js';	4✔
14	import { dsdiffParserLoader } from './dsdiff/DsdiffLoader.js';	4✔
15	import { aiffParserLoader } from './aiff/AiffLoader.js';	4✔
16	import { dsfParserLoader } from './dsf/DsfLoader.js';	4✔
17	import { flacParserLoader } from './flac/FlacLoader.js';	4✔
18	import { matroskaParserLoader } from './matroska/MatroskaLoader.js';	4✔
19	import { mp4ParserLoader } from './mp4/Mp4Loader.js';	4✔
20	import { musepackParserLoader } from './musepack/MusepackLoader.js';	4✔
21	import { oggParserLoader } from './ogg/OggLoader.js';	4✔
22	import { wavpackParserLoader } from './wavpack/WavPackLoader.js';	4✔
23	import { riffParserLoader } from './wav/WaveLoader.js';	4✔
24		4✔
25	const debug = initDebug('music-metadata:parser:factory');	4✔
26		4✔
27	export interface IParserLoader {	4✔
28	/**	4✔
29	* Returns a list of supported file extensions	4✔
30	*/	4✔
31	extensions: string[]	4✔
32		4✔
33	parserType: ParserType;	4✔
34		4✔
35	/**	4✔
36	* Lazy load the parser	4✔
37	*/	4✔
38	load(): Promise<ITokenParser>	4✔
39	}	4✔
40		4✔
41	export interface ITokenParser {	4✔
42		4✔
43	/**	4✔
44	* Initialize parser with output (metadata), input (tokenizer) & parsing options (options).	4✔
45	* @param metadata - Output	4✔
46	* @param tokenizer - Input	4✔
47	* @param options - Parsing options	4✔
48	*/	4✔
49	init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;	4✔
50		4✔
51	/**	4✔
52	* Parse audio track.	4✔
53	* Called after init(...).	4✔
54	* @returns Promise	4✔
55	*/	4✔
56	parse(): Promise<void>;	4✔
57	}	4✔
58		4✔
59	interface IContentType extends MediaType {	4✔
60	parameters: { [id: string]: string; };	4✔
61	}	4✔
62		4✔
63	export function parseHttpContentType(contentType: string): IContentType {	4✔
64	const type = ContentType.parse(contentType);	582✔
65	const mime = mimeTypeParse(type.type);	582✔
66	return {	582✔
67	type: mime.type,	582✔
68	subtype: mime.subtype,	582✔
69	suffix: mime.suffix,	582✔
70	parameters: type.parameters	582✔
71	} as IContentType;	582✔
72	}	582✔
73		4✔
74	export class ParserFactory {	4✔
75		4✔
76	parsers: IParserLoader[] = [];	4✔
77		4✔
78	constructor() {	4✔
79	[	1,700✔
80	flacParserLoader,	1,700✔
81	mpegParserLoader,	1,700✔
82	apeParserLoader,	1,700✔
83	mp4ParserLoader,	1,700✔
84	matroskaParserLoader,	1,700✔
85	riffParserLoader,	1,700✔
86	oggParserLoader,	1,700✔
87	asfParserLoader,	1,700✔
88	aiffParserLoader,	1,700✔
89	wavpackParserLoader,	1,700✔
90	musepackParserLoader,	1,700✔
91	dsfParserLoader,	1,700✔
92	dsdiffParserLoader	1,700✔
93	].forEach(parser => this.registerParser(parser));	1,700✔
94	}	1,700✔
95		4✔
96	registerParser(parser: IParserLoader): void {	4✔
97	this.parsers.push(parser);	22,100✔
98	}	22,100✔
99		4✔
100	async parse(tokenizer: ITokenizer, parserLoader: IParserLoader \| undefined, opts?: IOptions): Promise<IAudioMetadata> {	4✔
101		1,700✔
102	if (!parserLoader) {	1,700✔
103	const buf = new Uint8Array(4100);	624✔
104	if (tokenizer.fileInfo.mimeType) {	624✔
105	parserLoader = this.findLoaderForType(getParserIdForMimeType(tokenizer.fileInfo.mimeType));	436✔
106	}	436✔
107	if (!parserLoader && tokenizer.fileInfo.path) {	624✔
108	parserLoader = this.findLoaderForExtension(tokenizer.fileInfo.path);	192✔
109	}	192✔
110	if (!parserLoader) {	624✔
111	// Parser could not be determined on MIME-type or extension	134✔
112	debug('Guess parser on content...');	134✔
113	await tokenizer.peekBuffer(buf, {mayBeLess: true});	134✔
114		134✔
115	const guessedType = await fileTypeFromBuffer(buf);	134✔
116	if (!guessedType \|\| !guessedType.mime) {	134✔
117	throw new CouldNotDetermineFileTypeError('Failed to determine audio format');	4✔
118	}	4✔
119	debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);	130✔
120	parserLoader = this.findLoaderForType(getParserIdForMimeType(guessedType.mime));	130✔
121	if (!parserLoader) {	134✔
122	throw new UnsupportedFileTypeError(`Guessed MIME-type not supported: ${guessedType.mime}`);	12✔
123	}	12✔
124	}	134✔
125	}	624✔
126	// Parser found, execute parser	1,684✔
127	debug(`Loading ${parserLoader.parserType} parser...`);	1,684✔
128	const parser = await parserLoader.load();	1,684✔
129	debug(`Parser ${parserLoader.parserType} loaded`);	1,684✔
130	const metadata = new MetadataCollector(opts);	1,684✔
131	await parser.init(metadata, tokenizer, opts ?? {}).parse();	1,700!
132	return metadata.toCommonMetadata();	1,672✔
133	}	1,672✔
134		4✔
135	/**	4✔
136	* Parse metadata from tokenizer	4✔
137	* @param tokenizer - Tokenizer	4✔
138	* @param opts - Options	4✔
139	* @returns Native metadata	4✔
140	*/	4✔
141	async parseOnContentType(tokenizer: ITokenizer, opts?: IOptions): Promise<IAudioMetadata> {	4✔
NEW 142		×
NEW 143	const { mimeType, path, url } = tokenizer.fileInfo;	×
UNCOV 144		×
NEW 145	// Resolve parser based on MIME-type or file extension	×
NEW 146	const parserLoader = this.findLoaderForType(getParserIdForMimeType(mimeType)) \|\| this.findLoaderForExtension(path) \|\| this.findLoaderForExtension(url);	×
NEW 147		×
NEW 148	if (!parserLoader) {	×
NEW 149	debug(`No parser found for MIME-type / extension: ${mimeType}`);	×
NEW 150	throw new Error('No suitable parser found');	×
NEW 151	}	×
NEW 152		×
NEW 153	return this.parse(tokenizer, parserLoader, opts);	×
NEW 154	}	×
155		4✔
156	/**	4✔
157	* @param filePath - Path, filename or extension to audio file	4✔
158	* @return Parser submodule name	4✔
159	*/	4✔
160	findLoaderForExtension(filePath: string \| undefined): IParserLoader \| undefined {	4✔
161	if (!filePath)	1,356✔
162	return;	1,356!
163		1,356✔
164	const extension = getExtension(filePath).toLocaleLowerCase() \|\| filePath;	1,356✔
165		1,356✔
166	return this.parsers.find(parser => parser.extensions.indexOf(extension) !== -1);	1,356✔
167		1,356✔
168	// switch (extension) {	1,356✔
169	//	1,356✔
170	// case '.mp2':	1,356✔
171	// case '.mp3':	1,356✔
172	// case '.m2a':	1,356✔
173	// case '.aac': // Assume it is ADTS-container	1,356✔
174	// return 'mpeg';	1,356✔
175	//	1,356✔
176	// case '.ape':	1,356✔
177	// return 'apev2';	1,356✔
178	//	1,356✔
179	// case '.mp4':	1,356✔
180	// case '.m4a':	1,356✔
181	// case '.m4b':	1,356✔
182	// case '.m4pa':	1,356✔
183	// case '.m4v':	1,356✔
184	// case '.m4r':	1,356✔
185	// case '.3gp':	1,356✔
186	// return 'mp4';	1,356✔
187	//	1,356✔
188	// case '.wma':	1,356✔
189	// case '.wmv':	1,356✔
190	// case '.asf':	1,356✔
191	// return 'asf';	1,356✔
192	//	1,356✔
193	// case '.flac':	1,356✔
194	// return 'flac';	1,356✔
195	//	1,356✔
196	// case '.ogg':	1,356✔
197	// case '.ogv':	1,356✔
198	// case '.oga':	1,356✔
199	// case '.ogm':	1,356✔
200	// case '.ogx':	1,356✔
201	// case '.opus': // recommended filename extension for Ogg Opus	1,356✔
202	// case '.spx': // recommended filename extension for Ogg Speex	1,356✔
203	// return 'ogg';	1,356✔
204	//	1,356✔
205	// case '.aif':	1,356✔
206	// case '.aiff':	1,356✔
207	// case '.aifc':	1,356✔
208	// return 'aiff';	1,356✔
209	//	1,356✔
210	// case '.wav':	1,356✔
211	// case '.bwf': // Broadcast Wave Format	1,356✔
212	// return 'riff';	1,356✔
213	//	1,356✔
214	// case '.wv':	1,356✔
215	// case '.wvp':	1,356✔
216	// return 'wavpack';	1,356✔
217	//	1,356✔
218	// case '.mpc':	1,356✔
219	// return 'musepack';	1,356✔
220	//	1,356✔
221	// case '.dsf':	1,356✔
222	// return 'dsf';	1,356✔
223	//	1,356✔
224	// case '.dff':	1,356✔
225	// return 'dsdiff';	1,356✔
226	//	1,356✔
227	// case '.mka':	1,356✔
228	// case '.mkv':	1,356✔
229	// case '.mk3d':	1,356✔
230	// case '.mks':	1,356✔
231	// case '.webm':	1,356✔
232	// return 'matroska';	1,356✔
233	// }	1,356✔
234	}	1,356✔
235		4✔
236	findLoaderForType(moduleName: ParserType\| undefined): IParserLoader \| undefined {	4✔
237	// switch (moduleName) {	566✔
238	// case 'aiff': return new AIFFParser();	566✔
239	// case 'adts':	566✔
240	// case 'mpeg':	566✔
241	// return new MpegParser();	566✔
242	// case 'apev2': return new APEv2Parser();	566✔
243	// case 'asf': return new AsfParser();	566✔
244	// case 'dsf': return new DsfParser();	566✔
245	// case 'dsdiff': return new DsdiffParser();	566✔
246	// case 'flac': return new FlacParser();	566✔
247	// case 'mp4': return new MP4Parser();	566✔
248	// case 'musepack': return new MusepackParser();	566✔
249	// case 'ogg': return new OggParser();	566✔
250	// case 'riff': return new WaveParser();	566✔
251	// case 'wavpack': return new WavPackParser();	566✔
252	// case 'matroska': return new MatroskaParser();	566✔
253	// default:	566✔
254	// throw new Error(`Unknown parser type: ${moduleName}`);	566✔
255	// }	566✔
256	return moduleName ? this.parsers.find(parser => parser.parserType === moduleName) : undefined;	566✔
257	}	566✔
258	}	4✔
259		4✔
260	function getExtension(fname: string): string {	1,356✔
261	const i = fname.lastIndexOf('.');	1,356✔
262	return i === -1 ? '' : fname.slice(i);	1,356✔
263	}	1,356✔
264		4✔
265	/**	4✔
266	* @param httpContentType - HTTP Content-Type, extension, path or filename	4✔
267	* @returns Parser submodule name	4✔
268	*/	4✔
269	function getParserIdForMimeType(httpContentType: string \| undefined): ParserType \| undefined {	566✔
270		566✔
271	let mime: IContentType;	566✔
272	if (!httpContentType) return;	566!
273	try {	566✔
274	mime = parseHttpContentType(httpContentType);	566✔
275	} catch (err) {	566!
276	debug(`Invalid HTTP Content-Type header value: ${httpContentType}`);	×
277	return;	×
278	}	×
279		566✔
280	const subType = mime.subtype.indexOf('x-') === 0 ? mime.subtype.substring(2) : mime.subtype;	566✔
281		566✔
282	switch (mime.type) {	566✔
283		566✔
284	case 'audio':	566✔
285	switch (subType) {	460✔
286		460✔
287	case 'mp3': // Incorrect MIME-type, Chrome, in Web API File object	460!
288	case 'mpeg':	460✔
289	return 'mpeg';	96✔
290		460✔
291	case 'aac':	460✔
292	case 'aacp':	460✔
293	return 'mpeg'; // adts	460✔
294		460✔
295	case 'flac':	460✔
296	return 'flac';	14✔
297		460✔
298	case 'ape':	460✔
299	case 'monkeys-audio':	460✔
300	return 'apev2';	10✔
301		460✔
302	case 'mp4':	460✔
303	case 'm4a':	460✔
304	return 'mp4';	66✔
305		460✔
306	case 'ogg': // RFC 7845	460✔
307	case 'opus': // RFC 6716	460✔
308	case 'speex': // RFC 5574	460✔
309	return 'ogg';	34✔
310		460✔
311	case 'ms-wma':	460✔
312	case 'ms-wmv':	460✔
313	case 'ms-asf':	460✔
314	return 'asf';	24✔
315		460✔
316	case 'aiff':	460✔
317	case 'aif':	460✔
318	case 'aifc':	460✔
319	return 'aiff';	100✔
320		460✔
321	case 'vnd.wave':	460!
322	case 'wav':	460✔
323	case 'wave':	460✔
324	return 'riff';	8✔
325		460✔
326	case 'wavpack':	460✔
327	return 'wavpack';	30✔
328		460✔
329	case 'musepack':	460✔
330	return 'musepack';	18✔
331		460✔
332	case 'matroska':	460!
333	case 'webm':	460!
334	return 'matroska';	×
335		460✔
336	case 'dsf':	460!
337	return 'dsf';	×
338	}	460✔
339	break;	38✔
340		566✔
341	case 'video':	566✔
342	switch (subType) {	66✔
343		66✔
344	case 'ms-asf':	66!
345	case 'ms-wmv':	66!
346	return 'asf';	×
347		66✔
348	case 'm4v':	66!
349	case 'mp4':	66✔
350	return 'mp4';	30✔
351		66✔
352	case 'ogg':	66!
353	return 'ogg';	×
354		66✔
355	case 'matroska':	66!
356	case 'webm':	66✔
357	return 'matroska';	36✔
358	}	66✔
359	break;	×
360		566✔
361	case 'application':	566✔
362	switch (subType) {	28✔
363		28✔
364	case 'vnd.ms-asf':	28✔
365	return 'asf';	28✔
366		28✔
367	case 'ogg':	28!
368	return 'ogg';	×
369	}	28✔
370	break;	×
371	}	566✔
372	}	566✔

Borewit / music-metadata / 10619659649

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