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 | ||
37f130a7 | 13 | use super::{DecoderStuff, DecoderType, DispQueue, FrameRecord, PktSendEvent, FRAME_QUEUE_LEN}; |
69b93cb5 KS |
14 | |
15 | static SKIP_VDECODING: AtomicBool = AtomicBool::new(false); | |
16 | static VIDEO_END: AtomicBool = AtomicBool::new(false); | |
37f130a7 | 17 | static GET_FRAMES_END: AtomicBool = AtomicBool::new(false); |
69b93cb5 KS |
18 | |
19 | pub const FRAME_QUEUE_SIZE: usize = 25; | |
20 | ||
21 | pub const SDL_RGB_FMT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3, | |
22 | comp_info: [ | |
23 | Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 3 }), | |
24 | Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 3 }), | |
25 | Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 3 }), | |
26 | None, None | |
27 | ], elem_size: 3, be: false, alpha: false, palette: false }; | |
28 | ||
29 | pub struct VideoDecoder { | |
30 | yuv_pool: NAVideoBufferPool<u8>, | |
31 | rgb_pool: NAVideoBufferPool<u8>, | |
32 | tb_num: u32, | |
33 | tb_den: u32, | |
34 | dec: DecoderStuff, | |
35 | ifmt: NAVideoInfo, | |
36 | scaler: NAScale, | |
37 | ofmt_rgb: ScaleInfo, | |
38 | ofmt_yuv: ScaleInfo, | |
39 | oinfo_yuv: NAVideoInfo, | |
40 | oinfo_rgb: NAVideoInfo, | |
41 | } | |
42 | ||
43 | impl VideoDecoder { | |
44 | pub fn new(width: usize, height: usize, tb_num: u32, tb_den: u32, dec: DecoderStuff) -> Self { | |
45 | let ofmt_rgb = ScaleInfo { width, height, fmt: SDL_RGB_FMT }; | |
46 | let ofmt_yuv = ScaleInfo { width, height, fmt: YUV420_FORMAT }; | |
47 | let oinfo_rgb = NAVideoInfo { width, height, flipped: false, format: SDL_RGB_FMT, bits: 24 }; | |
48 | let oinfo_yuv = NAVideoInfo { width, height, flipped: false, format: YUV420_FORMAT, bits: 12 }; | |
49 | Self { | |
50 | yuv_pool: NAVideoBufferPool::new(FRAME_QUEUE_SIZE), | |
51 | rgb_pool: NAVideoBufferPool::new(FRAME_QUEUE_SIZE), | |
52 | tb_num, tb_den, | |
53 | dec, ofmt_yuv, ofmt_rgb, oinfo_yuv, oinfo_rgb, | |
54 | scaler: NAScale::new(ofmt_rgb, ofmt_rgb).unwrap(), | |
55 | ifmt: NAVideoInfo { width: 0, height: 0, flipped: false, format: SDL_RGB_FMT, bits: 24 }, | |
56 | } | |
57 | } | |
58 | fn convert_buf(&mut self, bt: NABufferType, ts: u64) -> Option<FrameRecord> { | |
59 | let vinfo = bt.get_video_info().unwrap(); | |
60 | if self.ifmt.get_width() != vinfo.get_width() || | |
61 | self.ifmt.get_height() != vinfo.get_height() || | |
62 | self.ifmt.get_format() != vinfo.get_format() { | |
63 | self.ifmt = vinfo; | |
64 | let sc_ifmt = ScaleInfo { width: self.ifmt.get_width(), height: self.ifmt.get_height(), fmt: self.ifmt.get_format() }; | |
65 | let do_yuv = if let ColorModel::YUV(_) = self.ifmt.get_format().get_model() { true } else { false }; | |
66 | let ofmt = if do_yuv { self.ofmt_yuv } else { self.ofmt_rgb }; | |
67 | self.scaler = NAScale::new(sc_ifmt, ofmt).unwrap(); | |
68 | } | |
69 | let mut opic = if let ColorModel::YUV(_) = self.ifmt.get_format().get_model() { | |
70 | self.yuv_pool.prealloc_video(self.oinfo_yuv, 2).unwrap(); | |
71 | while self.yuv_pool.get_free().is_none() { | |
72 | if SKIP_VDECODING.load(Ordering::Relaxed) { | |
73 | return None; | |
74 | } | |
75 | std::thread::yield_now(); | |
76 | } | |
77 | NABufferType::Video(self.yuv_pool.get_free().unwrap()) | |
78 | } else { | |
79 | self.rgb_pool.prealloc_video(self.oinfo_rgb, 0).unwrap(); | |
80 | while self.rgb_pool.get_free().is_none() { | |
81 | if SKIP_VDECODING.load(Ordering::Relaxed) { | |
82 | return None; | |
83 | } | |
84 | std::thread::yield_now(); | |
85 | } | |
86 | NABufferType::VideoPacked(self.rgb_pool.get_free().unwrap()) | |
87 | }; | |
88 | let ret = self.scaler.convert(&bt, &mut opic); | |
89 | if ret.is_err() { println!(" scaler error {:?}", ret.err()); return None; } | |
90 | ret.unwrap(); | |
91 | let time = NATimeInfo::ts_to_time(ts, 1000, self.tb_num, self.tb_den); | |
92 | Some((opic, time)) | |
93 | } | |
94 | pub fn next_frame(&mut self, pkt: &NAPacket) -> Option<FrameRecord> { | |
37f130a7 KS |
95 | match self.dec.dec { |
96 | DecoderType::Video(ref mut vdec, ref mut reord) => { | |
97 | if let Ok(frm) = vdec.decode(&mut self.dec.dsupp, pkt) { | |
98 | reord.add_frame(frm); | |
99 | while let Some(frm) = reord.get_frame() { | |
100 | let bt = frm.get_buffer(); | |
101 | if let NABufferType::None = bt { continue; } | |
102 | let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0)); | |
103 | return self.convert_buf(bt, ts); | |
104 | } | |
105 | } | |
106 | }, | |
107 | DecoderType::VideoMT(ref mut vdec, ref mut reord) => { | |
108 | let queue_id = reord.register_frame(); | |
109 | match vdec.queue_pkt(&mut self.dec.dsupp, &pkt, queue_id) { | |
110 | Ok(true) => {}, | |
111 | Ok(false) => { | |
112 | while !vdec.can_take_input() || vdec.has_output() { | |
113 | match vdec.get_frame() { | |
114 | (Ok(frm), id) => { | |
115 | reord.add_frame(frm, id); | |
116 | }, | |
117 | (Err(err), id) => { | |
118 | reord.drop_frame(id); | |
119 | panic!("frame {} decoding error {:?}", id, err); | |
120 | }, | |
121 | }; | |
122 | } | |
123 | match vdec.queue_pkt(&mut self.dec.dsupp, &pkt, queue_id) { | |
124 | Ok(true) => {}, | |
125 | Ok(false) => panic!("still can't queue frame!"), | |
126 | Err(err) => panic!("queueing error {:?}", err), | |
127 | }; | |
128 | }, | |
129 | Err(err) => panic!("queueing error {:?}", err), | |
130 | }; | |
131 | while let Some(frm) = reord.get_frame() { | |
132 | let bt = frm.get_buffer(); | |
133 | if let NABufferType::None = bt { continue; } | |
134 | let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0)); | |
135 | return self.convert_buf(bt, ts); | |
136 | } | |
137 | }, | |
138 | _ => panic!("not a video decoder!"), | |
139 | }; | |
140 | None | |
141 | } | |
142 | pub fn more_frames(&mut self, do_not_wait: bool) -> Option<FrameRecord> { | |
143 | match self.dec.dec { | |
144 | DecoderType::Video(ref mut _dec, ref mut reord) => { | |
145 | while let Some(frm) = reord.get_frame() { | |
146 | let bt = frm.get_buffer(); | |
147 | if let NABufferType::None = bt { continue; } | |
148 | let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0)); | |
149 | return self.convert_buf(bt, ts); | |
150 | } | |
151 | }, | |
152 | DecoderType::VideoMT(ref mut vdec, ref mut reord) => { | |
153 | let mut got_some = false; | |
154 | while vdec.has_output() { | |
155 | match vdec.get_frame() { | |
156 | (Ok(frm), id) => { | |
157 | reord.add_frame(frm, id); | |
158 | got_some = true; | |
159 | }, | |
160 | (Err(err), id) => { | |
161 | reord.drop_frame(id); | |
162 | panic!("frame {} decoding error {:?}", id, err); | |
163 | }, | |
164 | }; | |
165 | } | |
166 | if !got_some && !do_not_wait { | |
167 | match vdec.get_frame() { | |
168 | (Ok(frm), id) => { | |
169 | reord.add_frame(frm, id); | |
170 | }, | |
171 | (Err(DecoderError::NoFrame), _) => {}, | |
172 | (Err(err), id) => { | |
173 | reord.drop_frame(id); | |
174 | panic!("frame {} decoding error {:?}", id, err); | |
175 | }, | |
176 | }; | |
177 | } | |
178 | while let Some(frm) = reord.get_frame() { | |
179 | let bt = frm.get_buffer(); | |
180 | if let NABufferType::None = bt { continue; } | |
181 | let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0)); | |
182 | return self.convert_buf(bt, ts); | |
183 | } | |
184 | }, | |
185 | _ => {}, | |
186 | }; | |
69b93cb5 KS |
187 | None |
188 | } | |
189 | pub fn last_frame(&mut self) -> Option<FrameRecord> { | |
37f130a7 KS |
190 | match self.dec.dec { |
191 | DecoderType::Video(ref mut _dec, ref mut reord) => { | |
192 | while let Some(frm) = reord.get_last_frames() { | |
193 | let bt = frm.get_buffer(); | |
194 | if let NABufferType::None = bt { continue; } | |
195 | let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0)); | |
196 | return self.convert_buf(bt, ts); | |
197 | } | |
198 | }, | |
199 | DecoderType::VideoMT(ref mut _dec, ref mut reord) => { | |
200 | while let Some(frm) = reord.get_last_frames() { | |
201 | let bt = frm.get_buffer(); | |
202 | if let NABufferType::None = bt { continue; } | |
203 | let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0)); | |
204 | return self.convert_buf(bt, ts); | |
205 | } | |
206 | }, | |
207 | _ => {}, | |
208 | }; | |
69b93cb5 KS |
209 | None |
210 | } | |
211 | pub fn flush(&mut self) { | |
37f130a7 KS |
212 | match self.dec.dec { |
213 | DecoderType::Video(ref mut dec, ref mut reord) => { | |
214 | dec.flush(); | |
215 | reord.flush(); | |
216 | }, | |
217 | DecoderType::VideoMT(ref mut dec, ref mut reord) => { | |
218 | dec.flush(); | |
219 | reord.flush(); | |
220 | }, | |
221 | _ => {}, | |
222 | }; | |
69b93cb5 KS |
223 | } |
224 | } | |
225 | ||
226 | 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<()> { | |
227 | std::thread::Builder::new().name("vdecoder".to_string()).spawn(move ||{ | |
228 | SKIP_VDECODING.store(false, Ordering::Relaxed); | |
229 | let mut vdec = VideoDecoder::new(width, height, tb_num, tb_den, video_dec); | |
230 | let mut skip_mode = FrameSkipMode::None; | |
231 | loop { | |
232 | match vprecv.recv() { | |
233 | Ok(PktSendEvent::Packet(pkt)) => { | |
234 | if !SKIP_VDECODING.load(Ordering::Relaxed) { | |
235 | if let Some((buf, time)) = vdec.next_frame(&pkt) { | |
236 | vfsend.send((buf, time)).unwrap(); | |
237 | } | |
37f130a7 KS |
238 | while let Some((buf, time)) = vdec.more_frames(true) { |
239 | vfsend.send((buf, time)).unwrap(); | |
240 | } | |
241 | } | |
242 | }, | |
243 | Ok(PktSendEvent::GetFrames) => { | |
244 | while let Some((buf, time)) = vdec.more_frames(false) { | |
245 | vfsend.send((buf, time)).unwrap(); | |
69b93cb5 | 246 | } |
37f130a7 | 247 | GET_FRAMES_END.store(true, Ordering::Relaxed); |
69b93cb5 KS |
248 | }, |
249 | Ok(PktSendEvent::Flush) => { | |
250 | vdec.flush(); | |
251 | SKIP_VDECODING.store(false, Ordering::Relaxed); | |
252 | }, | |
253 | Ok(PktSendEvent::End) => { | |
254 | while vdec.yuv_pool.get_free().is_some() && vdec.rgb_pool.get_free().is_some() { | |
255 | let ret = vdec.last_frame(); | |
256 | if ret.is_none() { | |
257 | break; | |
258 | } | |
259 | vfsend.send(ret.unwrap()).unwrap(); | |
260 | } | |
261 | VIDEO_END.store(true, Ordering::Relaxed); | |
262 | break; | |
263 | }, | |
264 | Ok(PktSendEvent::ImmediateEnd) => { | |
265 | VIDEO_END.store(true, Ordering::Relaxed); | |
266 | break; | |
267 | }, | |
268 | Ok(PktSendEvent::HurryUp) => { | |
269 | skip_mode = skip_mode.advance(); | |
37f130a7 KS |
270 | if let DecoderType::Video(ref mut dec, ref mut _reord) = vdec.dec.dec { |
271 | dec.set_options(&[NAOption{ | |
69b93cb5 KS |
272 | name: FRAME_SKIP_OPTION, |
273 | value: NAValue::String(skip_mode.to_string()), | |
274 | }]); | |
37f130a7 | 275 | } |
69b93cb5 KS |
276 | }, |
277 | Err(_) => { | |
278 | break; | |
279 | }, | |
280 | }; | |
281 | } | |
282 | }).unwrap() | |
283 | } | |
284 | ||
285 | trait Advance { | |
286 | fn advance(&self) -> Self; | |
287 | } | |
288 | ||
289 | impl Advance for FrameSkipMode { | |
290 | fn advance(&self) -> Self { | |
291 | match *self { | |
292 | FrameSkipMode::None => FrameSkipMode::KeyframesOnly, | |
293 | FrameSkipMode::KeyframesOnly => FrameSkipMode::IntraOnly, | |
294 | FrameSkipMode::IntraOnly => FrameSkipMode::None, | |
295 | } | |
296 | } | |
297 | } | |
298 | ||
299 | fn output_yuv(yuv_texture: &mut Texture, buf: &NAVideoBuffer<u8>, width: usize, height: usize) { | |
300 | let src = buf.get_data(); | |
301 | let ysstride = buf.get_stride(0); | |
302 | let ysrc = &src[buf.get_offset(0)..]; | |
303 | let usstride = buf.get_stride(2); | |
304 | let usrc = &src[buf.get_offset(2)..]; | |
305 | let vsstride = buf.get_stride(1); | |
306 | let vsrc = &src[buf.get_offset(1)..]; | |
307 | yuv_texture.with_lock(None, |buffer: &mut [u8], pitch: usize| { | |
308 | let csize = pitch.min(width); | |
309 | for (dline, sline) in buffer.chunks_exact_mut(pitch).take(height).zip(ysrc.chunks_exact(ysstride)) { | |
310 | dline[..csize].copy_from_slice(&sline[..csize]); | |
311 | } | |
312 | let coff = pitch * height; | |
313 | let csize = (pitch / 2).min(width / 2); | |
314 | for (dline, sline) in buffer[coff..].chunks_exact_mut(pitch / 2).take(height/2).zip(vsrc.chunks(vsstride)) { | |
315 | dline[..csize].copy_from_slice(&sline[..csize]); | |
316 | } | |
317 | let coff = pitch * height + (pitch / 2) * (height / 2); | |
318 | for (dline, sline) in buffer[coff..].chunks_exact_mut(pitch / 2).take(height/2).zip(usrc.chunks(usstride)) { | |
319 | dline[..csize].copy_from_slice(&sline[..csize]); | |
320 | } | |
321 | }).unwrap(); | |
322 | } | |
323 | ||
324 | ||
325 | pub struct VideoControl { | |
326 | vqueue: Vec<PktSendEvent>, | |
327 | vpsend: SyncSender<PktSendEvent>, | |
328 | vfrecv: Receiver<FrameRecord>, | |
329 | do_yuv: bool, | |
330 | vthread: JoinHandle<()>, | |
331 | } | |
332 | ||
333 | impl VideoControl { | |
334 | pub fn new(video_dec: Option<DecoderStuff>, width: usize, height: usize, tb_num: u32, tb_den: u32) -> Self { | |
335 | let (vpsend, vprecv) = std::sync::mpsc::sync_channel::<PktSendEvent>(0); | |
336 | let (vfsend, vfrecv) = std::sync::mpsc::sync_channel::<FrameRecord>(FRAME_QUEUE_SIZE - 1); | |
337 | ||
338 | VIDEO_END.store(false, Ordering::Relaxed); | |
339 | ||
340 | let vthread = if let Some(video_dec) = video_dec { | |
341 | start_video_decoding(width, height, tb_num, tb_den, video_dec, vprecv, vfsend) | |
342 | } else { | |
343 | thread::Builder::new().name("vdecoder-dummy".to_string()).spawn(move ||{ | |
344 | loop { | |
345 | match vprecv.recv() { | |
346 | Ok(PktSendEvent::End) => break, | |
347 | Ok(PktSendEvent::ImmediateEnd) => break, | |
348 | Err(_) => { | |
349 | break; | |
350 | }, | |
351 | _ => {}, | |
352 | }; | |
353 | } | |
354 | }).unwrap() | |
355 | }; | |
356 | ||
357 | ||
358 | Self { | |
359 | vqueue: Vec::with_capacity(FRAME_QUEUE_LEN), | |
360 | vpsend, vfrecv, | |
361 | do_yuv: false, | |
362 | vthread, | |
363 | } | |
364 | } | |
365 | pub fn flush(&mut self) { | |
b5053bfc | 366 | self.vqueue.clear(); |
69b93cb5 KS |
367 | SKIP_VDECODING.store(true, Ordering::Release); |
368 | for _ in 0..8 { | |
369 | let _ = self.vfrecv.try_recv(); | |
370 | } | |
371 | let _ = self.vpsend.send(PktSendEvent::Flush); | |
372 | while self.vfrecv.try_recv().is_ok() { } | |
373 | } | |
374 | pub fn get_queue_size(&self) -> usize { self.vqueue.len() } | |
375 | pub fn is_filled(&self, size: usize) -> bool { | |
376 | self.vqueue.len() >= size | |
377 | } | |
378 | pub fn try_send_video(&mut self, evt: PktSendEvent) -> bool { | |
379 | if self.vqueue.len() > 0 { | |
380 | self.vqueue.push(evt); | |
381 | false | |
382 | } else { | |
383 | self.try_send_event(evt) | |
384 | } | |
385 | } | |
386 | fn try_send_event(&mut self, evt: PktSendEvent) -> bool { | |
387 | if let Err(TrySendError::Full(evt)) = self.vpsend.try_send(evt) { | |
388 | self.vqueue.insert(0, evt); | |
389 | false | |
390 | } else { | |
391 | true | |
392 | } | |
393 | } | |
394 | pub fn try_send_queued(&mut self) -> bool { | |
395 | while !self.vqueue.is_empty() { | |
396 | let pkt = self.vqueue.remove(0); | |
397 | if !self.try_send_event(pkt) { | |
398 | return false; | |
399 | } | |
400 | } | |
401 | true | |
402 | } | |
403 | pub fn is_video_end(&self) -> bool { | |
404 | VIDEO_END.load(Ordering::Relaxed) | |
405 | } | |
37f130a7 KS |
406 | pub fn wait_for_frames(&mut self) { |
407 | GET_FRAMES_END.store(false, Ordering::Relaxed); | |
408 | self.try_send_event(PktSendEvent::GetFrames); | |
409 | while !self.try_send_queued() { | |
410 | } | |
411 | while !GET_FRAMES_END.load(Ordering::Relaxed) { | |
412 | thread::yield_now(); | |
413 | } | |
414 | } | |
69b93cb5 KS |
415 | |
416 | pub fn is_yuv(&self) -> bool { self.do_yuv } | |
417 | ||
418 | pub fn fill(&mut self, disp_queue: &mut DispQueue) { | |
419 | while !disp_queue.is_full() { | |
420 | let is_empty = disp_queue.is_empty(); | |
421 | if let Ok((pic, time)) = self.vfrecv.try_recv() { | |
422 | let buf = pic.get_vbuf().unwrap(); | |
423 | self.do_yuv = buf.get_info().get_format().get_model().is_yuv(); | |
424 | let idx = disp_queue.end; | |
425 | disp_queue.move_end(); | |
426 | let frm = &mut disp_queue.pool[idx]; | |
427 | if !self.do_yuv { | |
428 | let sstride = buf.get_stride(0); | |
429 | let src = buf.get_data(); | |
430 | frm.rgb_tex.with_lock(None, |buffer: &mut [u8], pitch: usize| { | |
431 | let csize = sstride.min(pitch); | |
432 | for (dst, src) in buffer.chunks_mut(pitch).zip(src.chunks(sstride)) { | |
433 | (&mut dst[..csize]).copy_from_slice(&src[..csize]); | |
434 | } | |
435 | true | |
436 | }).unwrap(); | |
437 | } else { | |
438 | output_yuv(&mut frm.yuv_tex, &buf, disp_queue.width, disp_queue.height); | |
439 | } | |
440 | frm.valid = true; | |
441 | frm.is_yuv = self.do_yuv; | |
442 | frm.ts = time; | |
443 | if is_empty { | |
444 | disp_queue.first_ts = time; | |
445 | } | |
446 | disp_queue.last_ts = time; | |
447 | } else { | |
448 | break; | |
449 | } | |
450 | } | |
451 | } | |
452 | ||
453 | pub fn finish(self) { | |
454 | SKIP_VDECODING.store(true, Ordering::Release); | |
455 | for _ in 0..8 { | |
456 | let _ = self.vfrecv.try_recv(); | |
457 | } | |
458 | let _ = self.vpsend.send(PktSendEvent::ImmediateEnd); | |
459 | self.vthread.join().unwrap(); | |
460 | } | |
461 | } |