Delete nalu parser in mediaencoder

webrtc/api/android/jni/androidmediaencoder_jni.cc

 /*
  *  Copyright 2015 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 12 matching lines @@
 #include "webrtc/api/android/jni/classreferenceholder.h"
 #include "webrtc/api/android/jni/native_handle_impl.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/common_types.h"
 #include "webrtc/common_video/h264/h264_bitstream_parser.h"
+#include "webrtc/common_video/h264/h264_common.h"
 #include "webrtc/common_video/h264/profile_level_id.h"
 #include "webrtc/media/engine/internalencoderfactory.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/modules/video_coding/utility/quality_scaler.h"
 #include "webrtc/modules/video_coding/utility/vp8_header_parser.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/logcat_trace_context.h"
 #include "webrtc/video_encoder.h"
 
 using rtc::Bind;
 using rtc::Thread;
 using rtc::ThreadManager;
 
 using webrtc::CodecSpecificInfo;
 using webrtc::EncodedImage;
 using webrtc::VideoFrame;
 using webrtc::RTPFragmentationHeader;
 using webrtc::VideoCodec;
 using webrtc::VideoCodecType;
 using webrtc::kVideoCodecH264;
 using webrtc::kVideoCodecVP8;
 using webrtc::kVideoCodecVP9;
 using webrtc::QualityScaler;
 
 namespace webrtc_jni {
 
-// H.264 start code length.
-#define H264_SC_LENGTH 4
-// Maximum allowed NALUs in one output frame.
-#define MAX_NALUS_PERFRAME 32
 // Maximum supported HW video encoder fps.
 #define MAX_VIDEO_FPS 30
 // Maximum allowed fps value in SetRates() call.
 #define MAX_ALLOWED_VIDEO_FPS 60
 // Maximum allowed frames in encoder input queue.
 #define MAX_ENCODER_Q_SIZE 2
 // Maximum amount of dropped frames caused by full encoder queue - exceeding
 // this threshold means that encoder probably got stuck and need to be reset.
 #define ENCODER_STALL_FRAMEDROP_THRESHOLD 60
 
@@ skipping 99 matching lines @@
   int GetOutputBufferInfoIndex(JNIEnv* jni, jobject j_output_buffer_info);
   jobject GetOutputBufferInfoBuffer(JNIEnv* jni, jobject j_output_buffer_info);
   bool GetOutputBufferInfoIsKeyFrame(JNIEnv* jni, jobject j_output_buffer_info);
   jlong GetOutputBufferInfoPresentationTimestampUs(
       JNIEnv* jni, jobject j_output_buffer_info);
 
   // Deliver any outputs pending in the MediaCodec to our |callback_| and return
   // true on success.
   bool DeliverPendingOutputs(JNIEnv* jni);
 
-  // Search for H.264 start codes.
-  int32_t NextNaluPosition(uint8_t *buffer, size_t buffer_size);
-
   VideoEncoder::ScalingSettings GetScalingSettings() const override;
 
   // Displays encoder statistics.
   void LogStatistics(bool force_log);
 
   // Type of video codec.
   const cricket::VideoCodec codec_;
 
   // Valid all the time since RegisterEncodeCompleteCallback() Invoke()s to
   // |codec_thread_| synchronously.
@@ skipping 899 matching lines @@
           }
         }
       } else if (codec_type == kVideoCodecH264) {
         h264_bitstream_parser_.ParseBitstream(payload, payload_size);
         int qp;
         if (h264_bitstream_parser_.GetLastSliceQp(&qp)) {
           current_acc_qp_ += qp;
           image->qp_ = qp;
         }
         // For H.264 search for start codes.
-        int32_t scPositions[MAX_NALUS_PERFRAME + 1] = {};
-        int32_t scPositionsLength = 0;
-        int32_t scPosition = 0;
-        while (scPositionsLength < MAX_NALUS_PERFRAME) {
-          int32_t naluPosition = NextNaluPosition(
-              payload + scPosition, payload_size - scPosition);
-          if (naluPosition < 0) {
-            break;
-          }
-          scPosition += naluPosition;
-          scPositions[scPositionsLength++] = scPosition;
-          scPosition += H264_SC_LENGTH;
-        }
-        if (scPositionsLength == 0) {
+        const std::vector<webrtc::H264::NaluIndex> nalu_idxs =
+            webrtc::H264::FindNaluIndices(payload, payload_size);
+        if (nalu_idxs.empty()) {
           ALOGE << "Start code is not found!";
           ALOGE << "Data:" <<  image->_buffer[0] << " " << image->_buffer[1]
               << " " << image->_buffer[2] << " " << image->_buffer[3]
               << " " << image->_buffer[4] << " " << image->_buffer[5];
           ProcessHWErrorOnCodecThread(true /* reset_if_fallback_unavailable */);
           return false;
         }
-        scPositions[scPositionsLength] = payload_size;
-        header.VerifyAndAllocateFragmentationHeader(scPositionsLength);
-        for (size_t i = 0; i < scPositionsLength; i++) {
-          header.fragmentationOffset[i] = scPositions[i] + H264_SC_LENGTH;
-          header.fragmentationLength[i] =
-              scPositions[i + 1] - header.fragmentationOffset[i];
+        header.VerifyAndAllocateFragmentationHeader(nalu_idxs.size());
+        for (size_t i = 0; i < nalu_idxs.size(); i++) {
+          header.fragmentationOffset[i] = nalu_idxs[i].payload_start_offset;
+          header.fragmentationLength[i] = nalu_idxs[i].payload_size;
           header.fragmentationPlType[i] = 0;
           header.fragmentationTimeDiff[i] = 0;
         }
       }
 
       callback_result = callback_->OnEncodedImage(*image, &info, &header);
     }
 
     // Return output buffer back to the encoder.
     bool success = jni->CallBooleanMethod(*j_media_codec_video_encoder_,
@@ skipping 56 matching lines @@
     current_acc_qp_ = 0;
     current_encoding_time_ms_ = 0;
   }
 }
 
 webrtc::VideoEncoder::ScalingSettings
 MediaCodecVideoEncoder::GetScalingSettings() const {
   return VideoEncoder::ScalingSettings(scale_);
 }
 
-int32_t MediaCodecVideoEncoder::NextNaluPosition(
-    uint8_t *buffer, size_t buffer_size) {
-  if (buffer_size < H264_SC_LENGTH) {
-    return -1;
-  }
-  uint8_t *head = buffer;
-  // Set end buffer pointer to 4 bytes before actual buffer end so we can
-  // access head[1], head[2] and head[3] in a loop without buffer overrun.
-  uint8_t *end = buffer + buffer_size - H264_SC_LENGTH;
-
-  while (head < end) {
-    if (head[0]) {
-      head++;
-      continue;
-    }
-    if (head[1]) { // got 00xx
-      head += 2;
-      continue;
-    }
-    if (head[2]) { // got 0000xx
-      head += 3;
-      continue;
-    }
-    if (head[3] != 0x01) { // got 000000xx
-      head++; // xx != 1, continue searching.
-      continue;
-    }
-    return (int32_t)(head - buffer);
-  }
-  return -1;
-}
-
 const char* MediaCodecVideoEncoder::ImplementationName() const {
   return "MediaCodec";
 }
 
 MediaCodecVideoEncoderFactory::MediaCodecVideoEncoderFactory()
     : egl_context_(nullptr) {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   jclass j_encoder_class = FindClass(jni, "org/webrtc/MediaCodecVideoEncoder");
   supported_codecs_.clear();
@@ skipping 81 matching lines @@
   return supported_codecs_;
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni