Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e0f0b08a authored by Andreas Huber's avatar Andreas Huber
Browse files

Squashed commit of the following: 

commit 3fa5f3ce910f34da0cedb8bcce1bd593db7eb740
Author: Andreas Huber <andih@google.com>
Date:   Thu Aug 27 14:48:54 2009 -0700

    Getting rid of more code now obsolete with the departure of OMXDecoder.

commit e0d923ec0c7bb60bec8eb97739036a4c70c0feef
Author: Andreas Huber <andih@google.com>
Date:   Thu Aug 27 14:33:06 2009 -0700

    Remove obsoleted OMXDecoder class. OMXDecoder is dead, long live OMXCodec.
parent 152755d2

cmds/stagefright/Android.mk

+0 −20
Original line number Diff line number Diff line
@@ -38,23 +38,3 @@ LOCAL_CFLAGS += -Wno-multichar 
LOCAL_MODULE:= record



include $(BUILD_EXECUTABLE)
 


################################################################################



# include $(CLEAR_VARS)

# 

# LOCAL_SRC_FILES:=         \

#         play.cpp

# 

# LOCAL_SHARED_LIBRARIES := \

# 	libstagefright

# 

# LOCAL_C_INCLUDES:= \

# 	frameworks/base/media/libstagefright \

# 	$(TOP)/external/opencore/extern_libs_v2/khronos/openmax/include

# 

# LOCAL_CFLAGS += -Wno-multichar

# 

# LOCAL_MODULE:= play

# 

# include $(BUILD_EXECUTABLE)

cmds/stagefright/play.cpp

deleted100644 → 0
+0 −295
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2009 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <binder/ProcessState.h>

#include <media/stagefright/OMXClient.h>

#include <media/stagefright/TimedEventQueue.h>

#include <media/stagefright/MPEG4Extractor.h>

#include <media/stagefright/MediaSource.h>

#include <media/stagefright/MetaData.h>

#include <media/stagefright/MmapSource.h>

#include <media/stagefright/OMXDecoder.h>



using namespace android;



struct NewPlayer {

    NewPlayer();

    ~NewPlayer();



    void setSource(const char *uri);

    void start();

    void pause();

    void stop();



private:

    struct PlayerEvent : public TimedEventQueue::Event {

        PlayerEvent(NewPlayer *player,

                    void (NewPlayer::*method)(int64_t realtime_us))

            : mPlayer(player),

              mMethod(method) {

        }



        virtual void fire(TimedEventQueue *queue, int64_t realtime_us) {

            (mPlayer->*mMethod)(realtime_us);

        }



    private:

        NewPlayer *mPlayer;

        void (NewPlayer::*mMethod)(int64_t realtime_us);



        PlayerEvent(const PlayerEvent &);

        PlayerEvent &operator=(const PlayerEvent &);

    };



    struct PlayVideoFrameEvent : public TimedEventQueue::Event {

        PlayVideoFrameEvent(NewPlayer *player, MediaBuffer *buffer)

            : mPlayer(player),

              mBuffer(buffer) {

        }



        virtual ~PlayVideoFrameEvent() {

            if (mBuffer != NULL) {

                mBuffer->release();

                mBuffer = NULL;

            }

        }



        virtual void fire(TimedEventQueue *queue, int64_t realtime_us) {

            mPlayer->onPlayVideoFrame(realtime_us, mBuffer);

            mBuffer = NULL;

        }



    private:

        NewPlayer *mPlayer;

        MediaBuffer *mBuffer;



        PlayVideoFrameEvent(const PlayVideoFrameEvent &);

        PlayVideoFrameEvent &operator=(const PlayVideoFrameEvent &);

    };



    OMXClient mClient;



    MPEG4Extractor *mExtractor;

    MediaSource *mAudioSource;

    OMXDecoder *mAudioDecoder;

    MediaSource *mVideoSource;

    OMXDecoder *mVideoDecoder;



    int32_t mVideoWidth, mVideoHeight;



    TimedEventQueue mQueue;

    wp<TimedEventQueue::Event> mPlayVideoFrameEvent;



    int64_t mMediaTimeUsStart;

    int64_t mRealTimeUsStart;



    void setAudioSource(MediaSource *source);

    void setVideoSource(MediaSource *source);



    int64_t approxRealTime(int64_t mediatime_us) const;



    void onStart(int64_t realtime_us);

    void onPause(int64_t realtime_us);

    void onFetchVideoFrame(int64_t realtime_us);

    void onPlayVideoFrame(int64_t realtime_us, MediaBuffer *buffer);



    static int64_t getMediaBufferTimeUs(MediaBuffer *buffer);



    NewPlayer(const NewPlayer &);

    NewPlayer &operator=(const NewPlayer &);

};



NewPlayer::NewPlayer()

    : mExtractor(NULL),

      mAudioSource(NULL),

      mAudioDecoder(NULL),

      mVideoSource(NULL),

      mVideoDecoder(NULL),

      mVideoWidth(0),

      mVideoHeight(0) {

    status_t err = mClient.connect();

    assert(err == OK);

}



NewPlayer::~NewPlayer() {

    stop();



    mClient.disconnect();

}



void NewPlayer::setSource(const char *uri) {

    stop();



    mExtractor = new MPEG4Extractor(new MmapSource(uri));



    int num_tracks;

    status_t err = mExtractor->countTracks(&num_tracks);

    assert(err == OK);



    for (int i = 0; i < num_tracks; ++i) {

        const sp<MetaData> meta = mExtractor->getTrackMetaData(i);

        assert(meta != NULL);



        const char *mime;

        if (!meta->findCString(kKeyMIMEType, &mime)) {

            continue;

        }



        bool is_audio = false;

        bool is_acceptable = false;

        if (!strncasecmp(mime, "audio/", 6)) {

            is_audio = true;

            is_acceptable = (mAudioSource == NULL);

        } else if (!strncasecmp(mime, "video/", 6)) {

            is_acceptable = (mVideoSource == NULL);

        }



        if (!is_acceptable) {

            continue;

        }



        MediaSource *source;

        if (mExtractor->getTrack(i, &source) != OK) {

            continue;

        }



        if (is_audio) {

            setAudioSource(source);

        } else {

            setVideoSource(source);

        }

    }

}



void NewPlayer::setAudioSource(MediaSource *source) {

    mAudioSource = source;



    sp<MetaData> meta = source->getFormat();



    mAudioDecoder = OMXDecoder::Create(&mClient, meta);

    mAudioDecoder->setSource(source);

}



void NewPlayer::setVideoSource(MediaSource *source) {

    mVideoSource = source;



    sp<MetaData> meta = source->getFormat();



    bool success = meta->findInt32(kKeyWidth, &mVideoWidth);

    assert(success);



    success = meta->findInt32(kKeyHeight, &mVideoHeight);

    assert(success);



    mVideoDecoder = OMXDecoder::Create(&mClient, meta);

    mVideoDecoder->setSource(source);

}



void NewPlayer::start() {

    mQueue.start();

    mQueue.postEvent(new PlayerEvent(this, &NewPlayer::onStart));

}



void NewPlayer::pause() {

    mQueue.postEvent(new PlayerEvent(this, &NewPlayer::onPause));

}



void NewPlayer::stop() {

    mQueue.stop();



    delete mVideoDecoder;

    mVideoDecoder = NULL;

    delete mVideoSource;

    mVideoSource = NULL;

    mVideoWidth = mVideoHeight = 0;



    delete mAudioDecoder;

    mAudioDecoder = NULL;

    delete mAudioSource;

    mAudioSource = NULL;



    delete mExtractor;

    mExtractor = NULL;

}



int64_t NewPlayer::approxRealTime(int64_t mediatime_us) const {

    return mRealTimeUsStart + (mediatime_us - mMediaTimeUsStart);

}



void NewPlayer::onStart(int64_t realtime_us) {

    mRealTimeUsStart = TimedEventQueue::getRealTimeUs();



    if (mVideoDecoder != NULL) {

        mQueue.postEvent(new PlayerEvent(this, &NewPlayer::onFetchVideoFrame));

    }

}



void NewPlayer::onFetchVideoFrame(int64_t realtime_us) {

    MediaBuffer *buffer;

    status_t err = mVideoDecoder->read(&buffer);

    assert(err == OK);



    int64_t mediatime_us = getMediaBufferTimeUs(buffer);



    sp<TimedEventQueue::Event> event = new PlayVideoFrameEvent(this, buffer);

    mPlayVideoFrameEvent = event;



    mQueue.postTimedEvent(event, approxRealTime(mediatime_us));

}



// static

int64_t NewPlayer::getMediaBufferTimeUs(MediaBuffer *buffer) {

    int32_t units, scale;

    bool success =

        buffer->meta_data()->findInt32(kKeyTimeUnits, &units);

    assert(success);

    success =

        buffer->meta_data()->findInt32(kKeyTimeScale, &scale);

    assert(success);



    return (int64_t)units * 1000000 / scale;

}



void NewPlayer::onPlayVideoFrame(int64_t realtime_us, MediaBuffer *buffer) {

    LOGI("playing video frame (mediatime: %.2f sec)\n",

         getMediaBufferTimeUs(buffer) / 1E6);

    fflush(stdout);



    buffer->release();

    buffer = NULL;



    mQueue.postEvent(new PlayerEvent(this, &NewPlayer::onFetchVideoFrame));

}



void NewPlayer::onPause(int64_t realtime_us) {

}



int main(int argc, char **argv) {

    android::ProcessState::self()->startThreadPool();



    if (argc != 2) {

        fprintf(stderr, "usage: %s filename\n", argv[0]);

        return 1;

    }



    NewPlayer player;

    player.setSource(argv[1]);

    player.start();

    sleep(10);

    player.stop();



    return 0;

}

cmds/stagefright/record.cpp

+0 −13
Original line number Diff line number Diff line
@@ -26,7 +26,6 @@ 
#include <media/stagefright/MmapSource.h>

#include <media/stagefright/OMXClient.h>

#include <media/stagefright/OMXCodec.h>

#include <media/stagefright/OMXDecoder.h>



using namespace android;
@@ -87,8 +86,6 @@ private: 
    DummySource &operator=(const DummySource &);

};



#define USE_OMX_CODEC   1



sp<MediaSource> createSource(const char *filename) {

    sp<MediaSource> source;
@@ -140,13 +137,8 @@ int main(int argc, char **argv) { 


    sp<MetaData> meta = source->getFormat();



#if USE_OMX_CODEC

    sp<OMXCodec> decoder = OMXCodec::Create(

            client.interface(), meta, false /* createEncoder */, source);

#else

    sp<OMXDecoder> decoder = OMXDecoder::Create(

            &client, meta, false /* createEncoder */, source);

#endif



    int width, height;

    bool success = meta->findInt32(kKeyWidth, &width);
@@ -164,14 +156,9 @@ int main(int argc, char **argv) { 
    enc_meta->setInt32(kKeyWidth, width);

    enc_meta->setInt32(kKeyHeight, height);



#if USE_OMX_CODEC

    sp<OMXCodec> encoder =

        OMXCodec::Create(

                client.interface(), enc_meta, true /* createEncoder */, decoder);

#else

    sp<OMXDecoder> encoder = OMXDecoder::Create(

            &client, enc_meta, true /* createEncoder */, decoder);

#endif



#if 1

    sp<MPEG4Writer> writer = new MPEG4Writer("/sdcard/output.mp4");

cmds/stagefright/stagefright.cpp

+0 −8
Original line number Diff line number Diff line
@@ -33,7 +33,6 @@ 
#include <media/stagefright/MmapSource.h>

#include <media/stagefright/OMXClient.h>

#include <media/stagefright/OMXCodec.h>

#include <media/stagefright/OMXDecoder.h>



#include "JPEGSource.h"
@@ -50,18 +49,11 @@ static int64_t getNowUs() { 
    return (int64_t)tv.tv_usec + tv.tv_sec * 1000000;

}



#define USE_OMX_CODEC   1



static void playSource(OMXClient *client, const sp<MediaSource> &source) {

    sp<MetaData> meta = source->getFormat();



#if !USE_OMX_CODEC

    sp<OMXDecoder> decoder = OMXDecoder::Create(

            client, meta, false /* createEncoder */, source);

#else

    sp<OMXCodec> decoder = OMXCodec::Create(

            client->interface(), meta, false /* createEncoder */, source);

#endif



    if (decoder == NULL) {

        return;

include/media/IOMX.h

+3 −16
Original line number Diff line number Diff line
@@ -119,12 +119,6 @@ struct omx_message { 
        EMPTY_BUFFER_DONE,

        FILL_BUFFER_DONE,



        // reserved for OMXDecoder use.

        START,

        INITIAL_FILL_BUFFER,



        // reserved for OMXObserver use.

        QUIT_OBSERVER,

    } type;



    IOMX::node_id node;
@@ -137,28 +131,21 @@ struct omx_message { 
            OMX_U32 data2;

        } event_data;



        // if type == EMPTY_BUFFER_DONE || type == FILL_BUFFER

        //    || type == INITIAL_FILL_BUFFER

        // if type == EMPTY_BUFFER_DONE

        struct {

            IOMX::buffer_id buffer;

        } buffer_data;



        // if type == EMPTY_BUFFER || type == FILL_BUFFER_DONE

        // if type == FILL_BUFFER_DONE

        struct {

            IOMX::buffer_id buffer;

            OMX_U32 range_offset;

            OMX_U32 range_length;

            OMX_U32 flags;

            OMX_TICKS timestamp;

            OMX_PTR platform_private;  // ignored if type == EMPTY_BUFFER

            OMX_PTR platform_private;

        } extended_buffer_data;



        // if type == SEND_COMMAND

        struct {

            OMX_COMMANDTYPE cmd;

            OMX_S32 param;

        } send_command_data;



    } u;

};