yamu 0.1.2

An unofficial async Rust client for the Yandex Music API
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
//! In-process media backend linked against FFmpeg libraries.

use std::{
    path::{Path, PathBuf},
    sync::atomic::{AtomicU64, Ordering},
    time::Duration,
};

use ffmpeg_next as av;

use super::{Error, MediaBackend, Result, TrackMetadata, detect_mime, ensure_decoded_duration};
use crate::atomic_file;

static TEMPORARY_COUNTER: AtomicU64 = AtomicU64::new(0);

#[derive(Clone, Debug, Default)]
pub struct Ffmpeg;

impl MediaBackend for Ffmpeg {
    fn name(&self) -> &'static str {
        "ffmpeg-libav"
    }

    async fn write_m4a_metadata(
        &self,
        path: PathBuf,
        metadata: TrackMetadata,
        artwork: Option<Vec<u8>>,
    ) -> Result<()> {
        tokio::task::spawn_blocking(move || {
            let output = sibling_temporary(&path, "metadata.m4a");
            let result = remux_audio(&path, &output, Some(&metadata), artwork.as_deref(), "ipod")
                .and_then(|()| replace_file_blocking(&output, &path, true));
            if result.is_err() {
                let _ = std::fs::remove_file(&output);
            }
            result
        })
        .await?
    }

    async fn remux_flac(&self, source: PathBuf, destination: PathBuf, replace: bool) -> Result<()> {
        tokio::task::spawn_blocking(move || {
            if destination.exists() && !replace {
                return Err(backend(format!(
                    "destination {} already exists",
                    destination.display()
                )));
            }
            let output = sibling_temporary(&destination, "remux.flac");
            let result = remux_audio(&source, &output, None, None, "flac")
                .and_then(|()| replace_file_blocking(&output, &destination, replace));
            if result.is_err() {
                let _ = std::fs::remove_file(&output);
            }
            result
        })
        .await?
    }

    async fn transcode_mp3(
        &self,
        source: PathBuf,
        destination: PathBuf,
        bitrate_kbps: u32,
        replace: bool,
    ) -> Result<()> {
        tokio::task::spawn_blocking(move || {
            if destination.exists() && !replace {
                return Err(backend(format!(
                    "destination {} already exists",
                    destination.display()
                )));
            }
            let output = sibling_temporary(&destination, "transcode.mp3");
            let result = transcode_audio_mp3(&source, &output, bitrate_kbps)
                .and_then(|()| replace_file_blocking(&output, &destination, replace));
            if result.is_err() {
                let _ = std::fs::remove_file(&output);
            }
            result
        })
        .await?
    }

    async fn verify_audio(&self, path: PathBuf, expected_duration: Option<Duration>) -> Result<()> {
        let actual_duration = tokio::task::spawn_blocking(move || decode_audio(&path)).await??;
        match expected_duration {
            Some(expected_duration) => ensure_decoded_duration(expected_duration, actual_duration),
            None => Ok(()),
        }
    }

    async fn verify_m4a(&self, path: PathBuf) -> Result<()> {
        tokio::task::spawn_blocking(move || decode_audio(&path).map(|_| ())).await?
    }
}

fn initialize() -> Result<()> {
    av::init().map_err(|error| backend(format!("failed to initialize FFmpeg: {error}")))
}

fn remux_audio(
    source: &Path,
    destination: &Path,
    metadata: Option<&TrackMetadata>,
    artwork: Option<&[u8]>,
    output_format: &str,
) -> Result<()> {
    initialize()?;
    let mut input = av::format::input(source).map_err(av_error("failed to open media input"))?;
    let audio = input
        .streams()
        .best(av::media::Type::Audio)
        .ok_or_else(|| backend("input contains no audio stream"))?;
    let audio_index = audio.index();
    let audio_time_base = audio.time_base();
    let audio_parameters = audio.parameters();

    let mut output = av::format::output_as(destination, output_format)
        .map_err(av_error("failed to create media output"))?;
    let output_audio_index;
    {
        let mut stream = output
            .add_stream(av::encoder::find(av::codec::Id::None))
            .map_err(av_error("failed to add audio stream"))?;
        stream.set_parameters(audio_parameters);
        stream.set_time_base(audio_time_base);
        unsafe {
            (*stream.parameters().as_mut_ptr()).codec_tag = 0;
        }
        output_audio_index = stream.index();
    }

    let cover_index = if let Some(bytes) = artwork {
        let dimensions = imagesize::blob_size(bytes)
            .map_err(|error| backend(format!("failed to read cover dimensions: {error}")))?;
        let codec = match detect_mime(bytes) {
            lofty::picture::MimeType::Png => av::codec::Id::PNG,
            lofty::picture::MimeType::Jpeg => av::codec::Id::MJPEG,
            _ => return Err(backend("unsupported cover image format")),
        };
        let mut stream = output
            .add_stream(av::encoder::find(av::codec::Id::None))
            .map_err(av_error("failed to add cover stream"))?;
        stream.set_time_base((1, 90_000));
        unsafe {
            let raw_stream = stream.as_mut_ptr();
            (*raw_stream).disposition |= av::ffi::AV_DISPOSITION_ATTACHED_PIC;
            let parameters = (*raw_stream).codecpar;
            (*parameters).codec_type = av::ffi::AVMediaType::AVMEDIA_TYPE_VIDEO;
            (*parameters).codec_id = codec.into();
            (*parameters).codec_tag = 0;
            (*parameters).width = i32::try_from(dimensions.width)
                .map_err(|_| backend("cover width exceeds FFmpeg limits"))?;
            (*parameters).height = i32::try_from(dimensions.height)
                .map_err(|_| backend("cover height exceeds FFmpeg limits"))?;
        }
        Some(stream.index())
    } else {
        None
    };

    output.set_metadata(match metadata {
        Some(metadata) => metadata_dictionary(metadata),
        None => input.metadata().to_owned(),
    });
    let mut options = av::Dictionary::new();
    if output_format == "ipod" {
        options.set("movflags", "+faststart");
    }
    output
        .write_header_with(options)
        .map_err(av_error("failed to write media header"))?;
    let output_time_base = output
        .stream(output_audio_index)
        .ok_or_else(|| backend("output audio stream disappeared"))?
        .time_base();

    for (stream, mut packet) in input.packets() {
        if stream.index() != audio_index {
            continue;
        }
        packet.rescale_ts(audio_time_base, output_time_base);
        packet.set_position(-1);
        packet.set_stream(output_audio_index);
        packet
            .write_interleaved(&mut output)
            .map_err(av_error("failed to write audio packet"))?;
    }
    if let (Some(index), Some(bytes)) = (cover_index, artwork) {
        let mut packet = av::Packet::copy(bytes);
        packet.set_stream(index);
        packet.set_flags(av::packet::Flags::KEY);
        packet.set_pts(Some(0));
        packet.set_dts(Some(0));
        packet.set_position(-1);
        packet
            .write_interleaved(&mut output)
            .map_err(av_error("failed to write cover packet"))?;
    }
    output
        .write_trailer()
        .map_err(av_error("failed to write media trailer"))?;
    drop(output);
    sync_file(destination)?;
    Ok(())
}

fn decode_audio(path: &Path) -> Result<Duration> {
    initialize()?;
    let mut input = av::format::input(path).map_err(av_error("failed to open audio file"))?;
    let stream = input
        .streams()
        .best(av::media::Type::Audio)
        .ok_or_else(|| backend("file contains no audio stream"))?;
    let index = stream.index();
    let context = av::codec::context::Context::from_parameters(stream.parameters())
        .map_err(av_error("failed to create audio decoder"))?;
    let mut decoder = context
        .decoder()
        .audio()
        .map_err(av_error("failed to open audio decoder"))?;
    let mut frame = av::frame::Audio::empty();
    let mut decoded_samples = 0_u64;
    for (stream, packet) in input.packets() {
        if stream.index() != index {
            continue;
        }
        decoder
            .send_packet(&packet)
            .map_err(av_error("failed to send audio packet"))?;
        decoded_samples += drain_decoder(&mut decoder, &mut frame)?;
    }
    decoder
        .send_eof()
        .map_err(av_error("failed to flush audio decoder"))?;
    decoded_samples += drain_decoder(&mut decoder, &mut frame)?;
    if decoded_samples == 0 {
        return Err(backend("decoder produced no audio frames"));
    }
    let sample_rate = decoder.rate();
    if sample_rate == 0 {
        return Err(backend("decoder reported a zero sample rate"));
    }
    Ok(Duration::from_secs_f64(
        decoded_samples as f64 / f64::from(sample_rate),
    ))
}

struct AudioTranscoder {
    input_index: usize,
    decoder: av::decoder::Audio,
    encoder: av::encoder::Audio,
    filter: av::filter::Graph,
    encoder_time_base: av::Rational,
    output_time_base: av::Rational,
}

fn transcode_audio_mp3(source: &Path, destination: &Path, bitrate_kbps: u32) -> Result<()> {
    initialize()?;
    let mut input = av::format::input(source).map_err(av_error("failed to open media input"))?;
    let input_stream = input
        .streams()
        .best(av::media::Type::Audio)
        .ok_or_else(|| backend("input contains no audio stream"))?;
    let input_index = input_stream.index();
    let input_time_base = input_stream.time_base();
    let decoder_context = av::codec::context::Context::from_parameters(input_stream.parameters())
        .map_err(av_error("failed to create audio decoder"))?;
    let mut decoder = decoder_context
        .decoder()
        .audio()
        .map_err(av_error("failed to open audio decoder"))?;
    decoder.set_time_base(input_time_base);

    let codec = av::encoder::find_by_name("libmp3lame")
        .ok_or_else(|| backend("FFmpeg was built without the libmp3lame encoder"))?;
    let audio_codec = codec
        .audio()
        .map_err(av_error("libmp3lame is not an audio encoder"))?;
    let mut output = av::format::output_as(destination, "mp3")
        .map_err(av_error("failed to create MP3 output"))?;
    let global_header = output
        .format()
        .flags()
        .contains(av::format::flag::Flags::GLOBAL_HEADER);
    let mut encoder = av::codec::context::Context::new_with_codec(codec)
        .encoder()
        .audio()
        .map_err(av_error("failed to create MP3 encoder"))?;
    let channel_layout = audio_codec
        .channel_layouts()
        .map(|layouts| layouts.best(decoder.channel_layout().channels()))
        .unwrap_or(av::channel_layout::ChannelLayout::STEREO);
    let sample_format = audio_codec
        .formats()
        .and_then(|mut formats| formats.next())
        .ok_or_else(|| backend("libmp3lame reports no supported sample format"))?;
    let input_rate = decoder.rate() as i32;
    let sample_rate = audio_codec
        .rates()
        .and_then(|rates| {
            rates
                .filter(|rate| *rate > 0)
                .min_by_key(|rate| rate.abs_diff(input_rate))
        })
        .unwrap_or(input_rate);
    if global_header {
        encoder.set_flags(av::codec::flag::Flags::GLOBAL_HEADER);
    }
    encoder.set_rate(sample_rate);
    encoder.set_channel_layout(channel_layout);
    encoder.set_format(sample_format);
    encoder.set_bit_rate((bitrate_kbps as usize) * 1_000);
    encoder.set_time_base((1, sample_rate));
    let encoder = encoder
        .open_as(codec)
        .map_err(av_error("failed to open libmp3lame encoder"))?;
    let encoder_time_base = encoder.time_base();

    let output_index;
    {
        let mut stream = output
            .add_stream(codec)
            .map_err(av_error("failed to add MP3 stream"))?;
        stream.set_parameters(&encoder);
        stream.set_time_base(encoder_time_base);
        output_index = stream.index();
    }
    let output_time_base = output
        .stream(output_index)
        .ok_or_else(|| backend("output audio stream disappeared"))?
        .time_base();
    let filter = audio_filter(&decoder, &encoder)?;
    output
        .write_header()
        .map_err(av_error("failed to write MP3 header"))?;

    let mut transcoder = AudioTranscoder {
        input_index,
        decoder,
        encoder,
        filter,
        encoder_time_base,
        output_time_base,
    };
    for (stream, mut packet) in input.packets() {
        if stream.index() != transcoder.input_index {
            continue;
        }
        packet.rescale_ts(stream.time_base(), input_time_base);
        transcoder
            .decoder
            .send_packet(&packet)
            .map_err(av_error("failed to send audio packet"))?;
        transcoder.process_decoded(&mut output)?;
    }
    transcoder
        .decoder
        .send_eof()
        .map_err(av_error("failed to flush audio decoder"))?;
    transcoder.process_decoded(&mut output)?;
    transcoder
        .filter
        .get("in")
        .ok_or_else(|| backend("audio filter input disappeared"))?
        .source()
        .flush()
        .map_err(av_error("failed to flush audio filter"))?;
    transcoder.process_filtered(&mut output)?;
    transcoder
        .encoder
        .send_eof()
        .map_err(av_error("failed to flush MP3 encoder"))?;
    transcoder.process_encoded(&mut output)?;
    output
        .write_trailer()
        .map_err(av_error("failed to write MP3 trailer"))?;
    drop(output);
    sync_file(destination)?;
    Ok(())
}

fn audio_filter(
    decoder: &av::decoder::Audio,
    encoder: &av::encoder::Audio,
) -> Result<av::filter::Graph> {
    let mut filter = av::filter::Graph::new();
    let arguments = format!(
        "time_base={}:sample_rate={}:sample_fmt={}:channel_layout=0x{:x}",
        decoder.time_base(),
        decoder.rate(),
        decoder.format().name(),
        decoder.channel_layout().bits()
    );
    let input = av::filter::find("abuffer").ok_or_else(|| backend("abuffer filter is missing"))?;
    let output =
        av::filter::find("abuffersink").ok_or_else(|| backend("abuffersink filter is missing"))?;
    filter
        .add(&input, "in", &arguments)
        .map_err(av_error("failed to add audio filter input"))?;
    filter
        .add(&output, "out", "")
        .map_err(av_error("failed to add audio filter output"))?;
    let filters = format!(
        "aresample={},aformat=sample_fmts={}:sample_rates={}:channel_layouts=0x{:x}",
        encoder.rate(),
        encoder.format().name(),
        encoder.rate(),
        encoder.channel_layout().bits()
    );
    filter
        .output("in", 0)
        .map_err(av_error("failed to connect audio filter input"))?
        .input("out", 0)
        .map_err(av_error("failed to connect audio filter output"))?
        .parse(&filters)
        .map_err(av_error("failed to configure audio filter"))?;
    filter
        .validate()
        .map_err(av_error("failed to validate audio filter"))?;
    if !codec_has_variable_frames(encoder) {
        filter
            .get("out")
            .ok_or_else(|| backend("audio filter output disappeared"))?
            .sink()
            .set_frame_size(encoder.frame_size());
    }
    Ok(filter)
}

fn codec_has_variable_frames(encoder: &av::encoder::Audio) -> bool {
    encoder.codec().is_some_and(|codec| {
        codec
            .capabilities()
            .contains(av::codec::capabilities::Capabilities::VARIABLE_FRAME_SIZE)
    })
}

impl AudioTranscoder {
    fn process_decoded(&mut self, output: &mut av::format::context::Output) -> Result<()> {
        let mut decoded = av::frame::Audio::empty();
        loop {
            match self.decoder.receive_frame(&mut decoded) {
                Ok(()) => {
                    let timestamp = decoded.timestamp();
                    decoded.set_pts(timestamp);
                    self.filter
                        .get("in")
                        .ok_or_else(|| backend("audio filter input disappeared"))?
                        .source()
                        .add(&decoded)
                        .map_err(av_error("failed to filter decoded audio"))?;
                    self.process_filtered(output)?;
                }
                Err(error) if is_drain_complete(error) => break,
                Err(error) => return Err(backend(format!("audio decode failed: {error}"))),
            }
        }
        Ok(())
    }

    fn process_filtered(&mut self, output: &mut av::format::context::Output) -> Result<()> {
        let mut filtered = av::frame::Audio::empty();
        loop {
            let result = self
                .filter
                .get("out")
                .ok_or_else(|| backend("audio filter output disappeared"))?
                .sink()
                .frame(&mut filtered);
            match result {
                Ok(()) => {
                    self.encoder
                        .send_frame(&filtered)
                        .map_err(av_error("failed to send audio to MP3 encoder"))?;
                    self.process_encoded(output)?;
                }
                Err(error) if is_drain_complete(error) => break,
                Err(error) => return Err(backend(format!("audio filter failed: {error}"))),
            }
        }
        Ok(())
    }

    fn process_encoded(&mut self, output: &mut av::format::context::Output) -> Result<()> {
        let mut packet = av::Packet::empty();
        loop {
            match self.encoder.receive_packet(&mut packet) {
                Ok(()) => {
                    packet.set_stream(0);
                    packet.rescale_ts(self.encoder_time_base, self.output_time_base);
                    packet.set_position(-1);
                    packet
                        .write_interleaved(output)
                        .map_err(av_error("failed to write MP3 packet"))?;
                }
                Err(error) if is_drain_complete(error) => break,
                Err(error) => return Err(backend(format!("MP3 encode failed: {error}"))),
            }
        }
        Ok(())
    }
}

fn is_drain_complete(error: av::Error) -> bool {
    matches!(error, av::Error::Eof)
        || matches!(error, av::Error::Other { errno } if errno == av::error::EAGAIN)
}

fn drain_decoder(decoder: &mut av::decoder::Audio, frame: &mut av::frame::Audio) -> Result<u64> {
    let mut samples = 0_u64;
    loop {
        match decoder.receive_frame(frame) {
            Ok(()) => samples += frame.samples() as u64,
            Err(av::Error::Other { errno }) if errno == av::error::EAGAIN => break,
            Err(av::Error::Eof) => break,
            Err(error) => return Err(backend(format!("audio decode failed: {error}"))),
        }
    }
    Ok(samples)
}

fn metadata_dictionary(metadata: &TrackMetadata) -> av::Dictionary<'static> {
    let mut dictionary = av::Dictionary::new();
    dictionary.set("title", &metadata.title);
    dictionary.set("artist", &metadata.artist);
    if let Some(value) = &metadata.album {
        dictionary.set("album", value);
    }
    if let Some(value) = &metadata.album_artist {
        dictionary.set("album_artist", value);
    }
    if let Some(value) = &metadata.genre {
        dictionary.set("genre", value);
    }
    let year = metadata.year.map(|value| value.to_string());
    if let Some(value) = &year {
        dictionary.set("date", value);
    }
    let track = metadata.track_number.map(|value| value.to_string());
    if let Some(value) = &track {
        dictionary.set("track", value);
    }
    let disc = metadata.disc_number.map(|value| value.to_string());
    if let Some(value) = &disc {
        dictionary.set("disc", value);
    }
    if let Some(value) = &metadata.lyrics {
        dictionary.set("lyrics", &value.text);
    }
    dictionary
}

fn replace_file_blocking(source: &Path, destination: &Path, replace: bool) -> Result<()> {
    atomic_file::persist(source, destination, replace).map_err(Error::from)
}

fn sync_file(path: &Path) -> Result<()> {
    let file = std::fs::OpenOptions::new()
        .read(true)
        .write(true)
        .open(path)
        .map_err(|error| {
            backend(format!(
                "failed to open temporary media output {} for syncing: {error}",
                path.display()
            ))
        })?;
    file.sync_all().map_err(|error| {
        backend(format!(
            "failed to sync temporary media output {}: {error}",
            path.display()
        ))
    })
}

fn sibling_temporary(destination: &Path, suffix: &str) -> PathBuf {
    let parent = destination.parent().unwrap_or_else(|| Path::new("."));
    let name = destination
        .file_name()
        .unwrap_or_default()
        .to_string_lossy();
    let nonce = TEMPORARY_COUNTER.fetch_add(1, Ordering::Relaxed);
    parent.join(format!(".{name}.{}-{nonce}.{suffix}", std::process::id()))
}

fn av_error(context: &'static str) -> impl FnOnce(av::Error) -> Error {
    move |error| backend(format!("{context}: {error}"))
}

fn backend(message: impl Into<String>) -> Error {
    Error::Backend(message.into())
}