|| || || || || || || ||

---

RgbDataSrcLavcTestGUI.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_RgbDataSrcLavcTestGUI_h
#define Impala_Core_VideoSet_RgbDataSrcLavcTestGUI_h

#include "Basis/CmdOptions.h"
#include "Core/Array/Arrays.h"
#include "Core/Array/Pattern/PatBinaryPixOp.h"
#include "Core/Array/Trait/BpoTestEqual.h"
#include "Core/Geometry/Rectangle.h"
#include "Core/Stream/RgbDataSrc.h"
#include "Core/Stream/RgbDataSrcFactory.h"
#include "Core/VideoSet/MakeVideoSet.h"
#include "OglGui/DropDownWindow.h"
#include "OglGui/StaticText.h"
#include "OglGui/TextField.h"
#include "OglGui/CheckBox.h"
#include "OglGui/ScrollWnd.h"
#include "OglGui/StringSelector.h"
#include "OglGui/Strut.h"
#include "OglGui/Tabs.h"
#include "OglGui/SizableWindow.h"
#include "Visualization/VideoNav.h"
#include "Visualization/AppControlSrc.h"
#undef Next
#include <sstream>

enum FRAME_TYPE{
    I_FRAME=1,
    P_FRAME=2,
    B_FRAME=3,
    S_FRAME=4,
    SI_FRAME=5,
    SP_FRAME=6,
};

namespace Impala
{
namespace Visualization
{

using namespace Util;
using namespace OglGui;
using namespace Core::Array;
using namespace Core::Stream;
using namespace Core::VideoSet;



class PropertySheet:public Window
{
public:
    PropertySheet(Window* W, int w, int h)
    :Window(W,w,h,true)
    {
        mScrl=new ScrollWnd(this,w-6,h-6);
        mScrl->ConnectTo(this, ALLSIDES);

    }

    OglGui::Window* ContentPane(){
        return mScrl->ContentPane();
    }
private:
    ScrollWnd* mScrl;
    
};



class PropCtrl:public OglGui::Window
{
public:
    PropCtrl(OglGui::Window* parent,int width, int height,
            std::string Name,std::string Value)
    :OglGui::Window(parent, width, height)
    {
        mName = new StaticText(this,(width-20)/2,20,Name,false);
        mValue = new StaticText(this,(width-20)/2,20,Value,false);
        mValue->SetBackground(oglWHITE);
    }
    void Update(std::string Value){
        if((mValue->GetText()!=Value)&&(mValue->GetText()!=""))
            mValue->SetBackground(oglRED);
        mValue->SetText(Value);
    }
private:
    StaticText* mName; 
    StaticText* mValue;
};


class PropertyHolder:public OglGui::DropDownWindow{
public: 
    PropertyHolder(Window* parent,int width,int height,std::string Name)
    :DropDownWindow(parent,width,height,Name)
    {
        DropDown(true);
    }
    
    void AddProp(std::string Prop,std::string Value){
        PropCtrl* p=new PropCtrl(this,W()-30,20,Prop,Value);
        mPropCtrls[Prop]=p;
        AddWindow(p);
    }
    void AddPropHolder(PropertyHolder* ph){
        AddWindow((Window*)ph);
    }

    void UpdateCtrl(std::string Prop,std::string Value){
        mPropCtrls[Prop]->Update(Value);
    }
    void UpdateCtrl(std::string Prop,char* Value){
        if((Value==NULL)||(Value==0))
            mPropCtrls[Prop]->Update(std::string("NULL"));
        else
            mPropCtrls[Prop]->Update(std::string(Value));
    }
    
    void UpdateCtrl(std::string Prop,bool Value){
        std::string val = (Value?"True":"False");
        mPropCtrls[Prop]->Update(val);
    }
    void UpdateCtrl(std::string Prop,unsigned int Value){
        std::ostringstream oss;
        oss<<Value;
        mPropCtrls[Prop]->Update(oss.str());
    }
    void UpdateCtrl(std::string Prop,int Value){
        std::ostringstream oss;
        oss<<Value;
        mPropCtrls[Prop]->Update(oss.str());
    }
    void UpdateCtrl(std::string Prop,int64_t Value){
        std::ostringstream oss;
        oss<<Value;
        mPropCtrls[Prop]->Update(oss.str());
    }

    void UpdateCtrl(std::string Prop,float Value){
        std::ostringstream oss;
        oss<<Value;
        mPropCtrls[Prop]->Update(oss.str());
    }

    void UpdateCtrl(std::string Prop,AVRational Value){
        std::ostringstream oss;
        oss<<Value.num<<" / "<<Value.den;
        mPropCtrls[Prop]->Update(oss.str());
    }
    void UpdateCtrl(std::string Prop,AVFrac& Value){
        std::ostringstream oss;
        oss<<Value.val<<" + "<<Value.num<<" / "<<Value.den;
        mPropCtrls[Prop]->Update(oss.str());
    }
    void UpdateCtrl(std::string Prop,enum AVDiscard Value){
        std::string val;
        switch(Value){
            case AVDISCARD_NONE:
                val="AVDISCARD_NONE";break;
            case AVDISCARD_DEFAULT:
                val="AVDISCARD_DEFAULT";break;
            case AVDISCARD_NONREF:
                val="AVDISCARD_NONREF";break;
            case AVDISCARD_BIDIR:
                val="AVDISCARD_BIDIR";break;
            case AVDISCARD_NONKEY:
                val="AVDISCARD_NONKEY";break;
            case AVDISCARD_ALL:
                val="AVDISCARD_ALL";break;
        }
        mPropCtrls[Prop]->Update(val);
    }
    void UpdateCtrl(std::string Prop,enum FRAME_TYPE Value){
        std::string val;
        std::ostringstream oss;
        switch(Value){
            case I_FRAME:
                val="I Frame";break;
            case B_FRAME:
                val="B Frame";break;
            case P_FRAME:
                val="P Frame";break;
            case S_FRAME:
                val="S Frame";break;
            case SI_FRAME:
                val="SI Frame";break;
            case SP_FRAME:
                val="SP Frame";break;
            default:
                oss<<"Unknown Type: "<<Value;
                val=oss.str();
        }
        mPropCtrls[Prop]->Update(val);
    }
private:
    std::map<std::string,PropCtrl*> mPropCtrls;
};

class AVPacketDD:public PropertyHolder{
public:
    AVPacketDD(Window* parent,int width,int height,std::string Name="AVPacket")
    :PropertyHolder(parent,width,height,Name)
    {
        AddProp("pts","");
        AddProp("dts","");
        AddProp("size","");
        AddProp("pos","");
        AddProp("stream_index","");
        AddProp("flags","");
        AddProp("duration","");
    }
    void Update(AVPacket* p){
        UpdateCtrl("pos",p->pos);
        UpdateCtrl("pts",p->pts);
        UpdateCtrl("dts",p->dts);
        UpdateCtrl("size",p->size);
        UpdateCtrl("stream_index",p->stream_index);
        UpdateCtrl("flags",std::string(p->flags?"KeyFrame":"Non-KeyFrame"));
        UpdateCtrl("duration",p->duration);
    }
};

class AVStreamDD:public PropertyHolder{
public:
    AVStreamDD(Window* parent,int width,int height,std::string Name="AVStream")
    :PropertyHolder(parent,width,height,Name)
    {
        AddProp("pts","");
        AddProp("cur_dts","");
        AddProp("last_IP_pts","");
        AddProp("last_IP_duration","");
        AddProp("id","");
        AddProp("index","");
        AddProp("time_base","");
        AddProp("r_frame_rate","");
        AddProp("pts_wrap_bits","");
        AddProp("stream_copy","");
        AddProp("discard","");
        AddProp("quality","");
        AddProp("start_time","");
        AddProp("duration","");
        AddProp("language","");
        AddProp("nb_index_entries","");
        AddProp("nb_frames","");
    }
    void
    Update(AVStream* s){
        UpdateCtrl("index",s->index);
        UpdateCtrl("id",s->id);
        UpdateCtrl("cur_dts",s->cur_dts);
        UpdateCtrl("pts",s->pts);
        UpdateCtrl("time_base",s->time_base);
        UpdateCtrl("r_frame_rate",s->r_frame_rate);
        UpdateCtrl("pts_wrap_bits",s->pts_wrap_bits);
        UpdateCtrl("stream_copy",s->stream_copy);
        UpdateCtrl("discard",s->discard);
        UpdateCtrl("quality",s->quality);
        UpdateCtrl("start_time",s->start_time);
        UpdateCtrl("duration",s->duration);
        UpdateCtrl("language",s->language);
        UpdateCtrl("last_IP_duration",s->last_IP_duration);
        UpdateCtrl("last_IP_pts",s->last_IP_pts);
        UpdateCtrl("nb_index_entries",s->nb_index_entries);
        UpdateCtrl("nb_frames",s->nb_frames);
    }
};


class ByteIOContextDD:public PropertyHolder{
public:
    ByteIOContextDD(Window* parent,int width,int height,std::string Name="AVFormat")
    :PropertyHolder(parent,width,height,Name)
    {
        AddProp("pos","");
        AddProp("fpos","");
        AddProp("must_flush","");
        AddProp("eof_reached","");
        AddProp("write_flag","");
        AddProp("is_streamed","");
        AddProp("max_packet_size","");
        AddProp("error","");
    }
    void Update(ByteIOContext* b)
    {
        UpdateCtrl("pos",b->pos);
        UpdateCtrl("fpos",url_ftell(b));
        UpdateCtrl("must_flush",b->must_flush);
        UpdateCtrl("eof_reached",b->eof_reached);
        UpdateCtrl("write_flag",b->write_flag);
        UpdateCtrl("is_streamed",b->is_streamed);
        UpdateCtrl("max_packet_size",b->max_packet_size);
        UpdateCtrl("error",b->error);
    }
};
class AVFormatDD:public PropertyHolder{
public:
    AVFormatDD(Window* parent,int width,int height,std::string Name="AVFormat")
    :PropertyHolder(parent,width,height,Name)
    {
        mPb = new ByteIOContextDD(this,width-20,height,"pb");
        mCurPkt = new AVPacketDD(this,width-20,height,"cur_pkt");
        AddWindow(mPb);
        AddWindow(mCurPkt);
        AddProp("cur_len","");
        AddProp("cur_ptr","");
        AddProp("filename","");
        AddProp("nb_streams","");
        AddProp("title","");
        AddProp("author","");
        AddProp("copyright","");
        AddProp("comment","");
        AddProp("album","");
        AddProp("year","");
        AddProp("track","");
        AddProp("genre","");
        AddProp("ctx_flags","");
        AddProp("start_time","");
        AddProp("duration","");
        AddProp("file_size","");
        AddProp("bit_rate","");
        AddProp("data_offset","");
        AddProp("index_built","");
        AddProp("mux_rate","");
        AddProp("packet_size","");
        AddProp("preload","");
        AddProp("max_delay","");
        AddProp("loop_output","");
        AddProp("flags","");
#if LIBAVFORMAT_VERSION_INT >= ((51<<16)+(14<<8)+0)
        AddProp("loop_input","");
        AddProp("probesize","");
#endif

        for(int i=0;i<MAX_STREAMS;i++){
            mStreams[i]=0;
        }
        mStreamsDD = new DropDownWindow(this,width-20,height,"streams");
        AddWindow(mStreamsDD);
    };
    void Update(AVFormatContext* f){
        UpdateCtrl("filename",f->filename);
        UpdateCtrl("nb_streams",f->nb_streams);
        UpdateCtrl("title",f->title);
        UpdateCtrl("author",f->author);
        UpdateCtrl("copyright",f->copyright);
        UpdateCtrl("comment",f->comment);
        UpdateCtrl("album",f->album);
        UpdateCtrl("year",f->year);
        UpdateCtrl("track",f->track);
        UpdateCtrl("genre",f->genre);
        UpdateCtrl("ctx_flags",f->ctx_flags);
        UpdateCtrl("start_time",f->start_time);
        UpdateCtrl("duration",f->duration);
        UpdateCtrl("file_size",f->file_size);
        UpdateCtrl("bit_rate",f->bit_rate);
        UpdateCtrl("cur_len",f->cur_len);
        UpdateCtrl("cur_ptr",f->cur_ptr);
        UpdateCtrl("data_offset",f->data_offset);
        UpdateCtrl("index_built",f->index_built);
        UpdateCtrl("mux_rate",f->mux_rate);
        UpdateCtrl("packet_size",f->packet_size);
        UpdateCtrl("preload",f->preload);
        UpdateCtrl("max_delay",f->max_delay);
        UpdateCtrl("loop_output",f->loop_output);
        UpdateCtrl("flags",f->flags);
#if LIBAVFORMAT_VERSION_INT >= ((51<<16)+(14<<8)+0)
        UpdateCtrl("loop_input",f->loop_input);
        UpdateCtrl("probesize",f->probesize);
#endif
        mPb->Update(&f->pb);
        mCurPkt->Update(&f->cur_pkt);
        for(int i=0;i<f->nb_streams;i++){
            if(mStreams[i]==0){
                std::ostringstream oss;
                oss<<"Stream "<<i<<":"<<W();
                mStreams[i] = new AVStreamDD(mStreamsDD,W()-30,20,oss.str());
                mStreamsDD->AddWindow((mStreams[i]));
            }
            mStreams[i]->Update(f->streams[i]);
        }

    }

    AVStreamDD* mStreams[MAX_STREAMS];
    AVPacketDD* mCurPkt;
    ByteIOContextDD* mPb;
    DropDownWindow* mStreamsDD;
};


class AVCodecDD:public PropertyHolder{
public:
    AVCodecDD(Window* parent,int width,int height,std::string Name="AVFormat")
    :PropertyHolder(parent,width,height,Name)
    {
        AddProp("internal_buffer_count","");
        AddProp("frame_number","");
        AddProp("real_pict_num","");
        AddProp("codec_name","");
        AddProp("codec_type","");
        AddProp("codec_id","");
        AddProp("codec_tag","");
        AddProp("gop_size","");
        AddProp("flags","");
        AddProp("sub_id","");
        AddProp("me_method","");
        AddProp("time_base","");
        AddProp("frame_size","");
        AddProp("width","");
        AddProp("height","");
        AddProp("sample_aspect_ratio","");
        AddProp("coded_width","");
        AddProp("coded_height","");
        AddProp("bit_rate","");
        AddProp("bit_rate_tolerance","");
        AddProp("hurry_up","");
        AddProp("skip_count","");
        AddProp("timecode_frame_start","");
        AddProp("pix_fmt","");
        AddProp("rate_emu","");
        AddProp("sample_rate","");
        AddProp("channels","");
        AddProp("sample_fmt","");
        AddProp("delay","");
        AddProp("qcompress","");
        AddProp("qblur","");
        AddProp("qmin","");
        AddProp("qmax","");
        AddProp("max_qdiff","");
        AddProp("max_b_frames","");
        AddProp("b_quant_factor","");
        AddProp("b_frame_strategy","");
        AddProp("rtp_payload_size","");
        AddProp("mv_bits","");
        AddProp("header_bits","");
        AddProp("i_tex_bits","");
        AddProp("p_tex_bits","");
        AddProp("i_count","");
        AddProp("p_count","");
        AddProp("misc_bits","");
        AddProp("frame_bits","");
        AddProp("workaround_bugs","");
        AddProp("luma_elim_threshold","");
        AddProp("chroma_elim_threshold","");
        AddProp("strict_std_compliance","");
        AddProp("b_quant_offset","");
        AddProp("error_resilience","");
        AddProp("has_b_frames","");
        AddProp("block_align","");
        AddProp("parse_only","");
        AddProp("mpeg_quant","");
        AddProp("stats_out","");
        AddProp("stats_in","");
        AddProp("rc_qsquish","");
        AddProp("rc_qmod_amp","");
        AddProp("rc_qmod_freq","");
        AddProp("rc_override_count","");
        AddProp("rc_eq","");
        AddProp("rc_max_rate","");
        AddProp("rc_min_rate","");
        AddProp("rc_buffer_size","");
        AddProp("rc_buffer_aggressivity","");
        AddProp("i_quant_factor","");
        AddProp("i_quant_offset","");
        AddProp("rc_initial_cplx","");
        AddProp("dct_algo","");
        AddProp("lumi_masking","");
        AddProp("temporal_cplx_masking","");
        AddProp("spatial_cplx_masking","");
        AddProp("p_masking","");
        AddProp("dark_masking","");
        AddProp("unused","");
        AddProp("idct_algo","");
        AddProp("slice_count","");
        AddProp("slice_offset","");
        AddProp("error_concealment","");
        AddProp("dsp_mask","");
        AddProp("bits_per_sample","");
        AddProp("prediction_method","");
        AddProp("debug","");
        AddProp("debug_mv","");
        AddProp("error","");
        AddProp("mb_qmin","");
        AddProp("mb_qmax","");
        AddProp("me_cmp","");
        AddProp("me_sub_cmp","");
        AddProp("mb_cmp","");
        AddProp("ildct_cmp","");
        AddProp("dia_size","");
        AddProp("last_predictor_count","");
        AddProp("pre_me","");
        AddProp("me_pre_cmp","");
        AddProp("pre_dia_size","");
        AddProp("me_subpel_quality","");
        AddProp("dtg_active_format","");
        AddProp("me_range","");
        AddProp("intra_quant_bias","");
        AddProp("inter_quant_bias","");
        AddProp("color_table_id","");
        AddProp("global_quality","");
        AddProp("coder_type","");
        AddProp("context_model","");
        AddProp("slice_flags","");
        AddProp("xvmc_acceleration","");
        AddProp("mb_decision","");
        AddProp("stream_codec_tag","");
        AddProp("scenechange_threshold","");
        AddProp("lmin","");
        AddProp("lmax","");
        AddProp("noise_reduction","");
        AddProp("rc_initial_buffer_occupancy","");
        AddProp("inter_threshold","");
        AddProp("flags2","");
        AddProp("error_rate","");
        AddProp("antialias_algo","");
        AddProp("quantizer_noise_shaping","");
        AddProp("thread_count","");
        AddProp("me_threshold","");
        AddProp("mb_threshold","");
        AddProp("intra_dc_precision","");
        AddProp("nsse_weight","");
        AddProp("skip_top","");
        AddProp("skip_bottom","");
        AddProp("profile","");
        AddProp("level","");
        AddProp("lowres","");
        AddProp("frame_skip_threshold","");
        AddProp("frame_skip_factor","");
        AddProp("frame_skip_exp","");
        AddProp("frame_skip_cmp","");
        AddProp("border_masking","");
        AddProp("mb_lmin","");
        AddProp("mb_lmax","");
        AddProp("me_penalty_compensation","");
        AddProp("skip_loop_filter","");
        AddProp("skip_idct","");
        AddProp("skip_frame","");
        AddProp("bidir_refine","");
        AddProp("brd_scale","");
        AddProp("crf","");
        AddProp("cqp","");
        AddProp("keyint_min","");
        AddProp("refs","");
        AddProp("chromaoffset","");
        AddProp("bframebias","");
        AddProp("trellis","");
        AddProp("complexityblur","");
        AddProp("deblockalpha","");
        AddProp("deblockbeta","");
        AddProp("partitions","");
        AddProp("directpred","");
        AddProp("cutoff","");
        AddProp("scenechange_factor","");
#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(44<<8)+0) 
        AddProp("mv0_threshold","");
        AddProp("b_sensitivity","");
        AddProp("compression_level","");
        AddProp("use_lpc","");
        AddProp("lpc_coeff_precision","");
        AddProp("min_prediction_order","");
        AddProp("max_prediction_order","");
        AddProp("prediction_order_method","");
        AddProp("min_partition_order","");
        AddProp("max_partition_order","");
#endif
    }
    void 
    Update(AVCodecContext* c){
        UpdateCtrl("bit_rate",c->bit_rate);
        UpdateCtrl("bit_rate_tolerance",c->bit_rate_tolerance);
        UpdateCtrl("flags",c->flags);
        UpdateCtrl("sub_id",c->sub_id);
        UpdateCtrl("me_method",c->me_method);
        UpdateCtrl("time_base",c->time_base);
        UpdateCtrl("width",c->width);
        UpdateCtrl("height",c->height);
        UpdateCtrl("gop_size",c->gop_size);
        UpdateCtrl("pix_fmt",c->pix_fmt);
        UpdateCtrl("rate_emu",c->rate_emu);
        UpdateCtrl("sample_rate",c->sample_rate);
        UpdateCtrl("channels",c->channels);
        UpdateCtrl("sample_fmt",c->sample_fmt);
        UpdateCtrl("frame_size",c->frame_size);
        UpdateCtrl("frame_number",c->frame_number);
        UpdateCtrl("real_pict_num",c->real_pict_num);
        UpdateCtrl("delay",c->delay);
        UpdateCtrl("qcompress",c->qcompress);
        UpdateCtrl("qblur",c->qblur);
        UpdateCtrl("qmin",c->qmin);
        UpdateCtrl("qmax",c->qmax);
        UpdateCtrl("max_qdiff",c->max_qdiff);
        UpdateCtrl("max_b_frames",c->max_b_frames);
        UpdateCtrl("b_quant_factor",c->b_quant_factor);
        UpdateCtrl("b_frame_strategy",c->b_frame_strategy);
        UpdateCtrl("hurry_up",c->hurry_up);
        UpdateCtrl("rtp_payload_size",c->rtp_payload_size);
        UpdateCtrl("mv_bits",c->mv_bits);
        UpdateCtrl("header_bits",c->header_bits);
        UpdateCtrl("i_tex_bits",c->i_tex_bits);
        UpdateCtrl("p_tex_bits",c->p_tex_bits);
        UpdateCtrl("i_count",c->i_count);
        UpdateCtrl("p_count",c->p_count);
        UpdateCtrl("skip_count",c->skip_count);
        UpdateCtrl("misc_bits",c->misc_bits);
        UpdateCtrl("frame_bits",c->frame_bits);
        UpdateCtrl("codec_name",c->codec_name);
        UpdateCtrl("codec_type",c->codec_type);
        UpdateCtrl("codec_id",c->codec_id);
        UpdateCtrl("codec_tag",c->codec_tag);
        UpdateCtrl("workaround_bugs",c->workaround_bugs);
        UpdateCtrl("luma_elim_threshold",c->luma_elim_threshold);
        UpdateCtrl("chroma_elim_threshold",c->chroma_elim_threshold);
        UpdateCtrl("strict_std_compliance",c->strict_std_compliance);
        UpdateCtrl("b_quant_offset",c->b_quant_offset);
        UpdateCtrl("error_resilience",c->error_resilience);
        UpdateCtrl("has_b_frames",c->has_b_frames);
        UpdateCtrl("block_align",c->block_align);
        UpdateCtrl("parse_only",c->parse_only);
        UpdateCtrl("mpeg_quant",c->mpeg_quant);
        UpdateCtrl("stats_out",c->stats_out);
        UpdateCtrl("stats_in",c->stats_in);
        UpdateCtrl("rc_qsquish",c->rc_qsquish);
        UpdateCtrl("rc_qmod_amp",c->rc_qmod_amp);
        UpdateCtrl("rc_qmod_freq",c->rc_qmod_freq);
        UpdateCtrl("rc_override_count",c->rc_override_count);
        UpdateCtrl("rc_eq",c->rc_eq);
        UpdateCtrl("rc_max_rate",c->rc_max_rate);
        UpdateCtrl("rc_min_rate",c->rc_min_rate);
        UpdateCtrl("rc_buffer_size",c->rc_buffer_size);
        UpdateCtrl("rc_buffer_aggressivity",c->rc_buffer_aggressivity);
        UpdateCtrl("i_quant_factor",c->i_quant_factor);
        UpdateCtrl("i_quant_offset",c->i_quant_offset);
        UpdateCtrl("rc_initial_cplx",c->rc_initial_cplx);
        UpdateCtrl("dct_algo",c->dct_algo);
        UpdateCtrl("lumi_masking",c->lumi_masking);
        UpdateCtrl("temporal_cplx_masking",c->temporal_cplx_masking);
        UpdateCtrl("spatial_cplx_masking",c->spatial_cplx_masking);
        UpdateCtrl("p_masking",c->p_masking);
        UpdateCtrl("dark_masking",c->dark_masking);
        UpdateCtrl("unused",c->unused);
        UpdateCtrl("idct_algo",c->idct_algo);
        UpdateCtrl("slice_count",c->slice_count);
        UpdateCtrl("slice_offset",c->slice_offset);
        UpdateCtrl("error_concealment",c->error_concealment);
        UpdateCtrl("dsp_mask",c->dsp_mask);
        UpdateCtrl("bits_per_sample",c->bits_per_sample);
        UpdateCtrl("prediction_method",c->prediction_method);
        UpdateCtrl("sample_aspect_ratio",c->sample_aspect_ratio);
        UpdateCtrl("debug",c->debug);
        UpdateCtrl("debug_mv",c->debug_mv);
        UpdateCtrl("error",c->error);
        UpdateCtrl("mb_qmin",c->mb_qmin);
        UpdateCtrl("mb_qmax",c->mb_qmax);
        UpdateCtrl("me_cmp",c->me_cmp);
        UpdateCtrl("me_sub_cmp",c->me_sub_cmp);
        UpdateCtrl("mb_cmp",c->mb_cmp);
        UpdateCtrl("ildct_cmp",c->ildct_cmp);
        UpdateCtrl("dia_size",c->dia_size);
        UpdateCtrl("last_predictor_count",c->last_predictor_count);
        UpdateCtrl("pre_me",c->pre_me);
        UpdateCtrl("me_pre_cmp",c->me_pre_cmp);
        UpdateCtrl("pre_dia_size",c->pre_dia_size);
        UpdateCtrl("me_subpel_quality",c->me_subpel_quality);
        UpdateCtrl("dtg_active_format",c->dtg_active_format);
        UpdateCtrl("me_range",c->me_range);
        UpdateCtrl("intra_quant_bias",c->intra_quant_bias);
        UpdateCtrl("inter_quant_bias",c->inter_quant_bias);
        UpdateCtrl("color_table_id",c->color_table_id);
        UpdateCtrl("internal_buffer_count",c->internal_buffer_count);
        UpdateCtrl("global_quality",c->global_quality);
        UpdateCtrl("coder_type",c->coder_type);
        UpdateCtrl("context_model",c->context_model);
        UpdateCtrl("slice_flags",c->slice_flags);
        UpdateCtrl("xvmc_acceleration",c->xvmc_acceleration);
        UpdateCtrl("mb_decision",c->mb_decision);
        UpdateCtrl("stream_codec_tag",c->stream_codec_tag);
        UpdateCtrl("scenechange_threshold",c->scenechange_threshold);
        UpdateCtrl("lmin",c->lmin);
        UpdateCtrl("lmax",c->lmax);
        UpdateCtrl("noise_reduction",c->noise_reduction);
        UpdateCtrl("rc_initial_buffer_occupancy",c->rc_initial_buffer_occupancy);
        UpdateCtrl("inter_threshold",c->inter_threshold);
        UpdateCtrl("flags2",c->flags2);
        UpdateCtrl("error_rate",c->error_rate);
        UpdateCtrl("antialias_algo",c->antialias_algo);
        UpdateCtrl("quantizer_noise_shaping",c->quantizer_noise_shaping);
        UpdateCtrl("thread_count",c->thread_count);
        UpdateCtrl("me_threshold",c->me_threshold);
        UpdateCtrl("mb_threshold",c->mb_threshold);
        UpdateCtrl("intra_dc_precision",c->intra_dc_precision);
        UpdateCtrl("nsse_weight",c->nsse_weight);
        UpdateCtrl("skip_top",c->skip_top);
        UpdateCtrl("skip_bottom",c->skip_bottom);
        UpdateCtrl("profile",c->profile);
        UpdateCtrl("level",c->level);
        UpdateCtrl("lowres",c->lowres);
        UpdateCtrl("coded_width",c->coded_width);
        UpdateCtrl("coded_height",c->coded_height);
        UpdateCtrl("frame_skip_threshold",c->frame_skip_threshold);
        UpdateCtrl("frame_skip_factor",c->frame_skip_factor);
        UpdateCtrl("frame_skip_exp",c->frame_skip_exp);
        UpdateCtrl("frame_skip_cmp",c->frame_skip_cmp);
        UpdateCtrl("border_masking",c->border_masking);
        UpdateCtrl("mb_lmin",c->mb_lmin);
        UpdateCtrl("mb_lmax",c->mb_lmax);
        UpdateCtrl("me_penalty_compensation",c->me_penalty_compensation);
        UpdateCtrl("skip_loop_filter",c->skip_loop_filter);
        UpdateCtrl("skip_idct",c->skip_idct);
        UpdateCtrl("skip_frame",c->skip_frame);
        UpdateCtrl("bidir_refine",c->bidir_refine);
        UpdateCtrl("brd_scale",c->brd_scale);
        UpdateCtrl("crf",c->crf);
        UpdateCtrl("cqp",c->cqp);
        UpdateCtrl("keyint_min",c->keyint_min);
        UpdateCtrl("refs",c->refs);
        UpdateCtrl("chromaoffset",c->chromaoffset);
        UpdateCtrl("bframebias",c->bframebias);
        UpdateCtrl("trellis",c->trellis);
        UpdateCtrl("complexityblur",c->complexityblur);
        UpdateCtrl("deblockalpha",c->deblockalpha);
        UpdateCtrl("deblockbeta",c->deblockbeta);
        UpdateCtrl("partitions",c->partitions);
        UpdateCtrl("directpred",c->directpred);
        UpdateCtrl("cutoff",c->cutoff);
        UpdateCtrl("scenechange_factor",c->scenechange_factor);
#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(44<<8)+0) 
        UpdateCtrl("mv0_threshold",c->mv0_threshold);
        UpdateCtrl("b_sensitivity",c->b_sensitivity);
        UpdateCtrl("compression_level",c->compression_level);
        UpdateCtrl("use_lpc",c->use_lpc);
        UpdateCtrl("lpc_coeff_precision",c->lpc_coeff_precision);
        UpdateCtrl("min_prediction_order",c->min_prediction_order);
        UpdateCtrl("max_prediction_order",c->max_prediction_order);
        UpdateCtrl("prediction_order_method",c->prediction_order_method);
        UpdateCtrl("min_partition_order",c->min_partition_order);
        UpdateCtrl("max_partition_order",c->max_partition_order);
        UpdateCtrl("timecode_frame_start",c->timecode_frame_start);
#endif

    }

};
class AVFrameDD:public PropertyHolder{
public:
    AVFrameDD(Window* parent,int width,int height,std::string Name="AVFrame")
    :PropertyHolder(parent,width,height,Name)
    {
        AddProp("key_frame","");
        AddProp("pict_type","");
        AddProp("reference","");
        AddProp("coded_picture_number","");
        AddProp("display_picture_number","");
        AddProp("pts","");
        AddProp("quality","");
        AddProp("age","");
        AddProp("qstride","");
        AddProp("type","");
        AddProp("repeat_pict","");
        AddProp("qscale_type","");
        AddProp("interlaced_frame","");
        AddProp("top_field_first","");
        AddProp("palette_has_changed","");
    }
    void Update(AVFrame* f){
        UpdateCtrl("key_frame",f->key_frame);
        UpdateCtrl("pict_type",FRAME_TYPE(f->pict_type));
        UpdateCtrl("pts",f->pts);
        UpdateCtrl("coded_picture_number",f->coded_picture_number);
        UpdateCtrl("display_picture_number",f->display_picture_number);
        UpdateCtrl("quality",f->quality);
        UpdateCtrl("age",f->age);
        UpdateCtrl("reference",f->reference);
        UpdateCtrl("qstride",f->qstride);
        UpdateCtrl("type",f->type);
        UpdateCtrl("repeat_pict",f->repeat_pict);
        UpdateCtrl("qscale_type",f->qscale_type);
        UpdateCtrl("interlaced_frame",f->interlaced_frame);
        UpdateCtrl("top_field_first",f->top_field_first);
        UpdateCtrl("palette_has_changed",f->palette_has_changed);
    }

};

class DropDownList:public DropDownWindow,public StringListener{
public:
    DropDownList(Window* W,int x,int y,int w, int h,std::string head)
    :mList(0),
    mCurSelection(0),
    DropDownWindow(W,x,y,w,h,head,0){
        
        mList = new StringSelector(this,w-10,160);
        mList->SetStringListener(this,0);
        
        AddWindow(mList,5);
        HeaderText()->SetAlign(oglLeftAlign, oglCenterAlign);
        HeaderWindow()->SetBorderType(BEV_ETCHED);
    }

    void AddString(std::string s){
        mList->AddString(s);
    }
    
    void SetDefault(int strIndex){
        mCurSelection = strIndex;
        HeaderText()->SetText(mList->GetString(strIndex));
    }
    void
    StringSelectionEvent(StringSelector *src, int strIndex, void* listenerData)
    {
        mCurSelection = strIndex;
        HeaderText()->SetText(src->GetString(strIndex));
        DropDown(false);
    }

    virtual void
    WindowMouseEvent(Window *src, int msg, int but, int state, int x, int y,
                     void* listenerData)
    {
        if (but==oglLeftButton)
        {
            if ((msg == oglMouseDown)||( msg == oglMouseDblClick))
                DropDown(!IsDropped());
        }
    }
    int GetCurSel(){
        return mCurSelection;
    }

    StringSelector* mList;
    int mCurSelection;
};


class FFMPEGControl:public Window,public ButtonListener{
public:
    FFMPEGControl(Window* W,int w, int h,RgbDataSrcLavc* src,AppControlSrc* ctrl)
     :Window(W,w,h)
    {
        mCtrl=ctrl;
        mSrc=src;
        mSeekFrmField = new TextField(this,20,h-40,80,20,"");
        mSeekPosField = new TextField(this,20,h-80,80,20,"");
        mSeekFlags = new DropDownList(this,20,h-120,130,20,"CHOOSE SEEK FLAGS");
        mFlushCodec = new DropDownList(this,170,h-120,130,20,"FLUSH CODEC?");
        mSyncFrame = new DropDownList(this,320,h-120,130,20,"SYNC FRAME");

        mSeekFlags->AddString("NONE");
        mSeekFlags->AddString("BACKWARD");
        mSeekFlags->AddString("BYTE");
        mSeekFlags->AddString("BYTE & BACKWARD");
        mSeekFlags->AddString("ANY");
        mSeekFlags->AddString("ANY & BACKWARD");
        mSeekFlags->AddString("ANY & BYTE");
        mSeekFlags->AddString("ANY & BYTE & BACKWARD");
        (new Button(this,350,h-40,100,20,"JUMP"))
            ->SetButtonListener(this,0);
        (new Button(this,350,h-80,100,20,"SEEK"))
            ->SetButtonListener(this,1);
        (new Button(this,350,h-160,100,20,"NEXT"))
            ->SetButtonListener(this,3);
        (new Button(this,350,h-200,100,20,"RESET"))
            ->SetButtonListener(this,2);
        mFlushCodec->AddString("NONE");
        mFlushCodec->AddString("BEFORE");
        mFlushCodec->AddString("AFTER");
        mFlushCodec->AddString("BEFORE & AFTER");
        mSyncFrame->AddString("NONE");
        mSyncFrame->AddString("FRAME");
        mSyncFrame->AddString("KEYFRAME");
        mSeekFlags->SetDefault(2);
        mFlushCodec->SetDefault(2);
        mSyncFrame->SetDefault(2);
        SetBackground(oglTrLIGHTGREEN);

        
//        (new Button(this,150,90,90,20,"JUMP TO2"))->SetButtonListener(this,1);
        

    }
    void ButtonSelectionEvent(Button *src, void* vData)
    {
        int userData = (long long) vData;
        switch(userData){
            case 0://Jump to beginning and access sequential
                {
                int frm;
                std::istringstream iss(mSeekFrmField->GetText());
                if(iss.str()=="")
                    break;
                iss >> frm;
                if(iss.fail()){
                    mSeekPosField->SetText("");
                    break;
                }
                mSrc->GotoFrame(frm) ;
                //mSrc->Jump(pos,2,true);
                //mSrc->NextFrame(pos);
                break;
                }

            case 1: //SEEK
                {
                int64_t pos;
                std::istringstream iss(mSeekPosField->GetText());
                if(iss.str()=="")
                    break;
                iss >> pos;
                if(iss.fail())
                    mSeekPosField->SetText("");
                else
                    mSrc->Jump(pos,mSeekFlags->GetCurSel(),mFlushCodec->GetCurSel(),mSyncFrame->GetCurSel());
                
                //mSrc->NextFrame();
                break;
                }

            case 2: //RESET To FIRST FRAME
                mSrc->Jump(0,2,true);
                //mSrc->NextFrame();
                break;

            case 3://NEXT FRAME
                mSrc->NextFrame();
                break;

        }
        mCtrl->HandleNewFrame();
    }
    DropDownList* mSeekFlags;
    TextField* mSeekPosField;
    TextField* mSeekFrmField;
    DropDownList*  mFlushCodec;
    DropDownList*  mSyncFrame;
    RgbDataSrcLavc* mSrc;
    AppControlSrc* mCtrl;
};
class RgbDataSrcLavcTestGUI : public Window, public AppControlSrc,
                   public VideoNavListener, public OglGui::ViewListener
{
    VideoNav*         mVideoNav;
    DropDownWindow* mDropDown;
    AVFormatDD *mDDFormat;
    AVCodecDD *mDDCodec;
    AVFrameDD* mDDFrame;
    AVStreamDD* mDDStream;
    AVPacketDD* mDDPacket;
              
    StaticText* mStaticText;
    PropertySheet* mFPropSheet,*mCPropSheet,
                  *mFrPropSheet,*mSPropSheet,*mPPropSheet;
    RgbDataSrcLavc* mLavcsrc;
    VideoSet* mVideoSet;
    FFMPEGControl* mVideoCtrl;
    Tabs* mTabs;
    //View* mFrameView;
private:
    ILOG_VAR_DEC;

public:

    RgbDataSrcLavcTestGUI(int x, int y, bool doZoom, bool mainIs2d, 
            bool vpIs2d,RgbDataSrcLavc* src) 
    : Window(x, y, 1280, SuggestWndHeight(1, src->FrameHeight()+550),
              mainIs2d),
      AppControlSrc(1)
    {
        //Get The Command line options
        CmdOptions& options = CmdOptions::GetInstance();

        //Set the source
        SetSource(src);
        mLavcsrc=src;
        SetForeground(oglDARKGREY);
        SetBackground(oglLIGHTGREY);
        mTabs = new Tabs(this, src->FrameWidth()+20, src->FrameHeight()+70);

        mVideoNav = new VideoNav(mTabs->CreateTab("Video", 80), src);
        mVideoNav->SetVideoNavListener(this);

        /*
         * mFrameView = new View(mTabs->CreateTab("Frame",80)->GetOGLWND(),
                    0, 60,
                    src->FrameWidth()+10,
                    src->FrameHeight()+10,1,true,true,true);
        */
        mTabs->SetActiveTab(0);

        //standart video navigation stuff
//        mStaticText=
        mVideoCtrl=new FFMPEGControl(this,W()-src->FrameWidth()-50,70+src->FrameHeight(),src,this);
        mFPropSheet = new PropertySheet(this, 250, 500);
        mCPropSheet = new PropertySheet(this, 250, 500);
        mFrPropSheet= new PropertySheet(this, 250, 500);
        mSPropSheet = new PropertySheet(this, 250, 500);
        mPPropSheet = new PropertySheet(this, 250, 500);



        //mDropDown = new DropDownWindow(content,400,20,"FFMPEG Structs");

        OglGui::Window*  content   = mFPropSheet->ContentPane();
        content->SetDimensions(0, 0, 250, 4000);
        mDDFormat = new AVFormatDD(content,240,20,"Format Context");
        
        content   = mCPropSheet->ContentPane();
        content->SetDimensions(0, 0, 250, 4000);
        mDDCodec  = new AVCodecDD(content,240,20,"CodecContext");
        
        content   = mFrPropSheet->ContentPane();
        content->SetDimensions(0, 0, 250, 4000);
        mDDFrame  = new AVFrameDD(content,240,20,"Frame");
        
        content   = mSPropSheet->ContentPane();
        content->SetDimensions(0, 0, 250, 4000);
        mDDStream  = new AVStreamDD(content,240,20,"Stream");

        content   = mPPropSheet->ContentPane();
        content->SetDimensions(0, 0, 250, 4000);
        mDDPacket  = new AVPacketDD(content,240,20,"Packet");

        mVideoSet = MakeVideoSet(src->GetName());
        mVideoCtrl->SetBackground(oglTrLIGHTGREEN);
        //WriteRawFrames();
        //TempTest();

#ifdef OGL_USING_GLUT
        SetAlwaysDraw(); // UpdateScene() doesn't work.
#endif
        AppController::Instance().MainLoop();

    }

    void TempTest(){

        //TODO:This function should be changed to handle MD5 hashes
        ILOG_INFO("Starting");
        mLavcsrc->NextFrame();
        for (int i=168626;i<294912;i++){
            
            mLavcsrc->Jump(i,AVSEEK_FLAG_BYTE,2,2);

            if(mLavcsrc->IsFrameAccurate())
            {
                std::cout<<"Success @ "<<i<<std::endl;
            }else{
                std::cout<<"No Success @ "<<i<<std::endl;
            }
        }
        exit(0);

    }

    void SetSource(RgbDataSrc* src){
        SetSrc(src);
        AppController::Instance().AddControl((AppControlSrc*) this, true);
    }

    void
    MainLoop(){
        AppController::Instance().MainLoop();
    }

    void
    HandleCycleSrc()
    {
        UpdateScene();
        SetStatusStr((char*) GetFpsString().c_str());
    }

    void
    HandleDestroyEvent()
    {
    //    mShotSeg->HandleDoneFile();
    }

    void
    HandleNewFrame()
    {
        Array2dVec3UInt8* rgb = ArrayCreate<Array2dVec3UInt8>
                    (GetSrc()->FrameWidth(), GetSrc()->FrameHeight(), 
                        0, 0,GetSrc()->DataPtr(),true);

        mVideoNav->UpdateView(0,rgb,"");
        mDDFormat->Update(mLavcsrc->GetFormatCtx());
        mDDCodec->Update(mLavcsrc->GetCodecCtx());
        mDDFrame->Update(mLavcsrc->GetFrameCtx());
        mDDStream->Update(mLavcsrc->GetStream());
        mDDPacket->Update(mLavcsrc->GetPacket());

        if(mLavcsrc->IsFrameAccurate())
        {
            //mVideoCtrl->SetBackground(oglTrLIGHTGREEN);
        }else{
            mVideoCtrl->SetBackground(oglTrLIGHTRED);
        }
        delete rgb;
    }
    
    /*
 *  These Functions were for comparing a reference image with the current frame,
 *  now we use the MD5 hashing option.

    bool
    Compare(Array2dVec3UInt8* src, Array2dVec3UInt8* ref)
    {
        if (ref == 0)
        {
            ILOG_ERROR("Unable to read reference frame!");
            return false;
        }
        bool ret = DoCompare(src, ref);
        return ret;
    }
    
    bool
    DoCompare(Array2dVec3UInt8* src, Array2dVec3UInt8* ref)
    {
        std::ostringstream ost;
        bool ret=true;
        if (src->CW() != ref->CW())
            ret=false;
        if (src->CH() != ref->CH())
            ret=false;
        
        Trait::BpoTestEqual<Array2dScalarReal64,Array2dVec3UInt8,Array2dVec3UInt8> bpo(0.00001);
        Array2dScalarReal64* dst = 0;
        Pattern::PatBinaryPixOp(dst, src, ref, bpo);
        if (bpo.mNrDiff > 0){
            ost << "TestEqual found " << bpo.mNrDiff << " differences, in "
                << bpo.mNr << " pixels, sum diffs : " << bpo.mSumDiff 
                << " avg diff : " << bpo.mSumDiff / bpo.mNrDiff 
                << " avg src1 : " << bpo.mSumSrc1 / bpo.mNr
                << " avg src2 : " << bpo.mSumSrc2 / bpo.mNr << std::ends;
            ret=false;
        }
        delete dst;
        return ret;
        
    }
    */


    // specialization of base classes

    void
    NavFrameEvent(VideoNav* src, int requestedFrame, void* listenerData)
    {
        Jump(requestedFrame);
    }

    virtual void
    OnViewMouse(OglGui::View* view, int msg, int btn, int state,
    float x, float y)
    {
    }


};
ILOG_VAR_INIT(RgbDataSrcLavcTestGUI,Impala.Visualization);
} // namespace Visualization
} // namespace Impala
#endif

---