H.264 packetization mode 0 (try 3)

webrtc/media/base/codec.cc

 /*
  *  Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 64 matching lines @@
          found != params_.end(); ++found) {
       if (*found == *iter) {
         return true;
       }
     }
   }
   return false;
 }
 
 Codec::Codec(int id, const std::string& name, int clockrate)
-    : id(id), name(name), clockrate(clockrate) {}
+    : id(id), name(name), clockrate(clockrate) {
+  SetDefaultParameters();
+}
 
 Codec::Codec() : id(0), clockrate(0) {}
 
 Codec::Codec(const Codec& c) = default;
 Codec::Codec(Codec&& c) = default;
 Codec::~Codec() = default;
 Codec& Codec::operator=(const Codec& c) = default;
 Codec& Codec::operator=(Codec&& c) = default;
 
 bool Codec::operator==(const Codec& c) const {
   return this->id == c.id &&  // id is reserved in objective-c
          name == c.name && clockrate == c.clockrate && params == c.params &&
          feedback_params == c.feedback_params;
 }
 
 bool Codec::Matches(const Codec& codec) const {
   // Match the codec id/name based on the typical static/dynamic name rules.
   // Matching is case-insensitive.
   const int kMaxStaticPayloadId = 95;
   return (id <= kMaxStaticPayloadId || codec.id <= kMaxStaticPayloadId)
              ? (id == codec.id)
              : (_stricmp(name.c_str(), codec.name.c_str()) == 0);
 }
 
+void Codec::SetDefaultParameters() {
+  if (_stricmp(kH264CodecName, name.c_str()) == 0) {
+    // TODO(magjed): Move setting these parameters into webrtc::H264Encoder
+    // instead.
+    SetParam(kH264FmtpProfileLevelId, kH264ProfileLevelConstrainedBaseline);
+    SetParam(kH264FmtpLevelAsymmetryAllowed, "1");
+    SetParam(kH264FmtpPacketizationMode, "1");
+  }

[sprang_webrtc, 2016/12/01 16:58:56]

Why was this moved here?

[hta-webrtc, 2016/12/01 18:26:27]

Because it was the simplest way to set a default value for packetization mode
that would apply everywhere the cricket::Codec object was created by its
constructor (which is most places).

It did not cover all cases, unfortunately (see the comment next to the value
assignment for the packetization mode enum).

[magjed_webrtc, 2016/12/02 12:34:25]

This is a step in the wrong direction. Why can't you track down all places that
needs this and add it there? I couldn't find the comment you mention.

[hta-webrtc, 2016/12/02 12:48:47]

Why is it a step in the wrong direction?

Previous to this CL, all cases of creating an H.264 codec were implicitly
packetization mode 1.
Subsequent to this CL, we can have two states:

- All codecs with no params are implicitly packetization mode 1. This means that
we have a different meaning of "no parameter" than SDP assigns to it, and would
have to handle that in SDP generation (emitting a parameter when there's none in
the codec struct, setting an explicit parameter with mode 0 when there's none in
the SDP)

- Unless the user specifically removes it, all H.264 codecs have a
"packetization-mode=1" parameter. This is the same as SDP, and SHOULD produce
the same effect as alternative 1 (IF all instances that create a codec use the
constructor).
That's the approach implemented by this CL.

The comment refers to
https://codereview.webrtc.org/2528343002/patch/430001/440005 - it seems that
there's *something* that creates H.264 codecs without calling the constructor.
It's likely in Java, and it's likely only running on Android.

+}
+
 bool Codec::GetParam(const std::string& name, std::string* out) const {
   CodecParameterMap::const_iterator iter = params.find(name);
   if (iter == params.end())
     return false;
   *out = iter->second;
   return true;
 }
 
 bool Codec::GetParam(const std::string& name, int* out) const {
   CodecParameterMap::const_iterator iter = params.find(name);
@@ skipping 213 matching lines @@
     if (CodecNamesEq(codec.name.c_str(), kH264CodecName) &&
         !IsSameH264Profile(codec.params, supported_codec.params)) {
       continue;
     }
     return &supported_codec;
   }
   return nullptr;
 }
 
 }  // namespace cricket