demux: merge sh_video/sh_audio/sh_sub

This is mainly a refactor. I'm hoping it will make some things easier
in the future due to cleanly separating codec metadata and stream
metadata.

Also, declare that the "codec" field can not be NULL anymore. demux.c
will set it to "" if it's NULL when added. This gets rid of a corner
case everything had to handle, but which rarely happened.

1 files changed, 45 insertions, 45 deletions

diff --git a/demux/demux_mkv.c b/demux/demux_mkv.c
index 3951452074..024f7e7e6e 100644
--- a/demux/demux_mkv.c
+++ b/demux/demux_mkv.c
@@ -1201,7 +1201,7 @@ static void add_coverart(struct demuxer *demuxer)
             continue;
         struct sh_stream *sh = demux_alloc_sh_stream(STREAM_VIDEO);
         sh->demuxer_id = -1 - sh->index; // don't clash with mkv IDs
-        sh->codec = codec;
+        sh->codec->codec = codec;
         sh->attached_picture = new_demux_packet_from(att->data, att->data_size);
         if (sh->attached_picture) {
             sh->attached_picture->pts = 0;
@@ -1273,7 +1273,7 @@ static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track)
     unsigned int extradata_size = 0;
     struct sh_stream *sh = demux_alloc_sh_stream(STREAM_VIDEO);
     init_track(demuxer, track, sh);
-    sh_video_t *sh_v = sh->video;
+    struct mp_codec_params *sh_v = sh->codec;
 
     sh_v->bits_per_coded_sample = 24;
 
@@ -1288,11 +1288,11 @@ static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track)
         if (track->v_height == 0)
             track->v_height = AV_RL32(h + 8);       // biHeight
         sh_v->bits_per_coded_sample = AV_RL16(h + 14); // biBitCount
-        sh->codec_tag = AV_RL32(h + 16);            // biCompression
+        sh_v->codec_tag = AV_RL32(h + 16);            // biCompression
 
         extradata = track->private_data + 40;
         extradata_size = track->private_size - 40;
-        mp_set_codec_from_tag(sh);
+        mp_set_codec_from_tag(sh_v);
         sh_v->avi_dts = true;
     } else if (track->private_size >= RVPROPERTIES_SIZE
                && (!strcmp(track->codec_id, "V_REAL/RV10")
@@ -1308,10 +1308,10 @@ static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track)
         cnt = track->private_size - RVPROPERTIES_SIZE;
         uint32_t t2 = AV_RB32(src - 4);
         switch (t2 == 0x10003000 || t2 == 0x10003001 ? '1' : track->codec_id[9]) {
-        case '1': sh->codec = "rv10"; break;
-        case '2': sh->codec = "rv20"; break;
-        case '3': sh->codec = "rv30"; break;
-        case '4': sh->codec = "rv40"; break;
+        case '1': sh_v->codec = "rv10"; break;
+        case '2': sh_v->codec = "rv20"; break;
+        case '3': sh_v->codec = "rv30"; break;
+        case '4': sh_v->codec = "rv40"; break;
         }
         // copy type1 and type2 info from rv properties
         extradata_size = cnt + 8;
@@ -1320,8 +1320,8 @@ static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track)
         track->parse_timebase = 1e3;
     } else if (strcmp(track->codec_id, "V_UNCOMPRESSED") == 0) {
         // raw video, "like AVI" - this is a FourCC
-        sh->codec_tag = track->colorspace;
-        sh->codec = "rawvideo";
+        sh_v->codec_tag = track->colorspace;
+        sh_v->codec = "rawvideo";
     } else if (strcmp(track->codec_id, "V_QUICKTIME") == 0) {
         uint32_t fourcc1 = 0, fourcc2 = 0;
         if (track->private_size >= 8) {
@@ -1331,14 +1331,14 @@ static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track)
         if (fourcc1 == MP_FOURCC('S', 'V', 'Q', '3') ||
             fourcc2 == MP_FOURCC('S', 'V', 'Q', '3'))
         {
-            sh->codec = "svq3";
+            sh_v->codec = "svq3";
             extradata = track->private_data;
             extradata_size = track->private_size;
         }
     } else {
         for (int i = 0; mkv_video_tags[i][0]; i++) {
             if (!strcmp(mkv_video_tags[i][0], track->codec_id)) {
-                sh->codec = mkv_video_tags[i][1];
+                sh_v->codec = mkv_video_tags[i][1];
                 break;
             }
         }
@@ -1348,12 +1348,12 @@ static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track)
         }
     }
 
-    const char *codec = sh->codec ? sh->codec : "";
+    const char *codec = sh_v->codec ? sh_v->codec : "";
     if (!strcmp(codec, "vp9")) {
         track->parse = true;
         track->parse_timebase = 1e9;
     } else if (!strcmp(codec, "mjpeg")) {
-        sh->codec_tag = MP_FOURCC('m', 'j', 'p', 'g');
+        sh_v->codec_tag = MP_FOURCC('m', 'j', 'p', 'g');
     }
 
     if (extradata_size > 0x1000000) {
@@ -1361,9 +1361,9 @@ static int demux_mkv_open_video(demuxer_t *demuxer, mkv_track_t *track)
         goto done;
     }
 
-    sh->extradata = talloc_memdup(sh_v, extradata, extradata_size);
-    sh->extradata_size = extradata_size;
-    if (!sh->codec) {
+    sh_v->extradata = talloc_memdup(sh_v, extradata, extradata_size);
+    sh_v->extradata_size = extradata_size;
+    if (!sh_v->codec) {
         MP_WARN(demuxer, "Unknown/unsupported CodecID (%s) or missing/bad "
                 "CodecPrivate data (track %u).\n",
                 track->codec_id, track->tnum);
@@ -1477,7 +1477,7 @@ static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track)
 {
     struct sh_stream *sh = demux_alloc_sh_stream(STREAM_AUDIO);
     init_track(demuxer, track, sh);
-    sh_audio_t *sh_a = sh->audio;
+    struct mp_codec_params *sh_a = sh->codec;
 
     if (track->private_size > 0x1000000)
         goto error;
@@ -1492,7 +1492,7 @@ static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track)
 
     for (int i = 0; mkv_audio_tags[i][0]; i++) {
         if (!strcmp(mkv_audio_tags[i][0], track->codec_id)) {
-            sh->codec = mkv_audio_tags[i][1];
+            sh_a->codec = mkv_audio_tags[i][1];
             break;
         }
     }
@@ -1503,7 +1503,7 @@ static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track)
             goto error;
         MP_VERBOSE(demuxer, "track with MS compat audio.\n");
         unsigned char *h = track->private_data;
-        sh->codec_tag = AV_RL16(h + 0);         // wFormatTag
+        sh_a->codec_tag = AV_RL16(h + 0);         // wFormatTag
         if (track->a_channels == 0)
             track->a_channels = AV_RL16(h + 2); // nChannels
         if (sh_a->samplerate == 0)
@@ -1515,15 +1515,15 @@ static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track)
         extradata = track->private_data + 18;
         extradata_len = track->private_size - 18;
         sh_a->bits_per_coded_sample = track->a_bps;
-        mp_set_codec_from_tag(sh);
+        mp_set_codec_from_tag(sh_a);
     } else if (!strcmp(track->codec_id, "A_PCM/INT/LIT")) {
         bool sign = sh_a->bits_per_coded_sample > 8;
-        mp_set_pcm_codec(sh, sign, false, sh_a->bits_per_coded_sample, false);
+        mp_set_pcm_codec(sh_a, sign, false, sh_a->bits_per_coded_sample, false);
     } else if (!strcmp(track->codec_id, "A_PCM/INT/BIG")) {
         bool sign = sh_a->bits_per_coded_sample > 8;
-        mp_set_pcm_codec(sh, sign, false, sh_a->bits_per_coded_sample, true);
+        mp_set_pcm_codec(sh_a, sign, false, sh_a->bits_per_coded_sample, true);
     } else if (!strcmp(track->codec_id, "A_PCM/FLOAT/IEEE")) {
-        sh->codec = sh_a->bits_per_coded_sample == 64 ? "pcm_f64le" : "pcm_f32le";
+        sh_a->codec = sh_a->bits_per_coded_sample == 64 ? "pcm_f64le" : "pcm_f32le";
     } else if (!strncmp(track->codec_id, "A_REAL/", 7)) {
         if (track->private_size < RAPROPERTIES4_SIZE)
             goto error;
@@ -1563,29 +1563,29 @@ static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track)
         extradata = src + offset;
 
         if (!strcmp(track->codec_id, "A_REAL/ATRC")) {
-            sh->codec = "atrac3";
+            sh_a->codec = "atrac3";
             if (flavor >= MP_ARRAY_SIZE(atrc_fl2bps))
                 goto error;
             sh_a->bitrate = atrc_fl2bps[flavor] * 8;
             sh_a->block_align = track->sub_packet_size;
         } else if (!strcmp(track->codec_id, "A_REAL/COOK")) {
-            sh->codec = "cook";
+            sh_a->codec = "cook";
             if (flavor >= MP_ARRAY_SIZE(cook_fl2bps))
                 goto error;
             sh_a->bitrate = cook_fl2bps[flavor] * 8;
             sh_a->block_align = track->sub_packet_size;
         } else if (!strcmp(track->codec_id, "A_REAL/SIPR")) {
-            sh->codec = "sipr";
+            sh_a->codec = "sipr";
             if (flavor >= MP_ARRAY_SIZE(sipr_fl2bps))
                 goto error;
             sh_a->bitrate = sipr_fl2bps[flavor] * 8;
             sh_a->block_align = track->coded_framesize;
         } else if (!strcmp(track->codec_id, "A_REAL/28_8")) {
-            sh->codec = "ra_288";
+            sh_a->codec = "ra_288";
             sh_a->bitrate = 3600 * 8;
             sh_a->block_align = track->coded_framesize;
         } else if (!strcmp(track->codec_id, "A_REAL/DNET")) {
-            sh->codec = "ac3";
+            sh_a->codec = "ac3";
         } else {
             goto error;
         }
@@ -1595,7 +1595,7 @@ static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track)
         track->audio_timestamp =
             talloc_array(track, double, track->sub_packet_h);
     } else if (!strncmp(track->codec_id, "A_AAC/", 6)) {
-        sh->codec = "aac";
+        sh_a->codec = "aac";
 
         /* Recreate the 'private data' (not needed for plain A_AAC) */
         int srate_idx = aac_get_sample_rate_index(track->a_sfreq);
@@ -1627,17 +1627,17 @@ static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track)
             track->default_duration = 1024.0 / sh_a->samplerate;
         }
     } else if (!strncmp(track->codec_id, "A_AC3/", 6)) {
-        sh->codec = "ac3";
+        sh_a->codec = "ac3";
     } else if (!strncmp(track->codec_id, "A_EAC3/", 7)) {
-        sh->codec = "eac3";
+        sh_a->codec = "eac3";
     }
 
-    if (!sh->codec)
+    if (!sh_a->codec)
         goto error;
 
     mp_chmap_set_unknown(&sh_a->channels, track->a_channels);
 
-    const char *codec = sh->codec;
+    const char *codec = sh_a->codec;
     if (!strcmp(codec, "mp3") || !strcmp(codec, "truehd")) {
         track->parse = true;
     } else if (!strcmp(codec, "flac")) {
@@ -1681,8 +1681,8 @@ static int demux_mkv_open_audio(demuxer_t *demuxer, mkv_track_t *track)
     if (sh_a->samplerate == 8000 && strcmp(codec, "ac3") == 0)
         track->default_duration = 0;
 
-    sh->extradata = extradata;
-    sh->extradata_size = extradata_len;
+    sh_a->extradata = extradata;
+    sh_a->extradata_size = extradata_len;
 
     demux_add_sh_stream(demuxer, sh);
 
@@ -1727,7 +1727,7 @@ static int demux_mkv_open_sub(demuxer_t *demuxer, mkv_track_t *track)
     struct sh_stream *sh = demux_alloc_sh_stream(STREAM_SUB);
     init_track(demuxer, track, sh);
 
-    sh->codec = subtitle_type;
+    sh->codec->codec = subtitle_type;
     bstr in = (bstr){track->private_data, track->private_size};
     bstr buffer = demux_mkv_decode(demuxer->log, track, in, 2);
     if (buffer.start && buffer.start != track->private_data) {
@@ -1736,8 +1736,8 @@ static int demux_mkv_open_sub(demuxer_t *demuxer, mkv_track_t *track)
         track->private_data = buffer.start;
         track->private_size = buffer.len;
     }
-    sh->extradata = track->private_data;
-    sh->extradata_size = track->private_size;
+    sh->codec->extradata = track->private_data;
+    sh->codec->extradata_size = track->private_size;
 
     demux_add_sh_stream(demuxer, sh);
 
@@ -2027,7 +2027,7 @@ static bool handle_realaudio(demuxer_t *demuxer, mkv_track_t *track,
     if (!track->audio_buf || !track->audio_timestamp || !track->stream)
         return false;
 
-    const char *codec = track->stream->codec ? track->stream->codec : "";
+    const char *codec = track->stream->codec->codec ? track->stream->codec->codec : "";
     if (!strcmp(codec, "ra_288")) {
         for (int x = 0; x < sph / 2; x++) {
             uint64_t dst_offset = x * 2 * w + spc * (uint64_t)cfs;
@@ -2087,7 +2087,7 @@ static bool handle_realaudio(demuxer_t *demuxer, mkv_track_t *track,
     if (++(track->sub_packet_cnt) == sph) {
         track->sub_packet_cnt = 0;
         // apk_usize has same range as coded_framesize in worst case
-        uint32_t apk_usize = track->stream->audio->block_align;
+        uint32_t apk_usize = track->stream->codec->block_align;
         if (apk_usize > audiobuf_size)
             goto error;
         // Release all the audio packets
@@ -2222,7 +2222,7 @@ static void mkv_parse_and_add_packet(demuxer_t *demuxer, mkv_track_t *track,
     if (stream->type == STREAM_AUDIO && handle_realaudio(demuxer, track, dp))
         return;
 
-    if (stream->codec && strcmp(stream->codec, "wavpack") == 0) {
+    if (strcmp(stream->codec->codec, "wavpack") == 0) {
         int size = dp->len;
         uint8_t *parsed;
         if (libav_parse_wavpack(track, dp->buffer, &parsed, &size) >= 0) {
@@ -2236,7 +2236,7 @@ static void mkv_parse_and_add_packet(demuxer_t *demuxer, mkv_track_t *track,
         }
     }
 
-    if (stream->codec && strcmp(stream->codec, "prores") == 0) {
+    if (strcmp(stream->codec->codec, "prores") == 0) {
         size_t newlen = dp->len + 8;
         struct demux_packet *new = new_demux_packet(newlen);
         if (new) {
@@ -2251,7 +2251,7 @@ static void mkv_parse_and_add_packet(demuxer_t *demuxer, mkv_track_t *track,
     }
 
     if (track->parse && !track->av_parser) {
-        int id = mp_codec_to_av_codec_id(track->stream->codec);
+        int id = mp_codec_to_av_codec_id(track->stream->codec->codec);
         const AVCodec *codec = avcodec_find_decoder(id);
         track->av_parser = av_parser_init(id);
         if (codec)
@@ -2447,7 +2447,7 @@ static int handle_block(demuxer_t *demuxer, struct block_info *block_info)
              * packets resulting from parsing. */
             if (i == 0 || track->default_duration)
                 dp->pts = mkv_d->last_pts + i * track->default_duration;
-            if (stream->video && stream->video->avi_dts)
+            if (stream->codec->avi_dts)
                 MPSWAP(double, dp->pts, dp->dts);
             if (i == 0)
                 dp->duration = block_duration / 1e9;