← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to source/blender/imbuf/intern/jpeg.c

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2005-11-06 12:40:03 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051106124003-3pgs7tcg5rox96xg
Tags: 2.37a-1.1
http://bugs.debian.org/333958
* Non-maintainer upload.
* Split out parts of 01_SConstruct_debian.dpatch again: root_build_dir
  really needs to get adjusted before the clean target runs - closes: #333958,
  see #288882 for reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/imbuf/intern/jpeg.c
29
29
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
30
30
 * jpeg.c
31
31
 *
32
 
 * $Id: jpeg.c,v 1.5 2003/12/04 18:18:05 sirdude Exp $
 
32
 * $Id: jpeg.c,v 1.9 2005/04/02 15:36:56 zuster Exp $
33
33
 */
34
34
 
35
35
 
44
44
#include "IMB_jpeg.h"
45
45
#include "jpeglib.h" 
46
46
 
47
 
#ifdef HAVE_CONFIG_H
48
 
#include <config.h>
49
 
#endif
50
 
 
51
47
/* the types are from the jpeg lib */
52
48
static void jpeg_error (j_common_ptr cinfo);
53
49
static void init_source(j_decompress_ptr cinfo);
59
55
static ImBuf * ibJpegImageFromCinfo(struct jpeg_decompress_struct * cinfo, int flags);
60
56
 
61
57
 
62
 
/* strncasecmp hack */
63
 
#ifdef WIN32
64
 
#define strncasecmp(a, b, n) strncmp(a, b, n)
65
 
#endif
66
 
 
67
58
/*
68
59
 * In principle there are 4 jpeg formats.
69
60
 * 
93
84
}
94
85
 
95
86
//----------------------------------------------------------
96
 
//            INPUT HANDLER FROM MEMORY
 
87
//      INPUT HANDLER FROM MEMORY
97
88
//----------------------------------------------------------
98
89
 
99
90
typedef struct {
100
 
        unsigned char        *buffer;
101
 
        int                  filled;
 
91
        unsigned char   *buffer;
 
92
        int             filled;
102
93
} buffer_struct;
103
94
 
104
95
typedef struct {
105
 
        struct jpeg_source_mgr pub;   /* public fields */
 
96
        struct jpeg_source_mgr pub;     /* public fields */
106
97
 
107
98
        unsigned char   *buffer;
108
99
        int                             size;
150
141
        my_src_ptr src;
151
142
 
152
143
        if (cinfo->src == NULL)
153
 
        {    /* first time for this JPEG object? */
 
144
        {       /* first time for this JPEG object? */
154
145
                cinfo->src = (struct jpeg_source_mgr *)(*cinfo->mem->alloc_small)
155
 
                                        ((j_common_ptr) cinfo, JPOOL_PERMANENT,
156
 
                                         sizeof(my_source_mgr));
 
146
                        ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(my_source_mgr));
157
147
        }
158
148
 
159
149
        src = (my_src_ptr) cinfo->src;
160
 
        src->pub.init_source           = init_source;
161
 
        src->pub.fill_input_buffer     = fill_input_buffer;
162
 
        src->pub.skip_input_data       = skip_input_data;
163
 
        src->pub.resync_to_restart     = jpeg_resync_to_restart; 
164
 
        src->pub.term_source           = term_source;
 
150
        src->pub.init_source            = init_source;
 
151
        src->pub.fill_input_buffer      = fill_input_buffer;
 
152
        src->pub.skip_input_data        = skip_input_data;
 
153
        src->pub.resync_to_restart      = jpeg_resync_to_restart; 
 
154
        src->pub.term_source            = term_source;
165
155
 
166
 
        src->pub.bytes_in_buffer       = size;
167
 
        src->pub.next_input_byte       = buffer;
 
156
        src->pub.bytes_in_buffer        = size;
 
157
        src->pub.next_input_byte        = buffer;
168
158
 
169
159
        src->buffer = buffer;
170
160
        src->size = size;
171
161
}
172
162
 
173
163
 
174
 
#define MAKESTMT(stuff)            do { stuff } while (0)
 
164
#define MAKESTMT(stuff)         do { stuff } while (0)
175
165
 
176
166
#define INPUT_VARS(cinfo)  \
177
167
        struct jpeg_source_mgr * datasrc = (cinfo)->src;  \
194
184
 */
195
185
#define MAKE_BYTE_AVAIL(cinfo,action)  \
196
186
        if (bytes_in_buffer == 0) {  \
197
 
          if (! (*datasrc->fill_input_buffer) (cinfo))  \
198
 
            { action; }  \
199
 
          INPUT_RELOAD(cinfo);  \
 
187
                if (! (*datasrc->fill_input_buffer) (cinfo))  \
 
188
                        { action; }  \
 
189
                INPUT_RELOAD(cinfo);  \
200
190
        }  \
201
191
        bytes_in_buffer--
202
192
 
344
334
                
345
335
                jpeg_destroy((j_common_ptr) cinfo);
346
336
                ibuf->ftype = ibuf_ftype;
347
 
        }
 
337
        }
348
338
        
349
339
        return(ibuf);
350
 
}       
 
340
}
351
341
 
352
342
ImBuf * imb_ibJpegImageFromFilename (char * filename, int flags)
353
343
{
356
346
        FILE * infile;
357
347
        ImBuf * ibuf;
358
348
        
359
 
        if ((infile = fopen(filename, "rb")) == NULL) {
360
 
                /*fprintf(stderr, "can't open %s\n", filename);*/
361
 
                return 0;
362
 
        }
 
349
        if ((infile = fopen(filename, "rb")) == NULL) return 0;
363
350
 
364
351
        cinfo->err = jpeg_std_error(&jerr);
365
352
        jerr.error_exit = jpeg_error;
499
486
        struct jpeg_compress_struct _cinfo, *cinfo = &_cinfo;
500
487
        struct jpeg_error_mgr jerr;
501
488
 
502
 
        if ((outfile = fopen(name, "wb")) == NULL) return(-1);
 
489
        if ((outfile = fopen(name, "wb")) == NULL) return 0;
503
490
        jpeg_default_quality = 75;
504
491
 
505
492
        cinfo->err = jpeg_std_error(&jerr);
512
499
        fclose(outfile);
513
500
        jpeg_destroy_compress(cinfo);
514
501
 
515
 
        if (jpeg_failed) remove(name);
516
 
        return(jpeg_failed);
 
502
        if (jpeg_failed) {
 
503
                remove(name);
 
504
                return 0;
 
505
        }
 
506
        return 1;
517
507
}
518
508
 
519
509
 
523
513
        struct jpeg_compress_struct _cinfo, *cinfo = &_cinfo;
524
514
        struct jpeg_error_mgr jerr;
525
515
 
526
 
        if ((outfile = fopen(name, "wb")) == NULL) return(-1);
 
516
        if ((outfile = fopen(name, "wb")) == NULL) return 0;
527
517
        jpeg_default_quality = 90;
528
518
 
529
519
        cinfo->err = jpeg_std_error(&jerr);
542
532
        fclose(outfile);
543
533
        jpeg_destroy_compress(cinfo);
544
534
 
545
 
        if (jpeg_failed) remove(name);
546
 
        return(jpeg_failed);
 
535
        if (jpeg_failed) {
 
536
                remove(name);
 
537
                return 0;
 
538
        }
 
539
        return 1;
547
540
}
548
541
 
549
542
static int save_jstjpeg(char * name, struct ImBuf * ibuf)
550
543
{
551
544
        char fieldname[1024];
552
545
        struct ImBuf * tbuf;
553
 
        int oldy;
554
 
/*      extern rectcpy(); */
 
546
        int oldy, returnval;
555
547
 
556
548
        tbuf = IMB_allocImBuf(ibuf->x, ibuf->y / 2, 24, IB_rect, 0);
557
549
        tbuf->ftype = ibuf->ftype;
562
554
        ibuf->y /= 2;
563
555
 
564
556
        /* extra argument assumed to be 0 (nzc) */
565
 
/*      rectop(tbuf, ibuf, 0, 0, 0, 0, 32767, 32767, rectcpy); */
566
557
        IMB_rectop(tbuf, ibuf, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
567
558
        sprintf(fieldname, "%s.jf0", name);
568
559
 
569
 
        if (save_vidjpeg(fieldname, tbuf) == 0) {
570
 
        /* extra argument assumed to be 0 (nzc) */
571
 
/*              rectop(tbuf, ibuf, 0, 0, tbuf->x, 0, 32767, 32767, rectcpy); */
572
 
                IMB_rectop(tbuf, ibuf, 0, 0, tbuf->x, 0, 32767, 32767, IMB_rectcpy, 0);
 
560
        returnval = save_vidjpeg(fieldname, tbuf) ;
 
561
        if (returnval == 1) {
 
562
                /* extra argument assumed to be 0 (nzc) */
 
563
                IMB_rectop(tbuf, ibuf, 0, 0, tbuf->x, 0, 32767, 32767, 
 
564
                        IMB_rectcpy, 0);
573
565
                sprintf(fieldname, "%s.jf1", name);
574
 
                save_vidjpeg(fieldname, tbuf);
 
566
                returnval = save_vidjpeg(fieldname, tbuf);
575
567
        }
576
568
 
577
569
        ibuf->y = oldy;
578
570
        ibuf->x /= 2;
579
571
        IMB_freeImBuf(tbuf);
580
572
 
581
 
        /* no return value was given, assuming 0 */
582
 
        return 0;
 
573
        return returnval;
583
574
}
584
575
 
585
 
 
586
576
static int save_maxjpeg(char * name, struct ImBuf * ibuf)
587
577
{
588
578
        FILE * outfile;
589
579
        struct jpeg_compress_struct _cinfo, *cinfo = &_cinfo;
590
580
        struct jpeg_error_mgr jerr;
591
581
 
592
 
        if ((outfile = fopen(name, "wb")) == NULL) return(-1);
 
582
        if ((outfile = fopen(name, "wb")) == NULL) return 0;
593
583
        jpeg_default_quality = 100;
594
584
 
595
585
        cinfo->err = jpeg_std_error(&jerr);
608
598
        fclose(outfile);
609
599
        jpeg_destroy_compress(cinfo);
610
600
 
611
 
        if (jpeg_failed) remove(name);
612
 
        return(jpeg_failed);
 
601
        if (jpeg_failed) {
 
602
                remove(name);
 
603
                return 0;
 
604
        }
 
605
        return 1;
613
606
}
614
607
 
615
 
 
616
608
int imb_savejpeg(struct ImBuf * ibuf, char * name, int flags)
617
609
{
618
610