glGenerateMipmap and raw pixel buffer

#define DO_NATIVE_PROCESSING    1
#define DO_MIPMAP_IMAGE_PYRAMID 1
 
// Convenience pixel access struct
struct BGRA
{
    unsigned char b, g, r, a;  
};
 
GLint checkGLError()
{
    GLint error = 0;
    error = glGetError(); 
    if(error != 0)
    {
        exit(EXIT_FAILURE);
    }
    return error;
}
 
// Based on http://stackoverflow.com/questions/946700/glpaint-save-image
+(UIImage *) makeImageFromGLViewUsingWidth:(int)width AndHeight:(int)height
{
    NSInteger myDataLength = width * height * 4;
    GLubyte *buffer = (GLubyte *) malloc(myDataLength);    
 
    glPixelStorei(GL_PACK_ALIGNMENT, 1);
    checkGLError(); 
    glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
    checkGLError();
 
    CGDataProviderRef provider = CGDataProviderCreateWithData(NULL, buffer, myDataLength, NULL);
    int bitsPerComponent = 8;
    int bitsPerPixel = 32;
    int bytesPerRow = width * height;
    CGColorSpaceRef colorSpaceRef = CGColorSpaceCreateDeviceRGB();
    CGBitmapInfo bitmapInfo = kCGBitmapByteOrderDefault;
    CGColorRenderingIntent renderingIntent = kCGRenderingIntentDefault;
    CGImageRef imageRef = CGImageCreate(width, height, bitsPerComponent, bitsPerPixel, bytesPerRow, colorSpaceRef, bitmapInfo, provider, NULL, NO, renderingIntent);
    UIImage *myImage = [UIImage imageWithCGImage:imageRef];
 
    free(buffer);
 
    return myImage;
}
 
+(void) saveImageToDisk:(UIImage *)image WithFilename:(NSString *)path
{    
    NSData *imageData = [NSData dataWithData:UIImagePNGRepresentation(image)];
    [imageData writeToFile:path atomically:YES]; 
}
 
- (void)viewDidLoad
{
#if 0
    NSString *const kAVCaptureSessionPreset = AVCaptureSessionPreset1920x1080;
    m_ImageWidth = 1080; // TODO: link these to AVCaptureSessionPreset*x* string, or retrieve them from GPUImageVideoCamera
    m_ImageHeight = 1920;
#else
    NSString *const kAVCaptureSessionPreset = AVCaptureSessionPreset1280x720;
    m_ImageWidth = 720; // TODO: link these to AVCaptureSessionPreset*x* string, or retrieve them from GPUImageVideoCamera
    m_ImageHeight = 1280;
#endif
 
    [super viewDidLoad];
    vc = [[GPUImageVideoCamera alloc] initWithSessionPreset:kAVCaptureSessionPreset cameraPosition:AVCaptureDevicePositionBack];
    vc.outputImageOrientation = UIInterfaceOrientationPortrait;
 
    gf = [[GPUImageGrayscaleFilter alloc] init];
 
    GPUImageView *v = [[GPUImageView alloc] init];
 
#if DO_NATIVE_PROCESSING
 
#if DO_MIPMAP_IMAGE_PYRAMID
    // Calculate next power of two for glGenerateMipmap() call in setNewFrameAvailableBlock
    int width2=pow(2, ceil(log2(m_ImageWidth))); /* 720 -> 1024, 1280 -> 2048 */
    int height2=pow(2, ceil(log2(m_ImageHeight))); 
    rawDataOutput = [[GPUImageRawDataOutput alloc] initWithImageSize:CGSizeMake(width2, height2) resultsInBGRAFormat:YES];
#else
    rawDataOutput = [[GPUImageRawDataOutput alloc] initWithImageSize:CGSizeMake(m_ImageWidth, m_ImageHeight) resultsInBGRAFormat:YES];
#endif
    rawDataInput = [[GPUImageRawDataInput alloc] initWithBytes:[rawDataOutput rawBytesForImage] size:CGSizeMake(m_ImageWidth, m_ImageHeight)];
 
    __block int counter = 0, width = m_ImageWidth, height = m_ImageHeight; // add block friendly width and height parameters
    __weak GPUImageRawDataOutput *rawDataOutputSelf = rawDataOutput; // avoid retain cycle warning >= iOS 5.0 w/ ARC
 
    [rawDataOutput setNewFrameAvailableBlock:^{
 
        NSLog(@"Frame: %d", counter++);
 
#if DO_MIPMAP_IMAGE_PYRAMID
        // Trying to create fast image pyramid using glGenerateMipmap(GL_TEXTURE_2D) and FBOs 
        // Basic mipmap level extraction from 
        //  _http://mmmovania.blogspot.com/2011/02/implementing-histogram-pyramid.html
        // It seems mipmap setup must come after a call to glBindTexture, as in:
        //   glBindTexture(GL_TEXTURE_2D, textureName);
        // ERROR: all calls to glGenerateMipmap fail with return code 1282
 
        [rawDataOutputSelf rawBytesForImage]; // Trigger output to load texture
 
        GLuint fboIDs[6];
        GLint textureName;
        glGetIntegerv(GL_TEXTURE_BINDING_2D, &textureName); // Get the current texture id 
        checkGLError();        
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        checkGLError();
        glBindTexture(GL_TEXTURE_2D, textureName);
        checkGLError();       
        glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST); // GL_NICEST==GL_LINEAR on iOS 5.0?
        checkGLError();
        glGenerateMipmap(GL_TEXTURE_2D);
        checkGLError(); // ERROR: glGetError==1282
        glGenFramebuffers( 6, &fboIDs[0] );
        checkGLError();
 
        int w = width, h = height; // Use width and height of frame, not padded texture dimensions
        for( GLuint i=0; i<6; i++) 
        {
            glBindFramebuffer( GL_FRAMEBUFFER, fboIDs[i] );
            checkGLError();            
            glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureName, i );
            checkGLError();
            if( !glCheckFramebufferStatus(GL_FRAMEBUFFER) ) 
            {
                NSLog(@"Framebuffer fo level %d incomplete\n", i);
                exit(EXIT_FAILURE);
            }
 
            // Save each mipmap level for inspection
            UIImage *image = [ViewController makeImageFromGLViewUsingWidth:w AndHeight:h];
 
#if 0 /* save to disk */
            NSString *dir = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0]; 
            NSString *name = [NSString stringWithFormat:@"mipmap%ld.png", (long)i];
            NSString *path = [dir stringByAppendingPathComponent:name];
            [ViewController saveImageToDisk:image WithFilename:path];
#else /* save to album */
            UIImageWriteToSavedPhotosAlbum(image,nil,nil,nil);
#endif
            w /= 2;
            h /= 2;
        }
        glBindFramebuffer( GL_FRAMEBUFFER, 0 ); 
        checkGLError();
#endif
 
        NSUInteger bytesPerRow = [rawDataOutputSelf bytesPerRowInOutput];
        //NSLog(@"Bytes per row: %d", bytesPerRow);
 
        GLubyte *rawDataOutputBytes = [rawDataOutputSelf rawBytesForImage]; // retrieve address for raw pixels
        for (unsigned int y = 0; y < height; y++)
        {
            struct BGRA *ptr = (struct BGRA *) &rawDataOutputBytes[y * bytesPerRow];
            for (unsigned int x = 0; x < width; x++, ptr ++)
            {
                // For now just add scrolling bands
                if((y % 100) == (counter % 100))
                {
                    (*ptr).r = 255; 
                    (*ptr).g = 255; 
                    (*ptr).b = 255; 
                    (*ptr).a = 255;
                }
            }
        }
 
        // Trigger input callback as in <a href="http://www.sunsetlakesoftware.com/forum/cpu-processing-between-gpuimage-filters<br />
" title="http://www.sunsetlakesoftware.com/forum/cpu-processing-between-gpuimage-filters<br />
" rel="nofollow">http://www.sunsetlakesoftware.com/forum/cpu-processing-between-gpuimage-...</a>        [rawDataInput updateDataFromBytes:rawDataOutputBytes size:CGSizeMake((bytesPerRow/4), m_ImageHeight)];
        [rawDataInput processData]; 
 
    }];
 
    [vc addTarget:gf];
    [gf addTarget:rawDataOutput];
    [rawDataInput addTarget:v];
#else
    [vc addTarget:gf];
    [gf addTarget:v];
#endif
    self.view = v;
    [vc startCameraCapture];
}