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
|
//! Output frame reordering.
//!
//! NihAV decoders output frames in the same order as they are put in.
//! In result if you want to have frames in display order you might need some frame reorderer.
//! This module provides such functionality depending on codec type: audio codecs and video codecs without B-frames do not need any reorderer and can use `NoReorderer` if the common interface is required. Codecs with B-frames should use `IPBReorderer`. For codecs with very complex reordering rules like H.264 or H.256 `PictureIDReorderer` will be added eventually.
//!
//! You can find out required reorderer by quering codec properties using `nihav_core::register` module.
use std::mem::swap;
pub use crate::frame::{FrameType, NAFrameRef};
/// A trait for frame reorderer.
pub trait FrameReorderer {
/// Stores a newly decoded frame.
fn add_frame(&mut self, fref: NAFrameRef) -> bool;
/// Gets the next frame to be displayed (or `None` if that is not possible).
fn get_frame(&mut self) -> Option<NAFrameRef>;
/// Clears all stored frames.
fn flush(&mut self);
/// Retrieves the last frames stored by the reorderer.
fn get_last_frames(&mut self) -> Option<NAFrameRef>;
}
/// Zero reorderer.
pub struct NoReorderer {
fref: Option<NAFrameRef>,
}
impl NoReorderer {
/// Constructs a new instance of `NoReorderer`.
pub fn new() -> Self {
Self { fref: None }
}
}
impl Default for NoReorderer {
fn default() -> Self {
Self::new()
}
}
impl FrameReorderer for NoReorderer {
fn add_frame(&mut self, fref: NAFrameRef) -> bool {
if self.fref.is_none() {
self.fref = Some(fref);
true
} else {
false
}
}
fn get_frame(&mut self) -> Option<NAFrameRef> {
let mut ret = None;
swap(&mut ret, &mut self.fref);
ret
}
fn flush(&mut self) { self.fref = None; }
fn get_last_frames(&mut self) -> Option<NAFrameRef> { None }
}
/// Frame reorderer for codecs with I/P/B frames.
#[derive(Default)]
pub struct IPBReorderer {
rframe: Option<NAFrameRef>,
bframe: Option<NAFrameRef>,
}
impl IPBReorderer {
/// Constructs a new instance of `IPBReorderer`.
pub fn new() -> Self { Self::default() }
}
impl FrameReorderer for IPBReorderer {
fn add_frame(&mut self, fref: NAFrameRef) -> bool {
if self.rframe.is_some() && self.bframe.is_some() { return false; }
let is_b = fref.get_frame_type() == FrameType::B;
if is_b && self.bframe.is_some() { return false; }
if is_b {
self.bframe = Some(fref);
} else {
std::mem::swap(&mut self.bframe, &mut self.rframe);
self.rframe = Some(fref);
}
true
}
fn get_frame(&mut self) -> Option<NAFrameRef> {
let mut ret = None;
if self.bframe.is_some() {
std::mem::swap(&mut ret, &mut self.bframe);
}
ret
}
fn flush(&mut self) {
self.rframe = None;
self.bframe = None;
}
fn get_last_frames(&mut self) -> Option<NAFrameRef> {
let mut ret = None;
if self.bframe.is_some() {
std::mem::swap(&mut ret, &mut self.bframe);
} else if self.rframe.is_some() {
std::mem::swap(&mut ret, &mut self.rframe);
}
ret
}
}
/// Frame reorderer for codecs with complex I/P/B frame structure like ITU H.26x.
#[derive(Default)]
pub struct ComplexReorderer {
last_ref_dts: Option<u64>,
ready_idx: usize,
frames: Vec<NAFrameRef>,
}
impl ComplexReorderer {
/// Constructs a new instance of `IPBReorderer`.
pub fn new() -> Self { Self::default() }
}
impl FrameReorderer for ComplexReorderer {
fn add_frame(&mut self, fref: NAFrameRef) -> bool {
if self.frames.len() >= 64 {
return false;
}
let is_ref = fref.frame_type == FrameType::I || fref.frame_type == FrameType::P;
if !is_ref {
if self.frames.is_empty() || fref.get_dts().is_none() {
self.frames.push(fref);
} else if let Some(new_dts) = fref.get_dts() {
let mut idx = 0;
for (i, frm) in self.frames.iter().enumerate() {
idx = i;
if let Some(dts) = frm.get_dts() {
if dts > new_dts {
break;
}
}
}
self.frames.insert(idx, fref);
}
} else {
for (i, frm) in self.frames.iter().enumerate() {
if frm.get_dts() == self.last_ref_dts {
self.ready_idx = i + 1;
}
}
self.last_ref_dts = fref.get_dts();
self.frames.push(fref);
}
true
}
fn get_frame(&mut self) -> Option<NAFrameRef> {
if self.ready_idx > 0 {
self.ready_idx -= 1;
Some(self.frames.remove(0))
} else {
None
}
}
fn flush(&mut self) {
self.last_ref_dts = None;
self.ready_idx = 0;
self.frames.clear();
}
fn get_last_frames(&mut self) -> Option<NAFrameRef> {
if !self.frames.is_empty() {
Some(self.frames.remove(0))
} else {
None
}
}
}
|
