mixer undo fix, new ffmpeg opts, docs
[goodguy/history.git] / cinelerra-5.1 / cinelerra / filetiff.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 "edit.h"
24 #include "file.h"
25 #include "filetiff.h"
26 #include "interlacemodes.h"
27 #include "language.h"
28 #include "vframe.h"
29 #include "mainerror.h"
30
31 #include <stdint.h>
32 #include <string.h>
33 #include <unistd.h>
34
35 FileTIFF::FileTIFF(Asset *asset, File *file)
36  : FileList(asset, file, "TIFFLIST", ".tif", FILE_TIFF, FILE_TIFF_LIST)
37 {
38         asset->video_data = 1;
39         temp = 0;
40 }
41
42 FileTIFF::~FileTIFF()
43 {
44         if(temp) delete temp;
45 }
46
47
48 void FileTIFF::get_parameters(BC_WindowBase *parent_window,
49         Asset *asset,
50         BC_WindowBase* &format_window,
51         int audio_options,
52         int video_options)
53 {
54         if(video_options)
55         {
56                 TIFFConfigVideo *window = new TIFFConfigVideo(parent_window, asset);
57                 format_window = window;
58                 window->create_objects();
59                 window->run_window();
60                 delete window;
61         }
62 }
63
64
65 int FileTIFF::check_sig(Asset *asset)
66 {
67         FILE *stream = fopen(asset->path, "rb");
68
69         if(stream)
70         {
71                 char test[10];
72                 (void)fread(test, 10, 1, stream);
73                 fclose(stream);
74
75                 if(test[0] == 'I' && test[1] == 'I')
76                 {
77                         // Reject cr2, libtiff fails with it
78                         if( test[4] == 0x10 && !test[5] && !test[6] && !test[7] &&
79                                         test[8] == 'C' && test[9] == 'R' )
80                                 return 0;
81                         return 1;
82                 }
83                 else
84                 if(test[0] == 'T' && test[1] == 'I' && test[2] == 'F' && test[3] == 'F' &&
85                         test[4] == 'L' && test[5] == 'I' && test[6] == 'S' && test[7] == 'T')
86                 {
87                         return 1;
88                 }
89                 else
90                 if(strlen(asset->path) > 4 &&
91                         !strcasecmp(asset->path + strlen(asset->path) - 4, ".tif"))
92                 {
93                         return 1;
94                 }
95                 else
96                 if(strlen(asset->path) > 5 &&
97                         !strcasecmp(asset->path + strlen(asset->path) - 5, ".tiff"))
98                 {
99                         return 1;
100                 }
101         }
102         return 0;
103 }
104
105 const char* FileTIFF::compression_to_str(int value)
106 {
107         switch(value)
108         {
109                 case FileTIFF::NONE: return "None"; break;
110                 case FileTIFF::LZW: return "LZW"; break;
111                 case FileTIFF::PACK_BITS: return "Pack Bits"; break;
112                 case FileTIFF::DEFLATE: return "Deflate"; break;
113                 case FileTIFF::JPEG: return "JPEG"; break;
114                 default:
115                         return "None";
116                         break;
117         }
118 }
119
120 const char* FileTIFF::cmodel_to_str(int value)
121 {
122         switch(value)
123         {
124                 case FileTIFF::GREYSCALE: return "Greyscale"; break;
125                 case FileTIFF::RGB_888: return "RGB-8 Bit"; break;
126                 case FileTIFF::RGB_161616: return "RGB-16 Bit"; break;
127                 case FileTIFF::RGBA_8888: return "RGBA-8 Bit"; break;
128                 case FileTIFF::RGBA_16161616: return "RGBA-16 Bit"; break;
129                 case FileTIFF::RGB_FLOAT: return "RGB-FLOAT"; break;
130                 case FileTIFF::RGBA_FLOAT: return "RGBA-FLOAT"; break;
131                 default:
132                         return "RGB-8 Bit";
133                         break;
134         }
135 }
136
137
138 int FileTIFF::can_copy_from(Asset *asset, int64_t position)
139 {
140         if(asset->format == FILE_TIFF_LIST ||
141                 asset->format == FILE_TIFF)
142                 return 1;
143
144         return 0;
145 }
146
147
148
149 int FileTIFF::read_frame_header(char *path)
150 {
151         TIFF *stream;
152         int result = 0;
153
154         if(!(stream = TIFFOpen(path, "rb")))
155         {
156                 eprintf("Error while opening \"%s\" for reading. \n%m\n", asset->path);
157                 return 1;
158         }
159
160         char *ptr = 0;
161         TIFFGetField(stream, TIFFTAG_MODEL, &ptr);
162 //printf("FileTIFF::read_frame_header 1 %s\n", ptr);
163         if(ptr && !strcmp(ptr, "Canon EOS-1DS"))       // FIXME: Does this have a purpose?
164         {
165                 printf("FileTIFF::read_frame_header: got a %s.\n",
166                         ptr);
167         }
168
169 // The raw format for certain cameras deviates from TIFF here.
170
171         TIFFGetField(stream, TIFFTAG_IMAGEWIDTH, &(asset->width));
172         TIFFGetField(stream, TIFFTAG_IMAGELENGTH, &(asset->height));
173
174         int components = 0;
175         TIFFGetField(stream, TIFFTAG_SAMPLESPERPIXEL, &components);
176         int bitspersample = 0;
177         TIFFGetField(stream, TIFFTAG_BITSPERSAMPLE, &bitspersample);
178         int sampleformat = 0;
179         TIFFGetField(stream, TIFFTAG_SAMPLEFORMAT, &sampleformat);
180
181         if(bitspersample == 8 && components == 3)
182                 asset->tiff_cmodel = FileTIFF::RGB_888;
183         else
184         if(bitspersample == 16 && components == 3)
185                 asset->tiff_cmodel = FileTIFF::RGB_161616;
186         else
187         if(bitspersample == 8 && components == 4)
188                 asset->tiff_cmodel = FileTIFF::RGBA_8888;
189         else
190         if(bitspersample == 16 && components == 4)
191                 asset->tiff_cmodel = FileTIFF::RGBA_16161616;
192         else
193         if(bitspersample == 32 && components == 3)
194                 asset->tiff_cmodel = FileTIFF::RGB_FLOAT;
195         else
196         if(bitspersample == 32 && components == 4)
197                 asset->tiff_cmodel = FileTIFF::RGBA_FLOAT;
198         else
199         if(bitspersample == 8 && (components == 1 || components == 0))
200                 asset->tiff_cmodel = FileTIFF::GREYSCALE;
201
202 //printf("FileTIFF::read_frame_header %d %d %d\n", bitspersample, components, asset->tiff_cmodel);
203         TIFFClose(stream);
204
205         asset->interlace_mode = ILACE_MODE_NOTINTERLACED;
206         return result;
207 }
208
209 int FileTIFF::colormodel_supported(int colormodel)
210 {
211         switch(asset->tiff_cmodel)
212         {
213                 case FileTIFF::RGB_888: return BC_RGB888; break;
214                 case FileTIFF::RGB_161616: return BC_RGB_FLOAT; break;
215                 case FileTIFF::GREYSCALE: return BC_RGB888; break;
216                 case FileTIFF::RGBA_8888: return BC_RGBA8888; break;
217                 case FileTIFF::RGBA_16161616: return BC_RGBA_FLOAT; break;
218                 case FileTIFF::RGB_FLOAT: return BC_RGB_FLOAT; break;
219                 case FileTIFF::RGBA_FLOAT: return BC_RGBA_FLOAT; break;
220                 default: return BC_RGB888; break;
221         }
222 }
223
224 int FileTIFF::get_best_colormodel(Asset *asset, int driver)
225 {
226         switch(asset->tiff_cmodel)
227         {
228                 case FileTIFF::GREYSCALE: return BC_RGB888; break;
229                 case FileTIFF::RGB_888: return BC_RGB888; break;
230                 case FileTIFF::RGB_161616: return BC_RGB_FLOAT; break;
231                 case FileTIFF::RGBA_8888: return BC_RGBA8888; break;
232                 case FileTIFF::RGBA_16161616: return BC_RGBA_FLOAT; break;
233                 case FileTIFF::RGB_FLOAT: return BC_RGB_FLOAT; break;
234                 case FileTIFF::RGBA_FLOAT: return BC_RGBA_FLOAT; break;
235                 default: return BC_RGB888; break;
236         }
237 }
238
239
240 static tsize_t tiff_read(thandle_t ptr, tdata_t buf, tsize_t size)
241 {
242         FileTIFFUnit *tiff_unit = (FileTIFFUnit*)ptr;
243         if(tiff_unit->data->get_compressed_size() < tiff_unit->offset + size)
244                 return 0;
245         memcpy(buf, tiff_unit->data->get_data() + tiff_unit->offset, size);
246         tiff_unit->offset += size;
247         return size;
248 }
249
250 static tsize_t tiff_write(thandle_t ptr, tdata_t buf, tsize_t size)
251 {
252         FileTIFFUnit *tiff_unit = (FileTIFFUnit*)ptr;
253         if(tiff_unit->data->get_compressed_allocated() < tiff_unit->offset + size)
254         {
255                 tiff_unit->data->allocate_compressed_data((tiff_unit->offset + size) * 2);
256         }
257
258
259         if(tiff_unit->data->get_compressed_size() < tiff_unit->offset + size)
260                 tiff_unit->data->set_compressed_size(tiff_unit->offset + size);
261         memcpy(tiff_unit->data->get_data() + tiff_unit->offset,
262                 buf,
263                 size);
264         tiff_unit->offset += size;
265         return size;
266 }
267
268 static toff_t tiff_seek(thandle_t ptr, toff_t off, int whence)
269 {
270         FileTIFFUnit *tiff_unit = (FileTIFFUnit*)ptr;
271         switch(whence)
272         {
273                 case SEEK_SET:
274                         tiff_unit->offset = off;
275                         break;
276                 case SEEK_CUR:
277                         tiff_unit->offset += off;
278                         break;
279                 case SEEK_END:
280                         tiff_unit->offset = tiff_unit->data->get_compressed_size() + off;
281                         break;
282         }
283         return tiff_unit->offset;
284 }
285
286 static int tiff_close(thandle_t ptr)
287 {
288         return 0;
289 }
290
291 static toff_t tiff_size(thandle_t ptr)
292 {
293         FileTIFFUnit *tiff_unit = (FileTIFFUnit*)ptr;
294         return tiff_unit->data->get_compressed_size();
295 }
296
297 static int tiff_mmap(thandle_t ptr, tdata_t* pbase, toff_t* psize)
298 {
299         FileTIFFUnit *tiff_unit = (FileTIFFUnit*)ptr;
300         *pbase = tiff_unit->data->get_data();
301         *psize = tiff_unit->data->get_compressed_size();
302         return 0;
303 }
304
305 void tiff_unmap(thandle_t ptr, tdata_t base, toff_t size)
306 {
307 }
308
309 int FileTIFF::read_frame(VFrame *output, VFrame *input)
310 {
311         FileTIFFUnit *unit = new FileTIFFUnit(this, 0);
312         TIFF *stream;
313         unit->offset = 0;
314         unit->data = input;
315
316         stream = TIFFClientOpen("FileTIFF",
317                 "r",
318             (void*)unit,
319             tiff_read,
320                 tiff_write,
321             tiff_seek,
322                 tiff_close,
323             tiff_size,
324             tiff_mmap,
325                 tiff_unmap);
326
327 // This loads the original TIFF data into each scanline of the output frame,
328 // assuming the output scanlines are bigger than the input scanlines.
329 // Then it expands the input data in reverse to fill the row.
330         for(int i = 0; i < asset->height; i++)
331         {
332                 TIFFReadScanline(stream, output->get_rows()[i], i, 0);
333
334 // For the greyscale model, the output is RGB888 but the input must be expanded
335                 if(asset->tiff_cmodel == FileTIFF::GREYSCALE)
336                 {
337                         unsigned char *row = output->get_rows()[i];
338                         for(int j = output->get_w() - 1; j >= 0; j--)
339                         {
340                                 unsigned char value = row[j];
341                                 row[j * 3] = value;
342                                 row[j * 3 + 1] = value;
343                                 row[j * 3 + 2] = value;
344                         }
345                 }
346 // For the 16 bit models, the output is floating point.
347                 else
348                 if(asset->tiff_cmodel == FileTIFF::RGB_161616)
349                 {
350                         uint16_t *input_row = (uint16_t*)output->get_rows()[i];
351                         float *output_row = (float*)output->get_rows()[i];
352                         for(int j = output->get_w() - 1; j >= 0; j--)
353                         {
354                                 uint16_t r = input_row[j * 3];
355                                 uint16_t g = input_row[j * 3 + 1];
356                                 uint16_t b = input_row[j * 3 + 2];
357                                 output_row[j * 3] = (float)r / 65535;
358                                 output_row[j * 3 + 1] = (float)g / 65535;
359                                 output_row[j * 3 + 2] = (float)b / 65535;
360                         }
361                 }
362                 else
363                 if(asset->tiff_cmodel == FileTIFF::RGBA_16161616)
364                 {
365                         uint16_t *input_row = (uint16_t*)output->get_rows()[i];
366                         float *output_row = (float*)output->get_rows()[i];
367                         for(int j = output->get_w() - 1; j >= 0; j--)
368                         {
369                                 uint16_t r = input_row[j * 4];
370                                 uint16_t g = input_row[j * 4 + 1];
371                                 uint16_t b = input_row[j * 4 + 2];
372                                 output_row[j * 4] = (float)r / 65535;
373                                 output_row[j * 4 + 1] = (float)g / 65535;
374                                 output_row[j * 4 + 2] = (float)b / 65535;
375                         }
376                 }
377         }
378
379         TIFFClose(stream);
380         delete unit;
381
382         return 0;
383 }
384
385 int FileTIFF::write_frame(VFrame *frame, VFrame *data, FrameWriterUnit *unit)
386 {
387 //printf("FileTIFF::write_frame 1\n");
388         FileTIFFUnit *tiff_unit = (FileTIFFUnit*)unit;
389         int result = 0;
390         TIFF *stream;
391         tiff_unit->offset = 0;
392         tiff_unit->data = data;
393         tiff_unit->data->set_compressed_size(0);
394
395         stream = TIFFClientOpen("FileTIFF",
396                 "w",
397             (void*)tiff_unit,
398             tiff_read,
399                 tiff_write,
400             tiff_seek,
401                 tiff_close,
402             tiff_size,
403             tiff_mmap,
404                 tiff_unmap);
405
406         int components, color_model, bits, compression;
407         int sampleformat = SAMPLEFORMAT_UINT;
408         //int bytesperrow, type;
409         switch(asset->tiff_cmodel)
410         {
411                 case FileTIFF::RGB_888:
412                         components = 3;
413                         color_model = BC_RGB888;
414                         bits = 8;
415                         //type = TIFF_BYTE;
416                         //bytesperrow = 3 * asset->width;
417                         break;
418                 case FileTIFF::RGB_161616:
419                         components = 3;
420                         color_model = BC_RGB_FLOAT;
421                         bits = 16;
422                         //type = TIFF_SHORT;
423                         //bytesperrow = 6 * asset->width;
424                         break;
425                 case FileTIFF::RGBA_8888:
426                         components = 4;
427                         color_model = BC_RGBA8888;
428                         bits = 8;
429                         //type = TIFF_BYTE;
430                         //bytesperrow = 4 * asset->width;
431                         break;
432                 case FileTIFF::RGBA_16161616:
433                         components = 4;
434                         color_model = BC_RGBA_FLOAT;
435                         bits = 16;
436                         //type = TIFF_SHORT;
437                         //bytesperrow = 8 * asset->width;
438                         break;
439                 case FileTIFF::RGB_FLOAT:
440                         components = 3;
441                         color_model = BC_RGB_FLOAT;
442                         bits = 32;
443                         //type = TIFF_FLOAT;
444                         sampleformat = SAMPLEFORMAT_IEEEFP;
445                         //bytesperrow = 12 * asset->width;
446                         break;
447                 case FileTIFF::RGBA_FLOAT:
448                         components = 4;
449                         color_model = BC_RGBA_FLOAT;
450                         bits = 32;
451                         //type = TIFF_FLOAT;
452                         sampleformat = SAMPLEFORMAT_IEEEFP;
453                         //bytesperrow = 16 * asset->width;
454                         break;
455                 default:
456                         components = 3;
457                         color_model = BC_RGB888;
458                         bits = 8;
459                         //type = TIFF_BYTE;
460                         //bytesperrow = 3 * asset->width;
461                         break;
462         }
463
464
465         switch(asset->tiff_compression)
466         {
467                 case FileTIFF::LZW:
468                         compression = COMPRESSION_LZW;
469                         break;
470                 case FileTIFF::PACK_BITS:
471                         compression = COMPRESSION_PACKBITS;
472                         break;
473                 case FileTIFF::DEFLATE:
474                         compression = COMPRESSION_DEFLATE;
475                         break;
476                 case FileTIFF::JPEG:
477                         compression = COMPRESSION_JPEG;
478                         break;
479                 default:
480                         compression = COMPRESSION_NONE;
481                         break;
482         }
483
484         TIFFSetField(stream, TIFFTAG_IMAGEWIDTH, asset->width);
485         TIFFSetField(stream, TIFFTAG_IMAGELENGTH, asset->height);
486         TIFFSetField(stream, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
487         TIFFSetField(stream, TIFFTAG_SAMPLESPERPIXEL, components);
488         TIFFSetField(stream, TIFFTAG_BITSPERSAMPLE, bits);
489     TIFFSetField(stream, TIFFTAG_SAMPLEFORMAT, sampleformat);
490         TIFFSetField(stream, TIFFTAG_COMPRESSION, compression);
491         TIFFSetField(stream, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
492         TIFFSetField(stream, TIFFTAG_ROWSPERSTRIP,
493                 TIFFDefaultStripSize(stream, (uint32_t)-1));
494 //      TIFFSetField(stream, TIFFTAG_ROWSPERSTRIP,
495 //              (8 * 1024) / bytesperrow);
496         TIFFSetField(stream, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
497
498         if(frame->get_color_model() == color_model)
499         {
500                 for(int i = 0; i < asset->height; i++)
501                 {
502                         TIFFWriteScanline(stream, frame->get_rows()[i], i, 0);
503                 }
504         }
505         else
506         {
507                 if(tiff_unit->temp &&
508                         tiff_unit->temp->get_color_model() != color_model)
509                 {
510                         delete tiff_unit->temp;
511                         tiff_unit->temp = 0;
512                 }
513                 if(!tiff_unit->temp)
514                 {
515                         tiff_unit->temp =
516                                 new VFrame(asset->width, asset->height, color_model, 0);
517                 }
518
519                 BC_CModels::transfer(tiff_unit->temp->get_rows(),
520                         frame->get_rows(),
521                         tiff_unit->temp->get_y(),
522                         tiff_unit->temp->get_u(),
523                         tiff_unit->temp->get_v(),
524                         frame->get_y(),
525                         frame->get_u(),
526                         frame->get_v(),
527                         0,
528                         0,
529                         frame->get_w(),
530                         frame->get_h(),
531                         0,
532                         0,
533                         frame->get_w(),
534                         frame->get_h(),
535                         frame->get_color_model(),
536                         color_model,
537                         0,
538                         frame->get_w(),
539                         frame->get_w());
540                 for(int i = 0; i < asset->height; i++)
541                 {
542                         TIFFWriteScanline(stream, tiff_unit->temp->get_rows()[i], i, 0);
543                 }
544         }
545
546         TIFFClose(stream);
547
548 //printf("FileTIFF::write_frame 10\n");
549         return result;
550 }
551
552 FrameWriterUnit* FileTIFF::new_writer_unit(FrameWriter *writer)
553 {
554         return new FileTIFFUnit(this, writer);
555 }
556
557
558
559
560
561
562
563
564 FileTIFFUnit::FileTIFFUnit(FileTIFF *file, FrameWriter *writer)
565  : FrameWriterUnit(writer)
566 {
567         this->file = file;
568         temp = 0;
569 }
570
571 FileTIFFUnit::~FileTIFFUnit()
572 {
573         if(temp) delete temp;
574 }
575
576
577
578
579
580
581
582
583
584
585
586
587 TIFFConfigVideo::TIFFConfigVideo(BC_WindowBase *parent_window, Asset *asset)
588  : BC_Window(_(PROGRAM_NAME ": Video Compression"),
589         parent_window->get_abs_cursor_x(1),
590         parent_window->get_abs_cursor_y(1),
591         400,
592         200)
593 {
594         this->parent_window = parent_window;
595         this->asset = asset;
596 }
597
598 TIFFConfigVideo::~TIFFConfigVideo()
599 {
600 }
601
602 void TIFFConfigVideo::create_objects()
603 {
604         lock_window("TIFFConfigVideo::create_objects()");
605         int x = 10, y = 10;
606
607         add_subwindow(new BC_Title(x, y, _("Colorspace:")));
608         TIFFColorspace *menu1;
609         add_subwindow(menu1 = new TIFFColorspace(this, x + 150, y, 200));
610         menu1->create_objects();
611         y += 40;
612         add_subwindow(new BC_Title(x, y, _("Compression:")));
613         TIFFCompression *menu2;
614         add_subwindow(menu2 = new TIFFCompression(this, x + 150, y, 200));
615         menu2->create_objects();
616
617         add_subwindow(new BC_OKButton(this));
618         show_window(1);
619         unlock_window();
620 }
621
622 int TIFFConfigVideo::close_event()
623 {
624         set_done(0);
625         return 1;
626 }
627
628
629
630
631
632
633 TIFFColorspace::TIFFColorspace(TIFFConfigVideo *gui, int x, int y, int w)
634  : BC_PopupMenu(x,
635         y,
636         w,
637         FileTIFF::cmodel_to_str(gui->asset->tiff_cmodel))
638 {
639         this->gui = gui;
640 }
641 int TIFFColorspace::handle_event()
642 {
643         return 1;
644 }
645 void TIFFColorspace::create_objects()
646 {
647         add_item(new TIFFColorspaceItem(gui, FileTIFF::RGB_888));
648 //      add_item(new TIFFColorspaceItem(gui, FileTIFF::RGB_16161616));
649         add_item(new TIFFColorspaceItem(gui, FileTIFF::RGBA_8888));
650 //      add_item(new TIFFColorspaceItem(gui, FileTIFF::RGBA_16161616));
651         add_item(new TIFFColorspaceItem(gui, FileTIFF::RGB_FLOAT));
652         add_item(new TIFFColorspaceItem(gui, FileTIFF::RGBA_FLOAT));
653 }
654
655
656 TIFFColorspaceItem::TIFFColorspaceItem(TIFFConfigVideo *gui, int value)
657  : BC_MenuItem(FileTIFF::cmodel_to_str(value))
658 {
659         this->gui = gui;
660         this->value = value;
661 }
662 int TIFFColorspaceItem::handle_event()
663 {
664         gui->asset->tiff_cmodel = value;
665         return 0;
666 }
667
668
669
670
671
672
673
674 TIFFCompression::TIFFCompression(TIFFConfigVideo *gui, int x, int y, int w)
675  : BC_PopupMenu(x, y, w, FileTIFF::compression_to_str(gui->asset->tiff_compression))
676 {
677         this->gui = gui;
678 }
679 int TIFFCompression::handle_event()
680 {
681         return 1;
682 }
683 void TIFFCompression::create_objects()
684 {
685         add_item(new TIFFCompressionItem(gui, FileTIFF::NONE));
686 //      add_item(new TIFFCompressionItem(gui, FileTIFF::LZW));
687         add_item(new TIFFCompressionItem(gui, FileTIFF::PACK_BITS));
688 //      add_item(new TIFFCompressionItem(gui, FileTIFF::DEFLATE));
689 //      add_item(new TIFFCompressionItem(gui, FileTIFF::JPEG));
690 }
691
692
693
694
695
696 TIFFCompressionItem::TIFFCompressionItem(TIFFConfigVideo *gui, int value)
697  : BC_MenuItem(FileTIFF::compression_to_str(value))
698 {
699         this->gui = gui;
700         this->value = value;
701 }
702 int TIFFCompressionItem::handle_event()
703 {
704         gui->asset->tiff_compression = value;
705         return 0;
706 }
707
708
709