size_t nbOutputChannels =0;

for(size_t index =0; index < inputStreams.size(); ++index)

{

addDecoder(_inputStreamDesc.at(index), *_inputStreams.at(index));

nbOutputChannels += _inputStreamDesc.at(index)._channelIndexArray.size();

if(_inputStreams.at(index) !=NULL)

{

LOG_INFO("add decoder for input stream" << index);

addDecoder(_inputStreamDesc.at(index), *_inputStreams.at(index));

nbOutputChannels += _inputStreamDesc.at(index)._channelIndexArray.size();

}

{

LOG_INFO("add generator for empty input" << index);

addGenerator(_inputStreamDesc.at(index), profile);

}

}

IInputStream& inputStream = *_inputStreams.at(0);

const InputStreamDesc& inputStreamDesc = inputStreamsDesc.at(0);

constsize_t firstInputStreamIndex =getFirstInputStreamIndex();

IInputStream& inputStream = *_inputStreams.at(firstInputStreamIndex);

const InputStreamDesc& inputStreamDesc = inputStreamsDesc.at(firstInputStreamIndex);

switch(inputStream.getProperties().getStreamType())

setOffset(offset);

}

size_tStreamTranscoder::getFirstInputStreamIndex()

{

for(size_t index =0; index < _inputStreams.size(); ++index)

{

if(_inputStreams.at(index) !=NULL)

return index;

}

throwstd::runtime_error("Cannot handle only null input streams");

}

voidStreamTranscoder::addDecoder(const InputStreamDesc& inputStreamDesc, IInputStream& inputStream)

{

}

}

voidStreamTranscoder::addGenerator(const InputStreamDesc& inputStreamDesc,const ProfileLoader::Profile& profile)

{

if(profile.find(constants::avProfileType)->second == constants::avProfileTypeVideo)

{

VideoCodecinputVideoCodec(eCodecTypeEncoder, profile.find(constants::avProfileCodec)->second);

VideoFrameDescinputFrameDesc(profile);

inputVideoCodec.setImageParameters(inputFrameDesc);

VideoGenerator* generator =newVideoGenerator(inputFrameDesc);

_generators.push_back(generator);

_currentDecoder = generator;

VideoFrameDesc outputFrameDesc = inputFrameDesc;

outputFrameDesc.setParameters(profile);

_decodedData.push_back(newVideoFrame(inputFrameDesc));

_inputDecoders.push_back(NULL);

}

elseif(profile.find(constants::avProfileType)->second == constants::avProfileTypeAudio)

{

AudioCodecinputAudioCodec(eCodecTypeEncoder, profile.find(constants::avProfileCodec)->second);

AudioFrameDescinputFrameDesc(profile);

inputFrameDesc._nbChannels =1;

inputAudioCodec.setAudioParameters(inputFrameDesc);

AudioGenerator* generator =newAudioGenerator(inputFrameDesc);

_generators.push_back(generator);

_currentDecoder = generator;

_decodedData.push_back(newAudioFrame(inputFrameDesc));

_inputDecoders.push_back(NULL);

}

{

throwstd::runtime_error("unupported stream type");

}

}

StreamTranscoder::StreamTranscoder(IOutputFile& outputFile,const ProfileLoader::Profile& profile)

: _inputStreamDesc()

, _inputStreams()

for(std::vector<IDecoder*>::iterator it = _inputDecoders.begin(); it != _inputDecoders.end(); ++it)

{

delete(*it);

if(*it !=NULL)

delete(*it);

}

for(std::vector<IDecoder*>::iterator it = _generators.begin(); it != _generators.end(); ++it)

{

}

if(_decodedData.at(0)->isAudioFrame())

constsize_t firstInputStreamIndex =getFirstInputStreamIndex();

if(_decodedData.at(firstInputStreamIndex)->isAudioFrame())

{

constint nbInputSamplesPerChannel = _decodedData.at(0)->getAVFrame().nb_samples;

constint nbInputSamplesPerChannel = _decodedData.at(firstInputStreamIndex)->getAVFrame().nb_samples;

if(nbInputSamplesPerChannel > _filteredData->getAVFrame().nb_samples)

float minStreamDuration = -1;

for(size_t index =0; index < _inputStreams.size(); ++index)

{

const StreamProperties& streamProperties = _inputStreams.at(index)->getProperties();

IInputStream* inputStream = _inputStreams.at(index);

if(inputStream ==NULL)

continue;

const StreamProperties& streamProperties = inputStream->getProperties();

if(minStreamDuration == -1 || streamProperties.getDuration() < minStreamDuration)

minStreamDuration = streamProperties.getDuration();

}

voidaddDecoder(const InputStreamDesc& inputStreamDesc, IInputStream& inputStream);

voidaddGenerator(const InputStreamDesc& inputStreamDesc,const ProfileLoader::Profile& profile);

boolprocessRewrap();

boolprocessTranscode();

size_tgetFirstInputStreamIndex();

std::vector<InputStreamDesc> _inputStreamDesc;///< Description of the data to extract from the input stream.

std::vector<IInputStream*> _inputStreams;///< List of input stream to read next packet (has link, no ownership)

AVMediaType commonStreamType = AVMEDIA_TYPE_UNKNOWN;

for(std::vector<InputStreamDesc>::const_iterator it = inputStreamDescArray.begin(); it != inputStreamDescArray.end(); ++it)

{

if(it->_filename.empty())

{

inputStreams.push_back(NULL);

continue;

}

InputFile* referenceFile =addInputFile(it->_filename, it->_streamIndex, offset);

inputStreams.push_back(&referenceFile->getStream(it->_streamIndex));

assert(inputStreamDescArray.size() >=1);

const InputStreamDesc& inputStreamDesc = inputStreamDescArray.at(0);

size_t nonEmptyFileName =0;

for(size_t i =0; i < inputStreamDescArray.size(); ++i)

{

if(!inputStreamDescArray.at(i)._filename.empty())

{

nonEmptyFileName = i;

break;

}

}

const InputStreamDesc& inputStreamDesc = inputStreamDescArray.at(nonEmptyFileName);

InputFileinputFile(inputStreamDesc._filename);

const StreamProperties* streamProperties = &inputFile.getProperties().getStreamPropertiesWithIndex(inputStreamDesc._streamIndex);

LOG_WARN("Cannot process statistics of generated stream.")

continue;

}

const IInputStream* inputStream = _streamTranscoders.at(streamIndex)->getInputStreams().at(0);

size_t nonNullInputStreamIndex =0;

std::vector<IInputStream*> inputStreams = _streamTranscoders.at(streamIndex)->getInputStreams();

for(size_t i =0; i < inputStreams.size(); ++i)

{

if(inputStreams.at(i) !=NULL)

{

nonNullInputStreamIndex = i;

break;

}

}

const IInputStream* inputStream = inputStreams.at(nonNullInputStreamIndex);

const AVMediaType mediaType = inputStream->getProperties().getStreamType();

switch(mediaType)

{