home *** CD-ROM | disk | FTP | other *** search
/ Geek 6 / Geek-006.iso / linux / video / xmovie-1.5.3.tar.gz / xmovie-1.5.3.tar / xmovie-1.5.3 / quicktime / util.c < prev    next >
C/C++ Source or Header  |  2000-11-29  |  9KB  |  359 lines
  1. #include <time.h>
  2. #include "quicktime.h"
  3.  
  4. /* Disk I/O */
  5.  
  6.  
  7. /* Read entire buffer from the preload buffer */
  8. int quicktime_read_preload(quicktime_t *file, char *data, int size)
  9. {
  10.     long selection_start = file->file_position;
  11.     long selection_end = file->file_position + size;
  12.     long fragment_start, fragment_len, fragment_end;
  13.  
  14.     fragment_start = file->preload_ptr + (selection_start - file->preload_start);
  15.     while(fragment_start < 0) fragment_start += file->preload_size;
  16.     while(fragment_start >= file->preload_size) fragment_start -= file->preload_size;
  17.  
  18.     while(selection_start < selection_end)
  19.     {
  20.         fragment_len = selection_end - selection_start;
  21.         if(fragment_start + fragment_len > file->preload_size)
  22.             fragment_len = file->preload_size - fragment_start;
  23.         fragment_end = fragment_start + fragment_len;
  24.  
  25.         while(fragment_start < fragment_end)
  26.         {
  27.             *data++ = file->preload_buffer[fragment_start++];
  28.         }
  29.         if(fragment_start >= file->preload_size) fragment_start = 0;
  30.         selection_start += fragment_len;
  31.     }
  32.     return 0;
  33. }
  34.  
  35.  
  36. int quicktime_read_data(quicktime_t *file, char *data, int size)
  37. {
  38.     int result = 1;
  39.     if(!file->preload_size)
  40.     {
  41.         if(ftell(file->stream) != file->file_position) fseek(file->stream, file->file_position, SEEK_SET);
  42.         result = fread(data, size, 1, file->stream);
  43.     }
  44.     else
  45.     {
  46.         long selection_start = file->file_position;
  47.         long selection_end = file->file_position + size;
  48.         long fragment_start, fragment_len, fragment_end;
  49.  
  50.         if(selection_end - selection_start > file->preload_size)
  51.         {
  52. /* Size is larger than preload size.  Should never happen. */
  53.             if(ftell(file->stream) != file->file_position) fseek(file->stream, file->file_position, SEEK_SET);
  54.             result = fread(data, size, 1, file->stream);
  55.         }
  56.         else
  57.         if(selection_start >= file->preload_start && 
  58.             selection_start < file->preload_end &&
  59.             selection_end <= file->preload_end &&
  60.             selection_end > file->preload_start)
  61.         {
  62. /* Entire range is in buffer */
  63.             quicktime_read_preload(file, data, size);
  64.         }
  65.         else
  66.         if(selection_end > file->preload_end && selection_end - file->preload_size < file->preload_end)
  67.         {
  68. /* Range is after buffer */
  69. /* Move the preload start to within one preload length of the selection_end */
  70.             while(selection_end - file->preload_start > file->preload_size)
  71.             {
  72.                 fragment_len = selection_end - file->preload_start - file->preload_size;
  73.                 if(file->preload_ptr + fragment_len > file->preload_size) fragment_len = file->preload_size - file->preload_ptr;
  74.                 file->preload_start += fragment_len;
  75.                 file->preload_ptr += fragment_len;
  76.                 if(file->preload_ptr >= file->preload_size) file->preload_ptr = 0;
  77.             }
  78.  
  79. /* Append sequential data after the preload end to the new end */
  80.             fragment_start = file->preload_ptr + file->preload_end - file->preload_start;
  81.             while(fragment_start >= file->preload_size) fragment_start -= file->preload_size;
  82.  
  83.             while(file->preload_end < selection_end)
  84.             {
  85.                 fragment_len = selection_end - file->preload_end;
  86.                 if(fragment_start + fragment_len > file->preload_size) fragment_len = file->preload_size - fragment_start;
  87.                 if(ftell(file->stream) != file->preload_end) fseek(file->stream, file->preload_end, SEEK_SET);
  88.                 result = fread(&(file->preload_buffer[fragment_start]), fragment_len, 1, file->stream);
  89.                 file->preload_end += fragment_len;
  90.                 fragment_start += fragment_len;
  91.                 if(fragment_start >= file->preload_size) fragment_start = 0;
  92.             }
  93.  
  94.             quicktime_read_preload(file, data, size);
  95.         }
  96.         else
  97.         {
  98. /*printf("quicktime_read_data 4 selection_start %ld selection_end %ld preload_start %ld\n", selection_start, selection_end, file->preload_start); */
  99. /* Range is before buffer or over a preload_size away from the end of the buffer. */
  100. /* Replace entire preload buffer with range. */
  101.             if(ftell(file->stream) != file->file_position) fseek(file->stream, file->file_position, SEEK_SET);
  102.             result = fread(file->preload_buffer, size, 1, file->stream);
  103.             file->preload_start = file->file_position;
  104.             file->preload_end = file->file_position + size;
  105.             file->preload_ptr = 0;
  106.             quicktime_read_preload(file, data, size);
  107.         }
  108.     }
  109.  
  110.     file->file_position += size;
  111.     return result;
  112. }
  113.  
  114. int quicktime_write_data(quicktime_t *file, char *data, int size)
  115. {
  116.     int result;
  117.     if(ftell(file->stream) != file->file_position) fseek(file->stream, file->file_position, SEEK_SET);
  118.     result = fwrite(data, size, 1, file->stream);
  119.     file->file_position += size;
  120.     return result;
  121. }
  122.  
  123. int quicktime_test_position(quicktime_t *file)
  124. {
  125.     if(quicktime_position(file) > MAX_FILESIZE)
  126.     {
  127.         printf("quicktime_test_position: 32 bit overflow\n");
  128.         return 1;
  129.     }
  130.     else
  131.     return 0;
  132. }
  133.  
  134. long quicktime_byte_position(quicktime_t *file)
  135. {
  136.     return quicktime_position(file);
  137. }
  138.  
  139.  
  140. void quicktime_read_pascal(quicktime_t *file, char *data)
  141. {
  142.     char len = quicktime_read_char(file);
  143.     quicktime_read_data(file, data, len);
  144.     data[len] = 0;
  145. }
  146.  
  147. void quicktime_write_pascal(quicktime_t *file, char *data)
  148. {
  149.     char len = strlen(data);
  150.     quicktime_write_data(file, &len, 1);
  151.     quicktime_write_data(file, data, len);
  152. }
  153.  
  154. float quicktime_read_fixed32(quicktime_t *file)
  155. {
  156.     unsigned long a, b, c, d;
  157.     unsigned char data[4];
  158.  
  159.     quicktime_read_data(file, data, 4);
  160. /*    fread(data, 4, 1, file->stream); */
  161.     a = data[0];
  162.     b = data[1];
  163.     c = data[2];
  164.     d = data[3];
  165.     
  166.     a = (a << 8) + b;
  167.     b = (c << 8) + d;
  168.  
  169.     return (float)a + (float)b / 65536;
  170. }
  171.  
  172. int quicktime_write_fixed32(quicktime_t *file, float number)
  173. {
  174.     unsigned char data[4];
  175.     int a, b;
  176.  
  177.     a = number;
  178.     b = (number - a) * 65536;
  179.     data[0] = a >> 8;
  180.     data[1] = a & 0xff;
  181.     data[2] = b >> 8;
  182.     data[3] = b & 0xff;
  183.  
  184.     return quicktime_write_data(file, data, 4);
  185. }
  186.  
  187. int quicktime_write_int32(quicktime_t *file, long value)
  188. {
  189.     unsigned char data[4];
  190.  
  191.     data[0] = (value & 0xff000000) >> 24;
  192.     data[1] = (value & 0xff0000) >> 16;
  193.     data[2] = (value & 0xff00) >> 8;
  194.     data[3] = value & 0xff;
  195.  
  196.     return quicktime_write_data(file, data, 4);
  197. }
  198.  
  199. int quicktime_write_char32(quicktime_t *file, char *string)
  200. {
  201.     return quicktime_write_data(file, string, 4);
  202. }
  203.  
  204.  
  205. float quicktime_read_fixed16(quicktime_t *file)
  206. {
  207.     unsigned char data[2];
  208.     
  209.     quicktime_read_data(file, data, 2);
  210.     return (float)data[0] + (float)data[1] / 256;
  211. }
  212.  
  213. int quicktime_write_fixed16(quicktime_t *file, float number)
  214. {
  215.     unsigned char data[2];
  216.     int a, b;
  217.  
  218.     a = number;
  219.     b = (number - a) * 256;
  220.     data[0] = a;
  221.     data[1] = b;
  222.     
  223.     return quicktime_write_data(file, data, 2);
  224. }
  225.  
  226. long quicktime_read_int32(quicktime_t *file)
  227. {
  228.     unsigned long result;
  229.     unsigned long a, b, c, d;
  230.     char data[4];
  231.     
  232.     quicktime_read_data(file, data, 4);
  233.     a = (unsigned char)data[0];
  234.     b = (unsigned char)data[1];
  235.     c = (unsigned char)data[2];
  236.     d = (unsigned char)data[3];
  237.  
  238.     result = (a<<24) | (b<<16) | (c<<8) | d;
  239.     return (long)result;
  240. }
  241.  
  242.  
  243. long quicktime_read_int24(quicktime_t *file)
  244. {
  245.     unsigned long result;
  246.     unsigned long a, b, c;
  247.     char data[4];
  248.     
  249.     quicktime_read_data(file, data, 3);
  250. /*    fread(data, 3, 1, file->stream); */
  251.     a = (unsigned char)data[0];
  252.     b = (unsigned char)data[1];
  253.     c = (unsigned char)data[2];
  254.  
  255.     result = (a<<16) | (b<<8) | c;
  256.     return (long)result;
  257. }
  258.  
  259. int quicktime_write_int24(quicktime_t *file, long number)
  260. {
  261.     unsigned char data[3];
  262.     data[0] = (number & 0xff0000) >> 16;
  263.     data[1] = (number & 0xff00) >> 8;
  264.     data[2] = (number & 0xff);
  265.     
  266.     return quicktime_write_data(file, data, 3);
  267. /*    return fwrite(data, 3, 1, file->stream); */
  268. }
  269.  
  270. int quicktime_read_int16(quicktime_t *file)
  271. {
  272.     unsigned long result;
  273.     unsigned long a, b;
  274.     char data[2];
  275.     
  276.     quicktime_read_data(file, data, 2);
  277. /*    fread(data, 2, 1, file->stream); */
  278.     a = (unsigned char)data[0];
  279.     b = (unsigned char)data[1];
  280.  
  281.     result = (a<<8) | b;
  282.     return (int)result;
  283. }
  284.  
  285. int quicktime_write_int16(quicktime_t *file, int number)
  286. {
  287.     unsigned char data[2];
  288.     data[0] = (number & 0xff00) >> 8;
  289.     data[1] = (number & 0xff);
  290.     
  291.     return quicktime_write_data(file, data, 2);
  292. /*    return fwrite(data, 2, 1, file->stream); */
  293. }
  294.  
  295. int quicktime_read_char(quicktime_t *file)
  296. {
  297.     char output;
  298.     quicktime_read_data(file, &output, 1);
  299.     return output;
  300. }
  301.  
  302. int quicktime_write_char(quicktime_t *file, char x)
  303. {
  304.     return quicktime_write_data(file, &x, 1);
  305. }
  306.  
  307. void quicktime_read_char32(quicktime_t *file, char *string)
  308. {
  309.     quicktime_read_data(file, string, 4);
  310. /*    fread(string, 4, 1, file->stream); */
  311. }
  312.  
  313. long quicktime_position(quicktime_t *file) 
  314. { 
  315.     return file->file_position; 
  316. }
  317.  
  318. int quicktime_set_position(quicktime_t *file, long position) 
  319. {
  320.     file->file_position = position;
  321.     return 0;
  322. /*    fseek(file->stream, position, SEEK_SET);  */
  323. }
  324.  
  325. void quicktime_copy_char32(char *output, char *input)
  326. {
  327.     *output++ = *input++;
  328.     *output++ = *input++;
  329.     *output++ = *input++;
  330.     *output = *input;
  331. }
  332.  
  333.  
  334. void quicktime_print_chars(char *desc, char *input, int len)
  335. {
  336.     int i;
  337.     printf("%s", desc);
  338.     for(i = 0; i < len; i++) printf("%c", input[i]);
  339.     printf("\n");
  340. }
  341.  
  342. unsigned long quicktime_current_time(void)
  343. {
  344.     time_t t;
  345.     time (&t);
  346.     return (t+(66*31536000)+1468800);
  347. }
  348.  
  349. int quicktime_match_32(char *input, char *output)
  350. {
  351.     if(input[0] == output[0] &&
  352.         input[1] == output[1] &&
  353.         input[2] == output[2] &&
  354.         input[3] == output[3])
  355.         return 1;
  356.     else 
  357.         return 0;
  358. }
  359.