src/gallium/state_trackers/omx/vid_enc.c

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