[nihav-player.git] / videoplayer / src / videodec.rs

use std::thread::JoinHandle;
use std::sync::mpsc::{Receiver, SyncSender, TrySendError};
use std::thread;

use sdl2::render::Texture;

use nihav_core::frame::{NABufferType, NAVideoBuffer};
use nihav_core::formats::*;
use nihav_core::codecs::*;
use nihav_core::scale::*;

use super::{DecoderStuff, DecoderType, DecoderState, DecodingState, DispQueue, FrameRecord, PktSendEvent, FRAME_QUEUE_LEN};

static VDEC_STATE: DecoderState = DecoderState::new();

pub const FRAME_QUEUE_SIZE: usize = 25;

pub const SDL_RGB_FMT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
    comp_info: [
        Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 0, next_elem: 3 }),
        Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 1, next_elem: 3 }),
        Some(NAPixelChromaton { h_ss: 0, v_ss: 0, packed: true, depth: 8, shift: 0, comp_offs: 2, next_elem: 3 }),
        None, None
    ], elem_size: 3, be: false, alpha: false, palette: false };

pub struct VideoDecoder {
    yuv_pool:   NAVideoBufferPool<u8>,
    rgb_pool:   NAVideoBufferPool<u8>,
    tb_num:     u32,
    tb_den:     u32,
    dec:        DecoderStuff,
    ifmt:       NAVideoInfo,
    scaler:     NAScale,
    ofmt_rgb:   ScaleInfo,
    ofmt_yuv:   ScaleInfo,
    oinfo_yuv:  NAVideoInfo,
    oinfo_rgb:  NAVideoInfo,
}

impl VideoDecoder {
    pub fn new(width: usize, height: usize, tb_num: u32, tb_den: u32, dec: DecoderStuff) -> Self {
        let ofmt_rgb = ScaleInfo { width, height, fmt: SDL_RGB_FMT };
        let ofmt_yuv = ScaleInfo { width, height, fmt: YUV420_FORMAT };
        let oinfo_rgb = NAVideoInfo { width, height, flipped: false, format: SDL_RGB_FMT, bits: 24 };
        let oinfo_yuv = NAVideoInfo { width, height, flipped: false, format: YUV420_FORMAT, bits: 12 };
        Self {
            yuv_pool:   NAVideoBufferPool::new(FRAME_QUEUE_SIZE),
            rgb_pool:   NAVideoBufferPool::new(FRAME_QUEUE_SIZE),
            tb_num, tb_den,
            dec, ofmt_yuv, ofmt_rgb, oinfo_yuv, oinfo_rgb,
            scaler:     NAScale::new(ofmt_rgb, ofmt_rgb).expect("creating scaler failed"),
            ifmt:       NAVideoInfo { width: 0, height: 0, flipped: false, format: SDL_RGB_FMT, bits: 24 },
        }
    }
    fn convert_buf(&mut self, bt: NABufferType, ts: u64) -> Option<FrameRecord> {
        let vinfo = bt.get_video_info().expect("this should be a video buffer");
        if self.ifmt.get_width() != vinfo.get_width() ||
            self.ifmt.get_height() != vinfo.get_height() ||
            self.ifmt.get_format() != vinfo.get_format() {
            self.ifmt = vinfo;
            let sc_ifmt = ScaleInfo { width: self.ifmt.get_width(), height: self.ifmt.get_height(), fmt: self.ifmt.get_format() };
            let do_yuv = self.ifmt.get_format().get_model().is_yuv();
            let ofmt = if do_yuv { self.ofmt_yuv } else { self.ofmt_rgb };
            self.scaler = NAScale::new(sc_ifmt, ofmt).expect("scaling should not fail");
        }
        let mut opic = if let ColorModel::YUV(_) = self.ifmt.get_format().get_model() {
                self.yuv_pool.prealloc_video(self.oinfo_yuv, 2).expect("video frame pool allocation failure");
                while self.yuv_pool.get_free().is_none() {
                    if VDEC_STATE.is_flushing() {
                        return None;
                    }
                    std::thread::yield_now();
                }
                NABufferType::Video(self.yuv_pool.get_free().expect("video frame pool should have a free frame"))
            } else {
                self.rgb_pool.prealloc_video(self.oinfo_rgb, 0).expect("video frame pool allocation failure");
                while self.rgb_pool.get_free().is_none() {
                    if VDEC_STATE.is_flushing() {
                        return None;
                    }
                    std::thread::yield_now();
                }
                NABufferType::VideoPacked(self.rgb_pool.get_free().expect("video frame pool should have a free frame"))
            };
        let ret = self.scaler.convert(&bt, &mut opic);
        if ret.is_err() { println!(" scaler error {:?}", ret.err()); return None; }
        ret.unwrap();
        let time = NATimeInfo::ts_to_time(ts, 1000, self.tb_num, self.tb_den);
        Some((opic, time))
    }
    pub fn next_frame(&mut self, pkt: &NAPacket) -> Option<FrameRecord> {
        match self.dec.dec {
            DecoderType::Video(ref mut vdec, ref mut reord) => {
                if let Ok(frm) = vdec.decode(&mut self.dec.dsupp, pkt) {
                    reord.add_frame(frm);
                    while let Some(frm) = reord.get_frame() {
                        let bt = frm.get_buffer();
                        if let NABufferType::None = bt { continue; }
                        let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
                        return self.convert_buf(bt, ts);
                    }
                }
            },
            DecoderType::VideoMT(ref mut vdec, ref mut reord) => {
                let queue_id = reord.register_frame();
                match vdec.queue_pkt(&mut self.dec.dsupp, pkt, queue_id) {
                    Ok(true) => {},
                    Ok(false) => {
                        while !vdec.can_take_input() || vdec.has_output() {
                            match vdec.get_frame() {
                                (Ok(frm), id) => {
                                    reord.add_frame(frm, id);
                                },
                                (Err(err), id) => {
                                    reord.drop_frame(id);
                                    if err != DecoderError::MissingReference {
                                        println!("frame {} decoding error {:?}", id, err);
                                    }
                                },
                            };
                        }
                        match vdec.queue_pkt(&mut self.dec.dsupp, pkt, queue_id) {
                            Ok(true) => {},
                            Ok(false) => {
                                println!("still can't queue frame!");
                                VDEC_STATE.set_state(DecodingState::Error);
                            },
                            Err(err) => println!("queueing error {:?}", err),
                        };
                    },
                    Err(err) => println!("queueing error {:?}", err),
                };
                while let Some(frm) = reord.get_frame() {
                    let bt = frm.get_buffer();
                    if let NABufferType::None = bt { continue; }
                    let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
                    return self.convert_buf(bt, ts);
                }
            },
            #[cfg(feature="hwaccel")]
            DecoderType::VideoHW(ref mut vdec) => {
                let _ = vdec.queue_pkt(pkt);
                while let Some(frm) = vdec.get_frame() {
                    let bt = frm.get_buffer();
                    if let NABufferType::None = bt { continue; }
                    let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
                    return self.convert_buf(bt, ts);
                }
            },
            _ => panic!("not a video decoder!"),
        };
        None
    }
    pub fn more_frames(&mut self, do_not_wait: bool) -> Option<FrameRecord> {
        match self.dec.dec {
            DecoderType::Video(ref mut _dec, ref mut reord) => {
                while let Some(frm) = reord.get_frame() {
                    let bt = frm.get_buffer();
                    if let NABufferType::None = bt { continue; }
                    let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
                    return self.convert_buf(bt, ts);
                }
            },
            DecoderType::VideoMT(ref mut vdec, ref mut reord) => {
                let mut got_some = false;
                while vdec.has_output() {
                    match vdec.get_frame() {
                        (Ok(frm), id) => {
                            reord.add_frame(frm, id);
                            got_some = true;
                        },
                        (Err(err), id) => {
                            reord.drop_frame(id);
                            if err != DecoderError::MissingReference {
                                println!("frame {} decoding error {:?}", id, err);
                            }
                        },
                    };
                }
                if !got_some && !do_not_wait {
                    match vdec.get_frame() {
                        (Ok(frm), id) => {
                            reord.add_frame(frm, id);
                        },
                        (Err(DecoderError::NoFrame), _) => {},
                        (Err(err), id) => {
                            reord.drop_frame(id);
                            if err != DecoderError::MissingReference {
                                println!("frame {} decoding error {:?}", id, err);
                            }
                        },
                    };
                }
                while let Some(frm) = reord.get_frame() {
                    let bt = frm.get_buffer();
                    if let NABufferType::None = bt { continue; }
                    let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
                    return self.convert_buf(bt, ts);
                }
            },
            #[cfg(feature="hwaccel")]
            DecoderType::VideoHW(ref mut vdec) => {
                while let Some(frm) = vdec.get_frame() {
                    let bt = frm.get_buffer();
                    if let NABufferType::None = bt { continue; }
                    let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
                    return self.convert_buf(bt, ts);
                }
            },
            _ => {},
        };
        None
    }
    pub fn last_frame(&mut self) -> Option<FrameRecord> {
        match self.dec.dec {
            DecoderType::Video(ref mut _dec, ref mut reord) => {
                while let Some(frm) = reord.get_last_frames() {
                    let bt = frm.get_buffer();
                    if let NABufferType::None = bt { continue; }
                    let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
                    return self.convert_buf(bt, ts);
                }
            },
            DecoderType::VideoMT(ref mut _dec, ref mut reord) => {
                while let Some(frm) = reord.get_last_frames() {
                    let bt = frm.get_buffer();
                    if let NABufferType::None = bt { continue; }
                    let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
                    return self.convert_buf(bt, ts);
                }
            },
            #[cfg(feature="hwaccel")]
            DecoderType::VideoHW(ref mut dec) => {
                while let Some(frm) = dec.get_last_frames() {
                    let bt = frm.get_buffer();
                    if let NABufferType::None = bt { continue; }
                    let ts = frm.get_dts().unwrap_or_else(|| frm.get_pts().unwrap_or(0));
                    return self.convert_buf(bt, ts);
                }
            },
            _ => {},
        };
        None
    }
    pub fn flush(&mut self) {
        match self.dec.dec {
            DecoderType::Video(ref mut dec, ref mut reord) => {
                dec.flush();
                reord.flush();
            },
            DecoderType::VideoMT(ref mut dec, ref mut reord) => {
                dec.flush();
                reord.flush();
            },
            #[cfg(feature="hwaccel")]
            DecoderType::VideoHW(ref mut dec) => {
                dec.flush();
            },
            _ => {},
        };
    }
}

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<()> {
    std::thread::Builder::new().name("vdecoder".to_string()).spawn(move ||{
            VDEC_STATE.set_state(DecodingState::Waiting);
            let mut vdec = VideoDecoder::new(width, height, tb_num, tb_den, video_dec);
            let mut skip_mode = FrameSkipMode::None;
            loop {
                match vprecv.recv() {
                    Ok(PktSendEvent::Packet(pkt)) => {
                        if !VDEC_STATE.is_flushing() {
                            if let Some((buf, time)) = vdec.next_frame(&pkt) {
                                vfsend.send((buf, time)).expect("video frame should be sent");
                            }
                            while let Some((buf, time)) = vdec.more_frames(true) {
                                vfsend.send((buf, time)).expect("video frame should be sent");
                            }
                        }
                    },
                    Ok(PktSendEvent::GetFrames) => {
                        while let Some((buf, time)) = vdec.more_frames(false) {
                            vfsend.send((buf, time)).expect("video frame should be sent");
                        }
                        VDEC_STATE.set_state(DecodingState::Waiting);
                    },
                    Ok(PktSendEvent::Flush) => {
                        vdec.flush();
                        VDEC_STATE.set_state(DecodingState::Waiting);
                    },
                    Ok(PktSendEvent::End) => {
                        while vdec.yuv_pool.get_free().is_some() && vdec.rgb_pool.get_free().is_some() {
                            if let Some(frm) = vdec.last_frame() {
                                vfsend.send(frm).expect("video frame should be sent");
                            } else {
                                break;
                            }
                        }
                        VDEC_STATE.set_state(DecodingState::End);
                        break;
                    },
                    Ok(PktSendEvent::ImmediateEnd) => {
                        VDEC_STATE.set_state(DecodingState::End);
                        break;
                    },
                    Ok(PktSendEvent::HurryUp) => {
                        skip_mode = skip_mode.advance();
                        if let DecoderType::Video(ref mut dec, ref mut _reord) = vdec.dec.dec {
                            println!("setting hurry up mode to {}", skip_mode.to_string());
                            dec.set_options(&[NAOption{
                                name: FRAME_SKIP_OPTION,
                                value: NAValue::String(skip_mode.to_string()),
                            }]);
                        }
                    },
                    Err(_) => {
                        break;
                    },
                };
            }
        }).unwrap()
}

trait Advance {
    fn advance(&self) -> Self;
}

impl Advance for FrameSkipMode {
    fn advance(&self) -> Self {
        match *self {
            FrameSkipMode::None             => FrameSkipMode::KeyframesOnly,
            FrameSkipMode::KeyframesOnly    => FrameSkipMode::IntraOnly,
            FrameSkipMode::IntraOnly        => FrameSkipMode::None,
        }
    }
}

fn output_yuv(yuv_texture: &mut Texture, buf: &NAVideoBuffer<u8>, width: usize, height: usize) {
    let src = buf.get_data();
    let ysstride = buf.get_stride(0);
    let ysrc = &src[buf.get_offset(0)..];
    let usstride = buf.get_stride(2);
    let usrc = &src[buf.get_offset(2)..];
    let vsstride = buf.get_stride(1);
    let vsrc = &src[buf.get_offset(1)..];
    yuv_texture.with_lock(None, |buffer: &mut [u8], pitch: usize| {
            let csize = pitch.min(width);
            for (dline, sline) in buffer.chunks_exact_mut(pitch).take(height).zip(ysrc.chunks_exact(ysstride)) {
                dline[..csize].copy_from_slice(&sline[..csize]);
            }
            let coff = pitch * height;
            let csize = (pitch / 2).min(width / 2);
            for (dline, sline) in buffer[coff..].chunks_exact_mut(pitch / 2).take(height/2).zip(vsrc.chunks(vsstride)) {
                dline[..csize].copy_from_slice(&sline[..csize]);
            }
            let coff = pitch * height + (pitch / 2) * (height / 2);
            for (dline, sline) in buffer[coff..].chunks_exact_mut(pitch / 2).take(height/2).zip(usrc.chunks(usstride)) {
                dline[..csize].copy_from_slice(&sline[..csize]);
            }
        }).expect("surface should be locked");
}


pub struct VideoControl {
    vqueue:         Vec<PktSendEvent>,
    vpsend:         SyncSender<PktSendEvent>,
    vfrecv:         Receiver<FrameRecord>,
    do_yuv:         bool,
    vthread:        JoinHandle<()>,
}

impl VideoControl {
    pub fn new(video_dec: Option<DecoderStuff>, width: usize, height: usize, tb_num: u32, tb_den: u32) -> Self {
        let (vpsend, vprecv) = std::sync::mpsc::sync_channel::<PktSendEvent>(0);
        let (vfsend, vfrecv) = std::sync::mpsc::sync_channel::<FrameRecord>(FRAME_QUEUE_SIZE - 1);

        VDEC_STATE.set_state(DecodingState::Normal);

        let vthread = if let Some(video_dec) = video_dec {
                start_video_decoding(width, height, tb_num, tb_den, video_dec, vprecv, vfsend)
            } else {
                thread::Builder::new().name("vdecoder-dummy".to_string()).spawn(move ||{
                        loop {
                            match vprecv.recv() {
                                Ok(PktSendEvent::End) => break,
                                Ok(PktSendEvent::ImmediateEnd) => break,
                                Err(_) => {
                                    break;
                                },
                                _ => {},
                            };
                        }
                        VDEC_STATE.set_state(DecodingState::End);
                    }).unwrap()
            };


        Self {
            vqueue:         Vec::with_capacity(FRAME_QUEUE_LEN),
            vpsend, vfrecv,
            do_yuv:         false,
            vthread,
        }
    }
    pub fn flush(&mut self) {
        self.vqueue.clear();
        VDEC_STATE.set_state(DecodingState::Flush);
        for _ in 0..8 {
            let _ = self.vfrecv.try_recv();
        }
        let _ = self.vpsend.send(PktSendEvent::Flush);
        while self.vfrecv.try_recv().is_ok() { }
    }
    pub fn get_queue_size(&self) -> usize { self.vqueue.len() }
    pub fn is_filled(&self, size: usize) -> bool {
        self.vqueue.len() >= size
    }
    pub fn try_send_video(&mut self, evt: PktSendEvent) -> bool {
        if !self.vqueue.is_empty() {
            self.vqueue.push(evt);
            false
        } else {
            self.try_send_event(evt)
        }
    }
    fn try_send_event(&mut self, evt: PktSendEvent) -> bool {
        if let Err(TrySendError::Full(evt)) = self.vpsend.try_send(evt) {
            self.vqueue.insert(0, evt);
            false
        } else {
            true
        }
    }
    pub fn try_send_queued(&mut self) -> bool {
        while !self.vqueue.is_empty() {
            let pkt = self.vqueue.remove(0);
            if !self.try_send_event(pkt) {
                 return false;
            }
        }
        true
    }
    pub fn is_video_end(&self) -> bool {
        matches!(VDEC_STATE.get_state(), DecodingState::End | DecodingState::Error)
    }
    pub fn wait_for_frames(&mut self) -> Result<(), ()> {
        VDEC_STATE.set_state(DecodingState::Prefetch);
        self.try_send_event(PktSendEvent::GetFrames);
        while !self.try_send_queued() {
        }
        loop {
            match VDEC_STATE.get_state() {
                DecodingState::Waiting => {
                    VDEC_STATE.set_state(DecodingState::Normal);
                    return Ok(());
                },
                DecodingState::Prefetch => thread::yield_now(),
                _ => return Err(()),
            };
        }
    }

    pub fn is_yuv(&self) -> bool { self.do_yuv }

    pub fn fill(&mut self, disp_queue: &mut DispQueue) {
        while !disp_queue.is_full() {
            let is_empty = disp_queue.is_empty();
            if let Ok((pic, time)) = self.vfrecv.try_recv() {
                let buf = pic.get_vbuf().expect("video frame should be of u8 type");
                self.do_yuv = buf.get_info().get_format().get_model().is_yuv();
                let idx = disp_queue.end;
                disp_queue.move_end();
                let frm = &mut disp_queue.pool[idx];
                if !self.do_yuv {
                    let sstride = buf.get_stride(0);
                    let src = buf.get_data();
                    frm.rgb_tex.with_lock(None, |buffer: &mut [u8], pitch: usize| {
                            let csize = sstride.min(pitch);
                            for (dst, src) in buffer.chunks_mut(pitch).zip(src.chunks(sstride)) {
                                dst[..csize].copy_from_slice(&src[..csize]);
                            }
                            true
                        }).expect("surface should be locked");
                } else {
                    output_yuv(&mut frm.yuv_tex, &buf, disp_queue.width, disp_queue.height);
                }
                frm.valid = true;
                frm.is_yuv = self.do_yuv;
                frm.ts = time;
                if is_empty {
                    disp_queue.first_ts = time;
                }
                disp_queue.last_ts = time;
            } else {
                break;
            }
        }
    }

    pub fn finish(self) {
        VDEC_STATE.set_state(DecodingState::Flush);
        for _ in 0..8 {
            let _ = self.vfrecv.try_recv();
        }
        let _ = self.vpsend.send(PktSendEvent::ImmediateEnd);
        self.vthread.join().unwrap();
    }
}
Commit	Line	Data
69b93cb5	1	use std::thread::JoinHandle;
69b93cb5 KS	2	use std::sync::mpsc::{Receiver, SyncSender, TrySendError};
	3	use std::thread;
	4
	5	use sdl2::render::Texture;
	6
	7	use nihav_core::frame::{NABufferType, NAVideoBuffer};
	8	use nihav_core::formats::*;
	9	use nihav_core::codecs::*;
	10	use nihav_core::scale::*;
	11
4e72c04a	12	use super::{DecoderStuff, DecoderType, DecoderState, DecodingState, DispQueue, FrameRecord, PktSendEvent, FRAME_QUEUE_LEN};
69b93cb5	13
4e72c04a	14	static VDEC_STATE: DecoderState = DecoderState::new();
69b93cb5 KS	15
	16	pub const FRAME_QUEUE_SIZE: usize = 25;
	17
	18	pub const SDL_RGB_FMT: NAPixelFormaton = NAPixelFormaton { model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
	19	comp_info: [
	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 }),
	23	None, None
	24	], elem_size: 3, be: false, alpha: false, palette: false };
	25
	26	pub struct VideoDecoder {
	27	yuv_pool: NAVideoBufferPool<u8>,
	28	rgb_pool: NAVideoBufferPool<u8>,
	29	tb_num: u32,
	30	tb_den: u32,
	31	dec: DecoderStuff,
	32	ifmt: NAVideoInfo,
	33	scaler: NAScale,
	34	ofmt_rgb: ScaleInfo,
	35	ofmt_yuv: ScaleInfo,
	36	oinfo_yuv: NAVideoInfo,
	37	oinfo_rgb: NAVideoInfo,
	38	}
	39
	40	impl VideoDecoder {
	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 };
	46	Self {
	47	yuv_pool: NAVideoBufferPool::new(FRAME_QUEUE_SIZE),
	48	rgb_pool: NAVideoBufferPool::new(FRAME_QUEUE_SIZE),
	49	tb_num, tb_den,
	50	dec, ofmt_yuv, ofmt_rgb, oinfo_yuv, oinfo_rgb,
27c26a2a	51	scaler: NAScale::new(ofmt_rgb, ofmt_rgb).expect("creating scaler failed"),
69b93cb5 KS	52	ifmt: NAVideoInfo { width: 0, height: 0, flipped: false, format: SDL_RGB_FMT, bits: 24 },
	53	}
	54	}
	55	fn convert_buf(&mut self, bt: NABufferType, ts: u64) -> Option<FrameRecord> {
27c26a2a	56	let vinfo = bt.get_video_info().expect("this should be a video buffer");
69b93cb5 KS	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() {
	60	self.ifmt = vinfo;
	61	let sc_ifmt = ScaleInfo { width: self.ifmt.get_width(), height: self.ifmt.get_height(), fmt: self.ifmt.get_format() };
bbd69555	62	let do_yuv = self.ifmt.get_format().get_model().is_yuv();
69b93cb5	63	let ofmt = if do_yuv { self.ofmt_yuv } else { self.ofmt_rgb };
27c26a2a	64	self.scaler = NAScale::new(sc_ifmt, ofmt).expect("scaling should not fail");
69b93cb5 KS	65	}
69b93cb5 KS	66	let mut opic = if let ColorModel::YUV(_) = self.ifmt.get_format().get_model() {
27c26a2a	67	self.yuv_pool.prealloc_video(self.oinfo_yuv, 2).expect("video frame pool allocation failure");
69b93cb5	68	while self.yuv_pool.get_free().is_none() {
4e72c04a	69	if VDEC_STATE.is_flushing() {
69b93cb5 KS	70	return None;
	71	}
	72	std::thread::yield_now();
	73	}
27c26a2a	74	NABufferType::Video(self.yuv_pool.get_free().expect("video frame pool should have a free frame"))
69b93cb5	75	} else {
27c26a2a	76	self.rgb_pool.prealloc_video(self.oinfo_rgb, 0).expect("video frame pool allocation failure");
69b93cb5	77	while self.rgb_pool.get_free().is_none() {
4e72c04a	78	if VDEC_STATE.is_flushing() {
69b93cb5 KS	79	return None;
	80	}
	81	std::thread::yield_now();
	82	}
27c26a2a	83	NABufferType::VideoPacked(self.rgb_pool.get_free().expect("video frame pool should have a free frame"))
69b93cb5 KS	84	};
	85	let ret = self.scaler.convert(&bt, &mut opic);
	86	if ret.is_err() { println!(" scaler error {:?}", ret.err()); return None; }
	87	ret.unwrap();
	88	let time = NATimeInfo::ts_to_time(ts, 1000, self.tb_num, self.tb_den);
	89	Some((opic, time))
	90	}
	91	pub fn next_frame(&mut self, pkt: &NAPacket) -> Option<FrameRecord> {
37f130a7 KS	92	match self.dec.dec {
	93	DecoderType::Video(ref mut vdec, ref mut reord) => {
	94	if let Ok(frm) = vdec.decode(&mut self.dec.dsupp, pkt) {
	95	reord.add_frame(frm);
	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);
	101	}
	102	}
	103	},
	104	DecoderType::VideoMT(ref mut vdec, ref mut reord) => {
	105	let queue_id = reord.register_frame();
bbd69555	106	match vdec.queue_pkt(&mut self.dec.dsupp, pkt, queue_id) {
37f130a7 KS	107	Ok(true) => {},
	108	Ok(false) => {
	109	while !vdec.can_take_input() \|\| vdec.has_output() {
	110	match vdec.get_frame() {
	111	(Ok(frm), id) => {
	112	reord.add_frame(frm, id);
	113	},
	114	(Err(err), id) => {
	115	reord.drop_frame(id);
1e14f1e2 KS	116	if err != DecoderError::MissingReference {
	117	println!("frame {} decoding error {:?}", id, err);
	118	}
37f130a7 KS	119	},
	120	};
	121	}
bbd69555	122	match vdec.queue_pkt(&mut self.dec.dsupp, pkt, queue_id) {
37f130a7	123	Ok(true) => {},
364f01a3 KS	124	Ok(false) => {
	125	println!("still can't queue frame!");
	126	VDEC_STATE.set_state(DecodingState::Error);
	127	},
	128	Err(err) => println!("queueing error {:?}", err),
37f130a7 KS	129	};
37f130a7 KS	130	},
364f01a3	131	Err(err) => println!("queueing error {:?}", err),
37f130a7 KS	132	};
	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);
	138	}
	139	},
35d0d63a KS	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);
	148	}
	149	},
37f130a7 KS	150	_ => panic!("not a video decoder!"),
	151	};
	152	None
	153	}
	154	pub fn more_frames(&mut self, do_not_wait: bool) -> Option<FrameRecord> {
	155	match self.dec.dec {
	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);
	162	}
	163	},
	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() {
	168	(Ok(frm), id) => {
	169	reord.add_frame(frm, id);
	170	got_some = true;
	171	},
	172	(Err(err), id) => {
	173	reord.drop_frame(id);
1e14f1e2 KS	174	if err != DecoderError::MissingReference {
	175	println!("frame {} decoding error {:?}", id, err);
	176	}
37f130a7 KS	177	},
	178	};
	179	}
	180	if !got_some && !do_not_wait {
	181	match vdec.get_frame() {
	182	(Ok(frm), id) => {
	183	reord.add_frame(frm, id);
	184	},
	185	(Err(DecoderError::NoFrame), _) => {},
	186	(Err(err), id) => {
	187	reord.drop_frame(id);
1e14f1e2 KS	188	if err != DecoderError::MissingReference {
	189	println!("frame {} decoding error {:?}", id, err);
	190	}
37f130a7 KS	191	},
	192	};
	193	}
	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);
	199	}
	200	},
35d0d63a KS	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);
	208	}
	209	},
37f130a7 KS	210	_ => {},
37f130a7 KS	211	};
69b93cb5 KS	212	None
	213	}
	214	pub fn last_frame(&mut self) -> Option<FrameRecord> {
37f130a7 KS	215	match self.dec.dec {
	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);
	222	}
	223	},
	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);
	230	}
	231	},
35d0d63a KS	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);
	239	}
	240	},
37f130a7 KS	241	_ => {},
37f130a7 KS	242	};
69b93cb5 KS	243	None
	244	}
	245	pub fn flush(&mut self) {
37f130a7 KS	246	match self.dec.dec {
	247	DecoderType::Video(ref mut dec, ref mut reord) => {
	248	dec.flush();
	249	reord.flush();
	250	},
	251	DecoderType::VideoMT(ref mut dec, ref mut reord) => {
	252	dec.flush();
	253	reord.flush();
	254	},
35d0d63a KS	255	#[cfg(feature="hwaccel")]
	256	DecoderType::VideoHW(ref mut dec) => {
	257	dec.flush();
	258	},
37f130a7 KS	259	_ => {},
37f130a7 KS	260	};
69b93cb5 KS	261	}
	262	}
	263
	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 \|\|{
4e72c04a	266	VDEC_STATE.set_state(DecodingState::Waiting);
69b93cb5 KS	267	let mut vdec = VideoDecoder::new(width, height, tb_num, tb_den, video_dec);
	268	let mut skip_mode = FrameSkipMode::None;
	269	loop {
	270	match vprecv.recv() {
	271	Ok(PktSendEvent::Packet(pkt)) => {
4e72c04a	272	if !VDEC_STATE.is_flushing() {
69b93cb5	273	if let Some((buf, time)) = vdec.next_frame(&pkt) {
27c26a2a	274	vfsend.send((buf, time)).expect("video frame should be sent");
69b93cb5	275	}
37f130a7	276	while let Some((buf, time)) = vdec.more_frames(true) {
27c26a2a	277	vfsend.send((buf, time)).expect("video frame should be sent");
37f130a7 KS	278	}
	279	}
	280	},
	281	Ok(PktSendEvent::GetFrames) => {
	282	while let Some((buf, time)) = vdec.more_frames(false) {
27c26a2a	283	vfsend.send((buf, time)).expect("video frame should be sent");
69b93cb5	284	}
4e72c04a	285	VDEC_STATE.set_state(DecodingState::Waiting);
69b93cb5 KS	286	},
	287	Ok(PktSendEvent::Flush) => {
	288	vdec.flush();
4e72c04a	289	VDEC_STATE.set_state(DecodingState::Waiting);
69b93cb5 KS	290	},
	291	Ok(PktSendEvent::End) => {
	292	while vdec.yuv_pool.get_free().is_some() && vdec.rgb_pool.get_free().is_some() {
27c26a2a KS	293	if let Some(frm) = vdec.last_frame() {
	294	vfsend.send(frm).expect("video frame should be sent");
	295	} else {
69b93cb5 KS	296	break;
69b93cb5 KS	297	}
69b93cb5	298	}
4e72c04a	299	VDEC_STATE.set_state(DecodingState::End);
69b93cb5 KS	300	break;
	301	},
	302	Ok(PktSendEvent::ImmediateEnd) => {
4e72c04a	303	VDEC_STATE.set_state(DecodingState::End);
69b93cb5 KS	304	break;
	305	},
	306	Ok(PktSendEvent::HurryUp) => {
	307	skip_mode = skip_mode.advance();
37f130a7	308	if let DecoderType::Video(ref mut dec, ref mut _reord) = vdec.dec.dec {
31611a29	309	println!("setting hurry up mode to {}", skip_mode.to_string());
37f130a7	310	dec.set_options(&[NAOption{
69b93cb5 KS	311	name: FRAME_SKIP_OPTION,
	312	value: NAValue::String(skip_mode.to_string()),
	313	}]);
37f130a7	314	}
69b93cb5 KS	315	},
	316	Err(_) => {
	317	break;
	318	},
	319	};
	320	}
	321	}).unwrap()
	322	}
	323
	324	trait Advance {
	325	fn advance(&self) -> Self;
	326	}
	327
	328	impl Advance for FrameSkipMode {
	329	fn advance(&self) -> Self {
	330	match *self {
	331	FrameSkipMode::None => FrameSkipMode::KeyframesOnly,
	332	FrameSkipMode::KeyframesOnly => FrameSkipMode::IntraOnly,
	333	FrameSkipMode::IntraOnly => FrameSkipMode::None,
	334	}
	335	}
	336	}
	337
	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]);
	350	}
	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]);
	355	}
	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]);
	359	}
27c26a2a	360	}).expect("surface should be locked");
69b93cb5 KS	361	}
	362
	363
	364	pub struct VideoControl {
	365	vqueue: Vec<PktSendEvent>,
	366	vpsend: SyncSender<PktSendEvent>,
	367	vfrecv: Receiver<FrameRecord>,
	368	do_yuv: bool,
	369	vthread: JoinHandle<()>,
	370	}
	371
	372	impl VideoControl {
	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);
	376
4e72c04a	377	VDEC_STATE.set_state(DecodingState::Normal);
69b93cb5 KS	378
	379	let vthread = if let Some(video_dec) = video_dec {
	380	start_video_decoding(width, height, tb_num, tb_den, video_dec, vprecv, vfsend)
	381	} else {
	382	thread::Builder::new().name("vdecoder-dummy".to_string()).spawn(move \|\|{
	383	loop {
	384	match vprecv.recv() {
	385	Ok(PktSendEvent::End) => break,
	386	Ok(PktSendEvent::ImmediateEnd) => break,
	387	Err(_) => {
	388	break;
	389	},
	390	_ => {},
	391	};
	392	}
4e72c04a	393	VDEC_STATE.set_state(DecodingState::End);
69b93cb5 KS	394	}).unwrap()
	395	};
	396
	397
	398	Self {
	399	vqueue: Vec::with_capacity(FRAME_QUEUE_LEN),
	400	vpsend, vfrecv,
	401	do_yuv: false,
	402	vthread,
	403	}
	404	}
	405	pub fn flush(&mut self) {
b5053bfc	406	self.vqueue.clear();
4e72c04a	407	VDEC_STATE.set_state(DecodingState::Flush);
69b93cb5 KS	408	for _ in 0..8 {
	409	let _ = self.vfrecv.try_recv();
	410	}
	411	let _ = self.vpsend.send(PktSendEvent::Flush);
	412	while self.vfrecv.try_recv().is_ok() { }
	413	}
	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
	417	}
	418	pub fn try_send_video(&mut self, evt: PktSendEvent) -> bool {
bbd69555	419	if !self.vqueue.is_empty() {
69b93cb5 KS	420	self.vqueue.push(evt);
	421	false
	422	} else {
	423	self.try_send_event(evt)
	424	}
	425	}
	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);
	429	false
	430	} else {
	431	true
	432	}
	433	}
	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) {
	438	return false;
	439	}
	440	}
	441	true
	442	}
	443	pub fn is_video_end(&self) -> bool {
4e72c04a	444	matches!(VDEC_STATE.get_state(), DecodingState::End \| DecodingState::Error)
69b93cb5	445	}
4e72c04a KS	446	pub fn wait_for_frames(&mut self) -> Result<(), ()> {
4e72c04a KS	447	VDEC_STATE.set_state(DecodingState::Prefetch);
37f130a7 KS	448	self.try_send_event(PktSendEvent::GetFrames);
	449	while !self.try_send_queued() {
	450	}
4e72c04a KS	451	loop {
	452	match VDEC_STATE.get_state() {
	453	DecodingState::Waiting => {
	454	VDEC_STATE.set_state(DecodingState::Normal);
	455	return Ok(());
	456	},
	457	DecodingState::Prefetch => thread::yield_now(),
	458	_ => return Err(()),
	459	};
37f130a7 KS	460	}
37f130a7 KS	461	}
69b93cb5 KS	462
	463	pub fn is_yuv(&self) -> bool { self.do_yuv }
	464
	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() {
27c26a2a	469	let buf = pic.get_vbuf().expect("video frame should be of u8 type");
69b93cb5 KS	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];
	474	if !self.do_yuv {
	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)) {
bbd69555	480	dst[..csize].copy_from_slice(&src[..csize]);
69b93cb5 KS	481	}
69b93cb5 KS	482	true
27c26a2a	483	}).expect("surface should be locked");
69b93cb5 KS	484	} else {
	485	output_yuv(&mut frm.yuv_tex, &buf, disp_queue.width, disp_queue.height);
	486	}
	487	frm.valid = true;
	488	frm.is_yuv = self.do_yuv;
	489	frm.ts = time;
	490	if is_empty {
	491	disp_queue.first_ts = time;
	492	}
	493	disp_queue.last_ts = time;
	494	} else {
	495	break;
	496	}
	497	}
	498	}
	499
	500	pub fn finish(self) {
4e72c04a	501	VDEC_STATE.set_state(DecodingState::Flush);
69b93cb5 KS	502	for _ in 0..8 {
	503	let _ = self.vfrecv.try_recv();
	504	}
	505	let _ = self.vpsend.send(PktSendEvent::ImmediateEnd);
	506	self.vthread.join().unwrap();
	507	}
	508	}