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 53#include "entrypoint.h" 54#include "vid_enc.h" 55#include "vid_omx_common.h" 56#include "vid_enc_common.h" 57 58static OMX_ERRORTYPE vid_enc_Constructor(OMX_COMPONENTTYPE *comp, OMX_STRING name); 59static OMX_ERRORTYPE vid_enc_Destructor(OMX_COMPONENTTYPE *comp); 60static OMX_ERRORTYPE vid_enc_SetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param); 61static OMX_ERRORTYPE vid_enc_GetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param); 62static OMX_ERRORTYPE vid_enc_SetConfig(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR config); 63static OMX_ERRORTYPE vid_enc_GetConfig(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR config); 64static OMX_ERRORTYPE vid_enc_MessageHandler(OMX_COMPONENTTYPE *comp, internalRequestMessageType *msg); 65static OMX_ERRORTYPE vid_enc_AllocateInBuffer(omx_base_PortType *port, OMX_INOUT OMX_BUFFERHEADERTYPE **buf, 66 OMX_IN OMX_U32 idx, OMX_IN OMX_PTR private, OMX_IN OMX_U32 size); 67static OMX_ERRORTYPE vid_enc_UseInBuffer(omx_base_PortType *port, OMX_BUFFERHEADERTYPE **buf, OMX_U32 idx, 68 OMX_PTR private, OMX_U32 size, OMX_U8 *mem); 69static OMX_ERRORTYPE vid_enc_FreeInBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf); 70static OMX_ERRORTYPE vid_enc_EncodeFrame(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf); 71static OMX_ERRORTYPE vid_enc_AllocateOutBuffer(omx_base_PortType *comp, OMX_INOUT OMX_BUFFERHEADERTYPE **buf, 72 OMX_IN OMX_U32 idx, OMX_IN OMX_PTR private, OMX_IN OMX_U32 size); 73static OMX_ERRORTYPE vid_enc_FreeOutBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf); 74static void vid_enc_BufferEncoded(OMX_COMPONENTTYPE *comp, OMX_BUFFERHEADERTYPE* input, OMX_BUFFERHEADERTYPE* output); 75 76OMX_ERRORTYPE vid_enc_LoaderComponent(stLoaderComponentType *comp) 77{ 78 comp->componentVersion.s.nVersionMajor = 0; 79 comp->componentVersion.s.nVersionMinor = 0; 80 comp->componentVersion.s.nRevision = 0; 81 comp->componentVersion.s.nStep = 1; 82 comp->name_specific_length = 1; 83 comp->constructor = vid_enc_Constructor; 84 85 comp->name = CALLOC(1, OMX_MAX_STRINGNAME_SIZE); 86 if (!comp->name) 87 return OMX_ErrorInsufficientResources; 88 89 comp->name_specific = CALLOC(1, sizeof(char *)); 90 if (!comp->name_specific) 91 goto error_arrays; 92 93 comp->role_specific = CALLOC(1, sizeof(char *)); 94 if (!comp->role_specific) 95 goto error_arrays; 96 97 comp->name_specific[0] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE); 98 if (comp->name_specific[0] == NULL) 99 goto error_specific; 100 101 comp->role_specific[0] = CALLOC(1, OMX_MAX_STRINGNAME_SIZE); 102 if (comp->role_specific[0] == NULL) 103 goto error_specific; 104 105 strcpy(comp->name, OMX_VID_ENC_BASE_NAME); 106 strcpy(comp->name_specific[0], OMX_VID_ENC_AVC_NAME); 107 strcpy(comp->role_specific[0], OMX_VID_ENC_AVC_ROLE); 108 109 return OMX_ErrorNone; 110 111error_specific: 112 FREE(comp->role_specific[0]); 113 FREE(comp->name_specific[0]); 114 115error_arrays: 116 FREE(comp->role_specific); 117 FREE(comp->name_specific); 118 119 FREE(comp->name); 120 121 return OMX_ErrorInsufficientResources; 122} 123 124static OMX_ERRORTYPE vid_enc_Constructor(OMX_COMPONENTTYPE *comp, OMX_STRING name) 125{ 126 vid_enc_PrivateType *priv; 127 omx_base_video_PortType *port; 128 struct pipe_screen *screen; 129 OMX_ERRORTYPE r; 130 int i; 131 132 assert(!comp->pComponentPrivate); 133 134 priv = comp->pComponentPrivate = CALLOC(1, sizeof(vid_enc_PrivateType)); 135 if (!priv) 136 return OMX_ErrorInsufficientResources; 137 138 r = omx_base_filter_Constructor(comp, name); 139 if (r) 140 return r; 141 142 priv->BufferMgmtCallback = vid_enc_BufferEncoded; 143 priv->messageHandler = vid_enc_MessageHandler; 144 priv->destructor = vid_enc_Destructor; 145 146 comp->SetParameter = vid_enc_SetParameter; 147 comp->GetParameter = vid_enc_GetParameter; 148 comp->GetConfig = vid_enc_GetConfig; 149 comp->SetConfig = vid_enc_SetConfig; 150 151 priv->screen = omx_get_screen(); 152 if (!priv->screen) 153 return OMX_ErrorInsufficientResources; 154 155 screen = priv->screen->pscreen; 156 if (!screen->get_video_param(screen, PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH, 157 PIPE_VIDEO_ENTRYPOINT_ENCODE, PIPE_VIDEO_CAP_SUPPORTED)) 158 return OMX_ErrorBadParameter; 159 160 priv->s_pipe = pipe_create_multimedia_context(screen); 161 if (!priv->s_pipe) 162 return OMX_ErrorInsufficientResources; 163 164 enc_InitCompute_common(priv); 165 166 if (!vl_compositor_init(&priv->compositor, priv->s_pipe)) { 167 priv->s_pipe->destroy(priv->s_pipe); 168 priv->s_pipe = NULL; 169 return OMX_ErrorInsufficientResources; 170 } 171 172 if (!vl_compositor_init_state(&priv->cstate, priv->s_pipe)) { 173 vl_compositor_cleanup(&priv->compositor); 174 priv->s_pipe->destroy(priv->s_pipe); 175 priv->s_pipe = NULL; 176 return OMX_ErrorInsufficientResources; 177 } 178 179 priv->t_pipe = pipe_create_multimedia_context(screen); 180 if (!priv->t_pipe) 181 return OMX_ErrorInsufficientResources; 182 183 priv->sPortTypesParam[OMX_PortDomainVideo].nStartPortNumber = 0; 184 priv->sPortTypesParam[OMX_PortDomainVideo].nPorts = 2; 185 priv->ports = CALLOC(2, sizeof(omx_base_PortType *)); 186 if (!priv->ports) 187 return OMX_ErrorInsufficientResources; 188 189 for (i = 0; i < 2; ++i) { 190 priv->ports[i] = CALLOC(1, sizeof(omx_base_video_PortType)); 191 if (!priv->ports[i]) 192 return OMX_ErrorInsufficientResources; 193 194 base_video_port_Constructor(comp, &priv->ports[i], i, i == 0); 195 } 196 197 port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]; 198 port->sPortParam.format.video.nFrameWidth = 176; 199 port->sPortParam.format.video.nFrameHeight = 144; 200 port->sPortParam.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar; 201 port->sVideoParam.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar; 202 port->sPortParam.nBufferCountActual = 8; 203 port->sPortParam.nBufferCountMin = 4; 204 205 port->Port_SendBufferFunction = vid_enc_EncodeFrame; 206 port->Port_AllocateBuffer = vid_enc_AllocateInBuffer; 207 port->Port_UseBuffer = vid_enc_UseInBuffer; 208 port->Port_FreeBuffer = vid_enc_FreeInBuffer; 209 210 port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]; 211 strcpy(port->sPortParam.format.video.cMIMEType,"video/H264"); 212 port->sPortParam.format.video.nFrameWidth = 176; 213 port->sPortParam.format.video.nFrameHeight = 144; 214 port->sPortParam.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC; 215 port->sVideoParam.eCompressionFormat = OMX_VIDEO_CodingAVC; 216 217 port->Port_AllocateBuffer = vid_enc_AllocateOutBuffer; 218 port->Port_FreeBuffer = vid_enc_FreeOutBuffer; 219 220 priv->bitrate.eControlRate = OMX_Video_ControlRateDisable; 221 priv->bitrate.nTargetBitrate = 0; 222 223 priv->quant.nQpI = OMX_VID_ENC_QUANT_I_FRAMES_DEFAULT; 224 priv->quant.nQpP = OMX_VID_ENC_QUANT_P_FRAMES_DEFAULT; 225 priv->quant.nQpB = OMX_VID_ENC_QUANT_B_FRAMES_DEFAULT; 226 227 priv->profile_level.eProfile = OMX_VIDEO_AVCProfileBaseline; 228 priv->profile_level.eLevel = OMX_VIDEO_AVCLevel51; 229 230 priv->force_pic_type.IntraRefreshVOP = OMX_FALSE; 231 priv->frame_num = 0; 232 priv->pic_order_cnt = 0; 233 priv->restricted_b_frames = debug_get_bool_option("OMX_USE_RESTRICTED_B_FRAMES", FALSE); 234 235 priv->scale.xWidth = OMX_VID_ENC_SCALING_WIDTH_DEFAULT; 236 priv->scale.xHeight = OMX_VID_ENC_SCALING_WIDTH_DEFAULT; 237 238 list_inithead(&priv->free_tasks); 239 list_inithead(&priv->used_tasks); 240 list_inithead(&priv->b_frames); 241 list_inithead(&priv->stacked_tasks); 242 243 return OMX_ErrorNone; 244} 245 246static OMX_ERRORTYPE vid_enc_Destructor(OMX_COMPONENTTYPE *comp) 247{ 248 vid_enc_PrivateType* priv = comp->pComponentPrivate; 249 int i; 250 251 enc_ReleaseTasks(&priv->free_tasks); 252 enc_ReleaseTasks(&priv->used_tasks); 253 enc_ReleaseTasks(&priv->b_frames); 254 enc_ReleaseTasks(&priv->stacked_tasks); 255 256 if (priv->ports) { 257 for (i = 0; i < priv->sPortTypesParam[OMX_PortDomainVideo].nPorts; ++i) { 258 if(priv->ports[i]) 259 priv->ports[i]->PortDestructor(priv->ports[i]); 260 } 261 FREE(priv->ports); 262 priv->ports=NULL; 263 } 264 265 for (i = 0; i < OMX_VID_ENC_NUM_SCALING_BUFFERS; ++i) 266 if (priv->scale_buffer[i]) 267 priv->scale_buffer[i]->destroy(priv->scale_buffer[i]); 268 269 if (priv->s_pipe) { 270 vl_compositor_cleanup_state(&priv->cstate); 271 vl_compositor_cleanup(&priv->compositor); 272 enc_ReleaseCompute_common(priv); 273 priv->s_pipe->destroy(priv->s_pipe); 274 } 275 276 if (priv->t_pipe) 277 priv->t_pipe->destroy(priv->t_pipe); 278 279 if (priv->screen) 280 omx_put_screen(); 281 282 return omx_workaround_Destructor(comp); 283} 284 285static OMX_ERRORTYPE enc_AllocateBackTexture(omx_base_PortType *port, 286 struct pipe_resource **resource, 287 struct pipe_transfer **transfer, 288 OMX_U8 **map) 289{ 290 OMX_COMPONENTTYPE* comp = port->standCompContainer; 291 vid_enc_PrivateType *priv = comp->pComponentPrivate; 292 struct pipe_resource buf_templ; 293 struct pipe_box box = {}; 294 OMX_U8 *ptr; 295 296 memset(&buf_templ, 0, sizeof buf_templ); 297 buf_templ.target = PIPE_TEXTURE_2D; 298 buf_templ.format = PIPE_FORMAT_I8_UNORM; 299 buf_templ.bind = PIPE_BIND_LINEAR; 300 buf_templ.usage = PIPE_USAGE_STAGING; 301 buf_templ.flags = 0; 302 buf_templ.width0 = port->sPortParam.format.video.nFrameWidth; 303 buf_templ.height0 = port->sPortParam.format.video.nFrameHeight * 3 / 2; 304 buf_templ.depth0 = 1; 305 buf_templ.array_size = 1; 306 307 *resource = priv->s_pipe->screen->resource_create(priv->s_pipe->screen, &buf_templ); 308 if (!*resource) 309 return OMX_ErrorInsufficientResources; 310 311 box.width = (*resource)->width0; 312 box.height = (*resource)->height0; 313 box.depth = (*resource)->depth0; 314 ptr = priv->s_pipe->texture_map(priv->s_pipe, *resource, 0, PIPE_MAP_WRITE, &box, transfer); 315 if (map) 316 *map = ptr; 317 318 return OMX_ErrorNone; 319} 320 321static OMX_ERRORTYPE vid_enc_SetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param) 322{ 323 OMX_COMPONENTTYPE *comp = handle; 324 vid_enc_PrivateType *priv = comp->pComponentPrivate; 325 OMX_ERRORTYPE r; 326 327 if (!param) 328 return OMX_ErrorBadParameter; 329 330 switch(idx) { 331 case OMX_IndexParamPortDefinition: { 332 OMX_PARAM_PORTDEFINITIONTYPE *def = param; 333 334 r = omx_base_component_SetParameter(handle, idx, param); 335 if (r) 336 return r; 337 338 if (def->nPortIndex == OMX_BASE_FILTER_INPUTPORT_INDEX) { 339 omx_base_video_PortType *port; 340 unsigned framesize; 341 struct pipe_resource *resource; 342 struct pipe_transfer *transfer; 343 344 port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]; 345 enc_AllocateBackTexture(priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX], 346 &resource, &transfer, NULL); 347 port->sPortParam.format.video.nStride = transfer->stride; 348 pipe_texture_unmap(priv->s_pipe, transfer); 349 pipe_resource_reference(&resource, NULL); 350 351 framesize = port->sPortParam.format.video.nStride * 352 port->sPortParam.format.video.nFrameHeight; 353 port->sPortParam.format.video.nSliceHeight = port->sPortParam.format.video.nFrameHeight; 354 port->sPortParam.nBufferSize = framesize * 3 / 2; 355 356 port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]; 357 port->sPortParam.nBufferSize = framesize * 512 / (16*16); 358 359 priv->frame_rate = def->format.video.xFramerate; 360 361 priv->callbacks->EventHandler(comp, priv->callbackData, OMX_EventPortSettingsChanged, 362 OMX_BASE_FILTER_OUTPUTPORT_INDEX, 0, NULL); 363 } 364 break; 365 } 366 case OMX_IndexParamStandardComponentRole: { 367 OMX_PARAM_COMPONENTROLETYPE *role = param; 368 369 r = checkHeader(param, sizeof(OMX_PARAM_COMPONENTROLETYPE)); 370 if (r) 371 return r; 372 373 if (strcmp((char *)role->cRole, OMX_VID_ENC_AVC_ROLE)) { 374 return OMX_ErrorBadParameter; 375 } 376 377 break; 378 } 379 case OMX_IndexParamVideoBitrate: { 380 OMX_VIDEO_PARAM_BITRATETYPE *bitrate = param; 381 382 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_BITRATETYPE)); 383 if (r) 384 return r; 385 386 priv->bitrate = *bitrate; 387 388 break; 389 } 390 case OMX_IndexParamVideoQuantization: { 391 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *quant = param; 392 393 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE)); 394 if (r) 395 return r; 396 397 priv->quant = *quant; 398 399 break; 400 } 401 case OMX_IndexParamVideoProfileLevelCurrent: { 402 OMX_VIDEO_PARAM_PROFILELEVELTYPE *profile_level = param; 403 404 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE)); 405 if (r) 406 return r; 407 408 priv->profile_level = *profile_level; 409 410 break; 411 } 412 default: 413 return omx_base_component_SetParameter(handle, idx, param); 414 } 415 return OMX_ErrorNone; 416} 417 418static OMX_ERRORTYPE vid_enc_GetParameter(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR param) 419{ 420 OMX_COMPONENTTYPE *comp = handle; 421 vid_enc_PrivateType *priv = comp->pComponentPrivate; 422 OMX_ERRORTYPE r; 423 424 if (!param) 425 return OMX_ErrorBadParameter; 426 427 switch(idx) { 428 case OMX_IndexParamStandardComponentRole: { 429 OMX_PARAM_COMPONENTROLETYPE *role = param; 430 431 r = checkHeader(param, sizeof(OMX_PARAM_COMPONENTROLETYPE)); 432 if (r) 433 return r; 434 435 strcpy((char *)role->cRole, OMX_VID_ENC_AVC_ROLE); 436 break; 437 } 438 case OMX_IndexParamVideoInit: 439 r = checkHeader(param, sizeof(OMX_PORT_PARAM_TYPE)); 440 if (r) 441 return r; 442 443 memcpy(param, &priv->sPortTypesParam[OMX_PortDomainVideo], sizeof(OMX_PORT_PARAM_TYPE)); 444 break; 445 446 case OMX_IndexParamVideoPortFormat: { 447 OMX_VIDEO_PARAM_PORTFORMATTYPE *format = param; 448 omx_base_video_PortType *port; 449 450 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE)); 451 if (r) 452 return r; 453 454 if (format->nPortIndex > 1) 455 return OMX_ErrorBadPortIndex; 456 if (format->nIndex >= 1) 457 return OMX_ErrorNoMore; 458 459 port = (omx_base_video_PortType *)priv->ports[format->nPortIndex]; 460 memcpy(format, &port->sVideoParam, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE)); 461 break; 462 } 463 case OMX_IndexParamVideoBitrate: { 464 OMX_VIDEO_PARAM_BITRATETYPE *bitrate = param; 465 466 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_BITRATETYPE)); 467 if (r) 468 return r; 469 470 bitrate->eControlRate = priv->bitrate.eControlRate; 471 bitrate->nTargetBitrate = priv->bitrate.nTargetBitrate; 472 473 break; 474 } 475 case OMX_IndexParamVideoQuantization: { 476 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *quant = param; 477 478 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE)); 479 if (r) 480 return r; 481 482 quant->nQpI = priv->quant.nQpI; 483 quant->nQpP = priv->quant.nQpP; 484 quant->nQpB = priv->quant.nQpB; 485 486 break; 487 } 488 case OMX_IndexParamVideoProfileLevelCurrent: { 489 OMX_VIDEO_PARAM_PROFILELEVELTYPE *profile_level = param; 490 491 r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE)); 492 if (r) 493 return r; 494 495 profile_level->eProfile = priv->profile_level.eProfile; 496 profile_level->eLevel = priv->profile_level.eLevel; 497 498 break; 499 } 500 default: 501 return omx_base_component_GetParameter(handle, idx, param); 502 } 503 return OMX_ErrorNone; 504} 505 506static OMX_ERRORTYPE vid_enc_SetConfig(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR config) 507{ 508 OMX_COMPONENTTYPE *comp = handle; 509 vid_enc_PrivateType *priv = comp->pComponentPrivate; 510 OMX_ERRORTYPE r; 511 int i; 512 513 if (!config) 514 return OMX_ErrorBadParameter; 515 516 switch(idx) { 517 case OMX_IndexConfigVideoIntraVOPRefresh: { 518 OMX_CONFIG_INTRAREFRESHVOPTYPE *type = config; 519 520 r = checkHeader(config, sizeof(OMX_CONFIG_INTRAREFRESHVOPTYPE)); 521 if (r) 522 return r; 523 524 priv->force_pic_type = *type; 525 526 break; 527 } 528 case OMX_IndexConfigCommonScale: { 529 OMX_CONFIG_SCALEFACTORTYPE *scale = config; 530 531 r = checkHeader(config, sizeof(OMX_CONFIG_SCALEFACTORTYPE)); 532 if (r) 533 return r; 534 535 if (scale->xWidth < 176 || scale->xHeight < 144) 536 return OMX_ErrorBadParameter; 537 538 for (i = 0; i < OMX_VID_ENC_NUM_SCALING_BUFFERS; ++i) { 539 if (priv->scale_buffer[i]) { 540 priv->scale_buffer[i]->destroy(priv->scale_buffer[i]); 541 priv->scale_buffer[i] = NULL; 542 } 543 } 544 545 priv->scale = *scale; 546 if (priv->scale.xWidth != 0xffffffff && priv->scale.xHeight != 0xffffffff) { 547 struct pipe_video_buffer templat = {}; 548 549 templat.buffer_format = PIPE_FORMAT_NV12; 550 templat.width = priv->scale.xWidth; 551 templat.height = priv->scale.xHeight; 552 templat.interlaced = false; 553 for (i = 0; i < OMX_VID_ENC_NUM_SCALING_BUFFERS; ++i) { 554 priv->scale_buffer[i] = priv->s_pipe->create_video_buffer(priv->s_pipe, &templat); 555 if (!priv->scale_buffer[i]) 556 return OMX_ErrorInsufficientResources; 557 } 558 } 559 560 break; 561 } 562 default: 563 return omx_base_component_SetConfig(handle, idx, config); 564 } 565 566 return OMX_ErrorNone; 567} 568 569static OMX_ERRORTYPE vid_enc_GetConfig(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR config) 570{ 571 OMX_COMPONENTTYPE *comp = handle; 572 vid_enc_PrivateType *priv = comp->pComponentPrivate; 573 OMX_ERRORTYPE r; 574 575 if (!config) 576 return OMX_ErrorBadParameter; 577 578 switch(idx) { 579 case OMX_IndexConfigCommonScale: { 580 OMX_CONFIG_SCALEFACTORTYPE *scale = config; 581 582 r = checkHeader(config, sizeof(OMX_CONFIG_SCALEFACTORTYPE)); 583 if (r) 584 return r; 585 586 scale->xWidth = priv->scale.xWidth; 587 scale->xHeight = priv->scale.xHeight; 588 589 break; 590 } 591 default: 592 return omx_base_component_GetConfig(handle, idx, config); 593 } 594 595 return OMX_ErrorNone; 596} 597 598static OMX_ERRORTYPE vid_enc_MessageHandler(OMX_COMPONENTTYPE* comp, internalRequestMessageType *msg) 599{ 600 vid_enc_PrivateType* priv = comp->pComponentPrivate; 601 602 if (msg->messageType == OMX_CommandStateSet) { 603 if ((msg->messageParam == OMX_StateIdle ) && (priv->state == OMX_StateLoaded)) { 604 605 struct pipe_video_codec templat = {}; 606 omx_base_video_PortType *port; 607 608 port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX]; 609 610 templat.profile = enc_TranslateOMXProfileToPipe(priv->profile_level.eProfile); 611 templat.level = enc_TranslateOMXLevelToPipe(priv->profile_level.eLevel); 612 templat.entrypoint = PIPE_VIDEO_ENTRYPOINT_ENCODE; 613 templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420; 614 templat.width = priv->scale_buffer[priv->current_scale_buffer] ? 615 priv->scale.xWidth : port->sPortParam.format.video.nFrameWidth; 616 templat.height = priv->scale_buffer[priv->current_scale_buffer] ? 617 priv->scale.xHeight : port->sPortParam.format.video.nFrameHeight; 618 619 if (templat.profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE) { 620 struct pipe_screen *screen = priv->screen->pscreen; 621 templat.max_references = 1; 622 priv->stacked_frames_num = 623 screen->get_video_param(screen, 624 PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH, 625 PIPE_VIDEO_ENTRYPOINT_ENCODE, 626 PIPE_VIDEO_CAP_STACKED_FRAMES); 627 } else { 628 templat.max_references = OMX_VID_ENC_P_PERIOD_DEFAULT; 629 priv->stacked_frames_num = 1; 630 } 631 priv->codec = priv->s_pipe->create_video_codec(priv->s_pipe, &templat); 632 633 } else if ((msg->messageParam == OMX_StateLoaded) && (priv->state == OMX_StateIdle)) { 634 if (priv->codec) { 635 priv->codec->destroy(priv->codec); 636 priv->codec = NULL; 637 } 638 } 639 } 640 641 return omx_base_component_MessageHandler(comp, msg); 642} 643 644static OMX_ERRORTYPE vid_enc_AllocateInBuffer(omx_base_PortType *port, OMX_INOUT OMX_BUFFERHEADERTYPE **buf, 645 OMX_IN OMX_U32 idx, OMX_IN OMX_PTR private, OMX_IN OMX_U32 size) 646{ 647 struct input_buf_private *inp; 648 OMX_ERRORTYPE r; 649 650 r = base_port_AllocateBuffer(port, buf, idx, private, size); 651 if (r) 652 return r; 653 654 inp = (*buf)->pInputPortPrivate = CALLOC_STRUCT(input_buf_private); 655 if (!inp) { 656 base_port_FreeBuffer(port, idx, *buf); 657 return OMX_ErrorInsufficientResources; 658 } 659 660 list_inithead(&inp->tasks); 661 662 FREE((*buf)->pBuffer); 663 r = enc_AllocateBackTexture(port, &inp->resource, &inp->transfer, &(*buf)->pBuffer); 664 if (r) { 665 FREE(inp); 666 base_port_FreeBuffer(port, idx, *buf); 667 return r; 668 } 669 670 return OMX_ErrorNone; 671} 672 673static OMX_ERRORTYPE vid_enc_UseInBuffer(omx_base_PortType *port, OMX_BUFFERHEADERTYPE **buf, OMX_U32 idx, 674 OMX_PTR private, OMX_U32 size, OMX_U8 *mem) 675{ 676 struct input_buf_private *inp; 677 OMX_ERRORTYPE r; 678 679 r = base_port_UseBuffer(port, buf, idx, private, size, mem); 680 if (r) 681 return r; 682 683 inp = (*buf)->pInputPortPrivate = CALLOC_STRUCT(input_buf_private); 684 if (!inp) { 685 base_port_FreeBuffer(port, idx, *buf); 686 return OMX_ErrorInsufficientResources; 687 } 688 689 list_inithead(&inp->tasks); 690 691 return OMX_ErrorNone; 692} 693 694static OMX_ERRORTYPE vid_enc_FreeInBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf) 695{ 696 OMX_COMPONENTTYPE* comp = port->standCompContainer; 697 vid_enc_PrivateType *priv = comp->pComponentPrivate; 698 struct input_buf_private *inp = buf->pInputPortPrivate; 699 700 if (inp) { 701 enc_ReleaseTasks(&inp->tasks); 702 if (inp->transfer) 703 pipe_texture_unmap(priv->s_pipe, inp->transfer); 704 pipe_resource_reference(&inp->resource, NULL); 705 FREE(inp); 706 } 707 buf->pBuffer = NULL; 708 709 return base_port_FreeBuffer(port, idx, buf); 710} 711 712static OMX_ERRORTYPE vid_enc_AllocateOutBuffer(omx_base_PortType *port, OMX_INOUT OMX_BUFFERHEADERTYPE **buf, 713 OMX_IN OMX_U32 idx, OMX_IN OMX_PTR private, OMX_IN OMX_U32 size) 714{ 715 OMX_ERRORTYPE r; 716 717 r = base_port_AllocateBuffer(port, buf, idx, private, size); 718 if (r) 719 return r; 720 721 FREE((*buf)->pBuffer); 722 (*buf)->pBuffer = NULL; 723 (*buf)->pOutputPortPrivate = CALLOC(1, sizeof(struct output_buf_private)); 724 if (!(*buf)->pOutputPortPrivate) { 725 base_port_FreeBuffer(port, idx, *buf); 726 return OMX_ErrorInsufficientResources; 727 } 728 729 return OMX_ErrorNone; 730} 731 732static OMX_ERRORTYPE vid_enc_FreeOutBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf) 733{ 734 OMX_COMPONENTTYPE* comp = port->standCompContainer; 735 vid_enc_PrivateType *priv = comp->pComponentPrivate; 736 737 if (buf->pOutputPortPrivate) { 738 struct output_buf_private *outp = buf->pOutputPortPrivate; 739 if (outp->transfer) 740 pipe_buffer_unmap(priv->t_pipe, outp->transfer); 741 pipe_resource_reference(&outp->bitstream, NULL); 742 FREE(outp); 743 buf->pOutputPortPrivate = NULL; 744 } 745 buf->pBuffer = NULL; 746 747 return base_port_FreeBuffer(port, idx, buf); 748} 749 750static struct encode_task *enc_NeedTask(omx_base_PortType *port) 751{ 752 OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video; 753 OMX_COMPONENTTYPE* comp = port->standCompContainer; 754 vid_enc_PrivateType *priv = comp->pComponentPrivate; 755 756 return enc_NeedTask_common(priv, def); 757} 758 759static OMX_ERRORTYPE enc_LoadImage(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf, 760 struct pipe_video_buffer *vbuf) 761{ 762 OMX_COMPONENTTYPE* comp = port->standCompContainer; 763 vid_enc_PrivateType *priv = comp->pComponentPrivate; 764 OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video; 765 return enc_LoadImage_common(priv, def, buf, vbuf); 766} 767 768static void enc_ScaleInput(omx_base_PortType *port, struct pipe_video_buffer **vbuf, unsigned *size) 769{ 770 OMX_COMPONENTTYPE* comp = port->standCompContainer; 771 vid_enc_PrivateType *priv = comp->pComponentPrivate; 772 OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video; 773 enc_ScaleInput_common(priv, def, vbuf, size); 774} 775 776static void enc_ControlPicture(omx_base_PortType *port, struct pipe_h264_enc_picture_desc *picture) 777{ 778 OMX_COMPONENTTYPE* comp = port->standCompContainer; 779 vid_enc_PrivateType *priv = comp->pComponentPrivate; 780 enc_ControlPicture_common(priv, picture); 781} 782 783static void enc_HandleTask(omx_base_PortType *port, struct encode_task *task, 784 enum pipe_h2645_enc_picture_type picture_type) 785{ 786 OMX_COMPONENTTYPE* comp = port->standCompContainer; 787 vid_enc_PrivateType *priv = comp->pComponentPrivate; 788 unsigned size = priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]->sPortParam.nBufferSize; 789 struct pipe_video_buffer *vbuf = task->buf; 790 struct pipe_h264_enc_picture_desc picture = {}; 791 792 /* -------------- scale input image --------- */ 793 enc_ScaleInput(port, &vbuf, &size); 794 priv->s_pipe->flush(priv->s_pipe, NULL, 0); 795 796 /* -------------- allocate output buffer --------- */ 797 task->bitstream = pipe_buffer_create(priv->s_pipe->screen, 798 PIPE_BIND_VERTEX_BUFFER, 799 PIPE_USAGE_STAGING, /* map for read */ 800 size); 801 802 picture.picture_type = picture_type; 803 picture.pic_order_cnt = task->pic_order_cnt; 804 picture.base.profile = enc_TranslateOMXProfileToPipe(priv->profile_level.eProfile); 805 picture.base.entry_point = PIPE_VIDEO_ENTRYPOINT_ENCODE; 806 if (priv->restricted_b_frames && picture_type == PIPE_H2645_ENC_PICTURE_TYPE_B) 807 picture.not_referenced = true; 808 enc_ControlPicture(port, &picture); 809 810 /* -------------- encode frame --------- */ 811 priv->codec->begin_frame(priv->codec, vbuf, &picture.base); 812 priv->codec->encode_bitstream(priv->codec, vbuf, task->bitstream, &task->feedback); 813 priv->codec->end_frame(priv->codec, vbuf, &picture.base); 814} 815 816static void enc_ClearBframes(omx_base_PortType *port, struct input_buf_private *inp) 817{ 818 OMX_COMPONENTTYPE* comp = port->standCompContainer; 819 vid_enc_PrivateType *priv = comp->pComponentPrivate; 820 struct encode_task *task; 821 822 if (list_is_empty(&priv->b_frames)) 823 return; 824 825 task = LIST_ENTRY(struct encode_task, priv->b_frames.prev, list); 826 list_del(&task->list); 827 828 /* promote last from to P frame */ 829 priv->ref_idx_l0 = priv->ref_idx_l1; 830 enc_HandleTask(port, task, PIPE_H2645_ENC_PICTURE_TYPE_P); 831 list_addtail(&task->list, &inp->tasks); 832 priv->ref_idx_l1 = priv->frame_num++; 833 834 /* handle B frames */ 835 LIST_FOR_EACH_ENTRY(task, &priv->b_frames, list) { 836 enc_HandleTask(port, task, PIPE_H2645_ENC_PICTURE_TYPE_B); 837 if (!priv->restricted_b_frames) 838 priv->ref_idx_l0 = priv->frame_num; 839 priv->frame_num++; 840 } 841 842 enc_MoveTasks(&priv->b_frames, &inp->tasks); 843} 844 845static OMX_ERRORTYPE vid_enc_EncodeFrame(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf) 846{ 847 OMX_COMPONENTTYPE* comp = port->standCompContainer; 848 vid_enc_PrivateType *priv = comp->pComponentPrivate; 849 struct input_buf_private *inp = buf->pInputPortPrivate; 850 enum pipe_h2645_enc_picture_type picture_type; 851 struct encode_task *task; 852 unsigned stacked_num = 0; 853 OMX_ERRORTYPE err; 854 855 enc_MoveTasks(&inp->tasks, &priv->free_tasks); 856 task = enc_NeedTask(port); 857 if (!task) 858 return OMX_ErrorInsufficientResources; 859 860 if (buf->nFilledLen == 0) { 861 if (buf->nFlags & OMX_BUFFERFLAG_EOS) { 862 buf->nFilledLen = buf->nAllocLen; 863 enc_ClearBframes(port, inp); 864 enc_MoveTasks(&priv->stacked_tasks, &inp->tasks); 865 priv->codec->flush(priv->codec); 866 } 867 return base_port_SendBufferFunction(port, buf); 868 } 869 870 if (buf->pOutputPortPrivate) { 871 struct pipe_video_buffer *vbuf = buf->pOutputPortPrivate; 872 buf->pOutputPortPrivate = task->buf; 873 task->buf = vbuf; 874 } else { 875 /* ------- load input image into video buffer ---- */ 876 err = enc_LoadImage(port, buf, task->buf); 877 if (err != OMX_ErrorNone) { 878 FREE(task); 879 return err; 880 } 881 } 882 883 /* -------------- determine picture type --------- */ 884 if (!(priv->pic_order_cnt % OMX_VID_ENC_IDR_PERIOD_DEFAULT) || 885 priv->force_pic_type.IntraRefreshVOP) { 886 enc_ClearBframes(port, inp); 887 picture_type = PIPE_H2645_ENC_PICTURE_TYPE_IDR; 888 priv->force_pic_type.IntraRefreshVOP = OMX_FALSE; 889 priv->frame_num = 0; 890 priv->pic_order_cnt = 0; 891 } else if (priv->codec->profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE || 892 !(priv->pic_order_cnt % OMX_VID_ENC_P_PERIOD_DEFAULT) || 893 (buf->nFlags & OMX_BUFFERFLAG_EOS)) { 894 picture_type = PIPE_H2645_ENC_PICTURE_TYPE_P; 895 } else { 896 picture_type = PIPE_H2645_ENC_PICTURE_TYPE_B; 897 } 898 899 task->pic_order_cnt = priv->pic_order_cnt++; 900 901 if (picture_type == PIPE_H2645_ENC_PICTURE_TYPE_B) { 902 /* put frame at the tail of the queue */ 903 list_addtail(&task->list, &priv->b_frames); 904 } else { 905 /* handle I or P frame */ 906 priv->ref_idx_l0 = priv->ref_idx_l1; 907 enc_HandleTask(port, task, picture_type); 908 list_addtail(&task->list, &priv->stacked_tasks); 909 LIST_FOR_EACH_ENTRY(task, &priv->stacked_tasks, list) { 910 ++stacked_num; 911 } 912 if (stacked_num == priv->stacked_frames_num) { 913 struct encode_task *t; 914 t = LIST_ENTRY(struct encode_task, priv->stacked_tasks.next, list); 915 list_del(&t->list); 916 list_addtail(&t->list, &inp->tasks); 917 } 918 priv->ref_idx_l1 = priv->frame_num++; 919 920 /* handle B frames */ 921 LIST_FOR_EACH_ENTRY(task, &priv->b_frames, list) { 922 enc_HandleTask(port, task, PIPE_H2645_ENC_PICTURE_TYPE_B); 923 if (!priv->restricted_b_frames) 924 priv->ref_idx_l0 = priv->frame_num; 925 priv->frame_num++; 926 } 927 928 enc_MoveTasks(&priv->b_frames, &inp->tasks); 929 } 930 931 if (list_is_empty(&inp->tasks)) 932 return port->ReturnBufferFunction(port, buf); 933 else 934 return base_port_SendBufferFunction(port, buf); 935} 936 937static void vid_enc_BufferEncoded(OMX_COMPONENTTYPE *comp, OMX_BUFFERHEADERTYPE* input, OMX_BUFFERHEADERTYPE* output) 938{ 939 vid_enc_PrivateType *priv = comp->pComponentPrivate; 940 vid_enc_BufferEncoded_common(priv, input, output); 941} 942