quicktime/util.c

   1 #include <fcntl.h>
   2 #include <linux/cdrom.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <sys/ioctl.h>
   6 #include <sys/stat.h>
   7 #include <time.h>
   8 #include <unistd.h>
   9 #include "funcprotos.h"
  10 #include "quicktime.h"
  11 #include "workarounds.h"
  12
  13 /* Disk I/O */
  14
  15 int64_t quicktime_get_file_length(char *path)
  16 {
  17         struct stat64 status;
  18         if(stat64(path, &status))
  19                 perror("quicktime_get_file_length stat64:");
  20         return status.st_size;
  21 }
  22
  23 int quicktime_file_open(quicktime_t *file, char *path, int rd, int wr)
  24 {
  25         int exists = 0;
  26         char flags[10];
  27         if(rd && (file->stream = fopen(path, "rb")))
  28         {
  29                 exists = 1;
  30                 fclose(file->stream);
  31         }
  32
  33         if(rd && !wr) sprintf(flags, "rb");
  34         else
  35         if(!rd && wr) sprintf(flags, "wb");
  36         else
  37         if(rd && wr)
  38         {
  39                 if(exists)
  40                         sprintf(flags, "rb+");
  41                 else
  42                         sprintf(flags, "wb+");
  43         }
  44
  45         if(!(file->stream = fopen(path, flags)))
  46         {
  47                 perror(__FUNCTION__);
  48                 return 1;
  49         }
  50
  51
  52         if(rd && exists)
  53         {
  54                 file->total_length = quicktime_get_file_length(path);
  55         }
  56
  57         file->presave_buffer = calloc(1, QUICKTIME_PRESAVE);
  58         return 0;
  59 }
  60
  61 int quicktime_file_close(quicktime_t *file)
  62 {
  63 /* Flush presave buffer */
  64         if(file->presave_size)
  65         {
  66                 quicktime_fseek(file, file->presave_position - file->presave_size);
  67                 fwrite(file->presave_buffer, 1, file->presave_size, file->stream);
  68                 file->presave_size = 0;
  69         }
  70
  71         if(file->stream)
  72         {
  73                 fclose(file->stream);
  74         }
  75         file->stream = 0;
  76         return 0;
  77 }
  78
  79
  80
  81 int64_t quicktime_ftell(quicktime_t *file)
  82 {
  83         return file->ftell_position;
  84 }
  85
  86 int quicktime_fseek(quicktime_t *file, int64_t offset)
  87 {
  88         file->ftell_position = offset;
  89         if(offset > file->total_length || offset < 0) return 1;
  90         if(FSEEK(file->stream, file->ftell_position, SEEK_SET))
  91         {
  92 //              perror("quicktime_fseek FSEEK");
  93                 return 1;
  94         }
  95         return 0;
  96 }
  97
  98 /* Read entire buffer from the preload buffer */
  99 static int read_preload(quicktime_t *file, char *data, int64_t size)
 100 {
 101         int64_t selection_start = 0;
 102         int64_t selection_end = 0;
 103         int64_t fragment_start = 0;
 104         int64_t fragment_len = 0;
 105
 106         selection_start = file->file_position;
 107         selection_end = quicktime_add(file->file_position, size);
 108
 109         fragment_start = file->preload_ptr + (selection_start - file->preload_start);
 110         while(fragment_start < 0) fragment_start += file->preload_size;
 111         while(fragment_start >= file->preload_size) fragment_start -= file->preload_size;
 112
 113         while(selection_start < selection_end)
 114         {
 115                 fragment_len = selection_end - selection_start;
 116                 if(fragment_start + fragment_len > file->preload_size)
 117                         fragment_len = file->preload_size - fragment_start;
 118
 119                 memcpy(data, file->preload_buffer + fragment_start, fragment_len);
 120                 fragment_start += fragment_len;
 121                 data += fragment_len;
 122
 123                 if(fragment_start >= file->preload_size) fragment_start = (int64_t)0;
 124                 selection_start += fragment_len;
 125         }
 126         return 0;
 127 }
 128
 129 int quicktime_read_data(quicktime_t *file, char *data, int64_t size)
 130 {
 131         int result = 1;
 132
 133         if(!file->preload_size)
 134         {
 135                 quicktime_fseek(file, file->file_position);
 136                 result = fread(data, size, 1, file->stream);
 137                 file->ftell_position += size;
 138         }
 139         else
 140         {
 141 /* Region requested for loading */
 142                 int64_t selection_start = file->file_position;
 143                 int64_t selection_end = file->file_position + size;
 144                 int64_t fragment_start, fragment_len;
 145
 146                 if(selection_end - selection_start > file->preload_size)
 147                 {
 148 /* Size is larger than preload size.  Should never happen. */
 149 printf("read data Size is larger than preload size. size=%llx preload_size=%llx\n",
 150         selection_end - selection_start, file->preload_size);
 151                         quicktime_fseek(file, file->file_position);
 152                         result = fread(data, size, 1, file->stream);
 153                         file->ftell_position += size;
 154                 }
 155                 else
 156                 if(selection_start >= file->preload_start &&
 157                         selection_start < file->preload_end &&
 158                         selection_end <= file->preload_end &&
 159                         selection_end > file->preload_start)
 160                 {
 161 /* Entire range is in buffer */
 162                         read_preload(file, data, size);
 163                 }
 164                 else
 165                 if(selection_end > file->preload_end &&
 166                         selection_end - file->preload_size < file->preload_end)
 167                 {
 168 /* Range is after buffer */
 169 /* Move the preload start to within one preload length of the selection_end */
 170                         while(selection_end - file->preload_start > file->preload_size)
 171                         {
 172                                 fragment_len = selection_end - file->preload_start - file->preload_size;
 173                                 if(file->preload_ptr + fragment_len > file->preload_size)
 174                                         fragment_len = file->preload_size - file->preload_ptr;
 175                                 file->preload_start += fragment_len;
 176                                 file->preload_ptr += fragment_len;
 177                                 if(file->preload_ptr >= file->preload_size) file->preload_ptr = 0;
 178                         }
 179
 180 /* Append sequential data after the preload end to the new end */
 181                         fragment_start = file->preload_ptr + file->preload_end - file->preload_start;
 182                         while(fragment_start >= file->preload_size)
 183                                 fragment_start -= file->preload_size;
 184
 185                         while(file->preload_end < selection_end)
 186                         {
 187                                 fragment_len = selection_end - file->preload_end;
 188                                 if(fragment_start + fragment_len > file->preload_size) fragment_len = file->preload_size - fragment_start;
 189                                 quicktime_fseek(file, file->preload_end);
 190                                 result = fread(&(file->preload_buffer[fragment_start]), fragment_len, 1, file->stream);
 191                                 file->ftell_position += fragment_len;
 192                                 file->preload_end += fragment_len;
 193                                 fragment_start += fragment_len;
 194                                 if(fragment_start >= file->preload_size) fragment_start = 0;
 195                         }
 196
 197                         read_preload(file, data, size);
 198                 }
 199                 else
 200                 {
 201 /* Range is before buffer or over a preload_size away from the end of the buffer. */
 202 /* Replace entire preload buffer with range. */
 203                         quicktime_fseek(file, file->file_position);
 204                         result = fread(file->preload_buffer, size, 1, file->stream);
 205                         file->ftell_position += size;
 206                         file->preload_start = file->file_position;
 207                         file->preload_end = file->file_position + size;
 208                         file->preload_ptr = 0;
 209                         read_preload(file, data, size);
 210                 }
 211         }
 212
 213         file->file_position += size;
 214         return result;
 215 }
 216
 217 void quicktime_set_presave(quicktime_t *file, int value)
 218 {
 219 // Flush presave buffer
 220         if(!value && file->use_presave)
 221         {
 222                 quicktime_fseek(file, file->presave_position - file->presave_size);
 223                 fwrite(file->presave_buffer, 1, file->presave_size, file->stream);
 224                 file->presave_size = 0;
 225                 file->file_position = file->presave_position;
 226                 file->ftell_position = file->presave_position;
 227                 if(file->total_length < file->ftell_position)
 228                         file->total_length = file->ftell_position;
 229         }
 230         else
 231         if(value && !file->use_presave)
 232         {
 233                 ;
 234         }
 235
 236         file->use_presave = value;
 237 }
 238
 239 int quicktime_write_data(quicktime_t *file, char *data, int size)
 240 {
 241         int data_offset = 0;
 242         int writes_attempted = 0;
 243         int writes_succeeded = 0;
 244         int iterations = 0;
 245
 246         if(!file->use_presave)
 247         {
 248 //printf("quicktime_write_data 1\n");
 249                 quicktime_fseek(file, file->file_position);
 250                 writes_attempted = 1;
 251                 writes_succeeded = fwrite(data,
 252                                 size,
 253                                 1,
 254                                 file->stream);
 255                 file->file_position += size;
 256                 file->ftell_position += size;
 257                 file->presave_position = file->file_position;
 258         }
 259         else
 260         {
 261 // Flush existing buffer and seek to new position
 262                 if(file->file_position != file->presave_position)
 263                 {
 264                         if(file->presave_size)
 265                         {
 266                                 quicktime_fseek(file, file->presave_position - file->presave_size);
 267                                 writes_succeeded += fwrite(file->presave_buffer, 1, file->presave_size, file->stream);
 268                                 writes_attempted += file->presave_size;
 269                                 file->presave_size = 0;
 270                         }
 271                         file->presave_position = file->file_position;
 272                 }
 273
 274 // Write presave buffers until done
 275                 while(size > 0)
 276                 {
 277                         int fragment_size = QUICKTIME_PRESAVE;
 278                         if(fragment_size > size) fragment_size = size;
 279                         if(fragment_size + file->presave_size > QUICKTIME_PRESAVE)
 280                                 fragment_size = QUICKTIME_PRESAVE- file->presave_size;
 281
 282                         memcpy(file->presave_buffer + file->presave_size,
 283                                 data + data_offset,
 284                                 fragment_size);
 285
 286                         file->presave_position += fragment_size;
 287                         file->presave_size += fragment_size;
 288                         data_offset += fragment_size;
 289                         size -= fragment_size;
 290
 291                         if(file->presave_size >= QUICKTIME_PRESAVE)
 292                         {
 293 //if(++iterations > 1) printf("quicktime_write_data 2 iterations=%d\n", iterations);
 294                                 quicktime_fseek(file, file->presave_position - file->presave_size);
 295                                 writes_succeeded += fwrite(file->presave_buffer,
 296                                         file->presave_size,
 297                                         1,
 298                                         file->stream);
 299                                 writes_attempted += file->presave_size;
 300                                 file->presave_size = 0;
 301                         }
 302                 }
 303
 304 /* Adjust file position */
 305                 file->file_position = file->presave_position;
 306 /* Adjust ftell position */
 307                 file->ftell_position = file->presave_position;
 308         }
 309
 310
 311 /* Adjust total length */
 312         if(file->total_length < file->ftell_position) file->total_length = file->ftell_position;
 313
 314 /* fwrite failed */
 315         if(!writes_succeeded && writes_attempted)
 316         {
 317                 return 0;
 318         }
 319         else
 320         if(!size)
 321                 return 1;
 322         else
 323                 return size;
 324 }
 325
 326 int64_t quicktime_byte_position(quicktime_t *file)
 327 {
 328         return quicktime_position(file);
 329 }
 330
 331
 332 void quicktime_read_pascal(quicktime_t *file, char *data)
 333 {
 334         char len = quicktime_read_char(file);
 335         quicktime_read_data(file, data, len);
 336         data[len] = 0;
 337 }
 338
 339 void quicktime_write_pascal(quicktime_t *file, char *data)
 340 {
 341         char len = strlen(data);
 342         quicktime_write_data(file, &len, 1);
 343         quicktime_write_data(file, data, len);
 344 }
 345
 346 float quicktime_read_fixed32(quicktime_t *file)
 347 {
 348         unsigned long a, b, c, d;
 349         unsigned char data[4];
 350
 351         quicktime_read_data(file, data, 4);
 352         a = data[0];
 353         b = data[1];
 354         c = data[2];
 355         d = data[3];
 356
 357         a = (a << 8) + b;
 358         b = (c << 8) + d;
 359
 360         if(b)
 361                 return (float)a + (float)b / 65536;
 362         else
 363                 return a;
 364 }
 365
 366 int quicktime_write_fixed32(quicktime_t *file, float number)
 367 {
 368         unsigned char data[4];
 369         int a, b;
 370
 371         a = number;
 372         b = (number - a) * 65536;
 373         data[0] = a >> 8;
 374         data[1] = a & 0xff;
 375         data[2] = b >> 8;
 376         data[3] = b & 0xff;
 377
 378         return quicktime_write_data(file, data, 4);
 379 }
 380
 381 int quicktime_write_int64(quicktime_t *file, int64_t value)
 382 {
 383         unsigned char data[8];
 384
 385         data[0] = (((uint64_t)value) & 0xff00000000000000LL) >> 56;
 386         data[1] = (((uint64_t)value) & 0xff000000000000LL) >> 48;
 387         data[2] = (((uint64_t)value) & 0xff0000000000LL) >> 40;
 388         data[3] = (((uint64_t)value) & 0xff00000000LL) >> 32;
 389         data[4] = (((uint64_t)value) & 0xff000000LL) >> 24;
 390         data[5] = (((uint64_t)value) & 0xff0000LL) >> 16;
 391         data[6] = (((uint64_t)value) & 0xff00LL) >> 8;
 392         data[7] =  ((uint64_t)value) & 0xff;
 393
 394         return quicktime_write_data(file, data, 8);
 395 }
 396
 397 int quicktime_write_int64_le(quicktime_t *file, int64_t value)
 398 {
 399         unsigned char data[8];
 400
 401         data[7] = (((uint64_t)value) & 0xff00000000000000LL) >> 56;
 402         data[6] = (((uint64_t)value) & 0xff000000000000LL) >> 48;
 403         data[5] = (((uint64_t)value) & 0xff0000000000LL) >> 40;
 404         data[4] = (((uint64_t)value) & 0xff00000000LL) >> 32;
 405         data[3] = (((uint64_t)value) & 0xff000000LL) >> 24;
 406         data[2] = (((uint64_t)value) & 0xff0000LL) >> 16;
 407         data[1] = (((uint64_t)value) & 0xff00LL) >> 8;
 408         data[0] =  ((uint64_t)value) & 0xff;
 409
 410         return quicktime_write_data(file, data, 8);
 411 }
 412
 413 int quicktime_write_int32(quicktime_t *file, long value)
 414 {
 415         unsigned char data[4];
 416
 417         data[0] = (value & 0xff000000) >> 24;
 418         data[1] = (value & 0xff0000) >> 16;
 419         data[2] = (value & 0xff00) >> 8;
 420         data[3] = value & 0xff;
 421
 422         return quicktime_write_data(file, data, 4);
 423 }
 424
 425 int quicktime_write_int32_le(quicktime_t *file, long value)
 426 {
 427         unsigned char data[4];
 428
 429         data[3] = (value & 0xff000000) >> 24;
 430         data[2] = (value & 0xff0000) >> 16;
 431         data[1] = (value & 0xff00) >> 8;
 432         data[0] = value & 0xff;
 433
 434         return quicktime_write_data(file, data, 4);
 435 }
 436
 437 int quicktime_write_char32(quicktime_t *file, char *string)
 438 {
 439         return quicktime_write_data(file, string, 4);
 440 }
 441
 442
 443 float quicktime_read_fixed16(quicktime_t *file)
 444 {
 445         unsigned char data[2];
 446
 447         quicktime_read_data(file, data, 2);
 448 //printf("quicktime_read_fixed16 %02x%02x\n", data[0], data[1]);
 449         if(data[1])
 450                 return (float)data[0] + (float)data[1] / 256;
 451         else
 452                 return (float)data[0];
 453 }
 454
 455 int quicktime_write_fixed16(quicktime_t *file, float number)
 456 {
 457         unsigned char data[2];
 458         int a, b;
 459
 460         a = number;
 461         b = (number - a) * 256;
 462         data[0] = a;
 463         data[1] = b;
 464
 465         return quicktime_write_data(file, data, 2);
 466 }
 467
 468 unsigned long quicktime_read_uint32(quicktime_t *file)
 469 {
 470         unsigned long result;
 471         unsigned long a, b, c, d;
 472         char data[4];
 473
 474         quicktime_read_data(file, data, 4);
 475         a = (unsigned char)data[0];
 476         b = (unsigned char)data[1];
 477         c = (unsigned char)data[2];
 478         d = (unsigned char)data[3];
 479
 480         result = (a << 24) | (b << 16) | (c << 8) | d;
 481         return result;
 482 }
 483
 484 long quicktime_read_int32(quicktime_t *file)
 485 {
 486         unsigned long result;
 487         unsigned long a, b, c, d;
 488         char data[4];
 489
 490         quicktime_read_data(file, data, 4);
 491         a = (unsigned char)data[0];
 492         b = (unsigned char)data[1];
 493         c = (unsigned char)data[2];
 494         d = (unsigned char)data[3];
 495
 496         result = (a << 24) | (b << 16) | (c << 8) | d;
 497         return (long)result;
 498 }
 499
 500 long quicktime_read_int32_le(quicktime_t *file)
 501 {
 502         unsigned long result;
 503         unsigned long a, b, c, d;
 504         char data[4];
 505
 506         quicktime_read_data(file, data, 4);
 507         a = (unsigned char)data[0];
 508         b = (unsigned char)data[1];
 509         c = (unsigned char)data[2];
 510         d = (unsigned char)data[3];
 511
 512         result = (d << 24) | (c << 16) | (b << 8) | a;
 513         return (long)result;
 514 }
 515
 516 int64_t quicktime_read_int64(quicktime_t *file)
 517 {
 518         uint64_t result, a, b, c, d, e, f, g, h;
 519         char data[8];
 520
 521         quicktime_read_data(file, data, 8);
 522         a = (unsigned char)data[0];
 523         b = (unsigned char)data[1];
 524         c = (unsigned char)data[2];
 525         d = (unsigned char)data[3];
 526         e = (unsigned char)data[4];
 527         f = (unsigned char)data[5];
 528         g = (unsigned char)data[6];
 529         h = (unsigned char)data[7];
 530
 531         result = (a << 56) |
 532                 (b << 48) |
 533                 (c << 40) |
 534                 (d << 32) |
 535                 (e << 24) |
 536                 (f << 16) |
 537                 (g << 8) |
 538                 h;
 539         return (int64_t)result;
 540 }
 541
 542 int64_t quicktime_read_int64_le(quicktime_t *file)
 543 {
 544         uint64_t result, a, b, c, d, e, f, g, h;
 545         char data[8];
 546
 547         quicktime_read_data(file, data, 8);
 548         a = (unsigned char)data[7];
 549         b = (unsigned char)data[6];
 550         c = (unsigned char)data[5];
 551         d = (unsigned char)data[4];
 552         e = (unsigned char)data[3];
 553         f = (unsigned char)data[2];
 554         g = (unsigned char)data[1];
 555         h = (unsigned char)data[0];
 556
 557         result = (a << 56) |
 558                 (b << 48) |
 559                 (c << 40) |
 560                 (d << 32) |
 561                 (e << 24) |
 562                 (f << 16) |
 563                 (g << 8) |
 564                 h;
 565         return (int64_t)result;
 566 }
 567
 568
 569 long quicktime_read_int24(quicktime_t *file)
 570 {
 571         unsigned long result;
 572         unsigned long a, b, c;
 573         char data[4];
 574
 575         quicktime_read_data(file, data, 3);
 576         a = (unsigned char)data[0];
 577         b = (unsigned char)data[1];
 578         c = (unsigned char)data[2];
 579
 580         result = (a << 16) | (b << 8) | c;
 581         return (long)result;
 582 }
 583
 584 int quicktime_write_int24(quicktime_t *file, long number)
 585 {
 586         unsigned char data[3];
 587         data[0] = (number & 0xff0000) >> 16;
 588         data[1] = (number & 0xff00) >> 8;
 589         data[2] = (number & 0xff);
 590
 591         return quicktime_write_data(file, data, 3);
 592 }
 593
 594 int quicktime_read_int16(quicktime_t *file)
 595 {
 596         unsigned long result;
 597         unsigned long a, b;
 598         char data[2];
 599
 600         quicktime_read_data(file, data, 2);
 601         a = (unsigned char)data[0];
 602         b = (unsigned char)data[1];
 603
 604         result = (a << 8) | b;
 605         return (int)result;
 606 }
 607
 608 int quicktime_read_int16_le(quicktime_t *file)
 609 {
 610         unsigned long result;
 611         unsigned long a, b;
 612         char data[2];
 613
 614         quicktime_read_data(file, data, 2);
 615         a = (unsigned char)data[0];
 616         b = (unsigned char)data[1];
 617
 618         result = (b << 8) | a;
 619         return (int)result;
 620 }
 621
 622 int quicktime_write_int16(quicktime_t *file, int number)
 623 {
 624         unsigned char data[2];
 625         data[0] = (number & 0xff00) >> 8;
 626         data[1] = (number & 0xff);
 627
 628         return quicktime_write_data(file, data, 2);
 629 }
 630
 631 int quicktime_write_int16_le(quicktime_t *file, int number)
 632 {
 633         unsigned char data[2];
 634         data[1] = (number & 0xff00) >> 8;
 635         data[0] = (number & 0xff);
 636
 637         return quicktime_write_data(file, data, 2);
 638 }
 639
 640 int quicktime_read_char(quicktime_t *file)
 641 {
 642         char output;
 643         quicktime_read_data(file, &output, 1);
 644         return output;
 645 }
 646
 647 int quicktime_write_char(quicktime_t *file, char x)
 648 {
 649         return quicktime_write_data(file, &x, 1);
 650 }
 651
 652 void quicktime_read_char32(quicktime_t *file, char *string)
 653 {
 654         quicktime_read_data(file, string, 4);
 655 }
 656
 657 int64_t quicktime_position(quicktime_t *file)
 658 {
 659         return file->file_position;
 660 }
 661
 662 int quicktime_set_position(quicktime_t *file, int64_t position)
 663 {
 664         file->file_position = position;
 665         if(!file->use_presave)
 666         {
 667                 quicktime_fseek(file, position);
 668                 file->presave_position = position;
 669         }
 670         return 0;
 671 }
 672
 673 void quicktime_copy_char32(char *output, char *input)
 674 {
 675         *output++ = *input++;
 676         *output++ = *input++;
 677         *output++ = *input++;
 678         *output = *input;
 679 }
 680
 681
 682 void quicktime_print_chars(char *desc, char *input, int len)
 683 {
 684         int i;
 685         printf("%s", desc);
 686         for(i = 0; i < len; i++) printf("%c", input[i]);
 687         printf("\n");
 688 }
 689
 690 unsigned long quicktime_current_time(void)
 691 {
 692         time_t t;
 693         time (&t);
 694         return (t+(66*31536000)+1468800);
 695 }
 696
 697 int quicktime_match_32(char *input, char *output)
 698 {
 699         if(input[0] == output[0] &&
 700                 input[1] == output[1] &&
 701                 input[2] == output[2] &&
 702                 input[3] == output[3])
 703                 return 1;
 704         else
 705                 return 0;
 706 }
 707
 708 int quicktime_match_24(char *input, char *output)
 709 {
 710         if(input[0] == output[0] &&
 711                 input[1] == output[1] &&
 712                 input[2] == output[2])
 713                 return 1;
 714         else
 715                 return 0;
 716 }
 717
 718 int quicktime_quantize16(int number)
 719 {
 720         if(number && (number % 16))
 721         {
 722                 number += 16 - (number % 16);
 723         }
 724         return number;
 725 }
 726
 727 int quicktime_quantize32(int number)
 728 {
 729         if(number && (number % 32))
 730         {
 731                 number += 32 - (number % 32);
 732         }
 733         return number;
 734 }
 735