Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(223)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/modules/video_coding/utility/h264_bitstream_parser.cc

Issue 2430353004: Revert of Move bitstream parser to more appropriate directory. (Closed)
Patch Set: Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/modules/video_coding/utility/h264_bitstream_parser.h ('k') | webrtc/modules/video_coding/utility/h264_bitstream_parser_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/modules/video_coding/utility/h264_bitstream_parser.cc
diff --git a/webrtc/modules/video_coding/utility/h264_bitstream_parser.cc b/webrtc/modules/video_coding/utility/h264_bitstream_parser.cc
new file mode 100644
index 0000000000000000000000000000000000000000..97cd0038695ca5f30fe4bccb48b32b1392b02b67
--- /dev/null
+++ b/webrtc/modules/video_coding/utility/h264_bitstream_parser.cc
@@ -0,0 +1,293 @@
+/*
+ * 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.
+ */
+#include "webrtc/modules/video_coding/utility/h264_bitstream_parser.h"
+
+#include <memory>
+#include <vector>
+
+#include "webrtc/base/bitbuffer.h"
+#include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/checks.h"
+
+#include "webrtc/common_video/h264/h264_common.h"
+#include "webrtc/base/logging.h"
+
+namespace webrtc {
+
+#define RETURN_FALSE_ON_FAIL(x) \
+ if (!(x)) { \
+ LOG_F(LS_ERROR) << "FAILED: " #x; \
+ return false; \
+ }
+
+H264BitstreamParser::H264BitstreamParser() {}
+H264BitstreamParser::~H264BitstreamParser() {}
+
+bool H264BitstreamParser::ParseNonParameterSetNalu(const uint8_t* source,
+ size_t source_length,
+ uint8_t nalu_type) {
+ RTC_CHECK(sps_);
+ RTC_CHECK(pps_);
+ last_slice_qp_delta_ = rtc::Optional<int32_t>();
+ std::unique_ptr<rtc::Buffer> slice_rbsp(
+ H264::ParseRbsp(source, source_length));
+ rtc::BitBuffer slice_reader(slice_rbsp->data() + H264::kNaluTypeSize,
+ slice_rbsp->size() - H264::kNaluTypeSize);
+ // Check to see if this is an IDR slice, which has an extra field to parse
+ // out.
+ bool is_idr = (source[0] & 0x0F) == H264::NaluType::kIdr;
+ uint8_t nal_ref_idc = (source[0] & 0x60) >> 5;
+ uint32_t golomb_tmp;
+ uint32_t bits_tmp;
+
+ // first_mb_in_slice: ue(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ // slice_type: ue(v)
+ uint32_t slice_type;
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&slice_type));
+ // slice_type's 5..9 range is used to indicate that all slices of a picture
+ // have the same value of slice_type % 5, we don't care about that, so we map
+ // to the corresponding 0..4 range.
+ slice_type %= 5;
+ // pic_parameter_set_id: ue(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ if (sps_->separate_colour_plane_flag == 1) {
+ // colour_plane_id
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadBits(&bits_tmp, 2));
+ }
+ // frame_num: u(v)
+ // Represented by log2_max_frame_num_minus4 + 4 bits.
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadBits(&bits_tmp, sps_->log2_max_frame_num_minus4 + 4));
+ uint32_t field_pic_flag = 0;
+ if (sps_->frame_mbs_only_flag == 0) {
+ // field_pic_flag: u(1)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadBits(&field_pic_flag, 1));
+ if (field_pic_flag != 0) {
+ // bottom_field_flag: u(1)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadBits(&bits_tmp, 1));
+ }
+ }
+ if (is_idr) {
+ // idr_pic_id: ue(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ // pic_order_cnt_lsb: u(v)
+ // Represented by sps_.log2_max_pic_order_cnt_lsb_minus4 + 4 bits.
+ if (sps_->pic_order_cnt_type == 0) {
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadBits(
+ &bits_tmp, sps_->log2_max_pic_order_cnt_lsb_minus4 + 4));
+ if (pps_->bottom_field_pic_order_in_frame_present_flag &&
+ field_pic_flag == 0) {
+ // delta_pic_order_cnt_bottom: se(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ }
+ if (sps_->pic_order_cnt_type == 1 &&
+ !sps_->delta_pic_order_always_zero_flag) {
+ // delta_pic_order_cnt[0]: se(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ if (pps_->bottom_field_pic_order_in_frame_present_flag && !field_pic_flag) {
+ // delta_pic_order_cnt[1]: se(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ }
+ if (pps_->redundant_pic_cnt_present_flag) {
+ // redundant_pic_cnt: ue(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ if (slice_type == H264::SliceType::kB) {
+ // direct_spatial_mv_pred_flag: u(1)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadBits(&bits_tmp, 1));
+ }
+ switch (slice_type) {
+ case H264::SliceType::kP:
+ case H264::SliceType::kB:
+ case H264::SliceType::kSp:
+ uint32_t num_ref_idx_active_override_flag;
+ // num_ref_idx_active_override_flag: u(1)
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadBits(&num_ref_idx_active_override_flag, 1));
+ if (num_ref_idx_active_override_flag != 0) {
+ // num_ref_idx_l0_active_minus1: ue(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ if (slice_type == H264::SliceType::kB) {
+ // num_ref_idx_l1_active_minus1: ue(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ // assume nal_unit_type != 20 && nal_unit_type != 21:
+ RTC_CHECK_NE(nalu_type, 20);
+ RTC_CHECK_NE(nalu_type, 21);
+ // if (nal_unit_type == 20 || nal_unit_type == 21)
+ // ref_pic_list_mvc_modification()
+ // else
+ {
+ // ref_pic_list_modification():
+ // |slice_type| checks here don't use named constants as they aren't named
+ // in the spec for this segment. Keeping them consistent makes it easier to
+ // verify that they are both the same.
+ if (slice_type % 5 != 2 && slice_type % 5 != 4) {
+ // ref_pic_list_modification_flag_l0: u(1)
+ uint32_t ref_pic_list_modification_flag_l0;
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadBits(&ref_pic_list_modification_flag_l0, 1));
+ if (ref_pic_list_modification_flag_l0) {
+ uint32_t modification_of_pic_nums_idc;
+ do {
+ // modification_of_pic_nums_idc: ue(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(
+ &modification_of_pic_nums_idc));
+ if (modification_of_pic_nums_idc == 0 ||
+ modification_of_pic_nums_idc == 1) {
+ // abs_diff_pic_num_minus1: ue(v)
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ } else if (modification_of_pic_nums_idc == 2) {
+ // long_term_pic_num: ue(v)
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ } while (modification_of_pic_nums_idc != 3);
+ }
+ }
+ if (slice_type % 5 == 1) {
+ // ref_pic_list_modification_flag_l1: u(1)
+ uint32_t ref_pic_list_modification_flag_l1;
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadBits(&ref_pic_list_modification_flag_l1, 1));
+ if (ref_pic_list_modification_flag_l1) {
+ uint32_t modification_of_pic_nums_idc;
+ do {
+ // modification_of_pic_nums_idc: ue(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(
+ &modification_of_pic_nums_idc));
+ if (modification_of_pic_nums_idc == 0 ||
+ modification_of_pic_nums_idc == 1) {
+ // abs_diff_pic_num_minus1: ue(v)
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ } else if (modification_of_pic_nums_idc == 2) {
+ // long_term_pic_num: ue(v)
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ } while (modification_of_pic_nums_idc != 3);
+ }
+ }
+ }
+ // TODO(pbos): Do we need support for pred_weight_table()?
+ RTC_CHECK(
+ !((pps_->weighted_pred_flag && (slice_type == H264::SliceType::kP ||
+ slice_type == H264::SliceType::kSp)) ||
+ (pps_->weighted_bipred_idc != 0 && slice_type == H264::SliceType::kB)))
+ << "Missing support for pred_weight_table().";
+ // if ((weighted_pred_flag && (slice_type == P || slice_type == SP)) ||
+ // (weighted_bipred_idc == 1 && slice_type == B)) {
+ // pred_weight_table()
+ // }
+ if (nal_ref_idc != 0) {
+ // dec_ref_pic_marking():
+ if (is_idr) {
+ // no_output_of_prior_pics_flag: u(1)
+ // long_term_reference_flag: u(1)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadBits(&bits_tmp, 2));
+ } else {
+ // adaptive_ref_pic_marking_mode_flag: u(1)
+ uint32_t adaptive_ref_pic_marking_mode_flag;
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadBits(&adaptive_ref_pic_marking_mode_flag, 1));
+ if (adaptive_ref_pic_marking_mode_flag) {
+ uint32_t memory_management_control_operation;
+ do {
+ // memory_management_control_operation: ue(v)
+ RETURN_FALSE_ON_FAIL(slice_reader.ReadExponentialGolomb(
+ &memory_management_control_operation));
+ if (memory_management_control_operation == 1 ||
+ memory_management_control_operation == 3) {
+ // difference_of_pic_nums_minus1: ue(v)
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ if (memory_management_control_operation == 2) {
+ // long_term_pic_num: ue(v)
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ if (memory_management_control_operation == 3 ||
+ memory_management_control_operation == 6) {
+ // long_term_frame_idx: ue(v)
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ if (memory_management_control_operation == 4) {
+ // max_long_term_frame_idx_plus1: ue(v)
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadExponentialGolomb(&golomb_tmp));
+ }
+ } while (memory_management_control_operation != 0);
+ }
+ }
+ }
+ // cabac not supported: entropy_coding_mode_flag == 0 asserted above.
+ // if (entropy_coding_mode_flag && slice_type != I && slice_type != SI)
+ // cabac_init_idc
+ int32_t last_slice_qp_delta;
+ RETURN_FALSE_ON_FAIL(
+ slice_reader.ReadSignedExponentialGolomb(&last_slice_qp_delta));
+ last_slice_qp_delta_ = rtc::Optional<int32_t>(last_slice_qp_delta);
+ return true;
+}
+
+void H264BitstreamParser::ParseSlice(const uint8_t* slice, size_t length) {
+ H264::NaluType nalu_type = H264::ParseNaluType(slice[0]);
+ switch (nalu_type) {
+ case H264::NaluType::kSps: {
+ sps_ = SpsParser::ParseSps(slice + H264::kNaluTypeSize,
+ length - H264::kNaluTypeSize);
+ if (!sps_)
+ FATAL() << "Unable to parse SPS from H264 bitstream.";
+ break;
+ }
+ case H264::NaluType::kPps: {
+ pps_ = PpsParser::ParsePps(slice + H264::kNaluTypeSize,
+ length - H264::kNaluTypeSize);
+ if (!pps_)
+ FATAL() << "Unable to parse PPS from H264 bitstream.";
+ break;
+ }
+ default:
+ RTC_CHECK(ParseNonParameterSetNalu(slice, length, nalu_type))
+ << "Failed to parse picture slice.";
+ break;
+ }
+}
+
+void H264BitstreamParser::ParseBitstream(const uint8_t* bitstream,
+ size_t length) {
+ std::vector<H264::NaluIndex> nalu_indices =
+ H264::FindNaluIndices(bitstream, length);
+ RTC_CHECK(!nalu_indices.empty());
+ for (const H264::NaluIndex& index : nalu_indices)
+ ParseSlice(&bitstream[index.payload_start_offset], index.payload_size);
+}
+
+bool H264BitstreamParser::GetLastSliceQp(int* qp) const {
+ if (!last_slice_qp_delta_ || !pps_)
+ return false;
+ *qp = 26 + pps_->pic_init_qp_minus26 + *last_slice_qp_delta_;
+ return true;
+}
+
+} // namespace webrtc
« no previous file with comments | « webrtc/modules/video_coding/utility/h264_bitstream_parser.h ('k') | webrtc/modules/video_coding/utility/h264_bitstream_parser_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698