libvpx: Pull from upstream

source/libvpx/vp8/vp8_dx_iface.c

 /*
  *  Copyright (c) 2010 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 42 matching lines @@
 #if CONFIG_POSTPROC_VISUALIZER
     unsigned int            dbg_postproc_flag;
     int                     dbg_color_ref_frame_flag;
     int                     dbg_color_mb_modes_flag;
     int                     dbg_color_b_modes_flag;
     int                     dbg_display_mv_flag;
 #endif
     vpx_decrypt_cb          decrypt_cb;
     void                    *decrypt_state;
     vpx_image_t             img;
-    int                     flushed;
     int                     img_setup;
     struct frame_buffers    yv12_frame_buffers;
     void                    *user_priv;
     FRAGMENT_DATA           fragments;
 };
 
 static unsigned long vp8_priv_sz(const vpx_codec_dec_cfg_t *si, vpx_codec_flags_t flags)
 {
     /* Although this declaration is constant, we can't use it in the requested
      * segments list because we want to define the requested segments list
      * before defining the private type (so that the number of memory maps is
      * known)
      */
     (void)si;
+    (void)flags;
     return sizeof(vpx_codec_alg_priv_t);
 }
 
 static void vp8_init_ctx(vpx_codec_ctx_t *ctx)
 {
     vpx_codec_alg_priv_t *priv =
         (vpx_codec_alg_priv_t *)vpx_calloc(1, sizeof(*priv));
 
     ctx->priv = (vpx_codec_priv_t *)priv;
     ctx->priv->init_flags = ctx->init_flags;
 
     priv->si.sz = sizeof(priv->si);
     priv->decrypt_cb = NULL;
     priv->decrypt_state = NULL;
-    priv->flushed = 0;
 
     if (ctx->config.dec)
     {
         /* Update the reference to the config structure to an internal copy. */
         priv->cfg = *ctx->config.dec;
         ctx->config.dec = &priv->cfg;
     }
 }
 
 static vpx_codec_err_t vp8_init(vpx_codec_ctx_t *ctx,
@@ skipping 79 matching lines @@
             clear = clear_buffer;
         }
         si->is_kf = 0;
 
         if (data_sz >= 10 && !(clear[0] & 0x01))  /* I-Frame */
         {
             si->is_kf = 1;
 
             /* vet via sync code */
             if (clear[3] != 0x9d || clear[4] != 0x01 || clear[5] != 0x2a)
-                res = VPX_CODEC_UNSUP_BITSTREAM;
+                return VPX_CODEC_UNSUP_BITSTREAM;
 
             si->w = (clear[6] | (clear[7] << 8)) & 0x3fff;
             si->h = (clear[8] | (clear[9] << 8)) & 0x3fff;
 
             /*printf("w=%d, h=%d\n", si->w, si->h);*/
             if (!(si->h | si->w))
                 res = VPX_CODEC_UNSUP_BITSTREAM;
         }
         else
         {
@@ skipping 97 matching lines @@
         ctx->fragments.count++;
         if (ctx->fragments.count > (1 << EIGHT_PARTITION) + 1)
         {
             ctx->fragments.count = 0;
             *res = VPX_CODEC_INVALID_PARAM;
             return -1;
         }
         return 0;
     }
 
+    if (!ctx->fragments.enabled && (data == NULL && data_sz == 0))
+    {
+        return 0;
+    }
+
     if (!ctx->fragments.enabled)
     {
         ctx->fragments.ptrs[0] = data;
         ctx->fragments.sizes[0] = data_sz;
         ctx->fragments.count = 1;
     }
 
     return 1;
 }
 
 static vpx_codec_err_t vp8_decode(vpx_codec_alg_priv_t  *ctx,
                                   const uint8_t         *data,
                                   unsigned int            data_sz,
                                   void                    *user_priv,
                                   long                    deadline)
 {
     vpx_codec_err_t res = VPX_CODEC_OK;
     unsigned int resolution_change = 0;
     unsigned int w, h;
 
-    if (data == NULL && data_sz == 0) {
-      ctx->flushed = 1;
-      return VPX_CODEC_OK;
+    if (!ctx->fragments.enabled && (data == NULL && data_sz == 0))
+    {
+        return 0;
     }
 
-    /* Reset flushed when receiving a valid frame */
-    ctx->flushed = 0;
-
     /* Update the input fragment data */
     if(update_fragments(ctx, data, data_sz, &res) <= 0)
         return res;
 
     /* Determine the stream parameters. Note that we rely on peek_si to
      * validate that we have a buffer that does not wrap around the top
      * of the heap.
      */
     w = ctx->si.w;
     h = ctx->si.h;
@@ skipping 46 matching lines @@
      * decrypt config between frames.
      */
     if (ctx->decoder_init) {
       ctx->yv12_frame_buffers.pbi[0]->decrypt_cb = ctx->decrypt_cb;
       ctx->yv12_frame_buffers.pbi[0]->decrypt_state = ctx->decrypt_state;
     }
 
     if (!res)
     {
         VP8D_COMP *pbi = ctx->yv12_frame_buffers.pbi[0];
-        if(resolution_change)
+        if (resolution_change)
         {
             VP8_COMMON *const pc = & pbi->common;
             MACROBLOCKD *const xd  = & pbi->mb;
 #if CONFIG_MULTITHREAD
             int i;
 #endif
             pc->Width = ctx->si.w;
             pc->Height = ctx->si.h;
             {
                 int prev_mb_rows = pc->mb_rows;
@@ skipping 225 matching lines @@
     if (data)
     {
         ctx->postproc_cfg_set = 1;
         ctx->postproc_cfg = *((vp8_postproc_cfg_t *)data);
         return VPX_CODEC_OK;
     }
     else
         return VPX_CODEC_INVALID_PARAM;
 
 #else
+    (void)ctx;
+    (void)args;
     return VPX_CODEC_INCAPABLE;
 #endif
 }
 
 
 static vpx_codec_err_t vp8_set_dbg_color_ref_frame(vpx_codec_alg_priv_t *ctx,
                                                    va_list args) {
 #if CONFIG_POSTPROC_VISUALIZER && CONFIG_POSTPROC
   ctx->dbg_color_ref_frame_flag = va_arg(args, int);
   return VPX_CODEC_OK;
@@ skipping 157 matching lines @@
     { /* encoder functions */
         0,
         NULL,
         NULL,
         NULL,
         NULL,
         NULL,
         NULL
     }
 };