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 11 matching lines @@
 #include "vpx_mem/vpx_mem.h"
 #if CONFIG_ERROR_CONCEALMENT
 #include "decoder/error_concealment.h"
 #endif
 #include "decoder/decoderthreading.h"
 
 #define VP8_CAP_POSTPROC (CONFIG_POSTPROC ? VPX_CODEC_CAP_POSTPROC : 0)
 #define VP8_CAP_ERROR_CONCEALMENT (CONFIG_ERROR_CONCEALMENT ? \
                                     VPX_CODEC_CAP_ERROR_CONCEALMENT : 0)
 
-#define VP8_DECRYPT_KEY_SIZE 32
-
 typedef vpx_codec_stream_info_t  vp8_stream_info_t;
 
 /* Structures for handling memory allocations */
 typedef enum
 {
     VP8_SEG_ALG_PRIV     = 256,
     VP8_SEG_MAX
 } mem_seg_id_t;
 #define NELEMENTS(x) ((int)(sizeof(x)/sizeof(x[0])))
 
@@ skipping 24 matching lines @@
     int                     decoder_init;
     int                     postproc_cfg_set;
     vp8_postproc_cfg_t      postproc_cfg;
 #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
-    unsigned char           decrypt_key[VP8_DECRYPT_KEY_SIZE];
+    vp8_decrypt_cb          *decrypt_cb;
+    void                    *decrypt_state;
     vpx_image_t             img;
     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
@@ skipping 57 matching lines @@
             {
                 res = VPX_CODEC_MEM_ERROR;
                 break;
             }
         }
     }
 
     return res;
 }
 
-static const unsigned char fake_decrypt_key[VP8_DECRYPT_KEY_SIZE] = { 0 };
-
 static void vp8_init_ctx(vpx_codec_ctx_t *ctx, const vpx_codec_mmap_t *mmap)
 {
     int i;
 
     ctx->priv = mmap->base;
     ctx->priv->sz = sizeof(*ctx->priv);
     ctx->priv->iface = ctx->iface;
     ctx->priv->alg_priv = mmap->base;
 
     for (i = 0; i < NELEMENTS(ctx->priv->alg_priv->mmaps); i++)
         ctx->priv->alg_priv->mmaps[i].id = vp8_mem_req_segs[i].id;
 
     ctx->priv->alg_priv->mmaps[0] = *mmap;
     ctx->priv->alg_priv->si.sz = sizeof(ctx->priv->alg_priv->si);
-    memcpy(ctx->priv->alg_priv->decrypt_key, fake_decrypt_key,
-           VP8_DECRYPT_KEY_SIZE);
+    ctx->priv->alg_priv->decrypt_cb = NULL;
+    ctx->priv->alg_priv->decrypt_state = NULL;
     ctx->priv->init_flags = ctx->init_flags;
 
     if (ctx->config.dec)
     {
         /* Update the reference to the config structure to an internal copy. */
         ctx->priv->alg_priv->cfg = *ctx->config.dec;
         ctx->config.dec = &ctx->priv->alg_priv->cfg;
     }
 }
 
@@ skipping 78 matching lines @@
 
     for (i = NELEMENTS(ctx->mmaps) - 1; i >= 0; i--)
     {
         if (ctx->mmaps[i].dtor)
             ctx->mmaps[i].dtor(&ctx->mmaps[i]);
     }
 
     return VPX_CODEC_OK;
 }
 
-static vpx_codec_err_t vp8_peek_si_external(const uint8_t         *data,
-                                            unsigned int           data_sz,
+static vpx_codec_err_t vp8_peek_si_internal(const uint8_t *data,
+                                            unsigned int data_sz,
                                             vpx_codec_stream_info_t *si,
-                                            const unsigned char *decrypt_key)
+                                            vp8_decrypt_cb *decrypt_cb,
+                                            void *decrypt_state)
 {
     vpx_codec_err_t res = VPX_CODEC_OK;
 
     if(data + data_sz <= data)
     {
         res = VPX_CODEC_INVALID_PARAM;
     }
     else
     {
         /* Parse uncompresssed part of key frame header.
          * 3 bytes:- including version, frame type and an offset
          * 3 bytes:- sync code (0x9d, 0x01, 0x2a)
          * 4 bytes:- including image width and height in the lowest 14 bits
          *           of each 2-byte value.
          */
+        uint8_t clear_buffer[10];
+        const uint8_t *clear = data;
+        if (decrypt_cb)
+        {
+            int n = data_sz > 10 ? 10 : data_sz;
+            decrypt_cb(decrypt_state, data, clear_buffer, n);
+            clear = clear_buffer;
+        }
+        si->is_kf = 0;
 
-        const uint8_t data0 = decrypt_byte(data, data, decrypt_key);
-        si->is_kf = 0;
-        if (data_sz >= 10 && !(data0 & 0x01))  /* I-Frame */
+        if (data_sz >= 10 && !(clear[0] & 0x01))  /* I-Frame */
         {
-            const uint8_t data3 = decrypt_byte(data + 3, data, decrypt_key);
-            const uint8_t data4 = decrypt_byte(data + 4, data, decrypt_key);
-            const uint8_t data5 = decrypt_byte(data + 5, data, decrypt_key);
-            const uint8_t data6 = decrypt_byte(data + 6, data, decrypt_key);
-            const uint8_t data7 = decrypt_byte(data + 7, data, decrypt_key);
-            const uint8_t data8 = decrypt_byte(data + 8, data, decrypt_key);
-            const uint8_t data9 = decrypt_byte(data + 9, data, decrypt_key);
-
             si->is_kf = 1;
 
             /* vet via sync code */
-            if (data3 != 0x9d || data4 != 0x01 || data5 != 0x2a)
+            if (clear[3] != 0x9d || clear[4] != 0x01 || clear[5] != 0x2a)
                 res = VPX_CODEC_UNSUP_BITSTREAM;
 
-            si->w = (data6 | (data7 << 8)) & 0x3fff;
-            si->h = (data8 | (data9 << 8)) & 0x3fff;
+            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
         {
             res = VPX_CODEC_UNSUP_BITSTREAM;
         }
     }
 
     return res;
 }
 
 static vpx_codec_err_t vp8_peek_si(const uint8_t *data,
                                    unsigned int data_sz,
                                    vpx_codec_stream_info_t *si) {
-    return vp8_peek_si_external(data, data_sz, si, fake_decrypt_key);
+    return vp8_peek_si_internal(data, data_sz, si, NULL, NULL);
 }
 
 static vpx_codec_err_t vp8_get_si(vpx_codec_alg_priv_t    *ctx,
                                   vpx_codec_stream_info_t *si)
 {
 
     unsigned int sz;
 
     if (si->sz >= sizeof(vp8_stream_info_t))
         sz = sizeof(vp8_stream_info_t);
@@ skipping 108 matching lines @@
     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 = vp8_peek_si_external(ctx->fragments.ptrs[0],
-                               ctx->fragments.sizes[0],
-                               &ctx->si,
-                               ctx->decrypt_key);
+    res = vp8_peek_si_internal(ctx->fragments.ptrs[0], ctx->fragments.sizes[0],
+                               &ctx->si, ctx->decrypt_cb, ctx->decrypt_state);
 
     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 53 matching lines @@
             if (!ctx->postproc_cfg_set
                 && (ctx->base.init_flags & VPX_CODEC_USE_POSTPROC))
             {
                 ctx->postproc_cfg.post_proc_flag =
                     VP8_DEBLOCK | VP8_DEMACROBLOCK | VP8_MFQE;
                 ctx->postproc_cfg.deblocking_level = 4;
                 ctx->postproc_cfg.noise_level = 0;
             }
 
             res = vp8_create_decoder_instances(&ctx->yv12_frame_buffers, &oxcf);
-            ctx->yv12_frame_buffers.pbi[0]->decrypt_key = ctx->decrypt_key;
+            ctx->yv12_frame_buffers.pbi[0]->decrypt_cb = ctx->decrypt_cb;
+            ctx->yv12_frame_buffers.pbi[0]->decrypt_state = ctx->decrypt_state;
         }
 
         ctx->decoder_init = 1;
     }
 
     if (!res)
     {
         VP8D_COMP *pbi = ctx->yv12_frame_buffers.pbi[0];
         if(resolution_change)
         {
@@ skipping 403 matching lines @@
     {
         *corrupted = pbi->common.frame_to_show->corrupted;
 
         return VPX_CODEC_OK;
     }
     else
         return VPX_CODEC_INVALID_PARAM;
 
 }
 
+static vpx_codec_err_t vp8_set_decryptor(vpx_codec_alg_priv_t *ctx,
+                                         int ctrl_id,
+                                         va_list args)
+{
+    vp8_decrypt_init *init = va_arg(args, vp8_decrypt_init *);
 
-static vpx_codec_err_t vp8_set_decrypt_key(vpx_codec_alg_priv_t *ctx,
-                                           int ctr_id,
-                                           va_list args)
-{
-    const unsigned char *data = va_arg(args, const unsigned char *);
-    if (data == NULL) {
-        return VPX_CODEC_INVALID_PARAM;
+    if (init)
+    {
+        ctx->decrypt_cb = init->decrypt_cb;
+        ctx->decrypt_state = init->decrypt_state;
     }
-
-    memcpy(ctx->decrypt_key, data, VP8_DECRYPT_KEY_SIZE);
+    else
+    {
+        ctx->decrypt_cb = NULL;
+        ctx->decrypt_state = NULL;
+    }
     return VPX_CODEC_OK;
 }
 
 vpx_codec_ctrl_fn_map_t vp8_ctf_maps[] =
 {
     {VP8_SET_REFERENCE,             vp8_set_reference},
     {VP8_COPY_REFERENCE,            vp8_get_reference},
     {VP8_SET_POSTPROC,              vp8_set_postproc},
     {VP8_SET_DBG_COLOR_REF_FRAME,   vp8_set_dbg_options},
     {VP8_SET_DBG_COLOR_MB_MODES,    vp8_set_dbg_options},
     {VP8_SET_DBG_COLOR_B_MODES,     vp8_set_dbg_options},
     {VP8_SET_DBG_DISPLAY_MV,        vp8_set_dbg_options},
     {VP8D_GET_LAST_REF_UPDATES,     vp8_get_last_ref_updates},
     {VP8D_GET_FRAME_CORRUPTED,      vp8_get_frame_corrupted},
     {VP8D_GET_LAST_REF_USED,        vp8_get_last_ref_frame},
-    {VP8_SET_DECRYPT_KEY,           vp8_set_decrypt_key},
+    {VP8D_SET_DECRYPTOR,            vp8_set_decryptor},
     { -1, NULL},
 };
 
 
 #ifndef VERSION_STRING
 #define VERSION_STRING
 #endif
 CODEC_INTERFACE(vpx_codec_vp8_dx) =
 {
     "WebM Project VP8 Decoder" VERSION_STRING,
@@ skipping 14 matching lines @@
     },
     { /* encoder functions */
         NOT_IMPLEMENTED,
         NOT_IMPLEMENTED,
         NOT_IMPLEMENTED,
         NOT_IMPLEMENTED,
         NOT_IMPLEMENTED,
         NOT_IMPLEMENTED
     }
 };