M3U8Parser

https://github.com/xavierlaffargue/m3u8parser-csharp
Admin
M3U8Parser is a C# library for reading, editing, and creating M3U8/HLS playlist files for video...
Tokens:9,708
Snippets:46
Trust Score:7.1
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Generated Master Playlist Output

Source: https://github.com/xavierlaffargue/m3u8parser-csharp/blob/main/README.md

This is the expected output of the master playlist created in the previous example.

```m3u8
#EXTM3U
#EXT-X-VERSION:4

#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="English",LANGUAGE="eng",AUTOSELECT=YES,DEFAULT=YES
#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="English DV",LANGUAGE="eng",AUTOSELECT=YES,DEFAULT=NO,CHARACTERISTICS="public.accessibility.describes-video"

#EXT-X-STREAM-INF:BANDWIDTH=900000,CODECS="avc1.4d401f,mp4a.40.2"
v0.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1000000,CODECS="avc1.4d401f,mp4a.40.2"
v1.m3u8
```

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

### Create a New M3U8 Master Playlist

Source: https://github.com/xavierlaffargue/m3u8parser-csharp/blob/main/README.md

Shows how to programmatically create a new master m3u8 playlist, add audio media entries with specific attributes, and define stream information.

```csharp
    var masterPlaylist = new MasterPlaylist(hlsVersion: 4);

    // Add EXT-X-MEDIA
    masterPlaylist.Medias.Add(new Media
    {
        Default = true,
        AutoSelect = true,
        Language = "eng",
        Name = "English",
        Type = MediaType.Audio,
        GroupId = "audio"
    });

    // Add another EXT-X-MEDIA but from text, yes it works!

    var mediaWithDv = new Media("#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID=\"audio\",NAME=\"English DV\",LANGUAGE=\"eng\",AUTOSELECT=YES,DEFAULT=NO");
    mediaWithDv.Characteristics = "public.accessibility.describes-video";

    masterPlaylist.Medias.Add(mediaWithDv);

    // Add EXT-X-STREAM
    masterPlaylist.Stream.Add(new StreamInf() 
    {
        Codecs = "avc1.4d401f,mp4a.40.2",
        Bandwidth = 900000,
        Uri = "v0.m3u8"
    });
    
    masterPlaylist.Stream.Add(new StreamInf() 
    {
        Codecs = "avc1.4d401f,mp4a.40.2",
        Bandwidth = 1000000,
        Uri = "v1.m3u8"
    });
```

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

### Parse and Build EXT-X-KEY Tags

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Demonstrates parsing raw EXT-X-KEY tag strings and programmatically building Key objects for different encryption methods (AES-128, SAMPLE-AES, None).

```csharp
using M3U8Parser.Attributes.ValueType;
using M3U8Parser.Tags.MediaSegment;

// Parse from a raw tag string
var key = new Key("#EXT-X-KEY:METHOD=AES-128,URI=\"https://keys.example.com/key\"");
Console.WriteLine(key.Method); // AES-128
Console.WriteLine(key.Uri);    // https://keys.example.com/key

// Build programmatically
var sampleAes = new Key
{
    Method = MethodType.SAMPLE_AES,
    Uri    = "skd://com.example.fairplay/content-id"
};
Console.WriteLine(sampleAes.ToString());
// #EXT-X-KEY:METHOD=SAMPLE-AES,URI="skd://com.example.fairplay/content-id"

// No encryption
var noneKey = new Key { Method = MethodType.None };
Console.WriteLine(noneKey.Method); // NONE
```

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

### Handle Individual Media Segment

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Demonstrates parsing an individual media segment from its `#EXTINF` and URI lines, and constructing a byte-range segment with optional properties like `ProgramDateTime` and `#EXT-X-BYTERANGE`.

```csharp
using M3U8Parser.Tags.MediaSegment;

// Parse a segment block (EXTINF line + URI line)
var seg = new Segment("#EXTINF:10.005,\nmediaFileSample.aac");
Console.WriteLine(seg.Duration); // 10.005
Console.WriteLine(seg.Uri);      // mediaFileSample.aac

// Build a byte-range segment
var brseg = new Segment
{
    Duration              = 6.0,
    Uri                   = "video.mp4",
    ByteRangeLentgh       = 1048576,
    ByteRangeStartSubRange = 0,
    ProgramDateTime       = "2024-01-15T00:00:00.000Z"
};

Console.WriteLine(brseg.ToString());
```

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

### MasterPlaylist - Create and Serialize

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Demonstrates how to programmatically create a MasterPlaylist object by instantiating tag objects and then serialize it to a valid M3U8 string using the ToString() method.

```APIDOC
## MasterPlaylist — Create and Serialize

Construct a `MasterPlaylist` programmatically by instantiating tag objects and calling `ToString()` to produce valid M3U8 output.

```csharp
using M3U8Parser;
using M3U8Parser.Attributes.ValueType;
using M3U8Parser.Tags.MultivariantPlaylist;

var master = new MasterPlaylist(hlsVersion: 4);

// Add audio renditions
master.Medias.Add(new Media
{
    Default    = true,
    AutoSelect = true,
    Language   = "eng",
    Name       = "English",
    Type       = MediaType.Audio,
    GroupId    = "audio"
});

// Parse a rendition directly from a raw tag string
var dvMedia = new Media(
    "#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID=\"audio\",NAME=\"English DV\",LANGUAGE=\"eng\",AUTOSELECT=YES,DEFAULT=NO");
dvMedia.Characteristics = "public.accessibility.describes-video";
master.Medias.Add(dvMedia);

// Add stream variants
master.Streams.Add(new StreamInf
{
    Bandwidth = 900000,
    Codecs    = "avc1.4d401f,mp4a.40.2",
    Audio     = "audio",
    Uri       = "v0.m3u8"
});
master.Streams.Add(new StreamInf
{
    Bandwidth        = 1800000,
    AverageBandwidth = 1600000,
    Codecs           = "avc1.4d401f,mp4a.40.2",
    Resolution       = new ResolutionType { Width = 1280, Height = 720 },
    FrameRate        = 29.97m,
    Audio            = "audio",
    Uri              = "v1.m3u8"
});

// Add I-frame stream
master.IFrameStreams.Add(new IframeStreamInf
{
    Bandwidth  = 621335,
    Codecs     = "avc1.42c00d",
    Resolution = new ResolutionType { Width = 416, Height = 234 },
    Uri        = "iframe.m3u8"
});

string output = master.ToString();
Console.WriteLine(output);
/* Output:
#EXTM3U
#EXT-X-VERSION:4

#EXT-X-MEDIA:AUTOSELECT=YES,DEFAULT=YES,GROUP-ID="audio",LANGUAGE="eng",TYPE=AUDIO,NAME="English"
#EXT-X-MEDIA:AUTOSELECT=YES,DEFAULT=NO,GROUP-ID="audio",LANGUAGE="eng",TYPE=AUDIO,NAME="English DV",CHARACTERISTICS="public.accessibility.describes-video"

#EXT-X-I-FRAME-STREAM-INF:BANDWIDTH=621335,CODECS="avc1.42c00d",RESOLUTION=416x234,URI="iframe.m3u8"

#EXT-X-STREAM-INF:BANDWIDTH=900000,CODECS="avc1.4d401f,mp4a.40.2",AUDIO="audio"
v0.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1800000,AVERAGE-BANDWIDTH=1600000,CODECS="avc1.4d401f,mp4a.40.2",RESOLUTION=1280x720,FRAME-RATE=29.97,AUDIO="audio"
v1.m3u8
*/
```
```

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

### MediaPlaylist - Load from File

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Shows how to load and parse a media playlist from a file using `MediaPlaylist.LoadFromFile()`. It details how to access playlist properties and iterate through media segments, including encrypted ones.

```APIDOC
## MediaPlaylist — Load from File

`MediaPlaylist.LoadFromFile(string path)` reads a media segment playlist from disk. Parses `PlaylistType` (VOD/EVENT), `TargetDuration`, `MediaSequence`, `HlsVersion`, `Map`, `IFrameOnly`, and all `MediaSegment` groups (each group sharing a common `EXT-X-KEY` encryption context).

```csharp
using M3U8Parser;
using M3U8Parser.Attributes.ValueType;

var media = MediaPlaylist.LoadFromFile("mediaplaylist.m3u8");

Console.WriteLine($"Type: {media.PlaylistType}");           // VOD
Console.WriteLine($"Version: {media.HlsVersion}");          // 4
Console.WriteLine($"TargetDuration: {media.TargetDuration}"); // 10
Console.WriteLine($"MediaSequence: {media.MediaSequence}"); // 0
Console.WriteLine($"HasEndList: {media.HasEndList}");        // True
Console.WriteLine($"IFrameOnly: {media.IFrameOnly}");        // True
Console.WriteLine($"Map URI: {media.Map?.Uri}");             // main.mp4

// Iterate segments
foreach (var group in media.MediaSegments)
{
    if (group.Key != null)
        Console.WriteLine($"  Key: Method={group.Key.Method} URI={group.Key.Uri}");

    foreach (var segment in group.Segments)
    {
        Console.WriteLine($"  Segment: Duration={segment.Duration}s URI={segment.Uri}");
        if (segment.ByteRangeLentgh.HasValue)
            Console.WriteLine($"    ByteRange: {segment.ByteRangeLentgh}@{segment.ByteRangeStartSubRange}");
    }
}
```
```

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

### Create and Serialize MasterPlaylist

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Construct a MasterPlaylist programmatically by instantiating tag objects and calling ToString() to produce valid M3U8 output. Ensure all necessary media and stream variants are added before serialization.

```csharp
using M3U8Parser;
using M3U8Parser.Attributes.ValueType;
using M3U8Parser.Tags.MultivariantPlaylist;

var master = new MasterPlaylist(hlsVersion: 4);

// Add audio renditions
master.Medias.Add(new Media
{
    Default    = true,
    AutoSelect = true,
    Language   = "eng",
    Name       = "English",
    Type       = MediaType.Audio,
    GroupId    = "audio"
});

// Parse a rendition directly from a raw tag string
var dvMedia = new Media(
    "#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID=\"audio\",NAME=\"English DV\",LANGUAGE=\"eng\",AUTOSELECT=YES,DEFAULT=NO");
dvMedia.Characteristics = "public.accessibility.describes-video";
master.Medias.Add(dvMedia);

// Add stream variants
master.Streams.Add(new StreamInf
{
    Bandwidth = 900000,
    Codecs    = "avc1.4d401f,mp4a.40.2",
    Audio     = "audio",
    Uri       = "v0.m3u8"
});
master.Streams.Add(new StreamInf
{
    Bandwidth        = 1800000,
    AverageBandwidth = 1600000,
    Codecs           = "avc1.4d401f,mp4a.40.2",
    Resolution       = new ResolutionType { Width = 1280, Height = 720 },
    FrameRate        = 29.97m,
    Audio            = "audio",
    Uri              = "v1.m3u8"
});

// Add I-frame stream
master.IFrameStreams.Add(new IframeStreamInf
{
    Bandwidth  = 621335,
    Codecs     = "avc1.42c00d",
    Resolution = new ResolutionType { Width = 416, Height = 234 },
    Uri        = "iframe.m3u8"
});

string output = master.ToString();
Console.WriteLine(output);
/* Output:
#EXTM3U
#EXT-X-VERSION:4

#EXT-X-MEDIA:AUTOSELECT=YES,DEFAULT=YES,GROUP-ID="audio",LANGUAGE="eng",TYPE=AUDIO,NAME="English"
#EXT-X-MEDIA:AUTOSELECT=YES,DEFAULT=NO,GROUP-ID="audio",LANGUAGE="eng",TYPE=AUDIO,NAME="English DV",CHARACTERISTICS="public.accessibility.describes-video"

#EXT-X-I-FRAME-STREAM-INF:BANDWIDTH=621335,CODECS="avc1.42c00d",RESOLUTION=416x234,URI="iframe.m3u8"

#EXT-X-STREAM-INF:BANDWIDTH=900000,CODECS="avc1.4d401f,mp4a.40.2",AUDIO="audio"
v0.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1800000,AVERAGE-BANDWIDTH=1600000,CODECS="avc1.4d401f,mp4a.40.2",RESOLUTION=1280x720,FRAME-RATE=29.97,AUDIO="audio"
v1.m3u8
*/
```

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

### Create Media Playlist with AES-128 Encryption

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Programmatically constructs a VOD `MediaPlaylist` with multiple `MediaSegment` groups, each having its own AES-128 encryption context and byte-range-addressed segments. Shows how to set playlist properties and add segments.

```csharp
using M3U8Parser;
using M3U8Parser.Attributes.ValueType;
using M3U8Parser.Tags.MediaSegment;
using System.Collections.Generic;

var playlist = new MediaPlaylist
{
    HlsVersion     = 7,
    PlaylistType   = PlaylistType.Vod,
    TargetDuration = 10,
    MediaSequence  = 0,
    HasEndList     = true,
    IFrameOnly     = false
};

// First key group
playlist.MediaSegments.Add(new MediaSegment
{
    Key = new Key { Method = MethodType.AES_128, Uri = "https://keys.example.com/key1" },
    Segments = new List<Segment>
    {
        new() { Duration = 10.0, Uri = "https://cdn.example.com/seg1.ts" },
        new() { Duration = 10.0, Uri = "https://cdn.example.com/seg2.ts" }
    }
});

// Second key group with a different key
playlist.MediaSegments.Add(new MediaSegment
{
    Key = new Key { Method = MethodType.AES_128, Uri = "https://keys.example.com/key2" },
    Segments = new List<Segment>
    {
        new() { Duration = 10.0, Uri = "https://cdn.example.com/seg3.ts" },
        new() { Duration =  9.5, Uri = "https://cdn.example.com/seg4.ts" }
    }
});

Console.WriteLine(playlist.ToString());
```

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

### Parse and Assign EXT-X-MAP Tags

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Shows how to parse raw EXT-X-MAP tag strings, including those with byte ranges, and how to assign a Map object to a MediaPlaylist.

```csharp
using M3U8Parser.Tags.MediaSegment;

// Parse from raw tag
var map = new Map("#EXT-X-MAP:URI=\"init.mp4\"");
Console.WriteLine(map.Uri);       // init.mp4
Console.WriteLine(map.ByteRange); // (null)

// With byte range
var mapBr = new Map("#EXT-X-MAP:URI=\"main.mp4\",BYTERANGE=\"512@0\"");
Console.WriteLine(mapBr.Uri);       // main.mp4
Console.WriteLine(mapBr.ByteRange); // 512@0

// Assign map to a MediaPlaylist
var playlist = MediaPlaylist.LoadFromFile("media.m3u8");
playlist.Map = new Map { Uri = "new_init.mp4" };
Console.WriteLine(playlist.Map.Uri); // new_init.mp4
```

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

### MediaPlaylist - Create with AES-128 Encryption

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Demonstrates how to programmatically construct a VOD `MediaPlaylist` with multiple `MediaSegment` groups, each configured with its own AES-128 encryption context and byte-range-addressed segments.

```APIDOC
## MediaPlaylist — Create with AES-128 Encryption

Construct a VOD `MediaPlaylist` programmatically with multiple `MediaSegment` groups, each carrying its own `EXT-X-KEY` encryption context and byte-range-addressed segments.

```csharp
using M3U8Parser;
using M3U8Parser.Attributes.ValueType;
using M3U8Parser.Tags.MediaSegment;
using System.Collections.Generic;

var playlist = new MediaPlaylist
{
    HlsVersion     = 7,
    PlaylistType   = PlaylistType.Vod,
    TargetDuration = 10,
    MediaSequence  = 0,
    HasEndList     = true,
    IFrameOnly     = false
};

// First key group
playlist.MediaSegments.Add(new MediaSegment
{
    Key = new Key { Method = MethodType.AES_128, Uri = "https://keys.example.com/key1" },
    Segments = new List<Segment>
    {
        new() { Duration = 10.0, Uri = "https://cdn.example.com/seg1.ts" },
        new() { Duration = 10.0, Uri = "https://cdn.example.com/seg2.ts" }
    }
});

// Second key group with a different key
playlist.MediaSegments.Add(new MediaSegment
{
    Key = new Key { Method = MethodType.AES_128, Uri = "https://keys.example.com/key2" },
    Segments = new List<Segment>
    {
        new() { Duration = 10.0, Uri = "https://cdn.example.com/seg3.ts" },
        new() { Duration =  9.5, Uri = "https://cdn.example.com/seg4.ts" }
    }
});

Console.WriteLine(playlist.ToString());
/* Output:
#EXTM3U
#EXT-X-VERSION:7
#EXT-X-TARGETDURATION:10
#EXT-X-MEDIA-SEQUENCE:0
#EXT-X-PLAYLIST-TYPE:VOD

#EXT-X-KEY:METHOD=AES-128,URI="https://keys.example.com/key1"
#EXTINF:10,
https://cdn.example.com/seg1.ts
#EXTINF:10,
https://cdn.example.com/seg2.ts

#EXT-X-KEY:METHOD=AES-128,URI="https://keys.example.com/key2"
#EXTINF:10,
https://cdn.example.com/seg3.ts
#EXTINF:9.5,
https://cdn.example.com/seg4.ts
#EXT-X-ENDLIST
*/
```
```

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

### Using M3U8Parser Value Types

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Illustrates the usage of static-factory enum-like types (MediaType, MethodType, PlaylistType, VideoRangeType) for attribute values, enabling comparison and serialization.

```csharp
using M3U8Parser.Attributes.ValueType;

// MediaType values: Audio, Video, Subtitles, CloseCaptions
var t = MediaType.Audio;
Console.WriteLine(t);                                // AUDIO
Console.WriteLine(t.Equals(MediaType.Audio));        // True
Console.WriteLine(t.Equals(MediaType.CloseCaptions));// False

// MethodType values: None, AES_128, SAMPLE_AES
var m = MethodType.AES_128;
Console.WriteLine(m);                          // AES-128
Console.WriteLine(m.Equals(MethodType.None));  // False

// PlaylistType values: Vod, Event
var p = PlaylistType.Vod;
Console.WriteLine(p);                           // VOD
Console.WriteLine(p.Equals(PlaylistType.Event));// False

// HdcpLevelType and VideoRangeType follow the same pattern
var vr = VideoRangeType.PQ;
Console.WriteLine(vr); // PQ
```

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

### Parse and Build Media Tags

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Represents an #EXT-X-MEDIA tag, supporting Audio, Video, Subtitles, and ClosedCaptions media types. Can be parsed from a raw tag string or constructed from scratch.

```csharp
using M3U8Parser.Attributes.ValueType;
using M3U8Parser.Tags.MultivariantPlaylist;

// Parse a CLOSED-CAPTIONS rendition
var cc = new Media(
    "#EXT-X-MEDIA:TYPE=CLOSED-CAPTIONS,GROUP-ID=\"cc\",NAME=\"CEA608_CC\",
```

```csharp
    "AUTOSELECT=NO,DEFAULT=NO,INSTREAM-ID=\"CC1\"");

Console.WriteLine(cc.Type);       // CLOSED-CAPTIONS
Console.WriteLine(cc.GroupId);    // cc
Console.WriteLine(cc.Name);       // CEA608_CC
Console.WriteLine(cc.AutoSelect); // False
Console.WriteLine(cc.InstreamId); // CC1
Console.WriteLine(cc.Language);   // (null)
```

```csharp
// Build an audio rendition and modify it
var audio = new Media
{
    Type       = MediaType.Audio,
    GroupId    = "audio",
    Name       = "French",
    Language   = "fre",
    AutoSelect = true,
    Default    = false,
    Uri        = "audio_fre.m3u8"
};
audio.Channels = "2";

Console.WriteLine(audio.ToString());
// #EXT-X-MEDIA:AUTOSELECT=YES,DEFAULT=NO,GROUP-ID="audio",LANGUAGE="fre",TYPE=AUDIO,NAME="French",URI="audio_fre.m3u8",CHANNELS="2"
```

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

### Load MasterPlaylist from File in C#

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Load a multivariant playlist from disk using MasterPlaylist.LoadFromFile. This method parses the file into strongly-typed objects. Ensure the file exists to avoid FileNotFoundException.

```csharp
using M3U8Parser;
using M3U8Parser.Attributes.ValueType;

// Load a multivariant playlist from disk
var master = MasterPlaylist.LoadFromFile("master.m3u8");

Console.WriteLine($"HLS Version: {master.HlsVersion}");          // e.g. 7
Console.WriteLine($"Media renditions: {master.Medias.Count}");   // e.g. 5
Console.WriteLine($"Streams: {master.Streams.Count}");           // e.g. 7
Console.WriteLine($"I-Frame streams: {master.IFrameStreams.Count}"); // e.g. 6

// Enumerate all stream variants
foreach (var stream in master.Streams)
{
    Console.WriteLine($"  Bandwidth={stream.Bandwidth} Resolution={stream.Resolution?.Width}x{stream.Resolution?.Height} Uri={stream.Uri}");
}

// Filter audio media renditions
var audioTracks = master.Medias.FindAll(m => m.Type.Equals(MediaType.Audio));
foreach (var audio in audioTracks)
{
    Console.WriteLine($"  Audio: Name={audio.Name} Language={audio.Language} Default={audio.Default}");
}

// Remove all CLOSED-CAPTIONS renditions
master.Medias.RemoveAll(m => m.Type.Equals(MediaType.CloseCaptions));
Console.WriteLine($"Medias after removal: {master.Medias.Count}");
```

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

### Load Media Playlist from File

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Reads a media segment playlist from disk using `MediaPlaylist.LoadFromFile`. Parses playlist type, duration, sequence, version, map, and media segments, including encryption details.

```csharp
using M3U8Parser;
using M3U8Parser.Attributes.ValueType;

var media = MediaPlaylist.LoadFromFile("mediaplaylist.m3u8");

Console.WriteLine($"Type: {media.PlaylistType}");           // VOD
Console.WriteLine($"Version: {media.HlsVersion}");          // 4
Console.WriteLine($"TargetDuration: {media.TargetDuration}"); // 10
Console.WriteLine($"MediaSequence: {media.MediaSequence}"); // 0
Console.WriteLine($"HasEndList: {media.HasEndList}");        // True
Console.WriteLine($"IFrameOnly: {media.IFrameOnly}");        // True
Console.WriteLine($"Map URI: {media.Map?.Uri}");             // main.mp4

// Iterate segments
foreach (var group in media.MediaSegments)
{
    if (group.Key != null)
        Console.WriteLine($"  Key: Method={group.Key.Method} URI={group.Key.Uri}");

    foreach (var segment in group.Segments)
    {
        Console.WriteLine($"  Segment: Duration={segment.Duration}s URI={segment.Uri}");
        if (segment.ByteRangeLentgh.HasValue)
            Console.WriteLine($"    ByteRange: {segment.ByteRangeLentgh}@{segment.ByteRangeStartSubRange}");
    }
}
```

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

### Read and Edit M3U8 Master Playlist

Source: https://github.com/xavierlaffargue/m3u8parser-csharp/blob/main/README.md

Demonstrates how to load an existing m3u8 master playlist from a file, iterate through its streams, and remove specific media entries like closed captions.

```csharp
    // Load a file
    var masterPlaylist = MasterPlaylist.LoadFromFile("master.m3u8");

    // Example, list all stream uri
    foreach(var stream in masterPlaylist.Streams)
    {
        Console.WriteLine("Uri:" + stream.Uri);
    }
    
    // Delete CLOSED-CAPTIONS type EXT-X-MEDIA
    masterPlaylist.Medias.RemoveAll(m => m.Type.Equals(MediaType.CloseCaptions));
```

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

### MasterPlaylist.LoadFromFile

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Loads a multivariant playlist from a specified file path. This method parses the M3U8 file into strongly-typed objects representing media, stream information, and I-frame streams. It throws a FileNotFoundException if the specified path does not exist.

```APIDOC
## MasterPlaylist.LoadFromFile(string path)

### Description
Loads a multivariant playlist from disk and parses it into strongly-typed collections of `Media`, `StreamInf`, and `IframeStreamInf` objects.

### Method
`MasterPlaylist.LoadFromFile(string path)`

### Parameters
#### Path Parameters
- **path** (string) - Required - The file path to the M3U8 playlist.

### Throws
- `FileNotFoundException` - If the specified path does not exist.

### Request Example
```csharp
using M3U8Parser;
using M3U8Parser.Attributes.ValueType;

// Load a multivariant playlist from disk
var master = MasterPlaylist.LoadFromFile("master.m3u8");

Console.WriteLine($"HLS Version: {master.HlsVersion}");          // e.g. 7
Console.WriteLine($"Media renditions: {master.Medias.Count}");   // e.g. 5
Console.WriteLine($"Streams: {master.Streams.Count}");           // e.g. 7
Console.WriteLine($"I-Frame streams: {master.IFrameStreams.Count}"); // e.g. 6

// Enumerate all stream variants
foreach (var stream in master.Streams)
{
    Console.WriteLine($"  Bandwidth={stream.Bandwidth} Resolution={stream.Resolution?.Width}x{stream.Resolution?.Height} Uri={stream.Uri}");
}

// Filter audio media renditions
var audioTracks = master.Medias.FindAll(m => m.Type.Equals(MediaType.Audio));
foreach (var audio in audioTracks)
{
    Console.WriteLine($"  Audio: Name={audio.Name} Language={audio.Language} Default={audio.Default}");
}

// Remove all CLOSED-CAPTIONS renditions
master.Medias.RemoveAll(m => m.Type.Equals(MediaType.CloseCaptions));
Console.WriteLine($"Medias after removal: {master.Medias.Count}");
```
```

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

### Add M3U8Parser NuGet Package

Source: https://github.com/xavierlaffargue/m3u8parser-csharp/blob/main/README.md

Use this command to add the M3U8Parser package to your .NET project.

```bash
dotnet add package M3U8Parser
```

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

### Segment - Individual Media Segment

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Explains how to parse a single media segment from its `#EXTINF` and URI lines, and how to construct a `Segment` object programmatically, including support for byte-range and program date-time attributes.

```APIDOC
## Segment — Individual Media Segment

`Segment` represents a single `#EXTINF` entry with its URI, optional `#EXT-X-BYTERANGE`, `#EXT-X-PROGRAM-DATE-TIME`, and an associated `Map` (`#EXT-X-MAP`).

```csharp
using M3U8Parser.Tags.MediaSegment;

// Parse a segment block (EXTINF line + URI line)
var seg = new Segment("#EXTINF:10.005,\nmediaFileSample.aac");
Console.WriteLine(seg.Duration); // 10.005
Console.WriteLine(seg.Uri);      // mediaFileSample.aac

// Build a byte-range segment
var brseg = new Segment
{
    Duration              = 6.0,
    Uri                   = "video.mp4",
    ByteRangeLentgh       = 1048576,
    ByteRangeStartSubRange = 0,
    ProgramDateTime       = "2024-01-15T00:00:00.000Z"
};

Console.WriteLine(brseg.ToString());
/* Output:
#EXT-X-PROGRAM-DATE-TIME:2024-01-15T00:00:00.000Z
#EXTINF:6,
#EXT-X-BYTERANGE:1048576@0
video.mp4
*/
```
```

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

### MasterPlaylist.LoadFromText

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Parses a multivariant playlist directly from an in-memory string. This is useful when the M3U8 manifest is obtained over HTTP or embedded within other data structures.

```APIDOC
## MasterPlaylist.LoadFromText(string text)

### Description
Parses a multivariant playlist from an in-memory string, useful when the manifest is fetched over HTTP or embedded in another resource.

### Method
`MasterPlaylist.LoadFromText(string text)`

### Parameters
#### Path Parameters
- **text** (string) - Required - The raw M3U8 playlist content as a string.

### Request Example
```csharp
using M3U8Parser;

var m3u8Text = @"#EXTM3U
#EXT-X-VERSION:4

#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID=""audio"",NAME=""English"",LANGUAGE=""eng"",AUTOSELECT=YES,DEFAULT=YES
#EXT-X-STREAM-INF:BANDWIDTH=900000,CODECS=""avc1.4d401f,mp4a.40.2"",AUDIO=""audio""
v0.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1800000,CODECS=""avc1.4d401f,mp4a.40.2"",AUDIO=""audio""
v1.m3u8";

var master = MasterPlaylist.LoadFromText(m3u8Text);

Console.WriteLine($"Streams: {master.Streams.Count}");   // 2
Console.WriteLine($"Medias: {master.Medias.Count}");     // 1
Console.WriteLine(master.Streams[0].Uri);                // v0.m3u8
Console.WriteLine(master.Streams[1].Bandwidth);          // 1800000
```
```

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

### Load MasterPlaylist from Text String in C#

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Parse a multivariant playlist from an in-memory string using MasterPlaylist.LoadFromText. This is useful for playlists fetched over HTTP or embedded elsewhere. The provided text must be a valid M3U8 format.

```csharp
using M3U8Parser;

var m3u8Text = @"#EXTM3U
#EXT-X-VERSION:4

#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID=""audio"",NAME=""English"",LANGUAGE=""eng"",AUTOSELECT=YES,DEFAULT=YES
#EXT-X-STREAM-INF:BANDWIDTH=900000,CODECS=""avc1.4d401f,mp4a.40.2"",AUDIO=""audio""
v0.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=1800000,CODECS=""avc1.4d401f,mp4a.40.2"",AUDIO=""audio""
v1.m3u8";

var master = MasterPlaylist.LoadFromText(m3u8Text);

Console.WriteLine($"Streams: {master.Streams.Count}");   // 2
Console.WriteLine($"Medias: {master.Medias.Count}");     // 1
Console.WriteLine(master.Streams[0].Uri);                // v0.m3u8
Console.WriteLine(master.Streams[1].Bandwidth);          // 1800000
```

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

### IframeStreamInf - Parse and Reproduce Tag

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Demonstrates how to parse an #EXT-X-I-FRAME-STREAM-INF tag from a raw string and how to reproduce the original tag string from an IframeStreamInf object.

```APIDOC
## IframeStreamInf — I-Frame Stream Tag

`IframeStreamInf` represents an `#EXT-X-I-FRAME-STREAM-INF` tag for trick-play (fast-forward / rewind) streams.

```csharp
using M3U8Parser.Tags.MultivariantPlaylist;

// Parse from raw tag string
var iframe = new IframeStreamInf(
    "#EXT-X-I-FRAME-STREAM-INF:BANDWIDTH=621335,CODECS=\"avc1.42c00d\",
```

```APIDOC
    "RESOLUTION=416x234,URI=\"QualityLevels(399992)/Manifest(video,format=m3u8-aapl,type=keyframes)\"");

Console.WriteLine(iframe.Bandwidth);         // 621335
Console.WriteLine(iframe.Codecs);            // avc1.42c00d
Console.WriteLine(iframe.Resolution.Width);  // 416
Console.WriteLine(iframe.Uri);               // QualityLevels(399992)/Manifest(...)

// Reproduce the original tag line exactly
Console.WriteLine(iframe.ToString());
```
```

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

### Media - EXT-X-MEDIA Rendition Tag

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Details the Media class, which represents an #EXT-X-MEDIA tag. It supports various media types (Audio, Video, Subtitles, ClosedCaptions) and can be parsed from a raw tag string or constructed from scratch.

```APIDOC
## Media — EXT-X-MEDIA Rendition Tag

`Media` represents an `#EXT-X-MEDIA` tag. Supports `Audio`, `Video`, `Subtitles`, and `ClosedCaptions` media types via the `MediaType` static factory. Can be parsed from a raw tag string or constructed from scratch.

```csharp
using M3U8Parser.Attributes.ValueType;
using M3U8Parser.Tags.MultivariantPlaylist;

// Parse a CLOSED-CAPTIONS rendition
var cc = new Media(
    "#EXT-X-MEDIA:TYPE=CLOSED-CAPTIONS,GROUP-ID=\"cc\",NAME=\"CEA608_CC\"," +
    "AUTOSELECT=NO,DEFAULT=NO,INSTREAM-ID=\"CC1\"");

Console.WriteLine(cc.Type);       // CLOSED-CAPTIONS
Console.WriteLine(cc.GroupId);    // cc
Console.WriteLine(cc.Name);       // CEA608_CC
Console.WriteLine(cc.AutoSelect); // False
Console.WriteLine(cc.InstreamId); // CC1
Console.WriteLine(cc.Language);   // (null)

// Build an audio rendition and modify it
var audio = new Media
{
    Type       = MediaType.Audio,
    GroupId    = "audio",
    Name       = "French",
    Language   = "fre",
    AutoSelect = true,
    Default    = false,
    Uri        = "audio_fre.m3u8"
};
audio.Channels = "2";

Console.WriteLine(audio.ToString());
// #EXT-X-MEDIA:AUTOSELECT=YES,DEFAULT=NO,GROUP-ID="audio",LANGUAGE="fre",TYPE=AUDIO,NAME="French",URI="audio_fre.m3u8",CHANNELS="2"
```
```

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

### Parse IframeStreamInf Tag

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Demonstrates parsing an `#EXT-X-I-FRAME-STREAM-INF` tag string into an `IframeStreamInf` object and accessing its properties. Also shows how to reproduce the original tag.

```csharp
using M3U8Parser.Tags.MultivariantPlaylist;

// Parse from raw tag string
var iframe = new IframeStreamInf(
    "#EXT-X-I-FRAME-STREAM-INF:BANDWIDTH=621335,CODECS=\"avc1.42c00d\",
```

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

### StreamInf - Stream Variant Tag

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Explains the StreamInf class, which represents an #EXT-X-STREAM-INF tag. It can be parsed from a raw tag string or constructed programmatically, with optional attributes being nullable.

```APIDOC
## StreamInf — Stream Variant Tag

`StreamInf` represents an `#EXT-X-STREAM-INF` entry. It can be constructed from a raw tag string or built programmatically. All optional attributes (`AverageBandwidth`, `FrameRate`, `VideoRange`, `Resolution`, `HdcpLevel`) are nullable.

```csharp
using M3U8Parser.Attributes.ValueType;
using M3U8Parser.Tags.MultivariantPlaylist;

// Parse from raw tag text (note: URI must be on next line, separated by \r\n)
var stream = new StreamInf(
    "#EXT-X-STREAM-INF:AVERAGE-BANDWIDTH=2778321,BANDWIDTH=3971374,VIDEO-RANGE=PQ," +
    "CODECS=\"hvc1.2.4.L123.B0\",RESOLUTION=1280x720,FRAME-RATE=23.976," +
    "CLOSED-CAPTIONS=NONE,HDCP-LEVEL=TYPE-1\r\nsdr_720/prog_index.m3u8");

Console.WriteLine(stream.Bandwidth);         // 3971374
Console.WriteLine(stream.AverageBandwidth);  // 2778321
Console.WriteLine(stream.VideoRange);        // PQ
Console.WriteLine(stream.Codecs);            // hvc1.2.4.L123.B0
Console.WriteLine(stream.FrameRate);         // 23.976
Console.WriteLine(stream.HdcpLevel);         // TYPE-1
Console.WriteLine(stream.Resolution.Width);  // 1280
Console.WriteLine(stream.Resolution.Height); // 720
Console.WriteLine(stream.Uri);               // sdr_720/prog_index.m3u8

// Mutate resolution in place
stream.Resolution = new ResolutionType { Width = 1920, Height = 1080 };
Console.WriteLine(stream.Resolution.Width);  // 1920
```
```

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

### Parse StreamInf Tag from Raw Text

Source: https://context7.com/xavierlaffargue/m3u8parser-csharp/llms.txt

Parse a StreamInf tag directly from a raw tag string. Note that the URI must be on the next line, separated by \r\n. All optional attributes are nullable.

```csharp
using M3U8Parser.Attributes.ValueType;
using M3U8Parser.Tags.MultivariantPlaylist;

// Parse from raw tag text (note: URI must be on next line, separated by \r\n)
var stream = new StreamInf(
    "#EXT-X-STREAM-INF:AVERAGE-BANDWIDTH=2778321,BANDWIDTH=3971374,VIDEO-RANGE=PQ," +
    "CODECS=\"hvc1.2.4.L123.B0\",RESOLUTION=1280x720,FRAME-RATE=23.976," +
    "CLOSED-CAPTIONS=NONE,HDCP-LEVEL=TYPE-1\r\nsdr_720/prog_index.m3u8");

Console.WriteLine(stream.Bandwidth);         // 3971374
Console.WriteLine(stream.AverageBandwidth);  // 2778321
Console.WriteLine(stream.VideoRange);        // PQ
Console.WriteLine(stream.Codecs);            // hvc1.2.4.L123.B0
Console.WriteLine(stream.FrameRate);         // 23.976
Console.WriteLine(stream.HdcpLevel);         // TYPE-1
Console.WriteLine(stream.Resolution.Width);  // 1280
Console.WriteLine(stream.Resolution.Height); // 720
Console.WriteLine(stream.Uri);               // sdr_720/prog_index.m3u8

// Mutate resolution in place
stream.Resolution = new ResolutionType { Width = 1920, Height = 1080 };
Console.WriteLine(stream.Resolution.Width);  // 1920
```
Tokens:
Raw