containr 0.1.1

MP4, MOV, Matroska and WebM demuxer and muxer for Rust, with integer timestamps and raw edit lists
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! The end of the file: `Cues`, `Chapters`, `Tags`, `Attachments`, and the
//! patches a seekable output takes.

use std::io::{Seek, SeekFrom, Write};

use crate::error::{Error, Result};
use crate::mkv::ebml_write::ElementBuf;
use crate::mkv::ids;
use crate::mkv::mux::attachments::attachments_header;
use crate::mkv::mux::chapters::chapters_body;
use crate::mkv::mux::cues::cues_body;
use crate::mkv::mux::head::{seek_head, segment_size};
use crate::mkv::mux::muxer::Muxer;
use crate::mkv::mux::tags::{Targets, append_tags, check_targets};
use crate::mkv::mux::track::earliest;

impl<W: Write + Seek> Muxer<W> {
    /// Write `Cues`, `Chapters`, `Tags` and `Attachments`.
    fn write_tail(&mut self) -> Result<()> {
        if !self.cues.is_empty() {
            let mut cues = std::mem::take(&mut self.cues);
            let body = cues_body(&mut cues)?;
            self.put_master(ids::CUES, &body)?;
        }
        if !self.chapters.editions.is_empty() {
            let body = chapters_body(&self.chapters)?;
            self.put_master(ids::CHAPTERS, &body)?;
        }
        let mut tags = ElementBuf::new();
        append_tags(&mut tags, &self.metadata)?;
        for track in &self.tracks {
            append_tags(&mut tags, &track.spec.metadata)?;
        }
        if !tags.is_empty() {
            self.put_master(ids::TAGS, &tags)?;
        }
        if !self.attachments.is_empty() {
            self.seek
                .push((ids::ATTACHMENTS, self.pos - self.head.segment_data));
            let header = attachments_header(&self.attachments)?;
            self.put(&header, "Attachments")?;
            let files = std::mem::take(&mut self.attachments);
            for file in &files {
                for part in file.parts() {
                    self.put(part, "an AttachedFile")?;
                }
            }
        }
        Ok(())
    }

    /// Check every tag target against what the output holds.
    fn check_tag_targets(&self) -> Result<()> {
        let tracks: Vec<u64> = self.tracks.iter().map(|track| track.uid).collect();
        let editions: Vec<u64> = self
            .chapters
            .editions
            .iter()
            .filter_map(|edition| edition.uid)
            .collect();
        let attachments: Vec<u64> = self.attachments.iter().map(|file| file.uid).collect();
        let targets = Targets {
            tracks: &tracks,
            editions: &editions,
            chapters: &self.chapters.uids,
            attachments: &attachments,
        };
        check_targets(&self.metadata, &targets)
    }

    /// Replace bytes written earlier.
    fn patch(&mut self, at: u64, bytes: &[u8], what: &str) -> Result<()> {
        let result = self
            .writer
            .seek(SeekFrom::Start(at))
            .and_then(|_| self.writer.write_all(bytes));
        result.map_err(|err| {
            self.broken = true;
            Error::io(format!("the output: patching {what}"), at, err)
        })
    }

    /// Patch `SeekHead`, the Segment size and `Duration`, and leave the target
    /// at its end.
    fn patch_head(&mut self) -> Result<()> {
        if let Some(at) = self.head.seek_head_at {
            let bytes = seek_head(&self.seek)?;
            self.patch(at, &bytes, "SeekHead")?;
        }
        if let Some(at) = self.head.duration_at {
            let end = self.tracks.iter().map(|track| track.end).max().unwrap_or(0);
            // `Duration` is a float in the format. Nothing reads timing back
            // from it, and every block keeps its integer timestamp.
            let bits = (end as f64).to_bits().to_be_bytes();
            self.patch(at, &bits, "Duration")?;
        }
        if self.options.seekable {
            let size = segment_size(self.pos - self.head.segment_data)?;
            self.patch(self.head.segment_size_at, &size, "the Segment size")?;
            self.writer
                .seek(SeekFrom::Start(self.pos))
                .map_err(|err| Error::io("the output: seeking to its end", self.pos, err))?;
        }
        Ok(())
    }

    /// End the file and return the writer. A track whose last packet has no
    /// duration and no `DefaultDuration` gives [`Error::MissingDuration`].
    pub fn finish(mut self) -> Result<W> {
        self.check_usable()?;
        for track in &self.tracks {
            track.check_last()?;
        }
        self.check_tag_targets()?;
        self.start()?;
        while let Some(slot) = earliest(&self.tracks) {
            self.release(slot)?;
        }
        self.close_cluster()?;
        self.write_tail()?;
        self.patch_head()?;
        self.writer
            .flush()
            .map_err(|err| Error::io("the output: flushing", self.pos, err))?;
        Ok(self.writer)
    }
}