1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
|
/*############################################################################
# Copyright (C) 2005 Intel Corporation
#
# SPDX-License-Identifier: MIT
############################################################################*/
#ifndef _AVC_SPL_H__
#define _AVC_SPL_H__
#include <list>
#include <memory>
#include <vector>
#include "abstract_splitter.h"
#include "avc_bitstream.h"
#include "avc_headers.h"
#include "avc_nal_spl.h"
namespace ProtectedLibrary {
class AVCSlice : public SliceSplitterInfo {
public:
AVCSlice();
AVCSliceHeader* GetSliceHeader();
bool IsField() const {
return m_sliceHeader.field_pic_flag != 0;
}
mfxI32 RetrievePicParamSetNumber(mfxU8* pSource, mfxU32 nSourceSize);
bool DecodeHeader(mfxU8* pSource, mfxU32 nSourceSize);
AVCHeadersBitstream* GetBitStream(void) {
return &m_bitStream;
}
AVCPicParamSet* m_picParamSet;
AVCSeqParamSet* m_seqParamSet;
AVCSeqParamSet* m_seqParamSetMvcEx;
AVCSeqParamSetExtension* m_seqParamSetEx;
mfxU64 m_dTime;
protected:
AVCSliceHeader m_sliceHeader;
AVCHeadersBitstream m_bitStream;
void Reset();
};
class AVCFrameInfo {
public:
AVCFrameInfo();
void Reset();
AVCSlice* m_slice;
mfxU32 m_index;
};
class AVC_Spl : public AbstractSplitter {
public:
AVC_Spl();
virtual ~AVC_Spl();
virtual mfxStatus Reset();
virtual mfxStatus GetFrame(mfxBitstream* bs_in, FrameSplitterInfo** frame);
virtual mfxStatus PostProcessing(FrameSplitterInfo* frame, mfxU32 sliceNum);
void ResetCurrentState();
protected:
std::unique_ptr<NALUnitSplitter> m_pNALSplitter;
mfxStatus Init();
void Close();
mfxStatus ProcessNalUnit(mfxI32 nalType, mfxBitstream* destination);
mfxStatus DecodeHeader(mfxBitstream* nalUnit);
mfxStatus DecodeSEI(mfxBitstream* nalUnit);
AVCSlice* DecodeSliceHeader(mfxBitstream* nalUnit);
mfxStatus AddSlice(AVCSlice* pSlice);
AVCFrameInfo* GetFreeFrame();
mfxU8* GetMemoryForSwapping(mfxU32 size);
mfxStatus AddNalUnit(mfxBitstream* nalUnit);
mfxStatus AddSliceNalUnit(mfxBitstream* nalUnit, AVCSlice* pSlice);
bool IsFieldOfOneFrame(AVCFrameInfo* frame,
const AVCSliceHeader* slice1,
const AVCSliceHeader* slice2);
bool m_WaitForIDR;
AVCHeaders m_headers;
std::unique_ptr<AVCFrameInfo> m_AUInfo;
AVCFrameInfo* m_currentInfo;
AVCSlice* m_pLastSlice;
mfxBitstream* m_lastNalUnit;
enum { BUFFER_SIZE = 1024 * 1024 };
std::vector<mfxU8> m_currentFrame;
std::vector<mfxU8> m_swappingMemory;
std::list<AVCSlice> m_slicesStorage;
std::vector<SliceSplitterInfo> m_slices;
FrameSplitterInfo m_frame;
};
} // namespace ProtectedLibrary
#endif // _AVC_SPL_H__
|
