modules/rvc_dec/rvc

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
RVCD_AttachStream
RVCD_DetachStream
RVCD_GetCapabilities
RVCD_SetCapabilities
RVCD_ProcessData
RVCD_CanHandleStream
RVCD_GetCodecName
NewRVCDec
DeleteRVCDec
QueryInterfaces
LoadInterface
ShutdownInterface
/*
 *                      GPAC - Multimedia Framework C SDK
 *
 *                      Authors: Jean Le Feuvre
 *                      Copyright (c) Telecom ParisTech 2010-2012
 *                                      All rights reserved
 *
 *  This file is part of GPAC / OpenSVC Decoder module
 *
 *  GPAC is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  GPAC is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */


#include <gpac/modules/codec.h>
#include <gpac/avparse.h>
#include <gpac/constants.h>

#ifdef WIN32
#define DllImport __declspec( dllimport )


#if !defined(__GNUC__)
#  pragma comment(lib, "RVCDecoder")
#endif

#else
#define DllImport
#endif



typedef struct {
        int Width;
        int Height;
        unsigned char* pY[1];
        unsigned char* pU[1];
        unsigned char* pV[1];
} RVCFRAME;


DllImport int rvc_init(char* XDF, char* VTLFolder, int isAVCFile);
DllImport int rvc_decode(unsigned char* nal, int nal_length, char *outBuffer, int newBuffer);
DllImport void rvc_close();


typedef struct
{
        u16 ES_ID;
        u32 width, stride, height, out_size, pixel_ar, layer;
        Bool first_frame;

        u32 nalu_size_length;

        void *codec;
} RVCDec;


static GF_Err RVCD_AttachStream(GF_BaseDecoder *ifcg, GF_ESD *esd)
{
        u32 i, count;
        s32 res;
        char Picture;
        RVCDec *ctx = (RVCDec*) ifcg->privateStack;
        char* VTLFolder;
        char *XDF_doc = NULL;
        int isNALUFile;

        /*not supported in this version*/
        if (esd->dependsOnESID) return GF_NOT_SUPPORTED;

        ctx->ES_ID = esd->ESID;
        ctx->width = ctx->height = ctx->out_size = 0;

        VTLFolder = (char *)gf_modules_get_option((GF_BaseInterface *)ifcg, "RVCDecoder", "VTLPath");
        if (!VTLFolder) {
                GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[RVC Decoder] Cannot locate VTL: path is unknown. Please indicate path in GPAC config file:\n[RVCDecoder]\nVTLPath=PATH\n"));
                return GF_SERVICE_ERROR;
        } else {
                GF_LOG(GF_LOG_INFO, GF_LOG_CODEC, ("[RVC Decoder] Using VTL in %s\n", VTLFolder));
        }

        /*initialize RVC*/
        if (esd->decoderConfig->predefined_rvc_config) {
                char opt[100], *path;
                FILE *f;
                u32 size;
                sprintf(opt, "Predefined_%d", esd->decoderConfig->predefined_rvc_config);
                path = (char *) gf_modules_get_option((GF_BaseInterface *)ifcg, "RVCDecoder", (const char *)opt);
                if (!opt) return GF_NOT_SUPPORTED;
                f = gf_fopen(path, "rt");
                if (!f) return GF_NOT_SUPPORTED;
                fseek(f, 0, SEEK_END);
                size = ftell(f);
                fseek(f, 0, SEEK_SET);
                XDF_doc = gf_malloc(sizeof(char)*(size+1));
                if (!XDF_doc) {
                        gf_fclose(f);
                        return GF_OUT_OF_MEM;
                }
                fread(XDF_doc, 1, size, f);
                gf_fclose(f);
                XDF_doc[size]=0;
        } else {
                if (!esd->decoderConfig->rvc_config)
                        return GF_NOT_SUPPORTED;
                XDF_doc = esd->decoderConfig->rvc_config->data;
        }


        switch (esd->decoderConfig->objectTypeIndication) {
        case GPAC_OTI_VIDEO_AVC:
        case GPAC_OTI_VIDEO_SVC:
        case GPAC_OTI_VIDEO_HEVC:
        case GPAC_OTI_VIDEO_SHVC:
                isNALUFile = 1;
                break;
        default:
                isNALUFile = 0;
                break;
        }

        rvc_init(XDF_doc, VTLFolder, isNALUFile); //->data contains the uncompressed XDF

        /*free data*/
        gf_free(XDF_doc);
        if (esd->decoderConfig->rvc_config) {
                esd->decoderConfig->rvc_config->data = NULL;
                esd->decoderConfig->rvc_config->dataLength = 0;
        }

        /*decoder config not known, output buffers will be reconfigured at run-time*/
        if (!esd->decoderConfig->decoderSpecificInfo || !esd->decoderConfig->decoderSpecificInfo->data)
                return GF_OK;

        /*initialize the decoder */
        if ( (esd->decoderConfig->objectTypeIndication==GPAC_OTI_VIDEO_AVC) ||  (esd->decoderConfig->objectTypeIndication==GPAC_OTI_VIDEO_SVC)) {
                GF_AVCConfig *cfg = gf_odf_avc_cfg_read(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength);
                if (!cfg) return GF_NON_COMPLIANT_BITSTREAM;
                ctx->nalu_size_length = cfg->nal_unit_size;

                /*decode all NALUs*/
                count = gf_list_count(cfg->sequenceParameterSets);
                for (i=0; i<count; i++) {
                        u32 w, h, par_n, par_d;
                        GF_AVCConfigSlot *slc = gf_list_get(cfg->sequenceParameterSets, i);

                        gf_avc_get_sps_info(slc->data, slc->size, &slc->id, &w, &h, &par_n, &par_d);
                        /*by default use the base layer*/
                        if (!i) {
                                if ((ctx->width<w) || (ctx->height<h)) {
                                        ctx->width = w;
                                        ctx->height = h;
                                        if ( ((s32)par_n>0) && ((s32)par_d>0) )
                                                ctx->pixel_ar = (par_n<<16) || par_d;
                                }
                        }

                        /* call decode*/
                        res = rvc_decode(slc->data, slc->size, &Picture, 1);
                        if (res<0) {
                                GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[RVC Decoder] Error decoding SPS %d\n", res));
                        }
                }

                count = gf_list_count(cfg->pictureParameterSets);
                for (i=0; i<count; i++) {
                        GF_AVCConfigSlot *slc = gf_list_get(cfg->pictureParameterSets, i);
                        res = rvc_decode(slc->data, slc->size, &Picture, 1);
                        if (res<0) {
                                GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[RVC Decoder] Error decoding PPS %d\n", res));
                        }

                }

                gf_odf_avc_cfg_del(cfg);
                /*initialize the decoder */
        } else if ( (esd->decoderConfig->objectTypeIndication==GPAC_OTI_VIDEO_HEVC) ||  (esd->decoderConfig->objectTypeIndication==GPAC_OTI_VIDEO_SHVC)) {
                GF_HEVCConfig *cfg = gf_odf_hevc_cfg_read(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, 0);
                if (!cfg) return GF_NON_COMPLIANT_BITSTREAM;
                ctx->nalu_size_length = cfg->nal_unit_size;

                /*decode all NALUs*/
                count = gf_list_count(cfg->param_array);
                for (i=0; i<count; i++) {
                        u32 j, count2;
                        GF_HEVCParamArray *ar = gf_list_get(cfg->param_array, i);
                        count2 = gf_list_count(ar->nalus);
                        for (j=0; j<count2; j++) {
                                u32 w, h, par_n, par_d;
                                GF_AVCConfigSlot *slc = gf_list_get(ar->nalus, j);

                                if (ar->type==GF_HEVC_NALU_SEQ_PARAM) {
                                        gf_hevc_get_sps_info(slc->data, slc->size, &slc->id, &w, &h, &par_n, &par_d);
                                        /*by default use the base layer*/
                                        if (!j) {
                                                if ((ctx->width<w) || (ctx->height<h)) {
                                                        ctx->width = w;
                                                        ctx->height = h;
                                                        if ( ((s32)par_n>0) && ((s32)par_d>0) )
                                                                ctx->pixel_ar = (par_n<<16) || par_d;
                                                }
                                        }
                                }

                                /* call decode*/
                                res = rvc_decode(slc->data, slc->size, &Picture, 1);
                                if (res<0) {
                                        GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[RVC Decoder] Error decoding parameter set: %d\n", res));
                                }
                        }
                }

                gf_odf_hevc_cfg_del(cfg);
        } else if (esd->decoderConfig->objectTypeIndication==GPAC_OTI_VIDEO_MPEG4_PART2) {
                GF_M4VDecSpecInfo dsi;
                GF_Err e;
                /*decode DSI*/
                e = gf_m4v_get_config(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, &dsi);
                if (e) return e;
                if (!dsi.width || !dsi.height) return GF_NON_COMPLIANT_BITSTREAM;
                ctx->width = dsi.width;
                ctx->height = dsi.height;
                ctx->pixel_ar = (dsi.par_num<<16) | dsi.par_den;


                res = rvc_decode(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, &Picture, 1);
                if (res<0) {
                        GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[RVC Decoder] Error decoding PPS %d\n", res));
                }


        } else {
                /*unknown type, do what you want*/

                res = rvc_decode(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, &Picture, 1);
                if (res<0) {
                        GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[RVC Decoder] Error decoding PPS %d\n", res));
                }

        }
        /*adjust stride to what you decoder uses*/
        ctx->stride = ctx->width;
        /*precompute output buffer size*/
        ctx->out_size = ctx->stride * ctx->height * 3 / 2;
        return GF_OK;
}
static GF_Err RVCD_DetachStream(GF_BaseDecoder *ifcg, u16 ES_ID)
{
        RVCDec *ctx = (RVCDec*) ifcg->privateStack;

        //close RVC decoder
        rvc_close();
        ctx->codec = NULL;
        ctx->width = ctx->height = ctx->out_size = 0;
        return GF_OK;
}
static GF_Err RVCD_GetCapabilities(GF_BaseDecoder *ifcg, GF_CodecCapability *capability)
{
        RVCDec *ctx = (RVCDec*) ifcg->privateStack;

        switch (capability->CapCode) {
        case GF_CODEC_RESILIENT:
                capability->cap.valueInt = 1;
                break;
        case GF_CODEC_WIDTH:
                capability->cap.valueInt = ctx->width;
                break;
        case GF_CODEC_HEIGHT:
                capability->cap.valueInt = ctx->height;
                break;
        case GF_CODEC_STRIDE:
                capability->cap.valueInt = ctx->stride;
                break;
        case GF_CODEC_PAR:
                capability->cap.valueInt = ctx->pixel_ar;
                break;
        case GF_CODEC_OUTPUT_SIZE:
                capability->cap.valueInt = ctx->out_size;
                break;
        case GF_CODEC_PIXEL_FORMAT:
                capability->cap.valueInt = GF_PIXEL_YV12;
                break;
        case GF_CODEC_BUFFER_MIN:
                capability->cap.valueInt = 1;
                break;
        case GF_CODEC_BUFFER_MAX:
                capability->cap.valueInt = 2;
                break;
        case GF_CODEC_PADDING_BYTES:
                capability->cap.valueInt = 32;
                break;
        case GF_CODEC_REORDER:
                capability->cap.valueInt = 1;
                break;
        /*not known at our level...*/
        case GF_CODEC_CU_DURATION:
        default:
                capability->cap.valueInt = 0;
                break;
        }
        return GF_OK;
}
static GF_Err RVCD_SetCapabilities(GF_BaseDecoder *ifcg, GF_CodecCapability capability)
{
        return GF_NOT_SUPPORTED;
}


int bookmark = 0;

static GF_Err RVCD_ProcessData(GF_MediaDecoder *ifcg,
                               char *inBuffer, u32 inBufferLength,
                               u16 ES_ID, u32 *CTS,
                               char *outBuffer, u32 *outBufferLength,
                               u8 PaddingBits, u32 mmlevel)
{
        s32 got_pic;
        RVCDec *ctx = (RVCDec*) ifcg->privateStack;

        if (!ES_ID || (ES_ID!=ctx->ES_ID) /*|| !ctx->codec*/) {
                *outBufferLength = 0;
                return GF_OK;
        }
        if (*outBufferLength < ctx->out_size) {
                *outBufferLength = ctx->out_size;
                return GF_BUFFER_TOO_SMALL;
        }

        //if your decoder outputs directly in the memory passed, setup pointers for your decoder output picture

        got_pic = 0;

        if (ctx->nalu_size_length) {
                u32 i, nalu_size = 0;
                u8 *ptr = inBuffer;
                int nalNumber = 1;

                while (inBufferLength) {
                        for (i=0; i<ctx->nalu_size_length; i++) {
                                nalu_size = (nalu_size<<8) + ptr[i];
                        }
                        ptr += ctx->nalu_size_length;

                        //same remark as above regardin start codes

                        if(nalNumber > bookmark) {
                                got_pic = rvc_decode(ptr, nalu_size, outBuffer, !got_pic);
                                bookmark ++;
                                if(got_pic>1) {
                                        return GF_PACKED_FRAMES;
                                }
                        } else if(nalNumber == bookmark) {
                                got_pic = rvc_decode(NULL, 0, outBuffer, !got_pic);
                                if(got_pic>1) {
                                        return GF_PACKED_FRAMES;
                                }
                        }
                        nalNumber ++;

                        ptr += nalu_size;
                        if (inBufferLength < nalu_size + ctx->nalu_size_length)
                                break;

                        inBufferLength -= nalu_size + ctx->nalu_size_length;
                }
                bookmark = 0;

        } else {
                u32 nalu_size = 0;
                u8 *ptr = inBuffer;


                got_pic = rvc_decode(ptr, inBufferLength, outBuffer, 1);
        }

        //if (got_pic!=1) return GF_OK;

        /*if size changed during the decoding, resize the composition buffer*/
        /*if ((pic.Width != ctx->width) || (pic.Height!=ctx->height))
        {
                ctx->width = pic.Width;
                ctx->stride = pic.Width;
                ctx->height = pic.Height;
                ctx->out_size = ctx->stride * ctx->height * 3 / 2;
                *outBufferLength = ctx->out_size;
                return GF_BUFFER_TOO_SMALL;
        }

        *outBufferLength = ctx->out_size;*/

        /*if your decoder does not output directly in the memory passed, copy over the data*/

        /*memcpy(outBuffer, pic.pY[0], ctx->stride*ctx->height);
        memcpy(outBuffer + ctx->stride * ctx->height, pic.pU[0], ctx->stride*ctx->height/4);
        memcpy(outBuffer + 5*ctx->stride * ctx->height/4, pic.pV[0], ctx->stride*ctx->height/4);*/

        if(got_pic>1) return GF_PACKED_FRAMES;
        return GF_OK;
}

static u32 RVCD_CanHandleStream(GF_BaseDecoder *dec, u32 StreamType, GF_ESD *esd, u8 PL)
{
        if (StreamType != GF_STREAM_VISUAL) return GF_CODEC_NOT_SUPPORTED;
        /*media type query*/
        if (!esd) return GF_CODEC_STREAM_TYPE_SUPPORTED;
        switch (esd->decoderConfig->objectTypeIndication) {
        case GPAC_OTI_VIDEO_AVC:
        case GPAC_OTI_VIDEO_SVC:
        case GPAC_OTI_VIDEO_MPEG4_PART2:
        case GPAC_OTI_VIDEO_HEVC:
        case GPAC_OTI_VIDEO_SHVC:
                if (!esd->decoderConfig->rvc_config && !esd->decoderConfig->predefined_rvc_config) return GF_CODEC_NOT_SUPPORTED;
                return GF_CODEC_SUPPORTED+1;
        }
        return GF_CODEC_NOT_SUPPORTED;
}

static const char *RVCD_GetCodecName(GF_BaseDecoder *dec)
{
        return "Reconfigurable Video Decoder";
}

GF_BaseDecoder *NewRVCDec()
{
        GF_MediaDecoder *ifcd;
        RVCDec *dec;

        GF_SAFEALLOC(ifcd, GF_MediaDecoder);
        GF_SAFEALLOC(dec, RVCDec);
        GF_REGISTER_MODULE_INTERFACE(ifcd, GF_MEDIA_DECODER_INTERFACE, "RVC Decoder", "gpac distribution")

        ifcd->privateStack = dec;

        /*setup our own interface*/
        ifcd->AttachStream = RVCD_AttachStream;
        ifcd->DetachStream = RVCD_DetachStream;
        ifcd->GetCapabilities = RVCD_GetCapabilities;
        ifcd->SetCapabilities = RVCD_SetCapabilities;
        ifcd->GetName = RVCD_GetCodecName;
        ifcd->CanHandleStream = RVCD_CanHandleStream;
        ifcd->ProcessData = RVCD_ProcessData;
        return (GF_BaseDecoder *) ifcd;
}

void DeleteRVCDec(GF_BaseDecoder *ifcg)
{
        RVCDec *ctx = (RVCDec*) ifcg->privateStack;
        gf_free(ctx);
        gf_free(ifcg);
}

GPAC_MODULE_EXPORT
const u32 *QueryInterfaces()
{
        static u32 si [] = {
#ifndef GPAC_DISABLE_AV_PARSERS
                GF_MEDIA_DECODER_INTERFACE,
#endif
                0
        };
        return si;
}

GPAC_MODULE_EXPORT
GF_BaseInterface *LoadInterface(u32 InterfaceType)
{
#ifndef GPAC_DISABLE_AV_PARSERS
        if (InterfaceType == GF_MEDIA_DECODER_INTERFACE) return (GF_BaseInterface *)NewRVCDec();
#endif
        return NULL;
}

GPAC_MODULE_EXPORT
void ShutdownInterface(GF_BaseInterface *ifce)
{
        switch (ifce->InterfaceType) {
#ifndef GPAC_DISABLE_AV_PARSERS
        case GF_MEDIA_DECODER_INTERFACE:
                DeleteRVCDec((GF_BaseDecoder*)ifce);
                break;
#endif
        }
}


GPAC_MODULE_STATIC_DECLARATION( rev_dec )
/* [<][>][^][v][top][bottom][index][help] */
root/modules/rvc_dec/rvc_dec.c

DEFINITIONS
