//fdk-aacm
root@lyz-VirtualBox:/home/lyz/work/broadcast_app/app/thirds_libs_src/fdk-aac/build# vim arm-gcc-cxx11.cmake
root@lyz-VirtualBox:/home/lyz/work/broadcast_app/app/thirds_libs_src/fdk-aac/build# cmake -DCMAKE_TOOLCHAIN_FILE=/home/lyz/work/broadcast_app/app/thirds_libs_src/fdk-aac/build/arm-gcc-cxx11.cmake ../
-- The C compiler identification is GNU 6.4.1


root@lyz-VirtualBox:/home/lyz/work/broadcast_app/app_linux# cat /home/lyz/work/broadcast_app/app/thirds_libs_src/fdk-aac/build/arm-gcc-cxx11.cmake
# Sample toolchain file for building with gcc compiler
#
# Typical usage:
#    *) cmake -H. -B_build -DCMAKE_TOOLCHAIN_FILE="${PWD}/toolchains/gcc.cmake"

SET(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR arm)

# set compiler
set(CMAKE_C_COMPILER arm-openwrt-linux-gnueabi-gcc)
set(CMAKE_CXX_COMPILER arm-openwrt-linux-gnueabi-g++)

set(CONFIGURE_OPTS --enable-static=yes --enable-shared=no --disable-shared)

# set c++ standard
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

//mp3
/home/lyz/work/broadcast_app/app/thirds_libs_src/lame-3.100
./configure --host=arm-openwrt-linux-gnueabi --prefix=${PWD}/build/



./configure --target-os=linux --prefix=/home/lyz/work/broadcast_app/app_linux/thirds_libs_src/ffmpeg-4.1.9/tmp --disable-shared --disable-muxers --enable-pic --enable-static --enable-gpl --enable-nonfree --enable-ffmpeg --disable-debug --disable-filters --disable-encoders --disable-hwaccels --enable-static --enable-libmp3lame --enable-demuxers --enable-parsers --enable-protocols --disable-x86asm --disable-stripping --extra-cflags='-I/home/lyz/work/broadcast_app/app_linux/libs/include/ -I/home/lyz/work/broadcast_app/app_linux/libs/include/lame -Os -fpic ' --extra-ldflags='-ldl -lm -L/home/lyz/work/broadcast_app/app_linux/libs/' --enable-decoder=aac --enable-swresample --enable-decoder=ac3

//.cpp
#include <alsa/asoundlib.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "libavutil/time.h"
#include "libavformat/avformat.h"
#include "libavcodec/avcodec.h"
#include "libavdevice/avdevice.h"
#include "libswresample/swresample.h"
#include "libswscale/swscale.h"
 
#ifdef __cplusplus
}
#endif

LDFLAGS +=  -L ./libs/   -lavcodec -lavfilter -lavformat -lavutil -lpostproc -lswscale -lswresample  -lfdk-aac -lmp3lame

LDFLAGS += -Wl,-Bstatic -L./libs -lavformat -lavcodec -lswscale -lswresample -lavutil -lavfilter -lavdevice -lpostproc -lfdk-aac -lmp3lame

//static const char *device = "hw:1,0";			/* playback device "hw:0,0" */
static snd_pcm_format_t format = SND_PCM_FORMAT_S16;	/* sample format */
static unsigned int rate = 44100;			/* stream rate */
static unsigned int channels = 2;			/* count of channels */
static unsigned int buffer_time = 500000;		/* ring buffer length in us */
static unsigned int period_time = 100000;		/* period time in us */
static int resample = 1;				/* enable alsa-lib resampling */
static snd_pcm_sframes_t buffer_size;
static snd_pcm_sframes_t period_size;
snd_pcm_access_t mode = SND_PCM_ACCESS_RW_INTERLEAVED;
static snd_output_t *output = NULL;

/*Параметры конфигурации*/
static int set_hwparams(snd_pcm_t *handle,snd_pcm_hw_params_t *params,snd_pcm_access_t access)
{
	unsigned int rrate;
	snd_pcm_uframes_t size;
	int err, dir = 0;

	/* choose all parameters */
	err = snd_pcm_hw_params_any(handle, params);
	if (err < 0) {
		printf("Broken configuration for playback: no configurations available: %s\n", snd_strerror(err));
		return err;
	}
	/* set hardware resampling */
	err = snd_pcm_hw_params_set_rate_resample(handle, params, resample);
	if (err < 0) {
		printf("Resampling setup failed for playback: %s\n", snd_strerror(err));
		return err;
	}

	/* set the interleaved read/write format */
	/*Формат доступа*/
	err = snd_pcm_hw_params_set_access(handle, params, mode);
	if (err < 0) {
		printf("Access type not available for playback: %s\n", snd_strerror(err));
		return err;
	}

	/* set the sample format */
	/*формат выборки*/
	err = snd_pcm_hw_params_set_format(handle, params, format);
	if (err < 0) {
		printf("Sample format not available for playback: %s\n", snd_strerror(err));
		return err;
	}

	/* set the count of channels */
	/*Аудио Голос*/
	err = snd_pcm_hw_params_set_channels(handle, params, channels);
	if (err < 0) {
		printf("Channels count (%u) not available for playbacks: %s\n", channels, snd_strerror(err));
		return err;
	}

	/* set the stream rate */
	/*частота выборки*/
	rrate = rate;
	err = snd_pcm_hw_params_set_rate_near(handle, params, &rrate, 0);
	if (err < 0) {
		printf("Rate %uHz not available for playback: %s\n", rate, snd_strerror(err));
		return err;
	}
	if (rrate != rate) {
		printf("Rate doesn't match (requested %uHz, get %iHz)\n", rate, err);
		return -EINVAL;
	}

	/* set the buffer time */
	/*Нижний буферный интервал по времени 500000=0,5с*/
	err = snd_pcm_hw_params_set_buffer_time_near(handle, params, &buffer_time, &dir);
	if (err < 0) {
		printf("Unable to set buffer time %u for playback: %s\n", buffer_time, snd_strerror(err));
		return err;
	}
	err = snd_pcm_hw_params_get_buffer_size(params, &size);
	if (err < 0) {
		printf("Unable to get buffer size for playback: %s\n", snd_strerror(err));
		return err;
	}

	buffer_size = size;
	printf("buffer_size=%ld\n",buffer_size);
	/* set the period time */
	/*Интервал базового периода во времени: 100000=0,1 с*/
	err = snd_pcm_hw_params_set_period_time_near(handle, params, &period_time, &dir);
	if (err < 0) {
		printf("Unable to set period time %u for playback: %s\n", period_time, snd_strerror(err));
		return err;
	}
	/*Базовый интервал периода, в байтах, 44100*0,1=4410*/
	err = snd_pcm_hw_params_get_period_size(params, &size, &dir);
	if (err < 0) {
		printf("Unable to get period size for playback: %s\n", snd_strerror(err));
		return err;
	}
	period_size = size;
	printf("period_size=%ld\n",period_size);
	/* write the parameters to device */
	err = snd_pcm_hw_params(handle, params);
	if (err < 0) {
		printf("Unable to set hw params for playback: %s\n", snd_strerror(err));
		return err;
	}
	return 0;
}
/**
 * Initialize one data packet for reading or writing.
 * @param packet Packet to be initialized
 */
static void init_packet(AVPacket *packet)
{
    av_init_packet(packet);
    /* Set the packet data and size so that it is recognized as being empty. */
    packet->data = NULL;
    packet->size = 0;
}



int test_play_mp3(int argc, char *argv[])
{
	int rc;
	int size;
    int got_picture;
	int nb_data;
    bool pkt_pending = false;
    int audio_stream_idx;
    char **hints, **n;
	char *alsa_device_name;

	if (argc < 2){
		printf("please input filename!\r\n");
		return 1;
	}
    printf("test_play_file   filename :%s\r\n", argv[1]);
	
	snd_pcm_t *handle;
	snd_pcm_hw_params_t *hwparams;

	snd_pcm_hw_params_alloca(&hwparams);

	printf("Stream parameters are %uHz, %s, %u channels\n", rate, snd_pcm_format_name(format), channels);
    int err;

    /* Enumerate sound devices */
    err = snd_device_name_hint(-1, "pcm", (void***)&hints);
    if (err != 0){
		printf("please snd_device_name_hint:%d\r\n", err);
		return err;
	}

#if 1
    snd_lib_error_set_handler(alsa_error_handler);
#else
    /* Set a null error handler prior to enumeration to suppress errors */
    snd_lib_error_set_handler(null_alsa_error_handler);
#endif

    n = hints;
    while (*n != NULL) {
	char *name = snd_device_name_get_hint(*n, "NAME");
	if (name != NULL) {
	    if (0 != strcmp("null", name)){
			snd_pcm_t* pcm;		
			int pb_result = snd_pcm_open (&pcm, name, SND_PCM_STREAM_PLAYBACK, 0);
			if (pb_result >= 0) {
				printf("Try to open the device for playback - success\r\n");
			    snd_pcm_close (pcm);
				pcm = NULL;
				alsa_device_name = name;
				break;
			}
			printf("found device:%s\r\n", alsa_device_name);
			//break;
		}
	}
	n++;
    }
	printf("Playback device is %s\n", alsa_device_name);
  
    /* Install error handler after enumeration, otherwise we'll get many
     * error messages about invalid card/device ID.
     */
    snd_lib_error_set_handler(alsa_error_handler);

    err = snd_device_name_free_hint((void**)hints);
	 
    err = snd_output_stdio_attach(&output, stdout, 0);
	if (err < 0) {
		printf("Output failed: %s\n", snd_strerror(err));
		return 0;
	} 
    /*Установить режим воспроизведения*/
	err = snd_pcm_open(&handle, alsa_device_name, SND_PCM_STREAM_PLAYBACK, 0);
	if (err < 0) 
	{
		printf("Playback open error: %s\n", snd_strerror(err));
		return 0;
	}
    /*Установим параметры*/
    err = set_hwparams(handle, hwparams, mode);
	if (err < 0) {
		printf("Setting of hwparams failed: %s\n", snd_strerror(err));
		return 0;
	}
     
	// period_size — это примерно количество точек выборки/кадр — 4410 точек/кадр
	//Биты S16 представляют два байта плюс два канала
	//sizeчиновник=размер_периода*каналы*16/8
	size = (period_size * channels * snd_pcm_format_physical_width(format)) / 8; /* 2 bytes/sample, 1 channels */
	printf("size:%d\n",size);

	char *buffer;
	buffer = (char *) malloc(size);
    memset(buffer,0,size);

	char *in_name=argv[1];//"Дэн Цзыци - Спящая принцесса.wav";

    int ret;
    AVFormatContext* infmt_ctx = NULL;
    //Создаем обертку ввода
    ret=avformat_open_input(&infmt_ctx, in_name, NULL, NULL);
    if (ret != 0) 
    {
        printf("failed alloc output context\n");
        return -1;
    }

    infmt_ctx->max_analyze_duration        = 5*AV_TIME_BASE;

	

    //Читаем часть видеопотока и получаем необходимую информацию
    ret=avformat_find_stream_info(infmt_ctx, NULL);
    if (ret < 0) {
        printf("Can't get stream info\n");
		avformat_close_input(&infmt_ctx);
        return -1;
    }
    audio_stream_idx = av_find_best_stream(infmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, NULL, 0);
    if (audio_stream_idx < 0) {
      printf( "Can't find video stream in input file\n");
      avformat_close_input(&infmt_ctx);
      return -1;
    }
    AVCodecParameters *pCodecParameters = infmt_ctx->streams[audio_stream_idx]->codecpar;
    if (pCodecParameters == NULL){
		printf("pCodecParameters is NULL\n");
		avformat_close_input(&infmt_ctx);
    	return -1;
    }
	//Находим декодер
	const AVCodec* decodec = avcodec_find_decoder(pCodecParameters->codec_id);
	if (!decodec) 
	{
		printf("not find decoder codec audio_stream_idx:%d codec_id:%d\n", audio_stream_idx, pCodecParameters->codec_id);
		avformat_close_input(&infmt_ctx);
		return -1;
	}
    AVCodecContext *decodec_ctx = avcodec_alloc_context3(decodec);
    if (!decodec_ctx) {
        printf("Can't allocate decoder context\n");
		avformat_close_input(&infmt_ctx);
        return AVERROR(ENOMEM);
    } 
	if(avcodec_parameters_to_context(decodec_ctx, pCodecParameters)<0){
		printf("Cannot alloc codec context.\n");
		avformat_close_input(&infmt_ctx);
		return -1;
	}
    decodec_ctx->pkt_timebase = infmt_ctx->streams[audio_stream_idx]->time_base;
	#if 0
	decodec_ctx->sample_rate = pCodecParameters->sample_rate;
	decodec_ctx->sample_fmt = (AVSampleFormat)pCodecParameters->format   ;
	decodec_ctx->channels = pCodecParameters->channels;
	decodec_ctx->channel_layout = pCodecParameters->channel_layout;
	#endif//

	//Открываем декодер
	ret = avcodec_open2(decodec_ctx, decodec, NULL);
    if (ret < 0) {
        printf("Could not open codec: %d\n", ret);
		avformat_close_input(&infmt_ctx);
        return -1;
    }
	
	//Просмотр содержимого входного пакета
	av_dump_format(infmt_ctx, 0, in_name,0);
     
	#if 1
	AVFrame *pframePCM = av_frame_alloc();

	pframePCM->format = AV_SAMPLE_FMT_S16;
    pframePCM->channel_layout = AV_CH_LAYOUT_STEREO;
    pframePCM->sample_rate = rate;
    pframePCM->nb_samples = period_size;
    pframePCM->channels = channels;
    av_frame_get_buffer(pframePCM, 0);
	#else
    uint8_t *converted_input_samples = NULL;
	int converted_input_samples_size = av_samples_alloc(&converted_input_samples, NULL,
							  channels ,
							  period_size,
							  AV_SAMPLE_FMT_S16, 0);
	#endif

	struct SwrContext *pcm_convert_ctx  = swr_alloc();
    if (!pcm_convert_ctx) 
    {
        printf("Could not allocate resampler context\n");
		free(buffer);
        return -1;
    }
    
	swr_alloc_set_opts(pcm_convert_ctx, 
	                   AV_CH_LAYOUT_STEREO, 
	                   AV_SAMPLE_FMT_S16, 
	                   pframePCM->sample_rate, 
					   av_get_default_channel_layout(decodec_ctx->channels), 
	                   decodec_ctx->sample_fmt,
	                   decodec_ctx->sample_rate, 
	                   0, 
	                   NULL);
    
	ret = swr_init(pcm_convert_ctx);
	if (ret<0) 
	{
        printf("Failed to initialize the resampling context\n");
		free(buffer);
        return -1;
    }

  
    AVPacket *input_packet=av_packet_alloc();
	init_packet(input_packet);
	AVFrame *pframeSRC = av_frame_alloc();
	#if 0
	pframeSRC->format = (AVSampleFormat)pCodecParameters->format   ;
    pframeSRC->channel_layout = decodec_ctx->channel_layout;
    pframeSRC->sample_rate = decodec_ctx->sample_rate;
    pframeSRC->nb_samples =  (20*decodec_ctx->sample_rate * channels * 2) / 8000;;
    pframeSRC->channels = channels;
    av_frame_get_buffer(pframeSRC, 0);
	#endif
	
	int finished = 0;
	int decode_ret = 0;
	int data_size = av_get_bytes_per_sample(decodec_ctx->sample_fmt);
    printf("data_size:%d,  frame_size:%d, dst_samples:%d\n", data_size,  pCodecParameters->frame_size, pframePCM->nb_samples);
	
	while (!finished) 
	{ 
		ret=av_read_frame(infmt_ctx, input_packet);
		if (ret != 0)
        {    
			if (ret == AVERROR_EOF){ 
				  finished = 1;
				break;
			}

            printf("fail to read_frame\n");
            break;
        }
        //avcodec_send_packet/avcodec_receive_frame

		//Декодируем, чтобы получить исходное аудио 
        ret = avcodec_send_packet(decodec_ctx, input_packet); 
        if (ret == AVERROR(EAGAIN)) { 
            pkt_pending = true; 
            continue;
        }if (ret < 0){
			break;
		}		
			
		int no_resample = 0;

		do{ 
            decode_ret = avcodec_receive_frame(decodec_ctx, pframeSRC);
            if (decode_ret == AVERROR_EOF) {//Сброс декодера после получения кадра данных
                //avcodec_flush_buffers(decodec_ctx);	
                printf("avcodec_receive_frame eof\n"); 
				//av_packet_unref(&input_packet);
						
                break;
            } else if (decode_ret < 0){
				break;
			}
			int source_samples = swr_get_out_samples(pcm_convert_ctx, pframeSRC->nb_samples);
			int out_samples = source_samples;// 
			uint8_t *write_2_pcm = NULL;
			if (out_samples != pframePCM->nb_samples){
				no_resample = 1;
				//Читаем кадр Аудио или видео
				//MP3->PCM,
				ret=swr_convert(pcm_convert_ctx, pframePCM->data, pframePCM->nb_samples,(const uint8_t **)pframeSRC->extended_data, pframeSRC->nb_samples);
				if (ret <= 0)
				{
				    printf("[0]out_samples:%d, pframeSRC->nb_samples:%d,ret:%d\n", source_samples, pframeSRC->nb_samples, ret);
					continue;
				}else{
					//printf("[2]out_samples:%d, pframeSRC->nb_samples:%d,ret:%d\n", source_samples, pframeSRC->nb_samples, ret);
				}
				write_2_pcm = pframePCM->data[0]; 
				nb_data = ret; 
			}else{
			    printf("out_samples:%d, pframeSRC->nb_samples:%d  \n", out_samples, pframeSRC->nb_samples );
				nb_data = out_samples;

				write_2_pcm = pframeSRC->data[0]; 
			} 
			//Запись аудиоданных на оборудование
			rc = snd_pcm_writei(handle, write_2_pcm, out_samples);
			if (rc == -EPIPE) {
				printf("underrun occurred\n");
				err=snd_pcm_prepare(handle);
				if(err<0)
				{
					printf("can not recover from underrun: %s\n",snd_strerror(err));
				}
			
			} 
			else if (rc < 0) {
				fprintf(stderr,"error from writei: %s\n",snd_strerror(rc));
			}  
			else if (rc != (int)nb_data) {
				fprintf(stderr,"short write, write %d frames\n", rc);
			}
					
		}while(no_resample && decode_ret > 0);  
  		
        av_packet_unref(input_packet);
	} 

	if (pcm_convert_ctx) {
		swr_free(&pcm_convert_ctx);
	}
    av_packet_free(&input_packet);
	if (pframeSRC) {
	   av_frame_free(&pframeSRC);
	}
	#if 1
	if (pframePCM) {
	   av_frame_free(&pframePCM);
	}
	#endif
    if(decodec_ctx != NULL){
        avcodec_close(decodec_ctx);
        avcodec_free_context(&decodec_ctx);
    }
    if (infmt_ctx != NULL) {
        avformat_close_input(&infmt_ctx);
        avformat_free_context(infmt_ctx);
    } 
	
	snd_pcm_drain(handle);
	snd_pcm_close(handle);
	//free(converted_input_samples);
	free(buffer);
	free(alsa_device_name);
	
	return 0;
}