fileframefilter.h

#ifndef fileframefilter_HEADER_GUARD 
#define fileframefilter_HEADER_GUARD
 
/*
 * fileframefilter.h : File input to matroska files
 * 
 * (c) Copyright 2017-2024 Sampsa Riikonen
 * 
 * Authors: Sampsa Riikonen <sampsa.riikonen@iki.fi>
 * 
 * This file is part of the Valkka library.
 * 
 * Valkka 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 3 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>
 *
 */
 
/*
 
Some ideas:
 
  * SetupStorageFrameFilter (stores any setup frames it observes)
  
Writing streams:
 
  * By a FrameFilter
  * By a Thread that uses that FrameFilter .. a service, similar to LiveThread or OpenGLThread
  
Reading streams:
 
  * A service thread, similar to LiveThread ..?  
  * .. could do both writing and reading
  
Extend LiveThread into sending frames over rtsp (or sdp)
 
 
*/
 
#include "constant.h"
#include "framefilter.h"
 
 
class InitStreamFrameFilter : public FrameFilter {                          // <pyapi>
    
public:                                                                     // <pyapi>
    InitStreamFrameFilter(const char* name, FrameFilter *next = NULL);      // <pyapi>
    ~InitStreamFrameFilter();                                               // <pyapi>
    
protected:
    std::vector<SetupFrame> setupframes;  
 
protected:
    void go(Frame* frame);
    void run(Frame* frame);
};                                                                          // <pyapi>
 
 
 
class FileFrameFilter : public FrameFilter {                              // <pyapi>
  
public:                                                                   // <pyapi>  
    FileFrameFilter(const char *name, FrameFilter *next=NULL);              // <pyapi>
    ~FileFrameFilter();                                                     // <pyapi>
 
protected:
    bool active;                       
    bool ready;                        
    bool initialized;                  
    long int mstimestamp0;             
    long int zerotime;                 
    bool zerotimeset;
    std::string filename;
  
protected: //libav stuff
    AVRational timebase;
    std::vector<AVCodecContext*>  codec_contexes;
    std::vector<AVStream*>        streams;
    AVFormatContext               *av_format_context;
    AVPacket                      *avpkt;
  
protected: //mutex stuff
    std::mutex              mutex;     
    std::condition_variable condition; 
 
protected: //frames
    std::vector<SetupFrame>       setupframes;        
    BasicFrame                    internal_frame;     
  
protected:
    void go(Frame* frame);
    void initFile();           
    void closeFile();          
    void deActivate_();
    void writeHeader();
  
public: // API calls                                                                         // <pyapi>
    // setFileName(const char* fname); ///< Sets the output filename                           // <pyapi>
    void activate(const char* fname, long int zerotime=0);       
    void deActivate();                                           
};                                                                                           // <pyapi>
 
 
#endif