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_AVCLevel42;
 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
 477       port = (omx_base_video_PortType *)priv->ports[format->nPortIndex];
 478       memcpy(format, &port->sVideoParam, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
 479       break;
 480    }
 481    case OMX_IndexParamVideoBitrate: {
 482       OMX_VIDEO_PARAM_BITRATETYPE *bitrate = param;
 483
 484       r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_BITRATETYPE));
 485       if (r)
 486          return r;
 487
 488       bitrate->eControlRate = priv->bitrate.eControlRate;
 489       bitrate->nTargetBitrate = priv->bitrate.nTargetBitrate;
 490
 491       break;
 492    }
 493    case OMX_IndexParamVideoQuantization: {
 494       OMX_VIDEO_PARAM_QUANTIZATIONTYPE *quant = param;
 495
 496       r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE));
 497       if (r)
 498          return r;
 499
 500       quant->nQpI = priv->quant.nQpI;
 501       quant->nQpP = priv->quant.nQpP;
 502       quant->nQpB = priv->quant.nQpB;
 503
 504       break;
 505    }
 506    case OMX_IndexParamVideoProfileLevelCurrent: {
 507       OMX_VIDEO_PARAM_PROFILELEVELTYPE *profile_level = param;
 508
 509       r = checkHeader(param, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
 510       if (r)
 511          return r;
 512
 513       profile_level->eProfile = priv->profile_level.eProfile;
 514       profile_level->eLevel = priv->profile_level.eLevel;
 515
 516       break;
 517    }
 518    default:
 519       return omx_base_component_GetParameter(handle, idx, param);
 520    }
 521    return OMX_ErrorNone;
 522 }
 523
 524 static OMX_ERRORTYPE vid_enc_SetConfig(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR config)
 525 {
 526    OMX_COMPONENTTYPE *comp = handle;
 527    vid_enc_PrivateType *priv = comp->pComponentPrivate;
 528    OMX_ERRORTYPE r;
 529    int i;
 530
 531    if (!config)
 532       return OMX_ErrorBadParameter;
 533
 534    switch(idx) {
 535    case OMX_IndexConfigVideoIntraVOPRefresh: {
 536       OMX_CONFIG_INTRAREFRESHVOPTYPE *type = config;
 537
 538       r = checkHeader(config, sizeof(OMX_CONFIG_INTRAREFRESHVOPTYPE));
 539       if (r)
 540          return r;
 541
 542       priv->force_pic_type = *type;
 543
 544       break;
 545    }
 546    case OMX_IndexConfigCommonScale: {
 547       OMX_CONFIG_SCALEFACTORTYPE *scale = config;
 548
 549       r = checkHeader(config, sizeof(OMX_CONFIG_SCALEFACTORTYPE));
 550       if (r)
 551          return r;
 552
 553       if (scale->xWidth < 176 || scale->xHeight < 144)
 554          return OMX_ErrorBadParameter;
 555
 556       for (i = 0; i < OMX_VID_ENC_NUM_SCALING_BUFFERS; ++i) {
 557          if (priv->scale_buffer[i]) {
 558             priv->scale_buffer[i]->destroy(priv->scale_buffer[i]);
 559             priv->scale_buffer[i] = NULL;
 560          }
 561       }
 562
 563       priv->scale = *scale;
 564       if (priv->scale.xWidth != 0xffffffff && priv->scale.xHeight != 0xffffffff) {
 565          struct pipe_video_buffer templat = {};
 566
 567          templat.buffer_format = PIPE_FORMAT_NV12;
 568          templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
 569          templat.width = priv->scale.xWidth;
 570          templat.height = priv->scale.xHeight;
 571          templat.interlaced = false;
 572          for (i = 0; i < OMX_VID_ENC_NUM_SCALING_BUFFERS; ++i) {
 573             priv->scale_buffer[i] = priv->s_pipe->create_video_buffer(priv->s_pipe, &templat);
 574             if (!priv->scale_buffer[i])
 575                return OMX_ErrorInsufficientResources;
 576          }
 577       }
 578
 579       break;
 580    }
 581    default:
 582       return omx_base_component_SetConfig(handle, idx, config);
 583    }
 584
 585    return OMX_ErrorNone;
 586 }
 587
 588 static OMX_ERRORTYPE vid_enc_GetConfig(OMX_HANDLETYPE handle, OMX_INDEXTYPE idx, OMX_PTR config)
 589 {
 590    OMX_COMPONENTTYPE *comp = handle;
 591    vid_enc_PrivateType *priv = comp->pComponentPrivate;
 592    OMX_ERRORTYPE r;
 593
 594    if (!config)
 595       return OMX_ErrorBadParameter;
 596
 597    switch(idx) {
 598    case OMX_IndexConfigCommonScale: {
 599       OMX_CONFIG_SCALEFACTORTYPE *scale = config;
 600
 601       r = checkHeader(config, sizeof(OMX_CONFIG_SCALEFACTORTYPE));
 602       if (r)
 603          return r;
 604
 605       scale->xWidth = priv->scale.xWidth;
 606       scale->xHeight = priv->scale.xHeight;
 607
 608       break;
 609    }
 610    default:
 611       return omx_base_component_GetConfig(handle, idx, config);
 612    }
 613
 614    return OMX_ErrorNone;
 615 }
 616
 617 static enum pipe_video_profile enc_TranslateOMXProfileToPipe(unsigned omx_profile)
 618 {
 619    switch (omx_profile) {
 620    case OMX_VIDEO_AVCProfileBaseline:
 621       return PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE;
 622    case OMX_VIDEO_AVCProfileMain:
 623       return PIPE_VIDEO_PROFILE_MPEG4_AVC_MAIN;
 624    case OMX_VIDEO_AVCProfileExtended:
 625       return PIPE_VIDEO_PROFILE_MPEG4_AVC_EXTENDED;
 626    case OMX_VIDEO_AVCProfileHigh:
 627       return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH;
 628    case OMX_VIDEO_AVCProfileHigh10:
 629       return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH10;
 630    case OMX_VIDEO_AVCProfileHigh422:
 631       return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH422;
 632    case OMX_VIDEO_AVCProfileHigh444:
 633       return PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH444;
 634    default:
 635       return PIPE_VIDEO_PROFILE_UNKNOWN;
 636    }
 637 }
 638
 639 static unsigned enc_TranslateOMXLevelToPipe(unsigned omx_level)
 640 {
 641    switch (omx_level) {
 642    case OMX_VIDEO_AVCLevel1:
 643    case OMX_VIDEO_AVCLevel1b:
 644       return 10;
 645    case OMX_VIDEO_AVCLevel11:
 646       return 11;
 647    case OMX_VIDEO_AVCLevel12:
 648       return 12;
 649    case OMX_VIDEO_AVCLevel13:
 650       return 13;
 651    case OMX_VIDEO_AVCLevel2:
 652       return 20;
 653    case OMX_VIDEO_AVCLevel21:
 654       return 21;
 655    case OMX_VIDEO_AVCLevel22:
 656       return 22;
 657    case OMX_VIDEO_AVCLevel3:
 658       return 30;
 659    case OMX_VIDEO_AVCLevel31:
 660       return 31;
 661    case OMX_VIDEO_AVCLevel32:
 662       return 32;
 663    case OMX_VIDEO_AVCLevel4:
 664       return 40;
 665    case OMX_VIDEO_AVCLevel41:
 666       return 41;
 667    default:
 668    case OMX_VIDEO_AVCLevel42:
 669       return 42;
 670    case OMX_VIDEO_AVCLevel5:
 671       return 50;
 672    case OMX_VIDEO_AVCLevel51:
 673       return 51;
 674    }
 675 }
 676
 677 static OMX_ERRORTYPE vid_enc_MessageHandler(OMX_COMPONENTTYPE* comp, internalRequestMessageType *msg)
 678 {
 679    vid_enc_PrivateType* priv = comp->pComponentPrivate;
 680
 681    if (msg->messageType == OMX_CommandStateSet) {
 682       if ((msg->messageParam == OMX_StateIdle ) && (priv->state == OMX_StateLoaded)) {
 683
 684          struct pipe_video_codec templat = {};
 685          omx_base_video_PortType *port;
 686
 687          port = (omx_base_video_PortType *)priv->ports[OMX_BASE_FILTER_INPUTPORT_INDEX];
 688
 689          templat.profile = enc_TranslateOMXProfileToPipe(priv->profile_level.eProfile);
 690          templat.level = enc_TranslateOMXLevelToPipe(priv->profile_level.eLevel);
 691          templat.entrypoint = PIPE_VIDEO_ENTRYPOINT_ENCODE;
 692          templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
 693          templat.width = priv->scale_buffer[priv->current_scale_buffer] ?
 694                             priv->scale.xWidth : port->sPortParam.format.video.nFrameWidth;
 695          templat.height = priv->scale_buffer[priv->current_scale_buffer] ?
 696                             priv->scale.xHeight : port->sPortParam.format.video.nFrameHeight;
 697
 698          if (templat.profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE) {
 699             struct pipe_screen *screen = priv->screen->pscreen;
 700             templat.max_references = 1;
 701             priv->stacked_frames_num =
 702                screen->get_video_param(screen,
 703                                        PIPE_VIDEO_PROFILE_MPEG4_AVC_HIGH,
 704                                        PIPE_VIDEO_ENTRYPOINT_ENCODE,
 705                                        PIPE_VIDEO_CAP_STACKED_FRAMES);
 706          } else {
 707             templat.max_references = OMX_VID_ENC_P_PERIOD_DEFAULT;
 708             priv->stacked_frames_num = 1;
 709          }
 710          priv->codec = priv->s_pipe->create_video_codec(priv->s_pipe, &templat);
 711
 712       } else if ((msg->messageParam == OMX_StateLoaded) && (priv->state == OMX_StateIdle)) {
 713          if (priv->codec) {
 714             priv->codec->destroy(priv->codec);
 715             priv->codec = NULL;
 716          }
 717       }
 718    }
 719
 720    return omx_base_component_MessageHandler(comp, msg);
 721 }
 722
 723 static OMX_ERRORTYPE vid_enc_AllocateInBuffer(omx_base_PortType *port, OMX_INOUT OMX_BUFFERHEADERTYPE **buf,
 724                                               OMX_IN OMX_U32 idx, OMX_IN OMX_PTR private, OMX_IN OMX_U32 size)
 725 {
 726    struct input_buf_private *inp;
 727    OMX_ERRORTYPE r;
 728
 729    r = base_port_AllocateBuffer(port, buf, idx, private, size);
 730    if (r)
 731       return r;
 732
 733    inp = (*buf)->pInputPortPrivate = CALLOC_STRUCT(input_buf_private);
 734    if (!inp) {
 735       base_port_FreeBuffer(port, idx, *buf);
 736       return OMX_ErrorInsufficientResources;
 737    }
 738
 739    LIST_INITHEAD(&inp->tasks);
 740
 741    FREE((*buf)->pBuffer);
 742    r = enc_AllocateBackTexture(port, &inp->resource, &inp->transfer, &(*buf)->pBuffer);
 743    if (r) {
 744       FREE(inp);
 745       base_port_FreeBuffer(port, idx, *buf);
 746       return r;
 747    }
 748
 749    return OMX_ErrorNone;
 750 }
 751
 752 static OMX_ERRORTYPE vid_enc_UseInBuffer(omx_base_PortType *port, OMX_BUFFERHEADERTYPE **buf, OMX_U32 idx,
 753                                          OMX_PTR private, OMX_U32 size, OMX_U8 *mem)
 754 {
 755    struct input_buf_private *inp;
 756    OMX_ERRORTYPE r;
 757
 758    r = base_port_UseBuffer(port, buf, idx, private, size, mem);
 759    if (r)
 760       return r;
 761
 762    inp = (*buf)->pInputPortPrivate = CALLOC_STRUCT(input_buf_private);
 763    if (!inp) {
 764       base_port_FreeBuffer(port, idx, *buf);
 765       return OMX_ErrorInsufficientResources;
 766    }
 767
 768    LIST_INITHEAD(&inp->tasks);
 769
 770    return OMX_ErrorNone;
 771 }
 772
 773 static OMX_ERRORTYPE vid_enc_FreeInBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf)
 774 {
 775    OMX_COMPONENTTYPE* comp = port->standCompContainer;
 776    vid_enc_PrivateType *priv = comp->pComponentPrivate;
 777    struct input_buf_private *inp = buf->pInputPortPrivate;
 778
 779    if (inp) {
 780       enc_ReleaseTasks(&inp->tasks);
 781       if (inp->transfer)
 782          pipe_transfer_unmap(priv->s_pipe, inp->transfer);
 783       pipe_resource_reference(&inp->resource, NULL);
 784       FREE(inp);
 785    }
 786    buf->pBuffer = NULL;
 787
 788    return base_port_FreeBuffer(port, idx, buf);
 789 }
 790
 791 static OMX_ERRORTYPE vid_enc_AllocateOutBuffer(omx_base_PortType *port, OMX_INOUT OMX_BUFFERHEADERTYPE **buf,
 792                                                OMX_IN OMX_U32 idx, OMX_IN OMX_PTR private, OMX_IN OMX_U32 size)
 793 {
 794    OMX_ERRORTYPE r;
 795
 796    r = base_port_AllocateBuffer(port, buf, idx, private, size);
 797    if (r)
 798       return r;
 799
 800    FREE((*buf)->pBuffer);
 801    (*buf)->pBuffer = NULL;
 802    (*buf)->pOutputPortPrivate = CALLOC(1, sizeof(struct output_buf_private));
 803    if (!(*buf)->pOutputPortPrivate) {
 804       base_port_FreeBuffer(port, idx, *buf);
 805       return OMX_ErrorInsufficientResources;
 806    }
 807
 808    return OMX_ErrorNone;
 809 }
 810
 811 static OMX_ERRORTYPE vid_enc_FreeOutBuffer(omx_base_PortType *port, OMX_U32 idx, OMX_BUFFERHEADERTYPE *buf)
 812 {
 813    OMX_COMPONENTTYPE* comp = port->standCompContainer;
 814    vid_enc_PrivateType *priv = comp->pComponentPrivate;
 815
 816    if (buf->pOutputPortPrivate) {
 817       struct output_buf_private *outp = buf->pOutputPortPrivate;
 818       if (outp->transfer)
 819          pipe_transfer_unmap(priv->t_pipe, outp->transfer);
 820       pipe_resource_reference(&outp->bitstream, NULL);
 821       FREE(outp);
 822       buf->pOutputPortPrivate = NULL;
 823    }
 824    buf->pBuffer = NULL;
 825
 826    return base_port_FreeBuffer(port, idx, buf);
 827 }
 828
 829 static struct encode_task *enc_NeedTask(omx_base_PortType *port)
 830 {
 831    OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video;
 832    OMX_COMPONENTTYPE* comp = port->standCompContainer;
 833    vid_enc_PrivateType *priv = comp->pComponentPrivate;
 834
 835    struct pipe_video_buffer templat = {};
 836    struct encode_task *task;
 837
 838    if (!LIST_IS_EMPTY(&priv->free_tasks)) {
 839       task = LIST_ENTRY(struct encode_task, priv->free_tasks.next, list);
 840       LIST_DEL(&task->list);
 841       return task;
 842    }
 843
 844    /* allocate a new one */
 845    task = CALLOC_STRUCT(encode_task);
 846    if (!task)
 847       return NULL;
 848
 849    templat.buffer_format = PIPE_FORMAT_NV12;
 850    templat.chroma_format = PIPE_VIDEO_CHROMA_FORMAT_420;
 851    templat.width = def->nFrameWidth;
 852    templat.height = def->nFrameHeight;
 853    templat.interlaced = false;
 854
 855    task->buf = priv->s_pipe->create_video_buffer(priv->s_pipe, &templat);
 856    if (!task->buf) {
 857       FREE(task);
 858       return NULL;
 859    }
 860
 861    return task;
 862 }
 863
 864 static void enc_MoveTasks(struct list_head *from, struct list_head *to)
 865 {
 866    to->prev->next = from->next;
 867    from->next->prev = to->prev;
 868    from->prev->next = to;
 869    to->prev = from->prev;
 870    LIST_INITHEAD(from);
 871 }
 872
 873 static void enc_ReleaseTasks(struct list_head *head)
 874 {
 875    struct encode_task *i, *next;
 876
 877    if (!head)
 878            return;
 879
 880    LIST_FOR_EACH_ENTRY_SAFE(i, next, head, list) {
 881       pipe_resource_reference(&i->bitstream, NULL);
 882       i->buf->destroy(i->buf);
 883       FREE(i);
 884    }
 885 }
 886
 887 static OMX_ERRORTYPE enc_LoadImage(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf,
 888                                    struct pipe_video_buffer *vbuf)
 889 {
 890    OMX_COMPONENTTYPE* comp = port->standCompContainer;
 891    vid_enc_PrivateType *priv = comp->pComponentPrivate;
 892    OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video;
 893    struct pipe_box box = {};
 894    struct input_buf_private *inp = buf->pInputPortPrivate;
 895
 896    if (!inp->resource) {
 897       struct pipe_sampler_view **views;
 898       void *ptr;
 899
 900       views = vbuf->get_sampler_view_planes(vbuf);
 901       if (!views)
 902          return OMX_ErrorInsufficientResources;
 903
 904       ptr = buf->pBuffer;
 905       box.width = def->nFrameWidth;
 906       box.height = def->nFrameHeight;
 907       box.depth = 1;
 908       priv->s_pipe->transfer_inline_write(priv->s_pipe, views[0]->texture, 0,
 909                                           PIPE_TRANSFER_WRITE, &box,
 910                                           ptr, def->nStride, 0);
 911       ptr = ((uint8_t*)buf->pBuffer) + (def->nStride * box.height);
 912       box.width = def->nFrameWidth / 2;
 913       box.height = def->nFrameHeight / 2;
 914       box.depth = 1;
 915       priv->s_pipe->transfer_inline_write(priv->s_pipe, views[1]->texture, 0,
 916                                           PIPE_TRANSFER_WRITE, &box,
 917                                           ptr, def->nStride, 0);
 918    } else {
 919       struct pipe_blit_info blit;
 920       struct vl_video_buffer *dst_buf = (struct vl_video_buffer *)vbuf;
 921
 922       pipe_transfer_unmap(priv->s_pipe, inp->transfer);
 923
 924       box.width = def->nFrameWidth;
 925       box.height = def->nFrameHeight;
 926       box.depth = 1;
 927
 928       priv->s_pipe->resource_copy_region(priv->s_pipe,
 929                                          dst_buf->resources[0],
 930                                          0, 0, 0, 0, inp->resource, 0, &box);
 931
 932       memset(&blit, 0, sizeof(blit));
 933       blit.src.resource = inp->resource;
 934       blit.src.format = inp->resource->format;
 935
 936       blit.src.box.x = 0;
 937       blit.src.box.y = def->nFrameHeight;
 938       blit.src.box.width = def->nFrameWidth;
 939       blit.src.box.height = def->nFrameHeight / 2 ;
 940       blit.src.box.depth = 1;
 941
 942       blit.dst.resource = dst_buf->resources[1];
 943       blit.dst.format = blit.dst.resource->format;
 944
 945       blit.dst.box.width = def->nFrameWidth / 2;
 946       blit.dst.box.height = def->nFrameHeight / 2;
 947       blit.dst.box.depth = 1;
 948       blit.filter = PIPE_TEX_FILTER_NEAREST;
 949
 950       blit.mask = PIPE_MASK_G;
 951       priv->s_pipe->blit(priv->s_pipe, &blit);
 952
 953       blit.src.box.x = 1;
 954       blit.mask = PIPE_MASK_R;
 955       priv->s_pipe->blit(priv->s_pipe, &blit);
 956       priv->s_pipe->flush(priv->s_pipe, NULL, 0);
 957
 958       box.width = inp->resource->width0;
 959       box.height = inp->resource->height0;
 960       box.depth = inp->resource->depth0;
 961       buf->pBuffer = priv->s_pipe->transfer_map(priv->s_pipe, inp->resource, 0,
 962                                                 PIPE_TRANSFER_WRITE, &box,
 963                                                 &inp->transfer);
 964    }
 965
 966    return OMX_ErrorNone;
 967 }
 968
 969 static void enc_ScaleInput(omx_base_PortType *port, struct pipe_video_buffer **vbuf, unsigned *size)
 970 {
 971    OMX_COMPONENTTYPE* comp = port->standCompContainer;
 972    vid_enc_PrivateType *priv = comp->pComponentPrivate;
 973    OMX_VIDEO_PORTDEFINITIONTYPE *def = &port->sPortParam.format.video;
 974    struct pipe_video_buffer *src_buf = *vbuf;
 975    struct vl_compositor *compositor = &priv->compositor;
 976    struct vl_compositor_state *s = &priv->cstate;
 977    struct pipe_sampler_view **views;
 978    struct pipe_surface **dst_surface;
 979    unsigned i;
 980
 981    if (!priv->scale_buffer[priv->current_scale_buffer])
 982       return;
 983
 984    views = src_buf->get_sampler_view_planes(src_buf);
 985    dst_surface = priv->scale_buffer[priv->current_scale_buffer]->get_surfaces
 986                  (priv->scale_buffer[priv->current_scale_buffer]);
 987    vl_compositor_clear_layers(s);
 988
 989    for (i = 0; i < VL_MAX_SURFACES; ++i) {
 990       struct u_rect src_rect;
 991       if (!views[i] || !dst_surface[i])
 992          continue;
 993       src_rect.x0 = 0;
 994       src_rect.y0 = 0;
 995       src_rect.x1 = def->nFrameWidth;
 996       src_rect.y1 = def->nFrameHeight;
 997       if (i > 0) {
 998          src_rect.x1 /= 2;
 999          src_rect.y1 /= 2;
1000       }
1001       vl_compositor_set_rgba_layer(s, compositor, 0, views[i], &src_rect, NULL, NULL);
1002       vl_compositor_render(s, compositor, dst_surface[i], NULL, false);
1003    }
1004    *size  = priv->scale.xWidth * priv->scale.xHeight * 2;
1005    *vbuf = priv->scale_buffer[priv->current_scale_buffer++];
1006    priv->current_scale_buffer %= OMX_VID_ENC_NUM_SCALING_BUFFERS;
1007 }
1008
1009 static void enc_GetPictureParamPreset(struct pipe_h264_enc_picture_desc *picture)
1010 {
1011    picture->motion_est.enc_disable_sub_mode = 0x000000fe;
1012    picture->motion_est.enc_ime2_search_range_x = 0x00000001;
1013    picture->motion_est.enc_ime2_search_range_y = 0x00000001;
1014    picture->pic_ctrl.enc_constraint_set_flags = 0x00000040;
1015 }
1016
1017 static void enc_ControlPicture(omx_base_PortType *port, struct pipe_h264_enc_picture_desc *picture)
1018 {
1019    OMX_COMPONENTTYPE* comp = port->standCompContainer;
1020    vid_enc_PrivateType *priv = comp->pComponentPrivate;
1021    struct pipe_h264_enc_rate_control *rate_ctrl = &picture->rate_ctrl;
1022
1023    switch (priv->bitrate.eControlRate) {
1024    case OMX_Video_ControlRateVariable:
1025       rate_ctrl->rate_ctrl_method = PIPE_H264_ENC_RATE_CONTROL_METHOD_VARIABLE;
1026       break;
1027    case OMX_Video_ControlRateConstant:
1028       rate_ctrl->rate_ctrl_method = PIPE_H264_ENC_RATE_CONTROL_METHOD_CONSTANT;
1029       break;
1030    case OMX_Video_ControlRateVariableSkipFrames:
1031       rate_ctrl->rate_ctrl_method = PIPE_H264_ENC_RATE_CONTROL_METHOD_VARIABLE_SKIP;
1032       break;
1033    case OMX_Video_ControlRateConstantSkipFrames:
1034       rate_ctrl->rate_ctrl_method = PIPE_H264_ENC_RATE_CONTROL_METHOD_CONSTANT_SKIP;
1035       break;
1036    default:
1037       rate_ctrl->rate_ctrl_method = PIPE_H264_ENC_RATE_CONTROL_METHOD_DISABLE;
1038       break;
1039    }
1040
1041    rate_ctrl->frame_rate_den = OMX_VID_ENC_CONTROL_FRAME_RATE_DEN_DEFAULT;
1042    rate_ctrl->frame_rate_num = ((priv->frame_rate) >> 16) * rate_ctrl->frame_rate_den;
1043
1044    if (rate_ctrl->rate_ctrl_method != PIPE_H264_ENC_RATE_CONTROL_METHOD_DISABLE) {
1045       if (priv->bitrate.nTargetBitrate < OMX_VID_ENC_BITRATE_MIN)
1046          rate_ctrl->target_bitrate = OMX_VID_ENC_BITRATE_MIN;
1047       else if (priv->bitrate.nTargetBitrate < OMX_VID_ENC_BITRATE_MAX)
1048          rate_ctrl->target_bitrate = priv->bitrate.nTargetBitrate;
1049       else
1050          rate_ctrl->target_bitrate = OMX_VID_ENC_BITRATE_MAX;
1051       rate_ctrl->peak_bitrate = rate_ctrl->target_bitrate;
1052       if (rate_ctrl->target_bitrate < OMX_VID_ENC_BITRATE_MEDIAN)
1053          rate_ctrl->vbv_buffer_size = MIN2((rate_ctrl->target_bitrate * 2.75), OMX_VID_ENC_BITRATE_MEDIAN);
1054       else
1055          rate_ctrl->vbv_buffer_size = rate_ctrl->target_bitrate;
1056
1057       if (rate_ctrl->frame_rate_num) {
1058          unsigned long long t = rate_ctrl->target_bitrate;
1059          t *= rate_ctrl->frame_rate_den;
1060          rate_ctrl->target_bits_picture = t / rate_ctrl->frame_rate_num;
1061       } else {
1062          rate_ctrl->target_bits_picture = rate_ctrl->target_bitrate;
1063       }
1064       rate_ctrl->peak_bits_picture_integer = rate_ctrl->target_bits_picture;
1065       rate_ctrl->peak_bits_picture_fraction = 0;
1066    }
1067
1068    picture->quant_i_frames = priv->quant.nQpI;
1069    picture->quant_p_frames = priv->quant.nQpP;
1070    picture->quant_b_frames = priv->quant.nQpB;
1071
1072    picture->frame_num = priv->frame_num;
1073    picture->ref_idx_l0 = priv->ref_idx_l0;
1074    picture->ref_idx_l1 = priv->ref_idx_l1;
1075    picture->enable_vui = (picture->rate_ctrl.frame_rate_num != 0);
1076    enc_GetPictureParamPreset(picture);
1077 }
1078
1079 static void enc_HandleTask(omx_base_PortType *port, struct encode_task *task,
1080                            enum pipe_h264_enc_picture_type picture_type)
1081 {
1082    OMX_COMPONENTTYPE* comp = port->standCompContainer;
1083    vid_enc_PrivateType *priv = comp->pComponentPrivate;
1084    unsigned size = priv->ports[OMX_BASE_FILTER_OUTPUTPORT_INDEX]->sPortParam.nBufferSize;
1085    struct pipe_video_buffer *vbuf = task->buf;
1086    struct pipe_h264_enc_picture_desc picture = {};
1087
1088    /* -------------- scale input image --------- */
1089    enc_ScaleInput(port, &vbuf, &size);
1090    priv->s_pipe->flush(priv->s_pipe, NULL, 0);
1091
1092    /* -------------- allocate output buffer --------- */
1093    task->bitstream = pipe_buffer_create(priv->s_pipe->screen, PIPE_BIND_VERTEX_BUFFER,
1094                                         PIPE_USAGE_STREAM, size);
1095
1096    picture.picture_type = picture_type;
1097    picture.pic_order_cnt = task->pic_order_cnt;
1098    if (priv->restricted_b_frames && picture_type == PIPE_H264_ENC_PICTURE_TYPE_B)
1099       picture.not_referenced = true;
1100    enc_ControlPicture(port, &picture);
1101
1102    /* -------------- encode frame --------- */
1103    priv->codec->begin_frame(priv->codec, vbuf, &picture.base);
1104    priv->codec->encode_bitstream(priv->codec, vbuf, task->bitstream, &task->feedback);
1105    priv->codec->end_frame(priv->codec, vbuf, &picture.base);
1106 }
1107
1108 static void enc_ClearBframes(omx_base_PortType *port, struct input_buf_private *inp)
1109 {
1110    OMX_COMPONENTTYPE* comp = port->standCompContainer;
1111    vid_enc_PrivateType *priv = comp->pComponentPrivate;
1112    struct encode_task *task;
1113
1114    if (LIST_IS_EMPTY(&priv->b_frames))
1115       return;
1116
1117    task = LIST_ENTRY(struct encode_task, priv->b_frames.prev, list);
1118    LIST_DEL(&task->list);
1119
1120    /* promote last from to P frame */
1121    priv->ref_idx_l0 = priv->ref_idx_l1;
1122    enc_HandleTask(port, task, PIPE_H264_ENC_PICTURE_TYPE_P);
1123    LIST_ADDTAIL(&task->list, &inp->tasks);
1124    priv->ref_idx_l1 = priv->frame_num++;
1125
1126    /* handle B frames */
1127    LIST_FOR_EACH_ENTRY(task, &priv->b_frames, list) {
1128       enc_HandleTask(port, task, PIPE_H264_ENC_PICTURE_TYPE_B);
1129       if (!priv->restricted_b_frames)
1130          priv->ref_idx_l0 = priv->frame_num;
1131       priv->frame_num++;
1132    }
1133
1134    enc_MoveTasks(&priv->b_frames, &inp->tasks);
1135 }
1136
1137 static OMX_ERRORTYPE vid_enc_EncodeFrame(omx_base_PortType *port, OMX_BUFFERHEADERTYPE *buf)
1138 {
1139    OMX_COMPONENTTYPE* comp = port->standCompContainer;
1140    vid_enc_PrivateType *priv = comp->pComponentPrivate;
1141    struct input_buf_private *inp = buf->pInputPortPrivate;
1142    enum pipe_h264_enc_picture_type picture_type;
1143    struct encode_task *task;
1144    unsigned stacked_num = 0;
1145    OMX_ERRORTYPE err;
1146
1147    enc_MoveTasks(&inp->tasks, &priv->free_tasks);
1148    task = enc_NeedTask(port);
1149    if (!task)
1150       return OMX_ErrorInsufficientResources;
1151
1152    if (buf->nFilledLen == 0) {
1153       if (buf->nFlags & OMX_BUFFERFLAG_EOS) {
1154          buf->nFilledLen = buf->nAllocLen;
1155          enc_ClearBframes(port, inp);
1156          enc_MoveTasks(&priv->stacked_tasks, &inp->tasks);
1157          priv->codec->flush(priv->codec);
1158       }
1159       return base_port_SendBufferFunction(port, buf);
1160    }
1161
1162    if (buf->pOutputPortPrivate) {
1163       struct pipe_video_buffer *vbuf = buf->pOutputPortPrivate;
1164       buf->pOutputPortPrivate = task->buf;
1165       task->buf = vbuf;
1166    } else {
1167       /* ------- load input image into video buffer ---- */
1168       err = enc_LoadImage(port, buf, task->buf);
1169       if (err != OMX_ErrorNone) {
1170          FREE(task);
1171          return err;
1172       }
1173    }
1174
1175    /* -------------- determine picture type --------- */
1176    if (!(priv->pic_order_cnt % OMX_VID_ENC_IDR_PERIOD_DEFAULT) ||
1177        priv->force_pic_type.IntraRefreshVOP) {
1178       enc_ClearBframes(port, inp);
1179       picture_type = PIPE_H264_ENC_PICTURE_TYPE_IDR;
1180       priv->force_pic_type.IntraRefreshVOP = OMX_FALSE;
1181       priv->frame_num = 0;
1182    } else if (priv->codec->profile == PIPE_VIDEO_PROFILE_MPEG4_AVC_BASELINE ||
1183               !(priv->pic_order_cnt % OMX_VID_ENC_P_PERIOD_DEFAULT) ||
1184               (buf->nFlags & OMX_BUFFERFLAG_EOS)) {
1185       picture_type = PIPE_H264_ENC_PICTURE_TYPE_P;
1186    } else {
1187       picture_type = PIPE_H264_ENC_PICTURE_TYPE_B;
1188    }
1189
1190    task->pic_order_cnt = priv->pic_order_cnt++;
1191
1192    if (picture_type == PIPE_H264_ENC_PICTURE_TYPE_B) {
1193       /* put frame at the tail of the queue */
1194       LIST_ADDTAIL(&task->list, &priv->b_frames);
1195    } else {
1196       /* handle I or P frame */
1197       priv->ref_idx_l0 = priv->ref_idx_l1;
1198       enc_HandleTask(port, task, picture_type);
1199       LIST_ADDTAIL(&task->list, &priv->stacked_tasks);
1200       LIST_FOR_EACH_ENTRY(task, &priv->stacked_tasks, list) {
1201          ++stacked_num;
1202       }
1203       if (stacked_num == priv->stacked_frames_num) {
1204          struct encode_task *t;
1205          t = LIST_ENTRY(struct encode_task, priv->stacked_tasks.next, list);
1206          LIST_DEL(&t->list);
1207          LIST_ADDTAIL(&t->list, &inp->tasks);
1208       }
1209       priv->ref_idx_l1 = priv->frame_num++;
1210
1211       /* handle B frames */
1212       LIST_FOR_EACH_ENTRY(task, &priv->b_frames, list) {
1213          enc_HandleTask(port, task, PIPE_H264_ENC_PICTURE_TYPE_B);
1214          if (!priv->restricted_b_frames)
1215             priv->ref_idx_l0 = priv->frame_num;
1216          priv->frame_num++;
1217       }
1218
1219       enc_MoveTasks(&priv->b_frames, &inp->tasks);
1220    }
1221
1222    if (LIST_IS_EMPTY(&inp->tasks))
1223       return port->ReturnBufferFunction(port, buf);
1224    else
1225       return base_port_SendBufferFunction(port, buf);
1226 }
1227
1228 static void vid_enc_BufferEncoded(OMX_COMPONENTTYPE *comp, OMX_BUFFERHEADERTYPE* input, OMX_BUFFERHEADERTYPE* output)
1229 {
1230    vid_enc_PrivateType *priv = comp->pComponentPrivate;
1231    struct output_buf_private *outp = output->pOutputPortPrivate;
1232    struct input_buf_private *inp = input->pInputPortPrivate;
1233    struct encode_task *task;
1234    struct pipe_box box = {};
1235    unsigned size;
1236
1237    if (!inp || LIST_IS_EMPTY(&inp->tasks)) {
1238       input->nFilledLen = 0; /* mark buffer as empty */
1239       enc_MoveTasks(&priv->used_tasks, &inp->tasks);
1240       return;
1241    }
1242
1243    task = LIST_ENTRY(struct encode_task, inp->tasks.next, list);
1244    LIST_DEL(&task->list);
1245    LIST_ADDTAIL(&task->list, &priv->used_tasks);
1246
1247    if (!task->bitstream)
1248       return;
1249
1250    /* ------------- map result buffer ----------------- */
1251
1252    if (outp->transfer)
1253       pipe_transfer_unmap(priv->t_pipe, outp->transfer);
1254
1255    pipe_resource_reference(&outp->bitstream, task->bitstream);
1256    pipe_resource_reference(&task->bitstream, NULL);
1257
1258    box.width = outp->bitstream->width0;
1259    box.height = outp->bitstream->height0;
1260    box.depth = outp->bitstream->depth0;
1261
1262    output->pBuffer = priv->t_pipe->transfer_map(priv->t_pipe, outp->bitstream, 0,
1263                                                 PIPE_TRANSFER_READ_WRITE,
1264                                                 &box, &outp->transfer);
1265
1266    /* ------------- get size of result ----------------- */
1267
1268    priv->codec->get_feedback(priv->codec, task->feedback, &size);
1269
1270    output->nOffset = 0;
1271    output->nFilledLen = size; /* mark buffer as full */
1272 }