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