Add accelerated VP9 decode infrastructure and an implementation for VA-API.

media/filters/vp9_parser.cc

 // 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 {
 
+const int kMaxLoopFilterLevel = 63;
+
 // 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) {
+bool Vp9FrameHeader::IsKeyframe() const {
+  // When show_existing_frame is true, the frame header does not precede an
+  // actual frame to be decoded, so frame_type does not apply (and is not read
+  // from the stream).
+  return !show_existing_frame && frame_type == KEYFRAME;
+}
+
+Vp9Parser::FrameInfo::FrameInfo(const uint8_t* ptr, off_t size)
+    : ptr(ptr), size(size) {}
+
+Vp9Parser::Vp9Parser() {
+  Reset();
+}
+
+void Vp9Parser::SetStream(const uint8_t* stream, off_t stream_size) {
+  DCHECK(stream);
+  stream_ = stream;
+  bytes_left_ = stream_size;
+  frames_.clear();
+}
+
+void Vp9Parser::Reset() {
+  stream_ = nullptr;
+  bytes_left_ = 0;
+  frames_.clear();
+
+  memset(&segmentation_, 0, sizeof(segmentation_));
+  memset(&loop_filter_, 0, sizeof(loop_filter_));
   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())
@@ skipping 87 matching lines @@
     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;
+    return Vp9InterpFilter::SWICHABLE;
 
   // 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);
+void Vp9Parser::ReadLoopFilter() {
+  loop_filter_.filter_level = reader_.ReadLiteral(6);
+  loop_filter_.sharpness_level = reader_.ReadLiteral(3);
+  loop_filter_.mode_ref_delta_update = false;
 
-  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);
+  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::VP9_FRAME_MAX; 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);
+        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) {
+void Vp9Parser::ReadSegmentationMap() {
   for (size_t i = 0; i < Vp9Segmentation::kNumTreeProbs; i++) {
-    segment->tree_probs[i] =
+    segmentation_.tree_probs[i] =
         reader_.ReadBool() ? reader_.ReadLiteral(8) : kVp9MaxProb;
   }
 
   for (size_t i = 0; i < Vp9Segmentation::kNumPredictionProbs; i++)
-    segment->pred_probs[i] = kVp9MaxProb;
+    segmentation_.pred_probs[i] = kVp9MaxProb;
 
-  segment->temporal_update = reader_.ReadBool();
-  if (segment->temporal_update) {
+  segmentation_.temporal_update = reader_.ReadBool();
+  if (segmentation_.temporal_update) {
     for (size_t i = 0; i < Vp9Segmentation::kNumPredictionProbs; i++) {
       if (reader_.ReadBool())
-        segment->pred_probs[i] = reader_.ReadLiteral(8);
+        segmentation_.pred_probs[i] = reader_.ReadLiteral(8);
     }
   }
 }
 
-void Vp9Parser::ReadSegmentationData(Vp9Segmentation* segment) {
-  segment->abs_delta = reader_.ReadBool();
+void Vp9Parser::ReadSegmentationData() {
+  segmentation_.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++) {
+    for (size_t j = 0; j < Vp9Segmentation::SEG_LVL_MAX; j++) {
       int8_t data = 0;
-      segment->feature_enabled[i][j] = reader_.ReadBool();
-      if (segment->feature_enabled[i][j]) {
+      segmentation_.feature_enabled[i][j] = reader_.ReadBool();
+      if (segmentation_.feature_enabled[i][j]) {
         data = reader_.ReadLiteral(kFeatureDataBits[j]);
         if (kFeatureDataSigned[j])
           if (reader_.ReadBool())
             data = -data;
       }
-      segment->feature_data[i][j] = data;
+      segmentation_.feature_data[i][j] = data;
     }
   }
 }
 
-void Vp9Parser::ReadSegmentation(Vp9Segmentation* segment) {
-  segment->enabled = reader_.ReadBool();
+void Vp9Parser::ReadSegmentation() {
+  segmentation_.update_map = false;
+  segmentation_.update_data = false;
 
-  if (!segment->enabled) {
+  segmentation_.enabled = reader_.ReadBool();
+  if (!segmentation_.enabled)
     return;
-  }
 
-  segment->update_map = reader_.ReadBool();
-  if (segment->update_map)
-    ReadSegmentationMap(segment);
+  segmentation_.update_map = reader_.ReadBool();
+  if (segmentation_.update_map)
+    ReadSegmentationMap();
 
-  segment->update_data = reader_.ReadBool();
-  if (segment->update_data)
-    ReadSegmentationData(segment);
+  segmentation_.update_data = reader_.ReadBool();
+  if (segmentation_.update_data)
+    ReadSegmentationData();
 }
 
 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_);
+bool Vp9Parser::ParseUncompressedHeader(const uint8_t* stream,
+                                        off_t frame_size,
+                                        Vp9FrameHeader* fhdr) {
+  reader_.Initialize(stream, frame_size);
+
+  fhdr->data = stream;
+  fhdr->frame_size = frame_size;
 
   // frame marker
   if (reader_.ReadLiteral(2) != 0x2)
     return false;
 
   fhdr->profile = ReadProfile();
   if (fhdr->profile >= kVp9MaxProfile) {
     DVLOG(1) << "Unsupported bitstream profile";
     return false;
   }
@@ skipping 15 matching lines @@
   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;
+    fhdr->refresh_flags = 0xff;
 
     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();
+      fhdr->refresh_flags = reader_.ReadLiteral(8);
+
       ReadFrameSize(fhdr);
       ReadDisplayFrameSize(fhdr);
     } else {
-      for (size_t i = 0; i < kVp9NumRefFrames; i++)
-        fhdr->refresh_flag[i] = reader_.ReadBool();
+      fhdr->refresh_flags = reader_.ReadLiteral(8);
 
       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);
+  if (fhdr->IsKeyframe() || fhdr->intra_only)
+    SetupPastIndependence();
+
+  ReadLoopFilter();
   ReadQuantization(&fhdr->quant_params);
-  ReadSegmentation(&fhdr->segment);
+  ReadSegmentation();
 
   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();
 
+  SetupSegmentationDequant(fhdr->quant_params);
+  SetupLoopFilter();
+
+  UpdateSlots(fhdr);
+
   return true;
 }
 
 void Vp9Parser::UpdateSlots(const Vp9FrameHeader* fhdr) {
   for (size_t i = 0; i < kVp9NumRefFrames; i++) {
-    if (fhdr->refresh_flag[i]) {
+    if (fhdr->RefreshFlag(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;
+Vp9Parser::Result Vp9Parser::ParseNextFrame(Vp9FrameHeader* fhdr) {
+  if (frames_.empty()) {
+    // No frames to be decoded, if there is no more stream, request more.
+    if (!stream_)
+      return kEOStream;
+
+    // New stream to be parsed, parse it and fill frames_.
+    if (!ParseSuperframe()) {
+      DVLOG(1) << "Failed parsing superframes";
+      return kInvalidStream;
+    }
+  }
+
+  DCHECK(!frames_.empty());
+  FrameInfo frame_info = frames_.front();
+  frames_.pop_front();
+
   memset(fhdr, 0, sizeof(*fhdr));
-
-  if (!ParseUncompressedHeader(fhdr))
+  if (!ParseUncompressedHeader(frame_info.ptr, frame_info.size, fhdr))
+    return kInvalidStream;
+
+  return kOk;
+}
+
+bool Vp9Parser::ParseSuperframe() {
+  const uint8_t* stream = stream_;
+  off_t bytes_left = bytes_left_;
+
+  DCHECK(frames_.empty());
+
+  // Make sure we don't parse stream_ more than once.
+  stream_ = nullptr;
+  bytes_left_ = 0;
+
+  if (bytes_left < 1)
     return false;
 
-  UpdateSlots(fhdr);
+  // If this is a superframe, the last byte in the stream will contain the
+  // superframe marker. If not, the whole buffer contains a single frame.
+  uint8_t marker = *(stream + bytes_left - 1);
+  if ((marker & 0xe0) != 0xc0) {
+    frames_.push_back(FrameInfo(stream, bytes_left));
+    return true;
+  }
+
+  DVLOG(1) << "Parsing a superframe";
+
+  // The bytes immediately before the superframe marker constitute superframe
+  // index, which stores information about sizes of each frame in it.
+  // Calculate its size and set index_ptr to the beginning of it.
+  size_t num_frames = (marker & 0x7) + 1;
+  size_t mag = ((marker >> 3) & 0x3) + 1;
+  off_t index_size = 2 + mag * num_frames;
+
+  if (bytes_left < index_size)
+    return false;
+
+  const uint8_t* index_ptr = stream + bytes_left - index_size;
+  if (marker != *index_ptr)
+    return false;
+
+  ++index_ptr;
+  bytes_left -= index_size;
+
+  // Parse frame information contained in the index and add a pointer to and
+  // size of each frame to frames_.
+  for (size_t i = 0; i < num_frames; ++i) {
+    uint32_t size = 0;
+    for (size_t j = 0; j < mag; ++j) {
+      size |= *index_ptr << (j * 8);
+      ++index_ptr;
+    }
+
+    if (size > bytes_left) {
+      DVLOG(1) << "Not enough data in the buffer for frame " << i;
+      return false;
+    }
+
+    frames_.push_back(FrameInfo(stream, size));
+    stream += size;
+    bytes_left -= size;
+
+    DVLOG(1) << "Frame " << i << ", size: " << size;
+  }
 
   return true;
 }
 
+void Vp9Parser::ResetLoopfilter() {
+  loop_filter_.mode_ref_delta_enabled = true;
+  loop_filter_.mode_ref_delta_update = true;
+
+  const int8_t default_ref_deltas[] = {1, 0, -1, -1};
+  static_assert(
+      arraysize(default_ref_deltas) == arraysize(loop_filter_.ref_deltas),
+      "ref_deltas arrays of incorrect size");
+  for (size_t i = 0; i < arraysize(loop_filter_.ref_deltas); ++i)
+    loop_filter_.ref_deltas[i] = default_ref_deltas[i];
+
+  memset(loop_filter_.mode_deltas, 0, sizeof(loop_filter_.mode_deltas));
+}
+
+void Vp9Parser::SetupPastIndependence() {
+  memset(&segmentation_, 0, sizeof(segmentation_));
+  ResetLoopfilter();
+}
+
+const size_t QINDEX_RANGE = 256;
+const int16_t kDcQLookup[QINDEX_RANGE] = {
+  4,       8,    8,    9,   10,   11,   12,   12,
+  13,     14,   15,   16,   17,   18,   19,   19,
+  20,     21,   22,   23,   24,   25,   26,   26,
+  27,     28,   29,   30,   31,   32,   32,   33,
+  34,     35,   36,   37,   38,   38,   39,   40,
+  41,     42,   43,   43,   44,   45,   46,   47,
+  48,     48,   49,   50,   51,   52,   53,   53,
+  54,     55,   56,   57,   57,   58,   59,   60,
+  61,     62,   62,   63,   64,   65,   66,   66,
+  67,     68,   69,   70,   70,   71,   72,   73,
+  74,     74,   75,   76,   77,   78,   78,   79,
+  80,     81,   81,   82,   83,   84,   85,   85,
+  87,     88,   90,   92,   93,   95,   96,   98,
+  99,    101,  102,  104,  105,  107,  108,  110,
+  111,   113,  114,  116,  117,  118,  120,  121,
+  123,   125,  127,  129,  131,  134,  136,  138,
+  140,   142,  144,  146,  148,  150,  152,  154,
+  156,   158,  161,  164,  166,  169,  172,  174,
+  177,   180,  182,  185,  187,  190,  192,  195,
+  199,   202,  205,  208,  211,  214,  217,  220,
+  223,   226,  230,  233,  237,  240,  243,  247,
+  250,   253,  257,  261,  265,  269,  272,  276,
+  280,   284,  288,  292,  296,  300,  304,  309,
+  313,   317,  322,  326,  330,  335,  340,  344,
+  349,   354,  359,  364,  369,  374,  379,  384,
+  389,   395,  400,  406,  411,  417,  423,  429,
+  435,   441,  447,  454,  461,  467,  475,  482,
+  489,   497,  505,  513,  522,  530,  539,  549,
+  559,   569,  579,  590,  602,  614,  626,  640,
+  654,   668,  684,  700,  717,  736,  755,  775,
+  796,   819,  843,  869,  896,  925,  955,  988,
+  1022, 1058, 1098, 1139, 1184, 1232, 1282, 1336,
+};
+
+const int16_t kAcQLookup[QINDEX_RANGE] = {
+  4,       8,    9,   10,   11,   12,   13,   14,
+  15,     16,   17,   18,   19,   20,   21,   22,
+  23,     24,   25,   26,   27,   28,   29,   30,
+  31,     32,   33,   34,   35,   36,   37,   38,
+  39,     40,   41,   42,   43,   44,   45,   46,
+  47,     48,   49,   50,   51,   52,   53,   54,
+  55,     56,   57,   58,   59,   60,   61,   62,
+  63,     64,   65,   66,   67,   68,   69,   70,
+  71,     72,   73,   74,   75,   76,   77,   78,
+  79,     80,   81,   82,   83,   84,   85,   86,
+  87,     88,   89,   90,   91,   92,   93,   94,
+  95,     96,   97,   98,   99,  100,  101,  102,
+  104,   106,  108,  110,  112,  114,  116,  118,
+  120,   122,  124,  126,  128,  130,  132,  134,
+  136,   138,  140,  142,  144,  146,  148,  150,
+  152,   155,  158,  161,  164,  167,  170,  173,
+  176,   179,  182,  185,  188,  191,  194,  197,
+  200,   203,  207,  211,  215,  219,  223,  227,
+  231,   235,  239,  243,  247,  251,  255,  260,
+  265,   270,  275,  280,  285,  290,  295,  300,
+  305,   311,  317,  323,  329,  335,  341,  347,
+  353,   359,  366,  373,  380,  387,  394,  401,
+  408,   416,  424,  432,  440,  448,  456,  465,
+  474,   483,  492,  501,  510,  520,  530,  540,
+  550,   560,  571,  582,  593,  604,  615,  627,
+  639,   651,  663,  676,  689,  702,  715,  729,
+  743,   757,  771,  786,  801,  816,  832,  848,
+  864,   881,  898,  915,  933,  951,  969,  988,
+  1007, 1026, 1046, 1066, 1087, 1108, 1129, 1151,
+  1173, 1196, 1219, 1243, 1267, 1292, 1317, 1343,
+  1369, 1396, 1423, 1451, 1479, 1508, 1537, 1567,
+  1597, 1628, 1660, 1692, 1725, 1759, 1793, 1828,
+};
+
+static_assert(arraysize(kDcQLookup) == arraysize(kAcQLookup),
+              "quantizer lookup arrays of incorrect size");
+
+#define CLAMP_Q(q) std::min(std::max(0ul, q), arraysize(kDcQLookup) - 1)
+
+size_t Vp9Parser::GetQIndex(const Vp9QuantizationParams& quant,
+                            size_t segid) const {
+  if (segmentation_.FeatureEnabled(segid, Vp9Segmentation::SEG_LVL_ALT_Q)) {
+    int8_t feature_data =
+        segmentation_.FeatureData(segid, Vp9Segmentation::SEG_LVL_ALT_Q);
+    size_t q_index = segmentation_.abs_delta ? feature_data
+                                             : quant.base_qindex + feature_data;
+    return CLAMP_Q(q_index);
+  }
+
+  return quant.base_qindex;
+}
+
+void Vp9Parser::SetupSegmentationDequant(const Vp9QuantizationParams& quant) {
+  if (segmentation_.enabled) {
+    for (size_t i = 0; i < Vp9Segmentation::kNumSegments; ++i) {
+      const size_t q_index = GetQIndex(quant, i);
+      segmentation_.y_dequant[i][0] =
+          kDcQLookup[CLAMP_Q(q_index + quant.y_dc_delta)];
+      segmentation_.y_dequant[i][1] = kAcQLookup[CLAMP_Q(q_index)];
+      segmentation_.uv_dequant[i][0] =
+          kDcQLookup[CLAMP_Q(q_index + quant.uv_dc_delta)];
+      segmentation_.uv_dequant[i][1] =
+          kAcQLookup[CLAMP_Q(q_index + quant.uv_ac_delta)];
+    }
+  } else {
+    const size_t q_index = quant.base_qindex;
+    segmentation_.y_dequant[0][0] =
+        kDcQLookup[CLAMP_Q(q_index + quant.y_dc_delta)];
+    segmentation_.y_dequant[0][1] = kAcQLookup[CLAMP_Q(q_index)];
+    segmentation_.uv_dequant[0][0] =
+        kDcQLookup[CLAMP_Q(q_index + quant.uv_dc_delta)];
+    segmentation_.uv_dequant[0][1] =
+        kAcQLookup[CLAMP_Q(q_index + quant.uv_ac_delta)];
+  }
+}
+#undef CLAMP_Q
+
+#define CLAMP_LF(l) std::min(std::max(0, l), kMaxLoopFilterLevel)
+void Vp9Parser::SetupLoopFilter() {
+  if (!loop_filter_.filter_level)
+    return;
+
+  int scale = loop_filter_.filter_level < 32 ? 1 : 2;
+
+  for (size_t i = 0; i < Vp9Segmentation::kNumSegments; ++i) {
+    int level = loop_filter_.filter_level;
+
+    if (segmentation_.FeatureEnabled(i, Vp9Segmentation::SEG_LVL_ALT_LF)) {
+      int feature_data =
+          segmentation_.FeatureData(i, Vp9Segmentation::SEG_LVL_ALT_LF);
+      level = CLAMP_LF(segmentation_.abs_delta ? feature_data
+                                               : level + feature_data);
+    }
+
+    if (!loop_filter_.mode_ref_delta_enabled) {
+      memset(loop_filter_.lvl[i], level, sizeof(loop_filter_.lvl[i]));
+    } else {
+      loop_filter_.lvl[i][Vp9LoopFilter::VP9_FRAME_INTRA][0] = CLAMP_LF(
+          level +
+          loop_filter_.ref_deltas[Vp9LoopFilter::VP9_FRAME_INTRA] * scale);
+      loop_filter_.lvl[i][Vp9LoopFilter::VP9_FRAME_INTRA][1] = 0;
+
+      for (size_t type = Vp9LoopFilter::VP9_FRAME_LAST;
+           type < Vp9LoopFilter::VP9_FRAME_MAX; ++type) {
+        for (size_t mode = 0; mode < Vp9LoopFilter::kNumModeDeltas; ++mode) {
+          loop_filter_.lvl[i][type][mode] =
+              CLAMP_LF(level + loop_filter_.ref_deltas[type] * scale +
+                       loop_filter_.mode_deltas[mode] * scale);
+        }
+      }
+    }
+  }
+}
+#undef CLAMP_LF
+
 }  // namespace media