Initial import of Widevine Common Encryption DRM engine

Builds libwvmdrmengine.so, which is loaded by the new
MediaDrm APIs to support playback of Widevine/CENC
protected content.

Change-Id: I6f57dd37083dfd96c402cb9dd137c7d74edc8f1c

libwvdrmengine/cdm/core/src/string_conversions.cpp

@@ -0,0 +1,211 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+
+#include "string_conversions.h"
+
+#include <ctype.h>
+#include <iostream>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <vector>
+
+#include "log.h"
+
+namespace {
+// Helper for Base64SafeDecode()
+char B64ToBin(char inch) {
+  if (inch >= 'A' && inch <= 'Z') return inch - 'A';
+  if (inch >= 'a' && inch <= 'z') return inch - 'a' + 26;
+  if (inch >= '0' && inch <= '9') return inch - '0' + 52;
+  if (inch == '-') return 62;
+  // if (inch == '_')
+  return 63;
+}
+}
+
+namespace wvcdm {
+
+static bool CharToDigit(char ch, unsigned char* digit) {
+  if (ch >= '0' && ch <= '9') {
+    *digit = ch - '0';
+  } else {
+    ch = tolower(ch);
+    if ((ch >= 'a') && (ch <= 'f')) {
+      *digit = ch - 'a' + 10;
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+// converts an ascii hex string(2 bytes per digit) into a decimal byte string
+std::vector<uint8_t> a2b_hex(const std::string& byte) {
+  std::vector<uint8_t> array;
+  unsigned int count = byte.size();
+  if (count == 0 || (count % 2) != 0) {
+    LOGE("Invalid input size %u for string %s", count, byte.c_str());
+    return array;
+  }
+
+  for (unsigned int i = 0; i < count / 2; ++i) {
+    unsigned char msb = 0;  // most significant 4 bits
+    unsigned char lsb = 0;  // least significant 4 bits
+    if (!CharToDigit(byte[i * 2], &msb) ||
+        !CharToDigit(byte[i * 2 + 1], &lsb)) {
+      LOGE("Invalid hex value %c%c at index %d", byte[i*2], byte[i*2+1], i);
+      return array;
+    }
+    array.push_back((msb << 4) | lsb);
+  }
+  return array;
+}
+
+std::string a2bs_hex(const std::string& byte) {
+  std::vector<uint8_t> array = a2b_hex(byte);
+  return std::string(array.begin(), array.end());
+}
+
+std::string b2a_hex(const std::vector<uint8_t>& byte) {
+  return HexEncode(&byte[0], byte.size());
+}
+
+std::string b2a_hex(const std::string& byte) {
+  return HexEncode(reinterpret_cast<const uint8_t *>(byte.data()),
+                   byte.length());
+}
+
+// Filename-friendly base64 encoding (RFC4648).
+// This is the encoding required by GooglePlay for certain
+// license server transactions.  It is also used for logging
+// certain strings.
+std::string Base64SafeEncode(const std::vector<uint8_t>& bin_input) {
+  static const char kBase64Chars[] =
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+      "abcdefghijklmnopqrstuvwxyz"
+      "0123456789-_";
+  if (bin_input.empty()) {
+    return std::string();
+  }
+  int in_size = bin_input.size();
+  int rup = ((in_size % 3) != 0) ? 1 : 0;
+  int out_size = ((in_size * 4) / 3) + rup;
+  std::string b64_output(out_size, '\0');
+  int in_index = 0;
+  int out_index = 0;
+  unsigned long buffer;
+  unsigned char out_cc;
+  static const unsigned long kInMask = 0xff;
+  static const unsigned long kOutMask = 0x3f;
+
+  while (in_index < in_size) {
+    // up to 3 bytes (0..255) in
+    buffer = (bin_input.at(in_index) & kInMask);
+    buffer <<= 8;
+    buffer |= (++in_index >= in_size) ? 0 : (bin_input.at(in_index) & kInMask);
+    buffer <<= 8;
+    buffer |= (++in_index >= in_size) ? 0 : (bin_input.at(in_index) & kInMask);
+    ++in_index;
+    // up to 4 bytes (0..63) out
+    out_cc = (buffer >> 18) & kOutMask;
+    b64_output.at(out_index) = kBase64Chars[out_cc];
+    if (++out_index >= out_size)
+      break;
+    out_cc = (buffer >> 12) & kOutMask;
+    b64_output.at(out_index) = kBase64Chars[out_cc];
+    if (++out_index >= out_size)
+      break;
+    out_cc = (buffer >> 6) & kOutMask;
+    b64_output.at(out_index) = kBase64Chars[out_cc];
+    if (++out_index >= out_size)
+      break;
+    out_cc = buffer & kOutMask;
+    b64_output.at(out_index) = kBase64Chars[out_cc];
+    ++out_index;
+  }
+  return b64_output;
+}
+
+// Decode for Filename-friendly base64 encoding (RFC4648).
+// This is the encoding required by GooglePlay for certain
+// license server transactions.  It is also used for logging
+// certain strings.
+std::vector<uint8_t> Base64SafeDecode(const std::string& b64_input) {
+  if (b64_input.empty()) {
+    return std::vector<uint8_t>();
+  }
+  int in_size = b64_input.size();
+  // out_size should be an integral number of bytes, assuming correct encode
+  int out_size = ((in_size * 3) / 4);
+  std::vector<uint8_t> bin_output(out_size, '\0');
+  int in_index = 0;
+  int out_index = 0;
+  unsigned long buffer;
+  unsigned char out_cc;
+  static const unsigned long kOutMask = 0xff;
+
+  while (in_index < in_size) {
+    // up to 4 bytes (0..63) in
+    buffer = B64ToBin(b64_input.at(in_index));
+    buffer <<= 6;
+    buffer |= (++in_index >= in_size) ? 0 : B64ToBin(b64_input.at(in_index));
+    buffer <<= 6;
+    buffer |= (++in_index >= in_size) ? 0 : B64ToBin(b64_input.at(in_index));
+    buffer <<= 6;
+    buffer |= (++in_index >= in_size) ? 0 : B64ToBin(b64_input.at(in_index));
+    ++in_index;
+    // up to 3 bytes (0..255) out
+    out_cc = (buffer >> 16) & kOutMask;
+    bin_output.at(out_index) = out_cc;
+    if (++out_index >= out_size)
+      break;
+    out_cc = (buffer >> 8) & kOutMask;
+    bin_output.at(out_index) = out_cc;
+    if (++out_index >= out_size)
+      break;
+    out_cc = buffer & kOutMask;
+    bin_output.at(out_index) = out_cc;
+    ++out_index;
+  }
+  return bin_output;
+}
+
+std::string HexEncode(const uint8_t* in_buffer, unsigned int size) {
+  static const char kHexChars[] = "0123456789ABCDEF";
+
+  // Each input byte creates two output hex characters.
+  std::string out_buffer(size * 2, '\0');
+
+  for (unsigned int i = 0; i < size; ++i) {
+    char byte = in_buffer[i];
+    out_buffer[(i << 1)] = kHexChars[(byte >> 4) & 0xf];
+    out_buffer[(i << 1) + 1] = kHexChars[byte & 0xf];
+  }
+  return out_buffer;
+}
+
+std::string IntToString(int value) {
+  // log10(2) ~= 0.3 bytes needed per bit or per byte log10(2**8) ~= 2.4.
+  // So round up to allocate 3 output characters per byte, plus 1 for '-'.
+  const int kOutputBufSize = 3 * sizeof(int) + 1;
+  char buffer[kOutputBufSize];
+  memset(buffer, 0, kOutputBufSize);
+  snprintf(buffer, kOutputBufSize, "%d", value);
+
+  std::string out_string(buffer, sizeof(buffer));
+  return out_string;
+}
+
+std::string UintToString(unsigned int value) {
+  // log10(2) ~= 0.3 bytes needed per bit or per byte log10(2**8) ~= 2.4.
+  // So round up to allocate 3 output characters per byte.
+  const int kOutputBufSize = 3 * sizeof(unsigned int);
+  char buffer[kOutputBufSize];
+  memset(buffer, 0, kOutputBufSize);
+  snprintf(buffer, kOutputBufSize, "%u", value);
+
+  std::string out_string(buffer, sizeof(buffer));
+  return out_string;
+}
+
+};  // namespace wvcdm