1 use nihav_core::codecs::*;
2 use nihav_core::io::byteio::*;
4 use super::vpcommon::*;
20 const VERSION_VP61: u8 = VERSION_VP60 + 1;
22 enum VP6Writer<'a, 'b> {
23 BoolCoder(BoolEncoder<'a, 'b>),
24 Huffman(HuffEncoder<'a, 'b>),
28 pub struct VP56DCPred {
41 last_dc: [[i16; 4]; 3],
44 const INVALID_REF: u8 = 42;
47 fn new() -> Self { Self::default() }
48 fn resize(&mut self, mb_w: usize) {
49 self.dc_y.resize(mb_w * 2 + 2, 0);
50 self.dc_u.resize(mb_w + 2, 0);
51 self.dc_v.resize(mb_w + 2, 0);
52 self.ref_y.resize(mb_w * 2 + 2, INVALID_REF);
53 self.ref_c.resize(mb_w + 2, INVALID_REF);
58 for el in self.ref_y.iter_mut().skip(1) { *el = INVALID_REF; }
59 for el in self.ref_c.iter_mut().skip(1) { *el = INVALID_REF; }
61 self.last_dc = [[0; 4]; 3];
62 self.last_dc[0][1] = 0x80;
63 self.last_dc[0][2] = 0x80;
65 fn update_row(&mut self) {
71 self.ref_left = INVALID_REF;
73 fn next_mb(&mut self) {
77 fn predict_dc(&mut self, mb_type: VPMBType, blk_no: usize, coeffs: &mut [i16; 64], fwd: bool) {
78 let is_luma = blk_no < 4;
79 let (plane, dcs) = match blk_no {
80 4 => (1, &mut self.dc_u),
81 5 => (2, &mut self.dc_v),
82 _ => (0, &mut self.dc_y),
84 let (dc_ref, dc_idx) = if is_luma {
85 (&mut self.ref_y, self.y_idx + (blk_no & 1))
87 (&mut self.ref_c, self.c_idx)
89 let ref_id = mb_type.get_ref_id();
92 let has_left_blk = is_luma && ((blk_no & 1) == 1);
93 if has_left_blk || self.ref_left == ref_id {
94 dc_pred += match blk_no {
95 0 | 1 => self.ldc_y[0],
96 2 | 3 => self.ldc_y[1],
102 if dc_ref[dc_idx] == ref_id {
103 dc_pred += dcs[dc_idx];
107 dc_pred = self.last_dc[ref_id as usize][plane];
108 } else if count == 2 {
112 coeffs[0] += dc_pred;
116 if blk_no != 4 { // update top block reference only for the second chroma component
117 dc_ref[dc_idx] = ref_id;
131 self.ref_left = ref_id;
136 self.last_dc[ref_id as usize][plane] = dc;
138 coeffs[0] -= dc_pred;
144 fn no_dc(&self) -> bool;
145 fn no_ac(&self) -> bool;
148 impl ZeroBlock for [i16; 64] {
149 fn no_dc(&self) -> bool {
152 fn no_ac(&self) -> bool {
153 for &el in self[1..].iter() {
163 stream: Option<NAStreamRef>,
164 pkt: Option<NAPacket>,
170 top_ctx: [Vec<bool>; 4],
171 mc_buf: NAVideoBufferRef<u8>,
173 ratectl: RateControl,
182 stats: VP56ModelsStat,
185 last_frame: NABufferType,
186 gold_frame: NABufferType,
188 me_mode: MVSearchMode,
191 force_q: Option<usize>,
196 fn new(flipped: bool) -> Self {
197 let vt = alloc_video_buffer(NAVideoInfo::new(24, 24, false, VP_YUVA420_FORMAT), 4).unwrap();
198 let mc_buf = vt.get_vbuf().unwrap();
206 dc_pred: VP56DCPred::new(),
207 top_ctx: [Vec::new(), Vec::new(), Vec::new(), Vec::new()],
208 fenc: FrameEncoder::new(),
209 ratectl: RateControl::new(),
215 version: VERSION_VP60,
216 profile: VP6_SIMPLE_PROFILE,
218 models: VP56Models::new(),
219 pmodels: VP56Models::new(),
220 stats: VP56ModelsStat::new(),
222 last_frame: NABufferType::None,
223 gold_frame: NABufferType::None,
225 me_mode: MVSearchMode::default(),
232 fn decide_encoding(&mut self) -> bool {
235 fn estimate_blocks(&mut self, is_intra: bool) {
236 for top_ctx in self.top_ctx.iter_mut() {
237 for el in top_ctx.iter_mut() {
241 let mut last_mbt = VPMBType::InterNoMV;
243 for _mb_y in 0..self.mb_h {
244 let mut left_dc = [false; 4];
245 for mb_x in 0..self.mb_w {
246 let mb_type = self.fenc.mb_types[mb_idx];
248 estimate_mb_type(mb_type, last_mbt, ((self.fenc.num_mv[mb_idx] + 1) % 3) as usize, &mut self.stats);
251 VPMBType::InterMV | VPMBType::GoldenMV => {
252 estimate_mv(self.fenc.coded_mv[mb_idx][3], &mut self.stats);
254 VPMBType::InterFourMV => {
255 for (&sub_type, &mv) in self.fenc.fmv_sub[mb_idx].iter().zip(self.fenc.coded_mv[mb_idx].iter()) {
256 if sub_type == VPMBType::InterMV {
257 estimate_mv(mv, &mut self.stats);
264 let mb = self.fenc.get_mb(mb_idx);
266 let cur_idx = mb_x * 2 + (i & 1);
268 if self.top_ctx[0][cur_idx] {
274 self.top_ctx[0][cur_idx] = mb.coeffs[i][0] != 0;
275 left_dc[i >> 1] = mb.coeffs[i][0] != 0;
276 estimate_block(&mb.coeffs[i], dc_mode, &mut self.stats.coeff_models[0], &mut self.stats.vp6models, &self.models.vp6models.zigzag);
280 if self.top_ctx[1][mb_x] {
286 self.top_ctx[1][mb_x] = mb.coeffs[4][0] != 0;
287 left_dc[2] = mb.coeffs[4][0] != 0;
288 estimate_block(&mb.coeffs[4], dc_mode, &mut self.stats.coeff_models[1], &mut self.stats.vp6models, &self.models.vp6models.zigzag);
291 if self.top_ctx[2][mb_x] {
297 self.top_ctx[2][mb_x] = mb.coeffs[5][0] != 0;
298 left_dc[3] = mb.coeffs[5][0] != 0;
299 estimate_block(&mb.coeffs[5], dc_mode, &mut self.stats.coeff_models[1], &mut self.stats.vp6models, &self.models.vp6models.zigzag);
305 fn prepare_huff_models(&mut self) {
307 self.models.vp6huff.dc_token_tree[i].build_codes(&self.models.coeff_models[i].dc_value_probs);
312 self.models.vp6huff.ac_token_tree[i][mode][band].build_codes(&self.models.coeff_models[i].ac_val_probs[mode][band]);
317 self.models.vp6huff.zero_run_tree[i].build_codes_zero_run(&self.models.vp6models.zero_run_probs[i]);
320 fn determine_coeff_runs_luma(&self, hstate: &mut HuffState, mb_pos: usize, blk: usize) {
321 let mb = self.fenc.get_mb(mb_pos);
323 if !hstate.dc_zr_coded[0] {
324 if mb.coeffs[blk].no_dc() {
325 hstate.dc_zero_run[0] = 0;
326 let mut blk_no = (blk + 1) & 3;
327 let mut mb_no = mb_pos + ((blk + 1) >> 2);
329 let mut last_mb_no = mb_pos;
330 while (hstate.dc_zero_run[0] < MAX_EOB_RUN) && (mb_no < self.mb_w * self.mb_h) {
331 if mb_no != last_mb_no {
332 cmb = self.fenc.get_mb(mb_no);
335 if !cmb.coeffs[blk_no].no_dc() {
338 hstate.dc_zero_run[0] += 1;
347 if !hstate.ac_zr_coded[0] {
348 if mb.coeffs[blk].no_ac() {
349 hstate.ac_zero_run[0] = 0;
350 let mut blk_no = (blk + 1) & 3;
351 let mut mb_no = mb_pos + ((blk + 1) >> 2);
353 let mut last_mb_no = mb_pos;
354 while (hstate.ac_zero_run[0] < MAX_EOB_RUN) && (mb_no < self.mb_w * self.mb_h) {
355 if mb_no != last_mb_no {
356 cmb = self.fenc.get_mb(mb_no);
359 if !cmb.coeffs[blk_no].no_ac() {
362 hstate.ac_zero_run[0] += 1;
372 fn determine_coeff_runs_chroma(&self, hstate: &mut HuffState, mb_pos: usize, plane: usize) {
373 let mb = self.fenc.get_mb(mb_pos);
376 if !hstate.dc_zr_coded[1] {
377 if mb.coeffs[blk].no_dc() {
378 hstate.dc_zero_run[1] = 0;
379 let mut blk_no = if blk == 4 { 5 } else { 4 };
380 let mut mb_no = mb_pos + if blk == 4 { 0 } else { 1 };
381 while (hstate.dc_zero_run[1] < MAX_EOB_RUN) && (mb_no < self.mb_w * self.mb_h) {
382 let mb = self.fenc.get_mb(mb_no);
383 if !mb.coeffs[blk_no].no_dc() {
386 hstate.dc_zero_run[1] += 1;
395 if !hstate.ac_zr_coded[1] {
396 if mb.coeffs[blk].no_ac() {
397 hstate.ac_zero_run[1] = 0;
398 let mut blk_no = if blk == 4 { 5 } else { 4 };
399 let mut mb_no = mb_pos + if blk == 4 { 0 } else { 1 };
400 while (hstate.ac_zero_run[1] < MAX_EOB_RUN) && (mb_no < self.mb_w * self.mb_h) {
401 let mb = self.fenc.get_mb(mb_no);
402 if !mb.coeffs[blk_no].no_ac() {
405 hstate.ac_zero_run[1] += 1;
415 fn encode_intra(&mut self, bw: &mut ByteWriter, quant: usize) -> EncoderResult<bool> {
416 self.models.reset(false);
417 self.models.reset_mbtype_models();
420 self.pmodels.reset(false);
421 self.pmodels.reset_mbtype_models();
423 let multistream = self.huffman || self.version != VERSION_VP60;
425 self.fenc.prepare_intra_blocks();
426 self.fenc.apply_dc_prediction(&mut self.dc_pred);
427 self.estimate_blocks(true);
428 self.stats.generate(&mut self.models, true);
431 bw.write_byte(((quant as u8) << 1) | (multistream as u8))?;
432 bw.write_byte((self.version << 3) | (self.profile << 1))?;
433 bw.write_u16be(0)?; // part 2 offset placeholder
435 let mut bc = BoolEncoder::new(bw);
437 bc.put_bits(self.mb_h as u32, 8)?;
438 bc.put_bits(self.mb_w as u32, 8)?;
439 bc.put_bits(self.mb_h as u32, 8)?; // display MB height
440 bc.put_bits(self.mb_w as u32, 8)?; // display MB width
441 bc.put_bits(0, 2)?; // scaline mode
442 // todo other advanced profile bits
443 bc.put_bits(self.huffman as u32, 1)?; // Huffman mode
445 encode_coeff_models(&mut bc, &mut self.models, &self.pmodels, true, false)?;
446 self.pmodels = self.models.clone();
448 if multistream || (self.profile == VP6_SIMPLE_PROFILE) {
451 // patch coefficient offset
452 let offset = bw.tell();
454 return Err(EncoderError::Bug);
456 bw.seek(SeekFrom::Start(2))?;
457 bw.write_u16be(offset as u16)?;
458 bw.seek(SeekFrom::End(0))?;
460 bc = BoolEncoder::new(bw);
462 let writer = if !self.huffman {
463 VP6Writer::BoolCoder(bc)
465 VP6Writer::Huffman(HuffEncoder::new(bw))
467 self.encode_coeffs(writer)?;
470 fn encode_inter(&mut self, bw: &mut ByteWriter, quant: usize) -> EncoderResult<bool> {
473 let multistream = self.huffman || self.version != VERSION_VP60;
474 let loop_filter = false;
476 self.fenc.prepare_intra_blocks();
477 self.fenc.prepare_inter_blocks(false);
479 self.fenc.prepare_inter_blocks(true);
481 let lambda = if self.force_q.is_some() { 1.0 } else { self.ratectl.lambda };
482 self.fenc.select_inter_blocks(self.last_frame.get_vbuf().unwrap(), self.mc_buf.clone(), !self.last_gold, lambda);
483 // todo implement forced intra
484 let (_force_intra, golden_frame) = self.fenc.decide_frame_type();
485 self.fenc.apply_dc_prediction(&mut self.dc_pred);
486 self.fenc.predict_mvs();
488 self.write_inter_frame(bw, quant, multistream, loop_filter, golden_frame)?;
492 fn write_inter_frame(&mut self, bw: &mut ByteWriter, quant: usize, multistream: bool, loop_filter: bool, golden_frame: bool) -> EncoderResult<()> {
493 self.estimate_blocks(false);
495 self.stats.generate(&mut self.models, false);
498 bw.write_byte(0x80 | ((quant as u8) << 1) | (multistream as u8))?;
499 bw.write_u16be(0)?; // part 2 offset placeholder
501 let mut bc = BoolEncoder::new(bw);
503 bc.put_bits(golden_frame as u32, 1)?; // refresh golden frame
504 if self.profile == VP6_ADVANCED_PROFILE {
505 bc.put_bits(loop_filter as u32, 1)?; // use loop filter
507 bc.put_bits(0, 1)?; // loop filter selector
509 if self.version == VERSION_VP62 {
510 bc.put_bits(0, 1)?; // auto select PM
513 // todo other advanced profile bits
514 bc.put_bits(self.huffman as u32, 1)?;
516 encode_mode_prob_models(&mut bc, &mut self.models, &self.pmodels, &self.stats.mbtype_models)?;
517 encode_mv_models(&mut bc, &self.models.mv_models, &self.pmodels.mv_models)?;
518 encode_coeff_models(&mut bc, &mut self.models, &self.pmodels, false, false)?;
519 self.pmodels = self.models.clone();
521 let mut last_mbt = VPMBType::InterNoMV;
522 for mb_idx in 0..self.mb_w * self.mb_h {
523 let mb_type = self.fenc.mb_types[mb_idx];
524 encode_mb_type(&mut bc, self.fenc.mb_types[mb_idx], last_mbt, ((self.fenc.num_mv[mb_idx] + 1) % 3) as usize, &self.models)?;
527 VPMBType::InterMV | VPMBType::GoldenMV => {
528 encode_mv(&mut bc, self.fenc.coded_mv[mb_idx][3], &self.models)?;
530 VPMBType::InterFourMV => {
531 for &sub_type in self.fenc.fmv_sub[mb_idx].iter() {
532 let id = match sub_type {
533 VPMBType::InterNoMV => 0,
534 VPMBType::InterMV => 1,
535 VPMBType::InterNearest => 2,
536 VPMBType::InterNear => 3,
541 for (&sub_type, &mv) in self.fenc.fmv_sub[mb_idx].iter().zip(self.fenc.coded_mv[mb_idx].iter()) {
542 if sub_type == VPMBType::InterMV {
543 encode_mv(&mut bc, mv, &self.models)?;
551 if multistream || (self.profile == VP6_SIMPLE_PROFILE) {
554 // patch coefficient offset
555 let offset = bw.tell();
557 return Err(EncoderError::Bug);
559 bw.seek(SeekFrom::Start(1))?;
560 bw.write_u16be(offset as u16)?;
561 bw.seek(SeekFrom::End(0))?;
563 bc = BoolEncoder::new(bw);
565 let writer = if !self.huffman {
566 VP6Writer::BoolCoder(bc)
568 VP6Writer::Huffman(HuffEncoder::new(bw))
570 self.encode_coeffs(writer)?;
574 fn encode_inter_fast(&mut self, bw: &mut ByteWriter, quant: usize) -> EncoderResult<bool> {
577 let multistream = self.huffman || self.version != VERSION_VP60;
578 let loop_filter = false;
580 let last_frm = self.last_frame.get_vbuf().unwrap();
581 let gold_frm = if !self.last_gold {
582 Some(self.gold_frame.get_vbuf().unwrap())
586 let lambda = if self.force_q.is_some() { 1.0 } else { self.ratectl.lambda };
587 self.fenc.select_inter_blocks_fast(last_frm, gold_frm, self.mc_buf.clone(), lambda);
588 let golden_frame = false;
589 self.fenc.apply_dc_prediction(&mut self.dc_pred);
590 self.fenc.predict_mvs();
591 self.estimate_blocks(false);
593 self.write_inter_frame(bw, quant, multistream, loop_filter, golden_frame)?;
597 fn encode_coeffs(&mut self, mut writer: VP6Writer) -> EncoderResult<()> {
599 self.prepare_huff_models();
602 let mut hstate = HuffState::new();
603 for top_ctx in self.top_ctx.iter_mut() {
604 for el in top_ctx.iter_mut() {
609 for _mb_y in 0..self.mb_h {
610 let mut left_dc = [false; 4];
611 for mb_x in 0..self.mb_w {
612 let mb = self.fenc.get_mb(mb_pos);
614 let cur_idx = mb_x * 2 + (i & 1);
616 if self.top_ctx[0][cur_idx] {
622 self.top_ctx[0][cur_idx] = mb.coeffs[i][0] != 0;
623 left_dc[i >> 1] = mb.coeffs[i][0] != 0;
625 self.determine_coeff_runs_luma(&mut hstate, mb_pos, i);
628 VP6Writer::BoolCoder(ref mut bc) => encode_block(bc, &mb.coeffs[i], dc_mode, &self.models.coeff_models[0], &self.models.vp6models)?,
629 VP6Writer::Huffman(ref mut huff) => encode_block_huff(huff, &self.models.vp6models.zigzag, &mb.coeffs[i], 0, &mut hstate, &self.models.vp6huff)?,
635 if self.top_ctx[plane][mb_x] {
638 if left_dc[plane + 1] {
641 self.top_ctx[plane][mb_x] = mb.coeffs[plane + 3][0] != 0;
642 left_dc[plane + 1] = mb.coeffs[plane + 3][0] != 0;
644 self.determine_coeff_runs_chroma(&mut hstate, mb_pos, plane);
647 VP6Writer::BoolCoder(ref mut bc) => encode_block(bc, &mb.coeffs[plane + 3], dc_mode, &self.models.coeff_models[1], &self.models.vp6models)?,
648 VP6Writer::Huffman(ref mut huff) => encode_block_huff(huff, &self.models.vp6models.zigzag, &mb.coeffs[plane + 3], 1, &mut hstate, &self.models.vp6huff)?,
657 VP6Writer::BoolCoder(bc) => bc.flush()?,
658 VP6Writer::Huffman(huff) => huff.flush()?,
665 impl NAEncoder for VP6Encoder {
666 fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
667 match encinfo.format {
668 NACodecTypeInfo::None => {
669 Ok(EncodeParameters {
670 format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, self.flipped, YUV420_FORMAT)),
674 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
675 NACodecTypeInfo::Video(vinfo) => {
676 let outinfo = NAVideoInfo::new((vinfo.width + 3) & !3, (vinfo.height + 3) & !3, self.flipped, YUV420_FORMAT);
677 let mut ofmt = *encinfo;
678 ofmt.format = NACodecTypeInfo::Video(outinfo);
683 fn get_capabilities(&self) -> u64 { 0 }
684 fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
685 match encinfo.format {
686 NACodecTypeInfo::None => Err(EncoderError::FormatError),
687 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
688 NACodecTypeInfo::Video(vinfo) => {
689 if vinfo.format != YUV420_FORMAT {
690 return Err(EncoderError::FormatError);
692 if ((vinfo.width | vinfo.height) & 15) != 0 {
693 return Err(EncoderError::FormatError);
695 if (vinfo.width | vinfo.height) >= (1 << 12) {
696 return Err(EncoderError::FormatError);
699 let out_info = NAVideoInfo::new(vinfo.width, vinfo.height, self.flipped, vinfo.format);
700 let info = NACodecInfo::new(if self.flipped { "vp6" } else { "vp6f" }, NACodecTypeInfo::Video(out_info), None);
701 let mut stream = NAStream::new(StreamType::Video, stream_id, info, encinfo.tb_num, encinfo.tb_den, 0);
702 stream.set_num(stream_id as usize);
703 let stream = stream.into_ref();
705 self.last_frame = alloc_video_buffer(out_info, 4)?;
706 self.gold_frame = alloc_video_buffer(out_info, 4)?;
708 self.stream = Some(stream.clone());
710 self.mb_w = (vinfo.width + 15) >> 4;
711 self.mb_h = (vinfo.height + 15) >> 4;
712 self.fenc.resize(self.mb_w, self.mb_h);
713 self.ratectl.init(self.mb_w, self.mb_h, encinfo.bitrate, encinfo.tb_num, encinfo.tb_den);
715 self.dc_pred.resize(self.mb_w);
716 self.top_ctx = [vec![false; self.mb_w * 2], vec![false; self.mb_w], vec![false; self.mb_w], vec![false; self.mb_w * 2]];
718 self.version = VERSION_VP60;
719 self.profile = VP6_SIMPLE_PROFILE;
725 fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
726 let buf = frm.get_buffer();
727 if let Some(ref vbuf) = buf.get_vbuf() {
728 let mut dbuf = Vec::with_capacity(4);
729 let mut gw = GrowableMemoryWriter::new_write(&mut dbuf);
730 let mut bw = ByteWriter::new(&mut gw);
732 // todo integrate with rate control
733 let is_intra = (self.frmcount == 0) || self.decide_encoding();
734 let quant = if let Some(q) = self.force_q {
737 self.ratectl.guess_quant(is_intra, self.huffman)
740 self.fenc.read_mbs(vbuf);
741 self.fenc.set_quant(quant);
742 self.fenc.me_mode = self.me_mode;
743 self.fenc.me_range = self.me_range;
744 let golden_frame = if is_intra {
745 self.encode_intra(&mut bw, quant)?
746 } else if !self.fast {
747 self.fenc.estimate_mvs(self.last_frame.get_vbuf().unwrap(), self.mc_buf.clone(), false);
749 self.fenc.estimate_mvs(self.gold_frame.get_vbuf().unwrap(), self.mc_buf.clone(), true);
751 self.encode_inter(&mut bw, quant)?
753 self.encode_inter_fast(&mut bw, quant)?
755 self.fenc.reconstruct_frame(&mut self.dc_pred, self.last_frame.get_vbuf().unwrap());
756 self.last_gold = golden_frame;
758 let mut dfrm = self.gold_frame.get_vbuf().unwrap();
759 let src = self.last_frame.get_vbuf().unwrap();
761 let dst = dfrm.get_data_mut().unwrap();
762 dst.copy_from_slice(src.get_data());
765 if self.force_q.is_none() {
766 self.ratectl.update(dbuf.len() * 8);
769 self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, is_intra, dbuf));
770 if self.key_int > 0 {
773 if self.frmcount == self.key_int {
778 Err(EncoderError::InvalidParameters)
781 fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
783 std::mem::swap(&mut self.pkt, &mut npkt);
786 fn flush(&mut self) -> EncoderResult<()> {
792 const HUFFMAN_OPTION: &str = "huffman";
793 const QUANT_OPTION: &str = "quant";
794 const VERSION_OPTION: &str = "version";
795 const MV_SEARCH_OPTION: &str = "mv_mode";
796 const MV_RANGE_OPTION: &str = "mv_range";
797 const FAST_OPTION: &str = "fast";
799 const ENCODER_OPTS: &[NAOptionDefinition] = &[
801 name: KEYFRAME_OPTION, description: KEYFRAME_OPTION_DESC,
802 opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
804 name: HUFFMAN_OPTION, description: "use Huffman encoding",
805 opt_type: NAOptionDefinitionType::Bool },
807 name: VERSION_OPTION, description: "codec minor version",
808 opt_type: NAOptionDefinitionType::String(Some(&["vp60", "vp61", "vp62"])) },
810 name: QUANT_OPTION, description: "force fixed quantiser for encoding",
811 opt_type: NAOptionDefinitionType::Int(Some(-1), Some(63)) },
813 name: MV_SEARCH_OPTION, description: "motion search mode",
814 opt_type: NAOptionDefinitionType::String(Some(&["full", "dia", "hex"])) },
816 name: MV_RANGE_OPTION, description: "motion search range (in pixels)",
817 opt_type: NAOptionDefinitionType::Int(Some(0), Some(30)) },
819 name: FAST_OPTION, description: "faster (but worse) encoding",
820 opt_type: NAOptionDefinitionType::Bool },
823 impl NAOptionHandler for VP6Encoder {
824 fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
825 fn set_options(&mut self, options: &[NAOption]) {
826 for option in options.iter() {
827 for opt_def in ENCODER_OPTS.iter() {
828 if opt_def.check(option).is_ok() {
831 if let NAValue::Int(intval) = option.value {
832 self.key_int = intval as u8;
836 if let NAValue::Bool(bval) = option.value {
841 if let NAValue::String(ref string) = option.value {
842 self.version = match string.as_str() {
843 "vp60" => VERSION_VP60,
844 "vp61" => VERSION_VP61,
845 "vp62" => VERSION_VP62,
851 if let NAValue::Int(intval) = option.value {
852 self.force_q = if intval < 0 { None } else { Some(intval as usize) };
855 MV_SEARCH_OPTION => {
856 if let NAValue::String(ref string) = option.value {
857 if let Ok(mv_mode) = string.parse::<MVSearchMode>() {
858 self.me_mode = mv_mode;
863 if let NAValue::Int(intval) = option.value {
864 self.me_range = intval as i16;
868 if let NAValue::Bool(bval) = option.value {
878 fn query_option_value(&self, name: &str) -> Option<NAValue> {
880 KEYFRAME_OPTION => Some(NAValue::Int(i64::from(self.key_int))),
881 HUFFMAN_OPTION => Some(NAValue::Bool(self.huffman)),
883 let ver = match self.version {
884 VERSION_VP60 => "vp60",
885 VERSION_VP61 => "vp61",
886 VERSION_VP62 => "vp62",
889 Some(NAValue::String(ver.to_string()))
891 QUANT_OPTION => if let Some(q) = self.force_q {
892 Some(NAValue::Int(q as i64))
894 Some(NAValue::Int(-1))
896 MV_SEARCH_OPTION => Some(NAValue::String(self.me_mode.to_string())),
897 MV_RANGE_OPTION => Some(NAValue::Int(i64::from(self.me_range))),
898 FAST_OPTION => Some(NAValue::Bool(self.fast)),
904 pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
905 Box::new(VP6Encoder::new(true))
908 pub fn get_encoder_flv() -> Box<dyn NAEncoder + Send> {
909 Box::new(VP6Encoder::new(false))
914 use nihav_core::codecs::*;
915 use nihav_core::demuxers::*;
916 use nihav_core::muxers::*;
918 use nihav_commonfmt::*;
919 use nihav_codec_support::test::enc_video::*;
921 fn encode_test(out_name: &'static str, enc_options: &[NAOption], hash: &[u32; 4]) {
922 let mut dmx_reg = RegisteredDemuxers::new();
923 generic_register_all_demuxers(&mut dmx_reg);
924 let mut dec_reg = RegisteredDecoders::new();
925 duck_register_all_decoders(&mut dec_reg);
926 let mut mux_reg = RegisteredMuxers::new();
927 generic_register_all_muxers(&mut mux_reg);
928 let mut enc_reg = RegisteredEncoders::new();
929 duck_register_all_encoders(&mut enc_reg);
931 // sample: https://samples.mplayerhq.hu/V-codecs/VP4/ot171_vp40.avi
932 let dec_config = DecoderTestParams {
934 in_name: "assets/Duck/ot171_vp40.avi",
935 stream_type: StreamType::Video,
939 let enc_config = EncoderTestParams {
945 let dst_vinfo = NAVideoInfo {
948 format: YUV420_FORMAT,
952 let enc_params = EncodeParameters {
953 format: NACodecTypeInfo::Video(dst_vinfo),
960 //test_encoding_to_file(&dec_config, &enc_config, enc_params, enc_options);
961 test_encoding_md5(&dec_config, &enc_config, enc_params, enc_options,
965 fn test_vp6_encoder_bc() {
967 NAOption { name: super::QUANT_OPTION, value: NAValue::Int(42) },
969 encode_test("vp6-bool.avi", enc_options, &[0xb57f49e5, 0x6b48accd, 0xc28fadb3, 0xc89a30d2]);
972 fn test_vp6_encoder_fast() {
974 NAOption { name: super::QUANT_OPTION, value: NAValue::Int(42) },
975 NAOption { name: super::FAST_OPTION, value: NAValue::Bool(true) },
977 encode_test("vp6-fast.avi", enc_options, &[0xb8037ce1, 0xc00ade72, 0x3c0b73c2, 0xbfc4113d]);
980 fn test_vp6_encoder_rc() {
983 encode_test("vp6-rc.avi", enc_options, &[0x790baca9, 0x663eafcf, 0x36d1bed8, 0xddf882de]);
986 fn test_vp6_encoder_huff() {
988 NAOption { name: super::HUFFMAN_OPTION, value: NAValue::Bool(true) },
989 NAOption { name: super::QUANT_OPTION, value: NAValue::Int(42) },
991 encode_test("vp6-huff.avi", enc_options, &[0x6e9bb23d, 0xde296d92, 0x4c225bae, 0x3651e31f]);