hvirtual/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                 writes_attempted = 1;
 250                 writes_succeeded = fwrite(data,
 251                                 size,
 252                                 1,
 253                                 file->stream);
 254                 file->file_position += size;
 255                 file->ftell_position += size;
 256 //printf("quicktime_write_data 2\n");
 257         }
 258         else
 259         {
 260 // Flush existing buffer and seek to new position
 261                 if(file->file_position != file->presave_position)
 262                 {
 263                         if(file->presave_size)
 264                         {
 265                                 quicktime_fseek(file, file->presave_position - file->presave_size);
 266                                 writes_succeeded += fwrite(file->presave_buffer, 1, file->presave_size, file->stream);
 267                                 writes_attempted += file->presave_size;
 268                                 file->presave_size = 0;
 269                         }
 270                         file->presave_position = file->file_position;
 271                 }
 272
 273 // Write presave buffers until done
 274                 while(size > 0)
 275                 {
 276                         int fragment_size = QUICKTIME_PRESAVE;
 277                         if(fragment_size > size) fragment_size = size;
 278                         if(fragment_size + file->presave_size > QUICKTIME_PRESAVE)
 279                                 fragment_size = QUICKTIME_PRESAVE- file->presave_size;
 280
 281                         memcpy(file->presave_buffer + file->presave_size,
 282                                 data + data_offset,
 283                                 fragment_size);
 284
 285                         file->presave_position += fragment_size;
 286                         file->presave_size += fragment_size;
 287                         data_offset += fragment_size;
 288                         size -= fragment_size;
 289
 290                         if(file->presave_size >= QUICKTIME_PRESAVE)
 291                         {
 292 //if(++iterations > 1) printf("quicktime_write_data 2 iterations=%d\n", iterations);
 293                                 quicktime_fseek(file, file->presave_position - file->presave_size);
 294                                 writes_succeeded += fwrite(file->presave_buffer,
 295                                         file->presave_size,
 296                                         1,
 297                                         file->stream);
 298                                 writes_attempted += file->presave_size;
 299                                 file->presave_size = 0;
 300                         }
 301                 }
 302
 303 /* Adjust file position */
 304                 file->file_position = file->presave_position;
 305 /* Adjust ftell position */
 306                 file->ftell_position = file->presave_position;
 307         }
 308
 309
 310 /* Adjust total length */
 311         if(file->total_length < file->ftell_position) file->total_length = file->ftell_position;
 312
 313 /* fwrite failed */
 314         if(!writes_succeeded && writes_attempted)
 315         {
 316                 return 0;
 317         }
 318         else
 319         if(!size)
 320                 return 1;
 321         else
 322                 return size;
 323 }
 324
 325 int64_t quicktime_byte_position(quicktime_t *file)
 326 {
 327         return quicktime_position(file);
 328 }
 329
 330
 331 void quicktime_read_pascal(quicktime_t *file, char *data)
 332 {
 333         char len = quicktime_read_char(file);
 334         quicktime_read_data(file, data, len);
 335         data[len] = 0;
 336 }
 337
 338 void quicktime_write_pascal(quicktime_t *file, char *data)
 339 {
 340         char len = strlen(data);
 341         quicktime_write_data(file, &len, 1);
 342         quicktime_write_data(file, data, len);
 343 }
 344
 345 float quicktime_read_fixed32(quicktime_t *file)
 346 {
 347         unsigned long a, b, c, d;
 348         unsigned char data[4];
 349
 350         quicktime_read_data(file, data, 4);
 351         a = data[0];
 352         b = data[1];
 353         c = data[2];
 354         d = data[3];
 355
 356         a = (a << 8) + b;
 357         b = (c << 8) + d;
 358
 359         if(b)
 360                 return (float)a + (float)b / 65536;
 361         else
 362                 return a;
 363 }
 364
 365 int quicktime_write_fixed32(quicktime_t *file, float number)
 366 {
 367         unsigned char data[4];
 368         int a, b;
 369
 370         a = number;
 371         b = (number - a) * 65536;
 372         data[0] = a >> 8;
 373         data[1] = a & 0xff;
 374         data[2] = b >> 8;
 375         data[3] = b & 0xff;
 376
 377         return quicktime_write_data(file, data, 4);
 378 }
 379
 380 int quicktime_write_int64(quicktime_t *file, int64_t value)
 381 {
 382         unsigned char data[8];
 383
 384         data[0] = (((uint64_t)value) & 0xff00000000000000LL) >> 56;
 385         data[1] = (((uint64_t)value) & 0xff000000000000LL) >> 48;
 386         data[2] = (((uint64_t)value) & 0xff0000000000LL) >> 40;
 387         data[3] = (((uint64_t)value) & 0xff00000000LL) >> 32;
 388         data[4] = (((uint64_t)value) & 0xff000000LL) >> 24;
 389         data[5] = (((uint64_t)value) & 0xff0000LL) >> 16;
 390         data[6] = (((uint64_t)value) & 0xff00LL) >> 8;
 391         data[7] =  ((uint64_t)value) & 0xff;
 392
 393         return quicktime_write_data(file, data, 8);
 394 }
 395
 396 int quicktime_write_int64_le(quicktime_t *file, int64_t value)
 397 {
 398         unsigned char data[8];
 399
 400         data[7] = (((uint64_t)value) & 0xff00000000000000LL) >> 56;
 401         data[6] = (((uint64_t)value) & 0xff000000000000LL) >> 48;
 402         data[5] = (((uint64_t)value) & 0xff0000000000LL) >> 40;
 403         data[4] = (((uint64_t)value) & 0xff00000000LL) >> 32;
 404         data[3] = (((uint64_t)value) & 0xff000000LL) >> 24;
 405         data[2] = (((uint64_t)value) & 0xff0000LL) >> 16;
 406         data[1] = (((uint64_t)value) & 0xff00LL) >> 8;
 407         data[0] =  ((uint64_t)value) & 0xff;
 408
 409         return quicktime_write_data(file, data, 8);
 410 }
 411
 412 int quicktime_write_int32(quicktime_t *file, long value)
 413 {
 414         unsigned char data[4];
 415
 416         data[0] = (value & 0xff000000) >> 24;
 417         data[1] = (value & 0xff0000) >> 16;
 418         data[2] = (value & 0xff00) >> 8;
 419         data[3] = value & 0xff;
 420
 421         return quicktime_write_data(file, data, 4);
 422 }
 423
 424 int quicktime_write_int32_le(quicktime_t *file, long value)
 425 {
 426         unsigned char data[4];
 427
 428         data[3] = (value & 0xff000000) >> 24;
 429         data[2] = (value & 0xff0000) >> 16;
 430         data[1] = (value & 0xff00) >> 8;
 431         data[0] = value & 0xff;
 432
 433         return quicktime_write_data(file, data, 4);
 434 }
 435
 436 int quicktime_write_char32(quicktime_t *file, char *string)
 437 {
 438         return quicktime_write_data(file, string, 4);
 439 }
 440
 441
 442 float quicktime_read_fixed16(quicktime_t *file)
 443 {
 444         unsigned char data[2];
 445
 446         quicktime_read_data(file, data, 2);
 447 //printf("quicktime_read_fixed16 %02x%02x\n", data[0], data[1]);
 448         if(data[1])
 449                 return (float)data[0] + (float)data[1] / 256;
 450         else
 451                 return (float)data[0];
 452 }
 453
 454 int quicktime_write_fixed16(quicktime_t *file, float number)
 455 {
 456         unsigned char data[2];
 457         int a, b;
 458
 459         a = number;
 460         b = (number - a) * 256;
 461         data[0] = a;
 462         data[1] = b;
 463
 464         return quicktime_write_data(file, data, 2);
 465 }
 466
 467 unsigned long quicktime_read_uint32(quicktime_t *file)
 468 {
 469         unsigned long result;
 470         unsigned long a, b, c, d;
 471         char data[4];
 472
 473         quicktime_read_data(file, data, 4);
 474         a = (unsigned char)data[0];
 475         b = (unsigned char)data[1];
 476         c = (unsigned char)data[2];
 477         d = (unsigned char)data[3];
 478
 479         result = (a << 24) | (b << 16) | (c << 8) | d;
 480         return result;
 481 }
 482
 483 long quicktime_read_int32(quicktime_t *file)
 484 {
 485         unsigned long result;
 486         unsigned long a, b, c, d;
 487         char data[4];
 488
 489         quicktime_read_data(file, data, 4);
 490         a = (unsigned char)data[0];
 491         b = (unsigned char)data[1];
 492         c = (unsigned char)data[2];
 493         d = (unsigned char)data[3];
 494
 495         result = (a << 24) | (b << 16) | (c << 8) | d;
 496         return (long)result;
 497 }
 498
 499 long quicktime_read_int32_le(quicktime_t *file)
 500 {
 501         unsigned long result;
 502         unsigned long a, b, c, d;
 503         char data[4];
 504
 505         quicktime_read_data(file, data, 4);
 506         a = (unsigned char)data[0];
 507         b = (unsigned char)data[1];
 508         c = (unsigned char)data[2];
 509         d = (unsigned char)data[3];
 510
 511         result = (d << 24) | (c << 16) | (b << 8) | a;
 512         return (long)result;
 513 }
 514
 515 int64_t quicktime_read_int64(quicktime_t *file)
 516 {
 517         uint64_t result, a, b, c, d, e, f, g, h;
 518         char data[8];
 519
 520         quicktime_read_data(file, data, 8);
 521         a = (unsigned char)data[0];
 522         b = (unsigned char)data[1];
 523         c = (unsigned char)data[2];
 524         d = (unsigned char)data[3];
 525         e = (unsigned char)data[4];
 526         f = (unsigned char)data[5];
 527         g = (unsigned char)data[6];
 528         h = (unsigned char)data[7];
 529
 530         result = (a << 56) |
 531                 (b << 48) |
 532                 (c << 40) |
 533                 (d << 32) |
 534                 (e << 24) |
 535                 (f << 16) |
 536                 (g << 8) |
 537                 h;
 538         return (int64_t)result;
 539 }
 540
 541 int64_t quicktime_read_int64_le(quicktime_t *file)
 542 {
 543         uint64_t result, a, b, c, d, e, f, g, h;
 544         char data[8];
 545
 546         quicktime_read_data(file, data, 8);
 547         a = (unsigned char)data[7];
 548         b = (unsigned char)data[6];
 549         c = (unsigned char)data[5];
 550         d = (unsigned char)data[4];
 551         e = (unsigned char)data[3];
 552         f = (unsigned char)data[2];
 553         g = (unsigned char)data[1];
 554         h = (unsigned char)data[0];
 555
 556         result = (a << 56) |
 557                 (b << 48) |
 558                 (c << 40) |
 559                 (d << 32) |
 560                 (e << 24) |
 561                 (f << 16) |
 562                 (g << 8) |
 563                 h;
 564         return (int64_t)result;
 565 }
 566
 567
 568 long quicktime_read_int24(quicktime_t *file)
 569 {
 570         unsigned long result;
 571         unsigned long a, b, c;
 572         char data[4];
 573
 574         quicktime_read_data(file, data, 3);
 575         a = (unsigned char)data[0];
 576         b = (unsigned char)data[1];
 577         c = (unsigned char)data[2];
 578
 579         result = (a << 16) | (b << 8) | c;
 580         return (long)result;
 581 }
 582
 583 int quicktime_write_int24(quicktime_t *file, long number)
 584 {
 585         unsigned char data[3];
 586         data[0] = (number & 0xff0000) >> 16;
 587         data[1] = (number & 0xff00) >> 8;
 588         data[2] = (number & 0xff);
 589
 590         return quicktime_write_data(file, data, 3);
 591 }
 592
 593 int quicktime_read_int16(quicktime_t *file)
 594 {
 595         unsigned long result;
 596         unsigned long a, b;
 597         char data[2];
 598
 599         quicktime_read_data(file, data, 2);
 600         a = (unsigned char)data[0];
 601         b = (unsigned char)data[1];
 602
 603         result = (a << 8) | b;
 604         return (int)result;
 605 }
 606
 607 int quicktime_read_int16_le(quicktime_t *file)
 608 {
 609         unsigned long result;
 610         unsigned long a, b;
 611         char data[2];
 612
 613         quicktime_read_data(file, data, 2);
 614         a = (unsigned char)data[0];
 615         b = (unsigned char)data[1];
 616
 617         result = (b << 8) | a;
 618         return (int)result;
 619 }
 620
 621 int quicktime_write_int16(quicktime_t *file, int number)
 622 {
 623         unsigned char data[2];
 624         data[0] = (number & 0xff00) >> 8;
 625         data[1] = (number & 0xff);
 626
 627         return quicktime_write_data(file, data, 2);
 628 }
 629
 630 int quicktime_write_int16_le(quicktime_t *file, int number)
 631 {
 632         unsigned char data[2];
 633         data[1] = (number & 0xff00) >> 8;
 634         data[0] = (number & 0xff);
 635
 636         return quicktime_write_data(file, data, 2);
 637 }
 638
 639 int quicktime_read_char(quicktime_t *file)
 640 {
 641         char output;
 642         quicktime_read_data(file, &output, 1);
 643         return output;
 644 }
 645
 646 int quicktime_write_char(quicktime_t *file, char x)
 647 {
 648         return quicktime_write_data(file, &x, 1);
 649 }
 650
 651 void quicktime_read_char32(quicktime_t *file, char *string)
 652 {
 653         quicktime_read_data(file, string, 4);
 654 }
 655
 656 int64_t quicktime_position(quicktime_t *file)
 657 {
 658         return file->file_position;
 659 }
 660
 661 int quicktime_set_position(quicktime_t *file, int64_t position)
 662 {
 663         file->file_position = position;
 664         return 0;
 665 }
 666
 667 void quicktime_copy_char32(char *output, char *input)
 668 {
 669         *output++ = *input++;
 670         *output++ = *input++;
 671         *output++ = *input++;
 672         *output = *input;
 673 }
 674
 675
 676 void quicktime_print_chars(char *desc, char *input, int len)
 677 {
 678         int i;
 679         printf("%s", desc);
 680         for(i = 0; i < len; i++) printf("%c", input[i]);
 681         printf("\n");
 682 }
 683
 684 unsigned long quicktime_current_time(void)
 685 {
 686         time_t t;
 687         time (&t);
 688         return (t+(66*31536000)+1468800);
 689 }
 690
 691 int quicktime_match_32(char *input, char *output)
 692 {
 693         if(input[0] == output[0] &&
 694                 input[1] == output[1] &&
 695                 input[2] == output[2] &&
 696                 input[3] == output[3])
 697                 return 1;
 698         else
 699                 return 0;
 700 }
 701
 702 int quicktime_match_24(char *input, char *output)
 703 {
 704         if(input[0] == output[0] &&
 705                 input[1] == output[1] &&
 706                 input[2] == output[2])
 707                 return 1;
 708         else
 709                 return 0;
 710 }