libvpx: Pull from upstream

source/libvpx/vp8/decoder/decodframe.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 741 matching lines @@
     }
     yv12_extend_frame_left_right_c(yv12_fb_new,
                                    eb_dst[0],
                                    eb_dst[1],
                                    eb_dst[2]);
 
     yv12_extend_frame_bottom_c(yv12_fb_new);
 
 }
 
-static unsigned int read_partition_size(const unsigned char *cx_size)
+static unsigned int read_partition_size(VP8D_COMP *pbi,
+                                        const unsigned char *cx_size)
 {
-    const unsigned int size =
-        cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16);
-    return size;
+    unsigned char temp[3];
+    if (pbi->decrypt_cb)
+    {
+        pbi->decrypt_cb(pbi->decrypt_state, cx_size, temp, 3);
+        cx_size = temp;
+    }
+    return cx_size[0] + (cx_size[1] << 8) + (cx_size[2] << 16);
 }
 
 static int read_is_valid(const unsigned char *start,
                          size_t               len,
                          const unsigned char *end)
 {
     return (start + len > start && start + len <= end);
 }
 
 static unsigned int read_available_partition_size(
@@ skipping 10 matching lines @@
     unsigned int partition_size = 0;
     ptrdiff_t bytes_left = fragment_end - fragment_start;
     /* Calculate the length of this partition. The last partition
      * size is implicit. If the partition size can't be read, then
      * either use the remaining data in the buffer (for EC mode)
      * or throw an error.
      */
     if (i < num_part - 1)
     {
         if (read_is_valid(partition_size_ptr, 3, first_fragment_end))
-            partition_size = read_partition_size(partition_size_ptr);
+            partition_size = read_partition_size(pbi, partition_size_ptr);
         else if (pbi->ec_active)
             partition_size = (unsigned int)bytes_left;
         else
             vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                                "Truncated partition size data");
     }
     else
         partition_size = (unsigned int)bytes_left;
 
     /* Validate the calculated partition length. If the buffer
@@ skipping 79 matching lines @@
         }
     }
 
     pbi->fragments.count = num_token_partitions + 1;
 
     for (partition_idx = 1; partition_idx < pbi->fragments.count; ++partition_idx)
     {
         if (vp8dx_start_decode(bool_decoder,
                                pbi->fragments.ptrs[partition_idx],
                                pbi->fragments.sizes[partition_idx],
-                               pbi->fragments.ptrs[0],
-                               pbi->decrypt_key))
+                               pbi->decrypt_cb, pbi->decrypt_state))
             vpx_internal_error(&pbi->common.error, VPX_CODEC_MEM_ERROR,
                                "Failed to allocate bool decoder %d",
                                partition_idx);
 
         bool_decoder++;
     }
 
 #if CONFIG_MULTITHREAD
     /* Clamp number of decoder threads */
     if (pbi->decoding_thread_count > num_token_partitions - 1)
@@ skipping 70 matching lines @@
         xd->fullpixel_mask = 0xfffffff8;
 
 }
 
 int vp8_decode_frame(VP8D_COMP *pbi)
 {
     vp8_reader *const bc = &pbi->mbc[8];
     VP8_COMMON *const pc = &pbi->common;
     MACROBLOCKD *const xd  = &pbi->mb;
     const unsigned char *data = pbi->fragments.ptrs[0];
-    const unsigned char *const origin = data;
     const unsigned char *data_end =  data + pbi->fragments.sizes[0];
     ptrdiff_t first_partition_length_in_bytes;
 
     int i, j, k, l;
     const int *const mb_feature_data_bits = vp8_mb_feature_data_bits;
     int corrupt_tokens = 0;
     int prev_independent_partitions = pbi->independent_partitions;
 
     YV12_BUFFER_CONFIG *yv12_fb_new = pbi->dec_fb_ref[INTRA_FRAME];
 
@@ skipping 12 matching lines @@
         /* Declare the missing frame as an inter frame since it will
            be handled as an inter frame when we have estimated its
            motion vectors. */
         pc->frame_type = INTER_FRAME;
         pc->version = 0;
         pc->show_frame = 1;
         first_partition_length_in_bytes = 0;
     }
     else
     {
-        const unsigned char data0 = decrypt_byte(data + 0, origin,
-                                                 pbi->decrypt_key);
-        const unsigned char data1 = decrypt_byte(data + 1, origin,
-                                                 pbi->decrypt_key);
-        const unsigned char data2 = decrypt_byte(data + 2, origin,
-                                                 pbi->decrypt_key);
+        unsigned char clear_buffer[10];
+        const unsigned char *clear = data;
+        if (pbi->decrypt_cb)
+        {
+            int n = data_end - data;
+            if (n > 10) n = 10;
+            pbi->decrypt_cb(pbi->decrypt_state, data, clear_buffer, n);
+            clear = clear_buffer;
+        }
 
-        pc->frame_type = (FRAME_TYPE)(data0 & 1);
-        pc->version = (data0 >> 1) & 7;
-        pc->show_frame = (data0 >> 4) & 1;
+        pc->frame_type = (FRAME_TYPE)(clear[0] & 1);
+        pc->version = (clear[0] >> 1) & 7;
+        pc->show_frame = (clear[0] >> 4) & 1;
         first_partition_length_in_bytes =
-            (data0 | (data1 << 8) | (data2 << 16)) >> 5;
+            (clear[0] | (clear[1] << 8) | (clear[2] << 16)) >> 5;
 
         if (!pbi->ec_active &&
             (data + first_partition_length_in_bytes > data_end
             || data + first_partition_length_in_bytes < data))
             vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME,
                                "Truncated packet or corrupt partition 0 length");
 
         data += 3;
+        clear += 3;
 
         vp8_setup_version(pc);
 
 
         if (pc->frame_type == KEY_FRAME)
         {
             /* vet via sync code */
             /* When error concealment is enabled we should only check the sync
              * code if we have enough bits available
              */
             if (!pbi->ec_active || data + 3 < data_end)
             {
-                const unsigned char data0 = decrypt_byte(data + 0, origin,
-                                                         pbi->decrypt_key);
-                const unsigned char data1 = decrypt_byte(data + 1, origin,
-                                                         pbi->decrypt_key);
-                const unsigned char data2 = decrypt_byte(data + 2, origin,
-                                                         pbi->decrypt_key);
-                if (data0 != 0x9d || data1 != 0x01 || data2 != 0x2a)
+                if (clear[0] != 0x9d || clear[1] != 0x01 || clear[2] != 0x2a)
                     vpx_internal_error(&pc->error, VPX_CODEC_UNSUP_BITSTREAM,
                                    "Invalid frame sync code");
             }
 
             /* If error concealment is enabled we should only parse the new size
              * if we have enough data. Otherwise we will end up with the wrong
              * size.
              */
             if (!pbi->ec_active || data + 6 < data_end)
             {
-                const unsigned char data3 = decrypt_byte(data + 3, origin,
-                                                         pbi->decrypt_key);
-                const unsigned char data4 = decrypt_byte(data + 4, origin,
-                                                         pbi->decrypt_key);
-                const unsigned char data5 = decrypt_byte(data + 5, origin,
-                                                         pbi->decrypt_key);
-                const unsigned char data6 = decrypt_byte(data + 6, origin,
-                                                         pbi->decrypt_key);
-
-                pc->Width = (data3 | (data4 << 8)) & 0x3fff;
-                pc->horiz_scale = data4 >> 6;
-                pc->Height = (data5 | (data6 << 8)) & 0x3fff;
-                pc->vert_scale = data6 >> 6;
+                pc->Width = (clear[3] | (clear[4] << 8)) & 0x3fff;
+                pc->horiz_scale = clear[4] >> 6;
+                pc->Height = (clear[5] | (clear[6] << 8)) & 0x3fff;
+                pc->vert_scale = clear[6] >> 6;
             }
             data += 7;
-
+            clear += 7;
         }
         else
         {
           vpx_memcpy(&xd->pre, yv12_fb_new, sizeof(YV12_BUFFER_CONFIG));
           vpx_memcpy(&xd->dst, yv12_fb_new, sizeof(YV12_BUFFER_CONFIG));
         }
     }
     if ((!pbi->decoded_key_frame && pc->frame_type != KEY_FRAME))
     {
         return -1;
     }
 
     init_frame(pbi);
 
-    if (vp8dx_start_decode(bc,
-                           data,
-                           (unsigned int)(data_end - data),
-                           pbi->fragments.ptrs[0],
-                           pbi->decrypt_key))
+    if (vp8dx_start_decode(bc, data, (unsigned int)(data_end - data),
+                           pbi->decrypt_cb, pbi->decrypt_state))
         vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR,
                            "Failed to allocate bool decoder 0");
     if (pc->frame_type == KEY_FRAME) {
         pc->clr_type    = (YUV_TYPE)vp8_read_bit(bc);
         pc->clamp_type  = (CLAMP_TYPE)vp8_read_bit(bc);
     }
 
     /* Is segmentation enabled */
     xd->segmentation_enabled = (unsigned char)vp8_read_bit(bc);
 
@@ skipping 291 matching lines @@
         FILE *f = fopen("decompressor.VP8", "ab");
         unsigned int size = pbi->bc2.pos + pbi->bc.pos + 8;
         fwrite((void *) &size, 4, 1, f);
         fwrite((void *) pbi->Source, size, 1, f);
         fclose(f);
     }
 #endif
 
     return 0;
 }