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