H.264 video codec support using OpenH264/FFmpeg

webrtc/modules/video_coding/codecs/test/videoprocessor.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
 #include "webrtc/modules/video_coding/codecs/test/videoprocessor.h"
 
 #include <assert.h>
 #include <string.h>
 
 #include <limits>
 #include <vector>
 
+#include "webrtc/base/checks.h"
+#include "webrtc/modules/video_coding/codecs/h264/h264_encoder_impl.h"
 #include "webrtc/system_wrappers/interface/cpu_info.h"
 
 namespace webrtc {
 namespace test {
 
 TestConfig::TestConfig()
     : name(""),
       description(""),
       test_number(0),
       input_filename(""),
@@ skipping 180 matching lines @@
       fprintf(stderr, "Failed to encode frame %d, return code: %d\n",
               frame_number, encode_result);
     }
     stat.encode_return_code = encode_result;
     return true;
   } else {
     return false;  // we've reached the last frame
   }
 }
 
-void VideoProcessorImpl::FrameEncoded(const EncodedImage& encoded_image) {
+void VideoProcessorImpl::FrameEncoded(
+    const EncodedImage& encoded_image,
+    const webrtc::RTPFragmentationHeader* fragmentation) {
   // Timestamp is frame number, so this gives us #dropped frames.
   int num_dropped_from_prev_encode =  encoded_image._timeStamp -
       prev_time_stamp_ - 1;
   num_dropped_frames_ +=  num_dropped_from_prev_encode;
   prev_time_stamp_ =  encoded_image._timeStamp;
   if (num_dropped_from_prev_encode > 0) {
     // For dropped frames, we write out the last decoded frame to avoid getting
     // out of sync for the computation of PSNR and SSIM.
     for (int i = 0; i < num_dropped_from_prev_encode; i++) {
       frame_writer_->WriteFrame(last_successful_frame_buffer_);
@@ skipping 27 matching lines @@
           exclude_this_frame = true;
         }
         break;
       case kExcludeAllKeyFrames:
         exclude_this_frame = true;
         break;
       default:
         assert(false);
     }
   }
-  rtc::scoped_ptr<uint8_t[]> copied_buffer(new uint8_t[encoded_image._length]);
-  memcpy(copied_buffer.get(), encoded_image._buffer, encoded_image._length);
+
+  // The image to feed to the decoder.
   EncodedImage copied_image;
   memcpy(&copied_image, &encoded_image, sizeof(copied_image));
-  copied_image._size = copied_image._length;
-  copied_image._buffer = copied_buffer.get();
+  rtc::scoped_ptr<uint8_t[]> copied_buffer;
+  bool copied_image_done = false;
+#if defined(WEBRTC_OPENH264)

[stefan-webrtc, 2015/09/28 11:19:02]

Do you need this ifdef if you have the if statement below?

[hbos, 2015/09/30 15:35:19]

(Removed, no longer needed due to including start codes.)

+  if (config_.codec_settings->codecType == kVideoCodecH264 &&
+      H264Encoder::IsSupportedOpenH264()) {
+    // H264 with OpenH264 encoder (H264EncoderImpl): Defragmentization necessary
+    // for decoder to be able to decode the EncodedImage.
+    size_t copied_buffer_size =
+        H264EncoderImpl::RTPDefragmentizeBufferLengthWithNAL(encoded_image,

[stefan-webrtc, 2015/09/28 11:19:02]

Code should probably live in this test?

[hbos, 2015/09/30 15:35:19]

(Removed, no longer needed due to including start codes.)

+                                                             fragmentation);
+    copied_buffer.reset(new uint8_t[copied_buffer_size]);
+    H264EncoderImpl::RTPDefragmentize(
+        encoded_image, fragmentation, copied_buffer.get(), copied_buffer_size);
+    copied_image._size = copied_buffer_size;
+    copied_image._length = copied_buffer_size;
+    copied_image._buffer = copied_buffer.get();
+    copied_image_done = true;
+  }
+#endif
+  if (!copied_image_done) {
+    // Make a raw copy of the |encoded_image| buffer.
+    copied_buffer.reset(new uint8_t[encoded_image._length]);
+    memcpy(copied_buffer.get(), encoded_image._buffer, encoded_image._length);
+    copied_image._size = copied_image._length;
+    copied_image._buffer = copied_buffer.get();
+  }
+
   if (!exclude_this_frame) {
     stat.packets_dropped =
           packet_manipulator_->ManipulatePackets(&copied_image);
   }
 
   // Keep track of if frames are lost due to packet loss so we can tell
   // this to the encoder (this is handled by the RTP logic in the full stack)
   decode_start_ = TickTime::Now();
   // TODO(kjellander): Pass fragmentation header to the decoder when
   // CL 172001 has been submitted and PacketManipulator supports this.
@@ skipping 111 matching lines @@
       return "Unknown";
   }
 }
 
 // Callbacks
 int32_t
 VideoProcessorImpl::VideoProcessorEncodeCompleteCallback::Encoded(
     const EncodedImage& encoded_image,
     const webrtc::CodecSpecificInfo* codec_specific_info,
     const webrtc::RTPFragmentationHeader* fragmentation) {
-  video_processor_->FrameEncoded(encoded_image);  // Forward to parent class.
+  // Forward to parent class.
+  video_processor_->FrameEncoded(encoded_image, fragmentation);
   return 0;
 }
 int32_t VideoProcessorImpl::VideoProcessorDecodeCompleteCallback::Decoded(
     VideoFrame& image) {
-  video_processor_->FrameDecoded(image);  // forward to parent class
+  // Forward to parent class.
+  video_processor_->FrameDecoded(image);
   return 0;
 }
 
 }  // namespace test
 }  // namespace webrtc