Ticket #5324: mythtv-vid-21.diff

libs/libmythtv/openglcontext.cpp

@@ -617 +617 @@
     bzero(scratch, tmp_size);
 
     GLint check;
-
-    glTexImage2D(tmp->m_type, 0, tmp->m_internal_fmt,
-                 size.width(), size.height(), 0,
-                 tmp->m_data_fmt , tmp->m_data_type, scratch);
+    if (tmp->m_type == GL_TEXTURE_1D)
+    {
+        glTexImage1D(tmp->m_type, 0, tmp->m_internal_fmt,
+                     size.width(), 0,
+                     tmp->m_data_fmt , tmp->m_data_type, scratch);
+    }
+    else
+    {
+        glTexImage2D(tmp->m_type, 0, tmp->m_internal_fmt,
+                     size.width(), size.height(), 0,
+                     tmp->m_data_fmt , tmp->m_data_type, scratch);
+    }
     glGetTexLevelParameteriv(tmp->m_type, 0, GL_TEXTURE_WIDTH, &check);
 
     delete [] scratch;
@@ -1028 +1036 @@
     return tmp_pbo;
 }
 
+uint OpenGLContext::CreateHelperTexture(void)
+{
+    MakeCurrent(true);
+
+    uint width = m_max_tex_size;
+
+    uint tmp_tex = CreateTexture(QSize(width, 1), QSize(width, 1),
+                                false,
+                                GL_TEXTURE_1D, GL_FLOAT,
+                                GL_RGBA, GL_RGBA16,
+                                GL_NEAREST, GL_REPEAT);
+
+    if (!tmp_tex)
+    {
+        DeleteTexture(tmp_tex);
+        return 0;
+    }
+
+    float *buf = NULL;
+    buf = new float[m_priv->m_textures[tmp_tex].m_data_size];
+    float *ref = buf;
+
+    for (uint i = 0; i < width; i++)
+    {
+        float x = (((float)i) + 0.5f) / (float)width;
+        store_bicubic_weights(x, ref);
+        ref += 4;
+    }
+    store_bicubic_weights(0, buf);
+    store_bicubic_weights(1, &buf[(width - 1) << 2]);
+
+    EnableTextures(tmp_tex);
+    glBindTexture(m_priv->m_textures[tmp_tex].m_type, tmp_tex);
+    glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA16, width, 0, GL_RGBA, GL_FLOAT, buf);
+
+    VERBOSE(VB_PLAYBACK, LOC +
+            QString("Created bicubic helper texture (%1 samples)")
+            .arg(width));
+
+    delete [] buf;
+
+    MakeCurrent(false);
+
+    return tmp_tex;
+}
+
 int OpenGLContext::SetPictureAttribute(
     PictureAttribute attribute, int newValue)
 {

libs/libmythtv/openglcontext.h

@@ -110 +110 @@
     int SetPictureAttribute(PictureAttribute attributeType, int newValue);
     PictureAttributeSupported GetSupportedPictureAttributes(void) const;
     void SetColourParams(void);
+    uint CreateHelperTexture(void);
 
   private:
     void Init2DState(void);
@@ -192 +193 @@
     PictureAttributeSupported GetSupportedPictureAttributes(void) const
         { return kPictureAttributeSupported_None; }
     void SetColourParams(void);
+    uint CreateHelperTexture(void);
 };
 
 #endif //!USING_OPENGL

libs/libmythtv/openglvideo.cpp

@@ -44 +44 @@
     inputTextureSize(0,0),    currentFrameNum(0),
     inputUpdated(false),      
     textureRects(false),      textureType(GL_TEXTURE_2D),
+    helperTexture(0),         defaultResize(kGLFilterResize),
     convertSize(0,0),         convertBuf(NULL),
 
     videoResize(false),       videoResizeRect(0,0,0,0),
@@ -62 +63 @@
 {
     ShutDownYUV2RGB();
 
+    if (helperTexture)
+        gl_context->DeleteTexture(helperTexture);
+    helperTexture = 0;
+
     DeleteTextures(&inputTextures);
     DeleteTextures(&referenceTextures);
 
@@ -110 +115 @@
     inputUpdated          = false;
     gl_letterbox_colour   = letterbox_colour;
 
-    gl_context->GetTextureType(textureType, textureRects);
+    if (defaultResize != kGLFilterBicubic)
+        gl_context->GetTextureType(textureType, textureRects);
 
     SetViewPort(display_visible_rect.size());
 
@@ -192 +198 @@
 {
     bool resize =  ((video_dim.height() < display_video_rect.height()) ||
                     (video_dim.width()  <  display_video_rect.width()));
+    resize &= !filters.count(kGLFilterResize);
+    resize &= !filters.count(kGLFilterBicubic);
 
-    if (resize && !filters.count(kGLFilterResize))
-        AddFilter(kGLFilterResize);
-    else if (!resize && filters.count(kGLFilterResize) &&
-             !filters.count(kGLFilterYUV2RGBA))
-        RemoveFilter(kGLFilterResize);
+    if (resize)
+        AddFilter(defaultResize);
 
     glfilt_map_t::reverse_iterator it;
 
@@ -303 +308 @@
     temp->numInputs = 1;
     GLuint program = 0;
 
+    if (filter == kGLFilterBicubic)
+    {
+        if (helperTexture)
+            gl_context->DeleteTexture(helperTexture);
+ 
+        helperTexture = gl_context->CreateHelperTexture();
+        if (!helperTexture)
+            success = false;
+    }
+
     if (filter != kGLFilterNone && filter != kGLFilterResize)
     {
         program = AddFragmentProgram(filter);
@@ -880 +895 @@
             }
         }
 
+        if (helperTexture && type == kGLFilterBicubic)
+        {
+            glActiveTexture(GL_TEXTURE0 + active_tex);
+            glBindTexture(GL_TEXTURE_1D/*N.B.*/, helperTexture);
+        }
+
         // enable fragment program and set any environment variables
         if ((type != kGLFilterNone) && (type != kGLFilterResize))
         {
@@ -1021 +1042 @@
         ret = kGLFilterYUV2RGBA;
     else if (filter.contains("resize"))
         ret = kGLFilterResize;
+    else if (filter.contains("bicubic"))
+        ret = kGLFilterBicubic;
 
     return ret;
 }
@@ -1038 +1061 @@
             return "osd";
         case kGLFilterResize:
             return "resize";
+        case kGLFilterBicubic:
+            return "bicubic";
     }
 
     return "";
@@ -1410 +1435 @@
 "CMP res, prev, spred1, current;\n"
 };
 
+static const QString bicubic =
+"TEMP coord, coord2, cdelta, parmx, parmy, a, b, c, d;\n"
+"MAD coord.xy, fragment.texcoord[0], {%6, %7}, {0.5, 0.5};\n"
+"TEX parmx, coord.x, texture[1], 1D;\n"
+"TEX parmy, coord.y, texture[1], 1D;\n"
+"MUL cdelta.xz, parmx.rrgg, {-%5, 0, %5, 0};\n"
+"MUL cdelta.yw, parmy.rrgg, {0, -%3, 0, %3};\n"
+"ADD coord, fragment.texcoord[0].xyxy, cdelta.xyxw;\n"
+"ADD coord2, fragment.texcoord[0].xyxy, cdelta.zyzw;\n"
+"TEX a, coord.xyxy, texture[0], 2D;\n"
+"TEX b, coord.zwzw, texture[0], 2D;\n"
+"TEX c, coord2.xyxy, texture[0], 2D;\n"
+"TEX d, coord2.zwzw, texture[0], 2D;\n"
+"LRP a, parmy.b, a, b;\n"
+"LRP c, parmy.b, c, d;\n"
+"LRP result.color, parmx.b, a, c;\n";
+
 QString OpenGLVideo::GetProgramString(OpenGLFilterType name,
                                       QString deint, FrameScanType field)
 {
@@ -1487 +1529 @@
         case kGLFilterResize:
             break;
 
+        case kGLFilterBicubic:
+ 
+            ret += bicubic;
+            break;
+
         default:
             VERBOSE(VB_PLAYBACK, LOC_ERR + "Unknown fragment program.");
             break;
@@ -1497 +1544 @@
 
     float lineHeight = 1.0f;
     float colWidth   = 1.0f;
+    QSize fb_size = GetTextureSize(video_dim);
 
     if (!textureRects &&
        (inputTextureSize.height() > 0))
@@ -1511 +1559 @@
     ret.replace("%3", temp.setNum(lineHeight, 'f', 8));
     ret.replace("%4", temp.setNum(lineHeight * 2.0, 'f', 8));
     ret.replace("%5", temp.setNum(colWidth, 'f', 8));
+    ret.replace("%6", temp.setNum((float)fb_size.width(), 'f', 1));
+    ret.replace("%7", temp.setNum((float)fb_size.height(), 'f', 1));
 
     ret += "END";
 

libs/libmythtv/openglvideo.h

@@ -21 +21 @@
 
     // Frame scaling/resizing filters
     kGLFilterResize,
+    kGLFilterBicubic,
 };
 
 enum DisplayBuffer
@@ -127 +128 @@
     bool           inputUpdated;
     bool           textureRects;
     uint           textureType;
+    uint           helperTexture;
+    OpenGLFilterType defaultResize;
 
     QSize            convertSize;
     unsigned char   *convertBuf;

libs/libmythtv/util-opengl.cpp

@@ -911 +911 @@
         dst_1 += dwrap; dst_2 += dwrap; dst_3 += dwrap; dst_4 += dwrap;
     }
 }
+
+void store_bicubic_weights(float x, float *dst)
+{
+    float w0 = (((-1 * x + 3) * x - 3) * x + 1) / 6;
+    float w1 = ((( 3 * x - 6) * x + 0) * x + 4) / 6;
+    float w2 = (((-3 * x + 3) * x + 3) * x + 1) / 6;
+    float w3 = ((( 1 * x + 0) * x + 0) * x + 0) / 6;
+    *dst++ = 1 + x - w1 / (w0 + w1);
+    *dst++ = 1 - x + w3 / (w2 + w3);
+    *dst++ = w0 + w1;
+    *dst++ = 0;
+}

libs/libmythtv/util-opengl.h

@@ -128 +128 @@
                  const int *pitches,
                  const QSize size);
 
+void store_bicubic_weights(float x, float *dst);
+
 __GLXextFuncPtr get_gl_proc_address(const QString &procName);
 
 int get_gl_texture_rect_type(const QString &extensions);