Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

Video4LinuxContainerFile.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       Video4LinuxContainerFile.cpp                                        *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program 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 General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#include <string.h>

#include "Video4LinuxContainerFile.hpp"
#include "ContainerInfo.hpp"
#include "VideoESInfo.hpp"
#include "AudioESInfo.hpp"
#include "DataChannel.hpp"
#include "DataSink.hpp"
#include "Adaptor.hpp"
#include "AdaptorChain.hpp"
#include "MP3Parser.hpp"

#include "../adaptors/MP4Decoder.hpp"

#include "../io/DevNull.hpp"
#include "../io/MPGStreamIO.hpp"

#include "../net/Url.hpp"
#include "../net/SDP.hpp"
#include <malloc.h>

/* This structure is there temporarily .... I know it looks ugly.
   will be removed when FFmpeg becomes consistent in providing
   all required parameters
*/
struct stInfo {
        CodecID codec_id;     //eg. CODEC_ID_MPEG4==15,...
        float rate;                             //frame_rate for Video; sample_rate for audio
        long size;                                  //size of Elementary Stream
        u32 packet_size;
        int totalSamples;                       //total samples in ES
        long avgBitRate;                
        u32 bits_per_sample;    //bits per sample of uncompressed wave frame (eg. 16)
        u32 channels;         //audio only (eg. 2...stereo)
        u32 packetDuration;
        float duration;                         //duration of ES in ticks
        float test_duration;  //used internally for calculation               
        bool done;            //       -do-
};
static stInfo strm[MAX_STREAMS];                        

static AVFormatContext *input_files[MAX_STREAMS];
static int nb_input_files = 0;

//Some default values need to be declared here;
static int frame_width  = 720;
static int frame_height = 576;
static int frame_rate = 25; /*@ * FRAME_RATE_BASE;*/
static int frame_rate_base = 1;
static int audio_sample_rate = 44100;
static int audio_channels = 2;

static char *video_grab_format = "video4linux";
static char *video_device = NULL;
static int video_channel = 0;
static char *video_standard = "ntsc";

static char *audio_grab_format = "audio_device";
static char *audio_device = NULL;
        
/**********************************************************/
ContainerInfo *Video4LinuxContainerFile::loadContainerInfo() {
        int streamcnt;
        
        ContainerInfo * result = new ContainerInfo(NULL,"", ContainerInfo::MP4);


        dprintf_full("Video4LinuxContainerFile::loadContainerInfo\n");
        

        AVInputFormat *viformat = NULL;
        AVInputFormat *aiformat = NULL;
        AVFormatContext **ic = (AVFormatContext**)malloc(2*sizeof(AVFormatContext**));
        
        AVFormatParameters vp1, *vp = &vp1;
        AVFormatParameters ap1, *ap = &ap1;
        
        
        // set some default parameters if required 
        
        memset(ap, 0, sizeof(*ap));
        memset(vp, 0, sizeof(*vp));
        
        
        ap->sample_rate = audio_sample_rate;
        ap->channels = audio_channels;
        //      vp->frame_rate = frame_rate;
        vp->width = frame_width;
        vp->height = frame_height;
        vp->time_base = AV_TIME_BASE_Q;
        
        
        viformat = av_find_input_format(video_grab_format);
        
        vp->device  = video_device;
        vp->channel = video_channel;
        vp->standard = video_standard;
        
        
        //get video information
        
        int ret;
        ret = av_open_input_file(&ic[0], "", viformat, 0, vp); 
            
        if(ret < 0)
                {
                        //print_error(fileName, ret);
                        dprintf_full("Video4LinuxContainerFile::loadContainerInfo : Error in opening file!!\n");
                        delete result;
                        return NULL;
                }
        dprintf_full("Video4LinuxContainerFile::loadContainerInfo : av_open_input_file is ok\r\n");     
        

        // If not enough info to get the stream parameters, we decode the first frames to get it
        if ((ic[0]->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic[0]) < 0) {
            dprintf("Could not find video grab parameters\n");
            exit(1);
        }
        

        //ic[0]->streams[0]->r_frame_rate = vp->frame_rate;
        //ic[0]->streams[0]->r_frame_rate_base = vp->frame_rate_base; 

        

        input_files[nb_input_files] = ic[0];
        dump_format(ic[0], nb_input_files, "", 0);
        nb_input_files++;       



//   get aufio information
        
        /*aiformat = av_find_input_format(audio_grab_format);
        ap->device = audio_device;
        
        if (av_open_input_file(&ic[1], "", aiformat, 0, ap) < 0) {
            dprintf("Could not find audio grab device\n");
            exit(1);
        }
        input_files[nb_input_files] = ic[1];
        //dump_format(ic[1], nb_input_files, "", 0);
        //
        

        ic[1]->streams[0]->r_frame_rate = ap->frame_rate;
        ic[1]->streams[0]->r_frame_rate_base = ap->frame_rate_base;
        input_files[nb_input_files] = ic[1];
        dump_format(ic[1], nb_input_files, "", 0);
                        
        nb_input_files++;
        
        dprintf("Ok upt to here\n");
        */

        if (nb_input_files == 0) {
                dprintf_err("Video4LinuxContainerFile::loadFromffMP4ContainerFile  couldn't find any ElemStreams in container!\n");
                ::exit(1);
        }
        
        unsigned int size = 0;  
        for (int streamIndex = 0; streamIndex < nb_input_files; streamIndex++) 
        {       dprintf_full(">>>>>>>>ESINFOVCREATE: %d\n", streamIndex);
                ESInfo *es = Video4LinuxContainerFile::loadESInfo(ic[streamIndex], result,0);
                if (!es) {
                        delete es;
                        delete result;
                        av_close_input_file(ic[streamIndex]);   
                        return NULL;
                }
                
                dprintf_full("Video4LinuxContainerFile::loadFromffMP4ContainerFile creating ES %i\r\n", streamIndex);
                result->addESInfo(es);
                size += es->getOrigMediaSize();
                dprintf_full("Video4LinuxContainerFile::loadFromffMP4ContainerFile creating ES %i done \n", streamIndex);
          
        }
        
        

        av_close_input_file(ic[0]);
        //av_close_input_file(ic[1]);   
        dprintf_full("Video4LinuxContainerFile::loadFromffMP4ContainerFile all done \n");
        return result;  
};


/**********************************************************/
ESInfo *Video4LinuxContainerFile::loadESInfo(AVFormatContext *ic, ContainerInfo *vob, int streamIndex)
{
        //XXX currently some parameters for audio are set in MP4audioDecoder::initialize() 
        //this is becaue ffmpeg fails to deliver the necessary information for audio.   
        AVStream *st;
        st = ic->streams[streamIndex];
        

        unsigned int streamId, handlerType, width, height, mediaTimeScale, totalSamples, mediaSize;
        unsigned int objectType=0, streamType=0, bufferSize=0, avgbit = 0, maxbit = 0; 
        u64 duration = 0;              
        float aspect_ratio = -1;
        
        streamId = st->id;
        dprintf_full("ES Steamdek OK, %d %d\n",streamIndex, streamId);
        width = st->codec->width;               
        height = st->codec->height; 
        streamType = st->codec->codec_type; 


        streamType = 0;
        strm[streamIndex].codec_id = CODEC_ID_RAWVIDEO;

        printf("Streamtype: %d Codec ID: %d\n",streamType, /*strm[streamIndex].codec_id*/ st->codec->codec_type);
        
        if(st->codec->sample_aspect_ratio.num == 0)
                aspect_ratio = (float)width / (float)height;
        else if (height != 0)
                aspect_ratio = aspect_ratio = av_q2d(st->codec->sample_aspect_ratio) * (float)width / (float)height;
        if (aspect_ratio <= 0)
                aspect_ratio = (float)width / (float)height;
        
        handlerType = st->codec->codec_type;            //video = 0; audio = 1; others = -1     
        if(handlerType == 0)                            //FIXME set the #defines in global.hpp for ffmpeg and replace these lines
                handlerType = MP4VisualHandlerType;
        if(handlerType == 1)
                handlerType = MP4AudioHandlerType;
        
        
        mediaTimeScale = 90000; //FIXME: quickhack for divx
        
        
        strm[streamIndex].duration = 99999999;
        duration = strm[streamIndex].duration;
        strm[streamIndex].size = 99999999;
        totalSamples  = 50000;


        mediaSize = strm[streamIndex].size;
        dprintf_full("Video4LinuxContainerFile: Ticks/sec %i Duration: %6.2f secs (ticks %li, samples %u) \n",
                                                         mediaTimeScale,
                                                         (float) ((float)(duration) / (float)(mediaTimeScale)),
                                                         (long)duration, totalSamples );
        int dcsize = 0;
        u8 *dptr = NULL;
        
        u8 *encodedDecoderConfig = NULL;        
        
        
        
        //XXX some of these things are not set before passing
        if(handlerType == MP4VisualHandlerType) {
                avgbit = frame_width * frame_height * frame_rate * 12;          
                maxbit = avgbit;
                dprintf_full("Video4LinuxContainerFile: VideoESInfo CodecID %i,  ticks: %u\n", st->codec->codec_id, (unsigned)(duration/totalSamples));
                return new VideoESInfo(streamId, streamType, vob, duration/totalSamples, encodedDecoderConfig, objectType, bufferSize, avgbit, maxbit, mediaTimeScale, duration, mediaSize, width, height,
                
                true, true,  strm[streamIndex].codec_id, st->quality, aspect_ratio);
        }
        else if(handlerType == MP4AudioHandlerType) {
                u32 channels =  st->codec->channels;
                streamType = st->codec->codec_type;
                strm[streamIndex].codec_id = st->codec->codec_id;
                strm[streamIndex].bits_per_sample = st->codec->channels * st->codec->sample_rate * 16;
                avgbit = strm[streamIndex].bits_per_sample;
                dprintf_full("Video4LinuxContainerFile: AudioESInfo CodecID %i,  %i Hz  Channels: %i, ticks: %u, bitsPerSec %d:\n",
                                                                 st->codec->codec_id, st->codec->sample_rate, channels, (unsigned)(duration/totalSamples),strm[streamIndex].bits_per_sample );
                return new AudioESInfo(streamId, streamType, vob, duration/totalSamples,
                                                                                                         encodedDecoderConfig,
                                                                                                         objectType, bufferSize,
                                                                                                         avgbit, maxbit, mediaTimeScale, duration, mediaSize, 
                                                                                                         st->codec->sample_rate, channels, true,
                                                                                                         st->codec->codec_id, st->quality, strm[streamIndex].bits_per_sample);
        }
        return NULL;
}

© ViTooKi 2003 :: [Lite version] Created with Doxygen