msvideo1enc: switch to faster 2-colour quantiser
[nihav.git] / nihav-ms / src / codecs / msvideo1enc.rs
CommitLineData
dab59886
KS
1use nihav_core::codecs::*;
2use nihav_core::io::byteio::*;
dab59886 3
81d5776a 4const INVALID_CLR: u16 = 0x8000;
dab59886 5
81d5776a
KS
6trait InvalidPixel {
7 fn is_invalid(self) -> bool;
dab59886 8}
81d5776a
KS
9impl InvalidPixel for u16 {
10 fn is_invalid(self) -> bool { self == INVALID_CLR }
11}
12
13trait PixelOps {
14 fn unpack(&self) -> [u16; 4];
15 fn dist<T: PixelOps>(&self, val: T) -> u32 {
16 dist_core(self.unpack(), &val.unpack())
dab59886 17 }
81d5776a
KS
18}
19
20impl PixelOps for u16 {
21 fn unpack(&self) -> [u16; 4] {
22 let val = *self;
23 let r = (val >> 10) & 0x1F;
24 let g = (val >> 5) & 0x1F;
25 let b = val & 0x1F;
26 [r, g, b, rgb2y(r, g, b)]
dab59886 27 }
81d5776a
KS
28}
29
30fn dist_core(val: [u16; 4], other: &[u16; 4]) -> u32 {
31 let sum = val.iter().zip(other.iter()).take(3).fold(0i32,
32 |acc, (&a, &b)| {
33 let diff = i32::from(a) - i32::from(b);
34 acc + diff * diff
35 });
36 sum as u32
37}
38
39
40fn rgb2y(r: u16, g: u16, b: u16) -> u16 {
41 (r * 77 + g * 150 + b * 29) >> 8
42}
43
44fn pack_rgb555(val: [u16; 4]) -> u16 {
45 (val[0] << 10) | (val[1] << 5) | val[2]
46}
47
48#[derive(Default)]
49struct PixelAverage {
50 sum: [u16; 4],
51 count: u16,
52}
53
54impl PixelAverage {
55 fn new() -> Self { Self::default() }
56 fn add(&mut self, val: &[u16; 4]) {
57 for (dst, &src) in self.sum.iter_mut().zip(val.iter()) {
58 *dst += src;
dab59886 59 }
81d5776a 60 self.count += 1;
dab59886 61 }
81d5776a
KS
62 fn get_avg(&self) -> [u16; 4] {
63 if self.count > 0 {
64 let mut ret = self.sum;
65 for el in ret.iter_mut() {
66 *el /= self.count;
67 }
68 ret
dab59886 69 } else {
81d5776a 70 [0; 4]
dab59886
KS
71 }
72 }
73}
74
81d5776a
KS
75macro_rules! quant_template {
76 ($name:ident, $N:expr) => {
77 fn $name(pix: &[u16; $N]) -> ([u16; 2], u16, u32) {
78 let mut tmp = [[0; 4]; $N];
79 let mut avg = PixelAverage::new();
80 let mut maxv = [0; 4];
81 let mut minv = [255; 4];
82 for (dst, &src) in tmp.iter_mut().zip(pix.iter()) {
83 *dst = src.unpack();
84 avg.add(dst);
85 for ((maxv, minv), &comp) in maxv.iter_mut().zip(minv.iter_mut()).zip(dst.iter()) {
86 *maxv = (*maxv).max(comp);
87 *minv = (*minv).min(comp);
88 }
89 }
90 let avg = avg.get_avg();
dab59886 91
81d5776a
KS
92 let mut best_axis = 3;
93 let mut best_dist = maxv[3] - minv[3];
94 for (comp_no, (&minval, &maxval)) in minv.iter().zip(maxv.iter()).enumerate().take(3) {
95 if maxval - minval > best_dist {
96 best_axis = comp_no;
97 best_dist = maxval - minval;
98 }
99 }
100 if best_dist == 0 {
101 let avg_pix = pack_rgb555(avg);
102 let mut dist = 0;
103 for el in tmp.iter() {
104 dist += dist_core(avg, el);
105 }
106 return ([avg_pix; 2], 0, dist);
107 }
108
109 let mut avg1 = PixelAverage::new();
110 let mut avg2 = PixelAverage::new();
111 let mut mask = 0;
112 let mut mask_bit = 1;
113 for clr in tmp.iter() {
114 if clr[best_axis] > avg[best_axis] {
115 avg2.add(clr);
116 mask |= mask_bit;
117 } else {
118 avg1.add(clr);
119 }
120 mask_bit <<= 1;
121 }
122
123 let clr0 = avg1.get_avg();
124 let clr1 = avg2.get_avg();
125 let mut dist = 0;
126 for clr in tmp.iter() {
127 let dist0 = dist_core(clr0, clr);
128 let dist1 = dist_core(clr1, clr);
129 dist += dist0.min(dist1);
130 }
131 ([pack_rgb555(clr0), pack_rgb555(clr1)], mask, dist)
dab59886
KS
132 }
133 }
134}
135
81d5776a
KS
136quant_template!(quant2_16pix, 16);
137quant_template!(quant2_4pix, 4);
138
dab59886
KS
139#[derive(Default)]
140struct BlockState {
141 fill_dist: u32,
81d5776a 142 fill_val: u16,
dab59886
KS
143 clr2_dist: u32,
144 clr2_flags: u16,
81d5776a 145 clr2: [u16; 2],
dab59886
KS
146 clr8_dist: u32,
147 clr8_flags: u16,
81d5776a 148 clr8: [[u16; 2]; 4],
dab59886
KS
149}
150
151impl BlockState {
81d5776a 152 fn calc_clrs(buf: &[u16; 16]) -> Option<(u16, u16)> {
93d1e373 153 let clr0 = buf[0];
81d5776a 154 let mut clr1 = INVALID_CLR;
93d1e373
KS
155 for &pix in buf[1..].iter() {
156 if pix != clr0 && pix != clr1 {
157 if clr1.is_invalid() {
158 clr1 = pix;
159 } else {
160 return None;
161 }
162 }
163 }
164 Some((clr0, clr1))
165 }
81d5776a 166 fn calc_stats(&mut self, buf: &[u16; 16]) {
93d1e373
KS
167 let mut filled = false;
168 let mut two_clr = false;
169 if let Some((clr0, clr1)) = Self::calc_clrs(buf) {
170 self.clr2[0] = clr0;
171 self.clr2[1] = if !clr1.is_invalid() { clr1 } else { clr0 };
172 if clr0 == clr1 {
81d5776a 173 self.fill_val = buf[0] & !0x400;
93d1e373
KS
174 filled = true;
175 }
176 two_clr = true;
177 }
178 self.fill_dist = 0;
179 if !filled {
81d5776a
KS
180 let mut avg = PixelAverage::new();
181 for &pix in buf.iter() {
182 avg.add(&pix.unpack());
dab59886 183 }
81d5776a 184 self.fill_val = pack_rgb555(avg.get_avg()) & !0x400;
93d1e373
KS
185 for pix in buf.iter() {
186 self.fill_dist += pix.dist(self.fill_val);
187 }
dab59886
KS
188 }
189 if self.fill_dist == 0 {
190 self.clr2_dist = std::u32::MAX;
191 self.clr8_dist = std::u32::MAX;
192 return;
193 }
194
195 self.clr2_flags = 0u16;
93d1e373
KS
196 if two_clr {
197 let mut mask = 1;
198 self.clr2_dist = 0;
199 for &pix in buf.iter() {
200 if pix == self.clr2[0] {
201 self.clr2_flags |= mask;
202 } else {
203 }
204 mask <<= 1;
205 }
206 if (self.clr2_flags & 0x8000) != 0 {
207 self.clr2_flags = !self.clr2_flags;
208 self.clr2.swap(0, 1);
209 }
81d5776a
KS
210 } else {
211 let (clrs, mask, dist) = quant2_16pix(&buf);
212 self.clr2 = clrs;
213 self.clr2_flags = mask;
214 self.clr2_dist = dist;
dab59886
KS
215 if (self.clr2_flags & 0x8000) != 0 {
216 self.clr2_flags = !self.clr2_flags;
217 self.clr2.swap(0, 1);
218 }
dab59886
KS
219 }
220 if self.clr2_dist == 0 {
221 self.clr8_dist = std::u32::MAX;
222 return;
223 }
224
81d5776a 225 self.clr8 = [[0; 2]; 4];
dab59886
KS
226 self.clr8_flags = 0;
227 self.clr8_dist = 0;
dab59886
KS
228 for i in 0..4 {
229 let off = (i & 1) * 2 + (i & 2) * 4;
230 let src2 = [buf[off], buf[off + 1], buf[off + 4], buf[off + 5]];
81d5776a
KS
231 let (clrs, mask, dist) = quant2_4pix(&src2);
232 self.clr8[i] = clrs;
233 self.clr8_flags |= mask << (i * 4);
234 self.clr8_dist += dist;
dab59886
KS
235 }
236 if (self.clr8_flags & 0x8000) != 0 {
237 self.clr8_flags ^= 0xF000;
238 self.clr8[3].swap(0, 1);
239 }
240 }
241 fn put_fill(&self, dst: &mut [u16], dstride: usize) {
242 for line in dst.chunks_mut(dstride) {
243 for i in 0..4 {
81d5776a 244 line[i] = self.fill_val;
dab59886
KS
245 }
246 }
247 }
248 fn put_clr2(&self, dst: &mut [u16], dstride: usize) {
249 for j in 0..4 {
250 for i in 0..4 {
251 if (self.clr2_flags & (1 << (i + j * 4))) == 0 {
81d5776a 252 dst[i + j * dstride] = self.clr2[0];
dab59886 253 } else {
81d5776a 254 dst[i + j * dstride] = self.clr2[1];
dab59886
KS
255 }
256 }
257 }
258 }
259 fn put_clr8(&self, dst: &mut [u16], dstride: usize) {
260 for i in 0..4 {
261 let off = (i & 1) * 2 + (i & 2) * dstride;
262 let cur_flg = (self.clr8_flags >> (i * 4)) & 0xF;
81d5776a
KS
263 dst[off] = self.clr8[i][( !cur_flg & 1) as usize];
264 dst[off + 1] = self.clr8[i][((!cur_flg >> 1) & 1) as usize];
265 dst[off + dstride] = self.clr8[i][((!cur_flg >> 2) & 1) as usize];
266 dst[off + 1 + dstride] = self.clr8[i][((!cur_flg >> 3) & 1) as usize];
dab59886
KS
267 }
268 }
269 fn write_fill(&self, bw: &mut ByteWriter) -> EncoderResult<()> {
81d5776a 270 bw.write_u16le(self.fill_val | 0x8000)?;
dab59886
KS
271 Ok(())
272 }
273 fn write_clr2(&self, bw: &mut ByteWriter) -> EncoderResult<()> {
274 bw.write_u16le(self.clr2_flags)?;
81d5776a
KS
275 bw.write_u16le(self.clr2[0])?;
276 bw.write_u16le(self.clr2[1])?;
dab59886
KS
277 Ok(())
278 }
279 fn write_clr8(&self, bw: &mut ByteWriter) -> EncoderResult<()> {
280 bw.write_u16le(self.clr8_flags)?;
81d5776a
KS
281 bw.write_u16le(self.clr8[0][0] | 0x8000)?;
282 bw.write_u16le(self.clr8[0][1])?;
283 bw.write_u16le(self.clr8[1][0])?;
284 bw.write_u16le(self.clr8[1][1])?;
285 bw.write_u16le(self.clr8[2][0])?;
286 bw.write_u16le(self.clr8[2][1])?;
287 bw.write_u16le(self.clr8[3][0])?;
288 bw.write_u16le(self.clr8[3][1])?;
dab59886
KS
289 Ok(())
290 }
291}
292
293struct MSVideo1Encoder {
294 stream: Option<NAStreamRef>,
295 pkt: Option<NAPacket>,
296 pool: NAVideoBufferPool<u16>,
297 lastfrm: Option<NAVideoBufferRef<u16>>,
298 quality: u8,
299 frmcount: u8,
c9c7f648 300 key_int: u8,
dab59886
KS
301}
302
303impl MSVideo1Encoder {
304 fn new() -> Self {
305 Self {
306 stream: None,
307 pkt: None,
308 pool: NAVideoBufferPool::new(2),
309 lastfrm: None,
310 quality: 0,
311 frmcount: 0,
c9c7f648 312 key_int: 25,
dab59886
KS
313 }
314 }
81d5776a 315 fn get_block(src: &[u16], sstride: usize, buf: &mut [u16; 16]) {
dab59886 316 for (line, dst) in src.chunks(sstride).zip(buf.chunks_mut(4)) {
81d5776a 317 dst.copy_from_slice(&line[..4]);
dab59886
KS
318 }
319 }
320 fn write_skips(bw: &mut ByteWriter, skips: usize) -> EncoderResult<()> {
321 bw.write_u16le((skips as u16) | 0x8400)?;
322 Ok(())
323 }
324 fn encode_inter(bw: &mut ByteWriter, cur_frm: &mut NAVideoBuffer<u16>, in_frm: &NAVideoBuffer<u16>, prev_frm: &NAVideoBuffer<u16>, _quality: u8) -> EncoderResult<bool> {
325 let mut is_intra = true;
326 let src = in_frm.get_data();
327 let sstride = in_frm.get_stride(0);
328 let soff = in_frm.get_offset(0);
329 let (w, h) = in_frm.get_dimensions(0);
330 let rsrc = prev_frm.get_data();
331 let rstride = prev_frm.get_stride(0);
332 let roff = prev_frm.get_offset(0);
333 let dstride = cur_frm.get_stride(0);
334 let doff = cur_frm.get_offset(0);
335 let dst = cur_frm.get_data_mut().unwrap();
336 let mut skip_run = 0;
337 for ((sstrip, rstrip), dstrip) in (&src[soff..]).chunks(sstride * 4).take(h / 4).zip((&rsrc[roff..]).chunks(rstride * 4)).zip((&mut dst[doff..]).chunks_mut(dstride * 4)) {
338 for x in (0..w).step_by(4) {
81d5776a
KS
339 let mut buf = [0; 16];
340 let mut refbuf = [0; 16];
dab59886
KS
341 Self::get_block(&sstrip[x..], sstride, &mut buf);
342 Self::get_block(&rstrip[x..], rstride, &mut refbuf);
343
344 let mut skip_dist = 0;
345 for (pix, rpix) in buf.iter().zip(refbuf.iter()) {
346 skip_dist += pix.dist(*rpix);
347 }
348 if skip_dist == 0 {
349 skip_run += 1;
350 is_intra = false;
351 if skip_run == 1023 {
352 Self::write_skips(bw, skip_run)?;
353 skip_run = 0;
354 }
355 continue;
356 }
357
358 let mut bstate = BlockState::default();
359 bstate.calc_stats(&buf);
360
361 let dst = &mut dstrip[x..];
362 if skip_dist <= bstate.fill_dist {
363 skip_run += 1;
364 is_intra = false;
365 if skip_run == 1023 {
366 Self::write_skips(bw, skip_run)?;
367 skip_run = 0;
368 }
369 } else if bstate.fill_dist <= bstate.clr2_dist {
370 bstate.put_fill(dst, dstride);
371 if skip_run != 0 {
372 Self::write_skips(bw, skip_run)?;
373 skip_run = 0;
374 }
375 bstate.write_fill(bw)?;
376 } else if bstate.clr8_dist < bstate.clr2_dist {
377 bstate.put_clr8(dst, dstride);
378 if skip_run != 0 {
379 Self::write_skips(bw, skip_run)?;
380 skip_run = 0;
381 }
382 bstate.write_clr8(bw)?;
383 } else {
384 bstate.put_clr2(dst, dstride);
385 if skip_run != 0 {
386 Self::write_skips(bw, skip_run)?;
387 skip_run = 0;
388 }
389 bstate.write_clr2(bw)?;
390 }
391 }
392 }
393 if skip_run != 0 {
394 Self::write_skips(bw, skip_run)?;
395 }
396 if is_intra {
397 bw.write_u16le(0)?;
398 } //xxx: something for inter?
399 Ok(is_intra)
400 }
401 fn encode_intra(bw: &mut ByteWriter, cur_frm: &mut NAVideoBuffer<u16>, in_frm: &NAVideoBuffer<u16>, _quality: u8) -> EncoderResult<bool> {
402 let src = in_frm.get_data();
403 let sstride = in_frm.get_stride(0);
404 let soff = in_frm.get_offset(0);
405 let (w, h) = in_frm.get_dimensions(0);
406 let dstride = cur_frm.get_stride(0);
407 let doff = cur_frm.get_offset(0);
408 let dst = cur_frm.get_data_mut().unwrap();
409 for (sstrip, dstrip) in (&src[soff..]).chunks(sstride * 4).take(h / 4).zip((&mut dst[doff..]).chunks_mut(dstride * 4)) {
410 for x in (0..w).step_by(4) {
81d5776a 411 let mut buf = [0; 16];
dab59886
KS
412 Self::get_block(&sstrip[x..], sstride, &mut buf);
413 let mut bstate = BlockState::default();
414 bstate.calc_stats(&buf);
415
416 let dst = &mut dstrip[x..];
417 if bstate.fill_dist <= bstate.clr2_dist {
418 bstate.put_fill(dst, dstride);
419 bstate.write_fill(bw)?;
420 } else if bstate.clr8_dist < bstate.clr2_dist {
421 bstate.put_clr8(dst, dstride);
422 bstate.write_clr8(bw)?;
423 } else {
424 bstate.put_clr2(dst, dstride);
425 bstate.write_clr2(bw)?;
426 }
427 }
428 }
429 bw.write_u16le(0)?;
430 Ok(true)
431 }
432}
433
434const RGB555_FORMAT: NAPixelFormaton = NAPixelFormaton {
435 model: ColorModel::RGB(RGBSubmodel::RGB), components: 3,
436 comp_info: [
437 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 10, comp_offs: 0, next_elem: 2 }),
438 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 5, comp_offs: 0, next_elem: 2 }),
439 Some(NAPixelChromaton{ h_ss: 0, v_ss: 0, packed: true, depth: 5, shift: 0, comp_offs: 0, next_elem: 2 }),
440 None, None],
441 elem_size: 2, be: false, alpha: false, palette: false };
442
443impl NAEncoder for MSVideo1Encoder {
444 fn negotiate_format(&self, encinfo: &EncodeParameters) -> EncoderResult<EncodeParameters> {
445 match encinfo.format {
446 NACodecTypeInfo::None => {
6f263099
KS
447 Ok(EncodeParameters {
448 format: NACodecTypeInfo::Video(NAVideoInfo::new(0, 0, true, RGB555_FORMAT)),
449 ..Default::default() })
dab59886 450 },
4efceb69 451 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
dab59886
KS
452 NACodecTypeInfo::Video(vinfo) => {
453 let outinfo = NAVideoInfo::new((vinfo.width + 3) & !3, (vinfo.height + 3) & !3, true, RGB555_FORMAT);
d722ffe9 454 let mut ofmt = *encinfo;
dab59886
KS
455 ofmt.format = NACodecTypeInfo::Video(outinfo);
456 Ok(ofmt)
457 }
458 }
459 }
460 fn init(&mut self, stream_id: u32, encinfo: EncodeParameters) -> EncoderResult<NAStreamRef> {
461 match encinfo.format {
462 NACodecTypeInfo::None => Err(EncoderError::FormatError),
463 NACodecTypeInfo::Audio(_) => Err(EncoderError::FormatError),
464 NACodecTypeInfo::Video(vinfo) => {
465 if vinfo.format != RGB555_FORMAT {
466 return Err(EncoderError::FormatError);
467 }
468 if ((vinfo.width | vinfo.height) & 3) != 0 {
469 return Err(EncoderError::FormatError);
470 }
471
472 let out_info = NAVideoInfo::new(vinfo.width, vinfo.height, true, RGB555_FORMAT);
4efceb69 473 let info = NACodecInfo::new("msvideo1", NACodecTypeInfo::Video(out_info), None);
a480a0de 474 let mut stream = NAStream::new(StreamType::Video, stream_id, info, encinfo.tb_num, encinfo.tb_den, 0);
2ff56201
KS
475 stream.set_num(stream_id as usize);
476 let stream = stream.into_ref();
4efceb69 477 if self.pool.prealloc_video(out_info, 2).is_err() {
dab59886
KS
478 return Err(EncoderError::AllocError);
479 }
480
481 self.stream = Some(stream.clone());
482 self.quality = encinfo.quality;
c8db9313 483
dab59886
KS
484 Ok(stream)
485 },
486 }
487 }
488 fn encode(&mut self, frm: &NAFrame) -> EncoderResult<()> {
489 let buf = frm.get_buffer();
490 if let Some(ref vbuf) = buf.get_vbuf16() {
491 let mut cur_frm = self.pool.get_free().unwrap();
492 let mut dbuf = Vec::with_capacity(4);
493 let mut gw = GrowableMemoryWriter::new_write(&mut dbuf);
494 let mut bw = ByteWriter::new(&mut gw);
495 if self.frmcount == 0 {
496 self.lastfrm = None;
497 }
498 let is_intra = if let Some(ref prev_buf) = self.lastfrm {
499 Self::encode_inter(&mut bw, &mut cur_frm, vbuf, prev_buf, self.quality)?
500 } else {
501 Self::encode_intra(&mut bw, &mut cur_frm, vbuf, self.quality)?
502 };
503 self.lastfrm = Some(cur_frm);
504 self.pkt = Some(NAPacket::new(self.stream.clone().unwrap(), frm.ts, is_intra, dbuf));
505 self.frmcount += 1;
c9c7f648 506 if self.frmcount == self.key_int {
dab59886
KS
507 self.frmcount = 0;
508 }
509 Ok(())
510 } else {
511 Err(EncoderError::InvalidParameters)
512 }
513 }
514 fn get_packet(&mut self) -> EncoderResult<Option<NAPacket>> {
515 let mut npkt = None;
516 std::mem::swap(&mut self.pkt, &mut npkt);
517 Ok(npkt)
518 }
519 fn flush(&mut self) -> EncoderResult<()> {
520 self.frmcount = 0;
521 Ok(())
522 }
523}
524
c9c7f648
KS
525const ENCODER_OPTS: &[NAOptionDefinition] = &[
526 NAOptionDefinition {
527 name: KEYFRAME_OPTION, description: KEYFRAME_OPTION_DESC,
528 opt_type: NAOptionDefinitionType::Int(Some(0), Some(128)) },
529];
530
20766f15 531impl NAOptionHandler for MSVideo1Encoder {
c9c7f648
KS
532 fn get_supported_options(&self) -> &[NAOptionDefinition] { ENCODER_OPTS }
533 fn set_options(&mut self, options: &[NAOption]) {
534 for option in options.iter() {
535 for opt_def in ENCODER_OPTS.iter() {
536 if opt_def.check(option).is_ok() {
537 match option.name {
538 KEYFRAME_OPTION => {
539 if let NAValue::Int(intval) = option.value {
540 self.key_int = intval as u8;
541 }
542 },
543 _ => {},
544 };
545 }
546 }
547 }
548 }
549 fn query_option_value(&self, name: &str) -> Option<NAValue> {
550 match name {
551 KEYFRAME_OPTION => Some(NAValue::Int(i64::from(self.key_int))),
552 _ => None,
553 }
554 }
20766f15
KS
555}
556
dab59886
KS
557pub fn get_encoder() -> Box<dyn NAEncoder + Send> {
558 Box::new(MSVideo1Encoder::new())
559}
560
561#[cfg(test)]
562mod test {
563 use nihav_core::codecs::*;
564 use nihav_core::demuxers::*;
565 use nihav_core::muxers::*;
566 use crate::*;
567 use nihav_commonfmt::*;
568 use nihav_codec_support::test::enc_video::*;
569 use super::RGB555_FORMAT;
570
571 #[test]
572 fn test_ms_video1_encoder() {
573 let mut dmx_reg = RegisteredDemuxers::new();
574 generic_register_all_demuxers(&mut dmx_reg);
575 let mut dec_reg = RegisteredDecoders::new();
78fb6560
KS
576 generic_register_all_decoders(&mut dec_reg);
577 ms_register_all_decoders(&mut dec_reg);
dab59886
KS
578 let mut mux_reg = RegisteredMuxers::new();
579 generic_register_all_muxers(&mut mux_reg);
580 let mut enc_reg = RegisteredEncoders::new();
581 ms_register_all_encoders(&mut enc_reg);
582
886cde48 583 // sample: https://samples.mplayerhq.hu/V-codecs/UCOD/TalkingHead_352x288.avi
dab59886
KS
584 let dec_config = DecoderTestParams {
585 demuxer: "avi",
586 in_name: "assets/Misc/TalkingHead_352x288.avi",
587 stream_type: StreamType::Video,
c75dce78 588 limit: Some(3),
dab59886
KS
589 dmx_reg, dec_reg,
590 };
591 let enc_config = EncoderTestParams {
592 muxer: "avi",
593 enc_name: "msvideo1",
594 out_name: "msvideo1.avi",
595 mux_reg, enc_reg,
596 };
597 let dst_vinfo = NAVideoInfo {
598 width: 0,
599 height: 0,
600 format: RGB555_FORMAT,
601 flipped: true,
30940e74 602 bits: 16,
dab59886
KS
603 };
604 let enc_params = EncodeParameters {
605 format: NACodecTypeInfo::Video(dst_vinfo),
606 quality: 0,
607 bitrate: 0,
608 tb_num: 0,
609 tb_den: 0,
610 flags: 0,
611 };
b09ecc09
KS
612 //test_encoding_to_file(&dec_config, &enc_config, enc_params, &[]);
613 test_encoding_md5(&dec_config, &enc_config, enc_params, &[],
acabf163 614 &[0x6921e67e, 0x4f2ada95, 0x009ffc62, 0xd4bfab6a]);
dab59886
KS
615 }
616}