Implemented Multiple video track recoding.

media/capture/webm_muxer.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MEDIA_FILTERS_LIBWEBM_MUXER_H_
 #define MEDIA_FILTERS_LIBWEBM_MUXER_H_
 
 #include <set>
 
 #include "base/callback.h"
@@ skipping 26 matching lines @@
 class MEDIA_EXPORT WebmMuxer : public NON_EXPORTED_BASE(mkvmuxer::IMkvWriter) {
  public:
   // Callback to be called when WebmMuxer is ready to write a chunk of data,
   // either any file header or a SingleBlock.
   using WriteDataCB = base::Callback<void(base::StringPiece)>;
 
   explicit WebmMuxer(const WriteDataCB& write_data_callback);
   ~WebmMuxer() override;
 
   // Adds a |video_frame| with |encoded_data.data()| to WebM Segment.
-  void OnEncodedVideo(const scoped_refptr<VideoFrame>& video_frame,
+  void OnEncodedVideo(int track_index,
+                      const scoped_refptr<VideoFrame>& video_frame,
                       scoped_ptr<std::string> encoded_data,
                       base::TimeTicks timestamp,
                       bool is_key_frame);
 
+  int GetNextVideoTrackIndex();

[mcasas, 2015/10/06 17:53:13]

Should be const.

Actually it shouldn't exist at all. Extending to multiple track recording
is a tad more complex than this, since we don't want to surface
implementation details to clients. What I'd suggest is to add a
method to WebmMuxer that generates OnEncodedVideoCallbacks
with the parameter |track_index| bound in. The callers will then
piggyback the remaining four parameters. (See [1] for a refresher).

On a parallel note, adding a method for observing class X member is,
well, a last option :) -- Instead, you would add an accessor to XTest 
and use it in the individual test cases, that are public subclasses of 
XTest. And, if there' no other option or would be too messy, use the
suffix ForTesting so it'd be removed from release, non-test builds.

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/base/callback.h&l=120

[msu.koo, 2015/10/07 04:52:19]

Cool way! Thank you for your advice. reflected.

+
  private:
   friend class WebmMuxerTest;
+  struct VideoMuxerArg {
+    VideoMuxerArg(
+        const base::TimeTicks& first_frame_timestamp, uint64 track_number)
+        : first_frame_timestamp(first_frame_timestamp),
+          track_number(track_number) {}
+
+    base::TimeTicks first_frame_timestamp;
+    uint64 track_number;
+  };
 
   // Creates and adds a new video track. Called upon receiving the first
   // frame of a given Track, adds |frame_size| and |frame_rate| to the Segment
   // info, although individual frames passed to OnEncodedVideo() can have any
   // frame size.
-  void AddVideoTrack(const gfx::Size& frame_size, double frame_rate);
+  uint64 AddVideoTrack(const gfx::Size& frame_size, double frame_rate);
 
   // IMkvWriter interface.
   mkvmuxer::int32 Write(const void* buf, mkvmuxer::uint32 len) override;
   mkvmuxer::int64 Position() const override;
   mkvmuxer::int32 Position(mkvmuxer::int64 position) override;
   bool Seekable() const override;
   void ElementStartNotify(mkvmuxer::uint64 element_id,
                           mkvmuxer::int64 position) override;
 
   // Used to DCHECK that we are called on the correct thread.
   base::ThreadChecker thread_checker_;
 
-  // A caller-side identifier to interact with |segment_|, initialised upon
-  // first frame arrival by AddVideoTrack().
-  uint64_t track_index_;
-
-  // Origin of times for frame timestamps.
-  base::TimeTicks first_frame_timestamp_;
+  // Arguments for each tracks to mkvmuxer.
+  std::vector<VideoMuxerArg> video_muxer_args_;

[mcasas, 2015/10/06 17:53:13]

What about a std::map indexed by track indexes?

[msu.koo, 2015/10/07 04:52:19]

I considered to use Map for this, but using vector can minimize the overhead
then using map here because |track_index| will be assigned sequentially from
muxer([1]).
So I would leave as it is.

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/libweb...

 
   // Callback to dump written data as being called by libwebm.
   const WriteDataCB write_data_callback_;
 
   // Rolling counter of the position in bytes of the written goo.
   base::CheckedNumeric<mkvmuxer::int64> position_;
 
   // The MkvMuxer active element.
   mkvmuxer::Segment segment_;
 
   DISALLOW_COPY_AND_ASSIGN(WebmMuxer);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_LIBWEBM_MUXER_H_