1 use std::thread::JoinHandle;
2 use std::sync::mpsc::{Receiver, SyncSender, TrySendError};
5 use sdl2::render::Texture;
7 use nihav_core::frame::{NABufferType, NAVideoBuffer};
8 use nihav_core::formats::*;
9 use nihav_core::codecs::*;
10 use nihav_core::scale::*;
12 use super::{DecoderStuff, DecoderType, DecoderState, DecodingState, DispQueue, FrameRecord, PktSendEvent, FRAME_QUEUE_LEN};
14 static VDEC_STATE: DecoderState = DecoderState::new();
16 pub const FRAME_QUEUE_SIZE: usize = 25;
18 pub const SDL_RGB_FMT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
20 Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 3 }),
21 Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 3 }),
22 Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 3 }),
24 ], elem_size: 3, be: false, alpha: false, palette: false };
26 pub struct VideoDecoder {
27 yuv_pool: NAVideoBufferPool<u8>,
28 rgb_pool: NAVideoBufferPool<u8>,
36 oinfo_yuv: NAVideoInfo,
37 oinfo_rgb: NAVideoInfo,
41 pub fn new(width: usize, height: usize, tb_num: u32, tb_den: u32, dec: DecoderStuff) -> Self {
42 let ofmt_rgb = ScaleInfo { width, height, fmt: SDL_RGB_FMT };
43 let ofmt_yuv = ScaleInfo { width, height, fmt: YUV420_FORMAT };
44 let oinfo_rgb = NAVideoInfo { width, height, flipped: false, format: SDL_RGB_FMT, bits: 24 };
45 let oinfo_yuv = NAVideoInfo { width, height, flipped: false, format: YUV420_FORMAT, bits: 12 };
47 yuv_pool: NAVideoBufferPool::new(FRAME_QUEUE_SIZE),
48 rgb_pool: NAVideoBufferPool::new(FRAME_QUEUE_SIZE),
50 dec, ofmt_yuv, ofmt_rgb, oinfo_yuv, oinfo_rgb,
51 scaler: NAScale::new(ofmt_rgb, ofmt_rgb).expect("creating scaler failed"),
52 ifmt: NAVideoInfo { width: 0, height: 0, flipped: false, format: SDL_RGB_FMT, bits: 24 },
55 fn convert_buf(&mut self, bt: NABufferType, ts: u64) -> Option<FrameRecord> {
56 let vinfo = bt.get_video_info().expect("this should be a video buffer");
57 if self.ifmt.get_width() != vinfo.get_width() ||
58 self.ifmt.get_height() != vinfo.get_height() ||
59 self.ifmt.get_format() != vinfo.get_format() {
61 let sc_ifmt = ScaleInfo { width: self.ifmt.get_width(), height: self.ifmt.get_height(), fmt: self.ifmt.get_format() };
62 let do_yuv = self.ifmt.get_format().get_model().is_yuv();
63 let ofmt = if do_yuv { self.ofmt_yuv } else { self.ofmt_rgb };
64 self.scaler = NAScale::new(sc_ifmt, ofmt).expect("scaling should not fail");
66 let mut opic = if let ColorModel::YUV(_) = self.ifmt.get_format().get_model() {
67 self.yuv_pool.prealloc_video(self.oinfo_yuv, 2).expect("video frame pool allocation failure");
68 while self.yuv_pool.get_free().is_none() {
69 if VDEC_STATE.is_flushing() {
72 std::thread::yield_now();
74 NABufferType::Video(self.yuv_pool.get_free().expect("video frame pool should have a free frame"))
76 self.rgb_pool.prealloc_video(self.oinfo_rgb, 0).expect("video frame pool allocation failure");
77 while self.rgb_pool.get_free().is_none() {
78 if VDEC_STATE.is_flushing() {
81 std::thread::yield_now();
83 NABufferType::VideoPacked(self.rgb_pool.get_free().expect("video frame pool should have a free frame"))
85 let ret = self.scaler.convert(&bt, &mut opic);
86 if ret.is_err() { println!(" scaler error {:?}", ret.err()); return None; }
88 let time = NATimeInfo::ts_to_time(ts, 1000, self.tb_num, self.tb_den);
91 pub fn next_frame(&mut self, pkt: &NAPacket) -> Option<FrameRecord> {
93 DecoderType::Video(ref mut vdec, ref mut reord) => {
94 if let Ok(frm) = vdec.decode(&mut self.dec.dsupp, pkt) {
96 while let Some(frm) = 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);
104 DecoderType::VideoMT(ref mut vdec, ref mut reord) => {
105 let queue_id = reord.register_frame();
106 match vdec.queue_pkt(&mut self.dec.dsupp, pkt, queue_id) {
109 while !vdec.can_take_input() || vdec.has_output() {
110 match vdec.get_frame() {
112 reord.add_frame(frm, id);
115 reord.drop_frame(id);
116 if err != DecoderError::MissingReference {
117 println!("frame {} decoding error {:?}", id, err);
122 match vdec.queue_pkt(&mut self.dec.dsupp, pkt, queue_id) {
125 println!("still can't queue frame!");
126 VDEC_STATE.set_state(DecodingState::Error);
128 Err(err) => println!("queueing error {:?}", err),
131 Err(err) => println!("queueing error {:?}", err),
133 while let Some(frm) = reord.get_frame() {
134 let bt = frm.get_buffer();
135 if let NABufferType::None = bt { continue; }
136 let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
137 return self.convert_buf(bt, ts);
140 #[cfg(feature="hwaccel")]
141 DecoderType::VideoHW(ref mut vdec) => {
142 let _ = vdec.queue_pkt(pkt);
143 while let Some(frm) = vdec.get_frame() {
144 let bt = frm.get_buffer();
145 if let NABufferType::None = bt { continue; }
146 let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
147 return self.convert_buf(bt, ts);
150 _ => panic!("not a video decoder!"),
154 pub fn more_frames(&mut self, do_not_wait: bool) -> Option<FrameRecord> {
156 DecoderType::Video(ref mut _dec, ref mut reord) => {
157 while let Some(frm) = reord.get_frame() {
158 let bt = frm.get_buffer();
159 if let NABufferType::None = bt { continue; }
160 let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
161 return self.convert_buf(bt, ts);
164 DecoderType::VideoMT(ref mut vdec, ref mut reord) => {
165 let mut got_some = false;
166 while vdec.has_output() {
167 match vdec.get_frame() {
169 reord.add_frame(frm, id);
173 reord.drop_frame(id);
174 if err != DecoderError::MissingReference {
175 println!("frame {} decoding error {:?}", id, err);
180 if !got_some && !do_not_wait {
181 match vdec.get_frame() {
183 reord.add_frame(frm, id);
185 (Err(DecoderError::NoFrame), _) => {},
187 reord.drop_frame(id);
188 if err != DecoderError::MissingReference {
189 println!("frame {} decoding error {:?}", id, err);
194 while let Some(frm) = reord.get_frame() {
195 let bt = frm.get_buffer();
196 if let NABufferType::None = bt { continue; }
197 let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
198 return self.convert_buf(bt, ts);
201 #[cfg(feature="hwaccel")]
202 DecoderType::VideoHW(ref mut vdec) => {
203 while let Some(frm) = vdec.get_frame() {
204 let bt = frm.get_buffer();
205 if let NABufferType::None = bt { continue; }
206 let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
207 return self.convert_buf(bt, ts);
214 pub fn last_frame(&mut self) -> Option<FrameRecord> {
216 DecoderType::Video(ref mut _dec, ref mut reord) => {
217 while let Some(frm) = reord.get_last_frames() {
218 let bt = frm.get_buffer();
219 if let NABufferType::None = bt { continue; }
220 let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
221 return self.convert_buf(bt, ts);
224 DecoderType::VideoMT(ref mut _dec, ref mut reord) => {
225 while let Some(frm) = reord.get_last_frames() {
226 let bt = frm.get_buffer();
227 if let NABufferType::None = bt { continue; }
228 let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
229 return self.convert_buf(bt, ts);
232 #[cfg(feature="hwaccel")]
233 DecoderType::VideoHW(ref mut dec) => {
234 while let Some(frm) = dec.get_last_frames() {
235 let bt = frm.get_buffer();
236 if let NABufferType::None = bt { continue; }
237 let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
238 return self.convert_buf(bt, ts);
245 pub fn flush(&mut self) {
247 DecoderType::Video(ref mut dec, ref mut reord) => {
251 DecoderType::VideoMT(ref mut dec, ref mut reord) => {
255 #[cfg(feature="hwaccel")]
256 DecoderType::VideoHW(ref mut dec) => {
264 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<()> {
265 std::thread::Builder::new().name("vdecoder".to_string()).spawn(move ||{
266 VDEC_STATE.set_state(DecodingState::Waiting);
267 let mut vdec = VideoDecoder::new(width, height, tb_num, tb_den, video_dec);
268 let mut skip_mode = FrameSkipMode::None;
270 match vprecv.recv() {
271 Ok(PktSendEvent::Packet(pkt)) => {
272 if !VDEC_STATE.is_flushing() {
273 if let Some((buf, time)) = vdec.next_frame(&pkt) {
274 vfsend.send((buf, time)).expect("video frame should be sent");
276 while let Some((buf, time)) = vdec.more_frames(true) {
277 vfsend.send((buf, time)).expect("video frame should be sent");
281 Ok(PktSendEvent::GetFrames) => {
282 while let Some((buf, time)) = vdec.more_frames(false) {
283 vfsend.send((buf, time)).expect("video frame should be sent");
285 VDEC_STATE.set_state(DecodingState::Waiting);
287 Ok(PktSendEvent::Flush) => {
289 VDEC_STATE.set_state(DecodingState::Waiting);
291 Ok(PktSendEvent::End) => {
292 while vdec.yuv_pool.get_free().is_some() && vdec.rgb_pool.get_free().is_some() {
293 if let Some(frm) = vdec.last_frame() {
294 vfsend.send(frm).expect("video frame should be sent");
299 VDEC_STATE.set_state(DecodingState::End);
302 Ok(PktSendEvent::ImmediateEnd) => {
303 VDEC_STATE.set_state(DecodingState::End);
306 Ok(PktSendEvent::HurryUp) => {
307 skip_mode = skip_mode.advance();
308 if let DecoderType::Video(ref mut dec, ref mut _reord) = vdec.dec.dec {
309 println!("setting hurry up mode to {}", skip_mode.to_string());
310 dec.set_options(&[NAOption{
311 name: FRAME_SKIP_OPTION,
312 value: NAValue::String(skip_mode.to_string()),
325 fn advance(&self) -> Self;
328 impl Advance for FrameSkipMode {
329 fn advance(&self) -> Self {
331 FrameSkipMode::None => FrameSkipMode::KeyframesOnly,
332 FrameSkipMode::KeyframesOnly => FrameSkipMode::IntraOnly,
333 FrameSkipMode::IntraOnly => FrameSkipMode::None,
338 fn output_yuv(yuv_texture: &mut Texture, buf: &NAVideoBuffer<u8>, width: usize, height: usize) {
339 let src = buf.get_data();
340 let ysstride = buf.get_stride(0);
341 let ysrc = &src[buf.get_offset(0)..];
342 let usstride = buf.get_stride(2);
343 let usrc = &src[buf.get_offset(2)..];
344 let vsstride = buf.get_stride(1);
345 let vsrc = &src[buf.get_offset(1)..];
346 yuv_texture.with_lock(None, |buffer: &mut [u8], pitch: usize| {
347 let csize = pitch.min(width);
348 for (dline, sline) in buffer.chunks_exact_mut(pitch).take(height).zip(ysrc.chunks_exact(ysstride)) {
349 dline[..csize].copy_from_slice(&sline[..csize]);
351 let coff = pitch * height;
352 let csize = (pitch / 2).min(width / 2);
353 for (dline, sline) in buffer[coff..].chunks_exact_mut(pitch / 2).take(height/2).zip(vsrc.chunks(vsstride)) {
354 dline[..csize].copy_from_slice(&sline[..csize]);
356 let coff = pitch * height + (pitch / 2) * (height / 2);
357 for (dline, sline) in buffer[coff..].chunks_exact_mut(pitch / 2).take(height/2).zip(usrc.chunks(usstride)) {
358 dline[..csize].copy_from_slice(&sline[..csize]);
360 }).expect("surface should be locked");
364 pub struct VideoControl {
365 vqueue: Vec<PktSendEvent>,
366 vpsend: SyncSender<PktSendEvent>,
367 vfrecv: Receiver<FrameRecord>,
369 vthread: JoinHandle<()>,
373 pub fn new(video_dec: Option<DecoderStuff>, width: usize, height: usize, tb_num: u32, tb_den: u32) -> Self {
374 let (vpsend, vprecv) = std::sync::mpsc::sync_channel::<PktSendEvent>(0);
375 let (vfsend, vfrecv) = std::sync::mpsc::sync_channel::<FrameRecord>(FRAME_QUEUE_SIZE - 1);
377 VDEC_STATE.set_state(DecodingState::Normal);
379 let vthread = if let Some(video_dec) = video_dec {
380 start_video_decoding(width, height, tb_num, tb_den, video_dec, vprecv, vfsend)
382 thread::Builder::new().name("vdecoder-dummy".to_string()).spawn(move ||{
384 match vprecv.recv() {
385 Ok(PktSendEvent::End) => break,
386 Ok(PktSendEvent::ImmediateEnd) => break,
393 VDEC_STATE.set_state(DecodingState::End);
399 vqueue: Vec::with_capacity(FRAME_QUEUE_LEN),
405 pub fn flush(&mut self) {
407 VDEC_STATE.set_state(DecodingState::Flush);
409 let _ = self.vfrecv.try_recv();
411 let _ = self.vpsend.send(PktSendEvent::Flush);
412 while self.vfrecv.try_recv().is_ok() { }
414 pub fn get_queue_size(&self) -> usize { self.vqueue.len() }
415 pub fn is_filled(&self, size: usize) -> bool {
416 self.vqueue.len() >= size
418 pub fn try_send_video(&mut self, evt: PktSendEvent) -> bool {
419 if !self.vqueue.is_empty() {
420 self.vqueue.push(evt);
423 self.try_send_event(evt)
426 fn try_send_event(&mut self, evt: PktSendEvent) -> bool {
427 if let Err(TrySendError::Full(evt)) = self.vpsend.try_send(evt) {
428 self.vqueue.insert(0, evt);
434 pub fn try_send_queued(&mut self) -> bool {
435 while !self.vqueue.is_empty() {
436 let pkt = self.vqueue.remove(0);
437 if !self.try_send_event(pkt) {
443 pub fn is_video_end(&self) -> bool {
444 matches!(VDEC_STATE.get_state(), DecodingState::End | DecodingState::Error)
446 pub fn wait_for_frames(&mut self) -> Result<(), ()> {
447 VDEC_STATE.set_state(DecodingState::Prefetch);
448 self.try_send_event(PktSendEvent::GetFrames);
449 while !self.try_send_queued() {
452 match VDEC_STATE.get_state() {
453 DecodingState::Waiting => {
454 VDEC_STATE.set_state(DecodingState::Normal);
457 DecodingState::Prefetch => thread::yield_now(),
463 pub fn is_yuv(&self) -> bool { self.do_yuv }
465 pub fn fill(&mut self, disp_queue: &mut DispQueue) {
466 while !disp_queue.is_full() {
467 let is_empty = disp_queue.is_empty();
468 if let Ok((pic, time)) = self.vfrecv.try_recv() {
469 let buf = pic.get_vbuf().expect("video frame should be of u8 type");
470 self.do_yuv = buf.get_info().get_format().get_model().is_yuv();
471 let idx = disp_queue.end;
472 disp_queue.move_end();
473 let frm = &mut disp_queue.pool[idx];
475 let sstride = buf.get_stride(0);
476 let src = buf.get_data();
477 frm.rgb_tex.with_lock(None, |buffer: &mut [u8], pitch: usize| {
478 let csize = sstride.min(pitch);
479 for (dst, src) in buffer.chunks_mut(pitch).zip(src.chunks(sstride)) {
480 dst[..csize].copy_from_slice(&src[..csize]);
483 }).expect("surface should be locked");
485 output_yuv(&mut frm.yuv_tex, &buf, disp_queue.width, disp_queue.height);
488 frm.is_yuv = self.do_yuv;
491 disp_queue.first_ts = time;
493 disp_queue.last_ts = time;
500 pub fn finish(self) {
501 VDEC_STATE.set_state(DecodingState::Flush);
503 let _ = self.vfrecv.try_recv();
505 let _ = self.vpsend.send(PktSendEvent::ImmediateEnd);
506 self.vthread.join().unwrap();