cinelerra-5.0/quicktime/plugin.c

   1 #include <stdio.h>
   2 #include <dirent.h>
   3 #include <dlfcn.h>
   4 #include "funcprotos.h"
   5 #include "quicktime.h"
   6
   7
   8 static int total_vcodecs = 0;
   9 static int total_acodecs = 0;
  10 static quicktime_codectable_t *vcodecs = NULL;
  11 static quicktime_codectable_t *acodecs = NULL;
  12
  13
  14
  15
  16 static int register_vcodec(void (*init_vcodec)(quicktime_video_map_t *),
  17                 const char *fourcc, int vid_id)
  18 {
  19         int idx = total_vcodecs++;
  20         const uint8_t *bp = (const uint8_t *)fourcc;
  21         vcodecs = (quicktime_codectable_t *)realloc(vcodecs,
  22                 total_vcodecs * sizeof(quicktime_codectable_t));
  23         quicktime_codectable_t *codec = vcodecs + idx;
  24         codec->fourcc = (bp[3]<<24) | (bp[2]<<16) | (bp[1]<<8) | (bp[0]<<0);
  25         codec->id = vid_id;
  26         codec->init_vcodec = init_vcodec;
  27         return idx;
  28 }
  29
  30 static int register_acodec(void (*init_acodec)(quicktime_audio_map_t *),
  31                 const char *fourcc, int wav_id)
  32 {
  33         int idx = total_acodecs++;
  34         const uint8_t *bp = (const uint8_t *)fourcc;
  35         acodecs = (quicktime_codectable_t *)realloc(acodecs,
  36                 total_acodecs * sizeof(quicktime_codectable_t));
  37         quicktime_codectable_t *codec = acodecs + idx;
  38         codec->fourcc = (bp[3]<<24) | (bp[2]<<16) | (bp[1]<<8) | (bp[0]<<0);
  39         codec->id = wav_id;
  40         codec->init_acodec = init_acodec;
  41         return idx;
  42 }
  43
  44
  45
  46
  47 #include "ima4.h"
  48 #include "mp4a.h"
  49 #include "qdm2.h"
  50 #include "qtvorbis.h"
  51 #include "qtmp3.h"
  52 #include "rawaudio.h"
  53 #include "twos.h"
  54 #include "ulaw.h"
  55 #include "wma.h"
  56 #include "wmx2.h"
  57
  58 static void register_acodecs()
  59 {
  60         register_acodec(quicktime_init_codec_twos, QUICKTIME_TWOS, 0x01);
  61         register_acodec(quicktime_init_codec_sowt, QUICKTIME_SOWT, 0x01);
  62         register_acodec(quicktime_init_codec_rawaudio, QUICKTIME_RAW, 0x01);
  63         register_acodec(quicktime_init_codec_ima4, QUICKTIME_IMA4, 0x11);
  64         register_acodec(quicktime_init_codec_mp4a, QUICKTIME_MP4A, 0);
  65         register_acodec(quicktime_init_codec_qdm2, QUICKTIME_QDM2, 0);
  66         register_acodec(quicktime_init_codec_ulaw, QUICKTIME_ULAW, 0x07);
  67
  68         register_acodec(quicktime_init_codec_vorbis, QUICKTIME_VORBIS, 0x01);
  69         register_acodec(quicktime_init_codec_mp3, QUICKTIME_MP3, 0x55);
  70         register_acodec(quicktime_init_codec_wmx2, QUICKTIME_WMX2, 0x11);
  71         register_acodec(quicktime_init_codec_wmav1, QUICKTIME_WMA, 0x160);
  72         register_acodec(quicktime_init_codec_wmav2, QUICKTIME_WMA, 0x161);
  73 }
  74
  75
  76
  77
  78
  79 #include "qth264.h"
  80 #include "raw.h"
  81 #include "qtdv.h"
  82 #include "jpeg.h"
  83 #include "mpeg4.h"
  84 #include "qtpng.h"
  85 #include "rle.h"
  86 #include "v308.h"
  87 #include "v408.h"
  88 #include "v410.h"
  89 #include "yuv2.h"
  90 #include "yuv4.h"
  91 #include "yv12.h"
  92
  93 static void register_vcodecs()
  94 {
  95
  96         register_vcodec(quicktime_init_codec_raw, QUICKTIME_RAW, 0);
  97
  98         register_vcodec(quicktime_init_codec_h264, QUICKTIME_H264, 1);
  99         register_vcodec(quicktime_init_codec_hv64, QUICKTIME_HV64, 2);
 100         register_vcodec(quicktime_init_codec_divx, QUICKTIME_DIVX, 0);
 101         register_vcodec(quicktime_init_codec_hv60, QUICKTIME_HV60, 0);
 102         register_vcodec(quicktime_init_codec_div5, QUICKTIME_DX50, 0);
 103         register_vcodec(quicktime_init_codec_div3, QUICKTIME_DIV3, 0);
 104         register_vcodec(quicktime_init_codec_div3v2, QUICKTIME_MP42, 0);
 105         register_vcodec(quicktime_init_codec_div3lower, QUICKTIME_DIV3_LOWER, 0);
 106         register_vcodec(quicktime_init_codec_mp4v, QUICKTIME_MP4V, 0);
 107         register_vcodec(quicktime_init_codec_xvid, QUICKTIME_XVID, 0);
 108         register_vcodec(quicktime_init_codec_dnxhd, QUICKTIME_DNXHD, 0);
 109         register_vcodec(quicktime_init_codec_svq1, QUICKTIME_SVQ1, 0);
 110         register_vcodec(quicktime_init_codec_svq3, QUICKTIME_SVQ3, 0);
 111         register_vcodec(quicktime_init_codec_h263, QUICKTIME_H263, 0);
 112         register_vcodec(quicktime_init_codec_dv, QUICKTIME_DV, 0);
 113         register_vcodec(quicktime_init_codec_dvsd, QUICKTIME_DVSD, 0);
 114         register_vcodec(quicktime_init_codec_dvcp, QUICKTIME_DVCP, 0);
 115
 116         register_vcodec(quicktime_init_codec_jpeg, QUICKTIME_JPEG, 0);
 117         register_vcodec(quicktime_init_codec_mjpa, QUICKTIME_MJPA, 0);
 118         register_vcodec(quicktime_init_codec_mjpg, QUICKTIME_MJPG, 0);
 119         register_vcodec(quicktime_init_codec_png, QUICKTIME_PNG, 0);
 120         register_vcodec(quicktime_init_codec_rle, QUICKTIME_RLE, 0);
 121
 122         register_vcodec(quicktime_init_codec_yuv2, QUICKTIME_YUV2, 0);
 123         register_vcodec(quicktime_init_codec_2vuy, QUICKTIME_2VUY, 0);
 124         register_vcodec(quicktime_init_codec_yuv4, QUICKTIME_YUV4, 0);
 125         register_vcodec(quicktime_init_codec_yv12, QUICKTIME_YUV420, 0);
 126         register_vcodec(quicktime_init_codec_v410, QUICKTIME_YUV444_10bit, 0);
 127         register_vcodec(quicktime_init_codec_v308, QUICKTIME_YUV444, 0);
 128         register_vcodec(quicktime_init_codec_v408, QUICKTIME_YUVA4444, 0);
 129 }
 130
 131
 132
 133
 134 int quicktime_find_vcodec(quicktime_video_map_t *vtrack)
 135 {
 136         int i;
 137         quicktime_codec_t *codec_base = 0;
 138         char *compressor = vtrack->track->mdia.minf.stbl.stsd.table[0].format;
 139         const uint8_t *bp = (const uint8_t *)compressor;
 140         uint32_t fourcc = (bp[3]<<24) | (bp[2]<<16) | (bp[1]<<8) | (bp[0]<<0);
 141         if(!total_vcodecs) register_vcodecs();
 142         for(i = 0; i<total_vcodecs; ++i ) {
 143                 if( fourcc == vcodecs[i].fourcc ) break;
 144         }
 145         if( i >= total_vcodecs ) return -1;
 146         if( !(codec_base = quicktime_new_codec()) ) return -1;
 147         vtrack->codec = codec_base;
 148         vcodecs[i].init_vcodec(vtrack);
 149         return 0;
 150 }
 151
 152 int quicktime_find_acodec(quicktime_audio_map_t *atrack)
 153 {
 154         int i;
 155         char *compressor = atrack->track->mdia.minf.stbl.stsd.table[0].format;
 156         int compression_id = atrack->track->mdia.minf.stbl.stsd.table[0].compression_id;
 157         const uint8_t *bp = (const uint8_t *)compressor;
 158         uint32_t fourcc = (bp[3]<<24) | (bp[2]<<16) | (bp[1]<<8) | (bp[0]<<0);
 159         if(!total_acodecs) register_acodecs();
 160         quicktime_codec_t *codec_base = 0;
 161
 162         for(i = 0; i<total_acodecs; ++i ) {
 163                 if( fourcc == acodecs[i].fourcc ) break;
 164 // For reading AVI, sometimes the fourcc is 0 and the compression_id is used instead.
 165 // Sometimes the compression_id is the fourcc.
 166                 if( acodecs[i].id != compression_id ) continue;
 167                 if( !compressor[0] || fourcc == acodecs[i].id ) break;
 168         }
 169         if( i >= total_acodecs ) return -1;
 170         if( !(codec_base = quicktime_new_codec()) ) return -1;
 171         atrack->codec = codec_base;
 172         acodecs[i].init_acodec(atrack);
 173 // For writing and reading Quicktime
 174         quicktime_copy_char32(compressor, codec_base->fourcc);
 175         return 0;
 176 }
 177
 178
 179 char* quicktime_acodec_title(char *fourcc)
 180 {
 181         int i;
 182         char *result = 0;
 183         quicktime_audio_map_t *atrack = (quicktime_audio_map_t*)
 184                 calloc(1, sizeof(quicktime_audio_map_t));
 185         if(!total_acodecs) register_acodecs();
 186         quicktime_codec_t *codec_base = 0;
 187
 188         int done = 0;
 189         for(i = 0; i < total_acodecs && !done; i++) {
 190                 if( !(codec_base = quicktime_new_codec()) ) return 0;
 191                 atrack->codec = codec_base;
 192                 acodecs[i].init_acodec(atrack);
 193                 if( quicktime_match_32(fourcc, codec_base->fourcc) ) {
 194                         result = codec_base->title;
 195                         done = 1;
 196                 }
 197                 codec_base->delete_acodec(atrack);
 198                 quicktime_del_codec(codec_base);
 199         }
 200
 201         free(atrack);
 202         return result ? result : fourcc;
 203 }
 204
 205 char* quicktime_vcodec_title(char *fourcc)
 206 {
 207         int i;
 208         char *result = 0;
 209
 210         quicktime_video_map_t *vtrack =
 211                 (quicktime_video_map_t*)calloc(1, sizeof(quicktime_video_map_t));
 212         if(!total_vcodecs) register_vcodecs();
 213         quicktime_codec_t *codec_base = 0;
 214
 215         int done = 0;
 216         for(i = 0; i < total_vcodecs && !done; i++) {
 217                 if( !(codec_base = quicktime_new_codec()) ) return 0;
 218                 vtrack->codec = codec_base;
 219                 vcodecs[i].init_vcodec(vtrack);
 220                 if( quicktime_match_32(fourcc, codec_base->fourcc) ) {
 221                         result = codec_base->title;
 222                         done = 1;
 223                 }
 224                 codec_base->delete_vcodec(vtrack);
 225                 quicktime_del_codec(codec_base);
 226         }
 227
 228         free(vtrack);
 229         return result ? result : fourcc;
 230 }
 231