StreamTranscoder: add null input stream to generate output channel

Valentin NOEL · Valentin NOEL · commit 55a4baba8690 · 2017-09-21T14:52:27.000+02:00
If the InputStreamDesc filename is empty, a generator is set up as input
diff --git a/src/AvTranscoder/transcoder/StreamTranscoder.cpp b/src/AvTranscoder/transcoder/StreamTranscoder.cpp
@@ -147,12 +147,22 @@ StreamTranscoder::StreamTranscoder(const std::vector<InputStreamDesc>& inputStre
     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();
+        }
+        else
+        {
+            LOG_INFO("add generator for empty input " << index);
+            addGenerator(_inputStreamDesc.at(index), profile);
+        }
     }
 
-    IInputStream& inputStream = *_inputStreams.at(0);
-    const InputStreamDesc& inputStreamDesc = inputStreamsDesc.at(0);
+    const size_t firstInputStreamIndex = getFirstInputStreamIndex();
+    IInputStream& inputStream = *_inputStreams.at(firstInputStreamIndex);
+    const InputStreamDesc& inputStreamDesc = inputStreamsDesc.at(firstInputStreamIndex);
 
     // create a transcode case
     switch(inputStream.getProperties().getStreamType())
@@ -229,6 +239,16 @@ StreamTranscoder::StreamTranscoder(const std::vector<InputStreamDesc>& inputStre
     setOffset(offset);
 }
 
+size_t StreamTranscoder::getFirstInputStreamIndex()
+{
+    for(size_t index = 0; index < _inputStreams.size(); ++index)
+    {
+        if(_inputStreams.at(index) != NULL)
+            return index;
+    }
+    throw std::runtime_error("Cannot handle only null input streams");
+}
+
 void StreamTranscoder::addDecoder(const InputStreamDesc& inputStreamDesc, IInputStream& inputStream)
 {
     // create a transcode case
@@ -278,6 +298,53 @@ void StreamTranscoder::addDecoder(const InputStreamDesc& inputStreamDesc, IInput
     }
 }
 
+void StreamTranscoder::addGenerator(const InputStreamDesc& inputStreamDesc, const ProfileLoader::Profile& profile)
+{
+    // create a transcode case
+    if(profile.find(constants::avProfileType)->second == constants::avProfileTypeVideo)
+    {
+        VideoCodec inputVideoCodec(eCodecTypeEncoder, profile.find(constants::avProfileCodec)->second);
+        VideoFrameDesc inputFrameDesc(profile);
+        inputVideoCodec.setImageParameters(inputFrameDesc);
+
+        // generator decoder
+        VideoGenerator* generator = new VideoGenerator(inputFrameDesc);
+        _generators.push_back(generator);
+        _currentDecoder = generator;
+
+        // buffers to process
+        VideoFrameDesc outputFrameDesc = inputFrameDesc;
+        outputFrameDesc.setParameters(profile);
+        _decodedData.push_back(new VideoFrame(inputFrameDesc));
+
+        // no decoder for this input
+        _inputDecoders.push_back(NULL);
+
+    }
+    else if(profile.find(constants::avProfileType)->second == constants::avProfileTypeAudio)
+    {
+        // corresponding input codec
+        AudioCodec inputAudioCodec(eCodecTypeEncoder, profile.find(constants::avProfileCodec)->second);
+        AudioFrameDesc inputFrameDesc(profile);
+        inputFrameDesc._nbChannels = 1;
+        inputAudioCodec.setAudioParameters(inputFrameDesc);
+
+        // generator decoder
+        AudioGenerator* generator = new AudioGenerator(inputFrameDesc);
+        _generators.push_back(generator);
+        _currentDecoder = generator;
+        // buffers to get the decoded data
+        _decodedData.push_back(new AudioFrame(inputFrameDesc));
+
+        // no decoder for this input
+        _inputDecoders.push_back(NULL);
+    }
+    else
+    {
+        throw std::runtime_error("unupported stream type");
+    }
+}
+
 StreamTranscoder::StreamTranscoder(IOutputFile& outputFile, const ProfileLoader::Profile& profile)
     : _inputStreamDesc()
     , _inputStreams()
@@ -375,7 +442,8 @@ StreamTranscoder::~StreamTranscoder()
 
     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)
     {
@@ -548,9 +616,10 @@ bool StreamTranscoder::processTranscode()
     }
 
     // check the next data buffers in case of audio frames
-    if(_decodedData.at(0)->isAudioFrame())
+    const size_t firstInputStreamIndex = getFirstInputStreamIndex();
+    if(_decodedData.at(firstInputStreamIndex)->isAudioFrame())
     {
-        const int nbInputSamplesPerChannel = _decodedData.at(0)->getAVFrame().nb_samples;
+        const int nbInputSamplesPerChannel = _decodedData.at(firstInputStreamIndex)->getAVFrame().nb_samples;
 
         // Reallocate output frame
         if(nbInputSamplesPerChannel > _filteredData->getAVFrame().nb_samples)
@@ -670,7 +739,11 @@ float StreamTranscoder::getDuration() const
         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();
         }
diff --git a/src/AvTranscoder/transcoder/StreamTranscoder.hpp b/src/AvTranscoder/transcoder/StreamTranscoder.hpp
@@ -125,10 +125,13 @@ class AvExport StreamTranscoder
      * @param inputStream
      */
     void addDecoder(const InputStreamDesc& inputStreamDesc, IInputStream& inputStream);
+    void addGenerator(const InputStreamDesc& inputStreamDesc, const ProfileLoader::Profile& profile);
 
     bool processRewrap();
     bool processTranscode();
 
+    size_t getFirstInputStreamIndex();
+
 private:
     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)
diff --git a/src/AvTranscoder/transcoder/Transcoder.cpp b/src/AvTranscoder/transcoder/Transcoder.cpp
@@ -260,6 +260,12 @@ void Transcoder::addTranscodeStream(const std::vector<InputStreamDesc>& inputStr
     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));
 
@@ -329,7 +335,16 @@ ProfileLoader::Profile Transcoder::getProfileFromInputs(const std::vector<InputS
     assert(inputStreamDescArray.size() >= 1);
 
     // Get properties from the first input
-    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);
     InputFile inputFile(inputStreamDesc._filename);
 
     const StreamProperties* streamProperties = &inputFile.getProperties().getStreamPropertiesWithIndex(inputStreamDesc._streamIndex);
@@ -519,7 +534,19 @@ void Transcoder::fillProcessStat(ProcessStat& processStat)
             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)
         {
