cinelerra-5.1/cinelerra/filejpeg.C

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