Home | History | Annotate | Download | only in omxjpegdecoder 
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_TAG "OmxJpegDecoder"
     18 #include <sys/time.h>
     19 #include <utils/Log.h>
     20 
     21 #include <stdlib.h>
     22 #include <string.h>
     23 #include <unistd.h>
     24 
     25 #include <binder/IServiceManager.h>
     26 #include <binder/ProcessState.h>
     27 #include <media/IMediaPlayerService.h>
     28 #include <media/stagefright/foundation/ADebug.h>
     29 #include <media/stagefright/MediaSource.h>
     30 #include <media/stagefright/MetaData.h>
     31 #include <media/stagefright/OMXClient.h>
     32 #include <media/stagefright/OMXCodec.h>
     33 #include <SkImage.h>
     34 #include <SkMallocPixelRef.h>
     35 
     36 #include "omx_jpeg_decoder.h"
     37 #include "StreamSource.h"
     38 
     39 using namespace android;
     40 
     41 static void getJpegOutput(MediaBuffer* buffer, const char* filename) {
     42     int size = buffer->range_length();
     43     int offset = buffer->range_offset();
     44     FILE *pFile = fopen(filename, "w+");
     45 
     46     if (pFile == NULL) {
     47         printf("Error: cannot open %s.\n", filename);
     48     } else {
     49         char* data = (char*) buffer->data();
     50         data += offset;
     51         while (size > 0) {
     52             int numChars = fwrite(data, sizeof(char), 1024, pFile);
     53             int numBytes = numChars * sizeof(char);
     54             size -= numBytes;
     55             data += numBytes;
     56         }
     57         fclose(pFile);
     58     }
     59     return;
     60 }
     61 
     62 extern int storeBitmapToFile(SkBitmap* bitmap, const char* filename) {
     63     bitmap->lockPixels();
     64     uint8_t* data = (uint8_t *)bitmap->getPixels();
     65     int size = bitmap->getSize();
     66     FILE* fp = fopen(filename, "w+");
     67 
     68     if (NULL == fp) {
     69         printf("Cannot open the output file! \n");
     70         return -1;
     71     } else {
     72         while (size > 0) {
     73             int numChars = fwrite(data, sizeof(char), 1024, fp);
     74             int numBytes = numChars * sizeof(char);
     75             size -= numBytes;
     76             data += numBytes;
     77         }
     78         fclose(fp);
     79     }
     80     return 0;
     81 }
     82 
     83 static int64_t getNowUs() {
     84     struct timeval tv;
     85     gettimeofday(&tv, NULL);
     86 
     87     return (int64_t)tv.tv_usec + tv.tv_sec * 1000000;
     88 }
     89 
     90 OmxJpegImageDecoder::OmxJpegImageDecoder() {
     91     status_t err = mClient.connect();
     92     CHECK_EQ(err, (status_t)OK);
     93 }
     94 
     95 OmxJpegImageDecoder::~OmxJpegImageDecoder() {
     96     mClient.disconnect();
     97 }
     98 
     99 bool OmxJpegImageDecoder::onDecode(SkStream* stream,
    100         SkBitmap* bm, Mode mode) {
    101     sp<MediaSource> source = prepareMediaSource(stream);
    102     sp<MetaData> meta = source->getFormat();
    103     int width;
    104     int height;
    105     meta->findInt32(kKeyWidth, &width);
    106     meta->findInt32(kKeyHeight, &height);
    107     configBitmapSize(
    108             bm, getPrefColorType(k32Bit_SrcDepth, false),
    109             width, height);
    110 
    111     // mode == DecodeBounds
    112     if (mode == SkImageDecoder::kDecodeBounds_Mode) {
    113         return true;
    114     }
    115 
    116     // mode == DecodePixels
    117     if (!this->allocPixelRef(bm, NULL)) {
    118         ALOGI("Cannot allocPixelRef()!");
    119         return false;
    120     }
    121 
    122     sp<MediaSource> decoder = getDecoder(&mClient, source);
    123     return decodeSource(decoder, source, bm);
    124 }
    125 
    126 JPEGSource* OmxJpegImageDecoder::prepareMediaSource(SkStream* stream) {
    127     DataSource::RegisterDefaultSniffers();
    128     sp<DataSource> dataSource = new StreamSource(stream);
    129     return new JPEGSource(dataSource);
    130 }
    131 
    132 sp<MediaSource> OmxJpegImageDecoder::getDecoder(
    133         OMXClient *client, const sp<MediaSource>& source) {
    134     sp<MetaData> meta = source->getFormat();
    135     sp<MediaSource> decoder = OMXCodec::Create(
    136             client->interface(), meta, false /* createEncoder */, source);
    137 
    138     CHECK(decoder != NULL);
    139     return decoder;
    140 }
    141 
    142 bool OmxJpegImageDecoder::decodeSource(sp<MediaSource> decoder,
    143         const sp<MediaSource>& source, SkBitmap* bm) {
    144     status_t rt = decoder->start();
    145     if (rt != OK) {
    146         ALOGE("Cannot start OMX Decoder!");
    147         return false;
    148     }
    149     int64_t startTime = getNowUs();
    150     MediaBuffer *buffer;
    151 
    152     // decode source
    153     status_t err = decoder->read(&buffer, NULL);
    154     int64_t duration = getNowUs() - startTime;
    155 
    156     if (err != OK) {
    157         CHECK(buffer == NULL);
    158     }
    159     printf("Duration in decoder->read(): %.1f (msecs). \n",
    160                 duration / 1E3 );
    161 
    162     // Copy pixels from buffer to bm.
    163     // May need to check buffer->rawBytes() == bm->rawBytes().
    164     CHECK_EQ(buffer->size(), bm->getSize());
    165     memcpy(bm->getPixels(), buffer->data(), buffer->size());
    166     buffer->release();
    167     decoder->stop();
    168 
    169     return true;
    170 }
    171 
    172 void OmxJpegImageDecoder::configBitmapSize(SkBitmap* bm, SkColorType pref,
    173         int width, int height) {
    174     // Set the color space to ARGB_8888 for now (ignoring pref)
    175     // because of limitation in hardware support.
    176     bm->setInfo(SkImageInfo::MakeN32(width, height, kOpaque_SkAlphaType));
    177 }
    178