Add .smk Smacker video [Starcraft (PC)]

src/formats.c

@@ -398,6 +398,7 @@ static const char* extension_list[] = {
     "slb", //txth/reserved [THE Nekomura no Hitobito (PS2)]
     "sli",
     "smc",
+    "smk",
     "smp",
     "smpl", //fake extension/header id for .v0/v1 (renamed, to be removed)
     "smv",
@@ -1198,7 +1199,8 @@ static const meta_info meta_info_list[] = {
         {meta_XWMA_KONAMI,          "Konami XWMA header"},
         {meta_9TAV,                 "Konami 9TAV header"},
         {meta_BWAV,                 "Nintendo BWAV header"},
-        {meta_RAD,                  "Traveller's Tales RAD header"},
+        {meta_RAD,                  "Traveller's Tales .RAD header"},
+        {meta_SMACKER,              "RAD Game Tools SMACKER header"},
 
 };
 

src/libvgmstream.vcproj

@@ -1474,6 +1474,10 @@
                     RelativePath=".\meta\smc_smh.c"
                     >
                 </File>
+                <File
+                    RelativePath=".\meta\smk.c"
+                    >
+                </File>
                 <File
                     RelativePath=".\meta\smp.c"
                     >

src/libvgmstream.vcxproj

@@ -457,6 +457,7 @@
     <ClCompile Include="meta\sfl.c" />
     <ClCompile Include="meta\sli.c" />
     <ClCompile Include="meta\smc_smh.c" />
+    <ClCompile Include="meta\smk.c" />
     <ClCompile Include="meta\smp.c" />
     <ClCompile Include="meta\smv.c" />
     <ClCompile Include="meta\sps_n1.c" />

src/libvgmstream.vcxproj.filters

@@ -913,6 +913,9 @@
     <ClCompile Include="meta\smc_smh.c">
       <Filter>meta\Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="meta\smk.c">
+      <Filter>meta\Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="meta\smp.c">
       <Filter>meta\Source Files</Filter>
     </ClCompile>

src/meta/meta.h

@@ -867,4 +867,6 @@ void load_acb_wave_name(STREAMFILE *acbFile, VGMSTREAM* vgmstream, int waveid, i
 
 VGMSTREAM * init_vgmstream_rad(STREAMFILE * streamFile);
 
+VGMSTREAM * init_vgmstream_smk(STREAMFILE * streamFile);
+
 #endif /*_META_H*/

src/meta/smk.c

@@ -0,0 +1,187 @@
+#include "meta.h"
+#include "../coding/coding.h"
+#include "../util.h"
+
+static int smacker_get_info(STREAMFILE *streamFile, int target_subsong, int * out_total_streams, size_t *out_stream_size, int * out_channel_count, int * out_sample_rate, int * out_num_samples);
+
+/* SMK - RAD Game Tools Smacker movies (audio/video format) */
+VGMSTREAM * init_vgmstream_smk(STREAMFILE *streamFile) {
+    VGMSTREAM * vgmstream = NULL;
+    int channel_count = 0, loop_flag = 0, sample_rate = 0, num_samples = 0;
+    int total_subsongs = 0, target_subsong = streamFile->stream_index;
+    size_t stream_size;
+
+
+    /* checks */
+    if (!check_extensions(streamFile,"smk"))
+        goto fail;
+
+    if (read_32bitBE(0x00,streamFile) != 0x534D4B32 &&  /* "SMK2" */
+        read_32bitBE(0x00,streamFile) != 0x534D4B34)    /* "SMK4" */
+        goto fail;
+
+    /* find target stream info */
+    if (!smacker_get_info(streamFile, target_subsong, &total_subsongs, &stream_size, &channel_count, &sample_rate, &num_samples))
+        goto fail;
+
+
+    /* build the VGMSTREAM */
+    vgmstream = allocate_vgmstream(channel_count, loop_flag);
+    if (!vgmstream) goto fail;
+
+    vgmstream->layout_type = layout_none;
+    vgmstream->sample_rate = sample_rate;
+    vgmstream->num_samples = num_samples;
+    vgmstream->num_streams = total_subsongs;
+    vgmstream->stream_size = stream_size;
+    vgmstream->meta_type = meta_SMACKER;
+
+    {
+#ifdef VGM_USE_FFMPEG
+        /* target_subsong should be passed manually */
+        vgmstream->codec_data = init_ffmpeg_header_offset_subsong(streamFile, NULL,0, 0x0,get_streamfile_size(streamFile), target_subsong);
+        if (!vgmstream->codec_data) goto fail;
+        vgmstream->coding_type = coding_FFmpeg;
+#else
+        goto fail;
+#endif
+    }
+
+    return vgmstream;
+
+fail:
+    close_vgmstream(vgmstream);
+    return NULL;
+}
+
+typedef enum {
+    SMK_AUDIO_PACKED    = (1<<7),
+    SMK_AUDIO_PRESENT   = (1<<6),
+    SMK_AUDIO_16BITS    = (1<<5),
+    SMK_AUDIO_STEREO    = (1<<4),
+    SMK_AUDIO_BINK_RDFT = (1<<3),
+    SMK_AUDIO_BINK_DCT  = (1<<2),
+  //SMK_AUD_UNUSED1     = (1<<1),
+  //SMK_AUD_UNUSED0     = (1<<0),
+} smk_audio_flag;
+
+//todo test multilang streams and codecs other than SMACKAUD
+/* Gets stream info, and number of samples in a file by reading frames
+ * info: https://wiki.multimedia.cx/index.php/Smacker */
+static int smacker_get_info(STREAMFILE *sf, int target_subsong, int * out_total_subsongs, size_t * out_stream_size, int * out_channel_count, int * out_sample_rate, int * out_num_samples) {
+    STREAMFILE *sf_index = NULL;
+    uint32_t flags, total_frames, trees_sizes;
+    off_t size_offset, type_offset, data_offset;
+    int i, j, sample_rate = 0, channel_count = 0, num_samples = 0;
+    int total_subsongs, target_stream = 0;
+    size_t stream_size = 0;
+    uint8_t stream_flags = 0;
+    
+    
+    /* rough format:
+     * - header (id, frames, video info/config, audio info)
+     * - frame sizes table
+     * - frame info table
+     * - huffman trees
+     * - frame data
+     */
+
+    /* read header */
+    total_frames = read_u32le(0x0c,sf);
+    if (total_frames <= 0 || total_frames > 0x100000) goto fail; /* something must be off */
+
+    flags = read_u32le(0x14,sf);
+    if (flags & 1) /* extra "ring frame" */
+        total_frames += 1;
+
+    trees_sizes = read_u32le(0x34,sf);
+
+    if (target_subsong == 0) target_subsong = 1;
+    total_subsongs = 0;
+    for (i = 0; i < 7; i++) { /* up to 7 audio (multilang?) streams */
+        uint32_t audio_info = read_u32le(0x48 + 0x04*i,sf);
+        uint8_t audio_flags = (audio_info >> 24) & 0xFF;
+        int audio_rate = audio_info & 0x00FFFFFF;
+
+        if (audio_flags & SMK_AUDIO_PRESENT) {
+            total_subsongs++;
+            
+            if (target_subsong == total_subsongs) {
+                target_stream = i;
+                sample_rate = audio_rate & 0x00FFFFFF;
+                channel_count = (audio_flags & SMK_AUDIO_STEREO) ? 2 : 1;
+                stream_flags = audio_flags;
+            }
+        }
+    }
+    if (target_subsong < 0 || target_subsong > total_subsongs || total_subsongs < 1) goto fail;
+    if (sample_rate == 0 || channel_count == 0) goto fail;
+
+    /* read size and type tables into buffer */
+    sf_index = reopen_streamfile(sf, total_frames*0x04 + total_frames*0x01);
+    if (!sf_index) goto fail;
+
+    /* read frames and sum all samples, since some codecs are VBR */
+    size_offset = 0x68;
+    type_offset = size_offset + total_frames*0x04;
+    data_offset = type_offset + total_frames*0x01 + trees_sizes;
+    for (i=0; i < total_frames; i++) {
+        uint32_t frame_size = read_u32le(size_offset,sf_index) & 0xFFFFFFFC; /* last 2 bits are keyframe flags */
+        uint8_t  frame_type = read_u8   (type_offset,sf_index); /* 0: has palette, 1..7: has stream N) */
+        off_t offset = data_offset;
+        
+        /* skip palette */
+        if (frame_type & (1<<0)) {
+            uint8_t palette_size = read_u8(offset,sf);
+            offset += palette_size * 4;
+        }
+
+        /* read target audio packet and ignore rest (though probably all streams are the same) */
+        for (j = 0; j < 7; j++) {
+            uint32_t audio_size;
+            
+            /* check if stream N exists in this frame (supposedly streams can be go in separate frames) */
+            if ( !(frame_type & (1<<(j+1))) )
+                continue;
+
+            audio_size = read_u32le(offset,sf);
+            
+            if (j == target_stream) {
+                
+                /* resulting PCM bytes to samples */
+                if (stream_flags & SMK_AUDIO_PACKED) { /* Smacker and maybe Bink codecs */
+                    uint32_t unpacked_size = read_u32le(offset+0x04,sf);
+                    num_samples += unpacked_size / (0x02 * channel_count);
+                }
+                else if (stream_flags & SMK_AUDIO_16BITS) { /* PCM16 */
+                    num_samples += (audio_size - 0x04) / (0x02 * channel_count);
+                }
+                else { /* PCM8 */
+                    num_samples += (audio_size - 0x04) / (0x01 * channel_count);
+                }
+            }
+
+            stream_size += audio_size;
+            offset += audio_size;
+        }
+        
+        /* rest is video packet (size = offset - data_offset) */
+
+        size_offset += 0x04;
+        type_offset += 0x01;
+        data_offset += frame_size;
+    }
+
+    if (out_total_subsongs) *out_total_subsongs = total_subsongs;
+    if (out_stream_size)    *out_stream_size = stream_size;
+    if (out_sample_rate)    *out_sample_rate = sample_rate;
+    if (out_channel_count)  *out_channel_count = channel_count;
+    if (out_num_samples)    *out_num_samples = num_samples;
+
+    close_streamfile(sf_index);
+    return 1;
+
+fail:
+    close_streamfile(sf_index);
+    return 0;
+}

src/vgmstream.c

@@ -485,6 +485,7 @@ VGMSTREAM * (*init_vgmstream_functions[])(STREAMFILE *streamFile) = {
     init_vgmstream_awb,
     init_vgmstream_acb,
     init_vgmstream_rad,
+    init_vgmstream_smk,
 
     /* lowest priority metas (should go after all metas, and TXTH should go before raw formats) */
     init_vgmstream_txth,            /* proper parsers should supersede TXTH, once added */

src/vgmstream.h

@@ -732,6 +732,7 @@ typedef enum {
     meta_9TAV,
     meta_BWAV,
     meta_RAD,
+    meta_SMACKER,
 
 } meta_t;