Fix AnnexB validation logic to work with encrypted content.

media/filters/h264_parser.h

 // 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.
 //
 // This file contains an implementation of an H264 Annex-B video stream parser.
 
 #ifndef MEDIA_FILTERS_H264_PARSER_H_
 #define MEDIA_FILTERS_H264_PARSER_H_
 
 #include <sys/types.h>
 
 #include <map>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "media/base/media_export.h"
+#include "media/base/ranges.h"
 #include "media/filters/h264_bit_reader.h"
 
 namespace media {
 
+struct SubsampleEntry;
+
 // For explanations of each struct and its members, see H.264 specification
 // at http://www.itu.int/rec/T-REC-H.264.
 struct MEDIA_EXPORT H264NALU {
   H264NALU();
 
   enum Type {
     kUnspecified = 0,
     kNonIDRSlice = 1,
     kSliceDataA = 2,
     kSliceDataB = 3,
@@ skipping 300 matching lines @@
   // - |*start_code_size| is either 0, 3 or 4.
   static bool FindStartCode(const uint8* data, off_t data_size,
                             off_t* offset, off_t* start_code_size);
 
   H264Parser();
   ~H264Parser();
 
   void Reset();
   // Set current stream pointer to |stream| of |stream_size| in bytes,
   // |stream| owned by caller.
+  // |subsamples| contains information about what parts of |stream| are
+  // encrypted.
   void SetStream(const uint8* stream, off_t stream_size);
+  void SetEncryptedStream(const uint8* stream, off_t stream_size,
+                          const std::vector<SubsampleEntry>& subsamples);
 
   // Read the stream to find the next NALU, identify it and return
   // that information in |*nalu|. This advances the stream to the beginning
   // of this NALU, but not past it, so subsequent calls to NALU-specific
   // parsing functions (ParseSPS, etc.)  will parse this NALU.
   // If the caller wishes to skip the current NALU, it can call this function
   // again, instead of any NALU-type specific parse functions below.
   Result AdvanceToNextNALU(H264NALU* nalu);
 
   // NALU-specific parsing functions.
@@ skipping 34 matching lines @@
  private:
   // Move the stream pointer to the beginning of the next NALU,
   // i.e. pointing at the next start code.
   // Return true if a NALU has been found.
   // If a NALU is found:
   // - its size in bytes is returned in |*nalu_size| and includes
   //   the start code as well as the trailing zero bits.
   // - the size in bytes of the start code is returned in |*start_code_size|.
   bool LocateNALU(off_t* nalu_size, off_t* start_code_size);
 
+  // Wrapper for FindStartCode() that skips over start codes that
+  // may appear inside of |encrypted_ranges_|.
+  // Returns true if a start code was found. Otherwise returns false.
+  bool FindStartCodeInClearRanges(const uint8* data, off_t data_size,
+                                  off_t* offset, off_t* start_code_size);
+
   // Exp-Golomb code parsing as specified in chapter 9.1 of the spec.
   // Read one unsigned exp-Golomb code from the stream and return in |*val|.
   Result ReadUE(int* val);
 
   // Read one signed exp-Golomb code from the stream and return in |*val|.
   Result ReadSE(int* val);
 
   // Parse scaling lists (see spec).
   Result ParseScalingList(int size, int* scaling_list, bool* use_default);
   Result ParseSPSScalingLists(H264SPS* sps);
@@ skipping 29 matching lines @@
   off_t bytes_left_;
 
   H264BitReader br_;
 
   // PPSes and SPSes stored for future reference.
   typedef std::map<int, H264SPS*> SPSById;
   typedef std::map<int, H264PPS*> PPSById;
   SPSById active_SPSes_;
   PPSById active_PPSes_;
 
+  // Ranges of encrypted bytes in the buffer passed to
+  // SetEncryptedStream().
+  Ranges<const uint8*> encrypted_ranges_;
+
   DISALLOW_COPY_AND_ASSIGN(H264Parser);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_H264_PARSER_H_