[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);
                }
            },
            _ => 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);
                }
            },
            _ => {},
        };
        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);
                }
            },
            _ => {},
        };
        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();
            },
            _ => {},
        };
    }
}

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 {
                            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	},
	140	_ => panic!("not a video decoder!"),
	141	};
	142	None
	143	}
	144	pub fn more_frames(&mut self, do_not_wait: bool) -> Option<FrameRecord> {
	145	match self.dec.dec {
	146	DecoderType::Video(ref mut _dec, ref mut reord) => {
	147	while let Some(frm) = reord.get_frame() {
	148	let bt = frm.get_buffer();
	149	if let NABufferType::None = bt { continue; }
	150	let ts = frm.get_dts().unwrap_or_else(\|\| frm.get_pts().unwrap_or(0));
	151	return self.convert_buf(bt, ts);
	152	}
	153	},
	154	DecoderType::VideoMT(ref mut vdec, ref mut reord) => {
	155	let mut got_some = false;
	156	while vdec.has_output() {
	157	match vdec.get_frame() {
	158	(Ok(frm), id) => {
	159	reord.add_frame(frm, id);
	160	got_some = true;
	161	},
	162	(Err(err), id) => {
	163	reord.drop_frame(id);
1e14f1e2 KS	164	if err != DecoderError::MissingReference {
	165	println!("frame {} decoding error {:?}", id, err);
	166	}
37f130a7 KS	167	},
	168	};
	169	}
	170	if !got_some && !do_not_wait {
	171	match vdec.get_frame() {
	172	(Ok(frm), id) => {
	173	reord.add_frame(frm, id);
	174	},
	175	(Err(DecoderError::NoFrame), _) => {},
	176	(Err(err), id) => {
	177	reord.drop_frame(id);
1e14f1e2 KS	178	if err != DecoderError::MissingReference {
	179	println!("frame {} decoding error {:?}", id, err);
	180	}
37f130a7 KS	181	},
	182	};
	183	}
	184	while let Some(frm) = reord.get_frame() {
	185	let bt = frm.get_buffer();
	186	if let NABufferType::None = bt { continue; }
	187	let ts = frm.get_dts().unwrap_or_else(\|\| frm.get_pts().unwrap_or(0));
	188	return self.convert_buf(bt, ts);
	189	}
	190	},
	191	_ => {},
	192	};
69b93cb5 KS	193	None
	194	}
	195	pub fn last_frame(&mut self) -> Option<FrameRecord> {
37f130a7 KS	196	match self.dec.dec {
	197	DecoderType::Video(ref mut _dec, ref mut reord) => {
	198	while let Some(frm) = reord.get_last_frames() {
	199	let bt = frm.get_buffer();
	200	if let NABufferType::None = bt { continue; }
	201	let ts = frm.get_dts().unwrap_or_else(\|\| frm.get_pts().unwrap_or(0));
	202	return self.convert_buf(bt, ts);
	203	}
	204	},
	205	DecoderType::VideoMT(ref mut _dec, ref mut reord) => {
	206	while let Some(frm) = reord.get_last_frames() {
	207	let bt = frm.get_buffer();
	208	if let NABufferType::None = bt { continue; }
	209	let ts = frm.get_dts().unwrap_or_else(\|\| frm.get_pts().unwrap_or(0));
	210	return self.convert_buf(bt, ts);
	211	}
	212	},
	213	_ => {},
	214	};
69b93cb5 KS	215	None
	216	}
	217	pub fn flush(&mut self) {
37f130a7 KS	218	match self.dec.dec {
	219	DecoderType::Video(ref mut dec, ref mut reord) => {
	220	dec.flush();
	221	reord.flush();
	222	},
	223	DecoderType::VideoMT(ref mut dec, ref mut reord) => {
	224	dec.flush();
	225	reord.flush();
	226	},
	227	_ => {},
	228	};
69b93cb5 KS	229	}
	230	}
	231
	232	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<()> {
	233	std::thread::Builder::new().name("vdecoder".to_string()).spawn(move \|\|{
4e72c04a	234	VDEC_STATE.set_state(DecodingState::Waiting);
69b93cb5 KS	235	let mut vdec = VideoDecoder::new(width, height, tb_num, tb_den, video_dec);
	236	let mut skip_mode = FrameSkipMode::None;
	237	loop {
	238	match vprecv.recv() {
	239	Ok(PktSendEvent::Packet(pkt)) => {
4e72c04a	240	if !VDEC_STATE.is_flushing() {
69b93cb5	241	if let Some((buf, time)) = vdec.next_frame(&pkt) {
27c26a2a	242	vfsend.send((buf, time)).expect("video frame should be sent");
69b93cb5	243	}
37f130a7	244	while let Some((buf, time)) = vdec.more_frames(true) {
27c26a2a	245	vfsend.send((buf, time)).expect("video frame should be sent");
37f130a7 KS	246	}
	247	}
	248	},
	249	Ok(PktSendEvent::GetFrames) => {
	250	while let Some((buf, time)) = vdec.more_frames(false) {
27c26a2a	251	vfsend.send((buf, time)).expect("video frame should be sent");
69b93cb5	252	}
4e72c04a	253	VDEC_STATE.set_state(DecodingState::Waiting);
69b93cb5 KS	254	},
	255	Ok(PktSendEvent::Flush) => {
	256	vdec.flush();
4e72c04a	257	VDEC_STATE.set_state(DecodingState::Waiting);
69b93cb5 KS	258	},
	259	Ok(PktSendEvent::End) => {
	260	while vdec.yuv_pool.get_free().is_some() && vdec.rgb_pool.get_free().is_some() {
27c26a2a KS	261	if let Some(frm) = vdec.last_frame() {
	262	vfsend.send(frm).expect("video frame should be sent");
	263	} else {
69b93cb5 KS	264	break;
69b93cb5 KS	265	}
69b93cb5	266	}
4e72c04a	267	VDEC_STATE.set_state(DecodingState::End);
69b93cb5 KS	268	break;
	269	},
	270	Ok(PktSendEvent::ImmediateEnd) => {
4e72c04a	271	VDEC_STATE.set_state(DecodingState::End);
69b93cb5 KS	272	break;
	273	},
	274	Ok(PktSendEvent::HurryUp) => {
	275	skip_mode = skip_mode.advance();
37f130a7 KS	276	if let DecoderType::Video(ref mut dec, ref mut _reord) = vdec.dec.dec {
37f130a7 KS	277	dec.set_options(&[NAOption{
69b93cb5 KS	278	name: FRAME_SKIP_OPTION,
	279	value: NAValue::String(skip_mode.to_string()),
	280	}]);
37f130a7	281	}
69b93cb5 KS	282	},
	283	Err(_) => {
	284	break;
	285	},
	286	};
	287	}
	288	}).unwrap()
	289	}
	290
	291	trait Advance {
	292	fn advance(&self) -> Self;
	293	}
	294
	295	impl Advance for FrameSkipMode {
	296	fn advance(&self) -> Self {
	297	match *self {
	298	FrameSkipMode::None => FrameSkipMode::KeyframesOnly,
	299	FrameSkipMode::KeyframesOnly => FrameSkipMode::IntraOnly,
	300	FrameSkipMode::IntraOnly => FrameSkipMode::None,
	301	}
	302	}
	303	}
	304
	305	fn output_yuv(yuv_texture: &mut Texture, buf: &NAVideoBuffer<u8>, width: usize, height: usize) {
	306	let src = buf.get_data();
	307	let ysstride = buf.get_stride(0);
	308	let ysrc = &src[buf.get_offset(0)..];
	309	let usstride = buf.get_stride(2);
	310	let usrc = &src[buf.get_offset(2)..];
	311	let vsstride = buf.get_stride(1);
	312	let vsrc = &src[buf.get_offset(1)..];
	313	yuv_texture.with_lock(None, \|buffer: &mut [u8], pitch: usize\| {
	314	let csize = pitch.min(width);
	315	for (dline, sline) in buffer.chunks_exact_mut(pitch).take(height).zip(ysrc.chunks_exact(ysstride)) {
	316	dline[..csize].copy_from_slice(&sline[..csize]);
	317	}
	318	let coff = pitch * height;
	319	let csize = (pitch / 2).min(width / 2);
	320	for (dline, sline) in buffer[coff..].chunks_exact_mut(pitch / 2).take(height/2).zip(vsrc.chunks(vsstride)) {
	321	dline[..csize].copy_from_slice(&sline[..csize]);
	322	}
	323	let coff = pitch * height + (pitch / 2) * (height / 2);
	324	for (dline, sline) in buffer[coff..].chunks_exact_mut(pitch / 2).take(height/2).zip(usrc.chunks(usstride)) {
	325	dline[..csize].copy_from_slice(&sline[..csize]);
	326	}
27c26a2a	327	}).expect("surface should be locked");
69b93cb5 KS	328	}
	329
	330
	331	pub struct VideoControl {
	332	vqueue: Vec<PktSendEvent>,
	333	vpsend: SyncSender<PktSendEvent>,
	334	vfrecv: Receiver<FrameRecord>,
	335	do_yuv: bool,
	336	vthread: JoinHandle<()>,
	337	}
	338
	339	impl VideoControl {
	340	pub fn new(video_dec: Option<DecoderStuff>, width: usize, height: usize, tb_num: u32, tb_den: u32) -> Self {
	341	let (vpsend, vprecv) = std::sync::mpsc::sync_channel::<PktSendEvent>(0);
	342	let (vfsend, vfrecv) = std::sync::mpsc::sync_channel::<FrameRecord>(FRAME_QUEUE_SIZE - 1);
	343
4e72c04a	344	VDEC_STATE.set_state(DecodingState::Normal);
69b93cb5 KS	345
	346	let vthread = if let Some(video_dec) = video_dec {
	347	start_video_decoding(width, height, tb_num, tb_den, video_dec, vprecv, vfsend)
	348	} else {
	349	thread::Builder::new().name("vdecoder-dummy".to_string()).spawn(move \|\|{
	350	loop {
	351	match vprecv.recv() {
	352	Ok(PktSendEvent::End) => break,
	353	Ok(PktSendEvent::ImmediateEnd) => break,
	354	Err(_) => {
	355	break;
	356	},
	357	_ => {},
	358	};
	359	}
4e72c04a	360	VDEC_STATE.set_state(DecodingState::End);
69b93cb5 KS	361	}).unwrap()
	362	};
	363
	364
	365	Self {
	366	vqueue: Vec::with_capacity(FRAME_QUEUE_LEN),
	367	vpsend, vfrecv,
	368	do_yuv: false,
	369	vthread,
	370	}
	371	}
	372	pub fn flush(&mut self) {
b5053bfc	373	self.vqueue.clear();
4e72c04a	374	VDEC_STATE.set_state(DecodingState::Flush);
69b93cb5 KS	375	for _ in 0..8 {
	376	let _ = self.vfrecv.try_recv();
	377	}
	378	let _ = self.vpsend.send(PktSendEvent::Flush);
	379	while self.vfrecv.try_recv().is_ok() { }
	380	}
	381	pub fn get_queue_size(&self) -> usize { self.vqueue.len() }
	382	pub fn is_filled(&self, size: usize) -> bool {
	383	self.vqueue.len() >= size
	384	}
	385	pub fn try_send_video(&mut self, evt: PktSendEvent) -> bool {
bbd69555	386	if !self.vqueue.is_empty() {
69b93cb5 KS	387	self.vqueue.push(evt);
	388	false
	389	} else {
	390	self.try_send_event(evt)
	391	}
	392	}
	393	fn try_send_event(&mut self, evt: PktSendEvent) -> bool {
	394	if let Err(TrySendError::Full(evt)) = self.vpsend.try_send(evt) {
	395	self.vqueue.insert(0, evt);
	396	false
	397	} else {
	398	true
	399	}
	400	}
	401	pub fn try_send_queued(&mut self) -> bool {
	402	while !self.vqueue.is_empty() {
	403	let pkt = self.vqueue.remove(0);
	404	if !self.try_send_event(pkt) {
	405	return false;
	406	}
	407	}
	408	true
	409	}
	410	pub fn is_video_end(&self) -> bool {
4e72c04a	411	matches!(VDEC_STATE.get_state(), DecodingState::End \| DecodingState::Error)
69b93cb5	412	}
4e72c04a KS	413	pub fn wait_for_frames(&mut self) -> Result<(), ()> {
4e72c04a KS	414	VDEC_STATE.set_state(DecodingState::Prefetch);
37f130a7 KS	415	self.try_send_event(PktSendEvent::GetFrames);
	416	while !self.try_send_queued() {
	417	}
4e72c04a KS	418	loop {
	419	match VDEC_STATE.get_state() {
	420	DecodingState::Waiting => {
	421	VDEC_STATE.set_state(DecodingState::Normal);
	422	return Ok(());
	423	},
	424	DecodingState::Prefetch => thread::yield_now(),
	425	_ => return Err(()),
	426	};
37f130a7 KS	427	}
37f130a7 KS	428	}
69b93cb5 KS	429
	430	pub fn is_yuv(&self) -> bool { self.do_yuv }
	431
	432	pub fn fill(&mut self, disp_queue: &mut DispQueue) {
	433	while !disp_queue.is_full() {
	434	let is_empty = disp_queue.is_empty();
	435	if let Ok((pic, time)) = self.vfrecv.try_recv() {
27c26a2a	436	let buf = pic.get_vbuf().expect("video frame should be of u8 type");
69b93cb5 KS	437	self.do_yuv = buf.get_info().get_format().get_model().is_yuv();
	438	let idx = disp_queue.end;
	439	disp_queue.move_end();
	440	let frm = &mut disp_queue.pool[idx];
	441	if !self.do_yuv {
	442	let sstride = buf.get_stride(0);
	443	let src = buf.get_data();
	444	frm.rgb_tex.with_lock(None, \|buffer: &mut [u8], pitch: usize\| {
	445	let csize = sstride.min(pitch);
	446	for (dst, src) in buffer.chunks_mut(pitch).zip(src.chunks(sstride)) {
bbd69555	447	dst[..csize].copy_from_slice(&src[..csize]);
69b93cb5 KS	448	}
69b93cb5 KS	449	true
27c26a2a	450	}).expect("surface should be locked");
69b93cb5 KS	451	} else {
	452	output_yuv(&mut frm.yuv_tex, &buf, disp_queue.width, disp_queue.height);
	453	}
	454	frm.valid = true;
	455	frm.is_yuv = self.do_yuv;
	456	frm.ts = time;
	457	if is_empty {
	458	disp_queue.first_ts = time;
	459	}
	460	disp_queue.last_ts = time;
	461	} else {
	462	break;
	463	}
	464	}
	465	}
	466
	467	pub fn finish(self) {
4e72c04a	468	VDEC_STATE.set_state(DecodingState::Flush);
69b93cb5 KS	469	for _ in 0..8 {
	470	let _ = self.vfrecv.try_recv();
	471	}
	472	let _ = self.vpsend.send(PktSendEvent::ImmediateEnd);
	473	self.vthread.join().unwrap();
	474	}
	475	}