基于FFMPEG的音频解码器

朴灿烈づ我的快乐病毒、 2022-06-17 12:54 289阅读 0赞

USB中的数据，是通过解码模块之后，将PCM数据存放在FIFO中，再去写再播放出去。具体的数据流向图如下：  
![这里写图片描述][SouthEast]  
因为USB中的音频解码出来的PCM数据格式各不相同，为得到相同格式的PCM数据，故需要PCM重采样，将原始PCM数据，转换为双声道32位48KHz的PCM数据。

具体的程序流程如下图所示：其中蓝色部分为UDP输出的过程，浅绿色为解码过程，棕色为重采样过程。  
![这里写图片描述][SouthEast 1]  
![这里写图片描述][SouthEast 2]  
简单介绍下流程中各函数意义：  
av\_register\_all()：注册FFmpeg所有编解码器。  
avformat\_ network\_init()：注册FFmpeg所有网络协议。（如果没有，不能udp、rtmp等输出）  
avformat\_alloc\_output\_context2()：初始化输出码流的AVFormatContext。  
avio\_open()：打开输出文件。  
av\_new\_stream()：创建输出码流的AVStream。  
avcodec\_find\_decoder()：查找解码器。  
avcodec\_open2()：打开解码器。  
avformat\_write\_header()：写文件头（对于某些没有文件头的封装格式，不需要此函数。比如说MPEG2TS）。  
av\_read\_frame ()：将USB的文件，按帧读取。  
avcodec\_decode\_audio4():将包的数据解码成Pframe  
swr\_convert ()：PCM重采样。即将解码后的PCM数据重采样。  
av\_write\_trailer()：写文件尾（对于某些没有文件头的封装格式，不需要此函数。比如说MPEG2TS）。  
代码如下：

#include <stdio.h>
    #include <stdlib.h>
    #include <math.h>
    #include <stdio.h>
    #include <string.h>
    #include <sys/ioctl.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <net/if.h>
    #include <string.h>
    #include "libavformat/avformat.h"
    #include "libavutil/mathematics.h"
    #include "libavutil/audio_fifo.h"
    #include "libswscale/swscale.h"
    #include "libavfilter/avfilter.h"
    #include "libswresample/swresample.h"
    #include "AppGlobal.h"
    #include "pelog.h"
    #include "ram.h"
    #include "block.h"
    #include "FPGA.h"
    #include "playlist.h"
    #include "WSInterface.h"
    //#include "block.h"
    
    #define SWR_CH_MAX 32
    #define MAX_BUFFER_SIZE 0x100000
    #define SWR_SAMPLE_RATE 48000
    
    #define DEBUG_DECODER_FIFO
    //#define DEBUG_FFMPEG_FIFO
    //#define DEBUG_DECODER_PCM
    
    extern U32 g_PlayProgramID;
    extern bool g_USBBlocked;
    extern bool g_USBEnd;
    extern bool g_USBExit;
    extern pthread_t                g_decoder_thread;
    extern pthread_mutex_t          g_decoder_pthread_mutex;
    extern pthread_cond_t           g_decoder_pthread_cond;
    extern PCM_OutputMode g_curOutputMode;
    extern char g_heartbeat_status[30];
    
    
    pthread_t           g_ram_write_thread;
    pthread_mutex_t     g_udpout_mutex;
    bool      ram_thread_end = false;
    
    /***************************************************************************** Function: UDP_Lock_Init Description: UDP Lock init Input: none Output: none Return: none Author: ruibin.zhang *****************************************************************************/
    void UDP_Lock_Init()
    {
        pthread_mutex_init(&g_udpout_mutex, NULL);
    }
    
    /***************************************************************************** Function: REG_Lock Description: Lock UDP out Input: none Output: none Return: none Author: ruibin.zhang *****************************************************************************/
    void UDP_Lock()
    {
        pthread_mutex_lock(&g_udpout_mutex);
    }
    
    /***************************************************************************** Function: UDP_UnLock Description: unLock UDP out Input: none Output: none Return: none Author: ruibin.zhang *****************************************************************************/
    void UDP_UnLock()
    {
        pthread_mutex_unlock(&g_udpout_mutex);
    }
    
    void get_MacAddr(char *Mac, S32 MacLen, char *EthType)
    {
        if(!Mac || !EthType)
        {
            return ;
        }
    
        S32 s32Macfd = 0;
        struct ifreq Macreq;
    
        s32Macfd = socket(AF_INET, SOCK_DGRAM, 0);
        if(s32Macfd < 0)
        {
            close(s32Macfd);
            printf("build socket fail\n");
            return ;
        }
    
        strcpy(Macreq.ifr_name, EthType);
    
        if(ioctl(s32Macfd, SIOCGIFHWADDR, &Macreq) < 0)
        {
            close(s32Macfd);
            printf("ioctl error\n");
            return ;
        }
        close(s32Macfd);
    
        snprintf(Mac,  MacLen,  "%02x:%02x:%02x:%02x:%02x:%02x",
            Macreq.ifr_hwaddr.sa_data[0],Macreq.ifr_hwaddr.sa_data[1],
            Macreq.ifr_hwaddr.sa_data[2],Macreq.ifr_hwaddr.sa_data[3],
            Macreq.ifr_hwaddr.sa_data[4],Macreq.ifr_hwaddr.sa_data[5]);
    }
    /**************************************************************************** * * NAME * peErrCode swr_config(struct SwrContext *s, AVFormatContext *ic, S32 stream_index) * * PURPOSE: * config swr * * USAGE * ic->stream[stream_index]->codec is source pcm format * * RETURN VALUE * struct SwrContext *s * * REFERENCE * - None * * AUTHOR: * ruibin.zhang * ****************************************************************************/
    struct SwrContext *swr_config(struct SwrContext *s, AVFormatContext *ic, S32 stream_index)
    {
        if(NULL == ic)
        {
            DEBUG_LOG("In Param error!");
            return s;
        }
    
        if(NULL == s)
        {
            s = swr_alloc();
        }
        s = swr_alloc_set_opts(s,         // we're allocating a new context
                AV_CH_LAYOUT_STEREO,  // out_ch_layout
                AV_SAMPLE_FMT_S32,    // out_sample_fmt
                SWR_SAMPLE_RATE,      // out_sample_rate
                ic->streams[stream_index]->codec->channel_layout,   // in_ch_layout
                ic->streams[stream_index]->codec->sample_fmt,       // in_sample_fmt
                ic->streams[stream_index]->codec->sample_rate,      // in_sample_rate
                0,                    // log_offset
                NULL);                // log_ctx
        swr_init(s);
    
        return s;
    }
    
    /**************************************************************************** * * NAME * peErrCode avformat_find_audio_stream_index(AVFormatContext *ic, S32 *pstream_index) * * PURPOSE: * get audio stream index * * USAGE * get ic the first audio stream index * * RETURN VALUE * PE_SUCCESS - success * Other - fail * * REFERENCE * - None * * AUTHOR: * ruibin.zhang * ****************************************************************************/
    peErrCode avformat_find_audio_stream_index(AVFormatContext *ic, AVFormatContext *oc, S32 *pstream_index)
    {
        int i;
        AVStream *in_stream, *out_stream;
        for(i = 0; i < ic->nb_streams; i++)
        {
            if(AVMEDIA_TYPE_AUDIO == ic->streams[i]->codec->codec_type)
            {
                *pstream_index = i;
                in_stream = ic->streams[i];
                out_stream = avformat_new_stream(oc,  in_stream->codec->codec);
                if (!out_stream)
                {
                    DEBUG_LOG( "Failed allocating output stream\n");
                    return PE_ERR_FAILURE;
                }
                //复制AVCodecContext的设置（Copy the settings of AVCodecContext）
                if ((avcodec_copy_context(out_stream->codec, in_stream->codec)) < 0)
                {
                    DEBUG_LOG( "Failed to copy context from input to output stream codec context\n");
                    return PE_ERR_FAILURE;;
                }
                out_stream->codec->codec_tag = 0;
                if (oc->oformat->flags & AVFMT_GLOBALHEADER)
                {
                    out_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
                }
    
                break;
            }
    
        }
    
        return PE_SUCCESS;
    }
    
    peErrCode decoder(U32 pProgramId)
    {
        U8 *pProgramName;
        pProgramName = playlist_GetProgramsName(pProgramId);
        DEBUG_LOG("file name is %s", pProgramName);
        log_printf(LOG_LEVEL_DEBUG, LOG_MODULE_DECODER,"To play Programname is %s", pProgramName);
        if(access((const char *)pProgramName, F_OK) != 0)
        {
            DEBUG_LOG("The program URI not found!%s", pProgramName);
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "The program URI not found!%s", pProgramName);
            return PE_ERR_PARAMS;
        }
    
        AVOutputFormat *ofmt = NULL;
        AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
        AVStream *in_stream, *out_stream;
        AVCodecContext *codec_ctx = NULL;
        AVCodec *codec = NULL;
        AVPacket pkt;                       //pkt数据
        AVFrame *frame = NULL;              //解码后的的帧数据
        SwrContext *swr_ctx = NULL;         //pcm转换结构体
        S32 cnt =   0;
    
        char in_filename[MAX_FILENAME_LENGTH];
    
        //获取广播包地址
        char udp_url[32];
        ST_PEBROCASTOUTPUT stPE_BrocastOutput;
        PARAMS_GetBroadCastOutput(&stPE_BrocastOutput);
        snprintf(udp_url, 32, "udp://%d.%d.%d.%d:%d",
                stPE_BrocastOutput.u8BroadCastIpAddr[0],
                stPE_BrocastOutput.u8BroadCastIpAddr[1],
                stPE_BrocastOutput.u8BroadCastIpAddr[2],
                stPE_BrocastOutput.u8BroadCastIpAddr[3],
                stPE_BrocastOutput.u8BroadCasDesttPort);
        DEBUG_LOG("udp_url : %s", udp_url);
        log_printf(LOG_LEVEL_DEBUG, LOG_MODULE_DECODER,"u8BroadCast url : %s", udp_url);
    
    #ifdef DEBUG_DECODER_PCM
        char *out_filename;
    #endif
    
        S32 ret;
        S32 stream_index = -1;
        S32 got_frame = -1;
        S32 dst_nb_samples = 0;
        S32 nb_samples = 0;             //转码后的一桢的采样数
        uint8_t* audio_buf[SWR_CH_MAX]; //pcm 转换后的数据buf
    #ifdef DEBUG_FFMPEG_FIFO
        uint8_t* fifo_audio_buf[SWR_CH_MAX];    //pcm 转换后的数据buf
    #endif
        S32 data_size = 0;
    
    #ifdef DEBUG_FFMPEG_FIFO
        AVAudioFifo * Decoder_FIFO = NULL;
    #endif
    
    #ifndef DEBUG_DECODER_FIFO
        U32 buffer;
        U32 value;
        U32 addr = 0;
        U32 cnt = 0;
    #endif
    
        //ger decoder File URL
        strcpy(in_filename, (char *)pProgramName);
    
    #ifdef DEBUG_DECODER_PCM
        out_filename = "decoder1.pcm";//输出文件名（Output file URL）
    #endif
    
    
    
        av_register_all();
        avformat_network_init();
    
        //初始化buf
        audio_buf[0] = av_malloc(MAX_BUFFER_SIZE);
    
        //输入（Input）
        if ((ret = avformat_open_input(&ifmt_ctx, in_filename, 0, 0)) < 0)
        {
            DEBUG_LOG("Could not open input file.");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "Could not open input file.");
            playlist_SetNOSelectPrograms(pProgramId);
            goto free_buf;
        }
        if ((ret = avformat_find_stream_info(ifmt_ctx, 0)) < 0)
        {
            DEBUG_LOG( "Failed to retrieve input stream information");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "Failed to retrieve input stream information.");
            playlist_SetNOSelectPrograms(pProgramId);
            goto close_ifmt;
        }
    
        av_dump_format(ifmt_ctx, 0, in_filename, 0);
    
        //输出（Output）
        avformat_alloc_output_context2(&ofmt_ctx, NULL, "mpegts", udp_url);
        if (!ofmt_ctx)
        {
            DEBUG_LOG( "Could not create output context\n");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER,  "Could not create output context.");
            playlist_SetNOSelectPrograms(pProgramId);
            goto close_ifmt;
        }
        ofmt = ofmt_ctx->oformat;
    
        //选择第一路音频信号作为音频输出
        avformat_find_audio_stream_index(ifmt_ctx, ofmt_ctx, &stream_index);
        if (stream_index == -1)
        {
            DEBUG_LOG("Could not find audio stream.");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER,  "Could not find audio stream.");
            playlist_SetNOSelectPrograms(pProgramId);
            goto close_ofmt;
        }
        av_dump_format(ofmt_ctx, 0, udp_url, 1);
    
        // get audio stream codec
        codec_ctx = ifmt_ctx->streams[stream_index]->codec;
    
        // find the mpeg audio decoder
        codec = avcodec_find_decoder(codec_ctx->codec_id);
        if (!codec)
        {
            DEBUG_LOG("find codec for codec_id[%d] fail, file[%s]",ifmt_ctx->audio_codec_id, in_filename);
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER,  "find codec for codec_id[%d] fail, file[%s]",ifmt_ctx->audio_codec_id, in_filename);
            goto close_ofmt;
        }
    
        ret = avcodec_open2(codec_ctx, codec, NULL);
        if (ret >= 0)
        {
            DEBUG_LOG("open codec[name:%s] for stream [id:%d] of file [%s]",codec->name,stream_index,in_filename);
            log_printf(LOG_LEVEL_ALARM, LOG_MODULE_DECODER, "open codec[name:%s] for stream [id:%d] of file [%s]",codec->name,stream_index,in_filename);
        }
        else
        {
            DEBUG_LOG("cannot open codec");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "cannot open codec");
            goto close_ofmt;
        }
    
        DEBUG_LOG();
        //输出（Output）
        av_init_packet(&pkt);
        frame = av_frame_alloc();
        DEBUG_LOG();
        //配置swr
        swr_ctx = swr_config(swr_ctx, ifmt_ctx, stream_index);
        if(swr_ctx == NULL)
        {
            DEBUG_LOG("swr_ctx config fail!");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "swr_ctx config fail!");
            goto close_codec;
        }
    
    #ifdef DEBUG_DECODER_PCM
        FILE *fp = fopen(out_filename,"wb");
    #endif
    
    #ifdef DEBUG_FFMPEG_FIFO
        Decoder_FIFO = av_audio_fifo_alloc(
                ifmt_ctx->streams[stream_index]->codec->sample_fmt,
                ifmt_ctx->streams[stream_index]->codec->channels,
                ifmt_ctx->streams[stream_index]->codec->frame_size
                );
    #endif
        DEBUG_LOG();
        //打开输出文件（Open output file）
        if (!(ofmt->flags & AVFMT_NOFILE))
        {
            ret = avio_open(&ofmt_ctx->pb, udp_url, AVIO_FLAG_WRITE);
            if (ret < 0)
            {
                DEBUG_LOG( "Could not open output file '%s'", udp_url);
                log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "Could not open output file '%s'", udp_url);
                goto end;
            }
        }
        DEBUG_LOG();
        //写文件头（Write file header）
        ret = avformat_write_header(ofmt_ctx, NULL);
        if (ret < 0)
        {
            DEBUG_LOG( "Error occurred when opening output file\n");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "Error occurred when opening output file\n");
            goto end;
        }
    #ifdef DEBUG_DECODER_FIFO
        int pipe_fd;
        int open_mode = O_WRONLY;
        //创建FIFO文件
        if (access(DECODER_FIFO_NAME, F_OK) == -1)
        {
            ret = mkfifo(DECODER_FIFO_NAME, 0777);
            if (ret != 0)
            {
                DEBUG_LOG("Could not create fifo %s\n", DECODER_FIFO_NAME);
                log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "Could not create fifo %s\n", DECODER_FIFO_NAME);
            }
        }
    
        //开启往RAM里写数据的线程 还没加判断是否线程已经开启
        //FIXME
        while(1)
        {
            if(g_ram_write_thread == 0 || (pthread_kill(g_ram_write_thread, 0) == ESRCH))
            {
                break;
            }
            usleep(1000);
            cnt ++;
            if(cnt >= 100)
            {
                ram_thread_end = true;
                cnt = 0;
            }
        }
    
        pthread_attr_t thread_attr;
        //thread attribute
        ret = pthread_attr_init(&thread_attr);
        if(0 != ret)
        {
            DEBUG_LOG("thread attribute creation failed\n");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "thread attribute creation failed\n");
            return PE_ERR_FAILURE;
        }
    
        ret = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
        if(0 != ret)
        {
            DEBUG_LOG("thread attribute setting failed\n");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "thread attribute setting failed\n");
            return PE_ERR_FAILURE;
        }
    
        ret = pthread_create(&g_ram_write_thread, &thread_attr, RamWrite_Thread, NULL);
        if(-1 == ret)
        {
            DEBUG_LOG("RAM Write thread create failed!");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "RAM Write thread create failed!");
            return PE_ERR_FAILURE;
        }
        else
        {
            DEBUG_LOG("RAM Write thread create successfully!\r");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "RAM Write thread create successfully!\r");
        }
    
    #endif
    
    #ifdef DEBUG_DECODER_FIFO
        pipe_fd = open(DECODER_FIFO_NAME, open_mode);
        if(pipe_fd == -1)
        {
            DEBUG_LOG("Cannot open FIFO");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "Cannot open FIFO");
            goto end;
        }
    #endif
    
        SendTSInfoToServer_Simple(USB_OUTPUT_STR, NULL, "start");
        strcpy(g_heartbeat_status, "broadcast");
    
        //FIXME
        int j = 0;
        for(j = 0; j < 30; j++)
        usleep(100000);
    
        DEBUG_LOG();
        while (1)
        {
            ret = av_read_frame(ifmt_ctx, &pkt);
            if (ret < 0)
            {
                DEBUG_LOG("read frame end!\n");
                log_printf(LOG_LEVEL_ALARM, LOG_MODULE_DECODER, "read frame end!\n");
                break;
            }
    
            if(stream_index == pkt.stream_index)
            {
                got_frame = 0;
    
                //fixme use who
                //ret = avcodec_decode_audio4(codec_ctx, frame, &got_frame, &pkt);
    
                //fixme depercated
                ret = avcodec_decode_audio4(ifmt_ctx->streams[stream_index]->codec, frame, &got_frame, &pkt);
                if (ret <= 0)
                {
                    DEBUG_LOG("decoding audio stream failed\n");
                    log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "decoding audio stream failed\n");
                    //fixme
                    //break;
                }
    
                if (got_frame > 0)
                {
                    //fixme cannot know how to solve planer
    
                    dst_nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx, frame->sample_rate) + frame->nb_samples, SWR_SAMPLE_RATE, frame->sample_rate, AV_ROUND_UP);
                    nb_samples = swr_convert(swr_ctx, audio_buf, dst_nb_samples,(const uint8_t**)frame->data, frame->nb_samples);
    
                    //FIXME maybe can use av_samples_get_buffer_size();
                    data_size = av_get_channel_layout_nb_channels(AV_CH_LAYOUT_STEREO) * nb_samples * av_get_bytes_per_sample(AV_SAMPLE_FMT_S32);
    
    #ifdef DEBUG_DECODER_FIFO
    
                    write(pipe_fd, audio_buf[0], data_size);
                    //DEBUG_LOG("writen data :%d ",data_size);
    
    #else
                    //FIXME 可写成函数接口 data_size *data
                    REG_Write(PCM_WREN, 0);
                    cnt = 0;
                    while(1)
                    {
                        REG_Read(PCM_PNUM, &value);
                        if(value < 3)
                        {
                            memcpy(&buffer, audio_buf[0] + cnt*4, 4);
                            cnt++;
                            if(cnt >= data_size/4)
                            {
                                cnt = 0;
                                break;
                            }
    
                            REG_Write(PCM_DATA, (buffer & 0xffffff00));
                            REG_Write(PCM_ADDR, addr);
    
                            REG_Read(PCM_DATA, &value);
    
                            REG_Write(PCM_WREN, 1);
                            REG_Write(PCM_WREN, 0);
    
                            REG_Read(PCM_RDBK, &value);
                            if(value != (buffer & 0xffffff00))
                            {
                                //DEBUG_LOG("Write error");
                                //DEBUG_LOG("Need write value:%x ,writed value: %x", (buffer & 0xffffff00), value);
                                break;
                            }
    
                            addr++;
                            if(addr >= 128)
                            {
                                addr = 0;
                            }
                        }
                    }
    #endif
    
    #ifdef DEBUG_FFMPEG_FIFO
                    av_audio_fifo_write(Decoder_FIFO,(void **) audio_buf, av_get_channel_layout_nb_channels(AV_CH_LAYOUT_STEREO)*nb_samples );
                    av_audio_fifo_read(Decoder_FIFO,(void **) fifo_audio_buf, av_get_channel_layout_nb_channels(AV_CH_LAYOUT_STEREO)*nb_samples);
    #endif
    #ifdef DEBUG_DECODER_PCM
                    fwrite(audio_buf[0], 1, data_size, fp);
    #endif
                    playlist_SetProgramsStatus(pProgramId, IS_PLAY);
                }
    
                in_stream = ifmt_ctx->streams[stream_index];
                out_stream = ofmt_ctx->streams[0];
    
                pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base, (AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
                pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base, (AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
                pkt.duration = av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);
                pkt.pos = -1;
                pkt.stream_index = 0;
                ret = av_interleaved_write_frame(ofmt_ctx, &pkt);
                if (ret < 0)
                {
                    DEBUG_LOG( "Error muxing packet\n");
                    log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "Error muxing packet\n");
                    break;
                }
                strcpy(g_heartbeat_status, "broadcast");
    
                av_packet_unref(&pkt);
                av_init_packet(&pkt);
            }
            else
            {
                av_packet_unref(&pkt);
                av_init_packet(&pkt);
            }
            if(g_USBBlocked == true)
            {
                 pthread_mutex_lock(&g_decoder_pthread_mutex);
                 playlist_SetProgramsStatus(pProgramId, IS_PAUSE);
                 pthread_cond_wait(&g_decoder_pthread_cond, &g_decoder_pthread_mutex);
                 pthread_mutex_unlock(&g_decoder_pthread_mutex);
            }
            if((g_curOutputMode != USB_OUTPUT) || (g_USBEnd == true) || (true == g_USBExit))
            {   
                DEBUG_LOG("%s is end\n", (char *)pProgramName);
                log_printf(LOG_LEVEL_ALARM, LOG_MODULE_DECODER,"%s is end\n", (char *)pProgramName);
                break;
            }
            pthread_testcancel();
        }
    
    #ifdef DEBUG_DECODER_FIFO
        close(pipe_fd);
    #endif
    
        playlist_SetProgramsStatus(pProgramId, NO_PLAY);
        av_write_trailer(ofmt_ctx);
        av_free_packet(&pkt);
        av_frame_free(&frame);
        SendTSInfoToServer_Simple(USB_OUTPUT_STR, NULL, "end");
        strcpy(g_heartbeat_status, "idle");
    
    #ifdef DEBUG_DECODER_PCM
        fclose(fp);
    #endif
    
    end:
        swr_free(&swr_ctx);
    
        if (ofmt_ctx && !(ofmt->flags & AVFMT_NOFILE))
            avio_close(ofmt_ctx->pb);
    
        if (ret < 0 && ret != AVERROR_EOF)
        {
            DEBUG_LOG( "Error occurred.\n");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER, "Error occurred.\n");
        }
    
    close_codec:
        avcodec_close(codec_ctx);
    
    close_ofmt:
        avformat_free_context(ofmt_ctx);
    
    close_ifmt:
        avformat_close_input(&ifmt_ctx);
    
    free_buf:
        av_free(audio_buf[0]);
    
        return PE_SUCCESS;
    }
    
    
    void * Decoder_Thread(void * arg)
    {
        UDP_Lock();
        log_printf(LOG_LEVEL_DEBUG, LOG_MODULE_DECODER,"Creat decoder thread!");
        //U32 ProgramId = *((U32 *)arg);
        U32 ProgramId = g_PlayProgramID;
        U32 len;
        S32 i;
        S32 ret;
        U8 * pProgramName;
        DEBUG_LOG("Program Id is %d", ProgramId);
    
        //设置cancel参数 fixme
        ret = pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
        if(ret != 0)
        {
            DEBUG_LOG("Set CancelState Fail.");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER,"Set CancelState Fail.");
            return NULL;
        }
        ret = pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
        if(ret != 0)
        {
            DEBUG_LOG("Set CancelType Fail.");
            log_printf(LOG_LEVEL_ERROR, LOG_MODULE_DECODER,"Set CancelType Fail.");
            return NULL;
        }
    
        len = playlist_GetProgramslen();
        if(ProgramId < len)
        {
            for(i = ProgramId; i < len; i++)
            {
                if(playlist_GetProgramsStatus(i) == NO_PLAY)
                {
                    pProgramName = playlist_GetProgramsName(i);
                    if(pProgramName != NULL)
                    {
                        decoder(i);
                    }
                }
                if(g_USBEnd == true)
                {
                    len = playlist_GetProgramslen();
                    if(g_PlayProgramID > len)
                    {
                        break;
                    }
                    i = g_PlayProgramID - 1;
                    g_USBEnd = false;
                }
                if((g_curOutputMode != USB_OUTPUT) || ((true == g_USBExit)))
                {
                    g_USBExit = false;
                    break;
                }
            }
        }
        else
        {
            DEBUG_LOG("ProgramId >= len , %d", ProgramId);
            log_printf(LOG_LEVEL_DEBUG, LOG_MODULE_DECODER,"wanted to play ProgramId:%d >= len ", ProgramId);
        }
    
        log_printf(LOG_LEVEL_DEBUG, LOG_MODULE_DECODER,"Exit decoder thread!");
        g_decoder_thread = 0;
        UDP_UnLock();
        return NULL;
    }

[SouthEast]: /images/20220617/c390dc59b36b4ee98e9d81bd611d191f.png
[SouthEast 1]: /images/20220617/25955af837184a428e96b6c65a9ea9e3.png
[SouthEast 2]: /images/20220617/b6d98225f9f14920a9dae779d9454fe9.png