svn merge ^/trunk/blender -r46380:46390
[blender.git] / source / blender / avi / intern / mjpeg.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  *
27  */
28
29 /** \file blender/avi/intern/mjpeg.c
30  *  \ingroup avi
31  *
32  * This is external code. Converts between avi and mpeg/jpeg.
33  */
34
35
36 #include "AVI_avi.h"
37 #include <stdlib.h>
38 #include <string.h>
39 #include "jpeglib.h"
40 #include "jerror.h"
41 #include "MEM_guardedalloc.h"
42
43 #include "mjpeg.h"
44
45 #define PADUP(num, amt) ((num+(amt-1))&~(amt-1))
46
47 static void jpegmemdestmgr_build (j_compress_ptr cinfo, unsigned char *buffer, int bufsize);
48 static void jpegmemsrcmgr_build (j_decompress_ptr dinfo, unsigned char *buffer, int bufsize);
49
50 static int numbytes;
51
52 static void add_huff_table (j_decompress_ptr dinfo, JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val)
53 {
54         if (*htblptr == NULL)
55                 *htblptr = jpeg_alloc_huff_table((j_common_ptr) dinfo);
56
57         memcpy((*htblptr)->bits, bits, sizeof((*htblptr)->bits));
58         memcpy((*htblptr)->huffval, val, sizeof((*htblptr)->huffval));
59
60         /* Initialize sent_table FALSE so table will be written to JPEG file. */
61         (*htblptr)->sent_table = FALSE;
62 }
63
64 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
65 /* IMPORTANT: these are only valid for 8-bit data precision! */
66
67 static void std_huff_tables (j_decompress_ptr dinfo)
68 {
69         static const UINT8 bits_dc_luminance[17] =
70         { /* 0-base */
71                 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0       };
72         static const UINT8 val_dc_luminance[] =
73         { 
74                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11    };
75
76         static const UINT8 bits_dc_chrominance[17] =
77         { /* 0-base */
78                 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0       };
79         static const UINT8 val_dc_chrominance[] =
80         { 
81                 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11    };
82
83         static const UINT8 bits_ac_luminance[17] =
84         { /* 0-base */
85                 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d    };
86         static const UINT8 val_ac_luminance[] =
87         { 
88                 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
89                 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
90                 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
91                 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
92                 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
93                 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
94                 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
95                 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
96                 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
97                 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
98                 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
99                 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
100                 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
101                 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
102                 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
103                 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
104                 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
105                 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
106                 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
107                 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
108                 0xf9, 0xfa      };
109         static const UINT8 bits_ac_chrominance[17] =
110         { /* 0-base */
111                 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77    };
112         static const UINT8 val_ac_chrominance[] =
113         { 
114                 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
115                 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
116                 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
117                 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
118                 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
119                 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
120                 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
121                 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
122                 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
123                 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
124                 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
125                 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
126                 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
127                 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
128                 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
129                 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
130                 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
131                 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
132                 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
133                 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
134                 0xf9, 0xfa      };
135
136         add_huff_table(dinfo, &dinfo->dc_huff_tbl_ptrs[0],
137                 bits_dc_luminance, val_dc_luminance);
138         add_huff_table(dinfo, &dinfo->ac_huff_tbl_ptrs[0],
139                 bits_ac_luminance, val_ac_luminance);
140         add_huff_table(dinfo, &dinfo->dc_huff_tbl_ptrs[1],
141                 bits_dc_chrominance, val_dc_chrominance);
142         add_huff_table(dinfo, &dinfo->ac_huff_tbl_ptrs[1],
143                 bits_ac_chrominance, val_ac_chrominance);
144 }
145
146 static int Decode_JPEG(unsigned char *inBuffer, unsigned char *outBuffer, unsigned int width, unsigned int height, int bufsize)
147 {
148         int rowstride;
149         unsigned int y;
150         struct jpeg_decompress_struct dinfo;
151         struct jpeg_error_mgr jerr;
152         
153         (void)width; /* unused */
154
155         numbytes= 0;
156
157         dinfo.err = jpeg_std_error(&jerr);
158         jpeg_create_decompress(&dinfo);
159         jpegmemsrcmgr_build(&dinfo, inBuffer, bufsize);
160         jpeg_read_header(&dinfo, TRUE);
161         if (dinfo.dc_huff_tbl_ptrs[0] == NULL) {
162                 std_huff_tables(&dinfo);
163         }
164         dinfo.out_color_space = JCS_RGB;
165         dinfo.dct_method = JDCT_IFAST;
166
167         jpeg_start_decompress(&dinfo);
168
169         rowstride= dinfo.output_width*dinfo.output_components;
170         for (y= 0; y<dinfo.output_height; y++) {
171                 jpeg_read_scanlines(&dinfo, (JSAMPARRAY) &outBuffer, 1);
172                 outBuffer += rowstride;
173         }
174         jpeg_finish_decompress(&dinfo);
175
176         if (dinfo.output_height >= height) return 0;
177         
178         inBuffer+= numbytes;
179         jpegmemsrcmgr_build(&dinfo, inBuffer, bufsize-numbytes);
180
181         numbytes= 0;
182         jpeg_read_header(&dinfo, TRUE);
183         if (dinfo.dc_huff_tbl_ptrs[0] == NULL) {
184                 std_huff_tables(&dinfo);
185         }
186
187         jpeg_start_decompress(&dinfo);
188         rowstride= dinfo.output_width*dinfo.output_components;
189         for (y= 0; y<dinfo.output_height; y++) {
190                 jpeg_read_scanlines(&dinfo, (JSAMPARRAY) &outBuffer, 1);
191                 outBuffer += rowstride;
192         }
193         jpeg_finish_decompress(&dinfo);
194         jpeg_destroy_decompress(&dinfo);
195         
196         return 1;
197 }
198
199 static void Compress_JPEG(int quality, unsigned char *outbuffer, unsigned char *inBuffer, int width, int height, int bufsize)
200 {
201         int i, rowstride;
202         unsigned int y;
203         struct jpeg_compress_struct cinfo;
204         struct jpeg_error_mgr jerr;
205         unsigned char marker[60];
206
207         cinfo.err = jpeg_std_error(&jerr);
208         jpeg_create_compress(&cinfo);
209         jpegmemdestmgr_build(&cinfo, outbuffer, bufsize);
210
211         cinfo.image_width = width;
212         cinfo.image_height = height;
213         cinfo.input_components = 3;
214         cinfo.in_color_space = JCS_RGB;
215
216         jpeg_set_defaults(&cinfo);
217         jpeg_set_colorspace (&cinfo, JCS_YCbCr);
218                 
219         jpeg_set_quality (&cinfo, quality, TRUE);
220
221         cinfo.dc_huff_tbl_ptrs[0]->sent_table = TRUE;
222         cinfo.dc_huff_tbl_ptrs[1]->sent_table = TRUE;
223         cinfo.ac_huff_tbl_ptrs[0]->sent_table = TRUE;
224         cinfo.ac_huff_tbl_ptrs[1]->sent_table = TRUE;
225
226         cinfo.comp_info[0].component_id = 0;
227         cinfo.comp_info[0].v_samp_factor = 1;
228         cinfo.comp_info[1].component_id = 1;
229         cinfo.comp_info[2].component_id = 2;
230
231         cinfo.write_JFIF_header = FALSE;
232
233         jpeg_start_compress(&cinfo, FALSE);
234
235         i=0;
236         marker[i++] = 'A';
237         marker[i++] = 'V';
238         marker[i++] = 'I';
239         marker[i++] = '1';
240         marker[i++] = 0;
241         while (i<60)
242                 marker[i++] = 32;
243
244         jpeg_write_marker (&cinfo, JPEG_APP0, marker, 60);
245
246         i=0;
247         while (i<60)
248                 marker[i++] = 0;
249
250         jpeg_write_marker (&cinfo, JPEG_COM, marker, 60);
251
252         rowstride= cinfo.image_width*cinfo.input_components;
253         for (y = 0; y < cinfo.image_height; y++) {
254                 jpeg_write_scanlines(&cinfo, (JSAMPARRAY) &inBuffer, 1);
255                 inBuffer += rowstride;
256         }
257         jpeg_finish_compress(&cinfo);
258         jpeg_destroy_compress(&cinfo);
259 }
260
261 static void interlace(unsigned char *to, unsigned char *from, int width, int height)
262 {
263         int i, rowstride= width*3;
264         
265         for (i=0; i<height; i++) {
266                 if (i&1)
267                         memcpy (&to[i*rowstride], &from[(i/2 + height/2)*rowstride], rowstride);
268                 else 
269                         memcpy (&to[i*rowstride], &from[(i/2)*rowstride], rowstride);
270         }
271 }
272
273 static void deinterlace(int odd, unsigned char *to, unsigned char *from, int width, int height)
274 {
275         int i, rowstride= width*3;
276         
277         for (i=0; i<height; i++) {
278                 if ((i&1)==odd)
279                         memcpy (&to[(i/2 + height/2)*rowstride], &from[i*rowstride], rowstride);
280                 else 
281                         memcpy (&to[(i/2)*rowstride], &from[i*rowstride], rowstride);
282         }
283 }
284
285 static int check_and_decode_jpeg(unsigned char *inbuf, unsigned char *outbuf, int width, int height, int bufsize)
286 {
287                 /* JPEG's are always multiples of 16, extra is cropped out AVI's */     
288         if ((width&0xF) || (height&0xF)) {
289                 int i, rrowstride, jrowstride;
290                 int jwidth= PADUP(width, 16);
291                 int jheight= PADUP(height, 16);
292                 unsigned char *tmpbuf= MEM_mallocN(jwidth*jheight*3, "avi.check_and_decode_jpeg");
293                 int ret= Decode_JPEG(inbuf, tmpbuf, jwidth, jheight, bufsize);
294                 
295                         /* crop the tmpbuf into the real buffer */
296                 rrowstride= width*3;
297                 jrowstride= jwidth*3;
298                 for (i=0; i<height; i++)
299                         memcpy(&outbuf[i*rrowstride], &tmpbuf[i*jrowstride], rrowstride);
300                 MEM_freeN(tmpbuf);
301                 
302                 return ret;
303         }
304         else {
305                 return Decode_JPEG(inbuf, outbuf, width, height, bufsize);
306         }
307 }
308
309 static void check_and_compress_jpeg(int quality, unsigned char *outbuf, unsigned char *inbuf, int width, int height, int bufsize)
310 {
311                 /* JPEG's are always multiples of 16, extra is ignored in AVI's */      
312         if ((width&0xF) || (height&0xF)) {
313                 int i, rrowstride, jrowstride;
314                 int jwidth= PADUP(width, 16);
315                 int jheight= PADUP(height, 16);
316                 unsigned char *tmpbuf= MEM_mallocN(jwidth*jheight*3, "avi.check_and_compress_jpeg");
317                 
318                         /* resize the realbuf into the tmpbuf */
319                 rrowstride= width*3;
320                 jrowstride= jwidth*3;
321                 for (i=0; i<jheight; i++) {
322                         if (i<height)
323                                 memcpy(&tmpbuf[i*jrowstride], &inbuf[i*rrowstride], rrowstride);
324                         else
325                                 memset(&tmpbuf[i*jrowstride], 0, rrowstride);
326                         memset(&tmpbuf[i*jrowstride+rrowstride], 0, jrowstride-rrowstride);
327                 }
328
329                 Compress_JPEG(quality, outbuf, tmpbuf, jwidth, jheight, bufsize);
330
331                 MEM_freeN(tmpbuf);
332         }
333         else {
334                 Compress_JPEG(quality, outbuf, inbuf, width, height, bufsize);
335         }
336 }
337
338 void *avi_converter_from_mjpeg (AviMovie *movie, int stream, unsigned char *buffer, int *size)
339 {
340         int deint;
341         unsigned char *buf;
342
343         (void)stream; /* unused */
344
345         buf= MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_from_mjpeg 1");
346
347         deint= check_and_decode_jpeg(buffer, buf, movie->header->Width, movie->header->Height, *size);
348         
349         MEM_freeN(buffer);
350         
351         if (deint) {
352                 buffer = MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_from_mjpeg 2");
353                 interlace (buffer, buf, movie->header->Width, movie->header->Height);
354                 MEM_freeN (buf);
355         
356                 buf= buffer;
357         }
358                 
359         return buf;
360 }
361
362 void *avi_converter_to_mjpeg (AviMovie *movie, int stream, unsigned char *buffer, int *size)
363 {
364         unsigned char *buf;
365         int bufsize= *size;
366         
367         numbytes = 0;
368         *size= 0;
369
370         buf = MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_to_mjpeg 1");   
371         if (!movie->interlace) {
372                 check_and_compress_jpeg(movie->streams[stream].sh.Quality/100, buf, buffer,  movie->header->Width, movie->header->Height, bufsize);
373         }
374         else {
375                 deinterlace (movie->odd_fields, buf, buffer, movie->header->Width, movie->header->Height);
376                 MEM_freeN (buffer);
377         
378                 buffer= buf;
379                 buf= MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_to_mjpeg 2");
380         
381                 check_and_compress_jpeg(movie->streams[stream].sh.Quality/100, buf, buffer,  movie->header->Width, movie->header->Height/2, bufsize/2);
382                 *size+= numbytes;
383                 numbytes=0;
384                 check_and_compress_jpeg(movie->streams[stream].sh.Quality/100, buf+*size, buffer+(movie->header->Height/2)*movie->header->Width*3,  movie->header->Width, movie->header->Height/2, bufsize/2);
385         }
386         *size += numbytes;      
387
388         MEM_freeN (buffer);
389         return buf;
390 }
391
392
393 /* Compression from memory */
394
395 static void jpegmemdestmgr_init_destination(j_compress_ptr cinfo)
396 {
397         (void)cinfo; /* unused */
398 }
399
400 static boolean jpegmemdestmgr_empty_output_buffer(j_compress_ptr cinfo)
401 {
402         (void)cinfo; /* unused */
403         return TRUE;
404 }
405
406 static void jpegmemdestmgr_term_destination(j_compress_ptr cinfo)
407 {
408         numbytes-= cinfo->dest->free_in_buffer;
409
410         MEM_freeN(cinfo->dest);
411 }
412
413 static void jpegmemdestmgr_build(j_compress_ptr cinfo, unsigned char *buffer, int bufsize)
414 {
415         cinfo->dest= MEM_mallocN(sizeof(*(cinfo->dest)), "avi.jpegmemdestmgr_build");
416         
417         cinfo->dest->init_destination= jpegmemdestmgr_init_destination;
418         cinfo->dest->empty_output_buffer= jpegmemdestmgr_empty_output_buffer;
419         cinfo->dest->term_destination= jpegmemdestmgr_term_destination;
420
421         cinfo->dest->next_output_byte= buffer;
422         cinfo->dest->free_in_buffer= bufsize;
423         
424         numbytes= bufsize;
425 }
426
427 /* Decompression from memory */
428
429 static void jpegmemsrcmgr_init_source(j_decompress_ptr dinfo)
430 {
431         (void)dinfo;
432 }
433
434 static boolean jpegmemsrcmgr_fill_input_buffer(j_decompress_ptr dinfo)
435 {
436         unsigned char *buf= (unsigned char*) dinfo->src->next_input_byte-2;
437         
438                 /* if we get called, must have run out of data */
439         WARNMS(dinfo, JWRN_JPEG_EOF);
440         
441         buf[0]= (JOCTET) 0xFF;
442         buf[1]= (JOCTET) JPEG_EOI;
443         
444         dinfo->src->next_input_byte= buf;
445         dinfo->src->bytes_in_buffer= 2;
446         
447         return TRUE;
448 }
449
450 static void jpegmemsrcmgr_skip_input_data(j_decompress_ptr dinfo, long skipcnt)
451 {
452         if (dinfo->src->bytes_in_buffer<skipcnt)
453                 skipcnt= dinfo->src->bytes_in_buffer;
454
455         dinfo->src->next_input_byte+= skipcnt;
456         dinfo->src->bytes_in_buffer-= skipcnt;
457 }
458
459 static void jpegmemsrcmgr_term_source(j_decompress_ptr dinfo)
460 {
461         numbytes-= dinfo->src->bytes_in_buffer;
462         
463         MEM_freeN(dinfo->src);
464 }
465
466 static void jpegmemsrcmgr_build(j_decompress_ptr dinfo, unsigned char *buffer, int bufsize)
467 {
468         dinfo->src= MEM_mallocN(sizeof(*(dinfo->src)), "avi.jpegmemsrcmgr_build");
469         
470         dinfo->src->init_source= jpegmemsrcmgr_init_source;
471         dinfo->src->fill_input_buffer= jpegmemsrcmgr_fill_input_buffer;
472         dinfo->src->skip_input_data= jpegmemsrcmgr_skip_input_data;
473         dinfo->src->resync_to_restart= jpeg_resync_to_restart;
474         dinfo->src->term_source= jpegmemsrcmgr_term_source;
475         
476         dinfo->src->bytes_in_buffer= bufsize;
477         dinfo->src->next_input_byte= buffer;
478
479         numbytes= bufsize;
480 }