xlat changes, layout changes
[goodguy/history.git] / cinelerra-5.1 / cinelerra / filejpeg.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "asset.h"
23 #include "bcsignals.h"
24 #include "edit.h"
25 #include "file.h"
26 #include "filejpeg.h"
27 #include "interlacemodes.h"
28 #include "jpegwrapper.h"
29 #include "language.h"
30 #include "libmjpeg.h"
31 #include "mwindow.inc"
32 #include "vframe.h"
33 #include "videodevice.inc"
34 #include "mainerror.h"
35
36
37 FileJPEG::FileJPEG(Asset *asset, File *file)
38  : FileList(asset, file, "JPEGLIST", ".jpg", FILE_JPEG, FILE_JPEG_LIST)
39 {
40         decompressor = 0;
41 }
42
43 FileJPEG::~FileJPEG()
44 {
45         if(decompressor) mjpeg_delete((mjpeg_t*)decompressor);
46 }
47
48
49 int FileJPEG::check_sig(Asset *asset)
50 {
51         FILE *stream = fopen(asset->path, "rb");
52
53         if(stream)
54         {
55                 char test[10];
56                 (void)fread(test, 10, 1, stream);
57                 fclose(stream);
58
59                 if(test[6] == 'J' && test[7] == 'F' && test[8] == 'I' && test[9] == 'F')
60                 {
61                         return 1;
62                 }
63                 else
64                 if(test[0] == 'J' && test[1] == 'P' && test[2] == 'E' && test[3] == 'G' &&
65                         test[4] == 'L' && test[5] == 'I' && test[6] == 'S' && test[7] == 'T')
66                 {
67                         return 1;
68                 }
69         }
70
71         if(strlen(asset->path) > 4)
72         {
73                 int len = strlen(asset->path);
74                 if(!strncasecmp(asset->path + len - 4, ".jpg", 4)) return 1;
75         }
76         return 0;
77 }
78
79
80
81 void FileJPEG::get_parameters(BC_WindowBase *parent_window,
82         Asset *asset,
83         BC_WindowBase* &format_window,
84         int audio_options,
85         int video_options)
86 {
87         if(video_options)
88         {
89                 JPEGConfigVideo *window = new JPEGConfigVideo(parent_window, asset);
90                 format_window = window;
91                 window->create_objects();
92                 window->run_window();
93                 delete window;
94         }
95 }
96
97
98 int FileJPEG::can_copy_from(Asset *asset, int64_t position)
99 {
100 //printf("FileJPEG::can_copy_from %d %s\n", asset->format, asset->vcodec);
101         if(asset->format == FILE_JPEG ||
102                 asset->format == FILE_JPEG_LIST)
103                 return 1;
104
105         return 0;
106 }
107
108 int FileJPEG::colormodel_supported(int colormodel)
109 {
110         return colormodel;
111 }
112
113
114 int FileJPEG::get_best_colormodel(Asset *asset, int driver)
115 {
116         switch(driver)
117         {
118                 case PLAYBACK_X11:
119                         return BC_RGB888;
120                         break;
121                 case PLAYBACK_X11_XV:
122                 case PLAYBACK_DV1394:
123                 case PLAYBACK_FIREWIRE:
124                 case PLAYBACK_ASYNCHRONOUS:
125                         return BC_YUV420P;
126                         break;
127                 case PLAYBACK_X11_GL:
128                         return BC_YUV888;
129                         break;
130                 case PLAYBACK_LML:
131                 case PLAYBACK_BUZ:
132                         return BC_YUV422P;
133                         break;
134                 case VIDEO4LINUX:
135                 case VIDEO4LINUX2:
136                         return BC_YUV420P;
137                         break;
138                 case CAPTURE_BUZ:
139                 case CAPTURE_LML:
140                 case VIDEO4LINUX2JPEG:
141                         return BC_YUV422;
142                         break;
143                 case CAPTURE_FIREWIRE:
144                 case CAPTURE_IEC61883:
145                         return BC_YUV420P;
146                         break;
147                 case CAPTURE_DVB:
148                 case VIDEO4LINUX2MPEG:
149                         return BC_YUV422P;
150                         break;
151         }
152         return BC_YUV420P;
153 }
154
155
156 int FileJPEG::write_frame(VFrame *frame, VFrame *data, FrameWriterUnit *unit)
157 {
158         int result = 0;
159         JPEGUnit *jpeg_unit = (JPEGUnit*)unit;
160
161         if(!jpeg_unit->compressor)
162                 jpeg_unit->compressor = mjpeg_new(asset->width,
163                         asset->height,
164                         1);
165
166         mjpeg_set_quality((mjpeg_t*)jpeg_unit->compressor, asset->jpeg_quality);
167
168
169         mjpeg_compress((mjpeg_t*)jpeg_unit->compressor,
170                 frame->get_rows(),
171                 frame->get_y(),
172                 frame->get_u(),
173                 frame->get_v(),
174                 frame->get_color_model(),
175                 1);
176
177         data->allocate_compressed_data(mjpeg_output_size((mjpeg_t*)jpeg_unit->compressor));
178         data->set_compressed_size(mjpeg_output_size((mjpeg_t*)jpeg_unit->compressor));
179         memcpy(data->get_data(),
180                 mjpeg_output_buffer((mjpeg_t*)jpeg_unit->compressor),
181                 mjpeg_output_size((mjpeg_t*)jpeg_unit->compressor));
182
183         return result;
184 }
185
186
187
188
189
190
191
192
193
194
195 int FileJPEG::read_frame_header(char *path)
196 {
197         int result = 0;
198
199
200         FILE *stream;
201
202         if(!(stream = fopen(path, "rb")))
203         {
204                 eprintf("FileJPEG::read_frame_header %s: %m\n", path);
205                 return 1;
206         }
207
208
209         unsigned char test[2];
210         (void)fread(test, 2, 1, stream);
211         if(test[0] != 0xff || test[1] != 0xd8)
212         {
213                 eprintf("FileJPEG::read_frame_header %s bad header %02x%02x\n",
214                         path, test[0], test[1]);
215                 fclose(stream);
216                 return 1;
217         }
218         fseek(stream, 0, SEEK_SET);
219
220         struct jpeg_decompress_struct jpeg_decompress;
221         struct jpeg_error_mgr jpeg_error;
222
223         jpeg_decompress.err = jpeg_std_error(&jpeg_error);
224         jpeg_create_decompress(&jpeg_decompress);
225
226         jpeg_stdio_src(&jpeg_decompress, stream);
227         jpeg_read_header(&jpeg_decompress, TRUE);
228
229         asset->width = jpeg_decompress.image_width;
230         asset->height = jpeg_decompress.image_height;
231
232         asset->interlace_mode = BC_ILACE_MODE_NOTINTERLACED;
233
234         jpeg_destroy((j_common_ptr)&jpeg_decompress);
235         fclose(stream);
236
237         return result;
238 }
239
240
241
242 int FileJPEG::read_frame(VFrame *output, VFrame *input)
243 {
244         if(input->get_compressed_size() < 2 ||
245                 input->get_data()[0] != 0xff ||
246                 input->get_data()[1] != 0xd8)
247                 return 1;
248
249         if(!decompressor) decompressor = mjpeg_new(asset->width,
250                 asset->height,
251                 1);
252 // printf("FileJPEG::read_frame %d %p %d %d %d %p %p %p %p %d\n",
253 // __LINE__,
254 // input->get_data(),
255 // input->get_compressed_size(),
256 // output->get_w(),
257 // output->get_h(),
258 // output->get_rows(),
259 // output->get_y(),
260 // output->get_u(),
261 // output->get_v(),
262 // output->get_color_model());
263         mjpeg_decompress((mjpeg_t*)decompressor,
264                 input->get_data(),
265                 input->get_compressed_size(),
266                 0,
267                 output->get_rows(),
268                 output->get_y(),
269                 output->get_u(),
270                 output->get_v(),
271                 output->get_color_model(),
272                 1);
273 //      PRINT_TRACE
274
275 //printf("FileJPEG::read_frame %d\n", __LINE__);
276         return 0;
277 }
278
279 FrameWriterUnit* FileJPEG::new_writer_unit(FrameWriter *writer)
280 {
281         return new JPEGUnit(this, writer);
282 }
283
284
285
286
287
288
289 JPEGUnit::JPEGUnit(FileJPEG *file, FrameWriter *writer)
290  : FrameWriterUnit(writer)
291 {
292         this->file = file;
293         compressor = 0;
294 }
295 JPEGUnit::~JPEGUnit()
296 {
297         if(compressor) mjpeg_delete((mjpeg_t*)compressor);
298 }
299
300
301
302
303
304
305
306 JPEGConfigVideo::JPEGConfigVideo(BC_WindowBase *parent_window, Asset *asset)
307  : BC_Window(_(PROGRAM_NAME ": Video Compression"),
308         parent_window->get_abs_cursor_x(1),
309         parent_window->get_abs_cursor_y(1),
310         400,
311         100)
312 {
313         this->parent_window = parent_window;
314         this->asset = asset;
315 }
316
317 JPEGConfigVideo::~JPEGConfigVideo()
318 {
319 }
320
321 void JPEGConfigVideo::create_objects()
322 {
323         int x = 10, y = 10;
324         lock_window("JPEGConfigVideo::create_objects");
325         add_subwindow(new BC_Title(x, y, _("Quality:")));
326         add_subwindow(new BC_ISlider(x + 80,
327                 y,
328                 0,
329                 200,
330                 200,
331                 0,
332                 100,
333                 asset->jpeg_quality,
334                 0,
335                 0,
336                 &asset->jpeg_quality));
337
338         add_subwindow(new BC_OKButton(this));
339         show_window(1);
340         unlock_window();
341 }
342
343 int JPEGConfigVideo::close_event()
344 {
345         set_done(0);
346         return 1;
347 }
348
349
350