NT audio framework

1 files changed, 724 insertions, 0 deletions

diff --git a/NT/src/libavwrapper.cpp b/NT/src/libavwrapper.cpp
new file mode 100644
index 0000000..4a8315f
--- /dev/null
+++ b/NT/src/libavwrapper.cpp
@@ -0,0 +1,724 @@
+#include "libavwrapper.h"
+
+Poco::Mutex mutex;
+
+#include <stdexcept>
+#include <iostream>
+#include <cassert>
+
+using namespace std;
+using namespace Poco;
+
+static bool b_is_one_time_inited=false;
+static int sws_flags = SWS_BICUBIC;
+
+void libav::maybeInitFFMpegLib()
+{
+    if (b_is_one_time_inited)
+        return;
+    FFMS_Init(0, 0); //should do for all
+    //av_register_all();
+    //avcodec_register_all();
+    avformat_network_init();
+    b_is_one_time_inited = true;
+}
+
+ void libav::video_decoder::cleanup(){
+    if (loaded) {
+        Mutex::ScopedLock lock(mutex);
+        FFMS_DestroyVideoSource(source);
+        loaded=false;
+    }
+}
+
+bool libav::video_decoder::open(const std::string& filename){
+    cleanup();
+    Mutex::ScopedLock lock(mutex);
+    Poco::File f=Poco::File(filename);
+    if (!f.exists()) {
+        cerr<<"ERROR: "<<filename<<" does not exist"<<endl;
+        return false;
+    }
+
+    //first check if an index object exists
+    Poco::StringTokenizer tokens(filename,".");
+    string idxfile="";
+    if (tokens.count()>1){
+        for (uint32_t i=0;i<tokens.count()-1;i++){
+            idxfile+=tokens[i];
+            idxfile+=".";
+        }
+        idxfile+="idx";
+    }
+    else idxfile=filename+".idx";
+
+    f=Poco::File(idxfile);
+    bool makeindex=true;
+    FFMS_Index *index;
+    if (f.exists()) {
+        index=FFMS_ReadIndex(idxfile.c_str(),&err);
+        if (index) {
+            cerr<<"FFMS2: loaded index "<<idxfile<<endl;
+            if (FFMS_IndexBelongsToFile(index,filename.c_str(),&err)==0){        
+                makeindex=false;
+            }
+        }
+    }
+    if (makeindex) {
+        index = FFMS_MakeIndex(filename.c_str(), 0, 0, NULL, NULL, FFMS_IEH_IGNORE, NULL, NULL, &err);
+        if (index) {
+            FFMS_WriteIndex(idxfile.c_str(),index,&err);
+            cerr<<"FFMS2: created index "<<idxfile<<endl;
+        }
+        cerr<<"FFMS2: "<<filename<<" cannot be indexed "<<endl;
+    }
+    if (index == NULL) {
+        std::cerr<<"ffmpegsource: "<<err.Buffer<<std::endl;
+        return false;
+    }
+    int trackno = FFMS_GetFirstTrackOfType(index, FFMS_TYPE_VIDEO, &err);
+    if (trackno < 0) {
+        std::cerr<<"ffmpegsource: "<<err.Buffer<<std::endl;
+        return false;
+    }
+    source = FFMS_CreateVideoSource(filename.c_str(), trackno, index, 1, FFMS_SEEK_NORMAL, &err);
+    if (source == NULL) {
+        std::cerr<<"ffmpegsource: "<<err.Buffer<<std::endl;
+        return false;
+    }
+    FFMS_DestroyIndex(index);
+    props = FFMS_GetVideoProperties(source);
+    const FFMS_Frame *propframe = FFMS_GetFrame(source, 0, &err);
+    w=propframe->EncodedWidth;
+    h=propframe->EncodedHeight;
+    //propframe->EncodedPixelFormat;
+    
+    if (FFMS_SetOutputFormatV2(source, pixfmts, propframe->EncodedWidth, propframe->EncodedHeight, FFMS_RESIZER_BICUBIC, &err)) {
+        std::cerr<<"ffmpegsource: "<<err.Buffer<<std::endl;
+        return false;
+    }
+    
+    //std::cerr<<"ffmpegsource: successfully opened "<<filename<<std::endl;
+    loaded=true;
+    return loaded;
+}
+
+bool libav::audio_decoder::open(const std::string& filename){
+    Mutex::ScopedLock lock(mutex);
+    loaded=false;
+    FFMS_Index *index = FFMS_MakeIndex(filename.c_str(),-1, 0, NULL, NULL, FFMS_IEH_IGNORE, NULL, NULL, &err);
+    if (index == NULL) {
+        std::cerr<<"ffmpegsource error making index for "<<filename<<":"<<err.Buffer<<std::endl;
+        return false;
+    }
+    int trackno = FFMS_GetFirstTrackOfType(index, FFMS_TYPE_AUDIO, &err);
+    if (trackno < 0) {
+        std::cerr<<"ffmpegsource error finding audio track in "<<filename<<":"<<err.Buffer<<std::endl;
+        return false;
+    }
+    std::cerr<<"ffmpegsource found audio track "<<trackno<<" in "<<filename<<":"<<err.Buffer<<std::endl;
+    source = FFMS_CreateAudioSource(filename.c_str(), trackno, index, FFMS_DELAY_TIME_ZERO,  &err);
+    if (source == NULL) {
+        std::cerr<<"ffmpegsource error creating audio source from "<<filename<<":"<<err.Buffer<<std::endl;
+        return false;
+    }
+    FFMS_DestroyIndex(index);
+    props = FFMS_GetAudioProperties(source);
+
+    std::cerr<<"ffmpegsource: successfully opened "<<filename<<std::endl;
+    loaded=true;
+    return loaded;
+}
+ void libav::audio_decoder::cleanup(){
+    if (loaded) {
+        Mutex::ScopedLock lock(mutex);
+        FFMS_DestroyAudioSource(source);
+        loaded=false;
+    }
+}
+
+bool libav::exporter::setup(int w,int h, int bitRate, int frameRate, std::string container, bool _fragmentation){
+
+    maybeInitFFMpegLib();
+    
+    fragmentation=_fragmentation;
+
+    this->w=w;
+    this->h=h;
+    this->bitRate=bitRate;
+    this->frameRate=frameRate;
+    this->container=container;
+
+    if (NULL != sws_ctx) {
+        sws_freeContext(sws_ctx);
+        sws_ctx = NULL;
+    }
+
+    sws_ctx = sws_getContext(w, h, AV_PIX_FMT_RGB24,
+                             w, h, AV_PIX_FMT_YUV420P,
+                             sws_flags, NULL, NULL, NULL);
+
+    return true;
+}
+
+bool libav::exporter::record(std::string filename){
+
+
+    // allocate the output media context //
+    avformat_alloc_output_context2(&oc, NULL, NULL, filename.c_str());
+
+
+    if (!oc) {
+        printf("Could not deduce output format from file extension: using MPEG.\n");
+        avformat_alloc_output_context2(&oc, NULL, "mpeg", filename.c_str());
+    }
+    if (!oc) {
+        return false;
+    }
+    fmt = oc->oformat;
+
+    av_opt_set(oc->priv_data, "profile", "baseline", AV_OPT_SEARCH_CHILDREN);
+
+
+    // Add the audio and video streams using the default format codecs
+    // * and initialize the codecs. //
+    video_st = NULL;
+    audio_st = NULL;
+
+    fmt->video_codec=AV_CODEC_ID_H264; //AV_CODEC_ID_MPEG4
+    fmt->audio_codec=AV_CODEC_ID_AAC; //guessing, 011013
+
+
+    if (fmt->video_codec != AV_CODEC_ID_NONE) {
+        video_st = add_stream(oc, &video_codec, fmt->video_codec);
+    }
+    if (fmt->audio_codec != AV_CODEC_ID_NONE) {
+        //audio_st = add_stream(oc, &audio_codec, fmt->audio_codec);
+        audio_st = add_stream(oc, &audio_codec, fmt->audio_codec);
+    }
+
+    
+
+    //set initial video params
+    video_st->codec->width=w;
+    video_st->codec->height=h;
+    video_st->codec->time_base.num = 1;//codecCtx->ticks_per_frame;
+    video_st->codec->time_base.den = frameRate;
+    video_st->time_base = video_st->codec->time_base;
+        //audioStream->time_base = codecCtx->time_base; //???has the capability of crashing
+
+    video_st->codec->gop_size = 75; /* emit one intra frame every 75 frames */
+    video_st->codec->pix_fmt = PIX_FMT_YUV420P;
+
+    if (bitRate){
+        cerr<<"Libav::exporter setting bitrate to "<<bitRate<<endl;
+
+        video_st->codec->bit_rate = bitRate; //need to deal with resolution etc
+        video_st->codec->rc_max_rate = bitRate; 
+        video_st->codec->rc_min_rate = 0; 
+
+        //added 131113
+        video_st->codec->rc_buffer_size = bitRate * 2;
+    }
+
+    //av_dict_set(&options, "profile", "baseline", 0);
+    //video_st->codec->flags2 = CODEC_FLAG2_FASTPSKIP;
+    video_st->codec->profile = FF_PROFILE_H264_BASELINE;
+    video_st->codec->level = 13;
+
+    
+    //how to set profile????? 190913
+    //this causes a crash
+    //av_opt_set(video_st->codec->priv_data,"profile",FF_PROFILE_H264_CONSTRAINED_BASELINE, 0); 
+    //
+    // http://libav-users.943685.n4.nabble.com/Libav-user-encoding-bitrate-wrong-td4433740.html
+    // http://libav-users.943685.n4.nabble.com/Libav-user-H264-encoding-set-target-average-bitrate-td3912529.html
+    // http://trac.ffmpeg.org/wiki/x264EncodingGuide
+
+
+
+    // Now that all the parameters are set, we can open the audio and
+    // * video codecs and allocate the necessary encode buffers. //
+    
+    if (video_st) {
+        if (!open_video(oc, video_codec, video_st)){
+            return false;
+        }
+    }
+    if (audio_st) {
+        audioframesize=open_audio(oc, audio_codec, audio_st);
+        audiostep=((double)audioframesize)/(audio_st->codec->sample_rate);
+        std::cerr << "opened audio codec with "<<audioframesize<<" frame size and "<<audiostep<<" seconds per frame"<<std::endl;
+    }
+
+
+
+    av_dump_format(oc, 0, filename.c_str(), 1);
+
+    // open the output file, if needed //
+    if (!(fmt->flags & AVFMT_NOFILE)) {
+        Mutex::ScopedLock lock(mutex);
+        int ret = avio_open(&oc->pb, filename.c_str(), AVIO_FLAG_WRITE);
+        if (ret < 0) {
+            std::cerr <<"Could not open " << filename.c_str() << std::endl;
+            return false;
+        }
+    }
+
+    AVDictionary *opts = NULL; // "create" an empty dictionary
+
+    // https://libav.org/avprobe.html#MOV_002fMP4_002fISMV
+
+    //THIS DOES SEEM TO SET CONTAINER OPTS= AS MOOV_SIZE MAKES THE MOVIE BANJAXED
+    //av_dict_set(&opts, "moov_size", "20000", 0);
+    if (fragmentation) {
+       av_dict_set(&opts, "movflags","frag_keyframe", 0); //makes a video watchable in chrome, quicktime & mplayer
+       //av_dict_set(&opts, "movflags","empty_moov",1); 
+    }
+
+
+    // Write the stream header, if any. //
+    int ret = avformat_write_header(oc, &opts);
+    if (ret < 0) {
+        std::cerr <<"Error occurred when opening output file:" <<endl; // av_err2str(ret) << std::endl;
+        return false;
+    }
+    //#include <libavformat/movenc.h>
+    //mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s)
+    /*ret = mov_write_moov_tag(oc, NULL,NULL);
+     if (ret < 0) {
+        std::cerr <<"Error occurred when writing moov atom " <<endl; // << av_err2str(ret) << std::endl;
+        return false;
+    }*/
+
+    if (frame)
+        frame->pts = 0;
+
+    outputframe=0;
+
+    return true;
+}
+bool libav::exporter::encodeFrame(unsigned char *pixels,uint16_t *samples){
+    // Compute current audio and video time. //
+    if (audio_st)
+        audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
+    else
+        audio_pts = 0.0;
+
+    if (video_st)
+        video_pts = (double)video_st->pts.val * video_st->time_base.num /
+                    video_st->time_base.den;
+    else
+        video_pts = 0.0;
+
+    // write interleaved audio and video frames //
+    if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
+        write_audio_frame(oc, audio_st, samples);
+    } else {
+        write_video_frame(oc, video_st, pixels);
+
+        frame->pts += av_rescale_q(1, video_st->codec->time_base, video_st->time_base);
+    }
+
+    //std::cerr << "encoded frame " << outputframe << std::endl;
+    outputframe++;
+
+    return true;
+}
+bool libav::exporter::encodeFrame(unsigned char *pixels,AVPacket *audio){
+    // Compute current audio and video time. //
+    if (audio_st)
+        audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
+    else
+        audio_pts = 0.0;
+
+    if (video_st)
+        video_pts = (double)video_st->pts.val * video_st->time_base.num /
+                    video_st->time_base.den;
+    else
+        video_pts = 0.0;
+
+    // write interleaved audio and video frames //
+    if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
+        write_audio_frame(oc, audio_st, audio);
+    } else {
+        write_video_frame(oc, video_st, pixels);
+
+        frame->pts += av_rescale_q(1, video_st->codec->time_base, video_st->time_base);
+    }
+
+    //std::cerr << "encoded frame " << outputframe << std::endl;
+    outputframe++;
+
+    return true;
+}
+bool libav::exporter::encodeFrame(unsigned char *pixels,bool keyframe){
+    video_pts = (double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;
+    write_video_frame(oc, video_st, pixels,keyframe);
+    frame->pts += av_rescale_q(1, video_st->codec->time_base, video_st->time_base);
+    outputframe++;
+    return true;
+}
+bool libav::exporter::encodeFrame(uint16_t *samples){
+    audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
+    write_audio_frame(oc, audio_st, samples);
+    return true;
+}
+void libav::exporter::finishRecord(){
+
+    av_write_trailer(oc);
+    // Close each codec. //
+    if (video_st)
+        close_video(oc, video_st);
+    if (audio_st)
+        close_audio(oc, audio_st);
+
+    if (!(fmt->flags & AVFMT_NOFILE)) {
+        // Close the output file. //
+        Mutex::ScopedLock lock(mutex);
+        avio_close(oc->pb);
+    }
+
+    // free the stream //
+    avformat_free_context(oc);
+}
+
+AVStream* libav::exporter::add_stream(AVFormatContext *oc, AVCodec **codec,enum AVCodecID codec_id)
+    {
+        //removed some of the repeats from record() 141113
+        AVCodecContext *c;
+        AVStream *st;
+
+        // find the encoder //
+        *codec = avcodec_find_encoder(codec_id);
+        if (!(*codec)) {
+            //fprintf(stderr, "Could not find encoder for '%s'\n",
+            //        avcodec_get_name(codec_id));
+            exit(1);
+        }
+
+        st = avformat_new_stream(oc, *codec);
+        if (!st) {
+            //fprintf(stderr, "Could not allocate stream\n");
+            exit(1);
+        }
+        st->id = oc->nb_streams-1;
+        c = st->codec;
+
+        switch ((*codec)->type) {
+        case AVMEDIA_TYPE_AUDIO:
+            st->id = 1;
+            c->sample_fmt  = AV_SAMPLE_FMT_S16;
+            c->bit_rate    = 160000;
+            c->sample_rate = 44100;
+            c->channels    = 2;
+            c->channel_layout=AV_CH_LAYOUT_STEREO;
+            break;
+
+        case AVMEDIA_TYPE_VIDEO:
+            c->codec_id = codec_id;
+        
+            //c->bit_rate = bitRate; //need to deal with resolution etc
+
+           // c->rc_max_rate = bitRate; 
+            //c->rc_min_rate = 0; 
+            //c->rc_buffer_size = Profile()->m_videoMaxVopSize;  //??
+
+            /*
+            all taken out 091113 to try to stop making incompatible movies
+            */
+
+
+            // Resolution must be a multiple of two. //
+            //c->width    = 352;
+            //c->height   = 288;
+
+
+            // timebase: This is the fundamental unit of time (in seconds) in terms
+            // * of which frame timestamps are represented. For fixed-fps content,
+            // * timebase should be 1/framerate and timestamp increments should be
+            // * identical to 1. //
+            c->time_base.den = frameRate;
+            c->time_base.num = 1;
+           // c->gop_size      = 12; // emit one intra frame every twelve frames at most //
+            c->pix_fmt       = AV_PIX_FMT_YUV420P; //ADDED HARDCODED TJR 280513
+            if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
+                // just for testing, we also add B frames //
+                c->max_b_frames = 2;
+            }
+            if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
+                // Needed to avoid using macroblocks in which some coeffs overflow.
+                // * This does not happen with normal video, it just happens here as
+                // * the motion of the chroma plane does not match the luma plane. //
+                c->mb_decision = 2;
+            }
+
+        break;
+
+        default:
+            break;
+        }
+
+        // Some formats want stream headers to be separate. //
+        if (oc->oformat->flags & AVFMT_GLOBALHEADER)
+            c->flags |= CODEC_FLAG_GLOBAL_HEADER;
+
+        return st;
+    }
+
+bool libav::exporter::open_video(AVFormatContext *oc, AVCodec *codec, AVStream *st)
+    {
+
+        int ret;
+        AVCodecContext *c = st->codec;
+
+
+        // open the codec //
+        {
+            Mutex::ScopedLock lock(mutex);
+            ret = avcodec_open2(c, codec, NULL); //OPTIONS CAN GO HERE
+
+        }
+        if (ret < 0) {
+           //string e=av_err2str(ret);
+            cerr<<"Could not open video codec, avcodec_open2 returned "<<ret<<endl;
+            return false;
+        }
+
+        // allocate and init a re-usable frame //
+        frame = avcodec_alloc_frame();
+
+        // moved to constructor and freeing in destructor -- stills crashes the same
+        if (!frame) {
+            cerr<<"Could not allocate video frame "<<endl;
+            return false;
+        }
+
+        // Allocate the encoded raw picture. //
+        ret = avpicture_alloc(&dst_picture, c->pix_fmt, c->width, c->height);
+        if (ret < 0) {
+            //av_err2str(ret)<<
+            cerr<<"Could not allocate picture"<<endl;
+            return false;
+        }
+
+        // If the output format is not YUV420P, then a temporary YUV420P
+        // * picture is needed too. It is then converted to the required
+        // * output format. //
+        if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
+            ret = avpicture_alloc(&src_picture, AV_PIX_FMT_RGB24, c->width, c->height);
+            if (ret < 0) {
+                //<<av_err2str(ret)
+                cerr<<"Could not allocate temporary picture"<<endl;
+                return false;
+            }
+        }
+
+        // copy data and linesize picture pointers to frame //
+        *((AVPicture *)frame) = dst_picture;
+
+        outPixels = (uint8_t*)av_malloc(avpicture_get_size(PIX_FMT_YUV420P, st->codec->width,st->codec->height));
+        return true;
+    }
+
+    int libav::exporter::open_audio(AVFormatContext *oc, AVCodec *codec, AVStream *st)
+    {
+        AVCodecContext *c;
+        int ret;
+
+        c = st->codec;
+
+        // open it //
+        mutex.lock();
+        ret = avcodec_open2(c, codec, NULL);
+        mutex.unlock();
+        if (ret < 0) {
+            //fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
+            exit(1);
+        }
+
+        // init signal generator //
+        t     = 0;
+        tincr = 2 * M_PI * 110.0 / c->sample_rate;
+        // increment frequency by 110 Hz per second //
+        tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
+
+        if (c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)
+            audio_input_frame_size = 10000;
+        else
+            audio_input_frame_size = c->frame_size;
+
+        /*
+        samples = av_malloc(audio_input_frame_size *
+                            av_get_bytes_per_sample(c->sample_fmt) *
+                            c->channels);
+        if (!samples) {
+            //fprintf(stderr, "Could not allocate audio samples buffer\n");
+            exit(1);
+        }
+        */
+        return audio_input_frame_size;
+    }
+
+    void libav::exporter::write_audio_frame(AVFormatContext *oc, AVStream *st,uint16_t *samples)
+    {
+        AVCodecContext *c;
+        AVPacket pkt = { 0 }; // data and size must be 0;
+        AVFrame *frame = avcodec_alloc_frame(); 
+        int got_packet, ret;
+
+        //av_init_packet(&pkt);  111013 NOT NECESSARY
+        c = st->codec;
+
+        //get_audio_frame(samples, audio_input_frame_size, c->channels);
+        frame->nb_samples = audio_input_frame_size;
+        uint8_t *sampleptr;
+        int bufsize=audio_input_frame_size * av_get_bytes_per_sample(c->sample_fmt) *c->channels;
+        if (samples) {
+            sampleptr=(uint8_t*)samples;
+        }
+        else {
+            sampleptr=new uint8_t[bufsize];
+            memset(sampleptr,0,bufsize);
+        }
+
+        avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
+                                 sampleptr,
+                                 audio_input_frame_size *
+                                 av_get_bytes_per_sample(c->sample_fmt) *
+                                 c->channels, 0); //;
+        //frame->sample_rate=44100; //hard coded input rate- nope, this doesn't help
+        //frame->format=AV_SAMPLE_FMT_S16P;
+        //?? why is ffmpeg reporting fltp as the sample format??? doesn't seem to have an effect to change this though
+        ret = avcodec_encode_audio2(c, &pkt, frame, &got_packet);
+        if (!samples) {
+            delete[] sampleptr;
+        }
+        if (ret < 0) {
+            //fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));
+            exit(1);
+        }
+
+        if (!got_packet)
+            return;
+
+        pkt.stream_index = st->index;
+
+        //avcodec_free_frame(&frame); ///removed 091013
+
+
+        // Write the compressed frame to the media file. //
+        ret = av_interleaved_write_frame(oc, &pkt);
+        av_free_packet(&pkt);
+        if (ret != 0) {
+            //fprintf(stderr, "Error while writing audio frame: %s\n",
+            //        av_err2str(ret));
+            exit(1);
+        }
+        
+    }
+
+    void libav::exporter::write_audio_frame(AVFormatContext *oc, AVStream *st,AVPacket *pkt)
+    {
+      
+        pkt->stream_index = st->index;
+
+        // Write the compressed frame to the media file. //
+        int ret = av_interleaved_write_frame(oc, pkt);
+        if (ret != 0) {
+            //fprintf(stderr, "Error while writing audio frame: %s\n",
+            //        av_err2str(ret));
+            exit(1);
+        }
+        //avcodec_free_frame(&frame);
+        av_free_packet(pkt); ///added 091013
+    }
+
+    void libav::exporter::close_audio(AVFormatContext *oc, AVStream *st)
+    {
+        mutex.lock();
+        avcodec_close(st->codec);
+        mutex.unlock();
+
+    }
+
+    void libav::exporter::write_video_frame(AVFormatContext *oc, AVStream *st, uint8_t *pixels, bool keyframe)
+    {
+        int ret;
+
+        AVCodecContext *c = st->codec;
+
+        avpicture_fill(&src_picture, pixels, PIX_FMT_RGB24, c->width,c->height);
+        //avpicture_fill(&dst_picture, outPixels, PIX_FMT_YUV420P, c->width,c->height);
+
+        sws_scale(sws_ctx, src_picture.data, src_picture.linesize, 0, c->height, dst_picture.data, dst_picture.linesize);
+        //fill_yuv_image(&dst_picture, frame_count, c->width, c->height);
+        if (oc->oformat->flags & AVFMT_RAWPICTURE) {
+            // Raw video case - directly store the picture in the packet //
+            AVPacket pkt;
+            //av_init_packet(&pkt); ///removed 101013  NOT NECESSARY
+
+            pkt.flags        |= AV_PKT_FLAG_KEY;
+            pkt.stream_index  = st->index;
+            pkt.data          = dst_picture.data[0];
+            pkt.size          = sizeof(AVPicture);
+
+            ret = av_interleaved_write_frame(oc, &pkt);
+            av_free_packet(&pkt); ///added 091013
+        } else {
+            AVPacket pkt = { 0 };
+            int got_packet;
+
+            if (keyframe) pkt.flags |= AV_PKT_FLAG_KEY;
+           
+            ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
+            if (ret < 0) {
+                //fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
+                exit(1);
+            }
+            // If size is zero, it means the image was buffered. //
+
+            if (!ret && got_packet && pkt.size) {
+                pkt.stream_index = st->index;
+
+                // Write the compressed frame to the media file. //
+                ret = av_interleaved_write_frame(oc, &pkt);
+            } else {
+                ret = 0;
+            }
+            av_free_packet(&pkt); ///added 091013
+        }
+
+        
+
+
+        if (ret != 0) {
+            //fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
+            exit(1);
+        }
+        frame_count++;
+
+        //avcodec_free_frame(&frame);
+    }
+
+    void libav::exporter::close_video(AVFormatContext *oc, AVStream *st)
+    {
+        mutex.lock();
+        //avcodec_close(st->codec); //change 0706 to trace 2nd render issue
+        avcodec_close(audio_st->codec);
+        avcodec_close(video_st->codec);
+        //
+        //
+
+
+        //av_free(src_picture.data[0]); //removed to explore weird 2nd render crash.. seems to WORK -- seems that the picture data is owned elsewhere
+        av_free(dst_picture.data[0]);
+        av_free(frame); //removed to explore crash 2nd time render
+        //gives *** Error in `./rotord': corrupted double-linked list: 0x00007fd8b005bd60 ***
+        //where is frame initialised???
+        //moved to destructor
+
+
+        av_free(outPixels); //SIGSEV here???
+        mutex.unlock();
+    }
\ No newline at end of file