Ejemplo n.º 1
0
static int inflateToFileForSVM(int outFd, int inFd, size_t uncompLen, size_t compLen)
{
    void* olddex = malloc(MAX_DEX);
    void* buffer[BUFFER_SIZE];
    int length = 0;
    int oldsize = 0;
    int newsize = 0;
    int cnt = 0;
    int result = -1;
    static int times = 0;
    const size_t kBufSize = 32768;
    unsigned char* readBuf = (unsigned char*) malloc(kBufSize);
    unsigned char* writeBuf = (unsigned char*) malloc(kBufSize);
    z_stream zstream;
    int zerr;

    if (readBuf == NULL || writeBuf == NULL)
        goto bail;

    /*
     * Initialize the zlib stream struct.
     */
    memset(&zstream, 0, sizeof(zstream));
    zstream.zalloc = Z_NULL;
    zstream.zfree = Z_NULL;
    zstream.opaque = Z_NULL;
    zstream.next_in = NULL;
    zstream.avail_in = 0;
    zstream.next_out = (Bytef*) writeBuf;
    zstream.avail_out = kBufSize;
    zstream.data_type = Z_UNKNOWN;

    /*
     * Use the undocumented "negative window bits" feature to tell zlib
     * that there's no zlib header waiting for it.
     */
    zerr = inflateInit2(&zstream, -MAX_WBITS);
    if (zerr != Z_OK) {
        if (zerr == Z_VERSION_ERROR) {
            ALOGE("Installed zlib is not compatible with linked version (%s)",
                ZLIB_VERSION);
        } else {
            ALOGW("Call to inflateInit2 failed (zerr=%d)", zerr);
        }
        goto bail;
    }

    ALOG(LOG_INFO, "SVM", "in %s for %s", __FUNCTION__, apkname);
    if(client_socket<0) {
        if(new_sock(SYS_INSTRUMENT_PORT)<0) {
            ALOG(LOG_INFO, "SVM", "CL: in %s socket err",__FUNCTION__);  
        }
    }

    /*
     * Loop while we have more to do.
     */
    do {
        /* read as much as we can */
        if (zstream.avail_in == 0) {
            size_t getSize = (compLen > kBufSize) ? kBufSize : compLen;

            ssize_t actual = TEMP_FAILURE_RETRY(read(inFd, readBuf, getSize));
            if (actual != (ssize_t) getSize) {
                ALOGW("Zip: inflate read failed (%d vs %zd)",
                    (int)actual, getSize);
                goto z_bail;
            }

            compLen -= getSize;

            zstream.next_in = readBuf;
            zstream.avail_in = getSize;
        }

        /* uncompress the data */
        zerr = inflate(&zstream, Z_NO_FLUSH);
        if (zerr != Z_OK && zerr != Z_STREAM_END) {
            ALOGW("Zip: inflate zerr=%d (nIn=%p aIn=%u nOut=%p aOut=%u)",
                zerr, zstream.next_in, zstream.avail_in,
                zstream.next_out, zstream.avail_out);
            goto z_bail;
        }

        /* write when we're full or when we're done */
        if (zstream.avail_out == 0 ||
            (zerr == Z_STREAM_END && zstream.avail_out != kBufSize))
        {
            size_t writeSize = zstream.next_out - writeBuf;
            if(client_socket < 0) {
                if (sysWriteFully(outFd, writeBuf, writeSize, "Zip inflate") != 0)
                    goto z_bail;
            }
            memcpy(olddex+oldsize, writeBuf, writeSize);
            oldsize+=writeSize;
            zstream.next_out = writeBuf;
            zstream.avail_out = kBufSize;
        }
    } while (zerr == Z_OK);
    if(client_socket >= 0) {
        apk_original_dexsize = oldsize;
        int len = strlen(apkname);
        send(client_socket, &len, sizeof(int),0);
        send(client_socket,&oldsize,sizeof(int),0);
        send(client_socket, apkname, strlen(apkname),0);
        while(cnt < oldsize) {
            length = send(client_socket,olddex + cnt,min(BUFFER_SIZE, oldsize-cnt),0);
            cnt+=length;
        }

        length = recv(client_socket, &newsize, sizeof(int), 0);
        apk_new_dexsize = newsize;
        cnt = 0;
        while( cnt < newsize)
        {
            length = recv(client_socket,buffer,BUFFER_SIZE,0);
            if (sysWriteFully(outFd, buffer, length, "Zip inflate") != 0)
                goto z_bail;
            cnt+=length;
        }
        int eos = -1;
        send(client_socket,&eos,sizeof(int),0);
        close(client_socket);
        client_socket = -1;
    }

    assert(zerr == Z_STREAM_END);       /* other errors should've been caught */

    /* paranoia */
    if (zstream.total_out != uncompLen) {
        ALOGW("Zip: size mismatch on inflated file (%ld vs %zd)",
            zstream.total_out, uncompLen);
        goto z_bail;
    }

    result = 0;

z_bail:
    inflateEnd(&zstream);        /* free up any allocated structures */

bail:
    if(client_socket>0)
        close(client_socket);
    client_socket=-1;
    free(olddex);
    free(readBuf);
    free(writeBuf);
    return result;
}
Ejemplo n.º 2
0
/*
 * Data is pending on "fd".  Read as much as will fit in "data", then
 * write out any full lines and compact "data".
 */
static bool readAndLog(int fd, BufferedData* data, const char* tag)
{
    ssize_t actual;
    size_t want;

    assert(data->count < kMaxLine);

    want = kMaxLine - data->count;
    actual = read(fd, data->buf + data->count, want);
    if (actual <= 0) {
        ALOGW("read %s: (%d,%d) failed (%d): %s",
            tag, fd, want, (int)actual, strerror(errno));
        return false;
    } else {
        //ALOGI("read %s: %d at %d", tag, actual, data->count);
    }
    data->count += actual;

    /*
     * Got more data, look for an EOL.  We expect LF or CRLF, but will
     * try to handle a standalone CR.
     */
    char* cp = data->buf;
    const char* start = data->buf;
    int i = data->count;
    for (i = data->count; i > 0; i--, cp++) {
        if (*cp == '\n' || (*cp == '\r' && i != 0 && *(cp+1) != '\n')) {
            *cp = '\0';
            //ALOGW("GOT %d at %d '%s'", cp - start, start - data->buf, start);
            ALOG(LOG_INFO, tag, "%s", start);
            start = cp+1;
        }
    }

    /*
     * See if we overflowed.  If so, cut it off.
     */
    if (start == data->buf && data->count == kMaxLine) {
        data->buf[kMaxLine] = '\0';
        ALOG(LOG_INFO, tag, "%s!", start);
        start = cp + kMaxLine;
    }

    /*
     * Update "data" if we consumed some output.  If there's anything left
     * in the buffer, it's because we didn't see an EOL and need to keep
     * reading until we see one.
     */
    if (start != data->buf) {
        if (start >= data->buf + data->count) {
            /* consumed all available */
            data->count = 0;
        } else {
            /* some left over */
            int remaining = data->count - (start - data->buf);
            memmove(data->buf, start, remaining);
            data->count = remaining;
        }
    }

    return true;
}
Ejemplo n.º 3
0
int
audiotrack_init(cubeb ** context, char const * context_name)
{
  cubeb * ctx;
  struct AudioTrack* c;

  assert(context);
  *context = NULL;

  ctx = calloc(1, sizeof(*ctx));
  assert(ctx);

  /* If we use an absolute path here ("/system/lib/libmedia.so"), and on Android
   * 2.2, the dlopen succeeds, all the dlsym succeed, but a segfault happens on
   * the first call to a dlsym'ed function. Somehow this does not happen when
   * using only the name of the library. */
  ctx->library = dlopen("libmedia.so", RTLD_LAZY);
  if (!ctx->library) {
    ALOG("dlopen error: %s.", dlerror());
    free(ctx);
    return CUBEB_ERROR;
  }

  /* Recent Android first, then Gingerbread. */
  DLSYM_DLERROR("_ZN7android10AudioTrackC1EijiiijPFviPvS1_ES1_ii", ctx->klass.ctor, ctx->library);
  DLSYM_DLERROR("_ZN7android10AudioTrackD1Ev", ctx->klass.dtor, ctx->library);

  DLSYM_DLERROR("_ZNK7android10AudioTrack7latencyEv", ctx->klass.latency, ctx->library);
  DLSYM_DLERROR("_ZNK7android10AudioTrack9initCheckEv", ctx->klass.check, ctx->library);

  DLSYM_DLERROR("_ZN7android11AudioSystem21getOutputSamplingRateEPii", ctx->klass.get_output_samplingrate, ctx->library);

  /* |getMinFrameCount| is available on gingerbread and ICS with different signatures. */
  DLSYM_DLERROR("_ZN7android10AudioTrack16getMinFrameCountEPi19audio_stream_type_tj", ctx->klass.get_min_frame_count, ctx->library);
  if (!ctx->klass.get_min_frame_count) {
    DLSYM_DLERROR("_ZN7android10AudioTrack16getMinFrameCountEPiij", ctx->klass.get_min_frame_count_gingerbread, ctx->library);
  }

  DLSYM_DLERROR("_ZN7android10AudioTrack5startEv", ctx->klass.start, ctx->library);
  DLSYM_DLERROR("_ZN7android10AudioTrack5pauseEv", ctx->klass.pause, ctx->library);
  DLSYM_DLERROR("_ZN7android10AudioTrack11getPositionEPj", ctx->klass.get_position, ctx->library);
  DLSYM_DLERROR("_ZN7android10AudioTrack17setMarkerPositionEj", ctx->klass.set_marker_position, ctx->library);
  DLSYM_DLERROR("_ZN7android10AudioTrack9setVolumeEff", ctx->klass.set_volume, ctx->library);

  /* check that we have a combination of symbol that makes sense */
  c = &ctx->klass;
  if(!(c->ctor &&
       c->dtor && c->latency && c->check &&
       /* at least one way to get the minimum frame count to request. */
       (c->get_min_frame_count ||
        c->get_min_frame_count_gingerbread) &&
       c->start && c->pause && c->get_position && c->set_marker_position)) {
    ALOG("Could not find all the symbols we need.");
    audiotrack_destroy(ctx);
    return CUBEB_ERROR;
  }

  ctx->ops = &audiotrack_ops;

  *context = ctx;

  return CUBEB_OK;
}
static jint nativeEnrollCancel(JNIEnv* env, jobject clazz) {
    ALOG(LOG_VERBOSE, LOG_TAG, "nativeEnrollCancel()\n");
    int ret = gContext.device->enroll_cancel(gContext.device);
    return reinterpret_cast<jint>(ret);
}
Ejemplo n.º 5
0
void log_basic_info() {
  ALOG("Basic info for native scrypt run:");
  ALOG("Native library targeting arch: %s", STR(ANDROID_TARGET_ARCH));
}
Ejemplo n.º 6
0
int
audiotrack_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_name,
                       cubeb_stream_params stream_params, unsigned int latency,
                       cubeb_data_callback data_callback,
                       cubeb_state_callback state_callback,
                       void * user_ptr)
{
  struct cubeb_stream * stm;
  int32_t channels;
  int32_t min_frame_count;

  assert(ctx && stream);

  if (stream_params.format == CUBEB_SAMPLE_FLOAT32LE ||
      stream_params.format == CUBEB_SAMPLE_FLOAT32BE) {
    return CUBEB_ERROR_INVALID_FORMAT;
  }

  if (audiotrack_get_min_frame_count(ctx, &stream_params, &min_frame_count)) {
    return CUBEB_ERROR;
  }

  stm = calloc(1, sizeof(*stm));
  assert(stm);

  stm->context = ctx;
  stm->data_callback = data_callback;
  stm->state_callback = state_callback;
  stm->user_ptr = user_ptr;
  stm->params = stream_params;

  stm->instance = calloc(SIZE_AUDIOTRACK_INSTANCE, 1);
  (*(uint32_t*)((intptr_t)stm->instance + SIZE_AUDIOTRACK_INSTANCE - 4)) = 0xbaadbaad;
  assert(stm->instance && "cubeb: EOM");

  if (audiotrack_version_is_froyo(ctx)) {
    channels = stm->params.channels == 2 ? AUDIO_CHANNEL_OUT_STEREO_Froyo : AUDIO_CHANNEL_OUT_MONO_Froyo;
  } else {
    channels = stm->params.channels == 2 ? AUDIO_CHANNEL_OUT_STEREO_ICS : AUDIO_CHANNEL_OUT_MONO_ICS;
  }

  if (audiotrack_version_is_froyo(ctx)) {
    ctx->klass.ctor_froyo(stm->instance,
                          AUDIO_STREAM_TYPE_MUSIC,
                          stm->params.rate,
                          AUDIO_FORMAT_PCM_16_BIT,
                          channels,
                          min_frame_count,
                          0,
                          audiotrack_refill,
                          stm,
                          0);
  } else {
    ctx->klass.ctor(stm->instance,
                    AUDIO_STREAM_TYPE_MUSIC,
                    stm->params.rate,
                    AUDIO_FORMAT_PCM_16_BIT,
                    channels,
                    min_frame_count,
                    0,
                    audiotrack_refill,
                    stm,
                    0,
                    0);
  }

  assert((*(uint32_t*)((intptr_t)stm->instance + SIZE_AUDIOTRACK_INSTANCE - 4)) == 0xbaadbaad);

  if (ctx->klass.check(stm->instance)) {
    ALOG("stream not initialized properly.");
    audiotrack_stream_destroy(stm);
    return CUBEB_ERROR;
  }

  *stream = stm;

  return CUBEB_OK;
}
// Called each time a statement finishes execution, when profiling is enabled.
static void sqliteProfileCallback(void *data, const char *sql, sqlite3_uint64 tm) {
    SQLiteConnection* connection = static_cast<SQLiteConnection*>(data);
    ALOG(LOG_VERBOSE, SQLITE_PROFILE_TAG, "%s: \"%s\" took %0.3f ms\n",
            connection->label.string(), sql, tm * 0.000001f);
}
Ejemplo n.º 8
0
// Return the name of the shared library that implements Omx based decoding. This varies
// depending on libstagefright version installed on the device and whether it is B2G vs Android.
// nullptr is returned if Omx decoding is not supported on the device,
static const char* GetOmxLibraryName()
{
#if defined(ANDROID) && !defined(MOZ_WIDGET_GONK)
  nsCOMPtr<nsIPropertyBag2> infoService = do_GetService("@mozilla.org/system-info;1");
  NS_ASSERTION(infoService, "Could not find a system info service");

  int32_t version;
  nsresult rv = infoService->GetPropertyAsInt32(NS_LITERAL_STRING("version"), &version);
  if (NS_SUCCEEDED(rv)) {
    ALOG("Android Version is: %d", version);
  }

  nsAutoString release_version;
  rv = infoService->GetPropertyAsAString(NS_LITERAL_STRING("release_version"), release_version);
  if (NS_SUCCEEDED(rv)) {
    ALOG("Android Release Version is: %s", NS_LossyConvertUTF16toASCII(release_version).get());
  }

  nsAutoString device;
  rv = infoService->GetPropertyAsAString(NS_LITERAL_STRING("device"), device);
  if (NS_SUCCEEDED(rv)) {
    ALOG("Android Device is: %s", NS_LossyConvertUTF16toASCII(device).get());
  }

  nsAutoString manufacturer;
  rv = infoService->GetPropertyAsAString(NS_LITERAL_STRING("manufacturer"), manufacturer);
  if (NS_SUCCEEDED(rv)) {
    ALOG("Android Manufacturer is: %s", NS_LossyConvertUTF16toASCII(manufacturer).get());
  }

  nsAutoString hardware;
  rv = infoService->GetPropertyAsAString(NS_LITERAL_STRING("hardware"), hardware);
  if (NS_SUCCEEDED(rv)) {
    ALOG("Android Hardware is: %s", NS_LossyConvertUTF16toASCII(hardware).get());
  }
#endif

  if (!IsOmxSupported())
    return nullptr;

#if defined(ANDROID) && !defined(MOZ_WIDGET_GONK)
  if (version >= 17) {
    return "libomxpluginkk.so";
  }
  else if (version == 13 || version == 12 || version == 11) {
    return "libomxpluginhc.so";
  }
  else if (version == 10 && release_version >= NS_LITERAL_STRING("2.3.6")) {
    // Gingerbread versions from 2.3.6 and above have a different DataSource
    // layout to those on 2.3.5 and below.
    return "libomxplugingb.so";
  }
  else if (version == 10 && release_version >= NS_LITERAL_STRING("2.3.4") &&
           device.Find("HTC") == 0) {
    // HTC devices running Gingerbread 2.3.4+ (HTC Desire HD, HTC Evo Design, etc) seem to
    // use a newer version of Gingerbread libstagefright than other 2.3.4 devices.
    return "libomxplugingb.so";
  }
  else if (version == 9 || (version == 10 && release_version <= NS_LITERAL_STRING("2.3.5"))) {
    // Gingerbread versions from 2.3.5 and below have a different DataSource
    // than 2.3.6 and above.
    return "libomxplugingb235.so";
  }
  else if (version < 9) {
    // Below Gingerbread not supported
    return nullptr;
  }

  // Ice Cream Sandwich and Jellybean
  return "libomxplugin.so";

#elif defined(ANDROID) && defined(MOZ_WIDGET_GONK)
  return "libomxplugin.so";
#else
  return nullptr;
#endif
}
Ejemplo n.º 9
0
static void heap_error(const char* msg, const char* function, void* p) {
    ALOG(LOG_FATAL, LOG_TAG, "@@@ ABORTING: CODE FLINGER: %s IN %s addr=%p",
         msg, function, p);
    /* So that we can get a memory dump around p */
    *((int **) 0xdeadbaad) = (int *) p;
}
JNIEXPORT void JNICALL _stopRecordRTSPStream(JNIEnv *env, jclass clazz)
{
    ALOG(TX_LOG_INFO, TAG, "stopRecordRTSPStream\n");
    stopRecordingRtspStream();
}
JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved)
{
    ALOG(ANDROID_LOG_ERROR, "tag", "library was unload");
}
Ejemplo n.º 12
0
// Blocks until decoded sample is produced by the deoder.
nsresult
GonkVideoDecoderManager::Output(int64_t aStreamOffset,
                                nsAutoPtr<MediaData>& aOutData)
{
  aOutData = nullptr;
  status_t err;
  if (mDecoder == nullptr) {
    ALOG("Decoder is not inited");
    return NS_ERROR_UNEXPECTED;
  }
  err = mDecoder->Output(&mVideoBuffer, READ_OUTPUT_BUFFER_TIMEOUT_US);

  switch (err) {
    case OK:
    {
      VideoData* data = nullptr;
      nsresult rv = CreateVideoData(aStreamOffset, &data);
      if (rv == NS_ERROR_NOT_AVAILABLE) {
	// Decoder outputs a empty video buffer, try again
        return NS_ERROR_NOT_AVAILABLE;
      } else if (rv != NS_OK || data == nullptr) {
        ALOG("Failed to create VideoData");
        return NS_ERROR_UNEXPECTED;
      }
      aOutData = data;
      return NS_OK;
    }
    case android::INFO_FORMAT_CHANGED:
    {
      // If the format changed, update our cached info.
      ALOG("Decoder format changed");
      if (!SetVideoFormat()) {
        return NS_ERROR_UNEXPECTED;
      }
      return Output(aStreamOffset, aOutData);
    }
    case android::INFO_OUTPUT_BUFFERS_CHANGED:
    {
      if (mDecoder->UpdateOutputBuffers()) {
        return Output(aStreamOffset, aOutData);
      }
      return NS_ERROR_FAILURE;
    }
    case -EAGAIN:
    {
      return NS_ERROR_NOT_AVAILABLE;
    }
    case android::ERROR_END_OF_STREAM:
    {
      ALOG("Got the EOS frame!");
      VideoData* data = nullptr;
      nsresult rv = CreateVideoData(aStreamOffset, &data);
      if (rv == NS_ERROR_NOT_AVAILABLE) {
	// For EOS, no need to do any thing.
        return NS_ERROR_ABORT;
      }
      if (rv != NS_OK || data == nullptr) {
        ALOG("Failed to create video data");
        return NS_ERROR_UNEXPECTED;
      }
      aOutData = data;
      return NS_ERROR_ABORT;
    }
    case -ETIMEDOUT:
    {
      ALOG("Timeout. can try again next time");
      return NS_ERROR_UNEXPECTED;
    }
    default:
    {
      ALOG("Decoder failed, err=%d", err);
      return NS_ERROR_UNEXPECTED;
    }
  }

  return NS_OK;
}
Ejemplo n.º 13
0
nsresult
GonkVideoDecoderManager::CreateVideoData(int64_t aStreamOffset, VideoData **v)
{
  *v = nullptr;
  int64_t timeUs;
  int32_t keyFrame;

  if (mVideoBuffer == nullptr) {
    ALOG("Video Buffer is not valid!");
    return NS_ERROR_UNEXPECTED;
  }

  if (!mVideoBuffer->meta_data()->findInt64(kKeyTime, &timeUs)) {
    ALOG("Decoder did not return frame time");
    return NS_ERROR_UNEXPECTED;
  }

  if (mVideoBuffer->range_length() == 0) {
    // Some decoders may return spurious empty buffers that we just want to ignore
    // quoted from Android's AwesomePlayer.cpp
    ReleaseVideoBuffer();
    return NS_ERROR_NOT_AVAILABLE;
  }

  if (!mVideoBuffer->meta_data()->findInt32(kKeyIsSyncFrame, &keyFrame)) {
    keyFrame = 0;
  }

  gfx::IntRect picture = ToIntRect(mPicture);
  if (mFrameInfo.mWidth != mInitialFrame.width ||
      mFrameInfo.mHeight != mInitialFrame.height) {

    // Frame size is different from what the container reports. This is legal,
    // and we will preserve the ratio of the crop rectangle as it
    // was reported relative to the picture size reported by the container.
    picture.x = (mPicture.x * mFrameInfo.mWidth) / mInitialFrame.width;
    picture.y = (mPicture.y * mFrameInfo.mHeight) / mInitialFrame.height;
    picture.width = (mFrameInfo.mWidth * mPicture.width) / mInitialFrame.width;
    picture.height = (mFrameInfo.mHeight * mPicture.height) / mInitialFrame.height;
  }

  RefPtr<mozilla::layers::TextureClient> textureClient;

  if ((mVideoBuffer->graphicBuffer().get())) {
    textureClient = mNativeWindow->getTextureClientFromBuffer(mVideoBuffer->graphicBuffer().get());
  }

  if (textureClient) {
    GrallocTextureClientOGL* grallocClient = static_cast<GrallocTextureClientOGL*>(textureClient.get());
    grallocClient->SetMediaBuffer(mVideoBuffer);
    textureClient->SetRecycleCallback(GonkVideoDecoderManager::RecycleCallback, this);

    *v = VideoData::Create(mInfo.mVideo,
                          mImageContainer,
                          aStreamOffset,
                          timeUs,
                          1, // We don't know the duration.
                          textureClient,
                          keyFrame,
                          -1,
                          picture);

  } else {
    if (!mVideoBuffer->data()) {
      ALOG("No data in Video Buffer!");
      return NS_ERROR_UNEXPECTED;
    }
    uint8_t *yuv420p_buffer = (uint8_t *)mVideoBuffer->data();
    int32_t stride = mFrameInfo.mStride;
    int32_t slice_height = mFrameInfo.mSliceHeight;

    // Converts to OMX_COLOR_FormatYUV420Planar
    if (mFrameInfo.mColorFormat != OMX_COLOR_FormatYUV420Planar) {
      ARect crop;
      crop.top = 0;
      crop.bottom = mFrameInfo.mHeight;
      crop.left = 0;
      crop.right = mFrameInfo.mWidth;
      yuv420p_buffer = GetColorConverterBuffer(mFrameInfo.mWidth, mFrameInfo.mHeight);
      if (mColorConverter.convertDecoderOutputToI420(mVideoBuffer->data(),
          mFrameInfo.mWidth, mFrameInfo.mHeight, crop, yuv420p_buffer) != OK) {
          ReleaseVideoBuffer();
          ALOG("Color conversion failed!");
          return NS_ERROR_UNEXPECTED;
      }
        stride = mFrameInfo.mWidth;
        slice_height = mFrameInfo.mHeight;
    }

    size_t yuv420p_y_size = stride * slice_height;
    size_t yuv420p_u_size = ((stride + 1) / 2) * ((slice_height + 1) / 2);
    uint8_t *yuv420p_y = yuv420p_buffer;
    uint8_t *yuv420p_u = yuv420p_y + yuv420p_y_size;
    uint8_t *yuv420p_v = yuv420p_u + yuv420p_u_size;

    // This is the approximate byte position in the stream.
    int64_t pos = aStreamOffset;

    VideoData::YCbCrBuffer b;
    b.mPlanes[0].mData = yuv420p_y;
    b.mPlanes[0].mWidth = mFrameInfo.mWidth;
    b.mPlanes[0].mHeight = mFrameInfo.mHeight;
    b.mPlanes[0].mStride = stride;
    b.mPlanes[0].mOffset = 0;
    b.mPlanes[0].mSkip = 0;

    b.mPlanes[1].mData = yuv420p_u;
    b.mPlanes[1].mWidth = (mFrameInfo.mWidth + 1) / 2;
    b.mPlanes[1].mHeight = (mFrameInfo.mHeight + 1) / 2;
    b.mPlanes[1].mStride = (stride + 1) / 2;
    b.mPlanes[1].mOffset = 0;
    b.mPlanes[1].mSkip = 0;

    b.mPlanes[2].mData = yuv420p_v;
    b.mPlanes[2].mWidth =(mFrameInfo.mWidth + 1) / 2;
    b.mPlanes[2].mHeight = (mFrameInfo.mHeight + 1) / 2;
    b.mPlanes[2].mStride = (stride + 1) / 2;
    b.mPlanes[2].mOffset = 0;
    b.mPlanes[2].mSkip = 0;

    *v = VideoData::Create(
        mInfo.mVideo,
        mImageContainer,
        pos,
        timeUs,
        1, // We don't know the duration.
        b,
        keyFrame,
        -1,
        picture);
    ReleaseVideoBuffer();
  }
  return NS_OK;
}
Ejemplo n.º 14
0
int aapt(const char *source_apk, const char *internal_path, const char *out_restable, uid_t uid,
         int pkgId, const char *common_res_path)
{
    ALOGD("aapt source_apk=%s internal_path=%s out_restable=%s uid=%d, pkgId=%d, common_res_path=%s",
             source_apk, internal_path, out_restable, uid, pkgId, common_res_path);
    static const int PARENT_READ_PIPE = 0;
    static const int CHILD_WRITE_PIPE = 1;

    int restable_fd = -1;
    int resapk_fd = -1;
    char restable_path[PATH_MAX];
    char resapk_path[PATH_MAX];

    // get file descriptor for resources.arsc
    snprintf(restable_path, PATH_MAX, "%s/resources.arsc", out_restable);
    unlink(restable_path);
    restable_fd = open(restable_path, O_RDWR | O_CREAT | O_EXCL, 0644);
    if (restable_fd < 0) {
        ALOGE("aapt cannot open '%s' for output: %s\n", restable_path, strerror(errno));
        goto fail;
    }
    if (fchown(restable_fd, AID_SYSTEM, uid) < 0) {
        ALOGE("aapt cannot chown '%s'\n", restable_path);
        goto fail;
    }
    if (fchmod(restable_fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0) {
        ALOGE("aapt cannot chmod '%s'\n", restable_path);
        goto fail;
    }

    // get file descriptor for resources.apk
    snprintf(resapk_path, PATH_MAX, "%s/resources.apk", out_restable);
    unlink(resapk_path);
    resapk_fd = open(resapk_path, O_RDWR | O_CREAT | O_EXCL, 0644);
    if (resapk_fd < 0) {
        ALOGE("aapt cannot open '%s' for output: %s\n", resapk_path, strerror(errno));
        goto fail;
    }
    if (fchown(resapk_fd, AID_SYSTEM, uid) < 0) {
        ALOGE("aapt cannot chown '%s'\n", resapk_path);
        goto fail;
    }
    if (fchmod(resapk_fd, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH) < 0) {
        ALOGE("aapt cannot chmod '%s'\n", resapk_path);
        goto fail;
    }

    int pipefd[2];
    if (pipe(pipefd) != 0) {
        pipefd[0] = pipefd[1] = -1;
    }
    pid_t pid = fork();
    if (pid == 0) {
        /* child -- drop privileges before continuing */
        if (setgid(uid) != 0) {
            ALOGE("setgid(%d) failed during aapt\n", uid);
            exit(1);
        }
        if (setuid(uid) != 0) {
            ALOGE("setuid(%d) failed during aapt\n", uid);
            exit(1);
        }

        if (flock(restable_fd, LOCK_EX | LOCK_NB) != 0) {
            ALOGE("flock(%s) failed during aapt: %s\n", out_restable, strerror(errno));
            exit(1);
        }

        if (flock(resapk_fd, LOCK_EX | LOCK_NB) != 0) {
            ALOGE("flock(%s) failed during aapt: %s\n", out_restable, strerror(errno));
            exit(1);
        }

        if (pipefd[PARENT_READ_PIPE] > 0 && pipefd[CHILD_WRITE_PIPE] > 0) {
            close(pipefd[PARENT_READ_PIPE]); // close unused read end
            if (dup2(pipefd[CHILD_WRITE_PIPE], STDERR_FILENO) != STDERR_FILENO) {
                pipefd[CHILD_WRITE_PIPE] = -1;
            }
        }

        run_aapt(source_apk, internal_path, restable_fd, resapk_fd, pkgId, common_res_path);

        if (pipefd[CHILD_WRITE_PIPE] > 0) {
            close(pipefd[CHILD_WRITE_PIPE]);
        }
        exit(1); /* only if exec call to idmap failed */
    } else {
        int status, i;
        char buffer[1024];
        ssize_t readlen;

        if (pipefd[CHILD_WRITE_PIPE] > 0) {
            close(pipefd[CHILD_WRITE_PIPE]); // close unused write end
        }

        if (pipefd[PARENT_READ_PIPE] > 0) {
            while ((readlen = read(pipefd[PARENT_READ_PIPE], buffer, sizeof(buffer) - 1)) > 0) {
                // in case buffer has more than one string in it, replace '\0' with '\n'
                for (i = 0; i < readlen; i++) {
                    if (buffer[i] == '\0') buffer[i] = '\n';
                }
                // null terminate buffer at readlen
                buffer[readlen] = '\0';
                ALOG(LOG_ERROR, "InstallTheme", "%s", buffer);
            }
            waitpid(pid, &status, 0);

            if (pipefd[PARENT_READ_PIPE] > 0) {
                close(pipefd[PARENT_READ_PIPE]);
            }
        } else {
            status = wait_child(pid);
        }

        if (status != 0) {
            ALOGE("aapt failed, status=0x%04x\n", status);
            goto fail;
        }
    }

    close(restable_fd);
    close(resapk_fd);
    return 0;
fail:
    if (restable_fd >= 0) {
        close(restable_fd);
        unlink(restable_path);
    }
    if (resapk_fd >= 0) {
        close(resapk_fd);
        unlink(resapk_path);
    }
    return -1;
}
static jint nativeGetNumEnrollmentSteps(JNIEnv* env) {
    ALOG(LOG_VERBOSE, LOG_TAG, "nativeGetNumEnrollMents()\n");
    return reinterpret_cast<jint>(gContext.device->get_num_enrollment_steps(gContext.device));
}
int32_t FingerprintDaemonProxy::stopEnrollment() {
    ALOG(LOG_VERBOSE, LOG_TAG, "stopEnrollment()\n");
    return mDevice->cancel(mDevice);
}
void Mutex::unlock()
{
    if (!ReleaseMutex((HANDLE) mState))
        ALOG(LOG_WARN, "thread", "WARNING: bad result from unlocking mutex\n");
}
int32_t FingerprintDaemonProxy::authenticate(uint64_t sessionId, uint32_t groupId) {
    ALOG(LOG_VERBOSE, LOG_TAG, "authenticate(sid=%" PRId64 ", gid=%d)\n", sessionId, groupId);
    return mDevice->authenticate(mDevice, sessionId, groupId);
}
Ejemplo n.º 19
0
int iowrap_system(const char *cmd, char *const args[]) {
    int err = 0;
    int pid;

    /*
     * pipefd[0] - read
     * pipefd[1] - write
     */
    int pipefd[2];

    err = pipe(pipefd);
    if (err < 0) {
        ALOGE("error calling pipe: %s\n", strerror(errno));
        return err;
    }

    pid = fork();
    if (pid < 0) {
        ALOGE("error calling fork: %s\n", strerror(errno));
        close(pipefd[0]);
        close(pipefd[1]);
        return pid;
    }

    if (pid == 0) { /* child */
        close(pipefd[0]);

        // point stdout to pipe
        err = dup2(pipefd[1], STDOUT_FILENO);
        if (err < 0) {
            ALOGE("error dup'ing child's stdout: %s\n", strerror(errno));
            goto child_cleanup;
        }

        // point stderr to pipe
        err = dup2(pipefd[1], STDERR_FILENO);
        if (err < 0) {
            ALOGE("error dup'ing child's stderr: %s\n", strerror(errno));
            goto child_cleanup;
        }

        char *const cenvp[] = { NULL };
        err = execve(cmd, args, cenvp);
        if (err < 0) {
            ALOGE("error calling execve: %s\n", strerror(errno));
            goto child_cleanup;
        }

child_cleanup:
        close(pipefd[1]);
        return err;
    } else { /* parent */
        FILE *fpipe;
        char *cmd_copy, *tag;
        char line[LINE_MAX_SIZE];

        ALOGD_IF(DEBUG, "child pid: %d\n", pid);

        close(pipefd[1]);

        fpipe = fdopen(pipefd[0], "r");
        if (fpipe == NULL) {
            ALOGE("error converting pipe to FILE*: %s\n", strerror(errno));
            err = -1;
            goto parent_cleanup;
        }

        // create a copy since basename may modify its arg
        cmd_copy = strndup(cmd, TAG_MAX_SIZE);
        tag = basename(cmd_copy);

        while(fgets(line, sizeof(line), fpipe)) {
            ALOG(LOG_INFO, tag, "%s", line);
        }
        fclose(fpipe);

        pid = wait(NULL);
        if (pid < 0) {
            ALOGE("error waiting for child: %s\n", strerror(errno));
            err = pid;
            goto parent_cleanup;
        }

parent_cleanup:
        free(cmd_copy);
        close(pipefd[0]);
        return err;
    }

    // should never reach here
    return -1;
}
int32_t FingerprintDaemonProxy::stopAuthentication() {
    ALOG(LOG_VERBOSE, LOG_TAG, "stopAuthentication()\n");
    return mDevice->cancel(mDevice);
}
// Called each time a statement begins execution, when tracing is enabled.
static void sqliteTraceCallback(void *data, const char *sql) {
    SQLiteConnection* connection = static_cast<SQLiteConnection*>(data);
    ALOG(LOG_VERBOSE, SQLITE_TRACE_TAG, "%s: \"%s\"\n",
            connection->label.string(), sql);
}
int32_t FingerprintDaemonProxy::remove(int32_t fingerId, int32_t groupId) {
    ALOG(LOG_VERBOSE, LOG_TAG, "remove(fid=%d, gid=%d)\n", fingerId, groupId);
    return mDevice->remove(mDevice, groupId, fingerId);
}
static jint nativeRemove(JNIEnv* env, jobject clazz, jint fingerprintId) {
    ALOG(LOG_VERBOSE, LOG_TAG, "nativeRemove(%d)\n", fingerprintId);
    int ret = gContext.device->remove(gContext.device, fingerprintId);
    return reinterpret_cast<jint>(ret);
}
Ejemplo n.º 24
0
static jclass findAppClass(JNIEnv *jenv,const char *apn){
	//获取Loaders
	jclass clazzApplicationLoaders = jenv->FindClass("android/app/ApplicationLoaders");
	jthrowable exception = jenv->ExceptionOccurred();
	if (ClearException(jenv)) {
		ALOG("Exception","No class : %s", "android/app/ApplicationLoaders");
		return NULL;
	}
	jfieldID fieldApplicationLoaders = jenv->GetStaticFieldID(clazzApplicationLoaders,"gApplicationLoaders","Landroid/app/ApplicationLoaders;");
	if (ClearException(jenv)) {
		ALOG("Exception","No Static Field :%s","gApplicationLoaders");
		return NULL;
	}
	jobject objApplicationLoaders = jenv->GetStaticObjectField(clazzApplicationLoaders,fieldApplicationLoaders);
	if (ClearException(jenv)) {
		ALOG("Exception","GetStaticObjectField is failed [%s","gApplicationLoaders");
		return NULL;
	}
	jfieldID fieldLoaders = jenv->GetFieldID(clazzApplicationLoaders,"mLoaders","Ljava/util/Map;");
	if (ClearException(jenv)) {
		ALOG("Exception","No Field :%s","mLoaders");
		return NULL;
	}
	jobject objLoaders = jenv->GetObjectField(objApplicationLoaders,fieldLoaders);
	if (ClearException(jenv)) {
		ALOG("Exception","No object :%s","mLoaders");
		return NULL;
	}
	//提取map中的values
	jclass clazzHashMap = jenv->GetObjectClass(objLoaders);
	jmethodID methodValues = jenv->GetMethodID(clazzHashMap,"values","()Ljava/util/Collection;");
	jobject values = jenv->CallObjectMethod(objLoaders,methodValues);

	jclass clazzValues = jenv->GetObjectClass(values);
	jmethodID methodToArray = jenv->GetMethodID(clazzValues,"toArray","()[Ljava/lang/Object;");
	if (ClearException(jenv)) {
		ALOG("Exception","No Method:%s","toArray");
		return NULL;
	}

	jobjectArray classLoaders = (jobjectArray)jenv->CallObjectMethod(values,methodToArray);
	if (ClearException(jenv)) {
		ALOG("Exception","CallObjectMethod failed :%s","toArray");
		return NULL;
	}

		int size = jenv->GetArrayLength(classLoaders);

		for(int i = 0 ; i < size ; i ++){
			jobject classLoader = jenv->GetObjectArrayElement(classLoaders,i);
			jclass clazzCL = jenv->GetObjectClass(classLoader);
			jmethodID loadClass = jenv->GetMethodID(clazzCL,"loadClass","(Ljava/lang/String;)Ljava/lang/Class;");
			jstring param = jenv->NewStringUTF(apn);
			jclass tClazz = (jclass)jenv->CallObjectMethod(classLoader,loadClass,param);
			if (ClearException(jenv)) {
				ALOG("Exception","No");
				continue;
			}
			return tClazz;
		}
	ALOG("Exception","No");
	return NULL;
}
Ejemplo n.º 25
0
void log_params(JNIEnv *env, jbyteArray passwd, jbyteArray salt, jint N, jint r, jint p, jint dkLen) {
  ALOG("Parameters for native scrypt run:");
  ALOG("passwd (summary): %s", get_byte_array_summary(env, passwd));
  ALOG("salt (summary): %s", get_byte_array_summary(env, salt));
  ALOG("N, r, p, dkLen: %d, %d, %d, %d", (int32_t) N, (int32_t) r, (int32_t) p, (int32_t) dkLen);
}
Ejemplo n.º 26
0
void fatal(const char *msg) {
    fprintf(stderr, "%s", msg);
    ALOG(LOG_ERROR, "logwrapper", "%s", msg);
    exit(-1);
}
Ejemplo n.º 27
0
// Return the name of the shared library that implements Omx based decoding. This varies
// depending on libstagefright version installed on the device and whether it is B2G vs Android.
// nullptr is returned if Omx decoding is not supported on the device,
static const char* GetOmxLibraryName()
{
  if (!IsOmxSupported())
    return nullptr;

#if defined(ANDROID) && !defined(MOZ_WIDGET_GONK)
  nsCOMPtr<nsIPropertyBag2> infoService = do_GetService("@mozilla.org/system-info;1");
  NS_ASSERTION(infoService, "Could not find a system info service");

  int32_t version;
  nsresult rv = infoService->GetPropertyAsInt32(NS_LITERAL_STRING("version"), &version);
  if (NS_SUCCEEDED(rv)) {
    ALOG("Android Version is: %d", version);
  }

  nsAutoString release_version;
  rv = infoService->GetPropertyAsAString(NS_LITERAL_STRING("release_version"), release_version);
  if (NS_SUCCEEDED(rv)) {
    ALOG("Android Release Version is: %s", NS_LossyConvertUTF16toASCII(release_version).get());
  }

  nsAutoString device;
  rv = infoService->GetPropertyAsAString(NS_LITERAL_STRING("device"), device);
  if (NS_SUCCEEDED(rv)) {
    ALOG("Android Device is: %s", NS_LossyConvertUTF16toASCII(device).get());
  }

  if (version == 15 &&
      (device.Find("LT28", false) == 0 ||
       device.Find("LT26", false) == 0 ||
       device.Find("LT22", false) == 0 ||
       device.Find("IS12", false) == 0 ||
       device.Find("MT27", false) == 0)) {
    // Sony Ericsson devices running ICS
    return "libomxpluginsony.so";
  }
  else if (version == 13 || version == 12 || version == 11) {
    return "libomxpluginhc.so";
  }
  else if (version == 10 && release_version >= NS_LITERAL_STRING("2.3.6")) {
    // Gingerbread versions from 2.3.6 and above have a different DataSource
    // layout to those on 2.3.5 and below.
    return "libomxplugingb.so";
  }
  else if (version == 10 && release_version >= NS_LITERAL_STRING("2.3.4") &&
           device.Find("HTC") == 0) {
    // HTC devices running Gingerbread 2.3.4+ (HTC Desire HD, HTC Evo Design, etc) seem to
    // use a newer version of Gingerbread libstagefright than other 2.3.4 devices.
    return "libomxplugingb.so";
  }
  else if (version == 9 || (version == 10 && release_version <= NS_LITERAL_STRING("2.3.5"))) {
    // Gingerbread versions from 2.3.5 and below have a different DataSource
    // than 2.3.6 and above.
    return "libomxplugingb235.so";
  }
  else if (version == 8) {
    // Froyo
    return "libomxpluginfroyo.so";
  }
  else if (version < 8) {
    // Below Froyo not supported
    return nullptr;
  }

  // Default libomxplugin for non-gingerbread devices
  return "libomxplugin.so";

#elif defined(ANDROID) && defined(MOZ_WIDGET_GONK)
  return "libomxplugin.so";
#else
  return nullptr;
#endif
}
static jint nativeAuthenticate(JNIEnv* env, jobject clazz) {
    ALOG(LOG_VERBOSE, LOG_TAG, "nativeAuthenticate()\n");
    int ret = gContext.device->authenticate(gContext.device);
    return reinterpret_cast<jint>(ret);
}
Ejemplo n.º 29
0
int
audiotrack_stream_init(cubeb * ctx, cubeb_stream ** stream, char const * stream_name,
                       cubeb_devid input_device,
                       cubeb_stream_params * input_stream_params,
                       cubeb_devid output_device,
                       cubeb_stream_params * output_stream_params,
                       unsigned int latency,
                       cubeb_data_callback data_callback,
                       cubeb_state_callback state_callback,
                       void * user_ptr)
{
  cubeb_stream * stm;
  int32_t channels;
  uint32_t min_frame_count;

  assert(ctx && stream);

  assert(!input_stream_params && "not supported");
  if (input_device || output_device) {
    /* Device selection not yet implemented. */
    return CUBEB_ERROR_DEVICE_UNAVAILABLE;
  }

  if (output_stream_params->format == CUBEB_SAMPLE_FLOAT32LE ||
      output_stream_params->format == CUBEB_SAMPLE_FLOAT32BE) {
    return CUBEB_ERROR_INVALID_FORMAT;
  }

  if (audiotrack_get_min_frame_count(ctx, output_stream_params, (int *)&min_frame_count)) {
    return CUBEB_ERROR;
  }

  stm = calloc(1, sizeof(*stm));
  assert(stm);

  stm->context = ctx;
  stm->data_callback = data_callback;
  stm->state_callback = state_callback;
  stm->user_ptr = user_ptr;
  stm->params = *output_stream_params;

  stm->instance = calloc(SIZE_AUDIOTRACK_INSTANCE, 1);
  (*(uint32_t*)((intptr_t)stm->instance + SIZE_AUDIOTRACK_INSTANCE - 4)) = 0xbaadbaad;
  assert(stm->instance && "cubeb: EOM");

  /* gingerbread uses old channel layout enum */
  if (audiotrack_version_is_gingerbread(ctx)) {
    channels = stm->params.channels == 2 ? AUDIO_CHANNEL_OUT_STEREO_Legacy : AUDIO_CHANNEL_OUT_MONO_Legacy;
  } else {
    channels = stm->params.channels == 2 ? AUDIO_CHANNEL_OUT_STEREO_ICS : AUDIO_CHANNEL_OUT_MONO_ICS;
  }

  ctx->klass.ctor(stm->instance, stm->params.stream_type, stm->params.rate,
                  AUDIO_FORMAT_PCM_16_BIT, channels, min_frame_count, 0,
                  audiotrack_refill, stm, 0, 0);

  assert((*(uint32_t*)((intptr_t)stm->instance + SIZE_AUDIOTRACK_INSTANCE - 4)) == 0xbaadbaad);

  if (ctx->klass.check(stm->instance)) {
    ALOG("stream not initialized properly.");
    audiotrack_stream_destroy(stm);
    return CUBEB_ERROR;
  }

  *stream = stm;

  return CUBEB_OK;
}
Ejemplo n.º 30
0
int
sa_stream_write(sa_stream_t *s, const void *data, size_t nbytes) {

  if (s == NULL || s->output_unit == NULL) {
    return SA_ERROR_NO_INIT;
  }
  if (nbytes == 0) {
    return SA_SUCCESS;
  }
  JNIEnv *jenv = GetJNIForThread();
  if ((*jenv)->PushLocalFrame(jenv, 2)) {
    return SA_ERROR_OOM;
  }

  jbyteArray bytearray = (*jenv)->NewByteArray(jenv, nbytes);
  if (!bytearray) {
    (*jenv)->ExceptionClear(jenv);
    (*jenv)->PopLocalFrame(jenv, NULL);
    return SA_ERROR_OOM;
  }

  jbyte *byte = (*jenv)->GetByteArrayElements(jenv, bytearray, NULL);
  if (!byte) {
    (*jenv)->PopLocalFrame(jenv, NULL);
    return SA_ERROR_OOM;
  }

  memcpy(byte, data, nbytes);

  size_t wroteSoFar = 0;
  jint retval;

  do {
    retval = (*jenv)->CallIntMethod(jenv,
                                    s->output_unit,
                                    at.write,
                                    bytearray,
                                    wroteSoFar,
                                    nbytes - wroteSoFar);
    if (retval < 0) {
      ALOG("%x - Write failed %d", s, retval);
      break;
    }

    wroteSoFar += retval;

    if (wroteSoFar != nbytes) {

      /* android doesn't start playing until we explictly call play. */
      if (!s->isPaused)
	sa_stream_resume(s);

      struct timespec ts = {0, 100000000}; /* .10s */
      nanosleep(&ts, NULL);
    }
  } while(wroteSoFar < nbytes);

  s->amountWritten += nbytes;

  (*jenv)->ReleaseByteArrayElements(jenv, bytearray, byte, 0);

  (*jenv)->PopLocalFrame(jenv, NULL);

  return retval < 0 ? SA_ERROR_INVALID : SA_SUCCESS;
}