Build AVC decoder configuration record

content/common/gpu/media/h264_parser.cc

 // Copyright (c) 2012 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 "content/common/gpu/media/h264_parser.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 
@@ skipping 124 matching lines @@
   if (num_remaining_bits_in_curr_byte_ == 0 && !UpdateCurrByte())
       return false;
 
   // On last byte?
   if (bytes_left_)
     return true;
 
   // Last byte, look for stop bit;
   // We have more RBSP data if the last non-zero bit we find is not the
   // first available bit.
-  return curr_byte_ & ((1 << (num_remaining_bits_in_curr_byte_ - 1)) - 1);
+  return (curr_byte_ &
+          ((1 << (num_remaining_bits_in_curr_byte_ - 1)) - 1)) != 0;
 }
 
 #define READ_BITS_OR_RETURN(num_bits, out)                                    \
 do {                                                                          \
   int _out;                                                                   \
   if (!br_.ReadBits(num_bits, &_out)) {                                       \
     DVLOG(1) << "Error in stream: unexpected EOS while trying to read " #out; \
     return kInvalidStream;                                                    \
   }                                                                           \
   *out = _out;                                                                \
 } while (0)
 
+#define READ_BOOL_OR_RETURN(out)                                              \
+do {                                                                          \
+  int _out;                                                                   \
+  if (!br_.ReadBits(1, &_out)) {                                              \
+    DVLOG(1) << "Error in stream: unexpected EOS while trying to read " #out; \
+    return kInvalidStream;                                                    \
+  }                                                                           \
+  *out = _out != 0;                                                           \
+} while (0)
+
 #define READ_UE_OR_RETURN(out)                                               \
 do {                                                                         \
   if (ReadUE(out) != kOk) {                                                  \
     DVLOG(1) << "Error in stream: invalid value while trying to read " #out; \
     return kInvalidStream;                                                   \
   }                                                                          \
 } while (0)
 
 #define READ_SE_OR_RETURN(out)                                               \
 do {                                                                         \
@@ skipping 366 matching lines @@
 }
 
 H264Parser::Result H264Parser::ParseSPSScalingLists(H264SPS* sps) {
   // See 7.4.2.1.1.
   bool seq_scaling_list_present_flag;
   bool use_default;
   Result res;
 
   // Parse scaling_list4x4.
   for (int i = 0; i < 6; ++i) {
-    READ_BITS_OR_RETURN(1, &seq_scaling_list_present_flag);
+    READ_BOOL_OR_RETURN(&seq_scaling_list_present_flag);
 
     if (seq_scaling_list_present_flag) {
       res = ParseScalingList(sizeof(sps->scaling_list4x4[i]),
                              sps->scaling_list4x4[i], &use_default);
       if (res != kOk)
         return res;
 
       if (use_default)
         DefaultScalingList4x4(i, sps->scaling_list4x4);
 
     } else {
         FallbackScalingList4x4(i, kDefault4x4Intra, kDefault4x4Inter,
                                sps->scaling_list4x4);
     }
   }
 
   // Parse scaling_list8x8.
-  for (int i = 0; i < (sps->chroma_format_idc != 3) ? 2 : 6; ++i) {
-    READ_BITS_OR_RETURN(1, &seq_scaling_list_present_flag);
+  for (int i = 0; i < ((sps->chroma_format_idc != 3) ? 2 : 6); ++i) {
+    READ_BOOL_OR_RETURN(&seq_scaling_list_present_flag);
 
     if (seq_scaling_list_present_flag) {
       res = ParseScalingList(sizeof(sps->scaling_list8x8[i]),
                              sps->scaling_list8x8[i], &use_default);
       if (res != kOk)
         return res;
 
       if (use_default)
         DefaultScalingList8x8(i, sps->scaling_list8x8);
 
     } else {
         FallbackScalingList8x8(i, kDefault8x8Intra, kDefault8x8Inter,
                               sps->scaling_list8x8);
     }
   }
 
   return kOk;
 }
 
 H264Parser::Result H264Parser::ParsePPSScalingLists(const H264SPS& sps,
                                                     H264PPS* pps) {
   // See 7.4.2.2.
   bool pic_scaling_list_present_flag;
   bool use_default;
   Result res;
 
   for (int i = 0; i < 6; ++i) {
-    READ_BITS_OR_RETURN(1, &pic_scaling_list_present_flag);
+    READ_BOOL_OR_RETURN(&pic_scaling_list_present_flag);
 
     if (pic_scaling_list_present_flag) {
       res = ParseScalingList(sizeof(pps->scaling_list4x4[i]),
                              pps->scaling_list4x4[i], &use_default);
       if (res != kOk)
         return res;
 
       if (use_default)
         DefaultScalingList4x4(i, pps->scaling_list4x4);
 
     } else {
       if (sps.seq_scaling_matrix_present_flag) {
         // Table 7-2 fallback rule A in spec.
         FallbackScalingList4x4(i, kDefault4x4Intra, kDefault4x4Inter,
                                pps->scaling_list4x4);
       } else {
         // Table 7-2 fallback rule B in spec.
         FallbackScalingList4x4(i, sps.scaling_list4x4[0],
                                sps.scaling_list4x4[3], pps->scaling_list4x4);
       }
     }
   }
 
   if (pps->transform_8x8_mode_flag) {
-    for (int i = 0; i < (sps.chroma_format_idc != 3) ? 2 : 6; ++i) {
-      READ_BITS_OR_RETURN(1, &pic_scaling_list_present_flag);
+    for (int i = 0; i < ((sps.chroma_format_idc != 3) ? 2 : 6); ++i) {
+      READ_BOOL_OR_RETURN(&pic_scaling_list_present_flag);
 
       if (pic_scaling_list_present_flag) {
         res = ParseScalingList(sizeof(pps->scaling_list8x8[i]),
                                pps->scaling_list8x8[i], &use_default);
         if (res != kOk)
           return res;
 
         if (use_default)
           DefaultScalingList8x8(i, pps->scaling_list8x8);
 
@@ skipping 22 matching lines @@
 H264Parser::Result H264Parser::ParseSPS(int* sps_id) {
   // See 7.4.2.1.
   int data;
   Result res;
 
   *sps_id = -1;
 
   scoped_ptr<H264SPS> sps(new H264SPS());
 
   READ_BITS_OR_RETURN(8, &sps->profile_idc);
-  // Skip constraint_setx_flag and reserved flags.
-  READ_BITS_OR_RETURN(8, &data);
+  READ_BITS_OR_RETURN(6, &sps->constraint_setx_flag);
+  READ_BITS_OR_RETURN(2, &data);
   READ_BITS_OR_RETURN(8, &sps->level_idc);
   READ_UE_OR_RETURN(&sps->seq_parameter_set_id);
   TRUE_OR_RETURN(sps->seq_parameter_set_id < 32);
 
   if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
       sps->profile_idc == 122 || sps->profile_idc == 244 ||
       sps->profile_idc ==  44 || sps->profile_idc ==  83 ||
       sps->profile_idc ==  86 || sps->profile_idc == 118 ||
       sps->profile_idc == 128) {
     READ_UE_OR_RETURN(&sps->chroma_format_idc);
     TRUE_OR_RETURN(sps->chroma_format_idc < 4);
 
     if (sps->chroma_format_idc == 3)
-      READ_BITS_OR_RETURN(1, &sps->separate_colour_plane_flag);
+      READ_BOOL_OR_RETURN(&sps->separate_colour_plane_flag);
 
     if (sps->separate_colour_plane_flag)
       sps->chroma_array_type = 0;
     else
       sps->chroma_array_type = sps->chroma_format_idc;
 
     READ_UE_OR_RETURN(&sps->bit_depth_luma_minus8);
     TRUE_OR_RETURN(sps->bit_depth_luma_minus8 < 7);
 
     READ_UE_OR_RETURN(&sps->bit_depth_chroma_minus8);
     TRUE_OR_RETURN(sps->bit_depth_chroma_minus8 < 7);
 
-    READ_BITS_OR_RETURN(1, &sps->qpprime_y_zero_transform_bypass_flag);
-    READ_BITS_OR_RETURN(1, &sps->seq_scaling_matrix_present_flag);
+    READ_BOOL_OR_RETURN(&sps->qpprime_y_zero_transform_bypass_flag);
+    READ_BOOL_OR_RETURN(&sps->seq_scaling_matrix_present_flag);
 
     if (sps->seq_scaling_matrix_present_flag) {
       DVLOG(4) << "Scaling matrix present";
       res = ParseSPSScalingLists(sps.get());
       if (res != kOk)
         return res;
     } else {
       FillDefaultSeqScalingLists(sps.get());
     }
   }
 
   READ_UE_OR_RETURN(&sps->log2_max_frame_num_minus4);
   TRUE_OR_RETURN(sps->log2_max_frame_num_minus4 < 13);
 
   READ_UE_OR_RETURN(&sps->pic_order_cnt_type);
   TRUE_OR_RETURN(sps->pic_order_cnt_type < 3);
 
   if (sps->pic_order_cnt_type == 0) {
     READ_UE_OR_RETURN(&sps->log2_max_pic_order_cnt_lsb_minus4);
     TRUE_OR_RETURN(sps->log2_max_pic_order_cnt_lsb_minus4 < 13);
   } else if (sps->pic_order_cnt_type == 1) {
-    READ_BITS_OR_RETURN(1, &sps->delta_pic_order_always_zero_flag);
+    READ_BOOL_OR_RETURN(&sps->delta_pic_order_always_zero_flag);
     READ_SE_OR_RETURN(&sps->offset_for_non_ref_pic);
     READ_SE_OR_RETURN(&sps->offset_for_top_to_bottom_field);
     READ_UE_OR_RETURN(&sps->num_ref_frames_in_pic_order_cnt_cycle);
     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]);
   }
 
   READ_UE_OR_RETURN(&sps->max_num_ref_frames);
-  READ_BITS_OR_RETURN(1, &sps->gaps_in_frame_num_value_allowed_flag);
+  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_BITS_OR_RETURN(1, &sps->frame_mbs_only_flag);
+  READ_BOOL_OR_RETURN(&sps->frame_mbs_only_flag);
   if (!sps->frame_mbs_only_flag)
-    READ_BITS_OR_RETURN(1, &sps->mb_adaptive_frame_field_flag);
+    READ_BOOL_OR_RETURN(&sps->mb_adaptive_frame_field_flag);
 
-  READ_BITS_OR_RETURN(1, &sps->direct_8x8_inference_flag);
+  READ_BOOL_OR_RETURN(&sps->direct_8x8_inference_flag);
 
-  READ_BITS_OR_RETURN(1, &sps->frame_cropping_flag);
+  READ_BOOL_OR_RETURN(&sps->frame_cropping_flag);
   if (sps->frame_cropping_flag) {
     READ_UE_OR_RETURN(&sps->frame_crop_left_offset);
     READ_UE_OR_RETURN(&sps->frame_crop_right_offset);
     READ_UE_OR_RETURN(&sps->frame_crop_top_offset);
     READ_UE_OR_RETURN(&sps->frame_crop_bottom_offset);
   }
 
-  READ_BITS_OR_RETURN(1, &sps->vui_parameters_present_flag);
+  READ_BOOL_OR_RETURN(&sps->vui_parameters_present_flag);
   if (sps->vui_parameters_present_flag) {
     DVLOG(1) << "VUI parameters present in SPS, ignoring";
   }
 
   // If an SPS with the same id already exists, replace it.
   *sps_id = sps->seq_parameter_set_id;
   delete active_SPSes_[*sps_id];
   active_SPSes_[*sps_id] = sps.release();
 
   return kOk;
 }
 
 H264Parser::Result H264Parser::ParsePPS(int* pps_id) {
   // See 7.4.2.2.
   const H264SPS* sps;
   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);
 
   sps = GetSPS(pps->seq_parameter_set_id);
   TRUE_OR_RETURN(sps);
 
-  READ_BITS_OR_RETURN(1, &pps->entropy_coding_mode_flag);
-  READ_BITS_OR_RETURN(1, &pps->bottom_field_pic_order_in_frame_present_flag);
+  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;
   }
 
   READ_UE_OR_RETURN(&pps->num_ref_idx_l0_default_active_minus1);
   TRUE_OR_RETURN(pps->num_ref_idx_l0_default_active_minus1 < 32);
 
   READ_UE_OR_RETURN(&pps->num_ref_idx_l1_default_active_minus1);
   TRUE_OR_RETURN(pps->num_ref_idx_l1_default_active_minus1 < 32);
 
-  READ_BITS_OR_RETURN(1, &pps->weighted_pred_flag);
+  READ_BOOL_OR_RETURN(&pps->weighted_pred_flag);
   READ_BITS_OR_RETURN(2, &pps->weighted_bipred_idc);
   TRUE_OR_RETURN(pps->weighted_bipred_idc < 3);
 
   READ_SE_OR_RETURN(&pps->pic_init_qp_minus26);
   IN_RANGE_OR_RETURN(pps->pic_init_qp_minus26, -26, 25);
 
   READ_SE_OR_RETURN(&pps->pic_init_qs_minus26);
   IN_RANGE_OR_RETURN(pps->pic_init_qs_minus26, -26, 25);
 
   READ_SE_OR_RETURN(&pps->chroma_qp_index_offset);
   IN_RANGE_OR_RETURN(pps->chroma_qp_index_offset, -12, 12);
 
-  READ_BITS_OR_RETURN(1, &pps->deblocking_filter_control_present_flag);
-  READ_BITS_OR_RETURN(1, &pps->constrained_intra_pred_flag);
-  READ_BITS_OR_RETURN(1, &pps->redundant_pic_cnt_present_flag);
+  READ_BOOL_OR_RETURN(&pps->deblocking_filter_control_present_flag);
+  READ_BOOL_OR_RETURN(&pps->constrained_intra_pred_flag);
+  READ_BOOL_OR_RETURN(&pps->redundant_pic_cnt_present_flag);
 
   if (br_.HasMoreRBSPData()) {
-    READ_BITS_OR_RETURN(1, &pps->transform_8x8_mode_flag);
-    READ_BITS_OR_RETURN(1, &pps->pic_scaling_matrix_present_flag);
+    READ_BOOL_OR_RETURN(&pps->transform_8x8_mode_flag);
+    READ_BOOL_OR_RETURN(&pps->pic_scaling_matrix_present_flag);
 
     if (pps->pic_scaling_matrix_present_flag) {
       DVLOG(4) << "Picture scaling matrix present";
       res = ParsePPSScalingLists(*sps, pps.get());
       if (res != kOk)
         return res;
     }
 
     READ_SE_OR_RETURN(&pps->second_chroma_qp_index_offset);
   }
@@ skipping 47 matching lines @@
   TRUE_OR_RETURN(modification_of_pic_nums_idc == 3);
 
   return kOk;
 }
 
 H264Parser::Result H264Parser::ParseRefPicListModifications(
     H264SliceHeader* shdr) {
   Result res;
 
   if (!shdr->IsISlice() && !shdr->IsSISlice()) {
-    READ_BITS_OR_RETURN(1, &shdr->ref_pic_list_modification_flag_l0);
+    READ_BOOL_OR_RETURN(&shdr->ref_pic_list_modification_flag_l0);
     if (shdr->ref_pic_list_modification_flag_l0) {
       res = ParseRefPicListModification(shdr->num_ref_idx_l0_active_minus1,
                                         shdr->ref_list_l0_modifications);
       if (res != kOk)
         return res;
     }
   }
 
   if (shdr->IsBSlice()) {
-    READ_BITS_OR_RETURN(1, &shdr->ref_pic_list_modification_flag_l1);
+    READ_BOOL_OR_RETURN(&shdr->ref_pic_list_modification_flag_l1);
     if (shdr->ref_pic_list_modification_flag_l1) {
       res = ParseRefPicListModification(shdr->num_ref_idx_l1_active_minus1,
                                         shdr->ref_list_l1_modifications);
       if (res != kOk)
         return res;
     }
   }
 
   return kOk;
 }
 
 H264Parser::Result H264Parser::ParseWeightingFactors(
     int num_ref_idx_active_minus1,
     int chroma_array_type,
     int luma_log2_weight_denom,
     int chroma_log2_weight_denom,
     H264WeightingFactors* w_facts) {
 
   int def_luma_weight = 1 << luma_log2_weight_denom;
   int def_chroma_weight = 1 << chroma_log2_weight_denom;
 
   for (int i = 0; i < num_ref_idx_active_minus1 + 1; ++i) {
-    READ_BITS_OR_RETURN(1, &w_facts->luma_weight_flag);
+    READ_BOOL_OR_RETURN(&w_facts->luma_weight_flag);
     if (w_facts->luma_weight_flag) {
       READ_SE_OR_RETURN(&w_facts->luma_weight[i]);
       IN_RANGE_OR_RETURN(w_facts->luma_weight[i], -128, 127);
 
       READ_SE_OR_RETURN(&w_facts->luma_offset[i]);
       IN_RANGE_OR_RETURN(w_facts->luma_offset[i], -128, 127);
     } else {
       w_facts->luma_weight[i] = def_luma_weight;
       w_facts->luma_offset[i] = 0;
     }
 
     if (chroma_array_type != 0) {
-      READ_BITS_OR_RETURN(1, &w_facts->chroma_weight_flag);
+      READ_BOOL_OR_RETURN(&w_facts->chroma_weight_flag);
       if (w_facts->chroma_weight_flag) {
         for (int j = 0; j < 2; ++j) {
           READ_SE_OR_RETURN(&w_facts->chroma_weight[i][j]);
           IN_RANGE_OR_RETURN(w_facts->chroma_weight[i][j], -128, 127);
 
           READ_SE_OR_RETURN(&w_facts->chroma_offset[i][j]);
           IN_RANGE_OR_RETURN(w_facts->chroma_offset[i][j], -128, 127);
         }
       } else {
         for (int j = 0; j < 2; ++j) {
@@ skipping 32 matching lines @@
                                 &shdr->pred_weight_table_l1);
     if (res != kOk)
       return res;
   }
 
   return kOk;
 }
 
 H264Parser::Result H264Parser::ParseDecRefPicMarking(H264SliceHeader *shdr) {
   if (shdr->idr_pic_flag) {
-    READ_BITS_OR_RETURN(1, &shdr->no_output_of_prior_pics_flag);
-    READ_BITS_OR_RETURN(1, &shdr->long_term_reference_flag);
+    READ_BOOL_OR_RETURN(&shdr->no_output_of_prior_pics_flag);
+    READ_BOOL_OR_RETURN(&shdr->long_term_reference_flag);
   } else {
-    READ_BITS_OR_RETURN(1, &shdr->adaptive_ref_pic_marking_mode_flag);
+    READ_BOOL_OR_RETURN(&shdr->adaptive_ref_pic_marking_mode_flag);
 
     H264DecRefPicMarking* marking;
     if (shdr->adaptive_ref_pic_marking_mode_flag) {
       size_t i;
       for (i = 0; i < arraysize(shdr->ref_pic_marking); ++i) {
         marking = &shdr->ref_pic_marking[i];
 
         READ_UE_OR_RETURN(&marking->memory_mgmnt_control_operation);
         if (marking->memory_mgmnt_control_operation == 0)
           break;
@@ skipping 53 matching lines @@
   TRUE_OR_RETURN(sps);
 
   if (sps->separate_colour_plane_flag) {
     DVLOG(1) << "Interlaced streams not supported";
     return kUnsupportedStream;
   }
 
   READ_BITS_OR_RETURN(sps->log2_max_frame_num_minus4 + 4,
                       &shdr->frame_num);
   if (!sps->frame_mbs_only_flag) {
-    READ_BITS_OR_RETURN(1, &shdr->field_pic_flag);
+    READ_BOOL_OR_RETURN(&shdr->field_pic_flag);
     if (shdr->field_pic_flag) {
       DVLOG(1) << "Interlaced streams not supported";
       return kUnsupportedStream;
     }
   }
 
   if (shdr->idr_pic_flag)
     READ_UE_OR_RETURN(&shdr->idr_pic_id);
 
   if (sps->pic_order_cnt_type == 0) {
@@ skipping 10 matching lines @@
         !shdr->field_pic_flag)
       READ_SE_OR_RETURN(&shdr->delta_pic_order_cnt[1]);
   }
 
   if (pps->redundant_pic_cnt_present_flag) {
     READ_UE_OR_RETURN(&shdr->redundant_pic_cnt);
     TRUE_OR_RETURN(shdr->redundant_pic_cnt < 128);
   }
 
   if (shdr->IsBSlice())
-    READ_BITS_OR_RETURN(1, &shdr->direct_spatial_mv_pred_flag);
+    READ_BOOL_OR_RETURN(&shdr->direct_spatial_mv_pred_flag);
 
   if (shdr->IsPSlice() || shdr->IsSPSlice() || shdr->IsBSlice()) {
-    READ_BITS_OR_RETURN(1, &shdr->num_ref_idx_active_override_flag);
+    READ_BOOL_OR_RETURN(&shdr->num_ref_idx_active_override_flag);
     if (shdr->num_ref_idx_active_override_flag) {
       READ_UE_OR_RETURN(&shdr->num_ref_idx_l0_active_minus1);
       if (shdr->IsBSlice())
         READ_UE_OR_RETURN(&shdr->num_ref_idx_l1_active_minus1);
     } else {
       shdr->num_ref_idx_l0_active_minus1 =
             pps->num_ref_idx_l0_default_active_minus1;
       shdr->num_ref_idx_l1_active_minus1 =
             pps->num_ref_idx_l1_default_active_minus1;
     }
@@ skipping 30 matching lines @@
   if (pps->entropy_coding_mode_flag &&
       !shdr->IsISlice() && !shdr->IsSISlice()) {
     READ_UE_OR_RETURN(&shdr->cabac_init_idc);
     TRUE_OR_RETURN(shdr->cabac_init_idc < 3);
   }
 
   READ_SE_OR_RETURN(&shdr->slice_qp_delta);
 
   if (shdr->IsSPSlice() || shdr->IsSISlice()) {
     if (shdr->IsSPSlice())
-      READ_BITS_OR_RETURN(1, &shdr->sp_for_switch_flag);
+      READ_BOOL_OR_RETURN(&shdr->sp_for_switch_flag);
     READ_SE_OR_RETURN(&shdr->slice_qs_delta);
   }
 
   if (pps->deblocking_filter_control_present_flag) {
     READ_UE_OR_RETURN(&shdr->disable_deblocking_filter_idc);
     TRUE_OR_RETURN(shdr->disable_deblocking_filter_idc < 3);
 
     if (shdr->disable_deblocking_filter_idc != 1) {
       READ_SE_OR_RETURN(&shdr->slice_alpha_c0_offset_div2);
       IN_RANGE_OR_RETURN(shdr->slice_alpha_c0_offset_div2, -6, 6);
@@ skipping 30 matching lines @@
     READ_BITS_OR_RETURN(8, &byte);
   }
   sei_msg->payload_size += byte;
 
   DVLOG(4) << "Found SEI message type: " << sei_msg->type
            << " payload size: " << sei_msg->payload_size;
 
   switch (sei_msg->type) {
     case H264SEIMessage::kSEIRecoveryPoint:
       READ_UE_OR_RETURN(&sei_msg->recovery_point.recovery_frame_cnt);
-      READ_BITS_OR_RETURN(1, &sei_msg->recovery_point.exact_match_flag);
-      READ_BITS_OR_RETURN(1, &sei_msg->recovery_point.broken_link_flag);
+      READ_BOOL_OR_RETURN(&sei_msg->recovery_point.exact_match_flag);
+      READ_BOOL_OR_RETURN(&sei_msg->recovery_point.broken_link_flag);
       READ_BITS_OR_RETURN(2,
           &sei_msg->recovery_point.changing_slice_group_idc);
       break;
 
     default:
       DVLOG(4) << "Unsupported SEI message";
       break;
   }
 
   return kOk;
 }
 
 }  // namespace content