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

media/filters/vp9_parser.cc

Index: media/filters/vp9_parser.cc
diff --git a/media/filters/vp9_parser.cc b/media/filters/vp9_parser.cc
index 78d3361b44275f0fb8b3ccd6c1106ccd6dc216c1..e093d8c72dc48dddb3fe8a7db7610d95f4187c16 100644
--- a/media/filters/vp9_parser.cc
+++ b/media/filters/vp9_parser.cc
@@ -30,14 +30,28 @@ int GetMaxLog2TileCols(int sb64_cols) {
   return max_log2 - 1;
 }
 
+const int kMaxLoopFilter = 63;

[kcwu, 2015/09/02 10:09:45]

put before functions

[Pawel Osciak, 2015/09/08 06:43:49]

Hmm, I considered that, but didn't want to have two anonymous namespaces in the
file.

[kcwu, 2015/09/08 09:08:41]

Two anonymous namespaces? I mean put it at line 12.

[Pawel Osciak, 2015/09/08 11:08:08]

Ah, misunderstood then. Sure.

+
 }  // namespace
 
 namespace media {
 
-Vp9Parser::Vp9Parser() : stream_(nullptr), size_(0) {
+Vp9Parser::FrameInfo::FrameInfo(const uint8_t* ptr, off_t size)
+    : ptr(ptr), size(size) {}
+
+Vp9Parser::Vp9Parser() : stream_(nullptr), bytes_left_(0) {
+  memset(&segmentation_, 0, sizeof(segmentation_));
+  memset(&loop_filter_, 0, sizeof(loop_filter_));
   memset(&ref_slots_, 0, sizeof(ref_slots_));
 }
 
+void Vp9Parser::SetStream(const uint8_t* stream, off_t stream_size) {
+  DCHECK(stream);
+  stream_ = stream;
+  bytes_left_ = stream_size;
+  frames_.clear();
+}
+
 uint8_t Vp9Parser::ReadProfile() {
   uint8_t profile = 0;
 
@@ -142,7 +156,7 @@ void Vp9Parser::ReadDisplayFrameSize(Vp9FrameHeader* fhdr) {
 
 Vp9InterpFilter Vp9Parser::ReadInterpFilter() {
   if (reader_.ReadBool())
-    return Vp9InterpFilter::INTERP_FILTER_SELECT;
+    return Vp9InterpFilter::SWICHABLE;
 
   // The mapping table for next two bits.
   const Vp9InterpFilter table[] = {
@@ -152,24 +166,25 @@ Vp9InterpFilter Vp9Parser::ReadInterpFilter() {
   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);
+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::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);
       }
     }
   }
@@ -188,59 +203,60 @@ void Vp9Parser::ReadQuantization(Vp9QuantizationParams* quants) {
     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) {
@@ -258,8 +274,13 @@ void Vp9Parser::ReadTiles(Vp9FrameHeader* fhdr) {
     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)
@@ -295,8 +316,7 @@ bool Vp9Parser::ParseUncompressedHeader(Vp9FrameHeader* fhdr) {
     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);
@@ -320,13 +340,12 @@ bool Vp9Parser::ParseUncompressedHeader(Vp9FrameHeader* fhdr) {
         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);

[kcwu, 2015/08/31 09:58:34]

s/8/kVp9NumRefFrames/

[Pawel Osciak, 2015/09/08 06:43:48]

I intentionally used 8 explicitly to keep the convention of using values as per
spec. If refresh_flags was an array, I'd have used kVp9NumRefFrames (or rather,
arraysize).

+
       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);

[kcwu, 2015/08/31 09:58:34]

s/8/kVp9NumRefFrames/

 
       for (size_t i = 0; i < kVp9NumRefsPerFrame; i++) {
         fhdr->frame_refs[i] = reader_.ReadLiteral(kVp9NumRefFramesLog2);
@@ -351,9 +370,12 @@ bool Vp9Parser::ParseUncompressedHeader(Vp9FrameHeader* fhdr) {
 
   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);
 
@@ -369,32 +391,280 @@ bool Vp9Parser::ParseUncompressedHeader(Vp9FrameHeader* fhdr) {
   }
   fhdr->uncompressed_header_size = reader_.GetBytesRead();
 
+  UpdateSlots(fhdr);
+
+  SetupSegmentationDequant(fhdr->quant_params);

[kcwu, 2015/08/31 09:58:34]

Does these depend on UpdateSlots() ? If not, I'd prefer UpdateSlots() after
everything else.

[Pawel Osciak, 2015/09/08 06:43:48]

Done.

+  SetupLoopFilter();
+
   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(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_;
 
-  if (!ParseUncompressedHeader(fhdr))
+  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;

[kcwu, 2015/08/31 09:58:34]

should we check bytes_left == 0?

[Pawel Osciak, 2015/09/08 06:43:48]

We could, but I intentionally allow it, instead of failing to decode. It's not
specified whether all bytes before the index have to be used for frame data, and
if some bytes were left unused, it should not be an issue, apart from possibly
broken/corrupted stream.

 }
 
+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), kMaxLoopFilter)
+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