rework set default transtion, nested proxy edl fixes, doubleclick proxy media fix...
[goodguy/history.git] / cinelerra-5.1 / cinelerra / libmjpeg.h
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  #ifndef LIBMJPEG_H
19 #define LIBMJPEG_H
20
21
22 /* Motion JPEG library */
23
24
25
26 #ifdef __cplusplus
27 extern "C" {
28 #endif
29
30
31
32 #include <stdio.h>
33 #include <jpeglib.h>
34 #include <png.h>
35 #include "pthread.h"
36 #include <setjmp.h>
37
38 #define MAXFIELDS 2
39 #define QUICKTIME_MJPA_MARKSIZE 40
40 #define QUICKTIME_JPEG_TAG 0x6d6a7067
41 #define CODEC_TAG_MJPEG "mjpg"
42 #define CODEC_TAG_JPEG "jpeg"
43
44
45 struct mjpeg_error_mgr {
46   struct jpeg_error_mgr pub;    /* "public" fields */
47   jmp_buf setjmp_buffer;        /* for return to caller */
48 };
49
50 typedef struct mjpeg_error_mgr* mjpeg_error_ptr;
51
52
53 // The compressor structure is shared between decompressors and compressors
54 typedef struct
55 {
56         void *mjpeg;
57         int instance;
58         unsigned char *output_buffer;    /* Buffer for MJPEG output */
59         long output_size;     /* Size of image stored in buffer */
60         long output_allocated;    /* Allocated size of output buffer */
61         struct jpeg_decompress_struct jpeg_decompress;
62         struct jpeg_compress_struct jpeg_compress;
63         struct mjpeg_error_mgr jpeg_error;
64         pthread_t tid;   /* ID of thread */
65         pthread_mutex_t input_lock, output_lock;
66         int done;     /* Flag to end */
67         int error;
68 // Pointer to uncompressed YUV rows
69 // [3 planes][downsampled rows][downsampled pixels]
70         unsigned char **rows[3];
71 /* Temp rows for each MCU */
72         unsigned char **mcu_rows[3];
73 /* Height of the field */
74         int field_h;
75         int coded_field_h;
76 } mjpeg_compressor;
77
78 typedef struct
79 {
80 // Dimensions of user frame buffer
81         int output_w;
82         int output_h;
83 // Dimensions for encoder frame buffer
84         int coded_w, coded_h;
85         int fields;
86         int quality;
87         int use_float;
88         int kludge;
89         int cpus;
90 // Color model of user interface.
91         int color_model;
92 // Color model of compressed data.  Since MJPA streams use 4:2:0
93     int jpeg_color_model;
94 // To save on colormodel permutations, we flag grayscale separately and
95 // just set U and V to 0x80.
96         int greyscale;
97 // Error in compression process
98         int error;
99
100         mjpeg_compressor *compressors[MAXFIELDS];
101         mjpeg_compressor *decompressors[MAXFIELDS];
102
103 // Temp frame for interlacing
104 // [3 planes][downsampled rows][downsampled pixels]
105         unsigned char *temp_data;
106         unsigned char **temp_rows[3];
107         unsigned char **row_argument, *y_argument, *u_argument, *v_argument;
108
109 // Buffer passed to user
110 // This can contain one progressive field or two fields with headers
111         unsigned char *output_data;
112         long output_size;
113         long output_allocated;
114 // Offset to field2 in output_data
115         long output_field2;
116 // Buffer passed from user
117         unsigned char *input_data;
118         long input_size;
119 // Offset to field2 in input_data
120         long input_field2;
121         int deinterlace;
122         int rowspan;
123
124 // Workarounds for thread unsafe libraries
125         pthread_mutex_t decompress_init;
126         int decompress_initialized;
127 } mjpeg_t;
128
129
130
131
132
133 // Entry points
134 mjpeg_t* mjpeg_new(int w,
135         int h,
136         int fields);
137 void mjpeg_delete(mjpeg_t *mjpeg);
138
139 void mjpeg_set_quality(mjpeg_t *mjpeg, int quality);
140 void mjpeg_set_float(mjpeg_t *mjpeg, int use_float);
141 // This is useful when producing realtime NTSC output for a JPEG board.
142 void mjpeg_set_deinterlace(mjpeg_t *mjpeg, int value);
143 void mjpeg_set_cpus(mjpeg_t *mjpeg, int cpus);
144 void mjpeg_set_rowspan(mjpeg_t *mjpeg, int rowspan);
145
146
147 int mjpeg_get_fields(mjpeg_t *mjpeg);
148
149 int mjpeg_decompress(mjpeg_t *mjpeg,
150         unsigned char *buffer,
151         long buffer_len,
152         long input_field2,
153         unsigned char **row_pointers,
154         unsigned char *y_plane,
155         unsigned char *u_plane,
156         unsigned char *v_plane,
157         int color_model,
158         int cpus);
159
160 int mjpeg_compress(mjpeg_t *mjpeg,
161         unsigned char **row_pointers,
162         unsigned char *y_plane,
163         unsigned char *u_plane,
164         unsigned char *v_plane,
165         int color_model,
166         int cpus);
167
168 // Get buffer information after compressing
169 unsigned char* mjpeg_output_buffer(mjpeg_t *mjpeg);
170 // Called by decoder
171 long mjpeg_output_field2(mjpeg_t *mjpeg);
172 // Called before inserting markers by user
173 long mjpeg_output_size(mjpeg_t *mjpeg);
174 // Called before inserting markers by user
175 long mjpeg_output_allocated(mjpeg_t *mjpeg);
176 // Called after inserting markers by user to increase the size
177 void mjpeg_set_output_size(mjpeg_t *mjpeg, long output_size);
178
179 // Retrieve width and height from a buffer of JPEG data
180 void mjpeg_video_size(unsigned char *data, long data_size, int *w, int *h);
181
182
183
184 // Calculate marker contents and insert them into a buffer.
185 // Reallocates the buffer if it isn't big enough so make sure it's big enough
186 // when passing VFrames.
187 // field2_offset is set to -1 if the markers already exist or the field offset
188 // if markers don't already exist.
189 void mjpeg_insert_quicktime_markers(unsigned char **buffer,
190         long *buffer_size,
191         long *buffer_allocated,
192         int fields,
193         long *field2_offset);
194 void mjpeg_insert_avi_markers(unsigned char **buffer,
195         long *buffer_size,
196         long *buffer_allocated,
197         int fields,
198         long *field2_offset);
199
200 // Get the second field offset from the markers
201 long mjpeg_get_quicktime_field2(unsigned char *buffer, long buffer_size);
202 // Field dominance is retrieved for the jpeg decoder.  AVI stores field
203 // dominance in each field.
204 long mjpeg_get_avi_field2(unsigned char *buffer,
205         long buffer_size,
206         int *field_dominance);
207 long mjpeg_get_field2(unsigned char *buffer, long buffer_size);
208
209 #ifdef __cplusplus
210 }
211 #endif
212
213 #endif