Debian Codegraph @

.cargo/vendor/rav1e/src/api/channel/by_gop.rs

raw
1 // Copyright (c) 2018-2022, The rav1e contributors. All rights reserved
2 //
3 // This source code is subject to the terms of the BSD 2 Clause License and
4 // the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
5 // was not distributed with this source code in the LICENSE file, you can
6 // obtain it at www.aomedia.org/license/software. If the Alliance for Open
7 // Media Patent License 1.0 was not distributed with this source code in the
8 // PATENTS file, you can obtain it at www.aomedia.org/license/patent.
9
10 use crate::api::channel::data::*;
11 use crate::api::config::*;
12 use crate::api::util::*;
13 use crate::api::EncoderConfig;
14 use crate::api::InterConfig;
15
16 use crossbeam::channel::*;
17
18 use crate::frame::*;
19 use crate::util::Pixel;
20 use av_scenechange::SceneChangeDetector;
21
22 use std::collections::BTreeMap;
23 use std::sync::Arc;
24
25 struct SubGop<T: Pixel> {
26 frames: Vec<Arc<Frame<T>>>,
27 end_gop: bool,
28 }
29
30 /*
31 impl<T: Pixel> SubGop<T> {
32 fn build_fi(&self) -> Vec<FrameData<T>> {
33 todo!()
34 }
35 }
36 */
37
38 // TODO: Make the detector logic fitting the model
39 struct SceneChange<T: Pixel> {
40 frames: usize,
41 pyramid_size: usize,
42 processed: usize,
43 last_keyframe: usize,
44 detector: SceneChangeDetector<T>,
45 }
46
47 impl<T: Pixel> SceneChange<T> {
48 fn new(pyramid_size: usize, enc: &EncoderConfig) -> Self {
49 let inter_cfg = InterConfig::new(enc);
50 let lookahead_distance = inter_cfg.keyframe_lookahead_distance() as usize;
51 let detector = SceneChangeDetector::new(
52 (enc.width, enc.height),
53 enc.bit_depth,
54 av_scenechange::Rational32::new(
55 enc.time_base.den as i32,
56 enc.time_base.num as i32,
57 ),
58 enc.chroma_sampling,
59 lookahead_distance,
60 match enc.speed_settings.scene_detection_mode {
61 super::SceneDetectionSpeed::Fast => {
62 av_scenechange::SceneDetectionSpeed::Fast
63 }
64 super::SceneDetectionSpeed::Standard => {
65 av_scenechange::SceneDetectionSpeed::Standard
66 }
67 super::SceneDetectionSpeed::None => {
68 av_scenechange::SceneDetectionSpeed::None
69 }
70 },
71 enc.min_key_frame_interval as usize,
72 enc.max_key_frame_interval as usize,
73 av_scenechange::CpuFeatureLevel::default(),
74 );
75
76 Self { frames: 0, pyramid_size, processed: 0, last_keyframe: 0, detector }
77 }
78
79 // Tell where to split the lookahead
80 //
81 fn split(&mut self, lookahead: &[Arc<Frame<T>>]) -> Option<(usize, bool)> {
82 self.processed += 1;
83
84 let lookahead_ref: Vec<_> = lookahead[self.frames..].iter().collect();
85
86 let new_gop = self.detector.analyze_next_frame(
87 &lookahead_ref,
88 self.processed,
89 self.last_keyframe,
90 );
91
92 if new_gop {
93 self.last_keyframe = self.processed;
94 }
95
96 if self.frames > self.pyramid_size {
97 self.frames -= self.pyramid_size + 1;
98 Some((self.pyramid_size + 2, new_gop))
99 } else if new_gop {
100 let frames = self.frames + 1;
101 self.frames = 0;
102 Some((frames, true))
103 } else {
104 self.frames += 1;
105 None
106 }
107 }
108 }
109
110 struct WorkLoad<T: Pixel> {
111 s_recv: Receiver<SubGop<T>>,
112 send: Sender<Packet<T>>,
113 }
114
115 struct WorkerPoolSend<T: Pixel> {
116 recv_workers: Receiver<Sender<Option<WorkLoad<T>>>>,
117 send_reassemble: Sender<(usize, Receiver<Packet<T>>)>,
118 count: usize,
119 }
120
121 impl<T: Pixel> WorkerPoolSend<T> {
122 fn get_worker(&mut self) -> Option<Sender<SubGop<T>>> {
123 self.recv_workers.recv().ok().map(|sender| {
124 let (s_send, s_recv) = unbounded();
125 let (send, recv) = unbounded();
126
127 let _ = self.send_reassemble.send((self.count, recv));
128
129 let wl = WorkLoad { s_recv, send };
130
131 let _ = sender.send(Some(wl));
132
133 self.count += 1;
134
135 s_send
136 })
137 }
138 }
139
140 struct WorkerPoolRecv<T: Pixel> {
141 recv_reassemble: Receiver<(usize, Receiver<Packet<T>>)>,
142 recv_workers: Receiver<Sender<Option<WorkLoad<T>>>>,
143 }
144
145 // TODO: make it Drop ?
146 impl<T: Pixel> WorkerPoolRecv<T> {
147 fn close(&self) {
148 for worker in self.recv_workers.iter() {
149 let _ = worker.send(None);
150 }
151 }
152 }
153
154 fn workerpool<T: Pixel>(
155 s: &rayon::ScopeFifo, workers: usize, mut cfg: Config,
156 ) -> (WorkerPoolSend<T>, WorkerPoolRecv<T>) {
157 let (send_workers, recv_workers) = bounded(workers);
158 let (send_reassemble, recv_reassemble) = unbounded();
159
160 // TODO: unpack send_frame in process
161 cfg.enc.speed_settings.scene_detection_mode = SceneDetectionSpeed::None;
162
163 for _ in 0..workers {
164 let (send_workload, recv_workload) = unbounded::<Option<WorkLoad<T>>>();
165 let send_workload2 = send_workload.clone();
166 let send_back = send_workers.clone();
167
168 let cfg = cfg.clone();
169 s.spawn_fifo(move |_| {
170 for wl in recv_workload.iter() {
171 match wl {
172 Some(wl) => {
173 let mut inner = cfg.new_inner().unwrap();
174 for s in wl.s_recv.iter() {
175 for f in s.frames {
176 while !inner.needs_more_fi_lookahead() {
177 let r = inner.receive_packet();
178 match r {
179 Ok(p) => {
180 wl.send.send(p).unwrap();
181 }
182 Err(EncoderStatus::Encoded) => {}
183 _ => todo!("Error management {:?}", r),
184 }
185 }
186 let _ = inner.send_frame(Some(f), None);
187 }
188 }
189
190 inner.limit = Some(inner.frame_count);
191 let _ = inner.send_frame(None, None);
192
193 loop {
194 match inner.receive_packet() {
195 Ok(p) => wl.send.send(p).unwrap(),
196 Err(EncoderStatus::LimitReached) => break,
197 Err(EncoderStatus::Encoded) => {}
198 _ => todo!("Error management"),
199 }
200 }
201
202 let _ = send_back.send(send_workload2.clone());
203 }
204 None => break,
205 }
206 }
207 });
208 let _ = send_workers.send(send_workload);
209 }
210
211 (
212 WorkerPoolSend {
213 recv_workers: recv_workers.clone(),
214 send_reassemble,
215 count: 0,
216 },
217 WorkerPoolRecv { recv_reassemble, recv_workers },
218 )
219 }
220
221 fn reassemble<P: Pixel>(
222 pool: WorkerPoolRecv<P>, s: &rayon::ScopeFifo,
223 send_packet: Sender<Packet<P>>,
224 ) {
225 s.spawn_fifo(move |_| {
226 let mut pending = BTreeMap::new();
227 let mut last_idx = 0;
228 let mut packet_index = 0;
229 for (idx, recv) in pool.recv_reassemble.iter() {
230 pending.insert(idx, recv);
231 while let Some(recv) = pending.remove(&last_idx) {
232 for mut p in recv {
233 // patch up the packet_index
234 p.input_frameno = packet_index;
235 let _ = send_packet.send(p);
236 packet_index += 1;
237 }
238 last_idx += 1;
239 }
240 }
241
242 while !pending.is_empty() {
243 if let Some(recv) = pending.remove(&last_idx) {
244 for mut p in recv {
245 // patch up the packet_index
246 p.input_frameno = packet_index;
247 let _ = send_packet.send(p);
248 packet_index += 1;
249 }
250 }
251 last_idx += 1;
252 }
253
254 pool.close();
255 });
256 }
257
258 impl Config {
259 // Group the incoming frames in Gops, emit a SubGop at time.
260 fn scenechange<T: Pixel>(
261 &self, s: &rayon::ScopeFifo, r: Receiver<FrameInput<T>>,
262 ) -> Receiver<SubGop<T>> {
263 let inter_cfg = InterConfig::new(&self.enc);
264 let pyramid_size = inter_cfg.keyframe_lookahead_distance() as usize;
265 let lookahead_distance = pyramid_size + 1 + 1;
266 let (send, recv) = bounded(lookahead_distance * 2);
267
268 let mut sc = SceneChange::new(pyramid_size, &self.enc);
269
270 s.spawn_fifo(move |_| {
271 let mut lookahead = Vec::new();
272 for f in r.iter() {
273 let (frame, _params) = f;
274
275 lookahead.push(frame.unwrap());
276
277 // we need at least lookahead_distance frames to reason
278 if lookahead.len() < lookahead_distance {
279 continue;
280 }
281
282 if let Some((split_pos, end_gop)) = sc.split(&lookahead) {
283 let rem = lookahead.split_off(split_pos);
284 let _ = send.send(SubGop { frames: lookahead, end_gop });
285
286 lookahead = rem;
287 }
288 }
289
290 while lookahead.len() > lookahead_distance {
291 if let Some((split_pos, end_gop)) = sc.split(&lookahead) {
292 let rem = lookahead.split_off(split_pos);
293 let _ = send.send(SubGop { frames: lookahead, end_gop });
294
295 lookahead = rem;
296 }
297 }
298
299 if !lookahead.is_empty() {
300 let _ = send.send(SubGop { frames: lookahead, end_gop: true });
301 }
302 });
303
304 recv
305 }
306
307 /// Encode the subgops, dispatch each Gop to an available worker
308 fn encode<T: Pixel>(
309 &self, s: &rayon::ScopeFifo, workers: usize, r: Receiver<SubGop<T>>,
310 send_packet: Sender<Packet<T>>,
311 ) {
312 let (mut workers, recv) = workerpool(s, workers, self.clone());
313
314 s.spawn_fifo(move |_| {
315 let mut sg_send = workers.get_worker().unwrap();
316 for sb in r.iter() {
317 let end_gop = sb.end_gop;
318 let _ = sg_send.send(sb);
319
320 if end_gop {
321 sg_send = workers.get_worker().unwrap();
322 }
323 }
324 });
325
326 reassemble(recv, s, send_packet)
327 }
328
329 /// Create a single pass by-gop encoder channel
330 ///
331 /// Drop the `FrameSender<T>` endpoint to flush the encoder.
332 ///
333 /// # Errors
334 ///
335 /// - Returns `InvalidConfig` if configuration is invalid.
336 pub fn new_by_gop_channel<T: Pixel>(
337 &self, slots: usize,
338 ) -> Result<VideoDataChannel<T>, InvalidConfig> {
339 let rc = &self.rate_control;
340
341 if rc.emit_pass_data || rc.summary.is_some() {
342 return Err(InvalidConfig::RateControlConfigurationMismatch);
343 }
344
345 self.validate()?;
346
347 // TODO: make it user-settable
348 let input_len = self.enc.speed_settings.rdo_lookahead_frames as usize * 4;
349 let frame_limit = i32::MAX as u64;
350
351 let (send_frame, receive_frame) = bounded(input_len);
352 let (send_packet, receive_packet) = unbounded();
353
354 let cfg = self.clone();
355
356 let pool = self.new_thread_pool();
357
358 // TODO: move the accounting threads outside the threadpool
359 let run = move || {
360 let _ = rayon::scope_fifo(|s| {
361 let sg_recv = cfg.scenechange(s, receive_frame);
362 cfg.encode(s, slots, sg_recv, send_packet);
363 });
364 };
365
366 if let Some(pool) = pool {
367 pool.spawn_fifo(run);
368 } else {
369 rayon::spawn_fifo(run);
370 }
371
372 let channel = (
373 FrameSender::new(frame_limit, send_frame, Arc::new(self.enc.clone())),
374 PacketReceiver {
375 receiver: receive_packet,
376 config: Arc::new(self.enc.clone()),
377 },
378 );
379
380 Ok(channel)
381 }
382 }