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 / codecs.c < prev    next >
C/C++ Source or Header  |  2000-11-29  |  9KB  |  347 lines
  1. #include "colormodels.h"
  2. #include "quicktime.h"
  3.  
  4. static int quicktime_delete_vcodec_stub(quicktime_video_map_t *vtrack)
  5. {
  6.     printf("quicktime_delete_vcodec_stub called");
  7.     return 0;
  8. }
  9.  
  10. static int quicktime_delete_acodec_stub(quicktime_audio_map_t *atrack)
  11. {
  12.     printf("quicktime_delete_acodec_stub called");
  13.     return 0;
  14. }
  15.  
  16. static int quicktime_decode_video_stub(quicktime_t *file, 
  17.                 unsigned char **row_pointers, 
  18.                 int track)
  19. {
  20.     printf("quicktime_decode_video_stub called");
  21.     return 1;
  22. }
  23.  
  24. static int quicktime_encode_video_stub(quicktime_t *file, 
  25.                 unsigned char **row_pointers, 
  26.                 int track)
  27. {
  28.     printf("quicktime_encode_video_stub called");
  29.     return 1;
  30. }
  31.  
  32. static int quicktime_decode_audio_stub(quicktime_t *file, 
  33.                     QUICKTIME_INT16 *output_i, 
  34.                     float *output_f, 
  35.                     long samples, 
  36.                     int track, 
  37.                     int channel)
  38. {
  39.     printf("quicktime_decode_audio_stub called");
  40.     return 1;
  41. }
  42.  
  43. static int quicktime_encode_audio_stub(quicktime_t *file, 
  44.                 QUICKTIME_INT16 **input_i, 
  45.                 float **input_f, 
  46.                 int track, 
  47.                 long samples)
  48. {
  49.     printf("quicktime_encode_audio_stub called");
  50.     return 1;
  51. }
  52.  
  53.  
  54. static int quicktime_reads_colormodel_stub(quicktime_t *file, 
  55.         int colormodel, 
  56.         int track)
  57. {
  58.     return (colormodel == BC_RGB888);
  59. }
  60.  
  61. static int quicktime_writes_colormodel_stub(quicktime_t *file, 
  62.         int colormodel, 
  63.         int track)
  64. {
  65.     return (colormodel == BC_RGB888);
  66. }
  67.  
  68. int quicktime_codec_defaults(quicktime_codec_t *codec)
  69. {
  70.     codec->delete_vcodec = quicktime_delete_vcodec_stub;
  71.     codec->delete_acodec = quicktime_delete_acodec_stub;
  72.     codec->decode_video = quicktime_decode_video_stub;
  73.     codec->encode_video = quicktime_encode_video_stub;
  74.     codec->decode_audio = quicktime_decode_audio_stub;
  75.     codec->encode_audio = quicktime_encode_audio_stub;
  76.     codec->reads_colormodel = quicktime_reads_colormodel_stub;
  77.     codec->writes_colormodel = quicktime_writes_colormodel_stub;
  78.     return 0;
  79. }
  80.  
  81. static int get_vcodec_index(char *compressor)
  82. {
  83.     int index;
  84. /* Initialize internal codecs on the first call */
  85.     if(quicktime_vcodec_size() == 0)
  86.         quicktime_register_internal_vcodec();
  87.  
  88. /* Try internal codec */
  89.     index = quicktime_find_vcodec(compressor);
  90.  
  91. /* Try external codec */
  92.     if(index < 0)
  93.     {
  94.         index = quicktime_register_external_vcodec(compressor);
  95.     }
  96.  
  97.     if(index < 0)
  98.         return -1;
  99.     return index;
  100. }
  101.  
  102. static int get_acodec_index(char *compressor)
  103. {
  104.     int index;
  105. /* Initialize internal codecs on the first call */
  106.     if(quicktime_acodec_size() == 0)
  107.         quicktime_register_internal_acodec();
  108.  
  109. /* Try internal codec */
  110.     index = quicktime_find_acodec(compressor);
  111.  
  112. /* Try external codec */
  113.     if(index < 0)
  114.     {
  115.         index = quicktime_register_external_acodec(compressor);
  116.     }
  117.  
  118.     if(index < 0)
  119.         return -1;
  120.     return index;
  121. }
  122.  
  123.  
  124. int quicktime_init_vcodec(quicktime_video_map_t *vtrack)
  125. {
  126.     char *compressor = vtrack->track->mdia.minf.stbl.stsd.table[0].format;
  127.       int index;
  128.     vtrack->codec = calloc(1, sizeof(quicktime_codec_t));
  129.     quicktime_codec_defaults((quicktime_codec_t*)vtrack->codec);
  130.  
  131.     if((index = get_vcodec_index(compressor)) < 0) return -1;
  132.  
  133. /* Initialize the codec */
  134.     return quicktime_init_vcodec_core(index, vtrack);
  135. }
  136.  
  137. int quicktime_init_acodec(quicktime_audio_map_t *atrack)
  138. {
  139.     char *compressor = atrack->track->mdia.minf.stbl.stsd.table[0].format;
  140.     int index;
  141.  
  142.     atrack->codec = calloc(1, sizeof(quicktime_codec_t));
  143.     quicktime_codec_defaults((quicktime_codec_t*)atrack->codec);
  144.  
  145.     if((index = get_acodec_index(compressor)) < 0) return -1;
  146.  
  147. /* Initialize the codec */
  148.     return quicktime_init_acodec_core(index, atrack);
  149. }
  150.  
  151.  
  152. int quicktime_delete_vcodec(quicktime_video_map_t *vtrack)
  153. {
  154.     ((quicktime_codec_t*)vtrack->codec)->delete_vcodec(vtrack);
  155.     free(vtrack->codec);
  156.     vtrack->codec = 0;
  157.     return 0;
  158. }
  159.  
  160. int quicktime_delete_acodec(quicktime_audio_map_t *atrack)
  161. {
  162.     ((quicktime_codec_t*)atrack->codec)->delete_acodec(atrack);
  163.     free(atrack->codec);
  164.     atrack->codec = 0;
  165.     return 0;
  166. }
  167.  
  168. int quicktime_supported_video(quicktime_t *file, int track)
  169. {
  170.     char *compressor = quicktime_video_compressor(file, track);
  171.     if((get_vcodec_index(compressor)) < 0) return 0;
  172.     return 1;
  173. }
  174.  
  175. int quicktime_supported_audio(quicktime_t *file, int track)
  176. {
  177.     char *compressor = quicktime_audio_compressor(file, track);
  178.     if((get_acodec_index(compressor)) < 0) return 0;
  179.     return 1;
  180. }
  181.  
  182. int quicktime_decode_video(quicktime_t *file, unsigned char **row_pointers, int track)
  183. {
  184.     int result;
  185.     quicktime_trak_t *trak = file->vtracks[track].track;
  186.     int track_height = trak->tkhd.track_height;
  187.     int track_width = trak->tkhd.track_width;
  188.  
  189. // Fake scaling parameters
  190.     file->do_scaling = 0;
  191.     file->color_model = BC_RGB888;
  192.     file->in_x = 0;
  193.     file->in_y = 0;
  194.     file->in_w = track_width;
  195.     file->in_h = track_height;
  196.     file->out_w = track_width;
  197.     file->out_h = track_height;
  198.  
  199.     result = ((quicktime_codec_t*)file->vtracks[track].codec)->decode_video(file, row_pointers, track);
  200.     file->vtracks[track].current_position++;
  201.     return result;
  202. }
  203.  
  204. long quicktime_decode_scaled(quicktime_t *file, 
  205.     int in_x,                    /* Location of input frame to take picture */
  206.     int in_y,
  207.     int in_w,
  208.     int in_h,
  209.     int out_w,                   /* Dimensions of output frame */
  210.     int out_h,
  211.     int color_model,             /* One of the color models defined above */
  212.     unsigned char **row_pointers, 
  213.     int track)
  214. {
  215.     int result;
  216.  
  217.     file->do_scaling = 1;
  218.     file->color_model = color_model;
  219.     file->in_x = in_x;
  220.     file->in_y = in_y;
  221.     file->in_w = in_w;
  222.     file->in_h = in_h;
  223.     file->out_w = out_w;
  224.     file->out_h = out_h;
  225.  
  226.     result = ((quicktime_codec_t*)file->vtracks[track].codec)->decode_video(file, row_pointers, track);
  227.     file->vtracks[track].current_position++;
  228.     return result;
  229. }
  230.  
  231.  
  232. int quicktime_encode_video(quicktime_t *file, 
  233.     unsigned char **row_pointers, 
  234.     int track)
  235. {
  236.     int result;
  237.     result = ((quicktime_codec_t*)file->vtracks[track].codec)->encode_video(file, row_pointers, track);
  238.     file->vtracks[track].current_position++;
  239.     return result;
  240. }
  241.  
  242.  
  243. int quicktime_decode_audio(quicktime_t *file, 
  244.                 QUICKTIME_INT16 *output_i, 
  245.                 float *output_f, 
  246.                 long samples, 
  247.                 int channel)
  248. {
  249.     int quicktime_track, quicktime_channel;
  250.     int result = 1;
  251.  
  252.     quicktime_channel_location(file, &quicktime_track, &quicktime_channel, channel);
  253.     result = ((quicktime_codec_t*)file->atracks[quicktime_track].codec)->decode_audio(file, 
  254.                 output_i, 
  255.                 output_f, 
  256.                 samples, 
  257.                 quicktime_track, 
  258.                 quicktime_channel);
  259.     file->atracks[quicktime_track].current_position += samples;
  260.  
  261.     return result;
  262. }
  263.  
  264. /* Since all channels are written at the same time: */
  265. /* Encode using the compressor for the first audio track. */
  266. /* Which means all the audio channels must be on the same track. */
  267.  
  268. int quicktime_encode_audio(quicktime_t *file, QUICKTIME_INT16 **input_i, float **input_f, long samples)
  269. {
  270.     int result = 1;
  271.     char *compressor = quicktime_audio_compressor(file, 0);
  272.  
  273.     if(quicktime_test_position(file)) return 1;
  274.  
  275.     result = ((quicktime_codec_t*)file->atracks[0].codec)->encode_audio(file, 
  276.         input_i, 
  277.         input_f,
  278.         0, 
  279.         samples);
  280.     file->atracks[0].current_position += samples;
  281.  
  282.     return result;
  283. }
  284.  
  285. int quicktime_reads_cmodel(quicktime_t *file, 
  286.     int colormodel, 
  287.     int track)
  288. {
  289.     int result = ((quicktime_codec_t*)file->vtracks[track].codec)->reads_colormodel(file, colormodel, track);
  290.     return result;
  291. }
  292.  
  293. int quicktime_writes_cmodel(quicktime_t *file, 
  294.     int colormodel, 
  295.     int track)
  296. {
  297.     return ((quicktime_codec_t*)file->vtracks[track].codec)->writes_colormodel(file, colormodel, track);
  298. }
  299.  
  300. long quicktime_samples_to_bytes(quicktime_trak_t *track, long samples)
  301. {
  302.     char *compressor = track->mdia.minf.stbl.stsd.table[0].format;
  303.     int channels = track->mdia.minf.stbl.stsd.table[0].channels;
  304.  
  305.     if(quicktime_match_32(compressor, QUICKTIME_IMA4)) 
  306.         return samples * channels;
  307.  
  308.     if(quicktime_match_32(compressor, QUICKTIME_ULAW)) 
  309.         return samples * channels;
  310.  
  311. /* Default use the sample size specification for TWOS and RAW */
  312.     return samples * channels * track->mdia.minf.stbl.stsd.table[0].sample_size / 8;
  313. }
  314.  
  315. /* Compressors that can only encode a window at a time */
  316. /* need to flush extra data here. */
  317.  
  318. int quicktime_flush_acodec(quicktime_t *file, int track)
  319. {
  320.     int result = 0;
  321.     if(quicktime_match_32(quicktime_audio_compressor(file, track), QUICKTIME_IMA4))
  322.     {
  323.         result = quicktime_flush_ima4(file, track);
  324.     }
  325.     return result;
  326. };
  327.  
  328. void quicktime_flush_vcodec(quicktime_t *file, int track)
  329. {
  330. }
  331.  
  332. int quicktime_codecs_flush(quicktime_t *file)
  333. {
  334.     int result = 0;
  335.     int i;
  336.     if(!file->wr) return result;
  337.  
  338.     if(file->total_atracks)
  339.     {
  340.         for(i = 0; i < file->total_atracks && !result; i++)
  341.         {
  342.             result += quicktime_flush_acodec(file, i);
  343.         }
  344.     }
  345.     return result;
  346. }
  347.