YUV图片格式

#安装ffmpeg
$ sudo apt install ffmpeg

#将图片尺寸为384x182的TestPic.png转换为yuv420格式的图片out_384x182.yuv
$ ffmpeg -i TestPic.png -s 384x182 -pix_fmt yuv420p out_384x182.yuv

#查看尺寸为384x182的yuv格式图片out_384x182.yuv
$ ffplay -f rawvideo -video_size 384x182 out_384x182.yuv

#include<iostream>
#include<iomanip>
#include<fstream>
#include<thread>
#include<string.h>
#include<string>
#include<dirent.h>
#include<vector>
#include<utility>
#include<chrono>
#include<cstdlib>
#include<unistd.h>

#include <android/log.h>
#include <utils/CallStack.h>

//<utils/CallStack.h> refers <log/log.h>, in <log/log.h> defined  LOG_TAG to NULL
#undef LOG_TAG
#define LOG_TAG "wangtianlin1"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG ,__VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG ,__VA_ARGS__)

const uint WIDTH = 1844;
const uint HEIGTH = 4000;
const uint BUFFER_CAPACITY = 256;

const std::string INPUT_FOLDER = "input//";
const std::string OUTPUT_FOLDER = "output//";
const uint8_t FILE_TYPE_NUM = 8;

android::CallStack g_callStack;
void dump_stack_android(void)
{
        g_callStack.update();
        g_callStack.log(LOG_TAG);
}

class DataQueue{
public:
    DataQueue(){
        this->head = nullptr;
        this->tail = nullptr;
        this->readDone = false;
        this->writeDone = false;
    }
    //Add a node at queue tail.
    void Product(char* inputData, uint inputLength){
        if (!tail){
            this->tail = new DataNode(inputData, inputLength);
            this->head = this->tail;
        }else{
            this->tail->_next = new DataNode(inputData, inputLength);
            this->tail = this->tail->_next;
        }
    }
    //Get a node at queue head and delete it, if head is null, keep waitting.
    std::pair<char*, uint> Consume(){
        //Consumer is allowed to wait.
        while(!this->head);
        std::pair<char*, uint> result((char*)this->head->_data, this->head->_length);
        DataNode* temp = (DataNode*)this->head;
        //Another wait.
        while(!this->head->_next && !this->readDone);
        /*///////////////////////////////////////////////////////////////////////////////////////////////
        //
        //    Three situations : (next) || (done) || (next && done)
        //    next: strill reading.
        //    done: read finished and data is empty. Writting should stop at this situation.
        //    next && done: read finished but data is not empty.
        //
        ///////////////////////////////////////////////////////////////////////////////////////////////*/
        if(this->head->_next){
            this->head = temp->_next;
        }else{
            //read done and write done.
            this->writeDone = true;
            LOGD("Child Thread - Write Finished.\n");
            dump_stack_android();
        }
        delete(temp);
        return result;
    }
    void SetReadDone(){
        this->readDone = true;
    }
    bool IsWriteDone(){
        return (bool)this->writeDone;
    }
private:
    struct DataNode{
        char* volatile _data;
        volatile uint _length;
        DataNode* volatile _next;
        DataNode(char* inputData, uint inputLength){
            _data = inputData;
            _length = inputLength;
            _next = nullptr;
        }
    };
    DataNode* volatile head;
    DataNode* volatile tail;
    volatile bool readDone;
    volatile bool writeDone;
};

DataQueue* g_DQ = new DataQueue();

//Open INPUT_FOLDER and create a string vector by all files
void CreateFileNameVector(std::vector<std::string> &inputStringVector){
    DIR* dir;
    struct dirent* ptr;
    std::string path = "input//";
    if(NULL == (dir = opendir(path.c_str()))){
        LOGI("Main  Thread - No input file found!\n");
        exit(1);
        return;
    }
    while((ptr = readdir(dir)) != NULL){
        if(FILE_TYPE_NUM == ptr->d_type){
            std::string temp = ptr->d_name;
            inputStringVector.push_back(temp);
        }
    }
    return;
}
//Read BUFFER_CAPACITY Byte once from yuv file and deliver it to writer thread, skip -
//color informations(UV).
void PicDataRead(void){
    const uint ReadByteNum = WIDTH * HEIGTH;
    std::vector<std::string> fileNames;
    CreateFileNameVector(fileNames);

    for(const std::string &currentFileName : fileNames){
        std::ifstream picReader(INPUT_FOLDER + currentFileName, std::ifstream::binary);

        char* _temp = new char[currentFileName.size()];
        strcpy(_temp, currentFileName.c_str());

        picReader.seekg(0, picReader.end);
        const uint PicSize = picReader.tellg();
        picReader.seekg(0, picReader.beg);
        g_DQ->Product(_temp, PicSize - ReadByteNum);

        LOGD("Main  Thread - File %s reading...\n", currentFileName.c_str());
        for(uint readCounter = 0; readCounter < ReadByteNum;){
            uint _bufferLeft = ReadByteNum - readCounter;
            uint _currentBufferSize = BUFFER_CAPACITY;
            if(_bufferLeft < BUFFER_CAPACITY){
                _currentBufferSize = _bufferLeft;
            }
            char* inputData = new char[_currentBufferSize];
            picReader.read(inputData, _currentBufferSize);
            g_DQ->Product(inputData, _currentBufferSize);
            readCounter += _currentBufferSize;
        }
        picReader.close();
        LOGD("Main  Thread - File %s reading done!\n", currentFileName.c_str());
    }
    g_DQ->SetReadDone();
    LOGD("Main  Thread - Read Finished!\n");
    return;
}

//Write information received to file, and fill color information with 0x80.
void PicDataWrite(void){
    const uint WriteByteNum = WIDTH * HEIGTH;
    char* grayBuffer = new char[BUFFER_CAPACITY];
    memset(grayBuffer,0x80,BUFFER_CAPACITY);
    while(true){
        LOGD("Child Thread - Getting file name and bufferLeftNum...\n");
        std::pair<char*, uint> resultReceiver = g_DQ->Consume();
        std::string currentFileName(resultReceiver.first);
        const uint bufferLeftNum = resultReceiver.second;
        LOGD("Child Thread - File name: %s\n",  currentFileName.c_str());
        delete[](resultReceiver.first);
        std::ofstream picOutput(OUTPUT_FOLDER + currentFileName, std::ofstream::binary);

        LOGD("Child Thread - File %s writing...\n", currentFileName.c_str());
        for(uint writeCounter = 0; writeCounter < WriteByteNum;){
            resultReceiver = g_DQ->Consume();
            picOutput.write(resultReceiver.first, resultReceiver.second);
            delete[](resultReceiver.first);
            writeCounter += resultReceiver.second;
        }

        for(uint writeCounter = 0; writeCounter < bufferLeftNum;){
            uint _bufferLeft = bufferLeftNum - writeCounter;
            uint _currentBufferSize = BUFFER_CAPACITY;
            if(_bufferLeft < BUFFER_CAPACITY){
                _currentBufferSize = _bufferLeft;
            }
            picOutput.write(grayBuffer, _currentBufferSize);
            writeCounter += _currentBufferSize;
        }
        picOutput.close();
        LOGD("Child Thread - File %s writing done!\n", currentFileName.c_str());

        if(g_DQ->IsWriteDone()){
            LOGD("Child Thread - All file processed!\n");
            break;
        }
    }
    delete[](grayBuffer);
    return;
}

int main(void){
    const std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now();
    LOGD("Main  Thread - #######Start#######\n");

    std::thread t_writer(PicDataWrite);
    PicDataRead();
    LOGD("Main  Thread - Waitting child thread...\n");
    t_writer.join();

    const std::chrono::system_clock::time_point endTime = std::chrono::system_clock::now();
    const auto duration = std::chrono::duration_cast<std::chrono::microseconds>(endTime - startTime).count();
    LOGD("Main  Thread - All time consumed %.3f  ms\n", duration * 1e-3);
    LOGD("Main  Thread - ####### End #######\n");
}