libvpx: Pull from upstream

source/libvpx/webmdec.cc

 /*
  *  Copyright (c) 2013 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 45 matching lines @@
   rewind(vpx_ctx->file);
   reset(webm_ctx);
 }
 
 }  // namespace
 
 int file_is_webm(struct WebmInputContext *webm_ctx,
                  struct VpxInputContext *vpx_ctx) {
   mkvparser::MkvReader *const reader = new mkvparser::MkvReader(vpx_ctx->file);
   webm_ctx->reader = reader;
+  webm_ctx->reached_eos = 0;
 
   mkvparser::EBMLHeader header;
   long long pos = 0;
   if (header.Parse(reader, pos) < 0) {
     rewind_and_reset(webm_ctx, vpx_ctx);
     return 0;
   }
 
   mkvparser::Segment* segment;
   if (mkvparser::Segment::CreateInstance(reader, pos, segment)) {
@@ skipping 38 matching lines @@
 
   get_first_cluster(webm_ctx);
 
   return 1;
 }
 
 int webm_read_frame(struct WebmInputContext *webm_ctx,
                     uint8_t **buffer,
                     size_t *bytes_in_buffer,
                     size_t *buffer_size) {
+  // This check is needed for frame parallel decoding, in which case this
+  // function could be called even after it has reached end of input stream.
+  if (webm_ctx->reached_eos) {
+    return 1;
+  }
   mkvparser::Segment *const segment =
       reinterpret_cast<mkvparser::Segment*>(webm_ctx->segment);
   const mkvparser::Cluster* cluster =
       reinterpret_cast<const mkvparser::Cluster*>(webm_ctx->cluster);
   const mkvparser::Block *block =
       reinterpret_cast<const mkvparser::Block*>(webm_ctx->block);
   const mkvparser::BlockEntry *block_entry =
       reinterpret_cast<const mkvparser::BlockEntry*>(webm_ctx->block_entry);
   bool block_entry_eos = false;
   do {
     long status = 0;
     bool get_new_block = false;
     if (block_entry == NULL && !block_entry_eos) {
       status = cluster->GetFirst(block_entry);
       get_new_block = true;
     } else if (block_entry_eos || block_entry->EOS()) {
       cluster = segment->GetNext(cluster);
       if (cluster == NULL || cluster->EOS()) {
         *bytes_in_buffer = 0;
+        webm_ctx->reached_eos = 1;
         return 1;
       }
       status = cluster->GetFirst(block_entry);
       block_entry_eos = false;
       get_new_block = true;
     } else if (block == NULL ||
                webm_ctx->block_frame_index == block->GetFrameCount() ||
                block->GetTrackNumber() != webm_ctx->video_track_index) {
       status = cluster->GetNext(block_entry, block_entry);
       if (block_entry == NULL || block_entry->EOS()) {
@@ skipping 52 matching lines @@
   vpx_ctx->framerate.numerator = (i - 1) * 1000000;
   vpx_ctx->framerate.denominator =
       static_cast<int>(webm_ctx->timestamp_ns / 1000);
   delete[] buffer;
 
   get_first_cluster(webm_ctx);
   webm_ctx->block = NULL;
   webm_ctx->block_entry = NULL;
   webm_ctx->block_frame_index = 0;
   webm_ctx->timestamp_ns = 0;
+  webm_ctx->reached_eos = 0;
 
   return 0;
 }
 
 void webm_free(struct WebmInputContext *webm_ctx) {
   reset(webm_ctx);
 }