YUVVIEWER之YUV解析器

YUV是视频原始数据存储格式，如何将文件中的YUV解析出来呢？

一、YUV概要

        YUV中的Y表示图像的亮度，即灰度值；U和V表示图像的色度，即图像的颜色。一帧YUV数据只提取Y分量，仍然可以完整的显示这一帧图像，但是黑白色。

        YUV存储格式为两种：

1. planar ： 平面格式，即先存储Y分量，再U分量，最后V分量
2. packed ：打包格式，即Y，U，V分量交叉存储

        按照UV分量比例不同，YUV存储方式分为：

1. YUV444 ：Y，U，V分量存储比例相同
2. YUV422 ：Y分量存储比例是U，V分量的1倍；U，V分量比例相同
3. YUV420 ：Y分量存储比例是U，V分量和的1倍；U，V分量比例相同

　　YUV不同存储方式数据大小计算（图像分辨率：width * height）：

1. YUV444 ：width * height + width * height + width * height = width * height * 3
2. YUV422 ：width * height + width * height  / 2 + widht * height / 2 = widht * height * 2
3. YUV420 ：widht * height + width * height / 4 + width * height / 4 = width * height * 3 / 2

　　在实际编程中，需要根据YUV事件存储格式和存储方式动态提取或存储数据。

二、YUV解析器

　　YUV数据结构

namespace yuv{
    
    struct YUV
    {
        std::unique_ptr<uint8_t[]> Y;      // Y分量
        size_t YSize;
        std::unique_ptr<uint8_t[]> U;     // U分量
        size_t USize;
        std::unique_ptr<uint8_t[]> V;     // V分量
        size_t VSize;
    };
}

　　YUV帧数据结构

namespace yuv{
    struct YUVFrame
    {
        Resolution resolution;     // 分辨率
        YUV        yuv;            // YUV分量数据 
        size_t     size;           // 帧数据大小
    };
}

　　YUV解析器

namespace yuv{
    template <typename ParserType>
    class YUVParser
    {
    public:
        using Frames = std::vector<YUVFrame>;
        constexpr YUVParser(const std::string& file, const Resolution& resolution) noexcept
            : _file(file)
            , _iFileStream(file, std::ios::binary)
            , _ext(Extension(file))
            , _resolution(resolution)
        {
        }

        virtual ~YUVParser() {}

        virtual bool Parse()
        {
            if (!_iFileStream.is_open()) {
                return false;
            }

            const auto& resolution = GetResolution();
            const auto kFarmeSize = GetPerFrameSize();
            const auto frameCounts = CountFrames(_iFileStream, kFarmeSize);
            if (frameCounts == 0) {
                return false;
            }

            _frames.reserve(frameCounts);
            auto buffer = std::make_unique<uint8_t[]>(kFarmeSize);
            while (true) {
                std::memset(buffer.get(), 0x00, kFarmeSize);
                _iFileStream.read(reinterpret_cast<char*>(buffer.get()), kFarmeSize);
                auto readSize = _iFileStream.gcount();
                if (readSize == 0) {
                    break;
                }
                if (readSize != kFarmeSize) {
                    continue;
                }

                auto frame = BuildYUVFrame(buffer.get());
                _frames.push_back(std::move(frame));
            }

            return _frames.size();
        }

        bool DuplicateToFile(const std::string& duplicateFile) const
        {
            const auto& parser = static_cast<const ParserType&>(*this);
            return parser.DuplicateToFileImpl(duplicateFile);
        }

        bool DumpYToFile(const std::string& yFile) const
        {
            return DumpYToFileImpl(yFile);
        }

        inline const std::string& GetFilePath() const { return _file; }
        inline const std::string& GetExtension() const { return _ext; }
        inline const Resolution& GetResolution() const { return _resolution; }
        inline const Frames& GetFrames() const { return _frames; }
        inline const size_t GetFrameCounts() const { return _frames.size(); }
    protected:
        static constexpr auto Extension(const std::string& file)
        {
            using namespace std::filesystem;
            using namespace std::string_literals;

            if (u8path(file).has_extension()) {
                return u8path(file).extension().u8string();
            }
            else {
                return ".yuv"s;
            }
        }
        
        static size_t CountFrames(std::ifstream& iFileStream, size_t frameSize)
        {
            SeekBeg(iFileStream);
            auto begPos = iFileStream.tellg();
            iFileStream.seekg(0, std::ios_base::end);
            auto endPos = iFileStream.tellg();
            SeekBeg(iFileStream);

            return static_cast<size_t>(endPos - begPos) / frameSize;
        }

        static void SeekBeg(std::ifstream& iFileStream)
        {
            iFileStream.seekg(0, std::ios_base::beg);
        }
        
        virtual YUVFrame BuildYUVFrame(const uint8_t* buf) const = 0;
        virtual size_t GetPerFrameSize() const = 0;

        virtual bool DumpYToFileImpl(const std::string& yFile) const
        {
            std::ofstream oYFileStream(yFile, std::ios::binary);
            if (oYFileStream.is_open() && GetFrameCounts()) {
                for (const auto& frame : GetFrames()) {
                    oYFileStream.write(reinterpret_cast<char*>(frame.yuv.Y.get()), frame.yuv.YSize);
                }
                return true;
            }
            else {
                return false;
            }
        }

        virtual YUVFrame CreateYUVFrame() const
        {
            YUVFrame yuvFrame;
            yuvFrame.resolution = GetResolution();
            yuvFrame.size = GetPerFrameSize();
            yuvFrame.yuv.YSize = GetYSize();
            yuvFrame.yuv.Y = std::make_unique<uint8_t[]>(yuvFrame.yuv.YSize);
            yuvFrame.yuv.USize = GetUSize();
            yuvFrame.yuv.U = std::make_unique<uint8_t[]>(yuvFrame.yuv.USize);
            yuvFrame.yuv.VSize = GetVSize();
            yuvFrame.yuv.V = std::make_unique<uint8_t[]>(yuvFrame.yuv.VSize);

            return yuvFrame;
        }

        virtual void FillYUVFrame(const uint8_t* buf, YUVFrame& frame) const = 0;
        virtual size_t GetYSize() const
        {
            return _resolution.width * _resolution.height;
        }
        virtual size_t GetUSize() const = 0;
        virtual size_t GetVSize() const
        {
            return GetUSize();
        }
    protected:
        const std::string   _file;
        const std::string   _ext;
        const Resolution    _resolution;
        std::ifstream       _iFileStream;
        Frames              _frames;
    };  
}

　　YUV444P解析器（planar）

namesapce yuv{
    // YUV444P Foramt
    // example : 4 * 4
    //  -------------------------------
    // |  Y00  |  Y01  |  Y02  |  Y03  |
    //  -------------------------------
    // |  Y10  |  Y11  |  Y12  |  Y13  |
    //  -------------------------------
    // |  Y20  |  Y21  |  Y22  |  Y23  |
    //  -------------------------------
    // |  Y30  |  Y31  |  Y32  |  Y33  |
    //  -------------------------------
    // |  U40  |  U41  |  U42  |  U43  |
    //  -------------------------------
    // |  U50  |  U51  |  U52  |  U53  |
    //  -------------------------------
    // |  U60  |  U61  |  U62  |  U63  |
    //  -------------------------------
    // |  U70  |  U71  |  U72  |  U73  |
    //  -------------------------------
    // |  V80  |  V81  |  V82  |  V83  |
    //  -------------------------------
    // |  V90  |  V91  |  V92  |  V93  |
    //  -------------------------------
    // |  V100 |  V101 |  V102 |  V103 |
    //  -------------------------------
    // |  V110 |  V111 |  V112 |  V113 |
    //  -------------------------------  

    class YUVParser444P
        : public YUVParser420P 
    {
    public:
        YUVParser444P(const std::string& file, const Resolution& resolution)
            : YUVParser420P(file, resolution)
        {}

    private:
        size_t GetPerFrameSize() const override
        {
            return _resolution.width * _resolution.height * 3;
        }

        size_t GetUSize() const override
        {
            return GetYSize();
        }
    };
}    

　　YUV422P解析器（planar）

namespace yuv{
    // YUV422P Foramt
    // example : 4 * 4
    //  -------------------------------
    // |  Y00  |  Y01  |  Y02  |  Y03  |
    //  -------------------------------
    // |  Y10  |  Y11  |  Y12  |  Y13  |
    //  -------------------------------
    // |  Y20  |  Y21  |  Y22  |  Y23  |
    //  -------------------------------
    // |  Y30  |  Y31  |  Y32  |  Y33  |
    //  -------------------------------
    // |  U40  |  U41  |  U42  |  U43  |
    //  -------------------------------
    // |  U50  |  U51  |  U52  |  U53  |
    //  -------------------------------
    // |  V60  |  V61  |  V62  |  V63  |
    //  -------------------------------
    // |  V70  |  V71  |  V72  |  V73  |
    //  -------------------------------
    class YUVParser422P
        : public YUVParser420P
    {
    public:
        YUVParser422P(const std::string& file, const Resolution& resolution)
            : YUVParser420P(file, resolution)
        {}
    private:
        size_t GetPerFrameSize() const override
        {
            return _resolution.width * _resolution.height * 2;
        }

        size_t GetUSize() const override
        {
            return GetYSize() / 2;
        }
    };
}

　　YUV420P解析器（planar）

namespace yuv{
    // YUV420P Format
    // Example : 4 * 4
    //  -------------------------------
    // |  Y00  |  Y01  |  Y02  |  Y03  |
    //  -------------------------------
    // |  Y10  |  Y11  |  Y12  |  Y13  |
    //  -------------------------------
    // |  Y20  |  Y21  |  Y22  |  Y23  |
    //  -------------------------------
    // |  Y30  |  Y31  |  Y32  |  Y33  |
    //  -------------------------------
    // |  U40  |  U41  |  U42  |  U43  |
    //  -------------------------------
    // |  V50  |  V51  |  V52  |  V53  |
    //  -------------------------------
    template <typename ParserType> class YUVParser;
    class YUVParser420P
        : public YUVParser<YUVParser420P>
    {
        friend class YUVParser<YUVParser420P>;
    public:
        YUVParser420P(const std::string& file, const Resolution& resolution)
            : YUVParser(file, resolution)
        {}
    private:
        bool DuplicateToFileImpl(const std::string& duplicateFile) const
        {
            std::ofstream oDuplicateFileStream(duplicateFile, std::ios::binary);
            if (oDuplicateFileStream.is_open() && GetFrameCounts()) {
                for (const auto& frame : GetFrames()) {
                    oDuplicateFileStream.write(reinterpret_cast<char*>(frame.yuv.Y.get()), frame.yuv.YSize);
                    oDuplicateFileStream.write(reinterpret_cast<char*>(frame.yuv.U.get()), frame.yuv.USize);
                    oDuplicateFileStream.write(reinterpret_cast<char*>(frame.yuv.V.get()), frame.yuv.VSize);
                }
                return true;
            }
            else {
                return false;
            }
        }

        YUVFrame BuildYUVFrame(const uint8_t* buf) const override
        {
            auto frame = CreateYUVFrame();
            FillYUVFrame(buf, frame);
            return frame;
        }
        
        size_t GetPerFrameSize() const override
        {
            return _resolution.width * _resolution.height * 3 / 2;
        }

        void FillYUVFrame(const uint8_t* buf, YUVFrame& frame) const override
        {
            std::memcpy(frame.yuv.Y.get(),
                buf,
                frame.yuv.YSize);
            std::memcpy(frame.yuv.U.get(),
                buf
                + frame.yuv.YSize,
                frame.yuv.USize);
            std::memcpy(frame.yuv.V.get(),
                buf
                + frame.yuv.YSize
                + frame.yuv.USize,
                frame.yuv.VSize);
        }

        size_t GetUSize() const override
        {
            return GetYSize() / 4;
        }
    };
}

　　YUV420SP解析器（packed）

namespace yuv{
    // YUV420SP Foramt
    //  -------------------------------
    // |  Y00  |  Y01  |  Y02  |  Y03  |
    //  -------------------------------
    // |  Y10  |  Y11  |  Y12  |  Y13  |
    //  -------------------------------
    // |  Y20  |  Y21  |  Y22  |  Y23  |
    //  -------------------------------
    // |  Y30  |  Y31  |  Y32  |  Y33  |
    //  -------------------------------
    // |  U40  |  V41  |  U42  |  V43  |
    //  -------------------------------
    // |  U50  |  V51  |  U52  |  V53  |
    //  -------------------------------1
    class YUVParser420SP
        : public YUVParser420P 
    {
    public:
        YUVParser420SP(const std::string& file, const Resolution& resolution)
            : YUVParser420P(file, resolution)
        {}

    private:
        bool DuplicateToFileImpl(const std::string& duplicateFile) const
        {
            std::ofstream oDuplicateFileStream(duplicateFile, std::ios::binary);
            if (oDuplicateFileStream.is_open() && GetFrameCounts()) {
                for (const auto& frame : GetFrames()) {
                    oDuplicateFileStream.write(reinterpret_cast<char*>(frame.yuv.Y.get()), frame.yuv.YSize);
                    for (size_t index = 0; index < frame.yuv.USize; ++index) {
                        oDuplicateFileStream.write(reinterpret_cast<char*>(frame.yuv.U.get()), 1);
                        oDuplicateFileStream.write(reinterpret_cast<char*>(frame.yuv.V.get()), 1);
                    }
                }
                return true;
            }
            else {
                return false;
            }
        }

        void FillYUVFrame(const uint8_t* buf, YUVFrame& frame) const override
        {
            std::memcpy(frame.yuv.Y.get(),
                buf,
                frame.yuv.YSize);
            const auto& uvBuf = buf + frame.yuv.YSize;
            const auto& uvSize = frame.yuv.USize + frame.yuv.VSize;
            for (size_t index = frame.yuv.YSize, uIndex = 0, vIndex = 0; index < uvSize;) {
                std::memcpy(frame.yuv.U.get() + uIndex++,
                    buf + index++,
                    1);

                std::memcpy(frame.yuv.V.get() + vIndex++,
                    buf + index++,
                    1);
            }
        }
    };
}

　　... ...

三、测试样例

int main()
{
    using namespace yuv;
    constexpr auto kYUVFile = u8R"(.\res\file.xxx)";
    const Resolution resolution{ 1920,1080 };
    // 444P
    YUVParser444P parser(kYUVFile, resolution);
    // 422P
    YUVParser422P parser(kYUVFile, resolution);
    // 420P
    YUVParser420P parser(kYUVFile, resolution);
    // 420SP
    YUVParser420SP parser(kYUVFile, resolution);

    parser.Parse();
    std::cerr << "frames = > " << parser.GetFrameCounts() << "\n";
    
    const auto& ext = parser.GetExtension();
    const auto filename = "y_file" + ext;
    const auto duplicateFilename = "duplicate" + ext;
    parser.DuplicateToFile(".//" + duplicateFilename);
    parser.DumpYToFile(".//" + filename);

    return 0;
}

参考文献：

• http://www.chiark.greenend.org.uk/doc/linux-doc-3.16/html/media_api/yuv-formats.html