cinelerra-5.1/cinelerra/filetga.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 "filetga.h"
  26 #include "language.h"
  27 #include "mwindow.inc"
  28 #include "vframe.h"
  29 #include "mainerror.h"
  30
  31 #include <string.h>
  32 #include <unistd.h>
  33
  34 /* Known image types. */
  35 #define TGA_TYPE_MAPPED      1
  36 #define TGA_TYPE_COLOR       2
  37 #define TGA_TYPE_GRAY        3
  38
  39 /* Only known compression is RLE */
  40 #define TGA_COMP_NONE        0
  41 #define TGA_COMP_RLE         1
  42
  43
  44 FileTGA::FileTGA(Asset *asset, File *file)
  45  : FileList(asset, file, "TGALIST", ".tga", FILE_TGA, FILE_TGA_LIST)
  46 {
  47         temp = 0;
  48 }
  49
  50 FileTGA::~FileTGA()
  51 {
  52         if(temp) delete temp;
  53 }
  54
  55 int FileTGA::check_sig(Asset *asset)
  56 {
  57
  58
  59 // Test file extension
  60         int result = 0;
  61         char *ext = strrchr(asset->path, '.');
  62
  63         if(ext)
  64         {
  65
  66                 if(!strncasecmp(ext, ".tga", 4)) result = 1;
  67
  68         }
  69
  70
  71
  72 // Test for list
  73         if(!result)
  74         {
  75                 FILE *stream;
  76                 if(!(stream = fopen(asset->path, "rb")))
  77                 {
  78 // file not found
  79                         result = 0;
  80                 }
  81                 else
  82                 {
  83                         char test[16];
  84                         (void)fread(test, 16, 1, stream);
  85                         fclose(stream);
  86                         if(test[0] == 'T' && test[1] == 'G' && test[2] == 'A' &&
  87                                 test[3] == 'L' && test[4] == 'I' && test[5] == 'S' &&
  88                                 test[6] == 'T')
  89                         {
  90                                 result = 1;
  91                         }
  92
  93                 }
  94         }
  95
  96
  97         return result;
  98 }
  99
 100 void FileTGA::get_parameters(BC_WindowBase *parent_window,
 101         Asset *asset, BC_WindowBase* &format_window,
 102         int audio_options, int video_options, EDL *edl)
 103 {
 104         if(video_options)
 105         {
 106                 TGAConfigVideo *window = new TGAConfigVideo(parent_window, asset);
 107                 format_window = window;
 108                 window->create_objects();
 109                 window->run_window();
 110                 delete window;
 111         }
 112 }
 113
 114 #if 0
 115 N_("RGB compressed")
 116 N_("RGBA compressed")
 117 N_("RGB uncompressed")
 118 N_("RGBA uncompressed")
 119 #endif
 120
 121 #define TGA_RGB_RLE "rle "
 122 #define TGA_RGBA_RLE "rlea"
 123 #define TGA_RGB "raw "
 124 #define TGA_RGBA "rawa"
 125
 126 #define TGA_RGB_RLE_NAME "RGB compressed"
 127 #define TGA_RGBA_RLE_NAME "RGBA compressed"
 128 #define TGA_RGB_NAME "RGB uncompressed"
 129 #define TGA_RGBA_NAME "RGBA uncompressed"
 130
 131 const char* FileTGA::compression_to_str(const char *compression)
 132 {
 133         if(!strcasecmp(compression, TGA_RGB_RLE)) return _(TGA_RGB_RLE_NAME);
 134         if(!strcasecmp(compression, TGA_RGBA_RLE)) return _(TGA_RGBA_RLE_NAME);
 135         if(!strcasecmp(compression, TGA_RGB)) return _(TGA_RGB_NAME);
 136         if(!strcasecmp(compression, TGA_RGBA)) return _(TGA_RGBA_NAME);
 137         return TGA_RGB_NAME;
 138 }
 139
 140 const char* FileTGA::str_to_compression(const char *string)
 141 {
 142         if(!strcasecmp(compression_to_str(TGA_RGB_RLE), string)) return TGA_RGB_RLE;
 143         if(!strcasecmp(compression_to_str(TGA_RGBA_RLE), string)) return TGA_RGBA_RLE;
 144         if(!strcasecmp(compression_to_str(TGA_RGB), string)) return TGA_RGB;
 145         if(!strcasecmp(compression_to_str(TGA_RGBA), string)) return TGA_RGBA;
 146         return TGA_RGB;
 147 }
 148
 149 int FileTGA::can_copy_from(Asset *asset, int64_t position)
 150 {
 151         if(asset->format == FILE_TGA_LIST ||
 152                 asset->format == FILE_TGA)
 153                 return 1;
 154
 155         return 0;
 156 }
 157
 158
 159 int  FileTGA::colormodel_supported(int colormodel)
 160 {
 161         return colormodel;
 162 }
 163
 164 int FileTGA::get_best_colormodel(Asset *asset, int driver)
 165 {
 166         if(!strcasecmp(asset->vcodec, TGA_RGB_RLE) ||
 167                 !strcasecmp(asset->vcodec, TGA_RGB)) return BC_RGB888;
 168         if(!strcasecmp(asset->vcodec, TGA_RGBA_RLE) ||
 169                 !strcasecmp(asset->vcodec, TGA_RGBA)) return BC_RGBA8888;
 170         return BC_RGB888;
 171 }
 172
 173 int FileTGA::read_frame(VFrame *frame, VFrame *data)
 174 {
 175         read_tga(asset, frame, data, temp);
 176         return 0;
 177 }
 178
 179 int FileTGA::write_frame(VFrame *frame, VFrame *data, FrameWriterUnit *unit)
 180 {
 181         TGAUnit *tga_unit = (TGAUnit*)unit;
 182
 183         write_tga(asset, frame, data, tga_unit->temp);
 184         return 0;
 185 }
 186
 187 FrameWriterUnit* FileTGA::new_writer_unit(FrameWriter *writer)
 188 {
 189         return new TGAUnit(this, writer);
 190 }
 191
 192 int64_t FileTGA::get_memory_usage()
 193 {
 194         int64_t result = FileList::get_memory_usage();
 195         if(temp) result += temp->get_data_size();
 196         return result;
 197 }
 198
 199
 200
 201
 202
 203
 204
 205
 206 #define FOOTERSIZE 26
 207 #define HEADERSIZE 18
 208 int FileTGA::read_frame_header(char *path)
 209 {
 210         int result = 0;
 211
 212 //printf("FileTGA::read_frame_header 1\n");
 213         FILE *stream;
 214
 215         if(!(stream = fopen(path, "rb")))
 216         {
 217                 eprintf(_("Error while opening \"%s\" for reading. \n%m\n"), asset->path);
 218                 return 1;
 219         }
 220
 221         unsigned char header[HEADERSIZE];
 222         (void)fread(header, HEADERSIZE, 1, stream);
 223         fclose(stream);
 224
 225         asset->width = header[12] | (header[13] << 8);
 226         asset->height = header[14] | (header[15] << 8);
 227         int bpp = header[16];
 228         int rle = header[2] & 0x8;
 229         switch(bpp)
 230         {
 231                 case 32:
 232                         if(rle)
 233                                 strcpy(asset->vcodec, TGA_RGBA_RLE);
 234                         else
 235                                 strcpy(asset->vcodec, TGA_RGBA);
 236                         break;
 237                 case 24:
 238                         if(rle)
 239                                 strcpy(asset->vcodec, TGA_RGB_RLE);
 240                         else
 241                                 strcpy(asset->vcodec, TGA_RGB);
 242                         break;
 243         }
 244 //printf("FileTGA::read_frame_header 2 %d %d\n", asset->width, asset->height);
 245
 246         return result;
 247 }
 248
 249 void FileTGA::read_tga(Asset *asset, VFrame *frame, VFrame *data, VFrame* &temp)
 250 {
 251 // Read header
 252         int64_t file_offset = 0;
 253
 254 //      unsigned char *footer = data->get_data() +
 255 //              data->get_compressed_size() - FOOTERSIZE;
 256         unsigned char *header = data->get_data();
 257         file_offset += HEADERSIZE;
 258
 259         int image_type = 0;
 260         int image_compression = 0;
 261         switch(header[2])
 262         {
 263                 case 1:
 264                         image_type = TGA_TYPE_MAPPED;
 265                         image_compression = TGA_COMP_NONE;
 266                         break;
 267                 case 2:
 268                         image_type = TGA_TYPE_COLOR;
 269                         image_compression = TGA_COMP_NONE;
 270                         break;
 271                 case 3:
 272                         image_type = TGA_TYPE_GRAY;
 273                         image_compression = TGA_COMP_NONE;
 274                         break;
 275                 case 9:
 276                         image_type = TGA_TYPE_MAPPED;
 277                         image_compression = TGA_COMP_RLE;
 278                         break;
 279                 case 10:
 280                         image_type = TGA_TYPE_COLOR;
 281                         image_compression = TGA_COMP_RLE;
 282                         break;
 283                 case 11:
 284                         image_type = TGA_TYPE_GRAY;
 285                         image_compression = TGA_COMP_RLE;
 286                         break;
 287         }
 288
 289         int idlength = header[0];
 290         int colormaptype = header[1];
 291         //int colormapindex = header[3] + header[4] * 256;
 292         int colormaplength = header[5] + header[6] * 256;
 293         int colormapsize = header[7];
 294         //int xorigin = header[8] + header[9] * 256;
 295         //int yorigin = header[10] + header[11] * 256;
 296         int width = header[12] + header[13] * 256;
 297         int height = header[14] + header[15] * 256;
 298         int bpp = header[16];
 299         int bytes = (bpp + 7) / 8;
 300         int alphabits = header[17] & 0x0f;
 301         int fliphoriz = (header[17] & 0x10) ? 1 : 0;
 302         int flipvert = (header[17] & 0x20) ? 0 : 1;
 303         int data_size = data->get_compressed_size();
 304
 305         if(idlength) file_offset += idlength;
 306
 307 // Get colormap
 308         unsigned char *tga_cmap;
 309         unsigned char colormap[4 * 256];
 310
 311         if(colormaptype == 1)
 312         {
 313                 int cmap_bytes = (colormapsize + 7) / 8;
 314                 tga_cmap = data->get_data() + file_offset;
 315                 file_offset += colormaplength * cmap_bytes;
 316
 317                 switch(colormapsize)
 318                 {
 319                         case 32:
 320                                 bgr2rgb(colormap, tga_cmap, colormaplength, cmap_bytes, 1);
 321                                 break;
 322                         case 24:
 323                                 bgr2rgb(colormap, tga_cmap, colormaplength, cmap_bytes, 0);
 324                                 break;
 325                         case 16:
 326                                 upsample(colormap, tga_cmap, colormaplength, cmap_bytes);
 327                                 break;
 328                 }
 329         }
 330
 331         int source_cmodel = BC_RGB888;
 332         switch(bpp)
 333         {
 334                 case 32:
 335                         source_cmodel = BC_RGBA8888;
 336                         break;
 337                 case 24:
 338                         source_cmodel = BC_RGB888;
 339                         break;
 340         }
 341
 342 // Read image
 343         VFrame *output_frame;
 344         if(frame->get_color_model() == source_cmodel)
 345         {
 346                 output_frame = frame;
 347         }
 348         else
 349         {
 350                 if(temp && temp->get_color_model() != source_cmodel)
 351                 {
 352                         delete temp;
 353                         temp = 0;
 354                 }
 355
 356                 if(!temp)
 357                 {
 358                         temp = new VFrame(width, height, source_cmodel, 0);
 359                 }
 360                 output_frame = temp;
 361         }
 362
 363         if(flipvert)
 364         {
 365                 for(int i = height - 1; i >= 0; i--)
 366                 {
 367                         read_line(output_frame->get_rows()[i],
 368                                 data->get_data(),
 369                                 file_offset,
 370                                 image_type,
 371                                 bpp,
 372                                 image_compression,
 373                                 bytes,
 374                                 width,
 375                                 fliphoriz,
 376                                 alphabits,
 377                                 data_size);
 378                 }
 379         }
 380         else
 381         {
 382                 for(int i = 0; i < height; i++)
 383                 {
 384                         read_line(output_frame->get_rows()[i],
 385                                 data->get_data(),
 386                                 file_offset,
 387                                 image_type,
 388                                 bpp,
 389                                 image_compression,
 390                                 bytes,
 391                                 width,
 392                                 fliphoriz,
 393                                 alphabits,
 394                                 data_size);
 395                 }
 396         }
 397
 398         if(output_frame != frame)
 399         {
 400                 BC_CModels::transfer(frame->get_rows(), output_frame->get_rows(),
 401                         frame->get_y(), frame->get_u(), frame->get_v(),
 402                         output_frame->get_y(), output_frame->get_u(), output_frame->get_v(),
 403                         0, 0, width, height,
 404                         0, 0, frame->get_w(), frame->get_h(),
 405                         output_frame->get_color_model(), frame->get_color_model(),
 406                         0, width, frame->get_w());
 407         }
 408 }
 409
 410 void FileTGA::write_tga(Asset *asset, VFrame *frame, VFrame *data, VFrame* &temp)
 411 {
 412         unsigned char header[18];
 413         //unsigned char footer[26];
 414         int64_t file_offset = 0;
 415         int out_bpp = 0;
 416         int rle = 0;
 417         int dest_cmodel = BC_RGB888;
 418
 419 //printf("FileTGA::write_tga 1\n");
 420
 421         header[0] = 0;
 422         header[1] = 0;
 423         if(!strcasecmp(asset->vcodec, TGA_RGBA_RLE))
 424         {
 425                 header[2] = 10;
 426                 out_bpp = 4;
 427                 rle = 1;
 428                 header[16] = 32; /* bpp */
 429                 header[17] = 0x28; /* alpha + orientation */
 430                 dest_cmodel = BC_RGBA8888;
 431         }
 432         else
 433         if(!strcasecmp(asset->vcodec, TGA_RGBA))
 434         {
 435                 header[2] = 2;
 436                 out_bpp = 4;
 437                 rle = 0;
 438                 header[16] = 32; /* bpp */
 439                 header[17] = 0x28; /* alpha + orientation */
 440                 dest_cmodel = BC_RGBA8888;
 441         }
 442         else
 443         if(!strcasecmp(asset->vcodec, TGA_RGB_RLE))
 444         {
 445                 header[2] = 10;
 446                 out_bpp = 3;
 447                 rle = 1;
 448                 header[16] = 24; /* bpp */
 449                 header[17] = 0x20; /* alpha + orientation */
 450                 dest_cmodel = BC_RGB888;
 451         }
 452         else
 453         {
 454                 header[2] = 2;
 455                 out_bpp = 3;
 456                 rle = 0;
 457                 header[16] = 24; /* bpp */
 458                 header[17] = 0x20; /* alpha + orientation */
 459                 dest_cmodel = BC_RGB888;
 460         }
 461         header[3] = header[4] = header[5] = header[6] = header[7] = 0;
 462 //printf("FileTGA::write_tga 1\n");
 463
 464         VFrame *input_frame;
 465         if(frame->get_color_model() == dest_cmodel)
 466         {
 467                 input_frame = frame;
 468         }
 469         else
 470         {
 471                 if(temp && temp->get_color_model() != dest_cmodel)
 472                 {
 473                         delete temp;
 474                         temp = 0;
 475                 }
 476
 477                 if(!temp)
 478                 {
 479                         temp = new VFrame(0, -1, frame->get_w(), frame->get_h(), dest_cmodel, -1);
 480                 }
 481                 input_frame = temp;
 482
 483                 BC_CModels::transfer(input_frame->get_rows(), frame->get_rows(),
 484                         input_frame->get_y(), input_frame->get_u(), input_frame->get_v(),
 485                         frame->get_y(), frame->get_u(), frame->get_v(),
 486                         0, 0, frame->get_w(), frame->get_h(),
 487                         0, 0, frame->get_w(), frame->get_h(),
 488                         frame->get_color_model(), input_frame->get_color_model(),
 489                         0, frame->get_w(), frame->get_w());
 490         }
 491 //printf("FileTGA::write_tga 1\n");
 492
 493 // xorigin
 494 // yorigin
 495         header[8]  = header[9]  = 0;
 496         header[10] = header[11] = 0;
 497
 498         header[12] = input_frame->get_w() % 256;
 499         header[13] = input_frame->get_w() / 256;
 500
 501         header[14] = input_frame->get_h() % 256;
 502         header[15] = input_frame->get_h() / 256;
 503 //printf("FileTGA::write_tga 1\n");
 504
 505         write_data(header, data, file_offset, sizeof(header));
 506 //printf("FileTGA::write_tga 1\n");
 507
 508         unsigned char *output = new unsigned char[out_bpp * input_frame->get_w()];
 509 //printf("FileTGA::write_tga 1\n");
 510         for(int i = 0; i < input_frame->get_h(); i++)
 511         {
 512 //printf("FileTGA::write_tga 2\n");
 513                 bgr2rgb(output, input_frame->get_rows()[i], input_frame->get_w(), out_bpp, (out_bpp == 4));
 514 //printf("FileTGA::write_tga 3\n");
 515
 516                 if(rle)
 517                 {
 518 //printf("FileTGA::write_tga 4\n");
 519                         rle_write(output,
 520                                 input_frame->get_w(),
 521                                 out_bpp,
 522                                 data,
 523                                 file_offset);
 524 //printf("FileTGA::write_tga 5\n");
 525                 }
 526                 else
 527                 {
 528 //printf("FileTGA::write_tga 6\n");
 529                         write_data(output,
 530                                 data,
 531                                 file_offset,
 532                                 input_frame->get_w() * out_bpp);
 533 //printf("FileTGA::write_tga 7\n");
 534                 }
 535         }
 536 //printf("FileTGA::write_tga 8\n");
 537         delete [] output;
 538 //printf("FileTGA::write_tga 9\n");
 539 }
 540
 541 void FileTGA::write_data(unsigned char *buffer,
 542         VFrame *data,
 543         int64_t &file_offset,
 544         int64_t len)
 545 {
 546 //printf("FileTGA::write_data 1 %d\n", len);
 547         if(data->get_compressed_allocated() <= data->get_compressed_size() + len)
 548         {
 549                 data->allocate_compressed_data((data->get_compressed_size() + len) * 2);
 550         }
 551 //printf("FileTGA::write_data 1 %d\n", len);
 552
 553         bcopy(buffer, data->get_data() + file_offset, len);
 554 //printf("FileTGA::write_data 1 %d\n", len);
 555         file_offset += len;
 556 //printf("FileTGA::write_data 1 %d\n", len);
 557         data->set_compressed_size(file_offset);
 558 //printf("FileTGA::write_data 2 %d\n", len);
 559 }
 560
 561 void FileTGA::read_line(unsigned char *row, unsigned char *data,
 562         int64_t &file_offset, int image_type, int bpp, int image_compression,
 563         int bytes, int width, int fliphoriz, int alphabits, int data_size)
 564 {
 565         if(file_offset >= data_size) return;
 566         if(image_compression == TGA_COMP_RLE)
 567         {
 568                 rle_read(row, data, file_offset, bytes, width);
 569         }
 570         else
 571         {
 572                 if(file_offset + bytes * width <= data_size)
 573                         bcopy(data + file_offset, row, bytes * width);
 574                 file_offset += bytes * width;
 575         }
 576
 577         if(fliphoriz)
 578         {
 579                 flip_line(row, bytes, width);
 580         }
 581
 582         if(image_type == TGA_TYPE_COLOR)
 583         {
 584                 if(bpp == 16)
 585                 {
 586                         upsample(row, row, width, bytes);
 587                 }
 588                 else
 589                 {
 590                         bgr2rgb(row, row, width, bytes, alphabits);
 591                 }
 592         }
 593         else
 594         {
 595                 ;
 596         }
 597 }
 598
 599 void FileTGA::flip_line(unsigned char *row, int bytes, int width)
 600 {
 601         unsigned char temp;
 602         unsigned char *alt;
 603         int x, s;
 604         alt = row + (bytes * (width - 1));
 605
 606         for (x = 0; x * 2 <= width; x++) {
 607                 for(s = 0; s < bytes; ++s) {
 608                         temp = row[s];
 609                         row[s] = alt[s];
 610                         alt[s] = temp;
 611                 }
 612
 613                 row += bytes;
 614                 alt -= bytes;
 615         }
 616 }
 617
 618 void FileTGA::rle_read(unsigned char *row,
 619         unsigned char *data,
 620         int64_t &file_offset,
 621         int bytes,
 622         int width)
 623 {
 624         int repeat = 0;
 625         int direct = 0;
 626         unsigned char sample[4];
 627         int head;
 628
 629         for(int x = 0; x < width; x++)
 630         {
 631                 if(repeat == 0 && direct == 0)
 632                 {
 633                         head = data[file_offset++];
 634                         if(head == EOF)
 635                         {
 636                                 return;
 637                         }
 638                         else
 639                         if(head >= 128)
 640                         {
 641                                 repeat = head - 127;
 642                                 bcopy(data + file_offset, sample, bytes);
 643                                 file_offset += bytes;
 644                         }
 645                         else
 646                         {
 647                                 direct = head + 1;
 648                         }
 649                 }
 650
 651                 if(repeat > 0)
 652                 {
 653                         for(int k = 0; k < bytes; k++)
 654                         {
 655                                 row[k] = sample[k];
 656                         }
 657
 658                         repeat--;
 659                 }
 660                 else
 661                 {
 662                         bcopy(data + file_offset, row, bytes);
 663                         file_offset += bytes;
 664
 665                         direct--;
 666                 }
 667
 668                 row += bytes;
 669         }
 670 }
 671
 672 void FileTGA::rle_write(unsigned char *buffer,
 673         int width,
 674         int bytes,
 675         VFrame *frame,
 676         int64_t &file_offset)
 677 {
 678         int repeat = 0;
 679         int direct = 0;
 680         unsigned char *from = buffer;
 681         unsigned char output;
 682         int x;
 683
 684         for(x = 1; x < width; ++x)
 685         {
 686 /* next pixel is different */
 687                 if(memcmp(buffer, buffer + bytes, bytes))
 688                 {
 689                         if(repeat)
 690                         {
 691                                 output = 128 + repeat;
 692                                 write_data(&output, frame, file_offset, 1);
 693                                 write_data(from, frame, file_offset, bytes);
 694                                 from = buffer + bytes;
 695                                 repeat = 0;
 696                                 direct = 0;
 697                         }
 698                         else
 699                         {
 700                                 direct++;
 701                         }
 702                 }
 703                 else
 704 /* next pixel is the same */
 705                 {
 706                         if(direct)
 707                         {
 708                                 output = direct - 1;
 709                                 write_data(&output, frame, file_offset, 1);
 710                                 write_data(from, frame, file_offset, bytes * direct);
 711                                 from = buffer;
 712                                 direct = 0;
 713                                 repeat = 1;
 714                         }
 715                         else
 716                         {
 717                                 repeat++;
 718                         }
 719                 }
 720
 721                 if(repeat == 128)
 722                 {
 723                         output = 255;
 724                         write_data(&output, frame, file_offset, 1);
 725                         write_data(from, frame, file_offset, bytes);
 726                         from = buffer + bytes;
 727                         direct = 0;
 728                         repeat = 0;
 729                 }
 730                 else
 731                 if(direct == 128)
 732                 {
 733                         output = 127;
 734                         write_data(&output, frame, file_offset, 1);
 735                         write_data(from, frame, file_offset, direct * bytes);
 736                         from = buffer + bytes;
 737                         direct = 0;
 738                         repeat = 0;
 739                 }
 740
 741                 buffer += bytes;
 742         }
 743
 744         if(repeat > 0)
 745         {
 746                 output = 128 + repeat;
 747                 write_data(&output, frame, file_offset, 1);
 748                 write_data(from, frame, file_offset, bytes);
 749         }
 750         else
 751         {
 752                 output = direct;
 753                 write_data(&output, frame, file_offset, 1);
 754                 write_data(from, frame, file_offset, bytes * (direct + 1));
 755         }
 756 }
 757
 758
 759 void FileTGA::bgr2rgb(unsigned char *dest, unsigned char *src,
 760                  int width, int bytes, int alpha)
 761 {
 762         int x;
 763         unsigned char r, g, b;
 764
 765         if(alpha) {
 766                 for(x = 0; x < width; x++) {
 767                         r = src[2]; g = src[1]; b = src[0];
 768                         *(dest++) = r; *(dest++) = g; *(dest++) = b;
 769                         *(dest++) = src[3]; src += bytes;
 770                 }
 771         }
 772         else {
 773                 for(x = 0; x < width; x++) {
 774                         r = src[2]; g = src[1]; b = src[0];
 775                         *(dest++) = r; *(dest++) = g; *(dest++) = b;
 776                         src += bytes;
 777                 }
 778         }
 779 }
 780
 781 void FileTGA::upsample(unsigned char *dest,
 782           unsigned char *src,
 783           int width,
 784           int bytes)
 785 {
 786         int x;
 787
 788         dest += (width - 1) * 3;
 789         src += (width - 1) * bytes;
 790         for(x = width - 1; x >= 0; x--) {
 791                 dest[0] =  ((src[1] << 1) & 0xf8);
 792                 dest[0] += (dest[0] >> 5);
 793
 794                 dest[1] =  ((src[0] & 0xe0) >> 2) + ((src[1] & 0x03) << 6);
 795                 dest[1] += (dest[1] >> 5);
 796
 797                 dest[2] =  ((src[0] << 3) & 0xf8);
 798                 dest[2] += (dest[2] >> 5);
 799
 800                 dest -= 3;
 801                 src -= bytes;
 802         }
 803 }
 804
 805
 806 TGAUnit::TGAUnit(FileTGA *file, FrameWriter *writer)
 807  : FrameWriterUnit(writer)
 808 {
 809         temp = 0;
 810         this->file = file;
 811 }
 812
 813 TGAUnit::~TGAUnit()
 814 {
 815         if(temp) delete temp;
 816 }
 817
 818
 819 TGAConfigVideo::TGAConfigVideo(BC_WindowBase *gui, Asset *asset)
 820  : BC_Window(_(PROGRAM_NAME ": Video Compression"),
 821         gui->get_abs_cursor_x(1), gui->get_abs_cursor_y(1),
 822         xS(400), yS(100))
 823 {
 824         this->gui = gui;
 825         this->asset = asset;
 826
 827         compression_items.append(new BC_ListBoxItem(FileTGA::compression_to_str(TGA_RGB_RLE)));
 828         compression_items.append(new BC_ListBoxItem(FileTGA::compression_to_str(TGA_RGBA_RLE)));
 829         compression_items.append(new BC_ListBoxItem(FileTGA::compression_to_str(TGA_RGB)));
 830         compression_items.append(new BC_ListBoxItem(FileTGA::compression_to_str(TGA_RGBA)));
 831 }
 832
 833 TGAConfigVideo::~TGAConfigVideo()
 834 {
 835         compression_items.remove_all_objects();
 836 }
 837
 838 void TGAConfigVideo::create_objects()
 839 {
 840         lock_window("TGAConfigVideo::create_objects");
 841         int x = xS(10), y = yS(10);
 842
 843         add_subwindow(new BC_Title(x, y, _("Compression:")));
 844         TGACompression *textbox = new TGACompression(this,
 845                         x + xS(110), y, asset, &compression_items);
 846         textbox->create_objects();
 847         add_subwindow(new BC_OKButton(this));
 848         show_window(1);
 849         unlock_window();
 850 }
 851
 852 int TGAConfigVideo::close_event()
 853 {
 854         set_done(0);
 855         return 1;
 856 }
 857
 858
 859 TGACompression::TGACompression(TGAConfigVideo *gui, int x, int y,
 860         Asset *asset, ArrayList<BC_ListBoxItem*> *compression_items)
 861  : BC_PopupTextBox(gui, compression_items,
 862         FileTGA::compression_to_str(gui->asset->vcodec),
 863         x, y, xS(200), yS(200))
 864 {
 865         this->asset = asset;
 866 }
 867 int TGACompression::handle_event()
 868 {
 869         strcpy(asset->vcodec, FileTGA::str_to_compression(get_text()));
 870         return 1;
 871 }