Ticket #2439: 2439-v2.patch

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 should be called when a switch between dual and 
+ *  stereo mpeg audio is detected. Such changes can and will happen at
+ *  any time.
+ *
+ *  After this method returns, a new audio stream should be selected
+ *  using AvFormatDecoder::autoSelectSubtitleTrack().
+ *
+ *  \param index av_stream_index of the stream that has changed
+ */
+void AvFormatDecoder::SetupAudioStreamSubIndexes(int streamIndex)
+{
+    QMutexLocker locker(&avcodeclock);
+
+    // Find the position of the streaminfo in tracks[kTrackTypeAudio] 
+    sinfo_vec_t::iterator current = tracks[kTrackTypeAudio].begin();
+    for (; current != tracks[kTrackTypeAudio].end(); ++current) 
+    {
+        if (current->av_stream_index == streamIndex)
+            break;
+    }
+    if (current == tracks[kTrackTypeAudio].end()) {
+        VERBOSE(VB_IMPORTANT, LOC
+                <<"Warning: invalid stream index passed to "
+                <<"SetupAudioStreamSubIndexes: "
+                <<streamIndex);
+        return;
+    }
+
+    // Remove the extra substream or duplicate the current substream
+    sinfo_vec_t::iterator next = current + 1;
+    if (current->av_substream_index == -1) {
+        // Split stream in two (Language I + Language II)
+        StreamInfo lang1 = *current;
+        StreamInfo lang2 = *current;
+        lang1.av_substream_index = 0;
+        lang2.av_substream_index = 1;
+        *current = lang1;
+        tracks[kTrackTypeAudio].insert(next, lang2);
+    }
+    else
+    {
+        if (next == tracks[kTrackTypeAudio].end() ||
+            next->av_stream_index != streamIndex) {
+            VERBOSE(VB_IMPORTANT, LOC
+                    <<"Warning: expected substream 1 (Language I) of stream " 
+                    << streamIndex
+                    << " following substream 0, found end of list or another stream");
+            return;
+        }
+
+        // Remove extra stream info
+        StreamInfo stream = *current;
+        stream.av_substream_index = -1;
+        *current = stream;
+        tracks[kTrackTypeAudio].erase(next);
+    }
+}
+
 int get_avf_buffer(struct AVCodecContext *c, AVFrame *pic)
 {
     AvFormatDecoder *nd = (AvFormatDecoder *)(c->opaque);
@@ -2368 +2440 @@
  *   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 +2509 @@
     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 substream that was kept in wtrack,
+        // ignoring the stream index (which might have changed). 
+        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 +2607 @@
     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 +2911 @@
         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 +2921 @@
             {
                 case CODEC_TYPE_AUDIO:
                 {
+                    bool reselectAudioTrack = false;
+
+                    // detect switches between stereo and dual languages
+                    bool wasDual = audSubIdx != -1;
+                    bool isDual = curstream->codec->avcodec_dual_language;
+                    if ((wasDual && !isDual) || (!wasDual &&  isDual))
+                    {
+                        SetupAudioStreamSubIndexes(audIdx);
+                        reselectAudioTrack = true;
+                    }                            
+
                     // detect channels on streams that need
                     // to be decoded before we can know this
                     if (!curstream->codec->channels)
@@ -2801 +2941 @@
                         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 +3042 @@
                             .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;

libs/libmythtv/avformatdecoder.h

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