Add ADM2 .wem [The Grand Tour Game (PC)]

src/formats.c

@@ -1402,7 +1402,7 @@ static const meta_info meta_info_list[] = {
         {meta_SSPF,                 "Konami SSPF header"},
         {meta_S3V,                  "Konami S3V header"},
         {meta_ESF,                  "Eurocom ESF header"},
-        {meta_ADM3,                 "Crankcase ADM3 header"},
+        {meta_ADM,                  "Crankcase ADMx header"},
         {meta_TT_AD,                "Traveller's Tales AUDIO_DATA header"},
         {meta_SNDZ,                 "Sony SNDZ header"},
         {meta_VAB,                  "Sony VAB header"},

src/meta/adm3.c

@@ -5,6 +5,7 @@
 typedef struct {
     int total_subsongs;
     int target_subsong;
+    int version;
 
     uint32_t stream_offset;
     uint32_t stream_size;
@@ -13,51 +14,70 @@ typedef struct {
     int sample_rate;
     int channels;
     int32_t num_samples;
-} adm3_header_t;
+} adm_header_t;
 
-static int parse_adm3(adm3_header_t* adm3, STREAMFILE* sf);
+static int parse_adm(adm_header_t* adm, STREAMFILE* sf);
 
+static VGMSTREAM* init_vgmstream_adm(STREAMFILE* sf, int version);
+
+/* ADM2 - Crankcase Audio REV plugin file [The Grand Tour Game (PC)] */
+VGMSTREAM* init_vgmstream_adm2(STREAMFILE* sf) {
+
+    /* checks */
+    if (!is_id32be(0x00,sf, "ADM2"))
+        return NULL;
+    if (!check_extensions(sf, "wem"))
+        return NULL;
+
+    return init_vgmstream_adm(sf, 2);
+}
 
 /* ADM3 - Crankcase Audio REV plugin file [Cyberpunk 2077 (PC), MotoGP 21 (PC)] */
 VGMSTREAM* init_vgmstream_adm3(STREAMFILE* sf) {
-    VGMSTREAM* vgmstream = NULL;
-    adm3_header_t adm3 = {0};
-
 
     /* checks */
     if (!is_id32be(0x00,sf, "ADM3"))
-        goto fail;
+        return NULL;
     if (!check_extensions(sf, "wem"))
-        goto fail;
+        return NULL;
 
-    adm3.target_subsong = sf->stream_index;
+    return init_vgmstream_adm(sf, 3);
-    if (adm3.target_subsong == 0) adm3.target_subsong = 1;
+}
 
-    /* ADM3 are files used with the Wwise Crankaudio plugin, that simulate engine noises with
+static VGMSTREAM* init_vgmstream_adm(STREAMFILE* sf, int version) {
+    VGMSTREAM* vgmstream = NULL;
+    adm_header_t adm = {0};
+
+    /* ADMx are files used with the Wwise Crankaudio plugin, that simulate engine noises with
      * base internal samples and some internal RPM config (probably). Actual file seems to
      * define some combo of samples, this only plays those separate samples.
      * Decoder is basically Apple's IMA (internally just "ADPCMDecoder") but transforms to float
      * each sample during decode by multiplying by 0.000030518509 */
 
-    if (!parse_adm3(&adm3, sf))
+    adm.target_subsong = sf->stream_index;
+    if (adm.target_subsong == 0) adm.target_subsong = 1;
+
+    adm.version = version;
+
+    if (!parse_adm(&adm, sf))
         goto fail;
 
 
     /* build the VGMSTREAM */
-    vgmstream = allocate_vgmstream(adm3.channels, adm3.loop_flag);
+    vgmstream = allocate_vgmstream(adm.channels, adm.loop_flag);
     if (!vgmstream) goto fail;
 
-    vgmstream->meta_type = meta_ADM3;
+    vgmstream->meta_type = meta_ADM;
-    vgmstream->sample_rate = adm3.sample_rate;
+    vgmstream->sample_rate = adm.sample_rate;
-    vgmstream->num_samples = adm3.num_samples; /* slightly lower than bytes-to-samples */
+    vgmstream->num_samples = adm.num_samples; /* slightly lower than bytes-to-samples */
-    vgmstream->num_streams = adm3.total_subsongs;
+    vgmstream->num_streams = adm.total_subsongs;
-    vgmstream->stream_size = adm3.stream_size;
+    vgmstream->stream_size = adm.stream_size;
 
     vgmstream->coding_type = coding_APPLE_IMA4;
     vgmstream->layout_type = layout_interleave;
     vgmstream->interleave_block_size = 0x22;
 
-    if (!vgmstream_open_stream(vgmstream, sf, adm3.stream_offset))
+    if (!vgmstream_open_stream(vgmstream, sf, adm.stream_offset))
         goto fail;
     return vgmstream;
 
@@ -67,11 +87,37 @@ fail:
 }
 
 
-static int parse_type(adm3_header_t* adm3, STREAMFILE* sf, uint32_t offset) {
+static int parse_type(adm_header_t* adm, STREAMFILE* sf, uint32_t offset) {
 
-    if (is_id32be(offset, sf, "RMP1")) {
+    /* ADM2 chunks */
+    if (is_id32be(offset, sf, "GRN1")) {
+        /* 0x74: offset to floats? */
+        offset = read_u32le(offset + 0x78, sf); /* to SMP1 */
+        if (!parse_type(adm, sf, offset))
+            goto fail;
+    }
+    else if (is_id32be(offset, sf, "SMP1")) {
+        adm->total_subsongs++;
+
+        if (adm->target_subsong == adm->total_subsongs) {
+            /* 0x04 always 0 */
+            /* 0x08 version? (0x00030000) */
+            adm->channels = read_u16le(offset + 0x0c, sf);
+            /* 0x0e 0x0001? */
+            /* 0x10 header size (0x2c) */
+            adm->sample_rate = read_s32le(offset + 0x14, sf);
+            adm->num_samples = read_s32le(offset + 0x18, sf);
+            adm->stream_size = read_u32le(offset + 0x1c, sf);
+            adm->stream_offset = read_u32le(offset + 0x20, sf);
+            /* rest: null */
+            VGM_LOG("so=%x %x\n", adm->stream_size, adm->stream_offset);
+        }
+    }
+
+    /* ADM3 chunks */
+    else if (is_id32be(offset, sf, "RMP1")) {
         offset = read_u32le(offset + 0x1c, sf);
-        if (!parse_type(adm3, sf, offset))
+        if (!parse_type(adm, sf, offset))
             goto fail;
         /* 0x24: offset to GRN1 */
     }
@@ -87,30 +133,30 @@ static int parse_type(adm3_header_t* adm3, STREAMFILE* sf, uint32_t offset) {
             if (smp2_unk != 1)
                 goto fail;
 
-            if (!parse_type(adm3, sf, smp2_offset)) /* SMP2 */
+            if (!parse_type(adm, sf, smp2_offset)) /* SMP2 */
                 goto fail;
         }
     }
     else if (is_id32be(offset, sf, "SMP2")) {
-        adm3->total_subsongs++;
+        adm->total_subsongs++;
 
-        if (adm3->target_subsong == adm3->total_subsongs) {
+        if (adm->target_subsong == adm->total_subsongs) {
             /* 0x04 always 0 */
-            /* 0x08 always 0x00040000 */
+            /* 0x08 version? (0x00040000) */
-            adm3->channels = read_u32le(offset + 0x0c, sf);
+            adm->channels = read_u32le(offset + 0x0c, sf); /* usually 4, with different sounds*/
             /* 0x10 float pitch? */
             /* 0x14 int pitch? */
             /* 0x18 0x0001? */
-            /* 0x1a 0x0030? (header size?) */
+            /* 0x1a header size (0x30) */
-            adm3->sample_rate = read_s32le(offset + 0x1c, sf);
+            adm->sample_rate = read_s32le(offset + 0x1c, sf);
-            adm3->num_samples = read_s32le(offset + 0x20, sf);
+            adm->num_samples = read_s32le(offset + 0x20, sf);
-            adm3->stream_size = read_u32le(offset + 0x24, sf);
+            adm->stream_size = read_u32le(offset + 0x24, sf);
             /* 0x28 1? */
-            adm3->stream_offset = read_u32le(offset + 0x2c, sf);
+            adm->stream_offset = read_u32le(offset + 0x2c, sf);
         }
     }
     else {
-        VGM_LOG("ADM3: unknown at %x\n", offset);
+        VGM_LOG("ADM: unknown at %x\n", offset);
         goto fail;
     }
 
@@ -119,31 +165,52 @@ fail:
     return 0;
 }
 
-static int parse_adm3(adm3_header_t* adm3, STREAMFILE* sf) {
+static int parse_adm(adm_header_t* adm, STREAMFILE* sf) {
     uint32_t offset;
 
     /* 0x04: null */
-    /* 0x08: version? */
+    /* 0x08: version? (ADM2: 0x00050000, ADM3: 0x00060000) */
     /* 0x0c: header size */
     /* 0x10: data start */
-    /* rest unknown, looks mostly the same between files */
+    /* rest unknown, looks mostly the same between files (some floats and stuff) */
 
-    /* higher ramp, N samples from low to high */
+    switch(adm->version) {
-    offset = read_u32le(0x0FC, sf);
+        case 2:
-    if (!parse_type(adm3, sf, offset)) goto fail; /* RMP1 */
+            /* low to high */
-    if (read_u32le(0x100, sf) != 1) goto fail;
+            offset = read_u32le(0x104, sf);
+            if (!parse_type(adm, sf, offset)) goto fail; /* GRN1 */
 
-    /* lower ramp, also N samples */
+            /* high to low */
-    offset = read_u32le(0x104, sf);
+            offset = read_u32le(0x108, sf);
-    if (!parse_type(adm3, sf, offset)) goto fail; /* RMP1 */
+            if (!parse_type(adm, sf, offset)) goto fail; /* GRN1 */
-    if (read_u32le(0x108, sf) != 1) goto fail;
 
-    /* idle engine */
+            /* idle engine */
-    offset = read_u32le(0x10c, sf);
+            offset = read_u32le(0x10c, sf);
-    if (!parse_type(adm3, sf, offset)) goto fail; /* SMP2 */
+            if (!parse_type(adm, sf, offset)) goto fail; /* SMP1 */
-    if (read_u32le(0x110, sf) != 1) goto fail;
+            break;
 
-    if (adm3->target_subsong < 0 || adm3->target_subsong > adm3->total_subsongs || adm3->total_subsongs < 1)
+        case 3:
+            /* higher ramp, N samples from low to high */
+            offset = read_u32le(0x0FC, sf);
+            if (!parse_type(adm, sf, offset)) goto fail; /* RMP1 */
+            if (read_u32le(0x100, sf) != 1) goto fail;
+
+            /* lower ramp, also N samples */
+            offset = read_u32le(0x104, sf);
+            if (!parse_type(adm, sf, offset)) goto fail; /* RMP1 */
+            if (read_u32le(0x108, sf) != 1) goto fail;
+
+            /* idle engine */
+            offset = read_u32le(0x10c, sf);
+            if (!parse_type(adm, sf, offset)) goto fail; /* SMP2 */
+            if (read_u32le(0x110, sf) != 1) goto fail;
+            break;
+
+        default:
+            goto fail;
+    }
+
+    if (adm->target_subsong < 0 || adm->target_subsong > adm->total_subsongs || adm->total_subsongs < 1)
         goto fail;
 
     return 1;

src/meta/meta.h

@@ -953,6 +953,7 @@ VGMSTREAM* init_vgmstream_s3v(STREAMFILE* sf);
 
 VGMSTREAM* init_vgmstream_esf(STREAMFILE* sf);
 
+VGMSTREAM* init_vgmstream_adm2(STREAMFILE* sf);
 VGMSTREAM* init_vgmstream_adm3(STREAMFILE* sf);
 
 VGMSTREAM* init_vgmstream_tt_ad(STREAMFILE* sf);

src/vgmstream.c

@@ -522,6 +522,7 @@ init_vgmstream_t init_vgmstream_functions[] = {
     init_vgmstream_squeakstream,
     init_vgmstream_squeaksample,
     init_vgmstream_snds,
+    init_vgmstream_adm2,
 
     /* lower priority metas (no clean header identity, somewhat ambiguous, or need extension/companion file to identify) */
     init_vgmstream_scd_pcm,

src/vgmstream_types.h

@@ -691,7 +691,7 @@ typedef enum {
     meta_SSPF,
     meta_S3V,
     meta_ESF,
-    meta_ADM3,
+    meta_ADM,
     meta_TT_AD,
     meta_SNDZ,
     meta_VAB,