int
lpTextures::addTexture(char *fname)
{
int texnum;
unsigned char *p;
if(num_textures + 1 > max_textures) growTextures();
texnum = num_textures;
tex[texnum] = new texture_t;
#if 0
if((tex[texnum]->pixels = read_jpeg(fname, &tex[texnum]->imgXsize,
&tex[texnum]->imgYsize,
&tex[texnum]->imgZsize)) == 0) return(0);
#endif
p = read_jpeg(fname, &tex[texnum]->imgXsize,
&tex[texnum]->imgYsize,
&tex[texnum]->imgZsize);
if(!p) return 0;
tex[texnum]->pixels = p;
num_textures++;
// printf("\n\nAddTextureFile: added %s %dx%dx%d as texnum %d \n",fname,tex[texnum]->imgXsize,
// tex[texnum]->imgYsize, tex[texnum]->imgZsize,texnum);
last_accessed = texnum;
return(texnum);
}
static GLuint makeTexture(const char *filename)
{
int width, height;
unsigned char *pixels = read_jpeg(filename, &width, &height);
GLuint texture;
if (!pixels)
return 0;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(
GL_TEXTURE_2D, 0, /* target, level */
GL_RGB8, /* internal format */
width, height, 0, /* width, height, border */
GL_BGR, GL_UNSIGNED_BYTE, /* external format, type */
pixels /* pixels */
);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
free(pixels);
return texture;
}
int main (int argc, char *argv[])
{
unsigned char *rawpic = NULL;
unsigned char *warpedpic = NULL;
size_t width, height;
int num_components, color_space;
/* Get raw data */
rawpic = read_jpeg ("shrek_cat_eyes.jpg", &width, &height, &num_components, &color_space);
if (!rawpic)
goto out;
warpedpic = calloc(1, width*height*num_components);
if (!warpedpic)
goto out;
/* do some processing here */
warp(rawpic, warpedpic, width, height, num_components);
//thresholding(rawpic, warpedpic, width, height, num_components);
//shift(rawpic, warpedpic, width, height, num_components);
/* write it back as jpeg */
write_jpeg ("out.jpg", warpedpic, width, height, num_components, color_space);
printf("Done :)\n");
out:
if (rawpic)
free(rawpic);
if (warpedpic)
free(warpedpic);
return 0;
}
int main(int argc,char* argv[]) {
if(argc != 2)
{ fprintf(stderr,"\nusage: %s file.jpg\n\n",argv[0]); return 1; }
FILE *f = fopen(argv[1],"rb");
if(!f) { perror(argv[1]); return 1; }
read_jpeg(f);
return 0;
}
rgb* read_jpeg(const char* filename)
// Create and read a new image from the given filename, if possible.
{
SDL_RWops* in = SDL_RWFromFile(filename, "rb");
if (in)
{
rgb* im = read_jpeg(in);
SDL_RWclose(in);
return im;
}
else {
return NULL;
}
}
/**
* Load image
* Parameters:
* path: input path
* mem: memory for decoding
* Return:
* 0 OK
* -1 ERROR
*/
int loadImage (const char *path, Bitmap_t *mem)
{
VALIDATE_NOT_NULL2 (path, mem);
const char const *postfix = getFilePostfix (path);
if (NULL == postfix) {
LogE ("Failed getFilePostfix in loadImage\n");
return -1;
}
if (strcasecmp (postfix, "jpg") == 0) {
return read_jpeg (path, mem);
}
else if (strcasecmp (postfix, "png") == 0) {
return read_png (path, mem);
}
else {
LogE ("Invalid postfix name (%s) in loadImage\n", postfix);
return -1;
}
}
bool GPhotoCCD::grabImage()
{
//char ext[16];
uint8_t *memptr = PrimaryCCD.getFrameBuffer();
size_t memsize;
int fd, naxis=2, w, h, bpp=8;
if (sim)
{
w= PrimaryCCD.getXRes();
h= PrimaryCCD.getYRes();
size_t fullbuf_size = w*h + 512;
uint8_t * fullbuf = (uint8_t *) malloc(fullbuf_size);
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
fullbuf[i * w + j] = rand() % 255;
// Starting address if subframing
memptr = fullbuf + (PrimaryCCD.getSubY() * PrimaryCCD.getXRes()) + PrimaryCCD.getSubX();
memsize = PrimaryCCD.getSubW() * PrimaryCCD.getSubH() * PrimaryCCD.getBPP()/8;
PrimaryCCD.setFrameBuffer(memptr);
PrimaryCCD.setFrameBufferSize(memsize, false);
//PrimaryCCD.setResolution(w, h);
//PrimaryCCD.setFrame(0, 0, w, h);
PrimaryCCD.setNAxis(naxis);
PrimaryCCD.setBPP(bpp);
ExposureComplete(&PrimaryCCD);
return true;
}
// If only save to SD Card, let's not upload back to client
/*if (UploadS[GP_UPLOAD_SDCARD].s == ISS_ON)
{
DEBUG(INDI::Logger::DBG_SESSION, "Exposure complete. Image saved to SD Card.");
ExposureComplete(&PrimaryCCD);
return true;
}*/
if (transferFormatS[0].s == ISS_ON)
{
char tmpfile[] = "/tmp/indi_XXXXXX";
//dcraw can't read from stdin, so we need to write to disk then read it back
fd = mkstemp(tmpfile);
int ret = gphoto_read_exposure_fd(gphotodrv, fd);
if (ret != GP_OK || fd == -1)
{
if (fd == -1)
DEBUGF(INDI::Logger::DBG_ERROR, "Exposure failed to save image. Cannot create temp file %s", tmpfile);
else
DEBUGF(INDI::Logger::DBG_ERROR, "Exposure failed to save image... %s", gp_result_as_string(ret));
unlink(tmpfile);
return false;
}
if (!strcmp(gphoto_get_file_extension(gphotodrv), "unknown"))
{
DEBUG(INDI::Logger::DBG_ERROR, "Exposure failed.");
return false;
}
/* We're done exposing */
DEBUG(INDI::Logger::DBG_SESSION, "Exposure done, downloading image...");
if(strcasecmp(gphoto_get_file_extension(gphotodrv), "jpg") == 0 ||
strcasecmp(gphoto_get_file_extension(gphotodrv), "jpeg") == 0)
{
if (read_jpeg(tmpfile, &memptr, &memsize, &naxis, &w, &h))
{
DEBUG(INDI::Logger::DBG_ERROR, "Exposure failed to parse jpeg.");
unlink(tmpfile);
return false;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "read_jpeg: memsize (%d) naxis (%d) w (%d) h (%d) bpp (%d)", memsize, naxis, w, h, bpp);
}
else
{
if (read_dcraw(tmpfile, &memptr, &memsize, &naxis, &w, &h, &bpp))
{
DEBUG(INDI::Logger::DBG_ERROR, "Exposure failed to parse raw image.");
unlink(tmpfile);
return false;
}
DEBUGF(INDI::Logger::DBG_DEBUG, "read_dcraw: memsize (%d) naxis (%d) w (%d) h (%d) bpp (%d)", memsize, naxis, w, h, bpp);
unlink(tmpfile);
}
PrimaryCCD.setImageExtension("fits");
// If subframing is requested
if (frameInitialized && (PrimaryCCD.getSubH() < PrimaryCCD.getYRes() || PrimaryCCD.getSubW() < PrimaryCCD.getXRes()))
{
int subFrameSize = PrimaryCCD.getSubW() * PrimaryCCD.getSubH() * bpp/8 * ((naxis == 3) ? 3 : 1);
int oneFrameSize = PrimaryCCD.getSubW() * PrimaryCCD.getSubH() * bpp/8;
uint8_t *subframeBuf = (uint8_t *) malloc(subFrameSize);
int startY= PrimaryCCD.getSubY();
int endY = startY + PrimaryCCD.getSubH();
int lineW = PrimaryCCD.getSubW() * bpp/8;
int subX = PrimaryCCD.getSubX();
if (naxis == 2)
{
for (int i=startY ; i < endY; i++)
memcpy(subframeBuf + (i - startY) * lineW, memptr + (i * w + subX) * bpp/8 , lineW);
}
else
{
uint8_t *subR = subframeBuf;
uint8_t *subG = subframeBuf + oneFrameSize;
uint8_t *subB = subframeBuf + oneFrameSize * 2;
uint8_t *startR = memptr;
uint8_t *startG = memptr + (w * h * bpp/8);
uint8_t *startB = memptr + (w * h * bpp/8 * 2);
for (int i=startY; i < endY; i++)
{
memcpy(subR + (i-startY) * lineW, startR + (i * w + subX) * bpp/8 , lineW );
memcpy(subG + (i-startY) * lineW, startG + (i * w + subX) * bpp/8 , lineW );
memcpy(subB + (i-startY) * lineW, startB + (i * w + subX) * bpp/8 , lineW );
}
}
PrimaryCCD.setFrameBuffer(subframeBuf);
PrimaryCCD.setFrameBufferSize(subFrameSize, false);
PrimaryCCD.setResolution(w, h);
PrimaryCCD.setNAxis(naxis);
PrimaryCCD.setBPP(bpp);
ExposureComplete(&PrimaryCCD);
// Restore old pointer and release memory
PrimaryCCD.setFrameBuffer(memptr);
PrimaryCCD.setFrameBufferSize(memsize, false);
free(subframeBuf);
}
else
{
// We need to initially set the frame dimensions for the first time since it is unknown at the time of connection.
frameInitialized = true;
PrimaryCCD.setFrame(0, 0, w, h);
PrimaryCCD.setFrameBuffer(memptr);
PrimaryCCD.setFrameBufferSize(memsize, false);
PrimaryCCD.setResolution(w, h);
PrimaryCCD.setNAxis(naxis);
PrimaryCCD.setBPP(bpp);
ExposureComplete(&PrimaryCCD);
}
}
else
{
int rc = gphoto_read_exposure(gphotodrv);
if (rc != 0)
{
DEBUG(INDI::Logger::DBG_ERROR, "Failed to expose.");
return rc;
}
/* We're done exposing */
DEBUG(INDI::Logger::DBG_DEBUG, "Exposure done, downloading image...");
uint8_t *newMemptr = NULL;
gphoto_get_buffer(gphotodrv, (const char **)&newMemptr, &memsize);
memptr = (uint8_t *)realloc(memptr, memsize); // We copy the obtained memory pointer to avoid freeing some gphoto memory
memcpy(memptr, newMemptr, memsize); //
gphoto_get_dimensions(gphotodrv, &w, &h);
PrimaryCCD.setImageExtension(gphoto_get_file_extension(gphotodrv));
if (w > 0 && h > 0)
PrimaryCCD.setFrame(0, 0, w, h);
PrimaryCCD.setFrameBuffer(memptr);
PrimaryCCD.setFrameBufferSize(memsize, false);
if (w > 0 && h > 0)
PrimaryCCD.setResolution(w, h);
PrimaryCCD.setNAxis(naxis);
PrimaryCCD.setBPP(bpp);
ExposureComplete(&PrimaryCCD);
}
return true;
}
int
read_image(const char *filename, int *width, int *height,
unsigned char *rgb)
{
char buf[4];
unsigned char *ubuf = (unsigned char *) buf;
int success = 0;
FILE *file;
file = fopen(filename, "rb");
if (file == NULL) return(0);
/* see what kind of file we have */
fread(buf, 1, 4, file);
fclose(file);
if (!strncmp("BM", buf, 2))
{
success = read_bmp(filename, width, height, rgb);
}
else if (!strncmp("GIF8", buf, 4))
{
#ifdef HAVE_LIBGIF
success = read_gif(filename, width, height, rgb);
#else
fprintf(stderr,
"Sorry, this program was not compiled with GIF support\n");
success = 0;
#endif /* HAVE_LIBGIF */
}
else if ((ubuf[0] == 0xff) && (ubuf[1] == 0xd8))
{
#ifdef HAVE_LIBJPEG
success = read_jpeg(filename, width, height, rgb);
#else
fprintf(stderr,
"Sorry, this program was not compiled with JPEG support\n");
success = 0;
#endif /* HAVE_LIBJPEG */
}
else if ((ubuf[0] == 0x89) && !strncmp("PNG", buf+1, 3))
{
#ifdef HAVE_LIBPNG
success = read_png(filename, width, height, rgb);
#else
fprintf(stderr,
"Sorry, this program was not compiled with PNG support\n");
success = 0;
#endif /* HAVE_LIBPNG */
}
else if (( !strncmp("P6\n", buf, 3))
|| (!strncmp("P5\n", buf, 3))
|| (!strncmp("P4\n", buf, 3))
|| (!strncmp("P3\n", buf, 3))
|| (!strncmp("P2\n", buf, 3))
|| (!strncmp("P1\n", buf, 3)))
{
#ifdef HAVE_LIBPNM
success = read_pnm(filename, width, height, rgb);
#else
fprintf(stderr,
"Sorry, this program was not compiled with PNM support\n");
success = 0;
#endif /* HAVE_LIBPNM */
}
else if (((!strncmp ("MM", buf, 2)) && (ubuf[2] == 0x00)
&& (ubuf[3] == 0x2a))
|| ((!strncmp ("II", buf, 2)) && (ubuf[2] == 0x2a)
&& (ubuf[3] == 0x00)))
{
#ifdef HAVE_LIBTIFF
success = read_tiff(filename, width, height, rgb);
#else
fprintf(stderr,
"Sorry, this program was not compiled with TIFF support\n");
success = 0;
#endif
}
else
{
fprintf(stderr, "Unknown image format\n");
success = 0;
}
return(success);
}
int main(int argc, char **argv) {
extern int optind;
extern char *optarg;
int i;
char *outfile = NULL;
int de = 0;
while ((i = getopt(argc, argv, "o:d")) != -1) {
switch (i) {
case 'o':
outfile = optarg;
break;
case 'd':
de = 1;
break;
default:
usage(argv);
exit(EXIT_FAILURE);
}
}
if (argc - optind != 1) {
usage(argv);
exit(EXIT_FAILURE);
}
if (outfile == NULL && isatty(1)) {
fprintf(stderr, "Didn't specify -o and standard output is a terminal\n");
exit(EXIT_FAILURE);
}
FILE *outfp = stdout;
if (outfile != NULL) {
outfp = fopen(outfile, "wb");
if (outfp == NULL) {
perror(outfile);
exit(EXIT_FAILURE);
}
}
int width, height;
unsigned char *buf;
{
{
{
char *url = argv[optind];
CURL *curl = curl_easy_init();
if (curl == NULL) {
fprintf(stderr, "Curl won't start\n");
exit(EXIT_FAILURE);
}
struct data data;
data.buf = NULL;
data.len = 0;
data.nalloc = 0;
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &data);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_receive);
CURLcode res = curl_easy_perform(curl);
if (res != CURLE_OK) {
fprintf(stderr, "Can't retrieve %s: %s\n", url,
curl_easy_strerror(res));
exit(EXIT_FAILURE);
}
struct image *i;
if (data.len >= 4 && memcmp(data.buf, "\x89PNG", 4) == 0) {
i = read_png(data.buf, data.len);
} else if (data.len >= 2 && memcmp(data.buf, "\xFF\xD8", 2) == 0) {
i = read_jpeg(data.buf, data.len);
} else {
fprintf(stderr, "Don't recognize file format\n");
free(data.buf);
curl_easy_cleanup(curl);
exit(EXIT_FAILURE);
}
free(data.buf);
curl_easy_cleanup(curl);
width = i->width;
height = i->height;
buf = malloc(i->width * i->height * 4);
int x, y;
for (y = 0; y < i->height; y++) {
for (x = 0; x < i->width; x++) {
if (i->depth == 4) {
double as = buf[((y) * width + x) * 4 + 3] / 255.0;
double rs = buf[((y) * width + x) * 4 + 0] / 255.0 * as;
double gs = buf[((y) * width + x) * 4 + 1] / 255.0 * as;
double bs = buf[((y) * width + x) * 4 + 2] / 255.0 * as;
double ad = i->buf[(y * i->width + x) * 4 + 3] / 255.0;
double rd = i->buf[(y * i->width + x) * 4 + 0] / 255.0 * ad;
double gd = i->buf[(y * i->width + x) * 4 + 1] / 255.0 * ad;
double bd = i->buf[(y * i->width + x) * 4 + 2] / 255.0 * ad;
// https://code.google.com/p/pulpcore/wiki/TutorialBlendModes
double ar = as * (1 - ad) + ad;
double rr = rs * (1 - ad) + rd;
double gr = gs * (1 - ad) + gd;
double br = bs * (1 - ad) + bd;
buf[((y) * width + x) * 4 + 3] = ar * 255.0;
buf[((y) * width + x) * 4 + 0] = rr / ar * 255.0;
buf[((y) * width + x) * 4 + 1] = gr / ar * 255.0;
buf[((y) * width + x) * 4 + 2] = br / ar * 255.0;
} else if (i->depth == 3) {
buf[((y) * width + x) * 4 + 0] = i->buf[(y * i->width + x) * 3 + 0];
buf[((y) * width + x) * 4 + 1] = i->buf[(y * i->width + x) * 3 + 1];
buf[((y) * width + x) * 4 + 2] = i->buf[(y * i->width + x) * 3 + 2];
buf[((y) * width + x) * 4 + 3] = 255;
} else {
buf[((y) * width) * 4 + 0] = i->buf[(y * i->width + x) * i->depth + 0];
buf[((y) * width) * 4 + 1] = i->buf[(y * i->width + x) * i->depth + 0];
buf[((y) * width) * 4 + 2] = i->buf[(y * i->width + x) * i->depth + 0];
buf[((y) * width) * 4 + 3] = 255;
}
}
}
free(i->buf);
free(i);
}
}
}
unsigned char *rows[height];
for (i = 0; i < height; i++) {
rows[i] = buf + i * (4 * width);
}
convert(buf, width, height, de);
png_structp png_ptr;
png_infop info_ptr;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, fail, fail, fail);
if (png_ptr == NULL) {
fprintf(stderr, "PNG failure (write struct)\n");
exit(EXIT_FAILURE);
}
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) {
png_destroy_write_struct(&png_ptr, NULL);
fprintf(stderr, "PNG failure (info struct)\n");
exit(EXIT_FAILURE);
}
png_set_IHDR(png_ptr, info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
png_set_rows(png_ptr, info_ptr, rows);
png_init_io(png_ptr, outfp);
png_write_png(png_ptr, info_ptr, 0, NULL);
png_destroy_write_struct(&png_ptr, &info_ptr);
if (outfile != NULL) {
fclose(outfp);
}
return 0;
}
