]>
Commit | Line | Data |
---|---|---|
69b93cb5 KS |
1 | use std::thread::JoinHandle; |
2 | use std::sync::atomic::{AtomicBool, Ordering}; | |
3 | use std::sync::mpsc::{Receiver, SyncSender, TrySendError}; | |
4 | use std::thread; | |
5 | ||
6 | use sdl2::render::Texture; | |
7 | ||
8 | use nihav_core::frame::{NABufferType, NAVideoBuffer}; | |
9 | use nihav_core::formats::*; | |
10 | use nihav_core::codecs::*; | |
11 | use nihav_core::scale::*; | |
12 | ||
13 | use super::{DecoderStuff, DispQueue, FrameRecord, PktSendEvent, FRAME_QUEUE_LEN}; | |
14 | ||
15 | static SKIP_VDECODING: AtomicBool = AtomicBool::new(false); | |
16 | static VIDEO_END: AtomicBool = AtomicBool::new(false); | |
17 | ||
18 | pub const FRAME_QUEUE_SIZE: usize = 25; | |
19 | ||
20 | pub const SDL_RGB_FMT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3, | |
21 | comp_info: [ | |
22 | Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 3 }), | |
23 | Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 3 }), | |
24 | Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 3 }), | |
25 | None, None | |
26 | ], elem_size: 3, be: false, alpha: false, palette: false }; | |
27 | ||
28 | pub struct VideoDecoder { | |
29 | yuv_pool: NAVideoBufferPool<u8>, | |
30 | rgb_pool: NAVideoBufferPool<u8>, | |
31 | tb_num: u32, | |
32 | tb_den: u32, | |
33 | dec: DecoderStuff, | |
34 | ifmt: NAVideoInfo, | |
35 | scaler: NAScale, | |
36 | ofmt_rgb: ScaleInfo, | |
37 | ofmt_yuv: ScaleInfo, | |
38 | oinfo_yuv: NAVideoInfo, | |
39 | oinfo_rgb: NAVideoInfo, | |
40 | } | |
41 | ||
42 | impl VideoDecoder { | |
43 | pub fn new(width: usize, height: usize, tb_num: u32, tb_den: u32, dec: DecoderStuff) -> Self { | |
44 | let ofmt_rgb = ScaleInfo { width, height, fmt: SDL_RGB_FMT }; | |
45 | let ofmt_yuv = ScaleInfo { width, height, fmt: YUV420_FORMAT }; | |
46 | let oinfo_rgb = NAVideoInfo { width, height, flipped: false, format: SDL_RGB_FMT, bits: 24 }; | |
47 | let oinfo_yuv = NAVideoInfo { width, height, flipped: false, format: YUV420_FORMAT, bits: 12 }; | |
48 | Self { | |
49 | yuv_pool: NAVideoBufferPool::new(FRAME_QUEUE_SIZE), | |
50 | rgb_pool: NAVideoBufferPool::new(FRAME_QUEUE_SIZE), | |
51 | tb_num, tb_den, | |
52 | dec, ofmt_yuv, ofmt_rgb, oinfo_yuv, oinfo_rgb, | |
53 | scaler: NAScale::new(ofmt_rgb, ofmt_rgb).unwrap(), | |
54 | ifmt: NAVideoInfo { width: 0, height: 0, flipped: false, format: SDL_RGB_FMT, bits: 24 }, | |
55 | } | |
56 | } | |
57 | fn convert_buf(&mut self, bt: NABufferType, ts: u64) -> Option<FrameRecord> { | |
58 | let vinfo = bt.get_video_info().unwrap(); | |
59 | if self.ifmt.get_width() != vinfo.get_width() || | |
60 | self.ifmt.get_height() != vinfo.get_height() || | |
61 | self.ifmt.get_format() != vinfo.get_format() { | |
62 | self.ifmt = vinfo; | |
63 | let sc_ifmt = ScaleInfo { width: self.ifmt.get_width(), height: self.ifmt.get_height(), fmt: self.ifmt.get_format() }; | |
64 | let do_yuv = if let ColorModel::YUV(_) = self.ifmt.get_format().get_model() { true } else { false }; | |
65 | let ofmt = if do_yuv { self.ofmt_yuv } else { self.ofmt_rgb }; | |
66 | self.scaler = NAScale::new(sc_ifmt, ofmt).unwrap(); | |
67 | } | |
68 | let mut opic = if let ColorModel::YUV(_) = self.ifmt.get_format().get_model() { | |
69 | self.yuv_pool.prealloc_video(self.oinfo_yuv, 2).unwrap(); | |
70 | while self.yuv_pool.get_free().is_none() { | |
71 | if SKIP_VDECODING.load(Ordering::Relaxed) { | |
72 | return None; | |
73 | } | |
74 | std::thread::yield_now(); | |
75 | } | |
76 | NABufferType::Video(self.yuv_pool.get_free().unwrap()) | |
77 | } else { | |
78 | self.rgb_pool.prealloc_video(self.oinfo_rgb, 0).unwrap(); | |
79 | while self.rgb_pool.get_free().is_none() { | |
80 | if SKIP_VDECODING.load(Ordering::Relaxed) { | |
81 | return None; | |
82 | } | |
83 | std::thread::yield_now(); | |
84 | } | |
85 | NABufferType::VideoPacked(self.rgb_pool.get_free().unwrap()) | |
86 | }; | |
87 | let ret = self.scaler.convert(&bt, &mut opic); | |
88 | if ret.is_err() { println!(" scaler error {:?}", ret.err()); return None; } | |
89 | ret.unwrap(); | |
90 | let time = NATimeInfo::ts_to_time(ts, 1000, self.tb_num, self.tb_den); | |
91 | Some((opic, time)) | |
92 | } | |
93 | pub fn next_frame(&mut self, pkt: &NAPacket) -> Option<FrameRecord> { | |
94 | if let Ok(frm) = self.dec.dec.decode(&mut self.dec.dsupp, pkt) { | |
95 | self.dec.reord.add_frame(frm); | |
96 | while let Some(frm) = self.dec.reord.get_frame() { | |
97 | let bt = frm.get_buffer(); | |
98 | if let NABufferType::None = bt { continue; } | |
99 | let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0)); | |
100 | return self.convert_buf(bt, ts); | |
101 | } | |
102 | } | |
103 | None | |
104 | } | |
105 | pub fn last_frame(&mut self) -> Option<FrameRecord> { | |
106 | while let Some(frm) = self.dec.reord.get_last_frames() { | |
107 | let bt = frm.get_buffer(); | |
108 | if let NABufferType::None = bt { continue; } | |
109 | let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0)); | |
110 | return self.convert_buf(bt, ts); | |
111 | } | |
112 | None | |
113 | } | |
114 | pub fn flush(&mut self) { | |
115 | self.dec.dec.flush(); | |
116 | self.dec.reord.flush(); | |
117 | } | |
118 | } | |
119 | ||
120 | fn start_video_decoding(width: usize, height: usize, tb_num: u32, tb_den: u32, video_dec: DecoderStuff, vprecv: Receiver<PktSendEvent>, vfsend: SyncSender<(NABufferType, u64)>) -> JoinHandle<()> { | |
121 | std::thread::Builder::new().name("vdecoder".to_string()).spawn(move ||{ | |
122 | SKIP_VDECODING.store(false, Ordering::Relaxed); | |
123 | let mut vdec = VideoDecoder::new(width, height, tb_num, tb_den, video_dec); | |
124 | let mut skip_mode = FrameSkipMode::None; | |
125 | loop { | |
126 | match vprecv.recv() { | |
127 | Ok(PktSendEvent::Packet(pkt)) => { | |
128 | if !SKIP_VDECODING.load(Ordering::Relaxed) { | |
129 | if let Some((buf, time)) = vdec.next_frame(&pkt) { | |
130 | vfsend.send((buf, time)).unwrap(); | |
131 | } | |
132 | } | |
133 | }, | |
134 | Ok(PktSendEvent::Flush) => { | |
135 | vdec.flush(); | |
136 | SKIP_VDECODING.store(false, Ordering::Relaxed); | |
137 | }, | |
138 | Ok(PktSendEvent::End) => { | |
139 | while vdec.yuv_pool.get_free().is_some() && vdec.rgb_pool.get_free().is_some() { | |
140 | let ret = vdec.last_frame(); | |
141 | if ret.is_none() { | |
142 | break; | |
143 | } | |
144 | vfsend.send(ret.unwrap()).unwrap(); | |
145 | } | |
146 | VIDEO_END.store(true, Ordering::Relaxed); | |
147 | break; | |
148 | }, | |
149 | Ok(PktSendEvent::ImmediateEnd) => { | |
150 | VIDEO_END.store(true, Ordering::Relaxed); | |
151 | break; | |
152 | }, | |
153 | Ok(PktSendEvent::HurryUp) => { | |
154 | skip_mode = skip_mode.advance(); | |
155 | vdec.dec.dec.set_options(&[NAOption{ | |
156 | name: FRAME_SKIP_OPTION, | |
157 | value: NAValue::String(skip_mode.to_string()), | |
158 | }]); | |
159 | }, | |
160 | Err(_) => { | |
161 | break; | |
162 | }, | |
163 | }; | |
164 | } | |
165 | }).unwrap() | |
166 | } | |
167 | ||
168 | trait Advance { | |
169 | fn advance(&self) -> Self; | |
170 | } | |
171 | ||
172 | impl Advance for FrameSkipMode { | |
173 | fn advance(&self) -> Self { | |
174 | match *self { | |
175 | FrameSkipMode::None => FrameSkipMode::KeyframesOnly, | |
176 | FrameSkipMode::KeyframesOnly => FrameSkipMode::IntraOnly, | |
177 | FrameSkipMode::IntraOnly => FrameSkipMode::None, | |
178 | } | |
179 | } | |
180 | } | |
181 | ||
182 | fn output_yuv(yuv_texture: &mut Texture, buf: &NAVideoBuffer<u8>, width: usize, height: usize) { | |
183 | let src = buf.get_data(); | |
184 | let ysstride = buf.get_stride(0); | |
185 | let ysrc = &src[buf.get_offset(0)..]; | |
186 | let usstride = buf.get_stride(2); | |
187 | let usrc = &src[buf.get_offset(2)..]; | |
188 | let vsstride = buf.get_stride(1); | |
189 | let vsrc = &src[buf.get_offset(1)..]; | |
190 | yuv_texture.with_lock(None, |buffer: &mut [u8], pitch: usize| { | |
191 | let csize = pitch.min(width); | |
192 | for (dline, sline) in buffer.chunks_exact_mut(pitch).take(height).zip(ysrc.chunks_exact(ysstride)) { | |
193 | dline[..csize].copy_from_slice(&sline[..csize]); | |
194 | } | |
195 | let coff = pitch * height; | |
196 | let csize = (pitch / 2).min(width / 2); | |
197 | for (dline, sline) in buffer[coff..].chunks_exact_mut(pitch / 2).take(height/2).zip(vsrc.chunks(vsstride)) { | |
198 | dline[..csize].copy_from_slice(&sline[..csize]); | |
199 | } | |
200 | let coff = pitch * height + (pitch / 2) * (height / 2); | |
201 | for (dline, sline) in buffer[coff..].chunks_exact_mut(pitch / 2).take(height/2).zip(usrc.chunks(usstride)) { | |
202 | dline[..csize].copy_from_slice(&sline[..csize]); | |
203 | } | |
204 | }).unwrap(); | |
205 | } | |
206 | ||
207 | ||
208 | pub struct VideoControl { | |
209 | vqueue: Vec<PktSendEvent>, | |
210 | vpsend: SyncSender<PktSendEvent>, | |
211 | vfrecv: Receiver<FrameRecord>, | |
212 | do_yuv: bool, | |
213 | vthread: JoinHandle<()>, | |
214 | } | |
215 | ||
216 | impl VideoControl { | |
217 | pub fn new(video_dec: Option<DecoderStuff>, width: usize, height: usize, tb_num: u32, tb_den: u32) -> Self { | |
218 | let (vpsend, vprecv) = std::sync::mpsc::sync_channel::<PktSendEvent>(0); | |
219 | let (vfsend, vfrecv) = std::sync::mpsc::sync_channel::<FrameRecord>(FRAME_QUEUE_SIZE - 1); | |
220 | ||
221 | VIDEO_END.store(false, Ordering::Relaxed); | |
222 | ||
223 | let vthread = if let Some(video_dec) = video_dec { | |
224 | start_video_decoding(width, height, tb_num, tb_den, video_dec, vprecv, vfsend) | |
225 | } else { | |
226 | thread::Builder::new().name("vdecoder-dummy".to_string()).spawn(move ||{ | |
227 | loop { | |
228 | match vprecv.recv() { | |
229 | Ok(PktSendEvent::End) => break, | |
230 | Ok(PktSendEvent::ImmediateEnd) => break, | |
231 | Err(_) => { | |
232 | break; | |
233 | }, | |
234 | _ => {}, | |
235 | }; | |
236 | } | |
237 | }).unwrap() | |
238 | }; | |
239 | ||
240 | ||
241 | Self { | |
242 | vqueue: Vec::with_capacity(FRAME_QUEUE_LEN), | |
243 | vpsend, vfrecv, | |
244 | do_yuv: false, | |
245 | vthread, | |
246 | } | |
247 | } | |
248 | pub fn flush(&mut self) { | |
b5053bfc | 249 | self.vqueue.clear(); |
69b93cb5 KS |
250 | SKIP_VDECODING.store(true, Ordering::Release); |
251 | for _ in 0..8 { | |
252 | let _ = self.vfrecv.try_recv(); | |
253 | } | |
254 | let _ = self.vpsend.send(PktSendEvent::Flush); | |
255 | while self.vfrecv.try_recv().is_ok() { } | |
256 | } | |
257 | pub fn get_queue_size(&self) -> usize { self.vqueue.len() } | |
258 | pub fn is_filled(&self, size: usize) -> bool { | |
259 | self.vqueue.len() >= size | |
260 | } | |
261 | pub fn try_send_video(&mut self, evt: PktSendEvent) -> bool { | |
262 | if self.vqueue.len() > 0 { | |
263 | self.vqueue.push(evt); | |
264 | false | |
265 | } else { | |
266 | self.try_send_event(evt) | |
267 | } | |
268 | } | |
269 | fn try_send_event(&mut self, evt: PktSendEvent) -> bool { | |
270 | if let Err(TrySendError::Full(evt)) = self.vpsend.try_send(evt) { | |
271 | self.vqueue.insert(0, evt); | |
272 | false | |
273 | } else { | |
274 | true | |
275 | } | |
276 | } | |
277 | pub fn try_send_queued(&mut self) -> bool { | |
278 | while !self.vqueue.is_empty() { | |
279 | let pkt = self.vqueue.remove(0); | |
280 | if !self.try_send_event(pkt) { | |
281 | return false; | |
282 | } | |
283 | } | |
284 | true | |
285 | } | |
286 | pub fn is_video_end(&self) -> bool { | |
287 | VIDEO_END.load(Ordering::Relaxed) | |
288 | } | |
289 | ||
290 | pub fn is_yuv(&self) -> bool { self.do_yuv } | |
291 | ||
292 | pub fn fill(&mut self, disp_queue: &mut DispQueue) { | |
293 | while !disp_queue.is_full() { | |
294 | let is_empty = disp_queue.is_empty(); | |
295 | if let Ok((pic, time)) = self.vfrecv.try_recv() { | |
296 | let buf = pic.get_vbuf().unwrap(); | |
297 | self.do_yuv = buf.get_info().get_format().get_model().is_yuv(); | |
298 | let idx = disp_queue.end; | |
299 | disp_queue.move_end(); | |
300 | let frm = &mut disp_queue.pool[idx]; | |
301 | if !self.do_yuv { | |
302 | let sstride = buf.get_stride(0); | |
303 | let src = buf.get_data(); | |
304 | frm.rgb_tex.with_lock(None, |buffer: &mut [u8], pitch: usize| { | |
305 | let csize = sstride.min(pitch); | |
306 | for (dst, src) in buffer.chunks_mut(pitch).zip(src.chunks(sstride)) { | |
307 | (&mut dst[..csize]).copy_from_slice(&src[..csize]); | |
308 | } | |
309 | true | |
310 | }).unwrap(); | |
311 | } else { | |
312 | output_yuv(&mut frm.yuv_tex, &buf, disp_queue.width, disp_queue.height); | |
313 | } | |
314 | frm.valid = true; | |
315 | frm.is_yuv = self.do_yuv; | |
316 | frm.ts = time; | |
317 | if is_empty { | |
318 | disp_queue.first_ts = time; | |
319 | } | |
320 | disp_queue.last_ts = time; | |
321 | } else { | |
322 | break; | |
323 | } | |
324 | } | |
325 | } | |
326 | ||
327 | pub fn finish(self) { | |
328 | SKIP_VDECODING.store(true, Ordering::Release); | |
329 | for _ in 0..8 { | |
330 | let _ = self.vfrecv.try_recv(); | |
331 | } | |
332 | let _ = self.vpsend.send(PktSendEvent::ImmediateEnd); | |
333 | self.vthread.join().unwrap(); | |
334 | } | |
335 | } |