H264POC: Re-compute PicOrderCnt for duplicate frame_nums.

media/video/h264_poc.cc

 // 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 <stddef.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/macros.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;
-  prev_poc_ = 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;
@@ skipping 15 matching lines @@
 
 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;
   }
 
-  if (!slice_hdr.idr_pic_flag && slice_hdr.frame_num == prev_frame_num_) {
-    DLOG(WARNING) << "Redundant picture passed to H264POC";
-    *pic_order_cnt = prev_poc_;
-    return true;
-  }
-
   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);
 
+  // Check for invalid (including duplicate) |frame_num| values. All cases are
+  // treated as gaps, which is to say that nothing is done. (Gaps don't affect
+  // POC computation.)
   if (!slice_hdr.idr_pic_flag &&
       slice_hdr.frame_num != (prev_frame_num_ + 1) % max_frame_num) {
-    // We don't do any special handling of gaps in |frame_num|, because the
-    // computations below are unaffected by them. In particular, wrapping is
-    // handled the same whether we simulate the missing frames or not.
     if (!sps->gaps_in_frame_num_value_allowed_flag)
       DLOG(WARNING) << "Invalid gap in frame_num";
   }
 
   // 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.
-  int32_t poc;
   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;
       }
@@ skipping 11 matching lines @@
            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;
-      poc = std::min(top_foc, bottom_foc);
+      *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;
@@ skipping 48 matching lines @@
           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_cnt0;
       int32_t bottom_foc = top_foc + sps->offset_for_top_to_bottom_field +
                            slice_hdr.delta_pic_order_cnt1;
-      poc = std::min(top_foc, bottom_foc);
+      *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)
-        poc = 0;
+        *pic_order_cnt = 0;
       else if (slice_hdr.nal_ref_idc == 0)
-        poc = 2 * (frame_num_offset + slice_hdr.frame_num) - 1;
+        *pic_order_cnt = 2 * (frame_num_offset + slice_hdr.frame_num) - 1;
       else
-        poc = 2 * (frame_num_offset + slice_hdr.frame_num);
+        *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;
   }
 
-  *pic_order_cnt = prev_poc_ = poc;
   return true;
 }
 
 }  // namespace media