Support alpha channel recording for VPX in MediaRecorder

media/muxers/webm_muxer_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.

[vignesh, 2017/03/08 17:26:14]

A test for video with alpha channel data here would be nice.

[emircan, 2017/03/08 23:53:58]

I added one. I actually worked on a test similar to OnEncodedVideoTwoFrames but
found out that instead of an extra 6 bytes of kSimpleBlockSize, we get 21. I
couldn't find the appropriate documentation for alpha describing these extra
bytes. Can you help with describing the correct checks here?

[vignesh, 2017/03/09 07:13:46]

Here's the element structure for a block with alpha data:
BlockGroup
  Block
  ReferenceBlock
  BlockAdditions
    BlockMore
      BlockAdditionalID
      BlockAdditional

(As opposed to a simpleblock without alpha which contains only one element,
SimpleBlock).

Considering all this, 21 seems a bit low. I'm calculating something near 40. Can
we please talk about this offline? I think we should iron this out and add the
test.

 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/muxers/webm_muxer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 92 matching lines @@
   const scoped_refptr<VideoFrame> video_frame =
       VideoFrame::CreateBlackFrame(frame_size);
   const std::string encoded_data("abcdefghijklmnopqrstuvwxyz");
 
   EXPECT_CALL(*this, WriteCallback(_))
       .Times(AtLeast(1))
       .WillRepeatedly(
           WithArgs<0>(Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
   EXPECT_TRUE(webm_muxer_.OnEncodedVideo(
       WebmMuxer::VideoParameters(video_frame),
-      base::WrapUnique(new std::string(encoded_data)), base::TimeTicks::Now(),
-      false /* keyframe */));
+      base::WrapUnique(new std::string(encoded_data)), nullptr,
+      base::TimeTicks::Now(), false /* keyframe */));
 
   // First time around WriteCallback() is pinged a number of times to write the
   // Matroska header, but at the end it dumps |encoded_data|.
   EXPECT_EQ(last_encoded_length_, encoded_data.size());
   EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
   EXPECT_GE(GetWebmMuxerPosition(), static_cast<int64_t>(last_encoded_length_));
   EXPECT_EQ(GetWebmSegmentMode(), mkvmuxer::Segment::kLive);
 
   const int64_t begin_of_second_block = accumulated_position_;
   EXPECT_CALL(*this, WriteCallback(_))
       .Times(AtLeast(1))
       .WillRepeatedly(
           WithArgs<0>(Invoke(this, &WebmMuxerTest::SaveEncodedDataLen)));
   EXPECT_TRUE(webm_muxer_.OnEncodedVideo(
-      video_frame, base::WrapUnique(new std::string(encoded_data)),
+      video_frame, base::WrapUnique(new std::string(encoded_data)), nullptr,
       base::TimeTicks::Now(), false /* keyframe */));
 
   // The second time around the callbacks should include a SimpleBlock header,
   // namely the track index, a timestamp and a flags byte, for a total of 6B.
   EXPECT_EQ(last_encoded_length_, encoded_data.size());
   EXPECT_EQ(GetWebmMuxerPosition(), accumulated_position_);
   const uint32_t kSimpleBlockSize = 6u;
   EXPECT_EQ(static_cast<int64_t>(begin_of_second_block + kSimpleBlockSize +
                                  encoded_data.size()),
             accumulated_position_);
 
   // Force an error in libwebm and expect OnEncodedVideo to fail.
   webm_muxer_.ForceOneLibWebmErrorForTesting();
-  EXPECT_FALSE(
-      webm_muxer_.OnEncodedVideo(WebmMuxer::VideoParameters(video_frame),
-                                 base::MakeUnique<std::string>(encoded_data),
-                                 base::TimeTicks::Now(), true /* keyframe */));
+  EXPECT_FALSE(webm_muxer_.OnEncodedVideo(
+      WebmMuxer::VideoParameters(video_frame),
+      base::MakeUnique<std::string>(encoded_data), nullptr,
+      base::TimeTicks::Now(), true /* keyframe */));
 }
 
 TEST_P(WebmMuxerTest, OnEncodedAudioTwoFrames) {
   if (GetParam().num_video_tracks > 0)
     return;
 
   const int sample_rate = 48000;
   const int bits_per_sample = 16;
   const int frames_per_buffer = 480;
   media::AudioParameters audio_params(
@@ skipping 50 matching lines @@
   if (GetParam().num_video_tracks == 0 || GetParam().num_audio_tracks == 0)
     return;
 
   // First send a video keyframe.
   const gfx::Size frame_size(160, 80);
   const scoped_refptr<VideoFrame> video_frame =
       VideoFrame::CreateBlackFrame(frame_size);
   const std::string encoded_video("thisisanencodedvideopacket");
   EXPECT_TRUE(webm_muxer_.OnEncodedVideo(
       WebmMuxer::VideoParameters(video_frame),
-      base::WrapUnique(new std::string(encoded_video)), base::TimeTicks::Now(),
-      true /* keyframe */));
+      base::WrapUnique(new std::string(encoded_video)), nullptr,
+      base::TimeTicks::Now(), true /* keyframe */));
   // A few encoded non key frames.
   const int kNumNonKeyFrames = 2;
   for (int i = 0; i < kNumNonKeyFrames; ++i) {
     EXPECT_TRUE(webm_muxer_.OnEncodedVideo(
         WebmMuxer::VideoParameters(video_frame),
-        base::WrapUnique(new std::string(encoded_video)),
+        base::WrapUnique(new std::string(encoded_video)), nullptr,
         base::TimeTicks::Now(), false /* keyframe */));
   }
 
   const int sample_rate = 48000;
   const int bits_per_sample = 16;
   const int frames_per_buffer = 480;
   media::AudioParameters audio_params(
       media::AudioParameters::Format::AUDIO_PCM_LOW_LATENCY,
       media::CHANNEL_LAYOUT_MONO, sample_rate, bits_per_sample,
       frames_per_buffer);
@@ skipping 28 matching lines @@
     {kCodecVP9, 0, 1},
     {kCodecVP9, 1, 1},
     {kCodecH264, 1, 0},
     {kCodecH264, 0, 1},
     {kCodecH264, 1, 1},
 };
 
 INSTANTIATE_TEST_CASE_P(, WebmMuxerTest, ValuesIn(kTestCases));
 
 }  // namespace media