//
// Created by 倪路朋 on 10/24/24.
//

#include "server_global.h"
#include <SLES/OpenSLES.h>
#include <SLES/OpenSLES_Android.h>
#include <sys/resource.h>
#include <thread>

std::map<int,LivePusher *> pushers = {};
vector<MiniViewData *> pushMiniDatas = {};
MiniViewData *mainView = 0;
int mainStreamCode = 0;
pthread_mutex_t pushVideoMutex,pushNV21Mutex,pushAudioMutex;
ANativeWindow *nativeMainWindow = 0;
pthread_mutex_t loadSurfaceMutex;
int mainWidth = FRAME_WIDTH;
int mainHeight = FRAME_HEIGHT;
float STREAM_RATE = FRAME_WIDTH*1.0/FRAME_HEIGHT;
uint8_t *blackYUV[3];
uint32_t start_time;
SafeQueue<YUVData *> mainSurfaceFrames ;
SafeQueue<YUVData *> pushFrames;
AudioChannel *audioChannel = 0;
VideoChannel *videoChannel = 0;

void packetCallBack(RTMPPacket *packet){
    //LOGI("packetCallBack safequeue packets：%d",&packets);
    if(packet){
        //LOGI("packets.push ");
        if(packet->m_packetType == RTMP_PACKET_TYPE_AUDIO && packet->m_body[1] == 0x00){
            LOGI("RTMP1 发送音频头信息 ");
        }
        if(packet->m_nTimeStamp == -1){
            packet->m_nTimeStamp = RTMP_GetTime() - start_time;
        }
        if(pushers.size() > 0){
            for(auto i : pushers){
                if(packet->m_packetType == RTMP_PACKET_TYPE_VIDEO){
                    i.second->pushYUV(packet);
                }else{
                    i.second->pushPCM(packet);
                }
                //LOGI("pushPCM2.2");
            }
            RTMPPacket_Free(packet);
        }
    }
}

int CopyRTMPPacket(RTMPPacket *dest, const RTMPPacket *src) {

    // 初始化目标 RTMPPacket
    RTMPPacket_Alloc(dest, src->m_nBodySize);
    if (!dest->m_body) {
        return 0;  // 内存分配失败
    }

    // 复制字段
    memcpy(dest->m_body, src->m_body, src->m_nBodySize);
    dest->m_headerType = src->m_headerType;
    dest->m_packetType = src->m_packetType;
    dest->m_nChannel = src->m_nChannel;
    dest->m_nTimeStamp = src->m_nTimeStamp;
    dest->m_nInfoField2 = src->m_nInfoField2;
    dest->m_hasAbsTimestamp = src->m_hasAbsTimestamp;
    dest->m_nBodySize = src->m_nBodySize;

    return 1;  // 成功
}

int64_t getCurrentTimestamp(){
    auto now = std::chrono::system_clock::now();
    auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
    return millis.count();
}

int getIndexOfStream(int streamCode){
    int index = -1;
    for(int i = 0 ; i < pushMiniDatas.size() ; i ++){
        index = i ;
        if(pushMiniDatas[index]->streamCode == streamCode){
            break;
        }
    }
    return index;
}

int getIndexOfMain(){
    int index = -1;
    for(int i = 0 ; i < pushMiniDatas.size() ; i ++){
        index = i ;
        if(pushMiniDatas[index]->streamCode == mainStreamCode){
            break;
        }
    }
    return index;
}

/**
 * 获取主画面
 * @return
 */
MiniViewData *getMainViewData(){
    MiniViewData *mainView = 0;
    for (int i = 0; i < pushMiniDatas.size(); ++i) {
        MiniViewData *miniView = pushMiniDatas[i];
        if (miniView->streamCode == mainStreamCode) {
            mainView = miniView;
            continue;
        }
    }
    return mainView;
}

MiniViewData *getMiniView(int streamCode){

    int index = getIndexOfStream(streamCode);
    if(index == -1){
        return 0;
    }
    //LOGI("pushYUV");
    return pushMiniDatas[index];
}

/**
 * 添加黑边
 * @param yuvData
 * @param srcWidth
 * @param srcHeight
 * @param borderWidth
 */
void addBlackBorder(uint8_t *yuvData[3],int srcWidth,int srcHeight,int borderWidth)
{
    int uvWidth = srcWidth / 2;
    int uvHeight = srcHeight / 2;

    // 填充 Y 平面的黑边
    // 上边
    for (int y = 0; y < borderWidth; y++) {
        memset(yuvData[0] + y * srcWidth, 0, srcWidth);
    }
    // 下边
    for (int y = srcHeight - borderWidth; y < srcHeight; y++) {
        memset(yuvData[0] + y * srcWidth, 0, srcWidth);
    }
    // 左边和右边
    for (int y = borderWidth; y < srcHeight - borderWidth; y++) {
        memset(yuvData[0] + y * srcWidth, 0, borderWidth);                   // 左边
        memset(yuvData[0] + y * srcWidth + srcWidth - borderWidth, 0, borderWidth);  // 右边
    }

    // 填充 U 和 V 平面的黑边（边框宽度在 U 和 V 平面上缩小一半）
    int uvBorderWidth = borderWidth / 2;
    // 上边
    for (int y = 0; y < uvBorderWidth; y++) {
        memset(yuvData[1] + y * uvWidth, 128, uvWidth);
        memset(yuvData[2] + y * uvWidth, 128, uvWidth);
    }
    // 下边
    for (int y = uvHeight - uvBorderWidth; y < uvHeight; y++) {
        memset(yuvData[1] + y * uvWidth, 128, uvWidth);
        memset(yuvData[2] + y * uvWidth, 128, uvWidth);
    }
    // 左边和右边
    for (int y = uvBorderWidth; y < uvHeight - uvBorderWidth; y++) {
        memset(yuvData[1] + y * uvWidth, 128, uvBorderWidth);                        // 左边
        memset(yuvData[1] + y * uvWidth + uvWidth - uvBorderWidth, 128, uvBorderWidth); // 右边
        memset(yuvData[2] + y * uvWidth, 128, uvBorderWidth);                        // 左边
        memset(yuvData[2] + y * uvWidth + uvWidth - uvBorderWidth, 128, uvBorderWidth); // 右边
    }
}

/**
 * 添加圆角黑边
 * @param yuvData
 * @param width
 * @param height
 * @param borderWidth
 * @param cornerRadius
 */
void addCornerAndBlackBorder(uint8_t *yuvData[3],int srcWidth,int srcHeight,int borderWidth,int cornerRadius){
    int uvWidth = srcWidth / 2;
    int uvHeight = srcHeight / 2;
    int uvBorderWidth = borderWidth / 2;
    int uvCornerRadius = cornerRadius / 2;

    // 填充 Y 平面的上下黑色边框
    for (int y = 0; y < borderWidth; y++) {
        memset(yuvData[0] + y * srcWidth, 0, srcWidth); // 上黑边
        memset(yuvData[0] + (srcHeight - y - 1) * srcWidth, 0, srcWidth); // 下黑边
    }
    // 填充 Y 平面的左右黑色边框
    for (int y = borderWidth; y < srcHeight - borderWidth; y++) {
        memset(yuvData[0] + y * srcWidth, 0, borderWidth); // 左黑边
        memset(yuvData[0] + y * srcWidth + srcWidth - borderWidth, 0, borderWidth); // 右黑边
    }

    // 圆角裁切，给四角应用圆形裁切
    for (int y = 0; y < cornerRadius; y++) {
        for (int x = 0; x < cornerRadius; x++) {
            // 判断是否在圆角区域内
            if (sqrt((cornerRadius - x) * (cornerRadius - x) + (cornerRadius - y) * (cornerRadius - y)) >= cornerRadius) {
                // 设置为透明模拟值（中灰色）
                yuvData[0][y * srcWidth + x] = 128;                                 // 左上角
                yuvData[0][y * srcWidth + (srcWidth - x - 1)] = 128;                // 右上角
                yuvData[0][(srcHeight - y - 1) * srcWidth + x] = 128;               // 左下角
                yuvData[0][(srcHeight - y - 1) * srcWidth + (srcWidth - x - 1)] = 128; // 右下角
            }
        }
    }

    // U 和 V 平面的圆角裁切
    for (int y = 0; y < uvCornerRadius; y++) {
        for (int x = 0; x < uvCornerRadius; x++) {
            if (sqrt((uvCornerRadius - x) * (uvCornerRadius - x) + (uvCornerRadius - y) * (uvCornerRadius - y)) >= uvCornerRadius) {
                yuvData[1][y * uvWidth + x] = 128;                                     // 左上角
                yuvData[1][y * uvWidth + (uvWidth - x - 1)] = 128;                      // 右上角
                yuvData[1][(uvHeight - y - 1) * uvWidth + x] = 128;                     // 左下角
                yuvData[1][(uvHeight - y - 1) * uvWidth + (uvWidth - x - 1)] = 128;     // 右下角

                yuvData[2][y * uvWidth + x] = 128;                                     // 左上角
                yuvData[2][y * uvWidth + (uvWidth - x - 1)] = 128;                      // 右上角
                yuvData[2][(uvHeight - y - 1) * uvWidth + x] = 128;                     // 左下角
                yuvData[2][(uvHeight - y - 1) * uvWidth + (uvWidth - x - 1)] = 128;     // 右下角
            }
        }
    }
}

/**
 * 缩放图片
 * @param pData
 * @param data YUV数据
 */
void scaleYUV(uint8_t *yuvData[3],int width,int height,int dstWidth,int dstHeight,uint8_t *dstData[3]) {
    //LOGI("scaleYUV 缩放");

    int srcYSize = width * height;
    int srcUSize = width * height / 4;

    // 进行图像缩放
    //LOGI("scaleYUV 原图 %dx%d %d",width,height,sizeof(uint8_t));
    //LOGI("scaleYUV 缩放 %dx%d",dstWidth,dstHeight);


    // 源图像数据
    int srcStride[] = { width, width / 2, width / 2 };
    int dstStride[] = { dstWidth, dstWidth / 2, dstWidth / 2 };

    // 分配缩放后 YUV 数据缓冲区
    int dst_y_size = dstWidth * dstHeight;
    int dst_uv_size = (dstWidth/2) * (dstHeight/2);

    dstData[0] = new uint8_t[dst_y_size];
    dstData[1] = new uint8_t[dst_uv_size];
    dstData[2] = new uint8_t[dst_uv_size];


    // 进行图像缩放
    //LOGI("scaleYUV 缩放开始 sws_ctx：%d",sws_ctx);
    libyuv::I420Scale(
            yuvData[0], srcStride[0],
            yuvData[1], srcStride[1],
            yuvData[2], srcStride[2],
            width, height,
            dstData[0], dstStride[0],
            dstData[1], dstStride[1],
            dstData[2], dstStride[2],
            dstWidth, dstHeight,
            libyuv::kFilterBox  // 使用 Box 滤波器（可选：kFilterNone, kFilterLinear, kFilterBilinear, kFilterBox）
    );
    //LOGI("scaleYUV 缩放完毕 %d",result);
}

void rotate_yuv(uint8_t* srcData[3], int width, int height,int angle,uint8_t* dstData[3],int new_width,int new_height) {

    // 分配缩放后 YUV 数据缓冲区
    int dst_y_size = new_width * new_height;
    int dst_uv_size = (new_width/2) * (new_height/2);
    dstData[0] = new uint8_t[dst_y_size];
    dstData[1] = new uint8_t[dst_uv_size];
    dstData[2] = new uint8_t[dst_uv_size];

    uint8_t* src_y = srcData[0];
    uint8_t* src_u = srcData[1];
    uint8_t* src_v = srcData[2];

    uint8_t* dst_y = dstData[0];
    uint8_t* dst_u = dstData[1];
    uint8_t* dst_v = dstData[2];

    if (angle == 90) {
        // 90 度顺时针旋转
        for (int y = 0; y < height; ++y) {
            for (int x = 0; x < width; ++x) {
                dst_y[x * new_width + (new_width - y - 1)] = src_y[y * width + x];
            }
        }

        for (int y = 0; y < height / 2; ++y) {
            for (int x = 0; x < width / 2; ++x) {
                dst_u[x * new_width / 2 + (new_width / 2 - y - 1)] = src_u[y * width / 2 + x];
                dst_v[x * new_width / 2 + (new_width / 2 - y - 1)] = src_v[y * width / 2 + x];
            }
        }
    } else if (angle == 180) {
        // 180 度旋转
        for (int y = 0; y < height; ++y) {
            for (int x = 0; x < width; ++x) {
                dst_y[(height - y - 1) * width + (width - x - 1)] = src_y[y * width + x];
            }
        }

        for (int y = 0; y < height / 2; ++y) {
            for (int x = 0; x < width / 2; ++x) {
                dst_u[(height / 2 - y - 1) * width / 2 + (width / 2 - x - 1)] = src_u[y * width / 2 + x];
                dst_v[(height / 2 - y - 1) * width / 2 + (width / 2 - x - 1)] = src_v[y * width / 2 + x];
            }
        }
    } else if (angle == 270) {
        // 270 度顺时针旋转
        for (int y = 0; y < height; ++y) {
            for (int x = 0; x < width; ++x) {
                dst_y[(new_height - x - 1) * new_width + y] = src_y[y * width + x];
            }
        }

        for (int y = 0; y < height / 2; ++y) {
            for (int x = 0; x < width / 2; ++x) {
                dst_u[(new_height / 2 - x - 1) * new_width / 2 + y] = src_u[y * width / 2 + x];
                dst_v[(new_height / 2 - x - 1) * new_width / 2 + y] = src_v[y * width / 2 + x];
            }
        }
    }
}
/**
 * 剪切画面
 * @param pData
 * @param data
 */
void cutYUV(uint8_t *yuvData[3],int width,int height ,float positionRate,uint8_t *dstData[3]) {
    float rate = width * 1.0/height;
    int miniHeight = 0;
    int miniWidth = 0;
    if (rate < STREAM_RATE){
        miniWidth = width;
        miniHeight = (miniWidth / 9 * 16);
    }else{
        miniHeight = height;
        miniWidth = (miniHeight / 16 * 9);
    }
    int cropX =(rate < STREAM_RATE) ? 0 : (width) * positionRate;
    int cropY = (rate < STREAM_RATE) ? (height) * positionRate : 0;
    if(cropX + miniWidth > width){
        cropX = width - miniWidth;
    }
    if(cropY + miniHeight > height){
        cropY = height - miniHeight;
    }
    //LOGI("cutYUV 裁切 %dx%d mini：%dx%d crop：%dx%d",width,height,miniWidth,miniHeight,cropX,cropY);

    // 分配目标YUV内存
    int dstYSize = miniWidth * miniHeight;
    int dstUSize = dstYSize / 4;

    dstData[0] = new uint8_t[dstYSize];
    dstData[1] = new uint8_t[dstUSize];
    dstData[2] = new uint8_t[dstUSize];

    // 裁剪Y平面
    for (int y = 0; y < miniHeight; ++y) {
        memcpy(dstData[0] + y * miniWidth,yuvData[0]+ (cropY + y) * width + cropX,
               miniWidth);
    }

    // 裁剪U平面（UV分辨率是Y的1/2）
    for (int y = 0; y < miniHeight / 2; ++y) {
        memcpy(dstData[1] + y * (miniWidth / 2),
               yuvData[1] + (cropY / 2 + y) * (width / 2) + cropX / 2,
               miniWidth / 2);
    }

    // 裁剪V平面
    for (int y = 0; y < miniHeight / 2; ++y) {
        memcpy(dstData[2] + y * (miniWidth / 2),
               yuvData[2] + (cropY / 2 + y) * (width / 2) + cropX / 2,
               miniWidth / 2);
    }
}

/**
 * 加水印（画中画）
 * @param mainData
 */
void waterYUV(uint8_t *mainData[3]) {
    //LOGI("waterYUV 加水印（画中画）");
    int size = pushMiniDatas.size();
    for (int i = 0; i < pushMiniDatas.size(); ++i) {
        MiniViewData *pData = pushMiniDatas[i];
        if(pData->streamCode == mainStreamCode){
            continue;
        }
        if(!pData->videoOn){
            continue;
        }
        if(!pData->scaledYuvFrame && pData->scaledYuvFrames.size() == 0 ){
            //LOGE("小窗丢帧1");
            continue;
        }
        if(pData->scaledYuvFrames.size() > 0){
            releaseYuvFrameData(pData->scaledYuvFrame);
            pData->scaledYuvFrames.pop(pData->scaledYuvFrame);
        }else{
            LOGE("小窗丢帧2");
        }
        //清除yuv画面
        if(pData->yuvFrames.size() > 1){
            if(!pData->yuvFrame){
                pData->yuvFrames.pop(pData->yuvFrame);
            }
            while (pData->yuvFrame->timestamp < pData->scaledYuvFrame->timestamp && pData->yuvFrames.size() > 1 ){
                releaseYuvFrameData(pData->yuvFrame);
                pData->yuvFrames.pop(pData->yuvFrame);
            }
        }

        YUVData *scaledYuvFrame = pData->scaledYuvFrame;
        //位置
        int offsetY = (mainHeight - scaledYuvFrame->height) * scaledYuvFrame->pYrate;
        int offsetX = (mainWidth - scaledYuvFrame->width) * scaledYuvFrame->pXrate;

        //LOGI("waterYUV %dx%d x:%d,y:%d  x:%f,y:%f [0]:%d",pData->scaleWidth,miniHeight,pData->pYrate,pData->pXrate,offsetX,offsetY,pData->scaledYUVData[0]);

        // 边界检查，确保不会越界
        if (offsetX + scaledYuvFrame->width > mainWidth ) {
            offsetX = mainWidth - scaledYuvFrame->width - 1;
        }
        if (offsetY + scaledYuvFrame->height > mainHeight) {
            offsetY = mainHeight - scaledYuvFrame->height - 1;
        }
        if( scaledYuvFrame->height > mainHeight || scaledYuvFrame->width > mainWidth){
            LOGE("超出边界");
            return;
        }
        // 处理 Y 平面
        for (int y = 0; y < scaledYuvFrame->height; y++) {
            uint8_t* main_y_row = mainData[0] + (offsetY + y) * mainWidth + offsetX;
            uint8_t* mini_y_row = scaledYuvFrame->yuvData[0] + y * scaledYuvFrame->width;

            memcpy(main_y_row, mini_y_row, scaledYuvFrame->width);
        }

        // 处理 U 平面
        for (int y = 0; y < scaledYuvFrame->height / 2; y++) {
            uint8_t* main_u_row = mainData[1] + ((offsetY / 2) + y) * (mainWidth / 2) + (offsetX / 2);
            uint8_t* mini_u_row = scaledYuvFrame->yuvData[1] + y * (scaledYuvFrame->width / 2);

            memcpy(main_u_row, mini_u_row, scaledYuvFrame->width / 2);
        }

        // 处理 V 平面
        for (int y = 0; y < scaledYuvFrame->height / 2; y++) {
            uint8_t* main_v_row = mainData[2] + ((offsetY / 2) + y) * (mainWidth / 2) + (offsetX / 2);
            uint8_t* mini_v_row = scaledYuvFrame->yuvData[2] + y * (scaledYuvFrame->width / 2);

            memcpy(main_v_row, mini_v_row, scaledYuvFrame->width / 2);
        }
    }

}

uint8_t* yuvToRGBA(uint8_t *yuvData[3],int width,int height){

    // 将 I420 转为 RGBA
    // 分配 RGBA 缓冲区
    int rgba_size = width * height * 4; // RGBA 每个像素 4 字节
    uint8_t* rgba_data = new uint8_t[rgba_size];

    /*int y_stride = width;           // Y 平面的步幅
    int uv_stride = width / 2;      // U 和 V 平面的步幅
    int rgba_stride = width * 4;    // RGBA 的步幅，每个像素 4 字节


    //YUV->RGBA_8888
    libyuv::I420ToARGB(yuvData[0], y_stride, yuvData[2], uv_stride, yuvData[1], uv_stride, rgba_data, rgba_stride, width, height);*/

    // 初始化SwsContext
    struct SwsContext* sws_ctx = sws_getContext(width, height, AV_PIX_FMT_YUV420P,  // 输入格式
            width, height, AV_PIX_FMT_RGBA,    // 输出格式
            SWS_BILINEAR, nullptr, nullptr, nullptr);

    // YUV420P 的 linesize (Y, U, V)
    int yuv_linesize[3] = { width, width / 2, width / 2 }; // YUV420P: U 和 V 的宽度是 Y 的一半

    uint8_t* dest[4] = { rgba_data, nullptr, nullptr, nullptr };
    int dest_linesize[4] = { width * 4, 0, 0, 0 };

    // 转换 YUV 到 RGBA
    sws_scale(sws_ctx, yuvData, yuv_linesize, 0, height, dest, dest_linesize);
    // 释放上下文
    sws_freeContext(sws_ctx);
    return  rgba_data;
}
void copyYUV(uint8_t *yuvData[3],int width,int height, uint8_t *dstData[3]){
    // 计算每个平面的大小
    size_t y_size = width * height;         // Y 平面大小
    size_t u_size = (width / 2) * (height / 2); // U 平面大小
    size_t v_size = (width / 2) * (height / 2); // V 平面大小

    dstData[0] = new uint8_t[y_size];
    dstData[1] = new uint8_t[u_size];
    dstData[2] = new uint8_t[v_size];

    size_t slice_sizes[3] = {y_size, u_size, v_size};

    for (int i = 0; i < 3; ++i) {
        if (yuvData[i] && dstData[i] && slice_sizes[i] > 0) {
            // Copy the data from the source slice to the destination slice
            memcpy(dstData[i], yuvData[i], slice_sizes[i]);
        }
    }
}

void pushYUV(int streamCode, uint8_t *yuvData[3]) {
    //LOGI("pushYUV");
    MiniViewData *miniView = getMiniView(streamCode);
    if(!miniView){
        return;
    }
    if(miniView->videoOn || miniView->streamCode == mainStreamCode){
        pthread_mutex_lock(&pushVideoMutex);
        YUVData *yuvFrame = new YUVData();
        yuvFrame->width = miniView->width;
        yuvFrame->height = miniView->height;
        yuvFrame->timestamp = RTMP_GetTime() - start_time;
        yuvFrame->mainPositionRate = miniView->mainPositionRate;
        copyYUV(yuvData,miniView->width,miniView->height,yuvFrame->yuvData);
        miniView->yuvFrames.push(yuvFrame);
        //缩放尺寸
        //LOGI("pushYUV viewRate:%f", miniView->viewRate);
        int scaleWidth = (FRAME_WIDTH * miniView->viewRate);
        int scaleHeight = (FRAME_WIDTH / (miniView->width * 1.0 / miniView->height) * miniView->viewRate);
        //涉及到 YUV 4:2:0 格式的图像时，宽度和高度通常需要是 2 的倍数
        if(scaleWidth % 2 == 1){
            scaleWidth+=1;
        }
        if(scaleHeight % 2 == 1){
            scaleHeight+=1;
        }
        if(scaleWidth > FRAME_WIDTH){
            scaleWidth = FRAME_WIDTH;
        }
        if(scaleHeight > FRAME_HEIGHT){
            scaleHeight = FRAME_HEIGHT;
        }
        YUVData *scaleYuvFrame = new YUVData();
        scaleYuvFrame->width = scaleWidth;
        scaleYuvFrame->height = scaleHeight;
        scaleYuvFrame->pYrate = miniView->pYrate;
        scaleYuvFrame->pXrate = miniView->pXrate;
        scaleYuvFrame->timestamp = yuvFrame->timestamp;
        scaleYUV(yuvFrame->yuvData,yuvFrame->width,yuvFrame->height,scaleYuvFrame->width,scaleYuvFrame->height,scaleYuvFrame->yuvData);
        addBlackBorder(scaleYuvFrame->yuvData,scaleWidth,scaleHeight,3);
        miniView->scaledYuvFrames.push(scaleYuvFrame);
        //最大缓存画面数量不能超过max(5-10)帧
        int max = 15;int min = 3;
        if(miniView->yuvFrames.size() > (mainStreamCode == miniView->streamCode ? max:min) ){
            if(mainStreamCode == miniView->streamCode){
                LOGE("%d 溢帧 pushyuv %d",streamCode,miniView->yuvFrames.size() - (miniView->videoOn ? max:min));
            }
            while (miniView->yuvFrames.size() > (mainStreamCode == miniView->streamCode ? max:min)){
                releaseYuvFrameData(miniView->yuvFrame);
                miniView->yuvFrames.pop(miniView->yuvFrame);
            }
        }
        if(miniView->scaledYuvFrames.size() > (miniView->videoOn ? max:min)){
            if(miniView->videoOn && mainStreamCode != miniView->streamCode){
                LOGE("%d 溢帧 pushyuv %d",streamCode,miniView->scaledYuvFrames.size() - (miniView->videoOn ? max:min) );
            }
            while (miniView->scaledYuvFrames.size() > (miniView->videoOn ? max:min)){
                releaseYuvFrameData(miniView->scaledYuvFrame);
                miniView->scaledYuvFrames.pop(miniView->scaledYuvFrame);
            }
        }
        pthread_mutex_unlock(&pushVideoMutex);

    }
}

void pushYUYV(int streamCode,jbyte *yuyvData){

    MiniViewData *miniView = getMiniView(streamCode);
    if(!miniView){
        return;
    }
    int width = miniView->width;
    int height = miniView->height;
    int y_size = width * height;
    int uv_size = y_size / 4;

    uint8_t *data[3];
    // 分配 YUV 数据
    data[0] = new uint8_t[y_size];    // Y
    data[1] = new uint8_t[uv_size];   // U
    data[2] = new uint8_t[uv_size];   // V

    // YUYV -> YUV420P 转换
    for (int i = 0, j = 0; i < y_size; i += 2, j++) {
        // 从 YUYV 获取 Y 分量（Y1 和 Y2）
        data[0][i] = yuyvData[i * 2];      // Y1
        data[0][i + 1] = yuyvData[i * 2 + 2]; // Y2

        // 从 YUYV 获取 U 和 V 分量
        if (i % 2 == 0) {
            // U 和 V 共享
            data[1][j] = yuyvData[i * 2 + 1];  // U
            data[2][j] = yuyvData[i * 2 + 3];  // V
        }
    }
    pushYUV(streamCode,data);
}

void pushNV21(int streamCode, jbyte *data) {
    MiniViewData *miniView = getMiniView(streamCode);
    if(!miniView){
        return;
    }
    if(miniView->width == 0 || miniView->height == 0){
        return;
    }
    pthread_mutex_lock(&pushNV21Mutex);
    int src_frame_size = miniView->width * miniView->height * 3 / 2;
    uint8_t *nv21_data = (uint8_t*)data;

    //LOGI("pushNV21 %dx%d",miniView->width ,miniView->height);
    //LOGI("pushNV21 %d",src_frame_size);
    // 输入的 YUV420P 数据
    uint8_t* srcYUV420P = (uint8_t*)malloc(src_frame_size);

    int frame_size = miniView->width * miniView->height;
    uint8_t* y_plane = srcYUV420P;
    uint8_t* u_plane = srcYUV420P + frame_size;
    uint8_t* v_plane = srcYUV420P + frame_size + frame_size / 4;

    // 拷贝 Y 平面
    /*memcpy(y_plane, nv21_data, frame_size);

    // NV21 的 UV 是交错的，VU VUVUVU...
    uint8_t* uv_plane = nv21_data + frame_size;
    for (int i = 0; i < frame_size / 4; i++) {
        v_plane[i] = uv_plane[2 * i];     // NV21 中 V 在前
        u_plane[i] = uv_plane[2 * i + 1]; // U 在后
    }*/
    uint8_t *src_yplane = nv21_data;
    uint8_t *src_uvplane = nv21_data + miniView->width * miniView->height;

    libyuv::NV21ToI420(
            (const uint8_t *) src_yplane, miniView->width,
            (const uint8_t *) src_uvplane, miniView->width,
            (uint8_t *) y_plane, miniView->width,
            (uint8_t *) u_plane, miniView->width / 2,
            (uint8_t *) v_plane, miniView->width / 2,
            miniView->width, miniView->height);
    // 输入数据的平面指针
    uint8_t* src_slices[3] = {srcYUV420P,srcYUV420P + frame_size,srcYUV420P + frame_size + frame_size / 4};
    pushYUV(streamCode,src_slices);
    free(srcYUV420P);
    pthread_mutex_unlock(&pushNV21Mutex);
}

void pushRGBA(int streamCode, uint8_t *rgbaData){
    MiniViewData *miniView = getMiniView(streamCode);
    if(!miniView){
        return;
    }
    //LOGI("pushRGBA %d",rgbaData);
    //RGBA转yuv
    if(miniView->width == 0 || miniView->height == 0){
        return;
    }
    int frameSize = miniView->width * miniView->height;
    int uvSize = (miniView->width / 2) * (miniView->height / 2);
    // 为 YUV 数据分配内存
    int yuvSize = frameSize * 3 / 2;  // YUV420P 的大小
    uint8_t *yuvData = new uint8_t[yuvSize];

    // 将 yuvData 分成 3 部分（Y、U、V）
    uint8_t *yPlane = yuvData;
    uint8_t *uPlane = yuvData + frameSize;
    uint8_t *vPlane = uPlane + uvSize;

    // 使用 libyuv 将 RGBA 转换为 YUV420P
    libyuv::ARGBToI420(
            reinterpret_cast<uint8_t*>(rgbaData), miniView->width * 4,   // RGBA 数据和每行宽度（RGBA 每个像素 4 字节）
            yPlane, miniView->width,                                     // Y 分量数据
            uPlane, miniView->width / 2,                                 // U 分量数据
            vPlane, miniView->width / 2,                                 // V 分量数据
            miniView->width,                                             // 宽度
            miniView->height                                             // 高度
    );
    //LOGI("pushRGBA width:%d height:%d %d",miniView->width,miniView->height,rgbaData);
    // 输入数据的平面指针
    uint8_t* src_slices[3] = {yuvData,yuvData + frameSize,yuvData + frameSize + frameSize / 4};

    pushYUV(streamCode,src_slices);
    // 释放资源
    free(yuvData);
}

void pushNV21(int streamCode,uint8_t *yData,uint8_t *uData,uint8_t *vData,jint y_stride, jint u_stride,jint v_stride, jint uv_stride,jint angle,jint width,jint height){

    MiniViewData *miniView = getMiniView(streamCode);
    if(!miniView){
        return;
    }
    //LOGI("pushNV21");
    //nv21转yuv
    if(miniView->width == 0 || miniView->height == 0){
        return;
    }
    pthread_mutex_lock(&pushNV21Mutex);
    // 创建目标 I420 数据
    int ySize = width * height;
    int uvSize = width * height / 4; // UV 分量的大小（YUV 4:2:0）

    uint8_t* i420Y = new uint8_t[ySize];
    uint8_t* i420U = new uint8_t[uvSize];
    uint8_t* i420V = new uint8_t[uvSize];

    // 使用 libyuv 将 YUV 数据转换为 I420
    libyuv::Android420ToI420(yData, y_stride,uData, u_stride,vData, v_stride,uv_stride,
                             i420Y, width,i420U, width/2,i420V,width/2,
                             width, height);
    // 输入数据的平面指针
    uint8_t* src_slices[3] = {i420Y,i420U,i420V};
    if(angle != 0){
        uint8_t *dstData[3];
        int new_width = (angle%180 == 0) ? width : height;
        int new_height = (angle%180 == 0) ? height : width;
        LOGI("rotate_yuv angle:%d",angle);
        rotate_yuv(src_slices, width, height,angle,dstData,new_width,new_height);
        pushYUV(streamCode,dstData);
        delete[] i420Y;
        delete[] i420U;
        delete[] i420V;
    }else{
        pushYUV(streamCode,src_slices);
    }
    pthread_mutex_unlock(&pushNV21Mutex);
}

void loadSurface(ANativeWindow *nativeWindow,uint8_t *yuvData[3],int width,int height){
    if(nativeWindow){
        int64_t t = getCurrentTimestamp();

        uint8_t* rgba_data = yuvToRGBA(yuvData,width,height);
        int64_t t1 = getCurrentTimestamp();
        //缓冲区
        //LOGI("视频缓冲");
        ANativeWindow_setBuffersGeometry(nativeWindow,width,height,WINDOW_FORMAT_RGBA_8888);
        ANativeWindow_Buffer outBuffer;
        int64_t t2 = getCurrentTimestamp();

        ANativeWindow_lock(nativeWindow , &outBuffer,NULL);
        int64_t t3 = getCurrentTimestamp();
        //渲染
        //LOGI("开始渲染");
        //把buffer中的数据进行赋值（修改）
        uint8_t *dst_data = static_cast<uint8_t *>(outBuffer.bits);
        int dst_lineSize = width * 4;//ARGB
        //逐行拷贝
        // 将 RGB 数据逐行复制到窗口缓冲区
        for (int i = 0; i < height; i++) {
            memcpy(dst_data + i * outBuffer.stride * 4, rgba_data + i * dst_lineSize, dst_lineSize);
        }
        int64_t t4 = getCurrentTimestamp();
        ANativeWindow_unlockAndPost(nativeWindow);
        delete[] rgba_data;
        //LOGI("loadSurface 耗时：%d sws_scale:%d memcpy:%d ANativeWindow_lock:%d 视频缓冲:%d %dx%d",getCurrentTimestamp() - t,t1-t,t4-t3,t3-t2,t2-t1,width,height);
    }
}

void pushPCM(int8_t *data){

    //LOGI("pushPCM1");
    pthread_mutex_lock(&pushAudioMutex);
    //LOGI("pushPCM2");
    audioChannel->encodeData(data);
    //LOGI("pushPCM3");
    pthread_mutex_unlock(&pushAudioMutex);
}

void playPcm(uint8_t *out_buffer,int out_buffer_size){

}


void releaseYuvFrameData(YUVData *yuvData){
    if(yuvData){
        releaseYuvData(yuvData->yuvData);
        delete yuvData;
    }
}
void releaseYuvData(uint8_t *yuvData[3]){
    if(yuvData[0] != NULL){
        delete[] yuvData[0];
        delete[] yuvData[1];
        delete[] yuvData[2];
        yuvData[0] = NULL;
    }
}

void releaseYuvDataCallBack(YUVData **yuvData){
    if (!yuvData || !*yuvData) return;  // 先判断是否为空
    //free((*yuvData)->yuvData);
    //YUVData yuv;  // 栈上变量（不能 delete）
    //delete *yuvData;
}