int get_img(int fp,u8 *buf)
{
int fd;
int buffer_size;
// struct timeval starttime,endtime;
// fp=fp;
//打开framebuffer设备
buffer_size = (WIDTH * HEIGHT * BITS_PER_FB/8);
//获取一帧数据
if(read(fd,trgb,buffer_size) < 0)
{
printf("reaf failed!\n");
return 0;
}
//格式转换
// gettimeofday(&endtime,0);
RGB565_to_RGB24(trgb,buf,WIDTH,HEIGHT);
// gettimeofday(&starttime,0);
//jpeg压缩
if(jpeg_compress(buf,WIDTH,HEIGHT)<0)
printf("compress failed!\n");
// double timeuse = 1000000*(endtime.tv_sec - starttime.tv_sec) + endtime.tv_usec - starttime.tv_usec;
// printf("timeuse=%f\n",timeuse);
return 0;
}
/**
* @brief Save the image frame into a file
* @param Storage path
* @param file_name: Jpeg file name
* @retval Status
*/
static uint8_t Save_Jpg_To_File (uint8_t *path , uint8_t *file_name)
{
RTC_TimeTypeDef RTC_TimeStructure;
RTC_DateTypeDef RTC_DateStructure;
FIL file;
/* Update file name */
strcpy((char *)ImageBuffer.ImageName , (char *)path),
strcat ((char *)ImageBuffer.ImageName, "/");
if ( RTC_Error == 0)
{
RTC_GetTime(RTC_Format_BIN, &RTC_TimeStructure);
RTC_GetDate(RTC_Format_BIN, &RTC_DateStructure);
sprintf((char *)file_name, "Camera_%02d%02d%d%02d%02d%02d.jpg", RTC_DateStructure.RTC_Date,
RTC_DateStructure.RTC_Month,
RTC_DateStructure.RTC_Year + 2000,
RTC_TimeStructure.RTC_Hours,
RTC_TimeStructure.RTC_Minutes,
RTC_TimeStructure.RTC_Seconds);
}
else
{
sprintf((char *)file_name, "Camera_%08d.jpg", (int)(RecoveryImageCounter++));
}
strcat ((char *)ImageBuffer.ImageName, (char *)file_name);
/* Can not create file */
if (f_open(&file, (char *)ImageBuffer.ImageName, FA_CREATE_NEW | FA_WRITE) != FR_OK)
{
return 0;
}
/* Convert RGB16 image to RGB24 */
RGB16toRGB24(ImageBuffer.DestData, ImageBuffer.RawData , 1);
/* Set compression parameters */
jpeg_params.in_buff = (uint8_t *)ImageBuffer.DestData;
jpeg_params.in_length = IMAGE_COLUMN_SIZE * IMAGE_LINE_SIZE * 3;
jpeg_params.in_width = IMAGE_LINE_SIZE;
jpeg_params.in_height = IMAGE_COLUMN_SIZE;
jpeg_params.in_bpp = 3;
jpeg_params.in_colorspace = JCS_RGB;
jpeg_params.in_imagequality = 100;
jpeg_compress(&file, &jpeg_params);
/* Close file */
f_close(&file);
return 1 ;
}
static mp_obj_t py_image_threshold(mp_obj_t image_obj, mp_obj_t color_list_obj, mp_obj_t threshold)
{
color_t *color;
image_t *image;
/* sanity checks */
PY_ASSERT_TRUE(sensor.pixformat == PIXFORMAT_RGB565);
PY_ASSERT_TRUE(sensor.framesize <= FRAMESIZE_QCIF);
/* read arguments */
image = py_image_cobj(image_obj);
int thresh = mp_obj_get_int(threshold);
/* returned image */
image_t bimage = {
.w=image->w,
.h=image->h,
.bpp=1,
.pixels=image->data+(image->w*image->h*image->bpp)
};
/* copy color list */
uint len;
mp_obj_t *color_arr;
mp_obj_get_array(color_list_obj, &len, &color_arr);
color = xalloc(len*sizeof*color);
for (int i=0; i<len; i++) {
mp_obj_t *color_obj;
mp_obj_get_array_fixed_n(color_arr[i], 3, &color_obj);
color[i].r = mp_obj_get_int(color_obj[0]);
color[i].g = mp_obj_get_int(color_obj[1]);
color[i].b = mp_obj_get_int(color_obj[2]);
}
/* Threshold image using reference color */
imlib_threshold(image, &bimage, color, len, thresh);
return py_image_from_struct(&bimage);
}
static mp_obj_t py_image_rainbow(mp_obj_t src_image_obj)
{
image_t *src_image = NULL;
/* get C image pointer */
src_image = py_image_cobj(src_image_obj);
/* sanity checks */
PY_ASSERT_TRUE(src_image->bpp==1);
image_t dst_image = {
.w=src_image->w,
.h=src_image->h,
.bpp=2,
.pixels=xalloc(src_image->w*src_image->h*2)
};
imlib_rainbow(src_image, &dst_image);
*src_image = dst_image;
return src_image_obj;
}
static mp_obj_t py_image_compress(mp_obj_t image_obj, mp_obj_t quality)
{
image_t *image = py_image_cobj(image_obj);
image_t cimage = {
.w=image->w,
.h=image->h,
.bpp=0,
.pixels= NULL
};
jpeg_compress(image, &cimage, mp_obj_get_int(quality));
return py_image_from_struct(&cimage);
}
static mp_obj_t py_image_draw_line(mp_obj_t image_obj, mp_obj_t line_obj)
{
/* get image pointer */
struct image *image;
image = py_image_cobj(image_obj);
mp_obj_t *array;
mp_obj_get_array_fixed_n(line_obj, 4, &array);
int x0 = mp_obj_get_int(array[0]);
int y0 = mp_obj_get_int(array[1]);
int x1 = mp_obj_get_int(array[2]);
int y1 = mp_obj_get_int(array[3]);
imlib_draw_line(image, x0, y0, x1, y1);
return mp_const_none;
}
static mp_obj_t py_image_draw_circle(mp_obj_t image_obj, mp_obj_t c_obj, mp_obj_t r_obj)
{
int cx, cy, r;
mp_obj_t *array;
struct image *image;
color_t c = {.r=0xFF, .g=0xFF, .b=0xFF};
/* get image pointer */
image = py_image_cobj(image_obj);
/* center */
mp_obj_get_array_fixed_n(c_obj, 2, &array);
cx = mp_obj_get_int(array[0]);
cy = mp_obj_get_int(array[1]);
/* radius */
r = mp_obj_get_int(r_obj);
imlib_draw_circle(image, cx, cy, r, &c);
return mp_const_none;
}
static mp_obj_t py_image_draw_string(uint n_args, const mp_obj_t *args)
{
int x = mp_obj_get_int(args[1]);
int y = mp_obj_get_int(args[2]);
image_t *image =py_image_cobj(args[0]);
const char *str = mp_obj_str_get_str(args[3]);
color_t c = {.r=0xFF, .g=0xFF, .b=0xFF};
if (n_args == 5) {
// get color
mp_obj_t *array;
mp_obj_get_array_fixed_n(args[4], 3, &array);
c.r = mp_obj_get_int(array[0]);
c.g = mp_obj_get_int(array[1]);
c.b = mp_obj_get_int(array[2]);
}
imlib_draw_string(image, x, y, str, &c);
return mp_const_none;
}
static mp_obj_t py_image_erode(mp_obj_t image_obj, mp_obj_t ksize_obj)
{
image_t *image = NULL;
image = py_image_cobj(image_obj);
/* sanity checks */
PY_ASSERT_TRUE(image->bpp==1);
imlib_erode(image, mp_obj_get_int(ksize_obj));
return mp_const_none;
}
int main(int argc, char **argv) {
int err;
int myrank, numprocs;
double inicio, fim;
FILE * inputFiles[argc - 1];
char **arquivos[argc - 1];
char nomeArquivos[30][256];
char nomeArquivosJPG[30][256];
char nomeArquivosRAW[30][256];
char nomeArquivosCINZA[30][256];
if (argc != 2) {
printf("Número de Parâmetros incorreto. Use: mpirun -np <QTD_PROCESSOS> ./build/jpeg2raw <QTD_IMAGENS>\n");
err = -1;
goto error;
}
int QTD_IMAGENS = atoi(argv[1]);
//armazena a quantidade de imagens ainda a serem processadas
int imagensRestantes = QTD_IMAGENS;
int imagensProcessadas = 0;
int controle;
int acabou = 0; // [0=false,1=true]
MPI_Status status;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
inicio = MPI_Wtime();
int z;
char str1[40], str2[10], strJPG[40], strRAW[40], strCINZA[40];
controle = numprocs;
if ((numprocs - 1) > QTD_IMAGENS) {
printf("Bah, você está disperdiçando recursos...\n");
controle = QTD_IMAGENS;
}
//Armazena o nome das Imagens a serem processadas
for (z = 1; z <= QTD_IMAGENS; z++) {
strcpy(str1, "images/montage");
sprintf(str2, "%d", z);
strcat(str1, str2);
//printf("[str]%s\n", str1);
strncpy(strJPG, str1, sizeof (str1));
strncpy(strRAW, str1, sizeof (str1));
strncpy(strCINZA, str1, sizeof (str1));
strcpy(nomeArquivos[z], str1);
strcpy(nomeArquivosJPG[z], strcat(strJPG, ".jpg"));
strcpy(nomeArquivosRAW[z], strcat(strRAW, ".raw"));
strcpy(nomeArquivosCINZA[z], strcat(strCINZA, "cinza.jpg"));
}
printf("################################################### \n");
printf("Número de Processos: %d \n", numprocs);
printf("Imagens a serem processadas: \n");
for (z = 1; z <= QTD_IMAGENS; z++) {
printf("%s\n", nomeArquivos[z]);
}
printf("################################################### \n");
for (z = 1; z <= QTD_IMAGENS; z++) {
printf("\n[%d]Processando a Imagem %s\n", myrank, nomeArquivosJPG[z]);
struct raw_img raw_img;
err = 0;
FILE *jpeg_file;
struct jpeg_decompress_struct jdec;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1];
float r;
float g;
float b;
int i;
int j;
j = 0;
/**
* abre um arquivo JPEG no espaço de cores RGB e extrai a luminância
* (imagem em tons de cinza), que é gravada em um arquivo especificado pelo usuário.
*/
const char *file = argv[1];
struct raw_img *raw = &raw_img;
//err = jpeg_decompress(argv[1], &raw_img, myrank, numprocs);
//carrega o arquivo de imagem jpeg
jpeg_file = fopen(nomeArquivosJPG[z], "rb");
if (jpeg_file == NULL) {
printf("Error opening file %s\n!", nomeArquivosJPG[z]);
err = -1;
goto error;
}
jdec.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&jdec);
jpeg_stdio_src(&jdec, jpeg_file);
jpeg_read_header(&jdec, TRUE);
raw->width = jdec.image_width;
raw->height = jdec.image_height;
raw->num_comp = jdec.num_components;
if (raw->num_comp != 3) {
printf("Cannot convert a jpeg file with %d componentes per "
"pixel\n", raw->num_comp);
err = -1;
goto error;
}
//INFORMAÇÕES DA IMAGEM
//printf("JPEG File Information:\n");
printf("Resolução: %d x %d pixels\n", raw->width, raw->height);
//printf("\tColor components per pixel: %d\n", raw->num_comp);
jpeg_start_decompress(&jdec);
raw->img = (uint8_t *) malloc(raw->width * raw->height);
row_pointer[0] = (unsigned char *) malloc(raw->width * raw->num_comp);
while (jdec.output_scanline < jdec.image_height) {
jpeg_read_scanlines(&jdec, row_pointer, 1);
for (i = 0; i < raw->width * raw->num_comp; i += 3) {
r = (float) row_pointer[0][i];
g = (float) row_pointer[0][i + 1];
b = (float) row_pointer[0][i + 2];
/* here convert to grayscale */
raw->img[j] = (uint8_t)
(0.2126 * r + 0.7152 * g + 0.0722 * b);
j++;
}
}
jpeg_finish_decompress(&jdec);
jpeg_destroy_decompress(&jdec);
free(row_pointer[0]);
fclose(jpeg_file);
if (err == -1)
goto error;
// save_raw_image(argv[2], &raw_img);
save_raw_image(nomeArquivosRAW[z], &raw_img);
free(raw_img.img);
//Convere o RAW para imagem em tons de cinza
//SERIA o SEGUNDO COMANDO QUE É EXECUTADO
struct raw_img2 raw_img2;
err = 0;
raw_img2.width = raw->width;
raw_img2.height = raw->height;
// printf("DEBUG2 widht[%d] height[%d]\n", raw_img2.width, raw_img2.height);
// err = open_raw_image(argv[1], &raw_img);
//open_raw_image(const char *file, struct raw_img *raw)
const char *file2 = nomeArquivosRAW[z];
struct raw_img2 *raw2 = &raw_img2;
FILE *raw_file;
size_t read;
size_t size;
// raw_file = fopen(file2, "r");
raw_file = fopen(file2, "r");
if (raw_file == NULL) {
printf("Could not open '%s' file\n", file2);
err = -1;
goto error;
}
// printf("Abriu arquivo RAW\n");
size = raw2->width * raw2->height;
raw2->img = (uint8_t *) malloc(size * sizeof (uint8_t));
if (raw2->img == NULL) {
err = -2;
goto error;
}
read = fread((void *) raw2->img, 1, size, raw_file);
if (read != size)
printf("Only %lu/%lu bytes were read\n", read, size);
fclose(raw_file);
if (err == -1)
goto error;
if (err == -2)
goto error;
jpeg_compress(nomeArquivosCINZA[z], &raw_img2);
}
fim = MPI_Wtime();
printf("TEMPO SEQ[%f].\n", fim - inicio);
MPI_Finalize();
return 0;
//cleanup:
// free(raw_img2.img);
error:
return err;
}
int main()
{
int fd;
struct fb_var_screeninfo fb_var_info;
struct fb_fix_screeninfo fb_fix_info;
unsigned char *trgb;
unsigned char *rgb;
int buffer_size;
struct timeval starttime,endtime;
//打开framebuffer设备
fd = open("/dev/fb0",O_RDONLY);
if(fd < 0)
{
printf("can not open dev\n");
exit(1);
}
//获取LCD的可变参数
ioctl(fd,FBIOGET_VSCREENINFO,&fb_var_info);
//一个像素多少位
printf("bits_per_pixel: %d\n",fb_var_info.bits_per_pixel);
//x分辨率
printf("xres: %d\n",fb_var_info.xres);
//y分辨率
printf("yres: %d\n",fb_var_info.yres);
//r分量长度（bit）
printf("red_length: %d\n",fb_var_info.red.length);
//g分量长度（bit）
printf("green_length: %d\n",fb_var_info.green.length);
//b分量长度（bit）
printf("blue_length: %d\n",fb_var_info.blue.length);
//t(透明度)分量长度（bit）
printf("transp_length: %d\n",fb_var_info.transp.length);
//r分量偏移
printf("red_offset: %d\n",fb_var_info.red.offset);
//g分量偏移
printf("green_offset: %d\n",fb_var_info.green.offset);
//b分量偏移
printf("blue_offset: %d\n",fb_var_info.blue.offset);
//t分量偏移
printf("transp_offset: %d\n",fb_var_info.transp.offset);
//获取LCD的固定参数
ioctl(fd,FBIOGET_FSCREENINFO,&fb_fix_info);
//一帧大小
printf("smem_len: %d\n",fb_fix_info.smem_len);
//一行大小
printf("line_length: %d\n",fb_fix_info.line_length);
//一帧大小
buffer_size = (fb_var_info.xres * fb_var_info.yres * BITS_PER_FB/8);
trgb = (unsigned char *)malloc(buffer_size);
if(trgb==NULL)
exit(0);
rgb = (unsigned char *)malloc(fb_var_info.xres * fb_var_info.yres * 3);
if(rgb==NULL)
{
goto here;
}
//获取一帧数据
if(read(fd,trgb,buffer_size) < 0)
{
printf("reaf failed!\n");
goto read_fail;
}
//格式转换
gettimeofday(&endtime,0);
// RGB565_to_RGB24(trgb,rgb,fb_var_info.xres,fb_var_info.yres);
gettimeofday(&starttime,0);
//jpeg压缩
if(jpeg_compress(trgb,fb_var_info.xres,fb_var_info.yres)<0)
printf("compress failed!\n");
double timeuse = 1000000*(endtime.tv_sec - starttime.tv_sec) + endtime.tv_usec - starttime.tv_usec;
printf("timeuse=%f\n",timeuse);
read_fail:
free(rgb);
here:
free(trgb);
close(fd);
return 0;
}
void *
thread(void *arg)
{
struct fw_ctx *fctx;
int fd;
char buf[1024];
struct image curimg;
struct grab_ctx idx;
struct jpegbuf jbuf;
int ret;
int cpid;
char tsfnbuf[1024];
time_t now;
struct tm tm;
fctx = ((struct module_ctx *) arg)->custom;
memset(&idx, 0, sizeof(idx));
for (;;)
{
time(&now);
localtime_r(&now, &tm);
strftime(tsfnbuf, sizeof(tsfnbuf) - 1, fctx->path, &tm);
snprintf(buf, sizeof(buf) - 1, "%s.tmp", tsfnbuf);
filter_get_image(&curimg, &idx, ((struct module_ctx *) arg)->node, NULL);
jpeg_compress(&jbuf, &curimg, ((struct module_ctx *) arg)->node);
fd = open(buf, O_WRONLY | O_CREAT | O_TRUNC, 0666);
if (fd < 0)
{
log_log(MODNAME, "Open of %s failed: %s\n", buf, strerror(errno));
goto freesleeploop;
}
if (fctx->chmod != -1)
fchmod(fd, fctx->chmod);
ret = write(fd, jbuf.buf, jbuf.bufsize);
if (ret != jbuf.bufsize)
{
log_log(MODNAME, "Write to %s failed: %s\n",
buf, (ret == -1) ? strerror(errno) : "short write");
close(fd);
unlink(buf);
goto freesleeploop;
}
close(fd);
if (fctx->cmd)
{
cpid = fork();
if (cpid < 0)
{
log_log(MODNAME, "fork() failed: %s\n", strerror(errno));
unlink(buf);
goto freesleeploop;
}
if (!cpid)
{
/* child */
close(STDIN_FILENO);
for (fd = 3; fd < 1024; fd++)
close(fd);
execlp(fctx->cmd, fctx->cmd, buf, NULL);
/* notreached unless error */
log_log(MODNAME, "exec(\"%s\") failed: %s\n", fctx->cmd, strerror(errno));
_exit(0);
}
do
ret = waitpid(cpid, NULL, 0);
while (ret == -1 && errno == EINTR);
ret = access(buf, F_OK);
if (ret)
goto freesleeploop;
}
ret = rename(buf, tsfnbuf);
if (ret != 0)
{
log_log(MODNAME, "Rename of %s to %s failed: %s\n",
buf, tsfnbuf, strerror(errno));
unlink(buf);
goto freesleeploop;
}
freesleeploop:
free(jbuf.buf);
image_destroy(&curimg);
if (fctx->interval > 0)
sleep(fctx->interval);
else
{
sleep(5);
log_log(MODNAME, "Negative interval specified, exiting now.\n");
exit(0);
}
}
}
static mp_obj_t py_image_threshold(mp_obj_t image_obj, mp_obj_t color_list_obj, mp_obj_t threshold)
{
color_t *color;
image_t *image;
/* sanity checks */
PY_ASSERT_TRUE_MSG(sensor.pixformat == PIXFORMAT_RGB565,
"This function is only supported on RGB565 images");
PY_ASSERT_TRUE_MSG(sensor.framesize <= OMV_MAX_BLOB_FRAME,
"This function is only supported on "OMV_MAX_BLOB_FRAME_STR" and smaller frames");
/* read arguments */
image = py_image_cobj(image_obj);
int thresh = mp_obj_get_int(threshold);
/* returned image */
image_t bimage = {
.w=image->w,
.h=image->h,
.bpp=1,
.pixels=image->data+(image->w*image->h*image->bpp)
};
/* copy color list */
uint len;
mp_obj_t *color_arr;
mp_obj_get_array(color_list_obj, &len, &color_arr);
color = xalloc(len*sizeof*color);
for (int i=0; i<len; i++) {
mp_obj_t *color_obj;
mp_obj_get_array_fixed_n(color_arr[i], 3, &color_obj);
color[i].r = mp_obj_get_int(color_obj[0]);
color[i].g = mp_obj_get_int(color_obj[1]);
color[i].b = mp_obj_get_int(color_obj[2]);
}
/* Threshold image using reference color */
imlib_threshold(image, &bimage, color, len, thresh);
return py_image_from_struct(&bimage);
}
static mp_obj_t py_image_rainbow(mp_obj_t src_image_obj)
{
image_t *src_image = NULL;
/* get C image pointer */
src_image = py_image_cobj(src_image_obj);
/* sanity checks */
PY_ASSERT_TRUE_MSG(src_image->bpp == 1,
"This function is only supported on GRAYSCALE images");
image_t dst_image = {
.w=src_image->w,
.h=src_image->h,
.bpp=2,
.pixels=xalloc(src_image->w*src_image->h*2)
};
imlib_rainbow(src_image, &dst_image);
*src_image = dst_image;
return src_image_obj;
}
static mp_obj_t py_image_compress(mp_obj_t image_obj, mp_obj_t quality)
{
image_t *image = py_image_cobj(image_obj);
image_t cimage = {
.w=image->w,
.h=image->h,
.bpp = JPEG_INIT_BUF,
.pixels = xalloc(JPEG_INIT_BUF)
};
jpeg_compress(image, &cimage, mp_obj_get_int(quality));
return py_image_from_struct(&cimage);
}
GLOBAL void
write_JPEG_file (char * filename)
{
/* These three structs contain JPEG parameters and working data.
* They must survive for the duration of parameter setup and one
* call to jpeg_compress; typically, making them local data in the
* calling routine is the best strategy.
*/
struct Compress_info_struct cinfo;
struct Compress_methods_struct c_methods;
struct External_methods_struct e_methods;
/* Initialize the system-dependent method pointers. */
cinfo.methods = &c_methods; /* links to method structs */
cinfo.emethods = &e_methods;
/* Here we use the default JPEG error handler, which will just print
* an error message on stderr and call exit(). See the second half of
* this file for an example of more graceful error recovery.
*/
jselerror(&e_methods); /* select std error/trace message routines */
/* Here we use the standard memory manager provided with the JPEG code.
* In some cases you might want to replace the memory manager, or at
* least the system-dependent part of it, with your own code.
*/
jselmemmgr(&e_methods); /* select std memory allocation routines */
/* If the compressor requires full-image buffers (for entropy-coding
* optimization or a noninterleaved JPEG file), it will create temporary
* files for anything that doesn't fit within the maximum-memory setting.
* (Note that temp files are NOT needed if you use the default parameters.)
* You can change the default maximum-memory setting by changing
* e_methods.max_memory_to_use after jselmemmgr returns.
* On some systems you may also need to set up a signal handler to
* ensure that temporary files are deleted if the program is interrupted.
* (This is most important if you are on MS-DOS and use the jmemdos.c
* memory manager back end; it will try to grab extended memory for
* temp files, and that space will NOT be freed automatically.)
* See jcmain.c or jdmain.c for an example signal handler.
*/
/* Here, set up pointers to your own routines for input data handling
* and post-init parameter selection.
*/
c_methods.input_init = input_init;
c_methods.get_input_row = get_input_row;
c_methods.input_term = input_term;
c_methods.c_ui_method_selection = c_ui_method_selection;
/* Set up default JPEG parameters in the cinfo data structure. */
j_c_defaults(&cinfo, 75, FALSE);
/* Note: 75 is the recommended default quality level; you may instead pass
* a user-specified quality level. Be aware that values below 25 will cause
* non-baseline JPEG files to be created (and a warning message to that
* effect to be emitted on stderr). This won't bother our decoder, but some
* commercial JPEG implementations may choke on non-baseline JPEG files.
* If you want to force baseline compatibility, pass TRUE instead of FALSE.
* (If non-baseline files are fine, but you could do without that warning
* message, set e_methods.trace_level to -1.)
*/
/* At this point you can modify the default parameters set by j_c_defaults
* as needed. For a minimal implementation, you shouldn't need to change
* anything. See jcmain.c for some examples of what you might change.
*/
/* Select the input and output files.
* Note that cinfo.input_file is only used if your input reading routines
* use it; otherwise, you can just make it NULL.
* VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
* requires it in order to write binary files.
*/
cinfo.input_file = NULL; /* if no actual input file involved */
if ((cinfo.output_file = fopen(filename, "wb")) == NULL) {
fprintf(stderr, "can't open %s\n", filename);
exit(1);
}
/* Here we go! */
jpeg_compress(&cinfo);
/* That's it, son. Nothin' else to do, except close files. */
/* Here we assume only the output file need be closed. */
fclose(cinfo.output_file);
/* Note: if you want to compress more than one image, we recommend you
* repeat this whole routine. You MUST repeat the j_c_defaults()/alter
* parameters/jpeg_compress() sequence, as some data structures allocated
* in j_c_defaults are freed upon exit from jpeg_compress.
*/
}
int main(int argc, char **argv) {
int err;
int myrank, numprocs;
double inicio, fim;
FILE * inputFiles[argc - 1];
char **arquivos[argc - 1];
char nomeArquivos[30][256];
char nomeArquivosJPG[30][256];
char nomeArquivosRAW[30][256];
char nomeArquivosCINZA[30][256];
if (argc != 2) {
printf("Número de Parâmetros incorreto. Use: mpirun -np <QTD_PROCESSOS> ./build/jpeg2raw <QTD_IMAGENS>\n");
err = -1;
goto error;
}
int QTD_IMAGENS = atoi(argv[1]);
//armazena a quantidade de imagens ainda a serem processadas
int imagensRestantes = QTD_IMAGENS;
int imagensProcessadas = 0;
int controle;
int acabou = 0; // [0=false,1=true]
printf("ARGS%d", argc);
MPI_Status status;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
inicio = MPI_Wtime();
int z;
char str1[40], str2[10], strJPG[40], strRAW[40], strCINZA[40];
controle = numprocs;
if ((numprocs - 1) > QTD_IMAGENS) {
printf("Bah, você está disperdiçando recursos...\n");
controle = QTD_IMAGENS;
}
//Armazena o nome das Imagens a serem processadas
for (z = 1; z <= QTD_IMAGENS; z++) {
strcpy(str1, "images/montage");
sprintf(str2, "%d", z);
strcat(str1, str2);
//printf("[str]%s\n", str1);
strncpy(strJPG, str1, sizeof (str1));
strncpy(strRAW, str1, sizeof (str1));
strncpy(strCINZA, str1, sizeof (str1));
strcpy(nomeArquivos[z], str1);
strcpy(nomeArquivosJPG[z], strcat(strJPG, ".jpg"));
strcpy(nomeArquivosRAW[z], strcat(strRAW, ".raw"));
strcpy(nomeArquivosCINZA[z], strcat(strCINZA, "cinza.jpg"));
}
if (numprocs > 1) {
if (myrank == MESTRE) {
printf("################################################### \n");
printf("Número de Processos: %d \n", numprocs);
printf("Imagens a serem processadas: \n");
for (z = 1; z <= QTD_IMAGENS; z++) {
printf("%s\n", nomeArquivos[z]);
}
printf("################################################### \n");
//Envia para os primeiros processos
int tag = 0;
int x;
for (x = 1; x < controle; x++) {
MPI_Send(&x, 1, MPI_INT, x, tag, MPI_COMM_WORLD); //tamanho do array
imagensRestantes--;
//printf("Imagens Restantes: %d\n", imagensRestantes);
}
int destino;
int retorno;
int proxima = controle;
while (imagensRestantes != 0) {
MPI_Recv(&retorno, 1, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
imagensProcessadas++;
destino = status.MPI_SOURCE;
MPI_Send(&proxima, 1, MPI_INT, status.MPI_SOURCE, tag, MPI_COMM_WORLD); //tamanho do array
proxima++;
imagensRestantes--;
}
//recebe
int recebido = 0;
for (x = 1; x < controle; x++) {
MPI_Recv(&recebido, 1, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
imagensProcessadas++;
//envia código para finalizar os escravos (-1)
int dados = -1;
MPI_Send(&dados, 1, MPI_INT, status.MPI_SOURCE, tag, MPI_COMM_WORLD); //finalizacao
}
fim = MPI_Wtime();
printf("TEMPO PARALELO[%f] - Imagens Processadas[%d].\n", fim - inicio, imagensProcessadas);
} else {
while (acabou != 1) {
int posicao;
// int *arrayReceiving;
MPI_Recv(&posicao, 1, MPI_INT, 0, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
if (posicao == -1) {
acabou = 1;
} else {
printf("\n[%d]Processando a Imagem %s\n", myrank, nomeArquivosJPG[posicao]);
struct raw_img raw_img;
err = 0;
FILE *jpeg_file;
struct jpeg_decompress_struct jdec;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1];
float r;
float g;
float b;
int i;
int j;
j = 0;
/**
* abre um arquivo JPEG no espaço de cores RGB e extrai a luminância
* (imagem em tons de cinza), que é gravada em um arquivo especificado pelo usuário.
*/
const char *file = argv[1];
struct raw_img *raw = &raw_img;
//err = jpeg_decompress(argv[1], &raw_img, myrank, numprocs);
//carrega o arquivo de imagem jpeg
jpeg_file = fopen(nomeArquivosJPG[posicao], "rb");
if (jpeg_file == NULL) {
printf("Error opening file %s\n!", nomeArquivosJPG[posicao]);
err = -1;
goto error;
}
jdec.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&jdec);
jpeg_stdio_src(&jdec, jpeg_file);
jpeg_read_header(&jdec, TRUE);
raw->width = jdec.image_width;
raw->height = jdec.image_height;
raw->num_comp = jdec.num_components;
if (raw->num_comp != 3) {
printf("Cannot convert a jpeg file with %d componentes per "
"pixel\n", raw->num_comp);
err = -1;
goto error;
}
//INFORMAÇÕES DA IMAGEM
printf("JPEG File Information:\n");
printf("Resolução: %d x %d pixels\n", raw->width, raw->height);
//printf("\tColor components per pixel: %d\n", raw->num_comp);
jpeg_start_decompress(&jdec);
raw->img = (uint8_t *) malloc(raw->width * raw->height);
row_pointer[0] = (unsigned char *) malloc(raw->width * raw->num_comp);
while (jdec.output_scanline < jdec.image_height) {
jpeg_read_scanlines(&jdec, row_pointer, 1);
for (i = 0; i < raw->width * raw->num_comp; i += 3) {
r = (float) row_pointer[0][i];
g = (float) row_pointer[0][i + 1];
b = (float) row_pointer[0][i + 2];
/* here convert to grayscale */
raw->img[j] = (uint8_t)
(0.2126 * r + 0.7152 * g + 0.0722 * b);
j++;
}
}
jpeg_finish_decompress(&jdec);
jpeg_destroy_decompress(&jdec);
free(row_pointer[0]);
fclose(jpeg_file);
if (err == -1)
goto error;
// save_raw_image(argv[2], &raw_img);
save_raw_image(nomeArquivosRAW[posicao], &raw_img);
free(raw_img.img);
//Convere o RAW para imagem em tons de cinza
//SERIA o SEGUNDO COMANDO QUE É EXECUTADO
struct raw_img2 raw_img2;
err = 0;
raw_img2.width = raw->width;
raw_img2.height = raw->height;
// printf("DEBUG2 widht[%d] height[%d]\n", raw_img2.width, raw_img2.height);
// err = open_raw_image(argv[1], &raw_img);
//open_raw_image(const char *file, struct raw_img *raw)
const char *file2 = nomeArquivosRAW[posicao];
struct raw_img2 *raw2 = &raw_img2;
FILE *raw_file;
size_t read;
size_t size;
// raw_file = fopen(file2, "r");
raw_file = fopen(file2, "r");
if (raw_file == NULL) {
printf("Could not open '%s' file\n", file2);
err = -1;
goto error;
}
// printf("Abriu arquivo RAW\n");
size = raw2->width * raw2->height;
raw2->img = (uint8_t *) malloc(size * sizeof (uint8_t));
if (raw2->img == NULL) {
err = -2;
goto error;
}
read = fread((void *) raw2->img, 1, size, raw_file);
if (read != size)
printf("Only %lu/%lu bytes were read\n", read, size);
fclose(raw_file);
if (err == -1)
goto error;
if (err == -2)
goto error;
jpeg_compress(nomeArquivosCINZA[posicao], &raw_img2);
MPI_Send(&err, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
}
}
} else { //FAZ SEQUENCIAL
for (z = 1; z <= QTD_IMAGENS; z++) {
int posicao = z;
struct raw_img raw_img;
err = 0;
FILE *jpeg_file;
struct jpeg_decompress_struct jdec;
struct jpeg_error_mgr jerr;
JSAMPROW row_pointer[1];
float r;
float g;
float b;
int i;
int j;
err = 0;
j = 0;
/**
* abre um arquivo JPEG no espaço de cores RGB e extrai a luminância
* (imagem em tons de cinza), que é gravada em um arquivo especificado pelo usuário.
*/
const char *file = argv[1];
struct raw_img *raw = &raw_img;
//err = jpeg_decompress(argv[1], &raw_img, myrank, numprocs);
//carrega o arquivo de imagem jpeg
jpeg_file = fopen(nomeArquivosJPG[posicao], "rb");
// jpeg_file = fopen(arquivos[1], "rb");
// printf("%p\n",jpeg_file);
// printf("%s\n",jpeg_file);
if (jpeg_file == NULL) {
printf("Error opening file %s\n!", nomeArquivosJPG[posicao]);
err = -1;
goto error;
}
jdec.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&jdec);
jpeg_stdio_src(&jdec, jpeg_file);
jpeg_read_header(&jdec, TRUE);
raw->width = jdec.image_width;
raw->height = jdec.image_height;
raw->num_comp = jdec.num_components;
printf("[DEBUG] WIDTH[%d] HEIGHT[%d] COMP[%d]\n", jdec.image_width, jdec.image_height, jdec.num_components);
printf("[DEBUG] WIDTH[%d] HEIGHT[%d] COMP[%d]\n", raw->width, raw->height, raw->num_comp);
if (raw->num_comp != 3) {
printf("Cannot convert a jpeg file with %d componentes per "
"pixel\n", raw->num_comp);
err = -1;
goto error;
}
// int altura = raw->height;
// int partes = raw->height/(numprocs-1); //desconta 1 por causa do mestre
// int resto = raw->height%(numprocs-1); //desconta 1 por causa do mestre
// printf("Altura %u \n", altura);
if (myrank == MESTRE) {
// printf("raw->height %.f \n",raw->height/numprocs);
// printf("Altura %u \n", altura);
// printf("Processos %d Divisão %d \n", numprocs, partes);
// printf("Resto %u \n", resto);
//INFORMAÇÕES DA IMAGEM
printf("JPEG File Information:\n");
printf("\tResolution: %d x %d pixels\n", raw->width, raw->height);
printf("\tColor components per pixel: %d\n", raw->num_comp);
} else {
// printf("Sou o processo[%d] e vou calculdar de [%d - %d]\n", myrank, ((myrank-1)*partes), (myrank*partes));
}
jpeg_start_decompress(&jdec);
raw->img = (uint8_t *) malloc(raw->width * raw->height);
row_pointer[0] = (unsigned char *) malloc(raw->width * raw->num_comp);
printf("\t raw->width * raw->num_comp: %d\n", raw->width * raw->num_comp);
while (jdec.output_scanline < jdec.image_height) {
jpeg_read_scanlines(&jdec, row_pointer, 1);
// #pragma omp parallel for
// #pragma omp for schedule(static) ordered
// #pragma omp parallel
// {
// #pragma omp for schedule(static) ordered
// #pragma omp for ordered private(i,j)
for (i = 0; i < raw->width * raw->num_comp; i += 3) {
r = (float) row_pointer[0][i];
g = (float) row_pointer[0][i + 1];
b = (float) row_pointer[0][i + 2];
/* here convert to grayscale */
// #pragma omp ordered
// #pragma omp critical
// {
raw->img[j] = (uint8_t)
(0.2126 * r + 0.7152 * g + 0.0722 * b);
j++;
// }
// }
}
}
printf("J %d \n", j);
jpeg_finish_decompress(&jdec);
jpeg_destroy_decompress(&jdec);
free(row_pointer[0]);
fclose(jpeg_file);
if (err == -1)
goto error;
// save_raw_image(argv[2], &raw_img);
save_raw_image(nomeArquivosRAW[posicao], &raw_img);
free(raw_img.img);
//Convere o RAW para imagem em tons de cinza
//SERIA o SEGUNDO COMANDO QUE É EXECUTADO
struct raw_img2 raw_img2;
err = 0;
// if (argc != 5) {
// printf("Usage: %s <raw_file> <jpeg> <width> <height>\n",argv[0]);
// err = -1;
// goto error;
// }
raw_img2.width = raw->width;
raw_img2.height = raw->height;
printf("DEBUG2 widht[%d] height[%d]\n", raw_img2.width, raw_img2.height);
// err = open_raw_image(argv[1], &raw_img);
//open_raw_image(const char *file, struct raw_img *raw)
const char *file2 = nomeArquivosRAW[posicao];
struct raw_img2 *raw2 = &raw_img2;
FILE *raw_file;
size_t read;
size_t size;
// raw_file = fopen(file2, "r");
raw_file = fopen(file2, "r");
if (raw_file == NULL) {
printf("Could not open '%s' file\n", file2);
err = -1;
goto error;
}
printf("Abriu arquivo RAW\n");
size = raw2->width * raw2->height;
raw2->img = (uint8_t *) malloc(size * sizeof (uint8_t));
if (raw2->img == NULL) {
err = -2;
goto error;
}
read = fread((void *) raw2->img, 1, size, raw_file);
if (read != size)
printf("Only %lu/%lu bytes were read\n", read, size);
fclose(raw_file);
if (err == -1)
goto error;
if (err == -2)
goto error;
jpeg_compress(nomeArquivosCINZA[posicao], &raw_img2);
}
fim = MPI_Wtime();
printf("TEMPO SEQ[%f].\n", fim - inicio);
}
// fim = MPI_Wtime();
MPI_Finalize();
return 0;
//cleanup:
// free(raw_img2.img);
error:
return err;
}
