1 /**************************************************************************
2 *
3 * Copyright 2013 Advanced Micro Devices, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 /*
29 * Authors:
30 * Christian König <christian.koenig@amd.com>
31 *
32 */
33
34
35 #include <assert.h>
36
37 #include <OMX_Video.h>
38
39 /* bellagio defines a DEBUG macro that we don't want */
40 #ifndef DEBUG
41 #include <bellagio/omxcore.h>
42 #undef DEBUG
43 #else
44 #include <bellagio/omxcore.h>
45 #endif
46
47 #include <bellagio/omx_base_video_port.h>
48
49 #include "pipe/p_screen.h"
50 #include "pipe/p_video_codec.h"
51 #include "util/u_memory.h"
52 #include "vl/vl_video_buffer.h"
53
54 #include "entrypoint.h"
55 #include "vid_enc.h"
56
57 struct encode_task {
58 struct list_head list;
59
60 struct pipe_video_buffer *buf;
61 unsigned pic_order_cnt;
62 struct pipe_resource *bitstream;
63 void *feedback;
64 };
65
66 struct input_buf_private {
67 struct list_head tasks;
68
69 struct pipe_resource *resource;
70 struct pipe_transfer *transfer;
71 };
72
73 struct output_buf_private {
74 struct pipe_resource *bitstream;
75 struct pipe_transfer *transfer;
76 };
77
78 static OMX_ERRORTYPE vid_enc_Constructor(OMX_COMPONENTTYPE *comp, OMX_STRING name);
79 static OMX_ERRORTYPE vid_enc_Destructor(OMX_COMPONENTTYPE *comp);
80 static OMX_ERRORTYPE vid_enc_SetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param);
81 static OMX_ERRORTYPE vid_enc_GetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param);
82 static OMX_ERRORTYPE vid_enc_SetConfig(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR config);
83 static OMX_ERRORTYPE vid_enc_GetConfig(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR config);
84 static OMX_ERRORTYPE vid_enc_MessageHandler(OMX_COMPONENTTYPE *comp, internalRequestMessageType *msg);
85 static OMX_ERRORTYPE vid_enc_AllocateInBuffer(omx_base_PortType *port, OMX_INOUT OMX_BUFFERHEADERTYPE **buf,
86 OMX_IN OMX_U32 idx, OMX_IN OMX_PTR private, OMX_IN OMX_U32 size);
87 static OMX_ERRORTYPE vid_enc_UseInBuffer(omx_base_PortType *port, OMX_BUFFERHEADERTYPE **buf, OMX_U32 idx,
88 OMX_PTR private, OMX_U32 size, OMX_U8 *mem);
89 static OMX_ERRORTYPE vid_enc_FreeInBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf);
90 static OMX_ERRORTYPE vid_enc_EncodeFrame(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf);
91 static OMX_ERRORTYPE vid_enc_AllocateOutBuffer(omx_base_PortType *comp, OMX_INOUT OMX_BUFFERHEADERTYPE **buf,
92 OMX_IN OMX_U32 idx, OMX_IN OMX_PTR private, OMX_IN OMX_U32 size);
93 static OMX_ERRORTYPE vid_enc_FreeOutBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf);
94 static void vid_enc_BufferEncoded(OMX_COMPONENTTYPE *comp, OMX_BUFFERHEADERTYPE* input, OMX_BUFFERHEADERTYPE* output);
95
96 static void enc_ReleaseTasks(struct list_head *head);
97
vid_enc_LoaderComponent(stLoaderComponentType * comp)98 OMX_ERRORTYPE vid_enc_LoaderComponent(stLoaderComponentType *comp)
99 {
100 comp->componentVersion.s.nVersionMajor = 0;
101 comp->componentVersion.s.nVersionMinor = 0;
102 comp->componentVersion.s.nRevision = 0;
103 comp->componentVersion.s.nStep = 1;
104 comp->name_specific_length = 1;
105 comp->constructor = vid_enc_Constructor;
106
107 comp->name = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
108 if (!comp->name)
109 return OMX_ErrorInsufficientResources;
110
111 comp->name_specific = CALLOC(1, sizeof(char *));
112 if (!comp->name_specific)
113 goto error_arrays;
114
115 comp->role_specific = CALLOC(1, sizeof(char *));
116 if (!comp->role_specific)
117 goto error_arrays;
118
119 comp->name_specific[0] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
120 if (comp->name_specific[0] == NULL)
121 goto error_specific;
122
123 comp->role_specific[0] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE);
124 if (comp->role_specific[0] == NULL)
125 goto error_specific;
126
127 strcpy(comp->name, OMX_VID_ENC_BASE_NAME);
128 strcpy(comp->name_specific[0], OMX_VID_ENC_AVC_NAME);
129 strcpy(comp->role_specific[0], OMX_VID_ENC_AVC_ROLE);
130
131 return OMX_ErrorNone;
132
133 error_specific:
134 FREE(comp->role_specific[0]);
135 FREE(comp->name_specific[0]);
136
137 error_arrays:
138 FREE(comp->role_specific);
139 FREE(comp->name_specific);
140
141 FREE(comp->name);
142
143 return OMX_ErrorInsufficientResources;
144 }
145
vid_enc_Constructor(OMX_COMPONENTTYPE * comp,OMX_STRING name)146 static OMX_ERRORTYPE vid_enc_Constructor(OMX_COMPONENTTYPE *comp, OMX_STRING name)
147 {
148 vid_enc_PrivateType *priv;
149 omx_base_video_PortType *port;
150 struct pipe_screen *screen;
151 OMX_ERRORTYPE r;
152 int i;
153
154 assert(!comp->pComponentPrivate);
155
156 priv = comp->pComponentPrivate = CALLOC(1, sizeof(vid_enc_PrivateType));
157 if (!priv)
158 return OMX_ErrorInsufficientResources;
159
160 r = omx_base_filter_Constructor(comp, name);
161 if (r)
162 return r;
163
164 priv->BufferMgmtCallback = vid_enc_BufferEncoded;
165 priv->messageHandler = vid_enc_MessageHandler;
166 priv->destructor = vid_enc_Destructor;
167
168 comp->SetParameter = vid_enc_SetParameter;
169 comp->GetParameter = vid_enc_GetParameter;
170 comp->GetConfig = vid_enc_GetConfig;
171 comp->SetConfig = vid_enc_SetConfig;
172
173 priv->screen = omx_get_screen();
174 if (!priv->screen)
175 return OMX_ErrorInsufficientResources;
176
177 screen = priv->screen->pscreen;
178 if (!screen->get_video_param(screen, PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH,
179 PIPE_VIDEO_ENTRYPOINT_ENCODE, PIPE_VIDEO_CAP_SUPPORTED))
180 return OMX_ErrorBadParameter;
181
182 priv->s_pipe = screen->context_create(screen, NULL, 0);
183 if (!priv->s_pipe)
184 return OMX_ErrorInsufficientResources;
185
186 if (!vl_compositor_init(&priv->compositor, priv->s_pipe)) {
187 priv->s_pipe->destroy(priv->s_pipe);
188 priv->s_pipe = NULL;
189 return OMX_ErrorInsufficientResources;
190 }
191
192 if (!vl_compositor_init_state(&priv->cstate, priv->s_pipe)) {
193 vl_compositor_cleanup(&priv->compositor);
194 priv->s_pipe->destroy(priv->s_pipe);
195 priv->s_pipe = NULL;
196 return OMX_ErrorInsufficientResources;
197 }
198
199 priv->t_pipe = screen->context_create(screen, NULL, 0);
200 if (!priv->t_pipe)
201 return OMX_ErrorInsufficientResources;
202
203 priv->sPortTypesParam[OMX_PortDomainVideo].nStartPortNumber = 0;
204 priv->sPortTypesParam[OMX_PortDomainVideo].nPorts = 2;
205 priv->ports = CALLOC(2, sizeof(omx_base_PortType *));
206 if (!priv->ports)
207 return OMX_ErrorInsufficientResources;
208
209 for (i = 0; i < 2; ++i) {
210 priv->ports[i] = CALLOC(1, sizeof(omx_base_video_PortType));
211 if (!priv->ports[i])
212 return OMX_ErrorInsufficientResources;
213
214 base_video_port_Constructor(comp, &priv->ports[i], i, i == 0);
215 }
216
217 port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
218 port->sPortParam.format.video.nFrameWidth = 176;
219 port->sPortParam.format.video.nFrameHeight = 144;
220 port->sPortParam.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
221 port->sVideoParam.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
222 port->sPortParam.nBufferCountActual = 8;
223 port->sPortParam.nBufferCountMin = 4;
224
225 port->Port_SendBufferFunction = vid_enc_EncodeFrame;
226 port->Port_AllocateBuffer = vid_enc_AllocateInBuffer;
227 port->Port_UseBuffer = vid_enc_UseInBuffer;
228 port->Port_FreeBuffer = vid_enc_FreeInBuffer;
229
230 port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
231 strcpy(port->sPortParam.format.video.cMIMEType,"video/H264");
232 port->sPortParam.format.video.nFrameWidth = 176;
233 port->sPortParam.format.video.nFrameHeight = 144;
234 port->sPortParam.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
235 port->sVideoParam.eCompressionFormat = OMX_VIDEO_CodingAVC;
236
237 port->Port_AllocateBuffer = vid_enc_AllocateOutBuffer;
238 port->Port_FreeBuffer = vid_enc_FreeOutBuffer;
239
240 priv->bitrate.eControlRate = OMX_Video_ControlRateDisable;
241 priv->bitrate.nTargetBitrate = 0;
242
243 priv->quant.nQpI = OMX_VID_ENC_QUANT_I_FRAMES_DEFAULT;
244 priv->quant.nQpP = OMX_VID_ENC_QUANT_P_FRAMES_DEFAULT;
245 priv->quant.nQpB = OMX_VID_ENC_QUANT_B_FRAMES_DEFAULT;
246
247 priv->profile_level.eProfile = OMX_VIDEO_AVCProfileBaseline;
248 priv->profile_level.eLevel = OMX_VIDEO_AVCLevel51;
249
250 priv->force_pic_type.IntraRefreshVOP = OMX_FALSE;
251 priv->frame_num = 0;
252 priv->pic_order_cnt = 0;
253 priv->restricted_b_frames = debug_get_bool_option("OMX_USE_RESTRICTED_B_FRAMES", FALSE);
254
255 priv->scale.xWidth = OMX_VID_ENC_SCALING_WIDTH_DEFAULT;
256 priv->scale.xHeight = OMX_VID_ENC_SCALING_WIDTH_DEFAULT;
257
258 LIST_INITHEAD(&priv->free_tasks);
259 LIST_INITHEAD(&priv->used_tasks);
260 LIST_INITHEAD(&priv->b_frames);
261 LIST_INITHEAD(&priv->stacked_tasks);
262
263 return OMX_ErrorNone;
264 }
265
vid_enc_Destructor(OMX_COMPONENTTYPE * comp)266 static OMX_ERRORTYPE vid_enc_Destructor(OMX_COMPONENTTYPE *comp)
267 {
268 vid_enc_PrivateType* priv = comp->pComponentPrivate;
269 int i;
270
271 enc_ReleaseTasks(&priv->free_tasks);
272 enc_ReleaseTasks(&priv->used_tasks);
273 enc_ReleaseTasks(&priv->b_frames);
274 enc_ReleaseTasks(&priv->stacked_tasks);
275
276 if (priv->ports) {
277 for (i = 0; i < priv->sPortTypesParam[OMX_PortDomainVideo].nPorts; ++i) {
278 if(priv->ports[i])
279 priv->ports[i]->PortDestructor(priv->ports[i]);
280 }
281 FREE(priv->ports);
282 priv->ports=NULL;
283 }
284
285 for (i = 0; i < OMX_VID_ENC_NUM_SCALING_BUFFERS; ++i)
286 if (priv->scale_buffer[i])
287 priv->scale_buffer[i]->destroy(priv->scale_buffer[i]);
288
289 if (priv->s_pipe) {
290 vl_compositor_cleanup_state(&priv->cstate);
291 vl_compositor_cleanup(&priv->compositor);
292 priv->s_pipe->destroy(priv->s_pipe);
293 }
294
295 if (priv->t_pipe)
296 priv->t_pipe->destroy(priv->t_pipe);
297
298 if (priv->screen)
299 omx_put_screen();
300
301 return omx_workaround_Destructor(comp);
302 }
303
enc_AllocateBackTexture(omx_base_PortType * port,struct pipe_resource ** resource,struct pipe_transfer ** transfer,OMX_U8 ** map)304 static OMX_ERRORTYPE enc_AllocateBackTexture(omx_base_PortType *port,
305 struct pipe_resource **resource,
306 struct pipe_transfer **transfer,
307 OMX_U8 **map)
308 {
309 OMX_COMPONENTTYPE* comp = port->standCompContainer;
310 vid_enc_PrivateType *priv = comp->pComponentPrivate;
311 struct pipe_resource buf_templ;
312 struct pipe_box box = {};
313 OMX_U8 *ptr;
314
315 memset(&buf_templ, 0, sizeof buf_templ);
316 buf_templ.target = PIPE_TEXTURE_2D;
317 buf_templ.format = PIPE_FORMAT_I8_UNORM;
318 buf_templ.bind = PIPE_BIND_LINEAR;
319 buf_templ.usage = PIPE_USAGE_STAGING;
320 buf_templ.flags = 0;
321 buf_templ.width0 = port->sPortParam.format.video.nFrameWidth;
322 buf_templ.height0 = port->sPortParam.format.video.nFrameHeight * 3 / 2;
323 buf_templ.depth0 = 1;
324 buf_templ.array_size = 1;
325
326 *resource = priv->s_pipe->screen->resource_create(priv->s_pipe->screen, &buf_templ);
327 if (!*resource)
328 return OMX_ErrorInsufficientResources;
329
330 box.width = (*resource)->width0;
331 box.height = (*resource)->height0;
332 box.depth = (*resource)->depth0;
333 ptr = priv->s_pipe->transfer_map(priv->s_pipe, *resource, 0, PIPE_TRANSFER_WRITE, &box, transfer);
334 if (map)
335 *map = ptr;
336
337 return OMX_ErrorNone;
338 }
339
vid_enc_SetParameter(OMX_HANDLETYPE handle,OMX_INDEXTYPE idx,OMX_PTR param)340 static OMX_ERRORTYPE vid_enc_SetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param)
341 {
342 OMX_COMPONENTTYPE *comp = handle;
343 vid_enc_PrivateType *priv = comp->pComponentPrivate;
344 OMX_ERRORTYPE r;
345
346 if (!param)
347 return OMX_ErrorBadParameter;
348
349 switch(idx) {
350 case OMX_IndexParamPortDefinition: {
351 OMX_PARAM_PORTDEFINITIONTYPE *def = param;
352
353 r = omx_base_component_SetParameter(handle, idx, param);
354 if (r)
355 return r;
356
357 if (def->nPortIndex == OMX_BASE_FILTER_INPUTPORT_INDEX) {
358 omx_base_video_PortType *port;
359 unsigned framesize;
360 struct pipe_resource *resource;
361 struct pipe_transfer *transfer;
362
363 port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
364 enc_AllocateBackTexture(priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX],
365 &resource, &transfer, NULL);
366 port->sPortParam.format.video.nStride = transfer->stride;
367 pipe_transfer_unmap(priv->s_pipe, transfer);
368 pipe_resource_reference(&resource, NULL);
369
370 framesize = port->sPortParam.format.video.nStride *
371 port->sPortParam.format.video.nFrameHeight;
372 port->sPortParam.format.video.nSliceHeight = port->sPortParam.format.video.nFrameHeight;
373 port->sPortParam.nBufferSize = framesize * 3 / 2;
374
375 port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX];
376 port->sPortParam.nBufferSize = framesize * 512 / (16*16);
377
378 priv->frame_rate = def->format.video.xFramerate;
379
380 priv->callbacks->EventHandler(comp, priv->callbackData, OMX_EventPortSettingsChanged,
381 OMX_BASE_FILTER_OUTPUTPORT_INDEX, 0, NULL);
382 }
383 break;
384 }
385 case OMX_IndexParamStandardComponentRole: {
386 OMX_PARAM_COMPONENTROLETYPE *role = param;
387
388 r = checkHeader(param, sizeof(OMX_PARAM_COMPONENTROLETYPE));
389 if (r)
390 return r;
391
392 if (strcmp((char *)role->cRole, OMX_VID_ENC_AVC_ROLE)) {
393 return OMX_ErrorBadParameter;
394 }
395
396 break;
397 }
398 case OMX_IndexParamVideoBitrate: {
399 OMX_VIDEO_PARAM_BITRATETYPE *bitrate = param;
400
401 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_BITRATETYPE));
402 if (r)
403 return r;
404
405 priv->bitrate = *bitrate;
406
407 break;
408 }
409 case OMX_IndexParamVideoQuantization: {
410 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *quant = param;
411
412 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE));
413 if (r)
414 return r;
415
416 priv->quant = *quant;
417
418 break;
419 }
420 case OMX_IndexParamVideoProfileLevelCurrent: {
421 OMX_VIDEO_PARAM_PROFILELEVELTYPE *profile_level = param;
422
423 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
424 if (r)
425 return r;
426
427 priv->profile_level = *profile_level;
428
429 break;
430 }
431 default:
432 return omx_base_component_SetParameter(handle, idx, param);
433 }
434 return OMX_ErrorNone;
435 }
436
vid_enc_GetParameter(OMX_HANDLETYPE handle,OMX_INDEXTYPE idx,OMX_PTR param)437 static OMX_ERRORTYPE vid_enc_GetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param)
438 {
439 OMX_COMPONENTTYPE *comp = handle;
440 vid_enc_PrivateType *priv = comp->pComponentPrivate;
441 OMX_ERRORTYPE r;
442
443 if (!param)
444 return OMX_ErrorBadParameter;
445
446 switch(idx) {
447 case OMX_IndexParamStandardComponentRole: {
448 OMX_PARAM_COMPONENTROLETYPE *role = param;
449
450 r = checkHeader(param, sizeof(OMX_PARAM_COMPONENTROLETYPE));
451 if (r)
452 return r;
453
454 strcpy((char *)role->cRole, OMX_VID_ENC_AVC_ROLE);
455 break;
456 }
457 case OMX_IndexParamVideoInit:
458 r = checkHeader(param, sizeof(OMX_PORT_PARAM_TYPE));
459 if (r)
460 return r;
461
462 memcpy(param, &priv->sPortTypesParam[OMX_PortDomainVideo], sizeof(OMX_PORT_PARAM_TYPE));
463 break;
464
465 case OMX_IndexParamVideoPortFormat: {
466 OMX_VIDEO_PARAM_PORTFORMATTYPE *format = param;
467 omx_base_video_PortType *port;
468
469 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
470 if (r)
471 return r;
472
473 if (format->nPortIndex > 1)
474 return OMX_ErrorBadPortIndex;
475 if (format->nIndex >= 1)
476 return OMX_ErrorNoMore;
477
478 port = (omx_base_video_PortType *)priv->ports[format->nPortIndex];
479 memcpy(format, &port->sVideoParam, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
480 break;
481 }
482 case OMX_IndexParamVideoBitrate: {
483 OMX_VIDEO_PARAM_BITRATETYPE *bitrate = param;
484
485 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_BITRATETYPE));
486 if (r)
487 return r;
488
489 bitrate->eControlRate = priv->bitrate.eControlRate;
490 bitrate->nTargetBitrate = priv->bitrate.nTargetBitrate;
491
492 break;
493 }
494 case OMX_IndexParamVideoQuantization: {
495 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *quant = param;
496
497 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE));
498 if (r)
499 return r;
500
501 quant->nQpI = priv->quant.nQpI;
502 quant->nQpP = priv->quant.nQpP;
503 quant->nQpB = priv->quant.nQpB;
504
505 break;
506 }
507 case OMX_IndexParamVideoProfileLevelCurrent: {
508 OMX_VIDEO_PARAM_PROFILELEVELTYPE *profile_level = param;
509
510 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
511 if (r)
512 return r;
513
514 profile_level->eProfile = priv->profile_level.eProfile;
515 profile_level->eLevel = priv->profile_level.eLevel;
516
517 break;
518 }
519 default:
520 return omx_base_component_GetParameter(handle, idx, param);
521 }
522 return OMX_ErrorNone;
523 }
524
vid_enc_SetConfig(OMX_HANDLETYPE handle,OMX_INDEXTYPE idx,OMX_PTR config)525 static OMX_ERRORTYPE vid_enc_SetConfig(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR config)
526 {
527 OMX_COMPONENTTYPE *comp = handle;
528 vid_enc_PrivateType *priv = comp->pComponentPrivate;
529 OMX_ERRORTYPE r;
530 int i;
531
532 if (!config)
533 return OMX_ErrorBadParameter;
534
535 switch(idx) {
536 case OMX_IndexConfigVideoIntraVOPRefresh: {
537 OMX_CONFIG_INTRAREFRESHVOPTYPE *type = config;
538
539 r = checkHeader(config, sizeof(OMX_CONFIG_INTRAREFRESHVOPTYPE));
540 if (r)
541 return r;
542
543 priv->force_pic_type = *type;
544
545 break;
546 }
547 case OMX_IndexConfigCommonScale: {
548 OMX_CONFIG_SCALEFACTORTYPE *scale = config;
549
550 r = checkHeader(config, sizeof(OMX_CONFIG_SCALEFACTORTYPE));
551 if (r)
552 return r;
553
554 if (scale->xWidth < 176 || scale->xHeight < 144)
555 return OMX_ErrorBadParameter;
556
557 for (i = 0; i < OMX_VID_ENC_NUM_SCALING_BUFFERS; ++i) {
558 if (priv->scale_buffer[i]) {
559 priv->scale_buffer[i]->destroy(priv->scale_buffer[i]);
560 priv->scale_buffer[i] = NULL;
561 }
562 }
563
564 priv->scale = *scale;
565 if (priv->scale.xWidth != 0xffffffff && priv->scale.xHeight != 0xffffffff) {
566 struct pipe_video_buffer templat = {};
567
568 templat.buffer_format = PIPE_FORMAT_NV12;
569 templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
570 templat.width = priv->scale.xWidth;
571 templat.height = priv->scale.xHeight;
572 templat.interlaced = false;
573 for (i = 0; i < OMX_VID_ENC_NUM_SCALING_BUFFERS; ++i) {
574 priv->scale_buffer[i] = priv->s_pipe->create_video_buffer(priv->s_pipe, &templat);
575 if (!priv->scale_buffer[i])
576 return OMX_ErrorInsufficientResources;
577 }
578 }
579
580 break;
581 }
582 default:
583 return omx_base_component_SetConfig(handle, idx, config);
584 }
585
586 return OMX_ErrorNone;
587 }
588
vid_enc_GetConfig(OMX_HANDLETYPE handle,OMX_INDEXTYPE idx,OMX_PTR config)589 static OMX_ERRORTYPE vid_enc_GetConfig(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR config)
590 {
591 OMX_COMPONENTTYPE *comp = handle;
592 vid_enc_PrivateType *priv = comp->pComponentPrivate;
593 OMX_ERRORTYPE r;
594
595 if (!config)
596 return OMX_ErrorBadParameter;
597
598 switch(idx) {
599 case OMX_IndexConfigCommonScale: {
600 OMX_CONFIG_SCALEFACTORTYPE *scale = config;
601
602 r = checkHeader(config, sizeof(OMX_CONFIG_SCALEFACTORTYPE));
603 if (r)
604 return r;
605
606 scale->xWidth = priv->scale.xWidth;
607 scale->xHeight = priv->scale.xHeight;
608
609 break;
610 }
611 default:
612 return omx_base_component_GetConfig(handle, idx, config);
613 }
614
615 return OMX_ErrorNone;
616 }
617
enc_TranslateOMXProfileToPipe(unsigned omx_profile)618 static enum pipe_video_profile enc_TranslateOMXProfileToPipe(unsigned omx_profile)
619 {
620 switch (omx_profile) {
621 case OMX_VIDEO_AVCProfileBaseline:
622 return PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE;
623 case OMX_VIDEO_AVCProfileMain:
624 return PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN;
625 case OMX_VIDEO_AVCProfileExtended:
626 return PIPE_VIDEO_PROFILE_MPEG4_AVC_EXTENDED;
627 case OMX_VIDEO_AVCProfileHigh:
628 return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
629 case OMX_VIDEO_AVCProfileHigh10:
630 return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH10;
631 case OMX_VIDEO_AVCProfileHigh422:
632 return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH422;
633 case OMX_VIDEO_AVCProfileHigh444:
634 return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH444;
635 default:
636 return PIPE_VIDEO_PROFILE_UNKNOWN;
637 }
638 }
639
enc_TranslateOMXLevelToPipe(unsigned omx_level)640 static unsigned enc_TranslateOMXLevelToPipe(unsigned omx_level)
641 {
642 switch (omx_level) {
643 case OMX_VIDEO_AVCLevel1:
644 case OMX_VIDEO_AVCLevel1b:
645 return 10;
646 case OMX_VIDEO_AVCLevel11:
647 return 11;
648 case OMX_VIDEO_AVCLevel12:
649 return 12;
650 case OMX_VIDEO_AVCLevel13:
651 return 13;
652 case OMX_VIDEO_AVCLevel2:
653 return 20;
654 case OMX_VIDEO_AVCLevel21:
655 return 21;
656 case OMX_VIDEO_AVCLevel22:
657 return 22;
658 case OMX_VIDEO_AVCLevel3:
659 return 30;
660 case OMX_VIDEO_AVCLevel31:
661 return 31;
662 case OMX_VIDEO_AVCLevel32:
663 return 32;
664 case OMX_VIDEO_AVCLevel4:
665 return 40;
666 case OMX_VIDEO_AVCLevel41:
667 return 41;
668 default:
669 case OMX_VIDEO_AVCLevel42:
670 return 42;
671 case OMX_VIDEO_AVCLevel5:
672 return 50;
673 case OMX_VIDEO_AVCLevel51:
674 return 51;
675 }
676 }
677
vid_enc_MessageHandler(OMX_COMPONENTTYPE * comp,internalRequestMessageType * msg)678 static OMX_ERRORTYPE vid_enc_MessageHandler(OMX_COMPONENTTYPE* comp, internalRequestMessageType *msg)
679 {
680 vid_enc_PrivateType* priv = comp->pComponentPrivate;
681
682 if (msg->messageType == OMX_CommandStateSet) {
683 if ((msg->messageParam == OMX_StateIdle ) && (priv->state == OMX_StateLoaded)) {
684
685 struct pipe_video_codec templat = {};
686 omx_base_video_PortType *port;
687
688 port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
689
690 templat.profile = enc_TranslateOMXProfileToPipe(priv->profile_level.eProfile);
691 templat.level = enc_TranslateOMXLevelToPipe(priv->profile_level.eLevel);
692 templat.entrypoint = PIPE_VIDEO_ENTRYPOINT_ENCODE;
693 templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
694 templat.width = priv->scale_buffer[priv->current_scale_buffer] ?
695 priv->scale.xWidth : port->sPortParam.format.video.nFrameWidth;
696 templat.height = priv->scale_buffer[priv->current_scale_buffer] ?
697 priv->scale.xHeight : port->sPortParam.format.video.nFrameHeight;
698
699 if (templat.profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE) {
700 struct pipe_screen *screen = priv->screen->pscreen;
701 templat.max_references = 1;
702 priv->stacked_frames_num =
703 screen->get_video_param(screen,
704 PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH,
705 PIPE_VIDEO_ENTRYPOINT_ENCODE,
706 PIPE_VIDEO_CAP_STACKED_FRAMES);
707 } else {
708 templat.max_references = OMX_VID_ENC_P_PERIOD_DEFAULT;
709 priv->stacked_frames_num = 1;
710 }
711 priv->codec = priv->s_pipe->create_video_codec(priv->s_pipe, &templat);
712
713 } else if ((msg->messageParam == OMX_StateLoaded) && (priv->state == OMX_StateIdle)) {
714 if (priv->codec) {
715 priv->codec->destroy(priv->codec);
716 priv->codec = NULL;
717 }
718 }
719 }
720
721 return omx_base_component_MessageHandler(comp, msg);
722 }
723
vid_enc_AllocateInBuffer(omx_base_PortType * port,OMX_INOUT OMX_BUFFERHEADERTYPE ** buf,OMX_IN OMX_U32 idx,OMX_IN OMX_PTR private,OMX_IN OMX_U32 size)724 static OMX_ERRORTYPE vid_enc_AllocateInBuffer(omx_base_PortType *port, OMX_INOUT OMX_BUFFERHEADERTYPE **buf,
725 OMX_IN OMX_U32 idx, OMX_IN OMX_PTR private, OMX_IN OMX_U32 size)
726 {
727 struct input_buf_private *inp;
728 OMX_ERRORTYPE r;
729
730 r = base_port_AllocateBuffer(port, buf, idx, private, size);
731 if (r)
732 return r;
733
734 inp = (*buf)->pInputPortPrivate = CALLOC_STRUCT(input_buf_private);
735 if (!inp) {
736 base_port_FreeBuffer(port, idx, *buf);
737 return OMX_ErrorInsufficientResources;
738 }
739
740 LIST_INITHEAD(&inp->tasks);
741
742 FREE((*buf)->pBuffer);
743 r = enc_AllocateBackTexture(port, &inp->resource, &inp->transfer, &(*buf)->pBuffer);
744 if (r) {
745 FREE(inp);
746 base_port_FreeBuffer(port, idx, *buf);
747 return r;
748 }
749
750 return OMX_ErrorNone;
751 }
752
vid_enc_UseInBuffer(omx_base_PortType * port,OMX_BUFFERHEADERTYPE ** buf,OMX_U32 idx,OMX_PTR private,OMX_U32 size,OMX_U8 * mem)753 static OMX_ERRORTYPE vid_enc_UseInBuffer(omx_base_PortType *port, OMX_BUFFERHEADERTYPE **buf, OMX_U32 idx,
754 OMX_PTR private, OMX_U32 size, OMX_U8 *mem)
755 {
756 struct input_buf_private *inp;
757 OMX_ERRORTYPE r;
758
759 r = base_port_UseBuffer(port, buf, idx, private, size, mem);
760 if (r)
761 return r;
762
763 inp = (*buf)->pInputPortPrivate = CALLOC_STRUCT(input_buf_private);
764 if (!inp) {
765 base_port_FreeBuffer(port, idx, *buf);
766 return OMX_ErrorInsufficientResources;
767 }
768
769 LIST_INITHEAD(&inp->tasks);
770
771 return OMX_ErrorNone;
772 }
773
vid_enc_FreeInBuffer(omx_base_PortType * port,OMX_U32 idx,OMX_BUFFERHEADERTYPE * buf)774 static OMX_ERRORTYPE vid_enc_FreeInBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf)
775 {
776 OMX_COMPONENTTYPE* comp = port->standCompContainer;
777 vid_enc_PrivateType *priv = comp->pComponentPrivate;
778 struct input_buf_private *inp = buf->pInputPortPrivate;
779
780 if (inp) {
781 enc_ReleaseTasks(&inp->tasks);
782 if (inp->transfer)
783 pipe_transfer_unmap(priv->s_pipe, inp->transfer);
784 pipe_resource_reference(&inp->resource, NULL);
785 FREE(inp);
786 }
787 buf->pBuffer = NULL;
788
789 return base_port_FreeBuffer(port, idx, buf);
790 }
791
vid_enc_AllocateOutBuffer(omx_base_PortType * port,OMX_INOUT OMX_BUFFERHEADERTYPE ** buf,OMX_IN OMX_U32 idx,OMX_IN OMX_PTR private,OMX_IN OMX_U32 size)792 static OMX_ERRORTYPE vid_enc_AllocateOutBuffer(omx_base_PortType *port, OMX_INOUT OMX_BUFFERHEADERTYPE **buf,
793 OMX_IN OMX_U32 idx, OMX_IN OMX_PTR private, OMX_IN OMX_U32 size)
794 {
795 OMX_ERRORTYPE r;
796
797 r = base_port_AllocateBuffer(port, buf, idx, private, size);
798 if (r)
799 return r;
800
801 FREE((*buf)->pBuffer);
802 (*buf)->pBuffer = NULL;
803 (*buf)->pOutputPortPrivate = CALLOC(1, sizeof(struct output_buf_private));
804 if (!(*buf)->pOutputPortPrivate) {
805 base_port_FreeBuffer(port, idx, *buf);
806 return OMX_ErrorInsufficientResources;
807 }
808
809 return OMX_ErrorNone;
810 }
811
vid_enc_FreeOutBuffer(omx_base_PortType * port,OMX_U32 idx,OMX_BUFFERHEADERTYPE * buf)812 static OMX_ERRORTYPE vid_enc_FreeOutBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf)
813 {
814 OMX_COMPONENTTYPE* comp = port->standCompContainer;
815 vid_enc_PrivateType *priv = comp->pComponentPrivate;
816
817 if (buf->pOutputPortPrivate) {
818 struct output_buf_private *outp = buf->pOutputPortPrivate;
819 if (outp->transfer)
820 pipe_transfer_unmap(priv->t_pipe, outp->transfer);
821 pipe_resource_reference(&outp->bitstream, NULL);
822 FREE(outp);
823 buf->pOutputPortPrivate = NULL;
824 }
825 buf->pBuffer = NULL;
826
827 return base_port_FreeBuffer(port, idx, buf);
828 }
829
enc_NeedTask(omx_base_PortType * port)830 static struct encode_task *enc_NeedTask(omx_base_PortType *port)
831 {
832 OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video;
833 OMX_COMPONENTTYPE* comp = port->standCompContainer;
834 vid_enc_PrivateType *priv = comp->pComponentPrivate;
835
836 struct pipe_video_buffer templat = {};
837 struct encode_task *task;
838
839 if (!LIST_IS_EMPTY(&priv->free_tasks)) {
840 task = LIST_ENTRY(struct encode_task, priv->free_tasks.next, list);
841 LIST_DEL(&task->list);
842 return task;
843 }
844
845 /* allocate a new one */
846 task = CALLOC_STRUCT(encode_task);
847 if (!task)
848 return NULL;
849
850 templat.buffer_format = PIPE_FORMAT_NV12;
851 templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
852 templat.width = def->nFrameWidth;
853 templat.height = def->nFrameHeight;
854 templat.interlaced = false;
855
856 task->buf = priv->s_pipe->create_video_buffer(priv->s_pipe, &templat);
857 if (!task->buf) {
858 FREE(task);
859 return NULL;
860 }
861
862 return task;
863 }
864
enc_MoveTasks(struct list_head * from,struct list_head * to)865 static void enc_MoveTasks(struct list_head *from, struct list_head *to)
866 {
867 to->prev->next = from->next;
868 from->next->prev = to->prev;
869 from->prev->next = to;
870 to->prev = from->prev;
871 LIST_INITHEAD(from);
872 }
873
enc_ReleaseTasks(struct list_head * head)874 static void enc_ReleaseTasks(struct list_head *head)
875 {
876 struct encode_task *i, *next;
877
878 if (!head || !head->next)
879 return;
880
881 LIST_FOR_EACH_ENTRY_SAFE(i, next, head, list) {
882 pipe_resource_reference(&i->bitstream, NULL);
883 i->buf->destroy(i->buf);
884 FREE(i);
885 }
886 }
887
enc_LoadImage(omx_base_PortType * port,OMX_BUFFERHEADERTYPE * buf,struct pipe_video_buffer * vbuf)888 static OMX_ERRORTYPE enc_LoadImage(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf,
889 struct pipe_video_buffer *vbuf)
890 {
891 OMX_COMPONENTTYPE* comp = port->standCompContainer;
892 vid_enc_PrivateType *priv = comp->pComponentPrivate;
893 OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video;
894 struct pipe_box box = {};
895 struct input_buf_private *inp = buf->pInputPortPrivate;
896
897 if (!inp->resource) {
898 struct pipe_sampler_view **views;
899 void *ptr;
900
901 views = vbuf->get_sampler_view_planes(vbuf);
902 if (!views)
903 return OMX_ErrorInsufficientResources;
904
905 ptr = buf->pBuffer;
906 box.width = def->nFrameWidth;
907 box.height = def->nFrameHeight;
908 box.depth = 1;
909 priv->s_pipe->texture_subdata(priv->s_pipe, views[0]->texture, 0,
910 PIPE_TRANSFER_WRITE, &box,
911 ptr, def->nStride, 0);
912 ptr = ((uint8_t*)buf->pBuffer) + (def->nStride * box.height);
913 box.width = def->nFrameWidth / 2;
914 box.height = def->nFrameHeight / 2;
915 box.depth = 1;
916 priv->s_pipe->texture_subdata(priv->s_pipe, views[1]->texture, 0,
917 PIPE_TRANSFER_WRITE, &box,
918 ptr, def->nStride, 0);
919 } else {
920 struct pipe_blit_info blit;
921 struct vl_video_buffer *dst_buf = (struct vl_video_buffer *)vbuf;
922
923 pipe_transfer_unmap(priv->s_pipe, inp->transfer);
924
925 box.width = def->nFrameWidth;
926 box.height = def->nFrameHeight;
927 box.depth = 1;
928
929 priv->s_pipe->resource_copy_region(priv->s_pipe,
930 dst_buf->resources[0],
931 0, 0, 0, 0, inp->resource, 0, &box);
932
933 memset(&blit, 0, sizeof(blit));
934 blit.src.resource = inp->resource;
935 blit.src.format = inp->resource->format;
936
937 blit.src.box.x = -1;
938 blit.src.box.y = def->nFrameHeight;
939 blit.src.box.width = def->nFrameWidth;
940 blit.src.box.height = def->nFrameHeight / 2 ;
941 blit.src.box.depth = 1;
942
943 blit.dst.resource = dst_buf->resources[1];
944 blit.dst.format = blit.dst.resource->format;
945
946 blit.dst.box.width = def->nFrameWidth / 2;
947 blit.dst.box.height = def->nFrameHeight / 2;
948 blit.dst.box.depth = 1;
949 blit.filter = PIPE_TEX_FILTER_NEAREST;
950
951 blit.mask = PIPE_MASK_R;
952 priv->s_pipe->blit(priv->s_pipe, &blit);
953
954 blit.src.box.x = 0;
955 blit.mask = PIPE_MASK_G;
956 priv->s_pipe->blit(priv->s_pipe, &blit);
957 priv->s_pipe->flush(priv->s_pipe, NULL, 0);
958
959 box.width = inp->resource->width0;
960 box.height = inp->resource->height0;
961 box.depth = inp->resource->depth0;
962 buf->pBuffer = priv->s_pipe->transfer_map(priv->s_pipe, inp->resource, 0,
963 PIPE_TRANSFER_WRITE, &box,
964 &inp->transfer);
965 }
966
967 return OMX_ErrorNone;
968 }
969
enc_ScaleInput(omx_base_PortType * port,struct pipe_video_buffer ** vbuf,unsigned * size)970 static void enc_ScaleInput(omx_base_PortType *port, struct pipe_video_buffer **vbuf, unsigned *size)
971 {
972 OMX_COMPONENTTYPE* comp = port->standCompContainer;
973 vid_enc_PrivateType *priv = comp->pComponentPrivate;
974 OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video;
975 struct pipe_video_buffer *src_buf = *vbuf;
976 struct vl_compositor *compositor = &priv->compositor;
977 struct vl_compositor_state *s = &priv->cstate;
978 struct pipe_sampler_view **views;
979 struct pipe_surface **dst_surface;
980 unsigned i;
981
982 if (!priv->scale_buffer[priv->current_scale_buffer])
983 return;
984
985 views = src_buf->get_sampler_view_planes(src_buf);
986 dst_surface = priv->scale_buffer[priv->current_scale_buffer]->get_surfaces
987 (priv->scale_buffer[priv->current_scale_buffer]);
988 vl_compositor_clear_layers(s);
989
990 for (i = 0; i < VL_MAX_SURFACES; ++i) {
991 struct u_rect src_rect;
992 if (!views[i] || !dst_surface[i])
993 continue;
994 src_rect.x0 = 0;
995 src_rect.y0 = 0;
996 src_rect.x1 = def->nFrameWidth;
997 src_rect.y1 = def->nFrameHeight;
998 if (i > 0) {
999 src_rect.x1 /= 2;
1000 src_rect.y1 /= 2;
1001 }
1002 vl_compositor_set_rgba_layer(s, compositor, 0, views[i], &src_rect, NULL, NULL);
1003 vl_compositor_render(s, compositor, dst_surface[i], NULL, false);
1004 }
1005 *size = priv->scale.xWidth * priv->scale.xHeight * 2;
1006 *vbuf = priv->scale_buffer[priv->current_scale_buffer++];
1007 priv->current_scale_buffer %= OMX_VID_ENC_NUM_SCALING_BUFFERS;
1008 }
1009
enc_GetPictureParamPreset(struct pipe_h264_enc_picture_desc * picture)1010 static void enc_GetPictureParamPreset(struct pipe_h264_enc_picture_desc *picture)
1011 {
1012 picture->motion_est.enc_disable_sub_mode = 0x000000fe;
1013 picture->motion_est.enc_ime2_search_range_x = 0x00000001;
1014 picture->motion_est.enc_ime2_search_range_y = 0x00000001;
1015 picture->pic_ctrl.enc_constraint_set_flags = 0x00000040;
1016 }
1017
enc_ControlPicture(omx_base_PortType * port,struct pipe_h264_enc_picture_desc * picture)1018 static void enc_ControlPicture(omx_base_PortType *port, struct pipe_h264_enc_picture_desc *picture)
1019 {
1020 OMX_COMPONENTTYPE* comp = port->standCompContainer;
1021 vid_enc_PrivateType *priv = comp->pComponentPrivate;
1022 struct pipe_h264_enc_rate_control *rate_ctrl = &picture->rate_ctrl;
1023
1024 switch (priv->bitrate.eControlRate) {
1025 case OMX_Video_ControlRateVariable:
1026 rate_ctrl->rate_ctrl_method = PIPE_H264_ENC_RATE_CONTROL_METHOD_VARIABLE;
1027 break;
1028 case OMX_Video_ControlRateConstant:
1029 rate_ctrl->rate_ctrl_method = PIPE_H264_ENC_RATE_CONTROL_METHOD_CONSTANT;
1030 break;
1031 case OMX_Video_ControlRateVariableSkipFrames:
1032 rate_ctrl->rate_ctrl_method = PIPE_H264_ENC_RATE_CONTROL_METHOD_VARIABLE_SKIP;
1033 break;
1034 case OMX_Video_ControlRateConstantSkipFrames:
1035 rate_ctrl->rate_ctrl_method = PIPE_H264_ENC_RATE_CONTROL_METHOD_CONSTANT_SKIP;
1036 break;
1037 default:
1038 rate_ctrl->rate_ctrl_method = PIPE_H264_ENC_RATE_CONTROL_METHOD_DISABLE;
1039 break;
1040 }
1041
1042 rate_ctrl->frame_rate_den = OMX_VID_ENC_CONTROL_FRAME_RATE_DEN_DEFAULT;
1043 rate_ctrl->frame_rate_num = ((priv->frame_rate) >> 16) * rate_ctrl->frame_rate_den;
1044
1045 if (rate_ctrl->rate_ctrl_method != PIPE_H264_ENC_RATE_CONTROL_METHOD_DISABLE) {
1046 if (priv->bitrate.nTargetBitrate < OMX_VID_ENC_BITRATE_MIN)
1047 rate_ctrl->target_bitrate = OMX_VID_ENC_BITRATE_MIN;
1048 else if (priv->bitrate.nTargetBitrate < OMX_VID_ENC_BITRATE_MAX)
1049 rate_ctrl->target_bitrate = priv->bitrate.nTargetBitrate;
1050 else
1051 rate_ctrl->target_bitrate = OMX_VID_ENC_BITRATE_MAX;
1052 rate_ctrl->peak_bitrate = rate_ctrl->target_bitrate;
1053 if (rate_ctrl->target_bitrate < OMX_VID_ENC_BITRATE_MEDIAN)
1054 rate_ctrl->vbv_buffer_size = MIN2((rate_ctrl->target_bitrate * 2.75), OMX_VID_ENC_BITRATE_MEDIAN);
1055 else
1056 rate_ctrl->vbv_buffer_size = rate_ctrl->target_bitrate;
1057
1058 if (rate_ctrl->frame_rate_num) {
1059 unsigned long long t = rate_ctrl->target_bitrate;
1060 t *= rate_ctrl->frame_rate_den;
1061 rate_ctrl->target_bits_picture = t / rate_ctrl->frame_rate_num;
1062 } else {
1063 rate_ctrl->target_bits_picture = rate_ctrl->target_bitrate;
1064 }
1065 rate_ctrl->peak_bits_picture_integer = rate_ctrl->target_bits_picture;
1066 rate_ctrl->peak_bits_picture_fraction = 0;
1067 }
1068
1069 picture->quant_i_frames = priv->quant.nQpI;
1070 picture->quant_p_frames = priv->quant.nQpP;
1071 picture->quant_b_frames = priv->quant.nQpB;
1072
1073 picture->frame_num = priv->frame_num;
1074 picture->ref_idx_l0 = priv->ref_idx_l0;
1075 picture->ref_idx_l1 = priv->ref_idx_l1;
1076 picture->enable_vui = (picture->rate_ctrl.frame_rate_num != 0);
1077 enc_GetPictureParamPreset(picture);
1078 }
1079
enc_HandleTask(omx_base_PortType * port,struct encode_task * task,enum pipe_h264_enc_picture_type picture_type)1080 static void enc_HandleTask(omx_base_PortType *port, struct encode_task *task,
1081 enum pipe_h264_enc_picture_type picture_type)
1082 {
1083 OMX_COMPONENTTYPE* comp = port->standCompContainer;
1084 vid_enc_PrivateType *priv = comp->pComponentPrivate;
1085 unsigned size = priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]->sPortParam.nBufferSize;
1086 struct pipe_video_buffer *vbuf = task->buf;
1087 struct pipe_h264_enc_picture_desc picture = {};
1088
1089 /* -------------- scale input image --------- */
1090 enc_ScaleInput(port, &vbuf, &size);
1091 priv->s_pipe->flush(priv->s_pipe, NULL, 0);
1092
1093 /* -------------- allocate output buffer --------- */
1094 task->bitstream = pipe_buffer_create(priv->s_pipe->screen,
1095 PIPE_BIND_VERTEX_BUFFER,
1096 PIPE_USAGE_STAGING, /* map for read */
1097 size);
1098
1099 picture.picture_type = picture_type;
1100 picture.pic_order_cnt = task->pic_order_cnt;
1101 if (priv->restricted_b_frames && picture_type == PIPE_H264_ENC_PICTURE_TYPE_B)
1102 picture.not_referenced = true;
1103 enc_ControlPicture(port, &picture);
1104
1105 /* -------------- encode frame --------- */
1106 priv->codec->begin_frame(priv->codec, vbuf, &picture.base);
1107 priv->codec->encode_bitstream(priv->codec, vbuf, task->bitstream, &task->feedback);
1108 priv->codec->end_frame(priv->codec, vbuf, &picture.base);
1109 }
1110
enc_ClearBframes(omx_base_PortType * port,struct input_buf_private * inp)1111 static void enc_ClearBframes(omx_base_PortType *port, struct input_buf_private *inp)
1112 {
1113 OMX_COMPONENTTYPE* comp = port->standCompContainer;
1114 vid_enc_PrivateType *priv = comp->pComponentPrivate;
1115 struct encode_task *task;
1116
1117 if (LIST_IS_EMPTY(&priv->b_frames))
1118 return;
1119
1120 task = LIST_ENTRY(struct encode_task, priv->b_frames.prev, list);
1121 LIST_DEL(&task->list);
1122
1123 /* promote last from to P frame */
1124 priv->ref_idx_l0 = priv->ref_idx_l1;
1125 enc_HandleTask(port, task, PIPE_H264_ENC_PICTURE_TYPE_P);
1126 LIST_ADDTAIL(&task->list, &inp->tasks);
1127 priv->ref_idx_l1 = priv->frame_num++;
1128
1129 /* handle B frames */
1130 LIST_FOR_EACH_ENTRY(task, &priv->b_frames, list) {
1131 enc_HandleTask(port, task, PIPE_H264_ENC_PICTURE_TYPE_B);
1132 if (!priv->restricted_b_frames)
1133 priv->ref_idx_l0 = priv->frame_num;
1134 priv->frame_num++;
1135 }
1136
1137 enc_MoveTasks(&priv->b_frames, &inp->tasks);
1138 }
1139
vid_enc_EncodeFrame(omx_base_PortType * port,OMX_BUFFERHEADERTYPE * buf)1140 static OMX_ERRORTYPE vid_enc_EncodeFrame(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf)
1141 {
1142 OMX_COMPONENTTYPE* comp = port->standCompContainer;
1143 vid_enc_PrivateType *priv = comp->pComponentPrivate;
1144 struct input_buf_private *inp = buf->pInputPortPrivate;
1145 enum pipe_h264_enc_picture_type picture_type;
1146 struct encode_task *task;
1147 unsigned stacked_num = 0;
1148 OMX_ERRORTYPE err;
1149
1150 enc_MoveTasks(&inp->tasks, &priv->free_tasks);
1151 task = enc_NeedTask(port);
1152 if (!task)
1153 return OMX_ErrorInsufficientResources;
1154
1155 if (buf->nFilledLen == 0) {
1156 if (buf->nFlags & OMX_BUFFERFLAG_EOS) {
1157 buf->nFilledLen = buf->nAllocLen;
1158 enc_ClearBframes(port, inp);
1159 enc_MoveTasks(&priv->stacked_tasks, &inp->tasks);
1160 priv->codec->flush(priv->codec);
1161 }
1162 return base_port_SendBufferFunction(port, buf);
1163 }
1164
1165 if (buf->pOutputPortPrivate) {
1166 struct pipe_video_buffer *vbuf = buf->pOutputPortPrivate;
1167 buf->pOutputPortPrivate = task->buf;
1168 task->buf = vbuf;
1169 } else {
1170 /* ------- load input image into video buffer ---- */
1171 err = enc_LoadImage(port, buf, task->buf);
1172 if (err != OMX_ErrorNone) {
1173 FREE(task);
1174 return err;
1175 }
1176 }
1177
1178 /* -------------- determine picture type --------- */
1179 if (!(priv->pic_order_cnt % OMX_VID_ENC_IDR_PERIOD_DEFAULT) ||
1180 priv->force_pic_type.IntraRefreshVOP) {
1181 enc_ClearBframes(port, inp);
1182 picture_type = PIPE_H264_ENC_PICTURE_TYPE_IDR;
1183 priv->force_pic_type.IntraRefreshVOP = OMX_FALSE;
1184 priv->frame_num = 0;
1185 } else if (priv->codec->profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE ||
1186 !(priv->pic_order_cnt % OMX_VID_ENC_P_PERIOD_DEFAULT) ||
1187 (buf->nFlags & OMX_BUFFERFLAG_EOS)) {
1188 picture_type = PIPE_H264_ENC_PICTURE_TYPE_P;
1189 } else {
1190 picture_type = PIPE_H264_ENC_PICTURE_TYPE_B;
1191 }
1192
1193 task->pic_order_cnt = priv->pic_order_cnt++;
1194
1195 if (picture_type == PIPE_H264_ENC_PICTURE_TYPE_B) {
1196 /* put frame at the tail of the queue */
1197 LIST_ADDTAIL(&task->list, &priv->b_frames);
1198 } else {
1199 /* handle I or P frame */
1200 priv->ref_idx_l0 = priv->ref_idx_l1;
1201 enc_HandleTask(port, task, picture_type);
1202 LIST_ADDTAIL(&task->list, &priv->stacked_tasks);
1203 LIST_FOR_EACH_ENTRY(task, &priv->stacked_tasks, list) {
1204 ++stacked_num;
1205 }
1206 if (stacked_num == priv->stacked_frames_num) {
1207 struct encode_task *t;
1208 t = LIST_ENTRY(struct encode_task, priv->stacked_tasks.next, list);
1209 LIST_DEL(&t->list);
1210 LIST_ADDTAIL(&t->list, &inp->tasks);
1211 }
1212 priv->ref_idx_l1 = priv->frame_num++;
1213
1214 /* handle B frames */
1215 LIST_FOR_EACH_ENTRY(task, &priv->b_frames, list) {
1216 enc_HandleTask(port, task, PIPE_H264_ENC_PICTURE_TYPE_B);
1217 if (!priv->restricted_b_frames)
1218 priv->ref_idx_l0 = priv->frame_num;
1219 priv->frame_num++;
1220 }
1221
1222 enc_MoveTasks(&priv->b_frames, &inp->tasks);
1223 }
1224
1225 if (LIST_IS_EMPTY(&inp->tasks))
1226 return port->ReturnBufferFunction(port, buf);
1227 else
1228 return base_port_SendBufferFunction(port, buf);
1229 }
1230
vid_enc_BufferEncoded(OMX_COMPONENTTYPE * comp,OMX_BUFFERHEADERTYPE * input,OMX_BUFFERHEADERTYPE * output)1231 static void vid_enc_BufferEncoded(OMX_COMPONENTTYPE *comp, OMX_BUFFERHEADERTYPE* input, OMX_BUFFERHEADERTYPE* output)
1232 {
1233 vid_enc_PrivateType *priv = comp->pComponentPrivate;
1234 struct output_buf_private *outp = output->pOutputPortPrivate;
1235 struct input_buf_private *inp = input->pInputPortPrivate;
1236 struct encode_task *task;
1237 struct pipe_box box = {};
1238 unsigned size;
1239
1240 if (!inp || LIST_IS_EMPTY(&inp->tasks)) {
1241 input->nFilledLen = 0; /* mark buffer as empty */
1242 enc_MoveTasks(&priv->used_tasks, &inp->tasks);
1243 return;
1244 }
1245
1246 task = LIST_ENTRY(struct encode_task, inp->tasks.next, list);
1247 LIST_DEL(&task->list);
1248 LIST_ADDTAIL(&task->list, &priv->used_tasks);
1249
1250 if (!task->bitstream)
1251 return;
1252
1253 /* ------------- map result buffer ----------------- */
1254
1255 if (outp->transfer)
1256 pipe_transfer_unmap(priv->t_pipe, outp->transfer);
1257
1258 pipe_resource_reference(&outp->bitstream, task->bitstream);
1259 pipe_resource_reference(&task->bitstream, NULL);
1260
1261 box.width = outp->bitstream->width0;
1262 box.height = outp->bitstream->height0;
1263 box.depth = outp->bitstream->depth0;
1264
1265 output->pBuffer = priv->t_pipe->transfer_map(priv->t_pipe, outp->bitstream, 0,
1266 PIPE_TRANSFER_READ_WRITE,
1267 &box, &outp->transfer);
1268
1269 /* ------------- get size of result ----------------- */
1270
1271 priv->codec->get_feedback(priv->codec, task->feedback, &size);
1272
1273 output->nOffset = 0;
1274 output->nFilledLen = size; /* mark buffer as full */
1275
1276 /* all output buffers contain exactly one frame */
1277 output->nFlags = OMX_BUFFERFLAG_ENDOFFRAME;
1278 }
1279