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 59 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_image_t             img;
     int                     img_setup;
     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;
@@ skipping 118 matching lines @@
         mmap.sz = sizeof(vpx_codec_alg_priv_t);
         mmap.align = vp8_mem_req_segs[0].align;
         mmap.flags = vp8_mem_req_segs[0].flags;
 
         res = vp8_mmap_alloc(&mmap);
 
         if (!res)
         {
             vp8_init_ctx(ctx, &mmap);
 
+            /* initialize number of fragments to zero */
+            ctx->priv->alg_priv->fragments.count = 0;
+            /* is input fragments enabled? */
+            ctx->priv->alg_priv->fragments.enabled =
+                    (ctx->priv->alg_priv->base.init_flags &
+                        VPX_CODEC_USE_INPUT_FRAGMENTS);
+
             ctx->priv->alg_priv->defer_alloc = 1;
             /*post processing level initialized to do nothing */
         }
     }
 
     return res;
 }
 
 static vpx_codec_err_t vp8_destroy(vpx_codec_alg_priv_t *ctx)
 {
@@ skipping 108 matching lines @@
     img->stride[VPX_PLANE_U] = yv12->uv_stride;
     img->stride[VPX_PLANE_V] = yv12->uv_stride;
     img->stride[VPX_PLANE_ALPHA] = yv12->y_stride;
     img->bps = 12;
     img->user_priv = user_priv;
     img->img_data = yv12->buffer_alloc;
     img->img_data_owner = 0;
     img->self_allocd = 0;
 }
 
+static int
+update_fragments(vpx_codec_alg_priv_t  *ctx,
+                 const uint8_t         *data,
+                 unsigned int           data_sz,
+                 vpx_codec_err_t       *res)
+{
+    *res = VPX_CODEC_OK;
+
+    if (ctx->fragments.count == 0)
+    {
+        /* New frame, reset fragment pointers and sizes */
+        vpx_memset((void*)ctx->fragments.ptrs, 0, sizeof(ctx->fragments.ptrs));
+        vpx_memset(ctx->fragments.sizes, 0, sizeof(ctx->fragments.sizes));
+    }
+    if (ctx->fragments.enabled && !(data == NULL && data_sz == 0))
+    {
+        /* Store a pointer to this fragment and return. We haven't
+         * received the complete frame yet, so we will wait with decoding.
+         */
+        ctx->fragments.ptrs[ctx->fragments.count] = data;
+        ctx->fragments.sizes[ctx->fragments.count] = data_sz;
+        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)
+    {
+        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;
 
+
+    /* 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;
 
-    res = ctx->base.iface->dec.peek_si(data, data_sz, &ctx->si);
+    res = ctx->base.iface->dec.peek_si(ctx->fragments.ptrs[0],
+                                       ctx->fragments.sizes[0], &ctx->si);
 
     if((res == VPX_CODEC_UNSUP_BITSTREAM) && !ctx->si.is_kf)
     {
         /* the peek function returns an error for non keyframes, however for
          * this case, it is not an error */
         res = VPX_CODEC_OK;
     }
 
     if(!ctx->decoder_init && !ctx->si.is_kf)
         res = VPX_CODEC_UNSUP_BITSTREAM;
@@ skipping 40 matching lines @@
             VP8D_CONFIG oxcf;
             struct VP8D_COMP* optr;
 
             oxcf.Width = ctx->si.w;
             oxcf.Height = ctx->si.h;
             oxcf.Version = 9;
             oxcf.postprocess = 0;
             oxcf.max_threads = ctx->cfg.threads;
             oxcf.error_concealment =
                     (ctx->base.init_flags & VPX_CODEC_USE_ERROR_CONCEALMENT);
-            oxcf.input_fragments =
-                    (ctx->base.init_flags & VPX_CODEC_USE_INPUT_FRAGMENTS);
 
             optr = vp8dx_create_decompressor(&oxcf);
 
             /* If postprocessing was enabled by the application and a
              * configuration has not been provided, default it.
              */
             if (!ctx->postproc_cfg_set
                 && (ctx->base.init_flags & VPX_CODEC_USE_POSTPROC))
             {
                 ctx->postproc_cfg.post_proc_flag =
@@ skipping 101 matching lines @@
                 (void)prev_mb_rows;
 #endif
             }
 
             pbi->common.error.setjmp = 0;
 
             /* required to get past the first get_free_fb() call */
             ctx->pbi->common.fb_idx_ref_cnt[0] = 0;
         }
 
+        /* update the pbi fragment data */
+        ctx->pbi->num_fragments = ctx->fragments.count;
+        ctx->pbi->input_fragments = ctx->fragments.enabled;
+        vpx_memcpy(ctx->pbi->fragments, ctx->fragments.ptrs,
+                   sizeof(ctx->fragments.ptrs));
+        vpx_memcpy(ctx->pbi->fragment_sizes, ctx->fragments.sizes,
+                   sizeof(ctx->fragments.sizes));
+
+
         ctx->user_priv = user_priv;
         if (vp8dx_receive_compressed_data(ctx->pbi, data_sz, data, deadline))
         {
             VP8D_COMP *pbi = (VP8D_COMP *)ctx->pbi;
             res = update_error_state(ctx, &pbi->common.error);
         }
+
+        /* get ready for the next series of fragments */
+        ctx->fragments.count = 0;
     }
 
     return res;
 }
 
 static vpx_image_t *vp8_get_frame(vpx_codec_alg_priv_t  *ctx,
                                   vpx_codec_iter_t      *iter)
 {
     vpx_image_t *img = NULL;
 
@@ skipping 330 matching lines @@
     },
     { /* encoder functions */
         NOT_IMPLEMENTED,
         NOT_IMPLEMENTED,
         NOT_IMPLEMENTED,
         NOT_IMPLEMENTED,
         NOT_IMPLEMENTED,
         NOT_IMPLEMENTED
     }
 };