Attachment #182055 for bug #259009




    virtual void Reconfigure(int audio_bits, 
                             int audio_channels, 
                             int audio_samplerate,
                             bool audio_passthru) = 0;
                             void* audio_codec = NULL) = 0;
    
    virtual void SetStretchFactor(float factor);
    virtual float GetStretchFactor(void) { return 1.0f; }
    virtual bool ToggleUpmix(void) = 0;

    // do AddSamples calls block?
    virtual void SetBlocking(bool blocking) = 0;




AudioOutputALSA::~AudioOutputALSA()
{
    KillAudio();
    SetIECStatus(true);
}

void AudioOutputALSA::SetIECStatus(bool audio) {
    
    snd_ctl_t *ctl;
    const char *spdif_str = SND_CTL_NAME_IEC958("", PLAYBACK, DEFAULT);
    int spdif_index = -1;
    snd_ctl_elem_list_t *clist;
    snd_ctl_elem_id_t *cid;
    snd_ctl_elem_value_t *cval;
    snd_aes_iec958_t iec958;
    int cidx, controls;

    VERBOSE(VB_AUDIO, QString("Setting IEC958 status: %1")
                      .arg(audio ? "audio" : "non-audio"));
    
    snd_ctl_open(&ctl, "default", 0);
    snd_ctl_elem_list_alloca(&clist);
    snd_ctl_elem_list(ctl, clist);
    snd_ctl_elem_list_alloc_space(clist, snd_ctl_elem_list_get_count(clist));
    snd_ctl_elem_list(ctl, clist);
    controls = snd_ctl_elem_list_get_used(clist);
    for (cidx = 0; cidx < controls; cidx++) 
    {
        if (!strcmp(snd_ctl_elem_list_get_name(clist, cidx), spdif_str))
            if (spdif_index < 0 ||
                snd_ctl_elem_list_get_index(clist, cidx) == (uint)spdif_index)
                    break;
    }

    if (cidx >= controls)
        return;

    snd_ctl_elem_id_alloca(&cid);
    snd_ctl_elem_list_get_id(clist, cidx, cid);
    snd_ctl_elem_value_alloca(&cval);
    snd_ctl_elem_value_set_id(cval, cid);
    snd_ctl_elem_read(ctl,cval);
    snd_ctl_elem_value_get_iec958(cval, &iec958);
    
    if (!audio) 
        iec958.status[0] |= IEC958_AES0_NONAUDIO;
    else
        iec958.status[0] &= ~IEC958_AES0_NONAUDIO;

    snd_ctl_elem_value_set_iec958(cval, &iec958);
    snd_ctl_elem_write(ctl, cval);

}

bool AudioOutputALSA::OpenDevice()

    snd_pcm_format_t format;
    unsigned int buffer_time, period_time;
    int err;
    QString real_device;

    if (pcm_handle != NULL)
        CloseDevice();

    pcm_handle = NULL;
    numbadioctls = 0;
    
    if (audio_passthru || audio_enc)
    {
        real_device = audio_passthru_device;
        SetIECStatus(false);
    }
    else 
    {
        real_device = audio_main_device;
        SetIECStatus(true);
    }

    VERBOSE(VB_GENERAL, QString("Opening ALSA audio device '%1'.")
            .arg(real_device));

Lines 37-42 Link Here

(-)a/libs/libmyth/audiooutputalsa.h (+1 lines)
37	virtual inline int getBufferedOnSoundcard(void);	37	virtual inline int getBufferedOnSoundcard(void);
38		38
39	private:	39	private:
		40	void SetIECStatus(bool audio);
40	inline int SetParameters(snd_pcm_t *handle,	41	inline int SetParameters(snd_pcm_t *handle,
41	snd_pcm_format_t format, unsigned int channels,	42	snd_pcm_format_t format, unsigned int channels,
42	unsigned int rate, unsigned int buffer_time,	43	unsigned int rate, unsigned int buffer_time,





    audio_main_device(QDeepCopy<QString>(laudio_main_device)),
    audio_passthru_device(QDeepCopy<QString>(laudio_passthru_device)),
    audio_passthru(false),      audio_enc(false),
    audio_reenc(false),         audio_stretchfactor(1.0f),

    audio_codec(NULL),
    source(lsource),            killaudio(false),

    pauseaudio(false),          audio_actually_paused(false),

    pSoundStretch(NULL),        
    encoder(NULL),
    upmixer(NULL),

    source_audio_channels(-1),
    source_audio_samplerate(0),
    source_audio_bytes_per_sample(0),
    needs_upmix(false),
    surround_mode(FreeSurround::SurroundModePassive),
    old_audio_stretchfactor(1.0),

    blocking(false),


    memset(&audiotime_updated, 0, sizeof(audiotime_updated));
    memset(audiobuffer,        0, sizeof(char)  * AUDBUFSIZE);
    configured_audio_channels = gContext->GetNumSetting("MaxChannels", 2);
    orig_config_channels = configured_audio_channels;
    allow_ac3_passthru = gContext->GetNumSetting("AC3PassThru", false);
    src_quality = gContext->GetNumSetting("SRCQuality", 2);

    // You need to call Reconfigure from your concrete class.
    // Reconfigure(laudio_bits,       laudio_channels,

            VERBOSE(VB_GENERAL, LOC + QString("Using time stretch %1")
                                        .arg(audio_stretchfactor));
            pSoundStretch = new soundtouch::SoundTouch();
            pSoundStretch->setSampleRate(audio_samplerate);
            pSoundStretch->setChannels(upmixer ? 
                configured_audio_channels : source_audio_channels);
                {
                    VERBOSE(VB_AUDIO, LOC +
                            QString("Creating Encoder for codec %1 origfs %2")
                            .arg(audio_codec->codec_id)
                            .arg(audio_codec->frame_size));

                    encoder = new AudioOutputDigitalEncoder();
                    if (!encoder->Init(audio_codec->codec_id,
                                audio_codec->bit_rate,
                                audio_codec->sample_rate,
                                audio_codec->channels
                                ))
                    {
                        // eeks
                        delete encoder;
                        encoder = NULL;
                        VERBOSE(VB_AUDIO, LOC +
                                QString("Failed to Create Encoder"));
                    }
                }
            }
            if (audio_codec && encoder)
            {
                pSoundStretch->setSampleRate(audio_codec->sample_rate);
                pSoundStretch->setChannels(audio_codec->channels);
            }
            else
            {
                pSoundStretch->setSampleRate(audio_samplerate);
                pSoundStretch->setChannels(audio_channels);
            }

            pSoundStretch->setTempo(audio_stretchfactor);
            pSoundStretch->setSetting(SETTING_SEQUENCE_MS, 35);

            // dont need these with only tempo change
            //pSoundStretch->setPitch(1.0);
            //pSoundStretch->setRate(1.0);

            //pSoundStretch->setSetting(SETTING_USE_QUICKSEEK, true);
            //pSoundStretch->setSetting(SETTING_USE_AA_FILTER, false);
        }

    return audio_stretchfactor;
}

bool AudioOutputBase::ToggleUpmix(void)
{
    if (orig_config_channels == 2 || audio_passthru)
        return false;
    if (configured_audio_channels == 6)
        configured_audio_channels = 2;
    else
        configured_audio_channels = 6;
    
    Reconfigure(audio_bits, source_audio_channels, 
        source_audio_samplerate, audio_passthru);
    return (configured_audio_channels == 6);
}

void AudioOutputBase::Reconfigure(int laudio_bits, int laudio_channels, 
                                  int laudio_samplerate, bool laudio_passthru)
                                  void *laudio_codec)
{
    int codec_id = CODEC_ID_NONE;
    int lcodec_id = CODEC_ID_NONE;
    int lcchannels = 0;
    int cchannels = 0;
    int lsource_audio_channels = laudio_channels;
    bool lneeds_upmix = false;
    bool laudio_reenc = false;
   
    // Are we perhaps reencoding a (previously) timestretched bitstream?
    if (laudio_channels > 2 && !laudio_passthru)
        laudio_reenc = true;
  
    // Enough channels? Upmix if not
    if (laudio_channels < configured_audio_channels && !laudio_passthru)
        lcchannels = ((AVCodecContext*)laudio_codec)->channels;
    }

    if (audio_codec)
    {
        codec_id = audio_codec->codec_id;
        cchannels = ((AVCodecContext*)audio_codec)->channels;
    }

    if ((configured_audio_channels == 6) && 
        !(laudio_codec || audio_codec))
    {
        laudio_channels = configured_audio_channels;
        lneeds_upmix = true;

        laudio_samplerate == audio_samplerate && !need_resampler &&
        laudio_passthru == audio_passthru &&
        lneeds_upmix == needs_upmix &&
        laudio_reenc == audio_reenc);
    bool upmix_deps =
        (lsource_audio_channels == source_audio_channels);
    if (general_deps && upmix_deps)

    waud = raud = 0;
    audio_actually_paused = false;
    
    bool redo_stretch = (pSoundStretch && audio_channels != laudio_channels);
    audio_channels = laudio_channels;
    source_audio_channels = lsource_audio_channels;
    audio_bits = laudio_bits;
    source_audio_samplerate = audio_samplerate = laudio_samplerate;
    audio_reenc = laudio_reenc;
    audio_passthru = laudio_passthru;
    needs_upmix = lneeds_upmix;


        Error("AudioOutput only supports 8 or 16bit audio.");
        return;
    }
    audio_bytes_per_sample = audio_channels * audio_bits / 8;
    source_audio_bytes_per_sample = source_audio_channels * audio_bits / 8;
    
    need_resampler = false;
    killaudio = false;

    internal_vol = gContext->GetNumSetting("MythControlsVolume", 0);
    
    numlowbuffer = 0;
    
    // Encode to AC-3 if not passing thru, there's more than 2 channels
    // and we're allowed to passthru AC-3
    // This won't reencode timestretched 2ch AC-3 but there's no point doing so
    if (!audio_passthru && audio_channels > 2 && allow_ac3_passthru) 
    {
        VERBOSE(VB_AUDIO, LOC + "Creating AC-3 Encoder");
        int srate = src_quality == 0 ? audio_samplerate : 48000;
        encoder = new AudioOutputDigitalEncoder();
        if (!encoder->Init(CODEC_ID_AC3, 448000, srate, 
                           audio_channels, audio_reenc)) 
        {
            VERBOSE(VB_AUDIO, LOC + "Can't create AC-3 encoder");
            delete encoder;
            encoder = NULL;
        }
        
        audio_enc = true;
    }        
    
    if(audio_passthru || audio_enc)
        // AC-3 output - soundcard expects a 2ch 48k stream
	audio_channels = 2;
    
    audio_bytes_per_sample = audio_channels * audio_bits / 8;
    source_audio_bytes_per_sample = source_audio_channels * audio_bits / 8;

    // Always resample to 48k - many cards can't do anything else
    // and ALSA will do it with linear interpolation (yuk) if we don't anyway
    if (src_quality != 0 && audio_samplerate != 48000)
    {
        int error;
        audio_samplerate = 48000;
        VERBOSE(VB_GENERAL, LOC + QString("Using resampler. From: %1 to %2")
            .arg(laudio_samplerate).arg(audio_samplerate));
        src_ctx = src_new(3-src_quality, audio_channels, &error);
        if (error)
        {
            Error(QString("Error creating resampler, the error was: %1")
                  .arg(src_strerror(error)) );
            pthread_mutex_unlock(&avsync_lock);
            pthread_mutex_unlock(&audio_buflock);
	    src_ctx = NULL;
            return;
        }
        src_data.src_ratio = (double) audio_samplerate / laudio_samplerate;
        src_data.data_in = src_in;
        src_data.data_out = src_out;
        src_data.output_frames = 16384*6;
        need_resampler = true;
    }
    
    VERBOSE(VB_GENERAL, QString("Opening audio device '%1'. ch %2(%3) sr %4")
            .arg(audio_main_device).arg(audio_channels)
            .arg(source_audio_channels).arg(audio_samplerate));

    current_seconds = -1;
    source_bitrate = -1;

    // NOTE: this won't do anything as above samplerate vars are set equal
    // Check if we need the resampler
    if (audio_samplerate != laudio_samplerate)
    {
        int error;
        VERBOSE(VB_GENERAL, LOC + QString("Using resampler. From: %1 to %2")
                               .arg(laudio_samplerate).arg(audio_samplerate));
        src_ctx = src_new (SRC_SINC_BEST_QUALITY, audio_channels, &error);
        if (error)
        {
            Error(QString("Error creating resampler, the error was: %1")
                  .arg(src_strerror(error)) );
            pthread_mutex_unlock(&avsync_lock);
            pthread_mutex_unlock(&audio_buflock);
            return;
        }
        src_data.src_ratio = (double) audio_samplerate / laudio_samplerate;
        src_data.data_in = src_in;
        src_data.data_out = src_out;
        src_data.output_frames = 16384*6;
        need_resampler = true;
    }

    if (needs_upmix)
    {
        VERBOSE(VB_AUDIO, LOC + QString("create upmixer"));
        if (configured_audio_channels == 6)
        {
            surround_mode = gContext->GetNumSetting("AudioUpmixType", 2);

            (FreeSurround::SurroundMode)surround_mode);

        VERBOSE(VB_AUDIO, LOC +
                QString("Create upmixer done with surround mode %1")
                .arg(surround_mode));
    }

    VERBOSE(VB_AUDIO, LOC + QString("Audio Stretch Factor: %1")
            .arg(audio_stretchfactor));
    VERBOSE(VB_AUDIO, QString("Audio Codec Used: %1")
            .arg((audio_codec) ?
                 codec_id_string(audio_codec->codec_id) : "not set"));

    SetStretchFactorLocked(old_audio_stretchfactor);
    {
        float laudio_stretchfactor = audio_stretchfactor;
        delete pSoundStretch;
        pSoundStretch = NULL;
        audio_stretchfactor = 0.0f;
        SetStretchFactorLocked(laudio_stretchfactor);
    }
    else
    {
        SetStretchFactorLocked(audio_stretchfactor);
        if (pSoundStretch)
        {
            // if its passthru then we need to reencode
            if (audio_codec)
            {
                if (!encoder)
                {
                    VERBOSE(VB_AUDIO, LOC +
                            QString("Creating Encoder for codec %1")
                            .arg(audio_codec->codec_id));

                    encoder = new AudioOutputDigitalEncoder();
                    if (!encoder->Init(audio_codec->codec_id,
                                audio_codec->bit_rate,
                                audio_codec->sample_rate,
                                audio_codec->channels
                                ))
                    {
                        // eeks
                        delete encoder;
                        encoder = NULL;
                        VERBOSE(VB_AUDIO, LOC + "Failed to Create Encoder");
                    }
                }
            }
            if (audio_codec && encoder)
            {
                pSoundStretch->setSampleRate(audio_codec->sample_rate);
                pSoundStretch->setChannels(audio_codec->channels);
            }
            else
            {
                pSoundStretch->setSampleRate(audio_samplerate);
                pSoundStretch->setChannels(audio_channels);
            }
        }
    }

    // Setup visualisations, zero the visualisations buffers
    prepareVisuals();

    VERBOSE(VB_AUDIO, LOC + "Killing AudioOutputDSP");
    killaudio = true;
    StopOutputThread();
    
    pthread_mutex_lock(&audio_buflock);

    // Close resampler?
    if (src_ctx)
    {
        src_delete(src_ctx);
        src_ctx = NULL;
    }
		
    need_resampler = false;

    // close sound stretcher

    {
        delete pSoundStretch;
        pSoundStretch = NULL;
        old_audio_stretchfactor = audio_stretchfactor;
        audio_stretchfactor = 1.0;
    }

    if (encoder)

        upmixer = NULL;
    }
    needs_upmix = false;
    audio_enc = false;

    CloseDevice();

    pthread_mutex_unlock(&audio_buflock);
    killAudioLock.unlock();
}


    ret += (now.tv_usec - audiotime_updated.tv_usec) / 1000;
    ret = (long long)(ret * audio_stretchfactor);

#if 1
    VERBOSE(VB_AUDIO|VB_TIMESTAMP, 
            QString("GetAudiotime now=%1.%2, set=%3.%4, ret=%5, audt=%6 sf=%7")
            .arg(now.tv_sec).arg(now.tv_usec)

            .arg(audiotime)
            .arg(audio_stretchfactor)
           );
#endif

    ret += audiotime;


 
    soundcard_buffer = getBufferedOnSoundcard(); // bytes
    totalbuffer = audiolen(false) + soundcard_buffer;

    // include algorithmic latencies
    if (pSoundStretch)
    {
        // add the effect of any unused but processed samples,
        // AC3 reencode does this
        totalbuffer += (int)(pSoundStretch->numSamples() *
                             audio_bytes_per_sample);
        // add the effect of unprocessed samples in time stretch algo
        totalbuffer += (int)((pSoundStretch->numUnprocessedSamples() *
                              audio_bytes_per_sample) / audio_stretchfactor);
    }

    if (upmixer && needs_upmix)
    {
        totalbuffer += upmixer->sampleLatency() * audio_bytes_per_sample;

    if (encoder) 
        totalbuffer += encoder->Buffered();

    audiotime = audbuf_timecode - (int)(totalbuffer * 100000.0 /
                                   (audio_bytes_per_sample * effdspstretched));
 
    gettimeofday(&audiotime_updated, NULL);
    
    VERBOSE(VB_AUDIO|VB_TIMESTAMP, 
            QString("SetAudiotime set=%1.%2, audt=%3 atc=%4 "
                    "tb=%5 sb=%6 eds=%7 abps=%8 sf=%9")

            .arg(effdspstretched)
            .arg(audio_bytes_per_sample)
            .arg(audio_stretchfactor));
#endif

    pthread_mutex_unlock(&avsync_lock);
    pthread_mutex_unlock(&audio_buflock);

    int abps = (encoder) ?
        encoder->audio_bytes_per_sample : audio_bytes_per_sample;
    int len = samples * abps;
 
    // Check we have enough space to write the data
    if (need_resampler && src_ctx)
        len = (int)ceilf(float(len) * src_data.src_ratio);


        return false; // would overflow
    }
    
    pthread_mutex_lock(&audio_buflock);

    // resample input if necessary
    if (need_resampler && src_ctx) 

        // Call our function to do the work
        _AddSamples(buffers, false, samples, timecode);
    }
    
    pthread_mutex_unlock(&audio_buflock);

    return true;
}

    int abps = (encoder) ?
        encoder->audio_bytes_per_sample : audio_bytes_per_sample;
    int len = samples * abps;
 
    // Give original samples to mythmusic visualisation
    dispatchVisual((unsigned char *)buffer, len, timecode,
                   source_audio_channels, audio_bits);

    // Check we have enough space to write the data
    if (need_resampler && src_ctx)

                .arg(timecode)); 
        return false; // would overflow
    }
    
    pthread_mutex_lock(&audio_buflock);

    // resample input if necessary
    if (need_resampler && src_ctx) 

        // Call our function to do the work
        _AddSamples(buffer, true, samples, timecode);
    }
    
    pthread_mutex_unlock(&audio_buflock);

    return true;
}

            if (src_ctx) 
            {
                int error = src_reset(src_ctx);
                if (error) 
                {
                    VERBOSE(VB_IMPORTANT, LOC_ERR + QString(
                            "Error occured while resetting resampler: %1")
                            .arg(src_strerror(error)));
                    src_ctx = NULL;
                }
            }
        }
    }

void AudioOutputBase::_AddSamples(void *buffer, bool interleaved, int samples, 
                                  long long timecode)
{
    pthread_mutex_lock(&audio_buflock);

    int len; // = samples * audio_bytes_per_sample;
    int audio_bytes = audio_bits / 8;
    int org_waud = waud;

            .arg(samples * abps)
            .arg(AUDBUFSIZE-afree).arg(afree).arg(timecode)
            .arg(needs_upmix));

    len = WaitForFreeSpace(samples);
    
    if (upmixer && needs_upmix)
    {
        int out_samples = 0;
        org_waud = waud;
        int step = (interleaved)?source_audio_channels:1;
	
        for (int itemp = 0; itemp < samples; )
        {
            // just in case it does a processing cycle, release the lock
            // to allow the output loop to do output
            pthread_mutex_unlock(&audio_buflock);
            if (audio_bytes == 2)
            {
                itemp += upmixer->putSamples(

                    source_audio_channels,
                    (interleaved) ? 0 : samples);
            }
            pthread_mutex_lock(&audio_buflock);

            int copy_samples = upmixer->numSamples();
            if (copy_samples)

                        (short*)(audiobuffer), (copy_samples - bdiff_samples));
                }
                else
                {
                    upmixer->receiveSamples(
                        (short*)(audiobuffer + org_waud), copy_samples);
                
                org_waud = (org_waud + copy_len) % AUDBUFSIZE;
            }
        }

    }
    else
    {
        len = WaitForFreeSpace(samples);

        if (interleaved) 
        {
            char *mybuf = (char*)buffer;

            }
        }
    }
    
    if (samples <= 0)
        return;
    
    if (pSoundStretch)
    {
        // does not change the timecode, only the number of samples
        // back to orig pos
        org_waud = waud;
        int bdiff = AUDBUFSIZE - org_waud;
        int nSamplesToEnd = bdiff/abps;
        if (bdiff < len)
        {
            pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)
                                      (audiobuffer + 
                                       org_waud), nSamplesToEnd);
            pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)audiobuffer,
                                      (len - bdiff) / abps);
        }
        else
            pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)
                                      (audiobuffer + org_waud),
                                      len / abps);
            {
                pSoundStretch->putSamples((soundtouch::SAMPLETYPE*)
                                          (audiobuffer + org_waud),
                                          len / abps);
            }

            if (encoder)
            {
                // pull out a packet's worth and reencode it until we
                // don't have enough for any more packets
                soundtouch::SAMPLETYPE *temp_buff = 
                    (soundtouch::SAMPLETYPE*)encoder->GetFrameBuffer();
                size_t frameSize = encoder->FrameSize()/abps;

                VERBOSE(VB_AUDIO|VB_TIMESTAMP,
                        QString("_AddSamples Enc sfs=%1 bfs=%2 sss=%3")
                        .arg(frameSize)
                        .arg(encoder->FrameSize())
                        .arg(pSoundStretch->numSamples()));

                // process the same number of samples as it creates
                // a full encoded buffer just like before
                while (pSoundStretch->numSamples() >= frameSize)
                {
                    int got = pSoundStretch->receiveSamples(
                        temp_buff, frameSize);
                    int amount = encoder->Encode(temp_buff);

                    VERBOSE(VB_AUDIO|VB_TIMESTAMP, 
                            QString("_AddSamples Enc bytes=%1 got=%2 left=%3")
                            .arg(amount)
                            .arg(got)
                            .arg(pSoundStretch->numSamples()));

                    if (!amount)
                        continue;

                    //len = WaitForFreeSpace(amount);
                    char *ob = encoder->GetOutBuff();
                    if (amount >= bdiff)
                    {
                        memcpy(audiobuffer + org_waud, ob, bdiff);
                        ob += bdiff;
                        amount -= bdiff;
                        org_waud = 0;
                    }
                    if (amount > 0)
                        memcpy(audiobuffer + org_waud, ob, amount);

        int nSamples = pSoundStretch->numSamples();
        len = WaitForFreeSpace(nSamples); 
        
        while ((nSamples = pSoundStretch->numSamples())) 
        {
            if (nSamples > nSamplesToEnd) 
                nSamples = nSamplesToEnd;
            
            nSamples = pSoundStretch->receiveSamples(
                (soundtouch::SAMPLETYPE*)
                (audiobuffer + org_waud), nSamples
            );
            
            if (nSamples == nSamplesToEnd) {
                org_waud = 0;
                nSamplesToEnd = AUDBUFSIZE/abps;
            }
            else {
                org_waud += nSamples * abps;
                nSamplesToEnd -= nSamples;
                        (audiobuffer + org_waud), samplesToGet);
                    if (nSamples == nSamplesToEnd)
                    {
                        org_waud = 0;
                        nSamplesToEnd = AUDBUFSIZE/audio_bytes_per_sample;
                    }
                    else
                    {
                        org_waud += nSamples * audio_bytes_per_sample;
                        nSamplesToEnd -= nSamples;
                    }

                    newLen += nSamples * audio_bytes_per_sample;
                    len -= nSamples * audio_bytes_per_sample;
                } while (nSamples > 0);
            }
            
        }
        
    }

    // Encode to AC-3? 
    if (encoder) 
    {
        
        org_waud = waud;
        int bdiff = AUDBUFSIZE - org_waud;
        int to_get = 0;

        if (bdiff < len) 
        {
            encoder->Encode(audiobuffer + org_waud, bdiff);
            to_get = encoder->Encode(audiobuffer, len - bdiff);
        }
        else 
            to_get = encoder->Encode(audiobuffer + org_waud, len);
        
        if (to_get > 0) 
        
        /* we want the time at the end -- but the file format stores
           time at the start of the chunk. */
        // even with timestretch, timecode is still calculated from original
        // sample count
        audbuf_timecode = timecode + (int)((samples * 100000.0) / effdsp);

        if (interleaved)
        {
            
            if (to_get >= bdiff)
            {
                encoder->GetFrames(audiobuffer + org_waud, bdiff);
                to_get -= bdiff;
                org_waud = 0;
            }
            if (to_get > 0)
                encoder->GetFrames(audiobuffer + org_waud, to_get);

            org_waud += to_get;

        }

    }

    waud = org_waud;
    lastaudiolen = audiolen(false);

    if (timecode < 0)
        // mythmusic doesn't give timestamps..
        timecode = (int)((samples_buffered * 100000.0) / effdsp);
    
    samples_buffered += samples;
    
    /* we want the time at the end -- but the file format stores
       time at the start of the chunk. */
    // even with timestretch, timecode is still calculated from original
    // sample count
    audbuf_timecode = timecode + (int)((samples * 100000.0) / effdsp);

}

void AudioOutputBase::Status()

Lines 48-55 Link Here

(-)a/libs/libmyth/audiooutputbase.h (-3 / +9 lines)
48	virtual void Reconfigure(int audio_bits,	48	virtual void Reconfigure(int audio_bits,
49	int audio_channels,	49	int audio_channels,
50	int audio_samplerate,	50	int audio_samplerate,
51	bool audio_passthru,	51	bool audio_passthru);
52	void *audio_codec = NULL);
53		52
54	// do AddSamples calls block?	53	// do AddSamples calls block?
55	virtual void SetBlocking(bool blocking);	54	virtual void SetBlocking(bool blocking);
Lines 59-64 Link Here
59		58
60	virtual void SetStretchFactor(float factor);	59	virtual void SetStretchFactor(float factor);
61	virtual float GetStretchFactor(void);	60	virtual float GetStretchFactor(void);
		61	virtual bool ToggleUpmix(void);
62		62
63	virtual void Reset(void);	63	virtual void Reset(void);
64		64
Lines 139-147 Link Here
139	QString audio_passthru_device;	139	QString audio_passthru_device;
140		140
141	bool audio_passthru;	141	bool audio_passthru;
		142	bool audio_enc;
		143	bool audio_reenc;
142		144
143	float audio_stretchfactor;	145	float audio_stretchfactor;
144	AVCodecContext *audio_codec;
145	AudioOutputSource source;	146	AudioOutputSource source;
146		147
147	bool killaudio;	148	bool killaudio;
Lines 151-156 Link Here
151	bool buffer_output_data_for_use; // used by AudioOutputNULL	152	bool buffer_output_data_for_use; // used by AudioOutputNULL
152		153
153	int configured_audio_channels;	154	int configured_audio_channels;
		155	int orig_config_channels;
		156	int src_quality;
154		157
155	private:	158	private:
156	// resampler	159	// resampler
Lines 167-175 Link Here
167	FreeSurround *upmixer;	170	FreeSurround *upmixer;
168		171
169	int source_audio_channels;	172	int source_audio_channels;
		173	int source_audio_samplerate;
170	int source_audio_bytes_per_sample;	174	int source_audio_bytes_per_sample;
171	bool needs_upmix;	175	bool needs_upmix;
172	int surround_mode;	176	int surround_mode;
		177	bool allow_ac3_passthru;
		178	float old_audio_stretchfactor;
173		179
174	bool blocking; // do AddSamples calls block?	180	bool blocking; // do AddSamples calls block?
175		181





AudioOutputDigitalEncoder::AudioOutputDigitalEncoder(void) :
    av_context(NULL),
    outbuflen(0),
    inbuflen(0),
    one_frame_bytes(0),
    reorder(true)
{
}


        av_free(av_context);
        av_context = NULL;
    }

    if (outbuf)
    {
        delete [] outbuf;
        outbuf = NULL;
        outbuf_size = 0;
    }

    if (frame_buffer)
    {
        delete [] frame_buffer;
        frame_buffer = NULL;
        one_frame_bytes = 0;
    }
}

//CODEC_ID_AC3
bool AudioOutputDigitalEncoder::Init(
    CodecID codec_id, int bitrate, int samplerate, int channels, bool reencoding)
{
    AVCodec *codec;
    int ret;

    VERBOSE(VB_AUDIO, LOC + QString("Init codecid=%1, br=%2, sr=%3, ch=%4 re=%5")
            .arg(codec_id_string(codec_id))
            .arg(bitrate)
            .arg(samplerate)
            .arg(channels)
            .arg(reencoding));
    
    reorder = !reencoding;

    // We need to do this when called from mythmusic
    avcodec_init();
    avcodec_register_all();
    // always AC3 as there is no DTS encoder at the moment 2005/1/9
    codec = avcodec_find_encoder(CODEC_ID_AC3);
    if (!codec)

    audio_bytes_per_sample = bytes_per_frame;
    one_frame_bytes = bytes_per_frame * av_context->frame_size;

    outbuf_size = 16384;    // ok for AC3 but DTS?
    outbuf = new char [outbuf_size];
    VERBOSE(VB_AUDIO, QString("DigitalEncoder::Init fs=%1, bpf=%2 ofb=%3")
            .arg(av_context->frame_size)
            .arg(bytes_per_frame)


} AESHeader;


void reorder_6ch_ac3(void *buf, unsigned int len) {
    unsigned short *src = (unsigned short *)buf;
    unsigned short tmp;
    unsigned int samples = len >> 1;

    for (uint i = 0; i < samples; i += 6) {
        tmp = src[i+4];
        src[i+4] = src[i+3];
        src[i+3] = src[i+2];
        src[i+2] = src[i+1];
        src[i+1] = tmp;
    }
}

static int encode_frame(
        bool dts, 
        unsigned char *data,
        size_t enc_len)
{
    size_t enc_len;
    int flags, sample_rate, bit_rate;

    // we don't do any length/crc validation of the AC3 frame here; presumably

    // anything with a bad CRC...

    uint nr_samples = 0, block_len;
    
    if (dts)
    {
        enc_len = dts_syncinfo(data+8, &flags, &sample_rate, &bit_rate);

#endif
    }

    if (enc_len == 0 || enc_len > len)
    {
        int l = len;
        len = 0;
        return l;
    }

    enc_len = min((uint)enc_len, block_len - 8);
    
    //uint32_t x = *(uint32_t*)(data+8);
    // in place swab
    swab((const char *)data + 8, (char *)data + 8, enc_len);

                break;
        }
    }
    data[5] = 0;
    data[6] = (enc_len << 3) & 0xFF;
    data[7] = (enc_len >> 5) & 0xFF;
    memset(data + 8 + enc_len, 0, block_len - 8 - enc_len);
    len = block_len;

    return enc_len;
}

size_t AudioOutputDigitalEncoder::Encode(void *buf, int len)
size_t AudioOutputDigitalEncoder::Encode(short *buff)
{
    int encsize = 0;
    size_t outsize = 0;
 
    int fs = FrameSize();
    memcpy(inbuf+inbuflen, buf, len);
    inbuflen += len;
    int frames = inbuflen / fs;

    while (frames--) 
    {
        if (reorder)
            reorder_6ch_ac3(inbuf, fs);
        
	// put data in the correct spot for encode frame
        outsize = avcodec_encode_audio(
            av_context, ((uchar*)outbuf) + outbuflen + 8, OUTBUFSIZE - 8, (short int *)inbuf);

        encode_frame(
            /*av_context->codec_id==CODEC_ID_DTS*/ false,
            (unsigned char*)outbuf + outbuflen, outsize
        );

        outbuflen += MAX_AC3_FRAME_SIZE;
        inbuflen -= fs;
        memmove(inbuf, inbuf+fs, inbuflen);
    }

    return outbuflen;
}

void AudioOutputDigitalEncoder::GetFrames(void *ptr, int maxlen)
{
    int len = (maxlen < outbuflen ? maxlen : outbuflen);
    memcpy(ptr, outbuf, len);
    outbuflen -= len;
    memmove(outbuf, outbuf+len, outbuflen);
}




#include "libavcodec/avcodec.h"
};

#define INBUFSIZE 131072
#define OUTBUFSIZE 98304

class AudioOutputDigitalEncoder
{
  public:
    AudioOutputDigitalEncoder(void);
    ~AudioOutputDigitalEncoder();

    bool   Init(CodecID codec_id, int bitrate, int samplerate, 
                int channels, bool reencoding);
    void   Dispose(void);
    size_t Encode(void *buf, int len);
    void   GetFrames(void *ptr, int maxlen);
    inline char *GetFrameBuffer(void);
    size_t FrameSize(void)  const { return one_frame_bytes; }
    int    Buffered(void) const { return inbuflen; }

  public:
    size_t audio_bytes_per_sample;

  private:
    AVCodecContext *av_context;
    char            outbuf[OUTBUFSIZE];
    char            inbuf[INBUFSIZE];
    int             outbuflen;
    int             inbuflen;
    size_t          one_frame_bytes;
    bool            reorder;
};

inline char *AudioOutputDigitalEncoder::GetFrameBuffer(void)
{
    if (!frame_buffer && av_context)
        frame_buffer = new char [one_frame_bytes];

    return frame_buffer; 
}

#endif





const float PI = 3.141592654;
const float epsilon = 0.000001;
const float center_level = 0.5*sqrt(0.5);
//const float center_level = sqrt(0.5);   // gain of the center channel
const float center_level = 1.0;   // gain of the center channel
//const float center_level = 0.5;   // gain of the center channel

// should be .6-.7
// but with centerlevel 2x what its supposed to be, we halve 0.68
// to keep center from clipping
//const float window_gain = 0.34;     
//const float window_gain = 0.68;     
const float window_gain = 0.95;     // to prive a bit of margin

// private implementation of the surround decoder
class decoder_impl {

            outbuf[c].resize(N);
            filter[c].resize(N);
        }
        // DC component of filters is always 0
        for (unsigned c=0;c<5;c++)
        {
            filter[c][0] = 0.0;
            filter[c][1] = 0.0;
            filter[c][halfN] = 0.0;
        }
        sample_rate(48000);
        // generate the window function (square root of hann, b/c it is applied before and after the transform)
        wnd.resize(N);
        for (unsigned k=0;k<N;k++)
            wnd[k] = sqrt(0.5*(1-cos(2*PI*k/N))/N);
        surround_gain(1.0);
        current_buf = 0;
        // set the default coefficients
        surround_coefficients(0.8165,0.5774);

    // set lfe filter params
    void sample_rate(unsigned int srate) {
        // lfe filter is just straight through band limited
        unsigned int cutoff = (30*N)/srate;
        for (unsigned f=0;f<=halfN;f++) {           
            if (f<cutoff)
                filter[5][f] = 0.5*sqrt(0.5);
            else
                filter[5][f] = 0.0;
        }

        E = (o+v)*n; F = (o+u)*n; G = (o-v)*n;  H = (o-u)*n;
    }

    void surround_gain(float gain) {
        master_gain = gain * window_gain * 0.5 * 0.25;
        for (unsigned k=0;k<N;k++)
            wnd[k] = sqrt(master_gain*(1-cos(2*PI*k/N))/N);
    }

    // set the phase shifting mode
    void phase_mode(unsigned mode) {
        const float modes[4][2] = {{0,0},{0,PI},{PI,0},{-PI/2,PI/2}};


        // 2. compare amplitude and phase of each DFT bin and produce the X/Y coordinates in the sound field
        //    but dont do DC or N/2 component
        for (unsigned f=0;f<halfN;f++) {           
            // get left/right amplitudes/phases
            float ampL = amplitude(dftL[f]), ampR = amplitude(dftR[f]);
            float phaseL = phase(dftL[f]), phaseR = phase(dftR[f]);

            phaseDiff = abs(phaseDiff);

            if (linear_steering) {
/*              cfloat w = polar(sqrt(ampL*ampL+ampR*ampR), (phaseL+phaseR)/2);
                cfloat lt = cfloat(dftL[f][0],dftL[f][1])/w, rt = cfloat(dftR[f][0],dftR[f][1])/w;              */
//              xfs[f] = -(C*(rt-H) - B*E + F*A + G*(D-lt)) / (G*A - C*E).real();
//              yfs[f] = (rt - (xfs[f]*E+H))/(F+xfs[f]*G);

                /*
                Problem: 
                This assumes that the values are interpolated linearly between the cardinal points.
                But this way we have no chance of knowing the average volume...
                - Can we solve that computing everything under the assumption of normalized volume?
                  No. Seemingly not.
                - Maybe we should add w explitcitly into the equation and see if we can solve it...
                */


                //cfloat lt(0.5,0),rt(0.5,0);
                //cfloat x(0,0), y(1,0);
                /*cfloat p = (C*(rt-H) - B*E + F*A + G*(D-lt)) / (G*A - C*E);
                cfloat q = B*(rt+H) + F*(D-lt) / (G*A - C*E);
                cfloat s = sqrt(p*p/4.0f - q);
                cfloat x = -p;
                cfloat x1 = -p/2.0f + s;
                cfloat x2 = -p/2.0f - s;
                float x = 0;
                if (x1.real() >= -1 && x1.real() <= 1)
                    x = x1.real();
                else if (x2.real() >= -1 && x2.real() <= 1)
                    x = x2.real();*/

                //cfloat yp = (rt - (x*E+H))/(F+x*G);
                //cfloat xp = (lt - (y*B+D))/(A+y*C);

                /*xfs[f] = x;
                yfs[f] = y.real();*/

                // --- this is the fancy new linear mode ---

                // get sound field x/y position

    float surround_high,surround_low;  // high and low surround mixing coefficient (e.g. 0.8165/0.5774)
    float surround_balance;            // the xfs balance that follows from the coeffs
    float surround_level;              // gain for the surround channels (follows from the coeffs
    float master_gain;                 // gain for all channels
    float phase_offsetL, phase_offsetR;// phase shifts to be applied to the rear channels
    float front_separation;            // front stereo separation
    float rear_separation;             // rear stereo separation


void fsurround_decoder::surround_coefficients(float a, float b) { impl->surround_coefficients(a,b); }

void fsurround_decoder::gain(float gain) { impl->surround_gain(gain); }

void fsurround_decoder::phase_mode(unsigned mode) { impl->phase_mode(mode); }

void fsurround_decoder::steering_mode(bool mode) { impl->steering_mode(mode); }

Lines 47-55 Link Here

(-)a/libs/libmythfreesurround/el_processor.h (-3 lines)
47	// 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.	47	// 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.
48	void surround_coefficients(float a, float b);	48	void surround_coefficients(float a, float b);
49		49
50	// override for master surround gain
51	void gain(float gain);
52
53	// set the phase shifting mode for decoding	50	// set the phase shifting mode for decoding
54	// 0 = (+0°,+0°) - music mode	51	// 0 = (+0°,+0°) - music mode
55	// 1 = (+0°,+180°) - PowerDVD compatibility	52	// 1 = (+0°,+180°) - PowerDVD compatibility




const unsigned default_block_size = 8192;
// there will be a slider for this in the future
//const float master_gain = 1.0;
//#define MASTER_GAIN * master_gain 
#define MASTER_GAIN
//const float inv_master_gain = 1.0;
//const float inv_master_gain = (1<<15);
//#define INV_MASTER_GAIN * inv_master_gain
#define INV_MASTER_GAIN


    if (moviemode)
    {
        params.phasemode = 1;
        params.center_width = 25;
        params.dimension = 0.5;
    }
    else
    {
        params.center_width = 65;
        params.dimension = 0.3;
        // for 70, gain should be about 3.1, c/lr about 1.5
        params.gain = 3.1;
    }
    switch (surround_mode)
    {

        decoder->phase_mode(params.phasemode);
        decoder->surround_coefficients(params.coeff_a, params.coeff_b);				
        decoder->separation(params.front_sep/100.0,params.rear_sep/100.0);
        decoder->gain(params.gain);
    }
}


    phasemode(0),
    steering(1),
    front_sep(100),
    rear_sep(100) 
    gain(1.0)
{
}


    {
        if (decoder) 
        {
            // actually these params need only be set when they change... but it doesn't hurt
#if 0
            decoder->steering_mode(params.steering);
            decoder->phase_mode(params.phasemode);
            decoder->surround_coefficients(params.coeff_a, params.coeff_b);				
            decoder->separation(params.front_sep/100.0,params.rear_sep/100.0);
#endif
            // decode the bufs->block
            //decoder->decode(input,output,params.center_width/100.0,params.dimension/100.0);
            //decoder->decode(output,params.center_width/100.0,params.dimension/100.0);
            decoder->decode(params.center_width/100.0,params.dimension/100.0);
        }
    }

Lines 452-462 Link Here

(-)a/libs/libmythsamplerate/samplerate.c (-2 / +2 lines)
452	{ len -- ;	452	{ len -- ;
453		453
454	scaled_value = in [len] * (8.0 * 0x10000000) ;	454	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))
456	{ out [len] = 32767 ;	456	{ out [len] = 32767 ;
457	continue ;	457	continue ;
458	} ;	458	} ;
459	if (CPU_CLIPS_NEGATIVE == 0 && scaled_value <= (-8.0 * 0x10000000))	459	if (scaled_value <= (-8.0 * 0x10000000))
460	{ out [len] = -32768 ;	460	{ out [len] = -32768 ;
461	continue ;	461	continue ;
462	} ;	462	} ;




      audio_passthru_device(QString::null),
      audio_channels(2),            audio_bits(-1),
      audio_samplerate(44100),      audio_stretchfactor(1.0f),
      audio_codec(NULL),
      // Picture-in-Picture
      pipplayer(NULL), setpipplayer(NULL), needsetpipplayer(false),
      // Preview window support

    if (audioOutput)
    {
        audioOutput->Reconfigure(audio_bits, audio_channels,
                                 audio_samplerate, audio_passthru);
	if (audio_passthru)
	    audio_channels = 2;
        errMsg = audioOutput->GetError();
        if (!errMsg.isEmpty())
            audioOutput->SetStretchFactor(audio_stretchfactor);

    audio_passthru = passthru;
}

void NuppelVideoPlayer::SetAudioCodec(void *ac)
{
    audio_codec = ac;
}

void NuppelVideoPlayer::SetEffDsp(int dsprate)
{
    if (audioOutput)

Lines 685-691 Link Here

(-)a/libs/libmythtv/NuppelVideoPlayer.h (-1 lines)
685	int audio_bits;	685	int audio_bits;
686	int audio_samplerate;	686	int audio_samplerate;
687	float audio_stretchfactor;	687	float audio_stretchfactor;
688	void *audio_codec;
689	bool audio_passthru;	688	bool audio_passthru;
690		689
691	// Picture-in-Picture	690	// Picture-in-Picture




      audioSamples(new short int[AVCODEC_MAX_AUDIO_FRAME_SIZE]),
      allow_ac3_passthru(false),    allow_dts_passthru(false),
      disable_passthru(false),      max_channels(2),
      last_ac3_channels(0),	    dummy_frame(NULL),
      // DVD
      lastdvdtitle(-1),
      decodeStillFrame(false),

    {
        int idx = atracks[i].av_stream_index;
        AVCodecContext *codec_ctx = ic->streams[idx]->codec;
        bool do_ac3_passthru = (allow_ac3_passthru && !transcoding &&
                                !disable_passthru &&
                                (codec_ctx->codec_id == CODEC_ID_AC3));
        bool do_dts_passthru = (allow_dts_passthru && !transcoding &&
                                !disable_passthru &&
                                (codec_ctx->codec_id == CODEC_ID_DTS));
        AudioInfo item(codec_ctx->codec_id,
                       codec_ctx->sample_rate, codec_ctx->channels,
                       DoPassThrough(codec_ctx));
        VERBOSE(VB_AUDIO, LOC + " * " + item.toString());
    }
#endif

bool AvFormatDecoder::GetFrame(int onlyvideo)
{
    AVPacket *pkt = NULL;
    AC3HeaderInfo hdr;
    int len;
    unsigned char *ptr;
    int data_size = 0;

        pts = 0;

        AVStream *curstream = ic->streams[pkt->stream_index];
        AVCodecContext *ctx = curstream->codec;

        if (pkt->dts != (int64_t)AV_NOPTS_VALUE)
            pts = (long long)(av_q2d(curstream->time_base) * pkt->dts * 1000);

        if (ringBuffer->isDVD() && 
            ctx->codec_type == CODEC_TYPE_VIDEO)
        {
            MpegPreProcessPkt(curstream, pkt);



            if (!d->HasMPEG2Dec())
            {
                int current_width = ctx->width;
                int video_width = GetNVP()->GetVideoSize().width();
                if (dvd_xvmc_enabled && GetNVP() && GetNVP()->getVideoOutput())
                {

        }

        if (storevideoframes &&
            ctx->codec_type == CODEC_TYPE_VIDEO)
        {
            av_dup_packet(pkt);
            storedPackets.append(pkt);

            continue;
        }

        if (len > 0 && ctx->codec_type == CODEC_TYPE_VIDEO &&
            pkt->stream_index == selectedVideoIndex)
        {
            AVCodecContext *context = curstream->codec;

            if (ctx->codec_id == CODEC_ID_MPEG1VIDEO ||
                ctx->codec_id == CODEC_ID_MPEG2VIDEO ||
                ctx->codec_id == CODEC_ID_MPEG2VIDEO_XVMC ||
                ctx->codec_id == CODEC_ID_MPEG2VIDEO_XVMC_VLD ||
                ctx->codec_id == CODEC_ID_MPEGVIDEO_VDPAU)
            {
                if (!ringBuffer->isDVD())
                    MpegPreProcessPkt(curstream, pkt);
            }
            else if (ctx->codec_id == CODEC_ID_H264 ||
                     ctx->codec_id == CODEC_ID_H264_VDPAU)
            {
                H264PreProcessPkt(curstream, pkt);
            }

        }

        if (len > 0 &&
            ctx->codec_type == CODEC_TYPE_DATA &&
            ctx->codec_id   == CODEC_ID_MPEG2VBI)
        {
            ProcessVBIDataPacket(curstream, pkt);


        }

        if (len > 0 &&
            ctx->codec_type == CODEC_TYPE_DATA &&
            ctx->codec_id   == CODEC_ID_DVB_VBI)
        {
            ProcessDVBDataPacket(curstream, pkt);


        }

        if (len > 0 &&
            ctx->codec_type == CODEC_TYPE_DATA &&
            ctx->codec_id   == CODEC_ID_DSMCC_B)
        {
            ProcessDSMCCPacket(curstream, pkt);


        }

        // we don't care about other data streams
        if (ctx->codec_type == CODEC_TYPE_DATA)
        {
            av_free_packet(pkt);
            continue;
        }

        if (!ctx->codec)
        {
            VERBOSE(VB_PLAYBACK, LOC +
                    QString("No codec for stream index %1, type(%2) id(%3:%4)")
                    .arg(pkt->stream_index)
                    .arg(codec_type_string(ctx->codec_type))
                    .arg(codec_id_string(ctx->codec_id))
                    .arg(ctx->codec_id));
            av_free_packet(pkt);
            continue;
        }

        have_err = false;

        avcodeclock.lock();
        int ctype  = ctx->codec_type;
        int audIdx = selectedTrack[kTrackTypeAudio].av_stream_index;
        int audSubIdx = selectedTrack[kTrackTypeAudio].av_substream_index;
        int subIdx = selectedTrack[kTrackTypeSubtitle].av_stream_index;


                    // detect switches between stereo and dual languages
                    bool wasDual = audSubIdx != -1;
                    bool isDual = ctx->avcodec_dual_language;
                    if ((wasDual && !isDual) || (!wasDual &&  isDual))
                    {
                        SetupAudioStreamSubIndexes(audIdx);
                        reselectAudioTrack = true;
                    }                            

                    bool do_ac3_passthru =
                        (allow_ac3_passthru && !transcoding &&
                         (curstream->codec->codec_id == CODEC_ID_AC3));
                    bool do_dts_passthru =
                        (allow_dts_passthru && !transcoding &&
                         (curstream->codec->codec_id == CODEC_ID_DTS));
                    bool using_passthru = do_ac3_passthru || do_dts_passthru;

                    // detect channels on streams that need
                    // to be decoded before we can know this
                    bool already_decoded = false;
                    if (!ctx->channels)
                    {
                        QMutexLocker locker(&avcodeclock);
                        VERBOSE(VB_IMPORTANT, LOC +
                                QString("Setting channels to %1")
                                .arg(audioOut.channels));

                        if (DoPassThrough(ctx))
                        {
                            // for passthru let it select the max number
                            // of channels
                            ctx->channels = 0;
                            ctx->request_channels = 0;
                        }
                        else
                        {
                            ctx->channels = audioOut.channels;
                            ctx->request_channels =
                                audioOut.channels;
                        }
                        ret = avcodec_decode_audio(
                            ctx, audioSamples,
                            &data_size, ptr, len);
                        already_decoded = true;

                        reselectAudioTrack |= ctx->channels;
                    }

                    if (ctx->codec_id == CODEC_ID_AC3 && 
                        !ff_ac3_parse_header(ptr, &hdr)) 
                    {
                        if (hdr.channels != last_ac3_channels) 
                        {
                            last_ac3_channels = ctx->channels = hdr.channels;
                            SetupAudioStream();
                        }
                    }

                    if (reselectAudioTrack)

                            .av_stream_index;
                        audSubIdx = selectedTrack[kTrackTypeAudio]
                            .av_substream_index;
                        ctx = curstream->codec;
                    }

                    if ((onlyvideo > 0) || (pkt->stream_index != audIdx))

                    if (audioOut.do_passthru)
                    {
                        data_size = pkt->size;
                        bool dts = CODEC_ID_DTS == ctx->codec_id;
                        ret = encode_frame(dts, ptr, len,
                                           audioSamples, data_size);
                    }
                    else
                    {
                        AVCodecContext *ctx = curstream->codec;

                        if ((ctx->channels == 0) ||
                            (ctx->channels > audioOut.channels))
                        {


                        if (!already_decoded)
                        {
                            ctx->request_channels = audioOut.channels;
                                audioOut.channels;
                            ret = avcodec_decode_audio(
                                ctx, audioSamples, &data_size, ptr, len);
                        }

                            audIdx = -1;
                            AutoSelectAudioTrack();
                            data_size = 0;
                            ctx = curstream->codec;
                        }
                    }
                    avcodeclock.unlock();


                    // calc for next frame
                    lastapts += (long long)((double)(data_size * 1000) /
                                (ctx->channels * 2) / ctx->sample_rate);
                                curstream->codec->sample_rate);

                    VERBOSE(VB_PLAYBACK|VB_TIMESTAMP,
                            LOC + QString("audio timecode %1 %2 %3 %4") 

                        continue;
                    }

                    AVCodecContext *context = curstream->codec;
                    AVFrame mpa_pic;
                    bzero(&mpa_pic, sizeof(AVFrame));


                            // HACK
                            while (!gotpicture && count < 5)
                            {
                                ret = d->DecodeMPEG2Video(ctx, &mpa_pic,
                                                  &gotpicture, ptr, len);
                                count++;
                            }
                        }
                        else
                        {
                            ret = d->DecodeMPEG2Video(ctx, &mpa_pic,
                                                &gotpicture, ptr, len);
                        }
                    }
                    else
                    {
                        ret = avcodec_decode_video(ctx, &mpa_pic,
                                                   &gotpicture, ptr, len);
                        // Reparse it to not drop the DVD still frame
                        if (decodeStillFrame)
                            ret = avcodec_decode_video(ctx, &mpa_pic,
                                                        &gotpicture, ptr, len);
                    }
                    avcodeclock.unlock();


                        img_convert(&tmppicture, PIX_FMT_YUV420P, 
                                    (AVPicture *)&mpa_pic,
                                    ctx->pix_fmt,
                                    ctx->width,
                                    ctx->height);

                        if (xf)
                        {

                        (temppts + 10000 > lastvpts || temppts < 0))
                    {
                        temppts = lastvpts;
                        temppts += (long long)(1000 * av_q2d(ctx->time_base));
                        // MPEG2 frames can be repeated, update pts accordingly
                        temppts += (long long)(mpa_pic.repeat_pict * 500
                                      * av_q2d(ctx->time_base));
                    }

                    VERBOSE(VB_PLAYBACK|VB_TIMESTAMP, LOC +

                    picframe->frameNumber = framesPlayed;
                    GetNVP()->ReleaseNextVideoFrame(picframe, temppts);
                    if (d->HasMPEG2Dec() && mpa_pic.data[3])
                        ctx->release_buffer(ctx, &mpa_pic);

                    decoded_video_frame = picframe;
                    gotvideo = 1;

                }
                default:
                {
                    AVCodecContext *enc = curstream->codec;
                    VERBOSE(VB_IMPORTANT, LOC_ERR +
                            QString("Decoding - id(%1) type(%2)")
                            .arg(codec_id_string(ctx->codec_id))
                            .arg(codec_type_string(ctx->codec_type)));
                    have_err = true;
                    break;
                }

    }
}

bool AvFormatDecoder::DoPassThrough(const AVCodecContext *ctx)
{
    bool passthru = false; 

    if (ctx->codec_id == CODEC_ID_AC3)
        passthru = allow_ac3_passthru && 
                   ctx->channels >= (int)max_channels;
    else if (ctx->codec_id == CODEC_ID_DTS)
        passthru = allow_dts_passthru;
    
    passthru &= !transcoding && !disable_passthru;
    // Don't know any cards that support spdif clocked at < 44100
    // Some US cable transmissions have 2ch 32k AC-3 streams
    passthru &= ctx->sample_rate >= 44100;

    return passthru;
}


/** \fn AvFormatDecoder::SetupAudioStream(void)
 *  \brief Reinitializes audio if it needs to be reinitialized.
 *

    AVStream *curstream = NULL;
    AVCodecContext *codec_ctx = NULL;
    AudioInfo old_in  = audioIn;
    AudioInfo old_out = audioOut;
    bool using_passthru = false;

    if ((currentTrack[kTrackTypeAudio] >= 0) &&

        assert(curstream);
        assert(curstream->codec);
        codec_ctx = curstream->codec;        
        using_passthru = DoPassThrough(codec_ctx);
        info = AudioInfo(codec_ctx->codec_id, codec_ctx->sample_rate, 
                         codec_ctx->channels, using_passthru);
                                (codec_ctx->codec_id == CODEC_ID_DTS));
        using_passthru = do_ac3_passthru || do_dts_passthru;
        info = AudioInfo(codec_ctx->codec_id,
                         codec_ctx->sample_rate, codec_ctx->channels,
                         using_passthru && !disable_passthru);
    }

    if (info == audioIn)

            QString("audio track #%1").arg(currentTrack[kTrackTypeAudio]+1));

    audioOut = audioIn = info;

    if (!using_passthru && audioOut.channels > (int)max_channels)
        // A passthru stream looks like a 48KHz 2ch (@ 16bit) to the sound card
        AudioInfo digInfo = audioOut;
        if (!disable_passthru)
        {
            digInfo.channels    = 2;
            digInfo.sample_rate = 48000;
            digInfo.sample_size = 4;
        }
        if (audioOut.channels > (int) max_channels)
        {
            audioOut.channels = (int) max_channels;
            audioOut.sample_size = audioOut.channels * 2;
            codec_ctx->channels = audioOut.channels;
        }
        VERBOSE(VB_AUDIO, LOC + "Audio format changed digital passthrough " +
                QString("%1\n\t\t\tfrom %2 ; %3\n\t\t\tto   %4 ; %5")
                .arg(digInfo.toString())
                .arg(old_in.toString()).arg(old_out.toString())
                .arg(audioIn.toString()).arg(audioOut.toString()));

        if (digInfo.sample_rate > 0)
            GetNVP()->SetEffDsp(digInfo.sample_rate * 100);

        GetNVP()->SetAudioParams(digInfo.bps(), digInfo.channels,
                                 digInfo.sample_rate, audioIn.do_passthru);
        // allow the audio stuff to reencode
        GetNVP()->SetAudioCodec(codec_ctx);
        GetNVP()->ReinitAudio();
        return true;
    }
    else
    {
        audioOut.channels = (int)max_channels;
        audioOut.sample_size = audioOut.channels * 2;
        codec_ctx->channels = audioOut.channels;
            audioOut.sample_size = audioOut.channels * 2;
            codec_ctx->channels = audioOut.channels;
        }
    }
    
    VERBOSE(VB_AUDIO, LOC + "Audio format changed " +
            QString("\n\t\t\tfrom %1 to %2")
            .arg(old_in.toString()).arg(audioOut.toString()));
            .arg(audioIn.toString()).arg(audioOut.toString()));

    if (audioOut.sample_rate > 0)
        GetNVP()->SetEffDsp(audioOut.sample_rate * 100);

    GetNVP()->SetAudioParams(audioOut.bps(), audioOut.channels,
                             audioOut.sample_rate,
                             audioOut.do_passthru);

    // allow the audio stuff to reencode
    GetNVP()->SetAudioCodec(using_passthru?codec_ctx:NULL);
    QString errMsg = GetNVP()->ReinitAudio();
    bool audiook = errMsg.isEmpty();

    return true;
}

Lines 198-203 Link Here

(-)a/libs/libmythtv/avformatdecoder.h (+2 lines)
198		198
199	void SeekReset(long long, uint skipFrames, bool doFlush, bool discardFrames);	199	void SeekReset(long long, uint skipFrames, bool doFlush, bool discardFrames);
200		200
		201	bool DoPassThrough(const AVCodecContext *ctx);
201	bool SetupAudioStream(void);	202	bool SetupAudioStream(void);
202	void SetupAudioStreamSubIndexes(int streamIndex);	203	void SetupAudioStreamSubIndexes(int streamIndex);
203	void RemoveAudioStreams();	204	void RemoveAudioStreams();
Lines 266-271 Link Here
266	bool allow_dts_passthru;	267	bool allow_dts_passthru;
267	bool disable_passthru;	268	bool disable_passthru;
268	uint max_channels;	269	uint max_channels;
		270	uint last_ac3_channels;
269		271
270	VideoFrame *dummy_frame;	272	VideoFrame *dummy_frame;
271		273




    REG_KEY("TV Playback", "VOLUMEDOWN", "Volume down", "[,{,F10,Volume Down");
    REG_KEY("TV Playback", "VOLUMEUP",   "Volume up",   "],},F11,Volume Up");
    REG_KEY("TV Playback", "MUTE",       "Mute",        "|,\\,F9,Volume Mute");
    REG_KEY("TV Playback", "TOGGLEUPMIX", "Toggle upmixer", "Ctrl+U");
    REG_KEY("TV Playback", "TOGGLEPIPMODE", "Toggle Picture-in-Picture mode",
            "V");
    REG_KEY("TV Playback", "TOGGLEPIPWINDOW", "Toggle active PiP window", "B");

  Teletext     F2,F3,F4,F5,F6,F7,F8
  ITV          F2,F3,F4,F5,F6,F7,F12

  Playback: Ctrl-B,Ctrl-G,Ctrl-Y,Ctrl-U
*/
}


            else if (action == "VOLUMEDOWN" || action == "VOLUMEUP" ||
                     action == "STRETCHINC" || action == "STRETCHDEC" ||
                     action == "MUTE"       || action == "TOGGLEASPECT" ||
                     action == "TOGGLEFILL" || action == "TOGGLEUPMIX")
            {
                passThru = 1;
                handled = false;

            else
                handled = false;
        }
        
        if (!passThru)
            return;
    }
 
    if (zoomMode)
    {
        int passThru = 0;

            else if (action == "VOLUMEDOWN" || action == "VOLUMEUP" ||
                     action == "STRETCHINC" || action == "STRETCHDEC" ||
                     action == "MUTE" || action == "PAUSE" ||
                     action == "CLEAROSD" || action == "TOGGLEUPMIX")
            {
                passThru = 1;
                handled = false;

        if (!passThru)
            return;
    }
    
    if (dialogname != "" && GetOSD() && GetOSD()->DialogShowing(dialogname))
    {
        for (unsigned int i = 0; i < actions.size() && !handled; i++)

                return;
       }
    }
    
    for (unsigned int i = 0; i < actions.size() && !handled; i++)
    {
        QString action = actions[i];

            ChangeTimeStretch(0);   // just display
        else if (action == "TOGGLESTRETCH")
            ToggleTimeStretch();
        else if (action == "TOGGLEUPMIX")
            ToggleUpmix();
        else if (action == "CYCLECOMMSKIPMODE") {
            SetAutoCommercialSkip((enum commSkipMode)
                                  ((autoCommercialSkip + 1) % CommSkipModes));

    }
}

void TV::ToggleUpmix()
{
    AudioOutput *aud = nvp->getAudioOutput();
    if (!aud)
        return;
    QString text;
    if (aud->ToggleUpmix())
        text = tr("Upmixer On");
    else
        text = tr("Upmixer Off");
    
    if (GetOSD() && !browsemode)
        GetOSD()->SetSettingsText(text, 5);
}
    

// dir in 10ms jumps
void TV::ChangeAudioSync(int dir, bool allowEdit)
{


        ChangeTimeStretch(0, !floatRead);   // just display
    }
    else if (action == "TOGGLEUPMIX")
        ToggleUpmix();
    else if (action.left(11) == "SELECTSCAN_")
        activenvp->SetScanType((FrameScanType) action.right(1).toInt());
    else if (action.left(15) == "TOGGLEAUDIOSYNC")

    subitem = new OSDGenericTree(item, tr("1.5X"), "ADJUSTSTRETCH1.5",
                                 (speedX100 == 150) ? 1 : 0, NULL,
                                 "STRETCHGROUP");
    
    item = new OSDGenericTree(treeMenu, tr("Toggle Upmixer"), "TOGGLEUPMIX");

    // add scan mode override settings to menu
    FrameScanType scan_type = kScan_Ignore;

Lines 314-319 Link Here

(-)a/libs/libmythtv/tv_play.h (+1 lines)
314	void ChangeSpeed(int direction);	314	void ChangeSpeed(int direction);
315	void ToggleTimeStretch(void);	315	void ToggleTimeStretch(void);
316	void ChangeTimeStretch(int dir, bool allowEdit = true);	316	void ChangeTimeStretch(int dir, bool allowEdit = true);
		317	void ToggleUpmix(void);
317	void ChangeAudioSync(int dir, bool allowEdit = true);	318	void ChangeAudioSync(int dir, bool allowEdit = true);
318	float StopFFRew(void);	319	float StopFFRew(void);
319	void ChangeFFRew(int direction);	320	void ChangeFFRew(int direction);




    return gc;
}

static HostComboBox *SRCQuality()
{
    HostComboBox *gc = new HostComboBox("SRCQuality", false);
    gc->setLabel(QObject::tr("Sample Rate Conversion"));
    gc->addSelection(QObject::tr("Best"), "3", true); // default
    gc->addSelection(QObject::tr("Medium"), "2");
    gc->addSelection(QObject::tr("Fastest"), "1");
    gc->addSelection(QObject::tr("Disabled"), "0");
    gc->setHelpText(
            QObject::tr(
                "Set the quality of audio sample rate conversion. "
                "This only affects non 48000Hz PCM audio. "
                "All three options offer a worst-case SNR of 97dB. "
                "'Best' at a bandwidth of 97%. "
                "'Medium' at a bandwidth of 90%. "
                "'Fastest' at a bandwidth of 80%. "
                "Set 'Disabled' only if you know what you are doing . "));
    return gc;
}

static HostComboBox *PassThroughOutputDevice()
{
    HostComboBox *gc = new HostComboBox("PassThruOutputDevice", true);

         agrp->addChild(MaxAudioChannels());
         agrp->addChild(AudioUpmixType());
         addChild(agrp);
         
         HorizontalConfigurationGroup *agrp1 =
             new HorizontalConfigurationGroup(false, false, true, true);
         agrp1->addChild(SRCQuality());
         addChild(agrp1);

         VerticalConfigurationGroup *vgrp1 =
             new VerticalConfigurationGroup(false, false, true, true);





    // reconfigure sound out for new params
    virtual void Reconfigure(int audio_bits, int audio_channels,
                             int audio_samplerate, bool audio_passthru)
                             void *audio_codec = NULL)
    {
        (void)audio_samplerate;
        (void)audio_passthru;
        (void)audio_codec;

        ClearError();
        bits = audio_bits;

        // Do nothing
        return MUTE_OFF;
    }
    virtual bool ToggleUpmix(void) 
    {
        // Do nothing
        return false;
    }

    //  These are pure virtual in AudioOutput, but we don't need them here
    virtual void bufferOutputData(bool){ return; }

Return to bug 259009

Lines 209-215 Link Here

(-)a/libs/libmythtv/NuppelVideoPlayer.cpp (-8 / +3 lines)
209	audio_passthru_device(QString::null),	209	audio_passthru_device(QString::null),
210	audio_channels(2), audio_bits(-1),	210	audio_channels(2), audio_bits(-1),
211	audio_samplerate(44100), audio_stretchfactor(1.0f),	211	audio_samplerate(44100), audio_stretchfactor(1.0f),
212	audio_codec(NULL),
213	// Picture-in-Picture	212	// Picture-in-Picture
214	pipplayer(NULL), setpipplayer(NULL), needsetpipplayer(false),	213	pipplayer(NULL), setpipplayer(NULL), needsetpipplayer(false),
215	// Preview window support	214	// Preview window support
Lines 804-811 Link Here
804	if (audioOutput)	803	if (audioOutput)
805	{	804	{
806	audioOutput->Reconfigure(audio_bits, audio_channels,	805	audioOutput->Reconfigure(audio_bits, audio_channels,
807	audio_samplerate, audio_passthru,	806	audio_samplerate, audio_passthru);
808	audio_codec);	807	if (audio_passthru)
		808	audio_channels = 2;
809	errMsg = audioOutput->GetError();	809	errMsg = audioOutput->GetError();
810	if (!errMsg.isEmpty())	810	if (!errMsg.isEmpty())
811	audioOutput->SetStretchFactor(audio_stretchfactor);	811	audioOutput->SetStretchFactor(audio_stretchfactor);
Lines 3718-3728 Link Here
3718	audio_passthru = passthru;	3718	audio_passthru = passthru;
3719	}	3719	}
3720		3720
3721	void NuppelVideoPlayer::SetAudioCodec(void *ac)
3722	{
3723	audio_codec = ac;
3724	}
3725
3726	void NuppelVideoPlayer::SetEffDsp(int dsprate)	3721	void NuppelVideoPlayer::SetEffDsp(int dsprate)
3727	{	3722	{
3728	if (audioOutput)	3723	if (audioOutput)

Lines 348-353 Link Here

(-)a/libs/libmythtv/tv_play.cpp (-7 / +30 lines)
348	REG_KEY("TV Playback", "VOLUMEDOWN", "Volume down", "[,{,F10,Volume Down");	348	REG_KEY("TV Playback", "VOLUMEDOWN", "Volume down", "[,{,F10,Volume Down");
349	REG_KEY("TV Playback", "VOLUMEUP", "Volume up", "],},F11,Volume Up");	349	REG_KEY("TV Playback", "VOLUMEUP", "Volume up", "],},F11,Volume Up");
350	REG_KEY("TV Playback", "MUTE", "Mute", "\|,\\,F9,Volume Mute");	350	REG_KEY("TV Playback", "MUTE", "Mute", "\|,\\,F9,Volume Mute");
		351	REG_KEY("TV Playback", "TOGGLEUPMIX", "Toggle upmixer", "Ctrl+U");
351	REG_KEY("TV Playback", "TOGGLEPIPMODE", "Toggle Picture-in-Picture mode",	352	REG_KEY("TV Playback", "TOGGLEPIPMODE", "Toggle Picture-in-Picture mode",
352	"V");	353	"V");
353	REG_KEY("TV Playback", "TOGGLEPIPWINDOW", "Toggle active PiP window", "B");	354	REG_KEY("TV Playback", "TOGGLEPIPWINDOW", "Toggle active PiP window", "B");
Lines 480-486 Link Here
480	Teletext F2,F3,F4,F5,F6,F7,F8	481	Teletext F2,F3,F4,F5,F6,F7,F8
481	ITV F2,F3,F4,F5,F6,F7,F12	482	ITV F2,F3,F4,F5,F6,F7,F12
482		483
483	Playback: Ctrl-B,Ctrl-G,Ctrl-Y	484	Playback: Ctrl-B,Ctrl-G,Ctrl-Y,Ctrl-U
484	*/	485	*/
485	}	486	}
486		487
Lines 2710-2716 Link Here
2710	else if (action == "VOLUMEDOWN" \|\| action == "VOLUMEUP" \|\|	2711	else if (action == "VOLUMEDOWN" \|\| action == "VOLUMEUP" \|\|
2711	action == "STRETCHINC" \|\| action == "STRETCHDEC" \|\|	2712	action == "STRETCHINC" \|\| action == "STRETCHDEC" \|\|
2712	action == "MUTE" \|\| action == "TOGGLEASPECT" \|\|	2713	action == "MUTE" \|\| action == "TOGGLEASPECT" \|\|
2713	action == "TOGGLEFILL" )	2714	action == "TOGGLEFILL" \|\| action == "TOGGLEUPMIX")
2714	{	2715	{
2715	passThru = 1;	2716	passThru = 1;
2716	handled = false;	2717	handled = false;
Lines 2725-2735 Link Here
2725	else	2726	else
2726	handled = false;	2727	handled = false;
2727	}	2728	}
2728		2729
2729	if (!passThru)	2730	if (!passThru)
2730	return;	2731	return;
2731	}	2732	}
2732		2733
2733	if (zoomMode)	2734	if (zoomMode)
2734	{	2735	{
2735	int passThru = 0;	2736	int passThru = 0;
Lines 2765-2771 Link Here
2765	else if (action == "VOLUMEDOWN" \|\| action == "VOLUMEUP" \|\|	2766	else if (action == "VOLUMEDOWN" \|\| action == "VOLUMEUP" \|\|
2766	action == "STRETCHINC" \|\| action == "STRETCHDEC" \|\|	2767	action == "STRETCHINC" \|\| action == "STRETCHDEC" \|\|
2767	action == "MUTE" \|\| action == "PAUSE" \|\|	2768	action == "MUTE" \|\| action == "PAUSE" \|\|
2768	action == "CLEAROSD")	2769	action == "CLEAROSD" \|\| action == "TOGGLEUPMIX")
2769	{	2770	{
2770	passThru = 1;	2771	passThru = 1;
2771	handled = false;	2772	handled = false;
Lines 2777-2783 Link Here
2777	if (!passThru)	2778	if (!passThru)
2778	return;	2779	return;
2779	}	2780	}
2780		2781
2781	if (dialogname != "" && GetOSD() && GetOSD()->DialogShowing(dialogname))	2782	if (dialogname != "" && GetOSD() && GetOSD()->DialogShowing(dialogname))
2782	{	2783	{
2783	for (unsigned int i = 0; i < actions.size() && !handled; i++)	2784	for (unsigned int i = 0; i < actions.size() && !handled; i++)
Lines 3036-3042 Link Here
3036	return;	3037	return;
3037	}	3038	}
3038	}	3039	}
3039		3040
3040	for (unsigned int i = 0; i < actions.size() && !handled; i++)	3041	for (unsigned int i = 0; i < actions.size() && !handled; i++)
3041	{	3042	{
3042	QString action = actions[i];	3043	QString action = actions[i];
Lines 3070-3075 Link Here
3070	ChangeTimeStretch(0); // just display	3071	ChangeTimeStretch(0); // just display
3071	else if (action == "TOGGLESTRETCH")	3072	else if (action == "TOGGLESTRETCH")
3072	ToggleTimeStretch();	3073	ToggleTimeStretch();
		3074	else if (action == "TOGGLEUPMIX")
		3075	ToggleUpmix();
3073	else if (action == "CYCLECOMMSKIPMODE") {	3076	else if (action == "CYCLECOMMSKIPMODE") {
3074	SetAutoCommercialSkip((enum commSkipMode)	3077	SetAutoCommercialSkip((enum commSkipMode)
3075	((autoCommercialSkip + 1) % CommSkipModes));	3078	((autoCommercialSkip + 1) % CommSkipModes));
Lines 6054-6059 Link Here
6054	}	6057	}
6055	}	6058	}
6056		6059
		6060	void TV::ToggleUpmix()
		6061	{
		6062	AudioOutput *aud = nvp->getAudioOutput();
		6063	if (!aud)
		6064	return;
		6065	QString text;
		6066	if (aud->ToggleUpmix())
		6067	text = tr("Upmixer On");
		6068	else
		6069	text = tr("Upmixer Off");
		6070
		6071	if (GetOSD() && !browsemode)
		6072	GetOSD()->SetSettingsText(text, 5);
		6073	}
		6074
		6075
6057	// dir in 10ms jumps	6076	// dir in 10ms jumps
6058	void TV::ChangeAudioSync(int dir, bool allowEdit)	6077	void TV::ChangeAudioSync(int dir, bool allowEdit)
6059	{	6078	{
Lines 7300-7305 Link Here
7300		7319
7301	ChangeTimeStretch(0, !floatRead); // just display	7320	ChangeTimeStretch(0, !floatRead); // just display
7302	}	7321	}
		7322	else if (action == "TOGGLEUPMIX")
		7323	ToggleUpmix();
7303	else if (action.left(11) == "SELECTSCAN_")	7324	else if (action.left(11) == "SELECTSCAN_")
7304	activenvp->SetScanType((FrameScanType) action.right(1).toInt());	7325	activenvp->SetScanType((FrameScanType) action.right(1).toInt());
7305	else if (action.left(15) == "TOGGLEAUDIOSYNC")	7326	else if (action.left(15) == "TOGGLEAUDIOSYNC")
Lines 7547-7552 Link Here
7547	subitem = new OSDGenericTree(item, tr("1.5X"), "ADJUSTSTRETCH1.5",	7568	subitem = new OSDGenericTree(item, tr("1.5X"), "ADJUSTSTRETCH1.5",
7548	(speedX100 == 150) ? 1 : 0, NULL,	7569	(speedX100 == 150) ? 1 : 0, NULL,
7549	"STRETCHGROUP");	7570	"STRETCHGROUP");
		7571
		7572	item = new OSDGenericTree(treeMenu, tr("Toggle Upmixer"), "TOGGLEUPMIX");
7550		7573
7551	// add scan mode override settings to menu	7574	// add scan mode override settings to menu
7552	FrameScanType scan_type = kScan_Ignore;	7575	FrameScanType scan_type = kScan_Ignore;

Lines 116-121 Link Here

(-)a/programs/mythfrontend/globalsettings.cpp (+25 lines)
116	return gc;	116	return gc;
117	}	117	}
118		118
		119	static HostComboBox *SRCQuality()
		120	{
		121	HostComboBox *gc = new HostComboBox("SRCQuality", false);
		122	gc->setLabel(QObject::tr("Sample Rate Conversion"));
		123	gc->addSelection(QObject::tr("Best"), "3", true); // default
		124	gc->addSelection(QObject::tr("Medium"), "2");
		125	gc->addSelection(QObject::tr("Fastest"), "1");
		126	gc->addSelection(QObject::tr("Disabled"), "0");
		127	gc->setHelpText(
		128	QObject::tr(
		129	"Set the quality of audio sample rate conversion. "
		130	"This only affects non 48000Hz PCM audio. "
		131	"All three options offer a worst-case SNR of 97dB. "
		132	"'Best' at a bandwidth of 97%. "
		133	"'Medium' at a bandwidth of 90%. "
		134	"'Fastest' at a bandwidth of 80%. "
		135	"Set 'Disabled' only if you know what you are doing . "));
		136	return gc;
		137	}
		138
119	static HostComboBox *PassThroughOutputDevice()	139	static HostComboBox *PassThroughOutputDevice()
120	{	140	{
121	HostComboBox *gc = new HostComboBox("PassThruOutputDevice", true);	141	HostComboBox *gc = new HostComboBox("PassThruOutputDevice", true);
Lines 3307-3312 Link Here
3307	agrp->addChild(MaxAudioChannels());	3327	agrp->addChild(MaxAudioChannels());
3308	agrp->addChild(AudioUpmixType());	3328	agrp->addChild(AudioUpmixType());
3309	addChild(agrp);	3329	addChild(agrp);
		3330
		3331	HorizontalConfigurationGroup *agrp1 =
		3332	new HorizontalConfigurationGroup(false, false, true, true);
		3333	agrp1->addChild(SRCQuality());
		3334	addChild(agrp1);
3310		3335
3311	VerticalConfigurationGroup *vgrp1 =	3336	VerticalConfigurationGroup *vgrp1 =
3312	new VerticalConfigurationGroup(false, false, true, true);	3337	new VerticalConfigurationGroup(false, false, true, true);

Lines 34-44 Link Here

(-)a/libs/libmyth/audiooutput.h (-2 / +2 lines)
34	virtual void Reconfigure(int audio_bits,	34	virtual void Reconfigure(int audio_bits,
35	int audio_channels,	35	int audio_channels,
36	int audio_samplerate,	36	int audio_samplerate,
37	bool audio_passthru,	37	bool audio_passthru) = 0;
38	void* audio_codec = NULL) = 0;
39		38
40	virtual void SetStretchFactor(float factor);	39	virtual void SetStretchFactor(float factor);
41	virtual float GetStretchFactor(void) { return 1.0f; }	40	virtual float GetStretchFactor(void) { return 1.0f; }
		41	virtual bool ToggleUpmix(void) = 0;
42		42
43	// do AddSamples calls block?	43	// do AddSamples calls block?
44	virtual void SetBlocking(bool blocking) = 0;	44	virtual void SetBlocking(bool blocking) = 0;

Lines 35-40 Link Here

(-)a/libs/libmyth/audiooutputalsa.cpp (-3 / +61 lines)
35	AudioOutputALSA::~AudioOutputALSA()	35	AudioOutputALSA::~AudioOutputALSA()
36	{	36	{
37	KillAudio();	37	KillAudio();
		38	SetIECStatus(true);
		39	}
		40
		41	void AudioOutputALSA::SetIECStatus(bool audio) {
		42
		43	snd_ctl_t *ctl;
		44	const char *spdif_str = SND_CTL_NAME_IEC958("", PLAYBACK, DEFAULT);
		45	int spdif_index = -1;
		46	snd_ctl_elem_list_t *clist;
		47	snd_ctl_elem_id_t *cid;
		48	snd_ctl_elem_value_t *cval;
		49	snd_aes_iec958_t iec958;
		50	int cidx, controls;
		51
		52	VERBOSE(VB_AUDIO, QString("Setting IEC958 status: %1")
		53	.arg(audio ? "audio" : "non-audio"));
		54
		55	snd_ctl_open(&ctl, "default", 0);
		56	snd_ctl_elem_list_alloca(&clist);
		57	snd_ctl_elem_list(ctl, clist);
		58	snd_ctl_elem_list_alloc_space(clist, snd_ctl_elem_list_get_count(clist));
		59	snd_ctl_elem_list(ctl, clist);
		60	controls = snd_ctl_elem_list_get_used(clist);
		61	for (cidx = 0; cidx < controls; cidx++)
		62	{
		63	if (!strcmp(snd_ctl_elem_list_get_name(clist, cidx), spdif_str))
		64	if (spdif_index < 0 \|\|
		65	snd_ctl_elem_list_get_index(clist, cidx) == (uint)spdif_index)
		66	break;
		67	}
		68
		69	if (cidx >= controls)
		70	return;
		71
		72	snd_ctl_elem_id_alloca(&cid);
		73	snd_ctl_elem_list_get_id(clist, cidx, cid);
		74	snd_ctl_elem_value_alloca(&cval);
		75	snd_ctl_elem_value_set_id(cval, cid);
		76	snd_ctl_elem_read(ctl,cval);
		77	snd_ctl_elem_value_get_iec958(cval, &iec958);
		78
		79	if (!audio)
		80	iec958.status[0] \|= IEC958_AES0_NONAUDIO;
		81	else
		82	iec958.status[0] &= ~IEC958_AES0_NONAUDIO;
		83
		84	snd_ctl_elem_value_set_iec958(cval, &iec958);
		85	snd_ctl_elem_write(ctl, cval);
		86
38	}	87	}
39		88
40	bool AudioOutputALSA::OpenDevice()	89	bool AudioOutputALSA::OpenDevice()
Lines 42-56 Link Here
42	snd_pcm_format_t format;	91	snd_pcm_format_t format;
43	unsigned int buffer_time, period_time;	92	unsigned int buffer_time, period_time;
44	int err;	93	int err;
		94	QString real_device;
45		95
46	if (pcm_handle != NULL)	96	if (pcm_handle != NULL)
47	CloseDevice();	97	CloseDevice();
48		98
49	pcm_handle = NULL;	99	pcm_handle = NULL;
50	numbadioctls = 0;	100	numbadioctls = 0;
51		101
52	QString real_device = (audio_passthru) ?	102	if (audio_passthru \|\| audio_enc)
53	audio_passthru_device : audio_main_device;	103	{
		104	real_device = audio_passthru_device;
		105	SetIECStatus(false);
		106	}
		107	else
		108	{
		109	real_device = audio_main_device;
		110	SetIECStatus(true);
		111	}
54		112
55	VERBOSE(VB_GENERAL, QString("Opening ALSA audio device '%1'.")	113	VERBOSE(VB_GENERAL, QString("Opening ALSA audio device '%1'.")
56	.arg(real_device));	114	.arg(real_device));

Lines 27-36 Link Here

(-)a/libs/libmyth/audiooutputdigitalencoder.cpp (-55 / +66 lines)
27		27
28	AudioOutputDigitalEncoder::AudioOutputDigitalEncoder(void) :	28	AudioOutputDigitalEncoder::AudioOutputDigitalEncoder(void) :
29	av_context(NULL),	29	av_context(NULL),
30	outbuf(NULL),	30	outbuflen(0),
31	outbuf_size(0),	31	inbuflen(0),
32	frame_buffer(NULL),	32	one_frame_bytes(0),
33	one_frame_bytes(0)	33	reorder(true)
34	{	34	{
35	}	35	}
36		36
Lines 47-82 Link Here
47	av_free(av_context);	47	av_free(av_context);
48	av_context = NULL;	48	av_context = NULL;
49	}	49	}
50
51	if (outbuf)
52	{
53	delete [] outbuf;
54	outbuf = NULL;
55	outbuf_size = 0;
56	}
57
58	if (frame_buffer)
59	{
60	delete [] frame_buffer;
61	frame_buffer = NULL;
62	one_frame_bytes = 0;
63	}
64	}	50	}
65		51
66	//CODEC_ID_AC3	52	//CODEC_ID_AC3
67	bool AudioOutputDigitalEncoder::Init(	53	bool AudioOutputDigitalEncoder::Init(
68	CodecID codec_id, int bitrate, int samplerate, int channels)	54	CodecID codec_id, int bitrate, int samplerate, int channels, bool reencoding)
69	{	55	{
70	AVCodec *codec;	56	AVCodec *codec;
71	int ret;	57	int ret;
72		58
73	VERBOSE(VB_AUDIO, LOC + QString("Init codecid=%1, br=%2, sr=%3, ch=%4")	59	VERBOSE(VB_AUDIO, LOC + QString("Init codecid=%1, br=%2, sr=%3, ch=%4 re=%5")
74	.arg(codec_id_string(codec_id))	60	.arg(codec_id_string(codec_id))
75	.arg(bitrate)	61	.arg(bitrate)
76	.arg(samplerate)	62	.arg(samplerate)
77	.arg(channels));	63	.arg(channels)
78		64	.arg(reencoding));
79	//codec = avcodec_find_encoder(codec_id);	65
		66	reorder = !reencoding;
		67
		68	// We need to do this when called from mythmusic
		69	avcodec_init();
		70	avcodec_register_all();
80	// always AC3 as there is no DTS encoder at the moment 2005/1/9	71	// always AC3 as there is no DTS encoder at the moment 2005/1/9
81	codec = avcodec_find_encoder(CODEC_ID_AC3);	72	codec = avcodec_find_encoder(CODEC_ID_AC3);
82	if (!codec)	73	if (!codec)
Lines 105-112 Link Here
105	audio_bytes_per_sample = bytes_per_frame;	96	audio_bytes_per_sample = bytes_per_frame;
106	one_frame_bytes = bytes_per_frame * av_context->frame_size;	97	one_frame_bytes = bytes_per_frame * av_context->frame_size;
107		98
108	outbuf_size = 16384; // ok for AC3 but DTS?
109	outbuf = new char [outbuf_size];
110	VERBOSE(VB_AUDIO, QString("DigitalEncoder::Init fs=%1, bpf=%2 ofb=%3")	99	VERBOSE(VB_AUDIO, QString("DigitalEncoder::Init fs=%1, bpf=%2 ofb=%3")
111	.arg(av_context->frame_size)	100	.arg(av_context->frame_size)
112	.arg(bytes_per_frame)	101	.arg(bytes_per_frame)
Lines 256-267 Link Here
256		245
257	} AESHeader;	246	} AESHeader;
258		247
		248
		249	void reorder_6ch_ac3(void *buf, unsigned int len) {
		250	unsigned short src = (unsigned short )buf;
		251	unsigned short tmp;
		252	unsigned int samples = len >> 1;
		253
		254	for (uint i = 0; i < samples; i += 6) {
		255	tmp = src[i+4];
		256	src[i+4] = src[i+3];
		257	src[i+3] = src[i+2];
		258	src[i+2] = src[i+1];
		259	src[i+1] = tmp;
		260	}
		261	}
		262
259	static int encode_frame(	263	static int encode_frame(
260	bool dts,	264	bool dts,
261	unsigned char *data,	265	unsigned char *data,
262	size_t &len)	266	size_t enc_len)
263	{	267	{
264	size_t enc_len;
265	int flags, sample_rate, bit_rate;	268	int flags, sample_rate, bit_rate;
266		269
267	// we don't do any length/crc validation of the AC3 frame here; presumably	270	// we don't do any length/crc validation of the AC3 frame here; presumably
Lines 273-278 Link Here
273	// anything with a bad CRC...	276	// anything with a bad CRC...
274		277
275	uint nr_samples = 0, block_len;	278	uint nr_samples = 0, block_len;
		279
276	if (dts)	280	if (dts)
277	{	281	{
278	enc_len = dts_syncinfo(data+8, &flags, &sample_rate, &bit_rate);	282	enc_len = dts_syncinfo(data+8, &flags, &sample_rate, &bit_rate);
Lines 293-307 Link Here
293	#endif	297	#endif
294	}	298	}
295		299
296	if (enc_len == 0 \|\| enc_len > len)
297	{
298	int l = len;
299	len = 0;
300	return l;
301	}
302
303	enc_len = min((uint)enc_len, block_len - 8);	300	enc_len = min((uint)enc_len, block_len - 8);
304		301
305	//uint32_t x = (uint32_t)(data+8);	302	//uint32_t x = (uint32_t)(data+8);
306	// in place swab	303	// in place swab
307	swab((const char )data + 8, (char )data + 8, enc_len);	304	swab((const char )data + 8, (char )data + 8, enc_len);
Lines 348-382 Link Here
348	break;	345	break;
349	}	346	}
350	}	347	}
351	data[5] = 0x00;	348	data[5] = 0;
352	data[6] = (enc_len << 3) & 0xFF;	349	data[6] = (enc_len << 3) & 0xFF;
353	data[7] = (enc_len >> 5) & 0xFF;	350	data[7] = (enc_len >> 5) & 0xFF;
354	memset(data + 8 + enc_len, 0, block_len - 8 - enc_len);	351	memset(data + 8 + enc_len, 0, block_len - 8 - enc_len);
355	len = block_len;
356		352
357	return enc_len;	353	return enc_len;
358	}	354	}
359		355
360	// must have exactly 1 frames worth of data	356	size_t AudioOutputDigitalEncoder::Encode(void *buf, int len)
361	size_t AudioOutputDigitalEncoder::Encode(short *buff)
362	{	357	{
363	int encsize = 0;
364	size_t outsize = 0;	358	size_t outsize = 0;
365		359
366	// put data in the correct spot for encode frame	360	int fs = FrameSize();
367	outsize = avcodec_encode_audio(	361	memcpy(inbuf+inbuflen, buf, len);
368	av_context, ((uchar*)outbuf) + 8, outbuf_size - 8, buff);	362	inbuflen += len;
369		363	int frames = inbuflen / fs;
370	size_t tmpsize = outsize;	364
371		365	while (frames--)
372	outsize = MAX_AC3_FRAME_SIZE;	366	{
373	encsize = encode_frame(	367	if (reorder)
374	/av_context->codec_id==CODEC_ID_DTS/ false,	368	reorder_6ch_ac3(inbuf, fs);
375	(unsigned char*)outbuf, outsize);	369
376		370	// put data in the correct spot for encode frame
377	VERBOSE(VB_AUDIO\|VB_TIMESTAMP,	371	outsize = avcodec_encode_audio(
378	QString("DigitalEncoder::Encode len1=%1 len2=%2 finallen=%3")	372	av_context, ((uchar)outbuf) + outbuflen + 8, OUTBUFSIZE - 8, (short int )inbuf);
379	.arg(tmpsize).arg(encsize).arg(outsize));	373
		374	encode_frame(
		375	/av_context->codec_id==CODEC_ID_DTS/ false,
		376	(unsigned char*)outbuf + outbuflen, outsize
		377	);
		378
		379	outbuflen += MAX_AC3_FRAME_SIZE;
		380	inbuflen -= fs;
		381	memmove(inbuf, inbuf+fs, inbuflen);
		382	}
		383
		384	return outbuflen;
		385	}
380		386
381	return outsize;	387	void AudioOutputDigitalEncoder::GetFrames(void *ptr, int maxlen)
		388	{
		389	int len = (maxlen < outbuflen ? maxlen : outbuflen);
		390	memcpy(ptr, outbuf, len);
		391	outbuflen -= len;
		392	memmove(outbuf, outbuf+len, outbuflen);
382	}	393	}

Lines 5-41 Link Here

(-)a/libs/libmyth/audiooutputdigitalencoder.h (-16 / +13 lines)
5	#include "libavcodec/avcodec.h"	5	#include "libavcodec/avcodec.h"
6	};	6	};
7		7
		8	#define INBUFSIZE 131072
		9	#define OUTBUFSIZE 98304
		10
8	class AudioOutputDigitalEncoder	11	class AudioOutputDigitalEncoder
9	{	12	{
10	public:	13	public:
11	AudioOutputDigitalEncoder(void);	14	AudioOutputDigitalEncoder(void);
12	~AudioOutputDigitalEncoder();	15	~AudioOutputDigitalEncoder();
13		16
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);
15	void Dispose(void);	19	void Dispose(void);
16	size_t Encode(short * buff);	20	size_t Encode(void *buf, int len);
17		21	void GetFrames(void *ptr, int maxlen);
18	inline char *GetFrameBuffer(void);
19	size_t FrameSize(void) const { return one_frame_bytes; }	22	size_t FrameSize(void) const { return one_frame_bytes; }
20	char *GetOutBuff(void) const { return outbuf; }	23	int Buffered(void) const { return inbuflen; }
21		24
22	public:	25	public:
23	size_t audio_bytes_per_sample;	26	size_t audio_bytes_per_sample;
24		27
25	private:	28	private:
26	AVCodecContext *av_context;	29	AVCodecContext *av_context;
27	char *outbuf;	30	char outbuf[OUTBUFSIZE];
28	int outbuf_size;	31	char inbuf[INBUFSIZE];
29	char *frame_buffer;	32	int outbuflen;
		33	int inbuflen;
30	size_t one_frame_bytes;	34	size_t one_frame_bytes;
		35	bool reorder;
31	};	36	};
32		37
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
41	#endif	38	#endif

Lines 40-56 Link Here

(-)a/libs/libmythfreesurround/el_processor.cpp (-69 / +7 lines)
40		40
41	const float PI = 3.141592654;	41	const float PI = 3.141592654;
42	const float epsilon = 0.000001;	42	const float epsilon = 0.000001;
43	//const float center_level = 0.5*sqrt(0.5); // gain of the center channel	43	const float center_level = 0.5*sqrt(0.5);
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
47
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		44
55	// private implementation of the surround decoder	45	// private implementation of the surround decoder
56	class decoder_impl {	46	class decoder_impl {
Lines 98-116 Link Here
98	outbuf[c].resize(N);	88	outbuf[c].resize(N);
99	filter[c].resize(N);	89	filter[c].resize(N);
100	}	90	}
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	}
108	sample_rate(48000);	91	sample_rate(48000);
109	// generate the window function (square root of hann, b/c it is applied before and after the transform)	92	// generate the window function (square root of hann, b/c it is applied before and after the transform)
110	wnd.resize(N);	93	wnd.resize(N);
111	// dft normalization included in the window for zero cost scaling	94	for (unsigned k=0;k<N;k++)
112	// also add a gain factor of *2 due to processing gain in algo (see center_level)	95	wnd[k] = sqrt(0.5(1-cos(2PI*k/N))/N);
113	surround_gain(1.0);
114	current_buf = 0;	96	current_buf = 0;
115	// set the default coefficients	97	// set the default coefficients
116	surround_coefficients(0.8165,0.5774);	98	surround_coefficients(0.8165,0.5774);
Lines 192-201 Link Here
192	// set lfe filter params	174	// set lfe filter params
193	void sample_rate(unsigned int srate) {	175	void sample_rate(unsigned int srate) {
194	// lfe filter is just straight through band limited	176	// lfe filter is just straight through band limited
195	unsigned int cutoff = (250*N)/srate;	177	unsigned int cutoff = (30*N)/srate;
196	for (unsigned f=0;f<=halfN;f++) {	178	for (unsigned f=0;f<=halfN;f++) {
197	if ((f>=2) && (f<cutoff))	179	if (f<cutoff)
198	filter[5][f] = 1.0;	180	filter[5][f] = 0.5*sqrt(0.5);
199	else	181	else
200	filter[5][f] = 0.0;	182	filter[5][f] = 0.0;
201	}	183	}
Lines 214-225 Link Here
214	E = (o+v)n; F = (o+u)n; G = (o-v)n; H = (o-u)n;	196	E = (o+v)n; F = (o+u)n; G = (o-v)n; H = (o-u)n;
215	}	197	}
216		198
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(2PI*k/N))/N);
221	}
222
223	// set the phase shifting mode	199	// set the phase shifting mode
224	void phase_mode(unsigned mode) {	200	void phase_mode(unsigned mode) {
225	const float modes[4][2] = {{0,0},{0,PI},{PI,0},{-PI/2,PI/2}};	201	const float modes[4][2] = {{0,0},{0,PI},{PI,0},{-PI/2,PI/2}};
Lines 290-296 Link Here
290		266
291	// 2. compare amplitude and phase of each DFT bin and produce the X/Y coordinates in the sound field	267	// 2. compare amplitude and phase of each DFT bin and produce the X/Y coordinates in the sound field
292	// but dont do DC or N/2 component	268	// but dont do DC or N/2 component
293	for (unsigned f=2;f<halfN;f++) {	269	for (unsigned f=0;f<halfN;f++) {
294	// get left/right amplitudes/phases	270	// get left/right amplitudes/phases
295	float ampL = amplitude(dftL[f]), ampR = amplitude(dftR[f]);	271	float ampL = amplitude(dftL[f]), ampR = amplitude(dftR[f]);
296	float phaseL = phase(dftL[f]), phaseR = phase(dftR[f]);	272	float phaseL = phase(dftL[f]), phaseR = phase(dftR[f]);
Lines 305-345 Link Here
305	phaseDiff = abs(phaseDiff);	281	phaseDiff = abs(phaseDiff);
306		282
307	if (linear_steering) {	283	if (linear_steering) {
308	/* cfloat w = polar(sqrt(ampLampL+ampRampR), (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) - BE + FA + G(D-lt)) / (GA - CE).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) - BE + FA + G(D-lt)) / (GA - C*E);
326	cfloat q = B(rt+H) + F(D-lt) / (GA - CE);
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 - (xE+H))/(F+xG);
338	//cfloat xp = (lt - (yB+D))/(A+yC);
339
340	/*xfs[f] = x;
341	yfs[f] = y.real();*/
342
343	// --- this is the fancy new linear mode ---	284	// --- this is the fancy new linear mode ---
344		285
345	// get sound field x/y position	286	// get sound field x/y position
Lines 597-603 Link Here
597	float surround_high,surround_low; // high and low surround mixing coefficient (e.g. 0.8165/0.5774)	538	float surround_high,surround_low; // high and low surround mixing coefficient (e.g. 0.8165/0.5774)
598	float surround_balance; // the xfs balance that follows from the coeffs	539	float surround_balance; // the xfs balance that follows from the coeffs
599	float surround_level; // gain for the surround channels (follows from the coeffs	540	float surround_level; // gain for the surround channels (follows from the coeffs
600	float master_gain; // gain for all channels
601	float phase_offsetL, phase_offsetR;// phase shifts to be applied to the rear channels	541	float phase_offsetL, phase_offsetR;// phase shifts to be applied to the rear channels
602	float front_separation; // front stereo separation	542	float front_separation; // front stereo separation
603	float rear_separation; // rear stereo separation	543	float rear_separation; // rear stereo separation
Lines 625-632 Link Here
625		565
626	void fsurround_decoder::surround_coefficients(float a, float b) { impl->surround_coefficients(a,b); }	566	void fsurround_decoder::surround_coefficients(float a, float b) { impl->surround_coefficients(a,b); }
627		567
628	void fsurround_decoder::gain(float gain) { impl->surround_gain(gain); }
629
630	void fsurround_decoder::phase_mode(unsigned mode) { impl->phase_mode(mode); }	568	void fsurround_decoder::phase_mode(unsigned mode) { impl->phase_mode(mode); }
631		569
632	void fsurround_decoder::steering_mode(bool mode) { impl->steering_mode(mode); }	570	void fsurround_decoder::steering_mode(bool mode) { impl->steering_mode(mode); }

Lines 63-72 Link Here

(-)a/libs/libmythfreesurround/freesurround.cpp (-22 / +7 lines)
63	const unsigned default_block_size = 8192;	63	const unsigned default_block_size = 8192;
64	// there will be a slider for this in the future	64	// there will be a slider for this in the future
65	//const float master_gain = 1.0;	65	//const float master_gain = 1.0;
66	//#define MASTER_GAIN * master_gain	66	//#define MASTER_GAIN * master_gain
67	#define MASTER_GAIN	67	#define MASTER_GAIN
68	//const float master_gain = 1.0/(1<<15);	68	//const float inv_master_gain = 1.0;
69	//const float inv_master_gain = (1<<15);
70	//#define INV_MASTER_GAIN * inv_master_gain	69	//#define INV_MASTER_GAIN * inv_master_gain
71	#define INV_MASTER_GAIN	70	#define INV_MASTER_GAIN
72		71
Lines 191-205 Link Here
191	if (moviemode)	190	if (moviemode)
192	{	191	{
193	params.phasemode = 1;	192	params.phasemode = 1;
194	params.center_width = 0;	193	params.center_width = 25;
195	params.gain = 1.0;	194	params.dimension = 0.5;
196	}	195	}
197	else	196	else
198	{	197	{
199	params.center_width = 70;	198	params.center_width = 65;
200	// for 50, gain should be about 1.9, c/lr about 2.7	199	params.dimension = 0.3;
201	// for 70, gain should be about 3.1, c/lr about 1.5
202	params.gain = 3.1;
203	}	200	}
204	switch (surround_mode)	201	switch (surround_mode)
205	{	202	{
Lines 235-241 Link Here
235	decoder->phase_mode(params.phasemode);	232	decoder->phase_mode(params.phasemode);
236	decoder->surround_coefficients(params.coeff_a, params.coeff_b);	233	decoder->surround_coefficients(params.coeff_a, params.coeff_b);
237	decoder->separation(params.front_sep/100.0,params.rear_sep/100.0);	234	decoder->separation(params.front_sep/100.0,params.rear_sep/100.0);
238	decoder->gain(params.gain);
239	}	235	}
240	}	236	}
241		237
Lines 249-256 Link Here
249	phasemode(0),	245	phasemode(0),
250	steering(1),	246	steering(1),
251	front_sep(100),	247	front_sep(100),
252	rear_sep(100),	248	rear_sep(100)
253	gain(1.0)
254	{	249	{
255	}	250	}
256		251
Lines 654-669 Link Here
654	{	649	{
655	if (decoder)	650	if (decoder)
656	{	651	{
657	// actually these params need only be set when they change... but it doesn't hurt
658	#if 0
659	decoder->steering_mode(params.steering);
660	decoder->phase_mode(params.phasemode);
661	decoder->surround_coefficients(params.coeff_a, params.coeff_b);
662	decoder->separation(params.front_sep/100.0,params.rear_sep/100.0);
663	#endif
664	// decode the bufs->block
665	//decoder->decode(input,output,params.center_width/100.0,params.dimension/100.0);
666	//decoder->decode(output,params.center_width/100.0,params.dimension/100.0);
667	decoder->decode(params.center_width/100.0,params.dimension/100.0);	652	decoder->decode(params.center_width/100.0,params.dimension/100.0);
668	}	653	}
669	}	654	}

Lines 55-66 Link Here

(-)a/programs/mythtranscode/transcode.cpp (-3 / +6 lines)
55		55
56	// reconfigure sound out for new params	56	// reconfigure sound out for new params
57	virtual void Reconfigure(int audio_bits, int audio_channels,	57	virtual void Reconfigure(int audio_bits, int audio_channels,
58	int audio_samplerate, bool audio_passthru,	58	int audio_samplerate, bool audio_passthru)
59	void *audio_codec = NULL)
60	{	59	{
61	(void)audio_samplerate;	60	(void)audio_samplerate;
62	(void)audio_passthru;	61	(void)audio_passthru;
63	(void)audio_codec;
64		62
65	ClearError();	63	ClearError();
66	bits = audio_bits;	64	bits = audio_bits;
Lines 218-223 Link Here
218	// Do nothing	216	// Do nothing
219	return MUTE_OFF;	217	return MUTE_OFF;
220	}	218	}
		219	virtual bool ToggleUpmix(void)
		220	{
		221	// Do nothing
		222	return false;
		223	}
221		224
222	// These are pure virtual in AudioOutput, but we don't need them here	225	// These are pure virtual in AudioOutput, but we don't need them here
223	virtual void bufferOutputData(bool){ return; }	226	virtual void bufferOutputData(bool){ return; }