quicktime/util.c

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