### Install MediaInfo Dependencies on Fedora

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs MediaInfo dependencies on Fedora systems using dnf. This command ensures that zlib, curl, libzen, openssl, and libmms are installed.

```Shell
sudo dnf update
sudo dnf -y install zlib curl libzen openssl libmms
```

--------------------------------

### Install MediaInfo Dependencies on OpenSUSE

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs MediaInfo dependencies on OpenSUSE systems using zypper. This includes updating repositories and installing zlib, curl, libmms, openssl, and libnghttp2.

```Shell
sudo zypper refresh
sudo zypper update -y
sudo zypper install -y zlib curl libmms0 openssl libnghttp2-14
```

--------------------------------

### Install MediaInfo Dependencies on Ubuntu

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs required MediaInfo dependencies on Ubuntu systems using apt-get. This includes libraries like libzen, zlib, and curl.

```Shell
sudo apt-get update
sudo apt-get install libzen0v5 libmms0 zlib1g zlibc libnghttp2-14 librtmp1 curl libcurl4-gnutls-dev libglib2.0-dev
```

--------------------------------

### Install mp-mediainfo Dependencies in Docker (.NET 5.0)

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs required libraries for mp-mediainfo in a Docker container using the .NET 5.0 ASP.NET base image. The installation is performed using apt-get, including packages such as libzen0v5, libmms0, openssl, and curl.

```Dockerfile
FROM mcr.microsoft.com/dotnet/aspnet:5.0
RUN apt-get update && apt-get install -y libzen0v5 libmms0 openssl zlib1g zlibc libnghttp2-14 librtmp1 curl libcurl4-gnutls-dev libglib2.0
```

--------------------------------

### Install mp-mediainfo Dependencies on Debian

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs the necessary libraries for mp-mediainfo on Debian systems using the APT package manager. This command fetches and installs packages like libzen0v5, libmms0, openssl, zlib1g, and others required for media information processing.

```Shell
sudo apt-get update
sudo apt-get install libzen0v5 libmms0 openssl zlib1g zlibc libnghttp2-14 librtmp1 curl libcurl4-gnutls-dev libglib2.0
```

--------------------------------

### Install mp-mediainfo Dependencies in Docker (.NET Core 3.1)

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs essential libraries for mp-mediainfo within a Docker container based on the .NET Core 3.1 ASP.NET image. This command uses apt-get to install packages like libzen0v5, libmms0, openssl, and curl.

```Dockerfile
FROM mcr.microsoft.com/dotnet/aspnet:3.1
RUN apt-get update && apt-get install -y libzen0v5 libmms0 openssl zlib1g zlibc libnghttp2-14 librtmp1 curl libcurl4-gnutls-dev libglib2.0
```

--------------------------------

### Install mp-mediainfo Dependencies in Docker (.NET 6.0)

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs necessary libraries for mp-mediainfo within a Docker container based on the .NET 6.0 ASP.NET image. This command utilizes apt-get to install packages including libzen0v5, libmms0, openssl, and curl.

```Dockerfile
FROM mcr.microsoft.com/dotnet/aspnet:6.0
RUN apt-get update && apt-get install -y libzen0v5 libmms0 openssl zlib1g zlibc libnghttp2-14 librtmp1 curl libcurl4-gnutls-dev libglib2.0
```

--------------------------------

### Install mp-mediainfo Dependencies on ArchLinux

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs required packages for mp-mediainfo on ArchLinux using Pacman. This includes system updates and the installation of libraries such as libcurl-gnutls, libzen, libmms, libssh, and librtmp0.

```Shell
sudo pacman -Syu
sudo pacman -S libcurl-gnutls libzen libmms libssh librtmp0
```

--------------------------------

### Install MediaInfo Dependencies on CentOS 7

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs MediaInfo dependencies on CentOS 7 using yum and rpm. This includes enabling the EPEL repository and installing zlib, curl, libzen, and libmms.

```Shell
sudo rpm -ivh https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
sudo yum -y update
sudo yum -y install zlib curl libzen bzip2 libcurl
sudo rpm -ivh https://download1.rpmfusion.org/free/el/updates/7/x86_64/l/libmms-0.6.4-2.el7.x86_64.rpm
```

--------------------------------

### Install MP-MediaInfo .NET Core Package

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs the MP-MediaInfo.Wrapper.Core NuGet package for .NET Core projects. This package is designed for ASP.NET Core services.

```Shell
dotnet add package MediaInfo.Wrapper.Core --version 21.9.3
```

--------------------------------

### Install zlib, curl, and zenlib on MacOS

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs necessary dependencies (zlib, curl, zenlib) on MacOS using MacPorts. These libraries are required for the MediaInfo native packages.

```Shell
port install zlib curl zenlib
```

--------------------------------

### Install MP-MediaInfo .NET Framework Package

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs the MP-MediaInfo.Wrapper NuGet package for .NET Framework projects. This package is suitable for Windows-only applications not using .NET Core.

```PowerShell
Install-Package MediaInfo.Wrapper -Version 21.9.3
```

--------------------------------

### ASP.NET Core Web API for Media Analysis (C#)

Source: https://context7.com/yartat/mp-mediainfo/llms.txt

This C# code snippet demonstrates how to build an ASP.NET Core Web API controller to analyze media files. It uses the MediaInfoWrapper class to extract media information and returns it as a JSON response. The endpoint expects a JSON payload with a 'filePath' and returns a detailed MediaInfoResponse object. Ensure the MediaInfo native libraries are installed.

```csharp
using MediaInfo;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

[ApiController]
[Route("[controller]")]
public class MediaController : ControllerBase
{
    private readonly ILogger<MediaController> _logger;

    public MediaController(ILogger<MediaController> logger)
    {
        _logger = logger;
    }

    [HttpPost("analyze")]
    public ActionResult<MediaInfoResponse> AnalyzeMedia([FromBody] MediaInfoRequest request)
    {
        var media = new MediaInfoWrapper(request.FilePath, _logger);

        if (!media.Success)
        {
            return NotFound("Media file not found or could not be analyzed");
        }

        return Ok(new MediaInfoResponse
        {
            Format = media.Format,
            Duration = media.Duration,
            Size = media.Size,
            HasVideo = media.HasVideo,
            VideoCodec = media.VideoCodec,
            VideoResolution = media.VideoResolution,
            Width = media.Width,
            Height = media.Height,
            Framerate = media.Framerate,
            HasAudio = media.AudioStreams.Count > 0,
            AudioCodec = media.AudioCodec,
            AudioChannels = media.AudioChannelsFriendly,
            HasSubtitles = media.HasSubtitles,
            SubtitleCount = media.Subtitles.Count,
            Is3D = media.Is3D,
            IsHdr = media.IsHdr,
            IsDvd = media.IsDvd,
            IsBluRay = media.IsBluRay
        });
    }
}

// Request/Response DTOs
public class MediaInfoRequest
{
    public string FilePath { get; set; }
}

public class MediaInfoResponse
{
    public string Format { get; set; }
    public int Duration { get; set; }
    public long Size { get; set; }
    public bool HasVideo { get; set; }
    public string VideoCodec { get; set; }
    public string VideoResolution { get; set; }
    public int Width { get; set; }
    public int Height { get; set; }
    public double Framerate { get; set; }
    public bool HasAudio { get; set; }
    public string AudioCodec { get; set; }
    public string AudioChannels { get; set; }
    public bool HasSubtitles { get; set; }
    public int SubtitleCount { get; set; }
    public bool Is3D { get; set; }
    public bool IsHdr { get; set; }
    public bool IsDvd { get; set; }
    public bool IsBluRay { get; set; }
}
```

--------------------------------

### Install MediaInfo Dependencies on CentOS 8

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Installs MediaInfo dependencies on CentOS 8 using yum and rpm. This process is similar to CentOS 7, ensuring necessary libraries are present.

```Shell
sudo rpm -ivh https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm
sudo yum -y update
sudo yum -y install zlib curl libzen bzip2 libcurl
sudo rpm -ivh https://download1.rpmfusion.org/free/el/updates/8/x86_64/l/libmms-0.6.4-8.el8.x86_64.rpm
```

--------------------------------

### Direct Access to MediaInfo Library API (C#)

Source: https://context7.com/yartat/mp-mediainfo/llms.txt

The low-level `MediaInfo` class provides direct access to the MediaInfo library's API for advanced scenarios. It allows opening media files, retrieving comprehensive information in text format, and accessing specific properties by stream kind and parameter name. This method also supports getting stream counts and iterating through streams.

```csharp
using MediaInfo;

using (var mediaInfo = new MediaInfo())
{
    // Check if library loaded successfully
    if (mediaInfo.Handle == IntPtr.Zero)
    {
        Console.WriteLine("MediaInfo library not loaded");
        return;
    }

    // Get library version
    string version = mediaInfo.Option("Info_Version");
    Console.WriteLine($"MediaInfo Version: {version}");

    // Open a media file
    IntPtr handle = mediaInfo.Open("/path/to/video.mkv");
    if (handle != IntPtr.Zero)
    {
        // Get complete media information text
        string inform = mediaInfo.Inform();
        Console.WriteLine(inform);

        // Get specific properties by stream kind and parameter name
        string format = mediaInfo.Get(StreamKind.General, 0, "Format");
        string duration = mediaInfo.Get(StreamKind.General, 0, "Duration");
        string videoCodec = mediaInfo.Get(StreamKind.Video, 0, "Format");
        string videoWidth = mediaInfo.Get(StreamKind.Video, 0, "Width");
        string videoHeight = mediaInfo.Get(StreamKind.Video, 0, "Height");
        string audioCodec = mediaInfo.Get(StreamKind.Audio, 0, "Format");
        string audioChannels = mediaInfo.Get(StreamKind.Audio, 0, "Channel(s)");

        Console.WriteLine($"Format: {format}");
        Console.WriteLine($"Duration: {duration} ms");
        Console.WriteLine($"Video: {videoCodec} {videoWidth}x{videoHeight}");
        Console.WriteLine($"Audio: {audioCodec} {audioChannels}ch");

        // Get count of streams by type
        int videoCount = mediaInfo.CountGet(StreamKind.Video);
        int audioCount = mediaInfo.CountGet(StreamKind.Audio);
        int textCount = mediaInfo.CountGet(StreamKind.Text);

        Console.WriteLine($"Streams: {videoCount} video, {audioCount} audio, {textCount} text");

        // Get property by index (for enumeration)
        for (int i = 0; i < audioCount; i++)
        {
            string lang = mediaInfo.Get(StreamKind.Audio, i, "Language");
            string codec = mediaInfo.Get(StreamKind.Audio, i, "Format");
            Console.WriteLine($"Audio #{i}: {codec} ({lang})");
        }
    }
}

// Close is called automatically when disposed
```

--------------------------------

### Initialize and Use MediaInfoWrapper in C#

Source: https://github.com/yartat/mp-mediainfo/blob/master/README.md

Demonstrates how to instantiate the MediaInfoWrapper class with a media file path and access its properties to retrieve media information. It includes a check for successful parsing.

```C#
using MediaInfo;

// ...

var media = new MediaInfoWrapper(mediaFileLocation);

if (media.Success)
{
    var containerFormat = media.Format;
    var mediaHasVideo = media.HasVideo;
    var videoBitRate = media.VideoRate;
    foreach (var stream in media.AudioStreams)
    {
        var codec = stream.Codec;
    }
}
```

--------------------------------

### Analyze Media with Logging Support (C#)

Source: https://context7.com/yartat/mp-mediainfo/llms.txt

Demonstrates how to initialize MediaInfoWrapper with an ILogger for diagnostic output. This is useful for debugging media analysis processes. It shows how to write detailed media info to logs and access the raw text output.

```csharp
using MediaInfo;
using Microsoft.Extensions.Logging;

// Create with a logger (ILogger from Microsoft.Extensions.Logging)
ILogger logger = loggerFactory.CreateLogger<MyClass>();
var media = new MediaInfoWrapper("/path/to/video.mp4", logger);

if (media.Success)
{
    // Write detailed media info to logs
    media.WriteInfo();

    // Access the raw MediaInfo text output
    Console.WriteLine(media.Text);
}

// Log output includes:
// Inspecting media    : /path/to/video.mp4
// Library version      : MediaInfoLib - v21.09
// Media duration      : 01:30:00
// Has audio           : True
// Has video           : True
// Has subtitles       : False
// Video duration      : 01:30:00
// Video frame rate    : 29.97
// Video width         : 1920
// Video height        : 1080
// Video codec         : AVC
// Audio duration      : 01:30:00
// Audio rate          : 192000
// Audio channels      : 5.1
// Audio codec         : AAC
```

--------------------------------

### Analyze Media File Path with MediaInfoWrapper in C#

Source: https://context7.com/yartat/mp-mediainfo/llms.txt

This C# code snippet demonstrates how to use the `MediaInfoWrapper` class to analyze a media file from its path. It shows how to instantiate the wrapper, check for analysis success, and access general, video, audio, subtitle, and disc properties.

```csharp
using MediaInfo;
using MediaInfo.Model;

// Analyze a video file
var media = new MediaInfoWrapper("/path/to/video.mkv");

// Check if analysis was successful
if (media.Success)
{
    // General media properties
    Console.WriteLine($"Format: {media.Format}");
    Console.WriteLine($"Duration: {TimeSpan.FromMilliseconds(media.Duration)}");
    Console.WriteLine($"File Size: {media.Size} bytes");
    Console.WriteLine($"Is Streamable: {media.IsStreamable}");

    // Video properties
    if (media.HasVideo)
    {
        Console.WriteLine($"Video Codec: {media.VideoCodec}");
        Console.WriteLine($"Resolution: {media.Width}x{media.Height} ({media.VideoResolution})");
        Console.WriteLine($"Frame Rate: {media.Framerate} fps");
        Console.WriteLine($"Video Bitrate: {media.VideoRate} bps");
        Console.WriteLine($"Aspect Ratio: {media.AspectRatio}");
        Console.WriteLine($"Is Interlaced: {media.IsInterlaced}");
        Console.WriteLine($"Is 3D: {media.Is3D}");
        Console.WriteLine($"Is HDR: {media.IsHdr}");
    }

    // Audio properties
    Console.WriteLine($"Audio Streams: {media.AudioStreams.Count}");
    Console.WriteLine($"Audio Codec: {media.AudioCodec}");
    Console.WriteLine($"Audio Channels: {media.AudioChannelsFriendly}");
    Console.WriteLine($"Audio Bitrate: {media.AudioRate} bps");
    Console.WriteLine($"Audio Sample Rate: {media.AudioSampleRate} Hz");

    // Subtitle and chapter info
    Console.WriteLine($"Has Subtitles: {media.HasSubtitles}");
    Console.WriteLine($"Has External Subtitles: {media.HasExternalSubtitles}");
    Console.WriteLine($"Has Chapters: {media.HasChapters}");

    // Disc detection
    Console.WriteLine($"Is DVD: {media.IsDvd}");
    Console.WriteLine($"Is Blu-Ray: {media.IsBluRay}");
}

```

--------------------------------

### Analyze Media from Stream (C#)

Source: https://context7.com/yartat/mp-mediainfo/llms.txt

Shows how to use MediaInfoWrapper to analyze media directly from a Stream object, such as a file stream or memory stream. This avoids the need to write media to disk. It demonstrates accessing basic media properties like format and stream counts.

```csharp
using MediaInfo;
using System.IO;

// Analyze media from a file stream
using (var fileStream = File.OpenRead("/path/to/video.mkv"))
{
    var media = new MediaInfoWrapper(fileStream);

    if (media.Success)
    {
        Console.WriteLine($"Format: {media.Format}");
        Console.WriteLine($"Video Streams: {media.VideoStreams.Count}");
        Console.WriteLine($"Audio Streams: {media.AudioStreams.Count}");

        foreach (var video in media.VideoStreams)
        {
            Console.WriteLine($"  Video: {video.CodecName} {video.Width}x{video.Height}");
        }
    }
}

// Works with any seekable stream (memory, network, etc.)
using (var memoryStream = new MemoryStream(mediaBytes))
{
    var media = new MediaInfoWrapper(memoryStream, logger); // Assuming logger is defined
    // Process media info...
}
```

--------------------------------

### Access Chapter Information in C#

Source: https://context7.com/yartat/mp-mediainfo/llms.txt

This C# code snippet demonstrates how to access chapter information from a media file using the MediaInfoWrapper. It checks if the media file contains chapters and then iterates through each chapter to display its stream number, name, description, and offset. This requires the MediaInfo and MediaInfo.Model namespaces.

```csharp
using MediaInfo;
using MediaInfo.Model;

var media = new MediaInfoWrapper("/path/to/movie.mkv");

if (media.HasChapters)
{
    Console.WriteLine($"Total Chapters: {media.Chapters.Count}");

    foreach (ChapterStream chapter in media.Chapters)
    {
        Console.WriteLine($"Chapter #{chapter.StreamNumber}:");
        Console.WriteLine($"  Name: {chapter.Name}");
        Console.WriteLine($"  Description: {chapter.Description}");
        Console.WriteLine($"  Offset: {TimeSpan.FromMilliseconds(chapter.Offset)}");
    }
}
```

--------------------------------

### Access Audio Stream Details in C#

Source: https://context7.com/yartat/mp-mediainfo/llms.txt

This C# code snippet demonstrates how to use the MediaInfoWrapper to access detailed information about audio streams within a media file. It covers retrieving the best audio stream and iterating through all available audio streams to display properties like codec, channels, bitrate, language, and embedded tags. This requires the MediaInfo and MediaInfo.Model namespaces.

```csharp
using MediaInfo;
using MediaInfo.Model;

var media = new MediaInfoWrapper("/path/to/movie.mkv");

if (media.AudioStreams.Count > 0)
{
    // Access the best quality audio stream
    AudioStream best = media.BestAudioStream;
    Console.WriteLine($"Best Audio: {best.CodecFriendly} {best.AudioChannelsFriendly}");

    // Iterate through all audio streams
    foreach (AudioStream audio in media.AudioStreams)
    {
        Console.WriteLine($"Audio Stream #{audio.StreamNumber}:");
        Console.WriteLine($"  Codec: {audio.Codec}");
        Console.WriteLine($"  Codec Name: {audio.CodecName}");
        Console.WriteLine($"  Codec Friendly: {audio.CodecFriendly}"); // "Dolby TrueHD", "DTS-HD", etc.
        Console.WriteLine($"  Format: {audio.Format}");
        Console.WriteLine($"  Channels: {audio.Channel} ({audio.AudioChannelsFriendly})");
        Console.WriteLine($"  Bitrate: {audio.Bitrate} bps");
        Console.WriteLine($"  Bitrate Mode: {audio.BitrateMode}"); // CBR, VBR
        Console.WriteLine($"  Sampling Rate: {audio.SamplingRate} Hz");
        Console.WriteLine($"  Bit Depth: {audio.BitDepth} bits");
        Console.WriteLine($"  Duration: {audio.Duration}");
        Console.WriteLine($"  Language: {audio.Language}");
        Console.WriteLine($"  Stream Size: {audio.StreamSize} bytes");

        // Audio tags (for music files)
        if (audio.Tags != null)
        {
            Console.WriteLine($"  Album: {audio.Tags.Album}");
            Console.WriteLine($"  Track: {audio.Tags.Track}");
            Console.WriteLine($"  Artist: {audio.Tags.Artist}");
        }
    }
}
```

--------------------------------

### Access Video Stream Details (C#)

Source: https://context7.com/yartat/mp-mediainfo/llms.txt

Explains how to access detailed information about video streams within a media file using the `VideoStreams` collection and the `BestVideoStream` property. It covers properties like codec, resolution, frame rate, bit depth, HDR metadata, and stereoscopic mode.

```csharp
using MediaInfo;
using MediaInfo.Model;

var media = new MediaInfoWrapper("/path/to/4k-hdr-video.mkv");

if (media.HasVideo)
{
    // Access the best quality video stream (automatically selected)
    VideoStream best = media.BestVideoStream;
    Console.WriteLine($"Best Video: {best.CodecName} {best.Resolution}");

    // Iterate through all video streams
    foreach (VideoStream video in media.VideoStreams)
    {
        Console.WriteLine($"Stream #{video.StreamNumber}:");
        Console.WriteLine($"  Codec: {video.Codec} ({video.CodecName})");
        Console.WriteLine($"  Profile: {video.CodecProfile}");
        Console.WriteLine($"  Format: {video.Format}");
        Console.WriteLine($"  Resolution: {video.Width}x{video.Height} ({video.Resolution})");
        Console.WriteLine($"  Frame Rate: {video.FrameRate} fps ({video.FrameRateMode})");
        Console.WriteLine($"  Bitrate: {video.Bitrate} bps");
        Console.WriteLine($"  Bit Depth: {video.BitDepth} bits");
        Console.WriteLine($"  Duration: {video.Duration}");
        Console.WriteLine($"  Aspect Ratio: {video.AspectRatio}");
        Console.WriteLine($"  Interlaced: {video.Interlaced}");
        Console.WriteLine($"  Standard: {video.Standard}"); // PAL/NTSC

        // HDR information
        Console.WriteLine($"  HDR Type: {video.Hdr}"); // None, HDR10, DolbyVision, HLG
        Console.WriteLine($"  Color Space: {video.ColorSpace}"); // BT709, BT2020, etc.
        Console.WriteLine($"  Transfer Characteristics: {video.TransferCharacteristics}");
        Console.WriteLine($"  Chroma Subsampling: {video.SubSampling}"); // 4:2:0, 4:2:2, etc.

        // 3D stereoscopic mode
        Console.WriteLine($"  Stereoscopic: {video.Stereoscopic}"); // Mono, Stereo, SideBySide, TopBottom

        // Video tags
        if (video.Tags != null)
        {
            Console.WriteLine($"  Encoded Library: {video.Tags.EncodedLibrary}");
        }
    }
}

// Example output for 4K HDR content:
// Best Video: HEVC 2160P
// Stream #0:
//   Codec: MpeghIsoHevc (HEVC)
//   Profile: Main 10
//   Format: HEVC
//   Resolution: 3840x2160 (2160P)
//   Frame Rate: 23.976 fps (Constant)
//   Bitrate: 50000000 bps
//   Bit Depth: 10 bits
//   Duration: 02:15:30
//   Aspect Ratio: Ratio16X9
//   Interlaced: False
//   Standard: NTSC
//   HDR Type: HDR10
//   Color Space: BT2020
//   Transfer Characteristics: PQ
//   Chroma Subsampling: Sampling420
//   Stereoscopic: Mono
```

--------------------------------

### Access Audio Metadata Tags with AudioTags Class (C#)

Source: https://context7.com/yartat/mp-mediainfo/llms.txt

The `AudioTags` class allows easy access to common metadata tags embedded in audio files such as ID3 and Vorbis comments. It simplifies retrieving track, album, artist, genre, and other relevant information. This class is part of the MediaInfo library and requires a `MediaInfoWrapper` instance.

```csharp
using MediaInfo;
using MediaInfo.Model;

var media = new MediaInfoWrapper("/path/to/music.mp3");

if (media.Success)
{
    AudioTags tags = media.Tags;

    // Basic track information
    Console.WriteLine($"Track: {tags.Track}");
    Console.WriteLine($"Album: {tags.Album}");
    Console.WriteLine($"Artist: {tags.Artist}");
    Console.WriteLine($"Album Artist: {tags.AlbumArtist}");
    Console.WriteLine($"Genre: {tags.Genre}");
    Console.WriteLine($"Mood: {tags.Mood}");

    // Track positioning
    Console.WriteLine($"Track #: {tags.TrackPosition} of {tags.TotalTracks}");
    Console.WriteLine($"Disc #: {tags.DiscNumber} of {tags.TotalDiscs}");

    // Credits
    Console.WriteLine($"Composer: {tags.Composer}");
    Console.WriteLine($"Conductor: {tags.Conductor}");
    Console.WriteLine($"Lyricist: {tags.Lyricist}");
    Console.WriteLine($"Arranger: {tags.Arranger}");
    Console.WriteLine($"Remixed By: {tags.RemixedBy}");
    Console.WriteLine($"Mastered By: {tags.MasteredBy}");

    // Recording info
    Console.WriteLine($"Recorded Date: {tags.RecordedDate}");
    Console.WriteLine($"Encoded By: {tags.EncodedBy}");
    Console.WriteLine($"Label: {tags.Label}");

    // Identifiers
    Console.WriteLine($"ISRC: {tags.Isrc}");
    Console.WriteLine($"Bar Code: {tags.BarCode}");
    Console.WriteLine($"Catalog Number: {tags.CatalogNumber}");

    // Original release info
    Console.WriteLine($"Original Album: {tags.OriginalAlbum}");
    Console.WriteLine($"Original Track: {tags.OriginalTrack}");

    // Encoding dates
    Console.WriteLine($"Encoded Date: {tags.EncodedDate}");
    Console.WriteLine($"Tagged Date: {tags.TaggedDate}");
}

// Example output for an MP3 file:
// Track: Bohemian Rhapsody
// Album: A Night at the Opera
// Artist: Queen
// Album Artist: Queen
// Genre: Rock
// Track #: 11 of 12
// Disc #: 1 of 1
// Composer: Freddie Mercury
// Recorded Date: 1975-10-31
// Label: EMI
```

--------------------------------

### Access Subtitle Stream Details in C#

Source: https://context7.com/yartat/mp-mediainfo/llms.txt

This C# code snippet shows how to retrieve information about subtitle streams embedded within a media file using the MediaInfoWrapper. It checks for the presence of subtitles and iterates through each subtitle stream to display its format, codec, language, name, and default/forced flags. This functionality requires the MediaInfo and MediaInfo.Model namespaces.

```csharp
using MediaInfo;
using MediaInfo.Model;

var media = new MediaInfoWrapper("/path/to/movie.mkv");

if (media.HasSubtitles)
{
    Console.WriteLine($"Total Subtitles: {media.Subtitles.Count}");
    Console.WriteLine($"Has External Subtitles: {media.HasExternalSubtitles}");

    foreach (SubtitleStream subtitle in media.Subtitles)
    {
        Console.WriteLine($"Subtitle #{subtitle.StreamNumber}:");
        Console.WriteLine($"  Format: {subtitle.Format}");
        Console.WriteLine($"  Codec: {subtitle.Codec}"); // SRT, ASS, PGS, VobSub, etc.
        Console.WriteLine($"  Language: {subtitle.Language}");
        Console.WriteLine($"  Name: {subtitle.Name}");
        Console.WriteLine($"  Default: {subtitle.Default}");
        Console.WriteLine($"  Forced: {subtitle.Forced}");
    }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.