1/*
2* Copyright (c) 2009-2011 Intel Corporation.  All rights reserved.
3*
4* Licensed under the Apache License, Version 2.0 (the "License");
5* you may not use this file except in compliance with the License.
6* You may obtain a copy of the License at
7*
8* http://www.apache.org/licenses/LICENSE-2.0
9*
10* Unless required by applicable law or agreed to in writing, software
11* distributed under the License is distributed on an "AS IS" BASIS,
12* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13* See the License for the specific language governing permissions and
14* limitations under the License.
15*/
16
17#ifndef __VIDEO_ENCODER_DEF_H__
18#define __VIDEO_ENCODER_DEF_H__
19
20#include <stdint.h>
21
22#define STRING_TO_FOURCC(format) ((uint32_t)(((format)[0])|((format)[1]<<8)|((format)[2]<<16)|((format)[3]<<24)))
23#define min(X,Y) (((X) < (Y)) ? (X) : (Y))
24#define max(X,Y) (((X) > (Y)) ? (X) : (Y))
25
26typedef int32_t Encode_Status;
27
28// Video encode error code
29enum {
30    ENCODE_INVALID_SURFACE = -11,
31    ENCODE_NO_REQUEST_DATA = -10,
32    ENCODE_WRONG_STATE = -9,
33    ENCODE_NOTIMPL = -8,
34    ENCODE_NO_MEMORY = -7,
35    ENCODE_NOT_INIT = -6,
36    ENCODE_DRIVER_FAIL = -5,
37    ENCODE_INVALID_PARAMS = -4,
38    ENCODE_NOT_SUPPORTED = -3,
39    ENCODE_NULL_PTR = -2,
40    ENCODE_FAIL = -1,
41    ENCODE_SUCCESS = 0,
42    ENCODE_ALREADY_INIT = 1,
43    ENCODE_SLICESIZE_OVERFLOW = 2,
44    ENCODE_BUFFER_TOO_SMALL = 3, // The buffer passed to encode is too small to contain encoded data
45    ENCODE_DEVICE_BUSY = 4,
46    ENCODE_DATA_NOT_READY = 5,
47};
48
49typedef enum {
50    OUTPUT_EVERYTHING = 0,  //Output whatever driver generates
51    OUTPUT_CODEC_DATA = 1,
52    OUTPUT_FRAME_DATA = 2, //Equal to OUTPUT_EVERYTHING when no header along with the frame data
53    OUTPUT_ONE_NAL = 4,
54    OUTPUT_ONE_NAL_WITHOUT_STARTCODE = 8,
55    OUTPUT_LENGTH_PREFIXED = 16,
56    OUTPUT_CODEDBUFFER = 32,
57    OUTPUT_NALULENGTHS_PREFIXED = 64,
58    OUTPUT_BUFFER_LAST
59} VideoOutputFormat;
60
61typedef enum {
62    RAW_FORMAT_NONE = 0,
63    RAW_FORMAT_YUV420 = 1,
64    RAW_FORMAT_YUV422 = 2,
65    RAW_FORMAT_YUV444 = 4,
66    RAW_FORMAT_NV12 = 8,
67    RAW_FORMAT_RGBA = 16,
68    RAW_FORMAT_OPAQUE = 32,
69    RAW_FORMAT_PROTECTED = 0x80000000,
70    RAW_FORMAT_LAST
71} VideoRawFormat;
72
73typedef enum {
74    RATE_CONTROL_NONE = 1,
75    RATE_CONTROL_CBR = 2,
76    RATE_CONTROL_VBR = 4,
77    RATE_CONTROL_VCM = 8,
78    RATE_CONTROL_LAST
79} VideoRateControl;
80
81typedef enum {
82    PROFILE_MPEG2SIMPLE = 0,
83    PROFILE_MPEG2MAIN,
84    PROFILE_MPEG4SIMPLE,
85    PROFILE_MPEG4ADVANCEDSIMPLE,
86    PROFILE_MPEG4MAIN,
87    PROFILE_H264BASELINE,
88    PROFILE_H264MAIN,
89    PROFILE_H264HIGH,
90    PROFILE_VC1SIMPLE,
91    PROFILE_VC1MAIN,
92    PROFILE_VC1ADVANCED,
93    PROFILE_H263BASELINE
94} VideoProfile;
95
96typedef enum {
97    AVC_DELIMITER_LENGTHPREFIX = 0,
98    AVC_DELIMITER_ANNEXB
99} AVCDelimiterType;
100
101typedef enum {
102    VIDEO_ENC_NONIR,       // Non intra refresh
103    VIDEO_ENC_CIR, 		// Cyclic intra refresh
104    VIDEO_ENC_AIR, 		// Adaptive intra refresh
105    VIDEO_ENC_BOTH,
106    VIDEO_ENC_LAST
107} VideoIntraRefreshType;
108
109enum VideoBufferSharingMode {
110    BUFFER_SHARING_NONE = 1, //Means non shared buffer mode
111    BUFFER_SHARING_CI = 2,
112    BUFFER_SHARING_V4L2 = 4,
113    BUFFER_SHARING_SURFACE = 8,
114    BUFFER_SHARING_USRPTR = 16,
115    BUFFER_SHARING_GFXHANDLE = 32,
116    BUFFER_SHARING_KBUFHANDLE = 64,
117    BUFFER_LAST
118};
119
120typedef enum {
121    FTYPE_UNKNOWN = 0, // Unknown
122    FTYPE_I = 1, // General I-frame type
123    FTYPE_P = 2, // General P-frame type
124    FTYPE_B = 3, // General B-frame type
125    FTYPE_SI = 4, // H.263 SI-frame type
126    FTYPE_SP = 5, // H.263 SP-frame type
127    FTYPE_EI = 6, // H.264 EI-frame type
128    FTYPE_EP = 7, // H.264 EP-frame type
129    FTYPE_S = 8, // MPEG-4 S-frame type
130    FTYPE_IDR = 9, // IDR-frame type
131}FrameType;
132
133//function call mode
134#define FUNC_BLOCK        0xFFFFFFFF
135#define FUNC_NONBLOCK        0
136
137// Output buffer flag
138#define ENCODE_BUFFERFLAG_ENDOFFRAME       0x00000001
139#define ENCODE_BUFFERFLAG_PARTIALFRAME     0x00000002
140#define ENCODE_BUFFERFLAG_SYNCFRAME        0x00000004
141#define ENCODE_BUFFERFLAG_CODECCONFIG      0x00000008
142#define ENCODE_BUFFERFLAG_DATACORRUPT      0x00000010
143#define ENCODE_BUFFERFLAG_DATAINVALID      0x00000020
144#define ENCODE_BUFFERFLAG_SLICEOVERFOLOW   0x00000040
145#define ENCODE_BUFFERFLAG_ENDOFSTREAM     0x00000080
146#define ENCODE_BUFFERFLAG_NSTOPFRAME        0x00000100
147
148typedef struct {
149    uint8_t *data;
150    uint32_t bufferSize; //buffer size
151    uint32_t dataSize; //actual size
152    uint32_t offset; //buffer offset
153    uint32_t remainingSize;
154    int flag; //Key frame, Codec Data etc
155    VideoOutputFormat format; //output format
156    int64_t timeStamp; //reserved
157    FrameType type;
158    void *priv; //indicate corresponding input data
159} VideoEncOutputBuffer;
160
161typedef struct {
162    uint8_t *data;
163    uint32_t size;
164    bool bufAvailable; //To indicate whether this buffer can be reused
165    int64_t timeStamp; //reserved
166    FrameType type; //frame type expected to be encoded
167    int flag; // flag to indicate buffer property
168    void *priv; //indicate corresponding input data
169} VideoEncRawBuffer;
170
171struct VideoEncSurfaceBuffer {
172    VASurfaceID surface;
173    uint8_t *usrptr;
174    uint32_t index;
175    bool bufAvailable;
176    VideoEncSurfaceBuffer *next;
177};
178
179struct CirParams {
180    uint32_t cir_num_mbs;
181
182    CirParams &operator=(const CirParams &other) {
183        if (this == &other) return *this;
184
185        this->cir_num_mbs = other.cir_num_mbs;
186        return *this;
187    }
188};
189
190struct AirParams {
191    uint32_t airMBs;
192    uint32_t airThreshold;
193    uint32_t airAuto;
194
195    AirParams &operator=(const AirParams &other) {
196        if (this == &other) return *this;
197
198        this->airMBs= other.airMBs;
199        this->airThreshold= other.airThreshold;
200        this->airAuto = other.airAuto;
201        return *this;
202    }
203};
204
205struct VideoFrameRate {
206    uint32_t frameRateNum;
207    uint32_t frameRateDenom;
208
209    VideoFrameRate &operator=(const VideoFrameRate &other) {
210        if (this == &other) return *this;
211
212        this->frameRateNum = other.frameRateNum;
213        this->frameRateDenom = other.frameRateDenom;
214        return *this;
215    }
216};
217
218struct VideoResolution {
219    uint32_t width;
220    uint32_t height;
221
222    VideoResolution &operator=(const VideoResolution &other) {
223        if (this == &other) return *this;
224
225        this->width = other.width;
226        this->height = other.height;
227        return *this;
228    }
229};
230
231struct VideoRateControlParams {
232    uint32_t bitRate;
233    uint32_t initQP;
234    uint32_t minQP;
235    uint32_t maxQP;
236    uint32_t I_minQP;
237    uint32_t I_maxQP;
238    uint32_t windowSize;
239    uint32_t targetPercentage;
240    uint32_t disableFrameSkip;
241    uint32_t disableBitsStuffing;
242    uint32_t enableIntraFrameQPControl;
243    uint32_t temporalFrameRate;
244    uint32_t temporalID;
245
246    VideoRateControlParams &operator=(const VideoRateControlParams &other) {
247        if (this == &other) return *this;
248
249        this->bitRate = other.bitRate;
250        this->initQP = other.initQP;
251        this->minQP = other.minQP;
252        this->maxQP = other.maxQP;
253        this->I_minQP = other.I_minQP;
254        this->I_maxQP = other.I_maxQP;
255        this->windowSize = other.windowSize;
256        this->targetPercentage = other.targetPercentage;
257        this->disableFrameSkip = other.disableFrameSkip;
258        this->disableBitsStuffing = other.disableBitsStuffing;
259        this->enableIntraFrameQPControl = other.enableIntraFrameQPControl;
260        this->temporalFrameRate = other.temporalFrameRate;
261        this->temporalID = other.temporalID;
262
263        return *this;
264    }
265};
266
267struct SliceNum {
268    uint32_t iSliceNum;
269    uint32_t pSliceNum;
270
271    SliceNum &operator=(const SliceNum &other) {
272        if (this == &other) return *this;
273
274        this->iSliceNum = other.iSliceNum;
275        this->pSliceNum= other.pSliceNum;
276        return *this;
277    }
278};
279
280typedef struct {
281    uint32_t realWidth;
282    uint32_t realHeight;
283    uint32_t lumaStride;
284    uint32_t chromStride;
285    uint32_t format;
286} ExternalBufferAttrib;
287
288struct Cropping {
289    uint32_t LeftOffset;
290    uint32_t RightOffset;
291    uint32_t TopOffset;
292    uint32_t BottomOffset;
293
294    Cropping &operator=(const Cropping &other) {
295        if (this == &other) return *this;
296
297        this->LeftOffset = other.LeftOffset;
298        this->RightOffset = other.RightOffset;
299        this->TopOffset = other.TopOffset;
300        this->BottomOffset = other.BottomOffset;
301        return *this;
302    }
303};
304
305struct SamplingAspectRatio {
306    uint16_t SarWidth;
307    uint16_t SarHeight;
308
309    SamplingAspectRatio &operator=(const SamplingAspectRatio &other) {
310        if (this == &other) return *this;
311
312        this->SarWidth = other.SarWidth;
313        this->SarHeight = other.SarHeight;
314        return *this;
315    }
316};
317
318enum VideoParamConfigType {
319    VideoParamsTypeStartUnused = 0x01000000,
320    VideoParamsTypeCommon,
321    VideoParamsTypeAVC,
322    VideoParamsTypeH263,
323    VideoParamsTypeMP4,
324    VideoParamsTypeVC1,
325    VideoParamsTypeUpSteamBuffer,
326    VideoParamsTypeUsrptrBuffer,
327    VideoParamsTypeHRD,
328    VideoParamsTypeStoreMetaDataInBuffers,
329    VideoParamsTypeProfileLevel,
330    VideoParamsTypeVP8,
331    VideoParamsTypeTemporalLayer,
332
333    VideoConfigTypeFrameRate,
334    VideoConfigTypeBitRate,
335    VideoConfigTypeResolution,
336    VideoConfigTypeIntraRefreshType,
337    VideoConfigTypeAIR,
338    VideoConfigTypeCyclicFrameInterval,
339    VideoConfigTypeAVCIntraPeriod,
340    VideoConfigTypeNALSize,
341    VideoConfigTypeIDRRequest,
342    VideoConfigTypeSliceNum,
343    VideoConfigTypeVP8,
344    VideoConfigTypeVP8ReferenceFrame,
345    VideoConfigTypeCIR,
346    VideoConfigTypeVP8MaxFrameSizeRatio,
347    VideoConfigTypeTemperalLayerBitrateFramerate,
348
349    VideoParamsConfigExtension
350};
351
352struct VideoParamConfigSet {
353    VideoParamConfigType type;
354    uint32_t size;
355
356    VideoParamConfigSet &operator=(const VideoParamConfigSet &other) {
357        if (this == &other) return *this;
358        this->type = other.type;
359        this->size = other.size;
360        return *this;
361    }
362};
363
364struct VideoParamsCommon : VideoParamConfigSet {
365
366    VAProfile profile;
367    uint8_t level;
368    VideoRawFormat rawFormat;
369    VideoResolution resolution;
370    VideoFrameRate frameRate;
371    int32_t intraPeriod;
372    VideoRateControl rcMode;
373    VideoRateControlParams rcParams;
374    VideoIntraRefreshType refreshType;
375    int32_t cyclicFrameInterval;
376    AirParams airParams;
377    CirParams cirParams;
378    uint32_t disableDeblocking;
379    bool syncEncMode;
380    //CodedBuffer properties
381    uint32_t codedBufNum;
382    uint32_t numberOfLayer;
383    uint32_t nPeriodicity;
384    uint32_t nLayerID[32];
385
386    VideoParamsCommon() {
387        type = VideoParamsTypeCommon;
388        size = sizeof(VideoParamsCommon);
389    }
390
391    VideoParamsCommon &operator=(const VideoParamsCommon &other) {
392        if (this == &other) return *this;
393
394        VideoParamConfigSet::operator=(other);
395        this->profile = other.profile;
396        this->level = other.level;
397        this->rawFormat = other.rawFormat;
398        this->resolution = other.resolution;
399        this->frameRate = other.frameRate;
400        this->intraPeriod = other.intraPeriod;
401        this->rcMode = other.rcMode;
402        this->rcParams = other.rcParams;
403        this->refreshType = other.refreshType;
404        this->cyclicFrameInterval = other.cyclicFrameInterval;
405        this->airParams = other.airParams;
406        this->disableDeblocking = other.disableDeblocking;
407        this->syncEncMode = other.syncEncMode;
408        this->codedBufNum = other.codedBufNum;
409        this->numberOfLayer = other.numberOfLayer;
410        return *this;
411    }
412};
413
414struct VideoParamsAVC : VideoParamConfigSet {
415    uint32_t basicUnitSize;  //for rate control
416    uint8_t VUIFlag;
417    int32_t maxSliceSize;
418    uint32_t idrInterval;
419    uint32_t ipPeriod;
420    uint32_t refFrames;
421    SliceNum sliceNum;
422    AVCDelimiterType delimiterType;
423    Cropping crop;
424    SamplingAspectRatio SAR;
425    uint32_t refIdx10ActiveMinus1;
426    uint32_t refIdx11ActiveMinus1;
427    bool bFrameMBsOnly;
428    bool bMBAFF;
429    bool bEntropyCodingCABAC;
430    bool bWeightedPPrediction;
431    uint32_t weightedBipredicitonMode;
432    bool bConstIpred ;
433    bool bDirect8x8Inference;
434    bool bDirectSpatialTemporal;
435    uint32_t cabacInitIdc;
436
437    VideoParamsAVC() {
438        type = VideoParamsTypeAVC;
439        size = sizeof(VideoParamsAVC);
440    }
441
442    VideoParamsAVC &operator=(const VideoParamsAVC &other) {
443        if (this == &other) return *this;
444
445        VideoParamConfigSet::operator=(other);
446        this->basicUnitSize = other.basicUnitSize;
447        this->VUIFlag = other.VUIFlag;
448        this->maxSliceSize = other.maxSliceSize;
449        this->idrInterval = other.idrInterval;
450        this->ipPeriod = other.ipPeriod;
451        this->refFrames = other.refFrames;
452        this->sliceNum = other.sliceNum;
453        this->delimiterType = other.delimiterType;
454        this->crop.LeftOffset = other.crop.LeftOffset;
455        this->crop.RightOffset = other.crop.RightOffset;
456        this->crop.TopOffset = other.crop.TopOffset;
457        this->crop.BottomOffset = other.crop.BottomOffset;
458        this->SAR.SarWidth = other.SAR.SarWidth;
459        this->SAR.SarHeight = other.SAR.SarHeight;
460
461        this->refIdx10ActiveMinus1 = other.refIdx10ActiveMinus1;
462        this->refIdx11ActiveMinus1 = other.refIdx11ActiveMinus1;
463        this->bFrameMBsOnly = other.bFrameMBsOnly;
464        this->bMBAFF = other.bMBAFF;
465        this->bEntropyCodingCABAC = other.bEntropyCodingCABAC;
466        this->bWeightedPPrediction = other.bWeightedPPrediction;
467        this->weightedBipredicitonMode = other.weightedBipredicitonMode;
468        this->bConstIpred = other.bConstIpred;
469        this->bDirect8x8Inference = other.bDirect8x8Inference;
470        this->bDirectSpatialTemporal = other.bDirectSpatialTemporal;
471        this->cabacInitIdc = other.cabacInitIdc;
472        return *this;
473    }
474};
475
476struct VideoParamsUpstreamBuffer : VideoParamConfigSet {
477
478    VideoParamsUpstreamBuffer() {
479        type = VideoParamsTypeUpSteamBuffer;
480        size = sizeof(VideoParamsUpstreamBuffer);
481    }
482
483    VideoBufferSharingMode bufferMode;
484    intptr_t *bufList;
485    uint32_t bufCnt;
486    ExternalBufferAttrib *bufAttrib;
487    void *display;
488};
489
490struct VideoParamsUsrptrBuffer : VideoParamConfigSet {
491
492    VideoParamsUsrptrBuffer() {
493        type = VideoParamsTypeUsrptrBuffer;
494        size = sizeof(VideoParamsUsrptrBuffer);
495    }
496
497    //input
498    uint32_t width;
499    uint32_t height;
500    uint32_t format;
501    uint32_t expectedSize;
502
503    //output
504    uint32_t actualSize;
505    uint32_t stride;
506    uint8_t *usrPtr;
507};
508
509struct VideoParamsHRD : VideoParamConfigSet {
510
511    VideoParamsHRD() {
512        type = VideoParamsTypeHRD;
513        size = sizeof(VideoParamsHRD);
514    }
515
516    uint32_t bufferSize;
517    uint32_t initBufferFullness;
518};
519
520struct VideoParamsStoreMetaDataInBuffers : VideoParamConfigSet {
521
522    VideoParamsStoreMetaDataInBuffers() {
523        type = VideoParamsTypeStoreMetaDataInBuffers;
524        size = sizeof(VideoParamsStoreMetaDataInBuffers);
525    }
526
527    bool isEnabled;
528};
529
530struct VideoParamsProfileLevel : VideoParamConfigSet {
531
532    VideoParamsProfileLevel() {
533        type = VideoParamsTypeProfileLevel;
534        size = sizeof(VideoParamsProfileLevel);
535    }
536
537    VAProfile profile;
538    uint32_t level;
539    bool isSupported;
540};
541
542struct VideoParamsTemporalLayer : VideoParamConfigSet {
543
544    VideoParamsTemporalLayer() {
545        type = VideoParamsTypeTemporalLayer;
546        size = sizeof(VideoParamsTemporalLayer);
547    }
548
549    uint32_t numberOfLayer;
550    uint32_t nPeriodicity;
551    uint32_t nLayerID[32];
552};
553
554
555struct VideoConfigFrameRate : VideoParamConfigSet {
556
557    VideoConfigFrameRate() {
558        type = VideoConfigTypeFrameRate;
559        size = sizeof(VideoConfigFrameRate);
560    }
561
562    VideoFrameRate frameRate;
563};
564
565struct VideoConfigBitRate : VideoParamConfigSet {
566
567    VideoConfigBitRate() {
568        type = VideoConfigTypeBitRate;
569        size = sizeof(VideoConfigBitRate);
570    }
571
572    VideoRateControlParams rcParams;
573};
574
575struct VideoConfigAVCIntraPeriod : VideoParamConfigSet {
576
577    VideoConfigAVCIntraPeriod() {
578        type = VideoConfigTypeAVCIntraPeriod;
579        size = sizeof(VideoConfigAVCIntraPeriod);
580    }
581
582    uint32_t idrInterval;  //How many Intra frame will have a IDR frame
583    uint32_t intraPeriod;
584    uint32_t ipPeriod;
585};
586
587struct VideoConfigNALSize : VideoParamConfigSet {
588
589    VideoConfigNALSize() {
590        type = VideoConfigTypeNALSize;
591        size = sizeof(VideoConfigNALSize);
592    }
593
594    uint32_t maxSliceSize;
595};
596
597struct VideoConfigResolution : VideoParamConfigSet {
598
599    VideoConfigResolution() {
600        type = VideoConfigTypeResolution;
601        size = sizeof(VideoConfigResolution);
602    }
603
604    VideoResolution resolution;
605};
606
607struct VideoConfigIntraRefreshType : VideoParamConfigSet {
608
609    VideoConfigIntraRefreshType() {
610        type = VideoConfigTypeIntraRefreshType;
611        size = sizeof(VideoConfigIntraRefreshType);
612    }
613
614    VideoIntraRefreshType refreshType;
615};
616
617struct VideoConfigCyclicFrameInterval : VideoParamConfigSet {
618
619    VideoConfigCyclicFrameInterval() {
620        type = VideoConfigTypeCyclicFrameInterval;
621        size = sizeof(VideoConfigCyclicFrameInterval);
622    }
623
624    int32_t cyclicFrameInterval;
625};
626
627struct VideoConfigCIR : VideoParamConfigSet {
628
629    VideoConfigCIR() {
630        type = VideoConfigTypeCIR;
631        size = sizeof(VideoConfigCIR);
632    }
633
634    CirParams cirParams;
635};
636
637struct VideoConfigAIR : VideoParamConfigSet {
638
639    VideoConfigAIR() {
640        type = VideoConfigTypeAIR;
641        size = sizeof(VideoConfigAIR);
642    }
643
644    AirParams airParams;
645};
646
647struct VideoConfigSliceNum : VideoParamConfigSet {
648
649    VideoConfigSliceNum() {
650        type = VideoConfigTypeSliceNum;
651        size = sizeof(VideoConfigSliceNum);
652    }
653
654    SliceNum sliceNum;
655};
656
657struct VideoParamsVP8 : VideoParamConfigSet {
658
659        uint32_t profile;
660        uint32_t error_resilient;
661        uint32_t num_token_partitions;
662        uint32_t kf_auto;
663        uint32_t kf_min_dist;
664        uint32_t kf_max_dist;
665        uint32_t min_qp;
666        uint32_t max_qp;
667        uint32_t init_qp;
668        uint32_t rc_undershoot;
669        uint32_t rc_overshoot;
670        uint32_t hrd_buf_size;
671        uint32_t hrd_buf_initial_fullness;
672        uint32_t hrd_buf_optimal_fullness;
673        uint32_t max_frame_size_ratio;
674
675        VideoParamsVP8() {
676                type = VideoParamsTypeVP8;
677                size = sizeof(VideoParamsVP8);
678        }
679};
680
681struct VideoConfigVP8 : VideoParamConfigSet {
682
683        uint32_t force_kf;
684        uint32_t refresh_entropy_probs;
685        uint32_t value;
686        unsigned char sharpness_level;
687
688        VideoConfigVP8 () {
689                type = VideoConfigTypeVP8;
690                size = sizeof(VideoConfigVP8);
691        }
692};
693
694struct VideoConfigVP8ReferenceFrame : VideoParamConfigSet {
695
696        uint32_t no_ref_last;
697        uint32_t no_ref_gf;
698        uint32_t no_ref_arf;
699        uint32_t refresh_last;
700        uint32_t refresh_golden_frame;
701        uint32_t refresh_alternate_frame;
702
703        VideoConfigVP8ReferenceFrame () {
704                type = VideoConfigTypeVP8ReferenceFrame;
705                size = sizeof(VideoConfigVP8ReferenceFrame);
706        }
707};
708
709struct VideoConfigVP8MaxFrameSizeRatio : VideoParamConfigSet {
710
711    VideoConfigVP8MaxFrameSizeRatio() {
712        type = VideoConfigTypeVP8MaxFrameSizeRatio;
713        size = sizeof(VideoConfigVP8MaxFrameSizeRatio);
714    }
715
716    uint32_t max_frame_size_ratio;
717};
718
719struct VideoConfigTemperalLayerBitrateFramerate : VideoParamConfigSet {
720
721       VideoConfigTemperalLayerBitrateFramerate() {
722                type = VideoConfigTypeTemperalLayerBitrateFramerate;
723                size = sizeof(VideoConfigTemperalLayerBitrateFramerate);
724        }
725
726        uint32_t nLayerID;
727        uint32_t bitRate;
728        uint32_t frameRate;
729};
730
731#endif /*  __VIDEO_ENCODER_DEF_H__ */
732