H264Decoder: Handle gaps in frame_num.

media/filters/h264_parser.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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 
 #include "media/base/decrypt_config.h"
 #include "media/filters/h264_parser.h"
@@ skipping 142 matching lines @@
   for (size_t i = 0; i < subsamples.size() && start < stream_end; ++i) {
     start += subsamples[i].clear_bytes;
 
     const uint8* end = std::min(start + subsamples[i].cypher_bytes, stream_end);
     encrypted_ranges_.Add(start, end);
     start = end;
   }
 }
 
 const H264PPS* H264Parser::GetPPS(int pps_id) {
-  return active_PPSes_[pps_id];
+  auto it = active_PPSes_.find(pps_id);
+  if (it == active_PPSes_.end()) {
+    DVLOG(1) << "Requested a nonexistent PPS id " << pps_id;
+    return nullptr;
+  }
+
+  return it->second;
 }
 
 const H264SPS* H264Parser::GetSPS(int sps_id) {
-  return active_SPSes_[sps_id];
+  auto it = active_SPSes_.find(sps_id);
+  if (it == active_SPSes_.end()) {
+    DVLOG(1) << "Requested a nonexistent SPS id " << sps_id;
+    return nullptr;
+  }
+
+  return it->second;
 }
 
 static inline bool IsStartCode(const uint8* data) {
   return data[0] == 0x00 && data[1] == 0x00 && data[2] == 0x01;
 }
 
 // static
 bool H264Parser::FindStartCode(const uint8* data, off_t data_size,
                                off_t* offset, off_t* start_code_size) {
   DCHECK_GE(data_size, 0);
@@ skipping 650 matching lines @@
     for (int i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; ++i) {
       READ_SE_OR_RETURN(&sps->offset_for_ref_frame[i]);
       sps->expected_delta_per_pic_order_cnt_cycle +=
           sps->offset_for_ref_frame[i];
     }
   }
 
   READ_UE_OR_RETURN(&sps->max_num_ref_frames);
   READ_BOOL_OR_RETURN(&sps->gaps_in_frame_num_value_allowed_flag);
 
-  if (sps->gaps_in_frame_num_value_allowed_flag)
-    return kUnsupportedStream;
-
   READ_UE_OR_RETURN(&sps->pic_width_in_mbs_minus1);
   READ_UE_OR_RETURN(&sps->pic_height_in_map_units_minus1);
 
   READ_BOOL_OR_RETURN(&sps->frame_mbs_only_flag);
   if (!sps->frame_mbs_only_flag)
     READ_BOOL_OR_RETURN(&sps->mb_adaptive_frame_field_flag);
 
   READ_BOOL_OR_RETURN(&sps->direct_8x8_inference_flag);
 
   READ_BOOL_OR_RETURN(&sps->frame_cropping_flag);
@@ skipping 26 matching lines @@
   Result res;
 
   *pps_id = -1;
 
   scoped_ptr<H264PPS> pps(new H264PPS());
 
   READ_UE_OR_RETURN(&pps->pic_parameter_set_id);
   READ_UE_OR_RETURN(&pps->seq_parameter_set_id);
   TRUE_OR_RETURN(pps->seq_parameter_set_id < 32);
 
+  if (active_SPSes_.find(pps->seq_parameter_set_id) == active_SPSes_.end()) {
+    DVLOG(1) << "Invalid stream, no SPS id: " << pps->seq_parameter_set_id;
+    return kInvalidStream;
+  }
+
   sps = GetSPS(pps->seq_parameter_set_id);
   TRUE_OR_RETURN(sps);
 
   READ_BOOL_OR_RETURN(&pps->entropy_coding_mode_flag);
   READ_BOOL_OR_RETURN(&pps->bottom_field_pic_order_in_frame_present_flag);
 
   READ_UE_OR_RETURN(&pps->num_slice_groups_minus1);
   if (pps->num_slice_groups_minus1 > 1) {
     DVLOG(1) << "Slice groups not supported";
     return kUnsupportedStream;
@@ skipping 422 matching lines @@
 
     default:
       DVLOG(4) << "Unsupported SEI message";
       break;
   }
 
   return kOk;
 }
 
 }  // namespace media