Ticket #5900: ticket5900@trunk19685.diff

File ticket5900@trunk19685.diff, 79.9 KB (added by Markus Schulz <msc@…>, 12 years ago)

works with trunk@19685

  • mythplugins/mythmusic/mythmusic/playbackbox.cpp

     
    365365            changeSpeed(true);
    366366        else if (action == "MUTE")
    367367            toggleMute();
     368        else if (action == "TOGGLEUPMIX")
     369            toggleUpmix();
    368370        else if (action == "MENU" && visualizer_status != 2)
    369371        {
    370372            menufilters = false;
     
    11961198    }
    11971199}
    11981200
     1201void PlaybackBoxMusic::toggleUpmix()
     1202{
     1203    if (gPlayer->getOutput())
     1204        gPlayer->getOutput()->ToggleUpmix();
     1205}
     1206   
     1207
    11991208void PlaybackBoxMusic::showProgressBar()
    12001209{
    12011210    if (progress_bar && visualizer_status != 2)
  • mythplugins/mythmusic/mythmusic/main.cpp

     
    368368    REG_KEY("Music", "VOLUMEDOWN", "Volume down",       "[,{,F10,Volume Down");
    369369    REG_KEY("Music", "VOLUMEUP",   "Volume up",         "],},F11,Volume Up");
    370370    REG_KEY("Music", "MUTE",       "Mute",              "|,\\,F9,Volume Mute");
     371    REG_KEY("Music", "TOGGLEUPMIX","Toggle upmixer",             "Ctrl+U");
    371372    REG_KEY("Music", "CYCLEVIS",   "Cycle visualizer mode",      "6");
    372373    REG_KEY("Music", "BLANKSCR",   "Blank screen",               "5");
    373374    REG_KEY("Music", "THMBUP",     "Increase rating",            "9");
  • mythplugins/mythmusic/mythmusic/musicplayer.cpp

     
    354354
    355355void MusicPlayer::openOutputDevice(void)
    356356{
    357     QString adevice;
     357    QString adevice, pdevice;
    358358
    359359    if (gContext->GetSetting("MusicAudioDevice") == "default")
    360360        adevice = gContext->GetSetting("AudioOutputDevice");
    361361    else
    362362        adevice = gContext->GetSetting("MusicAudioDevice");
    363363
     364    pdevice = gContext->GetSetting("PassThruOutputDevice");
     365
    364366    // TODO: Error checking that device is opened correctly!
    365     m_output = AudioOutput::OpenAudio(adevice, "default", 16, 2, 44100,
     367    m_output = AudioOutput::OpenAudio(adevice, pdevice, 16, 2, 44100,
    366368                                    AUDIOOUTPUT_MUSIC, true, false);
    367369    m_output->setBufferSize(256 * 1024);
    368370    m_output->SetBlocking(false);
  • mythplugins/mythmusic/mythmusic/playbackbox.h

     
    7070    void changeVolume(bool up_or_down);
    7171    void changeSpeed(bool up_or_down);
    7272    void toggleMute();
     73    void toggleUpmix();
    7374    void resetTimer();
    7475    void hideVolume(){showVolume(false);}
    7576    void showVolume(bool on_or_off);
  • mythtv/libs/libmythtv/NuppelVideoPlayer.cpp

     
    213213      audio_passthru_device(QString::null),
    214214      audio_channels(2),            audio_bits(-1),
    215215      audio_samplerate(44100),      audio_stretchfactor(1.0f),
    216       audio_codec(NULL),
    217216      // Picture-in-Picture stuff
    218217      pip_active(false),            pip_visible(true),
    219218      // Preview window support
     
    902901    if (audioOutput)
    903902    {
    904903        const AudioSettings settings(
    905             audio_bits, audio_channels, audio_samplerate,
    906             audio_passthru, audio_codec);
     904            audio_bits, audio_channels, audio_samplerate, audio_passthru);
    907905        audioOutput->Reconfigure(settings);
     906        if (audio_passthru)
     907            audio_channels = 2;
    908908        errMsg = audioOutput->GetError();
    909909        if (!errMsg.isEmpty())
    910910            audioOutput->SetStretchFactor(audio_stretchfactor);
     
    38253825    audio_passthru = passthru;
    38263826}
    38273827
    3828 void NuppelVideoPlayer::SetAudioCodec(void *ac)
    3829 {
    3830     audio_codec = ac;
    3831 }
    3832 
    38333828void NuppelVideoPlayer::SetEffDsp(int dsprate)
    38343829{
    38353830    if (audioOutput)
     
    52485243    }
    52495244}
    52505245
     5246bool NuppelVideoPlayer::ToggleUpmix()
     5247{
     5248    if (audioOutput)
     5249        return audioOutput->ToggleUpmix();
     5250    return false;
     5251}
     5252
    52515253void NuppelVideoPlayer::Zoom(ZoomDirection direction)
    52525254{
    52535255    if (videoOutput)
  • mythtv/libs/libmythtv/avformatdecoder.cpp

     
    427427      audioSamples(NULL),
    428428      allow_ac3_passthru(false),    allow_dts_passthru(false),
    429429      disable_passthru(false),      max_channels(2),
    430       dummy_frame(NULL),
     430      last_ac3_channels(0),         dummy_frame(NULL),
    431431      // DVD
    432432      lastdvdtitle(-1),
    433433      decodeStillFrame(false),
     
    29762976    {
    29772977        int idx = atracks[i].av_stream_index;
    29782978        AVCodecContext *codec_ctx = ic->streams[idx]->codec;
    2979         bool do_ac3_passthru = (allow_ac3_passthru && !transcoding &&
    2980                                 !disable_passthru &&
    2981                                 (codec_ctx->codec_id == CODEC_ID_AC3));
    2982         bool do_dts_passthru = (allow_dts_passthru && !transcoding &&
    2983                                 !disable_passthru &&
    2984                                 (codec_ctx->codec_id == CODEC_ID_DTS));
    29852979        AudioInfo item(codec_ctx->codec_id,
    29862980                       codec_ctx->sample_rate, codec_ctx->channels,
    2987                        do_ac3_passthru || do_dts_passthru);
     2981                       DoPassThrough(codec_ctx));
    29882982        VERBOSE(VB_AUDIO, LOC + " * " + item.toString());
    29892983    }
    29902984#endif
     
    31183112bool AvFormatDecoder::GetFrame(int onlyvideo)
    31193113{
    31203114    AVPacket *pkt = NULL;
     3115    AC3HeaderInfo hdr;
    31213116    int len;
    31223117    unsigned char *ptr;
    31233118    int data_size = 0;
     
    33143309        pts = 0;
    33153310
    33163311        AVStream *curstream = ic->streams[pkt->stream_index];
     3312        AVCodecContext *ctx = curstream->codec;
    33173313
    33183314        if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
    33193315            pts = (long long)(av_q2d(curstream->time_base) * pkt->dts * 1000);
    33203316
    33213317        if (ringBuffer->isDVD() &&
    3322             curstream->codec->codec_type == CODEC_TYPE_VIDEO)
     3318            ctx->codec_type == CODEC_TYPE_VIDEO)
    33233319        {
    33243320            MpegPreProcessPkt(curstream, pkt);
    33253321           
     
    33413337           
    33423338            if (!d->HasMPEG2Dec())
    33433339            {
    3344                 int current_width = curstream->codec->width;
     3340                int current_width = ctx->width;
    33453341                int video_width = GetNVP()->GetVideoSize().width();
    33463342                if (dvd_xvmc_enabled && GetNVP() && GetNVP()->getVideoOutput())
    33473343                {
     
    33823378        }
    33833379
    33843380        if (storevideoframes &&
    3385             curstream->codec->codec_type == CODEC_TYPE_VIDEO)
     3381            ctx->codec_type == CODEC_TYPE_VIDEO)
    33863382        {
    33873383            av_dup_packet(pkt);
    33883384            storedPackets.append(pkt);
     
    33903386            continue;
    33913387        }
    33923388
    3393         if (len > 0 && curstream->codec->codec_type == CODEC_TYPE_VIDEO &&
     3389        if (len > 0 && ctx->codec_type == CODEC_TYPE_VIDEO &&
    33943390            pkt->stream_index == selectedVideoIndex)
    33953391        {
    33963392            AVCodecContext *context = curstream->codec;
    33973393
    3398             if (context->codec_id == CODEC_ID_MPEG1VIDEO ||
    3399                 context->codec_id == CODEC_ID_MPEG2VIDEO ||
    3400                 context->codec_id == CODEC_ID_MPEG2VIDEO_XVMC ||
    3401                 context->codec_id == CODEC_ID_MPEG2VIDEO_XVMC_VLD ||
    3402                 context->codec_id == CODEC_ID_MPEGVIDEO_VDPAU)
     3394            if (ctx->codec_id == CODEC_ID_MPEG1VIDEO ||
     3395                ctx->codec_id == CODEC_ID_MPEG2VIDEO ||
     3396                ctx->codec_id == CODEC_ID_MPEG2VIDEO_XVMC ||
     3397                ctx->codec_id == CODEC_ID_MPEG2VIDEO_XVMC_VLD ||
     3398                ctx->codec_id == CODEC_ID_MPEGVIDEO_VDPAU)
    34033399            {
    34043400                if (!ringBuffer->isDVD())
    34053401                    MpegPreProcessPkt(curstream, pkt);
    34063402            }
    3407             else if (context->codec_id == CODEC_ID_H264 ||
    3408                      context->codec_id == CODEC_ID_H264_VDPAU)
     3403            else if (ctx->codec_id == CODEC_ID_H264 ||
     3404                     ctx->codec_id == CODEC_ID_H264_VDPAU)
    34093405            {
    34103406                H264PreProcessPkt(curstream, pkt);
    34113407            }
     
    34503446        }
    34513447
    34523448        if (len > 0 &&
    3453             curstream->codec->codec_type == CODEC_TYPE_DATA &&
    3454             curstream->codec->codec_id   == CODEC_ID_MPEG2VBI)
     3449            ctx->codec_type == CODEC_TYPE_DATA &&
     3450            ctx->codec_id   == CODEC_ID_MPEG2VBI)
    34553451        {
    34563452            ProcessVBIDataPacket(curstream, pkt);
    34573453
     
    34603456        }
    34613457
    34623458        if (len > 0 &&
    3463             curstream->codec->codec_type == CODEC_TYPE_DATA &&
    3464             curstream->codec->codec_id   == CODEC_ID_DVB_VBI)
     3459            ctx->codec_type == CODEC_TYPE_DATA &&
     3460            ctx->codec_id   == CODEC_ID_DVB_VBI)
    34653461        {
    34663462            ProcessDVBDataPacket(curstream, pkt);
    34673463
     
    34713467
    34723468#ifdef USING_MHEG
    34733469        if (len > 0 &&
    3474             curstream->codec->codec_type == CODEC_TYPE_DATA &&
    3475             curstream->codec->codec_id   == CODEC_ID_DSMCC_B)
     3470            ctx->codec_type == CODEC_TYPE_DATA &&
     3471            ctx->codec_id   == CODEC_ID_DSMCC_B)
    34763472        {
    34773473            ProcessDSMCCPacket(curstream, pkt);
    34783474
     
    34933489#endif // USING_MHEG
    34943490
    34953491        // we don't care about other data streams
    3496         if (curstream->codec->codec_type == CODEC_TYPE_DATA)
     3492        if (ctx->codec_type == CODEC_TYPE_DATA)
    34973493        {
    34983494            av_free_packet(pkt);
    34993495            continue;
    35003496        }
    35013497
    3502         if (!curstream->codec->codec)
     3498        if (!ctx->codec)
    35033499        {
    35043500            VERBOSE(VB_PLAYBACK, LOC +
    35053501                    QString("No codec for stream index %1, type(%2) id(%3:%4)")
    35063502                    .arg(pkt->stream_index)
    3507                     .arg(codec_type_string(curstream->codec->codec_type))
    3508                     .arg(codec_id_string(curstream->codec->codec_id))
    3509                     .arg(curstream->codec->codec_id));
     3503                    .arg(codec_type_string(ctx->codec_type))
     3504                    .arg(codec_id_string(ctx->codec_id))
     3505                    .arg(ctx->codec_id));
    35103506            av_free_packet(pkt);
    35113507            continue;
    35123508        }
     
    35153511        have_err = false;
    35163512
    35173513        avcodeclock.lock();
    3518         int ctype  = curstream->codec->codec_type;
     3514        int ctype  = ctx->codec_type;
    35193515        int audIdx = selectedTrack[kTrackTypeAudio].av_stream_index;
    35203516        int audSubIdx = selectedTrack[kTrackTypeAudio].av_substream_index;
    35213517        int subIdx = selectedTrack[kTrackTypeSubtitle].av_stream_index;
     
    35403536
    35413537                    // detect switches between stereo and dual languages
    35423538                    bool wasDual = audSubIdx != -1;
    3543                     bool isDual = curstream->codec->avcodec_dual_language;
     3539                    bool isDual = ctx->avcodec_dual_language;
    35443540                    if ((wasDual && !isDual) || (!wasDual &&  isDual))
    35453541                    {
    35463542                        SetupAudioStreamSubIndexes(audIdx);
    35473543                        reselectAudioTrack = true;
    35483544                    }                           
    35493545
    3550                     bool do_ac3_passthru =
    3551                         (allow_ac3_passthru && !transcoding &&
    3552                          (curstream->codec->codec_id == CODEC_ID_AC3));
    3553                     bool do_dts_passthru =
    3554                         (allow_dts_passthru && !transcoding &&
    3555                          (curstream->codec->codec_id == CODEC_ID_DTS));
    3556                     bool using_passthru = do_ac3_passthru || do_dts_passthru;
    3557 
    35583546                    // detect channels on streams that need
    35593547                    // to be decoded before we can know this
    35603548                    bool already_decoded = false;
    3561                     if (!curstream->codec->channels)
     3549                    if (!ctx->channels)                   
    35623550                    {
    35633551                        QMutexLocker locker(&avcodeclock);
    35643552                        VERBOSE(VB_IMPORTANT, LOC +
    35653553                                QString("Setting channels to %1")
    35663554                                .arg(audioOut.channels));
    35673555
    3568                         if (using_passthru)
     3556                        if (DoPassThrough(ctx))
    35693557                        {
    35703558                            // for passthru let it select the max number
    35713559                            // of channels
    3572                             curstream->codec->channels = 0;
    3573                             curstream->codec->request_channels = 0;
     3560                            ctx->channels = 0;
     3561                            ctx->request_channels = 0;
    35743562                        }
    35753563                        else
    35763564                        {
    3577                             curstream->codec->channels = audioOut.channels;
    3578                             curstream->codec->request_channels =
     3565                            ctx->channels = audioOut.channels;
     3566                            ctx->request_channels =
    35793567                                audioOut.channels;
    35803568                        }
    35813569                        data_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
    3582                         ret = avcodec_decode_audio2(curstream->codec,
     3570                        ret = avcodec_decode_audio2(ctx,
    35833571                                                    audioSamples, &data_size,
    35843572                                                    ptr, len);
    35853573                        already_decoded = true;
    35863574
    3587                         reselectAudioTrack |= curstream->codec->channels;
     3575                        reselectAudioTrack |= ctx->channels;
    35883576                    }
     3577                    if (ctx->codec_id == CODEC_ID_AC3)
     3578                    {
     3579                        GetBitContext gbc;
     3580                        init_get_bits(&gbc, ptr, len * 8);
     3581                        if (!ff_ac3_parse_header(&gbc, &hdr))
     3582                        {
     3583                            if (hdr.channels != last_ac3_channels)
     3584                            {
     3585                                last_ac3_channels = ctx->channels = hdr.channels;
     3586                                SetupAudioStream();
     3587                            }
     3588                        }
     3589                    }
    35893590
    35903591                    if (reselectAudioTrack)
    35913592                    {
     
    36003601                            .av_stream_index;
    36013602                        audSubIdx = selectedTrack[kTrackTypeAudio]
    36023603                            .av_substream_index;
     3604                        ctx = curstream->codec;
    36033605                    }
    36043606
    36053607                    if ((onlyvideo > 0) || (pkt->stream_index != audIdx))
     
    36313633                    if (audioOut.do_passthru)
    36323634                    {
    36333635                        data_size = pkt->size;
    3634                         bool dts = CODEC_ID_DTS == curstream->codec->codec_id;
     3636                        bool dts = CODEC_ID_DTS == ctx->codec_id;
    36353637                        ret = encode_frame(dts, ptr, len,
    36363638                                           audioSamples, data_size);
    36373639                    }
    36383640                    else
    36393641                    {
    3640                         AVCodecContext *ctx = curstream->codec;
    3641 
    36423642                        if ((ctx->channels == 0) ||
    36433643                            (ctx->channels > audioOut.channels))
    36443644                        {
     
    36473647
    36483648                        if (!already_decoded)
    36493649                        {
    3650                             curstream->codec->request_channels =
    3651                                 audioOut.channels;
     3650                            ctx->request_channels = audioOut.channels;
    36523651                            data_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
    36533652                            ret = avcodec_decode_audio2(ctx, audioSamples,
    36543653                                                        &data_size, ptr, len);
     
    36663665                            audIdx = -1;
    36673666                            AutoSelectAudioTrack();
    36683667                            data_size = 0;
     3668                            ctx = curstream->codec;
    36693669                        }
    36703670                    }
    36713671                    avcodeclock.unlock();
     
    36833683
    36843684                    // calc for next frame
    36853685                    lastapts += (long long)((double)(data_size * 1000) /
    3686                                 (curstream->codec->channels * 2) /
    3687                                 curstream->codec->sample_rate);
     3686                                (ctx->channels * 2) / ctx->sample_rate);
    36883687
    36893688                    VERBOSE(VB_PLAYBACK+VB_TIMESTAMP,
    36903689                            LOC + QString("audio timecode %1 %2 %3 %4")
     
    37523751                        continue;
    37533752                    }
    37543753
    3755                     AVCodecContext *context = curstream->codec;
    37563754                    AVFrame mpa_pic;
    37573755                    bzero(&mpa_pic, sizeof(AVFrame));
    37583756
     
    37673765                            // HACK
    37683766                            while (!gotpicture && count < 5)
    37693767                            {
    3770                                 ret = d->DecodeMPEG2Video(context, &mpa_pic,
     3768                                ret = d->DecodeMPEG2Video(ctx, &mpa_pic,
    37713769                                                  &gotpicture, ptr, len);
    37723770                                count++;
    37733771                            }
    37743772                        }
    37753773                        else
    37763774                        {
    3777                             ret = d->DecodeMPEG2Video(context, &mpa_pic,
     3775                            ret = d->DecodeMPEG2Video(ctx, &mpa_pic,
    37783776                                                &gotpicture, ptr, len);
    37793777                        }
    37803778                    }
    37813779                    else
    37823780                    {
    3783                         ret = avcodec_decode_video(context, &mpa_pic,
     3781                        ret = avcodec_decode_video(ctx, &mpa_pic,
    37843782                                                   &gotpicture, ptr, len);
    37853783                        // Reparse it to not drop the DVD still frame
    37863784                        if (decodeStillFrame)
    3787                             ret = avcodec_decode_video(context, &mpa_pic,
     3785                            ret = avcodec_decode_video(ctx, &mpa_pic,
    37883786                                                        &gotpicture, ptr, len);
    37893787                    }
    37903788                    avcodeclock.unlock();
     
    38513849
    38523850                        img_convert(&tmppicture, PIX_FMT_YUV420P,
    38533851                                    (AVPicture *)&mpa_pic,
    3854                                     context->pix_fmt,
    3855                                     context->width,
    3856                                     context->height);
     3852                                    ctx->pix_fmt,
     3853                                    ctx->width,
     3854                                    ctx->height);
    38573855
    38583856                        if (xf)
    38593857                        {
     
    38763874                        (temppts + 10000 > lastvpts || temppts < 0))
    38773875                    {
    38783876                        temppts = lastvpts;
    3879                         temppts += (long long)(1000 * av_q2d(context->time_base));
     3877                        temppts += (long long)(1000 * av_q2d(ctx->time_base));
    38803878                        // MPEG2 frames can be repeated, update pts accordingly
    38813879                        temppts += (long long)(mpa_pic.repeat_pict * 500
    3882                                       * av_q2d(curstream->codec->time_base));
     3880                                      * av_q2d(ctx->time_base));
    38833881                    }
    38843882
    38853883                    VERBOSE(VB_PLAYBACK+VB_TIMESTAMP, LOC +
     
    39153913                    picframe->frameNumber = framesPlayed;
    39163914                    GetNVP()->ReleaseNextVideoFrame(picframe, temppts);
    39173915                    if (d->HasMPEG2Dec() && mpa_pic.data[3])
    3918                         context->release_buffer(context, &mpa_pic);
     3916                        ctx->release_buffer(ctx, &mpa_pic);
    39193917
    39203918                    decoded_video_frame = picframe;
    39213919                    gotvideo = 1;
     
    39713969                }
    39723970                default:
    39733971                {
    3974                     AVCodecContext *enc = curstream->codec;
    39753972                    VERBOSE(VB_IMPORTANT, LOC_ERR +
    39763973                            QString("Decoding - id(%1) type(%2)")
    3977                             .arg(codec_id_string(enc->codec_id))
    3978                             .arg(codec_type_string(enc->codec_type)));
     3974                            .arg(codec_id_string(ctx->codec_id))
     3975                            .arg(codec_type_string(ctx->codec_type)));
    39793976                    have_err = true;
    39803977                    break;
    39813978                }
     
    41244121    }
    41254122}
    41264123
     4124bool AvFormatDecoder::DoPassThrough(const AVCodecContext *ctx)
     4125{
     4126    bool passthru = false;
     4127
     4128    if (ctx->codec_id == CODEC_ID_AC3)
     4129        passthru = allow_ac3_passthru &&
     4130                   ctx->channels >= (int)max_channels;
     4131    else if (ctx->codec_id == CODEC_ID_DTS)
     4132        passthru = allow_dts_passthru;
     4133   
     4134    passthru &= !transcoding && !disable_passthru;
     4135    // Don't know any cards that support spdif clocked at < 44100
     4136    // Some US cable transmissions have 2ch 32k AC-3 streams
     4137    passthru &= ctx->sample_rate >= 44100;
     4138
     4139    return passthru;
     4140}
     4141
    41274142/** \fn AvFormatDecoder::SetupAudioStream(void)
    41284143 *  \brief Reinitializes audio if it needs to be reinitialized.
    41294144 *
     
    41374152    AVStream *curstream = NULL;
    41384153    AVCodecContext *codec_ctx = NULL;
    41394154    AudioInfo old_in  = audioIn;
    4140     AudioInfo old_out = audioOut;
    41414155    bool using_passthru = false;
    41424156
    41434157    if ((currentTrack[kTrackTypeAudio] >= 0) &&
     
    41514165        codec_ctx = curstream->codec;       
    41524166        if (codec_ctx)
    41534167        {
    4154             bool do_ac3_passthru = (allow_ac3_passthru && !transcoding &&
    4155                                     (codec_ctx->codec_id == CODEC_ID_AC3));
    4156             bool do_dts_passthru = (allow_dts_passthru && !transcoding &&
    4157                                     (codec_ctx->codec_id == CODEC_ID_DTS));
    4158             using_passthru = do_ac3_passthru || do_dts_passthru;
    4159             info = AudioInfo(codec_ctx->codec_id,
    4160                              codec_ctx->sample_rate, codec_ctx->channels,
    4161                              using_passthru && !disable_passthru);
     4168            using_passthru = DoPassThrough(codec_ctx);
     4169            info = AudioInfo(codec_ctx->codec_id, codec_ctx->sample_rate,
     4170                            codec_ctx->channels, using_passthru);
    41624171        }
    41634172    }
    41644173
     
    41754184            QString("audio track #%1").arg(currentTrack[kTrackTypeAudio]+1));
    41764185
    41774186    audioOut = audioIn = info;
    4178     AudioInfo tmpAudioOut = audioOut;
    41794187
    4180     // A passthru stream looks like a 48KHz 2ch (@ 16bit) to the sound card
    4181     if (using_passthru && !disable_passthru)
     4188    if (!using_passthru && audioOut.channels > (int)max_channels)
    41824189    {
    4183         tmpAudioOut.channels    = 2;
    4184         tmpAudioOut.sample_rate = 48000;
    4185         tmpAudioOut.sample_size = 4;
    4186     }
    4187 
    4188     if (audioOut.channels > (int) max_channels)
    4189     {
    4190         audioOut.channels    = (int) max_channels;
     4190        audioOut.channels = (int)max_channels;
    41914191        audioOut.sample_size = audioOut.channels * 2;
    4192         codec_ctx->channels  = audioOut.channels;
     4192        codec_ctx->channels = audioOut.channels;
    41934193    }
    41944194
    4195     if (!using_passthru)
    4196         tmpAudioOut = audioOut;
    4197 
    41984195    VERBOSE(VB_AUDIO, LOC + "Audio format changed " +
    4199             QString("%1%2\n\t\t\tfrom %3 ; %4\n\t\t\tto   %5 ; %6")
    4200             .arg((using_passthru) ? "digital passthrough " : "")
    4201             .arg((using_passthru) ? tmpAudioOut.toString() : QString(""))
    4202             .arg(old_in.toString()).arg(old_out.toString())
    4203             .arg(audioIn.toString()).arg(audioOut.toString()));
     4196            QString("\n\t\t\tfrom %1 to %2")
     4197            .arg(old_in.toString()).arg(audioOut.toString()));
    42044198
    4205     if (tmpAudioOut.sample_rate > 0)
    4206         GetNVP()->SetEffDsp(tmpAudioOut.sample_rate * 100);
     4199    if (audioOut.sample_rate > 0)
     4200        GetNVP()->SetEffDsp(audioOut.sample_rate * 100);
    42074201
    4208     GetNVP()->SetAudioParams(tmpAudioOut.bps(), tmpAudioOut.channels,
    4209                              tmpAudioOut.sample_rate, audioIn.do_passthru);
     4202    GetNVP()->SetAudioParams(audioOut.bps(), audioOut.channels,
     4203                             audioOut.sample_rate, audioOut.do_passthru);
    42104204
    4211     // allow the audio stuff to reencode
    4212     GetNVP()->SetAudioCodec((using_passthru) ? codec_ctx : NULL);
    42134205    GetNVP()->ReinitAudio();
    42144206
    42154207    return true;
  • mythtv/libs/libmythtv/tv_play.h

     
    406406    void NormalSpeed(PlayerContext*);
    407407    void ChangeSpeed(PlayerContext*, int direction);
    408408    void ToggleTimeStretch(PlayerContext*);
     409    void ToggleUpmix(PlayerContext*);
    409410    void ChangeTimeStretch(PlayerContext*, int dir, bool allowEdit = true);
    410411    bool TimeStretchHandleAction(PlayerContext*,
    411412                                 const QStringList &actions);
  • mythtv/libs/libmythtv/NuppelVideoPlayer.h

     
    180180    // Toggle Sets
    181181    void ToggleAspectOverride(AspectOverrideMode aspectMode = kAspect_Toggle);
    182182    void ToggleAdjustFill(AdjustFillMode adjustfillMode = kAdjustFill_Toggle);
     183    bool ToggleUpmix(void);
    183184
    184185    // Gets
    185186    QSize   GetVideoBufferSize(void) const    { return video_dim; }
     
    706707    int      audio_bits;
    707708    int      audio_samplerate;
    708709    float    audio_stretchfactor;
    709     void    *audio_codec;
    710710    bool     audio_passthru;
    711711
    712712    // Picture-in-Picture
  • mythtv/libs/libmythtv/tv_play.cpp

     
    428428    REG_KEY("TV Frontend", "VOLUMEDOWN", "Volume down", "[,{,F10,Volume Down");
    429429    REG_KEY("TV Frontend", "VOLUMEUP",   "Volume up",   "],},F11,Volume Up");
    430430    REG_KEY("TV Frontend", "MUTE",       "Mute",        "|,\\,F9,Volume Mute");
     431    REG_KEY("TV Playback", "TOGGLEUPMIX", "Toggle upmixer", "Ctrl+U");
    431432    REG_KEY("TV Frontend", "RANKINC", "Increase program or channel rank",
    432433            "Right");
    433434    REG_KEY("TV Frontend", "RANKDEC", "Decrease program or channel rank",
     
    613614  Teletext     F2,F3,F4,F5,F6,F7,F8
    614615  ITV          F2,F3,F4,F5,F6,F7,F12
    615616
    616   Playback: Ctrl-B,Ctrl-G,Ctrl-Y
     617  Playback: Ctrl-B,Ctrl-G,Ctrl-Y,Ctrl-U
    617618*/
    618619}
    619620
     
    42164217        DoTogglePictureAttribute(ctx, kAdjustingPicture_Playback);
    42174218    else if (has_action("TOGGLESTRETCH", actions))
    42184219        ToggleTimeStretch(ctx);
     4220    else if (has_action("TOGGLEUPMIX", actions))
     4221        ToggleUpmix(ctx);
    42194222    else if (has_action("TOGGLESLEEP", actions))
    42204223        ToggleSleepTimer(ctx);
    42214224    else if (has_action("TOGGLERECORD", actions) && islivetv)
     
    77097712    ChangeTimeStretch(ctx, 0, false);
    77107713}
    77117714
     7715void TV::ToggleUpmix(PlayerContext *ctx)
     7716{
     7717    if (!ctx->nvp || !ctx->nvp->HasAudioOut())
     7718        return;
     7719    QString text;
     7720    if (ctx->nvp->ToggleUpmix())
     7721        text = tr("Upmixer On");
     7722    else
     7723        text = tr("Upmixer Off");
     7724
     7725    if (ctx->nvp->GetOSD() && !browsemode)
     7726        ctx->nvp->GetOSD()->SetSettingsText(text, 5);
     7727}
     7728
    77127729void TV::ChangeTimeStretch(PlayerContext *ctx, int dir, bool allowEdit)
    77137730{
    77147731    const float kTimeStretchMin = 0.5;
     
    93199336        SetManualZoom(actx, true, tr("Zoom Mode ON"));
    93209337    else if (action == "TOGGLESTRETCH")
    93219338        ToggleTimeStretch(actx);
     9339    else if (action == "TOGGLEUPMIX")
     9340        ToggleUpmix(actx);
    93229341    else if (action.left(13) == "ADJUSTSTRETCH")
    93239342    {
    93249343        bool floatRead;
     
    95629581        FillMenuPlaying(ctx, treeMenu);
    95639582
    95649583    FillMenuTracks(ctx, treeMenu, kTrackTypeAudio);
     9584    new OSDGenericTree(treeMenu, tr("Toggle Upmixer"), "TOGGLEUPMIX");
    95659585    FillMenuTracks(ctx, treeMenu, kTrackTypeSubtitle);
    95669586    FillMenuTracks(ctx, treeMenu, kTrackTypeCC708);
    95679587
  • mythtv/libs/libmythtv/avformatdecoder.h

     
    199199
    200200    void SeekReset(long long, uint skipFrames, bool doFlush, bool discardFrames);
    201201
     202    bool DoPassThrough(const AVCodecContext *ctx);
    202203    bool SetupAudioStream(void);
    203204    void SetupAudioStreamSubIndexes(int streamIndex);
    204205    void RemoveAudioStreams();
     
    270271    bool              allow_dts_passthru;
    271272    bool              disable_passthru;
    272273    uint              max_channels;
     274    uint              last_ac3_channels;
    273275
    274276    VideoFrame       *dummy_frame;
    275277
  • mythtv/libs/libmythsamplerate/samplerate.c

     
    452452        {       len -- ;
    453453
    454454                scaled_value = in [len] * (8.0 * 0x10000000) ;
    455                 if (CPU_CLIPS_POSITIVE == 0 && scaled_value >= (1.0 * 0x7FFFFFFF))
     455                if (scaled_value >= (1.0 * 0x7FFFFFFF))
    456456                {       out [len] = 32767 ;
    457457                        continue ;
    458458                        } ;
    459                 if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))
     459                if (scaled_value <= (-8.0 * 0x10000000))
    460460                {       out [len] = -32768 ;
    461461                        continue ;
    462462                        } ;
  • mythtv/libs/libmyth/audiosettings.cpp

     
    1515    samplerate(-1),
    1616    set_initial_vol(false),
    1717    use_passthru(false),
    18     codec(NULL),
    1918    source(AUDIOOUTPUT_UNKNOWN)
    2019{
    2120}
     
    2827    samplerate(other.samplerate),
    2928    set_initial_vol(other.set_initial_vol),
    3029    use_passthru(other.use_passthru),
    31     codec(other.codec),
    3230    source(other.source)
    3331{
    3432}
     
    4139    int audio_samplerate,
    4240    AudioOutputSource audio_source,
    4341    bool audio_set_initial_vol,
    44     bool audio_use_passthru,
    45     void *audio_codec) :
     42    bool audio_use_passthru) :
    4643    main_device(audio_main_device),
    4744    passthru_device(audio_passthru_device),
    4845    bits(audio_bits),
     
    5047    samplerate(audio_samplerate),
    5148    set_initial_vol(audio_set_initial_vol),
    5249    use_passthru(audio_use_passthru),
    53     codec(audio_codec),
    5450    source(audio_source)
    5551{
    5652}
     
    5955    int   audio_bits,
    6056    int   audio_channels,
    6157    int   audio_samplerate,
    62     bool  audio_use_passthru,
    63     void *audio_codec) :
     58    bool  audio_use_passthru) :
    6459    main_device(QString::null),
    6560    passthru_device(QString::null),
    6661    bits(audio_bits),
     
    6863    samplerate(audio_samplerate),
    6964    set_initial_vol(false),
    7065    use_passthru(audio_use_passthru),
    71     codec(audio_codec),
    7266    source(AUDIOOUTPUT_UNKNOWN)
    7367{
    7468}
  • mythtv/libs/libmyth/audiooutputbase.h

     
    4343
    4444    virtual void SetStretchFactor(float factor);
    4545    virtual float GetStretchFactor(void) const;
     46    virtual bool ToggleUpmix(void);
    4647
    4748    virtual void Reset(void);
    4849
     
    132133    QString audio_passthru_device;
    133134
    134135    bool audio_passthru;
     136    bool audio_enc;
     137    bool audio_reenc;
    135138
    136139    float audio_stretchfactor;
    137     AVCodecContext *audio_codec;
    138140    AudioOutputSource source;
    139141
    140142    bool killaudio;
     
    144146    bool buffer_output_data_for_use; //  used by AudioOutputNULL
    145147
    146148    int configured_audio_channels;
     149    int orig_config_channels;
     150    int src_quality;
    147151
    148152 private:
    149153    // resampler
     
    156160    FreeSurround              *upmixer;
    157161
    158162    int source_audio_channels;
     163    int source_audio_samplerate;
    159164    int source_audio_bytes_per_sample;
    160165    bool needs_upmix;
    161166    int surround_mode;
     167    bool allow_ac3_passthru;
     168    float old_audio_stretchfactor;
    162169
    163170    bool blocking; // do AddSamples calls block?
    164171
  • mythtv/libs/libmyth/audiooutputalsa.cpp

     
    3232AudioOutputALSA::~AudioOutputALSA()
    3333{
    3434    KillAudio();
     35    SetIECStatus(true);
    3536}
    3637
     38void AudioOutputALSA::SetIECStatus(bool audio) {
     39   
     40    snd_ctl_t *ctl;
     41    const char *spdif_str = SND_CTL_NAME_IEC958("", PLAYBACK, DEFAULT);
     42    int spdif_index = -1;
     43    snd_ctl_elem_list_t *clist;
     44    snd_ctl_elem_id_t *cid;
     45    snd_ctl_elem_value_t *cval;
     46    snd_aes_iec958_t iec958;
     47    int cidx, controls;
     48
     49    VERBOSE(VB_AUDIO, QString("Setting IEC958 status: %1")
     50                      .arg(audio ? "audio" : "non-audio"));
     51   
     52    snd_ctl_open(&ctl, "default", 0);
     53    snd_ctl_elem_list_alloca(&clist);
     54    snd_ctl_elem_list(ctl, clist);
     55    snd_ctl_elem_list_alloc_space(clist, snd_ctl_elem_list_get_count(clist));
     56    snd_ctl_elem_list(ctl, clist);
     57    controls = snd_ctl_elem_list_get_used(clist);
     58    for (cidx = 0; cidx < controls; cidx++) {
     59        if (!strcmp(snd_ctl_elem_list_get_name(clist, cidx), spdif_str))
     60            if (spdif_index < 0 ||
     61                snd_ctl_elem_list_get_index(clist, cidx) == (uint)spdif_index)
     62                    break;
     63    }
     64
     65    if (cidx >= controls)
     66        return;
     67
     68    snd_ctl_elem_id_alloca(&cid);
     69    snd_ctl_elem_list_get_id(clist, cidx, cid);
     70    snd_ctl_elem_value_alloca(&cval);
     71    snd_ctl_elem_value_set_id(cval, cid);
     72    snd_ctl_elem_read(ctl,cval);
     73    snd_ctl_elem_value_get_iec958(cval, &iec958);
     74   
     75    if (!audio)
     76        iec958.status[0] |= IEC958_AES0_NONAUDIO;
     77    else
     78        iec958.status[0] &= ~IEC958_AES0_NONAUDIO;
     79
     80    snd_ctl_elem_value_set_iec958(cval, &iec958);
     81    snd_ctl_elem_write(ctl, cval);
     82
     83}
     84
    3785bool AudioOutputALSA::OpenDevice()
    3886{
    3987    snd_pcm_format_t format;
    4088    unsigned int buffer_time, period_time;
    4189    int err;
     90    QString real_device;
    4291
    4392    if (pcm_handle != NULL)
    4493        CloseDevice();
    4594
    4695    pcm_handle = NULL;
    4796    numbadioctls = 0;
     97   
     98    if (audio_passthru || audio_enc)
     99    {
     100        real_device = audio_passthru_device;
     101        SetIECStatus(false);
     102    }
     103    else
     104    {
     105        real_device = audio_main_device;
     106        SetIECStatus(true);
     107    }
    48108
    49     QString real_device = (audio_passthru) ?
    50         audio_passthru_device : audio_main_device;
    51 
    52109    VERBOSE(VB_GENERAL, QString("Opening ALSA audio device '%1'.")
    53110            .arg(real_device));
    54111
  • mythtv/libs/libmyth/audiooutputbase.cpp

     
    2828
    2929    audio_main_device(settings.GetMainDevice()),
    3030    audio_passthru_device(settings.GetPassthruDevice()),
    31     audio_passthru(false),      audio_stretchfactor(1.0f),
     31    audio_passthru(false),      audio_enc(false),
     32    audio_reenc(false),         audio_stretchfactor(1.0f),
    3233
    33     audio_codec(NULL),
    3434    source(settings.source),    killaudio(false),
    3535
    3636    pauseaudio(false),          audio_actually_paused(false),
     
    4848    encoder(NULL),
    4949    upmixer(NULL),
    5050    source_audio_channels(-1),
     51    source_audio_samplerate(0),
    5152    source_audio_bytes_per_sample(0),
    5253    needs_upmix(false),
    5354    surround_mode(FreeSurround::SurroundModePassive),
     55    old_audio_stretchfactor(1.0),
    5456
    5557    blocking(false),
    5658
     
    7981    memset(&audiotime_updated, 0, sizeof(audiotime_updated));
    8082    memset(audiobuffer,        0, sizeof(char)  * kAudioRingBufferSize);
    8183    configured_audio_channels = gContext->GetNumSetting("MaxChannels", 2);
     84    orig_config_channels = configured_audio_channels;
     85    allow_ac3_passthru = gContext->GetNumSetting("AC3PassThru", false);
     86    src_quality = gContext->GetNumSetting("SRCQuality", 3);
    8287
    8388    // You need to call Reconfigure from your concrete class.
    8489    // Reconfigure(laudio_bits,       laudio_channels,
     
    124129            VERBOSE(VB_GENERAL, LOC + QString("Using time stretch %1")
    125130                                        .arg(audio_stretchfactor));
    126131            pSoundStretch = new soundtouch::SoundTouch();
    127             if (audio_codec)
    128             {
    129                 if (!encoder)
    130                 {
    131                     VERBOSE(VB_AUDIO, LOC +
    132                             QString("Creating Encoder for codec %1 origfs %2")
    133                             .arg(audio_codec->codec_id)
    134                             .arg(audio_codec->frame_size));
     132            pSoundStretch->setSampleRate(audio_samplerate);
     133            pSoundStretch->setChannels(upmixer ?
     134                configured_audio_channels : source_audio_channels);
    135135
    136                     encoder = new AudioOutputDigitalEncoder();
    137                     if (!encoder->Init(audio_codec->codec_id,
    138                                 audio_codec->bit_rate,
    139                                 audio_codec->sample_rate,
    140                                 audio_codec->channels
    141                                 ))
    142                     {
    143                         // eeks
    144                         delete encoder;
    145                         encoder = NULL;
    146                         VERBOSE(VB_AUDIO, LOC +
    147                                 QString("Failed to Create Encoder"));
    148                     }
    149                 }
    150             }
    151             if (audio_codec && encoder)
    152             {
    153                 pSoundStretch->setSampleRate(audio_codec->sample_rate);
    154                 pSoundStretch->setChannels(audio_codec->channels);
    155             }
    156             else
    157             {
    158                 pSoundStretch->setSampleRate(audio_samplerate);
    159                 pSoundStretch->setChannels(audio_channels);
    160             }
    161 
    162136            pSoundStretch->setTempo(audio_stretchfactor);
    163137            pSoundStretch->setSetting(SETTING_SEQUENCE_MS, 35);
    164138
    165139            // dont need these with only tempo change
    166140            //pSoundStretch->setPitch(1.0);
    167141            //pSoundStretch->setRate(1.0);
    168 
    169142            //pSoundStretch->setSetting(SETTING_USE_QUICKSEEK, true);
    170143            //pSoundStretch->setSetting(SETTING_USE_AA_FILTER, false);
    171144        }
     
    183156    return audio_stretchfactor;
    184157}
    185158
     159bool AudioOutputBase::ToggleUpmix(void)
     160{
     161    if (orig_config_channels == 2 || audio_passthru)
     162        return false;
     163    if (configured_audio_channels == 6)
     164        configured_audio_channels = 2;
     165    else
     166        configured_audio_channels = 6;
     167
     168    const AudioSettings settings(audio_bits, source_audio_channels,
     169                            source_audio_samplerate, audio_passthru);
     170    Reconfigure(settings);
     171    return (configured_audio_channels == 6);
     172}
     173
     174
    186175void AudioOutputBase::Reconfigure(const AudioSettings &orig_settings)
    187176{
    188177    AudioSettings settings = orig_settings;
    189178
    190     int codec_id = CODEC_ID_NONE;
    191     int lcodec_id = CODEC_ID_NONE;
    192     int lcchannels = 0;
    193     int cchannels = 0;
    194179    int lsource_audio_channels = settings.channels;
    195180    bool lneeds_upmix = false;
     181    bool laudio_reenc = false;
    196182
    197     if (settings.codec)
    198     {
    199         lcodec_id = ((AVCodecContext*)settings.codec)->codec_id;
    200         settings.bits = 16;
    201         settings.channels = 2;
    202         lsource_audio_channels = settings.channels;
    203         settings.samplerate = 48000;
    204         lcchannels = ((AVCodecContext*)settings.codec)->channels;
    205     }
     183    // Are we reencoding a (previously) timestretched bitstream?
     184    if (settings.channels > 2 && !settings.use_passthru)
     185        laudio_reenc = true;
    206186
    207     if (audio_codec)
     187    // Enough channels? Upmix if not
     188    if (settings.channels < configured_audio_channels &&
     189        !settings.use_passthru)
    208190    {
    209         codec_id = audio_codec->codec_id;
    210         cchannels = ((AVCodecContext*)audio_codec)->channels;
    211     }
    212 
    213     if ((configured_audio_channels == 6) &&
    214         !(settings.codec || audio_codec))
    215     {
    216191        settings.channels = configured_audio_channels;
    217192        lneeds_upmix = true;
    218193        VERBOSE(VB_AUDIO,LOC + "Needs upmix");
     
    224199        settings.samplerate == audio_samplerate && !need_resampler &&
    225200        settings.use_passthru == audio_passthru &&
    226201        lneeds_upmix == needs_upmix &&
    227         lcodec_id == codec_id && lcchannels == cchannels);
     202        laudio_reenc == audio_reenc);
    228203    bool upmix_deps =
    229204        (lsource_audio_channels == source_audio_channels);
    230205    if (general_deps && upmix_deps)
     
    251226    waud = raud = 0;
    252227    audio_actually_paused = false;
    253228
    254     bool redo_stretch = (pSoundStretch && audio_channels != settings.channels);
    255229    audio_channels = settings.channels;
    256230    source_audio_channels = lsource_audio_channels;
    257231    audio_bits = settings.bits;
    258     audio_samplerate = settings.samplerate;
    259     audio_codec = (AVCodecContext*)settings.codec;
     232    source_audio_samplerate = audio_samplerate = settings.samplerate;
     233    audio_reenc = laudio_reenc;
    260234    audio_passthru = settings.use_passthru;
    261235    needs_upmix = lneeds_upmix;
    262236
     
    265239        Error("AudioOutput only supports 8 or 16bit audio.");
    266240        return;
    267241    }
    268     audio_bytes_per_sample = audio_channels * audio_bits / 8;
    269     source_audio_bytes_per_sample = source_audio_channels * audio_bits / 8;
    270242
    271243    need_resampler = false;
    272244    killaudio = false;
     
    275247    internal_vol = gContext->GetNumSetting("MythControlsVolume", 0);
    276248
    277249    numlowbuffer = 0;
     250   
     251    // Encode to AC-3 if not passing thru , there's > 2 channels
     252    // and a passthru device is defined
     253    if (!audio_passthru && audio_channels > 2 && allow_ac3_passthru)
     254    {
     255        int srate = src_quality == 0 ? audio_samplerate : 48000;
     256        VERBOSE(VB_AUDIO, LOC + "Creating AC-3 Encoder");
     257        encoder = new AudioOutputDigitalEncoder();
     258        if (!encoder->Init(CODEC_ID_AC3, 448000, srate,
     259                           configured_audio_channels, audio_reenc))
     260        {
     261            VERBOSE(VB_AUDIO, LOC + "Can't create AC-3 encoder");
     262            delete encoder;
     263            encoder = NULL;
     264        }
     265       
     266        audio_enc = true;
     267    }       
     268   
     269    if(audio_passthru || audio_enc)
     270        // AC-3 output - soundcard expects a 2ch 48k stream
     271        audio_channels = 2;
     272   
     273    audio_bytes_per_sample = audio_channels * audio_bits / 8;
     274    source_audio_bytes_per_sample = source_audio_channels * audio_bits / 8;
    278275
     276    // Always resample to 48k - many cards can't do anything else
     277    // and ALSA will do it with linear interpolation (yuk) if we don't anyway
     278    if (src_quality != 0 && audio_samplerate != 48000)
     279    {
     280        int error;
     281        audio_samplerate = 48000;
     282        VERBOSE(VB_GENERAL, LOC + QString("Using resampler. From: %1 to %2")
     283            .arg(settings.samplerate).arg(audio_samplerate));
     284        src_ctx = src_new(3-src_quality, audio_channels, &error);
     285        if (error)
     286        {
     287            Error(QString("Error creating resampler, the error was: %1")
     288                  .arg(src_strerror(error)) );
     289            src_ctx = NULL;
     290            return;
     291        }
     292        src_data.src_ratio = (double) audio_samplerate / settings.samplerate;
     293        src_data.data_in = src_in;
     294        src_data.data_out = src_out;
     295        src_data.output_frames = 16384*6;
     296        need_resampler = true;
     297    }
     298   
    279299    VERBOSE(VB_GENERAL, QString("Opening audio device '%1'. ch %2(%3) sr %4")
    280300            .arg(audio_main_device).arg(audio_channels)
    281301            .arg(source_audio_channels).arg(audio_samplerate));
     
    309329    current_seconds = -1;
    310330    source_bitrate = -1;
    311331
    312     // NOTE: this won't do anything as above samplerate vars are set equal
    313     // Check if we need the resampler
    314     if (audio_samplerate != settings.samplerate)
    315     {
    316         int error;
    317         VERBOSE(VB_GENERAL, LOC + QString("Using resampler. From: %1 to %2")
    318                                .arg(settings.samplerate).arg(audio_samplerate));
    319         src_ctx = src_new (SRC_SINC_BEST_QUALITY, audio_channels, &error);
    320         if (error)
    321         {
    322             Error(QString("Error creating resampler, the error was: %1")
    323                   .arg(src_strerror(error)) );
    324             return;
    325         }
    326         src_data.src_ratio = (double) audio_samplerate / settings.samplerate;
    327         src_data.data_in = src_in;
    328         src_data.data_out = src_out;
    329         src_data.output_frames = 16384*6;
    330         need_resampler = true;
    331     }
    332 
    333332    if (needs_upmix)
    334333    {
    335334        VERBOSE(VB_AUDIO, LOC + QString("create upmixer"));
     
    344343            (FreeSurround::SurroundMode)surround_mode);
    345344
    346345        VERBOSE(VB_AUDIO, LOC +
    347                 QString("create upmixer done with surround mode %1")
     346                QString("Create upmixer done with surround mode %1")
    348347                .arg(surround_mode));
    349348    }
    350349
    351350    VERBOSE(VB_AUDIO, LOC + QString("Audio Stretch Factor: %1")
    352351            .arg(audio_stretchfactor));
    353     VERBOSE(VB_AUDIO, QString("Audio Codec Used: %1")
    354             .arg((audio_codec) ?
    355                  codec_id_string(audio_codec->codec_id) : "not set"));
    356352
    357     if (redo_stretch)
    358     {
    359         delete pSoundStretch;
    360         pSoundStretch = NULL;
    361         SetStretchFactorLocked(audio_stretchfactor);
    362     }
    363     else
    364     {
    365         SetStretchFactorLocked(audio_stretchfactor);
    366         if (pSoundStretch)
    367         {
    368             // if its passthru then we need to reencode
    369             if (audio_codec)
    370             {
    371                 if (!encoder)
    372                 {
    373                     VERBOSE(VB_AUDIO, LOC +
    374                             QString("Creating Encoder for codec %1")
    375                             .arg(audio_codec->codec_id));
    376 
    377                     encoder = new AudioOutputDigitalEncoder();
    378                     if (!encoder->Init(audio_codec->codec_id,
    379                                 audio_codec->bit_rate,
    380                                 audio_codec->sample_rate,
    381                                 audio_codec->channels
    382                                 ))
    383                     {
    384                         // eeks
    385                         delete encoder;
    386                         encoder = NULL;
    387                         VERBOSE(VB_AUDIO, LOC + "Failed to Create Encoder");
    388                     }
    389                 }
    390             }
    391             if (audio_codec && encoder)
    392             {
    393                 pSoundStretch->setSampleRate(audio_codec->sample_rate);
    394                 pSoundStretch->setChannels(audio_codec->channels);
    395             }
    396             else
    397             {
    398                 pSoundStretch->setSampleRate(audio_samplerate);
    399                 pSoundStretch->setChannels(audio_channels);
    400             }
    401         }
    402     }
    403 
     353    SetStretchFactorLocked(old_audio_stretchfactor);
     354   
    404355    // Setup visualisations, zero the visualisations buffers
    405356    prepareVisuals();
    406357
     
    436387    VERBOSE(VB_AUDIO, LOC + "Killing AudioOutputDSP");
    437388    killaudio = true;
    438389    StopOutputThread();
     390    QMutexLocker lock1(&audio_buflock);
    439391
    440392    // Close resampler?
    441393    if (src_ctx)
     394    {
    442395        src_delete(src_ctx);
     396        src_ctx = NULL;
     397    }
     398               
    443399    need_resampler = false;
    444400
    445401    // close sound stretcher
     
    447403    {
    448404        delete pSoundStretch;
    449405        pSoundStretch = NULL;
     406        old_audio_stretchfactor = audio_stretchfactor;
     407        audio_stretchfactor = 1.0;
    450408    }
    451409
    452410    if (encoder)
     
    461419        upmixer = NULL;
    462420    }
    463421    needs_upmix = false;
     422    audio_enc = false;
    464423
    465424    CloseDevice();
    466425
     
    562521    ret += (now.tv_usec - audiotime_updated.tv_usec) / 1000;
    563522    ret = (long long)(ret * audio_stretchfactor);
    564523
    565 #if 1
    566524    VERBOSE(VB_AUDIO+VB_TIMESTAMP,
    567525            QString("GetAudiotime now=%1.%2, set=%3.%4, ret=%5, audt=%6 sf=%7")
    568526            .arg(now.tv_sec).arg(now.tv_usec)
     
    571529            .arg(audiotime)
    572530            .arg(audio_stretchfactor)
    573531           );
    574 #endif
    575532
    576533    ret += audiotime;
    577534
     
    611568
    612569    // include algorithmic latencies
    613570    if (pSoundStretch)
    614     {
    615         // add the effect of any unused but processed samples,
    616         // AC3 reencode does this
    617         totalbuffer += (int)(pSoundStretch->numSamples() *
    618                              audio_bytes_per_sample);
    619         // add the effect of unprocessed samples in time stretch algo
    620571        totalbuffer += (int)((pSoundStretch->numUnprocessedSamples() *
    621572                              audio_bytes_per_sample) / audio_stretchfactor);
    622     }
    623573
    624574    if (upmixer && needs_upmix)
    625     {
    626575        totalbuffer += upmixer->sampleLatency() * audio_bytes_per_sample;
    627     }
    628576
     577    if (encoder)
     578         totalbuffer += encoder->Buffered();
     579
    629580    audiotime = audbuf_timecode - (int)(totalbuffer * 100000.0 /
    630581                                   (audio_bytes_per_sample * effdspstretched));
    631582
    632583    gettimeofday(&audiotime_updated, NULL);
    633 #if 1
     584   
    634585    VERBOSE(VB_AUDIO+VB_TIMESTAMP,
    635586            QString("SetAudiotime set=%1.%2, audt=%3 atc=%4 "
    636587                    "tb=%5 sb=%6 eds=%7 abps=%8 sf=%9")
     
    642593            .arg(effdspstretched)
    643594            .arg(audio_bytes_per_sample)
    644595            .arg(audio_stretchfactor));
    645 #endif
    646596}
    647597
    648598int AudioOutputBase::GetAudioBufferedTime(void)
     
    681631        return false; // would overflow
    682632    }
    683633
     634    QMutexLocker lock1(&audio_buflock);
     635
    684636    // resample input if necessary
    685637    if (need_resampler && src_ctx)
    686638    {
     
    725677    int abps = (encoder) ?
    726678        encoder->audio_bytes_per_sample : audio_bytes_per_sample;
    727679    int len = samples * abps;
     680   
     681    // Give original samples to mythmusic visualisation
     682    dispatchVisual((unsigned char *)buffer, len, timecode,
     683                   source_audio_channels, audio_bits);
    728684
    729685    // Check we have enough space to write the data
    730686    if (need_resampler && src_ctx)
     
    749705        return false; // would overflow
    750706    }
    751707
     708    QMutexLocker lock1(&audio_buflock);
     709
    752710    // resample input if necessary
    753711    if (need_resampler && src_ctx)
    754712    {
     
    808766            if (src_ctx)
    809767            {
    810768                int error = src_reset(src_ctx);
    811                 if (error)
     769                if (error)
     770                {
    812771                    VERBOSE(VB_IMPORTANT, LOC_ERR + QString(
    813772                            "Error occured while resetting resampler: %1")
    814773                            .arg(src_strerror(error)));
     774                    src_ctx = NULL;
     775                }
    815776            }
    816777        }
    817778    }
     
    821782void AudioOutputBase::_AddSamples(void *buffer, bool interleaved, int samples,
    822783                                  long long timecode)
    823784{
    824     audio_buflock.lock();
    825 
    826785    int len; // = samples * audio_bytes_per_sample;
    827786    int audio_bytes = audio_bits / 8;
    828787    int org_waud = waud;
     
    839798            .arg(samples * abps)
    840799            .arg(kAudioRingBufferSize-afree).arg(afree).arg(timecode)
    841800            .arg(needs_upmix));
    842 
     801   
     802    len = WaitForFreeSpace(samples);
     803       
    843804    if (upmixer && needs_upmix)
    844805    {
    845806        int out_samples = 0;
     807        org_waud = waud;
    846808        int step = (interleaved)?source_audio_channels:1;
    847         len = WaitForFreeSpace(samples);    // test
     809       
    848810        for (int itemp = 0; itemp < samples; )
    849811        {
    850             // just in case it does a processing cycle, release the lock
    851             // to allow the output loop to do output
    852             audio_buflock.unlock();
    853812            if (audio_bytes == 2)
    854813            {
    855814                itemp += upmixer->putSamples(
     
    866825                    source_audio_channels,
    867826                    (interleaved) ? 0 : samples);
    868827            }
    869             audio_buflock.lock();
    870828
    871829            int copy_samples = upmixer->numSamples();
    872830            if (copy_samples)
     
    900858    }
    901859    else
    902860    {
    903         len = WaitForFreeSpace(samples);
    904 
    905861        if (interleaved)
    906862        {
    907863            char *mybuf = (char*)buffer;
     
    936892        }
    937893    }
    938894
    939     if (samples > 0)
     895    if (samples <= 0)
     896        return;
     897       
     898    if (pSoundStretch)
    940899    {
    941         if (pSoundStretch)
     900        // does not change the timecode, only the number of samples
     901        // back to orig pos
     902        org_waud = waud;
     903        int bdiff = kAudioRingBufferSize - org_waud;
     904        int nSamplesToEnd = bdiff/abps;
     905        if (bdiff < len)
    942906        {
     907            pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)
     908                                      (audiobuffer +
     909                                       org_waud), nSamplesToEnd);
     910            pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)audiobuffer,
     911                                      (len - bdiff) / abps);
     912        }
     913        else
     914        {
     915            pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)
     916                                      (audiobuffer + org_waud),
     917                                      len / abps);
     918        }
    943919
    944             // does not change the timecode, only the number of samples
    945             // back to orig pos
    946             org_waud = waud;
    947             int bdiff = kAudioRingBufferSize - org_waud;
    948             int nSamplesToEnd = bdiff/abps;
    949             if (bdiff < len)
    950             {
    951                 pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)
    952                                           (audiobuffer +
    953                                            org_waud), nSamplesToEnd);
    954                 pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)audiobuffer,
    955                                           (len - bdiff) / abps);
     920        int nSamples = pSoundStretch->numSamples();
     921        len = WaitForFreeSpace(nSamples);
     922       
     923        while ((nSamples = pSoundStretch->numSamples()))
     924        {
     925            if (nSamples > nSamplesToEnd)
     926                nSamples = nSamplesToEnd;
     927           
     928            nSamples = pSoundStretch->receiveSamples(
     929                (soundtouch::SAMPLETYPE*)
     930                (audiobuffer + org_waud), nSamples
     931            );
     932           
     933            if (nSamples == nSamplesToEnd) {
     934                org_waud = 0;
     935                nSamplesToEnd = kAudioRingBufferSize/abps;
    956936            }
    957             else
    958             {
    959                 pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)
    960                                           (audiobuffer + org_waud),
    961                                           len / abps);
     937            else {
     938                org_waud += nSamples * abps;
     939                nSamplesToEnd -= nSamples;
    962940            }
     941           
     942        }
     943       
     944    }
    963945
    964             if (encoder)
    965             {
    966                 // pull out a packet's worth and reencode it until we
    967                 // don't have enough for any more packets
    968                 soundtouch::SAMPLETYPE *temp_buff =
    969                     (soundtouch::SAMPLETYPE*)encoder->GetFrameBuffer();
    970                 size_t frameSize = encoder->FrameSize()/abps;
     946    // Encode to AC-3?
     947    if (encoder)
     948    {
     949       
     950        org_waud = waud;
     951        int bdiff = kAudioRingBufferSize - org_waud;
     952        int to_get = 0;
    971953
    972                 VERBOSE(VB_AUDIO+VB_TIMESTAMP,
    973                         QString("_AddSamples Enc sfs=%1 bfs=%2 sss=%3")
    974                         .arg(frameSize)
    975                         .arg(encoder->FrameSize())
    976                         .arg(pSoundStretch->numSamples()));
    977 
    978                 // process the same number of samples as it creates
    979                 // a full encoded buffer just like before
    980                 while (pSoundStretch->numSamples() >= frameSize)
    981                 {
    982                     int got = pSoundStretch->receiveSamples(
    983                         temp_buff, frameSize);
    984                     int amount = encoder->Encode(temp_buff);
    985 
    986                     VERBOSE(VB_AUDIO+VB_TIMESTAMP,
    987                             QString("_AddSamples Enc bytes=%1 got=%2 left=%3")
    988                             .arg(amount)
    989                             .arg(got)
    990                             .arg(pSoundStretch->numSamples()));
    991 
    992                     if (!amount)
    993                         continue;
    994 
    995                     //len = WaitForFreeSpace(amount);
    996                     char *ob = encoder->GetOutBuff();
    997                     if (amount >= bdiff)
    998                     {
    999                         memcpy(audiobuffer + org_waud, ob, bdiff);
    1000                         ob += bdiff;
    1001                         amount -= bdiff;
    1002                         org_waud = 0;
    1003                     }
    1004                     if (amount > 0)
    1005                         memcpy(audiobuffer + org_waud, ob, amount);
    1006 
    1007                     bdiff = kAudioRingBufferSize - amount;
    1008                     org_waud = (org_waud + amount) % kAudioRingBufferSize;
    1009                 }
    1010             }
    1011             else
     954        if (bdiff < len)
     955        {
     956            encoder->Encode(audiobuffer + org_waud, bdiff);
     957            to_get = encoder->Encode(audiobuffer, len - bdiff);
     958        }
     959        else
     960            to_get = encoder->Encode(audiobuffer + org_waud, len);
     961       
     962        if (to_get > 0)
     963        {
     964           
     965            if (to_get >= bdiff)
    1012966            {
    1013                 int newLen = 0;
    1014                 int nSamples;
    1015                 len = WaitForFreeSpace(pSoundStretch->numSamples() *
    1016                                        audio_bytes_per_sample);
    1017                 do
    1018                 {
    1019                     int samplesToGet = len/audio_bytes_per_sample;
    1020                     if (samplesToGet > nSamplesToEnd)
    1021                     {
    1022                         samplesToGet = nSamplesToEnd;
    1023                     }
    1024 
    1025                     nSamples = pSoundStretch->receiveSamples(
    1026                         (soundtouch::SAMPLETYPE*)
    1027                         (audiobuffer + org_waud), samplesToGet);
    1028                     if (nSamples == nSamplesToEnd)
    1029                     {
    1030                         org_waud = 0;
    1031                         nSamplesToEnd = kAudioRingBufferSize/audio_bytes_per_sample;
    1032                     }
    1033                     else
    1034                     {
    1035                         int bufsz = nSamples * audio_bytes_per_sample;
    1036                         org_waud = (org_waud + bufsz) % kAudioRingBufferSize;
    1037                         nSamplesToEnd -= nSamples;
    1038                     }
    1039 
    1040                     newLen += nSamples * audio_bytes_per_sample;
    1041                     len -= nSamples * audio_bytes_per_sample;
    1042                 } while (nSamples > 0);
     967                encoder->GetFrames(audiobuffer + org_waud, bdiff);
     968                to_get -= bdiff;
     969                org_waud = 0;
    1043970            }
    1044         }
     971            if (to_get > 0)
     972                encoder->GetFrames(audiobuffer + org_waud, to_get);
    1045973
    1046         waud = org_waud;
    1047         lastaudiolen = audiolen(false);
     974            org_waud += to_get;
    1048975
    1049         if (timecode < 0)
    1050         {
    1051             // mythmusic doesn't give timestamps..
    1052             timecode = (int)((samples_buffered * 100000.0) / effdsp);
    1053976        }
    1054  
    1055         samples_buffered += samples;
    1056  
    1057         /* we want the time at the end -- but the file format stores
    1058            time at the start of the chunk. */
    1059         // even with timestretch, timecode is still calculated from original
    1060         // sample count
    1061         audbuf_timecode = timecode + (int)((samples * 100000.0) / effdsp);
    1062977
    1063         if (interleaved)
    1064         {
    1065             dispatchVisual((unsigned char *)buffer, len, timecode,
    1066                            source_audio_channels, audio_bits);
    1067         }
    1068978    }
    1069979
    1070     audio_buflock.unlock();
     980    waud = org_waud;
     981    lastaudiolen = audiolen(false);
     982
     983    if (timecode < 0)
     984        // mythmusic doesn't give timestamps..
     985        timecode = (int)((samples_buffered * 100000.0) / effdsp);
     986
     987    samples_buffered += samples;
     988
     989    /* we want the time at the end -- but the file format stores
     990       time at the start of the chunk. */
     991    // even with timestretch, timecode is still calculated from original
     992    // sample count
     993    audbuf_timecode = timecode + (int)((samples * 100000.0) / effdsp);
     994
    1071995}
    1072996
    1073997void AudioOutputBase::Status()
  • mythtv/libs/libmyth/audiosettings.h

     
    3232        int               audio_samplerate,
    3333        AudioOutputSource audio_source,
    3434        bool              audio_set_initial_vol,
    35         bool              audio_use_passthru,
    36         void             *audio_codec = NULL);
     35        bool              audio_use_passthru);
    3736
    3837    AudioSettings(int   audio_bits,
    3938                  int   audio_channels,
    4039                  int   audio_samplerate,
    41                   bool  audio_use_passthru,
    42                   void *audio_codec = NULL);
     40                  bool  audio_use_passthru);
    4341
    4442    void FixPassThrough(void);
    4543    void TrimDeviceType(void);
     
    5755    int     samplerate;
    5856    bool    set_initial_vol;
    5957    bool    use_passthru;
    60     void   *codec;
    6158    AudioOutputSource source;
    6259};
    6360
  • mythtv/libs/libmyth/audiooutputdigitalencoder.cpp

     
    2929AudioOutputDigitalEncoder::AudioOutputDigitalEncoder(void) :
    3030    audio_bytes_per_sample(0),
    3131    av_context(NULL),
    32     outbuf(NULL),
    33     outbuf_size(0),
    34     frame_buffer(NULL),
    35     one_frame_bytes(0)
     32    outbuflen(0),
     33    inbuflen(0),
     34    one_frame_bytes(0),
     35    reorder(true)
    3636{
    3737}
    3838
     
    4949        av_free(av_context);
    5050        av_context = NULL;
    5151    }
    52 
    53     if (outbuf)
    54     {
    55         delete [] outbuf;
    56         outbuf = NULL;
    57         outbuf_size = 0;
    58     }
    59 
    60     if (frame_buffer)
    61     {
    62         delete [] frame_buffer;
    63         frame_buffer = NULL;
    64         one_frame_bytes = 0;
    65     }
    6652}
    6753
    6854//CODEC_ID_AC3
    6955bool AudioOutputDigitalEncoder::Init(
    70     CodecID codec_id, int bitrate, int samplerate, int channels)
     56    CodecID codec_id, int bitrate, int samplerate, int channels, bool reencoding)
    7157{
    7258    AVCodec *codec;
    7359    int ret;
    7460
    75     VERBOSE(VB_AUDIO, LOC + QString("Init codecid=%1, br=%2, sr=%3, ch=%4")
     61    VERBOSE(VB_AUDIO, LOC + QString("Init codecid=%1, br=%2, sr=%3, ch=%4 re=%5")
    7662            .arg(codec_id_string(codec_id))
    7763            .arg(bitrate)
    7864            .arg(samplerate)
    79             .arg(channels));
     65            .arg(channels)
     66            .arg(reencoding));
     67   
     68    reorder = !reencoding;
    8069
    81     //codec = avcodec_find_encoder(codec_id);
     70    // We need to do this when called from mythmusic
     71    avcodec_init();
     72    avcodec_register_all();
    8273    // always AC3 as there is no DTS encoder at the moment 2005/1/9
    8374    codec = avcodec_find_encoder(CODEC_ID_AC3);
    8475    if (!codec)
     
    10798    audio_bytes_per_sample = bytes_per_frame;
    10899    one_frame_bytes = bytes_per_frame * av_context->frame_size;
    109100
    110     outbuf_size = 16384;    // ok for AC3 but DTS?
    111     outbuf = new char [outbuf_size];
    112101    VERBOSE(VB_AUDIO, QString("DigitalEncoder::Init fs=%1, bpf=%2 ofb=%3")
    113102            .arg(av_context->frame_size)
    114103            .arg(bytes_per_frame)
     
    253242
    254243} AESHeader;
    255244
     245void reorder_6ch_ac3(void *buf, unsigned int len) {
     246    unsigned short *src = (unsigned short *)buf;
     247    unsigned short tmp;
     248    unsigned int samples = len >> 1;
     249
     250    for (uint i = 0; i < samples; i += 6) {
     251        tmp = src[i+4];
     252        src[i+4] = src[i+3];
     253        src[i+3] = src[i+2];
     254        src[i+2] = src[i+1];
     255        src[i+1] = tmp;
     256    }
     257}
     258
    256259static int encode_frame(
    257260        bool dts,
    258261        unsigned char *data,
    259         size_t &len)
     262        size_t enc_len)
    260263{
    261264    unsigned char *payload = data + 8;  // skip header, currently 52 or 54bits
    262     size_t         enc_len;
    263265    int            flags, sample_rate, bit_rate;
    264266
    265267    // we don't do any length/crc validation of the AC3 frame here; presumably
     
    270272    // ignore, and if so, may as well just assume that it will ignore
    271273    // anything with a bad CRC...
    272274
    273     uint nr_samples = 0, block_len;
     275    uint nr_samples = 0, block_len = 0;
     276   
    274277    if (dts)
    275278    {
    276279        enc_len = dts_syncinfo(payload, &flags, &sample_rate, &bit_rate);
     
    305308#endif
    306309    }
    307310
    308     if (enc_len == 0 || enc_len > len)
    309     {
    310         int l = len;
    311         len = 0;
    312         return l;
    313     }
    314 
    315311    enc_len = std::min((uint)enc_len, block_len - 8);
    316312
    317313    //uint32_t x = *(uint32_t*)payload;
     
    364360    data[6] = (enc_len << 3) & 0xFF;
    365361    data[7] = (enc_len >> 5) & 0xFF;
    366362    memset(payload + enc_len, 0, block_len - 8 - enc_len);
    367     len = block_len;
    368363
    369364    return enc_len;
    370365}
    371366
    372367// must have exactly 1 frames worth of data
    373 size_t AudioOutputDigitalEncoder::Encode(short *buff)
     368size_t AudioOutputDigitalEncoder::Encode(void *buf, int len)
    374369{
    375     int encsize = 0;
    376370    size_t outsize = 0;
    377371 
    378     // put data in the correct spot for encode frame
    379     outsize = avcodec_encode_audio(
    380         av_context, ((uchar*)outbuf) + 8, outbuf_size - 8, buff);
     372    int fs = FrameSize();
     373    memcpy(inbuf+inbuflen, buf, len);
     374    inbuflen += len;
     375    int frames = inbuflen / fs;
    381376
    382     size_t tmpsize = outsize;
     377    while (frames--)
     378    {
     379        if (reorder)
     380            reorder_6ch_ac3(inbuf, fs);
     381       
     382        // put data in the correct spot for encode frame
     383        outsize = avcodec_encode_audio(
     384            av_context, ((uchar*)outbuf) + outbuflen + 8, OUTBUFSIZE - 8, (short int *)inbuf);
     385       
     386        encode_frame(
     387            /*av_context->codec_id==CODEC_ID_DTS*/ false,
     388            (unsigned char*)outbuf + outbuflen, outsize
     389        );
    383390
    384     outsize = MAX_AC3_FRAME_SIZE;
    385     encsize = encode_frame(
    386         /*av_context->codec_id==CODEC_ID_DTS*/ false,
    387         (unsigned char*)outbuf, outsize);
     391        outbuflen += MAX_AC3_FRAME_SIZE;
     392        inbuflen -= fs;
     393        memmove(inbuf, inbuf+fs, inbuflen);
     394    }
     395 
     396    return outbuflen;
     397}
    388398
    389     VERBOSE(VB_AUDIO+VB_TIMESTAMP,
    390             QString("DigitalEncoder::Encode len1=%1 len2=%2 finallen=%3")
    391                 .arg(tmpsize).arg(encsize).arg(outsize));
    392 
    393     return outsize;
     399void AudioOutputDigitalEncoder::GetFrames(void *ptr, int maxlen)
     400{
     401    int len = (maxlen < outbuflen ? maxlen : outbuflen);
     402    memcpy(ptr, outbuf, len);
     403    outbuflen -= len;
     404    memmove(outbuf, outbuf+len, outbuflen);
    394405}
  • mythtv/libs/libmyth/audiooutput.h

     
    6868   
    6969    virtual void bufferOutputData(bool y) = 0;
    7070    virtual int readOutputData(unsigned char *read_buffer, int max_length) = 0;
     71    virtual bool ToggleUpmix(void) = 0;
    7172
    7273  protected:
    7374    void Error(const QString &msg);
  • mythtv/libs/libmyth/audiooutputdigitalencoder.h

     
    55#include "libavcodec/avcodec.h"
    66};
    77
     8#define INBUFSIZE 131072
     9#define OUTBUFSIZE 98304
     10
    811class AudioOutputDigitalEncoder
    912{
    1013  public:
    1114    AudioOutputDigitalEncoder(void);
    1215    ~AudioOutputDigitalEncoder();
    1316
    14     bool   Init(CodecID codec_id, int bitrate, int samplerate, int channels);
     17    bool   Init(CodecID codec_id, int bitrate, int samplerate,
     18                int channels, bool reencoding);
    1519    void   Dispose(void);
    16     size_t Encode(short * buff);
    17 
    18     inline char *GetFrameBuffer(void);
     20    size_t Encode(void *buf, int len);
     21    void   GetFrames(void *ptr, int maxlen);
    1922    size_t FrameSize(void)  const { return one_frame_bytes; }
    20     char  *GetOutBuff(void) const { return outbuf;          }
     23    int    Buffered(void) const { return inbuflen; }
    2124
    2225  public:
    2326    size_t audio_bytes_per_sample;
    2427
    2528  private:
    2629    AVCodecContext *av_context;
    27     char           *outbuf;
    28     int             outbuf_size;
    29     char           *frame_buffer;
     30    char            outbuf[OUTBUFSIZE];
     31    char            inbuf[INBUFSIZE];
     32    int             outbuflen;
     33    int             inbuflen;
    3034    size_t          one_frame_bytes;
     35    bool            reorder;
    3136};
    3237
    33 inline char *AudioOutputDigitalEncoder::GetFrameBuffer(void)
    34 {
    35     if (!frame_buffer && av_context)
    36         frame_buffer = new char [one_frame_bytes];
    37 
    38     return frame_buffer;
    39 }
    40 
    4138#endif
  • mythtv/libs/libmyth/audiooutputalsa.h

     
    6767    virtual int  GetBufferedOnSoundcard(void) const;
    6868
    6969  private:
     70    void SetIECStatus(bool audio);
    7071    inline int SetParameters(snd_pcm_t *handle,
    7172                             snd_pcm_format_t format, unsigned int channels,
    7273                             unsigned int rate, unsigned int buffer_time,
  • mythtv/libs/libmythfreesurround/el_processor.cpp

     
    4040
    4141const float PI = 3.141592654;
    4242const float epsilon = 0.000001;
    43 //const float center_level = 0.5*sqrt(0.5);   // gain of the center channel
    44 //const float center_level = sqrt(0.5);   // gain of the center channel
    45 const float center_level = 1.0;   // gain of the center channel
    46 //const float center_level = 0.5;   // gain of the center channel
     43const float center_level = 0.5*sqrt(0.5);
    4744
    48 // should be .6-.7
    49 // but with centerlevel 2x what its supposed to be, we halve 0.68
    50 // to keep center from clipping
    51 //const float window_gain = 0.34;     
    52 //const float window_gain = 0.68;     
    53 const float window_gain = 0.95;     // to prive a bit of margin
    54 
    5545// private implementation of the surround decoder
    5646class decoder_impl {
    5747public:
     
    9888            outbuf[c].resize(N);
    9989            filter[c].resize(N);
    10090        }
    101         // DC component of filters is always 0
    102         for (unsigned c=0;c<5;c++)
    103         {
    104             filter[c][0] = 0.0;
    105             filter[c][1] = 0.0;
    106             filter[c][halfN] = 0.0;
    107         }
    10891        sample_rate(48000);
    10992        // generate the window function (square root of hann, b/c it is applied before and after the transform)
    11093        wnd.resize(N);
    111         // dft normalization included in the window for zero cost scaling
    112         // also add a gain factor of *2 due to processing gain in algo (see center_level)
    113         surround_gain(1.0);
     94        for (unsigned k=0;k<N;k++)
     95            wnd[k] = sqrt(0.5*(1-cos(2*PI*k/N))/N);
    11496        current_buf = 0;
    11597        // set the default coefficients
    11698        surround_coefficients(0.8165,0.5774);
     
    192174    // set lfe filter params
    193175    void sample_rate(unsigned int srate) {
    194176        // lfe filter is just straight through band limited
    195         unsigned int cutoff = (250*N)/srate;
     177        unsigned int cutoff = (30*N)/srate;
    196178        for (unsigned f=0;f<=halfN;f++) {           
    197             if ((f>=2) && (f<cutoff))
    198                 filter[5][f] = 1.0;
     179            if (f<cutoff)
     180                filter[5][f] = 0.5*sqrt(0.5);
    199181            else
    200182                filter[5][f] = 0.0;
    201183        }
     
    214196        E = (o+v)*n; F = (o+u)*n; G = (o-v)*n;  H = (o-u)*n;
    215197    }
    216198
    217     void surround_gain(float gain) {
    218         master_gain = gain * window_gain * 0.5 * 0.25;
    219         for (unsigned k=0;k<N;k++)
    220             wnd[k] = sqrt(master_gain*(1-cos(2*PI*k/N))/N);
    221     }
    222 
    223199    // set the phase shifting mode
    224200    void phase_mode(unsigned mode) {
    225201        const float modes[4][2] = {{0,0},{0,PI},{PI,0},{-PI/2,PI/2}};
     
    290266
    291267        // 2. compare amplitude and phase of each DFT bin and produce the X/Y coordinates in the sound field
    292268        //    but dont do DC or N/2 component
    293         for (unsigned f=2;f<halfN;f++) {           
     269        for (unsigned f=0;f<halfN;f++) {           
    294270            // get left/right amplitudes/phases
    295271            float ampL = amplitude(dftL[f]), ampR = amplitude(dftR[f]);
    296272            float phaseL = phase(dftL[f]), phaseR = phase(dftR[f]);
     
    305281            phaseDiff = abs(phaseDiff);
    306282
    307283            if (linear_steering) {
    308 /*              cfloat w = polar(sqrt(ampL*ampL+ampR*ampR), (phaseL+phaseR)/2);
    309                 cfloat lt = cfloat(dftL[f][0],dftL[f][1])/w, rt = cfloat(dftR[f][0],dftR[f][1])/w;              */
    310 //              xfs[f] = -(C*(rt-H) - B*E + F*A + G*(D-lt)) / (G*A - C*E).real();
    311 //              yfs[f] = (rt - (xfs[f]*E+H))/(F+xfs[f]*G);
    312 
    313                 /*
    314                 Problem:
    315                 This assumes that the values are interpolated linearly between the cardinal points.
    316                 But this way we have no chance of knowing the average volume...
    317                 - Can we solve that computing everything under the assumption of normalized volume?
    318                   No. Seemingly not.
    319                 - Maybe we should add w explitcitly into the equation and see if we can solve it...
    320                 */
    321 
    322 
    323                 //cfloat lt(0.5,0),rt(0.5,0);
    324                 //cfloat x(0,0), y(1,0);
    325                 /*cfloat p = (C*(rt-H) - B*E + F*A + G*(D-lt)) / (G*A - C*E);
    326                 cfloat q = B*(rt+H) + F*(D-lt) / (G*A - C*E);
    327                 cfloat s = sqrt(p*p/4.0f - q);
    328                 cfloat x = -p;
    329                 cfloat x1 = -p/2.0f + s;
    330                 cfloat x2 = -p/2.0f - s;
    331                 float x = 0;
    332                 if (x1.real() >= -1 && x1.real() <= 1)
    333                     x = x1.real();
    334                 else if (x2.real() >= -1 && x2.real() <= 1)
    335                     x = x2.real();*/
    336 
    337                 //cfloat yp = (rt - (x*E+H))/(F+x*G);
    338                 //cfloat xp = (lt - (y*B+D))/(A+y*C);
    339 
    340                 /*xfs[f] = x;
    341                 yfs[f] = y.real();*/
    342 
    343284                // --- this is the fancy new linear mode ---
    344285
    345286                // get sound field x/y position
     
    597538    float surround_high,surround_low;  // high and low surround mixing coefficient (e.g. 0.8165/0.5774)
    598539    float surround_balance;            // the xfs balance that follows from the coeffs
    599540    float surround_level;              // gain for the surround channels (follows from the coeffs
    600     float master_gain;                 // gain for all channels
    601541    float phase_offsetL, phase_offsetR;// phase shifts to be applied to the rear channels
    602542    float front_separation;            // front stereo separation
    603543    float rear_separation;             // rear stereo separation
     
    625565
    626566void fsurround_decoder::surround_coefficients(float a, float b) { impl->surround_coefficients(a,b); }
    627567
    628 void fsurround_decoder::gain(float gain) { impl->surround_gain(gain); }
    629 
    630568void fsurround_decoder::phase_mode(unsigned mode) { impl->phase_mode(mode); }
    631569
    632570void fsurround_decoder::steering_mode(bool mode) { impl->steering_mode(mode); }
  • mythtv/libs/libmythfreesurround/freesurround.cpp

     
    6363const unsigned default_block_size = 8192;
    6464// there will be a slider for this in the future
    6565//const float master_gain = 1.0;
    66 //#define MASTER_GAIN * master_gain
     66//#define MASTER_GAIN * master_gain 
    6767#define MASTER_GAIN
    68 //const float master_gain = 1.0/(1<<15);
    69 //const float inv_master_gain = (1<<15);
     68//const float inv_master_gain = 1.0;
    7069//#define INV_MASTER_GAIN * inv_master_gain
    7170#define INV_MASTER_GAIN
    7271
     
    192191    if (moviemode)
    193192    {
    194193        params.phasemode = 1;
    195         params.center_width = 0;
    196         params.gain = 1.0;
     194        params.center_width = 25;
     195        params.dimension = 0.5;
    197196    }
    198197    else
    199198    {
    200         params.center_width = 70;
    201         // for 50, gain should be about 1.9, c/lr about 2.7
    202         // for 70, gain should be about 3.1, c/lr about 1.5
    203         params.gain = 3.1;
     199        params.center_width = 65;
     200        params.dimension = 0.3;
    204201    }
    205202    switch (surround_mode)
    206203    {
     
    236233        decoder->phase_mode(params.phasemode);
    237234        decoder->surround_coefficients(params.coeff_a, params.coeff_b);                         
    238235        decoder->separation(params.front_sep/100.0,params.rear_sep/100.0);
    239         decoder->gain(params.gain);
    240236    }
    241237}
    242238
     
    250246    phasemode(0),
    251247    steering(1),
    252248    front_sep(100),
    253     rear_sep(100),
    254     gain(1.0)
     249    rear_sep(100)
    255250{
    256251}
    257252
     
    655650    {
    656651        if (decoder)
    657652        {
    658             // actually these params need only be set when they change... but it doesn't hurt
    659 #if 0
    660             decoder->steering_mode(params.steering);
    661             decoder->phase_mode(params.phasemode);
    662             decoder->surround_coefficients(params.coeff_a, params.coeff_b);                             
    663             decoder->separation(params.front_sep/100.0,params.rear_sep/100.0);
    664 #endif
    665             // decode the bufs->block
    666             //decoder->decode(input,output,params.center_width/100.0,params.dimension/100.0);
    667             //decoder->decode(output,params.center_width/100.0,params.dimension/100.0);
    668653            decoder->decode(params.center_width/100.0,params.dimension/100.0);
    669654        }
    670655    }
  • mythtv/libs/libmythfreesurround/el_processor.h

     
    4747        //  a is the coefficient of left rear in left total, b is the coefficient of left rear in right total; the same is true for right.
    4848        void surround_coefficients(float a, float b);
    4949
    50         // override for master surround gain
    51         void gain(float gain);
    52 
    5350        // set the phase shifting mode for decoding
    5451        // 0 = (+0°,+0°)   - music mode
    5552        // 1 = (+0°,+180°) - PowerDVD compatibility
  • mythtv/programs/mythfrontend/globalsettings.cpp

     
    119119    return gc;
    120120}
    121121
     122static HostComboBox *SRCQuality()
     123{
     124    HostComboBox *gc = new HostComboBox("SRCQuality", false);
     125    gc->setLabel(QObject::tr("Sample Rate Conversion"));
     126    gc->addSelection(QObject::tr("Best"), "3", true); // default
     127    gc->addSelection(QObject::tr("Medium"), "2");
     128    gc->addSelection(QObject::tr("Fastest"), "1");
     129    gc->addSelection(QObject::tr("Disabled"), "0");
     130    gc->setHelpText(
     131            QObject::tr(
     132                "Set the quality of audio sample rate conversion. "
     133                "This only affects non 48000Hz PCM audio. "
     134                "All three options offer a worst-case SNR of 97dB. "
     135                "'Best' at a bandwidth of 97%. "
     136                "'Medium' at a bandwidth of 90%. "
     137                "'Fastest' at a bandwidth of 80%. "
     138                "Set 'Disabled' only if you know what you are doing."));
     139    return gc;
     140}
     141
     142
    122143static HostComboBox *PassThroughOutputDevice()
    123144{
    124145    HostComboBox *gc = new HostComboBox("PassThruOutputDevice", true);
     
    34423463
    34433464        addChild(MaxAudioChannels());
    34443465        addChild(AudioUpmixType());
     3466        addChild(SRCQuality());
    34453467
    34463468        // General boolean settings
    34473469        addChild(AC3PassThrough());
  • mythtv/programs/mythtranscode/transcode.cpp

     
    221221        // Do nothing
    222222        return kMuteOff;
    223223    }
     224    virtual bool ToggleUpmix(void)
     225    {
     226        // Do nothing
     227        return false;
     228    }
    224229
    225230    //  These are pure virtual in AudioOutput, but we don't need them here
    226231    virtual void bufferOutputData(bool){ return; }