ios - Problema en Coverting zlib base comprimida 64 cadena a Uiimage

objective-c base64

Question

En uno de mis proyectos actuales, tengo que analizar la cadena base 64, que está codificada y almacenada por la aplicación flex (Adobe Flash). Al hablar con el equipo de desarrollo de flex encontré que estaban almacenando cadenas de imágenes en formato de mapa de bits, así que asumí que es una representación de píxeles.

Entonces, la primera pregunta que hago es, en el caso mencionado anteriormente, ¿puedo convertir directamente los datos sin procesar a UIimage utilizando la clase de decodificación base64 o tengo que usar CGBitmapContext?

Sin embargo, actualmente he implementado el código mencionado a continuación para la conversión.

`// Convertir a datos de Base64

NSData *decodedData = [QSStrings decodeBase64WithString:_settingSerializedImage.currentValue];


NSError *error = nil;
NSData *unCompressedData = [decodedData bbs_dataByInflatingWithError:&error];



NSData *dataImage = [NSMutableData new];
NSUInteger bytePosition = 0;
uint8_t * bytes =  malloc(5);
[unCompressedData getBytes:&bytes range:NSMakeRange(unCompressedData.length-3, 3)];

bytes = OSSwapBigToHostInt16(bytes);
int width = (int)bytes;

[unCompressedData getBytes:&bytes range:NSMakeRange(unCompressedData.length-5, 5)];

bytes = OSSwapBigToHostInt16(bytes);dataImage = [unCompressedData subdataWithRange:NSMakeRange(0, (unCompressedData.length -5))];

NSUInteger length = [dataImage length];
unsigned char *bytesData = malloc( length * sizeof(unsigned char) ); [dataImage getBytes:bytesData length:length];UIImage *imgScreenShot = [ScreenshotPortlet convertBitmapRGBA8ToUIImage:bytesData withWidth:width withHeight:height];`

a continuación se muestra el método para convertir datos brutos en imágenes usando gráficos centrales

+ (UIImage *) convertBitmapRGBA8ToUIImage:(unsigned char *) buffer
                            withWidth:(int) width
                           withHeight:(int) height {

 char* rgba = (char*)malloc(width*height*4);
for(int i=0; i < width*height; ++i) {
    rgba[4*i] = buffer[4*i];
    rgba[4*i+1] = buffer[4*i+1];
    rgba[4*i+2] = buffer[4*i+2];
    rgba[4*i+3] = buffer[4*i+3];
}
//


size_t bufferLength = width * height * 4;
CGDataProviderRef provider = CGDataProviderCreateWithData(NULL, rgba, bufferLength, NULL);
size_t bitsPerComponent = 8;
size_t bitsPerPixel = 32;
size_t bytesPerRow = 4 * width;

CGColorSpaceRef colorSpaceRef = CGColorSpaceCreateDeviceRGB();
  if(colorSpaceRef == NULL) {
    NSLog(@"Error allocating color space");
    CGDataProviderRelease(provider);
    return nil;
}

CGBitmapInfo bitmapInfo = kCGBitmapByteOrder32Big | kCGImageAlphaPremultipliedFirst;

CGColorRenderingIntent renderingIntent = kCGRenderingIntentDefault;
CGImageRef iref = CGImageCreate(width,
                                height,
                                bitsPerComponent,
                                bitsPerPixel,
                                bytesPerRow,
                                colorSpaceRef,
                                bitmapInfo,
                                provider,
                                NULL,
                                YES,
                                renderingIntent);

uint32_t* pixels = (uint32_t*)malloc(bufferLength);

if(pixels == NULL) {
    NSLog(@"Error: Memory not allocated for bitmap");
    CGDataProviderRelease(provider);
    CGColorSpaceRelease(colorSpaceRef);
    CGImageRelease(iref);
    return nil;
}

CGContextRef context = CGBitmapContextCreate(pixels,
                                             width,
                                             height,
                                             bitsPerComponent,
                                             bytesPerRow,
                                             colorSpaceRef,
                                             bitmapInfo);

if(context == NULL) {
    NSLog(@"Error context not created");
    free(pixels);
}

UIImage *image = nil;
if(context) {

    CGContextDrawImage(context, CGRectMake(0.0f, 0.0f, width, height), iref);

    CGImageRef imageRef = CGBitmapContextCreateImage(context);

    image = [UIImage imageWithCGImage:imageRef];

    CGImageRelease(imageRef);
    CGContextRelease(context);
}

CGColorSpaceRelease(colorSpaceRef);
CGImageRelease(iref);
CGDataProviderRelease(provider);


if(pixels) {
    free(pixels);
}   
return image;

}

Aquí está la salida que estoy obteniendo, una imagen distorsionada:

Entonces, ¿alguien puede sugerirme una mejor solución o decirme si estoy en la dirección correcta o no? Gracias por adelantado :)

Para referencia aquí puede encontrar la base original de 64 cuerdas

Answer 1

Para convertir la imagen a base64string:

- (NSString *)imageToNSString:(UIImage *)image
{
    NSData *data = UIImagePNGRepresentation(image);

    return [data base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithLineFeed];
}

Para convertir base64string en una imagen:

- (UIImage *)stringToUIImage:(NSString *)string
{
    NSData *data = [[NSData alloc]initWithBase64EncodedString:string options:NSDataBase64DecodingIgnoreUnknownCharacters];

    return [UIImage imageWithData:data];
}