#include <string.h>
#include <tgmath.h>
#include <stdbool.h>
#include "stdlib.h"
#include "unistd.h"
#include "stdio.h"
#include "ImageUtil.h"

/**
 * 分离yuv420p图片的yuv数据
 * @param url yuv图片的地址
 * @param w 文件宽
 * @param h 文件的高
 * @param num 图片的大小
 * @return 
 */
int simplest_yuv420_split(char *url, int w, int h, int num) {
    FILE *fp = fopen(url, "rb+");
    FILE *fp_y = fopen("output_420p_y.y", "wb+");
    FILE *fp_u = fopen("output_420p_u.y", "wb+");
    FILE *fp_v = fopen("output_420p_v.y", "wb+");
    
    // y 占用的大小: w * h byte;
    // u 占用的大小: w / 2 * h / 2 = w * h / 4 byte;
    // v 占用的大小: w / 2 * h / 2 = w * h / 4 byte;
    // 总大小: 1 + 1/2 = 3/2(w * h) byte
    unsigned char *pic = (unsigned char*) calloc(1, w *h * 3 / 2);
    for (int i = 0; i < num; ++i) {
        fread(pic, 1, w * h * 3 / 2, fp);
        // Y
        fwrite(pic, 1, w * h / 4, fp_y);
        // U
        fwrite(pic, 1, w * h / 4, fp_u);
        // V
        fwrite(pic, 1, w * h / 4, fp_v);
    }
    free(pic);
    fclose(fp);
    fclose(fp_y);
    fclose(fp_v);
    fclose(fp_u);
    return 0;
}

/**
 * 分离yuv444p图片数据
 * @param url 
 * @param w 
 * @param h 
 * @param num 
 * @return 
 */
int simplest_yuv444_split(char *url, int w, int h, int num) {
    FILE *fp = fopen(url, "wb+");
    FILE *fp_y = fopen("output_444_y.y", "wb+");
    FILE *fp_u = fopen("output_444_u.y", "wb+");
    FILE *fp_v = fopen("output_444_v.y", "wb+");

    unsigned char *pic = (unsigned char*)calloc(1, w * h * 3);

    // yuv_444p格式
    // y 占用 w * h byte
    // u 占用 w * h byte
    // v 占用 w * h byte
    // 总的大小: w * h * 3 byte
    for (int i = 0; i < num; ++i) {
        fread(pic,1, w * h * 3, fp);
        fwrite(pic, 1, w * h, fp_y);
        fwrite(pic + w * h,1,w * h, fp_u);
        fwrite(pic + w * h * 2, 1, w * h, fp_v);
    }
    
    free(pic);
    fclose(fp);
    fclose(fp_y);
    fclose(fp_u);
    fclose(fp_v);

    return 0;
}


/**
 * 将yuv420转成灰色
 * uv都转成128便可
 * @param url 
 * @param w 
 * @param h 
 * @param num 
 * @return 
 */
int simplest_yuv420_gray(char *url, int w, int h, int num) {
    FILE *fp = fopen(url, "wb+");
    FILE *fp1 = fopen("output_gray.yuv", "wb+");
    unsigned char *pic = (unsigned char*)calloc(1, w *h *3 / 2);

    for (int i = 0; i < num; ++i) {
        fread(pic, 1, w * h * 3 / 2, fp);
        // Gray 将uv分量转成128就变成灰度图了
        memset(pic +w * h, 128, w * h /2);
        fwrite(pic, 1, w * h * 3 / 2, fp1);
    }
    free(pic);
    fclose(fp);
    fclose(fp1);
    
    return 0;
}

/**
 * 亮度减半
 * @param url 
 * @param w 
 * @param h 
 * @param num 
 * @return 
 */
int simplest_yuv_420_halfy(char *url, int w, int h, int num) {
    FILE *fp = fopen(url, "rb+");
    FILE *out = fopen("output_halfy.yuv", "wb+");
    unsigned char *pic = (unsigned char*)malloc(w*h*3/2);

    for (int i = 0; i < num; ++i) {
        fread(pic, 1, w * h * 3 / 2, fp);
        // y减半
        for (int j = 0; j < w * h; ++j) {
            unsigned char tmp = pic[j] /2;
            pic[j] = tmp;
        }
        fwrite(pic, 1, w *h * 3/ 2, out);
    }
    
    free(pic);
    fclose(fp);
    fclose(out);
    return 0;
}


/**
 * 给y通道对应边界大小的值设为最大便可以作为边框
 * @param url 
 * @param w 
 * @param h 
 * @param border 
 * @param num 
 * @return 
 */
int simplest_yuv420_border(char *url, int w, int h, int border, int num) {
    FILE *fp = fopen(url, "rb+");
    FILE *out = fopen("output_boder.yuv", "wb+");
    unsigned char *pic = (unsigned char*)calloc(1, w * h * 3 / 2);
    for (int i = 0; i < num; ++i) {
        fread(pic,1, w * h * 3/2, fp);
        // y
        for (int j = 0; j < h; ++j) {
            for (int k = 0; k < w; ++k) {
                if (k < border || k > (w - border) || j < border || j > (h - border)){
                    pic[j * w +k] = 255;
                }
            }
        }
        fwrite(pic, 1, w * h * 3/2, out);
    }
    
    free(pic);
    fclose(fp);
    fclose(out);
    return 0;
}

int simplest_yuv420_graybar(int width, int height, int ymin, int ymax, int barnum, char *url_out){
    int barwidth;
    float lum_inc;
    unsigned char lum_temp;
    int uv_width, uv_height;
    FILE *fp = NULL;
    unsigned char *data_y = NULL;
    unsigned char *data_u = NULL;
    unsigned char *data_v = NULL;
    int t = 0, i = 0, j = 0;
    
    barwidth = width / barnum;
    lum_inc = (float)(ymax - ymin)/((float )barnum - 1);
    uv_width = width / 2;
    uv_height = height / 2;
    
    data_y = (unsigned char *)malloc(width * height);
    data_u = (unsigned char *)malloc(uv_width * uv_height);
    data_v = (unsigned char *)malloc(uv_width * uv_height);
    
    if ((fp = fopen(url_out, "wb+")) == NULL) {
        printf("Error: Cannot create file!\n");
        return -1;
    }
    
    // 生成数据
    for(j = 0;j < height;j ++) {
        for(i = 0;i < width;i ++) {
            t = i / barwidth;
            lum_temp= ymin + (char)(t * lum_inc);
            data_y[j * width + i] = lum_temp;
        }
    }
    for(j = 0;j < uv_height;j ++){
        for(i = 0;i < uv_width;i ++) {
            data_u[j * uv_width + i] = 128;
            data_v[j * uv_width + i] = 128;
        }
    }
    
    fwrite(data_y, width * height, 1, fp);
    fwrite(data_u, uv_width * uv_height, 1, fp);
    fwrite(data_v, uv_height * uv_width, 1, fp);
    
    
    
    fclose(fp);
    free(data_v);
    free(data_u);
    free(data_y);
    
    
    
    
}

/**
 * 计算两个yuv的psnr
 * @param url1 
 * @param url2 
 * @param w 
 * @param h 
 * @param num 
 * @return
 */
int simplest_yuv420_psnr(char *url1, char *url2, int w, int h, int num) {
    FILE *fp1 = fopen(url1, "rb+");
    FILE *fp2 = fopen(url2, "rb+");
    unsigned char *pic1 = (unsigned char*)malloc(w * h);
    unsigned char *pic2 = (unsigned char*)malloc(w * h);

    for (int i = 0; i < num; ++i) {
        fread(pic1, 1, w *h , fp1);
        fread(pic2, 1, w * h, fp2);
        
        double mse_sum = 0, mse = 0, psnr = 0;
        for (int j = 0; j < w * h; ++j) {
            mse_sum += pow((double)(pic1[j] - pic2[j]), 2);
        }
        mse = mse_sum / (w * h);
        psnr = 10 * log10(255.0 * 255.0 / mse);
        printf("%5.3f\n", psnr);
        
        fseek(fp1, w *h / 2, SEEK_CUR);
        fseek(fp2, w *h / 2, SEEK_CUR);
        
    }

    free(pic1);
    free(pic2);
    fclose(fp1);
    fclose(fp2);
    return 0;
}


/**
 * rbg24图片顺序为[r,g,b],[r,g,b]
 * @param url 
 * @param w 
 * @param h 
 * @param num 
 * @return 
 */
int simplest_rgb24_split(char *url, int w, int h, int num){
    FILE *fp = fopen(url, "wb+");
    FILE *fp_r = fopen("output_r.y", "wb+");
    FILE *fp_g = fopen("output_g.y", "wb+");
    FILE *fp_b = fopen("output_b.y", "wb+");

    unsigned char *pic = (unsigned char*)malloc(w *h * 3);
    for (int i = 0; i < num; ++i) {
        fread(pic, 1, w * h * 3, fp);
        for (int j = 0; j < w * h * 3; j = j + 3) {
            // R
            fwrite(pic + j, 1, 1, fp_r);
            // G
            fwrite(pic + j + 1, 1,1,fp_g);
            // B
            fwrite(pic + j + 2, 1, 1, fp_b);
        }
    }

    free(pic);
    fclose(fp);
    fclose(fp_r);
    fclose(fp_g);
    fclose(fp_b);
}


int simplest_rgb24_to_bmp(const char *rgb24path, int width, int height, const char *bmppath) {
    int i = 0,j = 0;
    BITMAPFILEHEADER fHeader = {0};
    BITMAPINFOHEADER iHeader = {0};
    int header_size = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPFILEHEADER);
    unsigned char *rgb24_buffer  = NULL;
    FILE *fp_rgb24 = NULL,*fp_bmp = NULL;
    
    if ((fp_rgb24 = fopen(rgb24path, "rb")) == NULL){
        printf("Error: Cannot open input RGB24 file.\n");
        return -1;
    }
    if ((fp_bmp = fopen(bmppath, "wb")) == NULL) {
        printf("Error: Cannot open output BMP file.\n");
        fclose(fp_rgb24);
        return -1;
    }
    rgb24_buffer = (unsigned char *)malloc(width * height * 3);
    fread(rgb24_buffer, 1, width * height * 3, fp_rgb24);
    
    
    fHeader.bfType = 6677;
    fHeader.bfSize = header_size + width * height * 3;
    fHeader.bfOffBits = header_size;

    iHeader.biSize = sizeof(iHeader);
    iHeader.biWidth = width;
    iHeader.biHeight = height;
    iHeader.biPlanes = 1;
    iHeader.biBitCount = 24;
    
    fwrite(&fHeader, 1, sizeof(BITMAPFILEHEADER), fp_bmp);
    fwrite(&iHeader, 1, sizeof(BITMAPINFOHEADER), fp_bmp);

    // RGB = > BGR
    for (j = 0; j < height; ++j) {
        for (i = 0; i < width; ++i) {
            char temp = rgb24_buffer[j * width * 3 + i + 2];
            // exchange
            rgb24_buffer[j * width * 3 + i + 2] = rgb24_buffer[j * width * 3 + i + 0];
            rgb24_buffer[j * width * 3 + i + 0] = temp;
        }
    }
    fwrite(rgb24_buffer, width * height * 3, 1, fp_bmp);
    fclose(fp_rgb24);
    fclose(fp_bmp);
    free(rgb24_buffer);
    printf("finish generate: %s\n", bmppath);
    return 0;
    
}


static clip_value(unsigned char x, unsigned char min_val, unsigned max_val) {
    if (x > max_val) {
        return max_val;
    }else if(x < min_val) {
        return min_val;
    }else{
        return x;
    };
}

static int rbg24_to_yuv420(unsigned char *rgb_buf, int w, int h, unsigned char *yuv_buf) {
    unsigned char *ptr_y, *ptr_u, *ptr_v, *ptr_rgb;
    memset(yuv_buf, 0, w * h * 3 / 2);
    ptr_y = yuv_buf;
    ptr_u = yuv_buf + w * h;
    ptr_v = ptr_u + (w * h * 1 / 4);
    unsigned char y,u,v,r,g,b;
    for (int j = 0; j < h; ++j) {
        ptr_rgb = rgb_buf + w * j * 3;
        for (int i = 0; i < w; ++i) {
            r = *(ptr_rgb++);
            g = *(ptr_rgb++);
            b = *(ptr_rgb++);
            
            y = (unsigned char)(( 66 * r + 129 * g +  25 * b + 128) >> 8) + 16;
            u = (unsigned char)(( -38 * r -  74 * g + 112 * b + 128) >> 8) + 128;
            v = (unsigned char)(( 112 * r -  94 * g -  18 * b + 128) >> 8) + 128;
            
            *(ptr_y ++) = clip_value(y, 0, 255);
            
            // u / v 在水平方向和垂直的一半
            if (j % 2 == 0 && i % 2 == 0) {
                *(ptr_u) = clip_value(u, 0, 255);
            }else{
                if (i % 2 == 0) {
                    *(ptr_v ++) = clip_value(v, 0, 255);
                }
            }
        }
    }
}

/**
 * 转换的算法
 *    Y= 0.299*R+0.587*G+0.114*B
 *  U=-0.147*R-0.289*G+0.463*B
 *  V= 0.615*R-0.515*G-0.100*B
 * @param url 
 * @param w 
 * @param h 
 * @param num 
 * @param _ou 
 * @return 
 */
int simplest_rbg24_to_yuv420 (char *rgb24path, int w, int h, int num, char *yuv420path) {
    FILE *fp = fopen(rgb24path, "rb+");
    FILE *out = fopen(yuv420path, "wb+");
    unsigned char *pic_rgb24 = (unsigned char*)malloc(w * h * 3);
    unsigned char *pic_yuv420 = (unsigned char*)malloc(w * h * 3 / 2);
    for (int i = 0; i < num; ++i) {
        fread(pic_rgb24, 1, w * h * 3, fp);
        rbg24_to_yuv420(pic_rgb24, w, h, pic_yuv420);
        fwrite(pic_yuv420,1, w * h * 3 / 2, out);
    }
    free(pic_rgb24);
    free(pic_yuv420);
    fclose(fp);
    fclose(out);
    return 0;
}

int simplest_rgb24_colorbar(int w, int h, char *out_url) {
    unsigned char *data = NULL;
    int barwidth;
    FILE *fp = NULL;
    if ((fp = fopen(out_url, "wb+")) == NULL) {
        printf("Error: Cannot create file.\n");
        return -1;
    }
    data = (unsigned char*)malloc(w * h * 3);
    barwidth = w / 8;
    for (int j = 0; j < h; ++j) {
        for (int i = 0; i < w; ++i) {
            int barnum = i / barwidth;
            switch (barnum) {
                case 0:
                {
                    data[(j * w + i) * 3 + 0] = 255;
                    data[(j * w + i) * 3 + 1] = 255;
                    data[(j * w + i) * 3 + 2] = 255;
                    break;
                }
                case 1:{
                    data[(j * w + i) * 3 + 0] = 255;
                    data[(j * w + i) * 3 + 1] = 255;
                    data[(j * w + i) * 3 + 2] = 0;
                    break;
                }
                case 2:
                {
                    data[(j * w + i) * 3 + 0] = 255;
                    data[(j * w + i) * 3 + 1] = 255;
                    data[(j * w + i) * 3 + 2] = 255;
                    break;
                }
                case 3:
                {
                    data[(j * w + i) * 3 + 0] = 0;
                    data[(j * w + i) * 3 + 1] = 255;
                    data[(j * w + i) * 3 + 2] = 255;
                    break;
                }
                case 4:
                {
                    data[(j * w + i) * 3 + 0] = 0;
                    data[(j * w + i) * 3 + 1] = 255;
                    data[(j * w + i) * 3 + 2] = 0;
                    break;
                }
                case 5:
                {
                    data[(j * w + i) * 3 + 0] = 255;
                    data[(j * w + i) * 3 + 1] = 0;
                    data[(j * w + i) * 3 + 2] = 255;
                    break;
                }
                case 6:
                {
                    data[(j * w + i) * 3 + 0] = 255;
                    data[(j * w + i) * 3 + 1] = 0;
                    data[(j * w + i) * 3 + 2] = 0;
                    break;
                }
                case 7:
                {
                    data[(j * w + i) * 3 + 0] = 0;
                    data[(j * w + i) * 3 + 1] = 0;
                    data[(j * w + i) * 3 + 2] = 255;
                    break;
                }
            }
        }
    }
    
    fwrite(data, w * h * 3 ,1, fp);
    fclose(fp);
    free(data);
}

typedef enum {
    NALU_TYPE_SLICE = 1,
    NALU_TYPE_DPA = 2,
    NALU_TYPE_DPB = 3,
    NALU_TYPE_DPC = 4,
    NALU_TYPE_IDR = 5,
    NALU_TYPE_SEI = 6,
    NALU_TYPE_SPS = 7,
    NALU_TYPE_PPS = 8,
    NALU_TYPE_AUD = 9,
    NALU_TYPE_EOSEQ = 10,
    NALU_TYPE_EOSTREAM = 11,
    NALU_TYPE_FILL = 12,
} NaluType;

typedef enum  {
    NALU_PRIORITY_DISPOSABLE = 0,
    NALU_PRIRITY_LOW         = 1,
    NALU_PRIORITY_HIGH       = 2,
    NALU_PRIORITY_HIGHEST    = 3
}NaluPriority;

FILE *h264bitstream = NULL;

int info2 = 0, info3 = 0;

// startcode == 0x000001 ? 1 : 0
static int FindStartCode2(const unsigned char *buf) {
    if (buf[0] != 0 || buf[1] != 0 || buf[2] != 1) return 0;
    return 1;
}

// startcode == 0x00000001 ? 1 : 0
static int FindStartCode3(const unsigned char *buf) {
    if (buf[0] != 0 || buf[1] != 0 || buf[2] != 0 || buf[3] != 1) return 0;
    return 1;
}

typedef struct {
    int startcodeprefix_len; // startcoder长裤
    unsigned len;            // nalu长度，不包括starcode
    unsigned max_size;       // NAL Unit Buffer size
    int forbiden_bit;        // always FALSE
    int nal_reference_idc;   // NALU_PRIORITY_xxx
    int nal_unit_type;       // NALU_TYPE_xxxx
    char *buf;               // EBSP内容
}NALU_t;

int GetAnnexbNALU(NALU_t *nalu) {
    int pos = 0;
    int StartCodeFound, rewind;
    unsigned char *buf;
    if ((buf = (unsigned char*)calloc(nalu->max_size,sizeof(char))) == NULL){
        printf("GetAnnexbNALU:Could not allocate buf memory\n");
    }
    nalu->startcodeprefix_len = 3;
    if (3 != fread(buf, 1, 3, h264bitstream)) {
        free(buf);
        return 0;
    }
    info2 = FindStartCode2(buf);
    if (1 != info2) {
        if (1 != fread(buf + 3, 1, 1,h264bitstream)){
            free(buf);
            return 0;
        }
        info3 = FindStartCode3(buf);
        if (1 != info3) {
            free(buf);
            return -1;
        }else{
            pos = 4;
            nalu->startcodeprefix_len = 4;
        }
    }else{
        // found
        nalu->startcodeprefix_len = 3;
        pos = 3;
    }
    StartCodeFound = 0;
    info2 = 0;
    info3 = 0;
    while (!StartCodeFound) {
        if (feof(h264bitstream)) {
            nalu->len = (pos - 1) - nalu->startcodeprefix_len;
            memcpy(nalu->buf, &buf[nalu->startcodeprefix_len], nalu->len);
            nalu->forbiden_bit = nalu->buf[0] & 0x80;
            nalu->nal_reference_idc = nalu->buf[0] & 0x60;
            nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;
            free(buf);
            return pos - 1;
        }
        buf[pos ++] = fgetc(h264bitstream);
        info3 = FindStartCode3(&buf[pos - 4]);
        if (1 != info3) {
            info2 = FindStartCode2(&buf[pos - 3]);
        }
        StartCodeFound = (info2 == 1 || info3 == 1);
    }
    
    
    rewind = (info3 == 1)? -4 : -3;
    if (0 != fseek(h264bitstream,rewind, SEEK_CUR)) {
        free(buf);
        printf("GetAnnexbNALU: Cannot Fseek in the bit stream file\n");
    }
    
    nalu->len = (pos + rewind) - nalu->startcodeprefix_len;
    memcpy(nalu->buf, &buf[nalu->startcodeprefix_len], nalu->len);
    nalu->forbiden_bit = nalu->buf[0] & 0x80; //1 bit
    nalu->nal_reference_idc = nalu->buf[0] & 0x60; // 2 bit
    nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;// 5 bit
    free(buf);
    
    return pos + rewind;
}

/**
 * 解析H264码流
 * @param url 
 * @return 
 */
int simplest_h264_parser(char* url) {
    NALU_t *n;
    int buffersize = 100000;
    
    FILE *myout = stdout;
    
    h264bitstream = fopen(url, "rb+");
    if (NULL == h264bitstream) {
        printf("Open file %s err\n", url);
        return 0;
    }
    
    n = (NALU_t *)calloc(1, sizeof(NALU_t));
    if (NULL == n) {
        printf("alloc NALU Error\n");
        return 0;
    }
    
    n -> max_size = buffersize;
    n -> buf = (char *)calloc(buffersize, sizeof(char));
    if (NULL == n->buf) {
        free(n);
        printf("Alloc NALU buf failed.\n");
        return 0;
    }
    int data_offset = 0;
    int nal_num = 0;

    printf("-----+-------- NALU Table ------+---------+\n");
    printf(" NUM |    POS  |    IDC |  TYPE |   LEN   |\n");
    printf("-----+---------+--------+-------+---------+\n");
    // 解析
    while (!feof(h264bitstream)) {
        int data_length;
        
        data_length = GetAnnexbNALU(n);
        char type_str[20]={0};
        switch(n->nal_unit_type){
            case NALU_TYPE_SLICE:sprintf(type_str,"SLICE");break;
            case NALU_TYPE_DPA:sprintf(type_str,"DPA");break;
            case NALU_TYPE_DPB:sprintf(type_str,"DPB");break;
            case NALU_TYPE_DPC:sprintf(type_str,"DPC");break;
            case NALU_TYPE_IDR:sprintf(type_str,"IDR");break;
            case NALU_TYPE_SEI:sprintf(type_str,"SEI");break;
            case NALU_TYPE_SPS:sprintf(type_str,"SPS");break;
            case NALU_TYPE_PPS:sprintf(type_str,"PPS");break;
            case NALU_TYPE_AUD:sprintf(type_str,"AUD");break;
            case NALU_TYPE_EOSEQ:sprintf(type_str,"EOSEQ");break;
            case NALU_TYPE_EOSTREAM:sprintf(type_str,"EOSTREAM");break;
            case NALU_TYPE_FILL:sprintf(type_str,"FILL");break;
        }
        char idc_str[20]={0};
        switch(n->nal_reference_idc>>5){
            case NALU_PRIORITY_DISPOSABLE:sprintf(idc_str,"DISPOS");break;
            case NALU_PRIRITY_LOW:sprintf(idc_str,"LOW");break;
            case NALU_PRIORITY_HIGH:sprintf(idc_str,"HIGH");break;
            case NALU_PRIORITY_HIGHEST:sprintf(idc_str,"HIGHEST");break;
        }

        fprintf(myout,"%5d| %8d| %7s| %6s| %8d|\n",nal_num,data_offset,idc_str,type_str,n->len);

        data_offset=data_offset+data_length;
        nal_num++;
        
    }
    
    
    if (n) {
        if (n->buf) {
            free(n->buf);
            n->buf = NULL;
        }
        free(n);
    }
    return 0;
}

//=====================================================================
//
// KCP - A Better ARQ Protocol Implementation
// skywind3000 (at) gmail.com, 2010-2011
//  
// Features:
// + Average RTT reduce 30% - 40% vs traditional ARQ like tcp.
// + Maximum RTT reduce three times vs tcp.
// + Lightweight, distributed as a single source file.
//
//=====================================================================
#ifndef __IKCP_H__
#define __IKCP_H__

#include <stddef.h>
#include <stdlib.h>
#include <assert.h>


//=====================================================================
// 32BIT INTEGER DEFINITION 
//=====================================================================
#ifndef __INTEGER_32_BITS__
#define __INTEGER_32_BITS__
#if defined(_WIN64) || defined(WIN64) || defined(__amd64__) || \
    defined(__x86_64) || defined(__x86_64__) || defined(_M_IA64) || \
    defined(_M_AMD64)
    typedef unsigned int ISTDUINT32;
    typedef int ISTDINT32;
#elif defined(_WIN32) || defined(WIN32) || defined(__i386__) || \
    defined(__i386) || defined(_M_X86)
    typedef unsigned long ISTDUINT32;
    typedef long ISTDINT32;
#elif defined(__MACOS__)
    typedef UInt32 ISTDUINT32;
    typedef SInt32 ISTDINT32;
#elif defined(__APPLE__) && defined(__MACH__)
    #include <sys/types.h>
    typedef u_int32_t ISTDUINT32;
    typedef int32_t ISTDINT32;
#elif defined(__BEOS__)
    #include <sys/inttypes.h>
    typedef u_int32_t ISTDUINT32;
    typedef int32_t ISTDINT32;
#elif (defined(_MSC_VER) || defined(__BORLANDC__)) && (!defined(__MSDOS__))
    typedef unsigned __int32 ISTDUINT32;
    typedef __int32 ISTDINT32;
#elif defined(__GNUC__)
    #include <stdint.h>
    typedef uint32_t ISTDUINT32;
    typedef int32_t ISTDINT32;
#else 
    typedef unsigned long ISTDUINT32; 
    typedef long ISTDINT32;
#endif
#endif


//=====================================================================
// Integer Definition
//=====================================================================
#ifndef __IINT8_DEFINED
#define __IINT8_DEFINED
typedef char IINT8;
#endif

#ifndef __IUINT8_DEFINED
#define __IUINT8_DEFINED
typedef unsigned char IUINT8;
#endif

#ifndef __IUINT16_DEFINED
#define __IUINT16_DEFINED
typedef unsigned short IUINT16;
#endif

#ifndef __IINT16_DEFINED
#define __IINT16_DEFINED
typedef short IINT16;
#endif

#ifndef __IINT32_DEFINED
#define __IINT32_DEFINED
typedef ISTDINT32 IINT32;
#endif

#ifndef __IUINT32_DEFINED
#define __IUINT32_DEFINED
typedef ISTDUINT32 IUINT32;
#endif

#ifndef __IINT64_DEFINED
#define __IINT64_DEFINED
#if defined(_MSC_VER) || defined(__BORLANDC__)
typedef __int64 IINT64;
#else
typedef long long IINT64;
#endif
#endif

#ifndef __IUINT64_DEFINED
#define __IUINT64_DEFINED
#if defined(_MSC_VER) || defined(__BORLANDC__)
typedef unsigned __int64 IUINT64;
#else
typedef unsigned long long IUINT64;
#endif
#endif

#ifndef INLINE
#if defined(__GNUC__)

#if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
#define INLINE         __inline__ __attribute__((always_inline))
#else
#define INLINE         __inline__
#endif

#elif (defined(_MSC_VER) || defined(__BORLANDC__) || defined(__WATCOMC__))
#define INLINE __inline
#else
#define INLINE 
#endif
#endif

#if (!defined(__cplusplus)) && (!defined(inline))
#define inline INLINE
#endif


//=====================================================================
// QUEUE DEFINITION                                                  
//=====================================================================
#ifndef __IQUEUE_DEF__
#define __IQUEUE_DEF__

struct IQUEUEHEAD {
    struct IQUEUEHEAD *next, *prev;
};

typedef struct IQUEUEHEAD iqueue_head;


//---------------------------------------------------------------------
// queue init                                                         
//---------------------------------------------------------------------
#define IQUEUE_HEAD_INIT(name) { &(name), &(name) }
#define IQUEUE_HEAD(name) \
    struct IQUEUEHEAD name = IQUEUE_HEAD_INIT(name)

#define IQUEUE_INIT(ptr) ( \
    (ptr)->next = (ptr), (ptr)->prev = (ptr))

#define IOFFSETOF(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

#define ICONTAINEROF(ptr, type, member) ( \
        (type*)( ((char*)((type*)ptr)) - IOFFSETOF(type, member)) )

#define IQUEUE_ENTRY(ptr, type, member) ICONTAINEROF(ptr, type, member)


//---------------------------------------------------------------------
// queue operation                     
//---------------------------------------------------------------------
#define IQUEUE_ADD(node, head) ( \
    (node)->prev = (head), (node)->next = (head)->next, \
    (head)->next->prev = (node), (head)->next = (node))

#define IQUEUE_ADD_TAIL(node, head) ( \
    (node)->prev = (head)->prev, (node)->next = (head), \
    (head)->prev->next = (node), (head)->prev = (node))

#define IQUEUE_DEL_BETWEEN(p, n) ((n)->prev = (p), (p)->next = (n))

#define IQUEUE_DEL(entry) (\
    (entry)->next->prev = (entry)->prev, \
    (entry)->prev->next = (entry)->next, \
    (entry)->next = 0, (entry)->prev = 0)

#define IQUEUE_DEL_INIT(entry) do { \
    IQUEUE_DEL(entry); IQUEUE_INIT(entry); } while (0)

#define IQUEUE_IS_EMPTY(entry) ((entry) == (entry)->next)

#define iqueue_init        IQUEUE_INIT
#define iqueue_entry    IQUEUE_ENTRY
#define iqueue_add        IQUEUE_ADD
#define iqueue_add_tail    IQUEUE_ADD_TAIL
#define iqueue_del        IQUEUE_DEL
#define iqueue_del_init    IQUEUE_DEL_INIT
#define iqueue_is_empty IQUEUE_IS_EMPTY

#define IQUEUE_FOREACH(iterator, head, TYPE, MEMBER) \
    for ((iterator) = iqueue_entry((head)->next, TYPE, MEMBER); \
        &((iterator)->MEMBER) != (head); \
        (iterator) = iqueue_entry((iterator)->MEMBER.next, TYPE, MEMBER))

#define iqueue_foreach(iterator, head, TYPE, MEMBER) \
    IQUEUE_FOREACH(iterator, head, TYPE, MEMBER)

#define iqueue_foreach_entry(pos, head) \
    for( (pos) = (head)->next; (pos) != (head) ; (pos) = (pos)->next )
    

#define __iqueue_splice(list, head) do {    \
        iqueue_head *first = (list)->next, *last = (list)->prev; \
        iqueue_head *at = (head)->next; \
        (first)->prev = (head), (head)->next = (first);        \
        (last)->next = (at), (at)->prev = (last); }    while (0)

#define iqueue_splice(list, head) do { \
    if (!iqueue_is_empty(list)) __iqueue_splice(list, head); } while (0)

#define iqueue_splice_init(list, head) do {    \
    iqueue_splice(list, head);    iqueue_init(list); } while (0)


#ifdef _MSC_VER
#pragma warning(disable:4311)
#pragma warning(disable:4312)
#pragma warning(disable:4996)
#endif

#endif


//---------------------------------------------------------------------
// BYTE ORDER & ALIGNMENT
//---------------------------------------------------------------------
#ifndef IWORDS_BIG_ENDIAN
    #ifdef _BIG_ENDIAN_
        #if _BIG_ENDIAN_
            #define IWORDS_BIG_ENDIAN 1
        #endif
    #endif
    #ifndef IWORDS_BIG_ENDIAN
        #if defined(__hppa__) || \
            defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \
            (defined(__MIPS__) && defined(__MIPSEB__)) || \
            defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) || \
            defined(__sparc__) || defined(__powerpc__) || \
            defined(__mc68000__) || defined(__s390x__) || defined(__s390__)
            #define IWORDS_BIG_ENDIAN 1
        #endif
    #endif
    #ifndef IWORDS_BIG_ENDIAN
        #define IWORDS_BIG_ENDIAN  0
    #endif
#endif

#ifndef IWORDS_MUST_ALIGN
    #if defined(__i386__) || defined(__i386) || defined(_i386_)
        #define IWORDS_MUST_ALIGN 0
    #elif defined(_M_IX86) || defined(_X86_) || defined(__x86_64__)
        #define IWORDS_MUST_ALIGN 0
    #elif defined(__amd64) || defined(__amd64__)
        #define IWORDS_MUST_ALIGN 0
    #else
        #define IWORDS_MUST_ALIGN 1
    #endif
#endif


//=====================================================================
// SEGMENT
//=====================================================================
struct IKCPSEG
{
    // 链表节点
    struct IQUEUEHEAD node;
    
    // 会话ID,发送方和接收方的会话必须要一致才能收发
    IUINT32 conv;
    
    // 报文类型,
    // ICKP_CMD_PUSH(数据报文)、
    // IKCP_CMD_ACK(确认报文)、
    // IKCP_CMD_WASK(窗口探测报文),询问对端剩余接收窗口大小
    // IKCP_CMD_WINS(窗口通知报文),
    IUINT32 cmd;
    
    // 分片数量,表示后面还有多少报文属于同一个包,0表示最后一个包,应用层的数据会被分包
    IUINT32 frg;
    
    // 发送方剩余接收窗口大小, 接收窗口大小-接收窗口队列大小。发送方发送窗口不能大于接收方接收窗口大小
    IUINT32 wnd;
    
    // 发送的时间戳
    IUINT32 ts;
    
    // 报文的编号，按1累加，和frg有啥区别。该编号用于ack
    IUINT32 sn;
    
    // 待接收的消息的编号，ack相关,表示我想要收数据报的sn=una的没有收到。
    // 未发生丢包的话，una为下一个可接收数据包序号。当前收到的sn = 10, una = 11。
    IUINT32 una;
    
    // 数据data的长度
    IUINT32 len;
    
    // 下一次超时重发的时间戳
    IUINT32 resendts;
    
    // 该分片超时重传的等待时间
    IUINT32 rto;
    
    // ack被跳过大小，会影响重传。如果发送1,2,3,4,接收到1,3,4。那么2的数据包已经被跳过2次了（4 - 2 = 2）
    IUINT32 fastack;
    
    // 发送该分片的次数
    IUINT32 xmit;
    
    // data指针
    char data[1];
};


//---------------------------------------------------------------------
// IKCPCB
//---------------------------------------------------------------------
struct IKCPCB
{
    // conv  : 会话标识
    // mtu   : 最大传输单元（Maximum Transmission Unit）
    // mss   : 最大报文段大小, mss = mtu - 包头长度(24)
    // state : 连接状态, 0 连接建立, -1(0xffffffff) 断开连接
    IUINT32 conv, mtu, mss, state;
    
    // snd_una : 发送缓冲区中最小还未确认送达的报文段标号，比它小的已经确认送达了
    // snd_nxt : 下一个等待发送的报文段的编号
    // rcv_nxt : 下一个等待接收的报文段的编号
    IUINT32 snd_una, snd_nxt, rcv_nxt;
    
    // ts_recent  : 未使用
    // ts_lastack : 未使用
    // ssthresh   : 慢启动阈值Slow Start Threshold
    IUINT32 ts_recent, ts_lastack, ssthresh;
    
    
    // rx_rttval、rx_srtt、rx_minrto 计算出 => rx_rto
    IINT32 rx_rttval, rx_srtt, rx_rto, rx_minrto;
    
    // snd_wnd : 发送窗口大小
    // rcv_wnd : 接收窗口大小
    // rmt_wnd : 对端剩余接收窗口大小
    // cwnd    : congestion window 拥塞窗口,用于拥塞控制
    // probe   : 是否要发送控制报文的标志
    IUINT32 snd_wnd, rcv_wnd, rmt_wnd, cwnd, probe;
    
    // current  : 当前时间
    // interval : flush的时间粒度,多长进行flush
    // ts_flush : 下一次flush时间
    // xmit     : 该链接超时重传的总次数
    IUINT32 current, interval, ts_flush, xmit;
    
    // nrcv_buf、nsnd_buf 接收发送缓冲区长度
    IUINT32 nrcv_buf, nsnd_buf;
    
    // 接收/发送队列长度
    IUINT32 nrcv_que, nsnd_que;
    
    // nodelay : 使用启用快速模式
    // updated : 使用调用过ikcp_update
    IUINT32 nodelay, updated;
    
    // ts_probe、probe_wait :用于确定何时需要发送窗口询问报文
    IUINT32 ts_probe, probe_wait;
    
    // dead_link : 当一个报文发送超时次数达到deal_link次,则可以认为连接断开 (state = 0xffffffff)
    // incr      : 用于计算cwnd
    IUINT32 dead_link, incr;
    
    // 发送队列
    struct IQUEUEHEAD snd_queue;
    
    // 接收队列
    struct IQUEUEHEAD rcv_queue;
    
    // 发送缓冲区,能在发送缓冲区的数据
    // 1. 新加入snd_buf中的,从未发送过的报文
    // 2. 发送过，在RTO内未收到ACK报文
    // 3. 发送过，ACK失序报文，需要执行快速重传
    struct IQUEUEHEAD snd_buf;
    
    // 接收缓冲区
    struct IQUEUEHEAD rcv_buf;
    
    // ACK列表,待发送的ACK的信息会存在列表中，flush时一并发送
    IUINT32 *acklist;
    
    // ACK列表长度
    IUINT32 ackcount;
    
    // ACK列表容量
    IUINT32 ackblock;
    
    // 自定义的数据
    void *user;
    
    // flush 临时缓冲区
    char *buffer;
    
    // ACK失序次数大于等于fastresend，触发快速重传
    int fastresend;
    
    // 传输次数小于fastlimit,执行快速重传
    int fastlimit;
    
    // nocwnd : 是否不考虑拥塞窗口
    // stream : 是否开启流模式,开启后可能会粘包
    int nocwnd, stream;
    
    // 用于控制日志
    int logmask;
    
    // 下层传输协议输出函数
    int (*output)(const char *buf, int len, struct IKCPCB *kcp, void *user);
    
    // 日志函数
    void (*writelog)(const char *log, struct IKCPCB *kcp, void *user);
};


typedef struct IKCPCB ikcpcb;

#define IKCP_LOG_OUTPUT            1
#define IKCP_LOG_INPUT            2
#define IKCP_LOG_SEND            4
#define IKCP_LOG_RECV            8
#define IKCP_LOG_IN_DATA        16
#define IKCP_LOG_IN_ACK            32
#define IKCP_LOG_IN_PROBE        64
#define IKCP_LOG_IN_WINS        128
#define IKCP_LOG_OUT_DATA        256
#define IKCP_LOG_OUT_ACK        512
#define IKCP_LOG_OUT_PROBE        1024
#define IKCP_LOG_OUT_WINS        2048

#ifdef __cplusplus
extern "C" {
#endif

//---------------------------------------------------------------------
// interface
//---------------------------------------------------------------------

// create a new kcp control object, 'conv' must equal in two endpoint
// from the same connection. 'user' will be passed to the output callback
// output callback can be setup like this: 'kcp->output = my_udp_output'
ikcpcb* ikcp_create(IUINT32 conv, void *user);

// release kcp control object
void ikcp_release(ikcpcb *kcp);

// set output callback, which will be invoked by kcp
void ikcp_setoutput(ikcpcb *kcp, int (*output)(const char *buf, int len, 
    ikcpcb *kcp, void *user));

// user/upper level recv: returns size, returns below zero for EAGAIN
// 用户上层调用的接收数据的函数,这个函数得到的数据是通过kcp算法处理的
// 可以认为该数据一定是对端发送成功的，
int ikcp_recv(ikcpcb *kcp, char *buffer, int len);

// user/upper level send, returns below zero for error
// 用户上层调用的发送数据的函数,该函数内创建报文实例,将报文放入sdn_queue中
// 错误小于0
int ikcp_send(ikcpcb *kcp, const char *buffer, int len);

// update state (call it repeatedly, every 10ms-100ms), or you can ask 
// ikcp_check when to call it again (without ikcp_input/_send calling).
// 'current' - current timestamp in millisec. 
// 更新函数,需要不断重复调用该函数,用来驱动数据的收发。会调用ikcp_flush函数进行数据发送
// 会根据传进来的时间和上一次进行flush的时间进行比较,需要满足
// 当前时间戳(current) - 上一次flush的时间戳(kcp->ts_flush) >= 0,
// 则说明需要发送了
// 将kcp->ts_flush += kcp->interval之后 和 kcp->current进行比较。
// 如果current还是大过kcp->ts_flush,将kcp->ts_flush设置为kcp->current + kcp->interval
// 为什么要这样？需要控制ikcp_flush发送间隔,
// 如果调用ikcp_update的时间间隔太短(距离上一次调用间隔小于interval时间),就不会触发ikcp_flush了
// 我要怎么知道我调用update的时机?
// 通过调用ickp_check函数可以知道下一次调用update生效的时间距离现在多久
void ikcp_update(ikcpcb *kcp, IUINT32 current);

// Determine when should you invoke ikcp_update:
// returns when you should invoke ikcp_update in millisec, if there 
// is no ikcp_input/_send calling. you can call ikcp_update in that
// time, instead of call update repeatly.
// Important to reduce unnacessary ikcp_update invoking. use it to 
// schedule ikcp_update (eg. implementing an epoll-like mechanism, 
// or optimize ikcp_update when handling massive kcp connections)
IUINT32 ikcp_check(const ikcpcb *kcp, IUINT32 current);

// when you received a low level packet (eg. UDP packet), call it
// 接收到数据之后需要调用该函数
// 如果是UDP的话，调用recvfrom之后得到的数据需要调用这个函数
int ikcp_input(ikcpcb *kcp, const char *data, long size);

// flush pending data
// 该函数会完成如下动作
// + 发送ACK列表中的ACK
// 
// + 检查是否需要发送窗口探测和通知报文
// 
// + 计算拥塞窗口大小
//   从自身的发送窗口大小和远端接收窗口中选择最小的作为拥塞窗口
// 
// + 根据上一步计算得到的拥塞窗口，从发送队列中取出符合拥塞发送窗口大小的数据放入发送缓冲区kcp->snd_buf中,
//   上一步计算是为了这一步取出的数据大小能够发送到对端
// 
// + 从kcp->snd_buf中取出需要先发送的数据
//   新报文,需要重传的报文，ACK失序的报文
// 
// + 将kcp->snd_buf中剩余的数据发送出去
// 
// + 根据丢包计算ssthresh和cwnd
// 
// 数据发送的优先级:
// 1. ACK报文
// 2. 响应对端窗口询问报文
// 3. 询问对端窗口大小报文
// 4. 需要先发送的数据报文
// 5. 剩余的报文
// 
void ikcp_flush(ikcpcb *kcp);

// check the size of next message in the recv queue
int ikcp_peeksize(const ikcpcb *kcp);

// change MTU size, default is 1400
// 更改KCP的MTU，注意MTU不能小于50或小于24,
// 其中24为IKCP_OVERHEAD,KCP协议的头部大小,小过这个值,这个协议没法用的。
// 为什么不能小于50呢？？
// 设置MTU会影响切片的分包,最大分片大小kcp->mss = kcp->mtu - IKCP_OVERHEAD
int ikcp_setmtu(ikcpcb *kcp, int mtu);

// set maximum window size: sndwnd=32, rcvwnd=32 by default
// 设置发送和接收窗口大小
// 发送窗口>0就行，但是接收窗口大小有要求，必须>=128（IKCP_WND_RCV）,传小了被设成IKCP_WND_RCV
int ikcp_wndsize(ikcpcb *kcp, int sndwnd, int rcvwnd);

// get how many packet is waiting to be sent
// 获得当前等待发送数据量大小:发送队列大小 + 发送缓冲区大小
int ikcp_waitsnd(const ikcpcb *kcp);

// fastest: ikcp_nodelay(kcp, 1, 20, 2, 1)
// nodelay: 0:disable(default), 1:enable
// interval: internal update timer interval in millisec, default is 100ms 
// resend: 0:disable fast resend(default), 1:enable fast resend
// nc: 0:normal congestion control(default), 1:disable congestion control
// 设置ikcp的模式
int ikcp_nodelay(ikcpcb *kcp, int nodelay, int interval, int resend, int nc);


// ikcp_log日志模块,用来查看日志kcp的日志,
// 使用前需要先设置kcp->writelog函数
void ikcp_log(ikcpcb *kcp, int mask, const char *fmt, ...);

// setup allocator
// 设置内存分配和释放器,默认使用malloc
void ikcp_allocator(void* (*new_malloc)(size_t), void (*new_free)(void*));

// read conv
// 可以传入UDP接收到数据,会返回数据包的conv值，
// 可以在调用ikcp_input的时候做不同的过滤,只把符合kcp协议的包放入
// 可以用来融合其他协议
IUINT32 ikcp_getconv(const void *ptr);


#ifdef __cplusplus
}
#endif

#endif