2.5
[blender-staging.git] / source / blender / avi / intern / mjpeg.c
1 /**
2  * mjpeg.c
3  *
4  * This is external code. Converts between avi and mpeg/jpeg.
5  *
6  * $Id$ 
7  *
8  * ***** BEGIN GPL LICENSE BLOCK *****
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  *
24  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
25  * All rights reserved.
26  *
27  * The Original Code is: all of this file.
28  *
29  * Contributor(s): none yet.
30  *
31  * ***** END GPL LICENSE BLOCK *****
32  *  */
33
34 #include "AVI_avi.h"
35 #include <stdlib.h>
36 #include <string.h>
37 #include "jpeglib.h"
38 #include "jerror.h"
39 #include "MEM_guardedalloc.h"
40
41 #include "mjpeg.h"
42
43 #ifdef HAVE_CONFIG_H
44 #include <config.h>
45 #endif
46
47 #define PADUP(num, amt) ((num+(amt-1))&~(amt-1))
48
49 static void jpegmemdestmgr_build (j_compress_ptr cinfo, unsigned char *buffer, int bufsize);
50 static void jpegmemsrcmgr_build (j_decompress_ptr dinfo, unsigned char *buffer, int bufsize);
51
52 static int numbytes;
53
54 static void add_huff_table (j_decompress_ptr dinfo, JHUFF_TBL **htblptr, const UINT8 *bits, const UINT8 *val) {
55         if (*htblptr == NULL)
56                 *htblptr = jpeg_alloc_huff_table((j_common_ptr) dinfo);
57
58         memcpy((*htblptr)->bits, bits, sizeof((*htblptr)->bits));
59         memcpy((*htblptr)->huffval, val, sizeof((*htblptr)->huffval));
60
61         /* Initialize sent_table FALSE so table will be written to JPEG file. */
62         (*htblptr)->sent_table = FALSE;
63 }
64
65 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
66 /* IMPORTANT: these are only valid for 8-bit data precision! */
67
68 static void std_huff_tables (j_decompress_ptr dinfo) {
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         int rowstride;
148         unsigned int y;
149         struct jpeg_decompress_struct dinfo;
150         struct jpeg_error_mgr jerr;
151
152         numbytes= 0;
153
154         dinfo.err = jpeg_std_error(&jerr);
155         jpeg_create_decompress(&dinfo);
156         jpegmemsrcmgr_build(&dinfo, inBuffer, bufsize);
157         jpeg_read_header(&dinfo, TRUE);
158         if (dinfo.dc_huff_tbl_ptrs[0] == NULL){
159                 std_huff_tables(&dinfo);
160         }
161         dinfo.out_color_space = JCS_RGB;
162         dinfo.dct_method = JDCT_IFAST;
163
164         jpeg_start_decompress(&dinfo);
165
166         rowstride= dinfo.output_width*dinfo.output_components;
167         for (y= 0; y<dinfo.output_height; y++) {
168                 jpeg_read_scanlines(&dinfo, (JSAMPARRAY) &outBuffer, 1);
169                 outBuffer += rowstride;
170         }
171         jpeg_finish_decompress(&dinfo);
172
173         if (dinfo.output_height >= height) return 0;
174         
175         inBuffer+= numbytes;
176         jpegmemsrcmgr_build(&dinfo, inBuffer, bufsize-numbytes);
177
178         numbytes= 0;
179         jpeg_read_header(&dinfo, TRUE);
180         if (dinfo.dc_huff_tbl_ptrs[0] == NULL){
181                 std_huff_tables(&dinfo);
182         }
183
184         jpeg_start_decompress(&dinfo);
185         rowstride= dinfo.output_width*dinfo.output_components;
186         for (y= 0; y<dinfo.output_height; y++){
187                 jpeg_read_scanlines(&dinfo, (JSAMPARRAY) &outBuffer, 1);
188                 outBuffer += rowstride;
189         }
190         jpeg_finish_decompress(&dinfo);
191         jpeg_destroy_decompress(&dinfo);
192         
193         return 1;
194 }
195
196 static void Compress_JPEG(int quality, unsigned char *outbuffer, unsigned char *inBuffer, int width, int height, int bufsize) {
197         int i, rowstride;
198         unsigned int y;
199         struct jpeg_compress_struct cinfo;
200         struct jpeg_error_mgr jerr;
201         unsigned char marker[60];
202
203         cinfo.err = jpeg_std_error(&jerr);
204         jpeg_create_compress(&cinfo);
205         jpegmemdestmgr_build(&cinfo, outbuffer, bufsize);
206
207         cinfo.image_width = width;
208         cinfo.image_height = height;
209         cinfo.input_components = 3;
210         cinfo.in_color_space = JCS_RGB;
211
212         jpeg_set_defaults(&cinfo);
213         jpeg_set_colorspace (&cinfo, JCS_YCbCr);
214                 
215         jpeg_set_quality (&cinfo, quality, TRUE);
216
217         cinfo.dc_huff_tbl_ptrs[0]->sent_table = TRUE;
218         cinfo.dc_huff_tbl_ptrs[1]->sent_table = TRUE;
219         cinfo.ac_huff_tbl_ptrs[0]->sent_table = TRUE;
220         cinfo.ac_huff_tbl_ptrs[1]->sent_table = TRUE;
221
222         cinfo.comp_info[0].component_id = 0;
223         cinfo.comp_info[0].v_samp_factor = 1;
224         cinfo.comp_info[1].component_id = 1;
225         cinfo.comp_info[2].component_id = 2;
226
227         cinfo.write_JFIF_header = FALSE;
228
229         jpeg_start_compress(&cinfo, FALSE);
230
231         i=0;
232         marker[i++] = 'A';
233         marker[i++] = 'V';
234         marker[i++] = 'I';
235         marker[i++] = '1';
236         marker[i++] = 0;
237         while (i<60)
238                 marker[i++] = 32;
239
240         jpeg_write_marker (&cinfo, JPEG_APP0, marker, 60);
241
242         i=0;
243         while (i<60)
244                 marker[i++] = 0;
245
246         jpeg_write_marker (&cinfo, JPEG_COM, marker, 60);
247
248         rowstride= cinfo.image_width*cinfo.input_components;
249         for (y = 0; y < cinfo.image_height; y++){
250                 jpeg_write_scanlines(&cinfo, (JSAMPARRAY) &inBuffer, 1);
251                 inBuffer += rowstride;
252         }
253         jpeg_finish_compress(&cinfo);
254         jpeg_destroy_compress(&cinfo);
255 }
256
257 static void interlace(unsigned char *to, unsigned char *from, int width, int height) {
258         int i, rowstride= width*3;
259         
260         for (i=0; i<height; i++) {
261                 if (i&1)
262                         memcpy (&to[i*rowstride], &from[(i/2 + height/2)*rowstride], rowstride);
263                 else 
264                         memcpy (&to[i*rowstride], &from[(i/2)*rowstride], rowstride);
265         }
266 }
267
268 static void deinterlace(int odd, unsigned char *to, unsigned char *from, int width, int height) {
269         int i, rowstride= width*3;
270         
271         for (i=0; i<height; i++) {
272                 if ((i&1)==odd)
273                         memcpy (&to[(i/2 + height/2)*rowstride], &from[i*rowstride], rowstride);
274                 else 
275                         memcpy (&to[(i/2)*rowstride], &from[i*rowstride], rowstride);
276         }
277 }
278
279 static int check_and_decode_jpeg(unsigned char *inbuf, unsigned char *outbuf, int width, int height, int bufsize) {
280                 /* JPEG's are always multiples of 16, extra is cropped out AVI's */     
281         if ((width&0xF) || (height&0xF)) {
282                 int i, rrowstride, jrowstride;
283                 int jwidth= PADUP(width, 16);
284                 int jheight= PADUP(height, 16);
285                 unsigned char *tmpbuf= MEM_mallocN(jwidth*jheight*3, "avi.check_and_decode_jpeg");
286                 int ret= Decode_JPEG(inbuf, tmpbuf, jwidth, jheight, bufsize);
287                 
288                         /* crop the tmpbuf into the real buffer */
289                 rrowstride= width*3;
290                 jrowstride= jwidth*3;
291                 for (i=0; i<height; i++)
292                         memcpy(&outbuf[i*rrowstride], &tmpbuf[i*jrowstride], rrowstride);
293                 MEM_freeN(tmpbuf);
294                 
295                 return ret;
296         } else {
297                 return Decode_JPEG(inbuf, outbuf, width, height, bufsize);
298         }
299 }
300
301 static void check_and_compress_jpeg(int quality, unsigned char *outbuf, unsigned char *inbuf, int width, int height, int bufsize) {
302                 /* JPEG's are always multiples of 16, extra is ignored in AVI's */      
303         if ((width&0xF) || (height&0xF)) {
304                 int i, rrowstride, jrowstride;
305                 int jwidth= PADUP(width, 16);
306                 int jheight= PADUP(height, 16);
307                 unsigned char *tmpbuf= MEM_mallocN(jwidth*jheight*3, "avi.check_and_compress_jpeg");
308                 
309                         /* resize the realbuf into the tmpbuf */
310                 rrowstride= width*3;
311                 jrowstride= jwidth*3;
312                 for (i=0; i<jheight; i++) {
313                         if (i<height)
314                                 memcpy(&tmpbuf[i*jrowstride], &inbuf[i*rrowstride], rrowstride);
315                         else
316                                 memset(&tmpbuf[i*jrowstride], 0, rrowstride);
317                         memset(&tmpbuf[i*jrowstride+rrowstride], 0, jrowstride-rrowstride);
318                 }
319
320                 Compress_JPEG(quality, outbuf, tmpbuf, jwidth, jheight, bufsize);
321
322                 MEM_freeN(tmpbuf);
323         } else {
324                 Compress_JPEG(quality, outbuf, inbuf, width, height, bufsize);
325         }
326 }
327
328 void *avi_converter_from_mjpeg (AviMovie *movie, int stream, unsigned char *buffer, int *size) {
329         int deint;
330         unsigned char *buf;
331                 
332         buf= MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_from_mjpeg 1");
333
334         deint= check_and_decode_jpeg(buffer, buf, movie->header->Width, movie->header->Height, *size);
335         
336         MEM_freeN(buffer);
337         
338         if (deint) {
339                 buffer = MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_from_mjpeg 2");
340                 interlace (buffer, buf, movie->header->Width, movie->header->Height);
341                 MEM_freeN (buf);
342         
343                 buf= buffer;
344         }
345                 
346         return buf;
347 }
348
349 void *avi_converter_to_mjpeg (AviMovie *movie, int stream, unsigned char *buffer, int *size) {
350         unsigned char *buf;
351         int bufsize= *size;
352         
353         numbytes = 0;
354         *size= 0;
355
356         buf = MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_to_mjpeg 1");   
357         if (!movie->interlace) {
358                 check_and_compress_jpeg(movie->streams[stream].sh.Quality/100, buf, buffer,  movie->header->Width, movie->header->Height, bufsize);
359         } else {
360                 deinterlace (movie->odd_fields, buf, buffer, movie->header->Width, movie->header->Height);
361                 MEM_freeN (buffer);
362         
363                 buffer= buf;
364                 buf= MEM_mallocN (movie->header->Height * movie->header->Width * 3, "avi.avi_converter_to_mjpeg 2");
365         
366                 check_and_compress_jpeg(movie->streams[stream].sh.Quality/100, buf, buffer,  movie->header->Width, movie->header->Height/2, bufsize/2);
367                 *size+= numbytes;
368                 numbytes=0;
369                 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);
370         }
371         *size += numbytes;      
372
373         MEM_freeN (buffer);
374         return buf;
375 }
376
377
378 /* Compression from memory */
379
380 static void jpegmemdestmgr_init_destination(j_compress_ptr cinfo) {
381         ;
382 }
383
384 static boolean jpegmemdestmgr_empty_output_buffer(j_compress_ptr cinfo) {
385         return TRUE;
386 }
387
388 static void jpegmemdestmgr_term_destination(j_compress_ptr cinfo) {
389         numbytes-= cinfo->dest->free_in_buffer;
390
391         MEM_freeN(cinfo->dest);
392 }
393
394 static void jpegmemdestmgr_build(j_compress_ptr cinfo, unsigned char *buffer, int bufsize) {
395         cinfo->dest= MEM_mallocN(sizeof(*(cinfo->dest)), "avi.jpegmemdestmgr_build");
396         
397         cinfo->dest->init_destination= jpegmemdestmgr_init_destination;
398         cinfo->dest->empty_output_buffer= jpegmemdestmgr_empty_output_buffer;
399         cinfo->dest->term_destination= jpegmemdestmgr_term_destination;
400
401         cinfo->dest->next_output_byte= buffer;
402         cinfo->dest->free_in_buffer= bufsize;
403         
404         numbytes= bufsize;
405 }
406
407 /* Decompression from memory */
408
409 static void jpegmemsrcmgr_init_source(j_decompress_ptr dinfo) {
410         ;
411 }
412
413 static boolean jpegmemsrcmgr_fill_input_buffer(j_decompress_ptr dinfo) {
414         unsigned char *buf= (unsigned char*) dinfo->src->next_input_byte-2;
415         
416                 /* if we get called, must have run out of data */
417         WARNMS(dinfo, JWRN_JPEG_EOF);
418         
419         buf[0]= (JOCTET) 0xFF;
420         buf[1]= (JOCTET) JPEG_EOI;
421         
422         dinfo->src->next_input_byte= buf;
423         dinfo->src->bytes_in_buffer= 2;
424         
425         return TRUE;
426 }
427
428 static void jpegmemsrcmgr_skip_input_data(j_decompress_ptr dinfo, long skipcnt) {
429         if (dinfo->src->bytes_in_buffer<skipcnt)
430                 skipcnt= dinfo->src->bytes_in_buffer;
431
432         dinfo->src->next_input_byte+= skipcnt;
433         dinfo->src->bytes_in_buffer-= skipcnt;
434 }
435
436 static void jpegmemsrcmgr_term_source(j_decompress_ptr dinfo) {
437         numbytes-= dinfo->src->bytes_in_buffer;
438         
439         MEM_freeN(dinfo->src);
440 }
441
442 static void jpegmemsrcmgr_build(j_decompress_ptr dinfo, unsigned char *buffer, int bufsize) {
443         dinfo->src= MEM_mallocN(sizeof(*(dinfo->src)), "avi.jpegmemsrcmgr_build");
444         
445         dinfo->src->init_source= jpegmemsrcmgr_init_source;
446         dinfo->src->fill_input_buffer= jpegmemsrcmgr_fill_input_buffer;
447         dinfo->src->skip_input_data= jpegmemsrcmgr_skip_input_data;
448         dinfo->src->resync_to_restart= jpeg_resync_to_restart;
449         dinfo->src->term_source= jpegmemsrcmgr_term_source;
450         
451         dinfo->src->bytes_in_buffer= bufsize;
452         dinfo->src->next_input_byte= buffer;
453
454         numbytes= bufsize;
455 }