### mediainfo.js CLI Usage Examples
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Demonstrates various command-line options for analyzing media files using the globally installed mediainfo.js CLI. Includes basic usage, format specification, and help.
```bash
# Install globally
npm install -g mediainfo.js
# Basic usage - outputs text format by default
mediainfo.js video.mp4
# Specify output format
mediainfo.js --format JSON video.mp4
mediainfo.js -f XML video.mp4
mediainfo.js -f HTML video.mp4
# Include cover art data (requires JSON or XML format)
mediainfo.js --format JSON --cover-data video.mp4
# Show all internal tags (full information)
mediainfo.js --full video.mp4
# Help
mediainfo.js --help
```
--------------------------------
### Browser UMD Usage Example
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Load mediainfo.js via CDN for direct browser usage without a bundler. This example demonstrates initializing MediaInfo and analyzing a file selected by the user.
```html
MediaInfo.js Example
```
--------------------------------
### Callback-style Usage of analyzeData
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Example of using the `analyzeData` method with a callback function for handling the result or errors. This pattern is useful for asynchronous operations where Promises might not be preferred.
```typescript
mediainfo.analyzeData(
fileSize,
readChunk,
(result, error) => {
if (error) {
console.error('Analysis failed:', error)
return
}
console.log('Result:', result)
}
)
```
--------------------------------
### Create MediaInfo Instance with Default Options
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Use this for basic initialization when default settings are sufficient. It returns a promise that resolves to a MediaInfo object.
```typescript
import mediaInfoFactory from 'mediainfo.js'
import type { MediaInfo, MediaInfoFactoryOptions } from 'mediainfo.js'
// Basic usage with default options (returns parsed object)
const mediainfo = await mediaInfoFactory()
```
--------------------------------
### Create MediaInfo Instance with Callback Style
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Utilize a callback-style approach for initializing MediaInfo, providing success and error handlers. This pattern is useful for environments where promise-based asynchronous operations are less convenient.
```typescript
mediaInfoFactory({ format: 'text' }, (mediainfo) => {
console.log('MediaInfo ready')
// Use mediainfo here
}, (error) => {
console.error('Failed to load:', error)
})
```
--------------------------------
### Create MediaInfo Instance with Custom Options
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Configure the MediaInfo instance with custom options for output format, cover data, full tag display, chunk size, and WASM file location. Useful for specific analysis needs or bundler integration.
```typescript
const options: MediaInfoFactoryOptions<'JSON'> = {
format: 'JSON', // Output format: 'object' | 'JSON' | 'XML' | 'HTML' | 'text'
coverData: true, // Include cover art as base64
full: false, // Show all internal tags
chunkSize: 256 * 1024, // Chunk size for reading (default: 256KB)
locateFile: (path, prefix) => {
// Custom WASM file location (useful for bundlers)
return path === 'MediaInfoModule.wasm'
? '/custom/path/MediaInfoModule.wasm'
: `${prefix}${path}`
}
}
const mediainfoJson = await mediaInfoFactory(options)
```
--------------------------------
### MediaInfo Object Output Format
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Demonstrates creating a MediaInfo instance with the 'object' format, which returns a typed `MediaInfoResult` object. This is the default format and provides structured access to metadata.
```typescript
import mediaInfoFactory from 'mediainfo.js'
// Object format (default) - Returns typed MediaInfoResult
const miObject = await mediaInfoFactory({ format: 'object' })
const objectResult = await miObject.analyzeData(size, readChunk)
// objectResult.media.track[0].Format === 'MPEG-4'
```
--------------------------------
### MediaInfo Text Output Format
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Shows how to configure MediaInfo to return metadata as a human-readable text string. This format is useful for simple logging or display purposes.
```typescript
// Text format - Returns human-readable text
const miText = await mediaInfoFactory({ format: 'text' })
const textResult = await miText.analyzeData(size, readChunk)
// textResult === 'General
Complete name: ...'
```
--------------------------------
### Analyze Media File in Node.js
Source: https://context7.com/buzz/mediainfo.js/llms.txt
This function demonstrates how to analyze media files from the filesystem in a Node.js environment. It uses the `node:fs` module for file operations and requires a `ReadChunkFunc`.
```typescript
import { promises as fs } from 'node:fs'
async function analyzeFileInNode(filePath: string) {
const mediainfo = await mediaInfoFactory({ format: 'object' })
let fileHandle: fs.FileHandle | undefined
try {
fileHandle = await fs.open(filePath, 'r')
const stats = await fileHandle.stat()
const readChunk: ReadChunkFunc = async (size, offset) => {
const buffer = new Uint8Array(size)
await fileHandle!.read(buffer, 0, size, offset)
return buffer
}
// Size can be a number or a function returning number/Promise
const result = await mediainfo.analyzeData(stats.size, readChunk)
return result
} finally {
await fileHandle?.close()
mediainfo.close()
}
}
```
--------------------------------
### Close and Reset MediaInfo Instance
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Use `reset()` to reinitialize the instance for a new file analysis without creating a new instance. Call `close()` when completely done to release WASM resources.
```typescript
import mediaInfoFactory from 'mediainfo.js'
const mediainfo = await mediaInfoFactory()
// Analyze first file
const result1 = await mediainfo.analyzeData(file1Size, readChunk1)
console.log('File 1:', result1.media?.track[0].Format)
// Reset for analyzing another file (reuses the same instance)
mediainfo.reset()
// Analyze second file
const result2 = await mediainfo.analyzeData(file2Size, readChunk2)
console.log('File 2:', result2.media?.track[0].Format)
// Close when completely done (releases WASM resources)
mediainfo.close()
```
--------------------------------
### React Integration with mediainfo.js
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Integrates mediainfo.js into a React component, handling initialization, file analysis, and cleanup. Ensure WASM file handling is configured correctly, especially with bundlers like Vite.
```typescript
import { useState, useEffect, useRef, ChangeEvent } from 'react'
import mediaInfoFactory from 'mediainfo.js'
import type { MediaInfo, ReadChunkFunc, MediaInfoResult } from 'mediainfo.js'
import mediaInfoWasmUrl from 'mediainfo.js/MediaInfoModule.wasm?url'
function MediaInfoComponent() {
const mediaInfoRef = useRef | null>(null)
const [result, setResult] = useState(null)
const [error, setError] = useState(null)
const [loading, setLoading] = useState(false)
useEffect(() => {
// Initialize MediaInfo
mediaInfoFactory({
format: 'object',
locateFile: (path) =>
path === 'MediaInfoModule.wasm' ? mediaInfoWasmUrl : path,
})
.then((mi) => {
mediaInfoRef.current = mi
})
.catch((err) => {
setError(`Failed to load MediaInfo: ${err.message}`)
})
// Cleanup on unmount
return () => {
mediaInfoRef.current?.close()
}
}, [])
const handleFileSelect = async (event: ChangeEvent) => {
const file = event.target.files?.[0]
if (!file || !mediaInfoRef.current) return
setLoading(true)
setError(null)
const readChunk: ReadChunkFunc = async (chunkSize, offset) =>
new Uint8Array(await file.slice(offset, offset + chunkSize).arrayBuffer())
try {
const analysisResult = await mediaInfoRef.current.analyzeData(
file.size,
readChunk
)
setResult(analysisResult)
} catch (err) {
setError(err instanceof Error ? err.message : 'Analysis failed')
} finally {
setLoading(false)
}
}
return (
{loading &&
Analyzing...
}
{error &&
{error}
}
{result && (
{JSON.stringify(result, null, 2)}
)}
)
}
```
--------------------------------
### MediaInfo HTML Output Format
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Demonstrates setting MediaInfo to generate an HTML table representation of the media metadata. This is convenient for direct display in web pages.
```typescript
// HTML format - Returns HTML table
const miHtml = await mediaInfoFactory({ format: 'HTML' })
const htmlResult = await miHtml.analyzeData(size, readChunk)
// htmlResult === '...'
```
--------------------------------
### MediaInfo JSON Output Format
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Shows how to configure MediaInfo to return metadata as a JSON string. This format is useful for easy parsing and transmission of data.
```typescript
// JSON format - Returns JSON string
const miJson = await mediaInfoFactory({ format: 'JSON' })
const jsonResult = await miJson.analyzeData(size, readChunk)
// jsonResult === '{"media":{"track":[...]}}'
```
--------------------------------
### MediaInfo XML Output Format
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Illustrates configuring MediaInfo to output metadata in XML format. This is suitable for systems that require or prefer XML data structures.
```typescript
// XML format - Returns XML string
const miXml = await mediaInfoFactory({ format: 'XML' })
const xmlResult = await miXml.analyzeData(size, readChunk)
// xmlResult === '...'
```
--------------------------------
### Analyze Media File in Browser
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Use this function to analyze media files directly from a browser environment, such as from an input element. It requires a `ReadChunkFunc` to read file data in chunks.
```typescript
import mediaInfoFactory from 'mediainfo.js'
import type { ReadChunkFunc, MediaInfoResult } from 'mediainfo.js'
// Browser: Analyze a File from input element
async function analyzeFileInBrowser(file: File) {
const mediainfo = await mediaInfoFactory({ format: 'object' })
const readChunk: ReadChunkFunc = async (chunkSize, offset) => {
const blob = file.slice(offset, offset + chunkSize)
return new Uint8Array(await blob.arrayBuffer())
}
try {
const result: MediaInfoResult = await mediainfo.analyzeData(file.size, readChunk)
// Access general information
const generalTrack = result.media?.track.find(t => t['@type'] === 'General')
console.log('Format:', generalTrack?.Format)
console.log('Duration:', generalTrack?.Duration, 'ms')
console.log('File Size:', generalTrack?.FileSize)
// Access video track information
const videoTrack = result.media?.track.find(t => t['@type'] === 'Video')
if (videoTrack && videoTrack['@type'] === 'Video') {
console.log('Resolution:', videoTrack.Width, 'x', videoTrack.Height)
console.log('Frame Rate:', videoTrack.FrameRate)
console.log('Codec:', videoTrack.Format)
console.log('Bit Rate:', videoTrack.BitRate)
}
// Access audio track information
const audioTrack = result.media?.track.find(t => t['@type'] === 'Audio')
if (audioTrack && audioTrack['@type'] === 'Audio') {
console.log('Audio Codec:', audioTrack.Format)
console.log('Channels:', audioTrack.Channels)
console.log('Sample Rate:', audioTrack.SamplingRate)
}
return result
} finally {
mediainfo.close()
}
}
```
--------------------------------
### Output Formats
Source: https://context7.com/buzz/mediainfo.js/llms.txt
MediaInfo supports multiple output formats. The format is specified when creating the MediaInfo instance and determines the return type of analyzeData.
```APIDOC
## Output Formats
MediaInfo supports multiple output formats. The format is specified when creating the MediaInfo instance and determines the return type of `analyzeData`.
### Object Format
- **Description**: Returns typed `MediaInfoResult` object.
- **Example**: `const objectResult = await miObject.analyzeData(size, readChunk)`
### JSON Format
- **Description**: Returns a JSON string.
- **Example**: `const jsonResult = await miJson.analyzeData(size, readChunk)`
- **Output**: `"{\"media\":{\"track\":[...]}}"`
### XML Format
- **Description**: Returns an XML string.
- **Example**: `const xmlResult = await miXml.analyzeData(size, readChunk)`
- **Output**: `"<\?xml version=\"1.0\"?>..."`
### HTML Format
- **Description**: Returns an HTML table.
- **Example**: `const htmlResult = await miHtml.analyzeData(size, readChunk)`
- **Output**: `"..."`
### Text Format
- **Description**: Returns a human-readable text string.
- **Example**: `const textResult = await miText.analyzeData(size, readChunk)`
- **Output**: `"General\nComplete name: ..."`
```
--------------------------------
### Configure WASM Asset Copy in Angular
Source: https://github.com/buzz/mediainfo.js/blob/main/examples/angular/README.md
Specify the WASM module to be copied during the Angular build process. Ensure the 'input' path correctly points to the mediainfo.js distribution directory.
```json
"assets": [
{
"input": "node_modules/mediainfo.js/dist",
"glob": "MediaInfoModule.wasm",
"output": ""
}
],
```
--------------------------------
### Import WASM as Asset URL in Vite + React
Source: https://github.com/buzz/mediainfo.js/blob/main/examples/vite-react/README.md
Import the WASM file as an asset URL for Vite's asset pipeline. Provide this URL to mediainfo.js via the `locateFile` option to ensure correct loading.
```typescript
import mediaInfoFactory from 'mediainfo.js'
import mediaInfoWasmUrl from 'mediainfo.js/MediaInfoModule.wasm?url'
await mediaInfoFactory({
locateFile: (path, prefix) =>
path === 'MediaInfoModule.wasm' ? mediaInfoWasmUrl : `${prefix}${path}`,
})
```
--------------------------------
### Analyze Media Files with analyzeData
Source: https://context7.com/buzz/mediainfo.js/llms.txt
The analyzeData method is the primary way to extract metadata from media files. It processes the file in chunks using a provided read function, making it memory-efficient for large files. The method supports both Promise and callback patterns.
```APIDOC
## analyzeData - Analyze Media Files
### Description
The `analyzeData` method is the primary way to extract metadata from media files. It processes the file in chunks using a provided read function, making it memory-efficient for large files. The method supports both Promise and callback patterns.
### Method
`analyzeData(size, readChunkFunc, callback?)`
### Parameters
#### Path Parameters
None
#### Query Parameters
None
#### Request Body
None
### Request Example (Browser)
```typescript
import mediaInfoFactory from 'mediainfo.js'
import type { ReadChunkFunc, MediaInfoResult } from 'mediainfo.js'
async function analyzeFileInBrowser(file: File) {
const mediainfo = await mediaInfoFactory({ format: 'object' })
const readChunk: ReadChunkFunc = async (chunkSize, offset) => {
const blob = file.slice(offset, offset + chunkSize)
return new Uint8Array(await blob.arrayBuffer())
}
try {
const result: MediaInfoResult = await mediainfo.analyzeData(file.size, readChunk)
// ... process result
return result
} finally {
mediainfo.close()
}
}
```
### Request Example (Node.js)
```typescript
import mediaInfoFactory from 'mediainfo.js'
import { promises as fs } from 'node:fs'
async function analyzeFileInNode(filePath: string) {
const mediainfo = await mediaInfoFactory({ format: 'object' })
let fileHandle: fs.FileHandle | undefined
try {
fileHandle = await fs.open(filePath, 'r')
const stats = await fileHandle.stat()
const readChunk: ReadChunkFunc = async (size, offset) => {
const buffer = new Uint8Array(size)
await fileHandle!.read(buffer, 0, size, offset)
return buffer
}
const result = await mediainfo.analyzeData(stats.size, readChunk)
return result
} finally {
await fileHandle?.close()
mediainfo.close()
}
}
```
### Request Example (Callback Style)
```javascript
mediainfo.analyzeData(
fileSize,
readChunk,
(result, error) => {
if (error) {
console.error('Analysis failed:', error)
return
}
console.log('Result:', result)
}
)
```
### Response
#### Success Response (200)
- **result** (MediaInfoResult | string) - The analysis result, type depends on the output format specified during MediaInfo instance creation.
#### Response Example (Object Format)
```json
{
"media": {
"track": [
{
"@type": "General",
"Format": "MPEG-4",
"Duration": 120000,
"FileSize": "100MB"
},
{
"@type": "Video",
"Width": 1920,
"Height": 1080,
"FrameRate": 30,
"Format": "H.264"
},
{
"@type": "Audio",
"Format": "AAC",
"Channels": 2,
"SamplingRate": 44100
}
]
}
}
```
```
--------------------------------
### Configure Webpack Alias for WASM
Source: https://github.com/buzz/mediainfo.js/blob/main/examples/webpack-react/README.md
Use Webpack's `alias` to make the WASM file discoverable.
```javascript
alias: { 'MediaInfoModule.wasm': wasmFilePath },
```
--------------------------------
### Type Guard for Tracks in mediainfo.js
Source: https://context7.com/buzz/mediainfo.js/llms.txt
Use isTrackType to narrow down track types for type-safe access to properties. Ensure mediainfo.js is initialized and data is analyzed before use.
```typescript
import mediaInfoFactory, { isTrackType } from 'mediainfo.js'
import type { MediaInfoResult, VideoTrack, AudioTrack, GeneralTrack } from 'mediainfo.js'
const mediainfo = await mediaInfoFactory()
const result = await mediainfo.analyzeData(size, readChunk)
if (result.media?.track) {
for (const track of result.media.track) {
if (isTrackType(track, 'General')) {
// track is now typed as GeneralTrack
console.log('File:', track.FileName)
console.log('Format:', track.Format)
console.log('Duration:', track.Duration_String)
console.log('Overall Bitrate:', track.OverallBitRate_String)
}
if (isTrackType(track, 'Video')) {
// track is now typed as VideoTrack
console.log('Video Codec:', track.Format)
console.log('Resolution:', `${track.Width}x${track.Height}`)
console.log('Frame Rate:', track.FrameRate_String)
console.log('Bit Depth:', track.BitDepth)
console.log('HDR Format:', track.HDR_Format)
console.log('Scan Type:', track.ScanType)
}
if (isTrackType(track, 'Audio')) {
// track is now typed as AudioTrack
console.log('Audio Codec:', track.Format)
console.log('Channels:', track.Channels_String)
console.log('Sample Rate:', track.SamplingRate_String)
console.log('Bit Rate:', track.BitRate_String)
console.log('Language:', track.Language_String)
}
if (isTrackType(track, 'Text')) {
// track is now typed as TextTrack
console.log('Subtitle Format:', track.Format)
console.log('Language:', track.Language_String)
}
}
}
mediainfo.close()
```
--------------------------------
### Configure Webpack Asset Filename
Source: https://github.com/buzz/mediainfo.js/blob/main/examples/webpack-react/README.md
Set `assetModuleFilename` in Webpack to preserve the original WASM filename.
```javascript
assetModuleFilename: '[name][ext]',
```
--------------------------------
### Override locateFile in React
Source: https://github.com/buzz/mediainfo.js/blob/main/examples/webpack-react/README.md
In React, override the `locateFile` function when initializing `mediaInfoFactory` to specify the WASM file location.
```typescript
locateFile: (filename) => filename,
```
=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.