Graphics Optimisations

Graphs/gFlagsLine.cpp

@@ -138,33 +138,87 @@ void gFlagsLine::paint(gGraph & w,int left, int top, int width, int height)
     float bottom=top+height-2;
     bool verts_exceeded=false;
     qint64 X,X2,L;
-    lines->setColor(schema::channel[m_code].defaultColor().rgba());
+    lines->setColor(schema::channel[m_code].defaultColor());
+
+    qint64 start;
+    quint32 * tptr;
+    EventStoreType *dptr;
+    int idx;
     for (QVector<Session *>::iterator s=m_day->begin();s!=m_day->end(); s++) {
         if (!(*s)->enabled()) continue;
 
         if ((*s)->eventlist.find(m_code)==(*s)->eventlist.end()) continue;
 
         EventList & el=*((*s)->eventlist[m_code][0]);
+        start=el.first();
+        tptr=el.rawTime();
+        dptr=el.rawData();
+        int np=el.count();
 
-        for (quint32 i=0;i<el.count();i++) {
+        for (idx=0; idx < np; idx++) {
-            X=el.time(i);
+            X=start + *tptr++;
-            L=el.data(i)*1000;
+            L=*dptr++ * 1000;
+            if (X >= minx)
+                break;
             X2=X-L;
-            if (X2 < minx) continue;
+            if (X2 >= minx)
-            if (X > maxx) break;
+                break;
-            x1=(X - minx) * xmult + left;
+        }
-            if (m_flt==FT_Bar) {
+        np-=idx;
+
+        if (m_flt==FT_Bar) {
+            ///////////////////////////////////////////////////////////////////////////
+            // Draw Event Flag Bars
+            ///////////////////////////////////////////////////////////////////////////
+
+            // Check bounds outside of loop is faster..
+            // This will have to be reverted if multithreaded drawing is ever brought back
+
+            int rem=lines->Max() - lines->cnt();
+            if ((np<<1) > rem) {
+                qDebug() << "gFlagsLine would overfill lines for" << schema::channel[m_code].label();
+                np=rem >> 1;
+                verts_exceeded=true;
+            }
+
+            for (int i=0;i<np;i++) {
+                X=start + * tptr++; //el.time(i);
+
+                if (X > maxx)
+                    break;
+
+                x1=(X - minx) * xmult + left;
                 lines->add(x1,bartop,x1,bottom);
-                if (lines->full()) { verts_exceeded=true; break; }
+
-            } else if (m_flt==FT_Span) {
+                //if (lines->full()) { verts_exceeded=true; break; }
+            }
+        } else if (m_flt==FT_Span) {
+            ///////////////////////////////////////////////////////////////////////////
+            // Draw Event Flag Spans
+            ///////////////////////////////////////////////////////////////////////////
+            quads->setColor(m_flag_color);
+            int rem=quads->Max() - quads->cnt();
+
+            if ((np<<2) > rem) {
+                qDebug() << "gFlagsLine would overfill quads for" << schema::channel[m_code].label();
+                np=rem >> 2;
+                verts_exceeded=true;
+            }
+
+            for (int i=0;i < np; i++) {
+                X=start + * tptr++;
+
+                if (X > maxx)
+                    break;
+
+                L=*dptr++ * 1000;
+                X2=X-L;
+
+                x1=(X - minx) * xmult + left;
                 x2=(X2-minx)*xmult+left;
-                //w1=x2-x1;
+                quads->unsafe_add(x2,bartop,x1,bartop, x1,bottom,x2,bottom);
-                /*if (qAbs(x1-x2)<=1) {
+                //if (quads->full()) { verts_exceeded=true; break; }
-                    x1-=1;
+
-                    x2+=1;
-                }*/
-                quads->add(x2,bartop,x1,bartop, x1,bottom,x2,bottom,m_flag_color.rgba());
-                if (quads->full()) { verts_exceeded=true; break; }
             }
         }
         if (verts_exceeded) break;

Graphs/gFooBar.cpp

@@ -32,8 +32,8 @@ void gShadowArea::paint(gGraph & w,int left, int top, int width, int height)
     //float h=top;
 
     double rmx=w.rmax_x-w.rmin_x;
-    double px=((1/rmx)*(w.min_x-w.rmin_x))*width;
+    double px=((1.0/rmx)*(w.min_x-w.rmin_x))*width;
-    double py=((1/rmx)*(w.max_x-w.rmin_x))*width;
+    double py=((1.0/rmx)*(w.max_x-w.rmin_x))*width;
 
     quads->add(start_px,top,start_px,top+height,start_px+px, top+height, start_px+px, top,m_shadow_color.rgba());
     quads->add(start_px+py, top, start_px+py, top+height,end_px, top+height, end_px, top,m_shadow_color.rgba());

Graphs/gGraphView.cpp

@@ -321,18 +321,40 @@ void gVertexBuffer::add(GLshort x1, GLshort y1, GLshort x2, GLshort y2, GLshort
         m_cnt+=4;
     }
 }
+void gVertexBuffer::unsafe_add(GLshort x1, GLshort y1)
+{
+    gVertex & v=buffer[m_cnt++];
+
+    v.color=m_color;
+    v.x=x1;
+    v.y=y1;
+}
 void gVertexBuffer::add(GLshort x1, GLshort y1)
 {
     if (m_cnt<m_max) {
-        gVertex & v=buffer[m_cnt];
+        gVertex & v=buffer[m_cnt++];
 
         v.color=m_color;
         v.x=x1;
         v.y=y1;
-
-        m_cnt++;
     }
 }
+void gVertexBuffer::unsafe_add(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
+{
+    gVertex * v=&buffer[m_cnt];
+
+    v->x=x1;
+    v->y=y1;
+    v->color=m_color;
+
+    v++;
+    v->x=x2;
+    v->y=y2;
+    v->color=m_color;
+
+    m_cnt+=2;
+}
+
 void gVertexBuffer::add(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
     if (m_cnt < (m_max-1)) {
@@ -377,6 +399,31 @@ void gVertexBuffer::add(GLshort x1, GLshort y1, GLshort x2, GLshort y2, GLshort
         m_cnt+=4;
     }
 }
+void gVertexBuffer::unsafe_add(GLshort x1, GLshort y1, GLshort x2, GLshort y2, GLshort x3, GLshort y3, GLshort x4, GLshort y4)
+{
+    gVertex *v=&buffer[m_cnt];
+
+    v->color=m_color;
+    v->x=x1;
+    v->y=y1;
+    v++;
+
+    v->color=m_color;
+    v->x=x2;
+    v->y=y2;
+
+    v++;
+    v->color=m_color;
+    v->x=x3;
+    v->y=y3;
+
+    v++;
+    v->color=m_color;
+    v->x=x4;
+    v->y=y4;
+
+    m_cnt+=4;
+}
 
 
 GLBuffer::GLBuffer(int max,int type, bool stippled)

Graphs/gGraphView.h

@@ -94,6 +94,10 @@ public:
     void add(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
     void add(GLshort x1, GLshort y1, GLshort x2, GLshort y2, GLshort x3, GLshort y3, GLshort x4, GLshort y4);
 
+    void unsafe_add(GLshort x1, GLshort y1);
+    void unsafe_add(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+    void unsafe_add(GLshort x1, GLshort y1, GLshort x2, GLshort y2, GLshort x3, GLshort y3, GLshort x4, GLshort y4);
+
     void draw();
 
     void scissor(GLshort x, GLshort y, GLshort width, GLshort height) { s_x=x; s_y=y; s_width=width; s_height=height; m_scissor=true; }

Graphs/gLineChart.cpp

@@ -153,7 +153,7 @@ void gLineChart::paint(gGraph & w,int left, int top, int width, int height)
     EventDataType lastpx,lastpy;
     EventDataType px,py;
     int idx;
-    bool done,first;
+    bool done;
     double x0,xL;
     double sr;
     int sam;
@@ -326,45 +326,61 @@ void gLineChart::paint(gGraph & w,int left, int top, int width, int height)
                 double time;
                 EventDataType data;
                 EventDataType gain=el.gain();
-                EventDataType nmult=ymult*gain;
+                //EventDataType nmult=ymult*gain;
-                EventDataType ymin=EventDataType(miny)/gain;
+                //EventDataType ymin=EventDataType(miny)/gain;
 
-                const QVector<EventStoreType> & dat=el.getData();
+                //const QVector<EventStoreType> & dat=el.getData();
-                const QVector<quint32> & tim=el.getTime();
+                //const QVector<quint32> & tim=el.getTime();
+                //quint32 * tptr;
+
+
+                //qint64 stime=el.first();
 
                 done=false;
-                first=true;
 
                 if (!accel) {
                     lines->setSize(1.5);
                 } else lines->setSize(1);
-                bool firstpx=true;
+
                 if (el.type()==EVL_Waveform) {  // Waveform Plot
                     if (idx>sam) idx-=sam;
                     time=el.time(idx);
                     double rate=double(sr)*double(sam);
+                    EventStoreType * ptr=el.rawData()+idx;
 
                     if (accel) {
-    //////////////////////////////////////////////////////////////////
+                        //////////////////////////////////////////////////////////////////
-    // Accelerated Waveform Plot
+                        // Accelerated Waveform Plot
-    //////////////////////////////////////////////////////////////////
+                        //////////////////////////////////////////////////////////////////
-                        for (int i=idx;i<siz;i+=sam) {
-                            time+=rate;
-                            //time=el.time(i);
-                            //if (time < minx)
-                            //    continue; // Skip stuff before the start of our data window
 
-                            //data=el.data(i);
+//                        qint64 tmax=(maxx-time)/rate;
-                            data=dat[i];//*gain;
+//                        if ((tmax*sam) < siz) {
-                            px=((time - minx) * xmult);   // Scale the time scale X to pixel scale X
+//                            siz=idx+tmax*sam;
-                            py=((data - ymin) * nmult);   // Same for Y scale
+//                            done=true;
+//                        }
+
+                        for (int i=idx;i<siz;i+=sam,ptr+=sam) {
+                            time+=rate;
+                            // This is much faster than QVector access.
+                            data=*ptr;
+                            data *= gain;
+
+                            // Scale the time scale X to pixel scale X
+                            px=((time - minx) * xmult);
+
+                            // Same for Y scale, with gain factored in nmult
+                            py=((data - miny) * ymult);
 
                             // In accel mode, each pixel has a min/max Y value.
                             // m_drawlist's index is the pixel index for the X pixel axis.
-
                             int z=round(px); // Hmmm... round may screw this up.
-                            if (z<minz) minz=z;  // minz=First pixel
+
-                            if (z>maxz) maxz=z;  // maxz=Last pixel
+                            if (z<minz)
+                                minz=z;  // minz=First pixel
+
+                            if (z>maxz)
+                                maxz=z;  // maxz=Last pixel
+
                             if (minz<0) {
                                 qDebug() << "gLineChart::Plot() minz<0  should never happen!! minz =" << minz;
                                 minz=0;
@@ -375,151 +391,210 @@ void gLineChart::paint(gGraph & w,int left, int top, int width, int height)
                             }
 
                             // Update the Y pixel bounds.
-                            if (py<m_drawlist[z].x()) m_drawlist[z].setX(py);
+                            if (py<m_drawlist[z].x())
-                            if (py>m_drawlist[z].y()) m_drawlist[z].setY(py);
+                                m_drawlist[z].setX(py);
+                            if (py>m_drawlist[z].y())
+                                m_drawlist[z].setY(py);
+
+                            if (time>maxx) {
+                                done=true;
+                                break;
+                            }
+
+                        }
+                        // Plot compressed accelerated vertex list
+                        if (maxz>width) {
+                            maxz=width;
+                        }
+                        float ax1,ay1;
+                        QPoint * drl=m_drawlist+minz;
+                        // Don't need to cap VertexBuffer here, as it's limited to max_drawlist_size anyway
+
+
+                        // Cap within VertexBuffer capacity, one vertex per line point
+                        int np=(maxz-minz)*2;
+
+                        int j=lines->Max()-lines->cnt();
+                        if (np < j) {
+                            for (int i=minz;i<maxz;i++, drl++) {
+                                ax1=drl->x();
+                                ay1=drl->y();
+                                lines->unsafe_add(xst+i,yst-ax1,xst+i,yst-ay1);
+
+                                //if (lines->full()) break;
+                            }
+                        } else {
+                            qDebug() << "gLineChart full trying to draw" << schema::channel[code].label();
+                            done=true;
+                        }
+
+                    } else { // Zoomed in Waveform
+                        //////////////////////////////////////////////////////////////////
+                        // Normal Waveform Plot
+                        //////////////////////////////////////////////////////////////////
+
+                        // Cap within VertexBuffer capacity, one vertex per line point
+//                        int np=((siz-idx)/sam)*2;
+//                        int j=lines->Max()-lines->cnt();
+//                        if (np > j) {
+//                            siz=j*sam;
+//                        }
+
+                        // Prime first point
+                        data=*ptr * gain;
+                        lastpx=xst+((time - minx) * xmult);
+                        lastpy=yst-((data - miny) * ymult);
+
+                        for (int i=idx;i<siz;i+=sam) {
+                            ptr+=sam;
+                            time+=rate;
+
+                            data=*ptr * gain;
+
+                            px=xst+((time - minx) * xmult);   // Scale the time scale X to pixel scale X
+                            py=yst-((data - miny) * ymult);   // Same for Y scale, with precomputed gain
+                            //py=yst-((data - ymin) * nmult);   // Same for Y scale, with precomputed gain
+
+                            lines->add(lastpx,lastpy,px,py);
+
+                            lastpx=px;
+                            lastpy=py;
+
+                            if (time>maxx) {
+                                done=true;
+                                break;
+                            }
+                            if (lines->full())
+                                break;
+                        }
+                    }
+
+                } else  {
+                    //////////////////////////////////////////////////////////////////
+                    // Standard events/zoomed in Plot
+                    //////////////////////////////////////////////////////////////////
+
+                    double start=el.first();
+
+                    quint32 * tptr=el.rawTime();
+
+                    int idx=0;
+
+                    if (siz>15) {
+                        for (;idx<siz;++idx) {
+                            time=start + *tptr++;
+                            if (time >= minx) {
+                                break;
+                            }
+                        }
+
+                        if (idx > 0) {
+                            idx--;
+                            //tptr--;
+                        }
+                    }
+
+                    // Step one backwards if possible (to draw through the left margin)
+                    EventStoreType * dptr=el.rawData() + idx;
+                    tptr=el.rawTime() + idx;
+
+                    time=start + *tptr++;
+                    data=*dptr++ * gain;
+
+                    idx++;
+
+                    lastpx=xst+((time - minx) * xmult);   // Scale the time scale X to pixel scale X
+                    lastpy=yst-((data - miny) * ymult);   // Same for Y scale without precomputed gain
+
+                    siz-=idx;
+
+                    // Check if would overflow lines gVertexBuffer
+                    int gs=siz << 1;
+                    int j=lines->Max()-lines->cnt();
+                    if (square_plot)
+                        gs <<= 1;
+                    if (gs > j) {
+                        qDebug() << "Would overflow line points.. increase default VertexBuffer size in gLineChart";
+                        siz=j >> square_plot ? 2 : 1;
+                        done=true; // end after this partial draw..
+                    }
+
+                    // Unrolling square plot outside of loop to gain a minor speed improvement.
+                    if (square_plot) {
+                        for (int i=0;i<siz;i++) {
+                            time=start + *tptr++;
+                            data=gain  * *dptr++;
+
+                            px=xst+((time - minx) * xmult);   // Scale the time scale X to pixel scale X
+                            py=yst-((data - miny) * ymult);   // Same for Y scale without precomputed gain
+
+                            // Horizontal lines are easy to cap
+                            if (py==lastpy) {
+                                // Cap px to left margin
+                                if (lastpx<xst) lastpx=xst;
+
+                                // Cap px to right margin
+                                if (px>xst+width) px=xst+width;
+
+                                lines->unsafe_add(lastpx,lastpy,px,lastpy,px,lastpy,px,py);
+                            } else {
+                                // Letting the scissor do the dirty work for non horizontal lines
+                                // This really should be changed, as it might be cause that weird
+                                // display glitch on Linux..
+                                lines->unsafe_add(lastpx,lastpy,px,lastpy,px,lastpy,px,py);
+                            }
+
+                            lastpx=px;
+                            lastpy=py;
 
                             if (time > maxx) {
                                 done=true; // Let this iteration finish.. (This point will be in far clipping)
                                 break;
                             }
                         }
-                        // Plot compressed accelerated vertex list
+                    } else {
-                        if (maxz>width) {
+                        for (int i=0;i<siz;i++) {
-                            //qDebug() << "gLineChart::Plot() maxz exceeded graph width" << "maxz = " << maxz << "width =" << width;
+                            time=start + *tptr++;
-                            maxz=width;
+                            data=gain  * *dptr++;
-                        }
-                        float ax1,ay1;
-                        for (int i=minz;i<maxz;i++) {
-                           // ax1=(m_drawlist[i-1].x()+m_drawlist[i].x()+m_drawlist[i+1].x())/3.0;
-                           // ay1=(m_drawlist[i-1].y()+m_drawlist[i].y()+m_drawlist[i+1].y())/3.0;
-                            ax1=m_drawlist[i].x();
-                            ay1=m_drawlist[i].y();
-                            lines->add(xst+i,yst-ax1,xst+i,yst-ay1);
-
-                            if (lines->full()) break;
-                        }
-
-                    } else { // Zoomed in Waveform
-    //////////////////////////////////////////////////////////////////
-    // Normal Waveform Plot
-    //////////////////////////////////////////////////////////////////
-                        if (idx>sam) {
-                            idx-=sam;
-                            time=el.time(idx);
-                            //double rate=double(sr)*double(sam);
-                        }
-                        for (int i=idx;i<siz;i+=sam) {
-                            time+=rate;
-                            //if (time < minx)
-                            //    continue; // Skip stuff before the start of our data window
-                            data=dat[i];//el.data(i);
 
                             px=xst+((time - minx) * xmult);   // Scale the time scale X to pixel scale X
-                            py=yst-((data - ymin) * nmult);   // Same for Y scale, with precomputed gain
+                            py=yst-((data - miny) * ymult);   // Same for Y scale without precomputed gain
 
-                            if (firstpx) {
+                            // Horizontal lines are easy to cap
-                                lastpx=px;
+                            if (py==lastpy) {
-                                lastpy=py;
+                                // Cap px to left margin
-                                firstpx=false;
+                                if (lastpx<xst) lastpx=xst;
-                                continue;
-                            }
-                            lines->add(lastpx,lastpy,px,py);
 
-                            if (lines->full()) {
+                                // Cap px to right margin
-                                done=true;
+                                if (px>xst+width) px=xst+width;
-                                break;
+
-                            }
+                                lines->unsafe_add(lastpx,lastpy,px,py);
-                            if (time > maxx) {
+                            } else {
-                                //done=true; // Let this iteration finish.. (This point will be in far clipping)
+                                // Letting the scissor do the dirty work for non horizontal lines
-                                break;
+                                // This really should be changed, as it might be cause that weird
+                                // display glitch on Linux..
+                                lines->unsafe_add(lastpx,lastpy,px,py);
                             }
+
                             lastpx=px;
                             lastpy=py;
-                        }
-                    }
 
-                } else {
+                            if (time > maxx) { // Past right edge, abort further drawing..
-    //////////////////////////////////////////////////////////////////
-    // Standard events/zoomed in Plot
-    //////////////////////////////////////////////////////////////////
-                    first=true;
-                    double start=el.first();
-                    /*if (siz==2) {
-                        time=start+tim[0];
-                        data=dat[0]*gain;
-                        data-=subtract_offset;
-                        lastpy=yst-((data - miny) * ymult);   // Same for Y scale with precomputed gain
-                        lastpx=xst+((time - minx) * xmult);   // Scale the time scale X to pixel scale X
-                        if (lastpx<xst-1) lastpx=xst-1;
-
-                        EventDataType data2=(dat[1]*gain)-subtract_offset;
-                        qint64 time2=start+tim[1];
-                        py=yst-((data2 - miny) * ymult);
-                        px=xst+((time2 - minx) * xmult);
-                        if (px>xst+width) px=xst+width;
-
-                        lines->add(lastpx,lastpy,px,py);
-                    } else*/
-                    for (int i=0;i<siz;i++) {
-
-                        time=start+tim[i];
-                        if (first) {
-                            if (num_points>15 && (time < minx)) continue; // Skip stuff before the start of our data window
-                            first=false;
-                            if (i>0)  i--; // Start with the previous sample (which will be in clipping area)
-                            time=start+tim[i];
-                        }
-                        data=dat[i]*gain; //
-                        data-=subtract_offset;
-                        //data=el.data(i); // raw access is faster
-
-                        px=xst+((time - minx) * xmult);   // Scale the time scale X to pixel scale X
-                        //py=yst+((data - ymin) * nmult);   // Same for Y scale with precomputed gain
-                        py=yst-((data - miny) * ymult);   // Same for Y scale with precomputed gain
-
-                        //if (px<left) px=left;
-                        //if (px>left+width) px=left+width;
-                        if (firstpx) {
-                            firstpx=false;
-                        } else {
-                            if (py==lastpy) {
-                                if (lastpx<xst) lastpx=xst;
-                                if (px>xst+width) px=xst+width;
-                                if (square_plot) {
-                                    lines->add(lastpx,lastpy,px,lastpy,px,lastpy,px,py);
-                                } else {
-                                    lines->add(lastpx,lastpy,px,py);
-                                }
-                            } else {
-                                if (square_plot) {
-                                    lines->add(lastpx,lastpy,px,lastpy,px,lastpy,px,py);
-                                } else {
-                                    lines->add(lastpx,lastpy,px,py);
-                                }
-                            }
-
-                            //lines->add(px,py,m_line_color);
-
-                            if (lines->full()) {
                                 done=true;
                                 break;
                             }
                         }
-                        lastpx=px;
-                        lastpy=py;
-                        //if (lastpx>start_px+width) done=true;
-                        if (time > maxx) {
-                            done=true; // Let this iteration finish.. (This point will be in far clipping)
-                            break;
-                        }
                     }
                 }
 
                 if (done) break;
             }
         }
+
+        ////////////////////////////////////////////////////////////////////
+        // Draw Legends on the top line
+        ////////////////////////////////////////////////////////////////////
         if ((codepoints>0)) { //(m_codes.size()>1) &&
-            // Draw Legends for plots..
             QString text=schema::channel[code].label();
             int wid,hi;
             GetTextExtent(text,wid,hi);
@@ -601,7 +676,7 @@ void AHIChart::paint(gGraph & w,int left, int top, int width, int height)
     double lastpx,lastpy;
     double top1=top+height;
     bool done=false;
-    GLuint color=m_color.rgba();
+    //GLuint color=m_color.rgba();
     for (int i=0;i<m_time.size();i++) {
         qint64 ti=m_time[i];
         EventDataType v=m_data[i];

Graphs/gLineOverlay.cpp

@@ -63,33 +63,49 @@ void gLineOverlayBar::paint(gGraph & w, int left, int topp, int width, int heigh
     }
     EventStoreType raw;
 
+    quint32 * tptr;
+    EventStoreType * ptr;
+    qint64 stime;
+
+    OverlayDisplayType odt=PROFILE.appearance->overlayType();
+
+    // For each session, process it's eventlist
     for (QVector<Session *>::iterator s=m_day->begin();s!=m_day->end(); s++) {
         if (!(*s)->enabled()) continue;
         cei=(*s)->eventlist.find(m_code);
         if (cei==(*s)->eventlist.end()) continue;
         if (cei.value().size()==0) continue;
 
+        // Could loop through here, but nowhere uses more than one yet..
         EventList & el=*cei.value()[0];
+        stime=el.first();
+        ptr=el.rawData();
+        tptr=el.rawTime();
 
-        for (quint32 i=0;i<el.count();i++) {
+        ////////////////////////////////////////////////////////////////////////////
-            X=el.time(i);
+        // Skip data previous to minx bounds
-            raw=el.data(i);
+        ////////////////////////////////////////////////////////////////////////////
-            if (m_flt==FT_Span) {
+        quint32 idx;
+        for (idx=0;idx<el.count();idx++) {
+            X=stime + *tptr;
+            if (X >= w.min_x)
+                break;
+            tptr++;
+            ptr++;
+        }
+
+        if (m_flt==FT_Span) {
+            ////////////////////////////////////////////////////////////////////////////
+            // FT_Span
+            ////////////////////////////////////////////////////////////////////////////
+            for (quint32 i=idx;i<el.count();i++) {
+                X=stime + *tptr++; //el.time(i);
+                raw=*ptr++; //el.data(i);
                 Y=X-(qint64(raw)*1000.0L); // duration
-
-                if (X < w.min_x) continue;
                 if (Y > w.max_x) break;
-            } else {
+                x1=double(width)/double(xx)*double(X-w.min_x)+left;
-                if (X < w.min_x) continue;
+                m_count++;
-                if (X > w.max_x) break;
+                m_sum+=raw;
-            }
-
-            //x1=w.x2p(X);
-            x1=double(width)/double(xx)*double(X-w.min_x)+left;
-            m_count++;
-            m_sum+=raw;
-            if (m_flt==FT_Span) {
-                //x2=w.x2p(Y);
                 x2=double(width)/double(xx)*double(Y-w.min_x)+left;
                 if (int(x1)==int(x2)) x2+=1;
                 if (x2<left) x2=left;
@@ -97,8 +113,19 @@ void gLineOverlayBar::paint(gGraph & w, int left, int topp, int width, int heigh
                 //double w1=x2-x1;
                 quads->add(x2,start_py, x1,start_py, x1,start_py+height, x2,start_py+height,m_flag_color.rgba());
                 if (quads->full()) { verts_exceeded=true; break; }
-            } else if (m_flt==FT_Dot) {
+            }
-                if ((PROFILE.appearance->overlayType()==ODT_Bars) || (xx<3600000)) {
+        } else if (m_flt==FT_Dot) {
+            ////////////////////////////////////////////////////////////////////////////
+            // FT_Dot
+            ////////////////////////////////////////////////////////////////////////////
+            for (quint32 i=idx;i<el.count();i++) {
+                X=stime + *tptr++; //el.time(i);
+                raw=*ptr++; //el.data(i);
+                if (X > w.max_x) break;
+                x1=double(width)/double(xx)*double(X-w.min_x)+left;
+                m_count++;
+                m_sum+=raw;
+                if ((odt==ODT_Bars) || (xx<3600000)) {
                     // show the fat dots in the middle
                     points->add(x1,double(height)/double(yy)*double(-20-w.min_y)+topp);
                     if (points->full()) { verts_exceeded=true; break; }
@@ -106,32 +133,38 @@ void gLineOverlayBar::paint(gGraph & w, int left, int topp, int width, int heigh
                     // thin lines down the bottom
                     lines->add(x1,start_py+1,x1,start_py+1+12);
                     if (lines->full()) { verts_exceeded=true; break; }
-
                 }
-            } else if (m_flt==FT_Bar) {
+
+            }
+        } else if (m_flt==FT_Bar) {
+            ////////////////////////////////////////////////////////////////////////////
+            // FT_Bar
+            ////////////////////////////////////////////////////////////////////////////
+            for (quint32 i=idx;i<el.count();i++) {
+                X=stime + *tptr++;
+                raw=*ptr++;
+                if (X > w.max_x) break;
+                x1=double(width)/double(xx)*double(X-w.min_x)+left;
+                m_count++;
+                m_sum+=raw;
                 int z=start_py+height;
-                if ((PROFILE.appearance->overlayType()==ODT_Bars) || (xx<3600000)) {
+                if ((odt==ODT_Bars) || (xx<3600000)) {
                     z=top;
 
                     points->add(x1,top);
                     lines->add(x1,top,x1,bottom);
                     if (points->full()) { verts_exceeded=true; break; }
-               } else {
+                } else {
                     lines->add(x1,z,x1,z-12);
-               }
+                }
-               if (lines->full()) { verts_exceeded=true; break; }
+                if (lines->full()) { verts_exceeded=true; break; }
-               if (xx<(1800000)) {
+                if (xx<(1800000)) {
-                   GetTextExtent(m_label,x,y);
+                    GetTextExtent(m_label,x,y);
-                   w.renderText(m_label,x1-(x/2),top-y+(3*w.printScaleY()));
+                    w.renderText(m_label,x1-(x/2),top-y+(3*w.printScaleY()));
-
+                }
-                   // The follow lines enable the duration display underneath
+            }
-//                   QString a=QString::number(int(el.data(i)));
-//                   GetTextExtent(a,x,y);
-//                   w.renderText(a,x1-(x/2),bottom+y+(3*w.printScaleY()));
-               }
-
-           }
         }
+
         if (verts_exceeded) break;
     }
     if (verts_exceeded) {

Graphs/gSummaryChart.cpp

@@ -60,7 +60,6 @@ void SummaryChart::SetDay(Day * nullday)
         m_codes.clear();
         m_colors.clear();
         m_type.clear();
-        //m_zeros.clear();
         m_typeval.clear();
 
         if (cpapmode>=MODE_ASV) {
@@ -133,19 +132,8 @@ void SummaryChart::SetDay(Day * nullday)
                     zt=qint64(sess->first())/1000L;
                     zt+=tz_offset;
                     tmp2=zt-dn*86400;
-
-                    //zt %= 86400;
                     tmp2/=3600.0;
-                    //tmp2-=24.0;
 
-                    //if (zdn>dn2) {
-                    //if (tmp2<12) {
-                    //    tmp2-=24;
-                        //m_times[dn][s]=(tmp2+12);
-                    //}/* else {
-                      //  tmp2-=12;
-                        //m_times[dn][s]=(tmp2)-12;
-                    //}*/
                     m_times[dn][s]=tmp2;
 
                     if (tmp2 < m_miny)
@@ -162,8 +150,6 @@ void SummaryChart::SetDay(Day * nullday)
         } else {
             for (int j=0;j<m_codes.size();j++) { // for each code slice
                 code=m_codes[j];
-                //m_values[dn][0]=0;
-                //if (code==CPAP_Leak) suboffset=PROFILE.cpap->IntentionalLeak(); else
                 suboffset=0;
                 type=m_type[j];
                 EventDataType typeval=m_typeval[j];
@@ -171,7 +157,6 @@ void SummaryChart::SetDay(Day * nullday)
                     day=d.value()[i];
                     CPAPMode mode=(CPAPMode)(int)day->settings_max(CPAP_Mode);
                     if (day->machine_type()!=m_machinetype) continue;
-                    //m_values[dn][j+1]=0;
 
                     bool hascode=//day->channelHasData(code) ||
                             type==ST_HOURS ||
@@ -234,35 +219,9 @@ void SummaryChart::SetDay(Day * nullday)
                     if (total<m_miny) m_miny=total;
                     if (total>m_maxy) m_maxy=total;
                 }
-                //m_empty=false;
-           }// else m_hours[dn]=0;
-        }
-    }
-   /* if (m_graphtype!=GT_SESSIONS)
-    for (int j=0;j<m_codes.size();j++) { // for each code slice
-        ChannelID code=m_codes[j];
-        if (type==ST_HOURS || type==ST_SESSIONS || m_zeros[j]) continue;
-
-        for (QMap<QDate,QList<Day *> >::iterator d=PROFILE.daylist.begin();d!=PROFILE.daylist.end();d++) {
-            tt=QDateTime(d.key(),QTime(0,0,0),Qt::UTC).toTime_t();
-            dn=tt/86400;
-            for (int i=0;i<d.value().size();i++) { // for each machine object for this day
-                day=d.value().at(i);
-                if (day->machine_type()!=m_machinetype) continue;
-                if (!m_values[dn].contains(j+1)) {
-                    m_days[dn]=day;
-                    m_values[dn][j+1]=0;
-                    if (!m_values[dn].contains(0)) {
-                        m_values[dn][0]=0;
-                    }
-                    if (0<m_miny) m_miny=0;
-                    if (0>m_maxy) m_maxy=0;
-                    m_hours[dn]=day->hours();
-                }
-                break;
            }
         }
-    } */
+    }
     m_empty=true;
     for (int i=0;i<m_goodcodes.size();i++) {
         if (m_goodcodes[i]) {
@@ -314,7 +273,6 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
     //if (outlines->full()) qDebug() << "WTF??? Outlines full in SummaryChart::paint()";
 
     qint64 minx=w.min_x, maxx=w.max_x;
-    //qint64 minx=m_minx, maxx=m_maxx;
     qint64 xx=maxx - minx;
     float days=double(xx)/86400000.0;
 
@@ -327,8 +285,6 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
 
     barw=(float(width)/float(days));
 
-    //qint64 ts;
-
     graph=&w;
     float px=left;
     l_left=w.marginLeft()+gYAxis::Margin;
@@ -350,21 +306,17 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
     l_minx=minx;
     l_maxx=maxx+86400000L;
 
-    //QHash<short, EventDataType> lastvalues;
     int total_days=0;
     double total_val=0;
     double total_hours=0;
-    //qint64 lastQ=0;
     bool lastdaygood=false;
     QVector<double> totalcounts;
     QVector<double> totalvalues;
-    //QVector<EventDataType> lastvalues;
     QVector<float> lastX;
     QVector<short> lastY;
     int numcodes=m_codes.size();
     totalcounts.resize(numcodes);
     totalvalues.resize(numcodes);
-    //lastvalues.resize(numcodes);
     lastX.resize(numcodes);
     lastY.resize(numcodes);
     int zd=minx/86400000L;
@@ -373,9 +325,7 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
 
     QVector<bool> goodcodes;
     goodcodes.resize(m_goodcodes.size());
-//    if (d==m_values.end()) {
+
-//        d=m_values.find(zd--);
- //   }
     lastdaygood=true;
     for (int i=0;i<numcodes;i++) {
         totalcounts[i]=0;
@@ -392,7 +342,7 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
         goodcodes[i]=false;
 
         if (!m_goodcodes[i]) continue;
-       // lastvalues[i]=0;
+
         lastX[i]=px;
         if (d!=m_values.end() && d.value().contains(i+1)) {
 
@@ -413,6 +363,9 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
     Day * day;
     EventDataType hours;
 
+    quint32 * tptr;
+    EventStoreType * dptr;
+
     short px2,py2;
     for (qint64 Q=minx;Q<=maxx+86400000L;Q+=86400000L) {
         zd=Q/86400000L;
@@ -421,12 +374,11 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
         qint64 extra=86400000;
         if (Q<minx)
             goto jumpnext;
-            //continue;
+
         if (d!=m_values.end()) {
             day=m_days[zd];
             if (!m_hours.contains(zd))
                 goto jumpnext;
-                //continue;
 
             hours=m_hours[zd];
 
@@ -438,8 +390,6 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
             if (x2>left+width) x2=left+width;
             if (x2<x1)
                 goto jumpnext;
-                //continue;
-            //ChannelID code;
 
             if (m_graphtype==GT_SESSIONS) {
                 int j;
@@ -454,12 +404,13 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
                 GLuint col2=brighten(col).rgba();
                 outlines->setColor(Qt::black);
 
-                if (d.value().size()>0) {
+                int np=d.value().size();
+                if (np > 0) {
                     for (int i=0;i<goodcodes.size();i++) {
                         goodcodes[i]=true;
                     }
                 }
-                for (j=0;j<d.value().size();j++) {
+                for (j=0;j < np;j++) {
                     tmp2=times.value()[j]-miny;
                     py=top+height-(tmp2*ymult);
 
@@ -472,8 +423,7 @@ void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
                     if (h>0 && barw>2) {
                         outlines->add(x1,py,x1,py-h,x1,py-h,x2,py-h);
                         outlines->add(x1,py,x2,py,x2,py,x2,py-h);
-                    } // if (bar
+                    }
-                    //py-=h;
                     totalvalues[0]+=hours*tmp;
                 }
                 totalcounts[0]+=hours;

Graphs/gXAxis.cpp

@@ -165,22 +165,24 @@ void gXAxis::paint(gGraph & w,int left,int top, int width, int height)
         if (py<start_px) continue;
         lines->add(py,top,py,mintop);
     }
+    static QString dow[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
 
+    int ms,m,h,s,d;
+    qint64 j;
     for (qint64 i=aligned_start;i<maxx;i+=step) {
         px=(i-minx)*xmult;
         px+=left;
         lines->add(px,top,px,majtop);
-        qint64 j=i;
+        j=i;
         if (!m_utcfix) j+=tz_offset;
-        int ms=j % 1000;
+        ms=j % 1000;
-        int m=(j/60000L) % 60L;
+        m=(j/60000L) % 60L;
-        int h=(j/3600000L) % 24L;
+        h=(j/3600000L) % 24L;
-        int s=(j/1000L) % 60L;
+        s=(j/1000L) % 60L;
-        static QString dow[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
         //int d=(j/86400000) % 7;
 
         if (fitmode==0) {
-            int d=(j/1000);
+            d=(j/1000);
             QDateTime dt=QDateTime::fromTime_t(d).toUTC();
             tmpstr=dt.toString("MMM dd");
         //} else if (fitmode==0) {
@@ -195,9 +197,6 @@ void gXAxis::paint(gGraph & w,int left,int top, int width, int height)
 
         int tx=px-x/2.0;
 
-        // Massive bottle neck..
-        //GetTextExtent(tmpstr,x,y); // this only really needs running once :(
-
         if (m_utcfix)
             tx+=step_pixels/2.0;
         if ((tx+x)<(left+width))

SleepLib/session.cpp

@@ -41,6 +41,8 @@ Session::Session(Machine * m,SessionID session)
 
     s_first=s_last=0;
     s_eventfile="";
+    s_evchecksum_checked=false;
+
 }
 Session::~Session()
 {
@@ -80,7 +82,7 @@ bool Session::OpenEvents() {
 
 
     return s_events_loaded=true;
-};
+}
 
 bool Session::Store(QString path)
 // Storing Session Data in our format
@@ -511,23 +513,23 @@ bool Session::LoadEvents(QString filename)
     if (version>=10) {
         if (compmethod>0) {
             databytes=qUncompress(temp);
+            if (!s_evchecksum_checked) {
+                if (databytes.size()!=datasize) {
+                    qDebug() << "File" << filename << "has returned wrong datasize";
+                    return false;
+                }
+                quint16 crc=qChecksum(databytes.data(),databytes.size());
+                if (crc!=crc16) {
+                    qDebug() << "CRC Doesn't match in" << filename;
+                    return false;
+                }
+                s_evchecksum_checked=true;
+            }
         } else {
             databytes=temp;
         }
     } else databytes=temp;
 
-    if (version>=10) {
-        if (databytes.size()!=datasize) {
-            qDebug() << "File" << filename << "has returned wrong datasize";
-            return false;
-        }
-        quint16 crc=qChecksum(databytes.data(),databytes.size());
-        if (crc!=crc16) {
-            qDebug() << "CRC Doesn't match in" << filename;
-            return false;
-        }
-    }
-
     QDataStream in(databytes);
     in.setVersion(QDataStream::Qt_4_6);
     in.setByteOrder(QDataStream::LittleEndian);

SleepLib/session.h

@@ -258,6 +258,7 @@ protected:
     qint64 s_last;
     bool s_changed;
     bool s_lonesession;
+    bool s_evchecksum_checked;
     bool _first_session;
 
     bool s_events_loaded;