media/filters/vp9_parser.cc - chromium/src.git - Git at Google

 // Copyright 2015 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 a VP9 bitstream parser.

 #include "media/filters/vp9_parser.h"

 #include "base/logging.h"

 namespace {

 // Helper function for Vp9Parser::ReadTiles. Defined as get_min_log2_tile_cols
 // in spec.
 int GetMinLog2TileCols(int sb64_cols) {
   const int kMaxTileWidthB64 = 64;
   int min_log2 = 0;
   while ((kMaxTileWidthB64 << min_log2) < sb64_cols)
     min_log2++;
   return min_log2;
 }

 // Helper function for Vp9Parser::ReadTiles. Defined as get_max_log2_tile_cols
 // in spec.
 int GetMaxLog2TileCols(int sb64_cols) {
   const int kMinTileWidthB64 = 4;
   int max_log2 = 1;
   while ((sb64_cols >> max_log2) >= kMinTileWidthB64)
     max_log2++;
   return max_log2 - 1;
 }

 }  // namespace

 namespace media {

 Vp9Parser::Vp9Parser() : stream_(nullptr), size_(0) {
   memset(&ref_slots_, 0, sizeof(ref_slots_));
 }

 uint8_t Vp9Parser::ReadProfile() {
   uint8_t profile = 0;

   // LSB first.
   if (reader_.ReadBool())
     profile |= 1;
   if (reader_.ReadBool())
     profile |= 2;
   if (profile > 2 && reader_.ReadBool())
     profile += 1;
   return profile;
 }

 bool Vp9Parser::VerifySyncCode() {
   const int kSyncCode = 0x498342;
   if (reader_.ReadLiteral(8 * 3) != kSyncCode) {
     DVLOG(1) << "Invalid frame sync code";
     return false;
   }
   return true;
 }

 bool Vp9Parser::ReadBitDepthColorSpaceSampling(Vp9FrameHeader* fhdr) {
   if (fhdr->profile == 2 || fhdr->profile == 3) {
     fhdr->bit_depth = reader_.ReadBool() ? 12 : 10;
   } else {
     fhdr->bit_depth = 8;
   }

   fhdr->color_space = static_cast<Vp9ColorSpace>(reader_.ReadLiteral(3));
   if (fhdr->color_space != Vp9ColorSpace::SRGB) {
     fhdr->yuv_range = reader_.ReadBool();
     if (fhdr->profile == 1 || fhdr->profile == 3) {
       fhdr->subsampling_x = reader_.ReadBool() ? 1 : 0;
       fhdr->subsampling_y = reader_.ReadBool() ? 1 : 0;
       if (fhdr->subsampling_x == 1 && fhdr->subsampling_y == 1) {
         DVLOG(1) << "4:2:0 color not supported in profile 1 or 3";
         return false;
       }
       bool reserved = reader_.ReadBool();
       if (reserved) {
         DVLOG(1) << "reserved bit set";
         return false;
       }
     } else {
       fhdr->subsampling_x = fhdr->subsampling_y = 1;
     }
   } else {
     if (fhdr->profile == 1 || fhdr->profile == 3) {
       fhdr->subsampling_x = fhdr->subsampling_y = 0;

       bool reserved = reader_.ReadBool();
       if (reserved) {
         DVLOG(1) << "reserved bit set";
         return false;
       }
     } else {
       DVLOG(1) << "4:4:4 color not supported in profile 0 or 2";
       return false;
     }
   }

   return true;
 }

 void Vp9Parser::ReadFrameSize(Vp9FrameHeader* fhdr) {
   fhdr->width = reader_.ReadLiteral(16) + 1;
   fhdr->height = reader_.ReadLiteral(16) + 1;
 }

 bool Vp9Parser::ReadFrameSizeFromRefs(Vp9FrameHeader* fhdr) {
   for (size_t i = 0; i < kVp9NumRefsPerFrame; i++) {
     if (reader_.ReadBool()) {
       fhdr->width = ref_slots_[i].width;
       fhdr->height = ref_slots_[i].height;

       const int kMaxDimension = 1 << 16;
       if (fhdr->width == 0 || fhdr->width > kMaxDimension ||
           fhdr->height == 0 || fhdr->height > kMaxDimension) {
         DVLOG(1) << "The size of reference frame is out of range: "
                  << ref_slots_[i].width << "," << ref_slots_[i].height;
         return false;
       }
       return true;
     }
   }

   fhdr->width = reader_.ReadLiteral(16) + 1;
   fhdr->height = reader_.ReadLiteral(16) + 1;
   return true;
 }

 void Vp9Parser::ReadDisplayFrameSize(Vp9FrameHeader* fhdr) {
   if (reader_.ReadBool()) {
     fhdr->display_width = reader_.ReadLiteral(16) + 1;
     fhdr->display_height = reader_.ReadLiteral(16) + 1;
   } else {
     fhdr->display_width = fhdr->width;
     fhdr->display_height = fhdr->height;
   }
 }

 Vp9InterpFilter Vp9Parser::ReadInterpFilter() {
   if (reader_.ReadBool())
     return Vp9InterpFilter::INTERP_FILTER_SELECT;

   // The mapping table for next two bits.
   const Vp9InterpFilter table[] = {
       Vp9InterpFilter::EIGHTTAP_SMOOTH, Vp9InterpFilter::EIGHTTAP,
       Vp9InterpFilter::EIGHTTAP_SHARP, Vp9InterpFilter::BILINEAR,
   };
   return table[reader_.ReadLiteral(2)];
 }

 void Vp9Parser::ReadLoopFilter(Vp9LoopFilter* loop_filter) {
   loop_filter->filter_level = reader_.ReadLiteral(6);
   loop_filter->sharpness_level = reader_.ReadLiteral(3);

   loop_filter->mode_ref_delta_enabled = reader_.ReadBool();
   if (loop_filter->mode_ref_delta_enabled) {
     loop_filter->mode_ref_delta_update = reader_.ReadBool();
     if (loop_filter->mode_ref_delta_update) {
       for (size_t i = 0; i < Vp9LoopFilter::kNumRefDeltas; i++) {
         loop_filter->update_ref_deltas[i] = reader_.ReadBool();
         if (loop_filter->update_ref_deltas[i])
           loop_filter->ref_deltas[i] = reader_.ReadSignedLiteral(6);
       }

       for (size_t i = 0; i < Vp9LoopFilter::kNumModeDeltas; i++) {
         loop_filter->update_mode_deltas[i] = reader_.ReadBool();
         if (loop_filter->update_mode_deltas[i])
           loop_filter->mode_deltas[i] = reader_.ReadLiteral(6);
       }
     }
   }
 }

 void Vp9Parser::ReadQuantization(Vp9QuantizationParams* quants) {
   quants->base_qindex = reader_.ReadLiteral(8);

   if (reader_.ReadBool())
     quants->y_dc_delta = reader_.ReadSignedLiteral(4);

   if (reader_.ReadBool())
     quants->uv_ac_delta = reader_.ReadSignedLiteral(4);

   if (reader_.ReadBool())
     quants->uv_dc_delta = reader_.ReadSignedLiteral(4);
 }

 void Vp9Parser::ReadSegmentationMap(Vp9Segmentation* segment) {
   for (size_t i = 0; i < Vp9Segmentation::kNumTreeProbs; i++) {
     segment->tree_probs[i] =
         reader_.ReadBool() ? reader_.ReadLiteral(8) : kVp9MaxProb;
   }

   for (size_t i = 0; i < Vp9Segmentation::kNumPredictionProbs; i++)
     segment->pred_probs[i] = kVp9MaxProb;

   segment->temporal_update = reader_.ReadBool();
   if (segment->temporal_update) {
     for (size_t i = 0; i < Vp9Segmentation::kNumPredictionProbs; i++) {
       if (reader_.ReadBool())
         segment->pred_probs[i] = reader_.ReadLiteral(8);
     }
   }
 }

 void Vp9Parser::ReadSegmentationData(Vp9Segmentation* segment) {
   segment->abs_delta = reader_.ReadBool();

   const int kFeatureDataBits[] = {7, 6, 2, 0};
   const bool kFeatureDataSigned[] = {true, true, false, false};

   for (size_t i = 0; i < Vp9Segmentation::kNumSegments; i++) {
     for (size_t j = 0; j < Vp9Segmentation::kNumFeatures; j++) {
       int8_t data = 0;
       segment->feature_enabled[i][j] = reader_.ReadBool();
       if (segment->feature_enabled[i][j]) {
         data = reader_.ReadLiteral(kFeatureDataBits[j]);
         if (kFeatureDataSigned[j])
           if (reader_.ReadBool())
             data = -data;
       }
       segment->feature_data[i][j] = data;
     }
   }
 }

 void Vp9Parser::ReadSegmentation(Vp9Segmentation* segment) {
   segment->enabled = reader_.ReadBool();

   if (!segment->enabled) {
     return;
   }

   segment->update_map = reader_.ReadBool();
   if (segment->update_map)
     ReadSegmentationMap(segment);

   segment->update_data = reader_.ReadBool();
   if (segment->update_data)
     ReadSegmentationData(segment);
 }

 void Vp9Parser::ReadTiles(Vp9FrameHeader* fhdr) {
   int sb64_cols = (fhdr->width + 63) / 64;

   int min_log2_tile_cols = GetMinLog2TileCols(sb64_cols);
   int max_log2_tile_cols = GetMaxLog2TileCols(sb64_cols);

   int max_ones = max_log2_tile_cols - min_log2_tile_cols;
   fhdr->log2_tile_cols = min_log2_tile_cols;
   while (max_ones-- && reader_.ReadBool())
     fhdr->log2_tile_cols++;

   if (reader_.ReadBool())
     fhdr->log2_tile_rows = reader_.ReadLiteral(2) - 1;
 }

 bool Vp9Parser::ParseUncompressedHeader(Vp9FrameHeader* fhdr) {
   reader_.Initialize(stream_, size_);

   // frame marker
   if (reader_.ReadLiteral(2) != 0x2)
     return false;

   fhdr->profile = ReadProfile();
   if (fhdr->profile >= kVp9MaxProfile) {
     DVLOG(1) << "Unsupported bitstream profile";
     return false;
   }

   fhdr->show_existing_frame = reader_.ReadBool();
   if (fhdr->show_existing_frame) {
     fhdr->frame_to_show = reader_.ReadLiteral(3);
     fhdr->show_frame = true;

     if (!reader_.IsValid()) {
       DVLOG(1) << "parser reads beyond the end of buffer";
       return false;
     }
     fhdr->uncompressed_header_size = reader_.GetBytesRead();
     return true;
   }

   fhdr->frame_type = static_cast<Vp9FrameHeader::FrameType>(reader_.ReadBool());
   fhdr->show_frame = reader_.ReadBool();
   fhdr->error_resilient_mode = reader_.ReadBool();

   if (fhdr->IsKeyframe()) {
     if (!VerifySyncCode())
       return false;

     if (!ReadBitDepthColorSpaceSampling(fhdr))
       return false;

     for (size_t i = 0; i < kVp9NumRefFrames; i++)
       fhdr->refresh_flag[i] = true;

     ReadFrameSize(fhdr);
     ReadDisplayFrameSize(fhdr);
   } else {
     if (!fhdr->show_frame)
       fhdr->intra_only = reader_.ReadBool();

     if (!fhdr->error_resilient_mode)
       fhdr->reset_context = reader_.ReadLiteral(2);

     if (fhdr->intra_only) {
       if (!VerifySyncCode())
         return false;

       if (fhdr->profile > 0) {
         if (!ReadBitDepthColorSpaceSampling(fhdr))
           return false;
       } else {
         fhdr->bit_depth = 8;
         fhdr->color_space = Vp9ColorSpace::BT_601;
         fhdr->subsampling_x = fhdr->subsampling_y = 1;
       }

       for (size_t i = 0; i < kVp9NumRefFrames; i++)
         fhdr->refresh_flag[i] = reader_.ReadBool();
       ReadFrameSize(fhdr);
       ReadDisplayFrameSize(fhdr);
     } else {
       for (size_t i = 0; i < kVp9NumRefFrames; i++)
         fhdr->refresh_flag[i] = reader_.ReadBool();

       for (size_t i = 0; i < kVp9NumRefsPerFrame; i++) {
         fhdr->frame_refs[i] = reader_.ReadLiteral(kVp9NumRefFramesLog2);
         fhdr->ref_sign_biases[i] = reader_.ReadBool();
       }

       if (!ReadFrameSizeFromRefs(fhdr))
         return false;
       ReadDisplayFrameSize(fhdr);

       fhdr->allow_high_precision_mv = reader_.ReadBool();
       fhdr->interp_filter = ReadInterpFilter();
     }
   }

   if (fhdr->error_resilient_mode) {
     fhdr->frame_parallel_decoding_mode = true;
   } else {
     fhdr->refresh_frame_context = reader_.ReadBool();
     fhdr->frame_parallel_decoding_mode = reader_.ReadBool();
   }

   fhdr->frame_context_idx = reader_.ReadLiteral(2);

   ReadLoopFilter(&fhdr->loop_filter);
   ReadQuantization(&fhdr->quant_params);
   ReadSegmentation(&fhdr->segment);

   ReadTiles(fhdr);

   fhdr->first_partition_size = reader_.ReadLiteral(16);
   if (fhdr->first_partition_size == 0) {
     DVLOG(1) << "invalid header size";
     return false;
   }

   if (!reader_.IsValid()) {
     DVLOG(1) << "parser reads beyond the end of buffer";
     return false;
   }
   fhdr->uncompressed_header_size = reader_.GetBytesRead();

   return true;
 }

 void Vp9Parser::UpdateSlots(const Vp9FrameHeader* fhdr) {
   for (size_t i = 0; i < kVp9NumRefFrames; i++) {
     if (fhdr->refresh_flag[i]) {
       ref_slots_[i].width = fhdr->width;
       ref_slots_[i].height = fhdr->height;
     }
   }
 }

 bool Vp9Parser::ParseFrame(const uint8_t* stream,
                            size_t frame_size,
                            Vp9FrameHeader* fhdr) {
   DCHECK(stream);
   stream_ = stream;
   size_ = frame_size;
   memset(fhdr, 0, sizeof(*fhdr));

   if (!ParseUncompressedHeader(fhdr))
     return false;

   UpdateSlots(fhdr);

   return true;
 }

 }  // namespace media
	// Copyright 2015 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 a VP9 bitstream parser.

	#include "media/filters/vp9_parser.h"

	#include "base/logging.h"

	namespace {

	// Helper function for Vp9Parser::ReadTiles. Defined as get_min_log2_tile_cols
	// in spec.
	int GetMinLog2TileCols(int sb64_cols) {
	const int kMaxTileWidthB64 = 64;
	int min_log2 = 0;
	while ((kMaxTileWidthB64 << min_log2) < sb64_cols)
	min_log2++;
	return min_log2;
	}

	// Helper function for Vp9Parser::ReadTiles. Defined as get_max_log2_tile_cols
	// in spec.
	int GetMaxLog2TileCols(int sb64_cols) {
	const int kMinTileWidthB64 = 4;
	int max_log2 = 1;
	while ((sb64_cols >> max_log2) >= kMinTileWidthB64)
	max_log2++;
	return max_log2 - 1;
	}

	} // namespace

	namespace media {

	Vp9Parser::Vp9Parser() : stream_(nullptr), size_(0) {
	memset(&ref_slots_, 0, sizeof(ref_slots_));
	}

	uint8_t Vp9Parser::ReadProfile() {
	uint8_t profile = 0;

	// LSB first.
	if (reader_.ReadBool())
	profile \|= 1;
	if (reader_.ReadBool())
	profile \|= 2;
	if (profile > 2 && reader_.ReadBool())
	profile += 1;
	return profile;
	}

	bool Vp9Parser::VerifySyncCode() {
	const int kSyncCode = 0x498342;
	if (reader_.ReadLiteral(8 * 3) != kSyncCode) {
	DVLOG(1) << "Invalid frame sync code";
	return false;
	}
	return true;
	}

	bool Vp9Parser::ReadBitDepthColorSpaceSampling(Vp9FrameHeader* fhdr) {
	if (fhdr->profile == 2 \|\| fhdr->profile == 3) {
	fhdr->bit_depth = reader_.ReadBool() ? 12 : 10;
	} else {
	fhdr->bit_depth = 8;
	}

	fhdr->color_space = static_cast<Vp9ColorSpace>(reader_.ReadLiteral(3));
	if (fhdr->color_space != Vp9ColorSpace::SRGB) {
	fhdr->yuv_range = reader_.ReadBool();
	if (fhdr->profile == 1 \|\| fhdr->profile == 3) {
	fhdr->subsampling_x = reader_.ReadBool() ? 1 : 0;
	fhdr->subsampling_y = reader_.ReadBool() ? 1 : 0;
	if (fhdr->subsampling_x == 1 && fhdr->subsampling_y == 1) {
	DVLOG(1) << "4:2:0 color not supported in profile 1 or 3";
	return false;
	}
	bool reserved = reader_.ReadBool();
	if (reserved) {
	DVLOG(1) << "reserved bit set";
	return false;
	}
	} else {
	fhdr->subsampling_x = fhdr->subsampling_y = 1;
	}
	} else {
	if (fhdr->profile == 1 \|\| fhdr->profile == 3) {
	fhdr->subsampling_x = fhdr->subsampling_y = 0;

	bool reserved = reader_.ReadBool();
	if (reserved) {
	DVLOG(1) << "reserved bit set";
	return false;
	}
	} else {
	DVLOG(1) << "4:4:4 color not supported in profile 0 or 2";
	return false;
	}
	}

	return true;
	}

	void Vp9Parser::ReadFrameSize(Vp9FrameHeader* fhdr) {
	fhdr->width = reader_.ReadLiteral(16) + 1;
	fhdr->height = reader_.ReadLiteral(16) + 1;
	}

	bool Vp9Parser::ReadFrameSizeFromRefs(Vp9FrameHeader* fhdr) {
	for (size_t i = 0; i < kVp9NumRefsPerFrame; i++) {
	if (reader_.ReadBool()) {
	fhdr->width = ref_slots_[i].width;
	fhdr->height = ref_slots_[i].height;

	const int kMaxDimension = 1 << 16;
	if (fhdr->width == 0 \|\| fhdr->width > kMaxDimension \|\|
	fhdr->height == 0 \|\| fhdr->height > kMaxDimension) {
	DVLOG(1) << "The size of reference frame is out of range: "
	<< ref_slots_[i].width << "," << ref_slots_[i].height;
	return false;
	}
	return true;
	}
	}

	fhdr->width = reader_.ReadLiteral(16) + 1;
	fhdr->height = reader_.ReadLiteral(16) + 1;
	return true;
	}

	void Vp9Parser::ReadDisplayFrameSize(Vp9FrameHeader* fhdr) {
	if (reader_.ReadBool()) {
	fhdr->display_width = reader_.ReadLiteral(16) + 1;
	fhdr->display_height = reader_.ReadLiteral(16) + 1;
	} else {
	fhdr->display_width = fhdr->width;
	fhdr->display_height = fhdr->height;
	}
	}

	Vp9InterpFilter Vp9Parser::ReadInterpFilter() {
	if (reader_.ReadBool())
	return Vp9InterpFilter::INTERP_FILTER_SELECT;

	// The mapping table for next two bits.
	const Vp9InterpFilter table[] = {
	Vp9InterpFilter::EIGHTTAP_SMOOTH, Vp9InterpFilter::EIGHTTAP,
	Vp9InterpFilter::EIGHTTAP_SHARP, Vp9InterpFilter::BILINEAR,
	};
	return table[reader_.ReadLiteral(2)];
	}

	void Vp9Parser::ReadLoopFilter(Vp9LoopFilter* loop_filter) {
	loop_filter->filter_level = reader_.ReadLiteral(6);
	loop_filter->sharpness_level = reader_.ReadLiteral(3);

	loop_filter->mode_ref_delta_enabled = reader_.ReadBool();
	if (loop_filter->mode_ref_delta_enabled) {
	loop_filter->mode_ref_delta_update = reader_.ReadBool();
	if (loop_filter->mode_ref_delta_update) {
	for (size_t i = 0; i < Vp9LoopFilter::kNumRefDeltas; i++) {
	loop_filter->update_ref_deltas[i] = reader_.ReadBool();
	if (loop_filter->update_ref_deltas[i])
	loop_filter->ref_deltas[i] = reader_.ReadSignedLiteral(6);
	}

	for (size_t i = 0; i < Vp9LoopFilter::kNumModeDeltas; i++) {
	loop_filter->update_mode_deltas[i] = reader_.ReadBool();
	if (loop_filter->update_mode_deltas[i])
	loop_filter->mode_deltas[i] = reader_.ReadLiteral(6);
	}
	}
	}
	}

	void Vp9Parser::ReadQuantization(Vp9QuantizationParams* quants) {
	quants->base_qindex = reader_.ReadLiteral(8);

	if (reader_.ReadBool())
	quants->y_dc_delta = reader_.ReadSignedLiteral(4);

	if (reader_.ReadBool())
	quants->uv_ac_delta = reader_.ReadSignedLiteral(4);

	if (reader_.ReadBool())
	quants->uv_dc_delta = reader_.ReadSignedLiteral(4);
	}

	void Vp9Parser::ReadSegmentationMap(Vp9Segmentation* segment) {
	for (size_t i = 0; i < Vp9Segmentation::kNumTreeProbs; i++) {
	segment->tree_probs[i] =
	reader_.ReadBool() ? reader_.ReadLiteral(8) : kVp9MaxProb;
	}

	for (size_t i = 0; i < Vp9Segmentation::kNumPredictionProbs; i++)
	segment->pred_probs[i] = kVp9MaxProb;

	segment->temporal_update = reader_.ReadBool();
	if (segment->temporal_update) {
	for (size_t i = 0; i < Vp9Segmentation::kNumPredictionProbs; i++) {
	if (reader_.ReadBool())
	segment->pred_probs[i] = reader_.ReadLiteral(8);
	}
	}
	}

	void Vp9Parser::ReadSegmentationData(Vp9Segmentation* segment) {
	segment->abs_delta = reader_.ReadBool();

	const int kFeatureDataBits[] = {7, 6, 2, 0};
	const bool kFeatureDataSigned[] = {true, true, false, false};

	for (size_t i = 0; i < Vp9Segmentation::kNumSegments; i++) {
	for (size_t j = 0; j < Vp9Segmentation::kNumFeatures; j++) {
	int8_t data = 0;
	segment->feature_enabled[i][j] = reader_.ReadBool();
	if (segment->feature_enabled[i][j]) {
	data = reader_.ReadLiteral(kFeatureDataBits[j]);
	if (kFeatureDataSigned[j])
	if (reader_.ReadBool())
	data = -data;
	}
	segment->feature_data[i][j] = data;
	}
	}
	}

	void Vp9Parser::ReadSegmentation(Vp9Segmentation* segment) {
	segment->enabled = reader_.ReadBool();

	if (!segment->enabled) {
	return;
	}

	segment->update_map = reader_.ReadBool();
	if (segment->update_map)
	ReadSegmentationMap(segment);

	segment->update_data = reader_.ReadBool();
	if (segment->update_data)
	ReadSegmentationData(segment);
	}

	void Vp9Parser::ReadTiles(Vp9FrameHeader* fhdr) {
	int sb64_cols = (fhdr->width + 63) / 64;

	int min_log2_tile_cols = GetMinLog2TileCols(sb64_cols);
	int max_log2_tile_cols = GetMaxLog2TileCols(sb64_cols);

	int max_ones = max_log2_tile_cols - min_log2_tile_cols;
	fhdr->log2_tile_cols = min_log2_tile_cols;
	while (max_ones-- && reader_.ReadBool())
	fhdr->log2_tile_cols++;

	if (reader_.ReadBool())
	fhdr->log2_tile_rows = reader_.ReadLiteral(2) - 1;
	}

	bool Vp9Parser::ParseUncompressedHeader(Vp9FrameHeader* fhdr) {
	reader_.Initialize(stream_, size_);

	// frame marker
	if (reader_.ReadLiteral(2) != 0x2)
	return false;

	fhdr->profile = ReadProfile();
	if (fhdr->profile >= kVp9MaxProfile) {
	DVLOG(1) << "Unsupported bitstream profile";
	return false;
	}

	fhdr->show_existing_frame = reader_.ReadBool();
	if (fhdr->show_existing_frame) {
	fhdr->frame_to_show = reader_.ReadLiteral(3);
	fhdr->show_frame = true;

	if (!reader_.IsValid()) {
	DVLOG(1) << "parser reads beyond the end of buffer";
	return false;
	}
	fhdr->uncompressed_header_size = reader_.GetBytesRead();
	return true;
	}

	fhdr->frame_type = static_cast<Vp9FrameHeader::FrameType>(reader_.ReadBool());
	fhdr->show_frame = reader_.ReadBool();
	fhdr->error_resilient_mode = reader_.ReadBool();

	if (fhdr->IsKeyframe()) {
	if (!VerifySyncCode())
	return false;

	if (!ReadBitDepthColorSpaceSampling(fhdr))
	return false;

	for (size_t i = 0; i < kVp9NumRefFrames; i++)
	fhdr->refresh_flag[i] = true;

	ReadFrameSize(fhdr);
	ReadDisplayFrameSize(fhdr);
	} else {
	if (!fhdr->show_frame)
	fhdr->intra_only = reader_.ReadBool();

	if (!fhdr->error_resilient_mode)
	fhdr->reset_context = reader_.ReadLiteral(2);

	if (fhdr->intra_only) {
	if (!VerifySyncCode())
	return false;

	if (fhdr->profile > 0) {
	if (!ReadBitDepthColorSpaceSampling(fhdr))
	return false;
	} else {
	fhdr->bit_depth = 8;
	fhdr->color_space = Vp9ColorSpace::BT_601;
	fhdr->subsampling_x = fhdr->subsampling_y = 1;
	}

	for (size_t i = 0; i < kVp9NumRefFrames; i++)
	fhdr->refresh_flag[i] = reader_.ReadBool();
	ReadFrameSize(fhdr);
	ReadDisplayFrameSize(fhdr);
	} else {
	for (size_t i = 0; i < kVp9NumRefFrames; i++)
	fhdr->refresh_flag[i] = reader_.ReadBool();

	for (size_t i = 0; i < kVp9NumRefsPerFrame; i++) {
	fhdr->frame_refs[i] = reader_.ReadLiteral(kVp9NumRefFramesLog2);
	fhdr->ref_sign_biases[i] = reader_.ReadBool();
	}

	if (!ReadFrameSizeFromRefs(fhdr))
	return false;
	ReadDisplayFrameSize(fhdr);

	fhdr->allow_high_precision_mv = reader_.ReadBool();
	fhdr->interp_filter = ReadInterpFilter();
	}
	}

	if (fhdr->error_resilient_mode) {
	fhdr->frame_parallel_decoding_mode = true;
	} else {
	fhdr->refresh_frame_context = reader_.ReadBool();
	fhdr->frame_parallel_decoding_mode = reader_.ReadBool();
	}

	fhdr->frame_context_idx = reader_.ReadLiteral(2);

	ReadLoopFilter(&fhdr->loop_filter);
	ReadQuantization(&fhdr->quant_params);
	ReadSegmentation(&fhdr->segment);

	ReadTiles(fhdr);

	fhdr->first_partition_size = reader_.ReadLiteral(16);
	if (fhdr->first_partition_size == 0) {
	DVLOG(1) << "invalid header size";
	return false;
	}

	if (!reader_.IsValid()) {
	DVLOG(1) << "parser reads beyond the end of buffer";
	return false;
	}
	fhdr->uncompressed_header_size = reader_.GetBytesRead();

	return true;
	}

	void Vp9Parser::UpdateSlots(const Vp9FrameHeader* fhdr) {
	for (size_t i = 0; i < kVp9NumRefFrames; i++) {
	if (fhdr->refresh_flag[i]) {
	ref_slots_[i].width = fhdr->width;
	ref_slots_[i].height = fhdr->height;
	}
	}
	}

	bool Vp9Parser::ParseFrame(const uint8_t* stream,
	size_t frame_size,
	Vp9FrameHeader* fhdr) {
	DCHECK(stream);
	stream_ = stream;
	size_ = frame_size;
	memset(fhdr, 0, sizeof(*fhdr));

	if (!ParseUncompressedHeader(fhdr))
	return false;

	UpdateSlots(fhdr);

	return true;
	}

	} // namespace media