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