zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace scoped_ptr with unique_ptr in webrtc/modules/video_coding/

Browse Source 
BUG=webrtc:5520

Review URL: https://codereview.webrtc.org/1721353002

Cr-Commit-Position: refs/heads/master@{#11814}
This commit is contained in:
kwiberg
2016-02-29 05:51:59 -08:00
committed by Commit bot
parent a4f31bd03a
commit 3f55dea259
36 changed files with 145 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
webrtc/modules/video_coding/codecs/h264/h264_decoder_impl.h
View File

@ -12,13 +12,14 @@
#ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_H264_H264_DECODER_IMPL_H_
#define WEBRTC_MODULES_VIDEO_CODING_CODECS_H264_H264_DECODER_IMPL_H_
#include <memory>
#include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
extern "C" {
#include "third_party/ffmpeg/libavcodec/avcodec.h"
} // extern "C"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/common_video/include/i420_buffer_pool.h"
namespace webrtc {
@ -67,8 +68,8 @@ class H264DecoderImpl : public H264Decoder {
void ReportError();
I420BufferPool pool_;
rtc::scoped_ptr<AVCodecContext, AVCodecContextDeleter> av_context_;
rtc::scoped_ptr<AVFrame, AVFrameDeleter> av_frame_;
std::unique_ptr<AVCodecContext, AVCodecContextDeleter> av_context_;
std::unique_ptr<AVFrame, AVFrameDeleter> av_frame_;
DecodedImageCallback* decoded_image_callback_;

2
webrtc/modules/video_coding/codecs/h264/h264_encoder_impl.cc
View File

@ -81,7 +81,7 @@ static FrameType EVideoFrameType_to_FrameType(EVideoFrameType type) {
// is updated to point to each fragment, with offsets and lengths set as to
// exclude the start codes.
static void RtpFragmentize(EncodedImage* encoded_image,
rtc::scoped_ptr<uint8_t[]>* encoded_image_buffer,
std::unique_ptr<uint8_t[]>* encoded_image_buffer,
const VideoFrame& frame,
SFrameBSInfo* info,
RTPFragmentationHeader* frag_header) {

4
webrtc/modules/video_coding/codecs/h264/h264_encoder_impl.h
View File

@ -14,9 +14,9 @@
#include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
#include <memory>
#include <vector>
#include "webrtc/base/scoped_ptr.h"
class ISVCEncoder;
@ -65,7 +65,7 @@ class H264EncoderImpl : public H264Encoder {
VideoCodec codec_settings_;
EncodedImage encoded_image_;
rtc::scoped_ptr<uint8_t[]> encoded_image_buffer_;
std::unique_ptr<uint8_t[]> encoded_image_buffer_;
EncodedImageCallback* encoded_image_callback_;
bool has_reported_init_;

6
webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_decoder.cc
View File

@ -13,6 +13,8 @@
#if defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)
#include <memory>
#include "libyuv/convert.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
@ -85,7 +87,7 @@ void VTDecompressionOutputCallback(void* decoder,
CVImageBufferRef image_buffer,
CMTime timestamp,
CMTime duration) {
rtc::scoped_ptr<FrameDecodeParams> decode_params(
std::unique_ptr<FrameDecodeParams> decode_params(
reinterpret_cast<FrameDecodeParams*>(params));
if (status != noErr) {
LOG(LS_ERROR) << "Failed to decode frame. Status: " << status;
@ -142,7 +144,7 @@ int H264VideoToolboxDecoder::Decode(
}
VTDecodeFrameFlags decode_flags =
kVTDecodeFrame_EnableAsynchronousDecompression;
rtc::scoped_ptr<internal::FrameDecodeParams> frame_decode_params;
std::unique_ptr<internal::FrameDecodeParams> frame_decode_params;
frame_decode_params.reset(
new internal::FrameDecodeParams(callback_, input_image._timeStamp));
OSStatus status = VTDecompressionSessionDecodeFrame(

23
webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_encoder.cc
View File

@ -13,13 +13,13 @@
#if defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)
#include <memory>
#include <string>
#include <vector>
#include "libyuv/convert_from.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.h"
#include "webrtc/system_wrappers/include/clock.h"
@ -43,7 +43,7 @@ std::string CFStringToString(const CFStringRef cf_string) {
CFStringGetMaximumSizeForEncoding(CFStringGetLength(cf_string),
kCFStringEncodingUTF8) +
1;
rtc::scoped_ptr<char[]> buffer(new char[buffer_size]);
std::unique_ptr<char[]> buffer(new char[buffer_size]);
if (CFStringGetCString(cf_string, buffer.get(), buffer_size,
kCFStringEncodingUTF8)) {
// Copy over the characters.
@ -177,7 +177,7 @@ void VTCompressionOutputCallback(void* encoder,
OSStatus status,
VTEncodeInfoFlags info_flags,
CMSampleBufferRef sample_buffer) {
rtc::scoped_ptr<FrameEncodeParams> encode_params(
std::unique_ptr<FrameEncodeParams> encode_params(
reinterpret_cast<FrameEncodeParams*>(params));
encode_params->encoder->OnEncodedFrame(
status, info_flags, sample_buffer, encode_params->codec_specific_info,
@ -277,7 +277,7 @@ int H264VideoToolboxEncoder::Encode(
CFTypeRef values[] = {kCFBooleanTrue};
frame_properties = internal::CreateCFDictionary(keys, values, 1);
}
rtc::scoped_ptr<internal::FrameEncodeParams> encode_params;
std::unique_ptr<internal::FrameEncodeParams> encode_params;
encode_params.reset(new internal::FrameEncodeParams(
this, codec_specific_info, width_, height_, input_image.render_time_ms(),
input_image.timestamp()));
@ -462,11 +462,16 @@ void H264VideoToolboxEncoder::OnEncodedFrame(
// Convert the sample buffer into a buffer suitable for RTP packetization.
// TODO(tkchin): Allocate buffers through a pool.
rtc::scoped_ptr<rtc::Buffer> buffer(new rtc::Buffer());
rtc::scoped_ptr<webrtc::RTPFragmentationHeader> header;
if (!H264CMSampleBufferToAnnexBBuffer(sample_buffer, is_keyframe,
buffer.get(), header.accept())) {
return;
std::unique_ptr<rtc::Buffer> buffer(new rtc::Buffer());
std::unique_ptr<webrtc::RTPFragmentationHeader> header;
{
webrtc::RTPFragmentationHeader* header_raw;
bool result = H264CMSampleBufferToAnnexBBuffer(sample_buffer, is_keyframe,
buffer.get(), &header_raw);
header.reset(header_raw);
if (!result) {
return;
}
}
webrtc::EncodedImage frame(buffer->data(), buffer->size(), buffer->size());
frame._encodedWidth = width;

3
webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.cc
View File

@ -14,6 +14,7 @@
#if defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED)
#include <CoreFoundation/CoreFoundation.h>
#include <memory>
#include <vector>
#include "webrtc/base/checks.h"
@ -139,7 +140,7 @@ bool H264CMSampleBufferToAnnexBBuffer(
}
RTC_DCHECK_EQ(bytes_remaining, (size_t)0);
rtc::scoped_ptr<webrtc::RTPFragmentationHeader> header;
std::unique_ptr<webrtc::RTPFragmentationHeader> header;
header.reset(new webrtc::RTPFragmentationHeader());
header->VerifyAndAllocateFragmentationHeader(frag_offsets.size());
RTC_DCHECK_EQ(frag_lengths.size(), frag_offsets.size());

10
webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu_unittest.cc
View File

@ -9,6 +9,8 @@
*
*/
#include <memory>
#include "testing/gtest/include/gtest/gtest.h"
#include "webrtc/base/arraysize.h"
@ -90,7 +92,7 @@ TEST(AnnexBBufferReaderTest, TestReadMultipleNalus) {
TEST(AvccBufferWriterTest, TestEmptyOutputBuffer) {
const uint8_t expected_buffer[] = {0x00};
const size_t buffer_size = 1;
rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
memset(buffer.get(), 0, buffer_size);
AvccBufferWriter writer(buffer.get(), 0);
EXPECT_EQ(0u, writer.BytesRemaining());
@ -104,7 +106,7 @@ TEST(AvccBufferWriterTest, TestWriteSingleNalu) {
0x00, 0x00, 0x00, 0x03, 0xAA, 0xBB, 0xCC,
};
const size_t buffer_size = arraysize(NALU_TEST_DATA_0) + 4;
rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
AvccBufferWriter writer(buffer.get(), buffer_size);
EXPECT_EQ(buffer_size, writer.BytesRemaining());
EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0)));
@ -123,7 +125,7 @@ TEST(AvccBufferWriterTest, TestWriteMultipleNalus) {
// clang-format on
const size_t buffer_size =
arraysize(NALU_TEST_DATA_0) + arraysize(NALU_TEST_DATA_1) + 8;
rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
AvccBufferWriter writer(buffer.get(), buffer_size);
EXPECT_EQ(buffer_size, writer.BytesRemaining());
EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0)));
@ -138,7 +140,7 @@ TEST(AvccBufferWriterTest, TestWriteMultipleNalus) {
TEST(AvccBufferWriterTest, TestOverflow) {
const uint8_t expected_buffer[] = {0x00, 0x00, 0x00};
const size_t buffer_size = arraysize(NALU_TEST_DATA_0);
rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
memset(buffer.get(), 0, buffer_size);
AvccBufferWriter writer(buffer.get(), buffer_size);
EXPECT_EQ(buffer_size, writer.BytesRemaining());