Add QP for FFmpeg H264 decoder.

webrtc/modules/video_coding/codecs/h264/h264_decoder_impl.cc

 /*
  *  Copyright (c) 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 339 matching lines @@
       av_buffer_get_opaque(av_frame_->buf[0]));
   RTC_DCHECK(video_frame);
   RTC_CHECK_EQ(av_frame_->data[kYPlaneIndex],
                video_frame->video_frame_buffer()->DataY());
   RTC_CHECK_EQ(av_frame_->data[kUPlaneIndex],
                video_frame->video_frame_buffer()->DataU());
   RTC_CHECK_EQ(av_frame_->data[kVPlaneIndex],
                video_frame->video_frame_buffer()->DataV());
   video_frame->set_timestamp(input_image._timeStamp);
 
-  int32_t ret;
+  rtc::Optional<uint8_t> qp;
+  // TODO(sakal): Maybe it is possible to get QP directly from FFmpeg.
+  h264_bitstream_parser_.ParseBitstream(input_image._buffer,
+                                        input_image._length);
+  int qp_int;
+  if (h264_bitstream_parser_.GetLastSliceQp(&qp_int)) {
+    qp = rtc::Optional<uint8_t>(qp_int);

[sprang_webrtc, 2017/02/28 09:01:52]

nit: qp.emplace(qp_int);

[sakal, 2017/03/01 13:26:48]

Done.

+  }
 
   // The decoded image may be larger than what is supposed to be visible, see
   // |AVGetBuffer2|'s use of |avcodec_align_dimensions|. This crops the image
   // without copying the underlying buffer.
   rtc::scoped_refptr<VideoFrameBuffer> buf = video_frame->video_frame_buffer();
   if (av_frame_->width != buf->width() || av_frame_->height != buf->height()) {
     rtc::scoped_refptr<VideoFrameBuffer> cropped_buf(
         new rtc::RefCountedObject<WrappedI420Buffer>(
             av_frame_->width, av_frame_->height,
             buf->DataY(), buf->StrideY(),
             buf->DataU(), buf->StrideU(),
             buf->DataV(), buf->StrideV(),
             rtc::KeepRefUntilDone(buf)));
     VideoFrame cropped_frame(
         cropped_buf, video_frame->timestamp(), video_frame->render_time_ms(),
         video_frame->rotation());
     // TODO(nisse): Timestamp and rotation are all zero here. Change decoder
     // interface to pass a VideoFrameBuffer instead of a VideoFrame?
-    ret = decoded_image_callback_->Decoded(cropped_frame);
+    decoded_image_callback_->Decoded(cropped_frame, rtc::Optional<int32_t>(),
+                                     qp);
   } else {
     // Return decoded frame.
-    ret = decoded_image_callback_->Decoded(*video_frame);
+    decoded_image_callback_->Decoded(*video_frame, rtc::Optional<int32_t>(),
+                                     qp);
   }
   // Stop referencing it, possibly freeing |video_frame|.
   av_frame_unref(av_frame_.get());
   video_frame = nullptr;
 
-  if (ret) {
-    LOG(LS_WARNING) << "DecodedImageCallback::Decoded returned " << ret;
-    return ret;
-  }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 const char* H264DecoderImpl::ImplementationName() const {
   return "FFmpeg";
 }
 
 bool H264DecoderImpl::IsInitialized() const {
   return av_context_ != nullptr;
 }
@@ skipping 10 matching lines @@
 void H264DecoderImpl::ReportError() {
   if (has_reported_error_)
     return;
   RTC_HISTOGRAM_ENUMERATION("WebRTC.Video.H264DecoderImpl.Event",
                             kH264DecoderEventError,
                             kH264DecoderEventMax);
   has_reported_error_ = true;
 }
 
 }  // namespace webrtc