/*
 * Copyright (C) 2013-2016 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef vaapidecoder_h265_h
#define vaapidecoder_h265_h

#include "common/Functional.h"
#include "vaapidecoder_base.h"
#include "vaapidecpicture.h"

#include <set>
#include <map>
#include <va/va_dec_hevc.h>

namespace YamiParser {
namespace H265 {
    struct SPS;
    struct SliceHeader;
    struct NalUnit;
    class Parser;
};
};

namespace YamiMediaCodec {

class VaapiDecPictureH265;
class VaapiDecoderH265:public VaapiDecoderBase {
    typedef YamiParser::H265::SPS SPS;
    typedef YamiParser::H265::SliceHeader SliceHeader;
    typedef YamiParser::H265::NalUnit NalUnit;
    typedef YamiParser::H265::Parser Parser;

public:
    typedef SharedPtr<VaapiDecPictureH265> PicturePtr;
    typedef std::vector<VaapiDecPictureH265*> RefSet;
    VaapiDecoderH265();
    virtual ~VaapiDecoderH265();
    virtual YamiStatus start(VideoConfigBuffer*);
    virtual YamiStatus decode(VideoDecodeBuffer*);
    virtual void flush(void);

private:
    friend class FactoryTest<IVideoDecoder, VaapiDecoderH265>;
    friend class VaapiDecoderH265Test;

    class DPB {
        typedef VaapiDecoderH265::RefSet     RefSet;
        typedef std::function<YamiStatus(const PicturePtr&)> OutputCallback;
        typedef std::function<void (const PicturePtr&)> ForEachFunction;
    public:
        typedef VaapiDecoderH265::PicturePtr PicturePtr;
        DPB(OutputCallback output);
        bool init(const PicturePtr&,
                  const SliceHeader *const,
                  const NalUnit *const,
                  bool newStream);
        bool add(const PicturePtr&, const SliceHeader* const lastSlice);
        void flush();

        RefSet m_stCurrBefore;
        RefSet m_stCurrAfter;
        RefSet m_stFoll;
        RefSet m_ltCurr;
        RefSet m_ltFoll;
    private:
        void forEach(ForEachFunction);
        bool initReference(const PicturePtr&,
                           const SliceHeader *const,
                           const NalUnit *const,
                           bool newStream);
        bool initShortTermRef(const PicturePtr& picture,
                              const SliceHeader* const);
        bool initShortTermRef(RefSet& ref,int32_t currPoc,
                              const int32_t* const delta,
                              const uint8_t* const used,
                              uint8_t num);
        bool initLongTermRef(const PicturePtr&,
                             const SliceHeader *const);
        VaapiDecPictureH265* getPic(int32_t poc, bool hasMsb = true);

        //for C.5.2.2
        bool checkReorderPics(const SPS* const sps);
        bool checkDpbSize(const SPS* const);
        bool checkLatency(const SPS* const);
        void removeUnused();
        void clearRefSet();

        void bumpAll();
        bool bump();
        bool output(const PicturePtr& picture);


        struct PocLess
        {
            inline bool operator()(const PicturePtr& left, const PicturePtr& right) const;
        };
        typedef std::set<PicturePtr, PocLess> PictureList;
        PictureList     m_pictures;
        OutputCallback  m_output;
        PicturePtr      m_dummy;
    };
    YamiStatus decodeNalu(NalUnit*);
    YamiStatus decodeParamSet(NalUnit*);
    YamiStatus decodeSlice(NalUnit*);

    static VAProfile getVaProfile(const SPS* const sps);
    YamiStatus ensureContext(const SPS* const);
    bool fillPicture(const PicturePtr& , const SliceHeader* const );
    bool fillSlice(const PicturePtr&, const SliceHeader* const, const NalUnit* const );
    bool fillIqMatrix(const PicturePtr&, const SliceHeader* const);
    bool fillPredWeightTable(VASliceParameterBufferHEVC*, const SliceHeader* const);
    bool fillReference(const PicturePtr&,
            VASliceParameterBufferHEVC*, const SliceHeader* const);
    void fillReference(VAPictureHEVC* refs, int32_t size);
    void fillReference(VAPictureHEVC* refs, int32_t& n, const RefSet& refset, uint32_t flags);


    bool fillReferenceIndex(VASliceParameterBufferHEVC*, const SliceHeader* const);
    void fillReferenceIndexForList(VASliceParameterBufferHEVC*, const RefSet&, bool isList0);
    bool getRefPicList(RefSet& refset, const RefSet& stCurr0, const RefSet& stCurr1,
                       uint8_t numActive, bool modify, const uint32_t* modiList);
    uint8_t getIndex(int32_t poc);

    bool decodeHevcRecordData(uint8_t* buf, int32_t bufSize);

    SurfacePtr createSurface(const SliceHeader* const);
    YamiStatus createPicture(PicturePtr& picture, const SliceHeader* const, const NalUnit* const nalu);
    void getPoc(const PicturePtr&, const SliceHeader* const,
            const NalUnit* const);
    YamiStatus decodeCurrent();
    YamiStatus outputPicture(const PicturePtr&);
    void flush(bool discardOutput);

    SharedPtr<Parser> m_parser;
    PicturePtr  m_current;
    int32_t     m_prevPicOrderCntMsb;
    int32_t     m_prevPicOrderCntLsb;
    int32_t     m_nalLengthSize;
    bool        m_associatedIrapNoRaslOutputFlag;
    bool        m_noRaslOutputFlag;
    bool        m_newStream;
    bool        m_endOfSequence;
    DPB         m_dpb;
    std::map<int32_t, uint8_t> m_pocToIndex;
    SharedPtr<SliceHeader> m_prevSlice;

    /**
     * VaapiDecoderFactory registration result. This decoder is registered in
     * vaapidecoder_host.cpp
     */
    static const bool s_registered;
};

} // namespace YamiMediaCodec

#endif