?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make FloatAutos::get_values() always use a PLAY_FORWARD direction.
[cinelerra_cv/pmdumuid.git] / quicktime / libmjpeg.c
blob2475d33bbe273ad8b1383e94af1c0755b4d82661
1 /*
2 * This library is free software; you can redistribute it and/or modify it
3 * under the terms of the GNU Lesser General Public License as published
4 * by the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This library is distributed in the hope that it will be useful, but
8 * WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
10 * Lesser General Public License for more details.
11 *
12 * You should have received a copy of the GNU Lesser General Public
13 * License along with this library; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
15 * USA
16 */
17
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include "colormodels.h"
21 #include "libmjpeg.h"
22
23 /* JPEG MARKERS */
24 #define M_SOF0 0xc0
25 #define M_SOF1 0xc1
26 #define M_SOF2 0xc2
27 #define M_SOF3 0xc3
28 #define M_SOF5 0xc5
29 #define M_SOF6 0xc6
30 #define M_SOF7 0xc7
31 #define M_JPG 0xc8
32 #define M_SOF9 0xc9
33 #define M_SOF10 0xca
34 #define M_SOF11 0xcb
35 #define M_SOF13 0xcd
36 #define M_SOF14 0xce
37 #define M_SOF15 0xcf
38 #define M_DHT 0xc4
39 #define M_DAC 0xcc
40 #define M_RST0 0xd0
41 #define M_RST1 0xd1
42 #define M_RST2 0xd2
43 #define M_RST3 0xd3
44 #define M_RST4 0xd4
45 #define M_RST5 0xd5
46 #define M_RST6 0xd6
47 #define M_RST7 0xd7
48 #define M_SOI 0xd8
49 #define M_EOI 0xd9
50 #define M_SOS 0xda
51 #define M_DQT 0xdb
52 #define M_DNL 0xdc
53 #define M_DRI 0xdd
54 #define M_DHP 0xde
55 #define M_EXP 0xdf
56 #define M_APP0 0xe0
57 #define M_APP1 0xe1
58 #define M_APP2 0xe2
59 #define M_APP3 0xe3
60 #define M_APP4 0xe4
61 #define M_APP5 0xe5
62 #define M_APP6 0xe6
63 #define M_APP7 0xe7
64 #define M_APP8 0xe8
65 #define M_APP9 0xe9
66 #define M_APP10 0xea
67 #define M_APP11 0xeb
68 #define M_APP12 0xec
69 #define M_APP13 0xed
70 #define M_APP14 0xee
71 #define M_APP15 0xef
72 #define M_JPG0 0xf0
73 #define M_JPG13 0xfd
74 #define M_COM 0xfe
75 #define M_TEM 0x01
76 #define M_ERROR 0x100
77
78 #define QUICKTIME_MARKER_SIZE 0x2c
79 #define AVI_MARKER_SIZE 0x12
80 #define QUICKTIME_JPEG_TAG 0x6d6a7067
81 #define QUICKTIME_AVI_TAG 0x41564931
82
83
84 METHODDEF(void) mjpeg_error_exit (j_common_ptr cinfo)
85 {
86 /* cinfo->err really points to a mjpeg_error_mgr struct, so coerce pointer */
87 mjpeg_error_ptr mjpegerr = (mjpeg_error_ptr) cinfo->err;
88
89 /* Always display the message. */
90 /* We could postpone this until after returning, if we chose. */
91 (*cinfo->err->output_message) (cinfo);
92
93 /* Return control to the setjmp point */
94 longjmp(mjpegerr->setjmp_buffer, 1);
95 }
96
97 typedef struct
98 {
99 struct jpeg_destination_mgr pub; /* public fields */
100
101 JOCTET *buffer; /* Pointer to buffer */
102 mjpeg_compressor *engine;
103 } mjpeg_destination_mgr;
104
105 typedef mjpeg_destination_mgr *mjpeg_dest_ptr;
106
107
108 /*
109 * Initialize destination --- called by jpeg_start_compress
110 * before any data is actually written.
111 */
112
113 METHODDEF(void) init_destination(j_compress_ptr cinfo)
114 {
115 mjpeg_dest_ptr dest = (mjpeg_dest_ptr)cinfo->dest;
116
117 /* Set the pointer to the preallocated buffer */
118 if(!dest->engine->output_buffer)
119 {
120 dest->engine->output_buffer = calloc(1, 65536);
121 dest->engine->output_allocated = 65536;
122 }
123 dest->buffer = dest->engine->output_buffer;
124 dest->pub.next_output_byte = dest->engine->output_buffer;
125 dest->pub.free_in_buffer = dest->engine->output_allocated;
126 }
127
128 /*
129 * Empty the output buffer --- called whenever buffer fills up.
130 *
131 * In typical applications, this should write the entire output buffer
132 * (ignoring the current state of next_output_byte & free_in_buffer),
133 * reset the pointer & count to the start of the buffer, and return TRUE
134 * indicating that the buffer has been dumped.
135 *
136 * In applications that need to be able to suspend compression due to output
137 * overrun, a FALSE return indicates that the buffer cannot be emptied now.
138 * In this situation, the compressor will return to its caller (possibly with
139 * an indication that it has not accepted all the supplied scanlines). The
140 * application should resume compression after it has made more room in the
141 * output buffer. Note that there are substantial restrictions on the use of
142 * suspension --- see the documentation.
143 *
144 * When suspending, the compressor will back up to a convenient restart point
145 * (typically the start of the current MCU). next_output_byte & free_in_buffer
146 * indicate where the restart point will be if the current call returns FALSE.
147 * Data beyond this point will be regenerated after resumption, so do not
148 * write it out when emptying the buffer externally.
149 */
150
151 METHODDEF(boolean) empty_output_buffer(j_compress_ptr cinfo)
152 {
153 /* Allocate a bigger buffer. */
154 mjpeg_dest_ptr dest = (mjpeg_dest_ptr)cinfo->dest;
155
156 dest->engine->output_size = dest->engine->output_allocated;
157 dest->engine->output_allocated *= 2;
158 dest->engine->output_buffer = realloc(dest->engine->output_buffer,
159 dest->engine->output_allocated);
160 dest->buffer = dest->engine->output_buffer;
161 dest->pub.next_output_byte = dest->buffer + dest->engine->output_size;
162 dest->pub.free_in_buffer = dest->engine->output_allocated - dest->engine->output_size;
163
164 return TRUE;
165 }
166
167 /*
168 * Terminate destination --- called by jpeg_finish_compress
169 * after all data has been written. Usually needs to flush buffer.
170 *
171 * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding
172 * application must deal with any cleanup that should happen even
173 * for error exit.
174 */
175 METHODDEF(void) term_destination(j_compress_ptr cinfo)
176 {
177 /* Just get the length */
178 mjpeg_dest_ptr dest = (mjpeg_dest_ptr)cinfo->dest;
179 dest->engine->output_size = dest->engine->output_allocated - dest->pub.free_in_buffer;
180 }
181
182 GLOBAL(void) jpeg_buffer_dest(j_compress_ptr cinfo, mjpeg_compressor *engine)
183 {
184 mjpeg_dest_ptr dest;
185
186 /* The destination object is made permanent so that multiple JPEG images
187 * can be written to the same file without re-executing jpeg_stdio_dest.
188 * This makes it dangerous to use this manager and a different destination
189 * manager serially with the same JPEG object, because their private object
190 * sizes may be different. Caveat programmer.
191 */
192 if(cinfo->dest == NULL)
193 {
194 /* first time for this JPEG object? */
195 cinfo->dest = (struct jpeg_destination_mgr *)
196 (*cinfo->mem->alloc_small)((j_common_ptr)cinfo,
197 JPOOL_PERMANENT,
198 sizeof(mjpeg_destination_mgr));
199 }
200
201 dest = (mjpeg_dest_ptr)cinfo->dest;
202 dest->pub.init_destination = init_destination;
203 dest->pub.empty_output_buffer = empty_output_buffer;
204 dest->pub.term_destination = term_destination;
205 dest->engine = engine;
206 }
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221 typedef struct {
222 struct jpeg_source_mgr pub; /* public fields */
223
224 JOCTET * buffer; /* start of buffer */
225 int bytes; /* total size of buffer */
226 } mjpeg_source_mgr;
227
228 typedef mjpeg_source_mgr* mjpeg_src_ptr;
229
230 METHODDEF(void) init_source(j_decompress_ptr cinfo)
231 {
232 mjpeg_src_ptr src = (mjpeg_src_ptr) cinfo->src;
233 }
234
235 METHODDEF(boolean) fill_input_buffer(j_decompress_ptr cinfo)
236 {
237 mjpeg_src_ptr src = (mjpeg_src_ptr) cinfo->src;
238
239 src->buffer[0] = (JOCTET)0xFF;
240 src->buffer[1] = (JOCTET)M_EOI;
241 src->pub.next_input_byte = src->buffer;
242 src->pub.bytes_in_buffer = 2;
243
244 return TRUE;
245 }
246
247
248 METHODDEF(void) skip_input_data(j_decompress_ptr cinfo, long num_bytes)
249 {
250 mjpeg_src_ptr src = (mjpeg_src_ptr)cinfo->src;
251
252 src->pub.next_input_byte += (size_t)num_bytes;
253 src->pub.bytes_in_buffer -= (size_t)num_bytes;
254 }
255
256
257 METHODDEF(void) term_source(j_decompress_ptr cinfo)
258 {
259 }
260
261 GLOBAL(void) jpeg_buffer_src(j_decompress_ptr cinfo, unsigned char *buffer, long bytes)
262 {
263 mjpeg_src_ptr src;
264
265 /* first time for this JPEG object? */
266 if(cinfo->src == NULL)
267 {
268 cinfo->src = (struct jpeg_source_mgr*)
269 (*cinfo->mem->alloc_small)((j_common_ptr)cinfo,
270 JPOOL_PERMANENT,
271 sizeof(mjpeg_source_mgr));
272 src = (mjpeg_src_ptr)cinfo->src;
273 }
274
275 src = (mjpeg_src_ptr)cinfo->src;
276 src->pub.init_source = init_source;
277 src->pub.fill_input_buffer = fill_input_buffer;
278 src->pub.skip_input_data = skip_input_data;
279 src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
280 src->pub.term_source = term_source;
281 src->pub.bytes_in_buffer = bytes;
282 src->pub.next_input_byte = buffer;
283 src->buffer = buffer;
284 src->bytes = bytes;
285 }
286
287 /* JPEG DHT Segment for YCrCb omitted from MJPEG data */
288 static
289 unsigned char jpeg_odml_dht[0x1a4] = {
290 0xff, 0xc4, 0x01, 0xa2,
291
292 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
293 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
294
295 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
296 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
297
298 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d,
299 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
300 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
301 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
302 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
303 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
304 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
305 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
306 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
307 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
308 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
309 0xf9, 0xfa,
310
311 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77,
312 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
313 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
314 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
315 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
316 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
317 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
318 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
319 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
320 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
321 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
322 0xf9, 0xfa
323 };
324
325
326 /*
327 * Parse the DHT table.
328 * This code comes from jpeg6b (jdmarker.c).
329 */
330 static
331 int jpeg_load_dht (struct jpeg_decompress_struct *info, unsigned char *dht,
332 JHUFF_TBL *ac_tables[], JHUFF_TBL *dc_tables[])
333 {
334 unsigned int length = (dht[2] << 8) + dht[3] - 2;
335 unsigned int pos = 4;
336 unsigned int count, i;
337 int index;
338
339 JHUFF_TBL **hufftbl;
340 unsigned char bits[17];
341 unsigned char huffval[256];
342
343 while (length > 16)
344 {
345 bits[0] = 0;
346 index = dht[pos++];
347 count = 0;
348 for (i = 1; i <= 16; ++i)
349 {
350 bits[i] = dht[pos++];
351 count += bits[i];
352 }
353 length -= 17;
354
355 if (count > 256 || count > length)
356 return -1;
357
358 for (i = 0; i < count; ++i)
359 huffval[i] = dht[pos++];
360 length -= count;
361
362 if (index & 0x10)
363 {
364 index -= 0x10;
365 hufftbl = &ac_tables[index];
366 }
367 else
368 hufftbl = &dc_tables[index];
369
370 if (index < 0 || index >= NUM_HUFF_TBLS)
371 return -1;
372
373 if (*hufftbl == NULL)
374 *hufftbl = jpeg_alloc_huff_table ((j_common_ptr)info);
375 if (*hufftbl == NULL)
376 return -1;
377
378 memcpy ((*hufftbl)->bits, bits, sizeof (*hufftbl)->bits);
379 memcpy ((*hufftbl)->huffval, huffval, sizeof (*hufftbl)->huffval);
380 }
381
382 if (length != 0)
383 return -1;
384
385 return 0;
386 }
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402 static void reset_buffer(unsigned char **buffer, long *size, long *allocated)
403 {
404 *size = 0;
405 }
406
407 static void delete_buffer(unsigned char **buffer, long *size, long *allocated)
408 {
409 if(*buffer)
410 {
411 free(*buffer);
412 *size = 0;
413 *allocated = 0;
414 }
415 }
416
417 static void append_buffer(unsigned char **buffer,
418 long *size,
419 long *allocated,
420 unsigned char *data,
421 long data_size)
422 {
423 if(!*buffer)
424 {
425 *buffer = calloc(1, 65536);
426 *size = 0;
427 *allocated = 65536;
428 }
429
430 if(*size + data_size + 0x100 > *allocated)
431 {
432 *allocated = *size + data_size + 0x100;
433 *buffer = realloc(*buffer, *allocated);
434 }
435
436 memcpy(*buffer + *size, data, data_size);
437 *size += data_size;
438 }
439
440 static void allocate_temps(mjpeg_t *mjpeg)
441 {
442 int i;
443
444 if(!mjpeg->temp_data)
445 {
446 switch(mjpeg->jpeg_color_model)
447 {
448 case BC_YUV422P:
449 mjpeg->temp_data = calloc(1, mjpeg->coded_w * mjpeg->coded_h * 2);
450 mjpeg->temp_rows[0] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h);
451 mjpeg->temp_rows[1] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h);
452 mjpeg->temp_rows[2] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h);
453 for(i = 0; i < mjpeg->coded_h; i++)
454 {
455 mjpeg->temp_rows[0][i] = mjpeg->temp_data + i * mjpeg->coded_w;
456 mjpeg->temp_rows[1][i] = mjpeg->temp_data + mjpeg->coded_w * mjpeg->coded_h + i * mjpeg->coded_w / 2;
457 mjpeg->temp_rows[2][i] = mjpeg->temp_data + mjpeg->coded_w * mjpeg->coded_h + mjpeg->coded_w / 2 * mjpeg->coded_h + i * mjpeg->coded_w / 2;
458 }
459 break;
460
461 case BC_YUV444P:
462 mjpeg->temp_data = calloc(1, mjpeg->coded_w * mjpeg->coded_h * 3);
463 mjpeg->temp_rows[0] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h);
464 mjpeg->temp_rows[1] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h);
465 mjpeg->temp_rows[2] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h);
466 if(mjpeg->greyscale)
467 {
468 memset(mjpeg->temp_data + mjpeg->coded_w * mjpeg->coded_h,
469 0x80,
470 mjpeg->coded_w * mjpeg->coded_h * 2);
471 }
472 for(i = 0; i < mjpeg->coded_h; i++)
473 {
474 mjpeg->temp_rows[0][i] = mjpeg->temp_data + i * mjpeg->coded_w;
475 mjpeg->temp_rows[1][i] = mjpeg->temp_data + mjpeg->coded_w * mjpeg->coded_h + i * mjpeg->coded_w;
476 mjpeg->temp_rows[2][i] = mjpeg->temp_data + mjpeg->coded_w * mjpeg->coded_h + mjpeg->coded_w * mjpeg->coded_h + i * mjpeg->coded_w;
477 }
478 break;
479
480 case BC_YUV420P:
481 mjpeg->temp_data = calloc(1, mjpeg->coded_w * mjpeg->coded_h + mjpeg->coded_w * mjpeg->coded_h / 2);
482 mjpeg->temp_rows[0] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h);
483 mjpeg->temp_rows[1] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h / 2);
484 mjpeg->temp_rows[2] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h / 2);
485 for(i = 0; i < mjpeg->coded_h; i++)
486 {
487 mjpeg->temp_rows[0][i] = mjpeg->temp_data + i * mjpeg->coded_w;
488 if(i < mjpeg->coded_h / 2)
489 {
490 mjpeg->temp_rows[1][i] = mjpeg->temp_data + mjpeg->coded_w * mjpeg->coded_h + i * (mjpeg->coded_w / 2);
491 mjpeg->temp_rows[2][i] = mjpeg->temp_data + mjpeg->coded_w * mjpeg->coded_h + (mjpeg->coded_h / 2) * (mjpeg->coded_w / 2) + i * (mjpeg->coded_w / 2);
492 }
493 }
494 break;
495 }
496 }
497 }
498
499 static int get_input_row(mjpeg_t *mjpeg, mjpeg_compressor *compressor, int i)
500 {
501 int input_row;
502 if(mjpeg->fields > 1)
503 input_row = i * 2 + compressor->instance;
504 else
505 input_row = i;
506 if(input_row >= mjpeg->coded_h) input_row = mjpeg->coded_h - 1;
507 return input_row;
508 }
509
510 // Get pointers to rows for the JPEG compressor
511 static void get_rows(mjpeg_t *mjpeg, mjpeg_compressor *compressor)
512 {
513 int i;
514 switch(mjpeg->jpeg_color_model)
515 {
516 case BC_YUV444P:
517 {
518 if(!compressor->rows[0])
519 {
520 compressor->rows[0] = calloc(1, sizeof(unsigned char*) * compressor->coded_field_h);
521 compressor->rows[1] = calloc(1, sizeof(unsigned char*) * compressor->coded_field_h);
522 compressor->rows[2] = calloc(1, sizeof(unsigned char*) * compressor->coded_field_h);
523 }
524
525 // User colormodel matches jpeg colormodel
526 if(mjpeg->color_model == BC_YUV444P &&
527 mjpeg->output_w == mjpeg->coded_w &&
528 mjpeg->output_h == mjpeg->coded_h)
529 {
530 for(i = 0; i < compressor->coded_field_h; i++)
531 {
532 int input_row = get_input_row(mjpeg, compressor, i);
533 compressor->rows[0][i] = mjpeg->y_argument +
534 mjpeg->coded_w * input_row;
535 compressor->rows[1][i] = mjpeg->u_argument +
536 mjpeg->coded_w * input_row;
537 compressor->rows[2][i] = mjpeg->v_argument +
538 mjpeg->coded_w * input_row;
539 }
540 }
541 else
542 {
543 for(i = 0; i < compressor->coded_field_h; i++)
544 {
545 int input_row = get_input_row(mjpeg, compressor, i);
546 compressor->rows[0][i] = mjpeg->temp_rows[0][input_row];
547 compressor->rows[1][i] = mjpeg->temp_rows[1][input_row];
548 compressor->rows[2][i] = mjpeg->temp_rows[2][input_row];
549 }
550 }
551 break;
552 }
553
554 case BC_YUV422P:
555 {
556 if(!compressor->rows[0])
557 {
558 compressor->rows[0] = calloc(1, sizeof(unsigned char*) * compressor->coded_field_h);
559 compressor->rows[1] = calloc(1, sizeof(unsigned char*) * compressor->coded_field_h);
560 compressor->rows[2] = calloc(1, sizeof(unsigned char*) * compressor->coded_field_h);
561 }
562
563 // User colormodel matches jpeg colormodel
564 if(mjpeg->color_model == BC_YUV422P &&
565 mjpeg->output_w == mjpeg->coded_w &&
566 mjpeg->output_h == mjpeg->coded_h)
567 {
568 for(i = 0; i < compressor->coded_field_h; i++)
569 {
570 int input_row = get_input_row(mjpeg, compressor, i);
571 compressor->rows[0][i] = mjpeg->y_argument +
572 mjpeg->coded_w * input_row;
573 compressor->rows[1][i] = mjpeg->u_argument +
574 (mjpeg->coded_w / 2) * input_row;
575 compressor->rows[2][i] = mjpeg->v_argument +
576 (mjpeg->coded_w / 2) * input_row;
577 }
578 }
579 else
580 {
581 for(i = 0; i < compressor->coded_field_h; i++)
582 {
583 int input_row = get_input_row(mjpeg, compressor, i);
584 compressor->rows[0][i] = mjpeg->temp_rows[0][input_row];
585 compressor->rows[1][i] = mjpeg->temp_rows[1][input_row];
586 compressor->rows[2][i] = mjpeg->temp_rows[2][input_row];
587 }
588 }
589 break;
590 }
591
592 case BC_YUV420P:
593 {
594 if(!compressor->rows[0])
595 {
596 compressor->rows[0] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h);
597 compressor->rows[1] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h / 2);
598 compressor->rows[2] = calloc(1, sizeof(unsigned char*) * mjpeg->coded_h / 2);
599 }
600
601 // User colormodel matches jpeg colormodel
602 if(mjpeg->color_model == BC_YUV420P &&
603 mjpeg->output_w == mjpeg->coded_w &&
604 mjpeg->output_h == mjpeg->coded_h)
605 {
606 for(i = 0; i < compressor->coded_field_h; i++)
607 {
608 int input_row = get_input_row(mjpeg, compressor, i);
609 compressor->rows[0][i] = mjpeg->y_argument +
610 mjpeg->coded_w * input_row;
611 if(i < compressor->coded_field_h / 2)
612 {
613 compressor->rows[1][i] = mjpeg->u_argument +
614 (mjpeg->coded_w / 2) * input_row;
615 compressor->rows[2][i] = mjpeg->v_argument +
616 (mjpeg->coded_w / 2) * input_row;
617 }
618 }
619 }
620 else
621 {
622 for(i = 0; i < compressor->coded_field_h; i++)
623 {
624 int input_row = get_input_row(mjpeg, compressor, i);
625 compressor->rows[0][i] = mjpeg->temp_rows[0][input_row];
626 if(i < compressor->coded_field_h / 2)
627 {
628 compressor->rows[1][i] = mjpeg->temp_rows[1][input_row];
629 compressor->rows[2][i] = mjpeg->temp_rows[2][input_row];
630 }
631 }
632 }
633 break;
634 }
635 }
636 }
637
638 static void delete_rows(mjpeg_compressor *compressor)
639 {
640 if(compressor->rows[0])
641 {
642 free(compressor->rows[0]);
643 free(compressor->rows[1]);
644 free(compressor->rows[2]);
645 }
646 }
647
648
649 static void new_jpeg_objects(mjpeg_compressor *engine)
650 {
651 engine->jpeg_decompress.err = jpeg_std_error(&(engine->jpeg_error.pub));
652 engine->jpeg_error.pub.error_exit = mjpeg_error_exit;
653 /* Ideally the error handler would be set here but it must be called in a thread */
654 jpeg_create_decompress(&(engine->jpeg_decompress));
655 engine->jpeg_decompress.raw_data_out = TRUE;
656 engine->jpeg_decompress.dct_method = JDCT_IFAST;
657 }
658
659 static void delete_jpeg_objects(mjpeg_compressor *engine)
660 {
661 jpeg_destroy_decompress(&(engine->jpeg_decompress));
662 }
663
664
665
666 static void unlock_compress_loop(mjpeg_compressor *engine)
667 {
668 pthread_mutex_unlock(&(engine->input_lock));
669 }
670
671 static void lock_compress_loop(mjpeg_compressor *engine)
672 {
673 pthread_mutex_lock(&(engine->output_lock));
674 }
675
676 // Make temp rows for compressor
677 static void get_mcu_rows(mjpeg_t *mjpeg,
678 mjpeg_compressor *engine,
679 int start_row)
680 {
681 int i, j, scanline;
682 for(i = 0; i < 3; i++)
683 {
684 for(j = 0; j < 16; j++)
685 {
686 if(i > 0 && j >= 8 && mjpeg->jpeg_color_model == BC_YUV420P) break;
687
688 scanline = start_row;
689 if(i > 0 && mjpeg->jpeg_color_model == BC_YUV420P) scanline /= 2;
690 scanline += j;
691 if(scanline >= engine->coded_field_h) scanline = engine->coded_field_h - 1;
692 engine->mcu_rows[i][j] = engine->rows[i][scanline];
693 }
694 }
695 }
696
697
698 static void decompress_field(mjpeg_compressor *engine)
699 {
700 mjpeg_t *mjpeg = engine->mjpeg;
701 long buffer_offset = engine->instance * mjpeg->input_field2;
702 unsigned char *buffer = mjpeg->input_data + buffer_offset;
703 long buffer_size;
704 int i, j;
705
706 //printf("decompress_field %02x%02x %d\n", buffer[0], buffer[1], engine->instance * mjpeg->input_field2);
707 if(engine->instance == 0 && mjpeg->fields > 1)
708 buffer_size = mjpeg->input_field2 - buffer_offset;
709 else
710 buffer_size = mjpeg->input_size - buffer_offset;
711
712 mjpeg->error = 0;
713
714 if(setjmp(engine->jpeg_error.setjmp_buffer))
715 {
716 /* If we get here, the JPEG code has signaled an error. */
717 delete_jpeg_objects(engine);
718 new_jpeg_objects(engine);
719 mjpeg->error = 1;
720 //printf("decompress_field 1\n");
721 goto finish;
722 }
723
724 //printf("decompress_field 2\n");
725 jpeg_buffer_src(&engine->jpeg_decompress,
726 buffer,
727 buffer_size);
728 jpeg_read_header(&engine->jpeg_decompress, TRUE);
729
730 if ( engine->jpeg_decompress.ac_huff_tbl_ptrs[0] == NULL &&
731 engine->jpeg_decompress.ac_huff_tbl_ptrs[1] == NULL &&
732 engine->jpeg_decompress.dc_huff_tbl_ptrs[0] == NULL &&
733 engine->jpeg_decompress.dc_huff_tbl_ptrs[1] == NULL )
734 jpeg_load_dht( &engine->jpeg_decompress,
735 jpeg_odml_dht,
736 engine->jpeg_decompress.ac_huff_tbl_ptrs,
737 engine->jpeg_decompress.dc_huff_tbl_ptrs );
738 // Reset by jpeg_read_header
739 engine->jpeg_decompress.raw_data_out = TRUE;
740 jpeg_start_decompress(&engine->jpeg_decompress);
741
742 // Generate colormodel from jpeg sampling
743 if(engine->jpeg_decompress.comp_info[0].v_samp_factor == 2 &&
744 engine->jpeg_decompress.comp_info[0].h_samp_factor == 2)
745 mjpeg->jpeg_color_model = BC_YUV420P;
746 else
747 if(engine->jpeg_decompress.comp_info[0].v_samp_factor == 1 &&
748 engine->jpeg_decompress.comp_info[0].h_samp_factor == 2)
749 mjpeg->jpeg_color_model = BC_YUV422P;
750 else
751 mjpeg->jpeg_color_model = BC_YUV444P;
752
753 if(engine->jpeg_decompress.jpeg_color_space == JCS_GRAYSCALE)
754 mjpeg->greyscale = 1;
755
756 //printf("%d %d\n", engine->jpeg_decompress.comp_info[0].h_samp_factor, engine->jpeg_decompress.comp_info[0].v_samp_factor);
757 // Must be here because the color model isn't known until now
758 pthread_mutex_lock(&(mjpeg->decompress_init));
759 allocate_temps(mjpeg);
760 pthread_mutex_unlock(&(mjpeg->decompress_init));
761 get_rows(mjpeg, engine);
762
763
764 while(engine->jpeg_decompress.output_scanline < engine->jpeg_decompress.output_height)
765 {
766 get_mcu_rows(mjpeg, engine, engine->jpeg_decompress.output_scanline);
767 jpeg_read_raw_data(&engine->jpeg_decompress,
768 engine->mcu_rows,
769 engine->coded_field_h);
770 }
771 jpeg_finish_decompress(&engine->jpeg_decompress);
772
773
774 finish:
775 ;
776 }
777
778 void mjpeg_decompress_loop(mjpeg_compressor *engine)
779 {
780 while(!engine->done)
781 {
782 pthread_mutex_lock(&engine->input_lock);
783 if(!engine->done)
784 {
785 decompress_field(engine);
786 }
787 pthread_mutex_unlock(&(engine->output_lock));
788 }
789 }
790
791
792 static void compress_field(mjpeg_compressor *engine)
793 {
794 int i, j;
795 mjpeg_t *mjpeg = engine->mjpeg;
796
797 //printf("compress_field 1\n");
798 get_rows(engine->mjpeg, engine);
799 reset_buffer(&engine->output_buffer, &engine->output_size, &engine->output_allocated);
800 jpeg_buffer_dest(&engine->jpeg_compress, engine);
801
802
803 engine->jpeg_compress.raw_data_in = TRUE;
804 jpeg_start_compress(&engine->jpeg_compress, TRUE);
805
806 while(engine->jpeg_compress.next_scanline < engine->jpeg_compress.image_height)
807 {
808 get_mcu_rows(mjpeg, engine, engine->jpeg_compress.next_scanline);
809
810 jpeg_write_raw_data(&engine->jpeg_compress,
811 engine->mcu_rows,
812 engine->coded_field_h);
813 }
814 jpeg_finish_compress(&engine->jpeg_compress);
815 //printf("compress_field 2\n");
816 }
817
818
819 void mjpeg_compress_loop(mjpeg_compressor *engine)
820 {
821 while(!engine->done)
822 {
823 pthread_mutex_lock(&engine->input_lock);
824 if(!engine->done)
825 {
826 compress_field(engine);
827 }
828 pthread_mutex_unlock(&engine->output_lock);
829 }
830 }
831
832 static void delete_temps(mjpeg_t *mjpeg)
833 {
834 if(mjpeg->temp_data)
835 {
836 free(mjpeg->temp_data);
837 free(mjpeg->temp_rows[0]);
838 free(mjpeg->temp_rows[1]);
839 free(mjpeg->temp_rows[2]);
840 }
841 }
842
843 mjpeg_compressor* mjpeg_new_decompressor(mjpeg_t *mjpeg, int instance)
844 {
845 mjpeg_compressor *result = calloc(1, sizeof(mjpeg_compressor));
846 pthread_attr_t attr;
847 struct sched_param param;
848 pthread_mutexattr_t mutex_attr;
849 int i;
850
851 result->mjpeg = mjpeg;
852 result->instance = instance;
853 new_jpeg_objects(result);
854 result->field_h = mjpeg->output_h / mjpeg->fields;
855 result->coded_field_h = (result->field_h % 16) ?
856 result->field_h + (16 - (result->field_h % 16)) : result->field_h;
857
858 result->mcu_rows[0] = malloc(16 * sizeof(unsigned char*));
859 result->mcu_rows[1] = malloc(16 * sizeof(unsigned char*));
860 result->mcu_rows[2] = malloc(16 * sizeof(unsigned char*));
861
862 pthread_mutexattr_init(&mutex_attr);
863 // pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_ADAPTIVE_NP);
864 pthread_mutex_init(&(result->input_lock), &mutex_attr);
865 pthread_mutex_lock(&(result->input_lock));
866 pthread_mutex_init(&(result->output_lock), &mutex_attr);
867 pthread_mutex_lock(&(result->output_lock));
868
869 pthread_attr_init(&attr);
870 pthread_create(&(result->tid), &attr, (void*)mjpeg_decompress_loop, result);
871
872 return result;
873 }
874
875 void mjpeg_delete_decompressor(mjpeg_compressor *engine)
876 {
877 engine->done = 1;
878 pthread_mutex_unlock(&(engine->input_lock));
879 pthread_join(engine->tid, 0);
880 pthread_mutex_destroy(&(engine->input_lock));
881 pthread_mutex_destroy(&(engine->output_lock));
882 jpeg_destroy_decompress(&(engine->jpeg_decompress));
883 delete_rows(engine);
884 free(engine->mcu_rows[0]);
885 free(engine->mcu_rows[1]);
886 free(engine->mcu_rows[2]);
887 free(engine);
888 }
889
890 mjpeg_compressor* mjpeg_new_compressor(mjpeg_t *mjpeg, int instance)
891 {
892 pthread_attr_t attr;
893 struct sched_param param;
894 pthread_mutexattr_t mutex_attr;
895 mjpeg_compressor *result = calloc(1, sizeof(mjpeg_compressor));
896
897 result->field_h = mjpeg->output_h / mjpeg->fields;
898 result->coded_field_h = (result->field_h % 16) ?
899 result->field_h + (16 - (result->field_h % 16)) : result->field_h;
900 result->mjpeg = mjpeg;
901 result->instance = instance;
902 result->jpeg_compress.err = jpeg_std_error(&(result->jpeg_error.pub));
903 jpeg_create_compress(&(result->jpeg_compress));
904 result->jpeg_compress.image_width = mjpeg->output_w;
905 result->jpeg_compress.image_height = result->field_h;
906 result->jpeg_compress.input_components = 3;
907 result->jpeg_compress.in_color_space = JCS_RGB;
908 jpeg_set_defaults(&(result->jpeg_compress));
909 result->jpeg_compress.input_components = 3;
910 result->jpeg_compress.in_color_space = JCS_RGB;
911 jpeg_set_quality(&(result->jpeg_compress), mjpeg->quality, 0);
912
913 if(mjpeg->use_float)
914 result->jpeg_compress.dct_method = JDCT_FLOAT;
915 else
916 result->jpeg_compress.dct_method = JDCT_IFAST;
917 // result->jpeg_compress.dct_method = JDCT_ISLOW;
918
919 /* Fix sampling */
920 switch(mjpeg->fields)
921 {
922 case 1:
923 mjpeg->jpeg_color_model = BC_YUV420P;
924 result->jpeg_compress.comp_info[0].h_samp_factor = 2;
925 result->jpeg_compress.comp_info[0].v_samp_factor = 2;
926 result->jpeg_compress.comp_info[1].h_samp_factor = 1;
927 result->jpeg_compress.comp_info[1].v_samp_factor = 1;
928 result->jpeg_compress.comp_info[2].h_samp_factor = 1;
929 result->jpeg_compress.comp_info[2].v_samp_factor = 1;
930 break;
931 case 2:
932 mjpeg->jpeg_color_model = BC_YUV422P;
933 result->jpeg_compress.comp_info[0].h_samp_factor = 2;
934 result->jpeg_compress.comp_info[0].v_samp_factor = 1;
935 result->jpeg_compress.comp_info[1].h_samp_factor = 1;
936 result->jpeg_compress.comp_info[1].v_samp_factor = 1;
937 result->jpeg_compress.comp_info[2].h_samp_factor = 1;
938 result->jpeg_compress.comp_info[2].v_samp_factor = 1;
939 break;
940 }
941 allocate_temps(mjpeg);
942
943 result->mcu_rows[0] = malloc(16 * sizeof(unsigned char*));
944 result->mcu_rows[1] = malloc(16 * sizeof(unsigned char*));
945 result->mcu_rows[2] = malloc(16 * sizeof(unsigned char*));
946
947 pthread_mutexattr_init(&mutex_attr);
948 // pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_ADAPTIVE_NP);
949 pthread_mutex_init(&(result->input_lock), &mutex_attr);
950 pthread_mutex_lock(&(result->input_lock));
951 pthread_mutex_init(&(result->output_lock), &mutex_attr);
952 pthread_mutex_lock(&(result->output_lock));
953
954 pthread_attr_init(&attr);
955 pthread_create(&(result->tid), &attr, (void*)mjpeg_compress_loop, result);
956 return result;
957 }
958
959
960 void mjpeg_delete_compressor(mjpeg_compressor *engine)
961 {
962 engine->done = 1;
963 pthread_mutex_unlock(&(engine->input_lock));
964 pthread_join(engine->tid, 0);
965 pthread_mutex_destroy(&(engine->input_lock));
966 pthread_mutex_destroy(&(engine->output_lock));
967 jpeg_destroy((j_common_ptr)&(engine->jpeg_compress));
968 if(engine->output_buffer) free(engine->output_buffer);
969 delete_rows(engine);
970 free(engine->mcu_rows[0]);
971 free(engine->mcu_rows[1]);
972 free(engine->mcu_rows[2]);
973 free(engine);
974 }
975
976 unsigned char* mjpeg_output_buffer(mjpeg_t *mjpeg)
977 {
978 return mjpeg->output_data;
979 }
980
981 long mjpeg_output_field2(mjpeg_t *mjpeg)
982 {
983 return mjpeg->output_field2;
984 }
985
986 long mjpeg_output_size(mjpeg_t *mjpeg)
987 {
988 return mjpeg->output_size;
989 }
990
991 long mjpeg_output_allocated(mjpeg_t *mjpeg)
992 {
993 return mjpeg->output_allocated;
994 }
995
996 void mjpeg_set_output_size(mjpeg_t *mjpeg, long output_size)
997 {
998 mjpeg->output_size = output_size;
999 }
1000
1001
1002 int mjpeg_compress(mjpeg_t *mjpeg,
1003 unsigned char **row_pointers,
1004 unsigned char *y_plane,
1005 unsigned char *u_plane,
1006 unsigned char *v_plane,
1007 int color_model,
1008 int cpus)
1009 {
1010 int i, result = 0;
1011 int corrected_fields = mjpeg->fields;
1012 mjpeg->color_model = color_model;
1013 mjpeg->cpus = cpus;
1014
1015 //printf("mjpeg_compress 1 %d\n", color_model);
1016 /* Reset output buffer */
1017 reset_buffer(&mjpeg->output_data,
1018 &mjpeg->output_size,
1019 &mjpeg->output_allocated);
1020
1021 /* Create compression engines as needed */
1022 for(i = 0; i < mjpeg->fields; i++)
1023 {
1024 if(!mjpeg->compressors[i])
1025 {
1026 mjpeg->compressors[i] = mjpeg_new_compressor(mjpeg, i);
1027 }
1028 }
1029
1030 /* Arm YUV buffers */
1031 mjpeg->row_argument = row_pointers;
1032 mjpeg->y_argument = y_plane;
1033 mjpeg->u_argument = u_plane;
1034 mjpeg->v_argument = v_plane;
1035 // User colormodel doesn't match encoder colormodel
1036 // Copy to interlacing buffer first
1037 if(mjpeg->color_model != mjpeg->jpeg_color_model ||
1038 mjpeg->output_w != mjpeg->coded_w ||
1039 mjpeg->output_h != mjpeg->coded_h)
1040 {
1041 /*
1042 * printf("mjpeg_compress %d %d %d %d\n",
1043 * mjpeg->output_w, mjpeg->output_h, mjpeg->coded_w, mjpeg->coded_h);
1044 */
1045 cmodel_transfer(0,
1046 row_pointers,
1047 mjpeg->temp_rows[0][0],
1048 mjpeg->temp_rows[1][0],
1049 mjpeg->temp_rows[2][0],
1050 y_plane,
1051 u_plane,
1052 v_plane,
1053 0,
1054 0,
1055 mjpeg->output_w,
1056 mjpeg->output_h,
1057 0,
1058 0,
1059 mjpeg->output_w,
1060 mjpeg->output_h,
1061 mjpeg->color_model,
1062 mjpeg->jpeg_color_model,
1063 0,
1064 mjpeg->output_w,
1065 mjpeg->coded_w);
1066 }
1067
1068 /* Start the compressors on the image fields */
1069 if(mjpeg->deinterlace) corrected_fields = 1;
1070 for(i = 0; i < corrected_fields && !result; i++)
1071 {
1072 unlock_compress_loop(mjpeg->compressors[i]);
1073
1074 if(mjpeg->cpus < 2 && i < corrected_fields - 1)
1075 {
1076 lock_compress_loop(mjpeg->compressors[i]);
1077 }
1078 }
1079
1080 /* Wait for the compressors and store in master output */
1081 for(i = 0; i < corrected_fields && !result; i++)
1082 {
1083 if(mjpeg->cpus > 1 || i == corrected_fields - 1)
1084 {
1085 lock_compress_loop(mjpeg->compressors[i]);
1086 }
1087
1088 append_buffer(&mjpeg->output_data,
1089 &mjpeg->output_size,
1090 &mjpeg->output_allocated,
1091 mjpeg->compressors[i]->output_buffer,
1092 mjpeg->compressors[i]->output_size);
1093 if(i == 0) mjpeg->output_field2 = mjpeg->output_size;
1094 }
1095
1096 if(corrected_fields < mjpeg->fields)
1097 {
1098 append_buffer(&mjpeg->output_data,
1099 &mjpeg->output_size,
1100 &mjpeg->output_allocated,
1101 mjpeg->compressors[0]->output_buffer,
1102 mjpeg->compressors[0]->output_size);
1103 }
1104 //printf("mjpeg_compress 2\n");
1105 return 0;
1106 }
1107
1108
1109
1110 int mjpeg_decompress(mjpeg_t *mjpeg,
1111 unsigned char *buffer,
1112 long buffer_len,
1113 long input_field2,
1114 unsigned char **row_pointers,
1115 unsigned char *y_plane,
1116 unsigned char *u_plane,
1117 unsigned char *v_plane,
1118 int color_model,
1119 int cpus)
1120 {
1121 int i, result = 0;
1122 int got_first_thread = 0;
1123
1124 //printf("mjpeg_decompress 1 %d %d\n", buffer_len, input_field2);
1125 if(buffer_len == 0) return 1;
1126 if(input_field2 == 0 && mjpeg->fields > 1) return 1;
1127
1128 //printf("mjpeg_decompress 2\n");
1129 /* Create decompression engines as needed */
1130 for(i = 0; i < mjpeg->fields; i++)
1131 {
1132 if(!mjpeg->decompressors[i])
1133 {
1134 mjpeg->decompressors[i] = mjpeg_new_decompressor(mjpeg, i);
1135 }
1136 }
1137
1138 //printf("mjpeg_decompress 3\n");
1139 /* Arm YUV buffers */
1140 mjpeg->row_argument = row_pointers;
1141 mjpeg->y_argument = y_plane;
1142 mjpeg->u_argument = u_plane;
1143 mjpeg->v_argument = v_plane;
1144 mjpeg->input_data = buffer;
1145 mjpeg->input_size = buffer_len;
1146 mjpeg->input_field2 = input_field2;
1147 mjpeg->color_model = color_model;
1148 mjpeg->cpus = cpus;
1149
1150 //printf("mjpeg_decompress 4 %02x %02x %d %02x %02x\n", buffer[0], buffer[1], input_field2, buffer[input_field2], buffer[input_field2 + 1]);
1151 /* Start decompressors */
1152 for(i = 0; i < mjpeg->fields && !result; i++)
1153 {
1154 unlock_compress_loop(mjpeg->decompressors[i]);
1155
1156 // For dual CPUs, don't want second thread to start until temp data is allocated by the first.
1157 // For single CPUs, don't want two threads running simultaneously
1158 if(mjpeg->cpus < 2 || !mjpeg->temp_data)
1159 {
1160 lock_compress_loop(mjpeg->decompressors[i]);
1161 if(i == 0) got_first_thread = 1;
1162 }
1163 }
1164
1165 //printf("mjpeg_decompress 5\n");
1166 /* Wait for decompressors */
1167 for(i = 0; i < mjpeg->fields && !result; i++)
1168 {
1169 if(mjpeg->cpus > 1)
1170 {
1171 if(i > 0 || !got_first_thread)
1172 lock_compress_loop(mjpeg->decompressors[i]);
1173 }
1174 }
1175
1176 /* Convert colormodel */
1177 // User colormodel didn't match decompressor
1178 /*
1179 * if(!mjpeg->error &&
1180 * (mjpeg->jpeg_color_model != mjpeg->color_model ||
1181 * mjpeg->coded_w != mjpeg->output_w ||
1182 * mjpeg->coded_h != mjpeg->output_h))
1183 */
1184
1185 //printf("mjpeg_decompress 6 %d %d %d %d\n", mjpeg->coded_w, mjpeg->coded_h, mjpeg->output_w, mjpeg->output_h);
1186 if((mjpeg->jpeg_color_model != mjpeg->color_model ||
1187 mjpeg->coded_w != mjpeg->output_w ||
1188 mjpeg->coded_h != mjpeg->output_h)
1189 &&
1190 (mjpeg->temp_data ||
1191 !mjpeg->error))
1192 {
1193 unsigned char *y_in = mjpeg->temp_rows[0][0];
1194 unsigned char *u_in = mjpeg->temp_rows[1][0];
1195 unsigned char *v_in = mjpeg->temp_rows[2][0];
1196
1197 /*
1198 * printf("mjpeg_decompress 7 in_rowspan=%d out_rowspan=%d\n",
1199 * mjpeg->coded_w,
1200 * mjpeg->rowspan ? mjpeg->rowspan : mjpeg->output_w);
1201 */
1202 cmodel_transfer(row_pointers,
1203 0,
1204 y_plane,
1205 u_plane,
1206 v_plane,
1207 y_in,
1208 u_in,
1209 v_in,
1210 0,
1211 0,
1212 mjpeg->output_w,
1213 mjpeg->output_h,
1214 0,
1215 0,
1216 mjpeg->output_w,
1217 mjpeg->output_h,
1218 mjpeg->jpeg_color_model,
1219 mjpeg->color_model,
1220 0,
1221 mjpeg->coded_w,
1222 mjpeg->rowspan ? mjpeg->rowspan : mjpeg->output_w);
1223 //printf("mjpeg_decompress 8\n");
1224 }
1225 return 0;
1226 }
1227
1228
1229 void mjpeg_set_deinterlace(mjpeg_t *mjpeg, int value)
1230 {
1231 mjpeg->deinterlace = value;
1232 }
1233
1234 void mjpeg_set_quality(mjpeg_t *mjpeg, int quality)
1235 {
1236 mjpeg->quality = quality;
1237 }
1238
1239 void mjpeg_set_float(mjpeg_t *mjpeg, int use_float)
1240 {
1241 mjpeg->use_float = use_float;
1242 }
1243
1244 void mjpeg_set_cpus(mjpeg_t *mjpeg, int cpus)
1245 {
1246 mjpeg->cpus = cpus;
1247 }
1248
1249 void mjpeg_set_rowspan(mjpeg_t *mjpeg, int rowspan)
1250 {
1251 mjpeg->rowspan = rowspan;
1252 }
1253
1254 int mjpeg_get_fields(mjpeg_t *mjpeg)
1255 {
1256 return mjpeg->fields;
1257 }
1258
1259
1260 mjpeg_t* mjpeg_new(int w,
1261 int h,
1262 int fields)
1263 {
1264 mjpeg_t *result = calloc(1, sizeof(mjpeg_t));
1265 pthread_mutexattr_t mutex_attr;
1266 int i;
1267
1268 result->output_w = w;
1269 result->output_h = h;
1270 result->fields = fields;
1271 result->color_model = BC_RGB888;
1272 result->cpus = 1;
1273 result->quality = 80;
1274 result->use_float = 0;
1275
1276 pthread_mutexattr_init(&mutex_attr);
1277 // pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_ADAPTIVE_NP);
1278 pthread_mutex_init(&(result->decompress_init), &mutex_attr);
1279
1280
1281 // Calculate coded dimensions
1282 // An interlaced frame with 4:2:0 sampling must be a multiple of 32
1283
1284 result->coded_w = (w % 16) ? w + (16 - (w % 16)) : w;
1285
1286 if(fields == 1)
1287 result->coded_h = (h % 16) ? h + (16 - (h % 16)) : h;
1288 else
1289 result->coded_h = (h % 32) ? h + (32 - (h % 32)) : h;
1290
1291
1292
1293 //printf("mjpeg_new %d %d %d %d\n", result->output_w, result->output_h, result->coded_w, result->coded_h);
1294 return result;
1295 }
1296
1297
1298
1299
1300 void mjpeg_delete(mjpeg_t *mjpeg)
1301 {
1302 int i;
1303 //printf("mjpeg_delete 1\n");
1304 for(i = 0; i < mjpeg->fields; i++)
1305 {
1306 //printf("mjpeg_delete 2\n");
1307 if(mjpeg->compressors[i]) mjpeg_delete_compressor(mjpeg->compressors[i]);
1308 //printf("mjpeg_delete 3\n");
1309 if(mjpeg->decompressors[i]) mjpeg_delete_decompressor(mjpeg->decompressors[i]);
1310 //printf("mjpeg_delete 4\n");
1311 }
1312 //printf("mjpeg_delete 5\n");
1313 delete_temps(mjpeg);
1314 //printf("mjpeg_delete 6\n");
1315 delete_buffer(&mjpeg->output_data, &mjpeg->output_size, &mjpeg->output_allocated);
1316 //printf("mjpeg_delete 7\n");
1317 free(mjpeg);
1318 //printf("mjpeg_delete 2\n");
1319 }
1320
1321
1322 /* Open up a space to insert a marker */
1323 static void insert_space(unsigned char **buffer,
1324 long *buffer_size,
1325 long *buffer_allocated,
1326 long space_start,
1327 long space_len)
1328 {
1329 int in, out;
1330 // Make sure enough space is available
1331 if(*buffer_allocated - *buffer_size < space_len)
1332 {
1333 *buffer_allocated += space_len;
1334 *buffer = realloc(*buffer, *buffer_allocated);
1335 }
1336
1337 // Shift data back
1338 for(in = *buffer_size - 1, out = *buffer_size - 1 + space_len;
1339 in >= space_start;
1340 in--, out--)
1341 {
1342 (*buffer)[out] = (*buffer)[in];
1343 }
1344 *buffer_size += space_len;
1345 }
1346
1347
1348 static inline int nextbyte(unsigned char *data, long *offset, long length)
1349 {
1350 if(length - *offset < 1) return 0;
1351 *offset += 1;
1352 return (unsigned char)data[*offset - 1];
1353 }
1354
1355 static inline int read_int32(unsigned char *data, long *offset, long length)
1356 {
1357 if(length - *offset < 4)
1358 {
1359 *offset = length;
1360 return 0;
1361 }
1362 *offset += 4;
1363 return ((((unsigned int)data[*offset - 4]) << 24) |
1364 (((unsigned int)data[*offset - 3]) << 16) |
1365 (((unsigned int)data[*offset - 2]) << 8) |
1366 (((unsigned int)data[*offset - 1])));
1367 }
1368
1369 static inline int read_int16(unsigned char *data, long *offset, long length)
1370 {
1371 if(length - *offset < 2)
1372 {
1373 *offset = length;
1374 return 0;
1375 }
1376
1377 *offset += 2;
1378 return ((((unsigned int)data[*offset - 2]) << 8) |
1379 (((unsigned int)data[*offset - 1])));
1380 }
1381
1382 static inline unsigned char read_char(unsigned char *data, long *offset, long length)
1383 {
1384 if(length - *offset < 1)
1385 {
1386 *offset = length;
1387 return 0;
1388 }
1389
1390 *offset += 1;
1391 return (unsigned char)data[*offset - 1];
1392 }
1393
1394 static inline int next_int16(unsigned char *data, long *offset, long length)
1395 {
1396 if(length - *offset < 2)
1397 {
1398 return 0;
1399 }
1400
1401 return ((((unsigned int)data[*offset]) << 8) |
1402 (((unsigned int)data[*offset + 1])));
1403 }
1404
1405 static inline void write_int32(unsigned char *data, long *offset, long length, unsigned int value)
1406 {
1407 if(length - *offset < 4)
1408 {
1409 *offset = length;
1410 return;
1411 }
1412
1413
1414 data[(*offset)++] = (unsigned int)(value & 0xff000000) >> 24;
1415 data[(*offset)++] = (unsigned int)(value & 0xff0000) >> 16;
1416 data[(*offset)++] = (unsigned int)(value & 0xff00) >> 8;
1417 data[(*offset)++] = (unsigned char)(value & 0xff);
1418 return;
1419 }
1420
1421 static inline void write_char(unsigned char *data, long *offset, long length, unsigned char value)
1422 {
1423 if(length - *offset < 1)
1424 {
1425 *offset = length;
1426 return;
1427 }
1428
1429 data[(*offset)++] = value;
1430 return;
1431 }
1432
1433 static int next_marker(unsigned char *buffer, long *offset, long buffer_size)
1434 {
1435 int c, done = 0; /* 1 - completion 2 - error */
1436
1437 while(*offset < buffer_size - 1)
1438 {
1439 if(buffer[*offset] == 0xff && buffer[*offset + 1] != 0xff)
1440 {
1441 (*offset) += 2;
1442 return buffer[*offset - 1];
1443 }
1444
1445 (*offset)++;
1446 }
1447
1448 return 0;
1449
1450 }
1451
1452 /* Find the next marker after offset and return 0 on success */
1453 static int find_marker(unsigned char *buffer,
1454 long *offset,
1455 long buffer_size,
1456 unsigned long marker_type)
1457 {
1458 long result = 0;
1459 long marker_len;
1460
1461 while(!result && *offset < buffer_size - 1)
1462 {
1463 int marker = next_marker(buffer, offset, buffer_size);
1464 if(marker == (marker_type & 0xff)) result = 1;
1465 }
1466
1467 return !result;
1468 }
1469
1470
1471 typedef struct
1472 {
1473 int field_size;
1474 int padded_field_size;
1475 int next_offset;
1476 int quant_offset;
1477 int huffman_offset;
1478 int image_offset;
1479 int scan_offset;
1480 int data_offset;
1481 } qt_hdr_t;
1482
1483 typedef struct
1484 {
1485 int field_number;
1486 int field_size;
1487 int unpadded_field_size;
1488 } avi_hdr_t;
1489
1490 #define LML_MARKER_SIZE 0x2c
1491 #define LML_MARKER_TAG 0xffe3
1492 void insert_lml33_markers(unsigned char **buffer,
1493 long *field2_offset,
1494 long *buffer_size,
1495 long *buffer_allocated)
1496 {
1497 long marker_offset = -1;
1498 int marker_exists;
1499
1500 /* Search for existing marker to replace */
1501 // marker_offset = find_marker(*buffer, *buffer_size, LML_MARKER_TAG);
1502
1503 /* Insert new marker */
1504 if(marker_offset < 0)
1505 {
1506 marker_offset = 2;
1507 insert_space(buffer,
1508 buffer_size,
1509 buffer_allocated,
1510 2,
1511 LML_MARKER_SIZE);
1512 }
1513 }
1514
1515 static int qt_table_offsets(unsigned char *buffer,
1516 long buffer_size,
1517 qt_hdr_t *header)
1518 {
1519 int done = 0;
1520 long offset = 0;
1521 int marker = 0;
1522 int field = 0;
1523 int len;
1524 int result = 0;
1525
1526 bzero(header, sizeof(qt_hdr_t) * 2);
1527
1528 // Read every marker to get the offsets for the headers
1529 for(field = 0; field < 2; field++)
1530 {
1531 done = 0;
1532
1533 while(!done)
1534 {
1535 marker = next_marker(buffer,
1536 &offset,
1537 buffer_size);
1538
1539 len = 0;
1540
1541 switch(marker)
1542 {
1543 case M_SOI:
1544 // The first field may be padded
1545 if(field > 0)
1546 {
1547 header[0].next_offset =
1548 header[0].padded_field_size =
1549 offset - 2;
1550 }
1551 len = 0;
1552 break;
1553
1554 case M_APP1:
1555 // Quicktime marker already exists. Abort.
1556 if(buffer[offset + 6] == 'm' &&
1557 buffer[offset + 7] == 'j' &&
1558 buffer[offset + 8] == 'p' &&
1559 buffer[offset + 9] == 'a')
1560 {
1561 result = 1;
1562 done = 1;
1563 }
1564 break;
1565
1566 case M_DQT:
1567 if(!header[field].quant_offset)
1568 {
1569 header[field].quant_offset = offset - 2;
1570 if(field > 0)
1571 header[field].quant_offset -= header[0].next_offset;
1572 }
1573 len = read_int16(buffer, &offset, buffer_size);
1574 len -= 2;
1575 break;
1576
1577 case M_DHT:
1578 if(!header[field].huffman_offset)
1579 {
1580 header[field].huffman_offset = offset - 2;
1581 if(field > 0)
1582 header[field].huffman_offset -= header[0].next_offset;
1583 }
1584 len = read_int16(buffer, &offset, buffer_size);
1585 len -= 2;
1586 break;
1587
1588 case M_SOF0:
1589 if(!header[field].image_offset)
1590 {
1591 header[field].image_offset = offset - 2;
1592 if(field > 0)
1593 header[field].image_offset -= header[0].next_offset;
1594 }
1595 len = read_int16(buffer, &offset, buffer_size);
1596 len -= 2;
1597 break;
1598
1599 case M_SOS:
1600 header[field].scan_offset = offset - 2;
1601 if(field > 0)
1602 header[field].scan_offset -= header[0].next_offset;
1603 len = read_int16(buffer, &offset, buffer_size);
1604 len -= 2;
1605 header[field].data_offset = offset + len;
1606 if(field > 0)
1607 header[field].data_offset -= header[0].next_offset;
1608 break;
1609
1610 // case 0:
1611 case M_EOI:
1612 if(field > 0)
1613 {
1614 header[field].field_size =
1615 header[field].padded_field_size =
1616 offset - header[0].next_offset;
1617 header[field].next_offset = 0;
1618 }
1619 else
1620 {
1621 // Often misses second SOI but gets first EOI
1622 // header[0].next_offset =
1623 // header[0].padded_field_size =
1624 // offset;
1625 }
1626 //printf("table_offsets M_EOI %d %x\n", field, offset);
1627 done = 1;
1628 len = 0;
1629 break;
1630
1631 default:
1632 // Junk appears between fields
1633 len = 0;
1634 // len = read_int16(buffer, &offset, buffer_size);
1635 // len -= 2;
1636 break;
1637 }
1638
1639 if(!done) offset += len;
1640 if(offset >= buffer_size) done = 1;
1641 }
1642 //printf("qt_table_offsets 10 %d\n", field);
1643 }
1644
1645 return result;
1646 }
1647
1648 static void insert_quicktime_marker(unsigned char *buffer,
1649 long buffer_size,
1650 long offset,
1651 qt_hdr_t *header)
1652 {
1653 write_int32(buffer, &offset, buffer_size, 0xff000000 |
1654 ((unsigned long)M_APP1 << 16) |
1655 (QUICKTIME_MARKER_SIZE - 2));
1656 write_int32(buffer, &offset, buffer_size, 0);
1657 write_int32(buffer, &offset, buffer_size, QUICKTIME_JPEG_TAG);
1658 write_int32(buffer, &offset, buffer_size, header->field_size);
1659 write_int32(buffer, &offset, buffer_size, header->padded_field_size);
1660 write_int32(buffer, &offset, buffer_size, header->next_offset);
1661 write_int32(buffer, &offset, buffer_size, header->quant_offset);
1662 write_int32(buffer, &offset, buffer_size, header->huffman_offset);
1663 write_int32(buffer, &offset, buffer_size, header->image_offset);
1664 write_int32(buffer, &offset, buffer_size, header->scan_offset);
1665 write_int32(buffer, &offset, buffer_size, header->data_offset);
1666 }
1667
1668
1669 void mjpeg_insert_quicktime_markers(unsigned char **buffer,
1670 long *buffer_size,
1671 long *buffer_allocated,
1672 int fields,
1673 long *field2_offset)
1674 {
1675 qt_hdr_t header[2];
1676 long offset = 0;
1677 int exists = 0;
1678 *field2_offset = -1;
1679
1680 if(fields < 2) return;
1681
1682
1683 // Get offsets for tables in both fields
1684 exists = qt_table_offsets(*buffer, *buffer_size, header);
1685
1686 // APP1 for quicktime already exists
1687 if(exists) return;
1688
1689 //printf("mjpeg_insert_quicktime_markers %x %02x %02x\n",
1690 // header[0].next_offset, (*buffer)[*field2_offset], (*buffer)[*field2_offset + 1]);
1691 //if(*field2_offset == 0)
1692 // fwrite(*buffer, *buffer_size, 1, stdout);
1693
1694
1695
1696 header[0].field_size += QUICKTIME_MARKER_SIZE;
1697 header[0].padded_field_size += QUICKTIME_MARKER_SIZE;
1698 header[0].next_offset += QUICKTIME_MARKER_SIZE;
1699 header[0].quant_offset += QUICKTIME_MARKER_SIZE;
1700 header[0].huffman_offset += QUICKTIME_MARKER_SIZE;
1701 header[0].image_offset += QUICKTIME_MARKER_SIZE;
1702 header[0].scan_offset += QUICKTIME_MARKER_SIZE;
1703 header[0].data_offset += QUICKTIME_MARKER_SIZE;
1704 header[1].field_size += QUICKTIME_MARKER_SIZE;
1705 header[1].padded_field_size += QUICKTIME_MARKER_SIZE;
1706 header[1].quant_offset += QUICKTIME_MARKER_SIZE;
1707 header[1].huffman_offset += QUICKTIME_MARKER_SIZE;
1708 header[1].image_offset += QUICKTIME_MARKER_SIZE;
1709 header[1].scan_offset += QUICKTIME_MARKER_SIZE;
1710 header[1].data_offset += QUICKTIME_MARKER_SIZE;
1711 *field2_offset = header[0].next_offset;
1712
1713
1714
1715 // Insert APP1 marker
1716 insert_space(buffer,
1717 buffer_size,
1718 buffer_allocated,
1719 2,
1720 QUICKTIME_MARKER_SIZE);
1721
1722 insert_quicktime_marker(*buffer,
1723 *buffer_size,
1724 2,
1725 &header[0]);
1726
1727 insert_space(buffer,
1728 buffer_size,
1729 buffer_allocated,
1730 header[0].next_offset + 2,
1731 QUICKTIME_MARKER_SIZE);
1732
1733 header[1].next_offset = 0;
1734 insert_quicktime_marker(*buffer,
1735 *buffer_size,
1736 header[0].next_offset + 2,
1737 &header[1]);
1738 }
1739
1740
1741 static int avi_table_offsets(unsigned char *buffer,
1742 long buffer_size,
1743 avi_hdr_t *header)
1744 {
1745 int field2 = mjpeg_get_field2(buffer, buffer_size);
1746
1747 header[0].field_number = 1;
1748 header[0].field_size = field2;
1749 header[0].unpadded_field_size = field2;
1750
1751 header[1].field_number = 2;
1752 header[1].field_size = buffer_size - field2;
1753 header[1].unpadded_field_size = buffer_size - field2;
1754 return 0;
1755 }
1756
1757 static void insert_avi_marker(unsigned char *buffer,
1758 long buffer_size,
1759 long offset,
1760 avi_hdr_t *header)
1761 {
1762 write_int32(buffer, &offset, buffer_size, 0xff000000 |
1763 ((unsigned long)M_APP0 << 16) |
1764 (AVI_MARKER_SIZE - 2));
1765 write_int32(buffer, &offset, buffer_size, QUICKTIME_AVI_TAG);
1766
1767 // One version of McRoweSoft only allows field polarity while
1768 // another version allows field size.
1769 write_char(buffer, &offset, buffer_size, header->field_number);
1770 write_char(buffer, &offset, buffer_size, 0);
1771 write_int32(buffer, &offset, buffer_size, header->field_size);
1772 write_int32(buffer, &offset, buffer_size, header->unpadded_field_size);
1773 }
1774
1775 void mjpeg_insert_avi_markers(unsigned char **buffer,
1776 long *buffer_size,
1777 long *buffer_allocated,
1778 int fields,
1779 long *field2_offset)
1780 {
1781 avi_hdr_t header[2];
1782 long offset = 0;
1783 *field2_offset = -1;
1784
1785
1786 // Test for existing marker
1787 if(!find_marker(*buffer, &offset, *buffer_size, M_APP0))
1788 {
1789 if((*buffer)[offset + 2] == 'A' &&
1790 (*buffer)[offset + 3] == 'V' &&
1791 (*buffer)[offset + 4] == 'I' &&
1792 (*buffer)[offset + 5] == '1')
1793 return;
1794 }
1795
1796
1797 avi_table_offsets(*buffer, *buffer_size, header);
1798
1799 header[0].field_size += AVI_MARKER_SIZE;
1800 header[0].unpadded_field_size += AVI_MARKER_SIZE;
1801 header[1].field_size += AVI_MARKER_SIZE;
1802 header[1].unpadded_field_size += AVI_MARKER_SIZE;
1803 *field2_offset = header[0].field_size;
1804
1805 // Insert APP0 marker into field 1
1806 insert_space(buffer,
1807 buffer_size,
1808 buffer_allocated,
1809 2,
1810 AVI_MARKER_SIZE);
1811 insert_avi_marker(*buffer,
1812 *buffer_size,
1813 2,
1814 &header[0]);
1815
1816 insert_space(buffer,
1817 buffer_size,
1818 buffer_allocated,
1819 *field2_offset + 2,
1820 AVI_MARKER_SIZE);
1821 insert_avi_marker(*buffer,
1822 *buffer_size,
1823 *field2_offset + 2,
1824 &header[1]);
1825
1826
1827
1828 }
1829
1830
1831 static void read_avi_markers(unsigned char *buffer,
1832 long buffer_size,
1833 avi_hdr_t *header)
1834 {
1835 long offset = 0;
1836 int marker_count = 0;
1837 int result = 0;
1838 int marker_size = 0;
1839 while(marker_count < 2 && offset < buffer_size && !result)
1840 {
1841 result = find_marker(buffer,
1842 &offset,
1843 buffer_size,
1844 M_APP0);
1845 marker_size = ((unsigned char)buffer[offset] << 8) | (unsigned char)buffer[offset];
1846
1847
1848 if(!result && marker_size >= 16)
1849 {
1850 // Marker size, AVI1
1851 offset += 6;
1852 // field polarity
1853 header[marker_count].field_number = read_char(buffer, &offset, buffer_size);
1854 read_char(buffer, &offset, buffer_size);
1855 header[marker_count].field_size = read_int32(buffer, &offset, buffer_size);
1856 header[marker_count].unpadded_field_size = read_int32(buffer, &offset, buffer_size);
1857 marker_count++;
1858 }
1859 }
1860 }
1861
1862
1863 static void read_quicktime_markers(unsigned char *buffer,
1864 long buffer_size,
1865 qt_hdr_t *header)
1866 {
1867 long offset = 0;
1868 int marker_count = 0;
1869 int result = 0;
1870
1871 while(marker_count < 2 && offset < buffer_size && !result)
1872 {
1873 result = find_marker(buffer,
1874 &offset,
1875 buffer_size,
1876 M_APP1);
1877
1878 if(!result)
1879 {
1880 // Marker size
1881 read_int16(buffer, &offset, buffer_size);
1882 // Zero
1883 read_int32(buffer, &offset, buffer_size);
1884 // MJPA
1885 read_int32(buffer, &offset, buffer_size);
1886 // Information
1887 header[marker_count].field_size = read_int32(buffer, &offset, buffer_size);
1888 header[marker_count].padded_field_size = read_int32(buffer, &offset, buffer_size);
1889 header[marker_count].next_offset = read_int32(buffer, &offset, buffer_size);
1890 header[marker_count].quant_offset = read_int32(buffer, &offset, buffer_size);
1891 header[marker_count].huffman_offset = read_int32(buffer, &offset, buffer_size);
1892 header[marker_count].image_offset = read_int32(buffer, &offset, buffer_size);
1893 header[marker_count].scan_offset = read_int32(buffer, &offset, buffer_size);
1894 header[marker_count].data_offset = read_int32(buffer, &offset, buffer_size);
1895 marker_count++;
1896 }
1897 }
1898 //printf("read_quicktime_markers 1 %d\n", marker_count);
1899 }
1900
1901 long mjpeg_get_quicktime_field2(unsigned char *buffer, long buffer_size)
1902 {
1903 qt_hdr_t header[2];
1904 bzero(&header, sizeof(qt_hdr_t) * 2);
1905
1906 read_quicktime_markers(buffer, buffer_size, header);
1907 return header[0].next_offset;
1908 }
1909
1910 long mjpeg_get_avi_field2(unsigned char *buffer,
1911 long buffer_size,
1912 int *field_dominance)
1913 {
1914 avi_hdr_t header[2];
1915 bzero(&header, sizeof(avi_hdr_t) * 2);
1916 read_avi_markers(buffer, buffer_size, header);
1917
1918 *field_dominance = (header[0].field_number == 1) ? 1 : 2;
1919
1920 // One version of McRoweSoft only allows field polarity while
1921 // another version allows field size.
1922 if(header[0].field_size)
1923 {
1924 return header[0].field_size;
1925 }
1926 else
1927 {
1928 return mjpeg_get_field2(buffer, buffer_size);
1929 }
1930 return 0;
1931 }
1932
1933 long mjpeg_get_field2(unsigned char *buffer, long buffer_size)
1934 {
1935 long result = 0;
1936 int total_fields = 0;
1937 long offset = 0;
1938 long field2_offset = 0;
1939 int i;
1940
1941 for(i = 0; i < buffer_size; i++)
1942 {
1943 if(buffer[i] == 0xff && buffer[i + 1] == M_SOI)
1944 {
1945 total_fields++;
1946 field2_offset = i;
1947 if(total_fields == 2) break;
1948 }
1949 }
1950
1951
1952 return field2_offset;
1953 }
1954
1955 void mjpeg_video_size(unsigned char *data, long data_size, int *w, int *h)
1956 {
1957 long offset = 0;
1958 find_marker(data,
1959 &offset,
1960 data_size,
1961 M_SOF0);
1962 *h = (data[offset + 3] << 8) | (data[offset + 4]);
1963 *w = (data[offset + 5] << 8) | (data[offset + 6]);
1964 }
1965
1966
Mirror of private repository