cinelerra-5.1/cinelerra/fileexr.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 #ifdef HAVE_OPENEXR
  23
  24 #include "asset.h"
  25 #include "bcsignals.h"
  26 #include "clip.h"
  27 #include "file.h"
  28 #include "fileexr.h"
  29 #include "filesystem.h"
  30 #include "interlacemodes.h"
  31
  32 #include "mwindow.inc"
  33 #include "vframe.h"
  34
  35 #include "ImfChannelList.h"
  36 #include "ImfChromaticities.h"
  37 #include "ImfCompression.h"
  38 #include "ImfIO.h"
  39 #include "ImfInputFile.h"
  40 #include "ImfOutputFile.h"
  41 #include "ImfPixelType.h"
  42 #include "ImfRgbaFile.h"
  43 #include "ImfRgbaYca.h"
  44 #include "ImfVersion.h"
  45
  46 class EXRIStream : public Imf::IStream
  47 {
  48 public:
  49         EXRIStream(char *data, int size);
  50         ~EXRIStream();
  51
  52         bool read (char c[], int n);
  53         uint64_t tellg ();
  54         void seekg (uint64_t pos);
  55         void clear ();
  56
  57 private:
  58         char *data;
  59         int size;
  60         int position;
  61 };
  62
  63 class EXROStream : public Imf::OStream
  64 {
  65 public:
  66         EXROStream(VFrame *data);
  67         ~EXROStream();
  68
  69     virtual void write(const char c[], int n);
  70     virtual uint64_t tellp();
  71     virtual void seekp(uint64_t pos);
  72
  73 private:
  74         VFrame *data;
  75         int position;
  76 };
  77
  78
  79
  80 EXRIStream::EXRIStream(char *data, int size)
  81  : Imf::IStream("mypath")
  82 {
  83         this->data = data;
  84         this->size = size;
  85         position = 0;
  86 }
  87
  88 EXRIStream::~EXRIStream()
  89 {
  90 }
  91
  92 bool EXRIStream::read(char c[], int n)
  93 {
  94         int fragment = n;
  95         if(position + fragment > size)
  96         {
  97                 fragment = size - position;
  98         }
  99         memcpy(c, data + position, fragment);
 100         position += fragment;
 101
 102         if(n != fragment)
 103         {
 104                 throw Iex::InputExc ("EXRIStream::read: Unexpected end of file.");
 105         }
 106         return position >= size;
 107 }
 108
 109 uint64_t EXRIStream::tellg ()
 110 {
 111         return position;
 112 }
 113
 114 void EXRIStream::seekg(uint64_t pos)
 115 {
 116         position = pos;
 117 }
 118
 119 void EXRIStream::clear()
 120 {
 121 }
 122
 123
 124 EXROStream::EXROStream(VFrame *data)
 125  : Imf::OStream("mypath")
 126 {
 127         this->data = data;
 128         position = 0;
 129 }
 130 EXROStream::~EXROStream()
 131 {
 132 }
 133
 134 void EXROStream::write(const char c[], int n)
 135 {
 136         if(position + n > data->get_compressed_allocated())
 137                 data->allocate_compressed_data(MAX(position + n, data->get_compressed_allocated() * 2));
 138
 139         memcpy(data->get_data() + position, c, n);
 140         position += n;
 141         data->set_compressed_size(MAX(position, data->get_compressed_size()));
 142 }
 143
 144 uint64_t EXROStream::tellp()
 145 {
 146         return position;
 147 }
 148
 149 void EXROStream::seekp(uint64_t pos)
 150 {
 151         position = pos;
 152 }
 153
 154
 155 FileEXR::FileEXR(Asset *asset, File *file)
 156  : FileList(asset, file, "EXRLIST", ".exr", FILE_EXR, FILE_EXR_LIST)
 157 {
 158         native_cmodel = BC_RGB_FLOAT;
 159         is_yuv = 0;
 160         temp_y = 0;
 161         temp_u = 0;
 162         temp_v = 0;
 163 }
 164
 165 FileEXR::~FileEXR()
 166 {
 167         delete [] temp_y;
 168         delete [] temp_u;
 169         delete [] temp_v;
 170 }
 171
 172 const char* FileEXR::compression_to_str(int compression)
 173 {
 174         switch( compression ) {
 175         case NONE:      break;
 176         case PIZ:       return "PIZ";
 177         case ZIP:       return "ZIP";
 178         case ZIPS:      return "ZIPS";
 179         case RLE:       return "RLE";
 180         case PXR24:     return "PXR24";
 181         case B44:       return "B44";
 182         case B44A:      return "B44A";
 183         case DWAB:      return "DWAB";
 184         case DWAA:      return "DWAA";
 185         }
 186         return _("None");
 187 }
 188
 189 int FileEXR::compression_to_exr(int compression)
 190 {
 191         switch( compression ) {
 192         case NONE:      return Imf::NO_COMPRESSION;
 193         case PIZ:       return Imf::PIZ_COMPRESSION;
 194         case ZIP:       return Imf::ZIP_COMPRESSION;
 195         case ZIPS:      return Imf::ZIPS_COMPRESSION;
 196         case RLE:       return Imf::RLE_COMPRESSION;
 197         case PXR24:     return Imf::PXR24_COMPRESSION;
 198         case B44:       return Imf::B44_COMPRESSION;
 199         case B44A:      return Imf::B44A_COMPRESSION;
 200         case DWAA:      return Imf::DWAA_COMPRESSION;
 201         case DWAB:      return Imf::DWAB_COMPRESSION;
 202         }
 203         return Imf::NO_COMPRESSION;
 204 }
 205
 206 int FileEXR::str_to_compression(char *string)
 207 {
 208         if( !strcmp(compression_to_str(NONE), string) ) return NONE;
 209         if( !strcmp(compression_to_str(PIZ), string)  ) return PIZ;
 210         if( !strcmp(compression_to_str(ZIP), string)  ) return ZIP;
 211         if( !strcmp(compression_to_str(ZIPS), string) ) return ZIPS;
 212         if( !strcmp(compression_to_str(RLE), string)  ) return RLE;
 213         if( !strcmp(compression_to_str(RLE), string)  ) return B44;
 214         if( !strcmp(compression_to_str(RLE), string)  ) return B44A;
 215         if( !strcmp(compression_to_str(RLE), string)  ) return DWAA;
 216         if( !strcmp(compression_to_str(RLE), string)  ) return DWAB;
 217         if( !strcmp(compression_to_str(PXR24),string) ) return PXR24;
 218         return NONE;
 219 }
 220
 221 int FileEXR::check_sig(Asset *asset, char *test)
 222 {
 223         if(Imf::isImfMagic(test)) return 1;
 224         if(test[0] == 'E' && test[1] == 'X' && test[2] == 'R' &&
 225                 test[3] == 'L' && test[4] == 'I' && test[5] == 'S' && test[6] == 'T')
 226         {
 227                 return 1;
 228         }
 229
 230         return 0;
 231 }
 232
 233 void FileEXR::get_parameters(BC_WindowBase *parent_window,
 234         Asset *asset, BC_WindowBase* &format_window,
 235         int audio_options, int video_options, EDL *edl)
 236 {
 237         if( video_options ) {
 238                 EXRConfigVideo *window = new EXRConfigVideo(parent_window, asset);
 239                 format_window = window;
 240                 window->create_objects();
 241                 window->run_window();
 242                 delete window;
 243         }
 244 }
 245
 246 int FileEXR::colormodel_supported(int colormodel)
 247 {
 248         return native_cmodel;
 249 }
 250
 251 int FileEXR::get_best_colormodel(Asset *asset, int driver)
 252 {
 253         return asset->exr_use_alpha ? BC_RGBA_FLOAT : BC_RGB_FLOAT;
 254 }
 255
 256 int64_t FileEXR::get_memory_usage()
 257 {
 258         int64_t result = FileList::get_memory_usage();
 259         if(temp_y) result += (int64_t)asset->width * asset->height * 3 / 2;
 260         return result;
 261 }
 262
 263
 264 int FileEXR::read_frame_header(char *path)
 265 {
 266         int result = 0;
 267
 268 // This may have been used by VFS
 269 //      FILE *stream;
 270 //
 271 //      if(!(stream = fopen(path, "rb")))
 272 //      {
 273 //              perror("FileEXR::read_frame_header");
 274 //              return 1;
 275 //      }
 276 //      int size = FileSystem::get_size(path);
 277 //      char *buffer = new char[size];
 278 //      fread(buffer, size, 1, stream);
 279 //      fclose(stream);
 280 //
 281 //      EXRIStream exr_stream(buffer, size);
 282 //      Imf::InputFile file(exr_stream);
 283
 284         if( access(path, R_OK) ) return 1;
 285         Imf::InputFile file(path);
 286
 287         Imath::Box2i dw = file.header().dataWindow();
 288
 289         asset->width = dw.max.x - dw.min.x + 1;
 290         asset->height = dw.max.y - dw.min.y + 1;
 291         asset->interlace_mode = ILACE_MODE_NOTINTERLACED;
 292
 293         const Imf::ChannelList &channels = file.header().channels();
 294
 295         if(channels.findChannel("A"))
 296                 native_cmodel = BC_RGBA_FLOAT;
 297         else
 298                 native_cmodel = BC_RGB_FLOAT;
 299         asset->exr_use_alpha = BC_CModels::has_alpha(native_cmodel) ? 1 : 0;
 300
 301         if(channels.findChannel("Y"))
 302                 is_yuv = 1;
 303 // for (Imf::ChannelList::ConstIterator i = channels.begin(); i != channels.end(); ++i)
 304 // {
 305 // printf("%s\n", i.name());
 306 // }
 307
 308 //      delete [] buffer;
 309         return result;
 310 }
 311
 312 int FileEXR::read_frame(VFrame *frame, VFrame *data)
 313 {
 314         Imf::setGlobalThreadCount(file->cpus);
 315         EXRIStream exr_stream((char*)data->get_data(), data->get_compressed_size());
 316         Imf::InputFile file(exr_stream);
 317         Imath::Box2i dw = file.header().dataWindow();
 318         int dx = dw.min.x, dy = dw.min.y;
 319         Imf::FrameBuffer framebuffer;
 320         float **rows = (float**)frame->get_rows();
 321         int components = BC_CModels::components(frame->get_color_model());
 322
 323         if( is_yuv ) {
 324                 if( !temp_y ) temp_y = new float[asset->width * asset->height];
 325                 if( !temp_u ) temp_u = new float[asset->width * asset->height / 4];
 326                 if( !temp_v ) temp_v = new float[asset->width * asset->height / 4];
 327                 framebuffer.insert("Y", Imf::Slice(Imf::FLOAT,
 328                         (char*)(temp_y - dy * asset->width - dx),
 329                         sizeof(float),
 330                         sizeof(float) * frame->get_w()));
 331                 framebuffer.insert("BY", Imf::Slice(Imf::FLOAT,
 332                         (char*)(temp_u - dy * asset->width / 4 - dx / 2),
 333                         sizeof(float),
 334                         sizeof(float) * frame->get_w() / 2,
 335                         2,
 336                         2));
 337                 framebuffer.insert("RY", Imf::Slice(Imf::FLOAT,
 338                         (char*)(temp_v - dy * asset->width / 4 - dx / 2),
 339                         sizeof(float),
 340                         sizeof(float) * frame->get_w() / 2,
 341                         2,
 342                         2));
 343         }
 344         else {
 345                 framebuffer.insert("R", Imf::Slice(Imf::FLOAT,
 346                         (char*)(&rows[-dy][-dx * components]),
 347                         sizeof(float) * components,
 348                         sizeof(float) * components * frame->get_w()));
 349                 framebuffer.insert("G", Imf::Slice(Imf::FLOAT,
 350                         (char*)(&rows[-dy][-dx * components + 1]),
 351                         sizeof(float) * components,
 352                         sizeof(float) * components * frame->get_w()));
 353                 framebuffer.insert("B", Imf::Slice(Imf::FLOAT,
 354                         (char*)(&rows[-dy][-dx * components + 2]),
 355                         sizeof(float) * components,
 356                         sizeof(float) * components * frame->get_w()));
 357         }
 358
 359 // Alpha always goes directly to the output frame
 360         if( components == 4 ) {
 361                 framebuffer.insert("A", Imf::Slice(Imf::FLOAT,
 362                         (char*)(&rows[-dy][-dx * components + 3]),
 363                         sizeof(float) * components,
 364                         sizeof(float) * components * frame->get_w()));
 365         }
 366
 367         file.setFrameBuffer(framebuffer);
 368         file.readPixels (dw.min.y, dw.max.y);
 369
 370         if( is_yuv ) {
 371 // Convert to RGB using crazy ILM equations
 372                 Imath::V3f yw;
 373                 Imf::Chromaticities cr;
 374                 yw = Imf::RgbaYca::computeYw(cr);
 375
 376                 for( int i=0; i<asset->height-1; i+=2 ) {
 377                         float *y_row1 = temp_y + i * asset->width;
 378                         float *y_row2 = temp_y + (i + 1) * asset->width;
 379                         float *u_row = temp_u + (i * asset->width / 4);
 380                         float *v_row = temp_v + (i * asset->width / 4);
 381                         float *out_row1 = rows[i];
 382                         float *out_row2 = rows[i + 1];
 383                         for( int j=0; j<asset->width-1; j+=2 ) {
 384                                 float v = *u_row++;
 385                                 float u = *v_row++;
 386                                 float y;
 387
 388                                 float r, g, b;
 389                                 y = *y_row1++;
 390                                 r = (u + 1) * y;
 391                                 b = (v + 1) * y;
 392                                 g = (y - r * yw.x - b * yw.z) / yw.y;
 393                                 *out_row1++ = r;
 394                                 *out_row1++ = g;
 395                                 *out_row1++ = b;
 396                                 if(components == 4) out_row1++;
 397
 398                                 y = *y_row1++;
 399                                 r = (u + 1) * y;
 400                                 b = (v + 1) * y;
 401                                 g = (y - r * yw.x - b * yw.z) / yw.y;
 402                                 *out_row1++ = r;
 403                                 *out_row1++ = g;
 404                                 *out_row1++ = b;
 405                                 if(components == 4) out_row1++;
 406
 407                                 y = *y_row2++;
 408                                 r = (u + 1) * y;
 409                                 b = (v + 1) * y;
 410                                 g = (y - r * yw.x - b * yw.z) / yw.y;
 411                                 *out_row2++ = r;
 412                                 *out_row2++ = g;
 413                                 *out_row2++ = b;
 414                                 if(components == 4) out_row1++;
 415
 416                                 y = *y_row2++;
 417                                 r = (u + 1) * y;
 418                                 b = (v + 1) * y;
 419                                 g = (y - r * yw.x - b * yw.z) / yw.y;
 420                                 *out_row2++ = r;
 421                                 *out_row2++ = g;
 422                                 *out_row2++ = b;
 423                                 if(components == 4) out_row1++;
 424                         }
 425                 }
 426         }
 427         return 0;
 428 }
 429
 430
 431 int FileEXR::write_frame(VFrame *frame, VFrame *data, FrameWriterUnit *unit)
 432 {
 433         EXRUnit *exr_unit = (EXRUnit*)unit;
 434
 435         VFrame *output_frame;
 436         data->set_compressed_size(0);
 437         Imf::setGlobalThreadCount(file->cpus);
 438
 439         int native_cmodel = asset->exr_use_alpha ? BC_RGBA_FLOAT : BC_RGB_FLOAT;
 440         int components = BC_CModels::components(native_cmodel);
 441
 442         if( frame->get_color_model() != native_cmodel ) {
 443                 if( !exr_unit->temp_frame ) exr_unit->temp_frame =
 444                         new VFrame(asset->width, asset->height, native_cmodel, 0);
 445                 BC_CModels::transfer(exr_unit->temp_frame->get_rows(), /* Leave NULL if non existent */
 446                         frame->get_rows(),
 447                         exr_unit->temp_frame->get_y(), /* Leave NULL if non existent */
 448                         exr_unit->temp_frame->get_u(),
 449                         exr_unit->temp_frame->get_v(),
 450                         frame->get_y(), /* Leave NULL if non existent */
 451                         frame->get_u(),
 452                         frame->get_v(),
 453                         0,        /* Dimensions to capture from input frame */
 454                         0,
 455                         asset->width,
 456                         asset->height,
 457                         0,       /* Dimensions to project on output frame */
 458                         0,
 459                         asset->width,
 460                         asset->height,
 461                         frame->get_color_model(),
 462                         native_cmodel,
 463                         0,         /* When transfering BC_RGBA8888 to non-alpha this is the background color in 0xRRGGBB hex */
 464                         asset->width,       /* For planar use the luma rowspan */
 465                         asset->height);
 466                 output_frame = exr_unit->temp_frame;
 467         }
 468         else
 469                 output_frame = frame;
 470
 471         Imf::Header header(output_frame->get_w(), output_frame->get_h());
 472         header.compression() = (Imf::Compression)compression_to_exr(
 473                 asset->exr_compression);
 474         header.channels().insert("R", Imf::Channel(Imf::FLOAT));
 475         header.channels().insert("G", Imf::Channel(Imf::FLOAT));
 476         header.channels().insert("B", Imf::Channel(Imf::FLOAT));
 477         if(asset->exr_use_alpha) header.channels().insert("A", Imf::Channel(Imf::FLOAT));
 478
 479         EXROStream exr_stream(data);
 480         Imf::OutputFile file(exr_stream, header);
 481         Imf::FrameBuffer framebuffer;
 482         float **rows = (float**)output_frame->get_rows();
 483         framebuffer.insert("R",
 484                 Imf::Slice(Imf::FLOAT,
 485                         (char*)(rows[0]),
 486                         sizeof(float) * components,
 487                         sizeof(float) * components * output_frame->get_w()));
 488         framebuffer.insert("G",
 489                 Imf::Slice(Imf::FLOAT,
 490                         (char*)(rows[0] + 1),
 491                         sizeof(float) * components,
 492                         sizeof(float) * components * output_frame->get_w()));
 493         framebuffer.insert("B",
 494                 Imf::Slice(Imf::FLOAT,
 495                         (char*)(rows[0] + 2),
 496                         sizeof(float) * components,
 497                         sizeof(float) * components * output_frame->get_w()));
 498         if(asset->exr_use_alpha)
 499                 framebuffer.insert("A",
 500                         Imf::Slice(Imf::FLOAT,
 501                                 (char*)(rows[0] + 3),
 502                                 sizeof(float) * components,
 503                                 sizeof(float) * components * output_frame->get_w()));
 504         file.setFrameBuffer(framebuffer);
 505         file.writePixels(asset->height);
 506         return 0;
 507 }
 508
 509 int FileEXR::can_copy_from(Asset *asset, int64_t position)
 510 {
 511         if(asset->format == FILE_EXR ||
 512                 asset->format == FILE_EXR_LIST)
 513                 return 1;
 514
 515         return 0;
 516 }
 517
 518 FrameWriterUnit* FileEXR::new_writer_unit(FrameWriter *writer)
 519 {
 520         return new EXRUnit(this, writer);
 521 }
 522
 523
 524 EXRUnit::EXRUnit(FileEXR *file, FrameWriter *writer)
 525  : FrameWriterUnit(writer)
 526 {
 527         this->file = file;
 528         temp_frame = 0;
 529 }
 530
 531 EXRUnit::~EXRUnit()
 532 {
 533         if(temp_frame) delete temp_frame;
 534 }
 535
 536
 537 EXRConfigVideo::EXRConfigVideo(BC_WindowBase *parent_window, Asset *asset)
 538  : BC_Window(_(PROGRAM_NAME ": Video Compression"),
 539         parent_window->get_abs_cursor_x(1), parent_window->get_abs_cursor_y(1),
 540         xS(300), BC_OKButton::calculate_h() + yS(100))
 541 {
 542         this->parent_window = parent_window;
 543         this->asset = asset;
 544 // *** CONTEXT_HELP ***
 545         context_help_set_keyword("Single File Rendering");
 546 }
 547
 548 EXRConfigVideo::~EXRConfigVideo()
 549 {
 550 }
 551
 552 void EXRConfigVideo::create_objects()
 553 {
 554         lock_window("EXRConfigVideo::create_objects");
 555         int x = xS(10), y = yS(10);
 556         add_subwindow(new EXRUseAlpha(this, x, y));
 557         y += yS(30);
 558         EXRCompression *menu;
 559         add_subwindow(new BC_Title(x, y, _("Compression:")));
 560         x += xS(110);
 561         add_subwindow(menu = new EXRCompression(this, x, y, xS(100)));
 562         menu->create_objects();
 563         add_subwindow(new BC_OKButton(this));
 564         show_window(1);
 565         unlock_window();
 566 }
 567
 568 int EXRConfigVideo::close_event()
 569 {
 570         set_done(0);
 571         return 1;
 572 }
 573
 574
 575 EXRUseAlpha::EXRUseAlpha(EXRConfigVideo *gui, int x, int y)
 576  : BC_CheckBox(x, y, gui->asset->exr_use_alpha, _("Use alpha"))
 577 {
 578         this->gui = gui;
 579 }
 580
 581 int EXRUseAlpha::handle_event()
 582 {
 583         gui->asset->exr_use_alpha = get_value();
 584         return 1;
 585 }
 586
 587
 588
 589 EXRCompression::EXRCompression(EXRConfigVideo *gui, int x, int y, int w)
 590  : BC_PopupMenu(x, y, w,
 591         FileEXR::compression_to_str(gui->asset->exr_compression))
 592 {
 593         this->gui = gui;
 594 }
 595 void EXRCompression::create_objects()
 596 {
 597         add_item(new EXRCompressionItem(gui, FileEXR::NONE));
 598         add_item(new EXRCompressionItem(gui, FileEXR::PIZ));
 599         add_item(new EXRCompressionItem(gui, FileEXR::ZIP));
 600         add_item(new EXRCompressionItem(gui, FileEXR::ZIPS));
 601         add_item(new EXRCompressionItem(gui, FileEXR::RLE));
 602         add_item(new EXRCompressionItem(gui, FileEXR::PXR24));
 603         add_item(new EXRCompressionItem(gui, FileEXR::B44));
 604         add_item(new EXRCompressionItem(gui, FileEXR::B44A));
 605         add_item(new EXRCompressionItem(gui, FileEXR::DWAA));
 606         add_item(new EXRCompressionItem(gui, FileEXR::DWAB));
 607 }
 608
 609 int EXRCompression::handle_event()
 610 {
 611         return 1;
 612 }
 613
 614 EXRCompressionItem::EXRCompressionItem(EXRConfigVideo *gui, int value)
 615  : BC_MenuItem(FileEXR::compression_to_str(value))
 616 {
 617         this->gui = gui;
 618         this->value = value;
 619 }
 620
 621 int EXRCompressionItem::handle_event()
 622 {
 623         gui->asset->exr_compression = value;
 624         return 0;
 625 }
 626
 627 #endif