10689239225

Committed 03 Sep 2024 07:18PM UTC coverage: 97.054% (-0.02%) from 97.078%

Build # 10689239225

Build Type

Pull #2231

github

Committed by

Borewit

Commit Message

Dynamic import parsers

Pull Request Pull Request #2231: Dynamic import parsers

Run Details

1310 of 1480 branches covered (88.51%)

Branch coverage included in aggregate %.

273 of 278 new or added lines in 21 files covered. (98.2%)

18 existing lines in 1 file now uncovered.

11804 of 12032 relevant lines covered (98.11%)

15890.39 hits per line

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

90.87

/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(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): Promise<ITokenParser>
}

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

Borewit / music-metadata / 10689239225

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