Ticket #2439: 2439-v1.patch

libs/libmythtv/avformatdecoder.h

@@ -185 +185 @@
     void SeekReset(long long, uint skipFrames, bool doFlush, bool discardFrames);
 
     bool SetupAudioStream(void);
+    bool SetupAudioStreamSubIndexes(bool wasDual, bool isDual);
 
     /// Update our position map, keyframe distance, and the like.
     /// Called for key frame packets.

libs/libmythtv/avformatdecoder.cpp

@@ -1488 +1488 @@
                 lang_indx = lang_aud_cnt[lang];
                 lang_aud_cnt[lang]++;
             }
-            tracks[kTrackTypeAudio].push_back(
-                StreamInfo(i, lang, lang_indx, ic->streams[i]->id));
 
+            if (ic->streams[i]->codec->avcodec_dual_language)
+            {
+                tracks[kTrackTypeAudio].push_back(
+                    StreamInfo(i, lang, lang_indx, ic->streams[i]->id, 0));
+                tracks[kTrackTypeAudio].push_back(
+                    StreamInfo(i, lang, lang_indx, ic->streams[i]->id, 1));
+            }
+            else
+            {
+                tracks[kTrackTypeAudio].push_back(
+                    StreamInfo(i, lang, lang_indx, ic->streams[i]->id));
+            }
+
             VERBOSE(VB_AUDIO, LOC + QString(
                         "Audio Track #%1 is A/V stream #%2 "
                         "and has %3 channels in the %4 language(%5).")
@@ -1555 +1566 @@
     return scanerror;
 }
 
+/** \fn AvFormatDecoder::SetupAudioStreamSubIndexes(bool, bool)
+ *  \brief Reacts to DUAL/STEREO changes on the fly and fix streams.
+ *
+ *  This function kicks in when a switch between dual and stereo
+ *  mpeg audio is detected. Such changes can and will happen at
+ *  any time.
+ *
+ *  It can only be used in the case where the mpeg file contains
+ *  exactly one audio stream that switches automatically between
+ *  stereo (1 language) and dual (2 unspecified languages) audio.
+ *
+ *  If this method returns true, the stream list has changed and
+ *  a new audio stream needs to be selected, usually using
+ *  AvFormatDecoder::autoSelectSubtitleTrack()
+ *
+ *  \param wasDual true if the stream used to contain dual audio
+ *  \param isDual true if the stream currently contains dual audio
+ *  \return true if a change was made
+ */
+bool AvFormatDecoder::SetupAudioStreamSubIndexes(bool wasDual, bool isDual)
+{
+    if (wasDual == isDual)
+    {
+        // No changes
+        return false;
+    }
+
+    QMutexLocker locker(&avcodeclock);
+    int numStreams = tracks[kTrackTypeAudio].size();
+    if (isDual)
+    {
+        if (numStreams != 1)
+            return false;
+
+        // Split stream in two (Language I + Language II)
+        tracks[kTrackTypeAudio].push_back(tracks[kTrackTypeAudio][0]);
+        tracks[kTrackTypeAudio][0].av_substream_index = 0;
+        tracks[kTrackTypeAudio][1].av_substream_index = 1;
+    }
+    else
+    {
+        if (numStreams != 2)
+            return false;
+
+        // Remove extra stream
+        tracks[kTrackTypeAudio][0].av_substream_index = -1;
+        tracks[kTrackTypeAudio].pop_back();
+    }
+
+    // Changed
+    return true;
+}
+
 int get_avf_buffer(struct AVCodecContext *c, AVFrame *pic)
 {
     AvFormatDecoder *nd = (AvFormatDecoder *)(c->opaque);
@@ -2368 +2432 @@
  *   preference:
  *
  *   1) The stream last selected by the user, which is
- *      recalled as the Nth stream in the preferred language.
+ *      recalled as the Nth stream in the preferred language
+ *      or the Nth substream when audio is in dual language
+ *      format (each channel contains a different language track)
  *      If it can not be located we attempt to find a stream
  *      in the same language.
  *
@@ -2435 +2501 @@
     int selTrack = (1 == numStreams) ? 0 : -1;
     int wlang    = wtrack.language;
 
+
+    if (selTrack < 0 && wtrack.av_substream_index >= 0)
+    {
+        VERBOSE(VB_AUDIO, LOC + "Trying to reselect audio sub-stream");
+        // Dual stream without language information: choose
+        // the previous (sub)stream that was kept in wtrack.
+        int substream_index = wtrack.av_substream_index;
+
+        for (uint i = 0; i < numStreams; i++)
+        {
+            if (atracks[i].av_substream_index == substream_index)
+            {
+                selTrack = i;
+                break;
+            }
+        }
+    }
+
     if ((selTrack < 0) && wlang >= -1 && numStreams)
     {
         VERBOSE(VB_AUDIO, LOC + "Trying to reselect audio track");
@@ -2515 +2599 @@
     return selTrack;
 }
 
+static void filter_audio_data(int channel, AudioInfo *audioInfo,
+                              char *buffer, int bufsize)
+{
+    // Only stereo -> mono (left or right) is supported
+    if (audioInfo->channels != 2)
+        return;
+
+    if (channel != 0 && channel != 1)
+        return;
+
+    const int samplesize = audioInfo->sample_size;
+    const int samples = bufsize / samplesize;
+    const int halfsample = samplesize/2;
+
+    const char *from;
+    char *to;
+
+    if (channel==0)
+    {
+        from = buffer;
+        to = buffer + halfsample;
+    }
+    else
+    {
+        from = buffer + halfsample;
+        to = buffer;
+    }
+
+    for (int sample = 0; sample < samples;
+         (sample++), (from += samplesize), (to += samplesize))
+    {
+        for(int bit = 0; bit < halfsample; bit++)
+            to[bit] = from[bit];
+    }
+}
+
 bool AvFormatDecoder::GetFrame(int onlyvideo)
 {
     AVPacket *pkt = NULL;
@@ -2783 +2903 @@
         avcodeclock.lock();
         int ctype  = curstream->codec->codec_type;
         int audIdx = selectedTrack[kTrackTypeAudio].av_stream_index;
+        int audSubIdx = selectedTrack[kTrackTypeAudio].av_substream_index;
         int subIdx = selectedTrack[kTrackTypeSubtitle].av_stream_index;
         avcodeclock.unlock();
 
@@ -2792 +2913 @@
             {
                 case CODEC_TYPE_AUDIO:
                 {
+                    // detect switches between stereo and dual languages
+                    bool reselectAudioTrack =
+                        SetupAudioStreamSubIndexes(
+                            audSubIdx != -1,
+                            curstream->codec->avcodec_dual_language);
+
                     // detect channels on streams that need
                     // to be decoded before we can know this
                     if (!curstream->codec->channels)
@@ -2801 +2928 @@
                         ret = avcodec_decode_audio(
                             curstream->codec, audioSamples,
                             &data_size, ptr, len);
-                        if (curstream->codec->channels)
-                        {
-                            currentTrack[kTrackTypeAudio] = -1;
-                            selectedTrack[kTrackTypeAudio]
-                                .av_stream_index = -1;
-                            audIdx = -1;
-                            AutoSelectAudioTrack();
-                            audIdx = selectedTrack[kTrackTypeAudio]
-                                .av_stream_index;
-                        }
+
+                        reselectAudioTrack |= curstream->codec->channels;
                     }
 
+                    if (reselectAudioTrack)
+                    {
+                        QMutexLocker locker(&avcodeclock);
+                        currentTrack[kTrackTypeAudio] = -1;
+                        selectedTrack[kTrackTypeAudio]
+                            .av_stream_index = -1;
+                        audIdx = -1;
+                        audSubIdx = -1;
+                        AutoSelectAudioTrack();
+                        audIdx = selectedTrack[kTrackTypeAudio]
+                            .av_stream_index;
+                        audSubIdx = selectedTrack[kTrackTypeAudio]
+                            .av_substream_index;
+                    }
+
                     if (firstloop && pkt->pts != (int64_t)AV_NOPTS_VALUE)
                         lastapts = (long long)(av_q2d(curstream->time_base) *
                                                pkt->pts * 1000);
@@ -2895 +3029 @@
                             .arg(pkt->pts).arg(pkt->dts).arg(temppts)
                                                         .arg(lastapts)); 
 
+                    if (audSubIdx != -1)
+                    {
+                        filter_audio_data(audSubIdx, &audioOut,
+                                          (char *)audioSamples, data_size);
+                    }
+
                     GetNVP()->AddAudioData((char *)audioSamples, data_size,
                                            temppts);
 

libs/libmythtv/decoderbase.h

@@ -17 +17 @@
 class StreamInfo
 {
   public:
-    StreamInfo() : av_stream_index(-1), language(-2), language_index(0),
+    StreamInfo() :
+        av_stream_index(-1), av_substream_index(-1),
+        language(-2), language_index(0),
         stream_id(-1), easy_reader(false), wide_aspect_ratio(false) {}
     StreamInfo(int a, int b, uint c, int d, bool e = false, bool f = false) :
-        av_stream_index(a), language(b), language_index(c), stream_id(d),
+        av_stream_index(a), av_substream_index(-1),
+        language(b), language_index(c), stream_id(d),
         easy_reader(e), wide_aspect_ratio(f) {}
+    StreamInfo(int a, int b, uint c, int d, int e,
+               bool f = false, bool g = false) :
+        av_stream_index(a), av_substream_index(e),
+        language(b), language_index(c), stream_id(d),
+        easy_reader(f), wide_aspect_ratio(g) {}
 
   public:
     int  av_stream_index;
+    // -1 = no substream, 0 for first dual audio stream, 1 for second
+    int  av_substream_index;
     int  language; ///< ISO639 canonical language key
     uint language_index;
     int  stream_id;