Index: media/video/h264_poc.cc |
diff --git a/media/video/h264_poc.cc b/media/video/h264_poc.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..5d2892a3703384698a86078bc92ee6e837cd230e |
--- /dev/null |
+++ b/media/video/h264_poc.cc |
@@ -0,0 +1,226 @@ |
+// Copyright 2014 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include <algorithm> |
+ |
+#include "base/logging.h" |
+#include "media/filters/h264_parser.h" |
+#include "media/video/h264_poc.h" |
+ |
+namespace media { |
+ |
+H264POC::H264POC() { |
+ Reset(); |
+} |
+ |
+H264POC::~H264POC() { |
+} |
+ |
+void H264POC::Reset() { |
+ // It shouldn't be necessary to reset these values, but doing so will improve |
+ // reproducibility for buggy streams. |
+ ref_pic_order_cnt_msb_ = 0; |
+ ref_pic_order_cnt_lsb_ = 0; |
+ prev_frame_num_ = 0; |
+ prev_frame_num_offset_ = 0; |
+} |
+ |
+// Check if a slice includes memory management control operation 5, which |
+// results in some |pic_order_cnt| state being cleared. |
+static bool HasMMCO5(const media::H264SliceHeader& slice_hdr) { |
+ // Require that the frame actually has memory management control operations. |
+ if (slice_hdr.nal_ref_idc == 0 || |
+ slice_hdr.idr_pic_flag || |
+ !slice_hdr.adaptive_ref_pic_marking_mode_flag) { |
+ return false; |
+ } |
+ |
+ for (size_t i = 0; i < arraysize(slice_hdr.ref_pic_marking); i++) { |
+ int32_t op = slice_hdr.ref_pic_marking[i].memory_mgmnt_control_operation; |
+ if (op == 5) |
+ return true; |
+ |
+ // Stop at the end of the list. |
+ if (op == 0) |
+ return false; |
+ } |
+ |
+ // Should not get here, the list is always zero terminated. |
+ return false; |
+} |
+ |
+bool H264POC::ComputePicOrderCnt( |
+ const H264SPS* sps, |
+ const H264SliceHeader& slice_hdr, |
+ int32_t *pic_order_cnt) { |
+ if (slice_hdr.field_pic_flag) { |
+ DLOG(ERROR) << "Interlaced frames are not supported"; |
+ return false; |
+ } |
+ |
+ // TODO(sandersd): Handle |gaps_in_frame_num_value|. |
+ if (prev_frame_num_ > 0 && prev_frame_num_ < slice_hdr.frame_num - 1) { |
+ DLOG(ERROR) << "Gaps in frame_num are not supported"; |
+ return false; |
+ } |
+ |
+ bool mmco5 = HasMMCO5(slice_hdr); |
+ int32_t max_frame_num = 1 << (sps->log2_max_frame_num_minus4 + 4); |
+ int32_t max_pic_order_cnt_lsb = |
+ 1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4); |
+ |
+ // Based on T-REC-H.264 8.2.1, "Decoding process for picture order |
+ // count", available from http://www.itu.int/rec/T-REC-H.264. |
+ // |
+ // Reorganized slightly from spec pseudocode to handle MMCO5 when storing |
+ // state instead of when loading it. |
+ switch (sps->pic_order_cnt_type) { |
+ case 0: { |
+ int32_t prev_pic_order_cnt_msb = ref_pic_order_cnt_msb_; |
+ int32_t prev_pic_order_cnt_lsb = ref_pic_order_cnt_lsb_; |
+ |
+ // For an IDR picture, clear the state. |
+ if (slice_hdr.idr_pic_flag) { |
+ prev_pic_order_cnt_msb = 0; |
+ prev_pic_order_cnt_lsb = 0; |
+ } |
+ |
+ // 8-3. Derive |pic_order_cnt_msb|, accounting for wrapping which is |
+ // detected when |pic_order_cnt_lsb| increases or decreases by at |
+ // least half of its maximum. |
+ int32_t pic_order_cnt_msb; |
+ if ((slice_hdr.pic_order_cnt_lsb < prev_pic_order_cnt_lsb) && |
+ (prev_pic_order_cnt_lsb - slice_hdr.pic_order_cnt_lsb >= |
+ max_pic_order_cnt_lsb / 2)) { |
+ pic_order_cnt_msb = prev_pic_order_cnt_msb + max_pic_order_cnt_lsb; |
+ } else if ((slice_hdr.pic_order_cnt_lsb > prev_pic_order_cnt_lsb) && |
+ (slice_hdr.pic_order_cnt_lsb - prev_pic_order_cnt_lsb > |
+ max_pic_order_cnt_lsb / 2)) { |
+ pic_order_cnt_msb = prev_pic_order_cnt_msb - max_pic_order_cnt_lsb; |
+ } else { |
+ pic_order_cnt_msb = prev_pic_order_cnt_msb; |
+ } |
+ |
+ // 8-4, 8-5. Derive |top_field_order_count| and |bottom_field_order_cnt| |
+ // (assuming no interlacing). |
+ int32_t top_foc = pic_order_cnt_msb + slice_hdr.pic_order_cnt_lsb; |
+ int32_t bottom_foc = top_foc + slice_hdr.delta_pic_order_cnt_bottom; |
+ *pic_order_cnt = std::min(top_foc, bottom_foc); |
+ |
+ // Store state. |
+ prev_frame_num_ = slice_hdr.frame_num; |
+ if (slice_hdr.nal_ref_idc != 0) { |
+ if (mmco5) { |
+ ref_pic_order_cnt_msb_ = 0; |
+ ref_pic_order_cnt_lsb_ = top_foc; |
+ } else { |
+ ref_pic_order_cnt_msb_ = pic_order_cnt_msb; |
+ ref_pic_order_cnt_lsb_ = slice_hdr.pic_order_cnt_lsb; |
+ } |
+ } |
+ |
+ break; |
+ } |
+ |
+ case 1: { |
+ // 8-6. Derive |frame_num_offset|. |
+ int32_t frame_num_offset; |
+ if (slice_hdr.idr_pic_flag) |
+ frame_num_offset = 0; |
+ else if (prev_frame_num_ > slice_hdr.frame_num) |
+ frame_num_offset = prev_frame_num_offset_ + max_frame_num; |
+ else |
+ frame_num_offset = prev_frame_num_offset_; |
+ |
+ // 8-7. Derive |abs_frame_num|. |
+ int32_t abs_frame_num; |
+ if (sps->num_ref_frames_in_pic_order_cnt_cycle != 0) |
+ abs_frame_num = frame_num_offset + slice_hdr.frame_num; |
+ else |
+ abs_frame_num = 0; |
+ |
+ if (slice_hdr.nal_ref_idc == 0 && abs_frame_num > 0) |
+ abs_frame_num--; |
+ |
+ // 8-9. Derive |expected_pic_order_cnt| (the |pic_order_cnt| indicated |
+ // by the cycle described in the SPS). |
+ int32_t expected_pic_order_cnt = 0; |
+ if (abs_frame_num > 0) { |
+ // 8-8. Derive pic_order_cnt_cycle_cnt and |
+ // frame_num_in_pic_order_cnt_cycle. |
+ // Moved inside 8-9 to avoid division when this check is not done. |
+ if (sps->num_ref_frames_in_pic_order_cnt_cycle == 0) { |
+ DLOG(ERROR) << "Invalid num_ref_frames_in_pic_order_cnt_cycle"; |
+ return false; |
+ } |
+ |
+ // H264Parser checks that num_ref_frames_in_pic_order_cnt_cycle < 255. |
+ int32_t pic_order_cnt_cycle_cnt = |
+ (abs_frame_num - 1) / sps->num_ref_frames_in_pic_order_cnt_cycle; |
+ int32_t frame_num_in_pic_order_cnt_cycle = |
+ (abs_frame_num - 1) % sps->num_ref_frames_in_pic_order_cnt_cycle; |
+ |
+ // 8-9 continued. |
+ expected_pic_order_cnt = pic_order_cnt_cycle_cnt * |
+ sps->expected_delta_per_pic_order_cnt_cycle; |
+ for (int32_t i = 0; i <= frame_num_in_pic_order_cnt_cycle; i++) |
+ expected_pic_order_cnt += sps->offset_for_ref_frame[i]; |
+ } |
+ if (slice_hdr.nal_ref_idc == 0) |
+ expected_pic_order_cnt += sps->offset_for_non_ref_pic; |
+ |
+ // 8-10. Derive |top_field_order_cnt| and |bottom_field_order_cnt| |
+ // (assuming no interlacing). |
+ int32_t top_foc = expected_pic_order_cnt + |
+ slice_hdr.delta_pic_order_cnt[0]; |
+ int32_t bottom_foc = top_foc + sps->offset_for_top_to_bottom_field + |
+ slice_hdr.delta_pic_order_cnt[1]; |
+ *pic_order_cnt = std::min(top_foc, bottom_foc); |
+ |
+ // Store state. |
+ prev_frame_num_ = slice_hdr.frame_num; |
+ prev_frame_num_offset_ = frame_num_offset; |
+ if (mmco5) |
+ prev_frame_num_offset_ = 0; |
+ |
+ break; |
+ } |
+ |
+ case 2: { |
+ // 8-11. Derive |frame_num_offset|. |
+ int32_t frame_num_offset; |
+ if (slice_hdr.idr_pic_flag) |
+ frame_num_offset = 0; |
+ else if (prev_frame_num_ > slice_hdr.frame_num) |
+ frame_num_offset = prev_frame_num_offset_ + max_frame_num; |
+ else |
+ frame_num_offset = prev_frame_num_offset_; |
+ |
+ // 8-12, 8-13. Derive |temp_pic_order_count| (it's always the |
+ // |pic_order_cnt|, regardless of interlacing). |
+ if (slice_hdr.idr_pic_flag) |
+ *pic_order_cnt = 0; |
+ else if (slice_hdr.nal_ref_idc == 0) |
+ *pic_order_cnt = 2 * (frame_num_offset + slice_hdr.frame_num) - 1; |
+ else |
+ *pic_order_cnt = 2 * (frame_num_offset + slice_hdr.frame_num); |
+ |
+ // Store state. |
+ prev_frame_num_ = slice_hdr.frame_num; |
+ prev_frame_num_offset_ = frame_num_offset; |
+ if (mmco5) |
+ prev_frame_num_offset_ = 0; |
+ |
+ break; |
+ } |
+ |
+ default: |
+ DLOG(ERROR) << "Invalid pic_order_cnt_type: " << sps->pic_order_cnt_type; |
+ return false; |
+ } |
+ |
+ return true; |
+} |
+ |
+} // namespace media |