进一步有进一步惊喜

#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;
}