360 lines
14 KiB
C++
360 lines
14 KiB
C++
/*
|
|
* Copyright (c) 2016 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/common_video/h264/sps_vui_rewriter.h"
|
|
|
|
#include <algorithm>
|
|
#include <memory>
|
|
|
|
#include "webrtc/base/bitbuffer.h"
|
|
#include "webrtc/base/checks.h"
|
|
#include "webrtc/base/logging.h"
|
|
|
|
#include "webrtc/common_video/h264/h264_common.h"
|
|
#include "webrtc/common_video/h264/sps_parser.h"
|
|
|
|
namespace webrtc {
|
|
|
|
// The maximum expected growth from adding a VUI to the SPS. It's actually
|
|
// closer to 24 or so, but better safe than sorry.
|
|
const size_t kMaxVuiSpsIncrease = 64;
|
|
|
|
#define RETURN_FALSE_ON_FAIL(x) \
|
|
if (!(x)) { \
|
|
LOG_F(LS_ERROR) << " (line:" << __LINE__ << ") FAILED: " #x; \
|
|
return false; \
|
|
}
|
|
|
|
#define COPY_UINT8(src, dest, tmp) \
|
|
do { \
|
|
RETURN_FALSE_ON_FAIL((src)->ReadUInt8(&tmp)); \
|
|
if (dest) \
|
|
RETURN_FALSE_ON_FAIL((dest)->WriteUInt8(tmp)); \
|
|
} while (0)
|
|
|
|
#define COPY_EXP_GOLOMB(src, dest, tmp) \
|
|
do { \
|
|
RETURN_FALSE_ON_FAIL((src)->ReadExponentialGolomb(&tmp)); \
|
|
if (dest) \
|
|
RETURN_FALSE_ON_FAIL((dest)->WriteExponentialGolomb(tmp)); \
|
|
} while (0)
|
|
|
|
#define COPY_BITS(src, dest, tmp, bits) \
|
|
do { \
|
|
RETURN_FALSE_ON_FAIL((src)->ReadBits(&tmp, bits)); \
|
|
if (dest) \
|
|
RETURN_FALSE_ON_FAIL((dest)->WriteBits(tmp, bits)); \
|
|
} while (0)
|
|
|
|
typedef const SpsParser::SpsState& Sps;
|
|
|
|
bool CopyAndRewriteVui(Sps sps,
|
|
rtc::BitBuffer* source,
|
|
rtc::BitBufferWriter* destination,
|
|
SpsVuiRewriter::ParseResult* out_vui_rewritten);
|
|
bool CopyHrdParameters(rtc::BitBuffer* source,
|
|
rtc::BitBufferWriter* destination);
|
|
bool AddBitstreamRestriction(rtc::BitBufferWriter* destination,
|
|
uint32_t max_num_ref_frames);
|
|
bool CopyRemainingBits(rtc::BitBuffer* source,
|
|
rtc::BitBufferWriter* destination);
|
|
|
|
SpsVuiRewriter::ParseResult SpsVuiRewriter::ParseAndRewriteSps(
|
|
const uint8_t* buffer,
|
|
size_t length,
|
|
rtc::Optional<SpsParser::SpsState>* sps,
|
|
rtc::Buffer* destination) {
|
|
rtc::BitBuffer source_buffer(buffer, length);
|
|
rtc::Optional<SpsParser::SpsState> sps_state =
|
|
SpsParser::ParseSpsUpToVui(&source_buffer);
|
|
if (!sps_state)
|
|
return ParseResult::kFailure;
|
|
|
|
*sps = sps_state;
|
|
|
|
if (sps_state->pic_order_cnt_type >= 2) {
|
|
// No need to rewrite VUI in this case.
|
|
return ParseResult::kPocOk;
|
|
}
|
|
|
|
// We're going to completely muck up alignment, so we need a BitBuffer to
|
|
// write with.
|
|
rtc::Buffer out_buffer(length + kMaxVuiSpsIncrease);
|
|
rtc::BitBufferWriter sps_writer(out_buffer.data(), out_buffer.size());
|
|
|
|
// Check how far the SpsParser has read, and copy that data in bulk.
|
|
size_t byte_offset;
|
|
size_t bit_offset;
|
|
source_buffer.GetCurrentOffset(&byte_offset, &bit_offset);
|
|
memcpy(out_buffer.data(), buffer,
|
|
byte_offset + (bit_offset > 0 ? 1 : 0)); // OK to copy the last bits.
|
|
|
|
// SpsParser will have read the vui_params_present flag, which we want to
|
|
// modify, so back off a bit;
|
|
if (bit_offset == 0) {
|
|
--byte_offset;
|
|
bit_offset = 7;
|
|
} else {
|
|
--bit_offset;
|
|
}
|
|
sps_writer.Seek(byte_offset, bit_offset);
|
|
|
|
ParseResult vui_updated;
|
|
if (!CopyAndRewriteVui(*sps_state, &source_buffer, &sps_writer,
|
|
&vui_updated)) {
|
|
LOG(LS_ERROR) << "Failed to parse/copy SPS VUI.";
|
|
return ParseResult::kFailure;
|
|
}
|
|
|
|
if (vui_updated == ParseResult::kVuiOk) {
|
|
// No update necessary after all, just return.
|
|
return vui_updated;
|
|
}
|
|
|
|
if (!CopyRemainingBits(&source_buffer, &sps_writer)) {
|
|
LOG(LS_ERROR) << "Failed to parse/copy SPS VUI.";
|
|
return ParseResult::kFailure;
|
|
}
|
|
|
|
// Pad up to next byte with zero bits.
|
|
sps_writer.GetCurrentOffset(&byte_offset, &bit_offset);
|
|
if (bit_offset > 0) {
|
|
sps_writer.WriteBits(0, 8 - bit_offset);
|
|
++byte_offset;
|
|
bit_offset = 0;
|
|
}
|
|
|
|
RTC_DCHECK(byte_offset <= length + kMaxVuiSpsIncrease);
|
|
RTC_CHECK(destination != nullptr);
|
|
|
|
out_buffer.SetSize(byte_offset);
|
|
|
|
// Write updates SPS to destination with added RBSP
|
|
H264::WriteRbsp(out_buffer.data(), out_buffer.size(), destination);
|
|
|
|
return ParseResult::kVuiRewritten;
|
|
}
|
|
|
|
bool CopyAndRewriteVui(Sps sps,
|
|
rtc::BitBuffer* source,
|
|
rtc::BitBufferWriter* destination,
|
|
SpsVuiRewriter::ParseResult* out_vui_rewritten) {
|
|
uint32_t golomb_tmp;
|
|
uint32_t bits_tmp;
|
|
|
|
//
|
|
// vui_parameters_present_flag: u(1)
|
|
//
|
|
RETURN_FALSE_ON_FAIL(destination->WriteBits(1, 1));
|
|
|
|
// ********* IMPORTANT! **********
|
|
// Now we're at the VUI, so we want to (1) add it if it isn't present, and
|
|
// (2) rewrite frame reordering values so no reordering is allowed.
|
|
if (!sps.vui_params_present) {
|
|
// Write a simple VUI with the parameters we want and 0 for all other flags.
|
|
// There are 8 flags to be off before the bitstream restriction flag.
|
|
RETURN_FALSE_ON_FAIL(destination->WriteBits(0, 8));
|
|
// bitstream_restriction_flag: u(1)
|
|
RETURN_FALSE_ON_FAIL(destination->WriteBits(1, 1));
|
|
RETURN_FALSE_ON_FAIL(
|
|
AddBitstreamRestriction(destination, sps.max_num_ref_frames));
|
|
} else {
|
|
// Parse out the full VUI.
|
|
// aspect_ratio_info_present_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
if (bits_tmp == 1) {
|
|
// aspect_ratio_idc: u(8)
|
|
COPY_BITS(source, destination, bits_tmp, 8);
|
|
if (bits_tmp == 255u) { // Extended_SAR
|
|
// sar_width/sar_height: u(16) each.
|
|
COPY_BITS(source, destination, bits_tmp, 32);
|
|
}
|
|
}
|
|
// overscan_info_present_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
if (bits_tmp == 1) {
|
|
// overscan_appropriate_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
}
|
|
// video_signal_type_present_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
if (bits_tmp == 1) {
|
|
// video_format + video_full_range_flag: u(3) + u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 4);
|
|
// colour_description_present_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
if (bits_tmp == 1) {
|
|
// colour_primaries, transfer_characteristics, matrix_coefficients:
|
|
// u(8) each.
|
|
COPY_BITS(source, destination, bits_tmp, 24);
|
|
}
|
|
}
|
|
// chroma_loc_info_present_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
if (bits_tmp == 1) {
|
|
// chroma_sample_loc_type_(top|bottom)_field: ue(v) each.
|
|
COPY_EXP_GOLOMB(source, destination, golomb_tmp);
|
|
COPY_EXP_GOLOMB(source, destination, golomb_tmp);
|
|
}
|
|
// timing_info_present_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
if (bits_tmp == 1) {
|
|
// num_units_in_tick, time_scale: u(32) each
|
|
COPY_BITS(source, destination, bits_tmp, 32);
|
|
COPY_BITS(source, destination, bits_tmp, 32);
|
|
// fixed_frame_rate_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
}
|
|
// nal_hrd_parameters_present_flag: u(1)
|
|
uint32_t nal_hrd_parameters_present_flag;
|
|
COPY_BITS(source, destination, nal_hrd_parameters_present_flag, 1);
|
|
if (nal_hrd_parameters_present_flag == 1) {
|
|
RETURN_FALSE_ON_FAIL(CopyHrdParameters(source, destination));
|
|
}
|
|
// vcl_hrd_parameters_present_flag: u(1)
|
|
uint32_t vcl_hrd_parameters_present_flag;
|
|
COPY_BITS(source, destination, vcl_hrd_parameters_present_flag, 1);
|
|
if (vcl_hrd_parameters_present_flag == 1) {
|
|
RETURN_FALSE_ON_FAIL(CopyHrdParameters(source, destination));
|
|
}
|
|
if (nal_hrd_parameters_present_flag == 1 ||
|
|
vcl_hrd_parameters_present_flag == 1) {
|
|
// low_delay_hrd_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
}
|
|
// pic_struct_present_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
|
|
// bitstream_restriction_flag: u(1)
|
|
uint32_t bitstream_restriction_flag;
|
|
RETURN_FALSE_ON_FAIL(source->ReadBits(&bitstream_restriction_flag, 1));
|
|
RETURN_FALSE_ON_FAIL(destination->WriteBits(1, 1));
|
|
if (bitstream_restriction_flag == 0) {
|
|
// We're adding one from scratch.
|
|
RETURN_FALSE_ON_FAIL(
|
|
AddBitstreamRestriction(destination, sps.max_num_ref_frames));
|
|
} else {
|
|
// We're replacing.
|
|
// motion_vectors_over_pic_boundaries_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
// max_bytes_per_pic_denom: ue(v)
|
|
COPY_EXP_GOLOMB(source, destination, golomb_tmp);
|
|
// max_bits_per_mb_denom: ue(v)
|
|
COPY_EXP_GOLOMB(source, destination, golomb_tmp);
|
|
// log2_max_mv_length_horizontal: ue(v)
|
|
COPY_EXP_GOLOMB(source, destination, golomb_tmp);
|
|
// log2_max_mv_length_vertical: ue(v)
|
|
COPY_EXP_GOLOMB(source, destination, golomb_tmp);
|
|
// ********* IMPORTANT! **********
|
|
// The next two are the ones we need to set to low numbers:
|
|
// max_num_reorder_frames: ue(v)
|
|
// max_dec_frame_buffering: ue(v)
|
|
// However, if they are already set to no greater than the numbers we
|
|
// want, then we don't need to be rewriting.
|
|
uint32_t max_num_reorder_frames, max_dec_frame_buffering;
|
|
RETURN_FALSE_ON_FAIL(
|
|
source->ReadExponentialGolomb(&max_num_reorder_frames));
|
|
RETURN_FALSE_ON_FAIL(
|
|
source->ReadExponentialGolomb(&max_dec_frame_buffering));
|
|
if (max_num_reorder_frames == 0 &&
|
|
max_dec_frame_buffering <= sps.max_num_ref_frames) {
|
|
LOG(LS_INFO) << "VUI bitstream already contains an optimal VUI.";
|
|
*out_vui_rewritten = SpsVuiRewriter::ParseResult::kVuiOk;
|
|
return true;
|
|
}
|
|
RETURN_FALSE_ON_FAIL(destination->WriteExponentialGolomb(0));
|
|
RETURN_FALSE_ON_FAIL(
|
|
destination->WriteExponentialGolomb(sps.max_num_ref_frames));
|
|
}
|
|
}
|
|
*out_vui_rewritten = SpsVuiRewriter::ParseResult::kVuiRewritten;
|
|
return true;
|
|
}
|
|
|
|
// Copies a VUI HRD parameters segment.
|
|
bool CopyHrdParameters(rtc::BitBuffer* source,
|
|
rtc::BitBufferWriter* destination) {
|
|
uint32_t golomb_tmp;
|
|
uint32_t bits_tmp;
|
|
|
|
// cbp_cnt_minus1: ue(v)
|
|
uint32_t cbp_cnt_minus1;
|
|
COPY_EXP_GOLOMB(source, destination, cbp_cnt_minus1);
|
|
// bit_rate_scale and cbp_size_scale: u(4) each
|
|
COPY_BITS(source, destination, bits_tmp, 8);
|
|
for (size_t i = 0; i <= cbp_cnt_minus1; ++i) {
|
|
// bit_rate_value_minus1 and cbp_size_value_minus1: ue(v) each
|
|
COPY_EXP_GOLOMB(source, destination, golomb_tmp);
|
|
COPY_EXP_GOLOMB(source, destination, golomb_tmp);
|
|
// cbr_flag: u(1)
|
|
COPY_BITS(source, destination, bits_tmp, 1);
|
|
}
|
|
// initial_cbp_removal_delay_length_minus1: u(5)
|
|
COPY_BITS(source, destination, bits_tmp, 5);
|
|
// cbp_removal_delay_length_minus1: u(5)
|
|
COPY_BITS(source, destination, bits_tmp, 5);
|
|
// dbp_output_delay_length_minus1: u(5)
|
|
COPY_BITS(source, destination, bits_tmp, 5);
|
|
// time_offset_length: u(5)
|
|
COPY_BITS(source, destination, bits_tmp, 5);
|
|
return true;
|
|
}
|
|
|
|
// These functions are similar to webrtc::H264SpsParser::Parse, and based on the
|
|
// same version of the H.264 standard. You can find it here:
|
|
// http://www.itu.int/rec/T-REC-H.264
|
|
|
|
// Adds a bitstream restriction VUI segment.
|
|
bool AddBitstreamRestriction(rtc::BitBufferWriter* destination,
|
|
uint32_t max_num_ref_frames) {
|
|
// motion_vectors_over_pic_boundaries_flag: u(1)
|
|
// Default is 1 when not present.
|
|
RETURN_FALSE_ON_FAIL(destination->WriteBits(1, 1));
|
|
// max_bytes_per_pic_denom: ue(v)
|
|
// Default is 2 when not present.
|
|
RETURN_FALSE_ON_FAIL(destination->WriteExponentialGolomb(2));
|
|
// max_bits_per_mb_denom: ue(v)
|
|
// Default is 1 when not present.
|
|
RETURN_FALSE_ON_FAIL(destination->WriteExponentialGolomb(1));
|
|
// log2_max_mv_length_horizontal: ue(v)
|
|
// log2_max_mv_length_vertical: ue(v)
|
|
// Both default to 16 when not present.
|
|
RETURN_FALSE_ON_FAIL(destination->WriteExponentialGolomb(16));
|
|
RETURN_FALSE_ON_FAIL(destination->WriteExponentialGolomb(16));
|
|
|
|
// ********* IMPORTANT! **********
|
|
// max_num_reorder_frames: ue(v)
|
|
RETURN_FALSE_ON_FAIL(destination->WriteExponentialGolomb(0));
|
|
// max_dec_frame_buffering: ue(v)
|
|
RETURN_FALSE_ON_FAIL(destination->WriteExponentialGolomb(max_num_ref_frames));
|
|
return true;
|
|
}
|
|
|
|
bool CopyRemainingBits(rtc::BitBuffer* source,
|
|
rtc::BitBufferWriter* destination) {
|
|
uint32_t bits_tmp;
|
|
// Try to get at least the destination aligned.
|
|
if (source->RemainingBitCount() > 0 && source->RemainingBitCount() % 8 != 0) {
|
|
size_t misaligned_bits = source->RemainingBitCount() % 8;
|
|
COPY_BITS(source, destination, bits_tmp, misaligned_bits);
|
|
}
|
|
while (source->RemainingBitCount() > 0) {
|
|
size_t count = std::min(static_cast<size_t>(32u),
|
|
static_cast<size_t>(source->RemainingBitCount()));
|
|
COPY_BITS(source, destination, bits_tmp, count);
|
|
}
|
|
// TODO(noahric): The last byte could be all zeroes now, which we should just
|
|
// strip.
|
|
return true;
|
|
}
|
|
|
|
} // namespace webrtc
|