libvpx: Pull from upstream

source/libvpx/third_party/nestegg/src/nestegg.c

 /*
  * Copyright © 2010 Mozilla Foundation
  *
  * This program is made available under an ISC-style license.  See the
  * accompanying file LICENSE for details.
  */
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ skipping 676 matching lines @@
   else
     *val = value.d;
   return 1;
 }
 
 static int
 ne_read_string(nestegg * ctx, char ** val, uint64_t length)
 {
   char * str;
   int r;
+  const size_t alloc_size = (size_t)length + 1;
 
   if (length == 0 || length > LIMIT_STRING)
     return -1;
-  str = ne_pool_alloc(length + 1, ctx->alloc_pool);
-  r = ne_io_read(ctx->io, (unsigned char *) str, length);
+  str = ne_pool_alloc(alloc_size, ctx->alloc_pool);
+  r = ne_io_read(ctx->io, (unsigned char *) str, alloc_size - 1);
   if (r != 1)
     return r;
-  str[length] = '\0';
+  str[alloc_size - 1] = '\0';
   *val = str;
   return 1;
 }
 
 static int
 ne_read_binary(nestegg * ctx, struct ebml_binary * val, uint64_t length)
 {
   if (length == 0 || length > LIMIT_BINARY)
     return -1;
-  val->data = ne_pool_alloc(length, ctx->alloc_pool);
-  val->length = length;
-  return ne_io_read(ctx->io, val->data, length);
+  val->length = (size_t)length;
+  val->data = ne_pool_alloc(val->length, ctx->alloc_pool);
+  return ne_io_read(ctx->io, val->data, val->length);
 }
 
 static int
 ne_get_uint(struct ebml_type type, uint64_t * value)
 {
   if (!type.read)
     return -1;
 
   assert(type.type == TYPE_UINT);
 
@@ skipping 309 matching lines @@
         }
       }
 
       if (element->type == TYPE_MASTER) {
         if (element->flags & DESC_FLAG_MULTI)
           ne_read_master(ctx, element);
         else
           ne_read_single_master(ctx, element);
         continue;
       } else {
-        r = ne_read_simple(ctx, element, size);
+        r = ne_read_simple(ctx, element, (size_t)size);
         if (r < 0)
           break;
       }
     } else if (ne_is_ancestor_element(id, ctx->ancestor->previous)) {
       ctx->log(ctx, NESTEGG_LOG_DEBUG, "parent element %llx", id);
       if (top_level && ctx->ancestor->node == top_level) {
         ctx->log(ctx, NESTEGG_LOG_DEBUG, "*** parse about to back up past top_level");
         r = 1;
         break;
       }
       ne_ctx_pop(ctx);
     } else {
       r = ne_read_element(ctx, &id, &size);
       if (r != 1)
         break;
 
       if (id != ID_VOID && id != ID_CRC32)
         ctx->log(ctx, NESTEGG_LOG_DEBUG, "unknown element %llx", id);
-      r = ne_io_read_skip(ctx->io, size);
+      r = ne_io_read_skip(ctx->io, (size_t)size);
       if (r != 1)
         break;
     }
   }
 
   if (r != 1)
     while (ctx->ancestor)
       ne_ctx_pop(ctx);
 
   return r;
@@ skipping 68 matching lines @@
 ne_read_ebml_lacing(nestegg_io * io, size_t block, size_t * read, uint64_t n, uint64_t * sizes)
 {
   int r;
   uint64_t lace, sum, length;
   int64_t slace;
   size_t i = 0;
 
   r = ne_read_vint(io, &lace, &length);
   if (r != 1)
     return r;
-  *read += length;
+  assert(length <= 8);
+  *read += (size_t)length;
 
   sizes[i] = lace;
   sum = sizes[i];
 
   i += 1;
   n -= 1;
 
   while (--n) {
     r = ne_read_svint(io, &slace, &length);
     if (r != 1)
       return r;
-    *read += length;
+    assert(length <= 8);
+    *read += (size_t)length;
     sizes[i] = sizes[i - 1] + slace;
     sum += sizes[i];
     i += 1;
   }
 
   if (*read + sum > block)
     return -1;
 
   /* Last frame is the remainder of the block. */
   sizes[i] = block - *read - sum;
@@ skipping 79 matching lines @@
   if (block_size > LIMIT_BLOCK)
     return -1;
 
   r = ne_read_vint(ctx->io, &track_number, &length);
   if (r != 1)
     return r;
 
   if (track_number == 0 || (unsigned int)track_number != track_number)
     return -1;
 
-  consumed += length;
+  assert(length <= 8);
+  consumed += (size_t)length;
 
   r = ne_read_int(ctx->io, &timecode, 2);
   if (r != 1)
     return r;
 
   consumed += 2;
 
   r = ne_read_uint(ctx->io, &flags, 1);
   if (r != 1)
     return r;
@@ skipping 23 matching lines @@
   if (frames > 256)
     return -1;
 
   switch (lacing) {
   case LACING_NONE:
     frame_sizes[0] = block_size - consumed;
     break;
   case LACING_XIPH:
     if (frames == 1)
       return -1;
-    r = ne_read_xiph_lacing(ctx->io, block_size, &consumed, frames, frame_sizes);
+    r = ne_read_xiph_lacing(ctx->io, (size_t)block_size, &consumed, frames, frame_sizes);
     if (r != 1)
       return r;
     break;
   case LACING_FIXED:
     if ((block_size - consumed) % frames)
       return -1;
     for (i = 0; i < frames; ++i)
       frame_sizes[i] = (block_size - consumed) / frames;
     break;
   case LACING_EBML:
     if (frames == 1)
       return -1;
-    r = ne_read_ebml_lacing(ctx->io, block_size, &consumed, frames, frame_sizes);
+    r = ne_read_ebml_lacing(ctx->io, (size_t)block_size, &consumed, frames, frame_sizes);
     if (r != 1)
       return r;
     break;
   }
 
   /* Sanity check unlaced frame sizes against total block size. */
   total = consumed;
   for (i = 0; i < frames; ++i)
     total += frame_sizes[i];
   if (total > block_size)
@@ skipping 24 matching lines @@
   ctx->log(ctx, NESTEGG_LOG_DEBUG, "%sblock t %lld pts %f f %llx frames: %llu",
            block_id == ID_BLOCK ? "" : "simple", pkt->track, pkt->timecode / 1e9, flags, frames);
 
   last = NULL;
   for (i = 0; i < frames; ++i) {
     if (frame_sizes[i] > LIMIT_FRAME) {
       nestegg_free_packet(pkt);
       return -1;
     }
     f = ne_alloc(sizeof(*f));
-    f->data = ne_alloc(frame_sizes[i]);
-    f->length = frame_sizes[i];
-    r = ne_io_read(ctx->io, f->data, frame_sizes[i]);
+    f->length = (size_t)frame_sizes[i];
+    f->data = ne_alloc(f->length);
+    r = ne_io_read(ctx->io, f->data, f->length);
     if (r != 1) {
       free(f->data);
       free(f);
       nestegg_free_packet(pkt);
       return -1;
     }
 
     if (!last)
       pkt->frame = f;
     else
@@ skipping 18 matching lines @@
   if (r != 1)
     return r;
 
   if (id != ID_DISCARD_PADDING)
     return 1;
 
   element = ne_find_element(id, ctx->ancestor->node);
   if (!element)
     return 1;
 
-  r = ne_read_simple(ctx, element, size);
+  assert((size_t)size == size);
+  r = ne_read_simple(ctx, element, (size_t)size);
   if (r != 1)
     return r;
   storage = (struct ebml_type *) (ctx->ancestor->data + element->offset);
   pkt->discard_padding = storage->v.i;
 
   return 1;
 }
 
 
 static uint64_t
@@ skipping 173 matching lines @@
   size_t length;
   int64_t offset;
 };
 
 static int
 ne_buffer_read(void * buffer, size_t length, void * user_data)
 {
   struct sniff_buffer * sb = user_data;
 
   int rv = 1;
-  size_t available = sb->length - sb->offset;
+  size_t available = sb->length - (size_t)sb->offset;
 
   if (available < length)
     return 0;
 
   memcpy(buffer, sb->buffer + sb->offset, length);
   sb->offset += length;
 
   return rv;
 }
 
@@ skipping 453 matching lines @@
         i += 1;
       }
       sizes[i] = codec_private.length - total - (p - codec_private.data);
 
       for (i = 0; i < item; ++i) {
         if (sizes[i] > LIMIT_FRAME)
           return -1;
         p += sizes[i];
       }
       *data = p;
-      *length = sizes[item];
+      *length = (size_t)sizes[item];
   } else {
     *data = codec_private.data;
     *length = codec_private.length;
   }
 
   return 0;
 }
 
 int
 nestegg_track_video_params(nestegg * ctx, unsigned int track,
@@ skipping 221 matching lines @@
   user_data.length = length;
   user_data.offset = 0;
 
   io.read = ne_buffer_read;
   io.seek = ne_buffer_seek;
   io.tell = ne_buffer_tell;
   io.userdata = &user_data;
   return ne_match_webm(io, length);
 }