asfdemux_callback.c

1. 8623L平台

			//context->addSeqHeader = TRUE;
			break;
		case 0x20525644: //MPEG2 video
			RMDBGLOG((ENABLE, "MPEG2 video\n"));
			break;
		default:
			fprintf(stderr,"FourCC: 0x%lx not supported !!!\n",context->Compression_ID);
			return RM_VIDEO_CODEC_NOT_SUPPORTED;
		}
		context->video_decoder_initialized = TRUE;
	}
	return RM_OK;
}

static RMstatus initAudioDecoder(struct asf_context * context)
{
    RMstatus status = RM_ERROR;
    RMuint32 i;
    RMuint16 EncoderOptions = 0;
    RMuint16 wValidBitsPerSample = 0;
    RMuint32 dwChannelMask = 0;
    struct RMasfaudio_parameters *audio_params;
    RMuint32 codec;
    
    // Check that stream is enabled
    if (context->audio_parameters[context->audio_stream_index].enabled != TRUE)
    {
        RMDBGLOG((ENABLE, "Audio channel #%d is disabled, audio init bypassed\n",context->audio_stream_index));
        return RM_ERROR;
    }
 
    // Set audio decoder for current stream
    if (context->audio_decoder_initialized == TRUE)
        return RM_OK;
	
    // Get audio parameters
    audio_params = &(context->audio_parameters[context->audio_stream_index]);
	codec = (RMuint32) audio_params->Codec_ID;

	RMDBGLOG((ENABLE, "initAudioDecoder: Stream %d instance %lu codec 0x%08lx\n",context->audio_stream_index, context->audioInstances, codec));

	// Codec specific switch
    switch (codec)
    {
	case 0x161:
	case 0x7A21:
	case 0x7A22:
    {
        //WMA
        if (audio_params->Codec_Specific_Data_Size == 10)
        { // 4 + 2 + 4
            RMuint32      dwSamplesPerBlock;

            dwSamplesPerBlock = 
                  (((RMuint32) audio_params->Codec_Specific_Data[3]) << 24)
                + (((RMuint32) audio_params->Codec_Specific_Data[2]) << 16)
                + (((RMuint32) audio_params->Codec_Specific_Data[1]) << 8)
                +  ((RMuint32) audio_params->Codec_Specific_Data[0]);

            EncoderOptions = 
                + (((RMuint16) audio_params->Codec_Specific_Data[5]) << 8)
                +  ((RMuint16) audio_params->Codec_Specific_Data[4]);

            RMDBGLOG((ENABLE, 
                "    Audio codec ID: %04x,\n"
                "    Bits per block: 0x%04x\n"
                "    Encode option: 0x%04x \n",
                        (int) audio_params->Codec_ID, (int) dwSamplesPerBlock, 
                        (int) EncoderOptions));
    
        }
        else
        {
            RMDBGLOG((ENABLE, "Error: audio specific data has invalid size (%d)\n",
                              (int) audio_params->Codec_Specific_Data_Size));
            context->audio_parameters[context->audio_stream_index].enabled = FALSE;
            return RM_ERROR;
        }

#ifdef WITH_MONO
        RMDBGLOG((ENABLE, "set audio codec to WMA\n"));
        for (i = 0; i < context->audioInstances; i++)
            context->audio_opt[i].Codec = AudioDecoder_Codec_WMA;
       
        context->isWMAPRO = FALSE;
#endif
    
		break;
    }

	case 0x162:
	{
        // WMAPro
        
		RMstatus err;
		RMMetaWMAParameters temp_wmaparams;


        wValidBitsPerSample = 
            + (((RMuint16) audio_params->Codec_Specific_Data[1]) << 8)
            +  ((RMuint16) audio_params->Codec_Specific_Data[0]);
        dwChannelMask = 
              (((RMuint32) audio_params->Codec_Specific_Data[5]) << 24)
            + (((RMuint32) audio_params->Codec_Specific_Data[4]) << 16)
            + (((RMuint32) audio_params->Codec_Specific_Data[3]) << 8)
            +  ((RMuint32) audio_params->Codec_Specific_Data[2]);
        EncoderOptions = 
            + (((RMuint16) audio_params->Codec_Specific_Data[15]) << 8)
            +  ((RMuint16) audio_params->Codec_Specific_Data[14]);
        
        RMDBGLOG((ENABLE, 
              "    Audio codec ID: %04x,\n"
              "    %u valid bits/sample, %08X channel mask\n"
              "    0x%04x encode options\n",
                      (int) audio_params->Codec_ID,   (int) wValidBitsPerSample, 
                      (int) dwChannelMask, (int) EncoderOptions));
   
        // Get stored values
		temp_wmaparams.VersionNumber = audio_params->Codec_ID;
		temp_wmaparams.SamplingFrequency = audio_params->Samples_Per_Second;
		temp_wmaparams.NumberOfChannels = audio_params->Number_of_Channels;
		temp_wmaparams.Bitrate = audio_params->Average_Number_of_Bytes_Per_Second * 8;
		temp_wmaparams.PacketSize = audio_params->Block_Alignment * 8;
		temp_wmaparams.EncoderOptions = EncoderOptions;
		temp_wmaparams.BitsPerSample = audio_params->Bits_Per_Sample;
		temp_wmaparams.WMAProValidBitsPerSample = wValidBitsPerSample;
		temp_wmaparams.WMAProChannelMask = dwChannelMask;
		temp_wmaparams.WMAProVersionNumber = 0;
		//temp_wmaparams.OutputChannels = audio_params->OutputChannels;
		
		// Create video decoder only once
        if(context->vDecoder == (void *)NULL)
        {
			RMDBGLOG((ENABLE,"******** using RMF's WMAPRO decoder ********\n"));
			err = RMCreateWMAProVDecoder(&(context->vDecoder));
			if (err != RM_OK)
            {
				RMDBGLOG((ENABLE,"error: cant create wmaproVdecoder!\n"));
                context->audio_parameters[context->audio_stream_index].enabled = FALSE;
				return RM_ERROR;
			}
			
			err = RMWMAProVDecoderOpen(context->vDecoder);
			if (err != RM_OK)
            {
				RMDBGLOG((ENABLE,"error: cant open wmaproVdecoder!\n"));
                context->audio_parameters[context->audio_stream_index].enabled = FALSE;
				return RM_ERROR;
			}
		}
		
		// Init video decoder
        if (context->vDecoder != (void *)NULL)
        {
			err = RMWMAProVDecoderInit(context->vDecoder, 
						   EncoderOptions,
						   temp_wmaparams.PacketSize,
						   &temp_wmaparams);
			if (err != RM_OK)
            {
				RMDBGLOG((ENABLE, "wmaprodecoder init error\n"));
                context->audio_parameters[context->audio_stream_index].enabled = FALSE;
				return RM_ERROR;
			}
		}
        else
        {
			RMDBGLOG((ENABLE, "calling wmaprodecoder init before open!\n"));
            context->audio_parameters[context->audio_stream_index].enabled = FALSE;
            return RM_ERROR;
		}

#ifdef WITH_MONO
        RMDBGLOG((ENABLE, "set audio codec to WMAPro\n"));
        for (i = 0; i < context->audioInstances; i++)
            context->audio_opt[i].Codec = AudioDecoder_Codec_WMAPRO;

        context->isWMAPRO = TRUE;
#endif // WITH_MONO


	if ((context->isWMAPRO) && (!context->pDMAuncompressed)) {
		RMDBGLOG((ENABLE, "opening WMAPro DMApool, size %lu, bufferCount %lu bufferSize %lu\n",
			  AUDIO_DMA_BUFFER_COUNT*(1<<AUDIO_DMA_BUFFER_SIZE_LOG2),
			  AUDIO_DMA_BUFFER_COUNT,
			  (1<<AUDIO_DMA_BUFFER_SIZE_LOG2)));

		err = RUAOpenPool(context->dcc_info->pRUA, 0, AUDIO_DMA_BUFFER_COUNT, AUDIO_DMA_BUFFER_SIZE_LOG2, RUA_POOL_DIRECTION_SEND, &(context->pDMAuncompressed));
		if (RMFAILED(err)) {
			RMDBGLOG((ENABLE, "Error: cannot open dmapool for compressed audio - %d\n", err));
			return err;
		}

	}


        break;
    }
        
	case 0x1: //PCM on ASF
    {
		RMDBGLOG((ENABLE, "PCM on ASF\n"));
        context->audio_vop_tir = 90000;
        DCCSTCSetTimeResolution(context->dcc_info->pStcSource, DCC_Audio, context->audio_vop_tir);

#ifdef WITH_MONO
        for (i = 0; i < context->audioInstances; i++)
        {
            context->audio_opt[i].PcmCdaParams.MsbFirst = FALSE;
            context->audio_opt[i].Codec = AudioDecoder_Codec_PCM;
            context->audio_opt[i].SubCodec = 0;
            
            if (audio_params->Number_of_Channels == 6)
                context->audio_opt[i].PcmCdaParams.ChannelAssign = PcmCda6_LfRfCLfeLsRs;
            else
                context->audio_opt[i].PcmCdaParams.ChannelAssign = PcmCda2_LR;
            
            context->audio_opt[i].PcmCdaParams.BitsPerSample = audio_params->Bits_Per_Sample;
            
            if (!context->audio_opt[i].OutputChannelsExplicitAssign)
                context->audio_opt[i].OutputChannels = Audio_Out_Ch_LR;
        }

        context->isWMAPRO = FALSE;
#endif
        break;
    }
	case 0x50: // mpeg on ASF
		RMDBGLOG((ENABLE, "audio is MPEG\n"));
		RMDBGLOG((ENABLE, ">> set audio time scale to 90000\n"));
		context->audio_vop_tir = 90000;
		DCCSTCSetTimeResolution(context->dcc_info->pStcSource, DCC_Audio, context->audio_vop_tir);
		RMDBGLOG((ENABLE, ">> dont send audio pts\n"));
		//pSendContext->SendAudioPts = FALSE;
		break;

    default:
    {	
        // wrong codec, should not happend as it is filtered before the call
		fprintf(stderr, "error wrong codec %lx, disabling audio\n", codec);
		context->audio_parameters[context->audio_stream_index].enabled = FALSE;
		return RM_AUDIO_CODEC_NOT_SUPPORTED;
	}
    }
	

    if ((context->audio_opt[0].Spdif == OutputSpdif_NoDecodeCompressed) || (context->audio_opt[0].Spdif == OutputSpdif_Compressed))
        context->isWMAPRO = FALSE;

	// Send audio for this channel
    context->audio_parameters[context->audio_stream_index].enabled = TRUE;
    
    // Apply parameters
    if (codec != 0x163)
    { // any different from WMALSL
		
		struct AudioDecoder_WMAParameters_type wma_params;
        
        // apply the audio format - uninit, set codec, set specific parameters, init
		RMDBGLOG((ENABLE, "apply audio decoder options\n"));
		
        // Fill wmaparams structure
        wma_params.VersionNumber = audio_params->Codec_ID;
        wma_params.SamplingFrequency = audio_params->Samples_Per_Second;
        wma_params.NumberOfChannels = audio_params->Number_of_Channels;
        wma_params.Bitrate = audio_params->Average_Number_of_Bytes_Per_Second * 8;
        wma_params.PacketSize = audio_params->Block_Alignment * 8;
        wma_params.EncoderOptions = EncoderOptions;
        wma_params.BitsPerSample = audio_params->Bits_Per_Sample;
        wma_params.WMAProValidBitsPerSample = wValidBitsPerSample;
        wma_params.WMAProChannelMask = dwChannelMask;
        wma_params.WMAProVersionNumber = 0;
        /* TODO: need to handle dualmode for each audio decoder */
        wma_params.OutputDualMode = context->audio_opt[0].OutputDualMode;
        wma_params.OutputSpdif = context->audio_opt[0].Spdif;
            
        for (i = 0; i < context->audioInstances; i++)
        {
            memcpy(&context->audio_opt[i].WmaParams, &wma_params, sizeof(struct AudioDecoder_WMAParameters_type));
            
			/*******************************************************************************
			  Upsampling WMA or WMAPRO audio for SPDIF and HDMI output
			********************************************************************************/
			if(context->audio_opt[i].ForceSampleRate != TRUE)
			{
				context->audio_opt[i].SampleRate = wma_params.SamplingFrequency;

				if(wma_params.SamplingFrequency < 32000)
				{
					if(wma_params.SamplingFrequency == 8000)
					{
						context->audio_opt[i].SampleRate = 32000;
					}
					else if(wma_params.SamplingFrequency == 11025)
					{
						context->audio_opt[i].SampleRate = 44100;
					}
					else if(wma_params.SamplingFrequency == 12000)
					{
						context->audio_opt[i].SampleRate = 48000;
					}
					else if(wma_params.SamplingFrequency == 16000)
					{
						context->audio_opt[i].SampleRate = 32000;
					}
					else if(wma_params.SamplingFrequency == 22050)
					{
						context->audio_opt[i].SampleRate = 44100;
					}
					else if(wma_params.SamplingFrequency == 24000)
					{
						context->audio_opt[i].SampleRate = 48000;
					}
				}

				RMDBGLOG((ENABLE, ">> forcing output sample rate to %lu (stream sample rate %lu)\n",
                                    context->audio_opt[i].SampleRate, wma_params.SamplingFrequency));
			}
			/**************************************************************************/

			// apply the sample rate, serial out status
			RMDBGLOG((ENABLE, "apply audio engine options\n"));
			status = apply_audio_engine_options(context->dcc_info, &(context->audio_opt[i]));
			if(status != RM_OK)
            {			
				RMDBGLOG((ENABLE, "Cannot apply audio engine options ... disabling audio, error = %d\n", status));
				context->audio_parameters[context->audio_stream_index].enabled = FALSE;
                return RM_ERROR;
			}
			
			status = apply_audio_decoder_options(context->dcc_info, &(context->audio_opt[i]));
			if (RMFAILED(status))
            {
				RMDBGLOG((ENABLE, "Error applying audio_decoder_options %d\n", status));
    					context->audio_parameters[context->audio_stream_index].enabled = FALSE;
    					return RM_ERROR;
            }
    				
    			apply_dvi_hdmi_audio_options(context->dcc_info, &(context->audio_opt[i]),
                                                wma_params.NumberOfChannels, TRUE, TRUE, FALSE);
        }

#ifndef WITH_MONO
        if (! context->disp_opt->configure_outports)
                apply_hdcp(context->dcc_info, context->disp_opt);
#endif
    }

#ifdef _ENABLE_WMALSL_
    else
    { // WMALSL
       for (i = 0; i < context->audioInstances; i++)
       {
 			context->audio_opt[i].Codec = AudioDecoder_Codec_PCM;
			context->audio_opt[i].SubCodec = 0;
			context->audio_opt[i].SampleRate = audio_params->Samples_Per_Second;
			context->audio_opt[i].OutputChannels = Audio_Out_Ch_LR;
			context->audio_opt[i].PcmCdaParams.ChannelAssign = PcmCda2_LR;
			context->audio_opt[i].PcmCdaParams.BitsPerSample = audio_params;
			context->audio_opt[i].PcmCdaParams.MsbFirst = FALSE;
			
			// apply the sample rate, serial out status
			status = apply_audio_engine_options(context->dcc_info, &(context->audio_opt[i]));
			if(status != RM_OK)
            {
				RMDBGLOG((ENABLE, "Cannot apply audio engine options ... disabling audio, error = %d\n", status));
				context->audio_parameters[context->audio_stream_index].enabled = FALSE;
                return RM_ERROR;
			}
			
			status = apply_audio_decoder_options(context->dcc_info, &(context->audio_opt[i]));
			RMDBGLOG((ENABLE, " set PCM codec for WMALSL, Sampling Freq=%lu\n", context->audio_opt[i].SampleRate));
			DCCSTCSetTimeResolution(context->dcc_info->pStcSource, DCC_Audio, 90000);
			if(status != RM_OK)
            {			
				RMDBGLOG((ENABLE, "Cannot apply audio decoder options ... disabling audio, error = %d\n", status));
        					context->audio_parameters[context->audio_stream_index].enabled = FALSE;
        		return RM_ERROR;
            }