• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1root {
2    module = "master";
3    codec_adapter_config {
4        match_attr = "codec_adapter_capabilities";
5        use_openmax = false;
6        // capsMask: 0x01, Adaptive playback; 0x02, Secure playback; 0x04, Tunnel playback.
7        // allocateMask: 0x01, Input buffer allocated within the Codec module;
8        // allocateMask: 0x02, Input buffer allocated by an external user;
9        // allocateMask: 0x04, Output buffer allocated within the Codec module;
10        // allocateMask: 0x08, Output buffer allocated by an external user.
11
12        VideoHwEncoders {
13            /* node name explaination -- HDF_video_hw_enc_avc_rk:
14            **
15            **    HDF____________video__________________hw____________________enc____________avc_______rk
16            **     |               |                    |                      |              |        |
17            ** HDF or OMX    video or audio    hardware or software    encoder or decoder    mime    vendor
18            */
19            HDF_video_hw_enc_avc_rk {
20                role = 1;
21                type = 1;
22                name = "rk.video_encoder.avc";
23                supportProfiles = [1, 32768, 2, 32768, 8, 32768];
24                maxInst = 4;
25                isSoftwareCodec = false;
26                processModeMask = [];
27                capsMask = [0x01];
28                minBitRate = 1;
29                maxBitRate = 40000000;
30                bufferSize = 40960;
31                minWidth = 176;
32                minHeight = 144;
33                maxWidth = 1920;
34                maxHeight = 1088;
35                widthAlignment = 16;
36                heightAlignment = 8;
37                allocateMask = [0x01, 0x04, 0x08];
38                minInputBufferNum = 1;
39                maxInputBufferNum = 20;
40                minOutputBufferNum = 1;
41                maxOutputBufferNum = 40;
42                minBlockCount = 0xFFFFFFFF;
43                maxBlockCount = 0xFFFFFFFF;
44                minBlocksPerSecond = 0xFFFFFFFF;
45                maxBlocksPerSecond = 0xFFFFFFFF;
46                blockSizeWidth = 0xFFFFFFFF;
47                blockSizeHeight = 0xFFFFFFFF;
48                supportPixelFmts = [28, 24, 30, 22, 7, 3, 14, 13, 20, 26, 27, 12];
49                measuredFrameRate = [320, 240, 165, 165, 720, 480, 149, 149, 1280, 720, 73, 73, 1920, 1080, 18, 18];
50                bitRateMode = [1, 2];
51                minFrameRate = 0;
52                maxFrameRate = 0;
53                inputBufferCount = 4;
54                inputBufferSize = 614400;
55                outputBufferCount = 4;
56                outputBufferSize = 40960;
57            }
58        }
59        VideoHwDecoders {
60            HDF_video_hw_dec_avc_rk {
61                role = 1;
62                type = 0;
63                name = "rk.video_decoder.avc";
64                supportProfiles = [1, 32768, 2, 32768, 8, 32768];
65                maxInst = 6;
66                isSoftwareCodec = false;
67                processModeMask = [];
68                capsMask = [0x01];
69                minBitRate = 1;
70                maxBitRate = 10000000;
71                bufferSize = 40960;
72                minWidth = 176;
73                minHeight = 144;
74                maxWidth = 4096;
75                maxHeight = 2160;
76                widthAlignment = 8;
77                heightAlignment = 8;
78                allocateMask = [0x01, 0x04, 0x08];
79                minInputBufferNum = 1;
80                maxInputBufferNum = 20;
81                minOutputBufferNum = 1;
82                maxOutputBufferNum = 40;
83                minBlockCount = 0xFFFFFFFF;
84                maxBlockCount = 0xFFFFFFFF;
85                minBlocksPerSecond = 1;
86                maxBlocksPerSecond = 244800;
87                blockSizeWidth = 16;
88                blockSizeHeight = 16;
89                supportPixelFmts = [24];
90                measuredFrameRate = [320, 240, 617, 617, 720, 480, 559, 559, 1280, 720, 276, 276, 1920, 1080, 164, 164, 3840, 2160, 30, 30];
91                bitRateMode = [];
92                minFrameRate = 0;
93                maxFrameRate = 0;
94                inputBufferCount = 4;
95                inputBufferSize = 409600;
96                outputBufferCount = 10;
97                outputBufferSize = 614400;
98            }
99            HDF_video_hw_dec_mpeg2_rk {
100                role = 0xFFFFFFFF;
101                type = 0;
102                name = "rk.video_decoder.m2v";
103                supportProfiles = [0, 3, 1, 3];
104                maxInst = 6;
105                isSoftwareCodec = false;
106                processModeMask = [];
107                capsMask = [0x01];
108                minBitRate = 1;
109                maxBitRate = 10000000;
110                bufferSize = 40960;
111                minWidth = 176;
112                minHeight = 144;
113                maxWidth = 1920;
114                maxHeight = 1088;
115                widthAlignment = 8;
116                heightAlignment = 8;
117                allocateMask = [0x01, 0x04, 0x08];
118                minInputBufferNum = 1;
119                maxInputBufferNum = 20;
120                minOutputBufferNum = 1;
121                maxOutputBufferNum = 40;
122                minBlockCount = 0xFFFFFFFF;
123                maxBlockCount = 0xFFFFFFFF;
124                minBlocksPerSecond = 1;
125                maxBlocksPerSecond = 244800;
126                blockSizeWidth = 16;
127                blockSizeHeight = 8;
128                supportPixelFmts = [24];
129                measuredFrameRate = [];
130                bitRateMode = [];
131                minFrameRate = 0;
132                maxFrameRate = 0;
133                inputBufferCount = 4;
134                inputBufferSize = 4096;
135                outputBufferCount = 10;
136                outputBufferSize = 614400;
137            }
138            HDF_video_hw_dec_v8p_rk {
139                role = 0xFFFFFFFF;
140                type = 0;
141                name = "rk.video_decoder.vp8";
142                supportProfiles = [];
143                maxInst = 6;
144                isSoftwareCodec = false;
145                processModeMask = [];
146                capsMask = [0x01];
147                minBitRate = 1;
148                maxBitRate = 10000000;
149                bufferSize = 40960;
150                minWidth = 176;
151                minHeight = 144;
152                maxWidth = 1920;
153                maxHeight = 1088;
154                widthAlignment = 8;
155                heightAlignment = 8;
156                allocateMask = [0x01, 0x04, 0x08];
157                minInputBufferNum = 1;
158                maxInputBufferNum = 20;
159                minOutputBufferNum = 1;
160                maxOutputBufferNum = 40;
161                minBlockCount = 0xFFFFFFFF;
162                maxBlockCount = 0xFFFFFFFF;
163                minBlocksPerSecond = 1;
164                maxBlocksPerSecond = 244800;
165                blockSizeWidth = 16;
166                blockSizeHeight = 16;
167                supportPixelFmts = [24];
168                measuredFrameRate = [320, 180, 500, 500, 640, 360, 387, 387, 1280, 720, 112, 112, 1920, 1080, 77, 77];
169                bitRateMode = [];
170                minFrameRate = 0;
171                maxFrameRate = 0;
172                inputBufferCount = 4;
173                inputBufferSize = 4096;
174                outputBufferCount = 10;
175                outputBufferSize = 614400;
176            }
177            HDF_video_hw_dec_h263_rk {
178                role = 0xFFFFFFFF;
179                type = 0;
180                name = "rk.video_decoder.h263";
181                supportProfiles = [1, 1, 1, 2, 1, 4, 1, 16, 8, 1, 8, 2, 8, 4, 8, 16];
182                maxInst = 6;
183                isSoftwareCodec = false;
184                processModeMask = [];
185                capsMask = [0x01];
186                minBitRate = 1;
187                maxBitRate = 10000000;
188                bufferSize = 40960;
189                minWidth = 176;
190                minHeight = 144;
191                maxWidth = 1920;
192                maxHeight = 1088;
193                widthAlignment = 8;
194                heightAlignment = 8;
195                allocateMask = [0x01, 0x04, 0x08];
196                minInputBufferNum = 1;
197                maxInputBufferNum = 20;
198                minOutputBufferNum = 1;
199                maxOutputBufferNum = 40;
200                minBlockCount = 0xFFFFFFFF;
201                maxBlockCount = 0xFFFFFFFF;
202                minBlocksPerSecond = 1;
203                maxBlocksPerSecond = 244800;
204                blockSizeWidth = 16;
205                blockSizeHeight = 16;
206                supportPixelFmts = [24];
207                measuredFrameRate = [176, 144, 600, 600, 352, 288, 600, 600];
208                bitRateMode = [];
209                minFrameRate = 0;
210                maxFrameRate = 0;
211                inputBufferCount = 4;
212                inputBufferSize = 4096;
213                outputBufferCount = 10;
214                outputBufferSize = 614400;
215            }
216            HDF_video_hw_dec_m4v_rk {
217                role = 0xFFFFFFFF;
218                type = 0;
219                name = "rk.video_decoder.m4v";
220                supportProfiles = [1, 1, 1, 2, 1, 4, 1, 8, 1, 16];
221                maxInst = 6;
222                isSoftwareCodec = false;
223                processModeMask = [];
224                capsMask = [0x01];
225                minBitRate = 1;
226                maxBitRate = 10000000;
227                bufferSize = 40960;
228                minWidth = 176;
229                minHeight = 144;
230                maxWidth = 1920;
231                maxHeight = 1088;
232                widthAlignment = 8;
233                heightAlignment = 8;
234                allocateMask = [0x01, 0x04, 0x08];
235                minInputBufferNum = 1;
236                maxInputBufferNum = 20;
237                minOutputBufferNum = 1;
238                maxOutputBufferNum = 40;
239                minBlockCount = 0xFFFFFFFF;
240                maxBlockCount = 0xFFFFFFFF;
241                minBlocksPerSecond = 1;
242                maxBlocksPerSecond = 244800;
243                blockSizeWidth = 16;
244                blockSizeHeight = 16;
245                supportPixelFmts = [24];
246                measuredFrameRate = [176, 144, 600, 600];
247                bitRateMode = [];
248                minFrameRate = 0;
249                maxFrameRate = 0;
250                inputBufferCount = 4;
251                inputBufferSize = 4096;
252                outputBufferCount = 10;
253                outputBufferSize = 614400;
254            }
255            HDF_video_hw_dec_flv_rk {
256                role = 0xFFFFFFFF;
257                type = 0;
258                name = "rk.video_decoder.flv1";
259                supportProfiles = [];
260                maxInst = 6;
261                isSoftwareCodec = false;
262                processModeMask = [];
263                capsMask = [0x01];
264                minBitRate = 1;
265                maxBitRate = 10000000;
266                bufferSize = 40960;
267                minWidth = 176;
268                minHeight = 144;
269                maxWidth = 1920;
270                maxHeight = 1088;
271                widthAlignment = 8;
272                heightAlignment = 8;
273                allocateMask = [0x01, 0x04, 0x08];
274                minInputBufferNum = 1;
275                maxInputBufferNum = 20;
276                minOutputBufferNum = 1;
277                maxOutputBufferNum = 40;
278                minBlockCount = 0xFFFFFFFF;
279                maxBlockCount = 0xFFFFFFFF;
280                minBlocksPerSecond = 1;
281                maxBlocksPerSecond = 244800;
282                blockSizeWidth = 16;
283                blockSizeHeight = 16;
284                supportPixelFmts = [24];
285                measuredFrameRate = [];
286                bitRateMode = [];
287                minFrameRate = 0;
288                maxFrameRate = 0;
289                inputBufferCount = 4;
290                inputBufferSize = 4096;
291                outputBufferCount = 10;
292                outputBufferSize = 614400;
293            }
294            HDF_video_hw_dec_mjpeg_rk {
295                role = 0;
296                type = 0;
297                name = "rk.video_decoder.mjpeg";
298                supportProfiles = [];
299                maxInst = 6;
300                isSoftwareCodec = false;
301                processModeMask = [];
302                capsMask = [0x01];
303                minBitRate = 1;
304                maxBitRate = 10000000;
305                bufferSize = 40960;
306                minWidth = 176;
307                minHeight = 144;
308                maxWidth = 1920;
309                maxHeight = 1088;
310                widthAlignment = 8;
311                heightAlignment = 8;
312                allocateMask = [0x01, 0x04, 0x08];
313                minInputBufferNum = 1;
314                maxInputBufferNum = 20;
315                minOutputBufferNum = 1;
316                maxOutputBufferNum = 40;
317                minBlockCount = 0xFFFFFFFF;
318                maxBlockCount = 0xFFFFFFFF;
319                minBlocksPerSecond = 1;
320                maxBlocksPerSecond = 244800;
321                blockSizeWidth = 16;
322                blockSizeHeight = 16;
323                supportPixelFmts = [24];
324                measuredFrameRate = [];
325                bitRateMode = [];
326                minFrameRate = 0;
327                maxFrameRate = 0;
328                inputBufferCount = 4;
329                inputBufferSize = 4096;
330                outputBufferCount = 10;
331                outputBufferSize = 614400;
332            }
333            HDF_video_hw_dec_hevc_rk {
334                role = 2;
335                type = 0;
336                name = "rk.video_decoder.hevc";
337                supportProfiles = [1, 1, 1, 4, 1, 16, 1, 64, 1, 256, 1, 1024, 1, 4096, 1, 16384, 1, 65536, 2, 65536];
338                maxInst = 6;
339                isSoftwareCodec = false;
340                processModeMask = [];
341                capsMask = [0x01];
342                minBitRate = 1;
343                maxBitRate = 160000000;
344                bufferSize = 40960;
345                minWidth = 176;
346                minHeight = 144;
347                maxWidth = 1920;
348                maxHeight = 1088;
349                widthAlignment = 2;
350                heightAlignment = 2;
351                allocateMask = [0x01, 0x04, 0x08];
352                minInputBufferNum = 1;
353                maxInputBufferNum = 20;
354                minOutputBufferNum = 1;
355                maxOutputBufferNum = 40;
356                minBlockCount = 0xFFFFFFFF;
357                maxBlockCount = 0xFFFFFFFF;
358                minBlocksPerSecond = 1;
359                maxBlocksPerSecond = 244800;
360                blockSizeWidth = 16;
361                blockSizeHeight = 16;
362                supportPixelFmts = [24];
363                measuredFrameRate = [352, 288, 700, 700, 720, 480, 700, 700, 640, 360, 980, 980, 1280, 720, 600, 600, 1920, 1080, 130, 130, 3840, 2160, 130, 130];
364                bitRateMode = [];
365                minFrameRate = 0;
366                maxFrameRate = 0;
367                inputBufferCount = 4;
368                inputBufferSize = 4096;
369                outputBufferCount = 10;
370                outputBufferSize = 614400;
371            }
372        }
373        VideoSwEncoders {
374        }
375        VideoSwDecoders {
376        }
377        AudioHwEncoders {
378        }
379        AudioHwDecoders {
380        }
381        AudioSwEncoders {
382        }
383        AudioSwDecoders {
384        }
385    }
386}
387