NATIVES_SRC: media_decoder.cpp

/*
 * media_messages.cpp
 *
 *  Created on: Aug 18, 2009
 *      Author: nenko
 */

#include "media_decoder.h"

MediaBridge BRIDGE;
Decoder DECODER;

static int sophie_media_open(URLContext *h, const char *filename, int flags);
static int sophie_media_read(URLContext *h, unsigned char *buf, int size);
static int sophie_media_write(URLContext *h, unsigned char *buf, int size);
static int64_t sophie_media_seek(URLContext *h, int64_t pos, int whence);
static int sophie_media_close(URLContext *h);

// smp = SophieMediaProtocol is misleding
// (SMP - Simple Management Protocol, Smart Messaging Protocol)
// changing to sophie
URLProtocol SOPHIE_PROTOCOL = { "sophie", sophie_media_open, sophie_media_read, sophie_media_write, sophie_media_seek, sophie_media_close, };

struct Sophie2MediaContext {
        int pos;
};

//Sophie2 Media Protocol
static int sophie_media_open(URLContext *h, const char *filename, int flags) {
        Sophie2MediaContext *s = (Sophie2MediaContext*) av_malloc(sizeof(Sophie2MediaContext));
        s->pos = 0;
        //      if (!s) {
        //              return AVERROR(ENOMEM);
        //      }
        h->priv_data = s;

        return 0;
}

static int sophie_media_read(URLContext *h, unsigned char *buf, int size) {
        Sophie2MediaContext *s = (Sophie2MediaContext *) h->priv_data;

        int fileSize = DECODER.fileSize;

        if (s->pos + size > fileSize) {
                size = fileSize - s->pos;
        }
        Response res = MediaResponse::createRequestBytes(s->pos, size);
        BRIDGE.sendResponse(res);
        Command *cmd = BRIDGE.readCommand();
        if (cmd->getId() == STOP_COMMAND_ID) {
                        BRIDGE.sendResponse(BRIDGE.doStop());
                        exit(0);
        }
        assert(cmd->getId() == SEND_BYTES_COMMAND);
        SendBytesCommand *bytesCmd = (SendBytesCommand *) cmd;
        assert(s->pos == bytesCmd->filePos);
        assert(size == (int)bytesCmd->fileData.size());
        int len = min(int(bytesCmd->fileData.size()), size);

        memcpy(buf, (char *) &bytesCmd->fileData[0], len);

        s->pos += len;

        delete bytesCmd;

        return len;
}

static int sophie_media_write(URLContext *h, unsigned char *buf, int size) {
        //No writting... for now
        return -1;
}

static int64_t sophie_media_seek(URLContext *h, int64_t pos, int whence) {
        Sophie2MediaContext *s = (Sophie2MediaContext *) h->priv_data;

        switch(whence) {
                case SEEK_SET:
                        s->pos = pos;
                        break;
                case SEEK_CUR:
                        s->pos += pos;
                        break;
                case SEEK_END:
                        s->pos = DECODER.fileSize + pos;
                        break;
                case AVSEEK_SIZE:
                        return DECODER.fileSize;
                default:
                        assert(false);
        }

        return s->pos;
}

static int sophie_media_close(URLContext *h) {
        Sophie2MediaContext *s = (Sophie2MediaContext*) h->priv_data;
        av_free(s);

        return 0;

}

Response OpenCommand::execute() {
        fprintf(stderr, "executing open command (used to be-media_decoder.open())...\n");
        assert(!DECODER.isOpen);

        DECODER.fileSize = this->fileSize;
        DECODER.isOpen = false;

        //const char * filename = "/home/stefan/media_redesign_workspace/june_chorus.wav";//"smp:///a";
        string filename = "sophie:///a";

        av_register_all();
        av_register_protocol(&SOPHIE_PROTOCOL);

        fprintf(stderr, "opening input file...\n");
        if (av_open_input_file(&DECODER.pFormatContext, filename.c_str(), NULL, 0, NULL) != 0) {
                fprintf(stderr, "ERROR opening input file...\n");
                throw runtime_error("Decoder::open - Cannot open input file!");
        }

        fprintf(stderr, "finding Streams of input file...\n");
        if (av_find_stream_info(DECODER.pFormatContext) < 0) {
                throw runtime_error("Decoder::open - Cannot find stream info!");
        }

        DECODER.videoStream = -1;
        DECODER.audioStream = -1;
        for (int i = 0; i < int(DECODER.pFormatContext->nb_streams); i++) {
                if (DECODER.pFormatContext->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO) {
                        DECODER.videoStream = i;
                }
                if (DECODER.pFormatContext->streams[i]->codec->codec_type == CODEC_TYPE_AUDIO && DECODER.audioStream < 0) {
                        DECODER.audioStream = i;
                }
                if (DECODER.videoStream != -1 && DECODER.audioStream != -1) {
                        break;
                }
        }

        if (DECODER.videoStream != -1) {
                fprintf(stderr, "Video stream found!\n");
                DECODER.initVideo();
        }

        if (DECODER.audioStream != -1) {
                fprintf(stderr, "Audio stream found!\n");
                DECODER.initAudio();
        }
        DECODER.isOpen = true;
        DECODER.shifted = true;
        DECODER.lastVideoMillis = -1;
        DECODER.lastVideoDur = -1;

        //insufficient info
        fprintf(stderr, "\n");
        dump_format(DECODER.pFormatContext, 0, filename.c_str(), 0);
        return Response::createOk();
}

Response GetFrameCommand::execute() {
        vector<byte> data;
        int width = DECODER.pVideoCodecCtx->width;
        int height = DECODER.pVideoCodecCtx->height;
        DECODER.getFrame(data, timeMillis);
        return MediaResponse::createFrame(data, width, height);
}

Response GetAudioCommand::execute() {
        vector<byte> chunk = DECODER.getAudio(timeMillis);
        return MediaResponse::createAudio(chunk, timeMillis);
}

Response GetInfoCommand::execute() {
        int width = 0;
        int height = 0;
        AVRational frameRate;
        bool hasAudio = false;
        if(DECODER.videoStream >= 0) {
                width = DECODER.pVideoCodecCtx->width;
                height = DECODER.pVideoCodecCtx->height;
                frameRate = DECODER.pFormatContext->streams[DECODER.videoStream]->r_frame_rate;
        }
        if(DECODER.audioStream >= 0) {
                hasAudio = true;
        }
        int duration = DECODER.pFormatContext->duration * 1000 / AV_TIME_BASE;

        return MediaResponse::createVideoInfo(width, height, duration, frameRate, hasAudio);

}

int main() {
        cerr << "Starting media_decoder" << endl;
        BRIDGE.mainLoop();
        return 0;
}