cinelerra-5.1/cinelerra/filegif.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2014 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 "file.h"
  25 #include "filegif.h"
  26 #include "gif_lib.h"
  27 #include "mainerror.h"
  28 #include "interlacemodes.h"
  29 #include "vframe.h"
  30
  31 #include <stdlib.h>
  32 #include <unistd.h>
  33 #include <fcntl.h>
  34 #include <string.h>
  35
  36 FileGIF::FileGIF(Asset *asset, File *file)
  37  : FileBase(asset, file)
  38 {
  39         offset = 0;
  40         err = 0;
  41         gif_file = 0;
  42         eof = 1;
  43         row_size = 0;
  44         rows = 0;
  45         depth = 8;
  46         fp = 0;
  47         fd = -1;
  48         writes = -1;
  49         buffer = 0;
  50         bg = 0;
  51         output = 0;
  52 }
  53
  54 FileGIF::~FileGIF()
  55 {
  56         close_file();
  57 }
  58
  59 int FileGIF::check_sig(Asset *asset)
  60 {
  61         FILE *stream = fopen(asset->path, "rb");
  62         if( stream ) {
  63                 char test[8];
  64                 int ret = fread(test, 1, 6, stream);
  65                 fclose(stream);
  66                 if( ret >= 6 &&
  67                     test[0] == 'G' && test[1] == 'I' && test[2] == 'F' &&
  68                     test[3] == '8' && (test[4] == '7' || test[4] == '9') &&
  69                     test[5] == 'a' ) return 1;
  70         }
  71         return 0;
  72 }
  73
  74 int FileGIF::colormodel_supported(int colormodel)
  75 {
  76         return BC_RGB888;
  77 }
  78
  79 int FileGIF::get_best_colormodel(Asset *asset, int driver)
  80 {
  81         return BC_RGB888;
  82 }
  83
  84
  85 int FileGIF::read_frame_header(char *path)
  86 {
  87         FILE *stream = fopen(path, "rb");
  88         if( stream ) {
  89                 unsigned char test[16];
  90                 int ret = fread(test, 16, 1, stream);
  91                 fclose(stream);
  92                 if( ret < 1 ) return 1;
  93                 asset->format = FILE_GIF;
  94                 asset->width = test[6] | (test[7] << 8);
  95                 asset->height = test[8] | (test[9] << 8);
  96                 return 0;
  97         }
  98
  99         perror(path);
 100         return 1;
 101 }
 102
 103 static int input_file(GifFileType *gif_file, GifByteType *buffer, int bytes)
 104 {
 105         FileGIF *file = (FileGIF*)gif_file->UserData;
 106         fseek(file->fp, file->offset, SEEK_SET);
 107         bytes = fread(buffer, 1, bytes, file->fp);
 108         file->offset += bytes;
 109         return bytes;
 110 }
 111
 112 int FileGIF::open_file(int rd, int wr)
 113 {
 114         return  rd ? ropen_path(asset->path) :
 115                 wr ? wopen_path(asset->path) :
 116                 0 ;
 117 }
 118
 119 int FileGIF::ropen_path(const char *path)
 120 {
 121         fp = fopen(path, "r");
 122         int result = !fp ? 1 : 0;
 123         if( !result ) {
 124                 offset = 0;  eof = 0;
 125                 gif_file = DGifOpen(this, input_file, &err);
 126                 if( !gif_file ) {
 127                         eprintf("FileGIF::ropen_path %d: %s\n", __LINE__, GifErrorString(err));
 128                         result = 1;
 129                 }
 130         }
 131         if( !result )
 132                 result = open_gif();
 133         return result;
 134 }
 135
 136 int FileGIF::wopen_path(const char *path)
 137 {
 138         fd = open(path, O_CREAT+O_TRUNC+O_WRONLY, 0777);
 139         int result = fd < 0 ? 1 : 0;
 140         if( !result ) {
 141                 gif_file = EGifOpenFileHandle(fd, &err);
 142                 if( !gif_file ) {
 143                         eprintf("FileGIF::wopen_path %d: %s\n", __LINE__, GifErrorString(err));
 144                         result = 1;
 145                 }
 146         }
 147         if( !result ) {
 148                 writes = 0;
 149         }
 150         return result;
 151 }
 152
 153 int FileGIF::write_frames(VFrame ***frames, int len)
 154 {
 155         int result = !gif_file ? 1 : 0;
 156         for( int i=0; i<len && !result; ++i )
 157                 result = write_frame(frames[0][i]);
 158         return result;
 159 }
 160
 161 int FileGIF::open_gif()
 162 {
 163         file_pos.remove_all();
 164         int width = asset->width;
 165         int height = asset->height;
 166         int result = read_frame_header(asset->path);
 167         if( !result ) {
 168                 asset->actual_width = asset->width;
 169                 if( width ) asset->width = width;
 170                 asset->actual_height = asset->height;
 171                 if( height ) asset->height = height;
 172                 asset->layers = 1;
 173                 if( !asset->frame_rate )
 174                         asset->frame_rate = 10;
 175                 asset->video_data = 1;
 176                 row_size = gif_file->SWidth * sizeof(GifPixelType);
 177                 bg = (GifRowType)malloc(row_size);
 178                 for( int i=0; i<gif_file->SWidth; ++i )
 179                         bg[i] = gif_file->SBackGroundColor;
 180                 rows = gif_file->SHeight;
 181                 buffer = (GifRowType*)malloc(sizeof(GifRowType) * rows);
 182                 for( int i=0; i<gif_file->SHeight; ++i ) {
 183                         buffer[i] = (GifRowType)malloc(row_size);
 184                         memcpy(buffer[i], bg, row_size);
 185                 }
 186                 result = scan_gif();
 187                 asset->video_length = file_pos.size();
 188         }
 189         return result;
 190 }
 191
 192 int FileGIF::close_file()
 193 {
 194         if( gif_file ) {
 195                 EGifCloseFile(gif_file, &err);
 196                 gif_file = 0;
 197         }
 198         if( fp ) {
 199                 fclose(fp);  fp = 0;
 200         }
 201         if( fd >= 0 ) {
 202                 close(fd);  fd = -1;
 203         }
 204         if( bg ) { free(bg);  bg = 0; }
 205         if( buffer ) {
 206                 for( int k=0; k<rows; ++k )
 207                         free(buffer[k]);
 208                 free(buffer);  buffer = 0;
 209                 rows = 0;
 210         }
 211         offset = 0;
 212         row_size = 0;
 213         err = 0;
 214         writes = -1;
 215         eof = 1;
 216         output = 0;
 217         FileBase::close_file();
 218         return 0;
 219 }
 220
 221 int FileGIF::scan_gif()
 222 {
 223         int file_eof = eof;
 224         int64_t file_offset = offset;
 225         file_pos.remove_all();
 226         int image_pos = offset, ret;
 227 // read all imgs, build file_pos index
 228         while( (ret=read_next_image(0)) > 0 ) {
 229                 file_pos.append(image_pos);
 230                 image_pos = offset;
 231         }
 232         eof = file_eof;
 233         offset = file_offset;
 234         return ret;
 235 }
 236
 237 int FileGIF::set_video_position(int64_t pos)
 238 {
 239         if( !gif_file || !asset->video_length ) return 1;
 240         int64_t sz = file_pos.size();
 241         eof = pos < 0 || pos >= sz ? 1 : 0;
 242         offset = !eof ? file_pos[pos] : 0;
 243         return 0;
 244 }
 245
 246 int FileGIF::read_frame(VFrame *output)
 247 {
 248         if( !gif_file ) return 1;
 249         for( int i=0; i<gif_file->SHeight; ++i )
 250                 memcpy(buffer[i], bg, row_size);
 251         int ret = read_next_image(output) > 0 ? 0 : 1;
 252         return ret;
 253 }
 254
 255 // ret = -1:err, 0:eof, 1:frame
 256 int FileGIF::read_next_image(VFrame *output)
 257 {
 258         int ret = 0;
 259         GifRecordType record_type;
 260
 261         while( !ret && !eof ) {
 262                 if( DGifGetRecordType(gif_file, &record_type) == GIF_ERROR ) {
 263                         err = gif_file->Error;
 264                         eprintf("FileGIF::read_frame %d: %s\n", __LINE__, GifErrorString(err));
 265                         ret = -1;
 266                         break;
 267                 }
 268
 269                 switch( record_type ) {
 270                 case IMAGE_DESC_RECORD_TYPE: {
 271                         if( DGifGetImageDesc(gif_file) == GIF_ERROR ) {
 272                                 err = gif_file->Error;
 273                                 eprintf("FileGIF::read_frame %d: %s\n", __LINE__, GifErrorString(err));
 274                                 break;
 275                         }
 276                         int row = gif_file->Image.Top;
 277                         int col = gif_file->Image.Left;
 278                         int width = gif_file->Image.Width;
 279                         int height = gif_file->Image.Height;
 280                         if( gif_file->Image.Left + gif_file->Image.Width > gif_file->SWidth ||
 281                             gif_file->Image.Top + gif_file->Image.Height > gif_file->SHeight )
 282                                 ret = -1;
 283                         if( !ret && gif_file->Image.Interlace ) {
 284                                 static int InterlacedOffset[] = { 0, 4, 2, 1 };
 285                                 static int InterlacedJumps[] = { 8, 8, 4, 2 };
 286 /* Need to perform 4 passes on the images: */
 287                                 for( int i=0; i<4; ++i ) {
 288                                         int j = row + InterlacedOffset[i];
 289                                         for( ; !ret && j<row + height; j+=InterlacedJumps[i] ) {
 290                                                 if( DGifGetLine(gif_file, &buffer[j][col], width) == GIF_ERROR )
 291                                                         ret = -1;
 292                                         }
 293                                 }
 294                         }
 295                         else {
 296                                 for( int i=0; !ret && i<height; ++i ) {
 297                                         if (DGifGetLine(gif_file, &buffer[row++][col], width) == GIF_ERROR)
 298                                                 ret = -1;
 299                                 }
 300                         }
 301                         ret = 1;
 302                         break; }
 303                 case EXTENSION_RECORD_TYPE: {
 304                         int ExtFunction = 0;
 305                         GifByteType *ExtData = 0;
 306                         if( DGifGetExtension(gif_file, &ExtFunction, &ExtData) == GIF_ERROR )
 307                                 ret = -1;
 308                         while( !ret && ExtData ) {
 309                                 if( DGifGetExtensionNext(gif_file, &ExtData) == GIF_ERROR )
 310                                         ret = -1;
 311                         }
 312                         break; }
 313                 case TERMINATE_RECORD_TYPE:
 314                         eof = 1;
 315                         break;
 316                 default:
 317                         ret = -1;
 318                         break;
 319                 }
 320         }
 321
 322         ColorMapObject *color_map = 0;
 323         if( ret > 0 ) {
 324                 color_map = gif_file->Image.ColorMap;
 325                 if( !color_map ) color_map = gif_file->SColorMap;
 326                 if( !color_map ) ret = -1;
 327         }
 328         if( ret > 0 && output ) {
 329                 int screen_width = gif_file->SWidth;
 330                 int screen_height = gif_file->SHeight;
 331                 for( int i=0; i<screen_height; ++i ) {
 332                         GifRowType row = buffer[i];
 333                         unsigned char *out_ptr = output->get_rows()[i];
 334                         for( int j=0; j<screen_width; ++j ) {
 335                                 GifColorType *color_map_entry = &color_map->Colors[row[j]];
 336                                 *out_ptr++ = color_map_entry->Red;
 337                                 *out_ptr++ = color_map_entry->Green;
 338                                 *out_ptr++ = color_map_entry->Blue;
 339                         }
 340                 }
 341         }
 342         return ret;
 343 }
 344
 345 int FileGIF::write_frame(VFrame *frame)
 346 {
 347         int w = frame->get_w(), h = frame->get_h();
 348         ColorMapObject *cmap = 0;
 349         int cmap_sz = depth >= 0 ? 1 << depth : 0;
 350         int64_t len = w * h * sizeof(GifByteType);
 351         GifByteType *bfr = (GifByteType *) malloc(len);
 352         int result = !bfr ? 1 : 0;
 353         if( !result ) {
 354                 VFrame gbrp(w, h, BC_GBRP);
 355                 gbrp.transfer_from(frame);
 356                 if( !(cmap = GifMakeMapObject(cmap_sz, 0)) )
 357                         result = 1;
 358                 if( !result ) {
 359                         GifByteType *gp = (GifByteType *)gbrp.get_r();
 360                         GifByteType *bp = (GifByteType *)gbrp.get_g();
 361                         GifByteType *rp = (GifByteType *)gbrp.get_b();
 362                         if( GifQuantizeBuffer(w, h, &cmap_sz, rp, gp, bp,
 363                                         bfr, cmap->Colors) == GIF_ERROR )
 364                                 result = 1;
 365                 }
 366         }
 367         if( !result && !writes &&
 368             EGifPutScreenDesc(gif_file, w, h, depth, 0, 0) == GIF_ERROR )
 369                 result = 1;
 370         if( !result &&
 371             EGifPutImageDesc(gif_file, 0, 0, w, h, 0, cmap) == GIF_ERROR )
 372                 result = 1;
 373
 374         GifByteType *bp = bfr;
 375         for( int y=0; !result && y<h; ++y ) {
 376                 if( EGifPutLine(gif_file, bp, w) == GIF_ERROR )
 377                         result = 1;
 378                 bp += w;
 379         }
 380         GifFreeMapObject(cmap);
 381         if( bfr ) free(bfr);
 382         ++writes;
 383         return result;
 384 }
 385
 386 static int write_data(GifFileType *gif_file, const GifByteType *bfr, int bytes)
 387 {
 388         FileGIF *file = (FileGIF*)gif_file->UserData;
 389         VFrame *output = file->output;
 390         long size = output->get_compressed_size();
 391         long alloc = output->get_compressed_allocated();
 392         long len = size + bytes;
 393         if( len > alloc )
 394                 output->allocate_compressed_data(2*size + bytes);
 395         unsigned char *data = output->get_data() + size;
 396         memcpy(data, bfr, bytes);
 397         output->set_compressed_size(len);
 398         return bytes;
 399 }
 400
 401 int FileGIF::wopen_data(VFrame *output)
 402 {
 403         int result = 0;
 404         gif_file = EGifOpen(this, write_data, &err);
 405         if( !gif_file ) {
 406                 eprintf("FileGIF::wopen_data %d: %s\n", __LINE__, GifErrorString(err));
 407                 result = 1;
 408         }
 409         if( !result ) {
 410                 output->set_compressed_size(0);
 411                 this->output = output;
 412                 writes = 0;
 413         }
 414         return result;
 415 }
 416
 417
 418 FileGIFList::FileGIFList(Asset *asset, File *file)
 419  : FileList(asset, file, "GIFLIST", ".gif", FILE_UNKNOWN, FILE_GIF_LIST)
 420 {
 421 }
 422
 423 FileGIFList::~FileGIFList()
 424 {
 425 }
 426
 427 int FileGIFList::check_sig(Asset *asset)
 428 {
 429         FILE *stream = fopen(asset->path, "rb");
 430         if( stream ) {
 431                 unsigned char test[16];
 432                 int ret = fread(test, 16, 1, stream);
 433                 fclose(stream);
 434                 if( ret < 1 ) return 1;
 435                 if( test[0] == 'G' && test[1] == 'I' && test[2] == 'F' &&
 436                     test[3] == 'L' && test[4] == 'I' && test[5] == 'S' && test[6] == 'T')
 437                         return 1;
 438         }
 439         return 0;
 440 }
 441
 442 int FileGIFList::colormodel_supported(int colormodel) { return BC_RGB888; }
 443 int FileGIFList::get_best_colormodel(Asset *asset, int driver) { return BC_RGB888; }
 444
 445 int FileGIFList::read_frame_header(char *path)
 446 {
 447         FILE *stream = fopen(path, "rb");
 448         if( stream ) {
 449                 unsigned char test[16];
 450                 int ret = fread(test, 16, 1, stream);
 451                 fclose(stream);
 452                 if( ret < 1 ) return 1;
 453                 asset->format = FILE_GIF_LIST;
 454                 asset->width = test[6] | (test[7] << 8);
 455                 asset->height = test[8] | (test[9] << 8);
 456                 return 0;
 457         }
 458         perror(path);
 459         return 1;
 460 }
 461
 462 int FileGIFList::read_frame(VFrame *output, char *path)
 463 {
 464         Asset *asset = new Asset(path);
 465         FileGIF gif(asset, file);
 466         int ret = gif.ropen_path(path);
 467         if( !ret )
 468                 ret = gif.read_frame(output);
 469         asset->remove_user();
 470         return ret;
 471 }
 472
 473 int FileGIFList::write_frame(VFrame *frame, VFrame *data, FrameWriterUnit *unit)
 474 {
 475         int native_cmodel = BC_RGB888;
 476         if( frame->get_color_model() != native_cmodel ) {
 477                 GIFUnit *gif_unit = (GIFUnit *)unit;
 478                 if( !gif_unit->temp_frame ) gif_unit->temp_frame =
 479                         new VFrame(frame->get_w(), frame->get_h(), native_cmodel);
 480                 gif_unit->temp_frame->transfer_from(frame);
 481                 frame = gif_unit->temp_frame;
 482         }
 483
 484         FileGIF gif(asset, file);
 485         int ret = gif.wopen_data(data);
 486         if( !ret )
 487                 ret = gif.write_frame(frame);
 488         return ret;
 489 }
 490
 491 FrameWriterUnit* FileGIFList::new_writer_unit(FrameWriter *writer)
 492 {
 493         return new GIFUnit(this, writer);
 494 }
 495
 496 GIFUnit::GIFUnit(FileGIFList *file, FrameWriter *writer)
 497  : FrameWriterUnit(writer)
 498 {
 499         this->file = file;
 500         temp_frame = 0;
 501 }
 502
 503 GIFUnit::~GIFUnit()
 504 {
 505         delete temp_frame;
 506 }
 507